@effect-agent/testing 0.1.0-beta.44 → 0.1.0-beta.46

package/src/{certification.ts → Certification.ts}

@@ -1,55 +1,51 @@
+import * as Subagent from "@effect-agent/capabilities/Subagent";
+import { SubagentPolicy, SubagentRuntime } from "@effect-agent/capabilities/Subagent";
+import { SubagentReservationsMemoryLive } from "@effect-agent/capabilities/SubagentReservations";
+import * as Agent from "@effect-agent/core/Agent";
+import { AgentPolicy } from "@effect-agent/core/AgentPolicy";
 import {
-  Subagent,
-  SubagentPolicy,
-  SubagentReservationsMemoryLive,
-  SubagentRuntime,
-} from "@effect-agent/capabilities";
-import {
-  Agent,
-  AgentPolicy,
   ThreadId,
-  IdGenerator,
   RunId,
   ToolCallId,
   TurnId,
   type AgentId,
   type SubmissionId,
-} from "@effect-agent/core";
-import { DurableStep, DurableStepError } from "@effect-agent/engine";
+} from "@effect-agent/core/Identifiers";
+import { IdGenerator } from "@effect-agent/core/IdGenerator";
+import { DurableStep, DurableStepError } from "@effect-agent/engine/DurableStep";
+import { RunToolAuthorization } from "@effect-agent/engine/RunOptions";
+import { DurableWorkerBinding, type ResolvedBinding } from "@effect-agent/thread/AgentRegistration";
 import {
-  ApprovalDecisionCommand,
-  ThreadExportRequest,
-  ThreadStore,
-  DefinitionDigests,
-  DeploymentId,
-  Digest,
   DurableAgentRuntime,
   DurableRuntimeConfig,
+  type DurableSubmitFailure,
+  type DurableSubmitOptions,
+  type Receipt,
+} from "@effect-agent/thread/DurableAgentRuntime";
+import {
   DurableRuntimeFailpointError,
   DurableRuntimeFailpointLocation,
-  DurableWorkerBinding,
+} from "@effect-agent/thread/DurableFailpoint";
+import {
+  DefinitionDigests,
+  DeploymentId,
+  Digest,
+  ProducerId,
+  type BatchId,
+} from "@effect-agent/thread/Records";
+import { childThreadIdFor } from "@effect-agent/thread/RunJournal";
+import {
+  ApprovalDecisionCommand,
   IdempotencyKey,
-  LoadCheckpointRequest,
   Principal,
-  ProducerId,
   ResolutionSafeToRetry,
   SubmissionLedger,
   SubmissionLookupById,
-  ToolReconciler,
   UnknownResolutionCommand,
-  WakeScheduler,
   DEFAULT_OWNERSHIP_LEASE_DURATION,
-  childThreadIdFor,
-  verifyThreadInvariants,
-  type BatchId,
-  type DurableSubmitFailure,
-  type DurableSubmitOptions,
-  type Receipt,
-  type ResolvedBinding,
   type SubmissionSnapshot,
-} from "@effect-agent/thread";
+} from "@effect-agent/thread/SubmissionLedger";
 import {
-  DurableRuntimeFailpointTestControl,
   type CertificationCaseResult,
   CertificationReport,
   CertificationSweepResult,
@@ -57,7 +53,16 @@ import {
   CertifiedAdapterIdentity,
   certifyPorts,
   type CertificationScenario,
-} from "@effect-agent/thread/testing";
+} from "@effect-agent/thread/testing/Certification";
+import { DurableRuntimeFailpointTestControl } from "@effect-agent/thread/testing/DurableFailpointTestControl";
+import { verifyThreadInvariants } from "@effect-agent/thread/ThreadInvariants";
+import {
+  ThreadExportRequest,
+  ThreadStore,
+  LoadCheckpointRequest,
+} from "@effect-agent/thread/ThreadStore";
+import { ToolReconciler } from "@effect-agent/thread/ToolReconciler";
+import { WakeScheduler } from "@effect-agent/thread/WakeScheduler";
 import type { Crypto } from "effect";
 import {
   Cause,
@@ -575,21 +580,23 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
       const resolved = yield* DurableWorkerBinding.make(binding, DIGESTS);
       const threadId = decodeThreadId(`certify-${slug}`);
 
-      const submitOne = (key: string, question: string) =>
-        Effect.gen(function* () {
-          const runtime = yield* DurableAgentRuntime;
-
-          return yield* runtime.submit(
-            { definition: { id: plainDefinition.id, input: plainDefinition.input } },
-            { question },
-            {
-              threadId,
-              principal: PRINCIPAL,
-              idempotencyKey: decodeIdempotencyKey(key),
-              definitions: DIGESTS,
-            },
-          );
-        });
+      const submitOne = Effect.fn("Certification.submitOne")(function* (
+        key: string,
+        question: string,
+      ) {
+        const runtime = yield* DurableAgentRuntime;
+
+        return yield* runtime.submit(
+          { definition: { id: plainDefinition.id, input: plainDefinition.input } },
+          { question },
+          {
+            threadId,
+            principal: PRINCIPAL,
+            idempotencyKey: decodeIdempotencyKey(key),
+            definitions: DIGESTS,
+          },
+        );
+      });
 
       const cell: CertificationCell = {
         bindings: [resolved],
@@ -747,7 +754,6 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
   batchProducers: ReadonlyMap<BatchId, ProducerId>,
   leaseAdvance: Duration.Duration,
 ) {
-  const runtime = yield* DurableAgentRuntime;
   const ledger = yield* SubmissionLedger;
   const control = yield* DurableRuntimeFailpointTestControl;
   const slug = `${scenario}-${location.replaceAll(":", "-")}`;
@@ -764,6 +770,16 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
 
   const cell = yield* makeCell(scenario, slug);
 
+  const runtime = yield* DurableAgentRuntime.pipe(
+    Effect.provide(
+      DurableAgentRuntime.layerWithBindings(cell.bindings).pipe(
+        Layer.provide(RunToolAuthorization.allowAll),
+      ),
+    ),
+  );
+
+  const submit = cell.submit.pipe(Effect.provideService(DurableAgentRuntime, runtime));
+
   // One-shot arm: the fault fires at most once anywhere in the cell (initial drive OR a
   // re-drive round's public unblocking operation), modelling one crash at this boundary.
   const fired = yield* Ref.make(false);
@@ -782,12 +798,12 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
 
   // Submissions are idempotent (DUR-001): one replay recovers a submit-boundary fault.
   let receipts: ReadonlyArray<Receipt>;
-  const firstSubmit = yield* Effect.exit(cell.submit);
+  const firstSubmit = yield* Effect.exit(submit);
 
   if (Exit.isSuccess(firstSubmit)) {
     receipts = firstSubmit.value;
   } else {
-    const secondSubmit = yield* Effect.exit(cell.submit);
+    const secondSubmit = yield* Effect.exit(submit);
 
     if (Exit.isFailure(secondSubmit)) {
       yield* control.clear;
@@ -801,7 +817,7 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
   }
   const lanes = cell.lanes(receipts);
 
-  const driveLane = (lane: ThreadId) => runtime.processThreadResolved(lane, cell.bindings);
+  const driveLane = (lane: ThreadId) => runtime.processThreadResolved(lane);
 
   const allSettled = Effect.gen(function* () {
     for (const receipt of receipts) {
@@ -1008,7 +1024,9 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
     }),
   ).pipe(Layer.provide(options.threadStore));
 
-  const support = Layer.mergeAll(
+  // RUN-036: certification uses the default-none Tool failure observer. Trusted application
+  // reporting adds no durable transition and is verified separately from adapter certification.
+  const environment = Layer.mergeAll(
     options.submissionLedger,
     capturingStore,
     options.wakeScheduler ?? WakeScheduler.layerNoop,
@@ -1023,10 +1041,6 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
     }),
   );
 
-  // RUN-036: certification uses the default-none Tool failure observer. Trusted application
-  // reporting adds no durable transition and is verified separately from adapter certification.
-  const environment = DurableAgentRuntime.layer.pipe(Layer.provideMerge(support));
-
   const leaseAdvance = Duration.millis(
     Duration.toMillis(options.ownershipLeaseDuration ?? DEFAULT_OWNERSHIP_LEASE_DURATION) + 1_000,
   );

package/src/{chaos.ts → Chaos.ts}

@@ -1,34 +1,51 @@
+import * as Subagent from "@effect-agent/capabilities/Subagent";
+import { SubagentPolicy, SubagentRuntime } from "@effect-agent/capabilities/Subagent";
+import { SubagentReservationsMemoryLive } from "@effect-agent/capabilities/SubagentReservations";
+import * as Agent from "@effect-agent/core/Agent";
+import { AgentPolicy } from "@effect-agent/core/AgentPolicy";
 import {
-  Subagent,
-  SubagentPolicy,
-  SubagentReservationsMemoryLive,
-  SubagentRuntime,
-} from "@effect-agent/capabilities";
-import {
-  Agent,
-  AgentPolicy,
   ThreadId,
-  IdGenerator,
   RunId,
   ToolCallId,
   TurnId,
   type SubmissionId,
-} from "@effect-agent/core";
-import { DurableStep, DurableStepError, ToolExecutionClass } from "@effect-agent/engine";
+} from "@effect-agent/core/Identifiers";
+import { IdGenerator } from "@effect-agent/core/IdGenerator";
+import {
+  DurableStep,
+  DurableStepError,
+  ToolExecutionClass,
+} from "@effect-agent/engine/DurableStep";
+import { RunToolAuthorization } from "@effect-agent/engine/RunOptions";
+import { ObligationThresholds } from "@effect-agent/thread/Admin";
+import {
+  DurableWorkerBinding,
+  type DurableBindingFailure,
+  type ResolvedBinding,
+} from "@effect-agent/thread/AgentRegistration";
 import {
-  AbortCommand,
-  ApprovalDecisionCommand,
-  ThreadExportRequest,
-  ThreadStore,
-  DefinitionDigests,
-  Digest,
   DurableAgentRuntime,
   DurableRuntimeConfig,
+  type DurableSubmitFailure,
+  type DurableWorkerFailure,
+  type Receipt,
+} from "@effect-agent/thread/DurableAgentRuntime";
+import {
   DurableRuntimeFailpointError,
   DurableRuntimeFailpointLocation,
-  DurableWorkerBinding,
+} from "@effect-agent/thread/DurableFailpoint";
+import {
+  DefinitionDigests,
+  Digest,
+  type CanonicalRecordEnvelope,
+  type BatchId,
+  type ProducerId,
+} from "@effect-agent/thread/Records";
+import { childThreadIdFor } from "@effect-agent/thread/RunJournal";
+import {
+  AbortCommand,
+  ApprovalDecisionCommand,
   IdempotencyKey,
-  ObligationThresholds,
   Principal,
   ResolutionAbortSubmission,
   ResolutionCompletedWithResult,
@@ -36,21 +53,13 @@ import {
   SubmissionLedger,
   SubmissionLookupById,
   UnknownResolutionCommand,
-  childThreadIdFor,
-  verifyThreadInvariants,
-  type CanonicalRecordEnvelope,
-  type BatchId,
-  type DurableBindingFailure,
-  type DurableSubmitFailure,
-  type DurableWorkerFailure,
-  type ProducerId,
-  type Receipt,
-  type ResolvedBinding,
   type Settlement,
   type SubmissionSnapshot,
   type UnknownResolution,
-} from "@effect-agent/thread";
-import { DurableRuntimeFailpointTestControl } from "@effect-agent/thread/testing";
+} from "@effect-agent/thread/SubmissionLedger";
+import { DurableRuntimeFailpointTestControl } from "@effect-agent/thread/testing/DurableFailpointTestControl";
+import { verifyThreadInvariants } from "@effect-agent/thread/ThreadInvariants";
+import { ThreadExportRequest, ThreadStore } from "@effect-agent/thread/ThreadStore";
 import { Cause, Effect, Exit, Layer, Option, Ref, Schema, Stream } from "effect";
 import { FastCheck } from "effect/testing";
 import {
@@ -775,8 +784,15 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
         childLaneDigests(laneIndex),
       );
 
-      const bindings = [parentResolved, childResolved];
-      const driveResolved = (thread: ThreadId) => runtime.processThreadResolved(thread, bindings);
+      const registeredRuntime = yield* DurableAgentRuntime.pipe(
+        Effect.provide(
+          DurableAgentRuntime.layerWithBindings([parentResolved, childResolved]).pipe(
+            Layer.provide(RunToolAuthorization.allowAll),
+          ),
+        ),
+      );
+
+      const driveResolved = (thread: ThreadId) => registeredRuntime.processThreadResolved(thread);
 
       const fixture: LaneFixture = {
         index: laneIndex,

package/src/{code-executor-conformance.ts → CodeExecutorConformance.ts}

@@ -6,14 +6,16 @@ import {
   CodeExecutor,
   CodeHostCallFailure,
   CodeHostCallSuccess,
-  NetworkAllowlist,
-  NetworkDisabled,
   type CodeExecutionError,
   type CodeExecutionResult,
   type CodeHostCall,
   type CodeHostCallResult,
+} from "@effect-agent/sandbox/CodeExecutor";
+import {
+  NetworkAllowlist,
+  NetworkDisabled,
   type SandboxImplementation,
-} from "@effect-agent/sandbox";
+} from "@effect-agent/sandbox/Sandbox";
 import { Deferred, Duration, Effect, Fiber, Schema } from "effect";
 
 /**

package/src/{code-executor-substitute.ts → CodeExecutorSubstitute.ts}

@@ -13,11 +13,11 @@ import {
   CodeOutputLimitError,
   CodeProgramFailedError,
   CodeSourceError,
-  SandboxImplementation,
   type CodeExecutionLimits,
   type CodeExecutionNamespace,
   type CodeExecutionRequest,
-} from "@effect-agent/sandbox";
+} from "@effect-agent/sandbox/CodeExecutor";
+import { SandboxImplementation } from "@effect-agent/sandbox/Sandbox";
 import { Clock, Duration, Effect, Fiber, Layer, Option, Queue, Schema } from "effect";
 
 /**

package/src/{fixtures/docs-researcher/index.ts → DocsResearcher.ts}

@@ -1,6 +1,8 @@
+/** Shared Docs Researcher definitions and MCP delegation fixtures. */
+
 // ---------------------------------------------------------------------------
 // Docs Researcher fixture (P7 internal agent #3): S2 durable delegation on DN
-// with MCP-discovered content tools. See definition.ts / mcp.ts / harness.ts.
+// with MCP-discovered content tools. See fixtures/docs-researcher/{definition,mcp,harness}.ts.
 //
 // Authoring friction note (WP7 input; real observations from writing this
 // agent):
@@ -29,6 +31,67 @@
 //    exactly where a reviewer looks for them.
 // ---------------------------------------------------------------------------
 
-export * from "./definition.ts";
-export * from "./harness.ts";
-export * from "./mcp.ts";
+export {
+  ResearchDocumentId,
+  BoundedSummary,
+  DocumentQuery,
+  ResearchDocument,
+  DocumentUnavailable,
+  DocumentLibrary,
+  FetchDocument,
+  DocContentToolkit,
+  docContentToolkitLayer,
+  docsDocumentBodySecret,
+  researchCorpusDocumentIds,
+  researchDocumentLookup,
+  researchDocumentFor,
+  documentBodyPhrase,
+  SummaryBrief,
+  DocumentSummary,
+  documentSummaryFor,
+  encodedDocumentSummary,
+  DocSummarizer,
+  SummaryRequest,
+  SummaryFinding,
+  DocumentSummaryFailed,
+  documentSummaryPolicy,
+  delegateDocumentSummary,
+  mapSummaryChildFailure,
+  docsSummarizerDigestStrings,
+  docsSummaryHandlersLayer,
+  ResearchRequest,
+  ResearchDigest,
+  docsCoordinatorConfidentialMarker,
+  docsMissionConfidentialMarker,
+  DocsResearcherToolkit,
+  DocsResearcher,
+  researchMissionRequest,
+  expectedResearchDigest,
+} from "./fixtures/docs-researcher/definition.ts";
+
+export {
+  docsResearcherDeploymentId,
+  docsResearcherProducerId,
+  docsResearcherPrincipal,
+  docsCoordinatorDigests,
+  docsSummarizerDigests,
+  docsResearcherSubmitOptions,
+  docsResearcherSubmitAgent,
+  summarizeCallId,
+  fetchCallId,
+  type DocsResearcherHarnessOptions,
+  type DocsResearcherHarness,
+  makeDocsResearcherHarness,
+  redactedDocumentPreview,
+  type DocsResearcherHarnessRequirements,
+} from "./fixtures/docs-researcher/harness.ts";
+
+export {
+  docsMcpRequest,
+  docsMcpIdentity,
+  docsMcpConnectorLayer,
+  docsMcpOversizedConnectorLayer,
+  docsMcpMismatchedConnectorLayer,
+  assertDiscoveryMatchesAuthoredToolkit,
+  DocsMcpDiscoveryEvidence,
+} from "./fixtures/docs-researcher/mcp.ts";

package/src/TravelPlanner.ts

@@ -0,0 +1,244 @@
+/** Shared Travel Planner definitions, deterministic services, and durability fixtures. */
+export {
+  AirportCode,
+  QuoteId,
+  TripRequest,
+  FlightQuery,
+  LodgingQuery,
+  ActivityQuery,
+  FlightOption,
+  LodgingOption,
+  ActivitySearchResult,
+  Itinerary,
+  TravelPlan,
+  FlightUnavailable,
+  LodgingUnavailable,
+  ActivityUnavailable,
+  GuidanceFailure,
+  FlightCatalog,
+  LodgingCatalog,
+  ActivityCatalog,
+  TravelGuidance,
+  SearchFlights,
+  SearchLodging,
+  SearchActivities,
+  TravelPlannerToolkit,
+  TravelPlannerToolkitLayer,
+  TravelPlanner,
+} from "./fixtures/travel-planner/definition.ts";
+
+export {
+  CatalogLifecycleCounts,
+  CatalogLifecycle,
+  type TravelPlannerCompletionControls,
+  ReverseCompletionToolkitLayer,
+  FlightCatalogLayer,
+  LodgingCatalogLayer,
+  ActivityCatalogLayer,
+  BookingRef,
+  SupplierOperation,
+  SupplierBookingRecord,
+  SupplierUnavailable,
+  type SupplierBookRequest,
+  type SupplierHoldControls,
+  cancelBookingIdempotencyKey,
+  supplierBookingRefFor,
+  SupplierBookingDesk,
+  TravelGuidanceLayer,
+  DeterministicIdGeneratorLayer,
+  TravelPlannerRuntimeLayer,
+} from "./fixtures/travel-planner/deterministic-layers.ts";
+
+export {
+  ItineraryHoldRequest,
+  ItineraryHold,
+  ItineraryHoldUnavailable,
+  ItineraryHoldGateway,
+  HoldItinerary,
+  TravelPlannerPhase2Toolkit,
+  TravelPlannerPhase2ToolkitLayer,
+  TravelPlannerPhase2,
+} from "./fixtures/travel-planner/phase2.ts";
+
+export {
+  TravelPlannerPersistenceProfile,
+  phase3TravelPlannerProfile,
+  phase3TravelPlannerThreadId,
+  phase3TravelPlannerProducerId,
+  phase3TravelPlannerRunId,
+  phase3TravelPlannerDefinitionDigests,
+  phase3TravelPlannerInitialBatch,
+  phase3TravelPlannerCompletionBatch,
+  phase3TravelPlannerBatches,
+  phase3TravelPlannerEncodedFixture,
+  TravelPlannerProjectionError,
+  travelPlanFromProjection,
+  makePhase3TravelPlannerCheckpoint,
+} from "./fixtures/travel-planner/phase3.ts";
+
+export {
+  TravelPlannerDurabilityProfile,
+  phase4TravelPlannerProfile,
+  phase4TravelPlannerDeploymentId,
+  phase4TravelPlannerProducerId,
+  phase4TravelPlannerPrincipal,
+  phase4TravelPlannerDefinitionDigests,
+  phase4TravelPlannerSubmitOptions,
+  DurableSearchFlights,
+  DurableSearchLodging,
+  DurableSearchActivities,
+  TravelPlannerPhase4Toolkit,
+  TravelPlannerPhase4ToolkitLayer,
+  TravelPlannerPhase4,
+  makePhase4TravelPlannerAgent,
+  phase4TravelPlannerWorkerLayer,
+  TravelPlannerDurableEvidenceError,
+  travelPlanFromDurableSettlement,
+  normalizeDurableTravelPlannerEvidence,
+} from "./fixtures/travel-planner/phase4.ts";
+
+export {
+  TravelPlannerBookingProfile,
+  phase5TravelPlannerProfile,
+  phase5TravelPlannerDeploymentId,
+  phase5TravelPlannerProducerId,
+  phase5TravelPlannerPrincipal,
+  phase5TravelPlannerDefinitionDigests,
+  phase5TravelPlannerSubmitOptions,
+  TravelerRef,
+  FlightBookingRequest,
+  SupplierBookingConfirmation,
+  CancelBookingRequest,
+  CancellationConfirmation,
+  ItineraryBookingRequest,
+  ItineraryConfirmation,
+  TravelBookingReport,
+  bookFlightIdempotencyKey,
+  itineraryStepIdempotencyKey,
+  BookFlight,
+  CancelBooking,
+  BookItinerary,
+  TravelPlannerPhase5Toolkit,
+  TravelPlannerPhase5ToolkitLayer,
+  TravelSupplierReconcilerLayer,
+  TravelPlannerPhase5,
+  TravelPlannerBookingEvidenceError,
+  assertSettledBookingsExistAtSupplier,
+  phase5TravelPlannerWorkerLayer,
+} from "./fixtures/travel-planner/phase5.ts";
+
+export {
+  TravelPlannerCloudflareProfile,
+  phase6TravelPlannerProfile,
+  phase6TravelPlannerDeploymentId,
+  phase6TravelPlannerProducerPrefix,
+  phase6TravelPlannerProducerId,
+  phase6GatedPlannerDefinitionDigests,
+  type CrossPlatformEvidenceIdentity,
+  normalizeCrossPlatformTravelPlannerEvidence,
+  phase6FlightCallId,
+  phase6LodgingCallId,
+  phase6ActivityCallId,
+  phase6PlannerModel,
+  releasePhase6PlannerGate,
+  resetPhase6PlannerGate,
+  phase6GatedTrip,
+  phase6GatedPlannerModel,
+  phase6SupplierDesk,
+  phase6SupplierDeskLayer,
+  phase6SupplierReconcilerLayer,
+  phase6BookingToolCallId,
+  phase6BookingRef,
+  phase6BookingTrip,
+  phase6BookingModel,
+  phase6GuideInvocationCount,
+  phase6ResearchMission,
+  phase6ResearchDestination,
+  phase6ChildLookupCallId,
+  phase6CoordinatorModel,
+  releasePhase6ResearcherGate,
+  resetPhase6ResearcherGate,
+  phase6ResearcherModel,
+  makePhase6TravelPlannerBindings,
+  phase6TravelPlannerGoldenEvidence,
+} from "./fixtures/travel-planner/phase6.ts";
+
+export {
+  TravelPlannerPhase7Profile,
+  phase7TravelPlannerProfile,
+  PHASE7_LIVE_GATE_ENV,
+  PHASE7_LIVE_CREDENTIAL_ENV,
+  type Phase7LiveGateEnvironment,
+  phase7LiveProfileEnabled,
+} from "./fixtures/travel-planner/phase7.ts";
+
+export {
+  phase1Trip,
+  expectedTravelPlan,
+  phase1HappyPathTurns,
+} from "./fixtures/travel-planner/scenarios.ts";
+
+export {
+  DestinationQuery,
+  DestinationFacts,
+  DestinationGuideUnavailable,
+  DestinationGuide,
+  LookupDestination,
+  DestinationResearcherToolkit,
+  DestinationResearcherToolkitLayer,
+  DestinationBrief,
+  DestinationReport,
+  DestinationResearcher,
+  destinationLookup,
+  destinationReportFor,
+  encodedDestinationReport,
+  DestinationGuideLayer,
+  DestinationResearchSupportLayer,
+  DestinationResearchRequest,
+  DestinationResearchFindings,
+  DestinationResearchFailed,
+  ResearchDispatchGate,
+  destinationResearchPolicy,
+  destinationResearchDelegation,
+  mapResearchChildFailure,
+  destinationResearchHandlersLayer,
+  ResearchMission,
+  DestinationRecommendation,
+  DestinationShortlist,
+  coordinatorConfidentialMarker,
+  missionConfidentialMarker,
+  TravelCoordinatorToolkit,
+  TravelCoordinator,
+  researchMission,
+  expectedDestinationShortlist,
+  type DestinationResearchCall,
+  coordinatorResearchTurn,
+  coordinatorShortlistTurn,
+  researcherHappyPathTurns,
+  type DestinationResearcherControls,
+  makeDestinationResearcherModel,
+} from "./fixtures/travel-planner/subagents.ts";
+
+export {
+  TravelPlannerSubagentDurabilityProfile,
+  s2TravelPlannerProfile,
+  s2TravelPlannerDeploymentId,
+  s2TravelPlannerProducerId,
+  s2TravelPlannerPrincipal,
+  s2CoordinatorDigests,
+  s2ResearcherDigestStrings,
+  s2ResearcherDigests,
+  s2TravelPlannerSubmitOptions,
+  s2CoordinatorSubmitAgent,
+  durableResearchAllocation,
+  durableResearchCallId,
+  durableChildLookupCallId,
+  durableResearchFinding,
+  durableResearchShortlist,
+  encodedDestinationFacts,
+  makeInvocationCountingModel,
+  durableDestinationResearchHandlersLayer,
+  type DurableResearchHarnessOptions,
+  type DurableResearchHarness,
+  makeDurableResearchHarness,
+} from "./fixtures/travel-planner/subagents-durable.ts";

package/src/fixtures/docs-researcher/definition.ts

@@ -1,6 +1,8 @@
-import { Subagent, SubagentPolicy, SubagentRuntime } from "@effect-agent/capabilities";
-import { Agent, AgentPolicy } from "@effect-agent/core";
-import type { RuntimeBinding } from "@effect-agent/engine";
+import * as Subagent from "@effect-agent/capabilities/Subagent";
+import { SubagentPolicy, SubagentRuntime } from "@effect-agent/capabilities/Subagent";
+import * as Agent from "@effect-agent/core/Agent";
+import { AgentPolicy } from "@effect-agent/core/AgentPolicy";
+import { type RuntimeBinding } from "@effect-agent/engine/AgentRuntime";
 import { Context, Effect, Schema } from "effect";
 import { Tool, Toolkit } from "effect/unstable/ai";