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

package/src/durable/MessageDelivery.ts

@@ -1,7 +1,7 @@
 import { Clock, Context, Crypto, Effect, Layer, Result, Schema, Semaphore } from "effect";
 
 import * as FailureDiagnostic from "../core/FailureDiagnostic.ts";
-import { ThreadId } from "../core/Identifiers.ts";
+import { AgentId, DelegationId, ThreadId } from "../core/Identifiers.ts";
 import { Receipt } from "../core/Receipt.ts";
 import { WorkerUpdate } from "../core/Worker.ts";
 import { digestJson } from "./Digest.ts";
@@ -181,13 +181,28 @@ export const MessageDeliveryChange = Schema.Union([
 
 export type MessageDeliveryChange = typeof MessageDeliveryChange.Type;
 
+/** Select one native index per page; index filters cannot be combined. */
 export const MessageDeliveryPageRequest = Schema.Struct({
   ownerThreadId: ThreadId,
   limit: Positive.check(Schema.isLessThanOrEqualTo(4096)),
   after: Schema.optionalKey(IdempotencyKey),
   /** Native pending index, including accepted, future-due and parked obligations. */
   pendingOnly: Schema.optionalKey(Schema.Boolean),
-});
+  /** First retained envelopes, including starts not admitted at the destination. */
+  workerStarts: Schema.optionalKey(
+    Schema.Struct({ delegationId: DelegationId, targetAgentId: AgentId }),
+  ),
+  /** Retained inputs not yet acknowledged by one destination worker. */
+  pendingWorker: Schema.optionalKey(ThreadId),
+}).check(
+  Schema.makeFilter(
+    (request) =>
+      Number(request.pendingOnly === true) +
+        Number(request.workerStarts !== undefined) +
+        Number(request.pendingWorker !== undefined) <=
+      1,
+  ),
+);
 
 export type MessageDeliveryPageRequest = typeof MessageDeliveryPageRequest.Type;
 

package/src/durable/Records.ts

