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

package/src/durable/EventSource.ts

@@ -119,8 +119,8 @@ export const makeEventSource = Effect.fnUntraced(function* <
       Effect.provideContext(services),
     );
 
-  const parameters: EventSource["parameters"] = (value) =>
-    Effect.gen(function* () {
+  const parameters: EventSource["parameters"] = Effect.fnUntraced(
+    function* (value) {
       yield* Schema.decodeUnknownEffect(PersistedJson)(value).pipe(Effect.mapError(invalid));
 
       const decoded = yield* Schema.decodeUnknownEffect(options.parameters)(value).pipe(
@@ -131,10 +131,12 @@ export const makeEventSource = Effect.fnUntraced(function* <
         parameters: yield* encode(options.parameters, decoded),
         matchingKey: options.parameterKey(decoded),
       };
-    }).pipe(Effect.scoped, Effect.provideContext(services));
+    },
+    (effect) => effect.pipe(Effect.scoped, Effect.provideContext(services)),
+  );
 
-  const matches: EventSource["matches"] = (event, subscription) =>
-    Effect.gen(function* () {
+  const matches: EventSource["matches"] = Effect.fnUntraced(
+    function* (event, subscription) {
       const e = yield* Schema.decodeEffect(options.event)(event.payload).pipe(
         Effect.mapError(invalid),
       );
@@ -144,7 +146,9 @@ export const makeEventSource = Effect.fnUntraced(function* <
       ).pipe(Effect.mapError(invalid));
 
       return options.matches(e, p);
-    }).pipe(Effect.scoped, Effect.provideContext(services));
+    },
+    (effect) => effect.pipe(Effect.scoped, Effect.provideContext(services)),
+  );
 
   const reconcile = options.reconcile;
 
@@ -157,8 +161,8 @@ export const makeEventSource = Effect.fnUntraced(function* <
     ...(reconcile === undefined
       ? {}
       : {
-          reconcile: (subscription: SubscriptionRecord) =>
-            Effect.gen(function* () {
+          reconcile: Effect.fnUntraced(
+            function* (subscription: SubscriptionRecord) {
               const p = yield* Schema.decodeEffect(options.parameters)(
                 subscription.configuration.parameters,
               ).pipe(Effect.mapError(invalid));
@@ -166,7 +170,9 @@ export const makeEventSource = Effect.fnUntraced(function* <
               const event = yield* reconcile(p);
 
               return event === null ? null : yield* normalized(event);
-            }).pipe(Effect.scoped, Effect.provideContext(services)),
+            },
+            (effect) => effect.pipe(Effect.scoped, Effect.provideContext(services)),
+          ),
         }),
   };
 });

package/src/durable/RecordFormat.ts

