@effect-agent/testing 0.0.1-beta.0

package/src/fixtures/travel-planner/phase7.ts

@@ -0,0 +1,112 @@
+import { Schema } from "effect";
+
+// ---------------------------------------------------------------------------
+// Phase 7 (P7): the Travel Planner as an INTERNAL agent with two explicit
+// profiles (ROADMAP P7 exit gate: "Travel Planner ... retains a deterministic
+// offline conformance profile alongside its live integration profiles").
+//
+// - The OFFLINE profile is the cumulative P1–P6/S1/S2 suite set that already
+//   exists: scripted `LanguageModel`, deterministic supplier Layers,
+//   controllable time and IDs, no network, no credentials. Nothing in P7
+//   weakens it; this module only pins the claim as a Schema value so evidence
+//   can cite one committed fact instead of prose.
+// - The LIVE profile is opt-in and test-side: a suite gates itself with
+//   `describe.skipIf(...)` on the environment predicate below, so ordinary
+//   `bun run test` never makes a network request and never needs a credential.
+//   Live profiles bind live MODEL Layers only. No real travel supplier exists
+//   to integrate, so the deterministic supplier desk is retained deliberately
+//   and `liveSupplierLayers` is pinned `false` — the roadmap's "selected
+//   supplier Layers" is honestly scoped to live-model-only (P7 plan decision
+//   9), recorded here rather than silently claimed.
+// ---------------------------------------------------------------------------
+
+/**
+ * The P7 dual-profile claim, schema-first so the exact scope of "live
+ * integration profiles" is a committed, decodable value:
+ *
+ * - `offlineConformanceDeterministic` / `offlineRequiresCredentials`: the
+ *   cumulative conformance suites stay deterministic and credential-free.
+ * - `liveProfileOptIn`: live suites are excluded from ordinary gates by the
+ *   environment predicate (`phase7LiveProfileEnabled`), never by test-runner
+ *   configuration that could silently drift.
+ * - `liveModelLayers` / `liveSupplierLayers`: live profiles exercise real
+ *   model Layers over the SAME deterministic supplier desk — no claim of a
+ *   live supplier integration is made anywhere (decision 9).
+ * - `structurallyRedactedTranscripts`: transcript evidence a live profile
+ *   emits passes through the structural `Redactor` first (SEC-008,
+ *   testing.md §12: "live model and supplier profiles are opt-in smoke or
+ *   release tests, rate-limited and structurally redacted").
+ * - `exactlyOnceExternalEffects`: never claimed at any phase (DUR-003).
+ */
+export class TravelPlannerPhase7Profile extends Schema.Class<TravelPlannerPhase7Profile>(
+  "@effect-agent/testing/travel-planner/TravelPlannerPhase7Profile",
+)({
+  phase: Schema.Literal("P7"),
+  offlineConformanceDeterministic: Schema.Literal(true),
+  offlineRequiresCredentials: Schema.Literal(false),
+  liveProfileOptIn: Schema.Literal(true),
+  liveModelLayers: Schema.Literal(true),
+  liveSupplierLayers: Schema.Literal(false),
+  structurallyRedactedTranscripts: Schema.Literal(true),
+  exactlyOnceExternalEffects: Schema.Literal(false),
+}) {}
+
+export const phase7TravelPlannerProfile = TravelPlannerPhase7Profile.make({
+  phase: "P7",
+  offlineConformanceDeterministic: true,
+  offlineRequiresCredentials: false,
+  liveProfileOptIn: true,
+  liveModelLayers: true,
+  liveSupplierLayers: false,
+  structurallyRedactedTranscripts: true,
+  exactlyOnceExternalEffects: false,
+});
+
+/**
+ * The one opt-in switch for EVERY live profile in this repository. `"1"` is
+ * the only enabling value: an unset, empty, or differently-truthy value keeps
+ * the suite skipped, so CI and ordinary developer runs stay offline.
+ */
+export const PHASE7_LIVE_GATE_ENV = "EFFECT_AGENT_LIVE";
+
+/** The credential a Travel Planner live-model profile additionally requires. */
+export const PHASE7_LIVE_CREDENTIAL_ENV = "OPENAI_API_KEY";
+
+/** Structural shape of `process.env` without importing Node types here. */
+export interface Phase7LiveGateEnvironment {
+  readonly [name: string]: string | undefined;
+}
+
+/**
+ * The test-side live gate (P7 plan §6: no test-side live-gating pattern
+ * existed before this — the demo gates at serve time via
+ * `Config.redacted("OPENAI_API_KEY")`). Suites use it as
+ * `describe.skipIf(!phase7LiveProfileEnabled(process.env))`, which keeps the
+ * live block out of ordinary gates while the SAME file's ungated tests keep
+ * pinning the profile schema on every run.
+ */
+export const phase7LiveProfileEnabled = (env: Phase7LiveGateEnvironment): boolean =>
+  env[PHASE7_LIVE_GATE_ENV] === "1" && (env[PHASE7_LIVE_CREDENTIAL_ENV] ?? "") !== "";
+
+// ---------------------------------------------------------------------------
+// Authoring friction note (WP7 input; real observations from wiring the P7
+// live profile onto the existing Travel Planner):
+//
+// 1. There was no framework-owned place to put a test-side live gate: every
+//    earlier profile was either always-deterministic or gated at serve time
+//    inside an application. The predicate had to be invented here as a plain
+//    exported function because `packages/testing/src` must stay
+//    platform-neutral and cannot read `process.env` itself — fine, but the
+//    split (fixture exports the predicate, the example test applies it to
+//    `process.env`) is a convention a future author has to discover by
+//    reading this file rather than a typed seam.
+// 2. Capturing a structurally redacted transcript from a live Run takes
+//    manual assembly: collect `RunEvent`s, `Schema.encode` each one, pass the
+//    encoded value through `Redactor.redact`. Nothing composes those three
+//    steps, and nothing type-level stops a test from logging the RAW event by
+//    accident. A `redactedTranscript(events)` helper in capabilities (or an
+//    engine stream combinator) would make the safe path the short path.
+// 3. Binding a live model to the existing definition was pleasantly trivial
+//    (`Agent.withModel` + the upstream client Layer): no friction to report
+//    on the authoring surface itself for plain ephemeral runs.
+// ---------------------------------------------------------------------------

