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

package/src/capabilities/Subagent.ts

@@ -1544,6 +1544,7 @@ export function layer<
         };
 
   if (childBinding.definition !== delegation.target) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Subagent.layer synchronously requires the exact declared target before constructing its Layer.
     throw new Error("Subagent.layer requires the delegation's exact target Definition");
   }
 
@@ -2304,41 +2305,27 @@ export function layer<
     ): SubagentToolFailure<Failure>["Type"] =>
       failure instanceof GenuineEngineSignal ? failure.signal : failure;
 
-    const handlerImpl = (
+    const handlerImpl = Effect.fnUntraced(function* (
       parameters: Parameters["Type"],
       handlerContext: Toolkit.HandlerContext<
         SubagentTool<Name, Parameters, Success, Failure, Mode>
       >,
-    ) =>
-      Effect.gen(function* () {
-        // Resolve the engine-provided per-call services before providing the
-        // captured construction context and re-provide them innermost: if the
-        // Layer was constructed inside another Run's Tool batch, the captured
-        // context would otherwise shadow this Run's `AgentSpawner` (and its
-        // delegation depth), this batch's live `RunEventSink`, and this
-        // batch's live `SubagentDurability` mode.
-        const spawner = yield* AgentSpawner;
-        const sink = yield* RunEventSink;
-        const durability = yield* SubagentDurability;
-
-        // Service-mode dispatch (S2 plan §2): the engine states ephemeral
-        // mode explicitly when no durable coordinator supplied the hook, so
-        // absence keeps the S1 in-process spawn semantics honestly.
-        if (durability.mode === "durable") {
-          const durable = invokeDurable(parameters, handlerContext, durability).pipe(
-            Effect.scoped,
-            Effect.provideService(AgentSpawner, spawner),
-            Effect.provideService(RunEventSink, sink),
-            Effect.provideService(SubagentDurability, durability),
-            Effect.provide(captured),
-          );
-
-          return yield* contained
-            ? durable.pipe(Effect.catch(containSignals))
-            : durable.pipe(Effect.mapError(unwrapSignals));
-        }
+    ) {
+      // Resolve the engine-provided per-call services before providing the
+      // captured construction context and re-provide them innermost: if the
+      // Layer was constructed inside another Run's Tool batch, the captured
+      // context would otherwise shadow this Run's `AgentSpawner` (and its
+      // delegation depth), this batch's live `RunEventSink`, and this
+      // batch's live `SubagentDurability` mode.
+      const spawner = yield* AgentSpawner;
+      const sink = yield* RunEventSink;
+      const durability = yield* SubagentDurability;
 
-        const ephemeral = invoke(parameters, handlerContext).pipe(
+      // Service-mode dispatch (S2 plan §2): the engine states ephemeral
+      // mode explicitly when no durable coordinator supplied the hook, so
+      // absence keeps the S1 in-process spawn semantics honestly.
+      if (durability.mode === "durable") {
+        const durable = invokeDurable(parameters, handlerContext, durability).pipe(
           Effect.scoped,
           Effect.provideService(AgentSpawner, spawner),
           Effect.provideService(RunEventSink, sink),
@@ -2347,9 +2334,22 @@ export function layer<
         );
 
         return yield* contained
-          ? ephemeral.pipe(Effect.catch(containSignals))
-          : ephemeral.pipe(Effect.mapError(unwrapSignals));
-      });
+          ? durable.pipe(Effect.catch(containSignals))
+          : durable.pipe(Effect.mapError(unwrapSignals));
+      }
+
+      const ephemeral = invoke(parameters, handlerContext).pipe(
+        Effect.scoped,
+        Effect.provideService(AgentSpawner, spawner),
+        Effect.provideService(RunEventSink, sink),
+        Effect.provideService(SubagentDurability, durability),
+        Effect.provide(captured),
+      );
+
+      return yield* contained
+        ? ephemeral.pipe(Effect.catch(containSignals))
+        : ephemeral.pipe(Effect.mapError(unwrapSignals));
+    });
 
     // `handlerImpl`'s channels are the UNION of both modes because
     // `contained` is a runtime branch TypeScript cannot relate to the

package/src/capabilities/SubagentReservations.ts

@@ -327,6 +327,14 @@ type TransitionResult<A, E> =
 const ok = <A>(value: A): TransitionResult<A, never> => ({ _tag: "ok", value });
 const fail = <E>(error: E): TransitionResult<never, E> => ({ _tag: "error", error });
 
+/** Corrupt internal accounting is a defect, never an expected reservation failure. */
+class ReservationLedgerCorrupt extends Schema.TaggedError<ReservationLedgerCorrupt>()(
+  "ReservationLedgerCorrupt",
+  {
+    message: Schema.String,
+  },
+) {}
+
 const resolve = <A, E>(result: TransitionResult<A, E>): Effect.Effect<A, E> => {
   switch (result._tag) {
     case "ok":
@@ -334,7 +342,7 @@ const resolve = <A, E>(result: TransitionResult<A, E>): Effect.Effect<A, E> => {
     case "error":
       return Effect.fail(result.error);
     case "corrupt":
-      return Effect.die(new Error(result.message));
+      return Effect.die(ReservationLedgerCorrupt.make({ message: result.message }));
   }
 };
 

package/src/capabilities/WebCapture.ts

@@ -246,6 +246,7 @@ const HOST_PATTERN = /^(\*\.)?[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]
 
 const compileUrlPolicy = (patterns: ReadonlyArray<string>): ReadonlyArray<string> => {
   if (patterns.length === 0) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- WebCapture constructors synchronously require an explicit host allowlist.
     throw new Error(
       "Web capture requires at least one allowed host pattern; capture is deny-by-default",
     );
@@ -256,6 +257,7 @@ const compileUrlPolicy = (patterns: ReadonlyArray<string>): ReadonlyArray<string
       const pattern = raw.trim().toLowerCase();
 
       if (!HOST_PATTERN.test(pattern)) {
+        // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- WebCapture constructors synchronously reject malformed host allowlist patterns.
         throw new Error(
           `Web capture host pattern ${JSON.stringify(raw)} must be a bare host name such as docs.example.com or *.example.com — no scheme, path, port, or credentials`,
         );
@@ -282,6 +284,7 @@ const validateMaxResponseBytes = (value: number | undefined): number => {
 
   // Fail closed on an invalid budget: NaN would make every comparison false.
   if (!Number.isSafeInteger(bytes) || bytes < 1_024 || bytes > 1024 * 1024) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- WebCapture constructors synchronously reject invalid response-size bounds.
     throw new Error(
       `Web capture maxResponseBytes must be an integer between 1024 and ${1024 * 1024}; received ${String(value)}`,
     );
@@ -396,6 +399,7 @@ const make = <const Name extends string>(
   const actions = Object.freeze([...new Set(options.actions ?? allActions)]);
 
   if (actions.length === 0) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- WebCapture.make synchronously requires at least one model-selectable action.
     throw new Error("Web capture requires at least one model-selectable action");
   }
 
@@ -519,6 +523,7 @@ const makeExtract = <const Name extends string, S extends Schema.Top>(
   const prompt = options.prompt;
 
   if (prompt !== undefined && (prompt.length === 0 || prompt.length > 8_192)) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- WebCapture.extract synchronously validates its fixed extraction prompt length.
     throw new Error("Web capture extraction prompt must be between 1 and 8192 characters");
   }
 
@@ -530,6 +535,7 @@ const makeExtract = <const Name extends string, S extends Schema.Top>(
     const decoded = Schema.decodeUnknownOption(PageCaptureResponseFormat)(jsonSchema);
 
     if (Option.isNone(decoded)) {
+      // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- WebCapture.extract synchronously requires a bounded object response schema.
       throw new Error(
         `Web capture cannot derive a bounded object JSON response format from the extraction Schema for ${name}`,
       );

package/src/capabilities/WebSearch.ts

@@ -89,6 +89,7 @@ export const native = <T extends Tool.AnyProviderDefined>(options: Pick<Options<
     options.tool.requiresHandler ||
     !["web_search", "web_search_preview"].includes(options.tool.providerName)
   ) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- WebSearch.native synchronously requires a provider-executed search Tool.
     throw new Error("WebSearch.native requires a provider-executed web_search tool");
   }
 
@@ -97,6 +98,7 @@ export const native = <T extends Tool.AnyProviderDefined>(options: Pick<Options<
 
 const boundedInteger = (name: string, value: number, maximum: number): number => {
   if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- WebSearch.layer synchronously validates request and response bounds before creating its Layer.
     throw new Error(`WebSearch ${name} must be an integer between 1 and ${maximum}`);
   }
 
@@ -117,6 +119,7 @@ export const layer = <T extends Tool.AnyProviderDefined>(options: Options<T>) =>
     !Tool.isProviderDefined(options.tool) ||
     !["web_search", "web_search_preview"].includes(options.tool.providerName)
   ) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- WebSearch.layer synchronously requires a provider-defined search Tool.
     throw new Error("WebSearch requires a native provider-defined web_search tool");
   }
   const searchTool = options.tool;
@@ -150,14 +153,14 @@ export const layer = <T extends Tool.AnyProviderDefined>(options: Options<T>) =>
       return {
         WebSearch: Effect.fnUntraced(function* (input) {
           const { query } = yield* Schema.decodeEffect(Parameters)(input).pipe(
-            Effect.mapError(() => new Failure({ reason: "invalid-query" })),
+            Effect.mapError(() => Failure.make({ reason: "invalid-query" })),
           );
 
           const response = yield* generateWithContext(query).pipe(
-            Effect.mapError(() => new Failure({ reason: "provider" })),
+            Effect.mapError(() => Failure.make({ reason: "provider" })),
             Effect.timeoutOrElse({
               duration: timeoutMillis,
-              orElse: () => Effect.fail(new Failure({ reason: "timeout" })),
+              orElse: () => Effect.fail(Failure.make({ reason: "timeout" })),
             }),
           );
 
@@ -170,10 +173,10 @@ export const layer = <T extends Tool.AnyProviderDefined>(options: Options<T>) =>
               );
             })
           ) {
-            return yield* new Failure({ reason: "provider" });
+            return yield* Failure.make({ reason: "provider" });
           }
           if (!response.toolResults.some((result) => result.name === searchTool.name)) {
-            return yield* new Failure({ reason: "search-not-executed" });
+            return yield* Failure.make({ reason: "search-not-executed" });
           }
 
           const sources = response.content.flatMap((part) =>
@@ -192,11 +195,11 @@ export const layer = <T extends Tool.AnyProviderDefined>(options: Options<T>) =>
           };
 
           if (utf8ByteLength(JSON.stringify(result)) > maxOutputBytes) {
-            return yield* new Failure({ reason: "output-limit" });
+            return yield* Failure.make({ reason: "output-limit" });
           }
 
           return yield* Schema.decodeEffect(Result)(result).pipe(
-            Effect.mapError(() => new Failure({ reason: "invalid-response" })),
+            Effect.mapError(() => Failure.make({ reason: "invalid-response" })),
           );
         }),
       };

package/src/capabilities/internal/subagent-background.ts

@@ -304,48 +304,47 @@ const operations = <
       encodedGrant,
       ...(options.continuationOf === undefined ? {} : { continuationOf: options.continuationOf }),
       ...(options.budgetScope === undefined ? {} : { budgetScope: options.budgetScope }),
-      prepare: (budgetScope) =>
-        Effect.gen(function* () {
-          const encodedInput = yield* prepare(parameters, caller);
-
-          const effectiveTarget = yield* service.resolveTargetPolicy({
-            target: declaration.target,
-            encodedInput,
-            ...(options.continuationOf === undefined
+      prepare: Effect.fnUntraced(function* (budgetScope) {
+        const encodedInput = yield* prepare(parameters, caller);
+
+        const effectiveTarget = yield* service.resolveTargetPolicy({
+          target: declaration.target,
+          encodedInput,
+          ...(options.continuationOf === undefined
+            ? {}
+            : { continuationOf: options.continuationOf }),
+        });
+
+        const resolvedTarget = Option.getOrUndefined(effectiveTarget);
+
+        const resolved = resolveSubagentPolicy(
+          declaration,
+          budgetScope === "worker-run"
+            ? (resolvedTarget ?? declaration.target.policy)
+            : caller.policy,
+          undefined,
+          budgetScope === "worker-run" ? "root-attached" : "conserved",
+          resolvedTarget,
+        );
+
+        return {
+          encodedInput,
+          policy: resolved.childPolicy,
+          budget: SubagentBudgetReservation.make({
+            caps: resolved.caps,
+            allocation: resolved.allocation,
+            ...(resolved.policy.descendantInvocations === undefined
               ? {}
-              : { continuationOf: options.continuationOf }),
-          });
-
-          const resolvedTarget = Option.getOrUndefined(effectiveTarget);
-
-          const resolved = resolveSubagentPolicy(
-            declaration,
-            budgetScope === "worker-run"
-              ? (resolvedTarget ?? declaration.target.policy)
-              : caller.policy,
-            undefined,
-            budgetScope === "worker-run" ? "root-attached" : "conserved",
-            resolvedTarget,
-          );
-
-          return {
-            encodedInput,
-            policy: resolved.childPolicy,
-            budget: SubagentBudgetReservation.make({
-              caps: resolved.caps,
-              allocation: resolved.allocation,
-              ...(resolved.policy.descendantInvocations === undefined
-                ? {}
-                : { descendantInvocations: resolved.policy.descendantInvocations }),
-            }),
-            toolCallAllowance: resolveToolCallAllowance(
-              declaration.toolCallAllowance,
-              parameters,
-              resolved.policy,
-              resolved.childPolicy,
-            ),
-          };
-        }),
+              : { descendantInvocations: resolved.policy.descendantInvocations }),
+          }),
+          toolCallAllowance: resolveToolCallAllowance(
+            declaration.toolCallAllowance,
+            parameters,
+            resolved.policy,
+            resolved.childPolicy,
+          ),
+        };
+      }),
     });
 
     const validated = yield* Schema.decodeEffect(WorkerStarted)(started).pipe(
@@ -632,33 +631,32 @@ export const followUp = <
 ) => operations(declaration).followUp(worker, parameters, options);
 
 /** Inspect a continuing worker with the same summary contract returned by list. */
