@yielded/agent-storage-cloudflare 0.1.0-beta.167 → 0.1.0-beta.168

package/src/PortRouting.ts

@@ -1,6 +1,11 @@
 import type { DurableRuntimeFailpoint } from "@yielded/agent/durable-failpoint";
 import { LifecyclePublicationError } from "@yielded/agent/lifecycle-publication";
 import { MessageDeliveryStore, MessageDeliveryError } from "@yielded/agent/message-delivery";
+import {
+  SettlementPublisher,
+  type SettlementPublicationResult,
+  type SettlementPublicationFailure,
+} from "@yielded/agent/settlement-publisher";
 import {
   AdmissionIndeterminate,
   AdmissionConflict,
@@ -8,6 +13,7 @@ import {
   ChildAttachmentSnapshot,
   JoinedToHost,
   LedgerError,
+  OwnershipLost,
   RecoverySnapshot,
   SettlementConflict,
   SubmissionLedger,
@@ -19,10 +25,13 @@ import {
   AppendConflict,
   ThreadMaterialization,
   ThreadNotMaterialized,
+  ThreadExportRejected,
   ThreadStore,
+  ThreadReader,
   ThreadStoreError,
-  FenceRejected,
 } from "@yielded/agent/thread-store";
+import { checkExportSource } from "@yielded/agent/thread-transfer";
+import { WorkDiscoveryUnavailable } from "@yielded/agent/thread-work";
 import type { WakeScheduler } from "@yielded/agent/wake-scheduler";
 import {
   admitWorker,
@@ -32,6 +41,8 @@ import {
 import { Cause, Clock, Context, Effect, Layer, Option, Predicate, Schema, Stream } from "effect";
 
 import {
+  SettlementPublishCall,
+  SettlementPublishResult,
   WorkerAdmitCall,
   WorkerAdmitResult,
   MessageDeliveryListCall,
@@ -45,6 +56,8 @@ import {
   encodePortResponse,
   LedgerAdmitCall,
   LedgerAdmitResult,
+  LedgerFundingOwnerCall,
+  LedgerFundingOwnerResult,
   LedgerLookupCall,
   LedgerLookupResult,
   LedgerMarkReadyCall,
@@ -62,6 +75,14 @@ import {
   PortFailed,
   PortProtocolError,
   PortSucceeded,
+  StoreRangePageCall,
+  StoreRangePageResult,
+  StoreRangeSealCall,
+  StoreRangeSealResult,
+  StoreRangeArchiveCall,
+  StoreRangeArchiveResult,
+  StoreRangeVerifyCall,
+  StoreRangeVerifyResult,
   StoreAppendCall,
   StoreAppendResult,
   StoreCountPeerMessagesCall,
@@ -70,12 +91,24 @@ import {
   StoreExportResult,
   StoreInspectTailCall,
   StoreInspectTailResult,
+  StoreWorkerCapacityCall,
+  StoreWorkerCapacityResult,
+  StoreVerificationCall,
+  StoreVerificationResult,
   StoreReadIdentityCall,
   StoreReadIdentityResult,
+  StoreReadExecutionCall,
+  StoreReadExecutionResult,
   StoreMaterializeCall,
   StoreMaterializeResult,
   StoreReadPageCall,
   StoreReadPageResult,
+  StoreReadPromptCall,
+  StoreReadPromptResult,
+  StoreWorkPageCall,
+  StoreWorkPageResult,
+  StoreWorkRebuildCall,
+  StoreWorkRebuildResult,
   type PortFailure,
   type PortRequest,
   type PortRequestEnvelope,
@@ -89,6 +122,12 @@ type SubmissionId = SubmissionSnapshot["submissionId"];
 const ThreadIdSchema = ThreadMaterialization.fields.threadId;
 const decodeThreadId = Schema.decodeUnknownEffect(ThreadIdSchema);
 
+/** Owner-local maintenance scope; permits local inventory without global Object enumeration. */
+export const CurrentNativeSource = Context.Reference<boolean>(
+  "@effect-agent/storage-cloudflare/CurrentNativeSource",
+  { defaultValue: () => false },
+);
+
 /**
  * The ledger row bound routable Submission identities must respect (mirrors the local
  * facet's `MAX_IDENTIFIER_LENGTH`; the minting side already refuses longer identities typed
@@ -200,7 +239,7 @@ const LOCAL: RouteTarget = { _tag: "local" };
 const routableSubmissionTarget = (
   ownsThread: RoutedPortOptions["ownsThread"],
 ): ((operation: string, submissionId: string) => Effect.Effect<RouteTarget, LedgerError>) =>
-  Effect.fn("DoPortRouting.routableSubmissionTarget")(function* (
+  Effect.fnUntraced(function* (
     operation: string,
     submissionId: string,
   ): Effect.fn.Return<RouteTarget, LedgerError> {
@@ -239,7 +278,7 @@ export const makeLocalSubmissionLookup = (
 ) => Effect.Effect<Option.Option<SubmissionSnapshot>, LedgerError, SubmissionLedger>) => {
   const submissionTarget = routableSubmissionTarget(options.ownsThread);
 
-  return Effect.fn("DoPortRouting.lookupLocalSubmission")(function* (submissionId: SubmissionId) {
+  return Effect.fnUntraced(function* (submissionId: SubmissionId) {
     const operation = "local Submission lookup";
     const target = yield* submissionTarget(operation, submissionId);
 
@@ -264,7 +303,7 @@ export const makeLocalSubmissionLookup = (
 
 const NoAdditionalPortFailure = Schema.Never;
 const AbortPortFailure = Schema.Union([SettlementConflict, JoinedToHost]);
-const AppendPortFailure = Schema.Union([ThreadNotMaterialized, AppendConflict, FenceRejected]);
+const AppendPortFailure = Schema.Union([ThreadNotMaterialized, AppendConflict, OwnershipLost]);
 
 /**
  * The fail-fast refusal for any foreign operation OUTSIDE the closed route-capable subset
@@ -285,13 +324,13 @@ const crossThreadStoreError = (operation: string, target: string): ThreadStoreEr
     operation,
     message:
       `${operation} addressed to foreign Thread ${target} is not route-capable; the ` +
-      "closed cross-Object subset is materialize, append, read (paged), inspectTail, and " +
+      "closed cross-Object subset is materialize, append, read and readPrompt (paged), inspectTail, and " +
       "export. Observation and checkpoints are lane-local by construction and must execute " +
       "inside the owning Thread's Durable Object.",
   });
 
 const makeTransportCall = (transport: ThreadPortTransport["Service"]) =>
-  Effect.fn("DoPortRouting.transportCall")(function* (target: ThreadId, call: PortRequest) {
+  Effect.fnUntraced(function* (target: ThreadId, call: PortRequest) {
     const encoded = yield* encodePortRequest(call).pipe(
       Effect.mapError((error) =>
         PortProtocolError.make({
@@ -313,9 +352,7 @@ const makeTransportCall = (transport: ThreadPortTransport["Service"]) =>
 
 type TransportCall = ReturnType<typeof makeTransportCall>;
 
-const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServices")(function* (
-  options: RoutedPortOptions,
-) {
+const makeRoutedLedgerServices = Effect.fnUntraced(function* (options: RoutedPortOptions) {
   const local = yield* SubmissionLedger;
   const transport = yield* ThreadPortTransport;
   const transportCall: TransportCall = makeTransportCall(transport);
@@ -480,7 +517,7 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
    * local nor marker-settled. A transport failure surfaces as `LedgerError` so the alarm
    * pass retries; the child's canonical Settlement remains the only authority (DUR-015).
    */
-  const enrichChildAttachments = Effect.fn("DoPortRouting.enrichChildAttachments")(function* (
+  const enrichChildAttachments = Effect.fnUntraced(function* (
     snapshot: RecoverySnapshot,
   ): Effect.fn.Return<RecoverySnapshot, LedgerError> {
     const operation = "ledger load recovery snapshot";
@@ -582,6 +619,37 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
               ),
             ),
 
+    resolveFundingOwner: (request) =>
+      (options.ownsThread(request.threadId)
+        ? local.resolveFundingOwner === undefined
+          ? Effect.fail(
+              LedgerError.make({
+                operation: "resolve funding owner",
+                message: "Native funding-owner lookup unavailable.",
+              }),
+            )
+          : local.resolveFundingOwner(request)
+        : foreignLedgerCall(
+            "resolve funding owner",
+            request.threadId,
+            LedgerFundingOwnerCall.make({ request }),
+            LedgerFundingOwnerResult,
+            NoAdditionalPortFailure,
+          ).pipe(Effect.map((reply) => reply.funding))
+      ).pipe(
+        Effect.filterOrFail(
+          (funding) =>
+            funding.selected.submissionId === request.submissionId &&
+            funding.selected.threadId === request.threadId &&
+            funding.owner.threadId === request.threadId,
+          () =>
+            LedgerError.make({
+              operation: "resolve funding owner",
+              message: "Funding-owner response belongs to another input or Thread.",
+            }),
+        ),
+      ),
+
     resolveAdmission: (request) =>
       options.ownsThread(request.threadId)
         ? local.resolveAdmission(request)
@@ -652,9 +720,9 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
 
     // Every operation below is lane-local by construction (plan §1.3): a foreign address is
     // an out-of-contract call and fails fast typed instead of being quietly distributed.
-    claim: (request) =>
+    selectHead: (request) =>
       options.ownsThread(request.threadId)
-        ? local.claim(request)
+        ? local.selectHead(request)
         : Effect.fail(crossThreadLedgerError("ledger claim", request.threadId)),
 
     claimJoining: (request) =>
@@ -662,24 +730,6 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
         ? local.claimJoining(request)
         : Effect.fail(crossThreadLedgerError("ledger claim joining", request.threadId)),
 
-    renewOwnership: (request) =>
-      submissionTarget("ledger renew ownership", request.submissionId).pipe(
-        Effect.flatMap((target) =>
-          target._tag === "local"
-            ? local.renewOwnership(request)
-            : Effect.fail(crossThreadLedgerError("ledger renew ownership", target.threadId)),
-        ),
-      ),
-
-    releaseOwnership: (request) =>
-      submissionTarget("ledger release ownership", request.submissionId).pipe(
-        Effect.flatMap((target) =>
-          target._tag === "local"
-            ? local.releaseOwnership(request)
-            : Effect.fail(crossThreadLedgerError("ledger release ownership", target.threadId)),
-        ),
-      ),
-
     markInputApplied: (request) =>
       submissionTarget("ledger mark input applied", request.submissionId).pipe(
         Effect.flatMap((target) =>
@@ -689,15 +739,6 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
         ),
       ),
 
-    reserveSettlement: (request) =>
-      submissionTarget("ledger reserve settlement", request.submissionId).pipe(
-        Effect.flatMap((target) =>
-          target._tag === "local"
-            ? local.reserveSettlement(request)
-            : Effect.fail(crossThreadLedgerError("ledger reserve settlement", target.threadId)),
-        ),
-      ),
-
     finalizeSettlement: (request) =>
       submissionTarget("ledger finalize settlement", request.submissionId).pipe(
         Effect.flatMap((target) =>
@@ -806,12 +847,71 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
   return Context.make(SubmissionLedger, routed);
 });
 
-const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices")(function* (
-  options: RoutedPortOptions,
-) {
+/** Route the data-only atomic publication to the same owner as its canonical Thread. */
+export const routedSettlementPublisherLayer = (options: RoutedPortOptions) =>
+  Layer.effect(SettlementPublisher)(
+    Effect.gen(function* () {
+      const local = yield* SettlementPublisher;
+      const call = makeTransportCall(yield* ThreadPortTransport);
+
+      const isFailure = Schema.is(
+        Schema.Union([
+          LedgerError,
+          OwnershipLost,
+          SettlementConflict,
+          ThreadStoreError,
+          ThreadNotMaterialized,
+          AppendConflict,
+        ]),
+      );
+
+      return SettlementPublisher.of({
+        publish: (request) => {
+          if (options.ownsThread(request.append.threadId)) return local.publish(request);
+
+          return call(request.append.threadId, SettlementPublishCall.make({ request })).pipe(
+            Effect.mapError((cause) =>
+              LedgerError.make({
+                operation: "route settlement publication",
+                message: cause.message,
+                cause,
+              }),
+            ),
+            Effect.flatMap(
+              (
+                response,
+              ): Effect.Effect<SettlementPublicationResult, SettlementPublicationFailure> => {
+                if (response._tag === "PortFailed")
+                  return isFailure(response.failure)
+                    ? Effect.fail(response.failure)
+                    : Effect.fail(
+                        LedgerError.make({
+                          operation: "route settlement publication",
+                          message: "Unexpected publication failure",
+                          cause: response.failure,
+                        }),
+                      );
+
+                return response.result._tag === "SettlementPublishResult"
+                  ? Effect.succeed(response.result.result)
+                  : Effect.fail(
+                      LedgerError.make({
+                        operation: "route settlement publication",
+                        message: "Mismatched publication result",
+                      }),
+                    );
+              },
+            ),
+          );
+        },
+      });
+    }),
+  );
+
+const makeRoutedStoreServices = Effect.fnUntraced(function* (options: RoutedPortOptions) {
   const local = yield* ThreadStore;
   const checkpoints = local.checkpoints;
-  const recoveryCheckpoints = local.recoveryCheckpoints;
+  const promptCheckpoints = local.promptCheckpoints;
   const lifecyclePublications = local.lifecyclePublications;
   const acknowledgeMany = lifecyclePublications?.acknowledgeMany;
   const transport = yield* ThreadPortTransport;
@@ -885,6 +985,161 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
   };
 
   const routed = ThreadStore.of({
+    readExecution: (request) =>
+      options.ownsThread(request.threadId)
+        ? local.readExecution(request)
+        : foreignStoreCall(
+            "read execution",
+            request.threadId,
+            StoreReadExecutionCall.make({ request }),
+            StoreReadExecutionResult,
+            ThreadNotMaterialized,
+          ).pipe(Effect.map((reply) => reply.checkpoint)),
+    archives: {
+      page: (request) =>
+        options.ownsThread(request.threadId)
+          ? local.archives === undefined
+            ? Effect.fail(crossThreadStoreError("archive unavailable", request.threadId))
+            : local.archives.page(request)
+          : foreignStoreCall(
+              "archive page",
+              request.threadId,
+              StoreRangePageCall.make({ request }),
+              StoreRangePageResult,
+              ThreadNotMaterialized,
+            ).pipe(Effect.map((reply) => reply.page)),
+      seal: (request) =>
+        options.ownsThread(request.threadId)
+          ? local.archives === undefined
+            ? Effect.fail(crossThreadStoreError("archive unavailable", request.threadId))
+            : local.archives.seal(request)
+          : foreignStoreCall(
+              "archive seal",
+              request.threadId,
+              StoreRangeSealCall.make({ request }),
+              StoreRangeSealResult,
+              ThreadNotMaterialized,
+            ).pipe(Effect.map((reply) => reply.range)),
+      archive: (request) =>
+        options.ownsThread(request.threadId)
+          ? local.archives === undefined
+            ? Effect.fail(crossThreadStoreError("archive unavailable", request.threadId))
+            : local.archives.archive(request)
+          : foreignStoreCall(
+              "archive archive",
+              request.threadId,
+              StoreRangeArchiveCall.make({ request }),
+              StoreRangeArchiveResult,
+              ThreadNotMaterialized,
+            ).pipe(Effect.map((reply) => reply.range)),
+      verify: (request) =>
+        options.ownsThread(request.threadId)
+          ? local.archives === undefined
+            ? Effect.fail(crossThreadStoreError("archive unavailable", request.threadId))
+            : local.archives.verify(request)
+          : foreignStoreCall(
+              "archive verify",
+              request.threadId,
+              StoreRangeVerifyCall.make({ request }),
+              StoreRangeVerifyResult,
+              ThreadNotMaterialized,
+            ).pipe(Effect.map((reply) => reply.range)),
+    },
+    work: {
+      threads: (request) =>
+        Effect.flatMap(CurrentNativeSource, (nativeSource) =>
+          nativeSource && local.work !== undefined
+            ? local.work.threads(request)
+            : Effect.fail(
+                ThreadStoreError.make({
+                  operation: "work threads",
+                  message: nativeSource
+                    ? "The local Thread owner does not provide work inventory."
+                    : "Global Thread enumeration is unsupported by the owner-local Durable Object namespace. Use the local owner's work storage.",
+                }),
+              ),
+        ),
+      page: (request) =>
+        options.ownsThread(request.threadId)
+          ? local.work === undefined
+            ? Effect.fail(
+                WorkDiscoveryUnavailable.make({
+                  threadId: request.threadId,
+                  reason: "unsupported",
+                }),
+              )
+            : local.work.page(request)
+          : foreignStoreCall(
+              "work page",
+              request.threadId,
+              StoreWorkPageCall.make({ request }),
+              StoreWorkPageResult,
+              WorkDiscoveryUnavailable,
+            ).pipe(Effect.map((reply) => reply.page)),
+      rebuild: (request) =>
+        options.ownsThread(request.threadId)
+          ? local.work === undefined
+            ? Effect.fail(
+                WorkDiscoveryUnavailable.make({
+                  threadId: request.threadId,
+                  reason: "unsupported",
+                }),
+              )
+            : local.work.rebuild(request)
+          : foreignStoreCall(
+              "rebuild work",
+              request.threadId,
+              StoreWorkRebuildCall.make({ request }),
+              StoreWorkRebuildResult,
+              WorkDiscoveryUnavailable,
+            ).pipe(
+              Effect.flatMap((reply) =>
+                reply.progress.threadId === request.threadId
+                  ? Effect.succeed(reply.progress)
+                  : Effect.fail(
+                      ThreadStoreError.make({
+                        operation: "rebuild work",
+                        message: "The rebuild progress belongs to another Thread.",
+                      }),
+                    ),
+              ),
+            ),
+    },
+    readWorkerCapacity: (request) =>
+      (options.ownsThread(request.threadId)
+        ? local.readWorkerCapacity === undefined
+          ? Effect.fail(crossThreadStoreError("worker capacity unavailable", request.threadId))
+          : local.readWorkerCapacity(request)
+        : foreignStoreCall(
+            "worker capacity",
+            request.threadId,
+            StoreWorkerCapacityCall.make({ request }),
+            StoreWorkerCapacityResult,
+            ThreadNotMaterialized,
+          ).pipe(Effect.map((reply) => reply.capacity))
+      ).pipe(
+        Effect.filterOrFail(
+          (capacity) =>
+            capacity.threadId === request.threadId &&
+            capacity.tailSequence === request.expectedTailSequence,
+          () => crossThreadStoreError("worker capacity response mismatch", request.threadId),
+        ),
+      ),
+    verification: {
+      verify: (request) =>
+        options.ownsThread(request.threadId)
+          ? local.verification === undefined
+            ? Effect.fail(crossThreadStoreError("verification unavailable", request.threadId))
+            : local.verification.verify(request)
+          : foreignStoreCall(
+              "thread verification",
+              request.threadId,
+              StoreVerificationCall.make({ request }),
+              StoreVerificationResult,
+              ThreadNotMaterialized,
+            ).pipe(Effect.map((reply) => reply.report)),
+    },
+
     countPeerMessages: (request) =>
       options.ownsThread(request.threadId)
         ? local.countPeerMessages === undefined
@@ -906,7 +1161,7 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
             request.threadId,
             StoreMaterializeCall.make({ request }),
             StoreMaterializeResult,
-            FenceRejected,
+            NoAdditionalPortFailure,
           ).pipe(Effect.asVoid),
 
     append: (request) =>
@@ -933,6 +1188,19 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
             ).pipe(Effect.map((reply) => Stream.fromIterable(reply.records))),
           ),
 
+    readPrompt: (request) =>
+      options.ownsThread(request.threadId)
+        ? local.readPrompt(request)
+        : Stream.unwrap(
+            foreignStoreCall(
+              "thread read prompt",
+              request.threadId,
+              StoreReadPromptCall.make({ request }),
+              StoreReadPromptResult,
+              ThreadNotMaterialized,
+            ).pipe(Effect.map((reply) => Stream.fromIterable(reply.records))),
+          ),
+
     inspectTail: (request) =>
       options.ownsThread(request.threadId)
         ? local.inspectTail(request)
@@ -967,19 +1235,22 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
           ),
 
     export: (request) =>
-      options.ownsThread(request.threadId)
-        ? local.export(request)
-        : foreignStoreCall(
-            "thread export",
-            request.threadId,
-            StoreExportCall.make({ request }),
-            StoreExportResult,
-            ThreadNotMaterialized,
-          ).pipe(Effect.map((reply) => reply.export)),
+      checkExportSource(request.threadId).pipe(
+        Effect.andThen(
+          options.ownsThread(request.threadId)
+            ? local.export(request)
+            : foreignStoreCall(
+                "thread export",
+                request.threadId,
+                StoreExportCall.make({ request }),
+                StoreExportResult,
+                Schema.Union([ThreadNotMaterialized, ThreadExportRejected]),
+              ).pipe(Effect.map((reply) => reply.export)),
+        ),
+      ),
 
     // Observation and checkpoints are lane-local: the closed route-capable store subset
-    // is materialize/append/read/readIdentity/inspectTail/export. Recovery cache misses can fall back
-    // to those canonical reads, including when the cache belongs to a foreign Object.
+    // includes exact-Thread work pages and rebuild, but no global Object enumeration.
     observe: (request) =>
       options.ownsThread(request.threadId)
         ? local.observe(request)
@@ -1015,39 +1286,34 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
                 : Effect.fail(LifecyclePublicationError.make({ reason: "unavailable" })),
           },
         }),
-    ...(recoveryCheckpoints === undefined
+    ...(checkpoints === undefined
       ? {}
       : {
-          recoveryCheckpoints: {
+          checkpoints: {
             save: (request) =>
               options.ownsThread(request.checkpoint.threadId)
-                ? recoveryCheckpoints.save(request)
+                ? checkpoints.save(request)
                 : Effect.fail(
-                    crossThreadStoreError(
-                      "thread save recovery checkpoint",
-                      request.checkpoint.threadId,
-                    ),
+                    crossThreadStoreError("thread save checkpoint", request.checkpoint.threadId),
                   ),
             load: (request) =>
               options.ownsThread(request.threadId)
-                ? recoveryCheckpoints.load(request)
-                : Effect.succeed(Option.none()),
+                ? checkpoints.load(request)
+                : Effect.fail(crossThreadStoreError("thread load checkpoint", request.threadId)),
           },
         }),
-    ...(checkpoints === undefined
+    ...(promptCheckpoints === undefined
       ? {}
       : {
-          checkpoints: {
+          promptCheckpoints: {
             save: (request) =>
-              options.ownsThread(request.checkpoint.threadId)
-                ? checkpoints.save(request)
-                : Effect.fail(
-                    crossThreadStoreError("thread save checkpoint", request.checkpoint.threadId),
-                  ),
+              options.ownsThread(request.threadId)
+                ? promptCheckpoints.save(request)
+                : Effect.fail(crossThreadStoreError("save prompt checkpoint", request.threadId)),
             load: (request) =>
               options.ownsThread(request.threadId)
-                ? checkpoints.load(request)
-                : Effect.fail(crossThreadStoreError("thread load checkpoint", request.threadId)),
+                ? promptCheckpoints.load(request)
+                : Effect.fail(crossThreadStoreError("load prompt checkpoint", request.threadId)),
           },
         }),
   });
@@ -1069,14 +1335,16 @@ export const routedSubmissionLedgerLayer = (
 
 /**
  * Routing decorator over the LOCAL `ThreadStore` facet (plan §1.3): this-thread
- * requests execute locally; foreign materialize/append/read/inspectTail/export travel the
- * transport. Foreign recovery-cache loads return none for canonical replay; other foreign
- * checkpoint operations and observation fail fast typed.
+ * requests execute locally; foreign store reads, writes, and exact-Thread work pages/rebuild
+ * travel the transport. Work enumeration stays local under CurrentNativeSource; global
+ * enumeration, foreign checkpoints, and observation fail typed.
  */
 export const routedThreadStoreLayer = (
   options: RoutedPortOptions,
-): Layer.Layer<ThreadStore, never, ThreadStore | ThreadPortTransport> =>
-  Layer.effectContext(makeRoutedStoreServices(options));
+): Layer.Layer<ThreadStore | ThreadReader, never, ThreadStore | ThreadPortTransport> =>
+  ThreadReader.layer().pipe(
+    Layer.provideMerge(Layer.effectContext(makeRoutedStoreServices(options))),
+  );
 
 /** Route validated worker admission as one operation; source policy hooks stay at the caller. */
 export const routedWorkerAdmissionLayer = (options: RoutedPortOptions) =>
@@ -1223,14 +1491,105 @@ const capture = <Failure extends PortFailure, R>(
  * Failures never escape — every typed port failure becomes a `PortFailed` envelope that
  * re-decodes on the caller side.
  */
-export const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(function* (
+export const executePortRequest = Effect.fnUntraced(function* (
   request: PortRequest,
 ): Effect.fn.Return<
   PortResponse,
   never,
-  SubmissionLedger | ThreadStore | MessageDeliveryStore | WakeScheduler | DurableRuntimeFailpoint
+  | SubmissionLedger
+  | SettlementPublisher
+  | ThreadStore
+  | MessageDeliveryStore
+  | WakeScheduler
+  | DurableRuntimeFailpoint
 > {
   switch (request._tag) {
+    case "StoreRangePage": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store.archives === undefined
+          ? crossThreadStoreError("archive unavailable", request.request.threadId)
+          : store.archives
+              .page(request.request)
+              .pipe(Effect.map((page) => StoreRangePageResult.make({ page }))),
+      );
+    }
+    case "StoreRangeSeal": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store.archives === undefined
+          ? crossThreadStoreError("archive unavailable", request.request.threadId)
+          : store.archives
+              .seal(request.request)
+              .pipe(Effect.map((range) => StoreRangeSealResult.make({ range }))),
+      );
+    }
+    case "StoreRangeArchive": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store.archives === undefined
+          ? crossThreadStoreError("archive unavailable", request.request.threadId)
+          : store.archives
+              .archive(request.request)
+              .pipe(Effect.map((range) => StoreRangeArchiveResult.make({ range }))),
+      );
+    }
+    case "StoreRangeVerify": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store.archives === undefined
+          ? crossThreadStoreError("archive unavailable", request.request.threadId)
+          : store.archives
+              .verify(request.request)
+              .pipe(Effect.map((range) => StoreRangeVerifyResult.make({ range }))),
+      );
+    }
+
+    case "StoreWorkPage": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store.work === undefined
+          ? Effect.fail(
+              WorkDiscoveryUnavailable.make({
+                threadId: request.request.threadId,
+                reason: "unsupported",
+              }),
+            )
+          : store.work
+              .page(request.request)
+              .pipe(Effect.map((page) => StoreWorkPageResult.make({ page }))),
+      );
+    }
+    case "StoreWorkRebuild": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store.work === undefined
+          ? Effect.fail(
+              WorkDiscoveryUnavailable.make({
+                threadId: request.request.threadId,
+                reason: "unsupported",
+              }),
+            )
+          : store.work
+              .rebuild(request.request)
+              .pipe(Effect.map((progress) => StoreWorkRebuildResult.make({ progress }))),
+      );
+    }
+    case "SettlementPublish": {
+      const publisher = yield* SettlementPublisher;
+
+      return yield* capture(
+        publisher
+          .publish(request.request)
+          .pipe(Effect.map((result) => SettlementPublishResult.make({ result }))),
+      );
+    }
     case "MessageDeliveryComplete": {
       const store = yield* MessageDeliveryStore;
 
@@ -1301,6 +1660,22 @@ export const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(
           ),
       );
     }
+    case "LedgerFundingOwner": {
+      const ledger = yield* SubmissionLedger;
+
+      return yield* capture(
+        ledger.resolveFundingOwner === undefined
+          ? Effect.fail(
+              LedgerError.make({
+                operation: "resolve funding owner",
+                message: "Native funding-owner lookup unavailable.",
+              }),
+            )
+          : ledger
+              .resolveFundingOwner(request.request)
+              .pipe(Effect.map((funding) => LedgerFundingOwnerResult.make({ funding }))),
+      );
+    }
     case "LedgerResolveAdmission": {
       const ledger = yield* SubmissionLedger;
 
@@ -1383,6 +1758,16 @@ export const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(
         ),
       );
     }