@@ -45,7 +45,9 @@ export const decodeExportRecordJson = (
 // Both codecs validate RecordJson before this getter; decode the supported view once.
 const decodeView = SchemaGetter.transformEffect((value: RecordJson) =>
   decodeRecord(value).pipe(
-    Effect.map((record) => new ExportedRecord({ ...record, wire: value }, { disableChecks: true })),
+    Effect.map((record) =>
+      ExportedRecord.make({ ...record, wire: value }, { disableChecks: true }),
+    ),
     Effect.mapError((error) => error.issue),
   ),
 );
@@ -104,8 +106,8 @@ export const ReadEnvelope = Schema.Struct({
   record: ReadRecord,
 }).pipe(
   Schema.decodeTo(Schema.toType(CanonicalRecordEnvelope), {
-    decode: SchemaGetter.transform(
-      (fields) => new CanonicalRecordEnvelope(fields, { disableChecks: true }),
+    decode: SchemaGetter.transform((fields) =>
+      CanonicalRecordEnvelope.make(fields, { disableChecks: true }),
     ),
     encode: SchemaGetter.transform((envelope) => envelope),
   }),

package/src/durable/RunContinuation.ts

@@ -1,12 +1,12 @@
-import { Context, Crypto, DateTime, Effect, Option, Schema, Semaphore, Stream } from "effect";
+import { Context, DateTime, Effect, Option, Result, Schema, Semaphore, Stream } from "effect";
 import { Prompt } from "effect/ai";
 
 import { AgentPersistenceCapacityError } from "../core/AgentError.ts";
 import type { RunId, SubmissionId, ThreadId } from "../core/Identifiers.ts";
 import { ToolCallId } from "../core/Identifiers.ts";
 import { utf8ByteLength } from "../core/internal/utf8.ts";
-import { summarizeModelUsage } from "../core/Usage.ts";
 import { reference, resolveEvidence } from "./internal/evidence.ts";
+import { continuationUsage } from "./internal/usage-totals.ts";
 export { reference, resolveEvidence } from "./internal/evidence.ts";
 import {
   captureRecord,
@@ -119,6 +119,43 @@ const isExecutionProgressRecord = (
   record.payload._tag === "RunContinuation";
 
 const decodeResponsePrompt = Schema.decodeUnknownEffect(Prompt.Prompt);
+// The decoded Prompt stays private. Progress and capacity are recomputed on every invocation.
+const responsePrompts = new WeakMap<ModelResponseRecorded, Prompt.Prompt>();
+
+/** Cache eligibility only: freezing does not make accessors or custom iterators immutable. */
+const isFrozenJsonData = (input: Schema.Json): boolean => {
+  const pending: Array<unknown> = [input];
+  const seen = new WeakSet<object>();
+
+  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 === undefined || !("value" in descriptor)) return false;
+      pending.push(descriptor.value);
+    }
+  }
+
+  return true;
+};
 
 const validateBatchHeader = Schema.decodeSync(
   Schema.Struct({
@@ -136,39 +173,76 @@ const ContinuationBytes = Schema.Struct({
   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: CommitBatch) =>
   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, records: [records[0]!, ...records.slice(1)] },
-          { disableChecks: true },
-        ),
-      );
-    },
+    try: () =>
+      Result.gen(function* () {
+        const header = validateBatchHeader(batch);
+
+        validateBatchCount(batch.records);
+        const encodings = yield* Result.all(batch.records.map(captureRecord));
+        const records = encodings.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. */
-export const canonicalRecordBytes = (record: RecordEnvelope): number =>
-  recordEncoding(record).bytes;
+export const canonicalRecordBytes = (record: RecordEnvelope): number => {
+  const encoded = recordEncoding(record);
+
+  if (Result.isFailure(encoded)) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Public synchronous byte-accounting validation must reject malformed records before returning a number.
+    throw encoded.failure.cause ?? new RangeError(encoded.failure.message);
+  }
+
+  return encoded.success.bytes;
+};
 
 export type { ProgressAppendRecord } from "./internal/record-encoding.ts";
 
 /** Capture before acquiring the mutation owner; summaries never cross a wire boundary. */
 export const prepareProgressAppend = (
   records: ReadonlyArray<RecordEnvelope>,
-): ReadonlyArray<ProgressAppendRecord> =>
-  Object.freeze(records.map((record) => captureRecord(record).progress));
+): ReadonlyArray<ProgressAppendRecord> => {
+  const encodings = Result.all(records.map(captureRecord));
 
-const factUsageCharge = (facts: ReadonlyArray<RecordEnvelope>): number =>
-  facts.reduce((bytes, record) => bytes + recordEncoding(record).progress.terminalUsageBytes, 0);
+  if (Result.isFailure(encodings)) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Public synchronous progress construction must reject malformed records before acquiring a mutation owner.
+    throw encodings.failure.cause ?? new RangeError(encodings.failure.message);
+  }
+
+  return Object.freeze(encodings.success.map((record) => record.progress));
+};
+
+const factUsageCharge = (facts: ReadonlyArray<RecordEnvelope>) =>
+  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. */
 export const isOperationalRecord = ({ payload }: RecordEnvelope): boolean =>
@@ -663,10 +737,27 @@ const advanceFacts = Effect.fnUntraced(function* (
         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 === undefined) {
+          const property = Object.getOwnPropertyDescriptor(payload, "messages");
+
+          if (
+            Object.isFrozen(payload) &&
+            property !== undefined &&
+            "value" in property &&
+            property.value === promptInput &&
+            isFrozenJsonData(promptInput)
+          )
+            responsePrompts.set(payload, messages);
+        }
         responsePrompt = messages;
 
         const calls = messages.content.flatMap((message) =>
@@ -678,18 +769,18 @@ const advanceFacts = Effect.fnUntraced(function* (
         const summary =
           payload.modelUsage === undefined
             ? undefined
-            : yield* summarizeModelUsage(payload.modelUsage).pipe(
+            : 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;
@@ -754,14 +845,14 @@ const advanceFacts = Effect.fnUntraced(function* (
         if (payload.restart !== (accounting.modelRestarts ?? 0) + 1)
           return yield* failure("Model restart progress must advance once");
 
-        const summary = yield* summarizeModelUsage(payload.modelUsage).pipe(
+        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;
@@ -802,6 +893,7 @@ const advanceFacts = Effect.fnUntraced(function* (
   ) {
     const messages =
       responsePrompt ??
+      responsePrompts.get(response) ??
       (yield* decodeResponsePrompt(response.messages).pipe(
         Effect.mapError((cause) => failure("Invalid batch evidence", cause)),
       ));
@@ -848,7 +940,7 @@ const advanceFacts = Effect.fnUntraced(function* (
     (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);
@@ -951,7 +1043,6 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
   deploymentId: DeploymentId,
 ) {
   const reader = yield* ThreadReader;
-  const crypto = yield* Crypto.Crypto;
   const gate = yield* Semaphore.make(1);
   const cached = new Map<RunId, ProgressState>();
 
@@ -967,16 +1058,10 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
 
   const stagedUsage = new Map<RunId, number>();
 
-  const provide = <A, E>(effect: Effect.Effect<A, E, ThreadReader | Crypto.Crypto>) =>
-    effect.pipe(
-      Effect.provideService(ThreadReader, reader),
-      Effect.provideService(Crypto.Crypto, crypto),
-    );
-
-  const loadState = Effect.fnUntraced(function* (runId: RunId, after: CanonicalSequence) {
-    const retained = cached.get(runId);
+  const provide = <A, E>(effect: Effect.Effect<A, E, ThreadReader>) =>
+    Effect.provideService(effect, ThreadReader, reader);
 
-    if (retained !== undefined) return retained;
+  const loadUncachedState = Effect.fnUntraced(function* (runId: RunId, after: CanonicalSequence) {
     const loaded = yield* provide(readContinuation(threadId, runId, after));
 
     if (Option.isNone(loaded)) return undefined;
@@ -1095,11 +1180,21 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
     };
   });
 
-  const checkFutureShapes = (state: ProgressState): Effect.Effect<void, ThreadStoreError> => {
+  const loadState = (runId: RunId, after: CanonicalSequence) =>
+    Effect.suspend(() => {
+      const retained = cached.get(runId);
+
+      return retained === undefined ? loadUncachedState(runId, after) : Effect.succeed(retained);
+    });
+
+  const checkFutureShapes = (
+    state: ProgressState,
+    cursorBytes?: number,
+  ): Effect.Effect<void, ThreadStoreError> => {
     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: string) => utf8ByteLength(JSON.stringify(value));
     const refBytes = (value: EvidenceReference) => utf8ByteLength(JSON.stringify(value));
 
@@ -1213,14 +1308,20 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
     return Effect.void;
   };
 
-  const prepare = Effect.fnUntraced(function* (batch: CanonicalBatch, after: CanonicalSequence) {
+  const prepare = Effect.fnUntraced(function* (
+    batch: CanonicalBatch,
+    after: CanonicalSequence,
+    mode: "commit" | "preflight" = "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 = new Map<RunId, Array<RecordEnvelope>>();
 
@@ -1234,6 +1335,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
     }
     const executions: Array<ExecutionUpdate> = [];
     const accepted = new Map<RunId, ProgressState>();
+    let executionCount = 0;
 
     for (const [runId, facts] of groups) {
       const previous = yield* loadState(runId, after);
@@ -1337,12 +1439,17 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
 
         if (payload._tag !== "SubmissionSettled" || payload.runId !== runId) continue;
 
-        const retained = captureRecord(
-          RecordEnvelope.make({
-            ...fact,
-            payload: { ...payload, historyRecordCount: canonicalRecords },
-          }),
-        ).canonical;
+        const retained = yield* Effect.fromResult(
+          captureRecord(
+            RecordEnvelope.make({
+              ...fact,
+              payload: { ...payload, historyRecordCount: canonicalRecords },
+            }),
+          ),
+        ).pipe(
+          Effect.map((record) => record.canonical),
+          Effect.mapError((cause) => failure("Cannot capture canonical progress facts", cause)),
+        );
 
         facts[index] = retained;
         ownedRecords[ownedRecords.indexOf(fact)] = retained;
@@ -1353,9 +1460,9 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
           ? previous.continuation.originalInput
           : original === undefined
             ? yield* failure("Run progress has no original input")
-            : yield* provide(reference(original));
+            : yield* reference(original);
 
-      const next = yield* provide(advanceFacts(previous, facts, submissionId, initialBytes));
+      const next = yield* advanceFacts(previous, facts, submissionId, initialBytes);
 
       const {
         accounting,
@@ -1391,7 +1498,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
         ...(savedContext === undefined ? {} : { savedContext }),
         ...(latestResponse === undefined ? {} : { latestResponse }),
         ...(terminal === undefined ? {} : { terminal }),
-        lastFact: yield* provide(reference(last)),
+        lastFact: yield* reference(last),
         position,
         accounting,
       }).pipe(
@@ -1451,23 +1558,63 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
       );
 
       // Every other field was checked above; byte accounting changes only these counters.
-      continuation = new RunContinuation(
+      continuation = RunContinuation.make(
         { ...continuation, ...checkedBytes },
         { disableChecks: true },
       );
 
-      const record = captureRecord(
-        new RecordEnvelope({ ...header, payload: continuation }, { disableChecks: true }),
-      ).canonical;
+      const proposedRecord = RecordEnvelope.make(
+        { ...header, payload: continuation },
+        { disableChecks: true },
+      );
+
+      const cursorBytes = turnBytes - turnBase;
 
-      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) > MAX_RUN_CONTINUATION_BYTES)
+      if (cursorBytes > MAX_RUN_CONTINUATION_BYTES)
         return yield* capacityFailure(
           "Encoded continuation exceeds 8192 bytes including its envelope",
         );
+      executionCount++;
+      if (
+        mode === "preflight" &&
+        previous?.checkpoint !== undefined &&
+        facts.every(({ payload }) => payload._tag === "ModelResponseRecorded")
+      ) {
+        // The payload and header are validated, and operational facts are unchanged.
+        // Dispatch needs their capacity proof; only a commit needs checkpoint wire.
+        yield* decodeExecutionFrontier({
+          canonicalRecords,
+          throughSequence: after + ownedRecords.filter((fact) => !isOperationalRecord(fact)).length,
+        }).pipe(Effect.mapError((cause) => failure("Active execution exceeds its bounds", cause)));
+
+        const state: ProgressState = {
+          continuation,
+          record: proposedRecord,
+          ...(response === undefined ? {} : { response }),
+          results,
+          childResults,
+          ...(completionBytes === undefined ? {} : { completionBytes }),
+        };
+
+        yield* checkCapacity(
+          state,
+          new Set(batch.records.map(({ recordId }) => recordId)),
+          undefined,
+          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) !== cursorBytes)
+        return yield* failure("Continuation byte accounting differs from its Schema encoding");
 
       const operational = new Map(
         (previous?.checkpoint?.operational ?? []).map((fact) => [fact.recordId, fact]),
@@ -1478,7 +1625,15 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
       for (const fact of changed) {
         const prior = operational.get(fact.recordId);
 
-        if (prior !== undefined && recordEncoding(prior).json !== recordEncoding(fact).json)
+        if (
+          prior !== undefined &&
+          (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);
       }
@@ -1535,10 +1690,10 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
       accepted.set(runId, state);
     }
 
-    if (ownedRecords.length + executions.length > 256)
+    if (ownedRecords.length + executionCount > 256)
       return yield* failure("Progress and facts exceed the atomic batch bound");
 
-    const prepared = new CommitBatch(
+    const prepared = CommitBatch.make(
       {
         ...batch,
         records: ownedRecords.filter((fact) => !isOperationalRecord(fact)),
@@ -1566,14 +1721,11 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
     };
   });
 
-  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: CanonicalBatch) {
@@ -1699,7 +1851,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
 
         const owned = yield* captureFacts(batch);
 
-        yield* prepare(owned, after);
+        yield* prepare(owned, after, "preflight");
 
         const response = owned.records.find(
           (record) => record.payload._tag === "ModelResponseRecorded",

package/src/durable/RunJournal.ts

@@ -1,4 +1,4 @@
-import { Brand, type Crypto, Effect, Predicate, Schema, Stream, type DateTime } from "effect";
+import { Brand, Effect, Predicate, Schema, Stream, type DateTime } from "effect";
 import { Prompt } from "effect/ai";
 
 import {
@@ -22,13 +22,14 @@ import {
   contextWindowMessage,
 } from "../engine/Compaction.ts";
 import type { RunTurnToolResult } from "../engine/RunOptions.ts";
-import { digestJson, type DigestError } from "./Digest.ts";
+import { digestJson } from "./Digest.ts";
 import {
   makeJournalMetadata,
   toolCallSettledRecordId,
   type JournalMetadata,
   type JournalRecordEnvelope,
 } from "./internal/journal-metadata.ts";
+import { continuationUsage } from "./internal/usage-totals.ts";
 import {
   type BatchId,
   type RecordId,
@@ -1704,7 +1705,7 @@ const requireCanonicalTurn = (turn: number): Effect.Effect<void, RunJournalError
 
 const modelResponseRecord = Effect.fnUntraced(function* (
   input: TurnCommitInput,
-): Effect.fn.Return<RecordEnvelope, RunJournalError | DigestError, Crypto.Crypto> {
+): Effect.fn.Return<RecordEnvelope, RunJournalError> {
   const promptMessages = input.responseMessages;
 
   if (promptMessages.length === 0) {
@@ -1753,14 +1754,14 @@ const modelResponseRecord = Effect.fnUntraced(function* (
       return yield* journalError("Turn model usage must contain at least one completed call");
     }
 
-    const summary = yield* summarizeModelUsage(modelUsage).pipe(
+    const summary = yield* continuationUsage(modelUsage).pipe(
       Effect.mapError((cause) => journalError("Turn model usage exceeds accounting bounds", cause)),
     );
 
     if (
       input.usage === undefined ||
-      input.usage.inputTokens !== summary.inputTokens.total ||
-      input.usage.outputTokens !== summary.outputTokens.total ||
+      input.usage.inputTokens !== summary.inputTokens ||
+      input.usage.outputTokens !== summary.outputTokens ||
       (input.usage.costMicrousd ?? 0) !== summary.costMicrousd
     ) {
       return yield* journalError("Turn detailed and aggregate model usage disagree");
@@ -1882,7 +1883,7 @@ const runCompletionRecord = Effect.fnUntraced(function* (input: TurnCommitInput)
  */
 export const turnCanonicalBatch = Effect.fnUntraced(function* (
   input: TurnCommitInput,
-): Effect.fn.Return<CanonicalBatch, RunJournalError | DigestError, Crypto.Crypto> {
+): Effect.fn.Return<CanonicalBatch, RunJournalError> {
   yield* requireCanonicalTurn(input.turn);
   const modelResponse = yield* modelResponseRecord(input);
   const toolRecords = yield* toolSettledRecords(input);
@@ -1907,7 +1908,7 @@ export const turnCanonicalBatch = Effect.fnUntraced(function* (
  */
 export const turnResponseBatch = Effect.fnUntraced(function* (
   input: TurnCommitInput,
-): Effect.fn.Return<CanonicalBatch, RunJournalError | DigestError, Crypto.Crypto> {
+): Effect.fn.Return<CanonicalBatch, RunJournalError> {
   yield* requireCanonicalTurn(input.turn);
   const modelResponse = yield* modelResponseRecord(input);
 
@@ -1926,7 +1927,7 @@ export const turnResponseBatch = Effect.fnUntraced(function* (
  */
 export const turnResultsBatch = Effect.fnUntraced(function* (
   input: TurnCommitInput,
-): Effect.fn.Return<CanonicalBatch, RunJournalError | DigestError, Crypto.Crypto> {
+): Effect.fn.Return<CanonicalBatch, RunJournalError> {
   yield* requireCanonicalTurn(input.turn);
   const toolRecords = yield* toolSettledRecords(input);
   const first = toolRecords[0];