package/src/fixtures/travel-planner/scenarios.ts

@@ -0,0 +1,85 @@
+import { Schema } from "effect";
+
+import type { ScriptedTurnInput } from "../../scripted-model.ts";
+import { TravelPlan, TripRequest, type TravelPlan as TravelPlanValue } from "./definition.ts";
+
+const usage = { inputTokens: { total: 128 }, outputTokens: { total: 96 } };
+export const phase1Trip = Schema.decodeSync(TripRequest)({
+  request:
+    "Plan a review-only London trip using the deterministic flight, lodging, and activity searches.",
+  origin: "SFO",
+  destination: "LHR",
+  departOn: "2026-09-14",
+  nights: 4,
+  travelers: 2,
+  budgetCents: 350_000,
+  currency: "USD",
+});
+/** Backward-compatible fixture alias while consumers transition to the P1 name. */
+export const phase0Trip = phase1Trip;
+export const expectedTravelPlan: TravelPlanValue = Schema.decodeSync(TravelPlan)({
+  itineraries: [
+    {
+      title: "Westward light, eastbound overnight",
+      route: "San Francisco → London",
+      dates: "14–19 September 2026",
+      flight: "EA 218 · nonstop · SFO 18:40 → LHR 13:05+1",
+      lodging: "Bloomsbury House · refundable studio · 4 nights",
+      activities: ["British Museum timed entry", "Thames evening walk"],
+      estimatedTotalCents: 284_000,
+      currency: "USD",
+      quoteId: "quote-sfo-lhr-001",
+      assumptions: [
+        "Two travelers sharing one studio",
+        "Quote is read-only availability, not a reservation",
+      ],
+      unresolvedConstraints: [
+        "Traveler names and accessibility requests are intentionally omitted",
+      ],
+      nextAction: "review",
+    },
+  ],
+});
+
+export const phase1HappyPathTurns = [
+  {
+    _tag: "Stream",
+    parts: [
+      {
+        type: "tool-call",
+        id: "flight-call-1",
+        name: "search_flights",
+        params: { origin: "SFO", destination: "LHR", departOn: "2026-09-14", travelers: 2 },
+      },
+      {
+        type: "tool-call",
+        id: "lodging-call-1",
+        name: "search_lodging",
+        params: { destination: "LHR", departOn: "2026-09-14", nights: 4, travelers: 2 },
+      },
+      {
+        type: "tool-call",
+        id: "activity-call-1",
+        name: "search_activities",
+        params: { destination: "LHR", departOn: "2026-09-14", nights: 4, travelers: 2 },
+      },
+      { type: "finish", reason: "tool-calls", usage },
+    ],
+    termination: { _tag: "Complete" },
+  },
+  {
+    _tag: "Stream",
+    parts: [
+      { type: "text-start", id: "itinerary-json" },
+      {
+        type: "text-delta",
+        id: "itinerary-json",
+        delta: JSON.stringify(Schema.encodeSync(TravelPlan)(expectedTravelPlan)),
+      },
+      { type: "text-end", id: "itinerary-json" },
+      { type: "finish", reason: "stop", usage },
+    ],
+    termination: { _tag: "Complete" },
+  },
+] satisfies readonly [ScriptedTurnInput, ScriptedTurnInput];
+export const phase0HappyPathTurns = phase1HappyPathTurns;