-export const summary = <const Name extends string>(
+export const summary = Effect.fnUntraced(function* <const Name extends string>(
   declaration: WorkerDeclaration<Name> & { readonly target: AnyDefinition },
   worker: Worker<Name>,
-) =>
-  Effect.gen(function* () {
-    const service = yield* host;
+) {
+  const service = yield* host;
 
-    const validated = yield* Schema.decodeEffect(Worker(declaration))(worker).pipe(
-      Effect.mapError(() => WorkerError.make({ operation: "inspect", reason: "worker-mismatch" })),
-    );
+  const validated = yield* Schema.decodeEffect(Worker(declaration))(worker).pipe(
+    Effect.mapError(() => WorkerError.make({ operation: "inspect", reason: "worker-mismatch" })),
+  );
 
-    const result = yield* service.summary({ worker: validated, target: declaration.target });
+  const result = yield* service.summary({ worker: validated, target: declaration.target });
 
-    const value = yield* Schema.decodeEffect(WorkerSummary)(result).pipe(
-      Effect.mapError(() => WorkerError.make({ operation: "inspect", reason: "corrupt" })),
-    );
+  const value = yield* Schema.decodeEffect(WorkerSummary)(result).pipe(
+    Effect.mapError(() => WorkerError.make({ operation: "inspect", reason: "corrupt" })),
+  );
 
-    if (
-      value.worker.threadId !== validated.threadId ||
-      value.worker.delegationId !== validated.delegationId ||
-      value.worker.targetAgentId !== validated.targetAgentId ||
-      (value.latestReceipt !== null && value.latestReceipt.threadId !== validated.threadId)
-    )
-      return yield* WorkerError.make({ operation: "inspect", reason: "worker-mismatch" });
-
-    return { ...value, worker: validated };
-  });
+  if (
+    value.worker.threadId !== validated.threadId ||
+    value.worker.delegationId !== validated.delegationId ||
+    value.worker.targetAgentId !== validated.targetAgentId ||
+    (value.latestReceipt !== null && value.latestReceipt.threadId !== validated.threadId)
+  )
+    return yield* WorkerError.make({ operation: "inspect", reason: "worker-mismatch" });
+
+  return { ...value, worker: validated };
+});
 
 /** Inspect a worker summary, retained MessageRef, or the result of one exact accepted Receipt. */
 export function inspect<
