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

package/dist/{DurableAgentRuntime-BAmSkWYr.mjs → DurableAgentRuntime-CBBjRNJN.mjs}

@@ -16,33 +16,33 @@ import { a as PeerMessageCapacity, d as MessageAdmission, f as MessagingError, i
 import { SubagentHost } from "./engine/SubagentHost.mjs";
 import { ThreadHistory } from "./engine/ThreadHistory.mjs";
 import { n as RunToolVisibility } from "./ToolExposure-DBATXxmL.mjs";
-import { C as boundedValueFootprint, n as AgentChildPending, p as renderInputPrompt, u as executeWithUsageAccountingUnknown } from "./AgentRuntime-CQ-qcETl.mjs";
+import { C as boundedValueFootprint, n as AgentChildPending, p as renderInputPrompt, u as executeWithUsageAccountingUnknown } from "./AgentRuntime-B6qZlD3f.mjs";
 import { ContextRolloverTool } from "./engine/ContextWindow.mjs";
 import { getToolExecutionClass } from "./engine/DurableStep.mjs";
 import { CompactionError, ContextCompactor } from "./engine/ContextCompactor.mjs";
 import { AgentUpdateAcceptance, CurrentToolFailureObserver, ModelUsageAccounting, RunContextPreparation, RunContextPreparationPassthrough, RunToolAuthorization, RunToolScheduling } from "./engine/RunOptions.mjs";
 import { A as MAX_RUN_EVIDENCE_RECORDS, At as WorkHandoffCompleted, Bt as WorkerReportingIntent, Ct as ToolCallResolved, Dt as ToolStepSettled, Et as ToolOperation, Ft as WorkerInputRequested, G as PromptRecord, H as PeerMessagePrepared, I as ModelCallAborted, It as WorkerOrigin, Mt as WorkerContinuation, Nt as WorkerInputCompleted, O as MAX_RUN_CONTINUATION_BYTES, Ot as ToolUnavailable, P as MAX_RUN_TOOL_CALL_IDENTITIES, Pt as WorkerInputRefused, R as ModelResponseInterrupted, Rt as WorkerReportPrepared, Tt as ToolCallUnknown, U as PersistedJson, V as PROMPT_EVIDENCE_TAGS, Vt as WorkerStopRequested, X as RecordEnvelope, Z as RecordId, _t as SubmissionSettledRecord, at as RunDurationExhausted, bt as ToolApprovalDecided, c as CanonicalBatch, et as RepairAnnotated, f as CanonicalSequence, ft as SubagentJoined, g as DeclaredToolCall, gt as SubmissionSettled, ht as SubagentStarted, i as BatchId, jt as WorkerAdmission, kt as UserInputRecorded, lt as RunStartedRecord, mt as SubagentRequested, n as AgentUpdateEmitted, o as CURRENT_RECORD_FORMAT, p as CompactionCreated, pt as SubagentLineageRecorded, rt as RunContextRecorded, st as RunPolicyUsageReserved, t as AbortRequested, ut as SettlementFailureDiagnostic, v as DefinitionDigests, vt as SubtreeBudgetReserved, w as MAX_PERSISTED_JSON_BYTES, wt as ToolCallSettled, xt as ToolApprovalRequested, zt as WorkerReportRefused } from "./Records-BiuJDWNe.mjs";
-import { i as digestCanonicalJson, r as canonicalJson, s as digestJson } from "./Digest-DCuPlhNk.mjs";
+import { i as digestCanonicalJson, r as canonicalJson, s as digestJson } from "./Digest-EpeqWEdv.mjs";
 import { AbortCommand, AbortIntentRequest, AdmissionPolicyError, AdmissionRequest, ApprovalDecisionCommand, ApprovalPendingSuspension, BeginChildBudgetReleaseRequest, ChildReservationId, ChildSettledNotification, ClaimHandoff, ClaimRequest, FundingOwnerRequest, LedgerError, MarkReadyRequest, MarkUnknownRequest, ParentLinkage, RecoverySnapshotRequest, ReleaseChildBudgetRequest, RevertJoiningRequest, Settlement, SettlementFinalization, SubmissionLedger, SubmissionLookupById, SubmissionLookupByKey, SubmissionScheduling, UnknownResolutionCommand, WaitingChild, WaitingForChildSuspension, WorkerLedgerState, submissionAbortBatchId, submissionAbortRecordId, submissionInputBatchId, submissionInputRecordId, submissionSettlementBatchId, submissionSettlementId, submissionSettlementRecordId, unknownResolutionKind } from "./durable/SubmissionLedger.mjs";
 import { DeclaredPendingBatchEvidence, OpenDelegationCallEvidence, OpenToolCallEvidence, PendingApprovalEvidence, RecoveryDecision, RecoveryEvidence, classifyRecovery, pendingApprovalForRecovery } from "./durable/Recovery.mjs";
 import { ExplainedEvidence, ExplainedSubmission, ExplainedUnknownCall, ObligationEntry, ObligationReport, RecoveryExplanation, RetryRefused, obligationSeverityOf, predictRecoveryDisposition, recoveryDecisionMeaning } from "./durable/Admin.mjs";
-import { a as compileRegistrations, c as resolveDefinitionBinding, l as resolveWorkerBinding, n as CurrentBindingSelection, o as definitionDigestsEqual, s as makeLegacyWorkerBinding, t as BindingUnavailable, u as toolReplayContracts } from "./agent-registration-ByMZ_cK5.mjs";
-import { A as subagentStartedBatchId, B as turnApprovalsBatchId, C as runStartedRecordId, D as subagentLineageRecordId, E as subagentLineageBatchId, F as toolCallResolvedRecordId, G as turnResponseBatchId, H as turnCanonicalBatch, I as toolCallResultBatchId, J as workerInputRecordId, K as turnResultsBatch, L as toolCallUnknownRecordId, M as toolApprovalDecisionRecordId, N as toolApprovalRequestRecordId, O as subagentRequestedBatchId, P as toolCallResolutionBatchId, Q as toolCallSettledRecordId, R as toolStepSettledBatchId, S as runStartedBatchId, T as subagentJoinedRecordId, U as turnIdForRun, W as turnResponseBatch, X as workerReportRecordId, Y as workerOriginRecordId, Z as makeJournalMetadata, a as childIdempotencyKeyFor, b as runDurationRecordId, c as compactionRecordId, d as modelResponseInterruptedBatchId, f as modelResponseInterruptedRecordId, g as projectRunJournalStream, i as approvalDecisionBatchId, j as subagentStartedRecordId, k as subagentRequestedRecordId, l as firstWorkerInputRecordId, m as peerMessageRecordId, o as childThreadIdFor, p as modelResponseRecordId, r as agentUpdateRecordId, s as compactionBatchId, t as RunJournalError, u as markUnknownBatchId, v as runCompletedRecordId, w as subagentJoinBatchId, x as runIdForSubmission, y as runDurationBatchId, z as toolStepSettledRecordId } from "./RunJournal-kfKVxJj7.mjs";
-import { $ as ThreadTailRequest, B as ThreadPromptRead, F as ThreadIdentityRequest, I as ThreadMaterialization, J as ThreadStore, R as ThreadObservation, U as ThreadReader, V as ThreadRead, X as ThreadStoreError, Y as ThreadStoreDiagnostic, _t as isPreContinuationFact, bt as terminalUsageCharge, gt as executionRunIds, ht as canonicalRunIds, lt as readWorkerState, n as AppendRequest, ot as getRecord, p as MAX_THREAD_EXPORT_PAGE_BYTES, pt as captureRecord, st as getRunInput } from "./ThreadStore-CEekRa80.mjs";
+import { a as compileRegistrations, c as resolveDefinitionBinding, l as resolveWorkerBinding, n as CurrentBindingSelection, o as definitionDigestsEqual, s as makeLegacyWorkerBinding, t as BindingUnavailable, u as toolReplayContracts } from "./agent-registration-DRbyhAu-.mjs";
+import { $ as toolCallSettledRecordId, A as subagentStartedBatchId, B as turnApprovalsBatchId, C as runStartedRecordId, D as subagentLineageRecordId, E as subagentLineageBatchId, F as toolCallResolvedRecordId, G as turnResponseBatchId, H as turnCanonicalBatch, I as toolCallResultBatchId, J as workerInputRecordId, K as turnResultsBatch, L as toolCallUnknownRecordId, M as toolApprovalDecisionRecordId, N as toolApprovalRequestRecordId, O as subagentRequestedBatchId, P as toolCallResolutionBatchId, Q as makeJournalMetadata, R as toolStepSettledBatchId, S as runStartedBatchId, T as subagentJoinedRecordId, U as turnIdForRun, W as turnResponseBatch, X as workerReportRecordId, Y as workerOriginRecordId, a as childIdempotencyKeyFor, b as runDurationRecordId, c as compactionRecordId, d as modelResponseInterruptedBatchId, f as modelResponseInterruptedRecordId, g as projectRunJournalStream, i as approvalDecisionBatchId, j as subagentStartedRecordId, k as subagentRequestedRecordId, l as firstWorkerInputRecordId, m as peerMessageRecordId, o as childThreadIdFor, p as modelResponseRecordId, r as agentUpdateRecordId, s as compactionBatchId, t as RunJournalError, u as markUnknownBatchId, v as runCompletedRecordId, w as subagentJoinBatchId, x as runIdForSubmission, y as runDurationBatchId, z as toolStepSettledRecordId } from "./RunJournal-CNZqA3Ge.mjs";
+import { $ as ThreadTailRequest, B as ThreadPromptRead, F as ThreadIdentityRequest, I as ThreadMaterialization, J as ThreadStore, R as ThreadObservation, U as ThreadReader, V as ThreadRead, X as ThreadStoreError, Y as ThreadStoreDiagnostic, _t as isPreContinuationFact, bt as terminalUsageCharge, gt as executionRunIds, ht as canonicalRunIds, lt as readWorkerState, n as AppendRequest, ot as getRecord, p as MAX_THREAD_EXPORT_PAGE_BYTES, pt as captureRecord, st as getRunInput } from "./ThreadStore-59uDGXul.mjs";
 import { ScheduledInputRefused, ScheduledInputRetryable } from "./durable/Schedule.mjs";
 import { PreparedInputAdmission } from "./durable/PreparedInputAdmission.mjs";
 import { PreparedInput } from "./durable/Subscription.mjs";
 import { MessageDeliveryDriver, MessageDeliveryFailpoint, MessageDeliveryRecord, MessageDeliveryStore, prepareMessageDelivery } from "./durable/MessageDelivery.mjs";
 import { DurableRuntimeFailpoint } from "./durable/DurableFailpoint.mjs";
-import { _ as readRunContext, a as canonicalRecordBytes, b as reference, f as runEvidence, g as digestRunHistory, l as readContinuation, m as validateSuffix, n as CurrentRunWriter, s as makeProgressWriter, t as CurrentRunSettlement, u as readRunEvidenceSnapshot, x as resolveEvidence, y as RunContextReader } from "./RunContinuation-DHYNAQFi.mjs";
+import { _ as readRunContext, a as canonicalRecordBytes, b as reference, f as runEvidence, g as digestRunHistory, l as readContinuation, m as validateSuffix, n as CurrentRunWriter, s as makeProgressWriter, t as CurrentRunSettlement, u as readRunEvidenceSnapshot, x as resolveEvidence, y as RunContextReader } from "./RunContinuation-4ZATcVLB.mjs";
 import { MAX_WORK_CURSOR_CHARS, ThreadWorkDiscovery, ThreadWorkEntry, ThreadWorkRequest, WorkDiscoveryUnavailable, decodeWorkCursor, deliveryPredecessor, encodeWorkCursor, operationEvidence, resolveWorkEvidence, validateWorkPage, workId } from "./durable/ThreadWork.mjs";
 import { WakeScheduler } from "./durable/WakeScheduler.mjs";
 import { n as safeUnknownString, t as inspectForeignDiagnostic } from "./foreign-diagnostic-DBQ1XHKh.mjs";
-import { c as threadCreatedBatchId, l as threadCreatedRecordId, n as WorkerAdmissionPort, o as ensureThreadCreated, r as WorkerAdmissionRequest, s as ensureWorkerOrigin } from "./WorkerAdmission-DFVbbVh2.mjs";
+import { c as threadCreatedBatchId, l as threadCreatedRecordId, n as WorkerAdmissionPort, o as ensureThreadCreated, r as WorkerAdmissionRequest, s as ensureWorkerOrigin } from "./WorkerAdmission-DDYJdOsU.mjs";
 import { i as unresolvedToolOperations, n as isUnresolvedToolOperation, r as toolOperationStates, t as initialDispatchBlockedTurns } from "./tool-operations-BXBmagY1.mjs";
 import { WorkerBudgetAuthorizer, WorkerConcurrencyLimit, WorkerConcurrencyResolver, WorkerHostAuthorizer, WorkerHostConfig, WorkerPolicyResolver } from "./durable/WorkerHost.mjs";
 import { OperationAuthorizationRequest, OperationAuthorizer, OperationDenied } from "./durable/OperationAuthorizer.mjs";
-import { o as makeRunWriter, r as RunStorage, s as StorageOwner } from "./RunStorage-uqPxps09.mjs";
+import { o as makeRunWriter, r as RunStorage, s as StorageOwner } from "./RunStorage-BHjuuERI.mjs";
 import { SettlementPublication } from "./durable/SettlementPublisher.mjs";
 import { PendingSubmission, SettledSubmission } from "./durable/SubmissionStatus.mjs";
 import { DeclaredToolCallEvidence, ToolReconciler } from "./durable/ToolReconciler.mjs";
@@ -736,7 +736,7 @@ function hydratePart(part) {
 		case "tool-approval-request": return Prompt.toolApprovalRequestPart(part);
 		case "tool-approval-response": return Prompt.toolApprovalResponsePart(part);
 	}
-	throw new Error(`Unhandled Prompt part: ${part}`);
+	return part;
 }
 const hydrateMessage = (message) => {
 	switch (message.role) {
@@ -754,7 +754,7 @@ const hydrateMessage = (message) => {
 			content: message.content.map((p) => hydratePart(p))
 		});
 	}
