@effect-agent/testing 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/TravelPlanner.d.mts

@@ -0,0 +1,1680 @@
+import { f as ScriptedTurnInput, r as ScriptedModel } from "./ScriptedModel-DAvxIiud.mjs";
+import { Context, Effect, Layer, Option, Schema } from "effect";
+import { LanguageModel, Model, Response, Tool, Toolkit } from "effect/unstable/ai";
+import * as Agent from "effect-agent/agent";
+import { ResolvedBinding } from "effect-agent/agent-registration";
+import { DurableSubmitOptions, Receipt } from "effect-agent/durable-agent-runtime";
+import { DurableStep, DurableStepError } from "effect-agent/durable-step";
+import { ThreadId } from "effect-agent/identifiers";
+import { CanonicalBatch, CanonicalRecordEnvelope, DefinitionDigests, ProducerId } from "effect-agent/records";
+import * as Subagent from "effect-agent/subagent";
+import { SubagentPolicy } from "effect-agent/subagent";
+import { IdempotencyKey } from "effect-agent/submission-ledger";
+import { ThreadCheckpoint } from "effect-agent/thread-store";
+import { ToolReconciler } from "effect-agent/tool-reconciler";
+import { RuntimeBinding } from "effect-agent/agent-runtime";
+import { ThreadHistory } from "effect-agent/thread-history";
+import { ThreadProjection } from "effect-agent/thread-projection";
+//#region src/fixtures/travel-planner/definition.d.ts
+declare const AirportCode: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+type AirportCode = typeof AirportCode.Type;
+declare const QuoteId: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/QuoteId">;
+type QuoteId = typeof QuoteId.Type;
+declare const TripRequest_base: Schema.Class<TripRequest, Schema.Struct<{
+  readonly request: Schema.NonEmptyString;
+  readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly departOn: Schema.String;
+  readonly nights: Schema.Int;
+  readonly travelers: Schema.Int;
+  readonly budgetCents: Schema.Int;
+  readonly currency: Schema.Literal<"USD">;
+}>, {}>;
+declare class TripRequest extends TripRequest_base {}
+declare const FlightQuery_base: Schema.Class<FlightQuery, Schema.Struct<{
+  readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly departOn: Schema.String;
+  readonly travelers: Schema.Int;
+}>, {}>;
+declare class FlightQuery extends FlightQuery_base {}
+declare const LodgingQuery_base: Schema.Class<LodgingQuery, Schema.Struct<{
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly departOn: Schema.String;
+  readonly nights: Schema.Int;
+  readonly travelers: Schema.Int;
+}>, {}>;
+declare class LodgingQuery extends LodgingQuery_base {}
+declare const ActivityQuery_base: Schema.Class<ActivityQuery, Schema.Struct<{
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly departOn: Schema.String;
+  readonly nights: Schema.Int;
+  readonly travelers: Schema.Int;
+}>, {}>;
+declare class ActivityQuery extends ActivityQuery_base {}
+declare const FlightOption_base: Schema.Class<FlightOption, Schema.Struct<{
+  readonly quoteId: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/QuoteId">;
+  readonly flight: Schema.String;
+  readonly estimatedCents: Schema.Int;
+  readonly currency: Schema.Literal<"USD">;
+}>, {}>;
+declare class FlightOption extends FlightOption_base {}
+declare const LodgingOption_base: Schema.Class<LodgingOption, Schema.Struct<{
+  readonly lodging: Schema.String;
+  readonly estimatedCents: Schema.Int;
+  readonly currency: Schema.Literal<"USD">;
+}>, {}>;
+declare class LodgingOption extends LodgingOption_base {}
+declare const ActivitySearchResult_base: Schema.Class<ActivitySearchResult, Schema.Struct<{
+  readonly activities: Schema.$Array<Schema.String>;
+}>, {}>;
+/** A successful empty activity search is distinct from supplier unavailability. */
+declare class ActivitySearchResult extends ActivitySearchResult_base {}
+declare const Itinerary_base: Schema.Class<Itinerary, Schema.Struct<{
+  readonly title: Schema.String;
+  readonly route: Schema.String;
+  readonly dates: Schema.String;
+  readonly flight: Schema.String;
+  readonly lodging: Schema.String;
+  readonly activities: Schema.$Array<Schema.String>;
+  readonly estimatedTotalCents: Schema.Int;
+  readonly currency: Schema.Literal<"USD">;
+  readonly quoteId: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/QuoteId">;
+  readonly assumptions: Schema.$Array<Schema.String>;
+  readonly unresolvedConstraints: Schema.$Array<Schema.String>;
+  readonly nextAction: Schema.Literal<"review">;
+}>, {}>;
+declare class Itinerary extends Itinerary_base {}
+declare const TravelPlan_base: Schema.Class<TravelPlan, Schema.Struct<{
+  readonly itineraries: Schema.$Array<typeof Itinerary>;
+}>, {}>;
+declare class TravelPlan extends TravelPlan_base {}
+declare const FlightUnavailable_base: Schema.Class<FlightUnavailable, Schema.TaggedStruct<"FlightUnavailable", {
+  query: Schema.String;
+  message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class FlightUnavailable extends FlightUnavailable_base {}
+declare const LodgingUnavailable_base: Schema.Class<LodgingUnavailable, Schema.TaggedStruct<"LodgingUnavailable", {
+  query: Schema.String;
+  message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class LodgingUnavailable extends LodgingUnavailable_base {}
+declare const ActivityUnavailable_base: Schema.Class<ActivityUnavailable, Schema.TaggedStruct<"ActivityUnavailable", {
+  query: Schema.String;
+  message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ActivityUnavailable extends ActivityUnavailable_base {}
+declare const GuidanceFailure_base: Schema.Class<GuidanceFailure, Schema.TaggedStruct<"GuidanceFailure", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class GuidanceFailure extends GuidanceFailure_base {}
+declare const FlightCatalog_base: Context.ServiceClass<FlightCatalog, "@effect-agent/testing/travel-planner/FlightCatalog", {
+  readonly search: (query: FlightQuery) => Effect.Effect<FlightOption, FlightUnavailable>;
+}>;
+declare class FlightCatalog extends FlightCatalog_base {}
+declare const LodgingCatalog_base: Context.ServiceClass<LodgingCatalog, "@effect-agent/testing/travel-planner/LodgingCatalog", {
+  readonly search: (query: LodgingQuery) => Effect.Effect<LodgingOption, LodgingUnavailable>;
+}>;
+declare class LodgingCatalog extends LodgingCatalog_base {}
+declare const ActivityCatalog_base: Context.ServiceClass<ActivityCatalog, "@effect-agent/testing/travel-planner/ActivityCatalog", {
+  readonly search: (query: ActivityQuery) => Effect.Effect<ActivitySearchResult, ActivityUnavailable>;
+}>;
+declare class ActivityCatalog extends ActivityCatalog_base {}
+declare const TravelGuidance_base: Context.ServiceClass<TravelGuidance, "@effect-agent/testing/travel-planner/TravelGuidance", {
+  readonly instructions: (input: TripRequest) => Effect.Effect<string, GuidanceFailure>;
+}>;
+declare class TravelGuidance extends TravelGuidance_base {}
+declare const SearchFlights: Tool.Tool<"search_flights", {
+  readonly parameters: typeof FlightQuery;
+  readonly success: typeof FlightOption;
+  readonly failure: typeof FlightUnavailable;
+  readonly failureMode: "error";
+}, FlightCatalog>;
+declare const SearchLodging: Tool.Tool<"search_lodging", {
+  readonly parameters: typeof LodgingQuery;
+  readonly success: typeof LodgingOption;
+  readonly failure: typeof LodgingUnavailable;
+  readonly failureMode: "error";
+}, LodgingCatalog>;
+declare const SearchActivities: Tool.Tool<"search_activities", {
+  readonly parameters: typeof ActivityQuery;
+  readonly success: typeof ActivitySearchResult;
+  readonly failure: typeof ActivityUnavailable;
+  readonly failureMode: "error";
+}, ActivityCatalog>;
+declare const TravelPlannerToolkit: Toolkit.Toolkit<{
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: typeof ActivityQuery;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: typeof FlightQuery;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: typeof LodgingQuery;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>;
+declare const TravelPlannerToolkitLayer: import("effect/Layer").Layer<Tool.HandlersFor<{
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: typeof ActivityQuery;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: typeof FlightQuery;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: typeof LodgingQuery;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, never, never>;
+declare const TravelPlanner: Agent.Definition<typeof TripRequest, typeof TravelPlan, (input: TripRequest) => Effect.Effect<string, GuidanceFailure, TravelGuidance>, Toolkit.Toolkit<{
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: typeof ActivityQuery;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: typeof FlightQuery;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: typeof LodgingQuery;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, undefined, undefined, undefined> & {
+  readonly id: import("effect/Brand").Brand<"@effect-agent/core/AgentId"> & "travel-planner";
+};
+//#endregion
+//#region src/fixtures/travel-planner/deterministic-layers.d.ts
+declare const CatalogLifecycleCounts_base: Schema.Class<CatalogLifecycleCounts, Schema.Struct<{
+  readonly acquired: Schema.Natural;
+  readonly finalized: Schema.Natural;
+}>, {}>;
+declare class CatalogLifecycleCounts extends CatalogLifecycleCounts_base {}
+declare const CatalogLifecycle_base: Context.ServiceClass<CatalogLifecycle, "@effect-agent/testing/travel-planner/CatalogLifecycle", {
+  readonly markAcquired: Effect.Effect<void>;
+  readonly markFinalized: Effect.Effect<void>;
+  readonly counts: Effect.Effect<CatalogLifecycleCounts>;
+}>;
+declare class CatalogLifecycle extends CatalogLifecycle_base {
+  static readonly layerNoDeps: Layer.Layer<CatalogLifecycle, never, never>;
+}
+/**
+ * Deterministic controls for a Tool batch whose completions are released in a
+ * caller-selected order. This is intentionally a test fixture: it uses no
+ * clock or sleep and lets engine scheduler tests prove parallel starts and
+ * declaration-order prompt materialization.
+ */
+interface TravelPlannerCompletionControls {
+  readonly flightStarted: Effect.Effect<void>;
+  readonly lodgingStarted: Effect.Effect<void>;
+  readonly activityStarted: Effect.Effect<void>;
+  readonly releaseFlight: Effect.Effect<void>;
+  readonly releaseLodging: Effect.Effect<void>;
+  readonly releaseActivity: Effect.Effect<void>;
+}
+declare const ReverseCompletionToolkitLayer: Effect.Effect<{
+  controls: {
+    flightStarted: Effect.Effect<void, never, never>;
+    lodgingStarted: Effect.Effect<void, never, never>;
+    activityStarted: Effect.Effect<void, never, never>;
+    releaseFlight: Effect.Effect<void, never, never>;
+    releaseLodging: Effect.Effect<void, never, never>;
+    releaseActivity: Effect.Effect<void, never, never>;
+  };
+  layer: Layer.Layer<import("effect/unstable/ai/Tool").HandlersFor<{
+    readonly search_activities: import("effect/unstable/ai/Tool").Tool<"search_activities", {
+      readonly parameters: typeof ActivityQuery;
+      readonly success: typeof ActivitySearchResult;
+      readonly failure: typeof ActivityUnavailable;
+      readonly failureMode: "error";
+    }, ActivityCatalog>;
+    readonly search_flights: import("effect/unstable/ai/Tool").Tool<"search_flights", {
+      readonly parameters: typeof FlightQuery;
+      readonly success: typeof FlightOption;
+      readonly failure: typeof FlightUnavailable;
+      readonly failureMode: "error";
+    }, FlightCatalog>;
+    readonly search_lodging: import("effect/unstable/ai/Tool").Tool<"search_lodging", {
+      readonly parameters: typeof LodgingQuery;
+      readonly success: typeof LodgingOption;
+      readonly failure: typeof LodgingUnavailable;
+      readonly failureMode: "error";
+    }, LodgingCatalog>;
+  }>, never, never>;
+}, never, never>;
+declare const FlightCatalogLayer: Layer.Layer<FlightCatalog, never, CatalogLifecycle>;
+declare const LodgingCatalogLayer: Layer.Layer<LodgingCatalog, never, CatalogLifecycle>;
+declare const ActivityCatalogLayer: Layer.Layer<ActivityCatalog, never, CatalogLifecycle>;
+/** Stable supplier-side booking identity, minted deterministically from the idempotency key. */
+declare const BookingRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/BookingRef">;
+type BookingRef = typeof BookingRef.Type;
+/** The supplier desk operations the P5 booking Tools and Steps invoke. */
+declare const SupplierOperation: Schema.Literals<readonly ["book-flight", "cancel-booking", "reserve-flight", "reserve-lodging", "issue-confirmation"]>;
+type SupplierOperation = typeof SupplierOperation.Type;
+declare const SupplierBookingRecord_base: Schema.Class<SupplierBookingRecord, Schema.Struct<{
+  readonly bookingRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/BookingRef">;
+  readonly idempotencyKey: Schema.NonEmptyString;
+  readonly operation: Schema.Literals<readonly ["book-flight", "cancel-booking", "reserve-flight", "reserve-lodging", "issue-confirmation"]>;
+  readonly detail: Schema.NonEmptyString;
+  readonly status: Schema.Literals<readonly ["confirmed", "cancelled"]>;
+}>, {}>;
+/**
+ * One row of external supplier truth. The desk deduplicates by `idempotencyKey` — replaying a
+ * call with the same key returns this exact record without creating a second booking — which is
+ * precisely the honesty model of DUR-010: the framework never makes an external call
+ * exactly-once; the supplier's idempotency key does.
+ */
+declare class SupplierBookingRecord extends SupplierBookingRecord_base {}
+declare const SupplierUnavailable_base: Schema.Class<SupplierUnavailable, Schema.TaggedStruct<"SupplierUnavailable", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class SupplierUnavailable extends SupplierUnavailable_base {}
+interface SupplierBookRequest {
+  readonly operation: SupplierOperation;
+  readonly idempotencyKey: string;
+  readonly detail: string;
+}
+/** Controls returned by an armed crash window (`holdAfterWrite`). */
+interface SupplierHoldControls {
+  /** Resolves once the armed call has performed its supplier write and is blocked. */
+  readonly held: Effect.Effect<void>;
+  /** Releases the blocked call (tests that interrupt the Attempt never call this). */
+  readonly release: Effect.Effect<void>;
+}
+/** The desk-internal idempotency key of one cancellation: cancel is idempotent by bookingRef. */
+declare const cancelBookingIdempotencyKey: (bookingRef: string) => string;
+/** The deterministic bookingRef the desk mints for one idempotency key. */
+declare const supplierBookingRefFor: (idempotencyKey: string) => BookingRef;
+declare const SupplierBookingDesk_base: Context.ServiceClass<SupplierBookingDesk, "@effect-agent/testing/travel-planner/SupplierBookingDesk", {
+  readonly book: (request: SupplierBookRequest) => Effect.Effect<SupplierBookingRecord, SupplierUnavailable>;
+  readonly cancel: (bookingRef: BookingRef) => Effect.Effect<SupplierBookingRecord, SupplierUnavailable>;
+  readonly lookup: (idempotencyKey: string) => Effect.Effect<Option.Option<SupplierBookingRecord>>;
+  readonly bookings: Effect.Effect<ReadonlyArray<SupplierBookingRecord>>;
+  readonly callCount: (idempotencyKey: string) => Effect.Effect<number>;
+  readonly holdAfterWrite: (idempotencyKey: string) => Effect.Effect<SupplierHoldControls>;
+}>;
+/**
+ * The deterministic in-memory supplier: an idempotency-keyed booking store with per-key call
+ * counters and injectable crash windows.
+ *
+ * - `book`/`cancel` always count the call (at-least-once execution stays observable), then
+ *   dedupe the external effect by idempotency key — the supplier-side contract the P5 Tools and
+ *   Steps rely on.
+ * - `holdAfterWrite` arms a one-shot crash window: the next call with that key performs its
+ *   supplier write, signals `held`, and never returns. Interrupting the Attempt at that point
+ *   models "the external effect happened but no outcome was recorded" without any wall clock.
+ * - `bookings`/`lookup` expose external truth for the reconciler and for never-fabricate
+ *   assertions.
+ */
+declare class SupplierBookingDesk extends SupplierBookingDesk_base {
+  static readonly layer: Layer.Layer<SupplierBookingDesk>;
+}
+declare const TravelGuidanceLayer: Layer.Layer<TravelGuidance, never, never>;
+declare const DeterministicIdGeneratorLayer: Layer.Layer<never, never, never>;
+declare const TravelPlannerRuntimeLayer: Layer.Layer<ActivityCatalog | FlightCatalog | LodgingCatalog | import("effect-agent/run-options").RunContextPreparation | import("effect-agent/thread").Store | ThreadHistory | TravelGuidance | import("effect/unstable/ai/Tool").HandlersFor<{
+  readonly search_activities: import("effect/unstable/ai/Tool").Tool<"search_activities", {
+    readonly parameters: typeof ActivityQuery;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: import("effect/unstable/ai/Tool").Tool<"search_flights", {
+    readonly parameters: typeof FlightQuery;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: import("effect/unstable/ai/Tool").Tool<"search_lodging", {
+    readonly parameters: typeof LodgingQuery;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, never, never>;
+//#endregion
+//#region src/fixtures/travel-planner/phase2.d.ts
+declare const ItineraryHoldRequest_base: Schema.Class<ItineraryHoldRequest, Schema.Struct<{
+  readonly quoteId: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/QuoteId">;
+  readonly expiresInMinutes: Schema.Int;
+}>, {}>;
+declare class ItineraryHoldRequest extends ItineraryHoldRequest_base {}
+declare const ItineraryHold_base: Schema.Class<ItineraryHold, Schema.Struct<{
+  readonly holdId: Schema.NonEmptyString;
+  readonly quoteId: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/QuoteId">;
+  readonly status: Schema.Literal<"held">;
+}>, {}>;
+declare class ItineraryHold extends ItineraryHold_base {}
+declare const ItineraryHoldUnavailable_base: Schema.Class<ItineraryHoldUnavailable, Schema.TaggedStruct<"ItineraryHoldUnavailable", {
+  readonly quoteId: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/QuoteId">;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ItineraryHoldUnavailable extends ItineraryHoldUnavailable_base {}
+declare const ItineraryHoldGateway_base: Context.ServiceClass<ItineraryHoldGateway, "@effect-agent/testing/travel-planner/ItineraryHoldGateway", {
+  readonly hold: (request: ItineraryHoldRequest) => Effect.Effect<ItineraryHold, ItineraryHoldUnavailable>;
+}>;
+declare class ItineraryHoldGateway extends ItineraryHoldGateway_base {}
+/**
+ * The first mutating Travel Planner Tool. Effect AI marks it as approval-gated
+ * so the engine must settle approval before acquiring a handler permit.
+ */
+declare const HoldItinerary: Tool.Tool<"hold_itinerary", {
+  readonly parameters: typeof ItineraryHoldRequest;
+  readonly success: typeof ItineraryHold;
+  readonly failure: typeof ItineraryHoldUnavailable;
+  readonly failureMode: "error";
+}, ItineraryHoldGateway>;
+declare const TravelPlannerPhase2Toolkit: Toolkit.Toolkit<{
+  readonly hold_itinerary: Tool.Tool<"hold_itinerary", {
+    readonly parameters: typeof ItineraryHoldRequest;
+    readonly success: typeof ItineraryHold;
+    readonly failure: typeof ItineraryHoldUnavailable;
+    readonly failureMode: "error";
+  }, ItineraryHoldGateway>;
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: typeof ActivityQuery;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: typeof FlightQuery;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: typeof LodgingQuery;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>;
+declare const TravelPlannerPhase2ToolkitLayer: import("effect/Layer").Layer<Tool.HandlersFor<{
+  readonly hold_itinerary: Tool.Tool<"hold_itinerary", {
+    readonly parameters: typeof ItineraryHoldRequest;
+    readonly success: typeof ItineraryHold;
+    readonly failure: typeof ItineraryHoldUnavailable;
+    readonly failureMode: "error";
+  }, ItineraryHoldGateway>;
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: typeof ActivityQuery;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: typeof FlightQuery;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: typeof LodgingQuery;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, never, never>;
+declare const TravelPlannerPhase2: Agent.Definition<typeof TripRequest, typeof TravelPlan, (input: TripRequest) => Effect.Effect<string, GuidanceFailure, TravelGuidance>, Toolkit.Toolkit<{
+  readonly hold_itinerary: Tool.Tool<"hold_itinerary", {
+    readonly parameters: typeof ItineraryHoldRequest;
+    readonly success: typeof ItineraryHold;
+    readonly failure: typeof ItineraryHoldUnavailable;
+    readonly failureMode: "error";
+  }, ItineraryHoldGateway>;
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: typeof ActivityQuery;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: typeof FlightQuery;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: typeof LodgingQuery;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, undefined, undefined, undefined> & {
+  readonly id: import("effect/Brand").Brand<"@effect-agent/core/AgentId"> & "travel-planner-phase-2";
+};
+//#endregion
+//#region src/fixtures/travel-planner/phase3.d.ts
+declare const phase3TravelPlannerThreadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+declare const phase3TravelPlannerProducerId: string & import("effect/Brand").Brand<"@effect-agent/thread/ProducerId">;
+declare const phase3TravelPlannerRunId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">;
+/** Redacted, deterministic definition identities for the current fixture version. */
+declare const phase3TravelPlannerDefinitionDigests: DefinitionDigests;
+/**
+ * The first atomic append establishes the Thread and records its input.
+ * Its encoded value is the redacted current-version persistence fixture.
+ */
+declare const phase3TravelPlannerInitialBatch: CanonicalBatch;
+/** The second append records the Schema-decoded itinerary and terminal Run result. */
+declare const phase3TravelPlannerCompletionBatch: CanonicalBatch;
+declare const phase3TravelPlannerBatches: readonly [CanonicalBatch, CanonicalBatch];
+/** Portable current-version fixture; it contains no passenger identity or credentials. */
+declare const phase3TravelPlannerEncodedFixture: ReadonlyArray<typeof CanonicalBatch.Encoded>;
+declare const TravelPlannerProjectionError_base: Schema.Class<TravelPlannerProjectionError, Schema.TaggedStruct<"TravelPlannerProjectionError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class TravelPlannerProjectionError extends TravelPlannerProjectionError_base {}
+/** Decode the itinerary projection rebuilt from canonical model-completion records. */
+declare const travelPlanFromProjection: (projection: ThreadProjection) => Effect.Effect<TravelPlan, TravelPlannerProjectionError>;
+/** Build a disposable checkpoint bound to a validated canonical prefix. */
+declare const makePhase3TravelPlannerCheckpoint: (projection: ThreadProjection) => ThreadCheckpoint;
+//#endregion
+//#region src/fixtures/travel-planner/phase4.d.ts
+declare const phase4TravelPlannerDeploymentId: string & import("effect/Brand").Brand<"@effect-agent/thread/DeploymentId">;
+declare const phase4TravelPlannerProducerId: string & import("effect/Brand").Brand<"@effect-agent/thread/ProducerId">;
+declare const phase4TravelPlannerPrincipal: string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">;
+/** Redacted, deterministic definition identities for the current fixture version. */
+declare const phase4TravelPlannerDefinitionDigests: DefinitionDigests;
+/** Durable admission options for one Travel Planner Submission on one trip lane. */
+declare const phase4TravelPlannerSubmitOptions: (threadId: ThreadId, idempotencyKey: IdempotencyKey) => DurableSubmitOptions;
+/**
+ * The P4 read-only search Tools, calling the same deterministic catalogs as the P1 toolkit.
+ *
+ * The plain-Struct parameter shape is a historical remnant of the P4 carry-in workaround: since
+ * the P5 engine fix, official history carries Schema-ENCODED Tool-call parameters, so class-typed
+ * parameter codecs persist canonically too — the Structs simply need no change here. The
+ * `ToolExecutionClass` `readonly` annotation is the deliberate P5 migration (plan §4.3): these
+ * Tools perform no external mutation, so a crash between start and settlement is a free re-run
+ * and they never enter the prepared/settled uncertainty protocol — keeping the P4 canonical
+ * history byte-stable (an unannotated Tool fails closed to `uncertain`).
+ */
+declare const DurableSearchFlights: Tool.Tool<"search_flights", {
+  readonly parameters: Schema.Struct<{
+    readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+    readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+    readonly departOn: Schema.String;
+    readonly travelers: Schema.Int;
+  }>;
+  readonly success: typeof FlightOption;
+  readonly failure: typeof FlightUnavailable;
+  readonly failureMode: "error";
+}, FlightCatalog>;
+declare const DurableSearchLodging: Tool.Tool<"search_lodging", {
+  readonly parameters: Schema.Struct<{
+    readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+    readonly departOn: Schema.String;
+    readonly nights: Schema.Int;
+    readonly travelers: Schema.Int;
+  }>;
+  readonly success: typeof LodgingOption;
+  readonly failure: typeof LodgingUnavailable;
+  readonly failureMode: "error";
+}, LodgingCatalog>;
+declare const DurableSearchActivities: Tool.Tool<"search_activities", {
+  readonly parameters: Schema.Struct<{
+    readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+    readonly departOn: Schema.String;
+    readonly nights: Schema.Int;
+    readonly travelers: Schema.Int;
+  }>;
+  readonly success: typeof ActivitySearchResult;
+  readonly failure: typeof ActivityUnavailable;
+  readonly failureMode: "error";
+}, ActivityCatalog>;
+declare const TravelPlannerPhase4Toolkit: Toolkit.Toolkit<{
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: Schema.Struct<{
+      readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>;
+declare const TravelPlannerPhase4ToolkitLayer: Layer.Layer<Tool.HandlersFor<{
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: Schema.Struct<{
+      readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, never, never>;
+/**
+ * The cumulative Travel Planner, Phase 4: the P1 planning behavior on the durable Node/SQLite
+ * runtime. The searches are read-only and safe to repeat across Attempts (D6); supplier booking
+ * is deliberately absent because DN does NOT claim replay-safe external mutation (P5 scope).
+ */
+declare const TravelPlannerPhase4: Agent.Definition<typeof TripRequest, typeof TravelPlan, (input: TripRequest) => Effect.Effect<string, GuidanceFailure, TravelGuidance>, Toolkit.Toolkit<{
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: Schema.Struct<{
+      readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, undefined, undefined, undefined> & {
+  readonly id: import("effect/Brand").Brand<"@effect-agent/core/AgentId"> & "travel-planner-phase-4";
+};
+/**
+ * The P4 Agent Binding: the durable Travel Planner definition bound to a finite scripted model.
+ * The scripted Layer is rebuilt per Run, so every Run of one Binding replays the same
+ * deterministic script.
+ */
+declare const makePhase4TravelPlannerAgent: (turns?: ReadonlyArray<ScriptedTurnInput>) => Agent.Binding<Agent.Definition<typeof TripRequest, typeof TravelPlan, (input: TripRequest) => Effect.Effect<string, GuidanceFailure, TravelGuidance>, Toolkit.Toolkit<{
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: Schema.Struct<{
+      readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, undefined, undefined, undefined> & {
+  readonly id: import("effect/Brand").Brand<"@effect-agent/core/AgentId"> & "travel-planner-phase-4";
+}, Model.Model<"scripted", import("effect/unstable/ai/LanguageModel").LanguageModel | ScriptedModel, never>>;
+/**
+ * Everything a durable worker needs beyond the runtime stack, reusing the deterministic P1
+ * travel-service Layers. The durable coordinator supplies its own deterministic `IdGenerator`,
+ * so this Layer deliberately provides none.
+ */
+declare const phase4TravelPlannerWorkerLayer: Layer.Layer<ActivityCatalog | FlightCatalog | LodgingCatalog | TravelGuidance | Tool.HandlersFor<{
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: Schema.Struct<{
+      readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, never, never>;
+declare const TravelPlannerDurableEvidenceError_base: Schema.Class<TravelPlannerDurableEvidenceError, Schema.TaggedStruct<"TravelPlannerDurableEvidenceError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class TravelPlannerDurableEvidenceError extends TravelPlannerDurableEvidenceError_base {}
+/**
+ * Decode the completed itinerary from the canonical `SubmissionSettled` record. Canonical history
+ * is the outcome authority (DUR-015): the settled result — not any ledger cache — must decode
+ * through the trip output schema.
+ */
+declare const travelPlanFromDurableSettlement: (records: readonly CanonicalRecordEnvelope[]) => Effect.Effect<TravelPlan, TravelPlannerDurableEvidenceError, never>;
+/**
+ * Project canonical evidence into a Submission-identity-independent comparable form: batch
+ * identity, canonical sequence, and the full encoded record, with the ledger-minted
+ * `submissionId`/`receiptId` (and every identity derived from them: run, turn, batch, record,
+ * and settlement ids) replaced by stable placeholders. Two Threads whose normalized
+ * evidence is equal took byte-equivalent canonical histories, so restart-equivalence can compare
+ * a recovered run against an uninterrupted control run on a separate database.
+ */
+declare const normalizeDurableTravelPlannerEvidence: (records: readonly CanonicalRecordEnvelope[], receipt: Receipt) => Effect.Effect<Schema.Json, TravelPlannerDurableEvidenceError, never>;
+//#endregion
+//#region src/fixtures/travel-planner/phase5.d.ts
+declare const phase5TravelPlannerDeploymentId: string & import("effect/Brand").Brand<"@effect-agent/thread/DeploymentId">;
+declare const phase5TravelPlannerProducerId: string & import("effect/Brand").Brand<"@effect-agent/thread/ProducerId">;
+declare const phase5TravelPlannerPrincipal: string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">;
+/** Redacted, deterministic definition identities for the current fixture version. */
+declare const phase5TravelPlannerDefinitionDigests: DefinitionDigests;
+/** Durable admission options for one Travel Planner Submission on one trip lane. */
+declare const phase5TravelPlannerSubmitOptions: (threadId: ThreadId, idempotencyKey: IdempotencyKey) => DurableSubmitOptions;
+declare const TravelerRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/TravelerRef">;
+type TravelerRef = typeof TravelerRef.Type;
+declare const FlightBookingRequest_base: Schema.Class<FlightBookingRequest, Schema.Struct<{
+  readonly quoteId: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/QuoteId">;
+  readonly travelerRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/TravelerRef">;
+  readonly departOn: Schema.String;
+}>, {}>;
+/**
+ * Class-shaped booking parameters with branded fields: since the P5 engine fix, official history
+ * carries Schema-ENCODED Tool-call parameters, so class-typed parameter codecs persist
+ * canonically end-to-end (the P4 Struct workaround is gone for new Tools).
+ */
+declare class FlightBookingRequest extends FlightBookingRequest_base {}
+declare const SupplierBookingConfirmation_base: Schema.Class<SupplierBookingConfirmation, Schema.Struct<{
+  readonly bookingRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/BookingRef">;
+  readonly status: Schema.Literal<"confirmed">;
+  readonly detail: Schema.String;
+}>, {}>;
+declare class SupplierBookingConfirmation extends SupplierBookingConfirmation_base {}
+declare const CancelBookingRequest_base: Schema.Class<CancelBookingRequest, Schema.Struct<{
+  readonly bookingRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/BookingRef">;
+  readonly travelerRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/TravelerRef">;
+}>, {}>;
+declare class CancelBookingRequest extends CancelBookingRequest_base {}
+declare const CancellationConfirmation_base: Schema.Class<CancellationConfirmation, Schema.Struct<{
+  readonly bookingRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/BookingRef">;
+  readonly status: Schema.Literal<"cancelled">;
+}>, {}>;
+declare class CancellationConfirmation extends CancellationConfirmation_base {}
+declare const ItineraryBookingRequest_base: Schema.Class<ItineraryBookingRequest, Schema.Struct<{
+  readonly quoteId: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/QuoteId">;
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly nights: Schema.Int;
+  readonly travelerRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/TravelerRef">;
+}>, {}>;
+declare class ItineraryBookingRequest extends ItineraryBookingRequest_base {}
+declare const ItineraryConfirmation_base: Schema.Class<ItineraryConfirmation, Schema.Struct<{
+  readonly flightBookingRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/BookingRef">;
+  readonly lodgingBookingRef: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/BookingRef">;
+  readonly confirmationCode: Schema.String;
+}>, {}>;
+declare class ItineraryConfirmation extends ItineraryConfirmation_base {}
+declare const TravelBookingReport_base: Schema.Class<TravelBookingReport, Schema.Struct<{
+  readonly summary: Schema.String;
+  readonly bookingRefs: Schema.$Array<Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/BookingRef">>;
+}>, {}>;
+/** The P5 Run output: a booked (or explicitly not-booked) trip report. */
+declare class TravelBookingReport extends TravelBookingReport_base {}
+/**
+ * Supplier idempotency-key derivations. The handler owns key derivation (the `idempotent` and
+ * `uncertain` execution classes carry no key), and the reconciler MUST use the same derivations
+ * to query external truth — both sides are exported so they cannot drift.
+ */
+declare const bookFlightIdempotencyKey: (toolCallId: string) => string;
+declare const itineraryStepIdempotencyKey: (toolCallId: string, stepName: string) => string;
+/**
+ * Approval-gated supplier booking, explicitly `uncertain`: a crash after the call may have
+ * mutated supplier state without a recorded outcome, so recovery must reconcile or stop at an
+ * Unknown Outcome — never replay automatically (DUR-009, ADR-0004).
+ */
+declare const BookFlight: Tool.Tool<"book_flight", {
+  readonly parameters: typeof FlightBookingRequest;
+  readonly success: typeof SupplierBookingConfirmation;
+  readonly failure: typeof SupplierUnavailable;
+  readonly failureMode: "error";
+}, SupplierBookingDesk>;
+/**
+ * Approval-gated cancellation, annotated `idempotent`: the DECLARED external contract is that
+ * cancellation is idempotent by `bookingRef` (the supplier desk enforces it), so recovery may
+ * re-execute a prepared-but-unsettled cancel without reconciliation proof. Repeats stay
+ * observable in the supplier call counters — the annotation never claims exactly-once execution.
+ */
+declare const CancelBooking: Tool.Tool<"cancel_booking", {
+  readonly parameters: typeof CancelBookingRequest;
+  readonly success: typeof CancellationConfirmation;
+  readonly failure: typeof SupplierUnavailable;
+  readonly failureMode: "error";
+}, SupplierBookingDesk>;
+/**
+ * The Durable Tool: declaring `DurableStep` in `dependencies` is what makes it durable
+ * (GLOSSARY.md). Its handler divides supplier mutation into three named Steps — `reserve-flight`,
+ * `reserve-lodging`, `issue-confirmation` — each deriving its supplier idempotency key from
+ * `(toolCallId, stepName)`, so re-entry after interruption replays recorded Step results and the
+ * supplier dedupes any honestly-repeated call. The Tool itself carries no execution-class
+ * annotation: it stays fail-closed `uncertain`, and `TravelSupplierReconcilerLayer` proves
+ * re-entry safe from the keyed-Step construction instead.
+ */
+declare const BookItinerary: Tool.Tool<"book_itinerary", {
+  readonly parameters: typeof ItineraryBookingRequest;
+  readonly success: typeof ItineraryConfirmation;
+  readonly failure: Schema.Union<readonly [typeof SupplierUnavailable, typeof DurableStepError]>;
+  readonly failureMode: "error";
+}, DurableStep | SupplierBookingDesk>;
+declare const TravelPlannerPhase5Toolkit: Toolkit.Toolkit<{
+  readonly book_flight: Tool.Tool<"book_flight", {
+    readonly parameters: typeof FlightBookingRequest;
+    readonly success: typeof SupplierBookingConfirmation;
+    readonly failure: typeof SupplierUnavailable;
+    readonly failureMode: "error";
+  }, SupplierBookingDesk>;
+  readonly book_itinerary: Tool.Tool<"book_itinerary", {
+    readonly parameters: typeof ItineraryBookingRequest;
+    readonly success: typeof ItineraryConfirmation;
+    readonly failure: Schema.Union<readonly [typeof SupplierUnavailable, typeof DurableStepError]>;
+    readonly failureMode: "error";
+  }, DurableStep | SupplierBookingDesk>;
+  readonly cancel_booking: Tool.Tool<"cancel_booking", {
+    readonly parameters: typeof CancelBookingRequest;
+    readonly success: typeof CancellationConfirmation;
+    readonly failure: typeof SupplierUnavailable;
+    readonly failureMode: "error";
+  }, SupplierBookingDesk>;
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: Schema.Struct<{
+      readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>;
+declare const TravelPlannerPhase5ToolkitLayer: Layer.Layer<Tool.HandlersFor<{
+  readonly book_flight: Tool.Tool<"book_flight", {
+    readonly parameters: typeof FlightBookingRequest;
+    readonly success: typeof SupplierBookingConfirmation;
+    readonly failure: typeof SupplierUnavailable;
+    readonly failureMode: "error";
+  }, SupplierBookingDesk>;
+  readonly book_itinerary: Tool.Tool<"book_itinerary", {
+    readonly parameters: typeof ItineraryBookingRequest;
+    readonly success: typeof ItineraryConfirmation;
+    readonly failure: Schema.Union<readonly [typeof SupplierUnavailable, typeof DurableStepError]>;
+    readonly failureMode: "error";
+  }, DurableStep | SupplierBookingDesk>;
+  readonly cancel_booking: Tool.Tool<"cancel_booking", {
+    readonly parameters: typeof CancelBookingRequest;
+    readonly success: typeof CancellationConfirmation;
+    readonly failure: typeof SupplierUnavailable;
+    readonly failureMode: "error";
+  }, SupplierBookingDesk>;
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: Schema.Struct<{
+      readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, never, never>;
+/**
+ * The application reconciliation policy (durability §10): a claim about EXTERNAL truth, queried
+ * from the supplier desk by the same idempotency-key derivations the handlers use.
+ *
+ * - `book_flight`: a confirmed booking under `book-flight:{toolCallId}` is recovered supplier
+ *   truth — `CompletedWithResult` settles it canonically without executing anything. Absence is
+ *   NOT proof the call never started (a real supplier write could be in flight), so the desk
+ *   answer stays fail-closed `Uncertain`.
+ * - `book_itinerary`: every external mutation inside is a named Step whose supplier idempotency
+ *   key derives from `(toolCallId, stepName)`, so re-entry is provably safe by construction —
+ *   `SafeToRetry`. Committed Steps replay from their records; repeated calls dedupe at the desk.
+ * - `cancel_booking`: declared `idempotent`, so the coordinator re-executes without consulting
+ *   this policy; if ever asked, the bookingRef contract makes `SafeToRetry` honest.
+ * - anything else: fail-closed `Uncertain` (AGENTS rule 11).
+ */
+declare const TravelSupplierReconcilerLayer: Layer.Layer<ToolReconciler, never, SupplierBookingDesk>;
+/**
+ * The cumulative Travel Planner, Phase 5: the durable planner now performs consequential
+ * supplier mutation under the full uncertainty protocol — approval-gated uncertain booking,
+ * idempotent-by-contract cancellation, and one Durable Tool whose Steps carry supplier
+ * idempotency keys.
+ */
+declare const TravelPlannerPhase5: Agent.Definition<typeof TripRequest, typeof TravelBookingReport, string, Toolkit.Toolkit<{
+  readonly book_flight: Tool.Tool<"book_flight", {
+    readonly parameters: typeof FlightBookingRequest;
+    readonly success: typeof SupplierBookingConfirmation;
+    readonly failure: typeof SupplierUnavailable;
+    readonly failureMode: "error";
+  }, SupplierBookingDesk>;
+  readonly book_itinerary: Tool.Tool<"book_itinerary", {
+    readonly parameters: typeof ItineraryBookingRequest;
+    readonly success: typeof ItineraryConfirmation;
+    readonly failure: Schema.Union<readonly [typeof SupplierUnavailable, typeof DurableStepError]>;
+    readonly failureMode: "error";
+  }, DurableStep | SupplierBookingDesk>;
+  readonly cancel_booking: Tool.Tool<"cancel_booking", {
+    readonly parameters: typeof CancelBookingRequest;
+    readonly success: typeof CancellationConfirmation;
+    readonly failure: typeof SupplierUnavailable;
+    readonly failureMode: "error";
+  }, SupplierBookingDesk>;
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: Schema.Struct<{
+      readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, undefined, undefined, undefined> & {
+  readonly id: import("effect/Brand").Brand<"@effect-agent/core/AgentId"> & "travel-planner-phase-5";
+};
+declare const TravelPlannerBookingEvidenceError_base: Schema.Class<TravelPlannerBookingEvidenceError, Schema.TaggedStruct<"TravelPlannerBookingEvidenceError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class TravelPlannerBookingEvidenceError extends TravelPlannerBookingEvidenceError_base {}
+/**
+ * Never-fabricate assertion (ROADMAP P5 exit gate): every successfully settled booking result in
+ * canonical history must reference a booking that actually exists in the supplier store. A
+ * `ToolCallSettled` whose bookingRef the supplier cannot produce would be a fabricated result —
+ * the exact lie the uncertainty protocol exists to prevent.
+ */
+declare const assertSettledBookingsExistAtSupplier: (records: readonly CanonicalRecordEnvelope[]) => Effect.Effect<void, TravelPlannerBookingEvidenceError, SupplierBookingDesk>;
+/**
+ * Everything a durable P5 worker needs beyond the runtime stack and the supplier desk: the
+ * booking toolkit plus the deterministic P1 travel-service Layers. `SupplierBookingDesk` is
+ * deliberately NOT provided here — tests own the desk's lifetime so its counters, bookings, and
+ * crash windows survive Tool-Layer rebuilds across Attempts.
+ */
+declare const phase5TravelPlannerWorkerLayer: Layer.Layer<ActivityCatalog | FlightCatalog | LodgingCatalog | Tool.HandlersFor<{
+  readonly book_flight: Tool.Tool<"book_flight", {
+    readonly parameters: typeof FlightBookingRequest;
+    readonly success: typeof SupplierBookingConfirmation;
+    readonly failure: typeof SupplierUnavailable;
+    readonly failureMode: "error";
+  }, SupplierBookingDesk>;
+  readonly book_itinerary: Tool.Tool<"book_itinerary", {
+    readonly parameters: typeof ItineraryBookingRequest;
+    readonly success: typeof ItineraryConfirmation;
+    readonly failure: Schema.Union<readonly [typeof SupplierUnavailable, typeof DurableStepError]>;
+    readonly failureMode: "error";
+  }, DurableStep | SupplierBookingDesk>;
+  readonly cancel_booking: Tool.Tool<"cancel_booking", {
+    readonly parameters: typeof CancelBookingRequest;
+    readonly success: typeof CancellationConfirmation;
+    readonly failure: typeof SupplierUnavailable;
+    readonly failureMode: "error";
+  }, SupplierBookingDesk>;
+  readonly search_activities: Tool.Tool<"search_activities", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof ActivitySearchResult;
+    readonly failure: typeof ActivityUnavailable;
+    readonly failureMode: "error";
+  }, ActivityCatalog>;
+  readonly search_flights: Tool.Tool<"search_flights", {
+    readonly parameters: Schema.Struct<{
+      readonly origin: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof FlightOption;
+    readonly failure: typeof FlightUnavailable;
+    readonly failureMode: "error";
+  }, FlightCatalog>;
+  readonly search_lodging: Tool.Tool<"search_lodging", {
+    readonly parameters: Schema.Struct<{
+      readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+      readonly departOn: Schema.String;
+      readonly nights: Schema.Int;
+      readonly travelers: Schema.Int;
+    }>;
+    readonly success: typeof LodgingOption;
+    readonly failure: typeof LodgingUnavailable;
+    readonly failureMode: "error";
+  }, LodgingCatalog>;
+}>, never, never>;
+//#endregion
+//#region src/fixtures/travel-planner/subagents.d.ts
+declare const DestinationQuery_base: Schema.Class<DestinationQuery, Schema.Struct<{
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+}>, {}>;
+declare class DestinationQuery extends DestinationQuery_base {}
+declare const DestinationFacts_base: Schema.Class<DestinationFacts, Schema.Struct<{
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly highlights: Schema.$Array<Schema.String>;
+  readonly advisory: Schema.NonEmptyString;
+}>, {}>;
+declare class DestinationFacts extends DestinationFacts_base {}
+declare const DestinationGuideUnavailable_base: Schema.Class<DestinationGuideUnavailable, Schema.TaggedStruct<"DestinationGuideUnavailable", {
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class DestinationGuideUnavailable extends DestinationGuideUnavailable_base {}
+declare const DestinationGuide_base: Context.ServiceClass<DestinationGuide, "@effect-agent/testing/travel-planner/DestinationGuide", {
+  readonly lookup: (query: DestinationQuery) => Effect.Effect<DestinationFacts, DestinationGuideUnavailable>;
+}>;
+declare class DestinationGuide extends DestinationGuide_base {}
+declare const LookupDestination: Tool.Tool<"lookup_destination", {
+  readonly parameters: typeof DestinationQuery;
+  readonly success: typeof DestinationFacts;
+  readonly failure: typeof DestinationGuideUnavailable;
+  readonly failureMode: "error";
+}, DestinationGuide>;
+declare const DestinationResearcherToolkit: Toolkit.Toolkit<{
+  readonly lookup_destination: Tool.Tool<"lookup_destination", {
+    readonly parameters: typeof DestinationQuery;
+    readonly success: typeof DestinationFacts;
+    readonly failure: typeof DestinationGuideUnavailable;
+    readonly failureMode: "error";
+  }, DestinationGuide>;
+}>;
+declare const DestinationResearcherToolkitLayer: Layer.Layer<Tool.Handler<"lookup_destination">, never, never>;
+declare const DestinationBrief_base: Schema.Class<DestinationBrief, Schema.Struct<{
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly focus: Schema.NonEmptyString;
+}>, {}>;
+declare class DestinationBrief extends DestinationBrief_base {}
+declare const DestinationReport_base: Schema.Class<DestinationReport, Schema.Struct<{
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly highlights: Schema.$Array<Schema.String>;
+  readonly advisory: Schema.NonEmptyString;
+}>, {}>;
+declare class DestinationReport extends DestinationReport_base {}
+declare const DestinationResearcher: Agent.Definition<typeof DestinationBrief, typeof DestinationReport, "Consult lookup_destination exactly once for the briefed airport, then return only a JSON destination report.", Toolkit.Toolkit<{
+  readonly lookup_destination: Tool.Tool<"lookup_destination", {
+    readonly parameters: typeof DestinationQuery;
+    readonly success: typeof DestinationFacts;
+    readonly failure: typeof DestinationGuideUnavailable;
+    readonly failureMode: "error";
+  }, DestinationGuide>;
+}>, undefined, undefined, undefined> & {
+  readonly id: import("effect/Brand").Brand<"@effect-agent/core/AgentId"> & "destination-researcher";
+};
+/** Deterministic guide lookup shared by the default and test-local guide Layers. */
+declare const destinationLookup: (query: DestinationQuery) => Effect.Effect<DestinationFacts, DestinationGuideUnavailable>;
+/** The report the scripted researcher writes after consulting the guide. */
+declare const destinationReportFor: (destination: string) => DestinationReport;
+declare const encodedDestinationReport: (destination: string) => string;
+declare const DestinationGuideLayer: Layer.Layer<DestinationGuide, never, CatalogLifecycle>;
+/** Child-side construction requirements of the delegation handler Layer. */
+declare const DestinationResearchSupportLayer: Layer.Layer<DestinationGuide | Tool.Handler<"lookup_destination">, never, CatalogLifecycle>;
+declare const DestinationResearchRequest_base: Schema.Class<DestinationResearchRequest, Schema.Struct<{
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly focus: Schema.NonEmptyString;
+}>, {}>;
+declare class DestinationResearchRequest extends DestinationResearchRequest_base {}
+declare const DestinationResearchFindings_base: Schema.Class<DestinationResearchFindings, Schema.Struct<{
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly summary: Schema.NonEmptyString;
+}>, {}>;
+declare class DestinationResearchFindings extends DestinationResearchFindings_base {}
+declare const DestinationResearchFailed_base: Schema.Class<DestinationResearchFailed, Schema.TaggedStruct<"DestinationResearchFailed", {
+  readonly childErrorTag: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+declare class DestinationResearchFailed extends DestinationResearchFailed_base {}
+declare const ResearchDispatchGate_base: Context.ServiceClass<ResearchDispatchGate, "@effect-agent/testing/travel-planner/ResearchDispatchGate", {
+  readonly awaitDispatch: (destination: string) => Effect.Effect<void>;
+}>;
+/**
+ * Deterministic delegation-admission choreography seam. `prepareInput` awaits
+ * this gate before the handler reserves budget or spawns, so tests can order
+ * concurrent delegation preflights without sleeps. It also keeps the
+ * projection's construction requirements honestly visible in the handler
+ * Layer's `R`. The open Layer never waits.
+ */
+declare class ResearchDispatchGate extends ResearchDispatchGate_base {
+  static readonly layerOpen: Layer.Layer<ResearchDispatchGate, never, never>;
+}
+/**
+ * Finite per-invocation bounds (SUB-009): each child may use two Turns and
+ * one Tool Call; the parent Run may establish at most two children with at
+ * most two running concurrently.
+ */
+declare const destinationResearchPolicy: SubagentPolicy;
+declare const destinationResearchDelegation: Subagent.SubagentDelegation<"delegate_destination_research", typeof DestinationBrief, typeof DestinationReport, "Consult lookup_destination exactly once for the briefed airport, then return only a JSON destination report.", {
+  readonly lookup_destination: Tool.Tool<"lookup_destination", {
+    readonly parameters: typeof DestinationQuery;
+    readonly success: typeof DestinationFacts;
+    readonly failure: typeof DestinationGuideUnavailable;
+    readonly failureMode: "error";
+  }, DestinationGuide>;
+}, typeof DestinationResearchRequest, typeof DestinationResearchFindings, typeof DestinationResearchFailed, ResearchDispatchGate, never, "error"> & {
+  readonly target: Agent.Definition<typeof DestinationBrief, typeof DestinationReport, "Consult lookup_destination exactly once for the briefed airport, then return only a JSON destination report.", Toolkit.Toolkit<{
+    readonly lookup_destination: Tool.Tool<"lookup_destination", {
+      readonly parameters: typeof DestinationQuery;
+      readonly success: typeof DestinationFacts;
+      readonly failure: typeof DestinationGuideUnavailable;
+      readonly failureMode: "error";
+    }, DestinationGuide>;
+  }>, undefined, undefined, undefined> & {
+    readonly id: import("effect/Brand").Brand<"@effect-agent/core/AgentId"> & "destination-researcher";
+  };
+};
+/** Total mapping from every expected child Run failure to the declared Tool failure (SUB-028). */
+declare const mapResearchChildFailure: (failure: {
+  readonly _tag: string;
+}) => DestinationResearchFailed;
+/** Runtime wiring: pair the immutable delegation with one explicit child Binding. */
+declare const destinationResearchHandlersLayer: <Provider, ModelProvides, ModelRequires>(childBinding: RuntimeBinding<typeof DestinationBrief, typeof DestinationReport, string, Toolkit.Tools<typeof DestinationResearcherToolkit>, Provider, ModelProvides, ModelRequires>) => Layer.Layer<Tool.Handler<"delegate_destination_research">, never, Subagent.SubagentLayerRequirements<typeof DestinationBrief, typeof DestinationReport, string, {
+  readonly lookup_destination: Tool.Tool<"lookup_destination", {
+    readonly parameters: typeof DestinationQuery;
+    readonly success: typeof DestinationFacts;
+    readonly failure: typeof DestinationGuideUnavailable;
+    readonly failureMode: "error";
+  }, DestinationGuide>;
+}, Provider, ModelProvides, ModelRequires, ResearchDispatchGate, never, never, {
+  readonly _tag: string;
+}, never, undefined, undefined, undefined>>;
+declare const ResearchMission_base: Schema.Class<ResearchMission, Schema.Struct<{
+  readonly request: Schema.NonEmptyString;
+  readonly candidates: Schema.$Array<Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">>;
+}>, {}>;
+declare class ResearchMission extends ResearchMission_base {}
+declare const DestinationRecommendation_base: Schema.Class<DestinationRecommendation, Schema.Struct<{
+  readonly destination: Schema.brand<Schema.NonEmptyString, "@effect-agent/testing/travel-planner/AirportCode">;
+  readonly summary: Schema.NonEmptyString;
+}>, {}>;
+declare class DestinationRecommendation extends DestinationRecommendation_base {}
+declare const DestinationShortlist_base: Schema.Class<DestinationShortlist, Schema.Struct<{
+  readonly recommendations: Schema.$Array<typeof DestinationRecommendation>;
+  readonly nextAction: Schema.Literal<"review">;
+}>, {}>;
+declare class DestinationShortlist extends DestinationShortlist_base {}
+/** Parent-only transcript markers used to prove child context isolation (SUB-006/015). */
+declare const coordinatorConfidentialMarker = "coordinator-vault-7q42";
+declare const missionConfidentialMarker = "traveler-dossier-19f";
+declare const TravelCoordinatorToolkit: Toolkit.Toolkit<{
+  readonly delegate_destination_research: Tool.Tool<"delegate_destination_research", {
+    readonly parameters: typeof DestinationResearchRequest;
+    readonly success: typeof DestinationResearchFindings;
+    readonly failure: Subagent.SubagentToolFailure<typeof DestinationResearchFailed>;
+    readonly failureMode: "error";
+  }, import("effect-agent/agent-runtime").AgentSpawner | import("effect-agent/run-event-sink").RunEventSink | import("effect-agent/agent-runtime").SubagentDurability>;
+}>;
+declare const TravelCoordinator: Agent.Definition<typeof ResearchMission, typeof DestinationShortlist, string, Toolkit.Toolkit<{
+  readonly delegate_destination_research: Tool.Tool<"delegate_destination_research", {
+    readonly parameters: typeof DestinationResearchRequest;
+    readonly success: typeof DestinationResearchFindings;
+    readonly failure: Subagent.SubagentToolFailure<typeof DestinationResearchFailed>;
+    readonly failureMode: "error";
+  }, import("effect-agent/agent-runtime").AgentSpawner | import("effect-agent/run-event-sink").RunEventSink | import("effect-agent/agent-runtime").SubagentDurability>;
+}>, undefined, undefined, undefined> & {
+  readonly id: import("effect/Brand").Brand<"@effect-agent/core/AgentId"> & "travel-coordinator";
+};
+declare const researchMission: ResearchMission;
+declare const expectedDestinationShortlist: DestinationShortlist;
+interface DestinationResearchCall {
+  readonly id: string;
+  readonly destination: string;
+  readonly focus: string;
+}
+/** One coordinator Turn that declares the given delegation Tool Calls in order. */
+declare const coordinatorResearchTurn: (calls: ReadonlyArray<DestinationResearchCall>) => ScriptedTurnInput;
+/** The coordinator's final structured-output Turn. */
+declare const coordinatorShortlistTurn: (shortlist: DestinationShortlist) => ScriptedTurnInput;
+/** Static researcher script for single-child tests: one guide lookup, then the report. */
+declare const researcherHappyPathTurns: (destination: string) => readonly [ScriptedTurnInput, ScriptedTurnInput];
+/**
+ * Deterministic controls for parallel researcher children whose completions
+ * are released in a caller-selected order (ReverseCompletionToolkitLayer
+ * pattern). This is intentionally a test fixture: it uses no clock or sleep.
+ */
+interface DestinationResearcherControls {
+  /** Await the first model request of the child researching this destination. */
+  readonly awaitStarted: (destination: string) => Effect.Effect<void>;
+  /** Allow the child researching this destination to produce its final report. */
+  readonly release: (destination: string) => Effect.Effect<void>;
+  /** JSON-encoded first-Turn child prompts in arrival order (isolation evidence). */
+  readonly prompts: Effect.Effect<ReadonlyArray<string>>;
+}
+/**
+ * Build a deterministic researcher Model whose per-child behavior is keyed by
+ * the destination named in the child's own prompt: Turn one records the
+ * prompt, signals `started`, and calls the guide Tool; Turn two waits for the
+ * caller's `release` before writing the report. Each child Run builds the
+ * Model Layer inside its own scope, so one `CatalogLifecycle` acquisition and
+ * finalization is observed per child — the same acquire/release counting the
+ * catalog Layers use to prove interruption reaches every finalizer.
+ */
+declare const makeDestinationResearcherModel: (destinations: ReadonlyArray<string>) => Effect.Effect<{
+  controls: DestinationResearcherControls;
+  model: Model.Model<"scripted", LanguageModel.LanguageModel, never>;
+}, never, CatalogLifecycle>;
+//#endregion
+//#region src/fixtures/travel-planner/phase6.d.ts
+/** Platform-neutral bindings and canonical evidence shared by Node and Cloudflare tests. */
+declare const phase6TravelPlannerDeploymentId: string & import("effect/Brand").Brand<"@effect-agent/thread/DeploymentId">;
+/** Producer prefix of the DC host; each Object mints `{prefix}:{threadId}`. */
+declare const phase6TravelPlannerProducerPrefix = "travel-planner-p6-producer";
+/** The full producer identity one DC Thread Object mints for itself. */
+declare const phase6TravelPlannerProducerId: (threadId: string) => ProducerId;
+/**
+ * Registration digests of the GATED planner Binding: the same `TravelPlannerPhase4` definition
+ * bound to a model whose first response waits on a test gate, addressable separately so the
+ * admission-limits rows can hold a lane busy deterministically without touching the ordinary
+ * planner registration.
+ */
+declare const phase6GatedPlannerDefinitionDigests: DefinitionDigests;
+/** The run-specific identities the cross-platform normal form scrubs. */
+interface CrossPlatformEvidenceIdentity {
+  /** The Thread lane the evidence came from. */
+  readonly threadId: string;
+  /** The host's deployment identity (`DeploymentId` on every record envelope). */
+  readonly deploymentId: string;
+  /** The full producer identity of the run (DN: configured; DC: `{prefix}:{threadId}`). */
+  readonly producerId: string;
+}
+/**
+ * The CROSS-PLATFORM extension of `normalizeDurableTravelPlannerEvidence` (D-P6-6): after the
+ * base normalization replaces the two ledger-minted identities (which also normalizes the
+ * DC-format routable `{uuidv7}:{threadId}` Submission identities and everything derived
+ * from them), this form additionally scrubs everything that legitimately differs between a DN
+ * process and a DC Durable Object over the same scenario:
+ *
+ * - `RepairAnnotated` audit records are dropped BEFORE normalization and the canonical
+ *   sequence is renumbered to the surviving order: repairs are DUR-013 evidence of recovery
+ *   itself, legally present in a recovered run and legally absent from an uninterrupted
+ *   control (on DC even a CLEAN run carries one, because every pass reconciles before it
+ *   claims, so the ready lane's input is applied through the recovery path). Canonical ORDER
+ *   is the durability §5 claim; sequence contiguity is a platform artifact of who appended;
+ * - the Thread identity (DC lanes mint unique names per test run);
+ * - the deployment and producer identities (host configuration, not canonical semantics);
+ * - `createdAt` commit timestamps (wall clock);
+ * - 64-hex digests (they hash RAW content that legally embeds run-specific identity, so they
+ *   can never be byte-equal across runs; chain integrity is asserted separately by the
+ *   adapters and the convergence helpers).
+ *
+ * Two runs whose cross-platform normalized evidence is byte-equal took canonically equivalent
+ * histories — the exact sense in which durability §5 permits storage differences while
+ * requiring the same observable ordering. Both the DN and DC suites assert equality against
+ * the one committed `phase6TravelPlannerGoldenEvidence`, so DN ≡ DC transitively.
+ */
+declare const normalizeCrossPlatformTravelPlannerEvidence: (records: readonly CanonicalRecordEnvelope[], receipt: Receipt, identity: CrossPlatformEvidenceIdentity) => Effect.Effect<Schema.Json, TravelPlannerDurableEvidenceError, never>;
+/** The P1/P4 happy-path Tool Call identities (scenarios.ts, byte-stable since P1). */
+declare const phase6FlightCallId = "flight-call-1";
+declare const phase6LodgingCallId = "lodging-call-1";
+declare const phase6ActivityCallId = "activity-call-1";
+/**
+ * The P4 planner script (`phase1HappyPathTurns`) as a prompt-aware model: once the search
+ * batch is committed history, every later request gets the plan — identical parts, so the DC
+ * canonical evidence is byte-equivalent to the DN ScriptedModel run after normalization.
+ */
+declare const phase6PlannerModel: Model.Model<"scripted", LanguageModel.LanguageModel, never>;
+/** Release the gated planner model for one `[gate:...]` marker. */
+declare const releasePhase6PlannerGate: (marker: string) => void;
+/** Re-close one gate marker (fresh suites reuse markers safely). */
+declare const resetPhase6PlannerGate: (marker: string) => void;
+/** A trip whose request text carries the gate marker the gated model waits on. */
+declare const phase6GatedTrip: (marker: string) => TripRequest;
+/**
+ * The SAME planner behavior with a hanging first response: the model waits on the released
+ * gate before answering, keeping its lane durably busy so queue-depth admission limits can be
+ * exercised deterministically.
+ */
+declare const phase6GatedPlannerModel: Model.Model<"scripted", LanguageModel.LanguageModel, never>;
+/** The shared external supplier desk instance (module-level external truth). */
+declare const phase6SupplierDesk: {
+  readonly book: (request: SupplierBookRequest) => Effect.Effect<SupplierBookingRecord, SupplierUnavailable>;
+  readonly cancel: (bookingRef: BookingRef) => Effect.Effect<SupplierBookingRecord, SupplierUnavailable>;
+  readonly lookup: (idempotencyKey: string) => Effect.Effect<import("effect/Option").Option<SupplierBookingRecord>>;
+  readonly bookings: Effect.Effect<ReadonlyArray<SupplierBookingRecord>>;
+  readonly callCount: (idempotencyKey: string) => Effect.Effect<number>;
+  readonly holdAfterWrite: (idempotencyKey: string) => Effect.Effect<SupplierHoldControls>;
+};
+/** Layer handing the shared desk to Bindings, reconcilers, and assertions. */
+declare const phase6SupplierDeskLayer: Layer.Layer<SupplierBookingDesk>;
+/**
+ * The REAL P5 supplier reconciliation policy over the shared desk, closed to no requirements
+ * so a Thread Object can install it directly: `book_flight` recovers only from supplier
+ * truth (absence stays fail-closed `Uncertain` → durable Unknown Outcome), keyed Steps are
+ * provably re-enterable.
+ */
+declare const phase6SupplierReconcilerLayer: Layer.Layer<ToolReconciler>;
+/** The deterministic booking Tool Call identity for one `[case:...]` marker. */
+declare const phase6BookingToolCallId: (marker: string) => string;
+/** The bookingRef the supplier desk mints for one marker's approved booking. */
+declare const phase6BookingRef: (marker: string) => string;
+/** A trip whose request text carries the per-lane booking case marker. */
+declare const phase6BookingTrip: (marker: string) => TripRequest;
+/**
+ * The P5 booking script as a prompt-aware model: request 1 declares the approval-gated
+ * `book_flight` call (identity derived from the lane's `[case:...]` marker so supplier
+ * idempotency keys never collide across lanes); once that call is committed history, the model
+ * writes the booking report.
+ */
+declare const phase6BookingModel: Model.Model<"scripted", LanguageModel.LanguageModel, never>;
+/** Deterministic guide-lookup handler executions across every incarnation. */
+declare const phase6GuideInvocationCount: () => number;
+/** The one-candidate research mission of the DC delegation slice. */
+declare const phase6ResearchMission: ResearchMission;
+declare const phase6ResearchDestination = "LHR";
+/** The child's scripted guide-lookup Tool Call identity. */
+declare const phase6ChildLookupCallId = "lookup-LHR";
+/** Prompt-aware S2 coordinator: delegation call first, shortlist once it is history. */
+declare const phase6CoordinatorModel: Model.Model<"scripted", LanguageModel.LanguageModel, never>;
+/** Allow the researcher's FIRST model response to proceed (sticky across incarnations). */
+declare const releasePhase6ResearcherGate: () => void;
+/** Re-close the researcher gate (each delegation scenario starts gated). */
+declare const resetPhase6ResearcherGate: () => void;
+/**
+ * Prompt-aware S2 researcher: guide lookup first, report once it is history. The FIRST
+ * response waits on the researcher gate — a stand-in for real model latency. The child's own
+ * Object may legally start its Attempt the moment its routed admission commits, while the
+ * parent is still appending the lineage record into the child's log; a child whose first
+ * batch commits during that window races the parent's append on one tail. Real models answer
+ * in seconds, so establishment always wins that race in production; the gate reproduces that
+ * timing deterministically instead of relying on scheduler luck.
+ */
+declare const phase6ResearcherModel: Model.Model<"scripted", LanguageModel.LanguageModel, never>;
+/**
+ * Every phase-6 Travel Planner worker Binding, captured with its requirement Contexts:
+ * the P4 planner and its gated twin, the P5 booking agent over the
+ * shared supplier desk, and the S2 coordinator/researcher pair wired through the durable
+ * delegation Layer. A Thread Object registers these via its `bindings` option; the
+ * capture runs once per incarnation, and everything stateful the assertions rely on (desk,
+ * guide counter, gates) lives at module level so it survives incarnation loss.
+ */
+declare const makePhase6TravelPlannerBindings: Effect.Effect<ReadonlyArray<ResolvedBinding>>;
+/**
+ * The committed cross-platform normalized canonical evidence of ONE uninterrupted Travel
+ * Planner planning Submission (the P1/P4 happy path: canonical input, the search Turn, three
+ * Tool settlements, the plan Turn, one Settlement). `travel-planner-phase6.test.ts` asserts
+ * the DN run equals this value and `travel-planner-dc.test.ts` asserts the DC run equals this
+ * value, so the two platforms' canonical outcomes are byte-equivalent transitively — the P6
+ * exit gate "Travel Planner produces equivalent canonical outcomes under DN and DC".
+ *
+ * Regenerate ONLY when the Travel Planner scenario itself changes, by printing either suite's
+ * normalized value; both suites must then agree on the new golden.
+ */
+declare const phase6TravelPlannerGoldenEvidence: Schema.Json;
+//#endregion
+//#region src/fixtures/travel-planner/phase7.d.ts
+/** Explicit opt-in switch for live integration tests. */
+declare const PHASE7_LIVE_GATE_ENV = "EFFECT_AGENT_LIVE";
+/** The credential required by the Travel Planner live-model tests. */
+declare const PHASE7_LIVE_CREDENTIAL_ENV = "OPENAI_API_KEY";
+/** Structural shape of an environment without importing Node types. */
+interface Phase7LiveGateEnvironment {
+  readonly [name: string]: string | undefined;
+}
+/** Enable live tests only when both the opt-in flag and credential are present. */
+declare const phase7LiveProfileEnabled: (env: Phase7LiveGateEnvironment) => boolean;
+//#endregion
+//#region src/fixtures/travel-planner/scenarios.d.ts
+declare const phase1Trip: TripRequest;
+declare const expectedTravelPlan: TravelPlan;
+declare const phase1HappyPathTurns: [{
+  _tag: "Stream";
+  parts: ({
+    type: "tool-call";
+    id: string;
+    name: string;
+    params: {
+      origin: string;
+      destination: string;
+      departOn: string;
+      travelers: number;
+      nights?: undefined;
+    };
+    reason?: undefined;
+    usage?: undefined;
+  } | {
+    type: "tool-call";
+    id: string;
+    name: string;
+    params: {
+      origin?: undefined;
+      destination: string;
+      departOn: string;
+      nights: number;
+      travelers: number;
+    };
+    reason?: undefined;
+    usage?: undefined;
+  } | {
+    id?: undefined;
+    name?: undefined;
+    params?: undefined;
+    type: "finish";
+    reason: "tool-calls";
+    usage: {
+      inputTokens: {
+        total: number;
+      };
+      outputTokens: {
+        total: number;
+      };
+    };
+  })[];
+  termination: {
+    _tag: "Complete";
+  };
+}, {
+  _tag: "Stream";
+  parts: ({
+    reason?: undefined;
+    usage?: undefined;
+    type: "text-start";
+    id: string;
+    delta?: undefined;
+  } | {
+    reason?: undefined;
+    usage?: undefined;
+    type: "text-delta";
+    id: string;
+    delta: string;
+  } | {
+    reason?: undefined;
+    usage?: undefined;
+    delta?: undefined;
+    type: "text-end";
+    id: string;
+  } | {
+    id?: undefined;
+    delta?: undefined;
+    type: "finish";
+    reason: "stop";
+    usage: {
+      inputTokens: {
+        total: number;
+      };
+      outputTokens: {
+        total: number;
+      };
+    };
+  })[];
+  termination: {
+    _tag: "Complete";
+  };
+}];
+//#endregion
+//#region src/fixtures/travel-planner/subagents-durable.d.ts
+/** Registered coordinator and researcher bindings for durable delegation tests. */
+declare const s2TravelPlannerDeploymentId: string & import("effect/Brand").Brand<"@effect-agent/thread/DeploymentId">;
+declare const s2TravelPlannerProducerId: string & import("effect/Brand").Brand<"@effect-agent/thread/ProducerId">;
+declare const s2TravelPlannerPrincipal: string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">;
+/** Redacted, deterministic parent (coordinator) definition digests for this fixture version. */
+declare const s2CoordinatorDigests: DefinitionDigests;
+/**
+ * The exact child Binding digest strings the application declares on
+ * `SubagentRuntimeOptions.durable.targetDigests` AND the host registers with
+ * the host's binding array 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.
+ */
+declare const s2ResearcherDigestStrings: {
+  readonly agent: string;
+  readonly model: string;
+  readonly tools: string;
+};
+declare const s2ResearcherDigests: DefinitionDigests;
+/** Durable admission options for one coordinator Submission on one mission lane. */
+declare const s2TravelPlannerSubmitOptions: (threadId: ThreadId, idempotencyKey: IdempotencyKey) => DurableSubmitOptions;
+/** The structural submit slice of the coordinator Binding (`DurableAgentRuntime.submit`). */
+declare const s2CoordinatorSubmitAgent: {
+  readonly definition: {
+    readonly id: import("effect/Brand").Brand<"@effect-agent/core/AgentId"> & "travel-coordinator";
+    readonly input: typeof ResearchMission;
+  };
+};
+/**
+ * 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.
+ */
+declare const durableResearchAllocation: import("effect-agent/subagent-contract").SubagentReservationAmounts;
+/** The one scripted delegation Tool Call id of the durable coordinator Run. */
+declare const durableResearchCallId = "research-lhr-1";
+/** The child's own scripted guide-lookup Tool Call id. */
+declare const durableChildLookupCallId: (destination: string) => string;
+/** The projected finding the parent joins (only the advisory crosses, SUB-015). */
+declare const durableResearchFinding: (destination: string) => {
+  destination: string & import("effect/Brand").Brand<"@effect-agent/testing/travel-planner/AirportCode">;
+  summary: string;
+};
+/** The coordinator's expected final shortlist for one researched destination. */
+declare const durableResearchShortlist: (destination: string) => DestinationShortlist;
+/**
+ * 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).
+ */
+declare const encodedDestinationFacts: (destination: string) => unknown;
+/** One scripted model whose behavior is keyed by the global invocation index. */
+declare const makeInvocationCountingModel: (name: string, script: (call: number) => ReadonlyArray<Response.StreamPartEncoded>) => Effect.Effect<{
+  model: Model.Model<"scripted", LanguageModel.LanguageModel, never>;
+  calls: Effect.Effect<number, never, never>;
+  prompts: Effect.Effect<readonly string[], never, never>;
+}, never, never>;
+/** Runtime wiring for the durable slice: the S1 delegation plus the S2 digest declaration. */
+declare const durableDestinationResearchHandlersLayer: <Provider, ModelProvides, ModelRequires>(childBinding: RuntimeBinding<typeof DestinationBrief, typeof DestinationReport, string, Toolkit.Tools<typeof DestinationResearcherToolkit>, Provider, ModelProvides, ModelRequires>) => Layer.Layer<import("effect/unstable/ai/Tool").Handler<"delegate_destination_research">, never, Subagent.SubagentLayerRequirements<typeof DestinationBrief, typeof DestinationReport, string, {
+  readonly lookup_destination: import("effect/unstable/ai/Tool").Tool<"lookup_destination", {
+    readonly parameters: typeof DestinationQuery;
+    readonly success: typeof DestinationFacts;
+    readonly failure: typeof DestinationGuideUnavailable;
+    readonly failureMode: "error";
+  }, DestinationGuide>;
+}, Provider, ModelProvides, ModelRequires, ResearchDispatchGate, never, never, {
+  readonly _tag: string;
+}, never, undefined, undefined, undefined>>;
+/** Optional overrides for one durable research harness. */
+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. */
+interface DurableResearchHarness {
+  /** Host registrations for `NodeDurableAgentRuntimeOptions.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 `NodeDurableAgentRuntime` stacks over the same SQLite
+ * file while the counters keep counting across all of them.
+ */
+declare const makeDurableResearchHarness: (options?: DurableResearchHarnessOptions) => Effect.Effect<DurableResearchHarness, never, never>;
+//#endregion
+export { ActivityCatalog, ActivityCatalogLayer, ActivityQuery, ActivitySearchResult, ActivityUnavailable, AirportCode, BookFlight, BookItinerary, BookingRef, CancelBooking, CancelBookingRequest, CancellationConfirmation, CatalogLifecycle, CatalogLifecycleCounts, type CrossPlatformEvidenceIdentity, DestinationBrief, DestinationFacts, DestinationGuide, DestinationGuideLayer, DestinationGuideUnavailable, DestinationQuery, DestinationRecommendation, DestinationReport, type DestinationResearchCall, DestinationResearchFailed, DestinationResearchFindings, DestinationResearchRequest, DestinationResearchSupportLayer, DestinationResearcher, type DestinationResearcherControls, DestinationResearcherToolkit, DestinationResearcherToolkitLayer, DestinationShortlist, DeterministicIdGeneratorLayer, type DurableResearchHarness, type DurableResearchHarnessOptions, DurableSearchActivities, DurableSearchFlights, DurableSearchLodging, FlightBookingRequest, FlightCatalog, FlightCatalogLayer, FlightOption, FlightQuery, FlightUnavailable, GuidanceFailure, HoldItinerary, Itinerary, ItineraryBookingRequest, ItineraryConfirmation, ItineraryHold, ItineraryHoldGateway, ItineraryHoldRequest, ItineraryHoldUnavailable, LodgingCatalog, LodgingCatalogLayer, LodgingOption, LodgingQuery, LodgingUnavailable, LookupDestination, PHASE7_LIVE_CREDENTIAL_ENV, PHASE7_LIVE_GATE_ENV, type Phase7LiveGateEnvironment, QuoteId, ResearchDispatchGate, ResearchMission, ReverseCompletionToolkitLayer, SearchActivities, SearchFlights, SearchLodging, type SupplierBookRequest, SupplierBookingConfirmation, SupplierBookingDesk, SupplierBookingRecord, type SupplierHoldControls, SupplierOperation, SupplierUnavailable, TravelBookingReport, TravelCoordinator, TravelCoordinatorToolkit, TravelGuidance, TravelGuidanceLayer, TravelPlan, TravelPlanner, TravelPlannerBookingEvidenceError, type TravelPlannerCompletionControls, TravelPlannerDurableEvidenceError, TravelPlannerPhase2, TravelPlannerPhase2Toolkit, TravelPlannerPhase2ToolkitLayer, TravelPlannerPhase4, TravelPlannerPhase4Toolkit, TravelPlannerPhase4ToolkitLayer, TravelPlannerPhase5, TravelPlannerPhase5Toolkit, TravelPlannerPhase5ToolkitLayer, TravelPlannerProjectionError, TravelPlannerRuntimeLayer, TravelPlannerToolkit, TravelPlannerToolkitLayer, TravelSupplierReconcilerLayer, TravelerRef, TripRequest, assertSettledBookingsExistAtSupplier, bookFlightIdempotencyKey, cancelBookingIdempotencyKey, coordinatorConfidentialMarker, coordinatorResearchTurn, coordinatorShortlistTurn, destinationLookup, destinationReportFor, destinationResearchDelegation, destinationResearchHandlersLayer, destinationResearchPolicy, durableChildLookupCallId, durableDestinationResearchHandlersLayer, durableResearchAllocation, durableResearchCallId, durableResearchFinding, durableResearchShortlist, encodedDestinationFacts, encodedDestinationReport, expectedDestinationShortlist, expectedTravelPlan, itineraryStepIdempotencyKey, makeDestinationResearcherModel, makeDurableResearchHarness, makeInvocationCountingModel, makePhase3TravelPlannerCheckpoint, makePhase4TravelPlannerAgent, makePhase6TravelPlannerBindings, mapResearchChildFailure, missionConfidentialMarker, normalizeCrossPlatformTravelPlannerEvidence, normalizeDurableTravelPlannerEvidence, phase1HappyPathTurns, phase1Trip, phase3TravelPlannerBatches, phase3TravelPlannerCompletionBatch, phase3TravelPlannerDefinitionDigests, phase3TravelPlannerEncodedFixture, phase3TravelPlannerInitialBatch, phase3TravelPlannerProducerId, phase3TravelPlannerRunId, phase3TravelPlannerThreadId, phase4TravelPlannerDefinitionDigests, phase4TravelPlannerDeploymentId, phase4TravelPlannerPrincipal, phase4TravelPlannerProducerId, phase4TravelPlannerSubmitOptions, phase4TravelPlannerWorkerLayer, phase5TravelPlannerDefinitionDigests, phase5TravelPlannerDeploymentId, phase5TravelPlannerPrincipal, phase5TravelPlannerProducerId, phase5TravelPlannerSubmitOptions, phase5TravelPlannerWorkerLayer, phase6ActivityCallId, phase6BookingModel, phase6BookingRef, phase6BookingToolCallId, phase6BookingTrip, phase6ChildLookupCallId, phase6CoordinatorModel, phase6FlightCallId, phase6GatedPlannerDefinitionDigests, phase6GatedPlannerModel, phase6GatedTrip, phase6GuideInvocationCount, phase6LodgingCallId, phase6PlannerModel, phase6ResearchDestination, phase6ResearchMission, phase6ResearcherModel, phase6SupplierDesk, phase6SupplierDeskLayer, phase6SupplierReconcilerLayer, phase6TravelPlannerDeploymentId, phase6TravelPlannerGoldenEvidence, phase6TravelPlannerProducerId, phase6TravelPlannerProducerPrefix, phase7LiveProfileEnabled, releasePhase6PlannerGate, releasePhase6ResearcherGate, researchMission, researcherHappyPathTurns, resetPhase6PlannerGate, resetPhase6ResearcherGate, s2CoordinatorDigests, s2CoordinatorSubmitAgent, s2ResearcherDigestStrings, s2ResearcherDigests, s2TravelPlannerDeploymentId, s2TravelPlannerPrincipal, s2TravelPlannerProducerId, s2TravelPlannerSubmitOptions, supplierBookingRefFor, travelPlanFromDurableSettlement, travelPlanFromProjection };
+//# sourceMappingURL=TravelPlanner.d.mts.map