@yielded/agent 0.1.0-beta.177 → 0.1.0-beta.179

package/src/durable/DurableAgentRuntime.ts

@@ -174,6 +174,7 @@ import {
   type CommittedPromptSuffix,
   type PromptHistory,
 } from "./internal/prompt-history-cache.ts";
+import { captureRecord } from "./internal/record-encoding.ts";
 import { RunContextReader } from "./internal/run-context-reader.ts";
 import { readRunContext } from "./internal/run-context.ts";
 import * as ThreadInitialization from "./internal/thread-initialization.ts";
@@ -403,7 +404,6 @@ import {
   getRunInput,
   ThreadReader,
   MAX_THREAD_EXPORT_PAGE_BYTES,
-  PreparedAppend,
   type CommitBatch,
   type ExecutionUpdate,
 } from "./ThreadStore.ts";
@@ -4918,6 +4918,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       progressThrough: CanonicalSequence | undefined,
       continuation: RunContinuation | undefined,
       priorContext: RunJournalContext | undefined,
+      operational: ReadonlyArray<RecordEnvelope>,
       journalMetadata: JournalMetadata | undefined,
       lineage: AttemptLineage,
       approvalDecisions: ReadonlyArray<ApprovalDecisionIntent>,
@@ -5453,13 +5454,9 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           );
         });
 
