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

package/src/durable/ThreadStore.ts

@@ -343,19 +343,20 @@ export class AppendRequest extends Schema.Class<AppendRequest>(
   expectedTailSequence: CanonicalSequence,
 }) {}
 
+const RecordCount = Schema.Array(Schema.Unknown).check(Schema.isMaxLength(256));
+const ExecutionRecordCount = Schema.Array(Schema.Unknown).check(Schema.isMaxLength(8));
+
 const AppendHeader = Schema.Struct({
   threadId: ThreadId,
   expectedTailSequence: CanonicalSequence,
   batchId: BatchId,
   producerId: ProducerId,
+  records: RecordCount,
+  executions: RecordCount,
 });
 
 const validateHeader = Schema.decodeUnknownSync(AppendHeader);
 
-const validateRecordCount = Schema.decodeUnknownSync(
-  Schema.Array(Schema.Unknown).check(Schema.isMaxLength(256)),
-);
-
 const validateExecutionHeader = Schema.decodeUnknownSync(
   Schema.Struct({
     previousRevision: ExecutionUpdate.fields.previousRevision,
@@ -366,24 +367,36 @@ const validateExecutionHeader = Schema.decodeUnknownSync(
       originalSequence: ExecutionCheckpoint.fields.originalSequence,
       throughSequence: ExecutionCheckpoint.fields.throughSequence,
       batchId: ExecutionCheckpoint.fields.batchId,
+      operational: ExecutionRecordCount,
     }),
+    facts: ExecutionRecordCount,
   }),
 );
 