@@ -762,33 +760,32 @@ export const observe = <const Name extends string>(
   );
 
 /** Seal a continuing worker, retaining a stable command identity across retries and Runs. */
-export const stop = <const Name extends string>(
+export const stop = Effect.fnUntraced(function* <const Name extends string>(
   declaration: WorkerDeclaration<Name> & { readonly target: AnyDefinition },
   worker: Worker<Name>,
   options: { readonly idempotencyKey: IdempotencyKey },
-) =>
-  Effect.gen(function* () {
-    const service = yield* host;
-
-    const command = yield* Schema.decodeEffect(WorkerStop)({ worker, ...options }).pipe(
-      Effect.mapError((cause) => WorkerError.make({ operation: "stop", reason: "corrupt", cause })),
-    );
+) {
+  const service = yield* host;
 
-    if (
-      worker.delegationId !== declaration.delegationId ||
-      worker.targetAgentId !== declaration.target.id
-    )
-      return yield* WorkerError.make({ operation: "stop", reason: "worker-mismatch" });
+  const command = yield* Schema.decodeEffect(WorkerStop)({ worker, ...options }).pipe(
+    Effect.mapError((cause) => WorkerError.make({ operation: "stop", reason: "corrupt", cause })),
+  );
 
-    return yield* service.stop({ ...command, target: declaration.target }).pipe(
-      Effect.flatMap(Schema.decodeEffect(WorkerStopped)),
-      Effect.mapError((cause) =>
-        Schema.is(WorkerError)(cause)
-          ? cause
-          : WorkerError.make({ operation: "stop", reason: "corrupt", cause }),
-      ),
-    );
-  });
+  if (
+    worker.delegationId !== declaration.delegationId ||
+    worker.targetAgentId !== declaration.target.id
+  )
+    return yield* WorkerError.make({ operation: "stop", reason: "worker-mismatch" });
+
+  return yield* service.stop({ ...command, target: declaration.target }).pipe(
+    Effect.flatMap(Schema.decodeEffect(WorkerStopped)),
+    Effect.mapError((cause) =>
+      Schema.is(WorkerError)(cause)
+        ? cause
+        : WorkerError.make({ operation: "stop", reason: "corrupt", cause }),
+    ),
+  );
+});
 
 /** Wait for the exact Receipt. Interrupting this Effect never cancels accepted work. */
 export const awaitWorker = <
