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

package/src/durable/SubmissionLedger.ts

@@ -228,6 +228,10 @@ export class SubmissionSnapshot extends Schema.Class<SubmissionSnapshot>(
   inputPayload: PersistedJson,
   inputDigest: Digest,
   settledOutcome: Schema.optionalKey(SettlementOutcome),
+  /** First committed finalization time; paired with settledRecordId by native adapters. */
+  settledAt: Schema.optionalKey(Schema.DateTimeUtcFromString),
+  /** Exact canonical settlement behind the finalized projection; not a substitute for reading it. */
+  settledRecordId: Schema.optionalKey(RecordId),
   createdAt: Schema.DateTimeUtcFromString,
   readyAt: Schema.optionalKey(Schema.DateTimeUtcFromString),
   admissionGroup: Schema.optionalKey(AdmissionGroup),

package/src/durable/SubscriptionInput.ts

@@ -122,8 +122,8 @@ export const makeSubscriptionInputBinding = Effect.fnUntraced(function* <
         Effect.scoped,
         Effect.provideContext(services),
       ),
-    prepare: (event, subscription) =>
-      Effect.gen(function* () {
+    prepare: Effect.fnUntraced(
+      function* (event, subscription) {
         const e = yield* Schema.decodeEffect(options.event)(event.payload).pipe(
           Effect.mapError(invalid),
         );
@@ -137,6 +137,8 @@ export const makeSubscriptionInputBinding = Effect.fnUntraced(function* <
         ).pipe(Effect.mapError(invalid));
 
         return yield* encode(options.input, yield* options.prepare(e, p, c));
-      }).pipe(Effect.scoped, Effect.provideContext(services)),
+      },
+      (effect) => effect.pipe(Effect.scoped, Effect.provideContext(services)),
+    ),
   };
 });

package/src/durable/SubscriptionStoreConformance.ts

@@ -860,21 +860,20 @@ const lifetimeCapacity = conformanceCase(
         );
       }
 
-      const assertHostGuard = <A>(
+      const assertHostGuard = Effect.fnUntraced(function* <A>(
         effect: Effect.Effect<A, SubscriptionStoreFailure>,
         code: string,
-      ) =>
-        Effect.gen(function* () {
-          const result = yield* Effect.result(effect);
-
-          yield* ensure(
-            Result.isFailure(result) &&
-              result.failure._tag === "SubscriptionError" &&
-              result.failure.reason === "capacity" &&
-              result.failure.code === code,
-            `host ${code} guard ignored live work`,
-          );
-        });
+      ) {
+        const result = yield* Effect.result(effect);
+
+        yield* ensure(
+          Result.isFailure(result) &&
+            result.failure._tag === "SubscriptionError" &&
+            result.failure.reason === "capacity" &&
+            result.failure.code === code,
+          `host ${code} guard ignored live work`,
+        );
+      });
 
       const active = yield* store.register(record("host-active"), limits);
       const activeEvent = yield* store.accept(event("host-active"), limits);
@@ -934,17 +933,18 @@ const capacityReactivation = conformanceCase(
         maxDeliveriesPerOwner: 1,
       };
 
-      const expectCapacity = <A>(effect: Effect.Effect<A, SubscriptionStoreFailure>) =>
-        Effect.gen(function* () {
-          const result = yield* Effect.result(effect);
+      const expectCapacity = Effect.fnUntraced(function* <A>(
+        effect: Effect.Effect<A, SubscriptionStoreFailure>,
+      ) {
+        const result = yield* Effect.result(effect);
 
-          yield* ensure(
-            Result.isFailure(result) &&
-              result.failure._tag === "SubscriptionError" &&
-              result.failure.reason === "capacity",
-            "live work did not reserve capacity",
-          );
-        });
+        yield* ensure(
+          Result.isFailure(result) &&
+            result.failure._tag === "SubscriptionError" &&
+            result.failure.reason === "capacity",
+          "live work did not reserve capacity",
+        );
+      });
 
       const expiring = record("expiring");
 

package/src/durable/Subscriptions.ts

