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

package/dist/{RunContinuation-DHYNAQFi.mjs → RunContinuation-BiyKJK32.mjs}

@@ -2,13 +2,12 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { ToolCallId } from "./core/Identifiers.mjs";
 import { n as utf8ByteLength } from "./utf8-B5pAmhTo.mjs";
 import { AgentPersistenceCapacityError } from "./core/AgentError.mjs";
-import { summarizeModelUsage } from "./core/Usage.mjs";
-import { G as PromptRecord, J as RUN_TERMINAL_RESERVE_BYTES, O as MAX_RUN_CONTINUATION_BYTES, V as PROMPT_EVIDENCE_TAGS, X as RecordEnvelope, Z as RecordId, c as CanonicalBatch, f as CanonicalSequence, it as RunContinuation, rt as RunContextRecorded, w as MAX_PERSISTED_JSON_BYTES, x as EvidenceReference } from "./Records-BiuJDWNe.mjs";
-import { i as digestCanonicalJson, r as canonicalJson } from "./Digest-DCuPlhNk.mjs";
+import { G as PromptRecord, J as RUN_TERMINAL_RESERVE_BYTES, O as MAX_RUN_CONTINUATION_BYTES, V as PROMPT_EVIDENCE_TAGS, X as RecordEnvelope, Z as RecordId, c as CanonicalBatch, f as CanonicalSequence, it as RunContinuation, rt as RunContextRecorded, w as MAX_PERSISTED_JSON_BYTES, x as EvidenceReference } from "./Records-DzL4Kbtw.mjs";
+import { i as digestCanonicalJson, r as canonicalJson } from "./Digest-C3EODOee.mjs";
 import { submissionAbortRecordId, submissionInputRecordId, submissionSettlementBatchId, submissionSettlementRecordId } from "./durable/SubmissionLedger.mjs";