-	throw new Error(`Unhandled Prompt message: ${message}`);
+	return message;
 };
 /** Internal canonical projection; ownership comes from the ThreadStore read contract. */
 const preparePromptHistory = (prompt) => prompt.content.length > MAX_ENTRIES ? void 0 : {
@@ -851,7 +851,12 @@ const makeCommittedPromptSuffix = (original) => {
 		}
 		try {
 			for (const fact of facts) {
-				const owned = captureRecord(fact);
+				const captured = captureRecord(fact);
+				if (Result.isFailure(captured)) {
+					discard();
+					return;
+				}
+				const owned = captured.success;
 				const payload = owned.canonical.payload;
 				if (payload._tag !== "UserInputRecorded" && payload._tag !== "ModelResponseRecorded" && payload._tag !== "ToolCallSettled" && payload._tag !== "SubmissionSettled") {
 					discard();
@@ -2384,7 +2389,7 @@ const makeWorkerRuntime = Effect.fnUntraced(function* (options) {
 					ownerThreadId: context.source.threadId,
 					messageId
 				}).pipe(Effect.mapError(storageFailure("start")));
-				const replay = (saved) => Effect.gen(function* () {
+				const replay = Effect.fnUntraced(function* (saved) {
 					const currentPrevious = command.continuationOf === void 0 ? void 0 : yield* completedContinuation(context.source, command.continuationOf, command.target.id, command.delegationId, previous?.evidence);
 					const replayPrincipal = yield* authorize("start", "send", void 0, currentPrevious?.evidence);
 					yield* binding(command.target, "start");
@@ -2476,7 +2481,7 @@ const makeWorkerRuntime = Effect.fnUntraced(function* (options) {
 					ownerThreadId: context.source.threadId,
 					messageId
 				}).pipe(Effect.mapError(storageFailure("followUp")));
-				const replay = (saved) => Effect.gen(function* () {
+				const replay = Effect.fnUntraced(function* (saved) {
 					const replayPrincipal = yield* authorize("followUp", "send", command.worker);
 					yield* currentPolicy;
 					return yield* send(origin, messageId, saved.envelope.input, command.encodedParameters, replayPrincipal, "followUp");
@@ -3257,6 +3262,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 		let context;
 		let progress;
 		let progressThrough;
+		let operational = [];
 		const invalid = (message) => ThreadStoreError.make({
 			operation: "read Run continuation",
 			message
@@ -3325,20 +3331,20 @@ const make = Effect.fnUntraced(function* (bindings) {
 				context = saved;
 				progress = cursor;
 				progressThrough = envelope.throughSequence;
+				operational = envelope.operational;
 			}
 		}
-		const records = [...new Map([...identity.records.filter((entry) => entry.sequence <= throughSequence), ...selected].map((entry) => [entry.sequence, entry])).values()].sort((left, right) => left.sequence - right.sequence);
 		return {
-			canonical: Stream.fromIterable(records),
+			records: [...new Map([...identity.records.filter((entry) => entry.sequence <= throughSequence), ...selected].map((entry) => [entry.sequence, entry])).values()].sort((left, right) => left.sequence - right.sequence),
 			context,
 			progress,
-			progressThrough
+			progressThrough,
+			operational
 		};
 	});
 	const readControl = Effect.fnUntraced(function* (threadId, submissionIds) {
 		const tail = yield* store.inspectTail(ThreadTailRequest.make({ threadId }));
-		const view = yield* recoveryView(threadId, tail.tailSequence, submissionIds);
-		return yield* Stream.runCollect(view.canonical.pipe(Stream.filter(controlRecords(submissionIds))));
+		return (yield* recoveryView(threadId, tail.tailSequence, submissionIds)).records.filter(controlRecords(submissionIds));
 	});
 	const readAllTolerant = (threadId, submissionIds) => Effect.suspend(() => readControl(threadId, submissionIds).pipe(Effect.map((records) => ({
 		records,
@@ -3360,7 +3366,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			submissionIds
 		};
 		return {
-			records: yield* recoveryView(threadId, tail.value.tailSequence, submissionIds).pipe(Effect.flatMap((view) => Stream.runCollect(view.canonical.pipe(Stream.filter(controlRecords(submissionIds))))), Effect.catchTag("ThreadNotMaterialized", (error) => ThreadStoreError.make({
+			records: yield* recoveryView(threadId, tail.value.tailSequence, submissionIds).pipe(Effect.map((view) => view.records.filter(controlRecords(submissionIds))), Effect.catchTag("ThreadNotMaterialized", (error) => ThreadStoreError.make({
 				operation: "read recovery history",
 				message: `Thread ${threadId} disappeared after its recovery tail was captured`,
 				cause: error
@@ -3747,7 +3753,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 	});
 	const progressStore = ThreadStore.of({
 		...store,
-		append: (request) => Effect.gen(function* () {
+		append: Effect.fnUntraced(function* (request) {
 			const progress = activeProgress.get(request.threadId)?.writer ?? (yield* makeProgressWriter(request.threadId, config.deploymentId).pipe(Effect.provideService(ThreadReader, reader), Effect.provideService(Crypto.Crypto, crypto)));
 			let tail = { sequence: request.expectedTailSequence };
 			return yield* progress.commit(request.batch).pipe(Effect.provideService(CurrentRunWriter, {
@@ -3776,7 +3782,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			threadId: ctx.threadId,
 			tail: ctx.tail,
 			withProgress: ctx.withProgress,
-			publishSettlement: (prepared, executions) => Effect.gen(function* () {
+			publishSettlement: Effect.fnUntraced(function* (prepared, executions) {
 				let tail = yield* ctx.tail;
 				for (let retries = 0;; retries++) {
 					const result = yield* runStorage.publishSettlement(SettlementPublication.make({
@@ -4079,23 +4085,26 @@ const make = Effect.fnUntraced(function* (bindings) {
 			sequence: result.firstSequence
 		});
 	});
-	const readRunStart = Effect.fnUntraced(function* (threadId, runId) {
-		const loaded = yield* reader.readExecution({
-			threadId,
-			runId
-		}).pipe(Effect.catchTag("ThreadNotMaterialized", () => Effect.succeed(Option.none())));
-		if (Option.isNone(loaded)) return void 0;
+	const readRunStart = Effect.fnUntraced(function* (threadId, runId, operational) {
+		if (operational === void 0) {
+			const loaded = yield* reader.readExecution({
+				threadId,
+				runId
+			}).pipe(Effect.catchTag("ThreadNotMaterialized", () => Effect.succeed(Option.none())));
+			if (Option.isNone(loaded)) return void 0;
+			operational = loaded.value.operational;
+		}
 		const recordId = runStartedRecordId(runId);
-		const starts = loaded.value.operational.filter(({ payload }) => payload._tag === "RunStarted");
-		const existing = loaded.value.operational.find((record) => record.recordId === recordId);
+		const starts = operational.filter(({ payload }) => payload._tag === "RunStarted");
+		const existing = operational.find((record) => record.recordId === recordId);
 		if (starts.length > 1 || starts.length === 1 && starts[0]?.recordId !== recordId || existing !== void 0 && (existing.payload._tag !== "RunStarted" || existing.payload.runId !== runId)) return yield* RunJournalError.make({ message: `Run ${runId} has conflicting active start state` });
 		return existing;
 	});
-	const makeRunStart = Effect.fnUntraced(function* (submission, maxDurationMillis, records) {
+	const makeRunStart = Effect.fnUntraced(function* (submission, maxDurationMillis, records, operational) {
 		const writer = yield* CurrentRunWriter;
 		const runId = runIdForSubmission(submission.submissionId);
 		const recordId = runStartedRecordId(runId);
-		const existing = yield* readRunStart(submission.threadId, runId);
+		const existing = yield* readRunStart(submission.threadId, runId, operational);
 		let start;
 		let allowance = maxDurationMillis;
 		let committed = existing !== void 0;
@@ -4942,1474 +4951,1476 @@ const make = Effect.fnUntraced(function* (bindings) {
 		})).pipe(Effect.catchTag("AppendConflict", () => Effect.void), Effect.asVoid);
 		knownIds.add(recordId);
 	});
-	/**
-	* Drive the shared interpreter Effect with history rebuilt by the run journal, commit
-	* each Turn under the local owner, and watch for durable abort intent. Engine Run failures settle `failed`; coordinator failures abort the
-	* Attempt cleanly with the obligation still owed.
-	*
-	* The interpreter supplies validated response, closed Tool-result, and completion facts.
-	* Responses precede approval and effectful dispatch; readonly responses may join their closed
-	* results. Tool results precede input drains and the next Turn. A no-tool response and Run
-	* completion share one batch. A completion Tool's result
-	* precedes its terminal-only completion batch, so recovery can repeat a pure output projection
-	* without replaying the handler. Pending batches resume from their canonical declarations.
-	*/
-	const runModel = (agent, ctx, submission, session, records, canonical, initialJournal, canonicalThrough, progressThrough, continuation, priorContext, journalMetadata, lineage, approvalDecisions, currentContracts, runTiming, yieldAfter) => Effect.gen(function* () {
-		const submissionId = submission.submissionId;
-		const runId = runIdForSubmission(submissionId);
-		const boundaries = [];
-		const cached = projectedJournal;
-		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);
-		if (originalInput === void 0) return yield* RunJournalError.make({ message: "Run has no original context boundary" });
-		const historyEvidence = /* @__PURE__ */ new Map();
-		const retainHistory = (entry) => {
-			if (priorContext === void 0 && entry.sequence < originalInput.sequence) historyEvidence.set(entry.record.recordId, entry);
-		};
-		let journal = cached !== void 0 && 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 === void 0 ? retainHistory : void 0);
-		if (initialJournal?.prefix !== void 0) {
-			const prompt = initialJournal.prefix.prompt;
-			journal = {
-				...journal,
-				prompt,
-				historyBefore: prompt
+	const runModel = Effect.fnUntraced(
+		/**
+		* Drive the shared interpreter Effect with history rebuilt by the run journal, commit
+		* each Turn under the local owner, and watch for durable abort intent. Engine Run failures settle `failed`; coordinator failures abort the
+		* Attempt cleanly with the obligation still owed.
+		*
+		* The interpreter supplies validated response, closed Tool-result, and completion facts.
+		* Responses precede approval and effectful dispatch; readonly responses may join their closed
+		* results. Tool results precede input drains and the next Turn. A no-tool response and Run
+		* completion share one batch. A completion Tool's result
+		* precedes its terminal-only completion batch, so recovery can repeat a pure output projection
+		* without replaying the handler. Pending batches resume from their canonical declarations.
+		*/
+		function* (agent, ctx, submission, session, records, canonical, initialJournal, canonicalThrough, progressThrough, continuation, priorContext, journalMetadata, lineage, approvalDecisions, currentContracts, runTiming, yieldAfter) {
+			const submissionId = submission.submissionId;
+			const runId = runIdForSubmission(submissionId);
+			const boundaries = [];
+			const cached = projectedJournal;
+			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);
+			if (originalInput === void 0) return yield* RunJournalError.make({ message: "Run has no original context boundary" });
+			const historyEvidence = /* @__PURE__ */ new Map();
+			const retainHistory = (entry) => {
+				if (priorContext === void 0 && entry.sequence < originalInput.sequence) historyEvidence.set(entry.record.recordId, entry);
 			};
-		}
-		journalMetadata = void 0;
-		historyEvidence.forEach((entry, id) => {
-			if (entry.sequence >= journal.historyFrom) historyEvidence.delete(id);
-		});
-		projectedJournal = {
-			threadId: ctx.threadId,
-			through: CanonicalSequence.make(projectionThrough),
-			runId,
-			contextRecordId: priorContext?.recordId,
-			contextEvidence: [...historyEvidence.values()],
-			journal,
-			boundaries
-		};
-		if (continuation !== void 0) {
-			const accounting = continuation.accounting;
-			if ([
-				"committedTurns",
-				"toolCalls",
-				"programmaticToolCalls",
-				"consecutiveToolFailures",
-				"finalizationUsed",
-				"modelRestarts"
-			].some((field) => (journal.policyUsage[field] ?? 0) !== accounting[field]) || [
-				"modelCalls",
-				"inputTokens",
-				"outputTokens",
-				"lastInputTokens",
-				"lastOutputTokens",
-				"costMicrousd"
-			].some((field) => journal.usage[field] !== accounting[field]) || (journal.usage.unobservedModelCalls ?? 0) !== accounting.unobservedModelCalls) return yield* RunJournalError.make({ message: "Canonical continuation accounting differs from its exact execution evidence" });
-		}
-		const childLineage = records.find(({ record }) => record.recordId === subagentLineageRecordId(submission.threadId))?.record.payload;
-		const inheritedGrant = submission.workerAdmission?.origin.grant ?? (childLineage?._tag === "SubagentLineageRecorded" ? childLineage.grant : void 0);
-		const delegationDepth = submission.workerAdmission?.origin.depth ?? (childLineage?._tag === "SubagentLineageRecorded" ? childLineage.parentLink.depth : 0);
-		const inheritedBudget = submission.workerAdmission?.origin.budget ?? (childLineage?._tag === "SubagentLineageRecorded" ? childLineage.budget : void 0);
-		if (submission.parentLinkage !== void 0 && (childLineage?._tag !== "SubagentLineageRecorded" || childLineage.parentSubmissionId !== submission.parentLinkage.parentSubmissionId || childLineage.parentLink.parentToolCallId !== submission.parentLinkage.parentToolCallId || !definitionDigestsEqual(childLineage.childDefinitionDigests, submission.agentDigests) || childLineage.childInputDigest !== submission.inputDigest)) return yield* RunJournalError.make({ message: "The child Run has no matching canonical lineage and execution bounds" });
-		const completionTools = [...agent.definition.completion === void 0 ? [] : [agent.definition.completion.tool], ...agent.definition.completionFromTools?.map((declaration) => declaration.tool) ?? []];
-		const pending = yield* pendingToolBatchFor(records, runId, completionTools);
-		const resumeProjection = pending === void 0 ? journal : yield* projectRunJournalStream(withoutPendingBatch(canonical, pending, runId), runId, void 0, priorContext);
-		if (initialJournal !== void 0 && (journal.committedTurns !== 0 || journal.historyFrom !== 1 || journal.contextWindowId !== void 0 || historyEvidence.size !== 0 || pending !== void 0 || boundaries.some((boundary) => boundary.incomplete))) initialJournal.cacheable = false;
-		if (initialJournal?.cacheable) initialJournal.history = initialJournal.prefix ?? preparePromptHistory(journal.historyBefore);
-		if (initialJournal !== void 0) initialJournal.records = void 0;
-		const rolloverOperation = journal.pendingContextToolCallId === void 0 ? void 0 : operationsFor(records, runId).get(journal.pendingContextToolCallId);
-		const rolloverTool = rolloverOperation === void 0 ? void 0 : agent.definition.toolkit.tools[rolloverOperation.toolName];
-		const pendingContextToolCallId = rolloverOperation !== void 0 && rolloverTool !== void 0 && Context.get(rolloverTool.annotations, ContextRolloverTool) && currentContracts[rolloverOperation.toolName] === rolloverOperation.replay ? journal.pendingContextToolCallId : void 0;
-		const applicationCalls = pending?.calls.filter((call) => !call.providerExecuted);
-		const completionCandidate = applicationCalls?.length === 1 && completionTools.some((tool) => tool === applicationCalls[0]?.name) && pending?.settled.some((result) => result.id === applicationCalls[0]?.id && !result.isFailure) ? applicationCalls[0] : void 0;
-		const settledCompletion = pending !== void 0 && completionCandidate !== void 0 && supportsOperation(OpenToolCallEvidence.make({
-			toolCallId: Schema.decodeSync(ToolCallId)(completionCandidate.id),
-			toolName: completionCandidate.name,
-			turn: pending.turn
-		}), pending.toolOperations.find((operation) => operation.toolCallId === completionCandidate.id), {
-			definition: agent.definition,
-			contracts: currentContracts
-		}) ? Schema.decodeSync(ToolCallId)(completionCandidate.id) : void 0;
-		const knownIds = knownRecordIdsOf(records);
-		const stepOutputs = /* @__PURE__ */ new Map();
-		for (const envelope of records) {
-			const payload = envelope.record.payload;
-			if (payload._tag === "ToolStepSettled" && payload.runId === runId) stepOutputs.set(toolStepSettledRecordId(runId, payload.toolCallId, payload.stepName), payload.output);
-		}
-		const canonicalApprovalDecisions = /* @__PURE__ */ new Map();
-		const approvalRequestedTurns = /* @__PURE__ */ new Set();
-		for (const envelope of records) {
-			const payload = envelope.record.payload;
-			if (payload._tag === "ToolApprovalDecided" && payload.runId === runId) canonicalApprovalDecisions.set(payload.toolCallId, payload.decision);
-			else if (payload._tag === "ToolApprovalRequested" && payload.runId === runId) approvalRequestedTurns.add(payload.turn);
-		}
-		const approvalIntents = /* @__PURE__ */ new Map();
-		for (const intent of approvalDecisions) approvalIntents.set(intent.toolCallId, intent);
-		const joinedInputEnvelopes = /* @__PURE__ */ new Map();
-		let lastHostResponseSequence;
-		for (const envelope of records) {
-			const payload = envelope.record.payload;
-			if (payload._tag === "UserInputRecorded" && payload.runId === runId && payload.submissionId !== void 0 && payload.submissionId !== submissionId) joinedInputEnvelopes.set(payload.submissionId, envelope);
-			else if (payload._tag === "ModelResponseRecorded" && payload.runId === runId) {
-				if (lastHostResponseSequence === void 0 || envelope.sequence > lastHostResponseSequence) lastHostResponseSequence = envelope.sequence;
+			let journal = cached !== void 0 && 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 === void 0 ? retainHistory : void 0);
+			if (initialJournal?.prefix !== void 0) {
+				const prompt = initialJournal.prefix.prompt;
+				journal = {
+					...journal,
+					prompt,
+					historyBefore: prompt
+				};
 			}
-		}
-		const stagedUsage = /* @__PURE__ */ new Map();
-		const committedUsageLengths = /* @__PURE__ */ new Map();
-		const committedUnobservedCalls = /* @__PURE__ */ new Map();
-		const usageForCommit = (turn) => {
-			const staged = stagedUsage.get(turn);
-			if (staged === void 0) return void 0;
-			const modelUsage = staged.modelUsage.slice(committedUsageLengths.get(turn) ?? 0);
-			if (modelUsage.length === 0) return void 0;
-			return {
-				modelUsage,
-				inputTokens: modelUsage.reduce((sum, call) => sum + call.inputTokens.total, 0),
-				outputTokens: modelUsage.reduce((sum, call) => sum + call.outputTokens.total, 0),
-				costMicrousd: modelUsage.reduce((sum, call) => sum + call.costMicrousd, 0)
+			journalMetadata = void 0;
+			historyEvidence.forEach((entry, id) => {
+				if (entry.sequence >= journal.historyFrom) historyEvidence.delete(id);
+			});
+			projectedJournal = {
+				threadId: ctx.threadId,
+				through: CanonicalSequence.make(projectionThrough),
+				runId,
+				contextRecordId: priorContext?.recordId,
+				contextEvidence: [...historyEvidence.values()],
+				journal,
+				boundaries
 			};
-		};
-		const unobservedForCommit = (turn) => (stagedUnobservedCalls.get(turn) ?? 0) - (committedUnobservedCalls.get(turn) ?? 0);
-		const recordCommittedUsage = (batch) => {
-			for (const record of batch.records) {
-				if (record.payload._tag !== "ModelResponseRecorded" && record.payload._tag !== "ModelCallAborted") continue;
-				const payload = record.payload;
-				committedUsageLengths.set(payload.turn, (committedUsageLengths.get(payload.turn) ?? 0) + (payload.modelUsage?.length ?? 0));
-				committedUnobservedCalls.set(payload.turn, (committedUnobservedCalls.get(payload.turn) ?? 0) + (payload.unobservedModelCalls ?? 0));
+			if (continuation !== void 0) {
+				const accounting = continuation.accounting;
+				if ([
+					"committedTurns",
+					"toolCalls",
+					"programmaticToolCalls",
+					"consecutiveToolFailures",
+					"finalizationUsed",
+					"modelRestarts"
+				].some((field) => (journal.policyUsage[field] ?? 0) !== accounting[field]) || [
+					"modelCalls",
+					"inputTokens",
+					"outputTokens",
+					"lastInputTokens",
+					"lastOutputTokens",
+					"costMicrousd"
+				].some((field) => journal.usage[field] !== accounting[field]) || (journal.usage.unobservedModelCalls ?? 0) !== accounting.unobservedModelCalls) return yield* RunJournalError.make({ message: "Canonical continuation accounting differs from its exact execution evidence" });
 			}
-			progressWriters.get(ctx)?.stageUsage(runId, terminalUsageCharge(uncommittedModelUsage()));
-		};
-		const uncommittedModelUsage = () => [...stagedUsage.entries()].flatMap(([turn, usage]) => usage.modelUsage.slice(committedUsageLengths.get(turn) ?? 0));
-		const stagedUnobservedCalls = /* @__PURE__ */ new Map();
-		let interruptedUsage = records.some(({ record }) => record.payload._tag === "ModelResponseInterrupted" && record.payload.runId === runId);
-		const checkedUsageTotal = (field, value) => decodeUsageTotal(value).pipe(Effect.mapError((cause) => RunJournalError.make({
-			message: `Run usage summary exceeds safe-integer bounds at ${field}`,
-			cause
-		})));
-		const addUsageTotal = (field, left, right) => checkedUsageTotal(field, left + right);
-		const subtractUsageTotal = (field, left, right) => checkedUsageTotal(field, left - right);
-		const currentUsageSummary = () => Effect.gen(function* () {
-			const stagedCalls = [...stagedUsage.values()].flatMap((usage) => usage.modelUsage);
-			let unobservedModelCalls = journal.usage.unobservedModelCalls ?? 0;
-			for (const count of stagedUnobservedCalls.values()) unobservedModelCalls = yield* addUsageTotal("unobservedModelCalls", unobservedModelCalls, count);
-			const detailedCalls = [...journal.usage.modelUsage, ...stagedCalls];
-			const detailed = yield* summarizeModelUsage(detailedCalls, journal.usage.summarizedModelUsage).pipe(Effect.mapError((cause) => RunJournalError.make({
-				message: "Run detailed usage exceeds safe-integer accounting bounds",
+			const childLineage = records.find(({ record }) => record.recordId === subagentLineageRecordId(submission.threadId))?.record.payload;
+			const inheritedGrant = submission.workerAdmission?.origin.grant ?? (childLineage?._tag === "SubagentLineageRecorded" ? childLineage.grant : void 0);
+			const delegationDepth = submission.workerAdmission?.origin.depth ?? (childLineage?._tag === "SubagentLineageRecorded" ? childLineage.parentLink.depth : 0);
+			const inheritedBudget = submission.workerAdmission?.origin.budget ?? (childLineage?._tag === "SubagentLineageRecorded" ? childLineage.budget : void 0);
+			if (submission.parentLinkage !== void 0 && (childLineage?._tag !== "SubagentLineageRecorded" || childLineage.parentSubmissionId !== submission.parentLinkage.parentSubmissionId || childLineage.parentLink.parentToolCallId !== submission.parentLinkage.parentToolCallId || !definitionDigestsEqual(childLineage.childDefinitionDigests, submission.agentDigests) || childLineage.childInputDigest !== submission.inputDigest)) return yield* RunJournalError.make({ message: "The child Run has no matching canonical lineage and execution bounds" });
+			const completionTools = [...agent.definition.completion === void 0 ? [] : [agent.definition.completion.tool], ...agent.definition.completionFromTools?.map((declaration) => declaration.tool) ?? []];
+			const pending = yield* pendingToolBatchFor(records, runId, completionTools);
+			const resumeProjection = pending === void 0 ? journal : yield* projectRunJournalStream(withoutPendingBatch(canonical, pending, runId), runId, void 0, priorContext);
+			if (initialJournal !== void 0 && (journal.committedTurns !== 0 || journal.historyFrom !== 1 || journal.contextWindowId !== void 0 || historyEvidence.size !== 0 || pending !== void 0 || boundaries.some((boundary) => boundary.incomplete))) initialJournal.cacheable = false;
+			if (initialJournal?.cacheable) initialJournal.history = initialJournal.prefix ?? preparePromptHistory(journal.historyBefore);
+			if (initialJournal !== void 0) initialJournal.records = void 0;
+			const rolloverOperation = journal.pendingContextToolCallId === void 0 ? void 0 : operationsFor(records, runId).get(journal.pendingContextToolCallId);
+			const rolloverTool = rolloverOperation === void 0 ? void 0 : agent.definition.toolkit.tools[rolloverOperation.toolName];
+			const pendingContextToolCallId = rolloverOperation !== void 0 && rolloverTool !== void 0 && Context.get(rolloverTool.annotations, ContextRolloverTool) && currentContracts[rolloverOperation.toolName] === rolloverOperation.replay ? journal.pendingContextToolCallId : void 0;
+			const applicationCalls = pending?.calls.filter((call) => !call.providerExecuted);
+			const completionCandidate = applicationCalls?.length === 1 && completionTools.some((tool) => tool === applicationCalls[0]?.name) && pending?.settled.some((result) => result.id === applicationCalls[0]?.id && !result.isFailure) ? applicationCalls[0] : void 0;
+			const settledCompletion = pending !== void 0 && completionCandidate !== void 0 && supportsOperation(OpenToolCallEvidence.make({
+				toolCallId: Schema.decodeSync(ToolCallId)(completionCandidate.id),
+				toolName: completionCandidate.name,
+				turn: pending.turn
+			}), pending.toolOperations.find((operation) => operation.toolCallId === completionCandidate.id), {
+				definition: agent.definition,
+				contracts: currentContracts
+			}) ? Schema.decodeSync(ToolCallId)(completionCandidate.id) : void 0;
+			const knownIds = knownRecordIdsOf(records);
+			const stepOutputs = /* @__PURE__ */ new Map();
+			for (const envelope of records) {
+				const payload = envelope.record.payload;
+				if (payload._tag === "ToolStepSettled" && payload.runId === runId) stepOutputs.set(toolStepSettledRecordId(runId, payload.toolCallId, payload.stepName), payload.output);
+			}
+			const canonicalApprovalDecisions = /* @__PURE__ */ new Map();
+			const approvalRequestedTurns = /* @__PURE__ */ new Set();
+			for (const envelope of records) {
+				const payload = envelope.record.payload;
+				if (payload._tag === "ToolApprovalDecided" && payload.runId === runId) canonicalApprovalDecisions.set(payload.toolCallId, payload.decision);
+				else if (payload._tag === "ToolApprovalRequested" && payload.runId === runId) approvalRequestedTurns.add(payload.turn);
+			}
+			const approvalIntents = /* @__PURE__ */ new Map();
+			for (const intent of approvalDecisions) approvalIntents.set(intent.toolCallId, intent);
+			const joinedInputEnvelopes = /* @__PURE__ */ new Map();
+			let lastHostResponseSequence;
+			for (const envelope of records) {
+				const payload = envelope.record.payload;
+				if (payload._tag === "UserInputRecorded" && payload.runId === runId && payload.submissionId !== void 0 && payload.submissionId !== submissionId) joinedInputEnvelopes.set(payload.submissionId, envelope);
+				else if (payload._tag === "ModelResponseRecorded" && payload.runId === runId) {
+					if (lastHostResponseSequence === void 0 || envelope.sequence > lastHostResponseSequence) lastHostResponseSequence = envelope.sequence;
+				}
+			}
+			const stagedUsage = /* @__PURE__ */ new Map();
+			const committedUsageLengths = /* @__PURE__ */ new Map();
+			const committedUnobservedCalls = /* @__PURE__ */ new Map();
+			const usageForCommit = (turn) => {
+				const staged = stagedUsage.get(turn);
+				if (staged === void 0) return void 0;
+				const modelUsage = staged.modelUsage.slice(committedUsageLengths.get(turn) ?? 0);
+				if (modelUsage.length === 0) return void 0;
+				return {
+					modelUsage,
+					inputTokens: modelUsage.reduce((sum, call) => sum + call.inputTokens.total, 0),
+					outputTokens: modelUsage.reduce((sum, call) => sum + call.outputTokens.total, 0),
+					costMicrousd: modelUsage.reduce((sum, call) => sum + call.costMicrousd, 0)
+				};
+			};
+			const unobservedForCommit = (turn) => (stagedUnobservedCalls.get(turn) ?? 0) - (committedUnobservedCalls.get(turn) ?? 0);
+			const recordCommittedUsage = (batch) => {
+				for (const record of batch.records) {
+					if (record.payload._tag !== "ModelResponseRecorded" && record.payload._tag !== "ModelCallAborted") continue;
+					const payload = record.payload;
+					committedUsageLengths.set(payload.turn, (committedUsageLengths.get(payload.turn) ?? 0) + (payload.modelUsage?.length ?? 0));
+					committedUnobservedCalls.set(payload.turn, (committedUnobservedCalls.get(payload.turn) ?? 0) + (payload.unobservedModelCalls ?? 0));
+				}
+				progressWriters.get(ctx)?.stageUsage(runId, terminalUsageCharge(uncommittedModelUsage()));
+			};
+			const uncommittedModelUsage = () => [...stagedUsage.entries()].flatMap(([turn, usage]) => usage.modelUsage.slice(committedUsageLengths.get(turn) ?? 0));
+			const stagedUnobservedCalls = /* @__PURE__ */ new Map();
+			let interruptedUsage = records.some(({ record }) => record.payload._tag === "ModelResponseInterrupted" && record.payload.runId === runId);
+			const checkedUsageTotal = (field, value) => decodeUsageTotal(value).pipe(Effect.mapError((cause) => RunJournalError.make({
+				message: `Run usage summary exceeds safe-integer bounds at ${field}`,
 				cause
 			})));
-			let inputTokens = journal.usage.inputTokens;
-			let outputTokens = journal.usage.outputTokens;
-			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);
-			}
-			const modelCalls = yield* addUsageTotal("modelCalls", journal.usage.modelCalls, stagedCalls.length);
-			const legacyCalls = yield* subtractUsageTotal("legacy.modelCalls", modelCalls, detailed.modelCalls);
-			const legacyInput = yield* subtractUsageTotal("legacy.inputTokens", inputTokens, detailed.inputTokens.total);
-			const legacyOutput = yield* subtractUsageTotal("legacy.outputTokens", outputTokens, detailed.outputTokens.total);
-			const legacyCost = yield* subtractUsageTotal("legacy.costMicrousd", costMicrousd, detailed.costMicrousd);
-			if (legacyCalls === 0 && (legacyInput !== 0 || legacyOutput !== 0 || legacyCost !== 0)) return yield* RunJournalError.make({ message: "Run aggregate usage has legacy totals without a legacy model call" });
-			const byModel = [...detailed.byModel];
-			if (legacyCalls > 0) {
-				const existingIndex = byModel.findIndex((group) => group.provider === "unknown" && group.model === "legacy-record" && group.responseModel === void 0 && group.serviceTier === void 0 && group.pricingVersion === void 0);
-				const existing = existingIndex < 0 ? void 0 : byModel[existingIndex];
-				const legacyGroup = ModelUsageGroup.make({
-					provider: "unknown",
-					model: "legacy-record",
-					modelCalls: yield* addUsageTotal("byModel.modelCalls", existing?.modelCalls ?? 0, legacyCalls),
+			const addUsageTotal = (field, left, right) => checkedUsageTotal(field, left + right);
+			const subtractUsageTotal = (field, left, right) => checkedUsageTotal(field, left - right);
+			const currentUsageSummary = () => Effect.gen(function* () {
+				const stagedCalls = [...stagedUsage.values()].flatMap((usage) => usage.modelUsage);
+				let unobservedModelCalls = journal.usage.unobservedModelCalls ?? 0;
+				for (const count of stagedUnobservedCalls.values()) unobservedModelCalls = yield* addUsageTotal("unobservedModelCalls", unobservedModelCalls, count);
+				const detailedCalls = [...journal.usage.modelUsage, ...stagedCalls];
+				const detailed = yield* summarizeModelUsage(detailedCalls, journal.usage.summarizedModelUsage).pipe(Effect.mapError((cause) => RunJournalError.make({
+					message: "Run detailed usage exceeds safe-integer accounting bounds",
+					cause
+				})));
+				let inputTokens = journal.usage.inputTokens;
+				let outputTokens = journal.usage.outputTokens;
+				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);
+				}
+				const modelCalls = yield* addUsageTotal("modelCalls", journal.usage.modelCalls, stagedCalls.length);
+				const legacyCalls = yield* subtractUsageTotal("legacy.modelCalls", modelCalls, detailed.modelCalls);
+				const legacyInput = yield* subtractUsageTotal("legacy.inputTokens", inputTokens, detailed.inputTokens.total);
+				const legacyOutput = yield* subtractUsageTotal("legacy.outputTokens", outputTokens, detailed.outputTokens.total);
+				const legacyCost = yield* subtractUsageTotal("legacy.costMicrousd", costMicrousd, detailed.costMicrousd);
+				if (legacyCalls === 0 && (legacyInput !== 0 || legacyOutput !== 0 || legacyCost !== 0)) return yield* RunJournalError.make({ message: "Run aggregate usage has legacy totals without a legacy model call" });
+				const byModel = [...detailed.byModel];
+				if (legacyCalls > 0) {
+					const existingIndex = byModel.findIndex((group) => group.provider === "unknown" && group.model === "legacy-record" && group.responseModel === void 0 && group.serviceTier === void 0 && group.pricingVersion === void 0);
+					const existing = existingIndex < 0 ? void 0 : byModel[existingIndex];
+					const legacyGroup = ModelUsageGroup.make({
+						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),
+							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),
+							reasoning: existing?.outputTokens.reasoning ?? 0
+						}),
+						costMicrousd: yield* addUsageTotal("byModel.costMicrousd", existing?.costMicrousd ?? 0, legacyCost)
+					});
+					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({
+					...legacyCalls === 0 && detailed.webSearchCalls !== void 0 ? { webSearchCalls: detailed.webSearchCalls } : {},
+					modelCalls,
 					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),
-						cacheRead: existing?.inputTokens.cacheRead ?? 0,
-						cacheWrite: existing?.inputTokens.cacheWrite ?? 0
+						total: inputTokens,
+						uncached,
+						cacheRead: detailed.inputTokens.cacheRead,
+						cacheWrite: detailed.inputTokens.cacheWrite
 					}),
 					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),
-						reasoning: existing?.outputTokens.reasoning ?? 0
+						total: outputTokens,
+						text,
+						reasoning: detailed.outputTokens.reasoning
 					}),
-					costMicrousd: yield* addUsageTotal("byModel.costMicrousd", existing?.costMicrousd ?? 0, legacyCost)
+					costMicrousd,
+					byModel,
+					unobservedModelCalls,
+					usageStatus: legacyCalls > 0 || unobservedModelCalls > 0 || interruptedUsage ? detailed.usageStatus === "unknown" ? "unknown" : "partial" : detailed.usageStatus,
+					pricingStatus: legacyCalls > 0 || unobservedModelCalls > 0 || interruptedUsage ? detailed.pricingStatus === "unknown" ? "unknown" : "partial" : detailed.pricingStatus
 				});
-				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({
-				...legacyCalls === 0 && detailed.webSearchCalls !== void 0 ? { webSearchCalls: detailed.webSearchCalls } : {},
-				modelCalls,
-				inputTokens: InputTokenUsage.make({
-					total: inputTokens,
-					uncached,
-					cacheRead: detailed.inputTokens.cacheRead,
-					cacheWrite: detailed.inputTokens.cacheWrite
-				}),
-				outputTokens: OutputTokenUsage.make({
-					total: outputTokens,
-					text,
-					reasoning: detailed.outputTokens.reasoning
-				}),
-				costMicrousd,
-				byModel,
-				unobservedModelCalls,
-				usageStatus: legacyCalls > 0 || unobservedModelCalls > 0 || interruptedUsage ? detailed.usageStatus === "unknown" ? "unknown" : "partial" : detailed.usageStatus,
-				pricingStatus: legacyCalls > 0 || unobservedModelCalls > 0 || interruptedUsage ? detailed.pricingStatus === "unknown" ? "unknown" : "partial" : detailed.pricingStatus
 			});
-		});
-		const activeExecution = yield* reader.readExecution({
-			threadId: ctx.threadId,
-			runId
-		});
-		const recordedCompletion = Option.isSome(activeExecution) ? activeExecution.value.operational.find((record) => record.recordId === runCompletedRecordId(runId))?.payload : void 0;
-		if (recordedCompletion !== void 0) {
-			if (recordedCompletion._tag !== "RunCompleted" || recordedCompletion.runId !== runId) return yield* RunJournalError.make({ message: `Run ${runId} has an invalid terminal completion marker` });
-			const response = [...records].reverse().find((envelope) => envelope.record.payload._tag === "ModelResponseRecorded" && envelope.record.payload.runId === runId)?.record.payload;
-			if (response?._tag !== "ModelResponseRecorded") return yield* RunJournalError.make({ message: `Run ${runId} has a terminal completion marker without a response` });
-			const calls = (yield* declaredToolCalls(response.messages)).application;
-			if (calls.length > 0) {
-				const call = calls[0];
-				const settled = call === void 0 ? void 0 : records.find(({ record }) => record.payload._tag === "ToolCallSettled" && record.payload.runId === runId && record.payload.toolCallId === call.id)?.record.payload;
-				if (calls.length !== 1 || call === void 0 || settled?._tag !== "ToolCallSettled" || settled.toolName !== call.name || settled.isFailure) return yield* RunJournalError.make({ message: `Run ${runId} has a terminal completion marker without one successful declared Tool result` });
-			}
-			return {
-				_tag: "completed",
-				result: recordedCompletion.output,
-				...recordedCompletion.runDisposition === void 0 ? {} : { runDisposition: recordedCompletion.runDisposition },
-				...recordedCompletion.finishReason === void 0 ? {} : { finishReason: recordedCompletion.finishReason },
-				...recordedCompletion.exhausted === void 0 ? {} : { exhausted: recordedCompletion.exhausted },
-				usageSummary: yield* currentUsageSummary()
-			};
-		}
-		let ownerFirstSequence;
-		for (const envelope of records) {
-			const payload = envelope.record.payload;
-			if ("runId" in payload && payload.runId === runId) {
-				ownerFirstSequence = envelope.sequence;
-				break;
+			const activeExecution = yield* reader.readExecution({
+				threadId: ctx.threadId,
+				runId
+			});
+			const recordedCompletion = Option.isSome(activeExecution) ? activeExecution.value.operational.find((record) => record.recordId === runCompletedRecordId(runId))?.payload : void 0;
+			if (recordedCompletion !== void 0) {
+				if (recordedCompletion._tag !== "RunCompleted" || recordedCompletion.runId !== runId) return yield* RunJournalError.make({ message: `Run ${runId} has an invalid terminal completion marker` });
+				const response = [...records].reverse().find((envelope) => envelope.record.payload._tag === "ModelResponseRecorded" && envelope.record.payload.runId === runId)?.record.payload;
+				if (response?._tag !== "ModelResponseRecorded") return yield* RunJournalError.make({ message: `Run ${runId} has a terminal completion marker without a response` });
+				const calls = (yield* declaredToolCalls(response.messages)).application;
+				if (calls.length > 0) {
+					const call = calls[0];
+					const settled = call === void 0 ? void 0 : records.find(({ record }) => record.payload._tag === "ToolCallSettled" && record.payload.runId === runId && record.payload.toolCallId === call.id)?.record.payload;
+					if (calls.length !== 1 || call === void 0 || settled?._tag !== "ToolCallSettled" || settled.toolName !== call.name || settled.isFailure) return yield* RunJournalError.make({ message: `Run ${runId} has a terminal completion marker without one successful declared Tool result` });
+				}
+				return {
+					_tag: "completed",
+					result: recordedCompletion.output,
+					...recordedCompletion.runDisposition === void 0 ? {} : { runDisposition: recordedCompletion.runDisposition },
+					...recordedCompletion.finishReason === void 0 ? {} : { finishReason: recordedCompletion.finishReason },
+					...recordedCompletion.exhausted === void 0 ? {} : { exhausted: recordedCompletion.exhausted },
+					usageSummary: yield* currentUsageSummary()
+				};
 			}
-		}
-		/** Only canonical joined inputs can require restoration from an earlier Attempt. */
-		let joinBacklog = joinedInputEnvelopes.size === 0 ? [] : void 0;
-		/** Joined inputs already handed to the engine during THIS Attempt (never re-deliver). */
-		const deliveredJoinInputs = /* @__PURE__ */ new Set();
-		const encodedParamsByCallId = /* @__PURE__ */ new Map();
-		const declaredNamesByCallId = /* @__PURE__ */ new Map();
-		const subagentState = subagentRecordsOf(records, runId);
-		const declaredToolIds = new Set(subagentState.declaredNames.keys());
-		if (declaredToolIds.size > 4096) return yield* RunJournalError.make({ message: `Run exceeds the ${MAX_RUN_TOOL_CALL_IDENTITIES} Tool Call identity limit` });
-		for (const [callId, name] of subagentState.declaredNames) declaredNamesByCallId.set(callId, name);
-		if (pending !== void 0) for (const call of pending.calls) {
-			encodedParamsByCallId.set(call.id, call.params);
-			declaredNamesByCallId.set(call.id, call.name);
-		}
-		let resumeLeadingMessages;
-		let resumeResponseMessages;
-		if (pending !== void 0) {
-			const pendingMessages = yield* decodePrompt(pending.messages).pipe(Effect.mapError((cause) => RunJournalError.make({
-				message: "Pending ModelResponseRecorded messages are not Schema-encoded Prompt messages",
-				cause
-			})));
-			const firstAssistant = pendingMessages.content.findIndex((message) => message.role === "assistant");
-			if (firstAssistant > 0) resumeLeadingMessages = Prompt.fromMessages(pendingMessages.content.slice(0, firstAssistant).filter((message) => message.role !== "system"));
-			if (firstAssistant >= 0) resumeResponseMessages = Prompt.fromMessages(pendingMessages.content.slice(firstAssistant));
-		}
-		const initialDispatchProofTurns = new Set(initialDispatchBlockedTurns(records, runId));
-		let currentToolTurn = pending === void 0 ? void 0 : {
-			turn: pending.turn,
-			turnId: pending.turnId
-		};
-		const haltRef = yield* Ref.make(void 0);
-		const yieldSignal = yield* Deferred.make();
-		const recordHalt = (effect) => 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)))));
-		const checkpoint = recordHalt(Effect.gen(function* () {
-			const failure = yield* Ref.get(haltRef);
-			if (failure !== void 0) return yield* failure;
-			const progress = progressWriters.get(ctx);
-			if (progress !== void 0) yield* progress.check(runId).pipe(Effect.provideService(CurrentRunWriter, ctx));
-		}));
-		const responseGate = yield* Semaphore.make(1);
-		let deferredResponse;
-		const acceptResponseDeclarations = (batch) => {
-			for (const record of batch.records) {
-				if (record.payload._tag !== "ModelResponseRecorded") continue;
-				for (const call of record.payload.toolOperations) {
-					declaredToolIds.add(call.toolCallId);
-					declaredNamesByCallId.set(call.toolCallId, call.toolName);
+			let ownerFirstSequence;
+			for (const envelope of records) {
+				const payload = envelope.record.payload;
+				if ("runId" in payload && payload.runId === runId) {
+					ownerFirstSequence = envelope.sequence;
+					break;
 				}
 			}
-		};
-		const promoteResponse = Effect.gen(function* () {
-			const halted = yield* Ref.get(haltRef);
-			if (halted !== void 0) return yield* halted;
-			const deferred = deferredResponse;
-			if (deferred === void 0) return;
-			const record = deferred.batch.records[0];
-			if (record?.payload._tag !== "ModelResponseRecorded") return yield* RunJournalError.make({ message: "Deferred Turn has no owned response" });
-			const calls = yield* declaredToolCalls(record.payload.messages);
-			const batch = CanonicalBatch.make({
-				...deferred.batch,
-				batchId: turnResponseBatchId(runId, deferred.turn)
-			});
-			yield* appendBatch(ctx, batch);
-			acceptResponseDeclarations(batch);
-			for (const call of calls.application) encodedParamsByCallId.set(call.id, call.params);
-			recordCommittedUsage(batch);
-			for (const entry of batch.records) knownIds.add(entry.recordId);
-			deferredResponse = void 0;
-			yield* hit("turn:after-response-append");
-		});
-		const flushDeferredResponse = promoteResponse.pipe(Effect.tapError((failure) => failure instanceof ThreadStoreError && failure.cause instanceof AgentPersistenceCapacityError ? Effect.void : Ref.set(haltRef, failure)), responseGate.withPermits(1));
-		let initialHistoryLength = 0;
-		let initialInstructions = [];
-		const completionState = {};
-		const turnCounter = yield* Ref.make(journal.committedTurns + (journal.policyUsage.modelRestarts ?? 0));
-		const idGenerator = {
-			nextThreadId: Effect.succeed(submission.threadId),
-			nextRunId: Effect.succeed(runId),
-			nextTurnId: Ref.modify(turnCounter, (turn) => [turnIdForRun(runId, turn + 1), turn + 1])
-		};
-		const instructionView = (messages, instructions, insertWhenAbsent, priorRunPrefixLength) => {
-			const projected = [];
-			const lengths = [0];
-			let inserted = false;
-			for (const [index, message] of messages.entries()) {
-				if (index >= priorRunPrefixLength && message.role === "system") {
-					if (!inserted) projected.push(...instructions);
-					inserted = true;
-				} else projected.push(message);
-				lengths.push(projected.length);
+			/** Only canonical joined inputs can require restoration from an earlier Attempt. */
+			let joinBacklog = joinedInputEnvelopes.size === 0 ? [] : void 0;
+			/** Joined inputs already handed to the engine during THIS Attempt (never re-deliver). */
+			const deliveredJoinInputs = /* @__PURE__ */ new Set();
+			const encodedParamsByCallId = /* @__PURE__ */ new Map();
+			const declaredNamesByCallId = /* @__PURE__ */ new Map();
+			const subagentState = subagentRecordsOf(records, runId);
+			const declaredToolIds = new Set(subagentState.declaredNames.keys());
+			if (declaredToolIds.size > 4096) return yield* RunJournalError.make({ message: `Run exceeds the ${MAX_RUN_TOOL_CALL_IDENTITIES} Tool Call identity limit` });
+			for (const [callId, name] of subagentState.declaredNames) declaredNamesByCallId.set(callId, name);
+			if (pending !== void 0) for (const call of pending.calls) {
+				encodedParamsByCallId.set(call.id, call.params);
+				declaredNamesByCallId.set(call.id, call.name);
 			}
-			if (!inserted && insertWhenAbsent) projected.push(...instructions);
-			return {
-				messages: projected,
-				prefixLength: (length) => lengths[length] ?? projected.length
-			};
-		};
-		const resumeContext = { prepare: ({ source }) => Effect.sync(() => {
-			const prefix = journal.committedTurns === 0 && priorContext !== void 0 ? priorContext.prompt.content.slice(priorContext.priorHistoryLength) : [];
-			const priorRunPrefixLength = journal.committedTurns === 0 ? resumeProjection.prompt.content.length : resumeProjection.historyBefore.content.length;
-			const view = instructionView(prefix.length === 0 ? resumeProjection.prompt.content : [...resumeProjection.prompt.content, ...prefix], initialInstructions, true, priorRunPrefixLength);
-			return {
-				prompt: Prompt.fromMessages([...view.messages, ...source.content.slice(initialHistoryLength)]),
-				priorRunPrefixLength: view.prefixLength(priorRunPrefixLength)
-			};
-		}) };
-		const externalContext = runContextPreparation.hook;
-		const needsContextReplay = priorContext !== void 0 || journal.committedTurns > 0;
-		const preparedContext = externalContext === void 0 ? needsContextReplay ? resumeContext : void 0 : { prepare: (request) => (needsContextReplay ? resumeContext.prepare(request) : Effect.succeed({
-			prompt: request.source,
-			priorRunPrefixLength: journal.historyBefore.content.length
-		})).pipe(Effect.flatMap(({ prompt, priorRunPrefixLength }) => externalContext.prepare({
-			...request,
-			source: prompt,
-			priorRunPrefixLength
-		})), Effect.map((prepared) => {
-			if (prepared.rollover === void 0 || !knownIds.has(compactionRecordId(runId, request.turn, "rollover"))) return prepared;
-			const { rollover: _, ...retained } = prepared;
-			return retained;
-		})) };
-		const durability = {
-			toolResultMaxBytes: MAX_PERSISTED_JSON_BYTES,
-			checkpoint,
-			initialize: ({ initialHistory, priorHistoryLength }) => recordHalt(Effect.gen(function* () {
-				initialHistoryLength = initialHistory.content.length;
-				initialInstructions = initialHistory.content.slice(priorHistoryLength).filter((message) => message.role === "system");
-				if (priorContext !== void 0) return;
-				const recordId = decodeRecordIdSync(JSON.stringify(["run-context@1", runId]));
-				const prompt = yield* Schema.encodeEffect(Prompt.Prompt)(Prompt.fromMessages(initialHistory.content.slice(priorHistoryLength))).pipe(Effect.flatMap(decodePersisted), Effect.mapError((cause) => RunJournalError.make({
-					message: "Original Run context exceeds persistence bounds",
-					cause
-				})));
-				const history = Prompt.fromMessages(initialHistory.content.slice(0, priorHistoryLength));
-				const historyDigest = yield* withCrypto(digestPromptHistory(history, initialJournal?.history));
-				const retained = yield* Effect.forEach([...historyEvidence.values()].filter((entry) => entry.sequence < journal.historyFrom).sort((left, right) => left.sequence - right.sequence), (entry) => Effect.gen(function* () {
-					const full = yield* getRecord({
-						threadId: ctx.threadId,
-						recordId: entry.record.recordId
-					});
-					if (Option.isNone(full) || full.value.sequence !== entry.sequence) return yield* RunJournalError.make({ message: "Retained history has no exact canonical fact" });
-					return {
-						...yield* withCrypto(reference(full.value.record)),
-						sequence: entry.sequence
-					};
-				}).pipe(Effect.provideService(ThreadReader, reader)));
-				const payload = yield* RunContextRecorded.makeEffect({
-					version: 1,
-					runId,
-					runScopedInput: prompt,
-					historyFrom: journal.historyFrom,
-					historyThrough: CanonicalSequence.make(originalInput.sequence - 1),
-					retained,
-					historyDigest,
-					priorHistoryLength,
-					...journal.contextWindowId === void 0 ? {} : { contextWindowId: journal.contextWindowId }
-				}).pipe(Effect.mapError((cause) => RunJournalError.make({
-					message: "Original Run context mapping exceeds its bounds",
+			let resumeLeadingMessages;
+			let resumeResponseMessages;
+			if (pending !== void 0) {
+				const pendingMessages = yield* decodePrompt(pending.messages).pipe(Effect.mapError((cause) => RunJournalError.make({
+					message: "Pending ModelResponseRecorded messages are not Schema-encoded Prompt messages",
 					cause
 				})));
-				yield* (yield* CurrentRunStart).commit(yield* makeEnvelope(recordId, payload));
-				knownIds.add(runStartedRecordId(runId));
-				knownIds.add(recordId);
-				historyEvidence.clear();
-				projectedJournal = void 0;
-			})),
-			commitModelRestart: (restart) => recordHalt(Effect.gen(function* () {
-				if (knownIds.has(modelResponseRecordId(runId, restart.turn))) return yield* RunJournalError.make({ message: "Cannot restart a canonical model response" });
-				const recordId = decodeRecordIdSync(`model-aborted:${runId}:${restart.restart}`);
-				const record = yield* makeEnvelope(recordId, ModelCallAborted.make({
-					runId,
-					...restart,
-					reason: "joined-input",
-					modelUsage: usageForCommit(restart.turn)?.modelUsage ?? [],
-					unobservedModelCalls: unobservedForCommit(restart.turn)
-				}));
+				const firstAssistant = pendingMessages.content.findIndex((message) => message.role === "assistant");
+				if (firstAssistant > 0) resumeLeadingMessages = Prompt.fromMessages(pendingMessages.content.slice(0, firstAssistant).filter((message) => message.role !== "system"));
+				if (firstAssistant >= 0) resumeResponseMessages = Prompt.fromMessages(pendingMessages.content.slice(firstAssistant));
+			}
+			const initialDispatchProofTurns = new Set(initialDispatchBlockedTurns(records, runId));
+			let currentToolTurn = pending === void 0 ? void 0 : {
+				turn: pending.turn,
+				turnId: pending.turnId
+			};
+			const haltRef = yield* Ref.make(void 0);
+			const yieldSignal = yield* Deferred.make();
+			const recordHalt = (effect) => 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)))));
+			const checkpoint = recordHalt(Effect.gen(function* () {
+				const failure = yield* Ref.get(haltRef);
+				if (failure !== void 0) return yield* failure;
+				const progress = progressWriters.get(ctx);
+				if (progress !== void 0) yield* progress.check(runId).pipe(Effect.provideService(CurrentRunWriter, ctx));
+			}));
+			const responseGate = yield* Semaphore.make(1);
+			let deferredResponse;
+			const acceptResponseDeclarations = (batch) => {
+				for (const record of batch.records) {
+					if (record.payload._tag !== "ModelResponseRecorded") continue;
+					for (const call of record.payload.toolOperations) {
+						declaredToolIds.add(call.toolCallId);
+						declaredNamesByCallId.set(call.toolCallId, call.toolName);
+					}
+				}
+			};
+			const promoteResponse = Effect.gen(function* () {
+				const halted = yield* Ref.get(haltRef);
+				if (halted !== void 0) return yield* halted;
+				const deferred = deferredResponse;
+				if (deferred === void 0) return;
+				const record = deferred.batch.records[0];
+				if (record?.payload._tag !== "ModelResponseRecorded") return yield* RunJournalError.make({ message: "Deferred Turn has no owned response" });
+				const calls = yield* declaredToolCalls(record.payload.messages);
 				const batch = CanonicalBatch.make({
-					batchId: decodeBatchIdSync(recordId),
-					producerId: config.producerId,
-					records: [record]
+					...deferred.batch,
+					batchId: turnResponseBatchId(runId, deferred.turn)
 				});
 				yield* appendBatch(ctx, batch);
+				acceptResponseDeclarations(batch);
+				for (const call of calls.application) encodedParamsByCallId.set(call.id, call.params);
 				recordCommittedUsage(batch);
-				knownIds.add(recordId);
-			})),
-			reservePolicyUsage: (usage) => recordHalt(Effect.gen(function* () {
-				yield* flushDeferredResponse;
-				const recordId = decodeRecordIdSync(`policy:${runId}:${usage.programmaticToolCalls}:${usage.finalizationUsed}`);
-				if (knownIds.has(recordId)) return;
-				const record = yield* makeEnvelope(recordId, RunPolicyUsageReserved.make({
-					runId,
-					...usage
-				}));
-				yield* hit("policy:before-reservation-append");
-				yield* appendBatch(ctx, CanonicalBatch.make({
-					batchId: decodeBatchIdSync(recordId),
-					producerId: config.producerId,
-					records: [record]
-				}));
-				knownIds.add(recordId);
-				yield* hit("policy:after-reservation-append");
-			})),
-			commitTurn: (commit) => recordHalt(Effect.gen(function* () {
-				const halted = yield* Ref.get(haltRef);
-				if (halted !== void 0) return yield* halted;
-				if (deferredResponse !== void 0 && (deferredResponse.turn !== commit.turn || deferredResponse.turnId !== commit.turnId)) return yield* RunJournalError.make({ message: "A new Turn preceded settlement of its deferred response" });
-				if (commit._tag === "Partial") yield* promoteResponse;
-				const deferred = deferredResponse;
-				if (commit._tag === "Response" && deferred !== void 0) return yield* RunJournalError.make({ message: "Turn response was already deferred" });
-				const responseId = modelResponseRecordId(runId, commit.turn);
-				const suppliedResponse = commit._tag === "Partial" ? void 0 : commit.response;
-				const response = knownIds.has(responseId) || deferred !== void 0 ? void 0 : suppliedResponse;
-				if (suppliedResponse !== void 0) currentToolTurn = {
-					turn: commit.turn,
-					turnId: commit.turnId
-				};
-				if (commit._tag === "Response" && response === void 0) return "committed";
-				const toolOperations = [];
-				const responseToolIds = /* @__PURE__ */ new Set();
-				for (const call of response?.calls ?? []) {
-					if (declaredToolIds.has(call.toolCallId) || responseToolIds.has(call.toolCallId)) return yield* RunJournalError.make({ message: "Tool Call identity is reused within a Run" });
-					if (declaredToolIds.size + responseToolIds.size + 1 > 4096) return yield* RunJournalError.make({ message: `Run exceeds the ${MAX_RUN_TOOL_CALL_IDENTITIES} Tool Call identity limit` });
-					const replay = currentContracts[call.toolName];
-					if (replay === void 0) return yield* RunJournalError.make({ message: "Canonical Tool declaration has no original operation contract" });
-					toolOperations.push(ToolOperation.make({
-						toolCallId: call.toolCallId,
-						toolName: call.toolName,
-						executionClass: call.executionClass,
-						executionKind: call.executionKind,
-						replay
-					}));
-					responseToolIds.add(call.toolCallId);
+				for (const entry of batch.records) knownIds.add(entry.recordId);
+				deferredResponse = void 0;
+				yield* hit("turn:after-response-append");
+			});
+			const flushDeferredResponse = promoteResponse.pipe(Effect.tapError((failure) => failure instanceof ThreadStoreError && failure.cause instanceof AgentPersistenceCapacityError ? Effect.void : Ref.set(haltRef, failure)), responseGate.withPermits(1));
+			let initialHistoryLength = 0;
+			let initialInstructions = [];
+			const completionState = {};
+			const turnCounter = yield* Ref.make(journal.committedTurns + (journal.policyUsage.modelRestarts ?? 0));
+			const idGenerator = {
+				nextThreadId: Effect.succeed(submission.threadId),
+				nextRunId: Effect.succeed(runId),
+				nextTurnId: Ref.modify(turnCounter, (turn) => [turnIdForRun(runId, turn + 1), turn + 1])
+			};
+			const instructionView = (messages, instructions, insertWhenAbsent, priorRunPrefixLength) => {
+				const projected = [];
+				const lengths = [0];
+				let inserted = false;
+				for (const [index, message] of messages.entries()) {
+					if (index >= priorRunPrefixLength && message.role === "system") {
+						if (!inserted) projected.push(...instructions);
+						inserted = true;
+					} else projected.push(message);
+					lengths.push(projected.length);
 				}
-				const toolResults = commit._tag === "Response" ? [] : commit.results.filter((result) => !knownIds.has(toolCallSettledRecordId(runId, commit.turn, result.toolCallId)));
-				let runCompletion;
-				if (commit._tag === "Settled" && commit.completion !== void 0) {
-					const completion = commit.completion;
-					const output = yield* decodePersisted(completion.output).pipe(Effect.mapError((cause) => LedgerError.make({
-						operation: "recordCompleted",
-						message: "Run output exceeds canonical persistence bounds",
+				if (!inserted && insertWhenAbsent) projected.push(...instructions);
+				return {
+					messages: projected,
+					prefixLength: (length) => lengths[length] ?? projected.length
+				};
+			};
+			const resumeContext = { prepare: ({ source }) => Effect.sync(() => {
+				const prefix = journal.committedTurns === 0 && priorContext !== void 0 ? priorContext.prompt.content.slice(priorContext.priorHistoryLength) : [];
+				const priorRunPrefixLength = journal.committedTurns === 0 ? resumeProjection.prompt.content.length : resumeProjection.historyBefore.content.length;
+				const view = instructionView(prefix.length === 0 ? resumeProjection.prompt.content : [...resumeProjection.prompt.content, ...prefix], initialInstructions, true, priorRunPrefixLength);
+				return {
+					prompt: Prompt.fromMessages([...view.messages, ...source.content.slice(initialHistoryLength)]),
+					priorRunPrefixLength: view.prefixLength(priorRunPrefixLength)
+				};
+			}) };
+			const externalContext = runContextPreparation.hook;
+			const needsContextReplay = priorContext !== void 0 || journal.committedTurns > 0;
+			const preparedContext = externalContext === void 0 ? needsContextReplay ? resumeContext : void 0 : { prepare: (request) => (needsContextReplay ? resumeContext.prepare(request) : Effect.succeed({
+				prompt: request.source,
+				priorRunPrefixLength: journal.historyBefore.content.length
+			})).pipe(Effect.flatMap(({ prompt, priorRunPrefixLength }) => externalContext.prepare({
+				...request,
+				source: prompt,
+				priorRunPrefixLength
+			})), Effect.map((prepared) => {
+				if (prepared.rollover === void 0 || !knownIds.has(compactionRecordId(runId, request.turn, "rollover"))) return prepared;
+				const { rollover: _, ...retained } = prepared;
+				return retained;
+			})) };
+			const durability = {
+				toolResultMaxBytes: MAX_PERSISTED_JSON_BYTES,
+				checkpoint,
+				initialize: ({ initialHistory, priorHistoryLength }) => recordHalt(Effect.gen(function* () {
+					initialHistoryLength = initialHistory.content.length;
+					initialInstructions = initialHistory.content.slice(priorHistoryLength).filter((message) => message.role === "system");
+					if (priorContext !== void 0) return;
+					const recordId = decodeRecordIdSync(JSON.stringify(["run-context@1", runId]));
+					const prompt = yield* Schema.encodeEffect(Prompt.Prompt)(Prompt.fromMessages(initialHistory.content.slice(priorHistoryLength))).pipe(Effect.flatMap(decodePersisted), Effect.mapError((cause) => RunJournalError.make({
+						message: "Original Run context exceeds persistence bounds",
 						cause
 					})));
-					if (completion.finishReason === "budget-exhausted" && completion.runDisposition !== void 0) return yield* LedgerError.make({
-						operation: "recordCompleted",
-						message: "A budget-exhausted Run cannot declare an application run disposition"
-					});
-					const runDisposition = completion.runDisposition === void 0 ? void 0 : yield* decodePersisted(completion.runDisposition).pipe(Effect.mapError((cause) => LedgerError.make({
-						operation: "recordCompleted",
-						message: "Run disposition exceeds canonical persistence bounds",
+					const history = Prompt.fromMessages(initialHistory.content.slice(0, priorHistoryLength));
+					const historyDigest = yield* withCrypto(digestPromptHistory(history, initialJournal?.history));
+					const retained = yield* Effect.forEach([...historyEvidence.values()].filter((entry) => entry.sequence < journal.historyFrom).sort((left, right) => left.sequence - right.sequence), (entry) => Effect.gen(function* () {
+						const full = yield* getRecord({
+							threadId: ctx.threadId,
+							recordId: entry.record.recordId
+						});
+						if (Option.isNone(full) || full.value.sequence !== entry.sequence) return yield* RunJournalError.make({ message: "Retained history has no exact canonical fact" });
+						return {
+							...yield* withCrypto(reference(full.value.record)),
+							sequence: entry.sequence
+						};
+					}).pipe(Effect.provideService(ThreadReader, reader)));
+					const payload = yield* RunContextRecorded.makeEffect({
+						version: 1,
+						runId,
+						runScopedInput: prompt,
+						historyFrom: journal.historyFrom,
+						historyThrough: CanonicalSequence.make(originalInput.sequence - 1),
+						retained,
+						historyDigest,
+						priorHistoryLength,
+						...journal.contextWindowId === void 0 ? {} : { contextWindowId: journal.contextWindowId }
+					}).pipe(Effect.mapError((cause) => RunJournalError.make({
+						message: "Original Run context mapping exceeds its bounds",
 						cause
 					})));
-					runCompletion = {
-						output,
-						...runDisposition === void 0 ? {} : { runDisposition },
-						...completion.finishReason === "budget-exhausted" ? {
-							finishReason: completion.finishReason,
-							...completion.exhausted === void 0 ? {} : { exhausted: completion.exhausted }
-						} : {}
-					};
-				}
-				if (response === void 0 && deferred === void 0 && toolResults.length === 0 && runCompletion === void 0) return "committed";
-				if (response === void 0 && deferred === void 0 && !knownIds.has(responseId)) return yield* RunJournalError.make({ message: "Tool results or completion preceded the canonical response" });
-				const input = {
-					toolResultMaxBytes: Math.min(agent.definition.policy.toolResultBounds.maxBytes, MAX_PERSISTED_JSON_BYTES),
-					toolSelectionMaxBytes: utf8ByteLength(JSON.stringify({ toolSelection: { toolNames: Object.keys(currentContracts) } })),
-					runId,
-					turn: commit.turn,
-					turnId: commit.turnId,
-					responseMessages: response?.messages ?? [],
-					toolResults,
-					toolOperations,
-					toolExposure: response?.toolExposure,
-					toolParameterRejections: response?.toolParameterRejections,
-					runScopedPrefixLength: response?.runScopedPrefixLength,
-					producerId: config.producerId,
-					deploymentId: config.deploymentId,
-					createdAt: yield* nowUtc,
-					runCompletion,
-					usage: usageForCommit(commit.turn),
-					unobservedModelCalls: unobservedForCommit(commit.turn)
-				};
-				if (commit._tag === "Partial") {
-					for (const result of toolResults) {
-						const batch = yield* withCrypto(turnResultsBatch({
-							...input,
-							toolResults: [result]
-						}));
-						yield* appendBatch(ctx, CanonicalBatch.make({
-							...batch,
-							batchId: toolCallResultBatchId(runId, commit.turn, result.toolCallId)
-						}));
-						for (const record of batch.records) knownIds.add(record.recordId);
-						yield* hit("subagent:after-sibling-settle");
-					}
-					return "committed";
-				}
-				if (commit._tag === "Response" && commit.defer === true) {
-					if (toolOperations.length === 0 || toolOperations.some((call) => call.executionClass !== "readonly" || call.executionKind !== "ordinary")) return yield* RunJournalError.make({ message: "Only ordinary readonly Tool responses may be deferred" });
-					const candidate = {
-						turn: commit.turn,
-						turnId: commit.turnId,
-						batch: yield* withCrypto(turnCanonicalBatch({
-							...input,
-							toolParameterRejections: input.toolParameterRejections?.map((rejection) => ({
-								...rejection,
-								parameters: copyJson(rejection.parameters),
-								error: {
-									...rejection.error,
-									reason: { ...rejection.error.reason }
-								}
-							})),
-							toolExposure: input.toolExposure === void 0 ? void 0 : Snapshot.make({
-								exposedToolNames: [...input.toolExposure.exposedToolNames],
-								...input.toolExposure.selection === void 0 ? {} : { selection: Selection.make({ toolNames: [...input.toolExposure.selection.toolNames] }) }
-							}),
-							usage: input.usage === void 0 ? void 0 : {
-								...input.usage,
-								modelUsage: input.usage.modelUsage?.map((usage) => ModelCallUsage.make({
-									...usage,
-									...usage.response === void 0 ? {} : { response: ModelResponseIdentity.make({ ...usage.response }) },
-									inputTokens: InputTokenUsage.make({ ...usage.inputTokens }),
-									outputTokens: OutputTokenUsage.make({ ...usage.outputTokens })
-								}))
-							}
-						}))
-					};
-					const progress = progressWriters.get(ctx);
-					if (progress === void 0) return yield* ThreadStoreError.make({
-						operation: "reserve readonly dispatch",
-						message: "Dispatch has no scoped progress writer"
-					});
-					const batch = yield* progress.defer(candidate.batch).pipe(Effect.provideService(CurrentRunWriter, ctx));
-					deferredResponse = {
-						...candidate,
-						batch
-					};
-					return "deferred";
-				}
-				let batch;
-				if (deferred === void 0) batch = yield* withCrypto(commit._tag === "Response" ? turnResponseBatch(input) : response === void 0 ? turnResultsBatch(input) : turnCanonicalBatch(input));
-				else if (toolResults.length === 0 && runCompletion === void 0) batch = deferred.batch;
-				else {
-					const results = yield* withCrypto(turnResultsBatch(input));
-					batch = CanonicalBatch.make({
-						...deferred.batch,
-						records: [...deferred.batch.records, ...results.records]
-					});
-				}
-				yield* appendBatch(ctx, batch);
-				for (const call of response?.calls ?? []) {
-					declaredToolIds.add(call.toolCallId);
-					encodedParamsByCallId.set(call.toolCallId, call.parameters);
-					declaredNamesByCallId.set(call.toolCallId, call.toolName);
-				}
-				if (deferred !== void 0) {
-					acceptResponseDeclarations(batch);
-					deferredResponse = void 0;
-				}
-				if (commit._tag === "Response") initialDispatchProofTurns.add(commit.turn);
-				recordCommittedUsage(batch);
-				for (const record of batch.records) knownIds.add(record.recordId);
-				if (runCompletion !== void 0) completionState.committed = runCompletion;
-				yield* hit(commit._tag === "Response" ? "turn:after-response-append" : response === void 0 && deferred === void 0 ? "turn:after-results-append" : "turn:after-canonical-append");
-				return "committed";
-			}).pipe(responseGate.withPermits(1))),
-			checkToolDispatch: recordHalt(Effect.gen(function* () {
-				if (currentToolTurn === void 0) return yield* RunJournalError.make({ message: "Tool dispatch preceded its canonical response" });
-				yield* hit("tools:before-dispatch-fence");
-				yield* ctx.checkActive;
-				initialDispatchProofTurns.delete(currentToolTurn.turn);
-				yield* hit("tools:after-dispatch-fence");
-			})),
-			step: {
-				lookup: (key) => recordHalt(Effect.gen(function* () {
-					yield* flushDeferredResponse;
-					const output = stepOutputs.get(toolStepSettledRecordId(runId, key.toolCallId, key.stepName));
-					return output === void 0 ? Option.none() : Option.some({ encodedOutput: output });
+					yield* (yield* CurrentRunStart).commit(yield* makeEnvelope(recordId, payload));
+					knownIds.add(runStartedRecordId(runId));
+					knownIds.add(recordId);
+					historyEvidence.clear();
+					projectedJournal = void 0;
 				})),
-				reserve: (key) => recordHalt(Effect.gen(function* () {
-					yield* flushDeferredResponse;
-					const recordId = toolStepSettledRecordId(runId, key.toolCallId, key.stepName);
-					const template = yield* makeEnvelope(recordId, yield* ToolStepSettled.makeEffect({
+				commitModelRestart: (restart) => recordHalt(Effect.gen(function* () {
+					if (knownIds.has(modelResponseRecordId(runId, restart.turn))) return yield* RunJournalError.make({ message: "Cannot restart a canonical model response" });
+					const recordId = decodeRecordIdSync(`model-aborted:${runId}:${restart.restart}`);
+					const record = yield* makeEnvelope(recordId, ModelCallAborted.make({
 						runId,
-						toolCallId: key.toolCallId,
-						stepName: key.stepName,
-						output: null,
-						outputDigest: yield* withCrypto(digestJson(null))
-					}).pipe(Effect.mapError(() => ThreadStoreError.make({
-						operation: "reserve Step dispatch",
-						message: "Durable Step identity exceeds canonical persistence bounds",
-						cause: AgentPersistenceCapacityError.make({ message: "Durable Step identity exceeds canonical persistence bounds" })
-					}))));
-					const progress = progressWriters.get(ctx);
-					if (progress === void 0) return yield* ThreadStoreError.make({
-						operation: "reserve Step dispatch",
-						message: "Dispatch has no scoped progress writer"
-					});
-					return yield* progress.reserve(runId, CanonicalBatch.make({
+						...restart,
+						reason: "joined-input",
+						modelUsage: usageForCommit(restart.turn)?.modelUsage ?? [],
+						unobservedModelCalls: unobservedForCommit(restart.turn)
+					}));
+					const batch = CanonicalBatch.make({
 						batchId: decodeBatchIdSync(recordId),
 						producerId: config.producerId,
-						records: [template]
-					}), canonicalRecordBytes(template) + MAX_PERSISTED_JSON_BYTES + MAX_RUN_CONTINUATION_BYTES).pipe(Effect.provideService(CurrentRunWriter, ctx));
+						records: [record]
+					});
+					yield* appendBatch(ctx, batch);
+					recordCommittedUsage(batch);
+					knownIds.add(recordId);
 				})),
-				commit: (key, encodedOutput) => recordHalt(Effect.gen(function* () {
+				reservePolicyUsage: (usage) => recordHalt(Effect.gen(function* () {
 					yield* flushDeferredResponse;
-					const recordId = toolStepSettledRecordId(runId, key.toolCallId, key.stepName);
+					const recordId = decodeRecordIdSync(`policy:${runId}:${usage.programmaticToolCalls}:${usage.finalizationUsed}`);
 					if (knownIds.has(recordId)) return;
-					const output = yield* decodePersisted(encodedOutput).pipe(Effect.mapError(() => ThreadStoreError.make({
-						operation: "commit Step result",
-						message: "Durable Step output exceeds canonical persistence bounds",
-						cause: AgentPersistenceCapacityError.make({ message: "Durable Step output exceeds canonical persistence bounds" })
-					})));
-					const outputDigest = yield* withCrypto(digestJson(output));
-					const envelope = yield* makeEnvelope(recordId, ToolStepSettled.make({
+					const record = yield* makeEnvelope(recordId, RunPolicyUsageReserved.make({
 						runId,
-						toolCallId: key.toolCallId,
-						stepName: key.stepName,
-						output,
-						outputDigest
+						...usage
 					}));
+					yield* hit("policy:before-reservation-append");
 					yield* appendBatch(ctx, CanonicalBatch.make({
-						batchId: toolStepSettledBatchId(runId, key.toolCallId, key.stepName),
+						batchId: decodeBatchIdSync(recordId),
 						producerId: config.producerId,
-						records: [envelope]
+						records: [record]
 					}));
 					knownIds.add(recordId);
-					stepOutputs.set(recordId, output);
-					yield* hit("step:after-step-append");
-				}))
-			},
-			noteTurnUsage: (usage) => Effect.sync(() => {
-				const key = usage.turn;
-				const prior = stagedUsage.get(key);
-				stagedUsage.set(key, {
-					inputTokens: (prior?.inputTokens ?? 0) + usage.usage.inputTokens.total,
-					outputTokens: (prior?.outputTokens ?? 0) + usage.usage.outputTokens.total,
-					costMicrousd: (prior?.costMicrousd ?? 0) + usage.usage.costMicrousd,
-					modelUsage: [...prior?.modelUsage ?? [], usage.usage]
-				});
-				progressWriters.get(ctx)?.stageUsage(runId, terminalUsageCharge(uncommittedModelUsage()));
-			}),
-			commitCompaction: (commit) => Effect.gen(function* () {
-				const canonicalTurn = commit.turn;
-				const recordId = compactionRecordId(runId, canonicalTurn, commit.kind);
-				if (knownIds.has(recordId)) return yield* CompactionError.make({ message: "Compaction is already committed for this Turn and kind" });
-				let sourceJournal = journal;
-				let sourceBoundaries = boundaries;
-				if (initialJournal !== void 0) {
-					initialJournal.cacheable = false;
-					initialJournal.history = void 0;
-				}
-				if (commit.kind !== "summarize" || initialJournal?.prefix !== void 0) {
-					const tail = yield* ctx.tail;
-					const source = initialJournal === void 0 ? canonical : Stream.fromIterable(yield* recordHalt(readInitialJournal(initialJournal.original, initialJournal.suffix)));
-					sourceBoundaries = [];
-					sourceJournal = yield* recordHalt(projectRunJournalStream(Stream.concat(source, Stream.fromIterable(yield* recordHalt(selectedRange(ctx.threadId, [submissionId], tail.sequence, canonicalThrough)))).pipe(Stream.filter((envelope) => envelope.record.payload._tag !== "CompactionCreated" || envelope.sequence <= canonicalThrough)), runId, (boundary) => sourceBoundaries.push(boundary), priorContext));
-				}
-				const coverable = sourceBoundaries.filter((boundary) => commit.kind !== "summarize" || ownerFirstSequence === void 0 || boundary.sequence < ownerFirstSequence);
-				if (coverable.length === 0) return yield* CompactionError.make({ message: commit.kind === "rollover" ? "Durable rollover requires complete canonical records" : "Durable compaction requires eligible canonical records" });
-				const comparisonView = instructionView(sourceJournal.prompt.content, initialInstructions, false, sourceJournal.historyBefore.content.length);
-				let matchingPrefix = 0;
-				let requiredThrough = 0;
-				const comparisonLimit = Math.min(comparisonView.messages.length, commit.through);
-				for (let index = 0; index < commit.through; index += 1) {
-					const message = commit.source.content[index];
-					if (message !== void 0 && (commit.kind === "clear-tool-results" ? message.role === "tool" : message.role !== "system")) requiredThrough = index + 1;
-					if (index >= comparisonLimit || index !== matchingPrefix || message === void 0) continue;
-					const canonicalMessage = comparisonView.messages[index];
-					if (canonicalMessage === void 0) continue;
-					const encode = (entry) => encodeCompactionMessageJson(entry).pipe(Effect.flatMap(decodeCompactionMessageJson), Effect.map(canonicalJson), Effect.mapError((cause) => CompactionError.make({
-						message: "Could not encode the canonical compaction prefix",
+					yield* hit("policy:after-reservation-append");
+				})),
+				commitTurn: (commit) => recordHalt(Effect.gen(function* () {
+					const halted = yield* Ref.get(haltRef);
+					if (halted !== void 0) return yield* halted;
+					if (deferredResponse !== void 0 && (deferredResponse.turn !== commit.turn || deferredResponse.turnId !== commit.turnId)) return yield* RunJournalError.make({ message: "A new Turn preceded settlement of its deferred response" });
+					if (commit._tag === "Partial") yield* promoteResponse;
+					const deferred = deferredResponse;
+					if (commit._tag === "Response" && deferred !== void 0) return yield* RunJournalError.make({ message: "Turn response was already deferred" });
+					const responseId = modelResponseRecordId(runId, commit.turn);
+					const suppliedResponse = commit._tag === "Partial" ? void 0 : commit.response;
+					const response = knownIds.has(responseId) || deferred !== void 0 ? void 0 : suppliedResponse;
+					if (suppliedResponse !== void 0) currentToolTurn = {
+						turn: commit.turn,
+						turnId: commit.turnId
+					};
+					if (commit._tag === "Response" && response === void 0) return "committed";
+					const toolOperations = [];
+					const responseToolIds = /* @__PURE__ */ new Set();
+					for (const call of response?.calls ?? []) {
+						if (declaredToolIds.has(call.toolCallId) || responseToolIds.has(call.toolCallId)) return yield* RunJournalError.make({ message: "Tool Call identity is reused within a Run" });
+						if (declaredToolIds.size + responseToolIds.size + 1 > 4096) return yield* RunJournalError.make({ message: `Run exceeds the ${MAX_RUN_TOOL_CALL_IDENTITIES} Tool Call identity limit` });
+						const replay = currentContracts[call.toolName];
+						if (replay === void 0) return yield* RunJournalError.make({ message: "Canonical Tool declaration has no original operation contract" });
+						toolOperations.push(ToolOperation.make({
+							toolCallId: call.toolCallId,
+							toolName: call.toolName,
+							executionClass: call.executionClass,
+							executionKind: call.executionKind,
+							replay
+						}));
+						responseToolIds.add(call.toolCallId);
+					}
+					const toolResults = commit._tag === "Response" ? [] : commit.results.filter((result) => !knownIds.has(toolCallSettledRecordId(runId, commit.turn, result.toolCallId)));
+					let runCompletion;
+					if (commit._tag === "Settled" && commit.completion !== void 0) {
+						const completion = commit.completion;
+						const output = yield* decodePersisted(completion.output).pipe(Effect.mapError((cause) => LedgerError.make({
+							operation: "recordCompleted",
+							message: "Run output exceeds canonical persistence bounds",
+							cause
+						})));
+						if (completion.finishReason === "budget-exhausted" && completion.runDisposition !== void 0) return yield* LedgerError.make({
+							operation: "recordCompleted",
+							message: "A budget-exhausted Run cannot declare an application run disposition"
+						});
+						const runDisposition = completion.runDisposition === void 0 ? void 0 : yield* decodePersisted(completion.runDisposition).pipe(Effect.mapError((cause) => LedgerError.make({
+							operation: "recordCompleted",
+							message: "Run disposition exceeds canonical persistence bounds",
+							cause
+						})));
+						runCompletion = {
+							output,
+							...runDisposition === void 0 ? {} : { runDisposition },
+							...completion.finishReason === "budget-exhausted" ? {
+								finishReason: completion.finishReason,
+								...completion.exhausted === void 0 ? {} : { exhausted: completion.exhausted }
+							} : {}
+						};
+					}
+					if (response === void 0 && deferred === void 0 && toolResults.length === 0 && runCompletion === void 0) return "committed";
+					if (response === void 0 && deferred === void 0 && !knownIds.has(responseId)) return yield* RunJournalError.make({ message: "Tool results or completion preceded the canonical response" });
+					const input = {
+						toolResultMaxBytes: Math.min(agent.definition.policy.toolResultBounds.maxBytes, MAX_PERSISTED_JSON_BYTES),
+						toolSelectionMaxBytes: utf8ByteLength(JSON.stringify({ toolSelection: { toolNames: Object.keys(currentContracts) } })),
+						runId,
+						turn: commit.turn,
+						turnId: commit.turnId,
+						responseMessages: response?.messages ?? [],
+						toolResults,
+						toolOperations,
+						toolExposure: response?.toolExposure,
+						toolParameterRejections: response?.toolParameterRejections,
+						runScopedPrefixLength: response?.runScopedPrefixLength,
+						producerId: config.producerId,
+						deploymentId: config.deploymentId,
+						createdAt: yield* nowUtc,
+						runCompletion,
+						usage: usageForCommit(commit.turn),
+						unobservedModelCalls: unobservedForCommit(commit.turn)
+					};
+					if (commit._tag === "Partial") {
+						for (const result of toolResults) {
+							const batch = yield* turnResultsBatch({
+								...input,
+								toolResults: [result]
+							});
+							yield* appendBatch(ctx, CanonicalBatch.make({
+								...batch,
+								batchId: toolCallResultBatchId(runId, commit.turn, result.toolCallId)
+							}));
+							for (const record of batch.records) knownIds.add(record.recordId);
+							yield* hit("subagent:after-sibling-settle");
+						}
+						return "committed";
+					}
+					if (commit._tag === "Response" && commit.defer === true) {
+						if (toolOperations.length === 0 || toolOperations.some((call) => call.executionClass !== "readonly" || call.executionKind !== "ordinary")) return yield* RunJournalError.make({ message: "Only ordinary readonly Tool responses may be deferred" });
+						const candidate = {
+							turn: commit.turn,
+							turnId: commit.turnId,
+							batch: yield* turnCanonicalBatch({
+								...input,
+								toolParameterRejections: input.toolParameterRejections?.map((rejection) => ({
+									...rejection,
+									parameters: copyJson(rejection.parameters),
+									error: {
+										...rejection.error,
+										reason: { ...rejection.error.reason }
+									}
+								})),
+								toolExposure: input.toolExposure === void 0 ? void 0 : Snapshot.make({
+									exposedToolNames: [...input.toolExposure.exposedToolNames],
+									...input.toolExposure.selection === void 0 ? {} : { selection: Selection.make({ toolNames: [...input.toolExposure.selection.toolNames] }) }
+								}),
+								usage: input.usage === void 0 ? void 0 : {
+									...input.usage,
+									modelUsage: input.usage.modelUsage?.map((usage) => ModelCallUsage.make({
+										...usage,
+										...usage.response === void 0 ? {} : { response: ModelResponseIdentity.make({ ...usage.response }) },
+										inputTokens: InputTokenUsage.make({ ...usage.inputTokens }),
+										outputTokens: OutputTokenUsage.make({ ...usage.outputTokens })
+									}))
+								}
+							})
+						};
+						const progress = progressWriters.get(ctx);
+						if (progress === void 0) return yield* ThreadStoreError.make({
+							operation: "reserve readonly dispatch",
+							message: "Dispatch has no scoped progress writer"
+						});
+						const batch = yield* progress.defer(candidate.batch).pipe(Effect.provideService(CurrentRunWriter, ctx));
+						deferredResponse = {
+							...candidate,
+							batch
+						};
+						return "deferred";
+					}
+					let batch;
+					if (deferred === void 0) batch = yield* commit._tag === "Response" ? turnResponseBatch(input) : response === void 0 ? turnResultsBatch(input) : turnCanonicalBatch(input);
+					else if (toolResults.length === 0 && runCompletion === void 0) batch = deferred.batch;
+					else {
+						const results = yield* turnResultsBatch(input);
+						batch = CanonicalBatch.make({
+							...deferred.batch,
+							records: [...deferred.batch.records, ...results.records]
+						});
+					}
+					yield* appendBatch(ctx, batch);
+					for (const call of response?.calls ?? []) {
+						declaredToolIds.add(call.toolCallId);
+						encodedParamsByCallId.set(call.toolCallId, call.parameters);
+						declaredNamesByCallId.set(call.toolCallId, call.toolName);
+					}
+					if (deferred !== void 0) {
+						acceptResponseDeclarations(batch);
+						deferredResponse = void 0;
+					}
+					if (commit._tag === "Response") initialDispatchProofTurns.add(commit.turn);
+					recordCommittedUsage(batch);
+					for (const record of batch.records) knownIds.add(record.recordId);
+					if (runCompletion !== void 0) completionState.committed = runCompletion;
+					yield* hit(commit._tag === "Response" ? "turn:after-response-append" : response === void 0 && deferred === void 0 ? "turn:after-results-append" : "turn:after-canonical-append");
+					return "committed";
+				}).pipe(responseGate.withPermits(1))),
+				checkToolDispatch: recordHalt(Effect.gen(function* () {
+					if (currentToolTurn === void 0) return yield* RunJournalError.make({ message: "Tool dispatch preceded its canonical response" });
+					yield* hit("tools:before-dispatch-fence");
+					yield* ctx.checkActive;
+					initialDispatchProofTurns.delete(currentToolTurn.turn);
+					yield* hit("tools:after-dispatch-fence");
+				})),
+				step: {
+					lookup: (key) => recordHalt(Effect.gen(function* () {
+						yield* flushDeferredResponse;
+						const output = stepOutputs.get(toolStepSettledRecordId(runId, key.toolCallId, key.stepName));
+						return output === void 0 ? Option.none() : Option.some({ encodedOutput: output });
+					})),
+					reserve: (key) => recordHalt(Effect.gen(function* () {
+						yield* flushDeferredResponse;
+						const recordId = toolStepSettledRecordId(runId, key.toolCallId, key.stepName);
+						const template = yield* makeEnvelope(recordId, yield* ToolStepSettled.makeEffect({
+							runId,
+							toolCallId: key.toolCallId,
+							stepName: key.stepName,
+							output: null,
+							outputDigest: yield* withCrypto(digestJson(null))
+						}).pipe(Effect.mapError(() => ThreadStoreError.make({
+							operation: "reserve Step dispatch",
+							message: "Durable Step identity exceeds canonical persistence bounds",
+							cause: AgentPersistenceCapacityError.make({ message: "Durable Step identity exceeds canonical persistence bounds" })
+						}))));
+						const progress = progressWriters.get(ctx);
+						if (progress === void 0) return yield* ThreadStoreError.make({
+							operation: "reserve Step dispatch",
+							message: "Dispatch has no scoped progress writer"
+						});
+						return yield* progress.reserve(runId, CanonicalBatch.make({
+							batchId: decodeBatchIdSync(recordId),
+							producerId: config.producerId,
+							records: [template]
+						}), canonicalRecordBytes(template) + MAX_PERSISTED_JSON_BYTES + MAX_RUN_CONTINUATION_BYTES).pipe(Effect.provideService(CurrentRunWriter, ctx));
+					})),
+					commit: (key, encodedOutput) => recordHalt(Effect.gen(function* () {
+						yield* flushDeferredResponse;
+						const recordId = toolStepSettledRecordId(runId, key.toolCallId, key.stepName);
+						if (knownIds.has(recordId)) return;
+						const output = yield* decodePersisted(encodedOutput).pipe(Effect.mapError(() => ThreadStoreError.make({
+							operation: "commit Step result",
+							message: "Durable Step output exceeds canonical persistence bounds",
+							cause: AgentPersistenceCapacityError.make({ message: "Durable Step output exceeds canonical persistence bounds" })
+						})));
+						const outputDigest = yield* withCrypto(digestJson(output));
+						const envelope = yield* makeEnvelope(recordId, ToolStepSettled.make({
+							runId,
+							toolCallId: key.toolCallId,
+							stepName: key.stepName,
+							output,
+							outputDigest
+						}));
+						yield* appendBatch(ctx, CanonicalBatch.make({
+							batchId: toolStepSettledBatchId(runId, key.toolCallId, key.stepName),
+							producerId: config.producerId,
+							records: [envelope]
+						}));
+						knownIds.add(recordId);
+						stepOutputs.set(recordId, output);
+						yield* hit("step:after-step-append");
+					}))
+				},
+				noteTurnUsage: (usage) => Effect.sync(() => {
+					const key = usage.turn;
+					const prior = stagedUsage.get(key);
+					stagedUsage.set(key, {
+						inputTokens: (prior?.inputTokens ?? 0) + usage.usage.inputTokens.total,
+						outputTokens: (prior?.outputTokens ?? 0) + usage.usage.outputTokens.total,
+						costMicrousd: (prior?.costMicrousd ?? 0) + usage.usage.costMicrousd,
+						modelUsage: [...prior?.modelUsage ?? [], usage.usage]
+					});
+					progressWriters.get(ctx)?.stageUsage(runId, terminalUsageCharge(uncommittedModelUsage()));
+				}),
+				commitCompaction: Effect.fnUntraced(function* (commit) {
+					const canonicalTurn = commit.turn;
+					const recordId = compactionRecordId(runId, canonicalTurn, commit.kind);
+					if (knownIds.has(recordId)) return yield* CompactionError.make({ message: "Compaction is already committed for this Turn and kind" });
+					let sourceJournal = journal;
+					let sourceBoundaries = boundaries;
+					if (initialJournal !== void 0) {
+						initialJournal.cacheable = false;
+						initialJournal.history = void 0;
+					}
+					if (commit.kind !== "summarize" || initialJournal?.prefix !== void 0) {
+						const tail = yield* ctx.tail;
+						const source = initialJournal === void 0 ? canonical : Stream.fromIterable(yield* recordHalt(readInitialJournal(initialJournal.original, initialJournal.suffix)));
+						sourceBoundaries = [];
+						sourceJournal = yield* recordHalt(projectRunJournalStream(Stream.concat(source, Stream.fromIterable(yield* recordHalt(selectedRange(ctx.threadId, [submissionId], tail.sequence, canonicalThrough)))).pipe(Stream.filter((envelope) => envelope.record.payload._tag !== "CompactionCreated" || envelope.sequence <= canonicalThrough)), runId, (boundary) => sourceBoundaries.push(boundary), priorContext));
+					}
+					const coverable = sourceBoundaries.filter((boundary) => commit.kind !== "summarize" || ownerFirstSequence === void 0 || boundary.sequence < ownerFirstSequence);
+					if (coverable.length === 0) return yield* CompactionError.make({ message: commit.kind === "rollover" ? "Durable rollover requires complete canonical records" : "Durable compaction requires eligible canonical records" });
+					const comparisonView = instructionView(sourceJournal.prompt.content, initialInstructions, false, sourceJournal.historyBefore.content.length);
+					let matchingPrefix = 0;
+					let requiredThrough = 0;
+					const comparisonLimit = Math.min(comparisonView.messages.length, commit.through);
+					for (let index = 0; index < commit.through; index += 1) {
+						const message = commit.source.content[index];
+						if (message !== void 0 && (commit.kind === "clear-tool-results" ? message.role === "tool" : message.role !== "system")) requiredThrough = index + 1;
+						if (index >= comparisonLimit || index !== matchingPrefix || message === void 0) continue;
+						const canonicalMessage = comparisonView.messages[index];
+						if (canonicalMessage === void 0) continue;
+						const encode = (entry) => encodeCompactionMessageJson(entry).pipe(Effect.flatMap(decodeCompactionMessageJson), Effect.map(canonicalJson), Effect.mapError((cause) => CompactionError.make({
+							message: "Could not encode the canonical compaction prefix",
+							cause
+						})));
+						if ((yield* encode(canonicalMessage)) === (yield* encode(message))) matchingPrefix += 1;
+					}
+					let lastCovered;
+					for (let index = 0; index < coverable.length; index += 1) {
+						const candidate = coverable[index];
+						if (candidate === void 0) continue;
+						if (coverable[index + 1]?.tag === "ToolCallSettled") continue;
+						const length = comparisonView.prefixLength(candidate.promptLength);
+						if (length === 0 || length > commit.through) continue;
+						if (length < requiredThrough || length > matchingPrefix) continue;
+						lastCovered = candidate;
+					}
+					if (lastCovered === void 0) return yield* CompactionError.make({ message: commit.kind === "rollover" ? "Rollover coverage cannot be mapped to complete canonical records" : "Compaction coverage cannot be mapped to complete canonical records" });
+					const coveredSequence = lastCovered.sequence;
+					if (commit.kind !== "summarize" && sourceBoundaries.some((boundary) => boundary.incomplete === true && boundary.terminalPriorRun !== true && boundary.sequence <= coveredSequence)) return yield* CompactionError.make({ message: "Compaction cannot cover an incomplete Tool batch" });
+					if (commit.kind === "summarize" && (commit.summary ?? "").trim().length === 0) return yield* CompactionError.make({ message: "A summarize compaction commit carried no summary" });
+					const payload = yield* Schema.decodeEffect(CompactionCreated)({
+						_tag: "CompactionCreated",
+						runId,
+						turn: canonicalTurn,
+						kind: commit.kind,
+						coversThrough: lastCovered.sequence,
+						...commit.kind === "summarize" ? { summary: commit.summary } : {},
+						...commit.kind === "rollover" && commit.handoff !== void 0 ? { handoff: commit.handoff } : {}
+					}).pipe(Effect.mapError((cause) => CompactionError.make({
+						message: "Compaction decision exceeds canonical persistence bounds",
 						cause
 					})));
-					if ((yield* encode(canonicalMessage)) === (yield* encode(message))) matchingPrefix += 1;
-				}
-				let lastCovered;
-				for (let index = 0; index < coverable.length; index += 1) {
-					const candidate = coverable[index];
-					if (candidate === void 0) continue;
-					if (coverable[index + 1]?.tag === "ToolCallSettled") continue;
-					const length = comparisonView.prefixLength(candidate.promptLength);
-					if (length === 0 || length > commit.through) continue;
-					if (length < requiredThrough || length > matchingPrefix) continue;
-					lastCovered = candidate;
-				}
-				if (lastCovered === void 0) return yield* CompactionError.make({ message: commit.kind === "rollover" ? "Rollover coverage cannot be mapped to complete canonical records" : "Compaction coverage cannot be mapped to complete canonical records" });
-				const coveredSequence = lastCovered.sequence;
-				if (commit.kind !== "summarize" && sourceBoundaries.some((boundary) => boundary.incomplete === true && boundary.terminalPriorRun !== true && boundary.sequence <= coveredSequence)) return yield* CompactionError.make({ message: "Compaction cannot cover an incomplete Tool batch" });
-				if (commit.kind === "summarize" && (commit.summary ?? "").trim().length === 0) return yield* CompactionError.make({ message: "A summarize compaction commit carried no summary" });
-				const payload = yield* Schema.decodeEffect(CompactionCreated)({
-					_tag: "CompactionCreated",
-					runId,
-					turn: canonicalTurn,
-					kind: commit.kind,
-					coversThrough: lastCovered.sequence,
-					...commit.kind === "summarize" ? { summary: commit.summary } : {},
-					...commit.kind === "rollover" && commit.handoff !== void 0 ? { handoff: commit.handoff } : {}
-				}).pipe(Effect.mapError((cause) => CompactionError.make({
-					message: "Compaction decision exceeds canonical persistence bounds",
+					const envelope = yield* recordHalt(makeEnvelope(recordId, payload));
+					yield* recordHalt(hit("compaction:before-canonical-append"));
+					yield* recordHalt(appendBatch(ctx, CanonicalBatch.make({
+						batchId: compactionBatchId(runId, canonicalTurn, commit.kind),
+						producerId: config.producerId,
+						records: [envelope]
+					})));
+					knownIds.add(recordId);
+					yield* recordHalt(hit("compaction:after-canonical-append"));
+				})
+			};
+			/** Digest of one declared call's canonical encoded parameters (the original normalized wire). */
+			const approvalParametersDigest = (toolCallId) => Effect.gen(function* () {
+				if (!encodedParamsByCallId.has(toolCallId)) return yield* RunJournalError.make({ message: `Tool Call ${toolCallId} requested approval before its response commit` });
+				const parameters = yield* decodePersisted(encodedParamsByCallId.get(toolCallId)).pipe(Effect.mapError((cause) => RunJournalError.make({
+					message: `Tool Call ${toolCallId} parameters exceed canonical persistence bounds`,
 					cause
 				})));
-				const envelope = yield* recordHalt(makeEnvelope(recordId, payload));
-				yield* recordHalt(hit("compaction:before-canonical-append"));
-				yield* recordHalt(appendBatch(ctx, CanonicalBatch.make({
-					batchId: compactionBatchId(runId, canonicalTurn, commit.kind),
-					producerId: config.producerId,
-					records: [envelope]
-				})));
-				knownIds.add(recordId);
-				yield* recordHalt(hit("compaction:after-canonical-append"));
-			})
-		};
-		/** Digest of one declared call's canonical encoded parameters (the original normalized wire). */
-		const approvalParametersDigest = (toolCallId) => Effect.gen(function* () {
-			if (!encodedParamsByCallId.has(toolCallId)) return yield* RunJournalError.make({ message: `Tool Call ${toolCallId} requested approval before its response commit` });
-			const parameters = yield* decodePersisted(encodedParamsByCallId.get(toolCallId)).pipe(Effect.mapError((cause) => RunJournalError.make({
-				message: `Tool Call ${toolCallId} parameters exceed canonical persistence bounds`,
-				cause
-			})));
-			return yield* withCrypto(digestJson(parameters));
-		});
-		/**
-		* Append the canonical approval records for one declared call: the `ToolApprovalRequested`
-		* record — plus the immediate `ToolApprovalDecided` for a policy-auto or intent-backed
-		* decision, one atomic batch — or the decision alone when the request is already canonical.
-		* Batch identity: the Turn's FIRST canonical approval append owns
-		* `turn-approvals:{runId}:{turn}`; later appends of the same Turn (across suspension
-		* cycles) use deterministic per-call batches so committed batch content is never
-		* contradicted; decision-only appends use `approval-decision:{sid}:{toolCallId}`. Record
-		* identity dedupes every replay; an identity conflict means another pass already committed
-		* the same records.
-		*/
-		const appendApprovalRecords = (turnInfo, toolCallId, toolName, decided) => Effect.gen(function* () {
-			const requestRecordId = toolApprovalRequestRecordId(runId, turnInfo.turn, toolCallId);
-			const decisionRecordId = toolApprovalDecisionRecordId(runId, turnInfo.turn, toolCallId);
-			const envelopes = [];
-			const appendRequest = !knownIds.has(requestRecordId);
-			if (appendRequest) {
-				const parametersDigest = yield* approvalParametersDigest(toolCallId);
-				envelopes.push(yield* makeEnvelope(requestRecordId, ToolApprovalRequested.make({
-					blocksInitialDispatch: initialDispatchProofTurns.has(turnInfo.turn),
+				return yield* withCrypto(digestJson(parameters));
+			});
+			/**
+			* Append the canonical approval records for one declared call: the `ToolApprovalRequested`
+			* record — plus the immediate `ToolApprovalDecided` for a policy-auto or intent-backed
+			* decision, one atomic batch — or the decision alone when the request is already canonical.
+			* Batch identity: the Turn's FIRST canonical approval append owns
+			* `turn-approvals:{runId}:{turn}`; later appends of the same Turn (across suspension
+			* cycles) use deterministic per-call batches so committed batch content is never
+			* contradicted; decision-only appends use `approval-decision:{sid}:{toolCallId}`. Record
+			* identity dedupes every replay; an identity conflict means another pass already committed
+			* the same records.
+			*/
+			const appendApprovalRecords = (turnInfo, toolCallId, toolName, decided) => Effect.gen(function* () {
+				const requestRecordId = toolApprovalRequestRecordId(runId, turnInfo.turn, toolCallId);
+				const decisionRecordId = toolApprovalDecisionRecordId(runId, turnInfo.turn, toolCallId);
+				const envelopes = [];
+				const appendRequest = !knownIds.has(requestRecordId);
+				if (appendRequest) {
+					const parametersDigest = yield* approvalParametersDigest(toolCallId);
+					envelopes.push(yield* makeEnvelope(requestRecordId, ToolApprovalRequested.make({
+						blocksInitialDispatch: initialDispatchProofTurns.has(turnInfo.turn),
+						runId,
+						turnId: turnInfo.turnId,
+						turn: turnInfo.turn,
+						toolCallId,
+						toolName,
+						parametersDigest
+					})));
+				}
+				if (decided !== void 0 && !knownIds.has(decisionRecordId)) envelopes.push(yield* makeEnvelope(decisionRecordId, ToolApprovalDecided.make({
 					runId,
-					turnId: turnInfo.turnId,
 					turn: turnInfo.turn,
 					toolCallId,
-					toolName,
-					parametersDigest
+					decision: decided.decision,
+					resolver: decided.resolver,
+					reason: decided.reason
 				})));
-			}
-			if (decided !== void 0 && !knownIds.has(decisionRecordId)) envelopes.push(yield* makeEnvelope(decisionRecordId, ToolApprovalDecided.make({
-				runId,
-				turn: turnInfo.turn,
-				toolCallId,
-				decision: decided.decision,
-				resolver: decided.resolver,
-				reason: decided.reason
-			})));
-			const head = envelopes[0];
-			if (head !== void 0) {
-				const batchId = appendRequest ? approvalRequestedTurns.has(turnInfo.turn) ? decodeBatchId(`approval-request:${runId}:${turnInfo.turn}:${toolCallId}`) : turnApprovalsBatchId(runId, turnInfo.turn) : approvalDecisionBatchId(submissionId, toolCallId);
-				yield* appendBatch(ctx, CanonicalBatch.make({
-					batchId,
-					producerId: config.producerId,
-					records: [head, ...envelopes.slice(1)]
-				})).pipe(Effect.catchTag("AppendConflict", () => Effect.void), Effect.asVoid);
-				for (const record of envelopes) knownIds.add(record.recordId);
-			}
-			if (appendRequest) {
-				approvalRequestedTurns.add(turnInfo.turn);
-				yield* hit("approval:after-request-append");
-			}
-			if (decided !== void 0) canonicalApprovalDecisions.set(toolCallId, decided.decision);
-		});
-		/**
-		* Retain every required request before any decision can remove initial-dispatch proof.
-		* Policy preparation shares the engine deadline; canonical acceptance is a separate,
-		* fenced commit. Canonical decisions and accepted resolver intents keep their audit.
-		*/
-		const approval = {
-			prepareBatch: (requests) => recordHalt(Effect.gen(function* () {
-				if (requests.length === 0) return;
-				yield* flushDeferredResponse;
-				const turnInfo = currentToolTurn;
-				if (turnInfo === void 0) return yield* RunJournalError.make({ message: "Approval preparation preceded its canonical response" });
-				for (const request of requests) {
-					if (request.threadId !== submission.threadId || request.runId !== runId || request.turnId !== turnInfo.turnId || declaredNamesByCallId.get(request.toolCallId) !== request.toolName) return yield* RunJournalError.make({ message: "Approval preparation does not match its original declaration" });
-					yield* appendApprovalRecords(turnInfo, request.toolCallId, request.toolName, void 0);
-				}
-			})),
-			request: (request) => recordHalt(Effect.gen(function* () {
-				const canonical = canonicalApprovalDecisions.get(request.toolCallId);
-				if (canonical !== void 0) return canonical === "approved" ? { _tag: "approved" } : { _tag: "denied" };
-				const intent = approvalIntents.get(request.toolCallId);
-				if (intent !== void 0) return intent.decision === "approved" ? {
-					_tag: "approved",
-					reason: intent.reason
-				} : {
-					_tag: "denied",
-					reason: intent.reason
-				};
-				return approvalResolver === void 0 ? { _tag: "unresolved" } : yield* approvalResolver.request(request);
-			})),
-			commit: (request, decision) => recordHalt(Effect.gen(function* () {
-				const turnInfo = currentToolTurn;
-				if (turnInfo === void 0 || request.threadId !== submission.threadId || request.runId !== runId || request.turnId !== turnInfo.turnId || declaredNamesByCallId.get(request.toolCallId) !== request.toolName) return yield* RunJournalError.make({ message: "Approval acceptance does not match its original declaration" });
-				const canonical = canonicalApprovalDecisions.get(request.toolCallId);
-				if (canonical !== void 0) {
-					if (decision._tag !== canonical) return yield* RunJournalError.make({ message: "Approval preparation disagrees with its canonical decision" });
-					return;
+				const head = envelopes[0];
+				if (head !== void 0) {
+					const batchId = appendRequest ? approvalRequestedTurns.has(turnInfo.turn) ? decodeBatchId(`approval-request:${runId}:${turnInfo.turn}:${toolCallId}`) : turnApprovalsBatchId(runId, turnInfo.turn) : approvalDecisionBatchId(submissionId, toolCallId);
+					yield* appendBatch(ctx, CanonicalBatch.make({
+						batchId,
+						producerId: config.producerId,
+						records: [head, ...envelopes.slice(1)]
+					})).pipe(Effect.catchTag("AppendConflict", () => Effect.void), Effect.asVoid);
+					for (const record of envelopes) knownIds.add(record.recordId);
 				}
-				const intent = approvalIntents.get(request.toolCallId);
-				if (intent !== void 0 && decision._tag !== intent.decision) return yield* RunJournalError.make({ message: "Approval preparation disagrees with its accepted intent" });
-				yield* appendApprovalRecords(turnInfo, request.toolCallId, request.toolName, intent !== void 0 ? {
-					decision: intent.decision,
-					resolver: intent.resolver,
-					reason: intent.reason
-				} : decision._tag === "unresolved" ? void 0 : {
-					decision: decision._tag,
-					resolver: APPROVAL_POLICY_RESOLVER,
-					reason: boundedApprovalReason(decision.reason, "The configured approval policy decided immediately")
-				});
-			}))
-		};
-		/**
-		* Joining/Joined queued input hook (plan §2.5, DUR-016). At every engine drain seam:
-		*
-		* 1. Reattach first — pre-existing joins whose canonical `input:{sid}` record is not yet
-		*    prompt-covered re-deliver WITHOUT re-appending (record identity is the dedupe);
-		*    covered inputs are already inside the journal prompt. A `joining` row whose input is
-		*    canonical only lost its marker: it is repaired from history under the host's live
-		*    ownership (DUR-015). A `joining` row WITHOUT canonical input was never consumed and
-		*    is recovery's to revert — the hook never guesses at it (fail-closed).
-		* 2. Claim fresh — `claimJoining` atomically transitions the contiguous ready prefix of
-		*    strictly-later queue sequences to `joining` under the host's local generation (an
-		*    admitted-not-ready row breaks the prefix). Per fresh claim: honor a
-		*    pre-consumption abort intent by reverting (revert-then-abort), else append the
-		*    deterministic `UserInputRecorded` (batch `submission-input:{sid}`, record
-		*    `input:{sid}`, `runId` = host Run, kind `steering`) → `join:after-canonical-append`
-		*    → `markJoined` → hand the engine the `RunInputCommand`.
-		*
-		* Delivered input is `steering`: the engine appends it to official history at the seam,
-		* so the next Turn's response commit makes it model-visible canonically — exactly the
-		* prompt-coverage rule recovery relies on.
-		*/
-		const renderJoinedInput = ({ input: encodedInput, messageAdmission }) => Effect.gen(function* () {
-			if (Schema.is(FrameworkMessage)(messageAdmission)) return yield* Schema.encodeEffect(Schema.fromJsonString(FrameworkMessage))(messageAdmission).pipe(Effect.mapError(() => AgentInputError.make({ message: "Invalid worker completion message" })));
-			const inputPrompt = agent.definition.inputPrompt;
-			if (inputPrompt === void 0) return yield* renderInputPrompt(void 0, encodedInput, encodedInput);
-			const decodedInput = yield* Schema.decodeEffect(agent.definition.input)(encodedInput).pipe(Effect.mapError((cause) => AgentInputDecodeError.make({ message: cause.message })));
-			return yield* renderInputPrompt(inputPrompt, decodedInput, encodedInput);
-		});
-		const pendingJoinClaims = [];
-		const claimInputs = Effect.fnUntraced(function* (maxCount) {
-			const claims = yield* session.claimJoining(maxCount);
-			pendingJoinClaims.push(...claims.map((claim) => ({ claim })));
-			return claims.length;
-		}, Effect.uninterruptible);
-		const revertClaims = Effect.fnUntraced(function* (claims) {
-			for (const pending of claims) {
-				yield* session.revertJoining(pending.claim.submissionId);
-				pendingJoinClaims.splice(pendingJoinClaims.indexOf(pending), 1);
-			}
-		}, Effect.uninterruptible);
-		const prepareInputs = Effect.fnUntraced(function* (limit, firstReady = false) {
-			if (pendingJoinClaims.length < limit && (yield* claimInputs(limit - pendingJoinClaims.length)) > 0) yield* hit("join:after-claim");
-			const prepared = [];
-			for (const pending of pendingJoinClaims.slice(0, limit)) {
-				const claim = pending.claim;
-				const snapshot = yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId: claim.submissionId }));
-				if (snapshot.abortIntent !== void 0) {
-					yield* revertClaims([pending]);
-					continue;
+				if (appendRequest) {
+					approvalRequestedTurns.add(turnInfo.turn);
+					yield* hit("approval:after-request-append");
 				}
-				if (pending.prepared === void 0) {
-					const input = {
-						input: claim.inputPayload,
-						...snapshot.submission.messageAdmission === void 0 ? {} : { messageAdmission: snapshot.submission.messageAdmission }
-					};
-					const rendered = yield* Effect.result(renderJoinedInput(input));
-					if (Result.isFailure(rendered)) {
-						yield* revertClaims(pendingJoinClaims.slice(pendingJoinClaims.indexOf(pending)));
-						break;
+				if (decided !== void 0) canonicalApprovalDecisions.set(toolCallId, decided.decision);
+			});
+			/**
+			* Retain every required request before any decision can remove initial-dispatch proof.
+			* Policy preparation shares the engine deadline; canonical acceptance is a separate,
+			* fenced commit. Canonical decisions and accepted resolver intents keep their audit.
+			*/
+			const approval = {
+				prepareBatch: (requests) => recordHalt(Effect.gen(function* () {
+					if (requests.length === 0) return;
+					yield* flushDeferredResponse;
+					const turnInfo = currentToolTurn;
+					if (turnInfo === void 0) return yield* RunJournalError.make({ message: "Approval preparation preceded its canonical response" });
+					for (const request of requests) {
+						if (request.threadId !== submission.threadId || request.runId !== runId || request.turnId !== turnInfo.turnId || declaredNamesByCallId.get(request.toolCallId) !== request.toolName) return yield* RunJournalError.make({ message: "Approval preparation does not match its original declaration" });
+						yield* appendApprovalRecords(turnInfo, request.toolCallId, request.toolName, void 0);
 					}
-					pending.prepared = {
-						claim,
-						input,
-						rendered: rendered.success
+				})),
+				request: (request) => recordHalt(Effect.gen(function* () {
+					const canonical = canonicalApprovalDecisions.get(request.toolCallId);
+					if (canonical !== void 0) return canonical === "approved" ? { _tag: "approved" } : { _tag: "denied" };
+					const intent = approvalIntents.get(request.toolCallId);
+					if (intent !== void 0) return intent.decision === "approved" ? {
+						_tag: "approved",
+						reason: intent.reason
+					} : {
+						_tag: "denied",
+						reason: intent.reason
 					};
+					return approvalResolver === void 0 ? { _tag: "unresolved" } : yield* approvalResolver.request(request);
+				})),
+				commit: (request, decision) => recordHalt(Effect.gen(function* () {
+					const turnInfo = currentToolTurn;
+					if (turnInfo === void 0 || request.threadId !== submission.threadId || request.runId !== runId || request.turnId !== turnInfo.turnId || declaredNamesByCallId.get(request.toolCallId) !== request.toolName) return yield* RunJournalError.make({ message: "Approval acceptance does not match its original declaration" });
+					const canonical = canonicalApprovalDecisions.get(request.toolCallId);
+					if (canonical !== void 0) {
+						if (decision._tag !== canonical) return yield* RunJournalError.make({ message: "Approval preparation disagrees with its canonical decision" });
+						return;
+					}
+					const intent = approvalIntents.get(request.toolCallId);
+					if (intent !== void 0 && decision._tag !== intent.decision) return yield* RunJournalError.make({ message: "Approval preparation disagrees with its accepted intent" });
+					yield* appendApprovalRecords(turnInfo, request.toolCallId, request.toolName, intent !== void 0 ? {
+						decision: intent.decision,
+						resolver: intent.resolver,
+						reason: intent.reason
+					} : decision._tag === "unresolved" ? void 0 : {
+						decision: decision._tag,
+						resolver: APPROVAL_POLICY_RESOLVER,
+						reason: boundedApprovalReason(decision.reason, "The configured approval policy decided immediately")
+					});
+				}))
+			};
+			/**
+			* Joining/Joined queued input hook (plan §2.5, DUR-016). At every engine drain seam:
+			*
+			* 1. Reattach first — pre-existing joins whose canonical `input:{sid}` record is not yet
+			*    prompt-covered re-deliver WITHOUT re-appending (record identity is the dedupe);
+			*    covered inputs are already inside the journal prompt. A `joining` row whose input is
+			*    canonical only lost its marker: it is repaired from history under the host's live
+			*    ownership (DUR-015). A `joining` row WITHOUT canonical input was never consumed and
+			*    is recovery's to revert — the hook never guesses at it (fail-closed).
+			* 2. Claim fresh — `claimJoining` atomically transitions the contiguous ready prefix of
+			*    strictly-later queue sequences to `joining` under the host's local generation (an
+			*    admitted-not-ready row breaks the prefix). Per fresh claim: honor a
+			*    pre-consumption abort intent by reverting (revert-then-abort), else append the
+			*    deterministic `UserInputRecorded` (batch `submission-input:{sid}`, record
+			*    `input:{sid}`, `runId` = host Run, kind `steering`) → `join:after-canonical-append`
+			*    → `markJoined` → hand the engine the `RunInputCommand`.
+			*
+			* Delivered input is `steering`: the engine appends it to official history at the seam,
+			* so the next Turn's response commit makes it model-visible canonically — exactly the
+			* prompt-coverage rule recovery relies on.
+			*/
+			const renderJoinedInput = Effect.fnUntraced(function* (encodedInput, messageAdmission) {
+				if (Schema.is(FrameworkMessage)(messageAdmission)) return yield* Schema.encodeEffect(Schema.fromJsonString(FrameworkMessage))(messageAdmission).pipe(Effect.mapError(() => AgentInputError.make({ message: "Invalid worker completion message" })));
+				const inputPrompt = agent.definition.inputPrompt;
+				if (inputPrompt === void 0) return yield* renderInputPrompt(void 0, encodedInput, encodedInput);
+				const decodedInput = yield* Schema.decodeEffect(agent.definition.input)(encodedInput).pipe(Effect.mapError((cause) => AgentInputDecodeError.make({ message: cause.message })));
+				return yield* renderInputPrompt(inputPrompt, decodedInput, encodedInput);
+			});
+			const pendingJoinClaims = [];
+			const claimInputs = Effect.fnUntraced(function* (maxCount) {
+				const claims = yield* session.claimJoining(maxCount);
+				pendingJoinClaims.push(...claims.map((claim) => ({ claim })));
+				return claims.length;
+			}, Effect.uninterruptible);
+			const revertClaims = Effect.fnUntraced(function* (claims) {
+				for (const pending of claims) {
+					yield* session.revertJoining(pending.claim.submissionId);
+					pendingJoinClaims.splice(pendingJoinClaims.indexOf(pending), 1);
 				}
-				prepared.push(pending.prepared);
-				if (firstReady) break;
-			}
-			return prepared;
-		});
-		const input = {
-			awaitJoin: recordHalt(Effect.gen(function* () {
-				while (true) if (yield* Effect.scoped(Effect.gen(function* () {
-					const notified = yield* wake.subscribe(submission.threadId);
-					if ((yield* prepareInputs(MAX_JOIN_DRAIN, true)).length > 0) return true;
-					yield* notified;
-					return false;
-				}))) return;
-			})),
-			drain: (policy) => Effect.gen(function* () {
-				const joinedInputs = yield* recordHalt(Effect.gen(function* () {
-					const limit = policy === "one" ? 1 : MAX_JOIN_DRAIN;
-					const joinedInputs = [];
-					if (joinBacklog === void 0) joinBacklog = (yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId }))).joins;
-					for (const join of joinBacklog) {
-						const joinId = join.submissionId;
-						if (deliveredJoinInputs.has(joinId)) continue;
-						if (join.state !== "joining" && join.state !== "joined") continue;
-						const existing = joinedInputEnvelopes.get(joinId);
-						if (existing === void 0) continue;
-						if (join.state === "joining") yield* session.markJoined(joinId, {
-							recordId: existing.record.recordId,
-							sequence: existing.sequence
-						});
-						deliveredJoinInputs.add(joinId);
-						if (lastHostResponseSequence !== void 0 && lastHostResponseSequence > existing.sequence) continue;
-						const payload = existing.record.payload;
-						if (payload._tag !== "UserInputRecorded") continue;
-						joinedInputs.push(payload);
+			}, Effect.uninterruptible);
+			const prepareInputs = Effect.fnUntraced(function* (limit, firstReady = false) {
+				if (pendingJoinClaims.length < limit && (yield* claimInputs(limit - pendingJoinClaims.length)) > 0) yield* hit("join:after-claim");
+				const prepared = [];
+				for (const pending of pendingJoinClaims.slice(0, limit)) {
+					const claim = pending.claim;
+					const snapshot = yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId: claim.submissionId }));
+					if (snapshot.abortIntent !== void 0) {
+						yield* revertClaims([pending]);
+						continue;
 					}
-					const claims = yield* prepareInputs(limit);
-					pendingJoinClaims.splice(0, claims.length);
-					for (const { claim, input: payload, rendered } of claims) {
-						const recordId = submissionInputRecordId(claim.submissionId);
-						let sequence;
-						const existing = joinedInputEnvelopes.get(claim.submissionId);
-						if (existing !== void 0) sequence = existing.sequence;
-						else {
-							const envelope = yield* makeEnvelope(recordId, UserInputRecorded.make({
-								submissionId: claim.submissionId,
-								kind: "steering",
-								runId,
-								input: claim.inputPayload,
-								...payload.messageAdmission === void 0 ? {} : { messageAdmission: payload.messageAdmission }
-							}));
-							sequence = (yield* appendBatch(ctx, CanonicalBatch.make({
-								batchId: submissionInputBatchId(claim.submissionId),
-								producerId: config.producerId,
-								records: [envelope]
-							}))).firstSequence;
-							knownIds.add(recordId);
-							yield* hit("join:after-canonical-append");
+					if (pending.prepared === void 0) {
+						const input = {
+							input: claim.inputPayload,
+							...snapshot.submission.messageAdmission === void 0 ? {} : { messageAdmission: snapshot.submission.messageAdmission }
+						};
+						const rendered = yield* Effect.result(renderJoinedInput(input.input, input.messageAdmission));
+						if (Result.isFailure(rendered)) {
+							yield* revertClaims(pendingJoinClaims.slice(pendingJoinClaims.indexOf(pending)));
+							break;
 						}
-						yield* session.markJoined(claim.submissionId, {
-							recordId,
-							sequence
-						});
-						deliveredJoinInputs.add(claim.submissionId);
-						joinedInputs.push({
-							...payload,
-							rendered
-						});
+						pending.prepared = {
+							claim,
+							input,
+							rendered: rendered.success
+						};
 					}
-					return joinedInputs;
-				}));
-				return yield* Effect.forEach(joinedInputs, (joinedInput) => (joinedInput.rendered === void 0 ? renderJoinedInput(joinedInput) : Effect.succeed(joinedInput.rendered)).pipe(Effect.map((input) => ({
-					kind: "steering",
-					input
-				}))));
-			})
-		};
-		/**
-		* Durable child establishment: `establish` performs or replays
-		* the idempotent get-or-create establishment protocol under the
-		* parent's ownership fence and reports where the one child stands; `join` appends the
-		* atomic `[SubagentJoined, ToolCallSettled]` settlement batch (SUB-019) and applies the
-		* reservation release. Both use the halt side channel exactly like the durability/step
-		* hooks: the engine wraps a `CoordinatorHalt` into `SubagentDurabilityError` in the
-		* handler channel while the Attempt aborts with the original infrastructure failure.
-		*/
-		const establishmentGate = yield* Semaphore.make(1);
-		const establishSubagent = (request) => recordHalt(Effect.gen(function* () {
-			const toolCallId = request.toolCallId;
-			const turnInfo = currentToolTurn;
-			if (turnInfo === void 0) return yield* RunJournalError.make({ message: `Delegation Tool Call ${toolCallId} established before any canonical response commit` });
-			const denied = (errorTag, message) => ({
-				_tag: "denied",
-				errorTag,
-				message: boundedText(message)
-			});
-			let requestedPayload = subagentState.requested.get(toolCallId);
-			if (requestedPayload === void 0) {
-				if (request.depth !== delegationDepth + 1) return denied("SubagentDepthUnsupported", `The child depth must be exactly one greater than its source depth ${delegationDepth}`);
-				let targetDigests = request.targetDigests;
-				if (request.target !== void 0) {
-					if (request.target.id !== request.targetAgentId) return denied("SubagentBindingUnavailable", "The child target identity differs from its Definition");
-					const binding = yield* resolveDefinitionBinding(registeredBindings, request.target).pipe(Effect.result);
-					if (binding._tag === "Failure") return denied("SubagentBindingUnavailable", binding.failure.message);
-					if (targetDigests !== void 0 && (targetDigests.agent !== binding.success.digests.agent || targetDigests.model !== binding.success.digests.model || targetDigests.tools !== binding.success.digests.tools)) return denied("SubagentDigestsInvalid", "The explicit child digests differ from its exact registration");
-					targetDigests = binding.success.digests;
+					prepared.push(pending.prepared);
+					if (firstReady) break;
 				}
-				const decodedDigests = yield* decodeDefinitionDigests(targetDigests).pipe(Effect.option);
-				if (Option.isNone(decodedDigests)) return denied("SubagentDigestsInvalid", "The declared child Binding digests are not valid stored digests");
-				const childInput = yield* decodePersisted(request.encodedChildInput).pipe(Effect.option);
-				if (Option.isNone(childInput)) return denied("SubagentInputUnpersistable", "The prepared child input does not satisfy the canonical persistence bounds");
-				const grant = yield* decodePersisted(request.encodedGrant).pipe(Effect.option);
-				const allocation = yield* decodePersisted(request.encodedAllocation).pipe(Effect.option);
-				if (Option.isNone(grant) || Option.isNone(allocation)) return denied("SubagentDeclarationUnpersistable", "The delegation grant or allocation does not satisfy the canonical persistence bounds");
-				const decodedGrant = Schema.decodeUnknownOption(SubagentGrant)(grant.value);
-				if (Option.isNone(decodedGrant)) return denied("SubagentGrantInvalid", "The child authority grant is invalid");
-				if (request.policy === void 0 || request.budget === void 0) return denied("SubagentBudgetInvalid", "New durable children require their full execution policy and subtree allocation");
-				if (request.toolCallAllowance !== void 0 && !Schema.is(SubagentRequested.fields.toolCallAllowance)(request.toolCallAllowance)) return denied("SubagentAllowanceInvalid", "The child Tool Call allowance must be a positive integer");
-				if (request.policy !== void 0 && !Schema.is(AgentPolicy)(request.policy)) return denied("SubagentPolicyInvalid", "The resolved child policy is invalid");
-				if (request.budget !== void 0) {
-					if (!Schema.is(SubagentBudgetReservation)(request.budget)) return denied("SubagentBudgetInvalid", "The shared delegation budget is invalid");
-					const decodedAllocation = Schema.decodeUnknownOption(SubagentReservationAmounts)(allocation.value);
-					if (Option.isNone(decodedAllocation) || !Equal.equals(decodedAllocation.value, request.budget.allocation)) return denied("SubagentBudgetInvalid", "The reserved allocation differs from its budget declaration");
-					const { caps, allocation: requested } = request.budget;
-					const prior = [...subagentState.requested.values()];
-					if (prior.some((entry) => entry.budget === void 0 || !Equal.equals(entry.budget.caps, caps))) return denied("SubagentParentBudgetConflict", "Delegations in one parent Run must share the same caps");
-					if (caps.maxTotalChildInvocations !== void 0 && prior.reduce((sum, entry) => sum + 1 + (entry.budget?.descendantInvocations ?? 0), 1 + (request.budget.descendantInvocations ?? 0)) > caps.maxTotalChildInvocations) return denied("SubagentBudgetExhausted", "The parent Run exhausted its child invocation budget");
-					const active = prior.filter((entry) => !subagentState.joined.has(entry.toolCallId));
-					if (caps.maxConcurrentChildren !== void 0 && active.length >= caps.maxConcurrentChildren) return denied("SubagentBudgetExhausted", "The parent Run exhausted its concurrent child budget");
-					const dimensions = [
-						["turns", "maxTurns"],
-						["toolCalls", "maxToolCalls"],
-						["durationMillis", "maxDurationMillis"],
-						["inputTokens", "maxInputTokens"],
-						["outputTokens", "maxOutputTokens"],
-						["costMicrousd", "maxCostMicrousd"],
-						["resultBytes", "maxResultBytes"]
-					];
-					const accounting = Schema.Struct({ consumed: SubagentReservationAmounts });
-					for (const [amount, cap] of dimensions) {
-						const limit = caps[cap];
-						if (limit === void 0) continue;
-						let consumed = requested[amount];
-						for (const entry of prior) {
-							const joined = subagentState.joined.get(entry.toolCallId);
-							const observed = joined === void 0 ? Option.none() : Schema.decodeUnknownOption(accounting)(joined.finalAccounting);
-							consumed += Option.isSome(observed) ? observed.value.consumed[amount] : entry.budget?.allocation[amount] ?? limit;
+				return prepared;
+			});
+			const input = {
+				awaitJoin: recordHalt(Effect.gen(function* () {
+					while (true) if (yield* Effect.scoped(Effect.gen(function* () {
+						const notified = yield* wake.subscribe(submission.threadId);
+						if ((yield* prepareInputs(MAX_JOIN_DRAIN, true)).length > 0) return true;
+						yield* notified;
+						return false;
+					}))) return;
+				})),
+				drain: Effect.fnUntraced(function* (policy) {
+					const joinedInputs = yield* recordHalt(Effect.gen(function* () {
+						const limit = policy === "one" ? 1 : MAX_JOIN_DRAIN;
+						const joinedInputs = [];
+						if (joinBacklog === void 0) joinBacklog = (yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId }))).joins;
+						for (const join of joinBacklog) {
+							const joinId = join.submissionId;
+							if (deliveredJoinInputs.has(joinId)) continue;
+							if (join.state !== "joining" && join.state !== "joined") continue;
+							const existing = joinedInputEnvelopes.get(joinId);
+							if (existing === void 0) continue;
+							if (join.state === "joining") yield* session.markJoined(joinId, {
+								recordId: existing.record.recordId,
+								sequence: existing.sequence
+							});
+							deliveredJoinInputs.add(joinId);
+							if (lastHostResponseSequence !== void 0 && lastHostResponseSequence > existing.sequence) continue;
+							const payload = existing.record.payload;
+							if (payload._tag !== "UserInputRecorded") continue;
+							joinedInputs.push(payload);
+						}
+						const claims = yield* prepareInputs(limit);
+						pendingJoinClaims.splice(0, claims.length);
+						for (const { claim, input: payload, rendered } of claims) {
+							const recordId = submissionInputRecordId(claim.submissionId);
+							let sequence;
+							const existing = joinedInputEnvelopes.get(claim.submissionId);
+							if (existing !== void 0) sequence = existing.sequence;
+							else {
+								const envelope = yield* makeEnvelope(recordId, UserInputRecorded.make({
+									submissionId: claim.submissionId,
+									kind: "steering",
+									runId,
+									input: claim.inputPayload,
+									...payload.messageAdmission === void 0 ? {} : { messageAdmission: payload.messageAdmission }
+								}));
+								sequence = (yield* appendBatch(ctx, CanonicalBatch.make({
+									batchId: submissionInputBatchId(claim.submissionId),
+									producerId: config.producerId,
+									records: [envelope]
+								}))).firstSequence;
+								knownIds.add(recordId);
+								yield* hit("join:after-canonical-append");
+							}
+							yield* session.markJoined(claim.submissionId, {
+								recordId,
+								sequence
+							});
+							deliveredJoinInputs.add(claim.submissionId);
+							joinedInputs.push({
+								...payload,
+								rendered
+							});
+						}
+						return joinedInputs;
+					}));
+					return yield* Effect.forEach(joinedInputs, (joinedInput) => (joinedInput.rendered === void 0 ? renderJoinedInput(joinedInput.input, joinedInput.messageAdmission) : Effect.succeed(joinedInput.rendered)).pipe(Effect.map((input) => ({
+						kind: "steering",
+						input
+					}))));
+				})
+			};
+			/**
+			* Durable child establishment: `establish` performs or replays
+			* the idempotent get-or-create establishment protocol under the
+			* parent's ownership fence and reports where the one child stands; `join` appends the
+			* atomic `[SubagentJoined, ToolCallSettled]` settlement batch (SUB-019) and applies the
+			* reservation release. Both use the halt side channel exactly like the durability/step
+			* hooks: the engine wraps a `CoordinatorHalt` into `SubagentDurabilityError` in the
+			* handler channel while the Attempt aborts with the original infrastructure failure.
+			*/
+			const establishmentGate = yield* Semaphore.make(1);
+			const establishSubagent = (request) => recordHalt(Effect.gen(function* () {
+				const toolCallId = request.toolCallId;
+				const turnInfo = currentToolTurn;
+				if (turnInfo === void 0) return yield* RunJournalError.make({ message: `Delegation Tool Call ${toolCallId} established before any canonical response commit` });
+				const denied = (errorTag, message) => ({
+					_tag: "denied",
+					errorTag,
+					message: boundedText(message)
+				});
+				let requestedPayload = subagentState.requested.get(toolCallId);
+				if (requestedPayload === void 0) {
+					if (request.depth !== delegationDepth + 1) return denied("SubagentDepthUnsupported", `The child depth must be exactly one greater than its source depth ${delegationDepth}`);
+					let targetDigests = request.targetDigests;
+					if (request.target !== void 0) {
+						if (request.target.id !== request.targetAgentId) return denied("SubagentBindingUnavailable", "The child target identity differs from its Definition");
+						const binding = yield* resolveDefinitionBinding(registeredBindings, request.target).pipe(Effect.result);
+						if (binding._tag === "Failure") return denied("SubagentBindingUnavailable", binding.failure.message);
+						if (targetDigests !== void 0 && (targetDigests.agent !== binding.success.digests.agent || targetDigests.model !== binding.success.digests.model || targetDigests.tools !== binding.success.digests.tools)) return denied("SubagentDigestsInvalid", "The explicit child digests differ from its exact registration");
+						targetDigests = binding.success.digests;
+					}
+					const decodedDigests = yield* decodeDefinitionDigests(targetDigests).pipe(Effect.option);
+					if (Option.isNone(decodedDigests)) return denied("SubagentDigestsInvalid", "The declared child Binding digests are not valid stored digests");
+					const childInput = yield* decodePersisted(request.encodedChildInput).pipe(Effect.option);
+					if (Option.isNone(childInput)) return denied("SubagentInputUnpersistable", "The prepared child input does not satisfy the canonical persistence bounds");
+					const grant = yield* decodePersisted(request.encodedGrant).pipe(Effect.option);
+					const allocation = yield* decodePersisted(request.encodedAllocation).pipe(Effect.option);
+					if (Option.isNone(grant) || Option.isNone(allocation)) return denied("SubagentDeclarationUnpersistable", "The delegation grant or allocation does not satisfy the canonical persistence bounds");
+					const decodedGrant = Schema.decodeUnknownOption(SubagentGrant)(grant.value);
+					if (Option.isNone(decodedGrant)) return denied("SubagentGrantInvalid", "The child authority grant is invalid");
+					if (request.policy === void 0 || request.budget === void 0) return denied("SubagentBudgetInvalid", "New durable children require their full execution policy and subtree allocation");
+					if (request.toolCallAllowance !== void 0 && !Schema.is(SubagentRequested.fields.toolCallAllowance)(request.toolCallAllowance)) return denied("SubagentAllowanceInvalid", "The child Tool Call allowance must be a positive integer");
+					if (request.policy !== void 0 && !Schema.is(AgentPolicy)(request.policy)) return denied("SubagentPolicyInvalid", "The resolved child policy is invalid");
+					if (request.budget !== void 0) {
+						if (!Schema.is(SubagentBudgetReservation)(request.budget)) return denied("SubagentBudgetInvalid", "The shared delegation budget is invalid");
+						const decodedAllocation = Schema.decodeUnknownOption(SubagentReservationAmounts)(allocation.value);
+						if (Option.isNone(decodedAllocation) || !Equal.equals(decodedAllocation.value, request.budget.allocation)) return denied("SubagentBudgetInvalid", "The reserved allocation differs from its budget declaration");
+						const { caps, allocation: requested } = request.budget;
+						const prior = [...subagentState.requested.values()];
+						if (prior.some((entry) => entry.budget === void 0 || !Equal.equals(entry.budget.caps, caps))) return denied("SubagentParentBudgetConflict", "Delegations in one parent Run must share the same caps");
+						if (caps.maxTotalChildInvocations !== void 0 && prior.reduce((sum, entry) => sum + 1 + (entry.budget?.descendantInvocations ?? 0), 1 + (request.budget.descendantInvocations ?? 0)) > caps.maxTotalChildInvocations) return denied("SubagentBudgetExhausted", "The parent Run exhausted its child invocation budget");
+						const active = prior.filter((entry) => !subagentState.joined.has(entry.toolCallId));
+						if (caps.maxConcurrentChildren !== void 0 && active.length >= caps.maxConcurrentChildren) return denied("SubagentBudgetExhausted", "The parent Run exhausted its concurrent child budget");
+						const dimensions = [
+							["turns", "maxTurns"],
+							["toolCalls", "maxToolCalls"],
+							["durationMillis", "maxDurationMillis"],
+							["inputTokens", "maxInputTokens"],
+							["outputTokens", "maxOutputTokens"],
+							["costMicrousd", "maxCostMicrousd"],
+							["resultBytes", "maxResultBytes"]
+						];
+						const accounting = Schema.Struct({ consumed: SubagentReservationAmounts });
+						for (const [amount, cap] of dimensions) {
+							const limit = caps[cap];
+							if (limit === void 0) continue;
+							let consumed = requested[amount];
+							for (const entry of prior) {
+								const joined = subagentState.joined.get(entry.toolCallId);
+								const observed = joined === void 0 ? Option.none() : Schema.decodeUnknownOption(accounting)(joined.finalAccounting);
+								consumed += Option.isSome(observed) ? observed.value.consumed[amount] : entry.budget?.allocation[amount] ?? limit;
+							}
+							if (consumed > limit) return denied("SubagentBudgetExhausted", `The parent Run exhausted its shared ${amount} budget`);
 						}
-						if (consumed > limit) return denied("SubagentBudgetExhausted", `The parent Run exhausted its shared ${amount} budget`);
 					}
-				}
-				const childInputDigest = yield* withCrypto(digestJson(childInput.value));
-				const grantDigest = yield* withCrypto(digestJson(grant.value));
-				const allocationDigest = yield* withCrypto(digestJson(allocation.value));
-				const reservationId = childReservationIdFor(runId, toolCallId);
-				const subtree = delegationDepth === 0 ? void 0 : yield* workerRuntime.reserveSubtree(submission.threadId, SubtreeBudgetReserved.make({
-					reservationId,
-					executionRunId: runId,
-					sourceSubmissionId: submissionId,
-					childThreadId: childThreadIdFor(submissionId, toolCallId),
-					lifetime: "attached",
-					depth: request.depth,
-					policy: request.policy,
-					grant: decodedGrant.value,
-					budget: request.budget
-				})).pipe(Effect.result);
-				if (subtree?._tag === "Failure") {
-					if (subtree.failure.reason === "storage") return yield* LedgerError.make({
-						operation: "reserve-subtree",
-						message: "Subtree reservation is unavailable"
+					const childInputDigest = yield* withCrypto(digestJson(childInput.value));
+					const grantDigest = yield* withCrypto(digestJson(grant.value));
+					const allocationDigest = yield* withCrypto(digestJson(allocation.value));
+					const reservationId = childReservationIdFor(runId, toolCallId);
+					const subtree = delegationDepth === 0 ? void 0 : yield* workerRuntime.reserveSubtree(submission.threadId, SubtreeBudgetReserved.make({
+						reservationId,
+						executionRunId: runId,
+						sourceSubmissionId: submissionId,
+						childThreadId: childThreadIdFor(submissionId, toolCallId),
+						lifetime: "attached",
+						depth: request.depth,
+						policy: request.policy,
+						grant: decodedGrant.value,
+						budget: request.budget
+					})).pipe(Effect.result);
+					if (subtree?._tag === "Failure") {
+						if (subtree.failure.reason === "storage") return yield* LedgerError.make({
+							operation: "reserve-subtree",
+							message: "Subtree reservation is unavailable"
+						});
+						return denied("SubagentBudgetExhausted", `The subtree reservation was refused: ${subtree.failure.reason}`);
+					}
+					yield* session.reserveChildBudget({
+						reservationId,
+						parentToolCallId: toolCallId,
+						allocation: allocation.value,
+						allocationDigest
+					}).pipe(Effect.catchTag("ChildReservationConflict", conflictToLedgerError("reserveChildBudget")));
+					yield* hit("subagent:after-reserve");
+					requestedPayload = SubagentRequested.make({
+						runId,
+						turnId: turnInfo.turnId,
+						turn: turnInfo.turn,
+						toolCallId,
+						delegationId: request.delegationId,
+						targetAgentId: request.targetAgentId,
+						targetDigests: decodedDigests.value,
+						childInput: childInput.value,
+						childInputDigest,
+						grantDigest,
+						grant: decodedGrant.value,
+						depth: request.depth,
+						reservationId,
+						reservationDigest: allocationDigest,
+						childThreadId: childThreadIdFor(submissionId, toolCallId),
+						childPrincipal: submission.principal,
+						childIdempotencyKey: childIdempotencyKeyFor(runId, toolCallId),
+						...request.toolCallAllowance === void 0 ? {} : { toolCallAllowance: request.toolCallAllowance },
+						...request.policy === void 0 ? {} : { policy: request.policy },
+						...request.budget === void 0 ? {} : { budget: request.budget }
 					});
-					return denied("SubagentBudgetExhausted", `The subtree reservation was refused: ${subtree.failure.reason}`);
+					const requestRecordId = subagentRequestedRecordId(runId, toolCallId);
+					if (!knownIds.has(requestRecordId)) {
+						const envelope = yield* makeEnvelope(requestRecordId, requestedPayload);
+						yield* appendBatch(ctx, CanonicalBatch.make({
+							batchId: subagentRequestedBatchId(runId, toolCallId),
+							producerId: config.producerId,
+							records: [envelope]
+						})).pipe(Effect.catchTag("AppendConflict", () => Effect.void), Effect.asVoid);
+						knownIds.add(requestRecordId);
+					}
+					subagentState.requested.set(toolCallId, requestedPayload);
+					yield* hit("subagent:after-request-append");
 				}
-				yield* session.reserveChildBudget({
-					reservationId,
-					parentToolCallId: toolCallId,
-					allocation: allocation.value,
-					allocationDigest
-				}).pipe(Effect.catchTag("ChildReservationConflict", conflictToLedgerError("reserveChildBudget")));
-				yield* hit("subagent:after-reserve");
-				requestedPayload = SubagentRequested.make({
-					runId,
-					turnId: turnInfo.turnId,
-					turn: turnInfo.turn,
-					toolCallId,
-					delegationId: request.delegationId,
-					targetAgentId: request.targetAgentId,
-					targetDigests: decodedDigests.value,
-					childInput: childInput.value,
-					childInputDigest,
-					grantDigest,
-					grant: decodedGrant.value,
-					depth: request.depth,
-					reservationId,
-					reservationDigest: allocationDigest,
-					childThreadId: childThreadIdFor(submissionId, toolCallId),
-					childPrincipal: submission.principal,
-					childIdempotencyKey: childIdempotencyKeyFor(runId, toolCallId),
-					...request.toolCallAllowance === void 0 ? {} : { toolCallAllowance: request.toolCallAllowance },
-					...request.policy === void 0 ? {} : { policy: request.policy },
-					...request.budget === void 0 ? {} : { budget: request.budget }
+				const admission = yield* establishChildFromRequest(submission, requestedPayload);
+				if (admission._tag === "indeterminate") return yield* LedgerError.make({
+					operation: "establishSubagent",
+					message: `Child admission for Tool Call ${toolCallId} is indeterminate (${admission.reason}); retrying without a second admission (SUB-031)`
 				});
-				const requestRecordId = subagentRequestedRecordId(runId, toolCallId);
-				if (!knownIds.has(requestRecordId)) {
-					const envelope = yield* makeEnvelope(requestRecordId, requestedPayload);
-					yield* appendBatch(ctx, CanonicalBatch.make({
-						batchId: subagentRequestedBatchId(runId, toolCallId),
-						producerId: config.producerId,
-						records: [envelope]
-					})).pipe(Effect.catchTag("AppendConflict", () => Effect.void), Effect.asVoid);
-					knownIds.add(requestRecordId);
-				}
-				subagentState.requested.set(toolCallId, requestedPayload);
-				yield* hit("subagent:after-request-append");
-			}
-			const admission = yield* establishChildFromRequest(submission, requestedPayload);
-			if (admission._tag === "indeterminate") return yield* LedgerError.make({
-				operation: "establishSubagent",
-				message: `Child admission for Tool Call ${toolCallId} is indeterminate (${admission.reason}); retrying without a second admission (SUB-031)`
-			});
-			const childRunId = runIdForSubmission(admission.childSubmissionId);
-			let startedPayload = subagentState.started.get(toolCallId);
-			if (startedPayload === void 0) {
-				startedPayload = SubagentStarted.make({
-					runId,
-					toolCallId,
-					childThreadId: requestedPayload.childThreadId,
-					childSubmissionId: admission.childSubmissionId,
-					childReceiptId: admission.receiptId,
-					childRunId
+				const childRunId = runIdForSubmission(admission.childSubmissionId);
+				let startedPayload = subagentState.started.get(toolCallId);
+				if (startedPayload === void 0) {
+					startedPayload = SubagentStarted.make({
+						runId,
+						toolCallId,
+						childThreadId: requestedPayload.childThreadId,
+						childSubmissionId: admission.childSubmissionId,
+						childReceiptId: admission.receiptId,
+						childRunId
+					});
+					const startRecordId = subagentStartedRecordId(runId, toolCallId);
+					if (!knownIds.has(startRecordId)) {
+						const envelope = yield* makeEnvelope(startRecordId, startedPayload);
+						yield* appendBatch(ctx, CanonicalBatch.make({
+							batchId: subagentStartedBatchId(runId, toolCallId),
+							producerId: config.producerId,
+							records: [envelope]
+						})).pipe(Effect.catchTag("AppendConflict", () => Effect.void), Effect.asVoid);
+						knownIds.add(startRecordId);
+					}
+					subagentState.started.set(toolCallId, startedPayload);
+					yield* hit("subagent:after-start-append");
+				} else if (startedPayload.childSubmissionId !== admission.childSubmissionId) return yield* LedgerError.make({
+					operation: "establishSubagent",
+					message: `The canonical SubagentStarted record names child ${startedPayload.childSubmissionId} but admission resolved ${admission.childSubmissionId}; establishment fails closed (SUB-016)`
 				});
-				const startRecordId = subagentStartedRecordId(runId, toolCallId);
-				if (!knownIds.has(startRecordId)) {
-					const envelope = yield* makeEnvelope(startRecordId, startedPayload);
+				yield* session.attachChildToReservation({
+					reservationId: decodeChildReservationIdSync(requestedPayload.reservationId),
+					childSubmissionId: startedPayload.childSubmissionId
+				}).pipe(Effect.catchTag("ChildReservationConflict", conflictToLedgerError("attachChildToReservation")));
+				const identity = {
+					childThreadId: startedPayload.childThreadId,
+					childSubmissionId: startedPayload.childSubmissionId,
+					childRunId: startedPayload.childRunId,
+					receiptId: startedPayload.childReceiptId
+				};
+				const child = yield* ledger.lookup(SubmissionLookupById.make({ submissionId: startedPayload.childSubmissionId }));
+				if (Option.isNone(child)) return yield* LedgerError.make({
+					operation: "establishSubagent",
+					message: `Established child ${startedPayload.childSubmissionId} is unknown to the ledger`
+				});
+				if (child.value.state !== "settled") return {
+					_tag: "waiting",
+					...identity
+				};
+				const verification = yield* verifySettledChild(submission, requestedPayload, startedPayload.childSubmissionId);
+				if (verification._tag === "mismatch") return denied("SubagentVerificationFailed", verification.message);
+				return {
+					_tag: "settled",
+					...identity,
+					outcome: verification.value.outcome,
+					encodedResult: verification.value.encodedResult,
+					...yield* verifiedChildUsage(verification.value, startedPayload.childRunId),
+					...verification.value.settlement.finishReason === void 0 ? {} : { finishReason: verification.value.settlement.finishReason }
+				};
+			}).pipe(establishmentGate.withPermits(1)));
+			const joinSubagent = (request) => recordHalt(Effect.gen(function* () {
+				const toolCallId = request.toolCallId;
+				const turnInfo = currentToolTurn;
+				if (turnInfo === void 0) return yield* RunJournalError.make({ message: `Delegation Tool Call ${toolCallId} joined before any canonical response commit` });
+				const requestedPayload = subagentState.requested.get(toolCallId);
+				const startedPayload = subagentState.started.get(toolCallId);
+				if (requestedPayload === void 0 || startedPayload === void 0) return yield* RunJournalError.make({ message: `Delegation Tool Call ${toolCallId} joined without canonical establishment records` });
+				const reservationId = decodeChildReservationIdSync(requestedPayload.reservationId);
+				const joinedRecordId = subagentJoinedRecordId(runId, toolCallId);
+				let finalAccounting;
+				const existingJoined = subagentState.joined.get(toolCallId);
+				if (existingJoined !== void 0) finalAccounting = existingJoined.finalAccounting;
+				else {
+					const encodedResult = yield* decodePersisted(request.encodedResult).pipe(Effect.mapError((cause) => RunJournalError.make({
+						message: `The projected result of Tool Call ${toolCallId} exceeds canonical persistence bounds`,
+						cause
+					})));
+					const accounting = yield* decodePersisted(request.encodedAccounting).pipe(Effect.mapError((cause) => RunJournalError.make({
+						message: `The join accounting of Tool Call ${toolCallId} exceeds canonical persistence bounds`,
+						cause
+					})));
+					const verification = yield* verifySettledChild(submission, requestedPayload, startedPayload.childSubmissionId);
+					if (verification._tag === "mismatch") return yield* LedgerError.make({
+						operation: "joinSubagent",
+						message: `Child Settlement verification failed for Tool Call ${toolCallId}: ${verification.message}`
+					});
+					const verified = verification.value;
+					const toolName = declaredNamesByCallId.get(toolCallId);
+					if (toolName === void 0) return yield* RunJournalError.make({ message: `Delegation Tool Call ${toolCallId} joined without a declared Tool name` });
+					yield* hit("subagent:before-join-append");
+					const joinedPayload = SubagentJoined.make({
+						runId,
+						toolCallId,
+						childSubmissionId: startedPayload.childSubmissionId,
+						childSettlementId: verified.settlement.settlementId,
+						childOutcome: verified.outcome,
+						usageSummary: yield* childUsageSummaryOf(verified.childRecords, startedPayload.childRunId),
+						...yield* verifiedChildUsage(verified, startedPayload.childRunId),
+						reservationId: requestedPayload.reservationId,
+						finalAccounting: accounting
+					});
+					const settledRecordId = toolCallSettledRecordId(runId, turnInfo.turn, toolCallId);
+					const joinedEnvelope = yield* makeEnvelope(joinedRecordId, joinedPayload);
+					const settledEnvelope = yield* makeEnvelope(settledRecordId, ToolCallSettled.make({
+						runId,
+						toolCallId,
+						toolName,
+						result: encodedResult,
+						isFailure: request.isFailure
+					}));
 					yield* appendBatch(ctx, CanonicalBatch.make({
-						batchId: subagentStartedBatchId(runId, toolCallId),
+						batchId: subagentJoinBatchId(runId, toolCallId),
 						producerId: config.producerId,
-						records: [envelope]
+						records: [joinedEnvelope, settledEnvelope]
 					})).pipe(Effect.catchTag("AppendConflict", () => Effect.void), Effect.asVoid);
-					knownIds.add(startRecordId);
+					knownIds.add(joinedRecordId);
+					knownIds.add(settledRecordId);
+					subagentState.joined.set(toolCallId, joinedPayload);
+					finalAccounting = accounting;
+					yield* hit("subagent:after-join-append");
 				}
-				subagentState.started.set(toolCallId, startedPayload);
-				yield* hit("subagent:after-start-append");
-			} else if (startedPayload.childSubmissionId !== admission.childSubmissionId) return yield* LedgerError.make({
-				operation: "establishSubagent",
-				message: `The canonical SubagentStarted record names child ${startedPayload.childSubmissionId} but admission resolved ${admission.childSubmissionId}; establishment fails closed (SUB-016)`
-			});
-			yield* session.attachChildToReservation({
-				reservationId: decodeChildReservationIdSync(requestedPayload.reservationId),
-				childSubmissionId: startedPayload.childSubmissionId
-			}).pipe(Effect.catchTag("ChildReservationConflict", conflictToLedgerError("attachChildToReservation")));
-			const identity = {
-				childThreadId: startedPayload.childThreadId,
-				childSubmissionId: startedPayload.childSubmissionId,
-				childRunId: startedPayload.childRunId,
-				receiptId: startedPayload.childReceiptId
-			};
-			const child = yield* ledger.lookup(SubmissionLookupById.make({ submissionId: startedPayload.childSubmissionId }));
-			if (Option.isNone(child)) return yield* LedgerError.make({
-				operation: "establishSubagent",
-				message: `Established child ${startedPayload.childSubmissionId} is unknown to the ledger`
-			});
-			if (child.value.state !== "settled") return {
-				_tag: "waiting",
-				...identity
-			};
-			const verification = yield* verifySettledChild(submission, requestedPayload, startedPayload.childSubmissionId);
-			if (verification._tag === "mismatch") return denied("SubagentVerificationFailed", verification.message);
-			return {
-				_tag: "settled",
-				...identity,
-				outcome: verification.value.outcome,
-				encodedResult: verification.value.encodedResult,
-				...yield* verifiedChildUsage(verification.value, startedPayload.childRunId),
-				...verification.value.settlement.finishReason === void 0 ? {} : { finishReason: verification.value.settlement.finishReason }
-			};
-		}).pipe(establishmentGate.withPermits(1)));
-		const joinSubagent = (request) => recordHalt(Effect.gen(function* () {
-			const toolCallId = request.toolCallId;
-			const turnInfo = currentToolTurn;
-			if (turnInfo === void 0) return yield* RunJournalError.make({ message: `Delegation Tool Call ${toolCallId} joined before any canonical response commit` });
-			const requestedPayload = subagentState.requested.get(toolCallId);
-			const startedPayload = subagentState.started.get(toolCallId);
-			if (requestedPayload === void 0 || startedPayload === void 0) return yield* RunJournalError.make({ message: `Delegation Tool Call ${toolCallId} joined without canonical establishment records` });
-			const reservationId = decodeChildReservationIdSync(requestedPayload.reservationId);
-			const joinedRecordId = subagentJoinedRecordId(runId, toolCallId);
-			let finalAccounting;
-			const existingJoined = subagentState.joined.get(toolCallId);
-			if (existingJoined !== void 0) finalAccounting = existingJoined.finalAccounting;
-			else {
-				const encodedResult = yield* decodePersisted(request.encodedResult).pipe(Effect.mapError((cause) => RunJournalError.make({
-					message: `The projected result of Tool Call ${toolCallId} exceeds canonical persistence bounds`,
-					cause
-				})));
-				const accounting = yield* decodePersisted(request.encodedAccounting).pipe(Effect.mapError((cause) => RunJournalError.make({
-					message: `The join accounting of Tool Call ${toolCallId} exceeds canonical persistence bounds`,
-					cause
-				})));
-				const verification = yield* verifySettledChild(submission, requestedPayload, startedPayload.childSubmissionId);
-				if (verification._tag === "mismatch") return yield* LedgerError.make({
-					operation: "joinSubagent",
-					message: `Child Settlement verification failed for Tool Call ${toolCallId}: ${verification.message}`
-				});
-				const verified = verification.value;
-				const toolName = declaredNamesByCallId.get(toolCallId);
-				if (toolName === void 0) return yield* RunJournalError.make({ message: `Delegation Tool Call ${toolCallId} joined without a declared Tool name` });
-				yield* hit("subagent:before-join-append");
-				const joinedPayload = SubagentJoined.make({
+				yield* applyReservationRelease(reservationId, finalAccounting, {
+					threadId: submission.threadId,
 					runId,
-					toolCallId,
-					childSubmissionId: startedPayload.childSubmissionId,
-					childSettlementId: verified.settlement.settlementId,
-					childOutcome: verified.outcome,
-					usageSummary: yield* childUsageSummaryOf(verified.childRecords, startedPayload.childRunId),
-					...yield* verifiedChildUsage(verified, startedPayload.childRunId),
-					reservationId: requestedPayload.reservationId,
-					finalAccounting: accounting
+					toolCallId
 				});
-				const settledRecordId = toolCallSettledRecordId(runId, turnInfo.turn, toolCallId);
-				const joinedEnvelope = yield* makeEnvelope(joinedRecordId, joinedPayload);
-				const settledEnvelope = yield* makeEnvelope(settledRecordId, ToolCallSettled.make({
-					runId,
-					toolCallId,
-					toolName,
-					result: encodedResult,
-					isFailure: request.isFailure
-				}));
-				yield* appendBatch(ctx, CanonicalBatch.make({
-					batchId: subagentJoinBatchId(runId, toolCallId),
-					producerId: config.producerId,
-					records: [joinedEnvelope, settledEnvelope]
-				})).pipe(Effect.catchTag("AppendConflict", () => Effect.void), Effect.asVoid);
-				knownIds.add(joinedRecordId);
-				knownIds.add(settledRecordId);
-				subagentState.joined.set(toolCallId, joinedPayload);
-				finalAccounting = accounting;
-				yield* hit("subagent:after-join-append");
-			}
-			yield* applyReservationRelease(reservationId, finalAccounting, {
+			}));
+			const subagent = {
+				establish: establishSubagent,
+				join: joinSubagent
+			};
+			const toolAuthorization = inheritedGrant === void 0 && runToolAuthorization === RunToolAuthorization.allowAllPolicy ? runToolAuthorization : { authorize: (request) => inheritedGrant !== void 0 && !inheritedGrant.allowedToolNames.includes(request.call.toolName) ? Effect.succeed({
+				_tag: "denied",
+				reason: "Tool exceeds the worker's immutable grant"
+			}) : runToolAuthorization.authorize({
+				...request,
+				input: submission.inputPayload,
+				...Schema.is(FrameworkMessage)(submission.messageAdmission) ? { frameworkMessage: submission.messageAdmission } : {}
+			}) };
+			const options = {
 				threadId: submission.threadId,
 				runId,
-				toolCallId
-			});
-		}));
-		const subagent = {
-			establish: establishSubagent,
-			join: joinSubagent
-		};
-		const toolAuthorization = inheritedGrant === void 0 && runToolAuthorization === RunToolAuthorization.allowAllPolicy ? runToolAuthorization : { authorize: (request) => inheritedGrant !== void 0 && !inheritedGrant.allowedToolNames.includes(request.call.toolName) ? Effect.succeed({
-			_tag: "denied",
-			reason: "Tool exceeds the worker's immutable grant"
-		}) : runToolAuthorization.authorize({
-			...request,
-			input: submission.inputPayload,
-			...Schema.is(FrameworkMessage)(submission.messageAdmission) ? { frameworkMessage: submission.messageAdmission } : {}
-		}) };
-		const options = {
-			threadId: submission.threadId,
-			runId,
-			history: pending === void 0 ? journal.historyBefore : resumeProjection.historyBefore,
-			input,
-			commandDrainPolicy: "all",
-			...priorContext !== void 0 || journal.committedTurns > 0 || Schema.is(FrameworkMessage)(submission.messageAdmission) ? { retainedInput: submission.inputPayload } : {},
-			...priorContext === void 0 ? {} : { retainedContext: Prompt.fromMessages(priorContext.prompt.content.slice(priorContext.priorHistoryLength)) },
-			...Schema.is(FrameworkMessage)(submission.messageAdmission) ? { frameworkMessage: submission.messageAdmission } : {},
-			approval,
-			toolAuthorization,
-			...journal.toolSelection === void 0 ? {} : { toolSelection: { toolNames: journal.toolSelection.toolNames.filter((name) => Object.hasOwn(agent.definition.toolkit.tools, name)) } },
-			durability,
-			subagent,
-			delegationDepth,
-			...inheritedGrant === void 0 ? {} : { subagentGrant: inheritedGrant },
-			...inheritedBudget === void 0 ? {} : { subagentBudget: inheritedBudget },
-			...submission.workerAdmission?.origin.budgetScope === void 0 ? {} : { subagentBudgetScope: submission.workerAdmission.origin.budgetScope },
-			runStartedAt: runTiming.startedAt,
-			durationDeadline: runTiming.deadline,
-			...submission.workerAdmission === void 0 ? {} : { toolCallAllowance: submission.workerAdmission.origin.toolCallAllowance },
-			...submission.parentLinkage !== void 0 && childLineage?._tag === "SubagentLineageRecorded" ? { toolCallAllowance: childLineage.toolCallAllowance } : {},
-			...pending === void 0 ? {} : { resume: {
-				...settledCompletion === void 0 ? {} : { settledCompletion },
-				turn: pending.turn,
-				toolResultMaxBytes: pending.toolResultMaxBytes,
-				turnId: pending.turnId,
-				calls: pending.calls,
-				toolParameterRejections: pending.toolParameterRejections,
-				settled: pending.settled,
-				toolExposure: pending.toolExposure ?? Snapshot.make({ exposedToolNames: [...new Set(pending.calls.map((call) => call.name))] }),
-				...resumeLeadingMessages === void 0 ? {} : { leadingMessages: resumeLeadingMessages },
-				...resumeResponseMessages === void 0 ? {} : { responseMessages: resumeResponseMessages }
-			} },
-			...preparedContext === void 0 ? {} : { context: preparedContext },
-			beforeTurn: () => Effect.gen(function* () {
-				if (yieldAfter !== void 0 && (yield* Clock.currentTimeMillis) >= DateTime.toEpochMillis(yieldAfter)) {
-					yield* Deferred.succeed(yieldSignal, void 0);
-					return yield* Effect.never;
-				}
-				if (submissionScheduling.yieldTo !== void 0 && (yield* Ref.get(turnCounter)) > 0) {
-					const candidate = yield* recordHalt(eligibleThreadHead(submission.threadId, submission.queueSequence));
-					if (Option.isSome(candidate) && (candidate.value.state === "ready" || candidate.value.state === "input-applied")) {
-						const next = yield* recordHalt(ledger.lookup(SubmissionLookupById.make({ submissionId: candidate.value.submissionId })));
-						if (Option.isSome(next) && next.value.agentId === submission.agentId && (next.value.state === "ready" || next.value.state === "input-applied") && (yield* recordHalt(submissionScheduling.yieldTo({
-							active: submission,
-							next: next.value
-						})))) {
-							yield* Deferred.succeed(yieldSignal, next.value.submissionId);
-							return yield* Effect.never;
+				history: pending === void 0 ? journal.historyBefore : resumeProjection.historyBefore,
+				input,
+				commandDrainPolicy: "all",
+				...priorContext !== void 0 || journal.committedTurns > 0 || Schema.is(FrameworkMessage)(submission.messageAdmission) ? { retainedInput: submission.inputPayload } : {},
+				...priorContext === void 0 ? {} : { retainedContext: Prompt.fromMessages(priorContext.prompt.content.slice(priorContext.priorHistoryLength)) },
+				...Schema.is(FrameworkMessage)(submission.messageAdmission) ? { frameworkMessage: submission.messageAdmission } : {},
+				approval,
+				toolAuthorization,
+				...journal.toolSelection === void 0 ? {} : { toolSelection: { toolNames: journal.toolSelection.toolNames.filter((name) => Object.hasOwn(agent.definition.toolkit.tools, name)) } },
+				durability,
+				subagent,
+				delegationDepth,
+				...inheritedGrant === void 0 ? {} : { subagentGrant: inheritedGrant },
+				...inheritedBudget === void 0 ? {} : { subagentBudget: inheritedBudget },
+				...submission.workerAdmission?.origin.budgetScope === void 0 ? {} : { subagentBudgetScope: submission.workerAdmission.origin.budgetScope },
+				runStartedAt: runTiming.startedAt,
+				durationDeadline: runTiming.deadline,
+				...submission.workerAdmission === void 0 ? {} : { toolCallAllowance: submission.workerAdmission.origin.toolCallAllowance },
+				...submission.parentLinkage !== void 0 && childLineage?._tag === "SubagentLineageRecorded" ? { toolCallAllowance: childLineage.toolCallAllowance } : {},
+				...pending === void 0 ? {} : { resume: {
+					...settledCompletion === void 0 ? {} : { settledCompletion },
+					turn: pending.turn,
+					toolResultMaxBytes: pending.toolResultMaxBytes,
+					turnId: pending.turnId,
+					calls: pending.calls,
+					toolParameterRejections: pending.toolParameterRejections,
+					settled: pending.settled,
+					toolExposure: pending.toolExposure ?? Snapshot.make({ exposedToolNames: [...new Set(pending.calls.map((call) => call.name))] }),
+					...resumeLeadingMessages === void 0 ? {} : { leadingMessages: resumeLeadingMessages },
+					...resumeResponseMessages === void 0 ? {} : { responseMessages: resumeResponseMessages }
+				} },
+				...preparedContext === void 0 ? {} : { context: preparedContext },
+				beforeTurn: Effect.fnUntraced(function* () {
+					if (yieldAfter !== void 0 && (yield* Clock.currentTimeMillis) >= DateTime.toEpochMillis(yieldAfter)) {
+						yield* Deferred.succeed(yieldSignal, void 0);
+						return yield* Effect.never;
+					}
+					if (submissionScheduling.yieldTo !== void 0 && (yield* Ref.get(turnCounter)) > 0) {
+						const candidate = yield* recordHalt(eligibleThreadHead(submission.threadId, submission.queueSequence));
+						if (Option.isSome(candidate) && (candidate.value.state === "ready" || candidate.value.state === "input-applied")) {
+							const next = yield* recordHalt(ledger.lookup(SubmissionLookupById.make({ submissionId: candidate.value.submissionId })));
+							if (Option.isSome(next) && next.value.agentId === submission.agentId && (next.value.state === "ready" || next.value.state === "input-applied") && (yield* recordHalt(submissionScheduling.yieldTo({
+								active: submission,
+								next: next.value
+							})))) {
+								yield* Deferred.succeed(yieldSignal, next.value.submissionId);
+								return yield* Effect.never;
+							}
 						}
 					}
-				}
-			}),
-			...runContextPreparation.transientContext === void 0 ? {} : { transientContext: runContextPreparation.transientContext },
-			...config.estimateCostMicrousd === void 0 ? {} : { estimateCostMicrousd: config.estimateCostMicrousd },
-			resumeUsage: {
-				...journal.usage,
-				...journal.policyUsage,
-				...journal.usage.modelCalls === 0 && (journal.usage.unobservedModelCalls ?? 0) === 0 && !records.some(({ record }) => record.payload._tag === "ModelResponseInterrupted" && record.payload.runId === runId) ? emptyRunTotals() : runTotalsFromSummary(yield* currentUsageSummary()),
-				children: childUsageReportsOf(subagentState)
-			},
-			...journal.contextWindowId === void 0 ? {} : { initialContextWindowId: journal.contextWindowId },
-			...journal.protectedContext === void 0 ? {} : { protectedContext: journal.protectedContext },
-			...pendingContextToolCallId === void 0 ? {} : { pendingContextToolCallId }
-		};
-		if (pending === void 0 && lineage.inputWasRecorded) {
-			yield* appendInterruptedAudit(ctx, runId, knownIds);
-			interruptedUsage = true;
-		}
-		const consume = executeWithUsageAccountingUnknown(agent, submission.inputPayload, options).pipe(Effect.provideService(AgentUpdateAcceptance, { accept: (update) => flushDeferredResponse.pipe(Effect.catch((failure) => Ref.set(haltRef, failure).pipe(Effect.andThen(Effect.fail(UpdateError.make({ reason: "storage" }))))), Effect.andThen(() => updateRuntime.emit({
-			updateId: update.updateId,
-			value: update.value,
-			submission,
-			runId,
-			definitions: submission.agentDigests
-		}).pipe(Effect.provideService(CurrentRunWriter, ctx))), Effect.catchTag(["LedgerError", "DurableRuntimeFailpointError"], (failure) => Ref.set(haltRef, failure).pipe(Effect.andThen(Effect.fail(UpdateError.make({ reason: "storage" })))))) }), Effect.provideService(ModelUsageAccounting, { noteIncompleteUsage: (turn) => Effect.sync(() => {
-			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 === void 0 ? {} : { 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)), Effect.provideService(CurrentToolFailureObserver, toolFailureObserver), Effect.provideService(RunToolVisibility, runToolVisibility), Effect.provideService(RunToolScheduling, runToolScheduling), Effect.provideService(ContextCompactor, compactor), Effect.provideService(RunContextPreparation, runContextPreparation), Effect.andThen(checkpoint), Effect.catchCause((cause) => Ref.get(haltRef).pipe(Effect.flatMap((failure) => failure === void 0 ? Effect.failCause(cause) : Effect.failCause(Cause.map(cause, (error) => error instanceof CoordinatorHalt ? error : new CoordinatorHalt(failure)))))), Effect.tapCause((cause) => Option.isSome(agentApprovalPendingOption(cause)) && cause.reasons.every(Cause.isFailReason) ? Effect.flatMap(DurableApprovalSuspension, (retain) => retain === void 0 ? Effect.void : halt(retain)) : Effect.void), Effect.as({ _tag: "run" }));
-		const abortWatcher = halt(Effect.gen(function* () {
-			while (true) {
-				yield* Effect.sleep(config.abortPollInterval);
-				const intent = yield* ledger.readAbortIntent(AbortIntentRequest.make({ submissionId }));
-				if (intent === void 0) continue;
-				yield* appendAbortRecord(ctx, intent);
-				return { _tag: "aborted" };
-			}
-		}));
-		const execution = Effect.raceFirst(consume, abortWatcher);
-		const result = yield* (yieldAfter === void 0 && submissionScheduling.yieldTo === void 0 ? execution : Effect.raceFirst(execution, Deferred.await(yieldSignal).pipe(Effect.map((nextSubmissionId) => ({
-			_tag: "yielded",
-			...nextSubmissionId === void 0 ? {} : { nextSubmissionId }
-		}))))).pipe(Effect.provideService(IdGenerator$1, idGenerator)).pipe(Effect.catchCauseFilter(Cause.findError, (error, cause) => {
-			if (isCoordinatorHaltCause(cause)) return Effect.failCause(Cause.map(cause, (halt) => halt.failure));
-			if (cause.reasons.some((reason) => reason._tag === "Fail" && reason.error instanceof AgentInputDecodeError)) return Effect.failCause(Cause.map(cause, () => BindingUnavailable.make({
-				agentId: agent.definition.id,
-				message: "The current Binding cannot decode accepted input"
-			})));
-			const approvalPending = agentApprovalPendingOption(cause);
-			if (Option.isSome(approvalPending)) {
-				const residual = Cause.fromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"));
-				if (residual.reasons.length > 0) return Effect.failCause(residual);
-				return decodeToolCallIdUnknown(approvalPending.value.toolCallId).pipe(Effect.orDie, Effect.map((toolCallId) => ({
-					_tag: "suspendedRun",
-					toolCallId
-				})));
+				}),
+				...runContextPreparation.transientContext === void 0 ? {} : { transientContext: runContextPreparation.transientContext },
+				...config.estimateCostMicrousd === void 0 ? {} : { estimateCostMicrousd: config.estimateCostMicrousd },
+				resumeUsage: {
+					...journal.usage,
+					...journal.policyUsage,
+					...journal.usage.modelCalls === 0 && (journal.usage.unobservedModelCalls ?? 0) === 0 && !records.some(({ record }) => record.payload._tag === "ModelResponseInterrupted" && record.payload.runId === runId) ? emptyRunTotals() : runTotalsFromSummary(yield* currentUsageSummary()),
+					children: childUsageReportsOf(subagentState)
+				},
+				...journal.contextWindowId === void 0 ? {} : { initialContextWindowId: journal.contextWindowId },
+				...journal.protectedContext === void 0 ? {} : { protectedContext: journal.protectedContext },
+				...pendingContextToolCallId === void 0 ? {} : { pendingContextToolCallId }
+			};
+			if (pending === void 0 && lineage.inputWasRecorded) {
+				yield* appendInterruptedAudit(ctx, runId, knownIds);
+				interruptedUsage = true;
 			}
-			const childPending = agentChildPendingOption(error);
-			if (Option.isSome(childPending)) return Effect.succeed({
-				_tag: "suspendedChildRun",
-				children: childPending.value.children
-			});
-			return Effect.gen(function* () {
-				const halted = yield* Ref.get(haltRef);
-				if (halted !== void 0) return yield* halted;
-				yield* flushDeferredResponse;
-				if (error instanceof AgentToolAuthorizationDenied) {
+			const consume = executeWithUsageAccountingUnknown(agent, submission.inputPayload, options).pipe(Effect.provideService(AgentUpdateAcceptance, { accept: (update) => flushDeferredResponse.pipe(Effect.catch((failure) => Ref.set(haltRef, failure).pipe(Effect.andThen(Effect.fail(UpdateError.make({ reason: "storage" }))))), Effect.andThen(() => updateRuntime.emit({
+				updateId: update.updateId,
+				value: update.value,
+				submission,
+				runId,
+				definitions: submission.agentDigests
+			}).pipe(Effect.provideService(CurrentRunWriter, ctx))), Effect.catchTag(["LedgerError", "DurableRuntimeFailpointError"], (failure) => Ref.set(haltRef, failure).pipe(Effect.andThen(Effect.fail(UpdateError.make({ reason: "storage" })))))) }), Effect.provideService(ModelUsageAccounting, { noteIncompleteUsage: (turn) => Effect.sync(() => {
+				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 === void 0 ? {} : { 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)), Effect.provideService(CurrentToolFailureObserver, toolFailureObserver), Effect.provideService(RunToolVisibility, runToolVisibility), Effect.provideService(RunToolScheduling, runToolScheduling), Effect.provideService(ContextCompactor, compactor), Effect.provideService(RunContextPreparation, runContextPreparation), Effect.andThen(checkpoint), Effect.catchCause((cause) => Ref.get(haltRef).pipe(Effect.flatMap((failure) => failure === void 0 ? Effect.failCause(cause) : Effect.failCause(Cause.map(cause, (error) => error instanceof CoordinatorHalt ? error : new CoordinatorHalt(failure)))))), Effect.tapCause((cause) => Option.isSome(agentApprovalPendingOption(cause)) && cause.reasons.every(Cause.isFailReason) ? Effect.flatMap(DurableApprovalSuspension, (retain) => retain === void 0 ? Effect.void : halt(retain)) : Effect.void), Effect.as({ _tag: "run" }));
+			const abortWatcher = halt(Effect.gen(function* () {
+				while (true) {
+					yield* Effect.sleep(config.abortPollInterval);
 					const intent = yield* ledger.readAbortIntent(AbortIntentRequest.make({ submissionId }));
-					if (intent !== void 0) {
-						yield* appendAbortRecord(ctx, intent);
-						return { _tag: "aborted" };
-					}
+					if (intent === void 0) continue;
+					yield* appendAbortRecord(ctx, intent);
+					return { _tag: "aborted" };
 				}
-				if (cause.reasons.some((reason) => reason._tag === "Die" || reason._tag === "Fail" && !(reason.error instanceof AgentApprovalDenied) && !(reason.error instanceof AgentToolAuthorizationDenied))) yield* Effect.logError("Agent run failed", cause).pipe(Effect.annotateLogs({
+			}));
+			const execution = Effect.raceFirst(consume, abortWatcher);
+			const result = yield* (yieldAfter === void 0 && submissionScheduling.yieldTo === void 0 ? execution : Effect.raceFirst(execution, Deferred.await(yieldSignal).pipe(Effect.map((nextSubmissionId) => ({
+				_tag: "yielded",
+				...nextSubmissionId === void 0 ? {} : { nextSubmissionId }
+			}))))).pipe(Effect.provideService(IdGenerator$1, idGenerator)).pipe(Effect.catchCauseFilter(Cause.findError, (error, cause) => {
+				if (isCoordinatorHaltCause(cause)) return Effect.failCause(Cause.map(cause, (halt) => halt.failure));
+				if (cause.reasons.some((reason) => reason._tag === "Fail" && reason.error instanceof AgentInputDecodeError)) return Effect.failCause(Cause.map(cause, () => BindingUnavailable.make({
 					agentId: agent.definition.id,
-					runId,
-					threadId: ctx.threadId,
-					submissionId,
-					attemptId: lineage.attemptId
-				}));
-				return {
-					_tag: "failedRun",
-					outcome: yield* failureOutcome(error, cause, {
+					message: "The current Binding cannot decode accepted input"
+				})));
+				const approvalPending = agentApprovalPendingOption(cause);
+				if (Option.isSome(approvalPending)) {
+					const residual = Cause.fromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"));
+					if (residual.reasons.length > 0) return Effect.failCause(residual);
+					return decodeToolCallIdUnknown(approvalPending.value.toolCallId).pipe(Effect.orDie, Effect.map((toolCallId) => ({
+						_tag: "suspendedRun",
+						toolCallId
+					})));
+				}
+				const childPending = agentChildPendingOption(error);
+				if (Option.isSome(childPending)) return Effect.succeed({
+					_tag: "suspendedChildRun",
+					children: childPending.value.children
+				});
+				return Effect.gen(function* () {
+					const halted = yield* Ref.get(haltRef);
+					if (halted !== void 0) return yield* halted;
+					yield* flushDeferredResponse;
+					if (error instanceof AgentToolAuthorizationDenied) {
+						const intent = yield* ledger.readAbortIntent(AbortIntentRequest.make({ submissionId }));
+						if (intent !== void 0) {
+							yield* appendAbortRecord(ctx, intent);
+							return { _tag: "aborted" };
+						}
+					}
+					if (cause.reasons.some((reason) => reason._tag === "Die" || reason._tag === "Fail" && !(reason.error instanceof AgentApprovalDenied) && !(reason.error instanceof AgentToolAuthorizationDenied))) yield* Effect.logError("Agent run failed", cause).pipe(Effect.annotateLogs({
 						agentId: agent.definition.id,
 						runId,
 						threadId: ctx.threadId,
 						submissionId,
 						attemptId: lineage.attemptId
-					})
+					}));
+					return {
+						_tag: "failedRun",
+						outcome: yield* failureOutcome(error, cause, {
+							agentId: agent.definition.id,
+							runId,
+							threadId: ctx.threadId,
+							submissionId,
+							attemptId: lineage.attemptId
+						})
+					};
+				});
+			}));
+			if (result._tag === "yielded") return result;
+			if (result._tag === "suspendedRun") return approvalSuspension(result.toolCallId);
+			if (result._tag === "suspendedChildRun") return childSuspension(result.children);
+			if (result._tag === "aborted") {
+				yield* flushDeferredResponse;
+				return {
+					...abortedRunPhase(yield* currentUsageSummary()),
+					uncommittedModelUsage: uncommittedModelUsage()
 				};
+			}
+			if (result._tag === "failedRun") return {
+				...result.outcome,
+				usageSummary: yield* currentUsageSummary(),
+				uncommittedModelUsage: uncommittedModelUsage()
+			};
+			const committedCompletion = completionState.committed;
+			if (committedCompletion === void 0) return yield* LedgerError.make({
+				operation: "runModel",
+				message: "Agent Run ended without a committed completion"
 			});
-		}));
-		if (result._tag === "yielded") return result;
-		if (result._tag === "suspendedRun") return approvalSuspension(result.toolCallId);
-		if (result._tag === "suspendedChildRun") return childSuspension(result.children);
-		if (result._tag === "aborted") {
-			yield* flushDeferredResponse;
 			return {
-				...abortedRunPhase(yield* currentUsageSummary()),
+				_tag: "completed",
+				result: committedCompletion.output,
+				...committedCompletion.runDisposition === void 0 ? {} : { runDisposition: committedCompletion.runDisposition },
+				...committedCompletion.finishReason === void 0 ? {} : { finishReason: committedCompletion.finishReason },
+				...committedCompletion.exhausted === void 0 ? {} : { exhausted: committedCompletion.exhausted },
+				usageSummary: yield* currentUsageSummary(),
 				uncommittedModelUsage: uncommittedModelUsage()
 			};
 		}
-		if (result._tag === "failedRun") return {
-			...result.outcome,
-			usageSummary: yield* currentUsageSummary(),
-			uncommittedModelUsage: uncommittedModelUsage()
-		};
-		const committedCompletion = completionState.committed;
-		if (committedCompletion === void 0) return yield* LedgerError.make({
-			operation: "runModel",
-			message: "Agent Run ended without a committed completion"
-		});
-		return {
-			_tag: "completed",
-			result: committedCompletion.output,
-			...committedCompletion.runDisposition === void 0 ? {} : { runDisposition: committedCompletion.runDisposition },
-			...committedCompletion.finishReason === void 0 ? {} : { finishReason: committedCompletion.finishReason },
-			...committedCompletion.exhausted === void 0 ? {} : { exhausted: committedCompletion.exhausted },
-			usageSummary: yield* currentUsageSummary(),
-			uncommittedModelUsage: uncommittedModelUsage()
-		};
-	});
+	);
 	/**
 	* One ownership period over the claimed lane head. The step order mirrors the pure recovery
 	* classifier's decision table, so a fresh Attempt and a recovering Attempt take the same path
@@ -6417,7 +6428,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 	* (Unknown Outcomes, or a durable approval suspension) — no settlement occurs and the
 	* obligation stays owed.
 	*/
-	const runAttempt = (registeredAgent, session, resumeAfterRetention, onHandoff, yieldAfter) => Effect.gen(function* () {
+	const runAttempt = Effect.fnUntraced(function* (registeredAgent, session, resumeAfterRetention, onHandoff, yieldAfter) {
 		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));
 		let committedPromptSuffix;
@@ -6473,7 +6484,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			journalMetadata = void 0;
 			return metadata;
 		};
-		let records = yield* Stream.runCollect(initialView.canonical.pipe(Stream.filter(collectControl)));
+		let records = initialView.records.filter(collectControl);
 		const refreshControl = Effect.fnUntraced(function* (throughSequence) {
 			const through = throughSequence ?? (yield* store.inspectTail(ThreadTailRequest.make({ threadId }))).tailSequence;
 			if (through > controlThrough) {
@@ -6513,7 +6524,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			return Option.some(yield* settleAborted(ctx, submission, session.publishSettlement, snapshot.abortIntent, evidence, knownIds));
 		}
 		yield* applyCanonicalInput(ctx, submission, session, records, snapshot.inputApplied);
-		const start = yield* makeRunStart(submission, Duration.toMillis(agent.definition.policy.maxDuration), yield* refreshControl()).pipe(Effect.provideService(CurrentRunWriter, ctx));
+		const start = yield* makeRunStart(submission, Duration.toMillis(agent.definition.policy.maxDuration), yield* refreshControl(), initialView.operational).pipe(Effect.provideService(CurrentRunWriter, ctx));
 		const savedRunTiming = start.timing;
 		const commitStart = Effect.flatMap(CurrentRunStart, (publication) => publication.commit()).pipe(Effect.provideService(CurrentRunStart, start.publication));
 		const runTiming = workerOrigin === void 0 ? savedRunTiming : {
@@ -6623,7 +6634,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			const tail = yield* session.tail;
 			const currentRecords = yield* refreshControl(tail.sequence);
 			const view = yield* recoveryView(threadId, tail.sequence, [submissionId], runIdForSubmission(submissionId), currentRecords);
-			let canonical = view.canonical;
+			let canonical = Stream.fromIterable(view.records);
 			let initialJournal;
 			if (view.context === void 0) {
 				const original = currentRecords.find(({ record }) => record.payload._tag === "UserInputRecorded" && record.payload.kind === "user" && record.payload.submissionId === submissionId);
@@ -6733,7 +6744,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			if (outcome._tag === "completed" && initialJournal?.cacheable && initialJournal.history !== void 0) yield* promptHistory.complete({ threadId: session.threadId }, initialJournal.original, initialJournal.history, committedPromptSuffix).pipe(Effect.provideService(CurrentRunWriter, session), Effect.provideService(ThreadStore, store), Effect.provideService(ThreadReader, reader));
 			return Option.some(settlement);
 		}
-	}).pipe(Effect.scoped);
+	}, (effect) => effect.pipe(Effect.scoped));
 	const acquireAdministrativeClaim = (threadId, handoff) => runStorage.claim(ClaimRequest.make({
 		threadId,
 		...handoff === void 0 ? {} : { handoff }
@@ -6819,7 +6830,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			settlements.push(settlement.value);
 		}
 	}).pipe((body) => withProcessing(threadId, body));
-	const processThreadImpl = (agent, threadId) => Effect.gen(function* () {
+	const processThreadImpl = Effect.fnUntraced(function* (agent, threadId) {
 		const binding = yield* makeLegacyWorkerBinding(agent);
 		return yield* drainThread((submission) => submission.agentId === binding.agentId ? Effect.succeed(binding) : Effect.fail(BindingUnavailable.make({
 			agentId: submission.agentId,
@@ -7221,8 +7232,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 		const snapshot = yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId: submission.submissionId }));
 		if (snapshot.hostSubmissionId !== void 0 && !history.submissionIds.includes(snapshot.hostSubmissionId)) {
 			const hostId = snapshot.hostSubmissionId;
-			const hostView = yield* recoveryView(submission.threadId, history.throughSequence, [hostId]);
-			const hostRecords = yield* Stream.runCollect(hostView.canonical.pipe(Stream.filter(controlRecords([hostId]))));
+			const hostRecords = (yield* recoveryView(submission.threadId, history.throughSequence, [hostId])).records.filter(controlRecords([hostId]));
 			const merged = new Map(history.records.map((entry) => [entry.sequence, entry]));
 			for (const entry of hostRecords) merged.set(entry.sequence, entry);
 			history = {
@@ -7776,10 +7786,6 @@ const make = Effect.fnUntraced(function* (bindings) {
 			submissionId: receipt.submissionId
 		});
 		if (snapshot.value.state !== "settled") return Option.none();
-		const settlement = yield* ledger.finalizeSettlement(SettlementFinalization.make({
-			submissionId: receipt.submissionId,
-			settlementId: submissionSettlementId(receipt.submissionId)
-		}));
 		const canonical = yield* getRecord({
 			threadId: receipt.threadId,
 			recordId: submissionSettlementRecordId(receipt.submissionId)
@@ -7793,6 +7799,23 @@ const make = Effect.fnUntraced(function* (bindings) {
 			message: "Finalized Submission has no canonical Settlement"
 		});
 		const record = yield* settlementPayloadFromRecord(canonical.value.record, receipt.submissionId);
+		const finalized = snapshot.value;
+		const retainedFinalization = finalized.settledAt !== void 0 && finalized.settledRecordId !== void 0 && finalized.settledOutcome !== void 0;
+		if (retainedFinalization && (finalized.settledRecordId !== canonical.value.record.recordId || finalized.settledOutcome !== record.outcome || canonical.value.batchId !== submissionSettlementBatchId(receipt.submissionId))) return yield* LedgerError.make({
+			operation: "awaitSettlement",
+			message: "Settled projection disagrees with its canonical Settlement"
+		});
+		const settlement = retainedFinalization ? Settlement.make({
+			submissionId: receipt.submissionId,
+			settlementId: record.settlementId,
+			receiptId: record.receiptId,
+			outcome: record.outcome,
+			...record.outcome === "failed" ? { failure: record.result } : {},
+			settledAt: finalized.settledAt
+		}) : yield* ledger.finalizeSettlement(SettlementFinalization.make({
+			submissionId: receipt.submissionId,
+			settlementId: submissionSettlementId(receipt.submissionId)
+		}));
 		if (record.receiptId !== receipt.receiptId || record.settlementId !== settlement.settlementId || record.outcome !== settlement.outcome) return yield* LedgerError.make({
 			operation: "awaitSettlement",
 			message: "Canonical Settlement disagrees with the receipt or finalized outcome"
@@ -8348,4 +8371,4 @@ var DurableAgentRuntime = class DurableAgentRuntime extends Context.Service()("@
 //#endregion
 export { DurableApprovalSuspension as a, RecoveryFailure as c, WorkRecoveryReport as d, WorkRecoveryRequest as f, recoveryRepairRecordId as g, recoveryRepairBatchId as h, DurableApprovalResolver as i, RecoveryReport as l, isolateRecovery as m, DurableAgentRuntime as n, DurableRuntimeConfig as o, childReservationIdFor as p, DurableAgentRuntime_exports as r, RecoveryBlocked as s, ApprovalSuspensionError as t, RecoverySweepResult as u };
 
-//# sourceMappingURL=DurableAgentRuntime-BAmSkWYr.mjs.map
+//# sourceMappingURL=DurableAgentRuntime-CBBjRNJN.mjs.map