@@ -584,25 +584,24 @@ const makeManagement = Effect.fnUntraced(function* (requested: SubscriptionLimit
 
   return Subscriptions.of({
     getSubscription,
-    recoverSubscription: (scopeValue, key, expectedRevision) =>
-      Effect.gen(function* () {
-        const owner = yield* scope(scopeValue);
-
-        yield* authorizer.manage("recover", owner);
-
-        return snapshot(
-          yield* store.change(
-            yield* ownedKey(owner, key),
-            expectedRevision,
-            {
-              _tag: "Recover",
-              nowMillis: yield* now,
-            },
-            limits,
-          ),
-          yield* now,
-        );
-      }),
+    recoverSubscription: Effect.fnUntraced(function* (scopeValue, key, expectedRevision) {
+      const owner = yield* scope(scopeValue);
+
+      yield* authorizer.manage("recover", owner);
+
+      return snapshot(
+        yield* store.change(
+          yield* ownedKey(owner, key),
+          expectedRevision,
+          {
+            _tag: "Recover",
+            nowMillis: yield* now,
+          },
+          limits,
+        ),
+        yield* now,
+      );
+    }),
     recoverDelivery,
     subscribe,
     updateSubscription,

package/src/durable/ThreadImport.ts

@@ -701,28 +701,27 @@ export const prepareImportPage = Effect.fnUntraced(function* (
   return { archive, records, batches: prepared } satisfies PreparedImportPage;
 });
 
-export const finishThreadImport = (state: ThreadImportProgress) =>
-  Effect.gen(function* () {
-    const page = state.manifest;
+export const finishThreadImport = Effect.fnUntraced(function* (state: ThreadImportProgress) {
+  const page = state.manifest;
 
-    if (
-      page === undefined ||
-      !state.ended ||
-      state.sequence !== page.tailSequence ||
-      transferSections.some((section) => state.counts[section] !== page.snapshot[section])
-    )
-      return yield* invalid(
-        "Transfer stream ended before its complete canonical sequence and fact sections",
-      );
+  if (
+    page === undefined ||
+    !state.ended ||
+    state.sequence !== page.tailSequence ||
+    transferSections.some((section) => state.counts[section] !== page.snapshot[section])
+  )
+    return yield* invalid(
+      "Transfer stream ended before its complete canonical sequence and fact sections",
+    );
 
-    return ThreadImportResult.make({
-      threadId: page.threadId,
-      format: page.format,
-      tailSequence: page.tailSequence,
-      recordCount: state.sequence,
-      submissionCount: state.counts.admissions,
-    });
+  return ThreadImportResult.make({
+    threadId: page.threadId,
+    format: page.format,
+    tailSequence: page.tailSequence,
+    recordCount: state.sequence,
+    submissionCount: state.counts.admissions,
   });
+});
 
 /** An executed receipt must settle strictly after its own input. FIFO inputs are checked in one pass. */
 export const verifyImportedInputOrder = Effect.fnUntraced(function* (

package/src/durable/ThreadInvariants.ts

@@ -130,7 +130,8 @@ export const verifyThreadInvariants = Effect.fnUntraced(function* <E, R>(
               selected === undefined ||
               selected.sequence !== entry.sequence ||
               selected.batchId !== entry.batchId ||
-              recordEncoding(selected.record).json !== recordEncoding(entry.record).json
+              (yield* Effect.fromResult(recordEncoding(selected.record))).json !==
+                (yield* Effect.fromResult(recordEncoding(entry.record))).json
             )
               fail(
                 "continuation-evidence",

package/src/durable/ThreadStore.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, Option, Predicate, Result, Schema, Stream, Struct } from "effect";
+import { Context, Effect, Layer, Option, Result, Schema, Stream, Struct } from "effect";
 
 import { ReceiptId, RunId, SubmissionId, ThreadId, ToolCallId } from "../core/Identifiers.ts";
 import { utf8ByteLength } from "../core/internal/utf8.ts";
@@ -189,10 +189,10 @@ const selectedRecords = Effect.fnUntraced(function* (
       )
         return yield* incomplete("read selection identity");
       afterSequence = entry.sequence;
-      bytes += yield* Effect.try({
-        try: () => recordEncoding(entry.record).bytes,
-        catch: () => incomplete("read selection bytes"),
-      });
+      bytes += yield* Effect.fromResult(recordEncoding(entry.record)).pipe(
+        Effect.map((record) => record.bytes),
+        Effect.mapError(() => incomplete("read selection bytes")),
+      );
       if (bytes > MAX_THREAD_EXPORT_PAGE_BYTES)
         return yield* incomplete("read selection byte limit");
       records.push(entry);
@@ -356,11 +356,101 @@ const validateRecordCount = Schema.decodeUnknownSync(
   Schema.Array(Schema.Unknown).check(Schema.isMaxLength(256)),
 );
 
-const executionJson = Schema.fromJsonString(ExecutionUpdate);
-const encodeExecution = Schema.encodeSync(executionJson);
-const decodeExecution = Schema.decodeUnknownSync(ExecutionUpdate);
+const validateExecutionHeader = Schema.decodeUnknownSync(
+  Schema.Struct({
+    previousRevision: ExecutionUpdate.fields.previousRevision,
+    retire: ExecutionUpdate.fields.retire,
+    checkpoint: Schema.Struct({
+      version: ExecutionCheckpoint.fields.version,
+      canonicalRecords: ExecutionCheckpoint.fields.canonicalRecords,
+      originalSequence: ExecutionCheckpoint.fields.originalSequence,
+      throughSequence: ExecutionCheckpoint.fields.throughSequence,
+      batchId: ExecutionCheckpoint.fields.batchId,
+    }),
+  }),
+);
+
+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 factsInput = input.facts;
+
+  const operationalLength = validateExecutionRecordCount(operationalInput).length;
+  const factsLength = validateExecutionRecordCount(factsInput).length;
 
-const capturedAppends = new WeakMap<AppendRequest, PreparedAppend>();
+  const progress = captureRecord(input.checkpoint.progressRecord);
+
+  if (Result.isFailure(progress)) return Result.fail(progress.failure);
+  const progressRecord = progress.success.canonical;
+
+  if (!isExecutionProgressRecord(progressRecord))
+    return Result.fail(
+      ThreadStoreError.make({
+        operation: "prepare durable commit",
+        message: "Expected a Run continuation record",
+      }),
+    );
+
+  // Use the Schema-validated indexed lengths, never a caller's iterator. Sparse slots
+  // still visit the record boundary, where undefined is refused.
+  const operational = [];
+
+  for (let index = 0; index < operationalLength; index++) {
+    const record = captureRecord(operationalInput[index]!);
+
+    if (Result.isFailure(record)) return Result.fail(record.failure);
+    operational.push(record.success);
+  }
+  const facts = [];
+
+  for (let index = 0; index < factsLength; index++) {
+    const record = captureRecord(factsInput[index]!);
+
+    if (Result.isFailure(record)) return Result.fail(record.failure);
+    facts.push(record.success);
+  }
+
+  // Keep the actual owned arrays within the persisted bounds as well.
+  validateExecutionRecordCount(operational);
+  validateExecutionRecordCount(facts);
+
+  const checkpoint = Object.freeze(
+    ExecutionCheckpoint.make(
+      {
+        ...header.checkpoint,
+        progressRecord,
+        operational: Object.freeze(operational.map(({ canonical }) => canonical)),
+      },
+      { disableChecks: true },
+    ),
+  );
+
+  const update = Object.freeze(
+    ExecutionUpdate.make(
+      {
+        previousRevision: header.previousRevision,
+        retire: header.retire,
+        checkpoint,
+        facts: Object.freeze(facts.map(({ canonical }) => canonical)),
+      },
+      { disableChecks: true },
+    ),
+  );
+
+  const checkpointJson = `{"version":${checkpoint.version},"progressRecord":${progress.success.json},"operational":[${operational.map(({ json }) => json).join(",")}],"canonicalRecords":${checkpoint.canonicalRecords},"originalSequence":${checkpoint.originalSequence},"throughSequence":${checkpoint.throughSequence},"batchId":${JSON.stringify(checkpoint.batchId)}}`;
+  const json = `{"previousRevision":${update.previousRevision},"checkpoint":${checkpointJson},"facts":[${facts.map(({ json }) => json).join(",")}],"retire":${update.retire}}`;
+
+  return Result.succeed(
+    Object.freeze({ update, json, checkpointJson, bytes: utf8ByteLength(json) }),
+  );
+};
+
+const capturedAppends = new WeakMap<AppendRequest, CapturedAppend>();
 
 /**
  * Admission reserves one complete batch's envelope, references, snapshot and continuation cursor.
@@ -418,122 +508,125 @@ export interface PreparedAppend extends AppendRequest {
   }>;
 }
 
+interface CapturedAppend extends PreparedAppend {
+  readonly records: ReadonlyArray<
+    Omit<PreparedAppend["records"][number], "wire"> & {
+      readonly wire: typeof RecordEnvelope.Encoded;
+    }
+  >;
+}
+
 export const PreparedAppend = {
-  capture: (input: AppendRequest): Effect.Effect<PreparedAppend, ThreadStoreError> =>
+  capture: (input: AppendRequest): Effect.Effect<CapturedAppend, ThreadStoreError> =>
     Effect.suspend(() => {
       const existing = capturedAppends.get(input);
 
       if (existing !== undefined) return Effect.succeed(existing);
 
       return Effect.try({
-        try: () => {
-          const header = validateHeader({
-            ...input,
-            batchId: input.batch.batchId,
-            producerId: input.batch.producerId,
-          });
-
-          validateRecordCount(input.batch.records);
-          validateRecordCount(input.executions ?? []);
-
-          const executionWrites = Object.freeze(
-            (input.executions ?? []).map((update) => {
-              const json = encodeExecution(update);
-              const wire: unknown = JSON.parse(json);
-              const decoded = decodeExecution(wire);
-
-              if (!Predicate.hasProperty(wire, "checkpoint"))
-                throw ThreadStoreError.make({
-                  operation: "prepare durable commit",
-                  message: "Captured execution has no checkpoint wire",
-                });
-
-              return Object.freeze({
-                update: decoded,
-                json,
-                checkpointJson: JSON.stringify(wire.checkpoint),
-                bytes: utf8ByteLength(json),
-              });
-            }),
-          );
-
-          if (input.batch.records.length === 0 && executionWrites.length === 0)
-            throw ThreadStoreError.make({
-              operation: "prepare durable commit",
-              message: "A commit must contain history facts or an active execution transition",
-            });
-          if (executionWrites.some(({ bytes }) => !transferPageFits(header.threadId, bytes)))
-            throw ThreadStoreError.make({
-              operation: "prepare durable commit",
-              message: "Active state exceeds its bounded transfer representation",
-            });
-          // Visit sparse slots too: capture owns each record's validation boundary.
-          const encodings = Array.from(input.batch.records, captureRecord);
-          const prefix = `{"batchId":${JSON.stringify(header.batchId)},"producerId":${JSON.stringify(header.producerId)},"records":[`;
-          const batchJson = `${prefix}${encodings.map(({ json }) => json).join(",")}]}`;
-
-          const batchBytes = encodings.reduce(
-            (total, record) => total + record.bytes,
-            utf8ByteLength(prefix) + (encodings.length === 0 ? 2 : encodings.length + 1),
-          );
-
-          if (batchBytes > MAX_CANONICAL_BATCH_BYTES)
-            throw ThreadStoreError.make({
-              operation: "prepare canonical append",
-              message: `Canonical batch exceeds ${MAX_CANONICAL_BATCH_BYTES} bytes`,
+        try: () =>
+          Result.gen(function* () {
+            const header = validateHeader({
+              ...input,
+              batchId: input.batch.batchId,
+              producerId: input.batch.producerId,
             });
 
-          const batch = Object.freeze(
-            new CommitBatch(
+            validateRecordCount(input.batch.records);
+            const executions = input.executions ?? [];
+            const executionLength = validateRecordCount(executions).length;
+
+            const executionWrites: Array<PreparedAppend["executionWrites"][number]> = [];
+
+            for (let index = 0; index < executionLength; index++)
+              executionWrites.push(yield* captureExecution(executions[index]!));
+            Object.freeze(executionWrites);
+
+            validateRecordCount(executionWrites);
+
+            if (input.batch.records.length === 0 && executionWrites.length === 0)
+              return yield* Result.fail(
+                ThreadStoreError.make({
+                  operation: "prepare durable commit",
+                  message: "A commit must contain history facts or an active execution transition",
+                }),
+              );
+            if (executionWrites.some(({ bytes }) => !transferPageFits(header.threadId, bytes)))
+              return yield* Result.fail(
+                ThreadStoreError.make({
+                  operation: "prepare durable commit",
+                  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));
+            const prefix = `{"batchId":${JSON.stringify(header.batchId)},"producerId":${JSON.stringify(header.producerId)},"records":[`;
+            const batchJson = `${prefix}${encodings.map(({ json }) => json).join(",")}]}`;
+
+            const batchBytes = encodings.reduce(
+              (total, record) => total + record.bytes,
+              utf8ByteLength(prefix) + (encodings.length === 0 ? 2 : encodings.length + 1),
+            );
+
+            if (batchBytes > MAX_CANONICAL_BATCH_BYTES)
+              return yield* Result.fail(
+                ThreadStoreError.make({
+                  operation: "prepare canonical append",
+                  message: `Canonical batch exceeds ${MAX_CANONICAL_BATCH_BYTES} bytes`,
+                }),
+              );
+
+            const batch = Object.freeze(
+              CommitBatch.make(
+                {
+                  batchId: header.batchId,
+                  producerId: header.producerId,
+                  records: Object.freeze(encodings.map(({ canonical }) => canonical)),
+                },
+                { disableChecks: true },
+              ),
+            );
+
+            const request = AppendRequest.make(
               {
-                batchId: header.batchId,
-                producerId: header.producerId,
-                records: Object.freeze(encodings.map(({ canonical }) => canonical)),
+                threadId: header.threadId,
+                expectedTailSequence: header.expectedTailSequence,
+                batch,
+                ...(executionWrites.length === 0
+                  ? {}
+                  : { executions: Object.freeze(executionWrites.map(({ update }) => update)) }),
               },
               { disableChecks: true },
-            ),
-          );
-
-          const request = new AppendRequest(
-            {
-              threadId: header.threadId,
-              expectedTailSequence: header.expectedTailSequence,
-              batch,
-              ...(executionWrites.length === 0
-                ? {}
-                : { executions: Object.freeze(executionWrites.map(({ update }) => update)) }),
-            },
-            { disableChecks: true },
-          );
-
-          const records = Object.freeze(
-            encodings.map(({ canonical, json, wire, bytes }) =>
-              Object.freeze({
-                recordId: canonical.recordId,
-                recordJson: json,
-                recordBytes: bytes,
-                wire,
-                canonical,
+            );
+
+            const records = Object.freeze(
+              encodings.map(({ canonical, json, wire, bytes }) =>
+                Object.freeze({
+                  recordId: canonical.recordId,
+                  recordJson: json,
+                  recordBytes: bytes,
+                  wire,
+                  canonical,
+                }),
+              ),
+            );
+
+            const progress = Object.freeze(encodings.map(({ progress }) => progress));
+
+            const captured = Object.freeze(
+              Object.assign(request, {
+                batchJson,
+                batchBytes,
+                records,
+                progress,
+                executionWrites,
               }),
-            ),
-          );
-
-          const progress = Object.freeze(encodings.map(({ progress }) => progress));
+            );
 
-          const captured = Object.freeze(
-            Object.assign(request, {
-              batchJson,
-              batchBytes,
-              records,
-              progress,
-              executionWrites,
-            }),
-          );
+            capturedAppends.set(captured, captured);
 
-          capturedAppends.set(captured, captured);
-
-          return captured;
-        },
+            return captured;
+          }),
         catch: (cause) =>
           Schema.is(ThreadStoreError)(cause)
             ? cause
@@ -544,7 +637,18 @@ export const PreparedAppend = {
                   : "Canonical append capture failed",
                 cause,
               }),
-      });
+      }).pipe(
+        Effect.flatMap(Effect.fromResult),
+        Effect.mapError((cause) =>
+          Schema.is(ThreadStoreError)(cause)
+            ? cause
+            : ThreadStoreError.make({
+                operation: "prepare canonical append",
+                message: cause.message,
+                cause,
+              }),
+        ),
+      );
     }),
 };
 

package/src/durable/ThreadWork.ts

@@ -1,4 +1,3 @@
-import type { Crypto } from "effect";
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
 
 import { ReceiptId, RunId, SubmissionId, ThreadId, ToolCallId } from "../core/Identifiers.ts";
@@ -487,7 +486,7 @@ export type WorkIndexChange =
 export const workIndexChanges = Effect.fnUntraced(function* (
   envelope: CanonicalRecordEnvelope,
   reporting: WorkerReportingMode,
-): Effect.fn.Return<ReadonlyArray<WorkIndexChange>, ThreadStoreError, Crypto.Crypto> {
+): Effect.fn.Return<ReadonlyArray<WorkIndexChange>, ThreadStoreError> {
   const { record, sequence } = envelope;
   const payload = record.payload;
 

package/src/durable/internal/StorageOwner.ts

@@ -52,9 +52,13 @@ export const makeStorageOwner = Effect.fnUntraced(function* (gate: MutationGate)
   const active = new Map<string, { readonly claim: Claim; closed: boolean }>();
 
   const withMutation: MutationGate = (effect) =>
-    Effect.flatMap(ActiveOwner, (current) =>
-      current === identity ? effect : gate(Effect.provideService(effect, ActiveOwner, identity)),
-    );
+    Effect.withFiber((fiber) => {
+      const current = fiber.getRef(ActiveOwner);
+
+      return current === identity
+        ? effect
+        : gate(Effect.provideService(effect, ActiveOwner, identity));
+    });
 
   yield* Effect.addFinalizer(() =>
     withMutation(
@@ -70,7 +74,9 @@ export const makeStorageOwner = Effect.fnUntraced(function* (gate: MutationGate)
     identity,
     withMutation,
     withProgress: (threadId, effect) =>
-      Effect.flatMap(ActiveProgress, (current) => {
+      Effect.withFiber((fiber) => {
+        const current = fiber.getRef(ActiveProgress);
+
         if (current?.owner === identity && current.threadId === threadId) return effect;
 
         return Effect.suspend(() => {