+    case "StoreReadPrompt": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store.readPrompt(request.request).pipe(
+          Stream.runCollect,
+          Effect.map((records) => StoreReadPromptResult.make({ records })),
+        ),
+      );
+    }
     case "StoreInspectTail": {
       const store = yield* ThreadStore;
 
@@ -1392,6 +1777,15 @@ export const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(
           .pipe(Effect.map((tail) => StoreInspectTailResult.make({ tail }))),
       );
     }
+    case "StoreReadExecution": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store
+          .readExecution(request.request)
+          .pipe(Effect.map((checkpoint) => StoreReadExecutionResult.make({ checkpoint }))),
+      );
+    }
     case "StoreReadIdentity": {
       const store = yield* ThreadStore;
 
@@ -1401,6 +1795,30 @@ export const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(
           .pipe(Effect.map((identity) => StoreReadIdentityResult.make({ identity }))),
       );
     }
+    case "StoreWorkerCapacity": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store.readWorkerCapacity === undefined
+          ? Effect.fail(
+              crossThreadStoreError("worker capacity unavailable", request.request.threadId),
+            )
+          : store
+              .readWorkerCapacity(request.request)
+              .pipe(Effect.map((capacity) => StoreWorkerCapacityResult.make({ capacity }))),
+      );
+    }
+    case "StoreVerification": {
+      const store = yield* ThreadStore;
+
+      return yield* capture(
+        store.verification === undefined
+          ? Effect.fail(crossThreadStoreError("verification unavailable", request.request.threadId))
+          : store.verification
+              .verify(request.request)
+              .pipe(Effect.map((report) => StoreVerificationResult.make({ report }))),
+      );
+    }
     case "StoreExport": {
       const store = yield* ThreadStore;
 
@@ -1430,35 +1848,36 @@ const encodedProtocolFailure = (message: string): unknown => ({
  * cannot be encoded, answers `PortFailed(PortProtocolError)` instead of throwing, so the
  * transport never has to interpret exceptions as protocol answers.
  */
-export const handleEncodedPortRequest = Effect.fn("DoPortRouting.handleEncodedPortRequest")(
-  function* (
-    encoded: unknown,
-  ): Effect.fn.Return<
-    unknown,
-    never,
-    SubmissionLedger | ThreadStore | MessageDeliveryStore | WakeScheduler | DurableRuntimeFailpoint
-  > {
-    const response = yield* decodePortRequest(encoded).pipe(
-      Effect.flatMap(executePortRequest),
-      Effect.catch((error) =>
-        Effect.succeed<PortResponse>(
-          PortFailed.make({
-            failure: PortProtocolError.make({
-              message: boundPortDiagnostic(
-                `The port request could not be decoded: ${error.message}`,
-              ),
-            }),
+export const handleEncodedPortRequest = Effect.fnUntraced(function* (
+  encoded: unknown,
+): Effect.fn.Return<
+  unknown,
+  never,
+  | SubmissionLedger
+  | SettlementPublisher
+  | ThreadStore
+  | MessageDeliveryStore
+  | WakeScheduler
+  | DurableRuntimeFailpoint
+> {
+  const response = yield* decodePortRequest(encoded).pipe(
+    Effect.flatMap(executePortRequest),
+    Effect.catch((error) =>
+      Effect.succeed<PortResponse>(
+        PortFailed.make({
+          failure: PortProtocolError.make({
+            message: boundPortDiagnostic(`The port request could not be decoded: ${error.message}`),
           }),
-        ),
+        }),
       ),
-    );
+    ),
+  );
 
-    return yield* encodePortResponse(response).pipe(
-      Effect.catch((error) =>
-        Effect.succeed(
-          encodedProtocolFailure(`The port response could not be encoded: ${error.message}`),
-        ),
+  return yield* encodePortResponse(response).pipe(
+    Effect.catch((error) =>
+      Effect.succeed(
+        encodedProtocolFailure(`The port response could not be encoded: ${error.message}`),
       ),
-    );
-  },
-);
+    ),
+  );
+});