package/src/fixtures/travel-planner/subagents-durable.ts

@@ -0,0 +1,391 @@
+import {
+  delegationAllocationFromPolicy,
+  SubagentReservationsMemoryLive,
+  SubagentRuntime,
+} from "@effect-agent/capabilities";
+import { Agent, type ConversationId } from "@effect-agent/core";
+import type { RuntimeBinding } from "@effect-agent/engine";
+import {
+  DefinitionDigests,
+  DeploymentId,
+  Digest,
+  DurableWorkerBinding,
+  Principal,
+  ProducerId,
+  type DurableSubmitOptions,
+  type IdempotencyKey,
+  type ResolvedBinding,
+} from "@effect-agent/session";
+import { Effect, Layer, Ref, Schema, Stream } from "effect";
+import { LanguageModel, Model, type Response, type Toolkit } from "effect/unstable/ai";
+
+import { DeterministicIdGeneratorLayer } from "./deterministic-layers.ts";
+import {
+  DestinationBrief,
+  DestinationFacts,
+  DestinationGuide,
+  DestinationRecommendation,
+  DestinationReport,
+  DestinationResearcher,
+  DestinationResearcherToolkit,
+  DestinationResearcherToolkitLayer,
+  destinationLookup,
+  destinationReportFor,
+  destinationResearchDelegation,
+  destinationResearchPolicy,
+  DestinationShortlist,
+  encodedDestinationReport,
+  mapResearchChildFailure,
+  ResearchDispatchGate,
+  TravelCoordinator,
+} from "./subagents.ts";
+
+// ---------------------------------------------------------------------------
+// S2 durability profile (spec/subagents.md §17): the S1 coordinator →
+// destination-researcher delegation re-run as ACCEPTED WORK on the Node/SQLite
+// runtime. The claim is `DN` durable attached Subagents only: establishment
+// and join are replay-safe by construction (SUB-016/SUB-019), a completed
+// child is never re-executed on a lost join acknowledgment, and NO claim of
+// exactly-once child external effects is made (rule 8; an unresolved ordinary
+// child Tool blocks as an Unknown Outcome instead, SUB-021). Cloudflare
+// equivalence is P6 scope and explicitly not claimed here.
+// ---------------------------------------------------------------------------
+
+export class TravelPlannerSubagentDurabilityProfile extends Schema.Class<TravelPlannerSubagentDurabilityProfile>(
+  "@effect-agent/testing/travel-planner/TravelPlannerSubagentDurabilityProfile",
+)({
+  deploymentClass: Schema.Literal("DN"),
+  durableAttachedSubagents: Schema.Literal(true),
+  canonicalSchemaVersion: Schema.Literal(1),
+  /** Establishment/join replay converges on one child Receipt, Conversation, and join batch. */
+  subagentReplaySafe: Schema.Literal(true),
+  /** Never claimed (rule 8): child ordinary Tools stop at Unknown Outcomes, they do not replay. */
+  childExternalEffectsExactlyOnce: Schema.Literal(false),
+  /** The same conformance suite under DO eviction/alarms is P6 scope (spec §17 `DC`). */
+  cloudflareEquivalence: Schema.Literal(false),
+}) {}
+
+export const s2TravelPlannerProfile = TravelPlannerSubagentDurabilityProfile.make({
+  deploymentClass: "DN",
+  durableAttachedSubagents: true,
+  canonicalSchemaVersion: 1,
+  subagentReplaySafe: true,
+  childExternalEffectsExactlyOnce: false,
+  cloudflareEquivalence: false,
+});
+
+export const s2TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)(
+  "travel-planner-s2-deployment",
+);
+export const s2TravelPlannerProducerId = Schema.decodeSync(ProducerId)(
+  "travel-planner-s2-producer",
+);
+export const s2TravelPlannerPrincipal = Schema.decodeSync(Principal)("travel-planner-s2-principal");
+
+const digestOf = (character: string) => Schema.decodeSync(Digest)(character.repeat(64));
+
+/** Redacted, deterministic parent (coordinator) definition digests for this fixture version. */
+export const s2CoordinatorDigests = DefinitionDigests.make({
+  agent: digestOf("a"),
+  model: digestOf("b"),
+  tools: digestOf("c"),
+});
+
+/**
+ * The exact child Binding digest strings the application declares on
+ * `SubagentRuntimeOptions.durable.targetDigests` AND the host registers with
+ * the `AgentBindingResolver` for the researcher Binding. The coordinator
+ * stores and verifies them byte-for-byte (SUB-023); a host registration under
+ * different strings is a `ChildCompatibilityFailure`, never a substitution.
+ */
+export const s2ResearcherDigestStrings = {
+  agent: "d".repeat(64),
+  model: "e".repeat(64),
+  tools: "f".repeat(64),
+} as const;
+
+export const s2ResearcherDigests = DefinitionDigests.make({
+  agent: Schema.decodeSync(Digest)(s2ResearcherDigestStrings.agent),
+  model: Schema.decodeSync(Digest)(s2ResearcherDigestStrings.model),
+  tools: Schema.decodeSync(Digest)(s2ResearcherDigestStrings.tools),
+});
+
+/** Durable admission options for one coordinator Submission on one mission lane. */
+export const s2TravelPlannerSubmitOptions = (
+  conversationId: ConversationId,
+  idempotencyKey: IdempotencyKey,
+): DurableSubmitOptions => ({
+  conversationId,
+  principal: s2TravelPlannerPrincipal,
+  idempotencyKey,
+  definitions: s2CoordinatorDigests,
+});
+
+/** The structural submit slice of the coordinator Binding (`DurableAgentRuntime.submit`). */
+export const s2CoordinatorSubmitAgent = {
+  definition: { id: TravelCoordinator.id, input: TravelCoordinator.input },
+} as const;
+
+/**
+ * The per-invocation reservation the durable handler computes from the S1
+ * delegation policy (`delegationAllocationFromPolicy`): the conservation
+ * evidence in the S2 tests checks the ledger reservation rows and the
+ * canonical `SubagentJoined.finalAccounting` against exactly this value.
+ */
+export const durableResearchAllocation = delegationAllocationFromPolicy(destinationResearchPolicy);
+
+/** The one scripted delegation Tool Call id of the durable coordinator Run. */
+export const durableResearchCallId = "research-lhr-1";
+
+/** The child's own scripted guide-lookup Tool Call id. */
+export const durableChildLookupCallId = (destination: string): string => `lookup-${destination}`;
+
+/** The projected finding the parent joins (only the advisory crosses, SUB-015). */
+export const durableResearchFinding = (destination: string) => ({
+  destination: destinationReportFor(destination).destination,
+  summary: destinationReportFor(destination).advisory,
+});
+
+/** The coordinator's expected final shortlist for one researched destination. */
+export const durableResearchShortlist = (destination: string): DestinationShortlist =>
+  DestinationShortlist.make({
+    recommendations: [
+      DestinationRecommendation.make({
+        destination: destinationReportFor(destination).destination,
+        summary: destinationReportFor(destination).advisory,
+      }),
+    ],
+    nextAction: "review",
+  });
+
+/**
+ * The deterministic guide facts in encoded (wire) form: the "supplier truth"
+ * an authorized operator records through `resolveUnknown` when a child guide
+ * lookup stopped at an Unknown Outcome (DUR-017 — the framework never guesses
+ * or replays it).
+ */
+export const encodedDestinationFacts = (destination: string): unknown => {
+  const report = destinationReportFor(destination);
+  return Schema.encodeSync(DestinationFacts)(
+    DestinationFacts.make({
+      destination: report.destination,
+      highlights: report.highlights,
+      advisory: report.advisory,
+    }),
+  );
+};
+
+// ---------------------------------------------------------------------------
+// Invocation-counting scripted models (the P5 SupplierBookingDesk counter
+// pattern): the call counter and captured prompts live OUTSIDE the Model
+// Layer, so they survive Layer rebuilds across Attempts and across separate
+// runtime handles over the same SQLite file — "the child was never
+// re-executed" is asserted, not assumed.
+// ---------------------------------------------------------------------------
+
+const scriptedUsage = { inputTokens: { total: 96 }, outputTokens: { total: 64 } };
+
+/** One scripted model whose behavior is keyed by the global invocation index. */
+export const makeInvocationCountingModel = (
+  name: string,
+  script: (call: number) => ReadonlyArray<Response.StreamPartEncoded>,
+) =>
+  Effect.gen(function* () {
+    const calls = yield* Ref.make(0);
+    const prompts = yield* Ref.make<ReadonlyArray<string>>([]);
+    const model = Model.make(
+      "scripted",
+      name,
+      Layer.effect(
+        LanguageModel.LanguageModel,
+        LanguageModel.make({
+          generateText: () => Effect.succeed([]),
+          streamText: (request) =>
+            Stream.unwrap(
+              Effect.gen(function* () {
+                const call = yield* Ref.getAndUpdate(calls, (value) => value + 1);
+                yield* Ref.update(prompts, (previous) => [
+                  ...previous,
+                  JSON.stringify(request.prompt.content),
+                ]);
+                return Stream.fromIterable(script(call));
+              }),
+            ),
+        }),
+      ),
+    );
+    return { model, calls: Ref.get(calls), prompts: Ref.get(prompts) };
+  });
+
+const delegationTurnParts = (
+  toolCallId: string,
+  destination: string,
+  focus: string,
+): ReadonlyArray<Response.StreamPartEncoded> => [
+  {
+    type: "tool-call",
+    id: toolCallId,
+    name: "delegate_destination_research",
+    params: { destination, focus },
+    providerExecuted: false,
+  },
+  { type: "finish", reason: "tool-calls", usage: scriptedUsage },
+];
+
+const shortlistParts = (
+  shortlist: DestinationShortlist,
+): ReadonlyArray<Response.StreamPartEncoded> => [
+  { type: "text-start", id: "shortlist" },
+  {
+    type: "text-delta",
+    id: "shortlist",
+    delta: JSON.stringify(Schema.encodeSync(DestinationShortlist)(shortlist)),
+  },
+  { type: "text-end", id: "shortlist" },
+  { type: "finish", reason: "stop", usage: scriptedUsage },
+];
+
+const researcherLookupParts = (destination: string): ReadonlyArray<Response.StreamPartEncoded> => [
+  {
+    type: "tool-call",
+    id: durableChildLookupCallId(destination),
+    name: "lookup_destination",
+    params: { destination },
+    providerExecuted: false,
+  },
+  { type: "finish", reason: "tool-calls", usage: scriptedUsage },
+];
+
+const researcherReportParts = (destination: string): ReadonlyArray<Response.StreamPartEncoded> => [
+  { type: "text-start", id: "destination-report" },
+  { type: "text-delta", id: "destination-report", delta: encodedDestinationReport(destination) },
+  { type: "text-end", id: "destination-report" },
+  { type: "finish", reason: "stop", usage: scriptedUsage },
+];
+
+// ---------------------------------------------------------------------------
+// Durable delegation wiring (S2): the SAME immutable S1 Delegation Definition
+// paired with one explicit child Binding, now carrying the construction-fixed
+// durable declaration. Under a durable coordinator the handler establishes an
+// accepted-work child instead of spawning an in-process fiber; without the
+// declaration a durable-mode invocation fails closed (WP5 contract).
+// ---------------------------------------------------------------------------
+
+/** Runtime wiring for the durable slice: the S1 delegation plus the S2 digest declaration. */
+export const durableDestinationResearchHandlersLayer = <Provider, ModelProvides, ModelRequires>(
+  childBinding: RuntimeBinding<
+    typeof DestinationBrief,
+    typeof DestinationReport,
+    string,
+    Toolkit.Tools<typeof DestinationResearcherToolkit>,
+    Provider,
+    ModelProvides,
+    ModelRequires
+  >,
+) =>
+  SubagentRuntime.layer(destinationResearchDelegation, childBinding, {
+    mapChildFailure: mapResearchChildFailure,
+    durable: { targetDigests: s2ResearcherDigestStrings },
+  });
+
+/** Optional overrides for one durable research harness. */
+export interface DurableResearchHarnessOptions {
+  /** Researched destination; defaults to "LHR". */
+  readonly destination?: string | undefined;
+  /** Delegation focus; defaults to "museums". */
+  readonly focus?: string | undefined;
+  /**
+   * Digests the HOST registers the child Binding under; defaults to the exact
+   * declared `s2ResearcherDigests`. Register different digests to force the
+   * fail-closed `ChildCompatibilityFailure` path (SUB-023/SUB-032).
+   */
+  readonly childRegistrationDigests?: DefinitionDigests | undefined;
+}
+
+/** One durable coordinator/researcher pair with observable invocation counters. */
+export interface DurableResearchHarness {
+  /** Host registrations for `NodeDurableRuntimeOptions.bindings` (parent + child). */
+  readonly bindings: ReadonlyArray<ResolvedBinding>;
+  /** Total coordinator model invocations across every Attempt and runtime handle. */
+  readonly parentModelCalls: Effect.Effect<number>;
+  /** JSON-encoded coordinator prompts in request order. */
+  readonly parentPrompts: Effect.Effect<ReadonlyArray<string>>;
+  /** Total researcher model invocations across every Attempt and runtime handle. */
+  readonly childModelCalls: Effect.Effect<number>;
+  /** JSON-encoded researcher prompts in request order (context-isolation evidence). */
+  readonly childPrompts: Effect.Effect<ReadonlyArray<string>>;
+  /** Deterministic guide-lookup handler executions (ordinary child Tool side effects). */
+  readonly guideInvocations: Effect.Effect<number>;
+}
+
+/**
+ * Build the S2 Travel Planner harness: an invocation-counting scripted
+ * coordinator (Turn 1 declares the one delegation call, Turn 2 writes the
+ * shortlist), an invocation-counting scripted researcher (Turn 1 consults the
+ * guide, Turn 2 writes the report), and both worker Bindings captured with
+ * their requirement Contexts via `DurableWorkerBinding.make` under the exact
+ * fixture digests. The returned `bindings` are plain values: they can be
+ * registered with several `NodeDurableRuntime` stacks over the same SQLite
+ * file while the counters keep counting across all of them.
+ */
+export const makeDurableResearchHarness = (options?: DurableResearchHarnessOptions) =>
+  Effect.gen(function* () {
+    const destination = options?.destination ?? "LHR";
+    const focus = options?.focus ?? "museums";
+
+    const guideInvocations = yield* Ref.make(0);
+    const guideLayer = Layer.succeed(
+      DestinationGuide,
+      DestinationGuide.of({
+        lookup: (query) =>
+          Ref.update(guideInvocations, (count) => count + 1).pipe(
+            Effect.andThen(destinationLookup(query)),
+          ),
+      }),
+    );
+    const childToolkitLayer = DestinationResearcherToolkitLayer.pipe(
+      Layer.provideMerge(guideLayer),
+    );
+
+    const childModel = yield* makeInvocationCountingModel("destination-researcher-s2", (call) =>
+      call === 0 ? researcherLookupParts(destination) : researcherReportParts(destination),
+    );
+    const childBinding = Agent.withModel(DestinationResearcher, childModel.model);
+
+    const parentModel = yield* makeInvocationCountingModel("travel-coordinator-s2", (call) =>
+      call === 0
+        ? delegationTurnParts(durableResearchCallId, destination, focus)
+        : shortlistParts(durableResearchShortlist(destination)),
+    );
+    const parentBinding = Agent.withModel(TravelCoordinator, parentModel.model);
+
+    const delegationLayer = durableDestinationResearchHandlersLayer(childBinding).pipe(
+      Layer.provide(
+        Layer.mergeAll(
+          childToolkitLayer,
+          SubagentReservationsMemoryLive,
+          DeterministicIdGeneratorLayer,
+          ResearchDispatchGate.layerOpen,
+        ),
+      ),
+    );
+
+    const parentResolved: ResolvedBinding = yield* DurableWorkerBinding.make(
+      parentBinding,
+      s2CoordinatorDigests,
+    ).pipe(Effect.provide(delegationLayer));
+    const childResolved: ResolvedBinding = yield* DurableWorkerBinding.make(
+      childBinding,
+      options?.childRegistrationDigests ?? s2ResearcherDigests,
+    ).pipe(Effect.provide(childToolkitLayer));
+
+    const harness: DurableResearchHarness = {
+      bindings: [parentResolved, childResolved],
+      parentModelCalls: parentModel.calls,
+      parentPrompts: parentModel.prompts,
+      childModelCalls: childModel.calls,
+      childPrompts: childModel.prompts,
+      guideInvocations: Ref.get(guideInvocations),
+    };
+    return harness;
+  });