@yielded/agent 0.1.0-beta.181 → 0.1.0-beta.183

package/src/durable/RunContinuation.ts

@@ -1,5 +1,4 @@
 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";
@@ -118,45 +117,6 @@ const isExecutionProgressRecord = (
 ): record is RecordEnvelope & { readonly payload: RunContinuation } =>
   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 validateBatchShape = Schema.decodeUnknownSync(
   Schema.Struct({
     batchId: CanonicalBatch.fields.batchId,
@@ -165,11 +125,6 @@ const validateBatchShape = Schema.decodeUnknownSync(
   }),
 );
 
-const ContinuationBytes = Schema.Struct({
-  turnBytes: RunContinuation.fields.turnBytes,
-  terminalBytes: RunContinuation.fields.terminalBytes,
-});
-
 const decodeExecutionFrontier = Schema.decodeUnknownEffect(
   Schema.Struct({
     canonicalRecords: ExecutionCheckpoint.fields.canonicalRecords,
@@ -714,7 +669,6 @@ const advanceFacts = Effect.fnUntraced(function* (
   let terminal = previous?.continuation.terminal;
   let position = previous?.continuation.position ?? "starting";
   let response = previous?.response;
-  let responsePrompt: Prompt.Prompt | undefined;
   let results = new Map(previous?.results);
   let childResults = new Map(previous?.childResults);
   let completionBytes = previous?.completionBytes;
@@ -756,31 +710,10 @@ const advanceFacts = Effect.fnUntraced(function* (
         if (payload.turn !== accounting.committedTurns + 1)
           return yield* failure("Canonical Turn progress must advance once");
 
-        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 messages = payload.messages;
 
         const calls = messages.content.flatMap((message) =>
-          message.role === "assistant"
+          message.role === "assistant" && typeof message.content !== "string"
             ? message.content.filter((part) => part.type === "tool-call")
             : [],
         );
@@ -910,15 +843,8 @@ const advanceFacts = Effect.fnUntraced(function* (
     response.turn > accounting.accountedToolTurn &&
     response.toolOperations.every((operation) => results.has(operation.toolCallId))
   ) {
-    const messages =
-      responsePrompt ??
-      responsePrompts.get(response) ??
-      (yield* decodeResponsePrompt(response.messages).pipe(
-        Effect.mapError((cause) => failure("Invalid batch evidence", cause)),
-      ));
-
-    const parts = messages.content.flatMap((message) =>
-      message.role === "assistant" ? message.content : [],
+    const parts = response.messages.content.flatMap((message) =>
+      message.role === "assistant" && typeof message.content !== "string" ? message.content : [],
     );
 
     for (const call of parts) {
@@ -931,7 +857,8 @@ const advanceFacts = Effect.fnUntraced(function* (
       if (
         result === undefined ||
         !("isFailure" in result) ||
-        ("budgetRejected" in result && result.budgetRejected === true)
+        // Only canonical application settlements carry budget-rejection authority.
+        (!call.providerExecuted && "budgetRejected" in result && result.budgetRejected === true)
       )
         continue;
       accounting.consecutiveToolFailures = result.isFailure
@@ -1497,29 +1424,30 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
         terminalUsageBytes,
       } = next;
 
-      let continuation = yield* RunContinuation.makeEffect({
-        version: 1,
-        runId,
-        submissionId,
-        revision: (previous?.continuation.revision ?? 0) + 1,
-        recordCount: (previous?.continuation.recordCount ?? originalCount) + facts.length,
-        recordBytes: (previous?.continuation.recordBytes ?? initialBytes) + factBytes,
-        turn,
-        turnBytes: turnBase,
-        terminalUsageBytes,
-        terminalBytes: next.terminalBytes,
-        terminalRecords: next.terminalRecords,
-        originalInput,
-        ...(savedContext === undefined ? {} : { savedContext }),
-        ...(latestResponse === undefined ? {} : { latestResponse }),
-        ...(terminal === undefined ? {} : { terminal }),
-        lastFact: EvidenceReference.make({ recordId: last.recordId }),
-        position,
-        accounting,
-      }).pipe(
-        Effect.mapError(() =>
-          capacityFailure("Canonical continuation exceeds its protocol bounds"),
-        ),
+      // Facts and prior state are already checked. Validate the complete candidate at
+      // record capture, after byte accounting; preflight has its own boundary below.
+      let continuation = RunContinuation.make(
+        {
+          version: 1,
+          runId,
+          submissionId,
+          revision: (previous?.continuation.revision ?? 0) + 1,
+          recordCount: (previous?.continuation.recordCount ?? originalCount) + facts.length,
+          recordBytes: (previous?.continuation.recordBytes ?? initialBytes) + factBytes,
+          turn,
+          turnBytes: turnBase,
+          terminalUsageBytes,
+          terminalBytes: next.terminalBytes,
+          terminalRecords: next.terminalRecords,
+          originalInput,
+          ...(savedContext === undefined ? {} : { savedContext }),
+          ...(latestResponse === undefined ? {} : { latestResponse }),
+          ...(terminal === undefined ? {} : { terminal }),
+          lastFact: EvidenceReference.make({ recordId: last.recordId }),
+          position,
+          accounting,
+        },
+        { disableChecks: true },
       );
 
       const header = {
@@ -1530,7 +1458,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
         deploymentId: last.deploymentId,
       };
 
-      // The validated continuation fields are JSON; only the envelope DateTime needs encoding.
+      // Continuation fields are JSON; only the envelope DateTime needs encoding.
       // Key order does not change byte width. Measure without capturing a provisional record,
       // then compare against the final Schema encoding before accepting its accounting.
       const provisional = {
@@ -1563,18 +1491,9 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
         terminalBytes = nextTerminalBytes;
       }
 
-      const checkedBytes = yield* ContinuationBytes.makeEffect({
-        turnBytes,
-        terminalBytes,
-      }).pipe(
-        Effect.mapError(() =>
-          capacityFailure("Turn exceeds its incremental canonical byte budget"),
-        ),
-      );
-
-      // Every other field was checked above; byte accounting changes only these counters.
+      // Byte accounting changes only these counters; the full candidate is checked below.
       continuation = RunContinuation.make(
-        { ...continuation, ...checkedBytes },
+        { ...continuation, turnBytes, terminalBytes },
         { disableChecks: true },
       );
 
@@ -1595,8 +1514,13 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
         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.
+        // Preflight does not capture a record. Check its complete payload before
+        // dispatch; a commit receives the same proof from record capture below.
+        continuation = yield* RunContinuation.makeEffect({ ...continuation }).pipe(
+          Effect.mapError(() =>
+            capacityFailure("Canonical continuation exceeds its protocol bounds"),
+          ),
+        );
         yield* decodeExecutionFrontier({
           canonicalRecords,
           throughSequence: after + ownedRecords.filter((fact) => !isOperationalRecord(fact)).length,
@@ -1623,7 +1547,11 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
 
       const record = yield* Effect.fromResult(captureRecord(proposedRecord)).pipe(
         Effect.map((record) => record.canonical),
-        Effect.mapError((cause) => failure("Cannot capture canonical progress facts", cause)),
+        Effect.mapError((cause) =>
+          Schema.isSchemaError(cause.cause)
+            ? capacityFailure("Canonical continuation exceeds its protocol bounds")
+            : failure("Cannot capture canonical progress facts", cause),
+        ),
       );
 
       if (!isExecutionProgressRecord(record))
@@ -1679,7 +1607,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
       );
 
       const state = {
-        continuation,
+        continuation: record.payload,
         record,
         checkpoint,
         ...(response === undefined ? {} : { response }),
@@ -1803,13 +1731,14 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
         if (first === undefined)
           return yield* failure("Settlement must publish a retained terminal fact");
 
-        const terminalBatch = yield* CanonicalBatch.makeEffect({
-          ...prepared.batch,
-          records: [first, ...prepared.batch.records.slice(1)],
-        }).pipe(
-          Effect.mapError((cause) =>
-            failure("Settlement must publish a retained terminal fact", cause),
-          ),
+        // prepare retains captured records within the validated batch bound.
+        // The explicit first element proves this retained batch is still non-empty.
+        const terminalBatch = CanonicalBatch.make(
+          {
+            ...prepared.batch,
+            records: [first, ...prepared.batch.records.slice(1)],
+          },
+          { disableChecks: true },
         );
 
         const result = yield* publisher.publishSettlement(terminalBatch, prepared.executions).pipe(
@@ -1840,6 +1769,15 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
   const publish = (batch: CanonicalBatch) =>
     captureFacts(batch).pipe(Effect.flatMap(publishCaptured));
 
+  const preflight = (batch: CanonicalBatch) =>
+    gate.withPermits(1)(
+      Effect.gen(function* () {
+        const owned = yield* captureFacts(batch);
+
+        yield* prepare(owned, yield* tail, "preflight");
+      }),
+    );
+
   const reserve = (runId: RunId, probe: CanonicalBatch, bytes: number) =>
     gate.withPermits(1)(
       Effect.gen(function* () {
@@ -1952,6 +1890,7 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
   return {
     commit,
     publish,
+    preflight,
     reserve,
     defer,
     check,

package/src/durable/RunJournal.ts

@@ -8,7 +8,6 @@ import {
   ToolCallId,
   type SubmissionId,
 } from "../core/Identifiers.ts";
-import { copyJson } from "../core/internal/json.ts";
 import { type ExhaustedLimit } from "../core/RunEvent.ts";
 import { RunPolicyUsage } from "../core/RunPolicyUsage.ts";
 import { type Selection, type Snapshot } from "../core/ToolExposure.ts";
@@ -37,7 +36,7 @@ import {
   CanonicalBatch,
   ModelResponseRecorded,
   MAX_PERSISTED_JSON_BYTES,
-  PersistedJson,
+  type PersistedJson,
   RecordEnvelope,
   RunCompleted,
   ToolCallSettled,
@@ -1697,7 +1696,6 @@ export interface TurnCommitInput {
     | undefined;
 }
 
-const decodePersistedJson = Schema.decodeUnknownEffect(PersistedJson);
 const decodeModelResponse = Schema.decodeUnknownEffect(ModelResponseRecorded);
 const decodeToolSettled = Schema.decodeUnknownEffect(ToolCallSettled);
 const encodePrompt = Schema.encodeEffect(Prompt.Prompt);
@@ -1739,14 +1737,8 @@ const modelResponseRecord = Effect.fnUntraced(function* (
     Effect.mapErrorEager((cause) => journalError("Turn Prompt messages failed to encode", cause)),
   );
 
-  const messages = yield* decodePersistedJson(encodedMessages).pipe(
-    Effect.mapEager(copyJson),
-    Effect.mapErrorEager((cause) =>
-      journalError("Turn Prompt messages exceed canonical persistence bounds", cause),
-    ),
-  );
-
-  // Validate the detached messages and usage together; no mutable caller data is trusted.
+  // Validate messages and usage together. The progress writer captures the complete record
+  // before acquiring its mutation gate; a separate JSON copy here adds no ownership proof.
   const modelUsage = input.usage?.modelUsage;
 
   const payload = yield* decodeModelResponse({
@@ -1761,7 +1753,7 @@ const modelResponseRecord = Effect.fnUntraced(function* (
     runId: input.runId,
     turnId: input.turnId,
     turn: input.turn,
-    messages,
+    messages: encodedMessages,
     ...(runScopedPrefixLength === undefined ? {} : { runScopedPrefixLength }),
     ...(modelUsage === undefined ? {} : { modelUsage }),
     ...(input.unobservedModelCalls === undefined || input.unobservedModelCalls === 0

package/src/durable/internal/history-prompt.ts

@@ -23,7 +23,8 @@ function restorePart(part: Prompt.PartEncoded): Prompt.Part {
   }
 }
 
-const restoreMessage = (message: Prompt.MessageEncoded): Prompt.Message => {
+// The encoded-message Schema has validated this value; constructors restore brands/defaults.
+export const restoreHistoryMessage = (message: Prompt.MessageEncoded): Prompt.Message => {
   switch (message.role) {
     case "system":
       return Prompt.makeMessage("system", message);
@@ -52,14 +53,19 @@ const restoreMessage = (message: Prompt.MessageEncoded): Prompt.Message => {
 };
 
 /**
- * Validate the upstream encoded history once, then restore native values with its constructors.
+ * Share the upstream encoded-message boundary between canonical history and checkpoint reads.
  * The canonical codec remains authoritative at append, import, recovery and explicit verification.
  */
-export const HistoryPrompt = Schema.toEncoded(Prompt.Prompt).pipe(
+export const HistoryMessage = Schema.toEncoded(Prompt.Message);
+
+export const HistoryPrompt = Schema.Struct({
+  content: Schema.Array(HistoryMessage),
+}).pipe(
   Schema.decodeTo(
     Schema.toType(Prompt.Prompt),
     SchemaTransformation.transformEffect({
-      decode: (input) => Effect.succeed(Prompt.fromMessages(input.content.map(restoreMessage))),
+      decode: (input) =>
+        Effect.succeed(Prompt.fromMessages(input.content.map(restoreHistoryMessage))),
       encode: SchemaParser.encodeEffect(Prompt.Prompt),
     }),
   ),

package/src/durable/internal/initial-context.ts

@@ -145,7 +145,7 @@ export const initialContext = Effect.fnUntraced(function* (original: InitialCont
     )
       return yield* invalid("Late Tool result differs from its original declaration identity");
 
-    const prompt = yield* Schema.decodeUnknownEffect(Prompt.Prompt)(response.messages).pipe(
+    const prompt = yield* Schema.decodeEffect(Prompt.Prompt)(response.messages).pipe(
       Effect.mapError(() => invalid("Late Tool declaration messages are malformed")),
     );
 

package/src/durable/internal/prompt-history-cache.ts

@@ -23,8 +23,9 @@ import {
   ThreadStore,
   ThreadTailRequest,
 } from "../ThreadStore.ts";
+import { HistoryMessage, restoreHistoryMessage } from "./history-prompt.ts";
 import type { InitialContextInput } from "./initial-context.ts";
-import type { JournalRecordEnvelope } from "./journal-metadata.ts";
+import { makeJournalMetadata, type JournalRecordEnvelope } from "./journal-metadata.ts";
 import { promptJsonFootprint } from "./prompt-footprint.ts";
 import { captureRecord } from "./record-encoding.ts";
 import { digestRunHistory } from "./run-context.ts";
@@ -47,9 +48,7 @@ const decodeCommittedPromptRecord = Schema.decodeUnknownSync(PromptRecord);
 const decodeEncodedPrompt = Schema.decodeUnknownEffect(
   Schema.suspend(() =>
     Schema.Struct({
-      content: Schema.Array(Schema.toEncoded(Prompt.Message)).check(
-        Schema.isMaxLength(MAX_ENTRIES),
-      ),
+      content: Schema.Array(HistoryMessage).check(Schema.isMaxLength(MAX_ENTRIES)),
     }),
   ),
 );
@@ -64,64 +63,6 @@ const decodePrompt = Schema.decodeUnknownEffect(
   ),
 );
 
-// Inputs have crossed Effect's encoded-message Schema boundary. Native constructors
-// supply only the brands and defaults; Effect still owns every message and part type.
-function hydratePart(part: Prompt.UserMessagePartEncoded): Prompt.UserMessagePart;
-function hydratePart(part: Prompt.ToolMessagePartEncoded): Prompt.ToolMessagePart;
-function hydratePart(part: Prompt.AssistantMessagePartEncoded): Prompt.AssistantMessagePart;
-function hydratePart(part: Prompt.PartEncoded): Prompt.Part {
-  switch (part.type) {
-    case "text":
-      return Prompt.textPart(part);
-    case "reasoning":
-      return Prompt.reasoningPart(part);
-    case "file":
-      return Prompt.filePart(part);
-    case "tool-call":
-      // Unlike options, providerExecuted is required by Effect's constructors;
-      // only its Schema decoder supplies the false default.
-      return Prompt.toolCallPart({ ...part, providerExecuted: part.providerExecuted ?? false });
-    case "tool-result":
-      return Prompt.toolResultPart({ ...part, providerExecuted: part.providerExecuted ?? false });
-    case "tool-approval-request":
-      return Prompt.toolApprovalRequestPart(part);
-    case "tool-approval-response":
-      return Prompt.toolApprovalResponsePart(part);
-  }
-
-  return part satisfies never;
-}
-
-const hydrateMessage = (message: Prompt.MessageEncoded): Prompt.Message => {
-  switch (message.role) {
-    case "system":
-      return Prompt.systemMessage(message);
-    case "user":
-      return Prompt.userMessage({
-        ...message,
-        content:
-          typeof message.content === "string"
-            ? [Prompt.textPart({ text: message.content })]
-            : message.content.map((p) => hydratePart(p)),
-      });
-    case "assistant":
-      return Prompt.assistantMessage({
-        ...message,
-        content:
-          typeof message.content === "string"
-            ? [Prompt.textPart({ text: message.content })]
-            : message.content.map((p) => hydratePart(p)),
-      });
-    case "tool":
-      return Prompt.toolMessage({
-        ...message,
-        content: message.content.map((p) => hydratePart(p)),
-      });
-  }
-
-  return message satisfies never;
-};
-
 export interface PromptHistory {
   readonly prompt: Prompt.Prompt;
   encoded: string | undefined;
@@ -171,7 +112,7 @@ export const decodeCheckpointPrefix = Effect.fnUntraced(function* (
   if (bytes === undefined) return undefined;
 
   const decoded = yield* decodeEncodedPrompt(value).pipe(
-    Effect.map((prompt) => ({ content: prompt.content.map(hydrateMessage) })),
+    Effect.map((prompt) => ({ content: prompt.content.map(restoreHistoryMessage) })),
     // Keep the canonical codec as fallback for representations the encoded Schema rejects.
     Effect.catch(() => decodePrompt(value)),
   );
@@ -399,6 +340,7 @@ const readSuffix = Effect.fnUntraced(function* (
 ) {
   const store = yield* ThreadStore;
   const records: Array<JournalRecordEnvelope> = [];
+  const metadata = makeJournalMetadata(undefined);
   let after = from;
   let remaining = allowance;
   let active: RunId | undefined;
@@ -461,6 +403,7 @@ const readSuffix = Effect.fnUntraced(function* (
       if (footprint === undefined) return undefined;
       remaining -= 32 * footprint;
       records.push(entry);
+      metadata.add(entry);
       after = entry.sequence;
     }
     if (page.length === 0) break;
@@ -474,6 +417,8 @@ const readSuffix = Effect.fnUntraced(function* (
     (boundary) => {
       if (boundary.incomplete) incomplete = true;
     },
+    undefined,
+    metadata.finish(),
   );
 
   if (incomplete || delta.prompt.content.length > MAX_ENTRIES) return undefined;

package/src/engine/RunOptions.ts

@@ -688,10 +688,13 @@ export interface RunDurabilityHook<Error = never, Requirements = never> {
    * `committed` accepts the supplied facts canonically. `deferred` is valid only for a Response
    * with `defer: true`: validation and ownership succeeded, but no canonical acceptance occurred.
    * The interpreter retains its response and inputs until the Settled commit is accepted.
+   * `capacity-refused` is valid only for a fresh Response rejected before any storage append or
+   * Tool work. The interpreter settles every application call as not dispatched, atomically with
+   * that response. A failed append or an already accepted response must never return this value.
    */
   readonly commitTurn: (
     commit: RunTurnCommit,
-  ) => Effect.Effect<"committed" | "deferred", Error, Requirements>;
+  ) => Effect.Effect<"committed" | "deferred" | "capacity-refused", Error, Requirements>;
   /** Check the writer fence after approval/authorization and before handler permits; no write. */
   readonly checkToolDispatch: Effect.Effect<void, Error, Requirements>;
   readonly step: RunStepHook<Error, Requirements>;