effect-agent 0.1.0-beta.113 → 0.1.0-beta.115

package/src/durable/internal/worker-host.ts

@@ -19,6 +19,8 @@ import { MessageRef } from "../../core/Messaging.ts";
 import { IdempotencyKey, Receipt } from "../../core/Receipt.ts";
 import { SubagentDelegationCaps, SubagentGrant } from "../../core/SubagentContract.ts";
 import {
+  type WorkerSummary,
+  type WorkerStarted,
   WorkerCompletion,
   FrameworkMessage,
   WorkerUpdate,
@@ -26,9 +28,12 @@ import {
   WorkerHistoryEntry,
   type WorkerContext,
   WorkerRef,
+  WorkerStop,
 } from "../../core/Worker.ts";
 import {
   type SubagentHost,
+  type DeferredStartWorkerRequest,
+  type StartWorkerRequest,
   type WorkerObservation,
   type WorkerReceiptRequest,
   type WorkerRunReport,
@@ -62,6 +67,7 @@ import {
   RecordId,
   WorkerAdmission,
   WorkerInputRequested,
+  WorkerStopRequested,
   WorkerOrigin,
   WorkerOriginRecorded,
   WorkerInputCompleted,
@@ -86,13 +92,14 @@ import {
 } from "../Schedule.ts";
 import {
   SubmissionLedger,
+  WorkerLedgerState,
   LedgerError,
   AbortCommand,
   type AbortIntent,
   type Principal,
   type Settlement,
   SubmissionLookupById,
-  SubmissionLookupByKey,
+  submissionSettlementRecordId,
   type SubmissionSnapshot,
 } from "../SubmissionLedger.ts";
 import type { SubmissionStatus } from "../SubmissionStatus.ts";
@@ -100,6 +107,7 @@ import { PreparedInput } from "../Subscription.ts";
 import {
   ThreadStore,
   getRecord,
+  getRunInput,
   readWorkerState as readNativeWorkerState,
   FencedAppendRequest,
   ThreadExportRequest,
@@ -352,6 +360,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       threadId: ThreadId,
       id: string,
       payload:
+        | WorkerStopRequested
         | WorkerInputRequested
         | WorkerOriginRecorded
         | WorkerInputCompleted
@@ -359,7 +368,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         | WorkerReportRefused
         | SubtreeBudgetReserved,
       current: Pick<ThreadExport, "tailSequence" | "tailDigest" | "records">,
-      phase: "source" | "origin" | "completion" | "subtree" | "report",
+      phase: "source" | "origin" | "completion" | "subtree" | "report" | "stop",
       acknowledgements: ReadonlyArray<WorkerInputCompleted> = [],
     ) {
       const operation = "start";
@@ -487,50 +496,36 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
     const report = reports[0];
 
     if (report === undefined) return undefined;
-    if (
-      reports.length !== 1 ||
-      !Object.is(report.target, target.definition) ||
-      (report.mode !== "standard" && !Object.is(report.input, source.definition.input)) ||
-      (report.destination !== undefined && !Object.is(report.destination.target, source.definition))
-    )
+    if (reports.length !== 1 || !Object.is(report.target, target.definition))
       return yield* failure("start", "declaration-unavailable");
 
-    let returnAddress: NonNullable<WorkerOrigin["reporting"]>["returnAddress"];
+    const submission = authority.submission;
 
-    if (report.mode === "standard") {
-      const submission = authority.submission;
-
-      if (
-        submission === undefined ||
-        (authority.depth !== 0 && submission.workerAdmission === undefined)
-      )
-        return yield* failure("start", "denied");
+    if (
+      submission === undefined ||
+      (authority.depth !== 0 && submission.workerAdmission === undefined)
+    )
+      return yield* failure("start", "denied");
 
-      const retained =
-        submission.workerAdmission === undefined
-          ? undefined
-          : yield* Schema.encodeEffect(WorkerAdmission)(submission.workerAdmission).pipe(
-              Effect.flatMap(Schema.decodeEffect(PersistedJson)),
-              Effect.mapError(storageFailure("start")),
-            );
+    const retained =
+      submission.workerAdmission === undefined
+        ? undefined
+        : yield* Schema.encodeEffect(WorkerAdmission)(submission.workerAdmission).pipe(
+            Effect.flatMap(Schema.decodeEffect(PersistedJson)),
+            Effect.mapError(storageFailure("start")),
+          );
 
-      returnAddress = {
+    return {
+      sourceDigests: source.digests,
+      mode: "standard",
+      returnAddress: {
         input: submission.inputPayload,
         principal: submission.principal,
         policy: authority.policy,
         depth: authority.depth,
         ...(authority.grant === undefined ? {} : { grant: authority.grant }),
         ...(retained === undefined ? {} : { workerAdmission: retained }),
-      };
-    }
-
-    return {
-      sourceDigests: source.digests,
-      ...(report.mode === undefined ? {} : { mode: report.mode }),
-      ...(returnAddress === undefined ? {} : { returnAddress }),
-      ...(report.destination === undefined
-        ? {}
-        : { destinationDelegationId: report.destination.delegationId }),
+      },
     };
   });
 
@@ -1232,7 +1227,7 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         sourceBinding === undefined ||
         targetBinding === undefined ||
         reports.length !== 1 ||
-        reports[0]?.mode !== "standard" ||
+        reports[0] === undefined ||
         reports[0].target !== targetBinding.definition ||
         !definitionDigestsEqual(submission.agentDigests, origin.targetDigests)
       )
@@ -1351,6 +1346,9 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       const refused = (reason: WorkerReportRefused["reason"]) =>
         WorkerReportRefused.make({ runId, messageId, reason });
 
+      // Retired custom origins remain readable; already prepared envelopes bypass preparation.
+      if (intent.mode !== "standard") return refused("declaration-unavailable");
+
       const selected = yield* deps.ledger
         .lookup(SubmissionLookupById.make({ submissionId: host.submissionId }))
         .pipe(Effect.mapError(storageFailure("inspect")));
@@ -1366,84 +1364,18 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       const hostSubmission = selected.value;
       const hostAdmission = selected.value.workerAdmission;
 
-      // Standard reports use only the accepted return address. Application-mapped
-      // projections retain their explicit source-context contract.
-      const source = yield* Effect.gen(function* () {
-        if (intent.mode === "standard") {
-          const address = intent.returnAddress;
+      const address = intent.returnAddress;
 
-          if (address === undefined) return yield* failure("inspect", "corrupt");
+      if (address === undefined) return yield* failure("inspect", "corrupt");
 
-          const retained =
-            address.workerAdmission === undefined
-              ? undefined
-              : yield* Schema.decodeUnknownEffect(WorkerAdmission)(address.workerAdmission).pipe(
-                  Effect.mapError((cause) => failure("inspect", "corrupt", cause)),
-                );
-
-          return { ...address, admission: retained, sourceSubmissionId: undefined };
-        }
-
-        const first = Option.getOrUndefined(
-          yield* exactRecord(
-            origin.source.threadId,
-            workerInputRecordId(origin.firstMessageId),
-            "inspect",
-          ),
-        )?.record.payload;
-
-        if (
-          first?._tag !== "WorkerInputRequested" ||
-          first.admission.messageId !== origin.firstMessageId ||
-          !sameOrigin(first.admission.origin, origin)
-        )
-          return yield* failure("inspect", "corrupt");
-
-        const authority = yield* sourceAuthority(
-          origin.source.threadId,
-          first.admission.sourceSubmissionId,
-        );
-
-        const recorded = authority.current.records.find(
-          ({ record }) => record.payload._tag === "WorkerOriginRecorded",
-        )?.record.payload;
-
-        let retained: WorkerAdmission | undefined;
-        let principal = hostSubmission.principal;
-
-        if (recorded?._tag === "WorkerOriginRecorded") {
-          if (hostAdmission.sourceSubmissionId === undefined)
-            return yield* failure("inspect", "denied");
-
-          const snapshot = yield* deps.ledger
-            .lookup(
-              SubmissionLookupById.make({
-                submissionId: hostAdmission.sourceSubmissionId,
-              }),
-            )
-            .pipe(Effect.mapError(storageFailure("inspect")));
-
-          if (
-            Option.isNone(snapshot) ||
-            snapshot.value.threadId !== origin.source.threadId ||
-            snapshot.value.workerAdmission === undefined ||
-            !sameOrigin(snapshot.value.workerAdmission.origin, recorded.origin)
-          )
-            return yield* failure("inspect", "denied");
-          retained = snapshot.value.workerAdmission;
-          principal = snapshot.value.principal;
-        }
+      const retainedAdmission =
+        address.workerAdmission === undefined
+          ? undefined
+          : yield* Schema.decodeUnknownEffect(WorkerAdmission)(address.workerAdmission).pipe(
+              Effect.mapError((cause) => failure("inspect", "corrupt", cause)),
+            );
 
-        return {
-          policy: authority.policy,
-          depth: authority.depth,
-          grant: authority.grant,
-          input: authority.submission?.inputPayload,
-          admission: retained,
-          principal,
-          sourceSubmissionId: first.admission.sourceSubmissionId,
-        };
-      });
+      const source = { ...address, admission: retainedAdmission };
 
       const sourceBinding = currentBinding(origin.source.agentId);
       const targetBinding = currentBinding(origin.worker.targetAgentId);
@@ -1460,29 +1392,13 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         targetBinding === undefined ||
         descriptor === undefined ||
         reports.length !== 1 ||
-        !Object.is(descriptor.target, targetBinding.definition) ||
-        (descriptor.mode !== "standard" &&
-          !Object.is(descriptor.input, sourceBinding.definition.input)) ||
-        descriptor.mode !== intent.mode ||
-        descriptor.destination?.delegationId !== intent.destinationDelegationId ||
-        (descriptor.destination !== undefined &&
-          !Object.is(descriptor.destination.target, sourceBinding.definition))
+        !Object.is(descriptor.target, targetBinding.definition)
       )
         return refused("declaration-unavailable");
 
       const sourceOrigin = source.admission?.origin;
 
       if (source.depth !== 0 && sourceOrigin === undefined) return refused("destination");
-      if (
-        descriptor.mode !== "standard" &&
-        sourceOrigin !== undefined &&
-        (descriptor.destination === undefined ||
-          descriptor.destination.delegationId !== sourceOrigin.worker.delegationId ||
-          descriptor.destination.target.id !== sourceOrigin.worker.targetAgentId)
-      )
-        return refused("destination");
-      if (sourceOrigin === undefined && descriptor.destination !== undefined)
-        return refused("destination");
       const now = yield* Clock.currentTimeMillis;
 
       const deadlineAtMillis = Math.min(
@@ -1537,32 +1453,20 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
       if (projection._tag === "WorkerReportRefused") return projection;
 
-      if (descriptor.mode === "standard") {
-        const message = projection.value.message;
+      const message = projection.value.message;
 
-        if (source.input === undefined || !Schema.is(WorkerCompletion)(message))
-          return refused("input");
-        if (
-          !Schema.toEquivalence(WorkerRef)(message.report.worker, origin.worker) ||
-          !Schema.toEquivalence(Receipt)(message.report.receipt, report.observation.receipt) ||
-          message.report.runId !== runId ||
-          message.report.settlementId !== host.settlementId ||
-          message.report.outcome !== host.outcome ||
-          message.budgetExhausted !== report.observation.budgetExhausted
-        )
-          return refused("input");
-      } else if (projection.value.message !== undefined) return refused("input");
+      if (!Schema.is(WorkerCompletion)(message)) return refused("input");
+      if (
+        !Schema.toEquivalence(WorkerRef)(message.report.worker, origin.worker) ||
+        !Schema.toEquivalence(Receipt)(message.report.receipt, report.observation.receipt) ||
+        message.report.runId !== runId ||
+        message.report.settlementId !== host.settlementId ||
+        message.report.outcome !== host.outcome ||
+        message.budgetExhausted !== report.observation.budgetExhausted
+      )
+        return refused("input");
 
-      const reportInput =
-        descriptor.mode === "standard" ? source.input : projection.value.encodedInput;
-
-      const validated = yield* (
-        descriptor.mode === "standard"
-          ? Schema.decodeUnknownEffect(PersistedJson)(reportInput)
-          : Schema.decodeEffect(Schema.toEncoded(sourceBinding.definition.input))(reportInput).pipe(
-              Effect.flatMap(() => Schema.decodeUnknownEffect(PersistedJson)(reportInput)),
-            )
-      ).pipe(Effect.option);
+      const validated = yield* Schema.decodeEffect(PersistedJson)(source.input).pipe(Effect.option);
 
       if (Option.isNone(validated)) return refused("input");
       const input = validated.value;
@@ -1579,9 +1483,9 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
         if (retained === undefined) return refused("destination");
 
-        const parameters = yield* Schema.decodeUnknownEffect(PersistedJson)(
-          descriptor.mode === "standard" ? retained.parameters : projection.value.encodedParameters,
-        ).pipe(Effect.option);
+        const parameters = yield* Schema.decodeEffect(PersistedJson)(retained.parameters).pipe(
+          Effect.option,
+        );
 
         if (Option.isNone(parameters)) return refused("destination");
         workerAdmission = {
@@ -1595,56 +1499,21 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         };
       }
 
-      // Reporting remains owned by the original allocator, even when a later input joins
-      // or starts another Run. Nested reports authorize the enclosing worker's source owner.
-      const authorizationSourceSubmissionId =
-        sourceOrigin === undefined
-          ? source.sourceSubmissionId
-          : workerAdmission?.sourceSubmissionId;
-
-      // Standard framework messages are reauthorized by validateCompletion at
-      // their destination. Persisting an outbound report does not admit input there.
-      const authorized =
-        intent.mode === "standard"
-          ? Option.some(principal)
-          : yield* deps.authorizer
-              .authorize({
-                sourceThreadId: sourceOrigin?.source.threadId ?? origin.source.threadId,
-                ...(authorizationSourceSubmissionId === undefined
-                  ? {}
-                  : { sourceSubmissionId: authorizationSourceSubmissionId }),
-                principal,
-                operation: "followUp",
-                access: "send",
-                worker: sourceOrigin?.worker ?? origin.worker,
-              })
-              .pipe(
-                Effect.map(Option.some),
-                Effect.catchTag("WorkerError", (error) =>
-                  error.reason === "storage" || error.reason === "unavailable"
-                    ? Effect.fail(error)
-                    : Effect.succeed(Option.none<Principal>()),
-                ),
-              );
-
-      if (Option.isNone(authorized)) return refused("denied");
-
+      // The destination reauthorizes standard messages through validateCompletion.
       const envelope: PreparedInput = {
         schemaVersion: 1,
         threadId: origin.source.threadId,
-        deliveryPrincipal: authorized.value,
+        deliveryPrincipal: principal,
         agentId: origin.source.agentId,
         definitions: intent.sourceDigests,
         input,
         inputDigest,
         admissionKey: messageId,
         authorization: { policyId: "worker-report", decisionId: messageId },
-        ...(projection.value.message === undefined
-          ? {}
-          : { messageAdmission: projection.value.message }),
+        messageAdmission: message,
         ...(workerAdmission === undefined
           ? {}
-          : { workerAdmission: { ...workerAdmission, deliveryPrincipal: authorized.value } }),
+          : { workerAdmission: { ...workerAdmission, deliveryPrincipal: principal } }),
       };
 
       const encoded = yield* Schema.encodeEffect(PreparedInput)(envelope).pipe(
@@ -1868,7 +1737,28 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
       const origin = first?._tag === "WorkerInputRequested" ? first.admission.origin : undefined;
 
-      if (origin === undefined) return yield* failure(operation, "not-found");
+      if (origin === undefined) {
+        const retained = Option.isNone(deps.deliveries)
+          ? null
+          : yield* deps.deliveries.value
+              .get({
+                ownerThreadId: context.source.threadId,
+                messageId: Schema.decodeSync(IdempotencyKey)(worker.threadId),
+              })
+              .pipe(Effect.mapError(storageFailure(operation)));
+
+        const pendingOrigin = retained?.envelope.workerAdmission?.origin;
+
+        if (pendingOrigin === undefined) return yield* failure(operation, "not-found");
+        if (
+          !Schema.toEquivalence(WorkerRef)(pendingOrigin.worker, worker) ||
+          pendingOrigin.firstMessageId !== retained?.key.messageId ||
+          pendingOrigin.source.threadId !== context.source.threadId
+        )
+          return yield* failure(operation, "worker-mismatch");
+
+        return pendingOrigin;
+      }
       if (
         !Schema.toEquivalence(WorkerRef)(origin.worker, worker) ||
         first?._tag !== "WorkerInputRequested" ||
@@ -2091,65 +1981,194 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
     const summarize = Effect.fn("WorkerHost.summarize")(function* (
       origin: WorkerOrigin,
-      all: ReadonlyArray<WorkerInputRequested>,
       operation: "list" | "inspect",
-    ) {
+    ): Effect.fn.Return<WorkerSummary, WorkerError> {
       yield* authorize(operation, "read", origin.worker);
-      let latestReceipt: Receipt | null = null;
-      let active = false;
-      let starting = false;
+      if (deps.ledger.inspectWorker === undefined || Option.isNone(deps.deliveries))
+        return yield* failure(operation, "unavailable");
+      const threadId = origin.worker.threadId;
+      const deliveries = deps.deliveries.value;
 
-      for (const row of all) {
-        if (row.admission.origin.worker.threadId !== origin.worker.threadId) continue;
+      const pending = () =>
+        deliveries
+          .list({ ownerThreadId: context.source.threadId, pendingWorker: threadId, limit: 1 })
+          .pipe(
+            Effect.mapError(storageFailure(operation)),
+            Effect.map((page) => page.items[0]),
+          );
 
-        const delivery = Option.isNone(deps.deliveries)
-          ? null
-          : yield* deps.deliveries.value
-              .get({
-                ownerThreadId: context.source.threadId,
-                messageId: row.admission.messageId,
-              })
-              .pipe(Effect.mapError(storageFailure(operation)));
+      const tail = () =>
+        deps.store.inspectTail(ThreadTailRequest.make({ threadId })).pipe(
+          Effect.catchTag("ThreadNotMaterialized", () => Effect.succeed(undefined)),
+          Effect.mapError(storageFailure(operation)),
+        );
 
-        const principal = row.admission.deliveryPrincipal ?? delivery?.envelope.deliveryPrincipal;
-
-        const found =
-          principal === undefined
-            ? Option.none()
-            : yield* deps.ledger
-                .lookup(
-                  SubmissionLookupByKey.make({
-                    threadId: origin.worker.threadId,
-                    principal,
-                    idempotencyKey: row.admission.messageId,
-                  }),
-                )
-                .pipe(Effect.mapError(storageFailure(operation)));
+      const receipt = (row: SubmissionSnapshot): Receipt => ({
+        threadId: row.threadId,
+        submissionId: row.submissionId,
+        receiptId: row.receiptId,
+        queueSequence: row.queueSequence,
+      });
 
-        if (Option.isNone(found)) {
-          if (delivery?.status !== "refused") starting = true;
-          continue;
+      const input = (row: SubmissionSnapshot) => {
+        if (row.workerAdmission === undefined || !sameOrigin(row.workerAdmission.origin, origin))
+          return failure(operation, "corrupt");
+
+        return Effect.succeed({ receipt: receipt(row), messageId: row.workerAdmission.messageId });
+      };
+
+      const submission = (submissionId: SubmissionId) =>
+        deps.ledger.lookup(SubmissionLookupById.make({ submissionId })).pipe(
+          Effect.mapError(storageFailure(operation)),
+          Effect.flatMap((row) =>
+            Option.isNone(row) ? failure(operation, "corrupt") : Effect.succeed(row.value),
+          ),
+        );
+
+      // Native pages and exact lookups only. Retry changing watermarks instead of combining
+      // acceptance, application and completion facts that never coexisted.
+      for (let attempt = 0; attempt < 16; attempt++) {
+        const delivery = yield* pending();
+
+        const control = yield* deps.ledger
+          .inspectWorker(threadId)
+          .pipe(Effect.mapError(storageFailure(operation)));
+
+        const current = yield* tail();
+
+        const records =
+          current === undefined
+            ? []
+            : yield* deps.store
+                .read({
+                  threadId,
+                  selection: {
+                    _tag: "WorkerExecution",
+                    expectedTailSequence: current.tailSequence,
+                    expectedTailDigest: current.tailDigest,
+                  },
+                  page: { limit: 2 },
+                })
+                .pipe(
+                  Stream.runCollect,
+                  Effect.mapError(storageFailure(operation)),
+                  Effect.catch((error) =>
+                    Effect.gen(function* () {
+                      // An unavailable recheck cannot justify discarding the original error.
+                      const after = yield* tail().pipe(Effect.orElseSucceed(() => current));
+
+                      if (
+                        after !== undefined &&
+                        (current.tailSequence !== after.tailSequence ||
+                          current.tailDigest !== after.tailDigest)
+                      )
+                        return undefined;
+
+                      return yield* error;
+                    }),
+                  ),
+                );
+
+        if (records === undefined) continue;
+
+        const applied = records.find((entry) => entry.record.payload._tag === "UserInputRecorded");
+
+        const started = records.find((entry) => entry.record.payload._tag === "RunStarted")?.record
+          .payload;
+
+        const acceptedInput = control.latest === null ? null : yield* input(control.latest);
+        let appliedInput: WorkerSummary["appliedInput"] = null;
+        let run: WorkerSummary["run"] = null;
+
+        if (applied?.record.payload._tag === "UserInputRecorded") {
+          const value = applied.record.payload;
+
+          if (value.submissionId === undefined || value.runId === undefined)
+            return yield* failure(operation, "corrupt");
+          appliedInput = {
+            ...(yield* input(yield* submission(value.submissionId))),
+            runId: value.runId,
+            sequence: applied.sequence,
+          };
         }
-        active ||= found.value.state !== "settled";
-        if (latestReceipt === null || found.value.queueSequence > latestReceipt.queueSequence) {
-          latestReceipt = {
-            threadId: found.value.threadId,
-            submissionId: found.value.submissionId,
-            receiptId: found.value.receiptId,
-            queueSequence: found.value.queueSequence,
+        if (started?._tag === "RunStarted") {
+          const initial = Option.getOrUndefined(
+            yield* getRunInput({ threadId, runId: started.runId }).pipe(
+              Effect.provideService(ThreadStore, deps.store),
+              Effect.mapError(storageFailure(operation)),
+            ),
+          )?.record.payload;
+
+          if (initial?._tag !== "UserInputRecorded" || initial.submissionId === undefined)
+            return yield* failure(operation, "corrupt");
+          const host = yield* input(yield* submission(initial.submissionId));
+
+          const terminal = Option.getOrUndefined(
+            yield* exactRecord(
+              threadId,
+              submissionSettlementRecordId(initial.submissionId),
+              operation,
+            ),
+          )?.record.payload;
+
+          if (
+            terminal !== undefined &&
+            (terminal._tag !== "SubmissionSettled" || terminal.runId !== started.runId)
+          )
+            return yield* failure(operation, "corrupt");
+
+          run = {
+            runId: started.runId,
+            hostReceipt: host.receipt,
+            outcome: terminal?.outcome ?? null,
+            disposition: terminal?.runDisposition ?? null,
           };
         }
+
+        const after = yield* deps.ledger
+          .inspectWorker(threadId)
+          .pipe(Effect.mapError(storageFailure(operation)));
+
+        const afterTail = yield* tail();
+        const afterDelivery = yield* pending();
+
+        if (
+          !Schema.toEquivalence(WorkerLedgerState)(control, after) ||
+          current?.tailSequence !== afterTail?.tailSequence ||
+          current?.tailDigest !== afterTail?.tailDigest ||
+          delivery?.key.messageId !== afterDelivery?.key.messageId ||
+          delivery?.version !== afterDelivery?.version
+        )
+          continue;
+
+        return {
+          worker: origin.worker,
+          latestReceipt: acceptedInput?.receipt ?? null,
+          state:
+            control.terminal ??
+            (control.stopped
+              ? control.active === null
+                ? "stopped"
+                : "stopping"
+              : control.active !== null
+                ? "active"
+                : delivery !== undefined
+                  ? "starting"
+                  : "idle"),
+          acceptedInput,
+          appliedInput,
+          run,
+          pendingDelivery:
+            delivery === undefined ? null : yield* deliveryStatus(delivery, operation),
+          watermark: {
+            canonicalSequence: current?.tailSequence ?? 0,
+            acceptedQueueSequence: control.latest?.queueSequence ?? 0,
+            pendingDeliveryVersion: delivery?.version ?? null,
+          },
+        };
       }
 
-      return {
-        worker: origin.worker,
-        latestReceipt,
-        state: active
-          ? ("active" as const)
-          : starting || latestReceipt === null
-            ? ("starting" as const)
-            : ("idle" as const),
-      };
+      return yield* failure(operation, "storage");
     });
 
     return {
@@ -2168,104 +2187,181 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
 
         return (yield* preparedTarget(request.target, request.encodedInput)).policy;
       }),
-      start: Effect.fn("WorkerHost.start")(function* (request) {
+      start: Effect.fn("WorkerHost.start")(function* <E = never, R = never>(
+        command: StartWorkerRequest | DeferredStartWorkerRequest<E, R>,
+      ): Effect.fn.Return<WorkerStarted, WorkerError | E, R> {
         const principal = yield* authorize("start", "send");
 
         if (context.depth !== 0 && sourceSubmissionId === undefined)
           return yield* failure("start", "denied");
-        const prepared = yield* preparedTarget(request.target, request.encodedInput);
-        const resolved = prepared.resolved;
-        const sourcePolicy = Option.getOrElse(prepared.source.policyOverride, () => context.policy);
 
-        const grant = yield* Schema.decodeUnknownEffect(SubagentGrant)(request.encodedGrant).pipe(
+        const grant = yield* Schema.decodeUnknownEffect(SubagentGrant)(command.encodedGrant).pipe(
           Effect.mapError((cause) => failure("start", "corrupt", cause)),
         );
 
+        const parameters = yield* decode(PersistedJson, command.encodedParameters, "start");
+
         const messageId = yield* messageIdFor([
           context.source.threadId,
-          request.delegationId,
-          request.idempotencyKey,
+          command.delegationId,
+          command.idempotencyKey,
         ]);
 
         if (Option.isNone(deps.deliveries)) return yield* failure("start", "unavailable");
+        const deliveries = deps.deliveries.value;
 
-        const existing = yield* deps.deliveries.value
-          .get({ ownerThreadId: context.source.threadId, messageId })
-          .pipe(Effect.mapError(storageFailure("start")));
+        const retained = () =>
+          deliveries
+            .get({ ownerThreadId: context.source.threadId, messageId })
+            .pipe(Effect.mapError(storageFailure("start")));
 
-        const now = yield* Clock.currentTimeMillis;
-        const previousOrigin = existing?.envelope.workerAdmission?.origin;
-        const sourceBinding = prepared.source.binding;
+        const replay = (saved: MessageDeliveryRecord) =>
+          Effect.gen(function* () {
+            const replayPrincipal = yield* authorize("start", "send");
+
+            yield* binding(command.target, "start");
+            const metadata = saved.envelope.workerAdmission;
+
+            if (metadata === undefined) return yield* failure("start", "idempotency-conflict");
+            const origin = metadata.origin;
+
+            if (
+              origin.firstMessageId !== messageId ||
+              metadata.messageId !== messageId ||
+              origin.source.threadId !== context.source.threadId ||
+              origin.worker.delegationId !== command.delegationId ||
+              origin.worker.targetAgentId !== command.target.id ||
+              !sameJson(metadata.parameters, parameters) ||
+              !Schema.toEquivalence(SubagentGrant)(origin.grant, grant) ||
+              origin.budgetScope !== command.budgetScope ||
+              origin.depth !== context.depth + 1 ||
+              (!("prepare" in command) &&
+                (!samePolicy(origin.policy, command.policy) ||
+                  !Schema.toEquivalence(WorkerOrigin.fields.budget)(
+                    origin.budget,
+                    command.budget,
+                  ) ||
+                  origin.toolCallAllowance !== command.toolCallAllowance))
+            )
+              return yield* failure("start", "idempotency-conflict");
+
+            return {
+              worker: origin.worker,
+              delivery: yield* send(
+                origin,
+                messageId,
+                "prepare" in command ? saved.envelope.input : command.encodedInput,
+                parameters,
+                replayPrincipal,
+                "start",
+              ),
+            };
+          });
 
-        if (sourceBinding === undefined) return yield* failure("start", "declaration-unavailable");
+        const existing = yield* retained();
 
-        const reporting =
-          previousOrigin === undefined
-            ? yield* reportIntent(sourceBinding, resolved, request.delegationId, prepared.source)
-            : previousOrigin.reporting;
+        if (existing !== null) return yield* replay(existing);
 
-        if (reporting?.mode === "standard" && sourceSubmissionId === undefined)
-          return yield* failure("start", "denied");
+        return yield* Effect.gen(function* () {
+          const request =
+            "prepare" in command ? { ...(yield* command.prepare), ...command } : command;
+
+          const prepared = yield* preparedTarget(request.target, request.encodedInput);
+          const resolved = prepared.resolved;
+
+          const sourcePolicy = Option.getOrElse(
+            prepared.source.policyOverride,
+            () => context.policy,
+          );
+
+          const now = yield* Clock.currentTimeMillis;
+          const sourceBinding = prepared.source.binding;
+
+          if (sourceBinding === undefined)
+            return yield* failure("start", "declaration-unavailable");
 
-        const origin = yield* decode(
-          WorkerOrigin,
-          {
-            worker: {
-              schemaVersion: 1,
-              delegationId: request.delegationId,
-              targetAgentId: request.target.id,
-              threadId: Schema.decodeSync(ThreadId)(messageId),
+          const reporting = yield* reportIntent(
+            sourceBinding,
+            resolved,
+            request.delegationId,
+            prepared.source,
+          );
+
+          if (reporting?.mode === "standard" && sourceSubmissionId === undefined)
+            return yield* failure("start", "denied");
+
+          const origin = yield* decode(
+            WorkerOrigin,
+            {
+              worker: {
+                schemaVersion: 1,
+                delegationId: request.delegationId,
+                targetAgentId: request.target.id,
+                threadId: Schema.decodeSync(ThreadId)(messageId),
+              },
+              source: context.source,
+              ...(resolved.definition.runDisposition?.workerLifecycle === "assignment"
+                ? { lifecycle: "assignment" }
+                : {}),
+              targetDigests: resolved.digests,
+              policy: request.policy,
+              budget: request.budget,
+              ...(request.budgetScope === undefined ? {} : { budgetScope: request.budgetScope }),
+              grant,
+              depth: context.depth + 1,
+              firstMessageId: messageId,
+              createdAtMillis: now,
+              expiresAtMillis: now + deps.limits.lifetimeMillis,
+              ...(reporting === undefined ? {} : { reporting }),
+              ...(request.toolCallAllowance === undefined
+                ? {}
+                : { toolCallAllowance: request.toolCallAllowance }),
             },
-            source: existing?.envelope.workerAdmission?.origin.source ?? context.source,
-            targetDigests: previousOrigin?.targetDigests ?? resolved.digests,
-            policy: request.policy,
-            budget: request.budget,
-            ...(request.budgetScope === undefined ? {} : { budgetScope: request.budgetScope }),
-            grant,
-            depth: context.depth + 1,
-            firstMessageId: messageId,
-            createdAtMillis: existing?.envelope.workerAdmission?.origin.createdAtMillis ?? now,
-            expiresAtMillis:
-              existing?.envelope.workerAdmission?.origin.expiresAtMillis ??
-              now + deps.limits.lifetimeMillis,
-            ...(reporting === undefined ? {} : { reporting }),
-            ...(request.toolCallAllowance === undefined
-              ? {}
-              : { toolCallAllowance: request.toolCallAllowance }),
-          },
-          "start",
-        );
+            "start",
+          );
 
-        yield* authorizeBudget(origin, principal);
+          yield* authorizeBudget(origin, principal);
 
-        const targetPolicy = Option.isSome(prepared.policy)
-          ? prepared.policy.value
-          : origin.budgetScope === "worker-run"
-            ? resolved.definition.policy
-            : AgentPolicy.resolve(
-                resolved.definition.policyOverrides ?? resolved.definition.policy,
-                sourcePolicy,
-              );
+          const targetPolicy = Option.isSome(prepared.policy)
+            ? prepared.policy.value
+            : origin.budgetScope === "worker-run"
+              ? resolved.definition.policy
+              : AgentPolicy.resolve(
+                  resolved.definition.policyOverrides ?? resolved.definition.policy,
+                  sourcePolicy,
+                );
 
-        if (
-          !withinPolicy(
-            origin,
-            origin.budgetScope === "worker-run" ? targetPolicy : sourcePolicy,
-            targetPolicy,
+          if (
+            !withinPolicy(
+              origin,
+              origin.budgetScope === "worker-run" ? targetPolicy : sourcePolicy,
+              targetPolicy,
+            )
           )
-        )
-          return yield* failure("start", "capacity");
+            return yield* failure("start", "capacity");
 
-        const delivery = yield* send(
-          origin,
-          messageId,
-          request.encodedInput,
-          request.encodedParameters,
-          principal,
-          "start",
-        );
+          const delivery = yield* send(
+            origin,
+            messageId,
+            request.encodedInput,
+            request.encodedParameters,
+            principal,
+            "start",
+          );
 
-        return { worker: origin.worker, delivery };
+          return { worker: origin.worker, delivery };
+        }).pipe(
+          Effect.catch((error) =>
+            Effect.gen(function* () {
+              if (!("prepare" in command)) return yield* Effect.fail(error);
+              // A concurrent first writer may have retained the command during preparation or insert.
+              // Only its exact declared arguments permit replay; absent proof preserves the failure.
+              const saved = yield* retained();
+
+              return saved === null ? yield* Effect.fail(error) : yield* replay(saved);
+            }),
+          ),
+        );
       }),
       followUp: Effect.fn("WorkerHost.followUp")(function* (request) {
         const principal = yield* authorize("followUp", "send", request.worker);
@@ -2351,9 +2447,8 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
       summary: Effect.fn("WorkerHost.inspectWorker")(function* (request) {
         yield* authorize("inspect", "read", request.worker);
         const origin = yield* findOrigin(request.worker, request.target, "inspect");
-        const source = yield* readWorkerState(context.source.threadId, "inspect");
 
-        return yield* summarize(origin, requests(source.records), "inspect");
+        return yield* summarize(origin, "inspect");
       }),
       observe: (request) =>
         Stream.unwrap(
@@ -2438,33 +2533,87 @@ export const makeWorkerRuntime = Effect.fn("WorkerHost.make")(function* (
         yield* binding(request.target, "list");
         if (!Number.isSafeInteger(request.limit) || request.limit < 1 || request.limit > 100)
           return yield* failure("list", "capacity");
-        const source = yield* readWorkerState(context.source.threadId, "list");
-        const all = requests(source.records);
-
-        const origins = [
-          ...new Map(
-            all.map((row) => [row.admission.origin.worker.threadId, row.admission.origin]),
-          ).values(),
-        ]
-          .filter(
-            (origin) =>
-              origin.worker.delegationId === request.delegationId &&
-              origin.worker.targetAgentId === request.target.id &&
-              (request.after === undefined || origin.worker.threadId > request.after),
-          )
-          .sort((left, right) => left.worker.threadId.localeCompare(right.worker.threadId));
+        if (Option.isNone(deps.deliveries)) return yield* failure("list", "unavailable");
+
+        const page = yield* deps.deliveries.value
+          .list({
+            ownerThreadId: context.source.threadId,
+            limit: request.limit,
+            workerStarts: { delegationId: request.delegationId, targetAgentId: request.target.id },
+            ...(request.after === undefined
+              ? {}
+              : { after: Schema.decodeSync(IdempotencyKey)(request.after) }),
+          })
+          .pipe(Effect.mapError(storageFailure("list")));
 
-        const selected = origins.slice(0, request.limit);
+        const items = yield* Effect.forEach(page.items, (row) => {
+          const origin = row.envelope.workerAdmission?.origin;
 
-        const items = yield* Effect.forEach(selected, (origin) => summarize(origin, all, "list"));
+          return origin === undefined || origin.firstMessageId !== row.key.messageId
+            ? failure("list", "corrupt")
+            : summarize(origin, "list");
+        });
 
-        return {
-          items,
-          next:
-            origins.length > selected.length
-              ? (selected[selected.length - 1]?.worker.threadId ?? null)
-              : null,
-        };
+        return { items, next: page.next === null ? null : Schema.decodeSync(ThreadId)(page.next) };
+      }),
+      stop: Effect.fn("WorkerHost.stop")(function* (request) {
+        const principal = yield* authorize("stop", "control", request.worker);
+
+        yield* findOrigin(request.worker, request.target, "stop");
+        if (deps.ledger.stopWorker === undefined) return yield* failure("stop", "unavailable");
+        const command = yield* decode(WorkerStop, request, "stop");
+
+        const id = Schema.decodeSync(RecordId)(
+          `worker-stop:${yield* messageIdFor([context.source.threadId, request.idempotencyKey])}`,
+        );
+
+        let retained = false;
+
+        for (let attempt = 0; attempt < 16; attempt++) {
+          const current = yield* deps.store
+            .inspectTail(ThreadTailRequest.make({ threadId: context.source.threadId }))
+            .pipe(Effect.mapError(storageFailure("stop")));
+
+          const prior = Option.getOrUndefined(
+            yield* exactRecord(context.source.threadId, id, "stop"),
+          )?.record.payload;
+
+          if (prior !== undefined) {
+            if (
+              prior._tag !== "WorkerStopRequested" ||
+              !Schema.toEquivalence(WorkerStop)(prior.command, command)
+            )
+              return yield* failure("stop", "idempotency-conflict");
+            retained = true;
+            break;
+          }
+          if (
+            yield* append(
+              context.source.threadId,
+              id,
+              WorkerStopRequested.make({ command }),
+              { ...current, records: [] },
+              "stop",
+            )
+          ) {
+            retained = true;
+            break;
+          }
+        }
+        if (!retained) return yield* failure("stop", "storage");
+        // The destination serializes this seal with admission. Replays retain every earlier
+        // abort intent and wait for active handlers/finalizers, rather than acknowledging a hint.
+        while (true) {
+          yield* hit("worker:before-stop-seal", "stop");
+
+          const owned = yield* deps.ledger
+            .stopWorker({ threadId: request.worker.threadId, author: principal })
+            .pipe(Effect.mapError(storageFailure("stop")));
+
+          yield* hit("worker:after-stop-seal", "stop");
+          if (owned === 0) return command;
+          yield* Effect.sleep(deps.settlementPollInterval);
+        }
       }),
       cancel: Effect.fn("WorkerHost.cancel")(function* (request) {
         const principal = yield* authorize("cancel", "control", request.worker);