-import { I as toolCallResultBatchId, Q as toolCallSettledRecordId, g as projectRunJournalStream, j as subagentStartedRecordId, k as subagentRequestedRecordId, t as RunJournalError, v as runCompletedRecordId, x as runIdForSubmission } from "./RunJournal-kfKVxJj7.mjs";
-import { U as ThreadReader, X as ThreadStoreError, _t as isPreContinuationFact, a as CommitBatch, bt as terminalUsageCharge, c as ExecutionUpdate, gt as executionRunIds, ht as canonicalRunIds, mt as recordEncoding, o as ExecutionCheckpoint, ot as getRecord, pt as captureRecord, st as getRunInput, vt as isTerminalBudgetFact, yt as isWorkHandoff } from "./ThreadStore-CEekRa80.mjs";
-import { Context, Crypto, DateTime, Effect, Layer, Option, Schema, Semaphore, Stream } from "effect";
+import { A as subagentRequestedRecordId, L as toolCallResultBatchId, M as subagentStartedRecordId, Q as continuationUsage, S as runIdForSubmission, _ as projectRunJournalStream, et as toolCallSettledRecordId, t as RunJournalError, y as runCompletedRecordId } from "./RunJournal-CPMKcfd0.mjs";
+import { U as ThreadReader, X as ThreadStoreError, _t as isPreContinuationFact, a as CommitBatch, bt as terminalUsageCharge, c as ExecutionUpdate, gt as executionRunIds, ht as canonicalRunIds, mt as recordEncoding, o as ExecutionCheckpoint, ot as getRecord, pt as captureRecord, st as getRunInput, vt as isTerminalBudgetFact, yt as isWorkHandoff } from "./ThreadStore-EuUilthA.mjs";
+import { Context, DateTime, Effect, Layer, Option, Result, Schema, Semaphore, Stream } from "effect";
 import { Prompt } from "effect/ai";
 //#region src/durable/internal/evidence.ts
 const failure$1 = (message, cause) => ThreadStoreError.make({
@@ -173,33 +172,74 @@ const failure = (message, cause) => ThreadStoreError.make({
 const capacityFailure = (message) => failure(message, AgentPersistenceCapacityError.make({ message }));
 const isExecutionProgressRecord = (record) => record.payload._tag === "RunContinuation";
 const decodeResponsePrompt = Schema.decodeUnknownEffect(Prompt.Prompt);
-const validateBatchHeader = Schema.decodeSync(Schema.Struct({
+const responsePrompts = /* @__PURE__ */ new WeakMap();
+/** Cache eligibility only: freezing does not make accessors or custom iterators immutable. */
+const isFrozenJsonData = (input) => {
+	const pending = [input];
+	const seen = /* @__PURE__ */ new WeakSet();
+	while (pending.length > 0) {
+		const value = pending.pop();
+		if (value === null) continue;
+		if (typeof value !== "object") {
+			if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") return false;
+			continue;
+		}
+		if (seen.has(value)) continue;
+		seen.add(value);
+		const prototype = Object.getPrototypeOf(value);
+		if (!Object.isFrozen(value) || prototype !== null && prototype !== Object.prototype && prototype !== Array.prototype) return false;
+		for (const key of Reflect.ownKeys(value)) {
+			if (typeof key !== "string") return false;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor === void 0 || !("value" in descriptor)) return false;
+			pending.push(descriptor.value);
+		}
+	}
+	return true;
+};
+const validateBatchShape = Schema.decodeUnknownSync(Schema.Struct({
 	batchId: CanonicalBatch.fields.batchId,
-	producerId: CanonicalBatch.fields.producerId
+	producerId: CanonicalBatch.fields.producerId,
+	records: Schema.NonEmptyArray(Schema.Unknown).check(Schema.isMaxLength(256))
 }));
-const validateBatchCount = Schema.decodeUnknownSync(Schema.NonEmptyArray(Schema.Unknown).check(Schema.isMaxLength(256)));
 const ContinuationBytes = Schema.Struct({
 	turnBytes: RunContinuation.fields.turnBytes,
 	terminalBytes: RunContinuation.fields.terminalBytes
 });
+const decodeExecutionFrontier = Schema.decodeUnknownEffect(Schema.Struct({
+	canonicalRecords: ExecutionCheckpoint.fields.canonicalRecords,
+	throughSequence: ExecutionCheckpoint.fields.throughSequence
+}));
 /** One private snapshot for every retry; callers cannot change facts while awaiting the gate. */
 const captureFacts = (batch) => Effect.try({
-	try: () => {
-		const header = validateBatchHeader(batch);
-		validateBatchCount(batch.records);
-		const records = batch.records.map((record) => captureRecord(record).canonical);
-		return Object.freeze(new CanonicalBatch({
-			...header,
+	try: () => Result.gen(function* () {
+		const inputs = batch.records;
+		const { batchId, producerId } = validateBatchShape({
+			batchId: batch.batchId,
+			producerId: batch.producerId,
+			records: inputs
+		});
+		const records = (yield* Result.all(inputs.map(captureRecord))).map((record) => record.canonical);
+		return Object.freeze(CanonicalBatch.make({
+			batchId,
+			producerId,
 			records: [records[0], ...records.slice(1)]
 		}, { disableChecks: true }));
-	},
+	}),
 	catch: (cause) => failure("Cannot capture canonical progress facts", cause)
-});
+}).pipe(Effect.flatMap(Effect.fromResult), Effect.mapError((cause) => Schema.is(ThreadStoreError)(cause) ? cause : failure("Cannot capture canonical progress facts", cause)));
 /** Exact UTF-8 wire accounting reuses the append's privately captured Schema encoding. */
-const canonicalRecordBytes = (record) => recordEncoding(record).bytes;
+const canonicalRecordBytes = (record) => {
+	const encoded = recordEncoding(record);
+	if (Result.isFailure(encoded)) throw encoded.failure.cause ?? new RangeError(encoded.failure.message);
+	return encoded.success.bytes;
+};
 /** Capture before acquiring the mutation owner; summaries never cross a wire boundary. */
-const prepareProgressAppend = (records) => Object.freeze(records.map((record) => captureRecord(record).progress));
-const factUsageCharge = (facts) => facts.reduce((bytes, record) => bytes + recordEncoding(record).progress.terminalUsageBytes, 0);
+const prepareProgressAppend = (records) => {
+	const encodings = Result.all(records.map(captureRecord));
+	if (Result.isFailure(encodings)) throw encodings.failure.cause ?? new RangeError(encodings.failure.message);
+	return Object.freeze(encodings.success.map((record) => record.progress));
+};
 /** These values belong to the active Run, not its permanent conversation history. */
 const isOperationalRecord = ({ payload }) => payload._tag === "RunStarted" || payload._tag === "RunContextRecorded" || payload._tag === "RunCompleted";
 const readContinuation = Effect.fnUntraced(function* (threadId, runId, throughSequence) {
@@ -414,34 +454,55 @@ const advanceFacts = Effect.fnUntraced(function* (previous, facts, submissionId,
 	let results = new Map(previous?.results);
 	let childResults = new Map(previous?.childResults);
 	let completionBytes = previous?.completionBytes;
+	let factBytes = 0;
+	let turn = previous?.continuation.turn ?? 1;
+	let usageCharge = 0;
+	let closingBytes = 0;
+	let closingCount = 0;
 	for (const fact of facts) {
 		const payload = fact.payload;
+		const captured = recordEncoding(fact);
+		if (Result.isFailure(captured)) return yield* failure("Cannot account canonical progress facts", captured.failure);
+		const encoded = captured.success;
+		factBytes += encoded.bytes;
+		if ("turn" in payload) turn = Math.max(turn, payload.turn);
+		usageCharge += encoded.progress.terminalUsageBytes;
+		if (encoded.progress.terminal) {
+			closingBytes += encoded.bytes;
+			closingCount++;
+		}
 		switch (payload._tag) {
 			case "RunStarted":
 				position = "awaiting-model";
 				break;
 			case "RunContextRecorded":
 				if (savedContext !== void 0) return yield* failure("A Run's original context cannot be replaced");
-				savedContext = yield* reference(fact);
+				savedContext = EvidenceReference.make({ recordId: fact.recordId });
 				position = "awaiting-model";
 				break;
 			case "ModelResponseRecorded": {
 				if (savedContext === void 0) return yield* failure("A model response has no saved original Run context");
 				if (payload.turn !== accounting.committedTurns + 1) return yield* failure("Canonical Turn progress must advance once");
-				const messages = yield* decodeResponsePrompt(payload.messages).pipe(Effect.mapError((cause) => failure("Invalid model evidence", cause)));
+				const promptInput = payload.messages;
+				const retainedPrompt = responsePrompts.get(payload);
+				const messages = retainedPrompt ?? (yield* decodeResponsePrompt(promptInput).pipe(Effect.mapError((cause) => failure("Invalid model evidence", cause))));
+				if (retainedPrompt === void 0) {
+					const property = Object.getOwnPropertyDescriptor(payload, "messages");
+					if (Object.isFrozen(payload) && property !== void 0 && "value" in property && property.value === promptInput && isFrozenJsonData(promptInput)) responsePrompts.set(payload, messages);
+				}
 				responsePrompt = messages;
 				const calls = messages.content.flatMap((message) => message.role === "assistant" ? message.content.filter((part) => part.type === "tool-call") : []);
-				const summary = payload.modelUsage === void 0 ? void 0 : yield* summarizeModelUsage(payload.modelUsage).pipe(Effect.mapError((cause) => failure("Invalid usage evidence", cause)));
+				const summary = payload.modelUsage === void 0 ? void 0 : yield* continuationUsage(payload.modelUsage).pipe(Effect.mapError((cause) => failure("Invalid usage evidence", cause)));
 				accounting.committedTurns = payload.turn;
 				accounting.toolCalls += calls.length;
 				accounting.modelCalls += summary?.modelCalls ?? 1;
-				accounting.inputTokens += summary?.inputTokens.total ?? payload.inputTokens ?? 0;
-				accounting.outputTokens += summary?.outputTokens.total ?? payload.outputTokens ?? 0;
+				accounting.inputTokens += summary?.inputTokens ?? payload.inputTokens ?? 0;
+				accounting.outputTokens += summary?.outputTokens ?? payload.outputTokens ?? 0;
 				accounting.costMicrousd += summary?.costMicrousd ?? payload.costMicrousd ?? 0;
-				accounting.lastInputTokens = summary?.inputTokens.total ?? payload.inputTokens ?? 0;
-				accounting.lastOutputTokens = summary?.outputTokens.total ?? payload.outputTokens ?? 0;
+				accounting.lastInputTokens = summary?.inputTokens ?? payload.inputTokens ?? 0;
+				accounting.lastOutputTokens = summary?.outputTokens ?? payload.outputTokens ?? 0;
 				accounting.unobservedModelCalls += payload.unobservedModelCalls ?? 0;
-				latestResponse = yield* reference(fact);
+				latestResponse = EvidenceReference.make({ recordId: fact.recordId });
 				response = payload;
 				results = /* @__PURE__ */ new Map();
 				childResults = /* @__PURE__ */ new Map();
@@ -490,11 +551,11 @@ const advanceFacts = Effect.fnUntraced(function* (previous, facts, submissionId,
 				break;
 			case "ModelCallAborted": {
 				if (payload.restart !== (accounting.modelRestarts ?? 0) + 1) return yield* failure("Model restart progress must advance once");
-				const summary = yield* summarizeModelUsage(payload.modelUsage).pipe(Effect.mapError((cause) => failure("Invalid cancelled model usage", cause)));
+				const summary = yield* continuationUsage(payload.modelUsage).pipe(Effect.mapError((cause) => failure("Invalid cancelled model usage", cause)));
 				accounting.modelRestarts = payload.restart;
 				accounting.modelCalls += summary.modelCalls;
-				accounting.inputTokens += summary.inputTokens.total;
-				accounting.outputTokens += summary.outputTokens.total;
+				accounting.inputTokens += summary.inputTokens;
+				accounting.outputTokens += summary.outputTokens;
 				accounting.costMicrousd += summary.costMicrousd;
 				accounting.unobservedModelCalls += payload.unobservedModelCalls;
 				break;
@@ -502,12 +563,12 @@ const advanceFacts = Effect.fnUntraced(function* (previous, facts, submissionId,
 			case "RunCompleted":
 			case "RunFailed":
 				completionBytes = payload._tag === "RunCompleted" ? utf8ByteLength(JSON.stringify(payload.output)) + (payload.runDisposition === void 0 ? 0 : utf8ByteLength(JSON.stringify(payload.runDisposition))) : void 0;
-				terminal = yield* reference(fact);
+				terminal = EvidenceReference.make({ recordId: fact.recordId });
 				position = "settling";
 				break;
 			case "SubmissionSettled":
 				if (payload.submissionId !== submissionId) break;
-				terminal = yield* reference(fact);
+				terminal = EvidenceReference.make({ recordId: fact.recordId });
 				position = "settled";
 				if (payload.usageSummary !== void 0) {
 					accounting.modelCalls = payload.usageSummary.modelCalls;
@@ -519,7 +580,7 @@ const advanceFacts = Effect.fnUntraced(function* (previous, facts, submissionId,
 		}
 	}
 	if (response !== void 0 && response.turn > accounting.accountedToolTurn && response.toolOperations.every((operation) => results.has(operation.toolCallId))) {
-		const parts = (responsePrompt ?? (yield* decodeResponsePrompt(response.messages).pipe(Effect.mapError((cause) => failure("Invalid batch evidence", cause))))).content.flatMap((message) => message.role === "assistant" ? message.content : []);
+		const parts = (responsePrompt ?? responsePrompts.get(response) ?? (yield* decodeResponsePrompt(response.messages).pipe(Effect.mapError((cause) => failure("Invalid batch evidence", cause))))).content.flatMap((message) => message.role === "assistant" ? message.content : []);
 		for (const call of parts) {
 			if (call.type !== "tool-call") continue;
 			const result = call.providerExecuted ? parts.find((part) => part.type === "tool-result" && part.id === call.id) : results.get(ToolCallId.make(call.id));
@@ -534,12 +595,8 @@ const advanceFacts = Effect.fnUntraced(function* (previous, facts, submissionId,
 	if (last === void 0) return yield* failure("Progress has no owning fact");
 	if (previous?.continuation.position === "settled") position = "settled";
 	else if (previous?.continuation.position === "settling" && position !== "settled") position = "settling";
-	const factBytes = facts.reduce((bytes, fact) => bytes + canonicalRecordBytes(fact), 0);
-	const turn = facts.reduce((current, fact) => "turn" in fact.payload ? Math.max(current, fact.payload.turn) : current, previous?.continuation.turn ?? 1);
 	const turnBase = (previous?.continuation.turn === turn ? previous.continuation.turnBytes : initialBytes) + factBytes;
-	const usageCharge = factUsageCharge(facts);
 	const terminalUsageBytes = (previous?.continuation.terminalUsageBytes ?? 0) + usageCharge;
-	const closing = facts.filter(isTerminalBudgetFact);
 	return {
 		accounting,
 		savedContext,
@@ -556,9 +613,9 @@ const advanceFacts = Effect.fnUntraced(function* (previous, facts, submissionId,
 		turnBase,
 		usageCharge,
 		terminalUsageBytes,
-		terminalBytes: (previous?.continuation.terminalBytes ?? 0) + closing.reduce((bytes, fact) => bytes + canonicalRecordBytes(fact), 0),
-		terminalRecords: (previous?.continuation.terminalRecords ?? 0) + closing.length,
-		closing: closing.length > 0
+		terminalBytes: (previous?.continuation.terminalBytes ?? 0) + closingBytes,
+		terminalRecords: (previous?.continuation.terminalRecords ?? 0) + closingCount,
+		closing: closingCount > 0
 	};
 });
 /**
@@ -598,15 +655,13 @@ const verifyRunContinuations = Effect.fnUntraced(function* (records, options) {
 */
 const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId) {
 	const reader = yield* ThreadReader;
-	const crypto = yield* Crypto.Crypto;
 	const gate = yield* Semaphore.make(1);
 	const cached = /* @__PURE__ */ new Map();
+	let verifiedEmpty;
 	const reservations = /* @__PURE__ */ new Map();
 	const stagedUsage = /* @__PURE__ */ new Map();
-	const provide = (effect) => effect.pipe(Effect.provideService(ThreadReader, reader), Effect.provideService(Crypto.Crypto, crypto));
-	const loadState = Effect.fnUntraced(function* (runId, after) {
-		const retained = cached.get(runId);
-		if (retained !== void 0) return retained;
+	const provide = (effect) => Effect.provideService(effect, ThreadReader, reader);
+	const loadUncachedState = Effect.fnUntraced(function* (runId, after) {
 		const loaded = yield* provide(readContinuation(threadId, runId, after));
 		if (Option.isNone(loaded)) return void 0;
 		const continuation = loaded.value.continuation;
@@ -663,10 +718,10 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 			...completionBytes === void 0 ? {} : { completionBytes }
 		};
 	});
-	const checkFutureShapes = (state) => {
+	const checkFutureShapes = (state, cursorBytes) => {
 		const progress = state.continuation;
 		if (progress.position === "settled") return Effect.void;
-		const size = canonicalRecordBytes(state.record);
+		const size = cursorBytes ?? canonicalRecordBytes(state.record);
 		const textBytes = (value) => utf8ByteLength(JSON.stringify(value));
 		const refBytes = (value) => utf8ByteLength(JSON.stringify(value));
 		const ref = (recordId) => EvidenceReference.make({ recordId });
@@ -698,12 +753,9 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 		if (turnBytes > 4194304 || recordBytes > 33554432 || recordCount > 16384) return Effect.fail(failure("Run has no remaining canonical dispatch capacity", AgentPersistenceCapacityError.make({ message: "Run has no room for the next result and a bounded terminal settlement" })));
 		return Effect.void;
 	};
-	const prepare = Effect.fnUntraced(function* (batch, after) {
+	const prepare = Effect.fnUntraced(function* (batch, after, mode = "commit") {
 		if (batch.records.some((record) => record.payload._tag === "RunContinuation")) return yield* failure("A caller cannot supply interpreter progress to the progress writer");
-		const ownedRecords = yield* Effect.try({
-			try: () => batch.records.map((record) => captureRecord(record).canonical),
-			catch: (cause) => failure("Cannot capture canonical progress facts", cause)
-		});
+		const ownedRecords = [...batch.records];
 		const groups = /* @__PURE__ */ new Map();
 		for (const record of ownedRecords) for (const runId of executionRunIds(record)) {
 			const facts = groups.get(runId) ?? [];
@@ -712,8 +764,10 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 		}
 		const executions = [];
 		const accepted = /* @__PURE__ */ new Map();
+		let executionCount = 0;
 		for (const [runId, facts] of groups) {
-			const previous = yield* loadState(runId, after);
+			const empty = verifiedEmpty?.runId === runId && verifiedEmpty.through === after && verifiedEmpty.writer === Option.getOrUndefined(yield* Effect.serviceOption(CurrentRunWriter));
+			const previous = empty ? void 0 : cached.get(runId) ?? (yield* loadUncachedState(runId, after));
 			let original = facts.find((record) => record.payload._tag === "UserInputRecorded" && record.payload.kind === "user" && record.payload.runId === runId && record.payload.submissionId !== void 0);
 			let originalCount = 0;
 			let initialBytes = 0;
@@ -731,7 +785,7 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 			if (submissionId === void 0) return yield* failure("Run progress has no original admission identity");
 			if (runId !== runIdForSubmission(submissionId)) return yield* failure("Run progress conflicts with its original admission");
 			if (previous === void 0 && original === void 0) return yield* failure("Run has no accepted original input");
-			if (previous === void 0) {
+			if (previous === void 0 && !empty) {
 				const settled = yield* provide(getRecord({
 					threadId,
 					recordId: submissionSettlementRecordId(submissionId)
@@ -747,18 +801,18 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 				const fact = facts[index];
 				const payload = fact.payload;
 				if (payload._tag !== "SubmissionSettled" || payload.runId !== runId) continue;
-				const retained = captureRecord(RecordEnvelope.make({
+				const retained = yield* Effect.fromResult(captureRecord(RecordEnvelope.make({
 					...fact,
 					payload: {
 						...payload,
 						historyRecordCount: canonicalRecords
 					}
-				})).canonical;
+				}))).pipe(Effect.map((record) => record.canonical), Effect.mapError((cause) => failure("Cannot capture canonical progress facts", cause)));
 				facts[index] = retained;
 				ownedRecords[ownedRecords.indexOf(fact)] = retained;
 			}
-			const originalInput = previous !== void 0 ? previous.continuation.originalInput : original === void 0 ? yield* failure("Run progress has no original input") : yield* provide(reference(original));
-			const next = yield* provide(advanceFacts(previous, facts, submissionId, initialBytes));
+			const originalInput = previous !== void 0 ? previous.continuation.originalInput : original === void 0 ? yield* failure("Run progress has no original input") : EvidenceReference.make({ recordId: original.recordId });
+			const next = yield* advanceFacts(previous, facts, submissionId, initialBytes);
 			const { accounting, savedContext, latestResponse, terminal, position, response, results, childResults, completionBytes, last, factBytes, turn, turnBase, usageCharge, terminalUsageBytes } = next;
 			let continuation = yield* RunContinuation.makeEffect({
 				version: 1,
@@ -776,7 +830,7 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 				...savedContext === void 0 ? {} : { savedContext },
 				...latestResponse === void 0 ? {} : { latestResponse },
 				...terminal === void 0 ? {} : { terminal },
-				lastFact: yield* provide(reference(last)),
+				lastFact: EvidenceReference.make({ recordId: last.recordId }),
 				position,
 				accounting
 			}).pipe(Effect.mapError(() => capacityFailure("Canonical continuation exceeds its protocol bounds")));
@@ -813,22 +867,42 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 				turnBytes,
 				terminalBytes
 			}).pipe(Effect.mapError(() => capacityFailure("Turn exceeds its incremental canonical byte budget")));
-			continuation = new RunContinuation({
+			continuation = RunContinuation.make({
 				...continuation,
 				...checkedBytes
 			}, { disableChecks: true });
-			const record = captureRecord(new RecordEnvelope({
+			const proposedRecord = RecordEnvelope.make({
 				...header,
 				payload: continuation
-			}, { disableChecks: true })).canonical;
+			}, { disableChecks: true });
+			const cursorBytes = turnBytes - turnBase;
+			if (cursorBytes > 8192) return yield* capacityFailure("Encoded continuation exceeds 8192 bytes including its envelope");
+			executionCount++;
+			if (mode === "preflight" && previous?.checkpoint !== void 0 && facts.every(({ payload }) => payload._tag === "ModelResponseRecorded")) {
+				yield* decodeExecutionFrontier({
+					canonicalRecords,
+					throughSequence: after + ownedRecords.filter((fact) => !isOperationalRecord(fact)).length
+				}).pipe(Effect.mapError((cause) => failure("Active execution exceeds its bounds", cause)));
+				const state = {
+					continuation,
+					record: proposedRecord,
+					...response === void 0 ? {} : { response },
+					results,
+					childResults,
+					...completionBytes === void 0 ? {} : { completionBytes }
+				};
+				yield* checkCapacity(state, new Set(batch.records.map(({ recordId }) => recordId)), void 0, usageCharge);
+				yield* checkFutureShapes(state, cursorBytes);
+				continue;
+			}
+			const record = yield* Effect.fromResult(captureRecord(proposedRecord)).pipe(Effect.map((record) => record.canonical), Effect.mapError((cause) => failure("Cannot capture canonical progress facts", cause)));
 			if (!isExecutionProgressRecord(record)) return yield* failure("Captured execution has no Run continuation");
-			if (canonicalRecordBytes(record) !== turnBytes - turnBase) return yield* failure("Continuation byte accounting differs from its Schema encoding");
-			if (canonicalRecordBytes(record) > 8192) return yield* capacityFailure("Encoded continuation exceeds 8192 bytes including its envelope");
+			if (canonicalRecordBytes(record) !== cursorBytes) return yield* failure("Continuation byte accounting differs from its Schema encoding");
 			const operational = new Map((previous?.checkpoint?.operational ?? []).map((fact) => [fact.recordId, fact]));
 			const changed = facts.filter(isOperationalRecord);
 			for (const fact of changed) {
 				const prior = operational.get(fact.recordId);
-				if (prior !== void 0 && recordEncoding(prior).json !== recordEncoding(fact).json) return yield* failure("An active Run fact cannot change after becoming durable");
+				if (prior !== void 0 && (yield* Effect.fromResult(recordEncoding(prior)).pipe(Effect.mapError((cause) => failure("Cannot encode active Run fact", cause)))).json !== (yield* Effect.fromResult(recordEncoding(fact)).pipe(Effect.mapError((cause) => failure("Cannot encode active Run fact", cause)))).json) return yield* failure("An active Run fact cannot change after becoming durable");
 				operational.set(fact.recordId, fact);
 			}
 			const checkpoint = yield* ExecutionCheckpoint.makeEffect({
@@ -859,9 +933,9 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 			}));
 			accepted.set(runId, state);
 		}
-		if (ownedRecords.length + executions.length > 256) return yield* failure("Progress and facts exceed the atomic batch bound");
+		if (ownedRecords.length + executionCount > 256) return yield* failure("Progress and facts exceed the atomic batch bound");
 		return {
-			batch: new CommitBatch({
+			batch: CommitBatch.make({
 				...batch,
 				records: ownedRecords.filter((fact) => !isOperationalRecord(fact))
 			}, { disableChecks: true }),
@@ -877,11 +951,7 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 			}
 		};
 	});
-	const tail = Effect.gen(function* () {
-		const writer = yield* CurrentRunWriter;
-		if (writer.threadId !== threadId) return yield* failure("Progress writer belongs to another Thread");
-		return (yield* writer.tail).sequence;
-	});
+	const tail = Effect.flatMap(CurrentRunWriter, (writer) => writer.threadId !== threadId ? Effect.fail(failure("Progress writer belongs to another Thread")) : Effect.map(writer.tail, (position) => position.sequence));
 	const commitCaptured = Effect.fnUntraced(function* (batch) {
 		const writer = yield* CurrentRunWriter;
 		for (let retries = 0;; retries++) {
@@ -925,7 +995,7 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 		const after = yield* tail;
 		yield* prepare(yield* captureFacts(probe), after);
 		const recordId = probe.records[0].recordId;
-		const state = yield* loadState(runId, after);
+		const state = cached.get(runId) ?? (yield* loadUncachedState(runId, after));
 		if (state === void 0) return yield* failure("Dispatch has no canonical Run progress");
 		if (reservations.has(recordId)) return yield* failure("Dispatch capacity is already reserved");
 		yield* checkCapacity(state, /* @__PURE__ */ new Set(), {
@@ -946,10 +1016,10 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 	const defer = (batch) => gate.withPermits(1)(Effect.gen(function* () {
 		const after = yield* tail;
 		const owned = yield* captureFacts(batch);
-		yield* prepare(owned, after);
+		yield* prepare(owned, after, "preflight");
 		const response = owned.records.find((record) => record.payload._tag === "ModelResponseRecorded");
 		if (response === void 0 || response.payload._tag !== "ModelResponseRecorded") return yield* failure("Deferred dispatch has no response");
-		const progress = yield* loadState(response.payload.runId, after);
+		const progress = cached.get(response.payload.runId) ?? (yield* loadUncachedState(response.payload.runId, after));
 		if (progress === void 0) return yield* failure("Deferred dispatch has no Run progress");
 		const pending = resultCapacity({
 			...progress,
@@ -979,11 +1049,16 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 		});
 		return owned;
 	}));
-	const check = (runId) => gate.withPermits(1)(Effect.gen(function* () {
-		const state = yield* loadState(runId, yield* tail);
-		if (state === void 0) return yield* failure("Execution has no canonical Run progress");
-		if (cached.get(runId) !== state) yield* checkFutureShapes(state);
-		if (state.continuation.position !== "settling" && state.continuation.position !== "settled") yield* checkCapacity(state);
+	const checkState = (state, recovered) => {
+		if (state === void 0) return Effect.fail(failure("Execution has no canonical Run progress"));
+		const capacity = () => state.continuation.position === "settling" || state.continuation.position === "settled" ? Effect.void : checkCapacity(state);
+		return recovered ? Effect.andThen(checkFutureShapes(state), capacity) : capacity();
+	};
+	const check = (runId) => gate.withPermits(1)(Effect.flatMap(CurrentRunWriter, (writer) => {
+		if (writer.threadId !== threadId) return Effect.fail(failure("Progress writer belongs to another Thread"));
+		const retained = cached.get(runId);
+		if (retained !== void 0) return checkState(retained, false);
+		return Effect.flatMap(writer.tail, (position) => Effect.flatMap(loadUncachedState(runId, position.sequence), (state) => checkState(state, true)));
 	}));
 	return {
 		commit,
@@ -991,6 +1066,22 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 		reserve,
 		defer,
 		check,
+		/** Internal read view immediately after this writer's acknowledged commit, while
+		* holding its initialization gates. Never authority across ownership or writes. */
+		acceptedCheckpoint: (runId) => cached.get(runId)?.checkpoint,
+		/** Scope a verified empty execution/evidence view to one owned initialization body.
+		* The caller holds progress+mutation gates; a changed writer or tail never reuses it. */
+		withVerifiedEmptyRun: (runId, through, body) => Effect.flatMap(CurrentRunWriter, (writer) => {
+			const view = {
+				runId,
+				through,
+				writer
+			};
+			verifiedEmpty = view;
+			return body.pipe(Effect.ensuring(Effect.sync(() => {
+				if (verifiedEmpty === view) verifiedEmpty = void 0;
+			})));
+		}),
 		stageUsage: (runId, bytes) => {
 			if (bytes === 0) stagedUsage.delete(runId);
 			else stagedUsage.set(runId, bytes);
@@ -1000,4 +1091,4 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 //#endregion
 export { readRunContext as _, canonicalRecordBytes as a, reference as b, prepareProgressAppend as c, resolveExecutionEvidence as d, runEvidence as f, digestRunHistory as g, verifyRunContinuations as h, RunContinuation_exports as i, readContinuation as l, validateSuffix as m, CurrentRunWriter as n, isOperationalRecord as o, validateProgressAppend as p, ProgressAppendReader as r, makeProgressWriter as s, CurrentRunSettlement as t, readRunEvidenceSnapshot as u, validateContextBoundary as v, resolveEvidence as x, RunContextReader as y };
 
-//# sourceMappingURL=RunContinuation-DHYNAQFi.mjs.map
+//# sourceMappingURL=RunContinuation-BiyKJK32.mjs.map