@@ -1066,6 +1063,21 @@ const modelKey = Effect.fnUntraced(function* (operation: "start" | "followUp") {
   );
 });
 
+type SelectionServices<Flag, Requirements> = Flag extends true ? Requirements : never;
+
+// Conditional flags retain services for either possible runtime branch. Disabled operations
+// never run the capture effect and cannot install a handler that consumes those services.
+const captureSelected = <Flag extends true | undefined>(flag: Flag) => {
+  function capture<A, R>(
+    effect: Effect.Effect<A, never, R>,
+  ): Effect.Effect<Option.Option<A>, never, SelectionServices<Flag, R>>;
+  function capture<A, R>(effect: Effect.Effect<A, never, R>) {
+    return flag === true ? Effect.map(effect, Option.some) : Effect.succeedNone;
+  }
+
+  return capture;
+};
+
 // Construction-local service keys distinguish projections for co-registered parent versions.
 // These keys are never persisted; worker/run identity and registration digests remain canonical.
 let reportingServiceId = 0;
@@ -1196,64 +1208,88 @@ export const background = <
     | Parameters["DecodingServices"]
     | Output["DecodingServices"]
     | Success["EncodingServices"];
-  type Services = PrepareServices | ProjectServices;
-  type SelectionServices<Flag, Requirements> = Flag extends true ? Requirements : never;
 
   const build = Effect.gen(function* () {
-    const captured = yield* Effect.context<Services>();
+    const start = yield* captureSelected<Selected["start"]>(selected.start)(
+      Effect.map(
+        Effect.context<PrepareServices>(),
+        (captured) => (parameters: Parameters["Type"]) =>
+          Effect.gen(function* () {
+            const service = yield* host;
+            const idempotencyKey = yield* modelKey("start");
+
+            return yield* ops
+              .start(parameters, {
+                idempotencyKey,
+                ...(selected.budgetScope === undefined
+                  ? {}
+                  : { budgetScope: selected.budgetScope }),
+              })
+              .pipe(Effect.provideService(SubagentHost, service), Effect.provide(captured));
+          }),
+      ),
+    );
 
-    const handlers = {
-      [startTool.name]: (parameters: Parameters["Type"]) =>
-        Effect.gen(function* () {
-          const service = yield* host;
-          const idempotencyKey = yield* modelKey("start");
-
-          return yield* ops
-            .start(parameters, {
-              idempotencyKey,
-              ...(selected.budgetScope === undefined ? {} : { budgetScope: selected.budgetScope }),
-            })
-            .pipe(Effect.provideService(SubagentHost, service), Effect.provide(captured));
-        }),
-      [followUpTool.name]: (parameters: {
-        readonly worker: Worker<Name>;
-        readonly parameters: Parameters["Type"];
-      }) =>
-        Effect.gen(function* () {
-          const service = yield* host;
-          const idempotencyKey = yield* modelKey("followUp");
-
-          return yield* ops
-            .followUp(parameters.worker, parameters.parameters, { idempotencyKey })
-            .pipe(Effect.provideService(SubagentHost, service), Effect.provide(captured));
-        }),
-      [inspectTool.name]: (parameters: {
-        readonly worker: Worker<Name>;
-        readonly message?: MessageRef;
-        readonly receipt?: Receipt;
-      }) =>
-        Effect.gen(function* () {
-          const service = yield* host;
-
-          if (parameters.message !== undefined)
-            return yield* ops.inspectMessage(parameters.worker, parameters.message);
-          if (parameters.receipt === undefined)
-            return yield* WorkerError.make({ operation: "inspect", reason: "message-mismatch" });
-
-          return yield* ops.observe("inspect", parameters.worker, parameters.receipt).pipe(
-            Effect.map((observed) => {
-              if ("diagnostic" in observed) {
-                const { diagnostic: _diagnostic, ...projected } = observed;
-
-                return projected;
-              }
-
-              return observed;
+    const followUp = yield* captureSelected<Selected["followUp"]>(selected.followUp)(
+      Effect.map(
+        Effect.context<PrepareServices>(),
+        (captured) =>
+          (parameters: {
+            readonly worker: Worker<Name>;
+            readonly parameters: Parameters["Type"];
+          }) =>
+            Effect.gen(function* () {
+              const service = yield* host;
+              const idempotencyKey = yield* modelKey("followUp");
+
+              return yield* ops
+                .followUp(parameters.worker, parameters.parameters, { idempotencyKey })
+                .pipe(Effect.provideService(SubagentHost, service), Effect.provide(captured));
             }),
-            Effect.provideService(SubagentHost, service),
-            Effect.provide(captured),
-          );
-        }),
+      ),
+    );
+
+    const inspect = yield* captureSelected<Selected["inspect"]>(selected.inspect)(
+      Effect.map(
+        Effect.context<ProjectServices>(),
+        (captured) =>
+          (parameters: {
+            readonly worker: Worker<Name>;
+            readonly message?: MessageRef;
+            readonly receipt?: Receipt;
+          }) =>
+            Effect.gen(function* () {
+              const service = yield* host;
+
+              if (parameters.message !== undefined)
+                return yield* ops.inspectMessage(parameters.worker, parameters.message);
+              if (parameters.receipt === undefined)
+                return yield* WorkerError.make({
+                  operation: "inspect",
+                  reason: "message-mismatch",
+                });
+
+              return yield* ops.observe("inspect", parameters.worker, parameters.receipt).pipe(
+                Effect.map((observed) => {
+                  if ("diagnostic" in observed) {
+                    const { diagnostic: _diagnostic, ...projected } = observed;
+
+                    return projected;
+                  }
+
+                  return observed;
+                }),
+                Effect.provideService(SubagentHost, service),
+                Effect.provide(captured),
+              );
+            }),
+      ),
+    );
+
+    const handlers = {
+      ...(Option.isSome(start) ? { [startTool.name]: start.value } : {}),
+      ...(Option.isSome(followUp) ? { [followUpTool.name]: followUp.value } : {}),
+      ...(Option.isSome(inspect) ? { [inspectTool.name]: inspect.value } : {}),
       [listTool.name]: (parameters: typeof ListParameters.Type) => ops.list(parameters),
       [summaryTool.name]: (parameters: { readonly worker: Worker<Name> }) =>
         summary(declaration, parameters.worker),
@@ -1263,7 +1299,7 @@ export const background = <
       }) => ops.cancel(parameters.worker, parameters.receipt),
     };
 
-    // Each handler above is paired with its native schema; computed generic names need this bridge.
+    // Each selected handler is paired with its native schema; computed names need this bridge.
     return handlers as unknown as Toolkit.HandlersFrom<Tools>;
   });
 
@@ -1273,18 +1309,20 @@ export const background = <
     | SelectionServices<Selected["inspect"], ProjectServices>
     | SelectionServices<Selected["reportToParent"], Exclude<ProjectServices, Scope.Scope>>;
 
-  // Unselected handlers are never installed. Only selected operations consume projection services.
-  const reportingLayer =
-    report === undefined
-      ? Layer.empty
-      : Layer.effect(
-          reportService,
-          Effect.map(
-            Effect.context<Effect.Services<ReturnType<typeof report.prepare>>>(),
-            (context): WorkerReporting<WorkerReportPreparationFailure> => ({
-              ...report,
+  const reportingLayer = Layer.effectContext(
+    Effect.gen(function* () {
+      const capturedReport = yield* captureSelected<Selected["reportToParent"]>(
+        selected.reportToParent,
+      )(
+        Effect.map(
+          Effect.context<Exclude<ProjectServices, Scope.Scope>>(),
+          (context): WorkerReporting<WorkerReportPreparationFailure> => {
+            const reporting = automaticReporting(declaration);
+
+            return {
+              ...reporting,
               prepare: (value) =>
-                Effect.scoped(Effect.suspend(() => report.prepare(value))).pipe(
+                Effect.scoped(Effect.suspend(() => reporting.prepare(value))).pipe(
                   Effect.provide(context),
                   Effect.mapError((error) =>
                     Schema.is(WorkerReportPreparationFailure)(error)
@@ -1292,15 +1330,21 @@ export const background = <
                       : WorkerReportPreparationFailure.make({ stage: "preparation" }),
                   ),
                 ),
-            }),
-          ),
-        );
+            };
+          },
+        ),
+      );
 
-  const layer = Layer.merge(toolkit.toLayer(build), reportingLayer) as Layer.Layer<
-    Tool.HandlersFor<Tools>,
-    never,
-    SelectedServices
-  >;
+      return Option.isNone(capturedReport)
+        ? Context.empty()
+        : Context.make(reportService, capturedReport.value);
+    }),
+  );
+
+  const layer: Layer.Layer<Tool.HandlersFor<Tools>, never, SelectedServices> = Layer.merge(
+    toolkit.toLayer(build),
+    reportingLayer,
+  );
 
   return Object.freeze({ tools: toolkit.tools, toolkit, layer });
 };