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

package/src/durable/DurableAgentRuntime.ts

@@ -156,7 +156,7 @@ import {
   resolveWorkerBinding,
   CurrentBindingSelection,
 } from "./internal/agent-registration.ts";
-import { makeAgentUpdateRuntime } from "./internal/agent-updates.ts";
+import { makeAgentUpdateRuntime, nativeUpdateAccepted } from "./internal/agent-updates.ts";
 import { inspectForeignDiagnostic, safeUnknownString } from "./internal/foreign-diagnostic.ts";
 import { initialContext, type InitialContextInput } from "./internal/initial-context.ts";
 import {
@@ -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";
@@ -3094,6 +3094,22 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         recovered += 1;
       });
 
+      // Retry permission cannot mask a recorded outcome or require a runnable old binding.
+      // Explicit factual resolutions and abort instructions retain their own handling below.
+      if (
+        (intent === undefined || intent.resolution._tag === "SafeToRetry") &&
+        declared !== undefined &&
+        nativeUpdateAccepted(submission, declared, records)
+      ) {
+        yield* appendClosedCall(ctx, submissionId, knownIds, call, {
+          result: { value: { emitted: true }, isFailure: false },
+          resolution: "completed-with-result",
+          author: RECONCILER_AUTHOR,
+          reason: "The exact native update was canonically accepted",
+        });
+        recovered += 1;
+        continue;
+      }
       if (intent !== undefined) {
         switch (intent.resolution._tag) {
           case "AbortSubmission":
@@ -4902,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>,
@@ -5437,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) {
@@ -7814,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 }),
@@ -8285,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 }),
-                );
+      // 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;
 
-                const submission = snapshot.submission;
-
-                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;
 
@@ -8925,6 +8875,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           view.progressThrough,
           view.progress,
           view.context,
+          view.operational,
           takeJournalMetadata(),
           lineage,
           approvalDecisionIntents,
@@ -9649,6 +9600,8 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     for (const intent of intents) {
       const original = declared.get(intent.toolCallId);
 
+      if (original !== undefined && nativeUpdateAccepted(submission, original, records)) continue;
+
       if (
         original === undefined ||
         (current !== undefined &&
@@ -9830,9 +9783,52 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         return yield* applyUnknownResolutionsForRecovery(snapshot, evidence, records);
       }
       case "AwaitUnknownResolution": {
-        // This Submission stays parked awaiting the authorized DUR-017 resolution path;
-        // the settlement obligation stays visible, nothing replays.
-        return "unknown";
+        // Older Attempts may already have marked a native update unknown. Its exact
+        // canonical acceptance is a factual resolution, never permission to retry an
+        // external operation. The ledger wakes only when every unknown call is covered;
+        // the next owner appends closure under the original call identity.
+        const declared = yield* declaredCallsFor(
+          records,
+          runId,
+          new Set(evidence.openToolCalls.map((call) => call.toolCallId)),
+        );
+
+        let repaired = false;
+
+        for (const call of declared.values()) {
+          if (
+            snapshot.unknownResolutions.some((intent) => intent.toolCallId === call.toolCallId) ||
+            !nativeUpdateAccepted(submission, call, records)
+          )
+            continue;
+          yield* ledger
+            .recordUnknownResolution(
+              UnknownResolutionCommand.make({
+                submissionId: submission.submissionId,
+                toolCallId: call.toolCallId,
+                author: RECONCILER_AUTHOR,
+                reason: "The exact native update was canonically accepted",
+                resolution: {
+                  _tag: "CompletedWithResult",
+                  result: { emitted: true },
+                  isFailure: false,
+                },
+              }),
+            )
+            .pipe(
+              Effect.catchTag("UnknownResolutionConflict", (cause) =>
+                LedgerError.make({
+                  operation: "recover native update",
+                  message: "Native acceptance conflicts with a retained resolution",
+                  cause,
+                }),
+              ),
+            );
+          repaired = true;
+        }
+        if (repaired) yield* wake.notify(submission.threadId);
+
+        return repaired ? "repaired" : "unknown";
       }
       case "AwaitApprovalDecision": {
         return yield* awaitApprovalForRecovery(snapshot, evidence, decision);
@@ -10486,8 +10482,11 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
     const factual = intent?.resolution;
 
+    const acceptedNative =
+      factual === undefined && (yield* updateRuntime.accepted(submission, selected.declared));
+
     const reconciliation =
-      factual === undefined && selected.declared.executionKind === "ordinary"
+      factual === undefined && !acceptedNative && selected.declared.executionKind === "ordinary"
         ? yield* reconciler
             .reconcile(
               DeclaredToolCallEvidence.make({
@@ -10505,9 +10504,11 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     const completed =
       factual?._tag === "CompletedWithResult"
         ? factual
-        : Option.isSome(reconciliation) && reconciliation.value._tag === "CompletedWithResult"
-          ? reconciliation.value
-          : undefined;
+        : acceptedNative
+          ? { result: { emitted: true }, isFailure: false }
+          : Option.isSome(reconciliation) && reconciliation.value._tag === "CompletedWithResult"
+            ? reconciliation.value
+            : undefined;
 
     const neverStarted =
       factual?._tag === "NeverHappened" ||

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