@@ -32,7 +32,7 @@ import {
 import { Selection, Snapshot } from "../core/ToolExposure.ts";
 import { ToolParameterRejection } from "../core/ToolResult.ts";
 import { ModelCallUsage, RunUsageSummary, RunTotals } from "../core/Usage.ts";
-import { WorkerBudgetScope, WorkerRef, WorkerSource } from "../core/Worker.ts";
+import { WorkerBudgetScope, WorkerRef, WorkerSource, WorkerStop } from "../core/Worker.ts";
 import { ContextHandoff } from "../engine/ContextWindow.ts";
 
 const identifier = <const Name extends string>(name: Name) =>
@@ -805,9 +805,10 @@ export class SubagentLineageRecorded extends Schema.TaggedClass<SubagentLineageR
 }) {}
 
 export const WorkerReportingIntent = Schema.Struct({
-  /** Standard framework reports or an application-mapped input projection. */
+  /** Absent only in historical custom-report origins; these remain readable as evidence. */
   mode: Schema.optionalKey(Schema.Literal("standard")),
   sourceDigests: DefinitionDigests,
+  /** Historical custom destination evidence. New worker origins never write this field. */
   destinationDelegationId: Schema.optionalKey(DelegationId),
   /** Frozen by the sender before acceptance. Standard emission never reads the source runtime. */
   returnAddress: Schema.optionalKey(
@@ -831,6 +832,8 @@ export const WorkerOrigin = Schema.Struct({
   source: WorkerSource,
   /** Omitted retains source-subtree funding; worker-run renews only for a new native Run. */
   budgetScope: Schema.optionalKey(WorkerBudgetScope),
+  /** Frozen at worker creation; older origins remain reusable. */
+  lifecycle: Schema.optionalKey(Schema.Literal("assignment")),
   targetDigests: DefinitionDigests,
   policy: Schema.toCodecJson(AgentPolicy),
   budget: SubagentBudgetReservation,
@@ -862,6 +865,12 @@ export const WorkerAdmission = Schema.Struct({
 
 export type WorkerAdmission = typeof WorkerAdmission.Type;
 
+/** Owner command retained before the destination inbox is sealed. */
+export class WorkerStopRequested extends Schema.TaggedClass<WorkerStopRequested>()(
+  "WorkerStopRequested",
+  { command: WorkerStop },
+) {}
+
 /** Source-log capacity reservation, retained independently of the source Run's settlement. */
 export class WorkerInputRequested extends Schema.TaggedClass<WorkerInputRequested>()(
   "WorkerInputRequested",
@@ -1009,6 +1018,7 @@ export const CanonicalRecordPayload = Schema.Union([
   SubagentJoined,
   SubagentLineageRecorded,
   WorkerInputRequested,
+  WorkerStopRequested,
   WorkerOriginRecorded,
   WorkerInputCompleted,
   WorkerReportPrepared,

package/src/durable/SqlMessageDeliveryStore.ts

@@ -270,7 +270,21 @@ export const makeSqlMessageDeliveryStore = Effect.fn("SqlMessageDeliveryStore.ma
 
       const rows = yield* query(
         "list",
-        sql`SELECT owner_thread_id, message_id, version, state, deadline_at_millis, record_json FROM effect_agent_message_deliveries WHERE owner_thread_id = ${input.ownerThreadId} ${input.after === undefined ? sql`` : sql`AND message_id > ${input.after}`} ${input.pendingOnly ? sql`AND state NOT IN ('processed', 'refused')` : sql``} ORDER BY message_id LIMIT ${input.limit + 1}`,
+        sql`SELECT owner_thread_id, message_id, version, state, deadline_at_millis, record_json FROM effect_agent_message_deliveries WHERE owner_thread_id = ${input.ownerThreadId} ${input.after === undefined ? sql`` : sql`AND message_id > ${input.after}`} ${input.pendingOnly ? sql`AND state NOT IN ('processed', 'refused')` : sql``}
+        ${
+          input.workerStarts === undefined
+            ? sql``
+            : sql`AND json_extract(record_json, '$.envelope.workerAdmission.origin.worker.delegationId') = ${input.workerStarts.delegationId}
+          AND json_extract(record_json, '$.envelope.workerAdmission.origin.worker.targetAgentId') = ${input.workerStarts.targetAgentId}
+          AND message_id = json_extract(record_json, '$.envelope.workerAdmission.origin.firstMessageId')`
+        }
+        ${
+          input.pendingWorker === undefined
+            ? sql``
+            : sql`AND json_extract(record_json, '$.envelope.workerAdmission.origin.worker.threadId') = ${input.pendingWorker}
+          AND state IN ('pending', 'parked') AND json_extract(record_json, '$.receipt') IS NULL`
+        }
+        ORDER BY message_id LIMIT ${input.limit + 1}`,
       );
 
       const records = yield* decodeRows(rows);

package/src/durable/SqlThreadNativeReads.ts

@@ -178,6 +178,20 @@ export const makeSelectedReads = Effect.fnUntraced(function* (
               rows =
                 yield* sql`SELECT thread_id, sequence, record_id, batch_id, record_json, outstanding FROM effect_agent_canonical_records WHERE thread_id = ${request.threadId} AND outstanding <> 0 AND sequence > ${after} ORDER BY sequence LIMIT ${request.page.limit}`;
               break;
+            case "WorkerExecution":
+              rows = (yield* Effect.forEach(
+                ["UserInputRecorded", "RunStarted"],
+                (tag) =>
+                  sql`SELECT thread_id, sequence, record_id, batch_id, record_json FROM effect_agent_canonical_records
+                  WHERE thread_id = ${request.threadId} AND json_extract(record_json, '$.payload._tag') = ${tag}
+                    AND json_extract(record_json, '$.payload.runId') IS NOT NULL
+                  ORDER BY sequence DESC LIMIT 1`,
+              ))
+                .flat()
+                .filter((row) => Number(row.sequence) > after)
+                .sort((a, b) => Number(a.sequence) - Number(b.sequence))
+                .slice(0, request.page.limit);
+              break;
             case "WorkerState": {
               const runId =
                 selection.sourceSubmissionId === undefined

package/src/durable/SubmissionLedger.ts

@@ -15,6 +15,7 @@ import {
 import type { JoinedToHost } from "../core/Receipt.ts";
 import { IdempotencyKey, QueueSequence, Principal } from "../core/Receipt.ts";
 import { RunUsageSummary } from "../core/Usage.ts";
+import { AssignmentTerminal } from "../core/Worker.ts";
 import {
   AbortRequested,
   ApprovalDecision,
@@ -241,6 +242,16 @@ export class SubmissionSnapshot extends Schema.Class<SubmissionSnapshot>(
   messageAdmission: Schema.optionalKey(InputMessage),
 }) {}
 
+/** Bounded native control facts. Canonical input/Run records remain ThreadStore-owned. */
+export const WorkerLedgerState = Schema.Struct({
+  latest: Schema.NullOr(SubmissionSnapshot),
+  active: Schema.NullOr(SubmissionSnapshot),
+  stopped: Schema.Boolean,
+  terminal: Schema.optionalKey(AssignmentTerminal),
+}).check(Schema.makeFilter((state) => state.terminal === undefined || state.stopped));
+
+export type WorkerLedgerState = typeof WorkerLedgerState.Type;
+
 /** The authoritative store proves the scoped idempotency key was never admitted (SUB-031). */
 export class AdmissionNotAdmitted extends Schema.TaggedClass<AdmissionNotAdmitted>(
   "@effect-agent/thread/AdmissionNotAdmitted",
@@ -418,6 +429,38 @@ export const settlementFailureFromRecord = (
     : undefined;
 };
 
+/**
+ * Assignment intent derived only from frozen admission and exact settlement evidence.
+ * Joined receipts and cancellation before a Run starts do not finish an assignment.
+ * Adapters suppress completed intent when newer accepted input remains unapplied, then
+ * install the first seal and outstanding abort intents atomically before releasing the lane.
+ */
+export const workerTerminalFromRecord = (
+  submission: SubmissionSnapshot,
+  record: RecordEnvelope,
+): AssignmentTerminal | undefined => {
+  const payload = record.payload;
+
+  if (
+    submission.workerAdmission?.origin.lifecycle !== "assignment" ||
+    payload._tag !== "SubmissionSettled" ||
+    (payload.runId !== undefined && payload.runId !== `run:${submission.submissionId}`)
+  )
+    return undefined;
+  if (payload.outcome === "failed" || payload.finishReason === "budget-exhausted") return "failed";
+  if (payload.outcome === "aborted") return payload.runId === undefined ? undefined : "cancelled";
+
+  return payload.runDisposition === "completed" ? "completed" : undefined;
+};
+
+/** Destination-owned permanent inbox seal; recorded atomically with all outstanding abort intents. */
+export const WorkerStopCommand = Schema.Struct({
+  threadId: ThreadId,
+  author: Principal,
+});
+
+export type WorkerStopCommand = typeof WorkerStopCommand.Type;
+
 /**
  * A durable abort command (durability §13). Field bounds are exactly those of the canonical
  * `AbortRequested` payload so the intent can become canonical without re-validation.
@@ -995,7 +1038,8 @@ export type SubmissionLedgerFailure =
  *   recovery settles aborted never-claimed queued work immediately, without waiting for it to
  *   head the lane. Both exceptions are outcome- and state-narrow; everything else stays fenced.
  * - `finalizeSettlement` — idempotent terminal transition (state → settled) after the reserved
- *   record is canonical; releases the lane so the next `queueSequence` becomes claimable. It
+ *   record is canonical. Native adapters seal opted-in worker assignments atomically before
+ *   releasing the lane. Otherwise the next `queueSequence` becomes claimable. It
  *   requires no ownership token: canonical history authorizes finalization (DUR-015). A
  *   finalization that disagrees with the recorded outcome fails with `SettlementConflict`.
  * - `requestAbort` — durable, idempotent by `submissionId`: repeating returns the recorded
@@ -1100,6 +1144,9 @@ export class SubmissionLedger extends Context.Service<
     readonly finalizeSettlement: (
       request: SettlementFinalization,
     ) => Effect.Effect<Settlement, SettlementConflict | LedgerError>;
+    /** Optional for third-party adapters. Remaining ownership must reach zero before stop acknowledgement. */
+    readonly inspectWorker?: (threadId: ThreadId) => Effect.Effect<WorkerLedgerState, LedgerError>;
+    readonly stopWorker?: (request: WorkerStopCommand) => Effect.Effect<number, LedgerError>;
     readonly requestAbort: (
       request: AbortCommand,
     ) => Effect.Effect<AbortIntent, SettlementConflict | JoinedToHost | LedgerError>;

package/src/durable/SubmissionLedgerConformance.ts

@@ -26,6 +26,7 @@ import {
   WorkerAdmission,
   type SettlementFailureDiagnostic,
 } from "./Records.ts";
+import { runIdForSubmission } from "./RunJournal.ts";
 import {
   type AdmissionResult,
   AbortCommand,
@@ -64,6 +65,7 @@ import {
   ResolutionSafeToRetry,
   RevertJoiningRequest,
   SettlementConflict,
+  Settlement,
   SettlementFinalization,
   SettlementReservation,
   SubmissionLedger,
@@ -538,6 +540,50 @@ const admissionIdempotency = conformanceCase(
     }),
 );
 
+const workerMetadata = (base: AdmissionRequest) =>
+  WorkerAdmission.make({
+    messageId: base.idempotencyKey,
+    sourceSubmissionId: Schema.decodeSync(SubmissionId)("source-input"),
+    deliveryPrincipal: base.principal,
+    parameters: { prompt: "original projection parameters" },
+    createdAtMillis: 1,
+    origin: {
+      worker: {
+        schemaVersion: 1,
+        threadId: base.threadId,
+        targetAgentId: CONFORMANCE_AGENT,
+        delegationId: Schema.decodeSync(DelegationId)("worker-research"),
+      },
+      source: {
+        _tag: "programmatic",
+        threadId: decodeThreadId("worker-source"),
+        agentId: CONFORMANCE_AGENT,
+      },
+      targetDigests: CONFORMANCE_DIGESTS,
+      policy: AgentPolicy.resolve(),
+      budget: {
+        caps: SubagentDelegationCaps.make({
+          maxConcurrentChildren: 1,
+          maxTotalChildInvocations: 2,
+        }),
+        allocation: SubagentReservationAmounts.make({
+          turns: 12,
+          toolCalls: 24,
+          durationMillis: 300_000,
+          inputTokens: 0,
+          outputTokens: 0,
+          costMicrousd: 0,
+          resultBytes: 1_000,
+        }),
+      },
+      grant: SubagentGrant.make({ maxDepth: 1, allowedToolNames: [] }),
+      depth: 1,
+      firstMessageId: base.idempotencyKey,
+      createdAtMillis: 1,
+      expiresAtMillis: 1_000_000,
+    },
+  });
+
 const workerAdmissionIdentity = conformanceCase(
   "retains immutable worker admission metadata and rejects same-key changes or omission",
   ({ ensure, expectFailure, expectSome }) =>
@@ -550,48 +596,7 @@ const workerAdmissionIdentity = conformanceCase(
         { text: "first" },
       );
 
-      const metadata = WorkerAdmission.make({
-        messageId: base.idempotencyKey,
-        sourceSubmissionId: Schema.decodeSync(SubmissionId)("source-input"),
-        deliveryPrincipal: base.principal,
-        parameters: { prompt: "original projection parameters" },
-        createdAtMillis: 1,
-        origin: {
-          worker: {
-            schemaVersion: 1,
-            threadId: base.threadId,
-            targetAgentId: CONFORMANCE_AGENT,
-            delegationId: Schema.decodeSync(DelegationId)("worker-research"),
-          },
-          source: {
-            _tag: "programmatic",
-            threadId: decodeThreadId("worker-source"),
-            agentId: CONFORMANCE_AGENT,
-          },
-          targetDigests: CONFORMANCE_DIGESTS,
-          policy: AgentPolicy.resolve(),
-          budget: {
-            caps: SubagentDelegationCaps.make({
-              maxConcurrentChildren: 1,
-              maxTotalChildInvocations: 2,
-            }),
-            allocation: SubagentReservationAmounts.make({
-              turns: 12,
-              toolCalls: 24,
-              durationMillis: 300_000,
-              inputTokens: 0,
-              outputTokens: 0,
-              costMicrousd: 0,
-              resultBytes: 1_000,
-            }),
-          },
-          grant: SubagentGrant.make({ maxDepth: 1, allowedToolNames: [] }),
-          depth: 1,
-          firstMessageId: base.idempotencyKey,
-          createdAtMillis: 1,
-          expiresAtMillis: 1_000_000,
-        },
-      });
+      const metadata = workerMetadata(base);
 
       const admitted = yield* ledger.admit(
         AdmissionRequest.make({ ...base, workerAdmission: metadata }),
@@ -4553,6 +4558,218 @@ const abortedSettledRowIsNotAJoiningGap = conformanceCase(
     }),
 );
 
+const assignmentSettlement = conformanceCase(
+  "seals terminal assignments atomically while waiting and unapplied corrections remain steerable",
+  ({ ensure, expectSome, expectFailure }) =>
+    Effect.gen(function* () {
+      const ledger = yield* SubmissionLedger;
+
+      if (ledger.inspectWorker === undefined) return;
+
+      // Each row isolates one ownership rule. The same cases run on every native adapter.
+      const cases = [
+        {
+          name: "completed",
+          outcome: "completed",
+          disposition: "completed",
+          terminal: "completed",
+        },
+        { name: "waiting", outcome: "completed", disposition: "waiting", terminal: undefined },
+        { name: "failure", outcome: "failed", queued: true, terminal: "failed" },
+        {
+          name: "failure-joining",
+          outcome: "failed",
+          queued: true,
+          joining: true,
+          terminal: "failed",
+        },
+        { name: "exhaustion", outcome: "completed", exhausted: true, terminal: "failed" },
+        { name: "active-abort", outcome: "aborted", terminal: "cancelled" },
+        { name: "queued-abort", outcome: "aborted", noRun: true, terminal: undefined },
+        {
+          name: "reusable",
+          outcome: "completed",
+          disposition: "completed",
+          reusable: true,
+          terminal: undefined,
+        },
+        {
+          name: "late-correction",
+          outcome: "completed",
+          disposition: "completed",
+          queued: true,
+          terminal: undefined,
+        },
+        {
+          name: "applied-correction",
+          outcome: "completed",
+          disposition: "completed",
+          queued: true,
+          joined: true,
+          terminal: "completed",
+        },
+      ] as const;
+
+      for (const scenario of cases) {
+        const threadId = decodeThreadId(`assignment-${scenario.name}`);
+        const base = yield* admissionRequest(threadId, "first", { text: "first" });
+        const metadata = workerMetadata(base);
+
+        const workerAdmission = WorkerAdmission.make({
+          ...metadata,
+          origin: {
+            ...metadata.origin,
+            ...("reusable" in scenario ? {} : { lifecycle: "assignment" as const }),
+          },
+        });
+
+        const request = AdmissionRequest.make({ ...base, workerAdmission });
+
+        const first = yield* ledger.admit(request);
+
+        yield* ledger.markReady(MarkReadyRequest.make({ submissionId: first.submissionId }));
+        const claim = yield* expectSome("assignment claim", yield* claimLane(threadId, PRODUCER_A));
+        const runId = runIdForSubmission(first.submissionId);
+
+        const payload = yield* Schema.decodeEffect(SubmissionSettledRecord)(
+          SubmissionSettled.make({
+            submissionId: first.submissionId,
+            settlementId: submissionSettlementId(first.submissionId),
+            receiptId: first.receiptId,
+            outcome: scenario.outcome,
+            ...("noRun" in scenario ? {} : { runId }),
+            ...(scenario.outcome === "aborted"
+              ? {}
+              : {
+                  result:
+                    scenario.outcome === "failed"
+                      ? { errorTag: "TestFailure", message: "Failed task" }
+                      : { answer: "done" },
+                }),
+            ...("disposition" in scenario ? { runDisposition: scenario.disposition } : {}),
+            ...("exhausted" in scenario
+              ? { finishReason: "budget-exhausted" as const, exhausted: "turns" as const }
+              : {}),
+          }),
+        ).pipe(Effect.orDie);
+
+        const record = RecordEnvelope.make({
+          recordId: submissionSettlementRecordId(first.submissionId),
+          family: "thread",
+          schemaVersion: 1,
+          createdAt: CONFORMANCE_CREATED_AT,
+          deploymentId: CONFORMANCE_DEPLOYMENT,
+          payload,
+        });
+
+        let queued: AdmissionResult | undefined;
+
+        if ("queued" in scenario) {
+          const next = yield* admissionRequest(threadId, "correction", { text: "correction" });
+
+          queued = yield* ledger.admit(
+            AdmissionRequest.make({
+              ...next,
+              workerAdmission: { ...workerAdmission, messageId: next.idempotencyKey },
+            }),
+          );
+          yield* ledger.markReady(MarkReadyRequest.make({ submissionId: queued.submissionId }));
+          if ("joined" in scenario || "joining" in scenario) {
+            yield* ledger.claimJoining(
+              ClaimJoiningRequest.make({
+                threadId,
+                hostSubmissionId: first.submissionId,
+                ownershipToken: claim.ownershipToken,
+                maxCount: 1,
+              }),
+            );
+          }
+          if ("joined" in scenario) {
+            yield* ledger.markJoined(
+              MarkJoinedRequest.make({
+                submissionId: queued.submissionId,
+                ownershipToken: claim.ownershipToken,
+                recordId: submissionInputRecordId(queued.submissionId),
+                sequence: Schema.decodeSync(CanonicalSequence)(2),
+              }),
+            );
+          }
+        }
+        yield* ledger.reserveSettlement(
+          SettlementReservation.make({
+            submissionId: first.submissionId,
+            ownershipToken: claim.ownershipToken,
+            settlementId: payload.settlementId,
+            outcome: scenario.outcome,
+            record,
+            recordDigest: yield* digestJson(
+              yield* Schema.encodeEffect(RecordEnvelope)(record).pipe(Effect.orDie),
+            ),
+          }),
+        );
+
+        const finalization = SettlementFinalization.make({
+          submissionId: first.submissionId,
+          settlementId: payload.settlementId,
+        });
+
+        const settled = yield* ledger.finalizeSettlement(finalization);
+
+        yield* ensure(
+          Schema.toEquivalence(Settlement)(settled, yield* ledger.finalizeSettlement(finalization)),
+          "Finalization replay must preserve its exact outcome",
+        );
+        const control = yield* ledger.inspectWorker(threadId);
+
+        yield* ensure(
+          control.terminal === scenario.terminal &&
+            control.stopped === (scenario.terminal !== undefined),
+          `Wrong assignment state for ${scenario.name}`,
+        );
+        yield* ensure(
+          (yield* ledger.admit(request)).receiptId === first.receiptId,
+          "A seal must preserve same-command receipt replay",
+        );
+        const next = yield* admissionRequest(threadId, "later", { text: "later" });
+
+        const later = AdmissionRequest.make({
+          ...next,
+          workerAdmission: { ...workerAdmission, messageId: next.idempotencyKey },
+        });
+
+        if (scenario.terminal !== undefined) {
+          const refusal = yield* expectFailure("terminal admission", ledger.admit(later));
+
+          yield* ensure(
+            Schema.is(AdmissionPolicyError)(refusal) && refusal.code === "worker-stopped",
+            "New instructions cannot reopen a terminal assignment",
+          );
+        } else {
+          yield* ledger.admit(later);
+        }
+        if (queued !== undefined) {
+          if ("joining" in scenario)
+            yield* ledger.revertJoining(
+              RevertJoiningRequest.make({ submissionId: queued.submissionId }),
+            );
+          const state = yield* recoverySnapshot(queued.submissionId);
+
+          yield* ensure(
+            (state.abortIntent !== undefined) === (scenario.outcome === "failed"),
+            "Failure aborts queued inputs; completion never cancels an accepted correction or joined member",
+          );
+        }
+        if (scenario.terminal !== undefined && ledger.stopWorker !== undefined) {
+          yield* ledger.stopWorker({ threadId, author: CONFORMANCE_PRINCIPAL });
+          yield* ensure(
+            (yield* ledger.inspectWorker(threadId)).terminal === scenario.terminal,
+            "Explicit stop cannot replace an assignment's first terminal outcome",
+          );
+        }
+      }
+    }),
+);
+
 /**
  * The shared, adapter-parameterized SubmissionLedger contract suite (STORE-010). Every durable
  * ledger adapter test suite must execute each case against its own ledger provisioning, inside
@@ -4561,6 +4778,7 @@ const abortedSettledRowIsNotAJoiningGap = conformanceCase(
 export const submissionLedgerConformanceCases: ReadonlyArray<SubmissionLedgerConformanceCase> = [
   admissionIdempotency,
   workerAdmissionIdentity,
+  assignmentSettlement,
   messageAdmissionIdentity,
   workerCompletionIdentity,
   workerUpdateIdentity,

package/src/durable/ThreadStore.ts

@@ -324,6 +324,11 @@ export const ThreadSelection = Schema.Union([
     expectedTailSequence: CanonicalSequence,
     expectedTailDigest: Digest,
   }),
+  Schema.Struct({
+    _tag: Schema.Literal("WorkerExecution"),
+    expectedTailSequence: CanonicalSequence,
+    expectedTailDigest: Digest,
+  }),
   Schema.Struct({
     _tag: Schema.Literal("WorkerState"),
     expectedTailSequence: CanonicalSequence,

package/src/durable/internal/agent-registration.ts

@@ -230,15 +230,6 @@ interface CapturedBinding {
   ) => Effect.Effect<Option.Option<Settlement>, DurableWorkerFailure>;
 }
 
-type ReportRequirements<Reports> =
-  Reports extends ReadonlyArray<WorkerReporting<unknown, unknown>>
-    ? [Reports[number]] extends [never]
-      ? never
-      : Reports[number] extends WorkerReporting<unknown, infer R>
-        ? Exclude<R, Scope.Scope>
-        : never
-    : never;
-
 // Registrations outlive their construction span. Dependencies remain captured,
 // while every attempt/report inherits the invoking fiber's tracing state.
 const omitTraceContext = Context.omit(
@@ -352,32 +343,16 @@ const capture = <A extends ExecutableAgentBinding, Provides = never, Requires =
  * may supply a previously computed digest triple directly.
  */
 export const DurableWorkerBinding = {
-  make: <
-    A extends ExecutableAgentBinding,
-    const Reports extends ReadonlyArray<WorkerReporting<unknown, unknown>> = readonly [],
-  >(
+  make: <A extends ExecutableAgentBinding>(
     agent: A,
     digests: DefinitionDigests,
-    reporting?: Reports,
-  ): Effect.Effect<
-    ResolvedBinding,
-    never,
-    DurableWorkerRequirements<A> | ReportRequirements<Reports>
-  > =>
+  ): Effect.Effect<ResolvedBinding, never, DurableWorkerRequirements<A>> =>
     Effect.gen(function* () {
       const binding = yield* capture(agent);
+      const reporting = yield* captureReporting(backgroundReports(agent.definition));
 
-      const reports = yield* captureReporting([
-        ...(reporting ?? []),
-        ...backgroundReports(agent.definition),
-      ]);
-
-      return { ...binding, digests, reporting: reports };
-    }) as Effect.Effect<
-      ResolvedBinding,
-      never,
-      DurableWorkerRequirements<A> | ReportRequirements<Reports>
-    >,
+      return { ...binding, digests, reporting };
+    }),
 } as const;
 
 /** INTERNAL identity-only capture retained for the legacy direct worker path. */
@@ -442,12 +417,6 @@ export type AgentRegistration<A extends ExecutableAgentBinding = ExecutableAgent
   readonly continuity?: {
     readonly versions: ReplayVersions;
   };
-  /**
-   * Source-owned reports capture services outside attemptLayer and open a fresh Scope per
-   * preparation. Version changes with this registration. Missing exact code and preparation
-   * failures become retained report refusals; durable delivery retries reuse the frozen input.
-   */
-  readonly reporting?: ReadonlyArray<WorkerReporting<unknown, unknown>>;
   /**
    * Build fresh services for exactly one fenced Attempt, across all its Tool/model turns.
    * Finalizes on completion, suspension, failure and interruption. Never reused after eviction.
@@ -477,12 +446,10 @@ type AttemptLayerRequirements<Requirements, AttemptLayer> = AttemptLayer extends
 // Conditional options retain every service they may consume. An absent attempt Layer
 // still needs the original worker services; only a definite Layer can remove them.
 type EntryRequirements<Entry> = Entry extends unknown
-  ?
-      | AttemptLayerRequirements<
-          EntryWorkerRequirements<Entry>,
-          "attemptLayer" extends keyof Entry ? Entry["attemptLayer"] : undefined
-        >
-      | ("reporting" extends keyof Entry ? ReportRequirements<Entry["reporting"]> : never)
+  ? AttemptLayerRequirements<
+      EntryWorkerRequirements<Entry>,
+      "attemptLayer" extends keyof Entry ? Entry["attemptLayer"] : undefined
+    >
   : never;
 
 type RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = [
@@ -519,8 +486,9 @@ const registrationDefinitions = (entry: AgentRegistration): DefinitionDigestInpu
             backgroundReporting: automatic.map((report) => ({
               delegationId: report.delegationId,
               targetAgentId: report.target.id,
-              mode: report.mode ?? "custom",
-              destinationDelegationId: report.destination?.delegationId ?? null,
+              mode: "standard",
+              // Preserve the fingerprint of existing standard registrations.
+              destinationDelegationId: null,
             })),
           },
         };
@@ -579,10 +547,7 @@ const compileRegistration = <Entry extends AgentRegistration>(
           entry.attemptLayer,
         );
 
-        const reporting = yield* captureReporting([
-          ...(entry.reporting ?? []),
-          ...backgroundReports(binding.definition),
-        ]);
+        const reporting = yield* captureReporting(backgroundReports(binding.definition));
 
         return {
           ...binding,