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

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

@@ -12,37 +12,38 @@ import { DelegationDepth, SubagentBudgetReservation, SubagentDelegationCaps, Sub
 import { o as Selection, s as Snapshot } from "./ToolExposure-hTJT2ekj.mjs";
 import { ChildRunUsage, InputTokenUsage, ModelCallUsage, ModelResponseIdentity, ModelUsageGroup, OutputTokenUsage, RunUsageReport, RunUsageSummary, emptyRunTotals, runTotalsFromSummary, sumRunTotals, summarizeModelUsage, unknownRunTotals } from "./core/Usage.mjs";
 import { C as MessageStatus, S as MessageRef, _ as WorkerStop, b as WorkerUpdate, c as WorkerError, f as WorkerRef, l as WorkerHistoryEntry, o as WorkerCompletion, r as FrameworkMessage } from "./Worker-DZjdMjZn.mjs";
-import { a as PeerMessageCapacity, d as MessageAdmission, f as MessagingError, i as PeerDeliveryLifetime, o as PeerRoutes, p as PeerName, r as PeerAuthorizer, t as MessagingHost } from "./MessagingHost-CRUK4JBi.mjs";
+import { a as PeerMessageCapacity, d as MessageAdmission, f as MessagingError, i as PeerDeliveryLifetime, o as PeerRoutes, p as PeerName, r as PeerAuthorizer, t as MessagingHost } from "./MessagingHost-CZCyrnvJ.mjs";
 import { SubagentHost } from "./engine/SubagentHost.mjs";
+import { Store, makeMemoryStore } from "./core/Thread.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-B6qZlD3f.mjs";
+import { C as boundedValueFootprint, n as AgentChildPending, p as renderInputPrompt, u as executeWithUsageAccountingUnknown } from "./AgentRuntime-DaDKMasp.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-EpeqWEdv.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-DzL4Kbtw.mjs";
+import { i as digestCanonicalJson, r as canonicalJson, s as digestJson } from "./Digest-C3EODOee.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-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 { 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-a6QYaG3h.mjs";
+import { $ as makeJournalMetadata, A as subagentRequestedRecordId, B as toolStepSettledRecordId, C as runStartedBatchId, D as subagentLineageBatchId, E as subagentJoinedRecordId, F as toolCallResolutionBatchId, G as turnResponseBatch, I as toolCallResolvedRecordId, K as turnResponseBatchId, L as toolCallResultBatchId, M as subagentStartedRecordId, N as toolApprovalDecisionRecordId, O as subagentLineageRecordId, P as toolApprovalRequestRecordId, R as toolCallUnknownRecordId, S as runIdForSubmission, T as subagentJoinBatchId, U as turnCanonicalBatch, V as turnApprovalsBatchId, W as turnIdForRun, X as workerOriginRecordId, Y as workerInputRecordId, Z as workerReportRecordId, _ as projectRunJournalStream, a as childIdempotencyKeyFor, b as runDurationBatchId, c as compactionRecordId, d as markUnknownBatchId, et as toolCallSettledRecordId, f as modelResponseInterruptedBatchId, h as peerMessageRecordId, i as approvalDecisionBatchId, j as subagentStartedBatchId, k as subagentRequestedBatchId, l as firstWorkerInputRecordId, m as modelResponseRecordId, o as childThreadIdFor, p as modelResponseInterruptedRecordId, q as turnResultsBatch, r as agentUpdateRecordId, s as compactionBatchId, t as RunJournalError, u as initialRunJournal, w as runStartedRecordId, x as runDurationRecordId, y as runCompletedRecordId, z as toolStepSettledBatchId } from "./RunJournal-DGblbFas.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, h as PreparedAppend, 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-BC4V-mY-.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-4ZATcVLB.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-CWHuciup.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-DDYJdOsU.mjs";
+import { c as threadCreatedBatchId, l as threadCreatedRecordId, n as WorkerAdmissionPort, o as ensureThreadCreated, r as WorkerAdmissionRequest, s as ensureWorkerOrigin } from "./WorkerAdmission-C47Vy_cK.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-BHjuuERI.mjs";
+import { o as makeRunWriter, r as RunStorage, s as StorageOwner } from "./RunStorage-BF2YgWkg.mjs";
 import { SettlementPublication } from "./durable/SettlementPublisher.mjs";
 import { PendingSubmission, SettledSubmission } from "./durable/SubmissionStatus.mjs";
 import { DeclaredToolCallEvidence, ToolReconciler } from "./durable/ToolReconciler.mjs";
@@ -768,14 +769,13 @@ const retainedBytes = (value, json, allowance) => {
 	const footprint = promptJsonFootprint(value, Math.floor((allowance - encodedBytes) / 2));
 	return footprint === void 0 ? void 0 : encodedBytes + 2 * footprint;
 };
-const encodeHistory = Effect.fnUntraced(function* (prompt, allowance) {
-	const value = yield* encodePrompt(prompt);
+const encodeHistory = (prompt, allowance) => Effect.suspend(() => Effect.mapEager(encodePrompt(prompt), (value) => {
 	const encoded = canonicalJson(value);
 	return {
 		encoded,
 		bytes: retainedBytes(value, encoded, allowance)
 	};
-});
+}));
 const decodeCheckpointPrefix = Effect.fnUntraced(function* (encoded, length) {
 	const value = yield* parseJson(encoded);
 	const bytes = retainedBytes(value, encoded, MAX_BYTES);
@@ -2829,6 +2829,7 @@ const childUsageReportsOf = (state) => [...state.started.entries()].map(([toolCa
 });
 /** Deterministic batch identity of one executed recovery decision's audit append (DUR-013). */
 const recoveryRepairBatchId = (submissionId, decisionTag) => decodeBatchId(`repair:${submissionId}:${decisionTag}`);
+const isOriginalInputRecord = (record) => record.payload._tag === "UserInputRecorded";
 /** Deterministic record identity of one executed recovery decision's `RepairAnnotated` record. */
 const recoveryRepairRecordId = (submissionId, decisionTag) => decodeRecordId(`repair:${submissionId}:${decisionTag}`);
 const RecoveryCauseTag = Schema.Literals([
@@ -3152,6 +3153,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 	const store = yield* ThreadStore;
 	const reader = ThreadReader.fromStore(store);
 	const promptHistory = yield* makePromptHistoryCache();
+	const unclaimedAdmissions = /* @__PURE__ */ new Map();
 	const workDiscovery = yield* ThreadWorkDiscovery.pipe(Effect.provide(ThreadWorkDiscovery.layer), Effect.provideService(ThreadStore, store));
 	const runStorage = yield* RunStorage;
 	const storageOwner = yield* StorageOwner;
@@ -3175,8 +3177,10 @@ const make = Effect.fnUntraced(function* (bindings) {
 	})));
 	const operationAuthorizer = yield* OperationAuthorizer;
 	const toolFailureObserver = yield* CurrentToolFailureObserver;
+	const runServices = Context.make(CurrentToolFailureObserver, toolFailureObserver).pipe(Context.add(RunToolVisibility, runToolVisibility), Context.add(RunToolScheduling, runToolScheduling), Context.add(ContextCompactor, compactor), Context.add(RunContextPreparation, runContextPreparation));
+	const journalServices = Context.make(ThreadReader, reader).pipe(Context.add(Crypto.Crypto, crypto));
 	const withCrypto = (effect) => Effect.provideService(effect, Crypto.Crypto, crypto);
-	const readInitialJournal = (original, suffix) => initialContext(original).pipe(Effect.provideService(ThreadReader, reader), Effect.provideService(Crypto.Crypto, crypto), Effect.map((history) => history.concat(suffix)));
+	const readInitialJournal = (original, suffix) => initialContext(original).pipe(Effect.provideContext(journalServices), Effect.map((history) => history.concat(suffix)));
 	const resolutionIntentsFor = (snapshot) => {
 		const intents = /* @__PURE__ */ new Map();
 		for (const intent of snapshot.unknownResolutions) if (!intents.has(intent.toolCallId) || unknownResolutionKind(intent.resolution) === "factual") intents.set(intent.toolCallId, intent);
@@ -3286,7 +3290,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			const resolve = Effect.fnUntraced(function* (ref) {
 				const found = byId.get(ref.recordId);
 				if (found === void 0) {
-					yield* resolveEvidence(threadId, ref).pipe(Effect.provideService(ThreadReader, reader), Effect.provideService(Crypto.Crypto, crypto));
+					yield* resolveEvidence(threadId, ref).pipe(Effect.provideContext(journalServices));
 					return yield* invalid("Required Run evidence is absent from its locator; rebuild the index explicitly");
 				}
 				if (!canonicalRunIds(found.record).includes(runId)) return yield* invalid("Run continuation references another owner");
@@ -3310,7 +3314,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 				const cachedContext = resolvedContext;
 				if (cachedContext?.threadId === threadId && cachedContext.recordId === cursor.savedContext.recordId) saved = cachedContext.value;
 				else {
-					saved = yield* readRunContext(initial, input, cursor.savedContext.recordId).pipe(Effect.provide(RunContextReader.layer(threadId)), Effect.provideService(ThreadReader, reader), Effect.provideService(Crypto.Crypto, crypto), Effect.mapError(() => invalid("Saved original context cannot be resolved from its evidence")));
+					saved = yield* readRunContext(initial, input, cursor.savedContext.recordId).pipe(Effect.provide(RunContextReader.layer(threadId)), Effect.provideContext(journalServices), Effect.mapError(() => invalid("Saved original context cannot be resolved from its evidence")));
 					resolvedContext = {
 						threadId,
 						recordId: cursor.savedContext.recordId,
@@ -3725,7 +3729,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 	const progressWriters = /* @__PURE__ */ new WeakMap();
 	const activeProgress = /* @__PURE__ */ new Map();
 	const withProgress = Effect.fnUntraced(function* (writer) {
-		const progress = activeProgress.get(writer.threadId)?.writer ?? (yield* makeProgressWriter(writer.threadId, config.deploymentId).pipe(Effect.provideService(ThreadReader, reader), Effect.provideService(Crypto.Crypto, crypto)));
+		const progress = activeProgress.get(writer.threadId)?.writer ?? (yield* makeProgressWriter(writer.threadId, config.deploymentId).pipe(Effect.provideContext(journalServices)));
 		const owned = {
 			...writer,
 			append: (batch) => progress.commit(batch).pipe(Effect.provideService(CurrentRunWriter, writer), Effect.tapError(() => writer.checkActive))
@@ -3737,15 +3741,25 @@ const make = Effect.fnUntraced(function* (bindings) {
 		};
 	});
 	const attemptContextAtTail = (threadId) => makeRunWriter(threadId).pipe(Effect.provideService(ThreadStore, store), Effect.provideService(StorageOwner, storageOwner), Effect.flatMap(withProgress), Effect.map(({ owned }) => owned));
-	const withProgressSession = Effect.fnUntraced(function* (session) {
+	const withProgressSession = Effect.fnUntraced(function* (session, originalInput) {
 		const { owned, progress } = yield* withProgress(session);
 		activeProgress.set(session.threadId, { writer: progress });
 		yield* Effect.addFinalizer(() => Effect.sync(() => {
 			if (activeProgress.get(session.threadId)?.writer === progress) activeProgress.delete(session.threadId);
 		}));
+		const inputWriter = session.appendInput === void 0 ? void 0 : {
+			...session,
+			append: session.appendInput
+		};
 		const wrapped = {
 			...session,
 			append: owned.append,
+			...inputWriter === void 0 ? {} : { appendInput: (batch) => storageOwner.withProgress(session.threadId, storageOwner.withMutation(Effect.gen(function* () {
+				yield* session.checkActive;
+				const original = originalInput?.();
+				const commit = progress.commit(batch);
+				return yield* (original === void 0 ? commit : progress.withVerifiedEmptyRun(runIdForSubmission(session.claim.submissionId), CanonicalSequence.make(original.sequence - 1), commit)).pipe(Effect.provideService(CurrentRunWriter, inputWriter));
+			}))) },
 			publishSettlement: (batch) => progress.publish(batch).pipe(Effect.provideService(CurrentRunSettlement, session))
 		};
 		progressWriters.set(wrapped, progress);
@@ -3754,7 +3768,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 	const progressStore = ThreadStore.of({
 		...store,
 		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)));
+			const progress = activeProgress.get(request.threadId)?.writer ?? (yield* makeProgressWriter(request.threadId, config.deploymentId).pipe(Effect.provideContext(journalServices)));
 			let tail = { sequence: request.expectedTailSequence };
 			return yield* progress.commit(request.batch).pipe(Effect.provideService(CurrentRunWriter, {
 				threadId: request.threadId,
@@ -4050,6 +4064,13 @@ const make = Effect.fnUntraced(function* (bindings) {
 			reason
 		}));
 	});
+	const prepareOriginalInput = (submission) => makeEnvelope(submissionInputRecordId(submission.submissionId), UserInputRecorded.make({
+		submissionId: submission.submissionId,
+		kind: "user",
+		runId: runIdForSubmission(submission.submissionId),
+		input: submission.inputPayload,
+		...submission.messageAdmission === void 0 ? {} : { messageAdmission: submission.messageAdmission }
+	}));
 	/**
 	* Plan step 2: append the deterministic `UserInputRecorded` record (batch idempotency makes it
 	* exactly-once canonical, DUR-007) and mark it applied. When canonical history already carries
@@ -4067,13 +4088,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			});
 			return;
 		}
-		const envelope = yield* makeEnvelope(recordId, UserInputRecorded.make({
-			submissionId,
-			kind: "user",
-			runId: runIdForSubmission(submissionId),
-			input: submission.inputPayload,
-			...submission.messageAdmission === void 0 ? {} : { messageAdmission: submission.messageAdmission }
-		}));
+		const envelope = yield* prepareOriginalInput(submission);
 		const result = yield* appendBatch(ctx, CanonicalBatch.make({
 			batchId: submissionInputBatchId(submissionId),
 			producerId: config.producerId,
@@ -4100,8 +4115,10 @@ const make = Effect.fnUntraced(function* (bindings) {
 		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, operational) {
+	const makeRunStart = Effect.fnUntraced(function* (submission, maxDurationMillis, records, operational, input) {
 		const writer = yield* CurrentRunWriter;
+		const append = input === void 0 ? writer.append : writer.appendInput;
+		if (append === void 0) return yield* RunJournalError.make({ message: "Fresh startup requires an input publisher" });
 		const runId = runIdForSubmission(submission.submissionId);
 		const recordId = runStartedRecordId(runId);
 		const existing = yield* readRunStart(submission.threadId, runId, operational);
@@ -4129,11 +4146,19 @@ const make = Effect.fnUntraced(function* (bindings) {
 				return;
 			}
 			yield* hit("run:before-start-append");
-			yield* appendBatch(writer, CanonicalBatch.make({
-				batchId: runStartedBatchId(runId),
+			yield* appendBatch({
+				threadId: writer.threadId,
+				append
+			}, CanonicalBatch.make({
+				batchId: input === void 0 ? runStartedBatchId(runId) : submissionInputBatchId(submission.submissionId),
 				producerId: config.producerId,
-				records: [start, ...context === void 0 ? [] : [context]]
+				records: [
+					input ?? start,
+					...input === void 0 ? [] : [start],
+					...context === void 0 ? [] : [context]
+				]
 			}));
+			if (input !== void 0) yield* hit("input:after-canonical-append");
 			committed = true;
 			yield* hit("run:after-start-append");
 		});
@@ -4970,13 +4995,14 @@ const make = Effect.fnUntraced(function* (bindings) {
 			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);
+			const originalInput = initialJournal?.original ?? 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);
+			const freshPrefix = priorContext === void 0 && initialJournal?.prefix !== void 0 && initialJournal.records?.length === 1 && initialJournal.records[0] === originalInput ? initialJournal.prefix.prompt : void 0;
+			let journal = freshPrefix !== void 0 ? initialRunJournal(freshPrefix) : 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 = {
@@ -5096,12 +5122,11 @@ const make = Effect.fnUntraced(function* (bindings) {
 				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);
+				for (const count of stagedUnobservedCalls.values()) 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",
@@ -5111,11 +5136,11 @@ const make = Effect.fnUntraced(function* (bindings) {
 				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);
+					inputTokens += usage.inputTokens;
+					outputTokens += usage.outputTokens;
+					costMicrousd += usage.costMicrousd;
 				}
-				const modelCalls = yield* addUsageTotal("modelCalls", journal.usage.modelCalls, stagedCalls.length);
+				const modelCalls = journal.usage.modelCalls + stagedCalls.length;
 				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);
@@ -5125,48 +5150,52 @@ const make = Effect.fnUntraced(function* (bindings) {
 				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({
+					const legacyGroup = yield* ModelUsageGroup.makeEffect({
 						provider: "unknown",
 						model: "legacy-record",
-						modelCalls: yield* addUsageTotal("byModel.modelCalls", existing?.modelCalls ?? 0, legacyCalls),
-						inputTokens: InputTokenUsage.make({
-							total: yield* addUsageTotal("byModel.inputTokens.total", existing?.inputTokens.total ?? 0, legacyInput),
-							uncached: yield* addUsageTotal("byModel.inputTokens.uncached", existing?.inputTokens.uncached ?? 0, legacyInput),
+						modelCalls: (existing?.modelCalls ?? 0) + legacyCalls,
+						inputTokens: {
+							total: (existing?.inputTokens.total ?? 0) + legacyInput,
+							uncached: (existing?.inputTokens.uncached ?? 0) + legacyInput,
 							cacheRead: existing?.inputTokens.cacheRead ?? 0,
 							cacheWrite: existing?.inputTokens.cacheWrite ?? 0
-						}),
-						outputTokens: OutputTokenUsage.make({
-							total: yield* addUsageTotal("byModel.outputTokens.total", existing?.outputTokens.total ?? 0, legacyOutput),
-							text: yield* addUsageTotal("byModel.outputTokens.text", existing?.outputTokens.text ?? 0, legacyOutput),
+						},
+						outputTokens: {
+							total: (existing?.outputTokens.total ?? 0) + legacyOutput,
+							text: (existing?.outputTokens.text ?? 0) + legacyOutput,
 							reasoning: existing?.outputTokens.reasoning ?? 0
-						}),
-						costMicrousd: yield* addUsageTotal("byModel.costMicrousd", existing?.costMicrousd ?? 0, legacyCost)
-					});
+						},
+						costMicrousd: (existing?.costMicrousd ?? 0) + legacyCost
+					}).pipe(Effect.mapError((cause) => RunJournalError.make({
+						message: "Run legacy usage exceeds safe-integer accounting bounds",
+						cause
+					})));
 					if (existingIndex < 0) byModel.push(legacyGroup);
 					else byModel[existingIndex] = legacyGroup;
 				}
-				const uncached = yield* addUsageTotal("inputTokens.uncached", detailed.inputTokens.uncached, legacyInput);
-				const text = yield* addUsageTotal("outputTokens.text", detailed.outputTokens.text, legacyOutput);
-				return RunUsageSummary.make({
+				return yield* RunUsageSummary.makeEffect({
 					...legacyCalls === 0 && detailed.webSearchCalls !== void 0 ? { webSearchCalls: detailed.webSearchCalls } : {},
 					modelCalls,
-					inputTokens: InputTokenUsage.make({
+					inputTokens: {
 						total: inputTokens,
-						uncached,
+						uncached: detailed.inputTokens.uncached + legacyInput,
 						cacheRead: detailed.inputTokens.cacheRead,
 						cacheWrite: detailed.inputTokens.cacheWrite
-					}),
-					outputTokens: OutputTokenUsage.make({
+					},
+					outputTokens: {
 						total: outputTokens,
-						text,
+						text: detailed.outputTokens.text + legacyOutput,
 						reasoning: detailed.outputTokens.reasoning
-					}),
+					},
 					costMicrousd,
 					byModel,
 					unobservedModelCalls,
 					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
-				});
+				}).pipe(Effect.mapError((cause) => RunJournalError.make({
+					message: "Run usage summary exceeds safe-integer accounting bounds",
+					cause
+				})));
 			});
 			const activeExecution = yield* reader.readExecution({
 				threadId: ctx.threadId,
@@ -5192,14 +5221,6 @@ const make = Effect.fnUntraced(function* (bindings) {
 					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;
-				}
-			}
 			/** 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). */
@@ -5232,13 +5253,14 @@ const make = Effect.fnUntraced(function* (bindings) {
 			};
 			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 recordHalt = (effect) => Effect.catchCause(effect, (cause) => {
+				const first = Cause.findErrorOption(cause);
+				const failure = Effect.failCause(Cause.map(cause, (error) => error instanceof ThreadStoreError && error.cause instanceof AgentPersistenceCapacityError ? error.cause : new CoordinatorHalt(error)));
+				return Option.isNone(first) || first.value instanceof ThreadStoreError && first.value.cause instanceof AgentPersistenceCapacityError ? failure : Effect.andThen(Ref.set(haltRef, first.value), failure);
+			});
+			const progress = progressWriters.get(ctx);
+			const checkProgress = progress === void 0 ? Effect.void : progress.check(runId).pipe(Effect.provideService(CurrentRunWriter, ctx));
+			const checkpoint = recordHalt(Effect.flatMap(Ref.get(haltRef), (failure) => failure === void 0 ? checkProgress : Effect.fail(failure)));
 			const responseGate = yield* Semaphore.make(1);
 			let deferredResponse;
 			const acceptResponseDeclarations = (batch) => {
@@ -5360,6 +5382,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 						cause
 					})));
 					yield* (yield* CurrentRunStart).commit(yield* makeEnvelope(recordId, payload));
+					knownIds.add(originalInput.record.recordId);
 					knownIds.add(runStartedRecordId(runId));
 					knownIds.add(recordId);
 					historyEvidence.clear();
@@ -5656,7 +5679,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 						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);
+					const coverable = sourceBoundaries.filter((boundary) => commit.kind !== "summarize" || boundary.sequence < originalInput.sequence);
 					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;
@@ -6321,12 +6344,12 @@ const make = Effect.fnUntraced(function* (bindings) {
 				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({
+			}) }), (body) => body.pipe(Effect.provideServiceEffect(ThreadHistory, ThreadHistory.makeFromStore), Effect.provideServiceEffect(Store, makeMemoryStore), Effect.scoped), Effect.provideContext(runServices.pipe(Context.add(SubagentHost.forTool, (source) => source.threadId !== submission.threadId || source.agentId !== submission.agentId || source.runId !== runId ? SubagentHost.unavailable : workerRuntime.facet({
 				source,
 				policy: agent.definition.policy,
 				depth: delegationDepth,
 				...inheritedGrant === 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" }));
+			}, submission.principal, submission.submissionId)), Context.add(MessagingHost.forTool, (source) => source.threadId !== submission.threadId || source.agentId !== submission.agentId || source.runId !== runId ? MessagingHost.unavailable : messagingRuntime.forTool(source, submission.principal)))), Effect.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);
@@ -6336,11 +6359,14 @@ const make = Effect.fnUntraced(function* (bindings) {
 					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) => {
+			const result = yield* Effect.raceAllFirst([
+				consume,
+				abortWatcher,
+				...yieldAfter === void 0 && submissionScheduling.yieldTo === void 0 ? [] : [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,
@@ -6428,17 +6454,25 @@ const make = Effect.fnUntraced(function* (bindings) {
 	* (Unknown Outcomes, or a durable approval suspension) — no settlement occurs and the
 	* obligation stays owed.
 	*/
-	const runAttempt = Effect.fnUntraced(function* (registeredAgent, session, resumeAfterRetention, onHandoff, yieldAfter) {
+	const runAttempt = Effect.fnUntraced(function* (registeredAgent, session, resumeAfterRetention, onHandoff, yieldAfter, freshlyAdmitted = false) {
 		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));
+		const checkpointPrompt = yield* promptHistory.take({ threadId: session.threadId }).pipe(Effect.provideService(ThreadStore, store), Effect.provideContext(journalServices));
 		let committedPromptSuffix;
 		const storageSession = session;
+		let pendingOriginal;
 		yield* Effect.addFinalizer(() => Effect.sync(() => {
 			committedPromptSuffix?.discard();
 			committedPromptSuffix = void 0;
 		}));
-		session = yield* withProgressSession({
+		const promptSession = {
 			...storageSession,
+			...storageSession.appendInput === void 0 ? {} : { appendInput: (batch, executions) => storageSession.appendInput(batch, executions).pipe(Effect.tap((result) => Effect.sync(() => {
+				if (pendingOriginal !== void 0 && !result.replayed && result.firstSequence === pendingOriginal.sequence) committedPromptSuffix = makeCommittedPromptSuffix({
+					threadId: storageSession.threadId,
+					sequence: result.firstSequence,
+					record: batch.records[0]
+				});
+			}))) },
 			append: (batch, executions) => {
 				const suffix = committedPromptSuffix;
 				const append = storageSession.append(batch, executions);
@@ -6456,12 +6490,70 @@ const make = Effect.fnUntraced(function* (bindings) {
 					replayed: result.replayed
 				}))), Effect.tapCause(() => Effect.sync(() => suffix.discard())));
 			}
-		});
+		};
+		session = yield* withProgressSession(promptSession, () => pendingOriginal);
 		const { claim, threadId } = session;
 		const submissionId = claim.submissionId;
-		const snapshot = yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId }));
+		let prepared = freshlyAdmitted && session.withInitialization !== void 0 ? yield* session.withInitialization(Effect.gen(function* () {
+			const snapshot = yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId }));
+			const submission = snapshot.submission;
+			if (submission.state !== "ready" || submission.workerAdmission !== void 0 || submission.messageAdmission !== void 0 || submission.parentLinkage !== void 0 || snapshot.inputApplied !== void 0 || snapshot.abortIntent !== void 0 || snapshot.approvalDecisions.length !== 0) return void 0;
+			yield* ensureThreadCreated$1(threadId, submission.agentId, submission.agentDigests);
+			yield* session.refresh;
+			const before = (yield* session.tail).sequence;
+			const view = yield* recoveryView(threadId, before, [submissionId], runIdForSubmission(submissionId));
+			if (view.progress !== void 0 || view.context !== void 0 || view.operational.length !== 0 || view.records.some(({ record }) => record.payload._tag !== "ThreadCreated")) return void 0;
+			if (session.appendInput !== void 0) {
+				const record = (yield* PreparedAppend.capture(AppendRequest.make({
+					threadId,
+					expectedTailSequence: before,
+					batch: CanonicalBatch.make({
+						batchId: submissionInputBatchId(submissionId),
+						producerId: config.producerId,
+						records: [yield* prepareOriginalInput(submission)]
+					})
+				}))).records[0].canonical;
+				if (!isOriginalInputRecord(record)) return yield* RunJournalError.make({ message: "Captured startup has no original input" });
+				pendingOriginal = {
+					threadId,
+					sequence: CanonicalSequence.make(before + 1),
+					record
+				};
+				return {
+					snapshot,
+					through: before,
+					view,
+					start: yield* makeRunStart(submission, Duration.toMillis(registeredAgent.definition.policy.maxDuration), view.records, view.operational, record).pipe(Effect.provideService(CurrentRunWriter, session)),
+					input: pendingOriginal
+				};
+			}
+			const progress = progressWriters.get(session);
+			const applyInput = applyCanonicalInput(session, submission, session, view.records, void 0);
+			yield* progress === void 0 ? applyInput : progress.withVerifiedEmptyRun(runIdForSubmission(submissionId), before, applyInput).pipe(Effect.provideService(CurrentRunWriter, promptSession));
+			const through = (yield* session.tail).sequence;
+			const added = yield* selectedRange(threadId, [submissionId], through, before);
+			const records = [...view.records, ...added];
+			const accepted = progressWriters.get(session)?.acceptedCheckpoint(runIdForSubmission(submissionId));
+			if (accepted === void 0 || accepted.throughSequence !== through || accepted.progress.runId !== runIdForSubmission(submissionId) || accepted.progress.submissionId !== submissionId) return void 0;
+			const start = yield* makeRunStart(submission, Duration.toMillis(registeredAgent.definition.policy.maxDuration), records, view.operational).pipe(Effect.provideService(CurrentRunWriter, session));
+			return {
+				snapshot,
+				through,
+				view: {
+					...view,
+					records,
+					progress: accepted.progress,
+					progressThrough: accepted.throughSequence,
+					operational: accepted.operational
+				},
+				start,
+				input: void 0
+			};
+		})) : void 0;
+		const preparedInput = prepared !== void 0;
+		const snapshot = prepared?.snapshot ?? (yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId })));
 		const submission = snapshot.submission;
-		yield* ensureThreadCreated$1(threadId, submission.agentId, submission.agentDigests);
+		if (prepared === void 0) yield* ensureThreadCreated$1(threadId, submission.agentId, submission.agentDigests);
 		if (submission.workerAdmission?.origin.reporting?.mode === "standard") yield* updateRuntime.repairRun(threadId, submissionId);
 		if (submission.workerAdmission !== void 0) yield* workerRuntime.ensureOrigin(submission.workerAdmission.origin).pipe(Effect.mapError((cause) => LedgerError.make({
 			operation: "worker-origin",
@@ -6469,10 +6561,11 @@ const make = Effect.fnUntraced(function* (bindings) {
 			cause
 		})));
 		if (submission.state === "admitted") yield* ledger.markReady(MarkReadyRequest.make({ submissionId }));
-		yield* session.refresh;
+		if (prepared === void 0) yield* session.refresh;
 		const ctx = session;
-		let controlThrough = (yield* session.tail).sequence;
-		const initialView = yield* recoveryView(threadId, controlThrough, [submissionId], runIdForSubmission(submissionId));
+		let controlThrough = prepared?.through ?? (yield* session.tail).sequence;
+		const initialThrough = controlThrough;
+		const initialView = prepared?.view ?? (yield* recoveryView(threadId, initialThrough, [submissionId], runIdForSubmission(submissionId)));
 		let journalMetadata;
 		const retainControl = controlRecords([submissionId]);
 		const collectControl = (record) => {
@@ -6523,8 +6616,8 @@ 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(), initialView.operational).pipe(Effect.provideService(CurrentRunWriter, ctx));
+		if (prepared === void 0) yield* applyCanonicalInput(ctx, submission, session, records, snapshot.inputApplied);
+		const start = prepared?.start ?? (yield* makeRunStart(submission, Duration.toMillis(agent.definition.policy.maxDuration), yield* refreshControl(), initialView.operational).pipe(Effect.provideService(CurrentRunWriter, ctx)));
 		const savedRunTiming = start.timing;
 		const commitStart = Effect.flatMap(CurrentRunStart, (publication) => publication.commit()).pipe(Effect.provideService(CurrentRunStart, start.publication));
 		const runTiming = workerOrigin === void 0 ? savedRunTiming : {
@@ -6532,13 +6625,17 @@ const make = Effect.fnUntraced(function* (bindings) {
 			deadline: DateTime.makeUnsafe(Math.min(DateTime.toEpochMillis(savedRunTiming.deadline), workerOrigin.expiresAtMillis))
 		};
 		let expiredChildObligation = false;
+		let preparedControl = prepared !== void 0;
 		if ((yield* Clock.currentTimeMillis) >= DateTime.toEpochMillis(runTiming.deadline)) {
+			prepared = void 0;
+			preparedControl = false;
 			yield* commitStart;
 			yield* reconcileRetainedChildren(ctx, submission, session);
 			expiredChildObligation = yield* completeJoinedReleases(submission);
 		}
 		const ordinaryCallsResolved = Effect.gen(function* () {
-			const reconciliationRecords = yield* refreshControl();
+			const reconciliationRecords = preparedControl ? records : yield* refreshControl();
+			preparedControl = false;
 			const reconciliationEvidence = yield* evidenceFor(reconciliationRecords, submissionId, true, snapshot.hostSubmissionId);
 			if (reconciliationEvidence.openToolCalls.length === 0) return true;
 			const reconciliationSnapshot = yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId }));
@@ -6555,7 +6652,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			return true;
 		});
 		if (!expiredChildObligation && !(yield* ordinaryCallsResolved)) return Option.none();
-		const continuationRecords = yield* refreshControl();
+		const continuationRecords = prepared === void 0 ? yield* refreshControl() : records;
 		const continuation = yield* pendingToolBatchFor(continuationRecords, runIdForSubmission(submissionId));
 		if (continuation !== void 0) {
 			const current = {
@@ -6626,21 +6723,23 @@ const make = Effect.fnUntraced(function* (bindings) {
 		}
 		const lineage = {
 			attemptId: claim.attemptId,
-			inputWasRecorded: evidence.inputRecorded
+			inputWasRecorded: !preparedInput && evidence.inputRecorded
 		};
 		let approvalDecisionIntents = snapshot.approvalDecisions;
 		while (true) {
-			yield* session.refresh;
+			const initialization = prepared;
+			prepared = void 0;
+			if (initialization === void 0) yield* session.refresh;
 			const tail = yield* session.tail;
-			const currentRecords = yield* refreshControl(tail.sequence);
-			const view = yield* recoveryView(threadId, tail.sequence, [submissionId], runIdForSubmission(submissionId), currentRecords);
+			const currentRecords = initialization === void 0 ? yield* refreshControl(tail.sequence) : records;
+			const view = initialization?.view ?? (yield* recoveryView(threadId, tail.sequence, [submissionId], runIdForSubmission(submissionId), currentRecords));
 			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);
+				const original = initialization?.input ?? currentRecords.find(({ record }) => record.payload._tag === "UserInputRecorded" && record.payload.kind === "user" && record.payload.submissionId === submissionId);
 				if (original === void 0) return yield* RunJournalError.make({ message: "Run has no exact original input context boundary" });
 				const suffix = currentRecords.filter((entry) => entry.sequence > original.sequence);
-				const fresh = !lineage.inputWasRecorded && tail.sequence === original.sequence && suffix.length === 0;
+				const fresh = initialization?.input !== void 0 || !lineage.inputWasRecorded && tail.sequence === original.sequence && suffix.length === 0;
 				const source = yield* Effect.gen(function* () {
 					if (checkpointPrompt !== void 0 && fresh && original.sequence === checkpointPrompt.through + 1) {
 						const records = [original, ...suffix];
@@ -6672,8 +6771,8 @@ const make = Effect.fnUntraced(function* (bindings) {
 				canonical = Stream.fromIterableEffect(Effect.suspend(() => source.records === void 0 ? readInitialJournal(source.original, source.suffix) : Effect.succeed(source.records)));
 			}
 			committedPromptSuffix?.discard();
-			committedPromptSuffix = initialJournal?.cacheable ? makeCommittedPromptSuffix(initialJournal.original) : void 0;
-			const outcome = yield* runModel(agent, ctx, submission, session, currentRecords, canonical, initialJournal, tail.sequence, view.progressThrough, view.progress, view.context, takeJournalMetadata(), lineage, approvalDecisionIntents, currentContracts, runTiming, yieldAfter).pipe(Effect.provideService(CurrentRunStart, start.publication), Effect.ensuring(Effect.sync(() => {
+			committedPromptSuffix = initialJournal?.cacheable && initialization?.input === void 0 ? makeCommittedPromptSuffix(initialJournal.original) : void 0;
+			const outcome = yield* runModel(agent, ctx, submission, session, currentRecords, canonical, initialJournal, initialization?.input?.sequence ?? tail.sequence, view.progressThrough, view.progress, view.context, takeJournalMetadata(), lineage, approvalDecisionIntents, currentContracts, runTiming, yieldAfter).pipe(Effect.provideService(CurrentRunStart, start.publication), Effect.ensuring(Effect.sync(() => {
 				if (initialJournal !== void 0) initialJournal.records = void 0;
 			})));
 			if (outcome._tag === "yielded") {
@@ -6762,6 +6861,8 @@ const make = Effect.fnUntraced(function* (bindings) {
 			if (Option.isNone(claimed)) return Option.none();
 			const session = claimed.value;
 			const { claim } = session;
+			const freshlyAdmitted = unclaimedAdmissions.get(claim.submissionId) === threadId;
+			unclaimedAdmissions.delete(claim.submissionId);
 			firstClaimedSubmissionId ??= claim.submissionId;
 			const attributes = {
 				threadId,
@@ -6800,7 +6901,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 					deferredSubmissionIds: [...handoff?.deferredSubmissionIds ?? [], claim.submissionId],
 					submissionId: nextSubmissionId
 				});
-			}, options?.yieldAfter), threadId, claim);
+			}, options?.yieldAfter, freshlyAdmitted), threadId, claim);
 		}));
 		while (true) {
 			resumeAfterRetention = false;
@@ -7393,7 +7494,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 			cause
 		})));
 	});
-	const recoverOwnedWork = Effect.fnUntraced(function* (request, recoveredAdmissions = /* @__PURE__ */ new Map()) {
+	const recoverOwnedWork = Effect.fnUntraced(function* (request, recoveredAdmissions = /* @__PURE__ */ new Map(), deferUnclaimedAdmissions = false) {
 		const { threadId, work: entry } = yield* Schema.decodeEffect(WorkRecoveryRequest)(request).pipe(Effect.mapError((cause) => ThreadStoreError.make({
 			operation: "recover work",
 			message: "Invalid selected work",
@@ -7420,7 +7521,10 @@ const make = Effect.fnUntraced(function* (bindings) {
 		});
 		if (owner._tag === "Admission") {
 			if (entry.id !== workId("admission", owner.submissionId) || entry.stateReference._tag !== "Submission" || entry.stateReference.submissionId !== owner.submissionId) return yield* invalid();
-			if ((yield* lookupKnownSubmission("recover work", owner.submissionId)).threadId !== threadId) return yield* invalid();
+			const original = yield* lookupKnownSubmission("recover work", owner.submissionId);
+			if (original.threadId !== threadId) return yield* invalid();
+			if (deferUnclaimedAdmissions && unclaimedAdmissions.get(owner.submissionId) === threadId && original.state === "ready" && !storageOwner.hasOwner(threadId) && (yield* ledger.readAbortIntent(AbortIntentRequest.make({ submissionId: owner.submissionId }))) === void 0) return report("deferred");
+			unclaimedAdmissions.delete(owner.submissionId);
 			const submission = yield* recoverAdmission(owner.submissionId);
 			return report(submission.disposition, submission);
 		}
@@ -7626,6 +7730,16 @@ const make = Effect.fnUntraced(function* (bindings) {
 			let complete = false;
 			let phase = "history";
 			const outcome = yield* isolateRecovery(Effect.gen(function* () {
+				if (workCursor === void 0 && options?.deferUnclaimedAdmissions === true && workDiscovery.isOnlyFreshAdmission !== void 0 && !storageOwner.hasOwner(threadId)) {
+					const fresh = [...unclaimedAdmissions].find(([, owner]) => owner === threadId);
+					if (fresh !== void 0 && (yield* workDiscovery.isOnlyFreshAdmission({
+						threadId,
+						submissionId: fresh[0]
+					}))) {
+						complete = true;
+						return;
+					}
+				}
 				for (let pages = 0; pages < 8 && workReports.length < 32; pages++) {
 					phase = "history";
 					const workPage = yield* discoverWork({
@@ -7638,7 +7752,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 						const repaired = yield* recoverOwnedWork({
 							threadId,
 							work
-						}, recoveredAdmissions);
+						}, recoveredAdmissions, options?.deferUnclaimedAdmissions === true);
 						workReports.push(repaired);
 						if (repaired.submission !== void 0 && !reportedAdmissions.has(repaired.submission.submissionId)) {
 							reportedAdmissions.add(repaired.submission.submissionId);
@@ -7745,7 +7859,7 @@ const make = Effect.fnUntraced(function* (bindings) {
 				queueSequence: admitted.queueSequence
 			});
 		}
-		const admitted = yield* ledger.admit(request);
+		const admitted = yield* ledger.admit(request, { readyIfInitialized: true });
 		yield* hit("submit:after-admit");
 		const receipt = Receipt.make({
 			receiptId: admitted.receiptId,
@@ -7754,10 +7868,19 @@ const make = Effect.fnUntraced(function* (bindings) {
 			queueSequence: admitted.queueSequence
 		});
 		if (admitted.replayed && admitted.state !== "admitted") return receipt;
-		yield* materializeThread(options.threadId);
-		yield* ensureThreadCreated$1(options.threadId, agent.definition.id, options.definitions);
-		yield* hit("submit:after-materialize");
-		yield* ledger.markReady(MarkReadyRequest.make({ submissionId: admitted.submissionId }));
+		if (admitted.state === "admitted") {
+			yield* materializeThread(options.threadId);
+			yield* ensureThreadCreated$1(options.threadId, agent.definition.id, options.definitions);
+			yield* hit("submit:after-materialize");
+			yield* ledger.markReady(MarkReadyRequest.make({ submissionId: admitted.submissionId }));
+		}
+		if (!admitted.replayed && messageAdmission === void 0 && options.workerAdmission === void 0) {
+			unclaimedAdmissions.set(admitted.submissionId, options.threadId);
+			if (unclaimedAdmissions.size > 128) {
+				const oldest = unclaimedAdmissions.keys().next().value;
+				if (oldest !== void 0) unclaimedAdmissions.delete(oldest);
+			}
+		}
 		yield* wake.notify(options.threadId);
 		return receipt;
 	});
@@ -8371,4 +8494,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-CBBjRNJN.mjs.map
+//# sourceMappingURL=DurableAgentRuntime-BJbuIqQq.mjs.map