-      const activeExecution = yield* reader.readExecution({ threadId: ctx.threadId, runId });
-
-      const recordedCompletion = Option.isSome(activeExecution)
-        ? activeExecution.value.operational.find(
-            (record) => record.recordId === runCompletedRecordId(runId),
-          )?.payload
-        : undefined;
+      const recordedCompletion = operational.find(
+        (record) => record.recordId === runCompletedRecordId(runId),
+      )?.payload;
 
       if (recordedCompletion !== undefined) {
         if (recordedCompletion._tag !== "RunCompleted" || recordedCompletion.runId !== runId) {
@@ -7830,19 +7827,26 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         ...(config.estimateCostMicrousd === undefined
           ? {}
           : { estimateCostMicrousd: config.estimateCostMicrousd }),
-        resumeUsage: {
-          ...journal.usage,
-          ...journal.policyUsage,
-          ...(journal.usage.modelCalls === 0 &&
-          (journal.usage.unobservedModelCalls ?? 0) === 0 &&
-          !records.some(
-            ({ record }) =>
-              record.payload._tag === "ModelResponseInterrupted" && record.payload.runId === runId,
-          )
-            ? emptyRunTotals()
-            : runTotalsFromSummary(yield* currentUsageSummary())),
-          children: childUsageReportsOf(subagentState),
-        },
+        // An exact committed history prefix followed only by this input creates the
+        // initial journal above. There is no resumed accounting to reconstruct or decode.
+        ...(freshPrefix !== undefined && continuation === undefined
+          ? {}
+          : {
+              resumeUsage: {
+                ...journal.usage,
+                ...journal.policyUsage,
+                ...(journal.usage.modelCalls === 0 &&
+                (journal.usage.unobservedModelCalls ?? 0) === 0 &&
+                !records.some(
+                  ({ record }) =>
+                    record.payload._tag === "ModelResponseInterrupted" &&
+                    record.payload.runId === runId,
+                )
+                  ? emptyRunTotals()
+                  : runTotalsFromSummary(yield* currentUsageSummary())),
+                children: childUsageReportsOf(subagentState),
+              },
+            }),
         ...(journal.contextWindowId === undefined
           ? {}
           : { initialContextWindowId: journal.contextWindowId }),
@@ -8301,136 +8305,66 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       const { claim, threadId } = session;
       const submissionId = claim.submissionId;
 
-      // The hint only selects this preparation. A real claim, current controls, exact
-      // evidence and checkpoint absence are verified under its owner before any reuse.
-      // No binding, instructions, model, Tool or cross-Thread operation runs in the window.
-      let prepared =
-        freshlyAdmitted && session.withInitialization !== undefined
-          ? yield* session.withInitialization(
-              Effect.gen(function* () {
-                const snapshot = yield* ledger.loadRecoverySnapshot(
-                  RecoverySnapshotRequest.make({ submissionId }),
-                );
-
-                const submission = snapshot.submission;
+      // The hint selects a read under the existing owner. Only exact empty-Run evidence
+      // permits startup; the initial commit still checks its tail and revision-zero CAS.
+      const preparation = freshlyAdmitted ? yield* session.prepareStart ?? Effect.void : undefined;
 
-                if (
-                  submission.state !== "ready" ||
-                  submission.workerAdmission !== undefined ||
-                  submission.messageAdmission !== undefined ||
-                  submission.parentLinkage !== undefined ||
-                  snapshot.inputApplied !== undefined ||
-                  snapshot.abortIntent !== undefined ||
-                  snapshot.approvalDecisions.length !== 0
-                )
-                  return undefined;
-                yield* ensureThreadCreated(threadId, submission.agentId, submission.agentDigests);
-                yield* session.refresh;
-                const before = (yield* session.tail).sequence;
-
-                const view = yield* recoveryView(
-                  threadId,
-                  before,
-                  [submissionId],
-                  runIdForSubmission(submissionId),
-                );
-
-                if (
-                  view.progress !== undefined ||
-                  view.context !== undefined ||
-                  view.operational.length !== 0 ||
-                  view.records.some(({ record }) => record.payload._tag !== "ThreadCreated")
-                )
-                  return undefined;
-                if (session.appendInput !== undefined) {
-                  const captured = yield* PreparedAppend.capture(
-                    AppendRequest.make({
-                      threadId,
-                      expectedTailSequence: before,
-                      batch: CanonicalBatch.make({
-                        batchId: submissionInputBatchId(submissionId),
-                        producerId: config.producerId,
-                        records: [yield* prepareOriginalInput(submission)],
-                      }),
-                    }),
-                  );
-
-                  const record = captured.records[0]!.canonical;
+      let prepared:
+        | {
+            snapshot: RecoverySnapshot;
+            through: CanonicalSequence;
+            view: Omit<Effect.Success<ReturnType<typeof recoveryView>>, "records"> & {
+              readonly records: ReadonlyArray<CanonicalRecordEnvelope>;
+            };
+            start: Effect.Success<ReturnType<typeof makeRunStart>>;
+            input: InitialContextInput;
+          }
+        | undefined;
 
-                  if (!isOriginalInputRecord(record))
-                    return yield* RunJournalError.make({
-                      message: "Captured startup has no original input",
-                    });
-                  pendingOriginal = {
-                    threadId,
-                    sequence: CanonicalSequence.make(before + 1),
-                    record,
-                  };
+      if (preparation !== undefined) {
+        const { snapshot, identity } = preparation;
+        const before = identity.tailSequence;
 
-                  const start = yield* makeRunStart(
-                    submission,
-                    Duration.toMillis(registeredAgent.definition.policy.maxDuration),
-                    view.records,
-                    view.operational,
-                    record,
-                  ).pipe(Effect.provideService(CurrentRunWriter, session));
+        const captured = yield* Effect.fromResult(
+          captureRecord(yield* prepareOriginalInput(snapshot.submission)),
+        ).pipe(
+          Effect.mapError((cause) =>
+            ThreadStoreError.make({
+              operation: "capture startup input",
+              message: cause.message,
+              cause,
+            }),
+          ),
+        );
 
-                  return { snapshot, through: before, view, start, input: pendingOriginal };
-                }
-                const progress = progressWriters.get(session);
+        const record = captured.canonical;
 
-                const applyInput = applyCanonicalInput(
-                  session,
-                  submission,
-                  session,
-                  view.records,
-                  undefined,
-                );
+        if (!isOriginalInputRecord(record))
+          return yield* RunJournalError.make({ message: "Captured startup has no original input" });
+        pendingOriginal = {
+          threadId,
+          sequence: CanonicalSequence.make(before + 1),
+          record,
+        };
 
-                yield* progress === undefined
-                  ? applyInput
-                  : progress
-                      .withVerifiedEmptyRun(runIdForSubmission(submissionId), before, applyInput)
-                      .pipe(Effect.provideService(CurrentRunWriter, promptSession));
-                const through = (yield* session.tail).sequence;
-                const added = yield* selectedRange(threadId, [submissionId], through, before);
-                const records = [...view.records, ...added];
+        const view = {
+          records: identity.records,
+          context: undefined,
+          progress: undefined,
+          progressThrough: undefined,
+          operational: [],
+        };
 
-                const accepted = progressWriters
-                  .get(session)
-                  ?.acceptedCheckpoint(runIdForSubmission(submissionId));
+        const start = yield* makeRunStart(
+          snapshot.submission,
+          Duration.toMillis(registeredAgent.definition.policy.maxDuration),
+          view.records,
+          view.operational,
+          record,
+        ).pipe(Effect.provideService(CurrentRunWriter, session));
 
-                if (
-                  accepted === undefined ||
-                  accepted.throughSequence !== through ||
-                  accepted.progress.runId !== runIdForSubmission(submissionId) ||
-                  accepted.progress.submissionId !== submissionId
-                )
-                  return undefined;
-
-                const start = yield* makeRunStart(
-                  submission,
-                  Duration.toMillis(registeredAgent.definition.policy.maxDuration),
-                  records,
-                  view.operational,
-                ).pipe(Effect.provideService(CurrentRunWriter, session));
-
-                return {
-                  snapshot,
-                  through,
-                  view: {
-                    ...view,
-                    records,
-                    progress: accepted.progress,
-                    progressThrough: accepted.throughSequence,
-                    operational: accepted.operational,
-                  },
-                  start,
-                  input: undefined,
-                };
-              }),
-            )
-          : undefined;
+        prepared = { snapshot, through: before, view, start, input: pendingOriginal };
+      }
 
       const preparedInput = prepared !== undefined;
 
@@ -8941,6 +8875,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           view.progressThrough,
           view.progress,
           view.context,
+          view.operational,
           takeJournalMetadata(),
           lineage,
           approvalDecisionIntents,

package/src/durable/RunContinuation.ts

@@ -184,18 +184,25 @@ const captureFacts = (batch: CommitBatch) =>
       Result.gen(function* () {
         const inputs = batch.records;
 
-        const { batchId, producerId } = validateBatchShape({
+        const {
+          batchId,
+          producerId,
+          records: slots,
+        } = validateBatchShape({
           batchId: batch.batchId,
           producerId: batch.producerId,
           records: inputs,
         });
 
-        const encodings = yield* Result.all(inputs.map(captureRecord));
-        const records = encodings.map((record) => record.canonical);
+        const first = yield* captureRecord(inputs[0]!);
+        const records: [RecordEnvelope, ...Array<RecordEnvelope>] = [first.canonical];
+
+        for (let index = 1; index < slots.length; index++)
+          records.push((yield* captureRecord(inputs[index]!)).canonical);
 
         return Object.freeze(
           CanonicalBatch.make(
-            { batchId, producerId, records: [records[0]!, ...records.slice(1)] },
+            { batchId, producerId, records: Object.freeze(records) },
             { disableChecks: true },
           ),
         );
@@ -1646,25 +1653,30 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
         operational.set(fact.recordId, fact);
       }
 
-      const checkpoint = yield* ExecutionCheckpoint.makeEffect({
-        version: 2,
-        progressRecord: record,
-        operational: [...operational.values()],
-        canonicalRecords,
-        originalSequence:
-          originalSequence ??
-          CanonicalSequence.make(
-            after +
-              ownedRecords
-                .filter((fact) => !isOperationalRecord(fact))
-                .findIndex((fact) => fact.recordId === originalInput.recordId) +
-              1,
+      // The records above already belong to this writer. PreparedAppend captures the
+      // complete update at the storage boundary, preserving their private encodings.
+      const checkpoint = ExecutionCheckpoint.make(
+        {
+          version: 2,
+          progressRecord: record,
+          operational: [...operational.values()],
+          canonicalRecords,
+          originalSequence:
+            originalSequence ??
+            CanonicalSequence.make(
+              after +
+                ownedRecords
+                  .filter((fact) => !isOperationalRecord(fact))
+                  .findIndex((fact) => fact.recordId === originalInput.recordId) +
+                1,
+            ),
+          throughSequence: CanonicalSequence.make(
+            after + ownedRecords.filter((fact) => !isOperationalRecord(fact)).length,
           ),
-        throughSequence: CanonicalSequence.make(
-          after + ownedRecords.filter((fact) => !isOperationalRecord(fact)).length,
-        ),
-        batchId: batch.batchId,
-      }).pipe(Effect.mapError((cause) => failure("Active execution exceeds its bounds", cause)));
+          batchId: batch.batchId,
+        },
+        { disableChecks: true },
+      );
 
       const state = {
         continuation,
@@ -1687,13 +1699,16 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
         );
       yield* checkFutureShapes(state);
       executions.push(
-        ExecutionUpdate.make({
-          previousRevision: previous?.continuation.revision ?? 0,
-          checkpoint,
-          facts: changed,
-          // Pending operations and handoffs retain their own recovery rows and original facts.
-          retire: position === "settled",
-        }),
+        ExecutionUpdate.make(
+          {
+            previousRevision: previous?.continuation.revision ?? 0,
+            checkpoint,
+            facts: changed,
+            // Pending operations and handoffs retain their own recovery rows and original facts.
+            retire: position === "settled",
+          },
+          { disableChecks: true },
+        ),
       );
       accepted.set(runId, state);
     }
@@ -1940,9 +1955,6 @@ export const makeProgressWriter = Effect.fnUntraced(function* (
     reserve,
     defer,
     check,
-    /** Internal read view immediately after this writer's acknowledged commit, while
-     * holding its initialization gates. Never authority across ownership or writes. */
-    acceptedCheckpoint: (runId: RunId) => cached.get(runId)?.checkpoint,
     /** Scope a verified empty execution/evidence view to one owned initialization body.
      * The caller holds progress+mutation gates; a changed writer or tail never reuses it. */
     withVerifiedEmptyRun: <A, E, R>(

package/src/durable/RunStorage.ts

@@ -17,6 +17,8 @@ import {
   type Claim,
   type ClaimRequest,
   type InputAppliedMarker,
+  type RecoverySnapshot,
+  RecoverySnapshotRequest,
   LedgerError,
   MarkInputAppliedRequest,
   MarkJoinedRequest,
@@ -34,6 +36,8 @@ import {
   type CommitBatch,
   type ExecutionUpdate,
   PreparedAppend,
+  FreshRunRead,
+  type ThreadIdentity,
   ThreadMaterialization,
   ThreadNotMaterialized,
   ThreadStore,
@@ -115,11 +119,12 @@ export interface RunStorageSession extends RunWriter, RunOwnership {
   readonly claim: Claim;
   /** Atomic original input/context plus the ledger marker, when the adapter supports it. */
   readonly appendInput?: RunWriter["append"];
-  /** Library-only initialization, before application/model IO. Hold progress before mutation
-   * so the captured controls and this owner's acknowledged input remain one read view. */
-  readonly withInitialization?: <A, E, R>(
-    effect: Effect.Effect<A, E, R>,
-  ) => Effect.Effect<A, E | OwnershipLost, R>;
+  /** Read current controls, root identity and empty-Run evidence under this owner.
+   * Its tail is adopted by the writer; append still checks the tail and revision. */
+  readonly prepareStart?: Effect.Effect<
+    { readonly snapshot: RecoverySnapshot; readonly identity: ThreadIdentity } | undefined,
+    LedgerError | ThreadStoreFailure
+  >;
   readonly refresh: Effect.Effect<void, ThreadStoreFailure>;
   readonly publishSettlement: (
     batch: CanonicalBatch,
@@ -182,14 +187,12 @@ const makeWriter = Effect.fnUntraced(function* (threadId: ThreadId) {
     const publisher = yield* ThreadStore;
 
     const append: RunWriter["append"] = Effect.fnUntraced(function* (batch, executions) {
-      const captured = yield* PreparedAppend.capture(
-        AppendRequest.make({
-          threadId,
-          expectedTailSequence: tail.sequence,
-          batch,
-          ...(executions === undefined ? {} : { executions }),
-        }),
-      ).pipe(
+      const captured = yield* PreparedAppend.capture({
+        threadId,
+        expectedTailSequence: tail.sequence,
+        batch,
+        ...(executions === undefined ? {} : { executions }),
+      }).pipe(
         Effect.mapError((cause) =>
           ThreadStoreError.make({
             operation: "capture append",
@@ -343,8 +346,46 @@ export const make = Effect.gen(function* () {
               ...writer,
               claim: claimed,
               ...(appendInput === undefined ? {} : { appendInput }),
-              withInitialization: (effect) =>
-                owner.withProgress(request.threadId, generation.use(effect)),
+              ...(store.readFreshRun === undefined || appendInput === undefined
+                ? {}
+                : {
+                    prepareStart: owner.withProgress(
+                      request.threadId,
+                      generation.use(
+                        Effect.gen(function* () {
+                          const snapshot = yield* ledger.loadRecoverySnapshot(
+                            RecoverySnapshotRequest.make({ submissionId: claimed.submissionId }),
+                          );
+
+                          const submission = snapshot.submission;
+
+                          if (
+                            submission.threadId !== request.threadId ||
+                            submission.state !== "ready" ||
+                            submission.workerAdmission !== undefined ||
+                            submission.messageAdmission !== undefined ||
+                            submission.parentLinkage !== undefined ||
+                            snapshot.inputApplied !== undefined ||
+                            snapshot.abortIntent !== undefined ||
+                            snapshot.approvalDecisions.length !== 0
+                          )
+                            return undefined;
+
+                          const identity = yield* store.readFreshRun!(
+                            FreshRunRead.make({
+                              threadId: request.threadId,
+                              submissionId: claimed.submissionId,
+                            }),
+                          );
+
+                          if (Option.isNone(identity)) return undefined;
+                          adoptTail(identity.value.tailSequence);
+
+                          return { snapshot, identity: identity.value };
+                        }),
+                      ),
+                    ),
+                  }),
               release: generation.release,
               refresh: writer.refresh,
               markInputApplied: (marker) =>

package/src/durable/ThreadStore.ts

@@ -836,6 +836,11 @@ export class ThreadIdentityRequest extends Schema.Class<ThreadIdentityRequest>(
   "@effect-agent/thread/ThreadIdentityRequest",
 )({ threadId: ThreadId }) {}
 
+export class FreshRunRead extends Schema.Class<FreshRunRead>("@effect-agent/thread/FreshRunRead")({
+  threadId: ThreadId,
+  submissionId: SubmissionId,
+}) {}
+
 /**
  * One consistent snapshot: Thread ID, canonical tail, admission presence, first record,
  * exact worker origin, then exact subagent lineage. A row selected twice appears only
@@ -1246,6 +1251,12 @@ export class ThreadStore extends Context.Service<
     readonly readIdentity: (
       request: ThreadIdentityRequest,
     ) => Effect.Effect<ThreadIdentity, ThreadStoreError | ThreadNotMaterialized>;
+    /** Owner-held preparation for an admitted root Run. Some proves an initialized root
+     * identity and no checkpoint, Run membership or exact input/abort/settlement record.
+     * None requires ordinary recovery; it never authorizes overwriting existing evidence. */
+    readonly readFreshRun?: (
+      request: FreshRunRead,
+    ) => Effect.Effect<Option.Option<ThreadIdentity>, ThreadStoreError | ThreadNotMaterialized>;
     readonly readWorkerCapacity?: (
       request: ThreadWorkerCapacityRequest,
     ) => Effect.Effect<ThreadWorkerCapacity, ThreadStoreError | ThreadNotMaterialized>;

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

@@ -294,8 +294,9 @@ export const makeCommittedPromptSuffix = (
       return;
     }
     // Prepared append facts already have privately frozen encodings; the original input and
-    // winning settlement are captured here before retention. Decode the same prompt projection
-    // as readPrompt, never raw provider values. Failure invalidates this derivative, not the commit.
+    // winning settlement are captured here before retention. An input contributes only its
+    // owned identity; other facts still decode the prompt projection used by readPrompt.
+    // Failure invalidates this derivative, not the commit.
     try {
       for (const fact of facts) {
         const captured = captureRecord(fact);
@@ -332,10 +333,25 @@ export const makeCommittedPromptSuffix = (
           return;
         }
 
+        const record: PromptRecord =
+          payload._tag === "UserInputRecorded"
+            ? {
+                recordId: owned.canonical.recordId,
+                payload: {
+                  _tag: payload._tag,
+                  kind: payload.kind,
+                  ...(payload.runId === undefined ? {} : { runId: payload.runId }),
+                  ...(payload.submissionId === undefined
+                    ? {}
+                    : { submissionId: payload.submissionId }),
+                },
+              }
+            : decodeCommittedPromptRecord(owned.wire);
+
         const entry: PromptRecordEnvelope = {
           threadId: original.threadId,
           sequence: CanonicalSequence.make(through + 1),
-          record: decodeCommittedPromptRecord(owned.wire),
+          record,
         };
 
         const footprint = suffixRecordFootprint(entry, remaining);

package/src/durable/internal/record-encoding.ts

@@ -118,14 +118,14 @@ const capturePayload = (payload: CanonicalRecordPayload) => {
   Object.setPrototypeOf(copy, Object.getPrototypeOf(payload));
   const copies = new WeakMap<object, object>([[payload, copy]]);
 
-  const pending: Array<object> = [copy];
-
   const owned: Array<object> = [copy];
 
-  while (pending.length > 0) {
-    const next = pending.pop()!;
+  for (let index = 0; index < owned.length; index++) {
+    const next = owned[index]!;
+
+    for (const key of Object.keys(next)) {
+      const value = Reflect.get(next, key);
 
-    for (const [key, value] of Object.entries(next)) {
       if (!Predicate.isObjectOrArray(value)) continue;
       let child = copies.get(value);
 
@@ -134,7 +134,6 @@ const capturePayload = (payload: CanonicalRecordPayload) => {
 
         copies.set(value, created);
         owned.push(created);
-        pending.push(created);
         child = created;
       }
       setOwn(next, key, child);
@@ -152,7 +151,9 @@ const ownWire = <Wire extends RecordJson>(wire: Wire, copies: WeakMap<object, ob
   while (pending.length > 0) {
     const next = pending.pop()!;
 
-    for (const [key, value] of Object.entries(next)) {
+    for (const key of Object.keys(next)) {
+      const value = Reflect.get(next, key);
+
       if (!Predicate.isObjectOrArray(value)) continue;
       const copy = copies.get(value);
 

package/src/sandbox/CodeExecutor.ts

@@ -159,7 +159,9 @@ export class CodeHostCallSuccess extends Schema.TaggedClass<CodeHostCallSuccess>
 /**
  * A host call settled with a Schema-encoded typed failure envelope. Inside the
  * generated program the call's Promise rejects with the envelope value, so a
- * program can catch and branch on expected failures.
+ * program can catch and branch on expected failures. Object and array failures
+ * stringify to their encoded JSON, preserving recovery details in String(error)
+ * without changing the enumerable fields returned or rethrown by the program.
  */
 export class CodeHostCallFailure extends Schema.TaggedClass<CodeHostCallFailure>()(
   "CodeHostCallFailure",