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

package/dist/{EventSource-BwliwQz9.d.mts → EventSource-C9aaJaXT.d.mts}

@@ -1,5 +1,5 @@
 import { K as PersistedJson } from "./Records-BTnGRdcf.mjs";
-import { E as SubscriptionSourceError, b as SubscriptionRecord, i as EventSourceVersion, t as AcceptedEvent } from "./Subscription-DONig54Q.mjs";
+import { E as SubscriptionSourceError, b as SubscriptionRecord, i as EventSourceVersion, t as AcceptedEvent } from "./Subscription-BNg9VCRl.mjs";
 import { Context, Effect, Schema, Scope } from "effect";
 declare namespace EventSource_d_exports {
   export { EventSource, EventSources, NormalizedEvent, makeEventSource };
@@ -48,4 +48,4 @@ declare const makeEventSource: <Event extends Schema.Top, Parameters extends Sch
 }) => Effect.Effect<EventSource, never, Exclude<R, Scope.Scope> | Exclude<Event["DecodingServices"], Scope.Scope> | Exclude<Event["EncodingServices"], Scope.Scope> | Exclude<Parameters["DecodingServices"], Scope.Scope> | Exclude<Parameters["EncodingServices"], Scope.Scope>>;
 //#endregion
 export { makeEventSource as a, NormalizedEvent as i, EventSource_d_exports as n, EventSources as r, EventSource as t };
-//# sourceMappingURL=EventSource-BwliwQz9.d.mts.map
+//# sourceMappingURL=EventSource-C9aaJaXT.d.mts.map

package/dist/{MessageDelivery-CeSDfHZa.d.mts → MessageDelivery-BGDm-c46.d.mts}

@@ -5,9 +5,9 @@ import { r as Update } from "./AgentUpdates-DksV4D0A.mjs";
 import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-DvHruCSJ.mjs";
 import { t as AgentPolicy } from "./AgentPolicy-B4lbCU2T.mjs";
 import { b as DefinitionDigests } from "./Records-BTnGRdcf.mjs";