-const validateExecutionRecordCount = Schema.decodeUnknownSync(
-  Schema.Array(Schema.Unknown).check(Schema.isMaxLength(8)),
-);
-
 /** Capture records once; wrapper fields retain their owning Schema's constraints. */
 const captureExecution = (input: ExecutionUpdate) => {
-  const header = validateExecutionHeader(input);
-  const operationalInput = input.checkpoint.operational;
+  const checkpointInput = input.checkpoint;
+  const operationalInput = checkpointInput.operational;
   const factsInput = input.facts;
 
-  const operationalLength = validateExecutionRecordCount(operationalInput).length;
-  const factsLength = validateExecutionRecordCount(factsInput).length;
+  const header = validateExecutionHeader({
+    previousRevision: input.previousRevision,
+    retire: input.retire,
+    checkpoint: {
+      version: checkpointInput.version,
+      canonicalRecords: checkpointInput.canonicalRecords,
+      originalSequence: checkpointInput.originalSequence,
+      throughSequence: checkpointInput.throughSequence,
+      batchId: checkpointInput.batchId,
+      operational: operationalInput,
+    },
+    facts: factsInput,
+  });
+
+  const operationalLength = header.checkpoint.operational.length;
+  const factsLength = header.facts.length;
 
-  const progress = captureRecord(input.checkpoint.progressRecord);
+  const progress = captureRecord(checkpointInput.progressRecord);
 
   if (Result.isFailure(progress)) return Result.fail(progress.failure);
   const progressRecord = progress.success.canonical;
@@ -530,15 +543,19 @@ export const PreparedAppend = {
       return Effect.try({
         try: () =>
           Result.gen(function* () {
+            const executions = input.executions ?? [];
+            const recordInputs = input.batch.records;
+
             const header = validateHeader({
               ...input,
               batchId: input.batch.batchId,
               producerId: input.batch.producerId,
+              records: recordInputs,
+              executions,
             });
 
-            validateRecordCount(input.batch.records);
-            const executions = input.executions ?? [];
-            const executionLength = validateRecordCount(executions).length;
+            const recordLength = header.records.length;
+            const executionLength = header.executions.length;
 
             const executionWrites: Array<PreparedAppend["executionWrites"][number]> = [];
 
@@ -546,7 +563,7 @@ export const PreparedAppend = {
               executionWrites.push(yield* captureExecution(executions[index]!));
             Object.freeze(executionWrites);
 
-            if (input.batch.records.length === 0 && executionWrites.length === 0)
+            if (recordLength === 0 && executionWrites.length === 0)
               return yield* Result.fail(
                 ThreadStoreError.make({
                   operation: "prepare durable commit",
@@ -560,8 +577,11 @@ export const PreparedAppend = {
                   message: "Active state exceeds its bounded transfer representation",
                 }),
               );
-            // Visit sparse slots too: capture owns each record's validation boundary.
-            const encodings = yield* Result.all(Array.from(input.batch.records, captureRecord));
+            // Visit Schema-validated indexed slots, including sparse ones, never a caller's iterator.
+            const encodings = [];
+
+            for (let index = 0; index < recordLength; index++)
+              encodings.push(yield* captureRecord(recordInputs[index]!));
             const prefix = `{"batchId":${JSON.stringify(header.batchId)},"producerId":${JSON.stringify(header.producerId)},"records":[`;
             const batchJson = `${prefix}${encodings.map(({ json }) => json).join(",")}]}`;
 

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

@@ -1,17 +1,32 @@
 import { Effect, Option, Schema, Stream } from "effect";
 import { Prompt } from "effect/ai";
 
-import { CanonicalSequence, type CanonicalRecordEnvelope } from "../Records.ts";
+import {
+  CanonicalSequence,
+  type CanonicalRecordEnvelope,
+  type RecordEnvelope,
+  type UserInputRecorded,
+} from "../Records.ts";
 import { RunJournalError, toolCallSettledRecordId } from "../RunJournal.ts";
 import { submissionSettlementRecordId } from "../SubmissionLedger.ts";
 import { getRecord, getRunInput, PROMPT_EVIDENCE_TAGS, ThreadReader } from "../ThreadStore.ts";
 import type { JournalRecordEnvelope } from "./journal-metadata.ts";
 
+/** A captured original input can prepare context before its atomic publication. It carries
+ * an expected position, never a committed observation cursor or dispatch authority. */
+export type InitialContextInput =
+  | CanonicalRecordEnvelope
+  | {
+      readonly threadId: CanonicalRecordEnvelope["threadId"];
+      readonly sequence: CanonicalRecordEnvelope["sequence"];
+      readonly record: RecordEnvelope & { readonly payload: UserInputRecorded };
+    };
+
 const invalid = (message: string) => RunJournalError.make({ message });
 const promptTag = new Set<string>(PROMPT_EVIDENCE_TAGS);
 
 /** Fresh admission trusts validated immutable history; recovery verifies its saved Prompt digest. */
-export const initialContext = Effect.fnUntraced(function* (original: CanonicalRecordEnvelope) {
+export const initialContext = Effect.fnUntraced(function* (original: InitialContextInput) {
   const reader = yield* ThreadReader;
   const threadId = original.threadId;
   const through = CanonicalSequence.make(original.sequence - 1);

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

@@ -6,9 +6,9 @@ import { boundedValueFootprint } from "../../engine/internal/bounded-value.ts";
 import { canonicalJson, digestCanonicalJson, utf8ByteLength } from "../Digest.ts";
 import {
   CanonicalSequence,
+  type CanonicalRecordEnvelope,
   CURRENT_RECORD_FORMAT,
   PromptRecord,
-  type CanonicalRecordEnvelope,
   type Digest,
   type PromptRecordEnvelope,
   type RecordEnvelope,
@@ -23,6 +23,7 @@ import {
   ThreadStore,
   ThreadTailRequest,
 } from "../ThreadStore.ts";
+import type { InitialContextInput } from "./initial-context.ts";
 import type { JournalRecordEnvelope } from "./journal-metadata.ts";
 import { promptJsonFootprint } from "./prompt-footprint.ts";
 import { captureRecord } from "./record-encoding.ts";
@@ -149,12 +150,14 @@ const retainedBytes = (value: unknown, json: string, allowance: number) => {
   return footprint === undefined ? undefined : encodedBytes + 2 * footprint;
 };
 
-const encodeHistory = Effect.fnUntraced(function* (prompt: Prompt.Prompt, allowance: number) {
-  const value = yield* encodePrompt(prompt);
-  const encoded = canonicalJson(value);
+const encodeHistory = (prompt: Prompt.Prompt, allowance: number) =>
+  Effect.suspend(() =>
+    Effect.mapEager(encodePrompt(prompt), (value) => {
+      const encoded = canonicalJson(value);
 
-  return { encoded, bytes: retainedBytes(value, encoded, allowance) };
-});
+      return { encoded, bytes: retainedBytes(value, encoded, allowance) };
+    }),
+  );
 
 // Finish parsing/decoding before suspending for suffix reads. Only the native prefix and its
 // canonical string leave this Effect; it does not keep a second parsed root in the outer Run.
@@ -252,7 +255,9 @@ const suffixRecordFootprint = (entry: PromptRecordEnvelope, allowance: number) =
  * acknowledged, consecutive appends. Never authority for writes or recovery; any uncertainty
  * discards this derivative and completion rereads canonical history.
  */
-export const makeCommittedPromptSuffix = (original: CanonicalRecordEnvelope) => {
+export const makeCommittedPromptSuffix = (
+  original: Pick<CanonicalRecordEnvelope, "threadId" | "sequence" | "record">,
+) => {
   const records: Array<PromptRecordEnvelope> = [];
 
   const runId =
@@ -558,7 +563,7 @@ export const makePromptHistoryCache = Effect.fnUntraced(function* () {
   const complete = Effect.fnUntraced(
     function* (
       writer: WriterIdentity,
-      original: CanonicalRecordEnvelope,
+      original: InitialContextInput,
       history: PromptHistory,
       committed?: CommittedPromptSuffix,
     ) {