@yielded/agent 0.1.0-beta.174 → 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;
@@ -415,10 +428,6 @@ const captureExecution = (input: ExecutionUpdate) => {
     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(
       {
@@ -446,7 +455,13 @@ const captureExecution = (input: ExecutionUpdate) => {
   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) }),
+    Object.freeze({
+      update,
+      json,
+      checkpointJson,
+      factsJson: JSON.stringify(facts.map(({ wire }) => wire)),
+      bytes: utf8ByteLength(json),
+    }),
   );
 };
 
@@ -497,6 +512,8 @@ export interface PreparedAppend extends AppendRequest {
     readonly json: string;
     /** Checkpoint wire from the same detached, validated execution capture. */
     readonly checkpointJson: string;
+    /** Schema-encoded fact array from this same capture, for the stable retry digest. */
+    readonly factsJson: string;
     readonly bytes: number;
   }>;
   readonly records: ReadonlyArray<{
@@ -526,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]> = [];
 
@@ -542,9 +563,7 @@ export const PreparedAppend = {
               executionWrites.push(yield* captureExecution(executions[index]!));
             Object.freeze(executionWrites);
 
-            validateRecordCount(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",
@@ -558,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/ThreadWork.ts

@@ -144,6 +144,10 @@ export const ThreadWorkCursor = Schema.Struct({
 
 export type ThreadWorkCursor = typeof ThreadWorkCursor.Type;
 
+/** Local snapshot request; it grants no claim or dispatch authority. */
+export const FreshAdmissionWork = Schema.Struct({ threadId: ThreadId, submissionId: SubmissionId });
+export type FreshAdmissionWork = typeof FreshAdmissionWork.Type;
+
 export const WorkThreadsRequest = Schema.Struct({
   afterThreadId: Schema.optionalKey(ThreadId),
   limit: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 32 })),
@@ -192,6 +196,12 @@ export class WorkDiscoveryUnavailable extends Schema.TaggedError<WorkDiscoveryUn
 
 /** Native owner pages and canonical-index maintenance, implemented at the storage owner. */
 export interface ThreadWorkStorage {
+  /** Native proof that this untouched root admission has no other recovery obligations.
+   * A caller must still claim and validate current controls before dispatch. */
+  readonly isOnlyFreshAdmission?: (
+    request: FreshAdmissionWork,
+  ) => Effect.Effect<boolean, ThreadStoreError>;
+
   readonly threads: (
     request: WorkThreadsRequest,
   ) => Effect.Effect<WorkThreadsPage, ThreadStoreError>;

package/src/durable/WakeScheduler.ts

@@ -1,5 +1,5 @@
 import type { Scope } from "effect";
-import { Context, Deferred, Effect, Layer, Ref, Stream } from "effect";
+import { Context, Deferred, Effect, Layer, Stream } from "effect";
 
 import { type ThreadId } from "../core/Identifiers.ts";
 
@@ -17,79 +17,47 @@ export interface WakeSubscriptionHub {
   readonly notify: (threadId: ThreadId) => Effect.Effect<void>;
 }
 
-interface WakeRegistration {
-  readonly id: number;
-  readonly deferred: Deferred.Deferred<void>;
-}
-
-type WakeRegistrations = ReadonlyMap<ThreadId, ReadonlyMap<number, Deferred.Deferred<void>>>;
-
 /**
  * Build the shared per-incarnation registration primitive used by host WakeSchedulers. The hub
  * contains hints only: eviction may discard it, while a reconnecting caller re-subscribes and
  * rechecks canonical storage. Scope finalizers remove cancelled waiters, and notify broadcasts
  * instead of consuming a signal that belongs to another waiter.
  */
-export const makeWakeSubscriptionHub: Effect.Effect<WakeSubscriptionHub> = Effect.gen(function* () {
-  const registrations = yield* Ref.make<WakeRegistrations>(new Map());
-  const nextId = yield* Ref.make(0);
-
-  const remove = (threadId: ThreadId, id: number) =>
-    Ref.update(registrations, (current) => {
-      const existing = current.get(threadId);
-
-      if (existing === undefined || !existing.has(id)) return current;
-      const next = new Map(current);
-      const thread = new Map(existing);
-
-      thread.delete(id);
-      if (thread.size === 0) {
-        next.delete(threadId);
-      } else {
-        next.set(threadId, thread);
-      }
-
-      return next;
+export const makeWakeSubscriptionHub: Effect.Effect<WakeSubscriptionHub> = Effect.sync(() => {
+  const registrations = new Map<ThreadId, Set<Deferred.Deferred<void>>>();
+
+  const subscribe = (threadId: ThreadId) =>
+    Effect.acquireRelease(
+      Effect.sync(() => {
+        const deferred = Deferred.makeUnsafe<void>();
+        let waiters = registrations.get(threadId);
+
+        if (waiters === undefined) {
+          waiters = new Set();
+          registrations.set(threadId, waiters);
+        }
+        waiters.add(deferred);
+
+        return deferred;
+      }),
+      (deferred) =>
+        Effect.sync(() => {
+          const waiters = registrations.get(threadId);
+
+          if (waiters?.delete(deferred) && waiters.size === 0) registrations.delete(threadId);
+        }),
+    ).pipe(Effect.map(Deferred.await));
+
+  const notify = (threadId: ThreadId) =>
+    Effect.sync(() => {
+      const waiters = registrations.get(threadId);
+
+      if (waiters === undefined) return;
+      // Detach before resuming: a resumed waiter may register its next wait immediately.
+      registrations.delete(threadId);
+      for (const waiter of waiters) Deferred.doneUnsafe(waiter, Effect.void);
     });
 
-  const subscribe = Effect.fnUntraced(function* (
-    threadId: ThreadId,
-  ): Effect.fn.Return<Effect.Effect<void>, never, Scope.Scope> {
-    const deferred = yield* Deferred.make<void>();
-    const id = yield* Ref.getAndUpdate(nextId, (current) => current + 1);
-    const registration: WakeRegistration = { id, deferred };
-
-    yield* Effect.addFinalizer(() => remove(threadId, registration.id));
-    yield* Ref.update(registrations, (current) => {
-      const next = new Map(current);
-      const thread = new Map(current.get(threadId) ?? []);
-
-      thread.set(registration.id, registration.deferred);
-      next.set(threadId, thread);
-
-      return next;
-    });
-
-    return Deferred.await(registration.deferred);
-  });
-
-  const notify = Effect.fnUntraced(function* (threadId: ThreadId) {
-    const waiters = yield* Ref.modify(registrations, (current) => {
-      const thread = current.get(threadId);
-
-      if (thread === undefined) return [[], current] as const;
-      const next = new Map(current);
-
-      next.delete(threadId);
-
-      return [[...thread.values()], next] as const;
-    });
-
-    yield* Effect.forEach(waiters, (waiter) => Deferred.succeed(waiter, undefined), {
-      discard: true,
-    });
-  });
-
   return { subscribe, notify };
 });
 

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,
     ) {

package/src/durable/internal/usage-totals.ts

@@ -3,36 +3,33 @@ import { Effect } from "effect";
 import { summarizeModelUsage, type ModelCallUsage } from "../../core/Usage.ts";
 
 /** Captured calls are additive and nonnegative; progress does not need attribution groups. */
-export const continuationUsage = Effect.fnUntraced(function* (
-  calls: ReadonlyArray<ModelCallUsage>,
-) {
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let costMicrousd = 0;
-  let knownWebSearchCalls = 0;
+export const continuationUsage = (calls: ReadonlyArray<ModelCallUsage>) =>
+  Effect.suspend(() => {
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let costMicrousd = 0;
+    let knownWebSearchCalls = 0;
 
-  for (const call of calls) {
-    inputTokens += call.inputTokens.total;
-    outputTokens += call.outputTokens.total;
-    costMicrousd += call.costMicrousd;
-    knownWebSearchCalls += call.webSearchCalls ?? 0;
-  }
-  if (
-    Number.isSafeInteger(inputTokens) &&
-    Number.isSafeInteger(outputTokens) &&
-    Number.isSafeInteger(costMicrousd) &&
-    Number.isSafeInteger(knownWebSearchCalls)
-  )
-    return { modelCalls: calls.length, inputTokens, outputTokens, costMicrousd };
+    for (const call of calls) {
+      inputTokens += call.inputTokens.total;
+      outputTokens += call.outputTokens.total;
+      costMicrousd += call.costMicrousd;
+      knownWebSearchCalls += call.webSearchCalls ?? 0;
+    }
+    if (
+      Number.isSafeInteger(inputTokens) &&
+      Number.isSafeInteger(outputTokens) &&
+      Number.isSafeInteger(costMicrousd) &&
+      Number.isSafeInteger(knownWebSearchCalls)
+    )
+      return Effect.succeed({ modelCalls: calls.length, inputTokens, outputTokens, costMicrousd });
 
-  // Safe global sums bound every component/group. On overflow retain the full validator,
-  // including groups whose hosted-search coverage differs from the aggregate's coverage.
-  const summary = yield* summarizeModelUsage(calls);
-
-  return {
-    modelCalls: summary.modelCalls,
-    inputTokens: summary.inputTokens.total,
-    outputTokens: summary.outputTokens.total,
-    costMicrousd: summary.costMicrousd,
-  };
-});
+    // Safe global sums bound every component/group. On overflow retain the full validator,
+    // including groups whose hosted-search coverage differs from the aggregate's coverage.
+    return Effect.map(summarizeModelUsage(calls), (summary) => ({
+      modelCalls: summary.modelCalls,
+      inputTokens: summary.inputTokens.total,
+      outputTokens: summary.outputTokens.total,
+      costMicrousd: summary.costMicrousd,
+    }));
+  });

package/src/engine/MessagingHost.ts

@@ -1,4 +1,4 @@
-import type { Effect } from "effect";
+import { Effect } from "effect";
 import * as Context from "effect/Context";
 
 import type { AnyDefinition } from "../core/Agent.ts";
@@ -47,7 +47,9 @@ export class MessagingHost extends Context.Service<
   }
 >()("@effect-agent/engine/MessagingHost") {
   static readonly unavailable: MessagingHost["Service"] = {
-    context: MessagingError.make({ operation: "context", reason: "unavailable" }),
+    context: Effect.suspend(() =>
+      MessagingError.make({ operation: "context", reason: "unavailable" }),
+    ),
     send: () => MessagingError.make({ operation: "send", reason: "unavailable" }),
     reply: () => MessagingError.make({ operation: "reply", reason: "unavailable" }),
     inbox: () => MessagingError.make({ operation: "inbox", reason: "unavailable" }),

package/src/engine/ThreadHistory.ts

@@ -75,57 +75,56 @@ export class ThreadHistory extends Context.Service<
   }
 >()("@effect-agent/engine/ThreadHistory") {
   /** Bind incremental history to the supplied Thread.Store, including scoped ownership views. */
-  static readonly layerFromStore = Layer.effect(
-    ThreadHistory,
-    Effect.gen(function* () {
-      const threads = yield* ConversationStore;
+  static readonly makeFromStore = Effect.gen(function* () {
+    const threads = yield* ConversationStore;
 
-      const historyError = (cause: ThreadError): ThreadHistoryError =>
-        ThreadHistoryError.make({
-          threadId: cause.threadId,
-          reason:
-            cause._tag === "ThreadNotFound"
-              ? "not-found"
-              : cause._tag === "ThreadLimitExceeded"
-                ? "limit"
-                : cause._tag === "ThreadHistoryDiverged"
-                  ? "conflict"
-                  : cause._tag === "ThreadOwnershipError"
-                    ? cause.reason === "closed"
-                      ? "fenced"
-                      : "conflict"
-                    : "encoding",
-          message:
-            cause._tag === "ThreadNotFound"
-              ? "Thread history is not present in this application Scope"
-              : cause._tag === "ThreadLimitExceeded"
-                ? `In-memory history exceeds the ${cause.limit} limit of ${cause.limitValue}`
-                : cause.message,
-          cause,
-        });
+    const historyError = (cause: ThreadError): ThreadHistoryError =>
+      ThreadHistoryError.make({
+        threadId: cause.threadId,
+        reason:
+          cause._tag === "ThreadNotFound"
+            ? "not-found"
+            : cause._tag === "ThreadLimitExceeded"
+              ? "limit"
+              : cause._tag === "ThreadHistoryDiverged"
+                ? "conflict"
+                : cause._tag === "ThreadOwnershipError"
+                  ? cause.reason === "closed"
+                    ? "fenced"
+                    : "conflict"
+                  : "encoding",
+        message:
+          cause._tag === "ThreadNotFound"
+            ? "Thread history is not present in this application Scope"
+            : cause._tag === "ThreadLimitExceeded"
+              ? `In-memory history exceeds the ${cause.limit} limit of ${cause.limitValue}`
+              : cause.message,
+        cause,
+      });
 
-      return ThreadHistory.of({
-        retention: "incremental",
-        memoryStore: threads,
-        load: (threadId) =>
-          threads.snapshot(threadId).pipe(Effect.map(toPrompt), Effect.mapError(historyError)),
-        open: Effect.fnUntraced(function* ({ threadId, runId }) {
-          const snapshot = yield* threads.create(threadId).pipe(Effect.mapError(historyError));
+    return ThreadHistory.of({
+      retention: "incremental",
+      memoryStore: threads,
+      load: (threadId) =>
+        threads.snapshot(threadId).pipe(Effect.map(toPrompt), Effect.mapError(historyError)),
+      open: Effect.fnUntraced(function* ({ threadId, runId }) {
+        const snapshot = yield* threads.create(threadId).pipe(Effect.mapError(historyError));
 
-          return {
-            prompt: toPrompt(snapshot),
-            stageInput: () => Effect.void,
-            stageHistory: ({ source }) =>
-              threads
-                .recordHistory(threadId, runId, source)
-                .pipe(Effect.asVoid, Effect.mapError(historyError)),
-            commit: () =>
-              threads.snapshot(threadId).pipe(Effect.asVoid, Effect.mapError(historyError)),
-          };
-        }),
-      });
-    }),
-  );
+        return {
+          prompt: toPrompt(snapshot),
+          stageInput: () => Effect.void,
+          stageHistory: ({ source }) =>
+            threads
+              .recordHistory(threadId, runId, source)
+              .pipe(Effect.asVoid, Effect.mapError(historyError)),
+          commit: () =>
+            threads.snapshot(threadId).pipe(Effect.asVoid, Effect.mapError(historyError)),
+        };
+      }),
+    });
+  });
+
+  static readonly layerFromStore = Layer.effect(ThreadHistory, ThreadHistory.makeFromStore);
 
   /** Retain history for the application Scope, within message and host capacity. Separate Layer builds own separate stores. */
   static readonly layer = ThreadHistory.layerFromStore.pipe(Layer.provideMerge(layerMemory));