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

package/src/durable/SqlMemoryStore.ts

@@ -33,11 +33,13 @@ const EncodedMemoryChange = Schema.Struct({
   resultJson: StoredJson,
 });
 
-const equivalentContent = Schema.toEquivalence(
-  Schema.toEncoded(MemoryWrite.Wire.members[0].fields.content),
-);
+const makeEquivalentContent = () =>
+  Schema.toEquivalence(Schema.toEncoded(MemoryWrite.Wire.members[0].fields.content));
+
+let equivalentContent: ReturnType<typeof makeEquivalentContent> | undefined;
 
-const equivalentScopes = Schema.toEquivalence(MemoryWrite.Wire.members[0].fields.scopes);
+const makeEquivalentScopes = () => Schema.toEquivalence(MemoryWrite.Wire.members[0].fields.scopes);
+let equivalentScopes: ReturnType<typeof makeEquivalentScopes> | undefined;
 
 /** Ordered commands committed atomically by the SQL memory adapter. */
 export const SqlMemoryWriteBatch = Schema.Array(MemoryWrite.Wire).check(Schema.isMaxLength(128));
@@ -388,8 +390,8 @@ const validateReceiptResult = Effect.fnUntraced(function* (
       return yield* storageError(operation, "corrupt");
     }
     if (
-      !equivalentContent(command.content, result.content) ||
-      !equivalentScopes(command.scopes, result.scopes)
+      !(equivalentContent ??= makeEquivalentContent())(command.content, result.content) ||
+      !(equivalentScopes ??= makeEquivalentScopes())(command.scopes, result.scopes)
     ) {
       return yield* storageError(operation, "corrupt");
     }

package/src/durable/SubmissionLedger.ts

@@ -989,6 +989,10 @@ export type SubmissionLedgerFailure =
  *   An optional `parentLinkage` is recorded immutably at first admission (SUB-016); a replay
  *   whose linkage diverges (present vs. absent, or different identities) fails with
  *   `AdmissionConflict` even when the input digest matches.
+ *   With `readyIfInitialized`, an adapter may insert a fresh ordinary Submission as ready
+ *   when it proves Thread initialization under the admission's owner transaction. Readiness,
+ *   its lifecycle fact and source progress commit with the receipt. Otherwise it returns
+ *   admitted and the caller completes materialization and `markReady` as usual.
  * - `resolveAdmission` — authoritative tri-state admission lookup by scoped idempotency key
  *   (SUB-031): `NotAdmitted` proves absence, `Admitted` carries the full snapshot, and
  *   `Indeterminate` states that the adapter cannot currently prove either. Only `NotAdmitted`
@@ -1093,6 +1097,7 @@ export class SubmissionLedger extends Context.Service<
     readonly capabilities: Effect.Effect<LedgerCapabilities>;
     readonly admit: (
       request: AdmissionRequest,
+      options?: { readonly readyIfInitialized?: boolean },
     ) => Effect.Effect<AdmissionResult, AdmissionConflict | AdmissionPolicyError | LedgerError>;
     readonly markReady: (request: MarkReadyRequest) => Effect.Effect<void, LedgerError>;
     readonly lookup: (
@@ -1168,6 +1173,8 @@ export class SubmissionLedger extends Context.Service<
       request: ReleaseChildBudgetRequest,
     ) => Effect.Effect<ChildBudgetReservationSnapshot, ChildReservationConflict | LedgerError>;
     readonly scanNonterminal: Stream.Stream<SubmissionWorkItem, LedgerError>;
+    /** Optional native snapshot for hosts that need the complete control worklist. */
+    readonly listNonterminal?: Effect.Effect<ReadonlyArray<SubmissionWorkItem>, LedgerError>;
     readonly loadRecoverySnapshot: (
       request: RecoverySnapshotRequest,
     ) => Effect.Effect<RecoverySnapshot, LedgerError>;

package/src/durable/ThreadStore.ts

@@ -415,10 +415,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 +442,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 +499,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<{
@@ -542,8 +546,6 @@ export const PreparedAppend = {
               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({

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/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));