-import { sn as Settlement, uo as LifecyclePublicationStorage } from "./Admin-BX9ns28E.mjs";
-import { a as PreparedInput } from "./Subscription-DONig54Q.mjs";
-import { t as PreparedInputAdmission } from "./PreparedInputAdmission-CxSJSiTl.mjs";
+import { sn as Settlement, uo as LifecyclePublicationStorage } from "./Admin-BHmp2V9p.mjs";
+import { a as PreparedInput } from "./Subscription-BNg9VCRl.mjs";
+import { t as PreparedInputAdmission } from "./PreparedInputAdmission-BvDqlgiP.mjs";
 import { Context, Crypto, Effect, Layer, Result, Schema } from "effect";
 declare namespace MessageDelivery_d_exports {
   export { MessageDeliveryChange, MessageDeliveryCompletion, MessageDeliveryDriver, MessageDeliveryDriverLimits, MessageDeliveryError, MessageDeliveryFailpoint, MessageDeliveryFailpointError, MessageDeliveryFailure, MessageDeliveryKey, MessageDeliveryPage, MessageDeliveryPageRequest, MessageDeliveryPolicy, MessageDeliveryRecord, MessageDeliveryStore, MessageDeliveryStoreLimits, applyMessageDeliveryChange, defaultMessageDeliveryPolicy, defaultMessageDeliveryStoreLimits, isWorkerUpdateDelivery, messageDeliveryCapacity, messageDeliveryDeadline, messageDeliveryKeyString, messageDeliveryUsesCapacity, peerMessageRetentionDeadline, prepareMessageDelivery, readPending, sameMessageDeliveryIdentity, validateMessageDelivery };
@@ -950,4 +950,4 @@ declare class MessageDeliveryDriver extends MessageDeliveryDriver_base {
 }
 //#endregion
 export { messageDeliveryKeyString as C, readPending as D, prepareMessageDelivery as E, sameMessageDeliveryIdentity as O, messageDeliveryDeadline as S, peerMessageRetentionDeadline as T, applyMessageDeliveryChange as _, MessageDeliveryError as a, isWorkerUpdateDelivery as b, MessageDeliveryFailure as c, MessageDeliveryPageRequest as d, MessageDeliveryPolicy as f, MessageDelivery_d_exports as g, MessageDeliveryStoreLimits as h, MessageDeliveryDriverLimits as i, validateMessageDelivery as k, MessageDeliveryKey as l, MessageDeliveryStore as m, MessageDeliveryCompletion as n, MessageDeliveryFailpoint as o, MessageDeliveryRecord as p, MessageDeliveryDriver as r, MessageDeliveryFailpointError as s, MessageDeliveryChange as t, MessageDeliveryPage as u, defaultMessageDeliveryPolicy as v, messageDeliveryUsesCapacity as w, messageDeliveryCapacity as x, defaultMessageDeliveryStoreLimits as y };
-//# sourceMappingURL=MessageDelivery-CeSDfHZa.d.mts.map
+//# sourceMappingURL=MessageDelivery-BGDm-c46.d.mts.map

package/dist/{Messaging-C_6OOg_s.d.mts → Messaging-SVu6rWV8.d.mts}

@@ -1,7 +1,7 @@
 import { a as Receipt, t as IdempotencyKey } from "./Receipt-BkM21Qiu.mjs";
-import { r as AnyDefinition } from "./Agent-9aBoIi74.mjs";
+import { r as AnyDefinition } from "./Agent-B39jRnFv.mjs";
 import { a as MessageAdmission, c as MessageRef, i as MessageAddress, l as MessageStatus, n as InboxPage, o as MessagingError, r as InputMessage, s as PeerName, t as InboxEntry } from "./Messaging-DF_IWnxV.mjs";
-import { t as MessagingHost } from "./MessagingHost-B8oKM7AC.mjs";
+import { t as MessagingHost } from "./MessagingHost-C6SOAcoG.mjs";
 import { Crypto, Effect, Schema } from "effect";
 import { Tool, Toolkit } from "effect/ai";
 declare namespace Messaging_d_exports {
@@ -128,7 +128,7 @@ declare const reply: <Name extends string, Input extends Schema.Top>(declaration
 declare const inbox: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, options?: {
   readonly after?: number;
   readonly limit?: number;
-}) => Effect.Effect<{
+} | undefined) => Effect.Effect<{
   readonly items: readonly {
     readonly sequence: number;
     readonly admission: {
@@ -154,7 +154,10 @@ declare const inbox: <Name extends string, Input extends Schema.Top>(declaration
   }[];
   readonly next: number | null;
 }, MessagingError, MessagingHost>;
-declare const inspect: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, message: MessageRef) => Effect.Effect<{
+declare const inspect: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, message: {
+  readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+}) => Effect.Effect<{
   readonly message: {
     readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
     readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
@@ -204,7 +207,10 @@ declare const inspect: <Name extends string, Input extends Schema.Top>(declarati
   readonly reason: string;
 }, MessagingError, MessagingHost>;
 /** Explicitly renew a parked delivery's bounded retry budget, retaining its complete frozen envelope. */
-declare const retry: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, message: MessageRef) => Effect.Effect<{
+declare const retry: <Name extends string, Input extends Schema.Top>(declaration: Peer<Name, Input>, message: {
+  readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
+}) => Effect.Effect<{
   readonly message: {
     readonly ownerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
     readonly messageId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">;
@@ -1064,4 +1070,4 @@ declare const retryTool: <const Name extends string, Input extends Schema.Top>(d
 };
 //#endregion
 export { inspect as a, reply as c, retryTool as d, send as f, inboxTool as i, replyTool as l, Peer as n, inspectTool as o, sendTool as p, inbox as r, peer as s, Messaging_d_exports as t, retry as u };
-//# sourceMappingURL=Messaging-C_6OOg_s.d.mts.map
+//# sourceMappingURL=Messaging-SVu6rWV8.d.mts.map

package/dist/{MessagingHost-B8oKM7AC.d.mts → MessagingHost-C6SOAcoG.d.mts}

@@ -1,6 +1,6 @@
 import { u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
 import { r as Principal, t as IdempotencyKey } from "./Receipt-BkM21Qiu.mjs";
-import { r as AnyDefinition } from "./Agent-9aBoIi74.mjs";
+import { r as AnyDefinition } from "./Agent-B39jRnFv.mjs";
 import { h as WorkerSource } from "./Worker-CHRaIsWu.mjs";
 import { c as MessageRef, i as MessageAddress, l as MessageStatus, n as InboxPage, o as MessagingError } from "./Messaging-DF_IWnxV.mjs";
 import * as Context$1 from "effect/Context";
@@ -79,4 +79,4 @@ declare const PeerDeliveryLifetime: Context$1.Reference<number>;
 declare const PeerMessageCapacity: Context$1.Reference<number>;
 //#endregion
 export { PeerDeliveryLifetime as a, PeerTarget as c, PeerAuthorizer as i, SendPeerMessage as l, MessagingHost_d_exports as n, PeerMessageCapacity as o, PeerAuthorizationRequest as r, PeerRoutes as s, MessagingHost as t };
-//# sourceMappingURL=MessagingHost-B8oKM7AC.d.mts.map
+//# sourceMappingURL=MessagingHost-C6SOAcoG.d.mts.map

package/dist/{Output-Dsx6k52t.d.mts → Output-CRamN1Fy.d.mts}

@@ -1,4 +1,4 @@
-import "./Agent-9aBoIi74.mjs";
+import "./Agent-B39jRnFv.mjs";
 import * as Schema from "effect/Schema";
 import "effect/ai/Prompt";
 //#region src/engine/internal/output-contract.d.ts
@@ -22,4 +22,4 @@ declare namespace Output_d_exports {
 }
 //#endregion
 export { textOutput as n, Output_d_exports as t };
-//# sourceMappingURL=Output-Dsx6k52t.d.mts.map
+//# sourceMappingURL=Output-CRamN1Fy.d.mts.map

package/dist/{PreparedInputAdmission-CxSJSiTl.d.mts → PreparedInputAdmission-BvDqlgiP.d.mts}

@@ -1,8 +1,8 @@
 import { a as Receipt } from "./Receipt-BkM21Qiu.mjs";
 import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-DvHruCSJ.mjs";
-import { kr as SubmissionStatus } from "./Admin-BX9ns28E.mjs";
+import { kr as SubmissionStatus } from "./Admin-BHmp2V9p.mjs";
 import { H as ScheduledInputRefused, V as ScheduledInputFailure, j as ScheduleStorageError } from "./Schedule-CDgTz0vj.mjs";
-import { a as PreparedInput } from "./Subscription-DONig54Q.mjs";
+import { a as PreparedInput } from "./Subscription-BNg9VCRl.mjs";
 import { Context, Effect } from "effect";
 declare namespace PreparedInputAdmission_d_exports {
   export { PreparedInputAdmission, admitPreparedInput };
@@ -39,4 +39,4 @@ declare const admitPreparedInput: <R>(submit: Effect.Effect<Receipt, ScheduledIn
 }, ScheduleStorageError, R>;
 //#endregion
 export { PreparedInputAdmission_d_exports as n, admitPreparedInput as r, PreparedInputAdmission as t };
-//# sourceMappingURL=PreparedInputAdmission-CxSJSiTl.d.mts.map
+//# sourceMappingURL=PreparedInputAdmission-BvDqlgiP.d.mts.map

package/dist/{RunContinuation-DHYNAQFi.mjs → RunContinuation-4ZATcVLB.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 { i as digestCanonicalJson, r as canonicalJson } from "./Digest-EpeqWEdv.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 { $ as toolCallSettledRecordId, I as toolCallResultBatchId, Z as continuationUsage, g as projectRunJournalStream, j as subagentStartedRecordId, k as subagentRequestedRecordId, t as RunJournalError, v as runCompletedRecordId, x as runIdForSubmission } from "./RunJournal-CNZqA3Ge.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-59uDGXul.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,6 +172,31 @@ 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 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 validateBatchHeader = Schema.decodeSync(Schema.Struct({
 	batchId: CanonicalBatch.fields.batchId,
 	producerId: CanonicalBatch.fields.producerId
@@ -182,24 +206,36 @@ 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: () => {
+	try: () => Result.gen(function* () {
 		const header = validateBatchHeader(batch);
 		validateBatchCount(batch.records);
-		const records = batch.records.map((record) => captureRecord(record).canonical);
-		return Object.freeze(new CanonicalBatch({
+		const records = (yield* Result.all(batch.records.map(captureRecord))).map((record) => record.canonical);
+		return Object.freeze(CanonicalBatch.make({
 			...header,
 			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));
+};
+const factUsageCharge = (facts) => Effect.fromResult(Result.all(facts.map(recordEncoding))).pipe(Effect.map((encodings) => encodings.reduce((bytes, record) => bytes + record.progress.terminalUsageBytes, 0)), Effect.mapError((cause) => failure("Cannot account canonical progress facts", cause)));
 /** 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) {
@@ -428,18 +464,24 @@ const advanceFacts = Effect.fnUntraced(function* (previous, facts, submissionId,
 			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);
 				response = payload;
@@ -490,11 +532,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;
@@ -519,7 +561,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));
@@ -537,7 +579,7 @@ const advanceFacts = Effect.fnUntraced(function* (previous, facts, submissionId,
 	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 usageCharge = yield* factUsageCharge(facts);
 	const terminalUsageBytes = (previous?.continuation.terminalUsageBytes ?? 0) + usageCharge;
 	const closing = facts.filter(isTerminalBudgetFact);
 	return {
@@ -598,15 +640,12 @@ 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();
 	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 +702,14 @@ const makeProgressWriter = Effect.fnUntraced(function* (threadId, deploymentId)
 			...completionBytes === void 0 ? {} : { completionBytes }
 		};
 	});
-	const checkFutureShapes = (state) => {
+	const loadState = (runId, after) => Effect.suspend(() => {
+		const retained = cached.get(runId);
+		return retained === void 0 ? loadUncachedState(runId, after) : Effect.succeed(retained);
+	});
+	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 +741,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 = yield* Effect.fromResult(Result.all(batch.records.map(captureRecord))).pipe(Effect.map((encodings) => encodings.map((record) => record.canonical)), Effect.mapError((cause) => failure("Cannot capture canonical progress facts", cause)));
 		const groups = /* @__PURE__ */ new Map();
 		for (const record of ownedRecords) for (const runId of executionRunIds(record)) {
 			const facts = groups.get(runId) ?? [];
@@ -712,6 +752,7 @@ 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);
 			let original = facts.find((record) => record.payload._tag === "UserInputRecorded" && record.payload.kind === "user" && record.payload.runId === runId && record.payload.submissionId !== void 0);
@@ -747,18 +788,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") : yield* reference(original);
+			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 +817,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: yield* reference(last),
 				position,
 				accounting
 			}).pipe(Effect.mapError(() => capacityFailure("Canonical continuation exceeds its protocol bounds")));
@@ -813,22 +854,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 +920,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 +938,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++) {
@@ -946,7 +1003,7 @@ 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);
@@ -1000,4 +1057,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-4ZATcVLB.mjs.map