@effect-agent/testing 0.1.0-beta.38 → 0.1.0-beta.40

package/dist/travel-planner.mjs

@@ -0,0 +1,2103 @@
+import { r as ScriptedModel } from "./scripted-model-C2y0ztuj.mjs";
+import { A as LodgingQuery, B as TravelPlannerToolkitLayer, C as FlightOption, D as Itinerary, E as GuidanceFailure, F as SearchLodging, I as TravelGuidance, L as TravelPlan, M as QuoteId, N as SearchActivities, O as LodgingCatalog, P as SearchFlights, R as TravelPlanner, S as FlightCatalog, T as FlightUnavailable, V as TripRequest, _ as ActivityCatalog, a as DeterministicIdGeneratorLayer, b as ActivityUnavailable, c as ReverseCompletionToolkitLayer, d as SupplierOperation, f as SupplierUnavailable, g as supplierBookingRefFor, h as cancelBookingIdempotencyKey, i as CatalogLifecycleCounts, j as LodgingUnavailable, k as LodgingOption, l as SupplierBookingDesk, m as TravelPlannerRuntimeLayer, n as BookingRef, o as FlightCatalogLayer, p as TravelGuidanceLayer, r as CatalogLifecycle, s as LodgingCatalogLayer, t as ActivityCatalogLayer, u as SupplierBookingRecord, v as ActivityQuery, w as FlightQuery, x as AirportCode, y as ActivitySearchResult, z as TravelPlannerToolkit } from "./deterministic-layers-CKyYxBhN.mjs";
+import { Context, Deferred, Duration, Effect, Layer, Option, Ref, Schema, Stream } from "effect";
+import { LanguageModel, Model, Tool, Toolkit } from "effect/unstable/ai";
+import { Subagent, SubagentPolicy, SubagentReservationsMemoryLive, SubagentRuntime, delegationAllocationFromPolicy } from "@effect-agent/capabilities";
+import { Agent, AgentId, AgentPolicy, RunId, SubmissionId, ThreadId } from "@effect-agent/core";
+import { DurableStep, DurableStepError, ToolExecutionClass } from "@effect-agent/engine";
+import { BatchId, CanonicalBatch, CanonicalRecordEnvelope, DefinitionDigests, DeploymentId, Digest, DurableWorkerBinding, PersistedJson, Principal, ProducerId, ReconciliationCompleted, ReconciliationSafeToRetry, ReconciliationUncertain, RecordEnvelope, RecordId, ThreadCheckpoint, ThreadProjection, ToolReconciler, ToolReconcilerError } from "@effect-agent/thread";
+//#region src/fixtures/travel-planner/phase2.ts
+var ItineraryHoldRequest = class extends Schema.Class("@effect-agent/testing/travel-planner/ItineraryHoldRequest")({
+	quoteId: QuoteId,
+	expiresInMinutes: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(60))
+}) {};
+var ItineraryHold = class extends Schema.Class("@effect-agent/testing/travel-planner/ItineraryHold")({
+	holdId: Schema.NonEmptyString,
+	quoteId: QuoteId,
+	status: Schema.Literal("held")
+}) {};
+var ItineraryHoldUnavailable = class extends Schema.TaggedError()("ItineraryHoldUnavailable", {
+	quoteId: QuoteId,
+	message: Schema.String
+}) {};
+var ItineraryHoldGateway = class extends Context.Service()("@effect-agent/testing/travel-planner/ItineraryHoldGateway") {};
+/**
+* The first mutating Travel Planner Tool. Effect AI marks it as approval-gated
+* so the engine must settle approval before acquiring a handler permit.
+*/
+const HoldItinerary = Tool.make("hold_itinerary", {
+	parameters: ItineraryHoldRequest,
+	success: ItineraryHold,
+	failure: ItineraryHoldUnavailable,
+	failureMode: "error",
+	dependencies: [ItineraryHoldGateway],
+	needsApproval: true
+});
+const TravelPlannerPhase2Toolkit = Toolkit.make(SearchFlights, SearchLodging, SearchActivities, HoldItinerary);
+const TravelPlannerPhase2ToolkitLayer = TravelPlannerPhase2Toolkit.toLayer({
+	search_flights: (query) => Effect.flatMap(FlightCatalog, (catalog) => catalog.search(query)),
+	search_lodging: (query) => Effect.flatMap(LodgingCatalog, (catalog) => catalog.search(query)),
+	search_activities: (query) => Effect.flatMap(ActivityCatalog, (catalog) => catalog.search(query)),
+	hold_itinerary: (request) => Effect.flatMap(ItineraryHoldGateway, (gateway) => gateway.hold(request))
+});
+const TravelPlannerPhase2 = Agent.make("travel-planner-phase-2", {
+	input: TripRequest,
+	output: TravelPlan,
+	instructions: (input) => Effect.flatMap(TravelGuidance, (guidance) => guidance.instructions(input)),
+	toolkit: TravelPlannerPhase2Toolkit,
+	policy: AgentPolicy.make({
+		maxTurns: 3,
+		maxToolCalls: 4,
+		maxDuration: "30 seconds",
+		toolConcurrency: 3,
+		tokenBudget: 4096
+	}),
+	description: "Build a review-only itinerary and require approval before creating a temporary hold.",
+	metadata: {
+		deploymentClass: "E",
+		phase: "P2"
+	}
+});
+//#endregion
+//#region src/fixtures/travel-planner/scenarios.ts
+const usage = {
+	inputTokens: { total: 128 },
+	outputTokens: { total: 96 }
+};
+const phase1Trip = Schema.decodeSync(TripRequest)({
+	request: "Plan a review-only London trip using the deterministic flight, lodging, and activity searches.",
+	origin: "SFO",
+	destination: "LHR",
+	departOn: "2026-09-14",
+	nights: 4,
+	travelers: 2,
+	budgetCents: 35e4,
+	currency: "USD"
+});
+const expectedTravelPlan = Schema.decodeSync(TravelPlan)({ itineraries: [{
+	title: "Westward light, eastbound overnight",
+	route: "San Francisco → London",
+	dates: "14–19 September 2026",
+	flight: "EA 218 · nonstop · SFO 18:40 → LHR 13:05+1",
+	lodging: "Bloomsbury House · refundable studio · 4 nights",
+	activities: ["British Museum timed entry", "Thames evening walk"],
+	estimatedTotalCents: 284e3,
+	currency: "USD",
+	quoteId: "quote-sfo-lhr-001",
+	assumptions: ["Two travelers sharing one studio", "Quote is read-only availability, not a reservation"],
+	unresolvedConstraints: ["Traveler names and accessibility requests are intentionally omitted"],
+	nextAction: "review"
+}] });
+const phase1HappyPathTurns = [{
+	_tag: "Stream",
+	parts: [
+		{
+			type: "tool-call",
+			id: "flight-call-1",
+			name: "search_flights",
+			params: {
+				origin: "SFO",
+				destination: "LHR",
+				departOn: "2026-09-14",
+				travelers: 2
+			}
+		},
+		{
+			type: "tool-call",
+			id: "lodging-call-1",
+			name: "search_lodging",
+			params: {
+				destination: "LHR",
+				departOn: "2026-09-14",
+				nights: 4,
+				travelers: 2
+			}
+		},
+		{
+			type: "tool-call",
+			id: "activity-call-1",
+			name: "search_activities",
+			params: {
+				destination: "LHR",
+				departOn: "2026-09-14",
+				nights: 4,
+				travelers: 2
+			}
+		},
+		{
+			type: "finish",
+			reason: "tool-calls",
+			usage
+		}
+	],
+	termination: { _tag: "Complete" }
+}, {
+	_tag: "Stream",
+	parts: [
+		{
+			type: "text-start",
+			id: "itinerary-json"
+		},
+		{
+			type: "text-delta",
+			id: "itinerary-json",
+			delta: JSON.stringify(Schema.encodeSync(TravelPlan)(expectedTravelPlan))
+		},
+		{
+			type: "text-end",
+			id: "itinerary-json"
+		},
+		{
+			type: "finish",
+			reason: "stop",
+			usage
+		}
+	],
+	termination: { _tag: "Complete" }
+}];
+//#endregion
+//#region src/fixtures/travel-planner/phase3.ts
+/**
+* The Phase 3 profile persists Thread history but deliberately does not
+* claim durable admission or recovery of accepted work.
+*/
+var TravelPlannerPersistenceProfile = class extends Schema.Class("@effect-agent/testing/travel-planner/TravelPlannerPersistenceProfile")({
+	deploymentClass: Schema.Literal("P"),
+	durableAcceptedWork: Schema.Literal(false),
+	canonicalSchemaVersion: Schema.Literal(1)
+}) {};
+const phase3TravelPlannerProfile = TravelPlannerPersistenceProfile.make({
+	deploymentClass: "P",
+	durableAcceptedWork: false,
+	canonicalSchemaVersion: 1
+});
+const phase3TravelPlannerThreadId = Schema.decodeSync(ThreadId)("travel-planner-p3-thread");
+const phase3TravelPlannerProducerId = Schema.decodeSync(ProducerId)("travel-planner-p3-producer");
+const phase3TravelPlannerRunId = Schema.decodeSync(RunId)("travel-planner-p3-run");
+const deploymentId = Schema.decodeSync(DeploymentId)("travel-planner-p3-scripted");
+const agentId = Schema.decodeSync(AgentId)("travel-planner");
+const submissionId = Schema.decodeSync(SubmissionId)("travel-planner-p3-submission");
+const digest$2 = (character) => Schema.decodeSync(Digest)(character.repeat(64));
+/** Redacted, deterministic definition identities for the current fixture version. */
+const phase3TravelPlannerDefinitionDigests = DefinitionDigests.make({
+	agent: digest$2("a"),
+	model: digest$2("b"),
+	tools: digest$2("c")
+});
+const tripInput = Schema.encodeSync(TripRequest)(phase1Trip);
+const travelPlanOutput = Schema.encodeSync(TravelPlan)(expectedTravelPlan);
+const record = (recordId, createdAt, payload) => Schema.decodeUnknownSync(RecordEnvelope)({
+	recordId: Schema.decodeSync(RecordId)(recordId),
+	family: "thread",
+	schemaVersion: 1,
+	createdAt,
+	deploymentId,
+	payload
+});
+/**
+* The first atomic append establishes the Thread and records its input.
+* Its encoded value is the redacted current-version persistence fixture.
+*/
+const phase3TravelPlannerInitialBatch = CanonicalBatch.make({
+	batchId: Schema.decodeSync(BatchId)("travel-planner-p3-initial"),
+	producerId: phase3TravelPlannerProducerId,
+	records: [record("travel-planner-p3-created", "2026-09-01T00:00:00.000Z", {
+		_tag: "ThreadCreated",
+		agentId,
+		definitions: phase3TravelPlannerDefinitionDigests
+	}), record("travel-planner-p3-input", "2026-09-01T00:00:01.000Z", {
+		_tag: "UserInputRecorded",
+		submissionId,
+		kind: "user",
+		runId: phase3TravelPlannerRunId,
+		input: tripInput
+	})]
+});
+/** The second append records the Schema-decoded itinerary and terminal Run result. */
+const phase3TravelPlannerCompletionBatch = CanonicalBatch.make({
+	batchId: Schema.decodeSync(BatchId)("travel-planner-p3-completion"),
+	producerId: phase3TravelPlannerProducerId,
+	records: [record("travel-planner-p3-model", "2026-09-01T00:00:02.000Z", {
+		_tag: "ModelCompleted",
+		runId: phase3TravelPlannerRunId,
+		output: travelPlanOutput
+	}), record("travel-planner-p3-completed", "2026-09-01T00:00:03.000Z", {
+		_tag: "RunCompleted",
+		runId: phase3TravelPlannerRunId,
+		output: travelPlanOutput
+	})]
+});
+const phase3TravelPlannerBatches = [phase3TravelPlannerInitialBatch, phase3TravelPlannerCompletionBatch];
+/** Portable current-version fixture; it contains no passenger identity or credentials. */
+const phase3TravelPlannerEncodedFixture = Schema.encodeSync(Schema.Array(CanonicalBatch))(phase3TravelPlannerBatches);
+var TravelPlannerProjectionError = class extends Schema.TaggedError()("TravelPlannerProjectionError", { message: Schema.String }) {};
+/** Decode the itinerary projection rebuilt from canonical model-completion records. */
+const travelPlanFromProjection = (projection) => {
+	const output = projection.modelOutputs.at(-1);
+	if (output === void 0) return Effect.fail(TravelPlannerProjectionError.make({ message: "The canonical projection has no completed Travel Planner model output." }));
+	return Schema.decodeUnknownEffect(TravelPlan)(output).pipe(Effect.mapError((error) => TravelPlannerProjectionError.make({ message: error.message })));
+};
+/** Build a disposable checkpoint bound to a validated canonical prefix. */
+const makePhase3TravelPlannerCheckpoint = (projection) => Schema.decodeSync(ThreadCheckpoint)({
+	schemaVersion: 1,
+	threadId: projection.threadId,
+	throughSequence: projection.throughSequence,
+	tailDigest: projection.tailDigest,
+	engineVersion: "phase-3-test-runtime",
+	agentDefinitionDigest: phase3TravelPlannerDefinitionDigests.agent,
+	modelDigest: phase3TravelPlannerDefinitionDigests.model,
+	toolDigest: phase3TravelPlannerDefinitionDigests.tools,
+	state: Schema.encodeSync(ThreadProjection)(projection),
+	createdAt: "2026-09-01T00:00:04.000Z"
+});
+//#endregion
+//#region src/fixtures/travel-planner/phase4.ts
+/**
+* The Phase 4 profile claims durable accepted work on the Node/SQLite runtime (deployment class
+* DN): once `submit` returns a Receipt, the Submission settles exactly once even across process
+* loss. The claim is limited to safe-to-repeat toolkits (D6): supplier booking is explicitly NOT
+* claimed safely replayable — replay-safe external mutation is P5 (Durable Tools) scope.
+*/
+var TravelPlannerDurabilityProfile = class extends Schema.Class("@effect-agent/testing/travel-planner/TravelPlannerDurabilityProfile")({
+	deploymentClass: Schema.Literal("DN"),
+	durableAcceptedWork: Schema.Literal(true),
+	canonicalSchemaVersion: Schema.Literal(1),
+	/** Supplier booking replay safety is P5 (Durable Tools) scope; DN does not claim it. */
+	supplierBookingReplaySafe: Schema.Literal(false)
+}) {};
+const phase4TravelPlannerProfile = TravelPlannerDurabilityProfile.make({
+	deploymentClass: "DN",
+	durableAcceptedWork: true,
+	canonicalSchemaVersion: 1,
+	supplierBookingReplaySafe: false
+});
+const phase4TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)("travel-planner-p4-deployment");
+const phase4TravelPlannerProducerId = Schema.decodeSync(ProducerId)("travel-planner-p4-producer");
+const phase4TravelPlannerPrincipal = Schema.decodeSync(Principal)("travel-planner-p4-principal");
+const digest$1 = (character) => Schema.decodeSync(Digest)(character.repeat(64));
+/** Redacted, deterministic definition identities for the current fixture version. */
+const phase4TravelPlannerDefinitionDigests = DefinitionDigests.make({
+	agent: digest$1("d"),
+	model: digest$1("e"),
+	tools: digest$1("f")
+});
+/** Durable admission options for one Travel Planner Submission on one trip lane. */
+const phase4TravelPlannerSubmitOptions = (threadId, idempotencyKey) => ({
+	threadId,
+	principal: phase4TravelPlannerPrincipal,
+	idempotencyKey,
+	definitions: phase4TravelPlannerDefinitionDigests
+});
+/**
+* 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`).
+*/
+const DurableSearchFlights = Tool.make("search_flights", {
+	parameters: Schema.Struct(FlightQuery.fields),
+	success: FlightOption,
+	failure: FlightUnavailable,
+	failureMode: "error",
+	dependencies: [FlightCatalog]
+}).annotate(ToolExecutionClass, "readonly");
+const DurableSearchLodging = Tool.make("search_lodging", {
+	parameters: Schema.Struct(LodgingQuery.fields),
+	success: LodgingOption,
+	failure: LodgingUnavailable,
+	failureMode: "error",
+	dependencies: [LodgingCatalog]
+}).annotate(ToolExecutionClass, "readonly");
+const DurableSearchActivities = Tool.make("search_activities", {
+	parameters: Schema.Struct(ActivityQuery.fields),
+	success: ActivitySearchResult,
+	failure: ActivityUnavailable,
+	failureMode: "error",
+	dependencies: [ActivityCatalog]
+}).annotate(ToolExecutionClass, "readonly");
+const TravelPlannerPhase4Toolkit = Toolkit.make(DurableSearchFlights, DurableSearchLodging, DurableSearchActivities);
+const TravelPlannerPhase4ToolkitLayer = TravelPlannerPhase4Toolkit.toLayer({
+	search_flights: (query) => Effect.flatMap(FlightCatalog, (catalog) => catalog.search(FlightQuery.make(query))),
+	search_lodging: (query) => Effect.flatMap(LodgingCatalog, (catalog) => catalog.search(LodgingQuery.make(query))),
+	search_activities: (query) => Effect.flatMap(ActivityCatalog, (catalog) => catalog.search(ActivityQuery.make(query)))
+});
+/**
+* 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).
+*/
+const TravelPlannerPhase4 = Agent.make("travel-planner-phase-4", {
+	input: TripRequest,
+	output: TravelPlan,
+	instructions: (input) => Effect.flatMap(TravelGuidance, (guidance) => guidance.instructions(input)),
+	toolkit: TravelPlannerPhase4Toolkit,
+	policy: AgentPolicy.make({
+		maxTurns: 2,
+		maxToolCalls: 3,
+		maxDuration: "30 seconds",
+		toolConcurrency: 3
+	}),
+	description: "Durably plan one review-only itinerary from safe-to-repeat deterministic searches; supplier booking is not claimed safely replayable.",
+	metadata: {
+		deploymentClass: "DN",
+		phase: "P4"
+	}
+});
+/**
+* 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.
+*/
+const makePhase4TravelPlannerAgent = (turns = phase1HappyPathTurns) => Agent.withModel(TravelPlannerPhase4, Model.make("scripted", "travel-planner-phase-4", ScriptedModel.layer(turns)));
+/**
+* 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.
+*/
+const phase4TravelPlannerWorkerLayer = Layer.mergeAll(TravelPlannerPhase4ToolkitLayer, FlightCatalogLayer, LodgingCatalogLayer, ActivityCatalogLayer, TravelGuidanceLayer).pipe(Layer.provide(CatalogLifecycle.layerNoDeps));
+var TravelPlannerDurableEvidenceError = class extends Schema.TaggedError()("TravelPlannerDurableEvidenceError", { message: Schema.String }) {};
+/**
+* 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.
+*/
+const travelPlanFromDurableSettlement = Effect.fn("TravelPlannerPhase4.travelPlanFromDurableSettlement")(function* (records) {
+	const settled = records.flatMap((envelope) => envelope.record.payload._tag === "SubmissionSettled" ? [envelope.record.payload] : []).at(0);
+	if (settled === void 0) return yield* TravelPlannerDurableEvidenceError.make({ message: "The canonical Thread Log has no SubmissionSettled record." });
+	if (settled.outcome !== "completed" || settled.result === void 0) return yield* TravelPlannerDurableEvidenceError.make({ message: `The Submission settled ${settled.outcome} without a completed itinerary result.` });
+	return yield* Schema.decodeUnknownEffect(TravelPlan)(settled.result).pipe(Effect.mapError((error) => TravelPlannerDurableEvidenceError.make({ message: `The settled result does not decode through the TravelPlan schema: ${error.message}` })));
+});
+const encodeEvidence = Schema.encodeEffect(Schema.Array(CanonicalRecordEnvelope));
+const decodeComparableJson$1 = Schema.decodeUnknownEffect(Schema.Json);
+/**
+* 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.
+*/
+const normalizeDurableTravelPlannerEvidence = Effect.fn("TravelPlannerPhase4.normalizeDurableTravelPlannerEvidence")(function* (records, receipt) {
+	const comparable = (yield* encodeEvidence(records).pipe(Effect.mapError((error) => TravelPlannerDurableEvidenceError.make({ message: `Canonical evidence failed to encode: ${error.message}` })))).map((envelope) => ({
+		batchId: envelope.batchId,
+		sequence: envelope.sequence,
+		record: envelope.record
+	}));
+	const substituted = JSON.parse(JSON.stringify(comparable).replaceAll(receipt.submissionId, "{submissionId}").replaceAll(receipt.receiptId, "{receiptId}"));
+	return yield* decodeComparableJson$1(substituted).pipe(Effect.mapError((error) => TravelPlannerDurableEvidenceError.make({ message: `Normalized evidence is not comparable JSON: ${error.message}` })));
+});
+//#endregion
+//#region src/fixtures/travel-planner/phase5.ts
+/**
+* The Phase 5 profile extends the P4 `DN` claim to consequential supplier mutation: booking
+* Tools enter the prepared/settled uncertainty protocol, unresolved external effects stop at
+* Unknown Outcomes instead of replaying, Durable Steps replay recorded results, and queued
+* traveler input joins the active Run. Exactly-once EXTERNAL execution is still — deliberately —
+* not claimed (DUR-003): the supplier's own idempotency keys are what dedupe repeats.
+*/
+var TravelPlannerBookingProfile = class extends Schema.Class("@effect-agent/testing/travel-planner/TravelPlannerBookingProfile")({
+	deploymentClass: Schema.Literal("DN"),
+	durableAcceptedWork: Schema.Literal(true),
+	canonicalSchemaVersion: Schema.Literal(1),
+	/** P5: supplier mutations get prepared/settled records, Unknown Outcomes, and reconciliation. */
+	supplierBookingUncertaintyProtocol: Schema.Literal(true),
+	/** P5: Durable Steps are exactly-once-RECORDED; their side effects stay at-least-once. */
+	durableStepsRecorded: Schema.Literal(true),
+	/** Never claimed at any phase (DUR-003). */
+	exactlyOnceExternalEffects: Schema.Literal(false)
+}) {};
+const phase5TravelPlannerProfile = TravelPlannerBookingProfile.make({
+	deploymentClass: "DN",
+	durableAcceptedWork: true,
+	canonicalSchemaVersion: 1,
+	supplierBookingUncertaintyProtocol: true,
+	durableStepsRecorded: true,
+	exactlyOnceExternalEffects: false
+});
+const phase5TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)("travel-planner-p5-deployment");
+const phase5TravelPlannerProducerId = Schema.decodeSync(ProducerId)("travel-planner-p5-producer");
+const phase5TravelPlannerPrincipal = Schema.decodeSync(Principal)("travel-planner-p5-principal");
+const digest = (character) => Schema.decodeSync(Digest)(character.repeat(64));
+/** Redacted, deterministic definition identities for the current fixture version. */
+const phase5TravelPlannerDefinitionDigests = DefinitionDigests.make({
+	agent: digest("1"),
+	model: digest("2"),
+	tools: digest("3")
+});
+/** Durable admission options for one Travel Planner Submission on one trip lane. */
+const phase5TravelPlannerSubmitOptions = (threadId, idempotencyKey) => ({
+	threadId,
+	principal: phase5TravelPlannerPrincipal,
+	idempotencyKey,
+	definitions: phase5TravelPlannerDefinitionDigests
+});
+const TravelerRef = Schema.NonEmptyString.pipe(Schema.brand("@effect-agent/testing/travel-planner/TravelerRef"));
+/**
+* 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).
+*/
+var FlightBookingRequest = class extends Schema.Class("FlightBookingRequest")({
+	quoteId: QuoteId,
+	travelerRef: TravelerRef,
+	departOn: Schema.String
+}) {};
+var SupplierBookingConfirmation = class extends Schema.Class("SupplierBookingConfirmation")({
+	bookingRef: BookingRef,
+	status: Schema.Literal("confirmed"),
+	detail: Schema.String
+}) {};
+var CancelBookingRequest = class extends Schema.Class("CancelBookingRequest")({
+	bookingRef: BookingRef,
+	travelerRef: TravelerRef
+}) {};
+var CancellationConfirmation = class extends Schema.Class("CancellationConfirmation")({
+	bookingRef: BookingRef,
+	status: Schema.Literal("cancelled")
+}) {};
+var ItineraryBookingRequest = class extends Schema.Class("ItineraryBookingRequest")({
+	quoteId: QuoteId,
+	destination: AirportCode,
+	nights: Schema.Int.check(Schema.isGreaterThan(0)),
+	travelerRef: TravelerRef
+}) {};
+var ItineraryConfirmation = class extends Schema.Class("ItineraryConfirmation")({
+	flightBookingRef: BookingRef,
+	lodgingBookingRef: BookingRef,
+	confirmationCode: Schema.String
+}) {};
+/** The P5 Run output: a booked (or explicitly not-booked) trip report. */
+var TravelBookingReport = class extends Schema.Class("TravelBookingReport")({
+	summary: Schema.String,
+	bookingRefs: Schema.Array(BookingRef)
+}) {};
+/**
+* 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.
+*/
+const bookFlightIdempotencyKey = (toolCallId) => `book-flight:${toolCallId}`;
+const itineraryStepIdempotencyKey = (toolCallId, stepName) => `${toolCallId}:${stepName}`;
+/**
+* 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).
+*/
+const BookFlight = Tool.make("book_flight", {
+	parameters: FlightBookingRequest,
+	success: SupplierBookingConfirmation,
+	failure: SupplierUnavailable,
+	failureMode: "error",
+	needsApproval: true,
+	dependencies: [SupplierBookingDesk]
+}).annotate(ToolExecutionClass, "uncertain");
+/**
+* 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.
+*/
+const CancelBooking = Tool.make("cancel_booking", {
+	parameters: CancelBookingRequest,
+	success: CancellationConfirmation,
+	failure: SupplierUnavailable,
+	failureMode: "error",
+	needsApproval: true,
+	dependencies: [SupplierBookingDesk]
+}).annotate(ToolExecutionClass, "idempotent");
+/**
+* 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.
+*/
+const BookItinerary = Tool.make("book_itinerary", {
+	parameters: ItineraryBookingRequest,
+	success: ItineraryConfirmation,
+	failure: Schema.Union([SupplierUnavailable, DurableStepError]),
+	failureMode: "error",
+	dependencies: [DurableStep, SupplierBookingDesk]
+});
+const TravelPlannerPhase5Toolkit = Toolkit.make(DurableSearchFlights, DurableSearchLodging, DurableSearchActivities, BookFlight, CancelBooking, BookItinerary);
+const requireToolCallId = (toolName, toolCallId) => toolCallId === void 0 ? Effect.fail(SupplierUnavailable.make({ message: `${toolName} needs its stable Tool Call ID to derive the supplier idempotency key.` })) : Effect.succeed(toolCallId);
+const TravelPlannerPhase5ToolkitLayer = TravelPlannerPhase5Toolkit.toLayer({
+	search_flights: (query) => Effect.flatMap(FlightCatalog, (catalog) => catalog.search(FlightQuery.make(query))),
+	search_lodging: (query) => Effect.flatMap(LodgingCatalog, (catalog) => catalog.search(LodgingQuery.make(query))),
+	search_activities: (query) => Effect.flatMap(ActivityCatalog, (catalog) => catalog.search(ActivityQuery.make(query))),
+	book_flight: (request, context) => Effect.gen(function* () {
+		const desk = yield* SupplierBookingDesk;
+		const toolCallId = yield* requireToolCallId("book_flight", context.toolCallId);
+		const record = yield* desk.book({
+			operation: "book-flight",
+			idempotencyKey: bookFlightIdempotencyKey(toolCallId),
+			detail: `flight ${request.quoteId} for ${request.travelerRef} on ${request.departOn}`
+		});
+		return SupplierBookingConfirmation.make({
+			bookingRef: record.bookingRef,
+			status: "confirmed",
+			detail: record.detail
+		});
+	}),
+	cancel_booking: (request) => Effect.gen(function* () {
+		const record = yield* (yield* SupplierBookingDesk).cancel(request.bookingRef);
+		return CancellationConfirmation.make({
+			bookingRef: record.bookingRef,
+			status: "cancelled"
+		});
+	}),
+	book_itinerary: (request, context) => Effect.gen(function* () {
+		const desk = yield* SupplierBookingDesk;
+		const step = yield* DurableStep;
+		const toolCallId = yield* requireToolCallId("book_itinerary", context.toolCallId);
+		const bookStep = (stepName, detail) => step.do(stepName, SupplierBookingRecord, desk.book({
+			operation: stepName,
+			idempotencyKey: itineraryStepIdempotencyKey(toolCallId, stepName),
+			detail
+		}));
+		const flight = yield* bookStep("reserve-flight", `flight ${request.quoteId} for ${request.travelerRef}`);
+		const lodging = yield* bookStep("reserve-lodging", `lodging ${request.destination} for ${request.nights} nights (${request.travelerRef})`);
+		const confirmation = yield* bookStep("issue-confirmation", `itinerary confirmation for ${request.travelerRef}`);
+		return ItineraryConfirmation.make({
+			flightBookingRef: flight.bookingRef,
+			lodgingBookingRef: lodging.bookingRef,
+			confirmationCode: confirmation.bookingRef
+		});
+	})
+});
+const decodePersistedJson = Schema.decodeUnknownEffect(PersistedJson);
+const encodeConfirmation = Schema.encodeEffect(SupplierBookingConfirmation);
+/**
+* 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).
+*/
+const TravelSupplierReconcilerLayer = Layer.effect(ToolReconciler, Effect.gen(function* () {
+	const desk = yield* SupplierBookingDesk;
+	return ToolReconciler.of({ reconcile: (evidence) => Effect.gen(function* () {
+		switch (evidence.toolName) {
+			case "book_flight": {
+				const key = bookFlightIdempotencyKey(evidence.toolCallId);
+				const booking = yield* desk.lookup(key);
+				if (Option.isSome(booking) && booking.value.status === "confirmed") {
+					const confirmation = yield* encodeConfirmation(SupplierBookingConfirmation.make({
+						bookingRef: booking.value.bookingRef,
+						status: "confirmed",
+						detail: booking.value.detail
+					})).pipe(Effect.flatMap(decodePersistedJson));
+					return ReconciliationCompleted.make({
+						result: confirmation,
+						isFailure: false
+					});
+				}
+				return ReconciliationUncertain.make({ reason: `The supplier desk shows no confirmed booking under ${key}; a write may still be in flight.` });
+			}
+			case "book_itinerary": return ReconciliationSafeToRetry.make();
+			case "cancel_booking": return ReconciliationSafeToRetry.make();
+			default: return ReconciliationUncertain.make({ reason: `No supplier reconciliation exists for ${evidence.toolName}.` });
+		}
+	}).pipe(Effect.mapError((error) => ToolReconcilerError.make({
+		toolCallId: evidence.toolCallId,
+		message: `Supplier reconciliation failed: ${error.message}`
+	}))) });
+}));
+/**
+* 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.
+*/
+const TravelPlannerPhase5 = Agent.make("travel-planner-phase-5", {
+	input: TripRequest,
+	output: TravelBookingReport,
+	instructions: [
+		"You are the Effect Agent Travel Planner P5 booking fixture.",
+		"Search with the read-only tools, then book with book_flight, book_itinerary, or",
+		"cancel_booking exactly as scripted. Every consequential mutation is approval-gated",
+		"or Step-structured. Return only a JSON object with summary and bookingRefs."
+	].join(" "),
+	toolkit: TravelPlannerPhase5Toolkit,
+	policy: AgentPolicy.make({
+		maxTurns: 4,
+		maxToolCalls: 6,
+		maxDuration: "30 seconds",
+		toolConcurrency: 2
+	}),
+	description: "Durably book one itinerary with prepared/settled supplier records, Unknown Outcomes, named Steps, and joined traveler input.",
+	metadata: {
+		deploymentClass: "DN",
+		phase: "P5"
+	}
+});
+var TravelPlannerBookingEvidenceError = class extends Schema.TaggedError()("TravelPlannerBookingEvidenceError", { message: Schema.String }) {};
+const bookingResultRefs = (result) => {
+	if (typeof result !== "object" || result === null) return [];
+	const refs = [];
+	for (const [field, value] of Object.entries(result)) if (typeof value === "string" && (field === "bookingRef" || field === "flightBookingRef" || field === "lodgingBookingRef" || field === "confirmationCode")) refs.push(value);
+	return refs;
+};
+const bookingToolNames = /* @__PURE__ */ new Set([
+	"book_flight",
+	"cancel_booking",
+	"book_itinerary"
+]);
+/**
+* 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.
+*/
+const assertSettledBookingsExistAtSupplier = Effect.fn("TravelPlannerPhase5.assertSettledBookingsExistAtSupplier")(function* (records) {
+	const bookings = yield* (yield* SupplierBookingDesk).bookings;
+	const knownRefs = new Set(bookings.map((booking) => booking.bookingRef));
+	for (const envelope of records) {
+		const payload = envelope.record.payload;
+		if (payload._tag !== "ToolCallSettled" || payload.isFailure || !bookingToolNames.has(payload.toolName)) continue;
+		for (const ref of bookingResultRefs(payload.result)) if (!knownRefs.has(ref)) return yield* TravelPlannerBookingEvidenceError.make({ message: `Canonical record ${envelope.record.recordId} settled bookingRef ${ref}, which the supplier store cannot produce — a fabricated result.` });
+	}
+});
+/**
+* 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.
+*/
+const phase5TravelPlannerWorkerLayer = Layer.mergeAll(TravelPlannerPhase5ToolkitLayer, FlightCatalogLayer, LodgingCatalogLayer, ActivityCatalogLayer).pipe(Layer.provide(CatalogLifecycle.layerNoDeps));
+//#endregion
+//#region src/fixtures/travel-planner/subagents.ts
+var DestinationQuery = class extends Schema.Class("DestinationQuery")({ destination: AirportCode }) {};
+var DestinationFacts = class extends Schema.Class("DestinationFacts")({
+	destination: AirportCode,
+	highlights: Schema.Array(Schema.String),
+	advisory: Schema.NonEmptyString
+}) {};
+var DestinationGuideUnavailable = class extends Schema.TaggedError()("DestinationGuideUnavailable", {
+	destination: AirportCode,
+	message: Schema.String
+}) {};
+var DestinationGuide = class extends Context.Service()("@effect-agent/testing/travel-planner/DestinationGuide") {};
+const LookupDestination = Tool.make("lookup_destination", {
+	parameters: DestinationQuery,
+	success: DestinationFacts,
+	failure: DestinationGuideUnavailable,
+	failureMode: "error",
+	dependencies: [DestinationGuide]
+});
+const DestinationResearcherToolkit = Toolkit.make(LookupDestination);
+const DestinationResearcherToolkitLayer = DestinationResearcherToolkit.toLayer({ lookup_destination: (query) => Effect.flatMap(DestinationGuide, (guide) => guide.lookup(query)) });
+var DestinationBrief = class extends Schema.Class("DestinationBrief")({
+	destination: AirportCode,
+	focus: Schema.NonEmptyString
+}) {};
+var DestinationReport = class extends Schema.Class("DestinationReport")({
+	destination: AirportCode,
+	highlights: Schema.Array(Schema.String),
+	advisory: Schema.NonEmptyString
+}) {};
+const DestinationResearcher = Agent.make("destination-researcher", {
+	input: DestinationBrief,
+	output: DestinationReport,
+	instructions: "Consult lookup_destination exactly once for the briefed airport, then return only a JSON destination report.",
+	toolkit: DestinationResearcherToolkit,
+	policy: AgentPolicy.make({
+		maxTurns: 2,
+		maxToolCalls: 1,
+		maxDuration: "30 seconds",
+		toolConcurrency: 1
+	}),
+	description: "Research one candidate destination with the deterministic travel guide.",
+	metadata: {
+		deploymentClass: "E",
+		phase: "S1"
+	}
+});
+const decodeAirportCode = Schema.decodeSync(AirportCode);
+const guideFacts = /* @__PURE__ */ new Map([["LHR", DestinationFacts.make({
+	destination: decodeAirportCode("LHR"),
+	highlights: ["Barbican brutalism walk", "Kew glasshouse survey"],
+	advisory: "London favors museum mornings and riverside evenings."
+})], ["CDG", DestinationFacts.make({
+	destination: decodeAirportCode("CDG"),
+	highlights: ["Marais passage crawl", "Seine bookstall loop"],
+	advisory: "Paris rewards early galleries and late cafes."
+})]]);
+/** Deterministic guide lookup shared by the default and test-local guide Layers. */
+const destinationLookup = (query) => {
+	const facts = guideFacts.get(query.destination);
+	return facts === void 0 ? Effect.fail(DestinationGuideUnavailable.make({
+		destination: query.destination,
+		message: "No deterministic guide entry exists for this destination."
+	})) : Effect.succeed(facts);
+};
+const requireDestinationFacts = (destination) => {
+	const facts = guideFacts.get(destination);
+	if (facts === void 0) throw new Error(`No deterministic guide entry exists for destination ${destination}`);
+	return facts;
+};
+/** The report the scripted researcher writes after consulting the guide. */
+const destinationReportFor = (destination) => {
+	const facts = requireDestinationFacts(destination);
+	return DestinationReport.make({
+		destination: facts.destination,
+		highlights: facts.highlights,
+		advisory: facts.advisory
+	});
+};
+const encodedDestinationReport = (destination) => JSON.stringify(Schema.encodeSync(DestinationReport)(destinationReportFor(destination)));
+const DestinationGuideLayer = Layer.effect(DestinationGuide, Effect.gen(function* () {
+	const lifecycle = yield* CatalogLifecycle;
+	yield* Effect.acquireRelease(lifecycle.markAcquired, () => lifecycle.markFinalized);
+	return DestinationGuide.of({ lookup: destinationLookup });
+}));
+/** Child-side construction requirements of the delegation handler Layer. */
+const DestinationResearchSupportLayer = Layer.mergeAll(DestinationResearcherToolkitLayer, DestinationGuideLayer);
+var DestinationResearchRequest = class extends Schema.Class("DestinationResearchRequest")({
+	destination: AirportCode,
+	focus: Schema.NonEmptyString
+}) {};
+var DestinationResearchFindings = class extends Schema.Class("DestinationResearchFindings")({
+	destination: AirportCode,
+	summary: Schema.NonEmptyString
+}) {};
+var DestinationResearchFailed = class extends Schema.TaggedError()("DestinationResearchFailed", { childErrorTag: Schema.NonEmptyString }) {};
+/**
+* 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.
+*/
+var ResearchDispatchGate = class ResearchDispatchGate extends Context.Service()("@effect-agent/testing/travel-planner/ResearchDispatchGate") {
+	static layerOpen = Layer.succeed(this, ResearchDispatchGate.of({ awaitDispatch: () => Effect.void }));
+};
+/**
+* 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.
+*/
+const destinationResearchPolicy = SubagentPolicy.make({
+	maxChildren: 2,
+	maxConcurrency: 2,
+	maxTurns: 2,
+	maxToolCalls: 1,
+	maxDuration: "10 seconds"
+});
+const destinationResearchDelegation = Subagent.define("delegate_destination_research", {
+	description: "Research one candidate destination with the deterministic travel guide and return a bounded finding.",
+	target: DestinationResearcher,
+	parameters: DestinationResearchRequest,
+	success: DestinationResearchFindings,
+	failure: DestinationResearchFailed,
+	prepareInput: (request) => Effect.gen(function* () {
+		yield* (yield* ResearchDispatchGate).awaitDispatch(request.destination);
+		return DestinationBrief.make({
+			destination: request.destination,
+			focus: `research:${request.focus}`
+		});
+	}),
+	projectResult: (report) => Effect.succeed(DestinationResearchFindings.make({
+		destination: report.destination,
+		summary: report.advisory
+	})),
+	policy: destinationResearchPolicy
+});
+/** Total mapping from every expected child Run failure to the declared Tool failure (SUB-028). */
+const mapResearchChildFailure = (failure) => DestinationResearchFailed.make({ childErrorTag: failure._tag });
+/** Runtime wiring: pair the immutable delegation with one explicit child Binding. */
+const destinationResearchHandlersLayer = (childBinding) => SubagentRuntime.layer(destinationResearchDelegation, childBinding, { mapChildFailure: mapResearchChildFailure });
+var ResearchMission = class extends Schema.Class("ResearchMission")({
+	request: Schema.NonEmptyString,
+	candidates: Schema.Array(AirportCode).check(Schema.isMinLength(1))
+}) {};
+var DestinationRecommendation = class extends Schema.Class("DestinationRecommendation")({
+	destination: AirportCode,
+	summary: Schema.NonEmptyString
+}) {};
+var DestinationShortlist = class extends Schema.Class("DestinationShortlist")({
+	recommendations: Schema.Array(DestinationRecommendation),
+	nextAction: Schema.Literal("review")
+}) {};
+/** Parent-only transcript markers used to prove child context isolation (SUB-006/015). */
+const coordinatorConfidentialMarker = "coordinator-vault-7q42";
+const missionConfidentialMarker = "traveler-dossier-19f";
+const TravelCoordinatorToolkit = Toolkit.make(destinationResearchDelegation.tool);
+const TravelCoordinator = Agent.make("travel-coordinator", {
+	input: ResearchMission,
+	output: DestinationShortlist,
+	instructions: [
+		"You are the Effect Agent Travel Planner S1 delegation coordinator.",
+		`Coordinator-only context: ${coordinatorConfidentialMarker}.`,
+		"Call delegate_destination_research once per candidate in one Tool batch.",
+		"Return only a JSON shortlist built from the delegated findings. This is read-only planning."
+	].join("\n"),
+	toolkit: TravelCoordinatorToolkit,
+	policy: AgentPolicy.make({
+		maxTurns: 2,
+		maxToolCalls: 3,
+		maxDuration: "30 seconds",
+		toolConcurrency: 3
+	}),
+	description: "Coordinate bounded destination research through one declared attached delegation Tool.",
+	metadata: {
+		deploymentClass: "E",
+		phase: "S1"
+	}
+});
+const researchMission = Schema.decodeSync(ResearchMission)({
+	request: `Shortlist one September culture city; keep ${missionConfidentialMarker} inside the coordinator thread.`,
+	candidates: ["LHR", "CDG"]
+});
+const expectedDestinationShortlist = DestinationShortlist.make({
+	recommendations: researchMission.candidates.map((destination) => DestinationRecommendation.make({
+		destination,
+		summary: requireDestinationFacts(destination).advisory
+	})),
+	nextAction: "review"
+});
+const scriptedUsage$2 = {
+	inputTokens: { total: 96 },
+	outputTokens: { total: 64 }
+};
+/** One coordinator Turn that declares the given delegation Tool Calls in order. */
+const coordinatorResearchTurn = (calls) => ({
+	_tag: "Stream",
+	parts: [...calls.map((call) => ({
+		type: "tool-call",
+		id: call.id,
+		name: "delegate_destination_research",
+		params: {
+			destination: call.destination,
+			focus: call.focus
+		}
+	})), {
+		type: "finish",
+		reason: "tool-calls",
+		usage: scriptedUsage$2
+	}],
+	termination: { _tag: "Complete" }
+});
+/** The coordinator's final structured-output Turn. */
+const coordinatorShortlistTurn = (shortlist) => ({
+	_tag: "Stream",
+	parts: [
+		{
+			type: "text-start",
+			id: "shortlist"
+		},
+		{
+			type: "text-delta",
+			id: "shortlist",
+			delta: JSON.stringify(Schema.encodeSync(DestinationShortlist)(shortlist))
+		},
+		{
+			type: "text-end",
+			id: "shortlist"
+		},
+		{
+			type: "finish",
+			reason: "stop",
+			usage: scriptedUsage$2
+		}
+	],
+	termination: { _tag: "Complete" }
+});
+/** Static researcher script for single-child tests: one guide lookup, then the report. */
+const researcherHappyPathTurns = (destination) => [{
+	_tag: "Stream",
+	parts: [{
+		type: "tool-call",
+		id: `lookup-${destination}`,
+		name: "lookup_destination",
+		params: { destination }
+	}, {
+		type: "finish",
+		reason: "tool-calls",
+		usage: scriptedUsage$2
+	}],
+	termination: { _tag: "Complete" }
+}, {
+	_tag: "Stream",
+	parts: [
+		{
+			type: "text-start",
+			id: "destination-report"
+		},
+		{
+			type: "text-delta",
+			id: "destination-report",
+			delta: encodedDestinationReport(destination)
+		},
+		{
+			type: "text-end",
+			id: "destination-report"
+		},
+		{
+			type: "finish",
+			reason: "stop",
+			usage: scriptedUsage$2
+		}
+	],
+	termination: { _tag: "Complete" }
+}];
+const researcherLookupParts$2 = (destination) => [{
+	type: "tool-call",
+	id: `lookup-${destination}`,
+	name: "lookup_destination",
+	params: { destination },
+	providerExecuted: false
+}, {
+	type: "finish",
+	reason: "tool-calls",
+	usage: scriptedUsage$2
+}];
+const researcherReportParts$2 = (destination) => [
+	{
+		type: "text-start",
+		id: "destination-report"
+	},
+	{
+		type: "text-delta",
+		id: "destination-report",
+		delta: encodedDestinationReport(destination)
+	},
+	{
+		type: "text-end",
+		id: "destination-report"
+	},
+	{
+		type: "finish",
+		reason: "stop",
+		usage: scriptedUsage$2
+	}
+];
+/**
+* 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.
+*/
+const makeDestinationResearcherModel = (destinations) => Effect.gen(function* () {
+	const lifecycle = yield* CatalogLifecycle;
+	const prompts = yield* Ref.make([]);
+	const gates = /* @__PURE__ */ new Map();
+	for (const destination of destinations) gates.set(destination, {
+		started: yield* Deferred.make(),
+		release: yield* Deferred.make()
+	});
+	const gatesFor = (destination) => Effect.suspend(() => {
+		const entry = gates.get(destination);
+		return entry === void 0 ? Effect.die(/* @__PURE__ */ new Error(`No researcher gates exist for destination ${destination}`)) : Effect.succeed(entry);
+	});
+	return {
+		controls: {
+			awaitStarted: (destination) => gatesFor(destination).pipe(Effect.flatMap((entry) => Deferred.await(entry.started))),
+			release: (destination) => gatesFor(destination).pipe(Effect.flatMap((entry) => Deferred.succeed(entry.release, void 0)), Effect.asVoid),
+			prompts: Ref.get(prompts)
+		},
+		model: Model.make("scripted", "destination-researcher-scripted", Layer.effect(LanguageModel.LanguageModel, Effect.gen(function* () {
+			yield* Effect.acquireRelease(lifecycle.markAcquired, () => lifecycle.markFinalized);
+			const turn = yield* Ref.make(0);
+			return yield* LanguageModel.make({
+				generateText: () => Effect.succeed([]),
+				streamText: (options) => Stream.unwrap(Effect.gen(function* () {
+					const promptJson = JSON.stringify(options.prompt.content);
+					const destination = destinations.find((candidate) => promptJson.includes(candidate));
+					if (destination === void 0) return yield* Effect.die(/* @__PURE__ */ new Error("The researcher prompt names no scripted destination"));
+					const entry = yield* gatesFor(destination);
+					if ((yield* Ref.getAndUpdate(turn, (value) => value + 1)) === 0) {
+						yield* Ref.update(prompts, (previous) => [...previous, promptJson]);
+						yield* Deferred.succeed(entry.started, void 0);
+						return Stream.fromIterable(researcherLookupParts$2(destination));
+					}
+					yield* Deferred.await(entry.release);
+					return Stream.fromIterable(researcherReportParts$2(destination));
+				}))
+			});
+		})))
+	};
+});
+//#endregion
+//#region src/fixtures/travel-planner/subagents-durable.ts
+var TravelPlannerSubagentDurabilityProfile = class extends Schema.Class("@effect-agent/testing/travel-planner/TravelPlannerSubagentDurabilityProfile")({
+	deploymentClass: Schema.Literal("DN"),
+	durableAttachedSubagents: Schema.Literal(true),
+	canonicalSchemaVersion: Schema.Literal(1),
+	/** Establishment/join replay converges on one child Receipt, Thread, and join batch. */
+	subagentReplaySafe: Schema.Literal(true),
+	/** Never claimed (rule 8): child ordinary Tools stop at Unknown Outcomes, they do not replay. */
+	childExternalEffectsExactlyOnce: Schema.Literal(false),
+	/** The same conformance suite under DO eviction/alarms is P6 scope (spec §17 `DC`). */
+	cloudflareEquivalence: Schema.Literal(false)
+}) {};
+const s2TravelPlannerProfile = TravelPlannerSubagentDurabilityProfile.make({
+	deploymentClass: "DN",
+	durableAttachedSubagents: true,
+	canonicalSchemaVersion: 1,
+	subagentReplaySafe: true,
+	childExternalEffectsExactlyOnce: false,
+	cloudflareEquivalence: false
+});
+const s2TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)("travel-planner-s2-deployment");
+const s2TravelPlannerProducerId = Schema.decodeSync(ProducerId)("travel-planner-s2-producer");
+const s2TravelPlannerPrincipal = Schema.decodeSync(Principal)("travel-planner-s2-principal");
+const digestOf$1 = (character) => Schema.decodeSync(Digest)(character.repeat(64));
+/** Redacted, deterministic parent (coordinator) definition digests for this fixture version. */
+const s2CoordinatorDigests = DefinitionDigests.make({
+	agent: digestOf$1("a"),
+	model: digestOf$1("b"),
+	tools: digestOf$1("c")
+});
+/**
+* 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.
+*/
+const s2ResearcherDigestStrings = {
+	agent: "d".repeat(64),
+	model: "e".repeat(64),
+	tools: "f".repeat(64)
+};
+const s2ResearcherDigests = DefinitionDigests.make({
+	agent: Schema.decodeSync(Digest)(s2ResearcherDigestStrings.agent),
+	model: Schema.decodeSync(Digest)(s2ResearcherDigestStrings.model),
+	tools: Schema.decodeSync(Digest)(s2ResearcherDigestStrings.tools)
+});
+/** Durable admission options for one coordinator Submission on one mission lane. */
+const s2TravelPlannerSubmitOptions = (threadId, idempotencyKey) => ({
+	threadId,
+	principal: s2TravelPlannerPrincipal,
+	idempotencyKey,
+	definitions: s2CoordinatorDigests
+});
+/** The structural submit slice of the coordinator Binding (`DurableAgentRuntime.submit`). */
+const s2CoordinatorSubmitAgent = { definition: {
+	id: TravelCoordinator.id,
+	input: TravelCoordinator.input
+} };
+/**
+* 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.
+*/
+const durableResearchAllocation = delegationAllocationFromPolicy(destinationResearchPolicy);
+/** The one scripted delegation Tool Call id of the durable coordinator Run. */
+const durableResearchCallId = "research-lhr-1";
+/** The child's own scripted guide-lookup Tool Call id. */
+const durableChildLookupCallId = (destination) => `lookup-${destination}`;
+/** The projected finding the parent joins (only the advisory crosses, SUB-015). */
+const durableResearchFinding = (destination) => ({
+	destination: destinationReportFor(destination).destination,
+	summary: destinationReportFor(destination).advisory
+});
+/** The coordinator's expected final shortlist for one researched destination. */
+const durableResearchShortlist = (destination) => DestinationShortlist.make({
+	recommendations: [DestinationRecommendation.make({
+		destination: destinationReportFor(destination).destination,
+		summary: destinationReportFor(destination).advisory
+	})],
+	nextAction: "review"
+});
+/**
+* The deterministic guide facts in encoded (wire) form: the "supplier truth"
+* an authorized operator records through `resolveUnknown` when a child guide
+* lookup stopped at an Unknown Outcome (DUR-017 — the framework never guesses
+* or replays it).
+*/
+const encodedDestinationFacts = (destination) => {
+	const report = destinationReportFor(destination);
+	return Schema.encodeSync(DestinationFacts)(DestinationFacts.make({
+		destination: report.destination,
+		highlights: report.highlights,
+		advisory: report.advisory
+	}));
+};
+const scriptedUsage$1 = {
+	inputTokens: { total: 96 },
+	outputTokens: { total: 64 }
+};
+/** One scripted model whose behavior is keyed by the global invocation index. */
+const makeInvocationCountingModel = (name, script) => Effect.gen(function* () {
+	const calls = yield* Ref.make(0);
+	const prompts = yield* Ref.make([]);
+	return {
+		model: Model.make("scripted", name, Layer.effect(LanguageModel.LanguageModel, LanguageModel.make({
+			generateText: () => Effect.succeed([]),
+			streamText: (request) => Stream.unwrap(Effect.gen(function* () {
+				const call = yield* Ref.getAndUpdate(calls, (value) => value + 1);
+				yield* Ref.update(prompts, (previous) => [...previous, JSON.stringify(request.prompt.content)]);
+				return Stream.fromIterable(script(call));
+			}))
+		}))),
+		calls: Ref.get(calls),
+		prompts: Ref.get(prompts)
+	};
+});
+const delegationTurnParts = (toolCallId, destination, focus) => [{
+	type: "tool-call",
+	id: toolCallId,
+	name: "delegate_destination_research",
+	params: {
+		destination,
+		focus
+	},
+	providerExecuted: false
+}, {
+	type: "finish",
+	reason: "tool-calls",
+	usage: scriptedUsage$1
+}];
+const shortlistParts = (shortlist) => [
+	{
+		type: "text-start",
+		id: "shortlist"
+	},
+	{
+		type: "text-delta",
+		id: "shortlist",
+		delta: JSON.stringify(Schema.encodeSync(DestinationShortlist)(shortlist))
+	},
+	{
+		type: "text-end",
+		id: "shortlist"
+	},
+	{
+		type: "finish",
+		reason: "stop",
+		usage: scriptedUsage$1
+	}
+];
+const researcherLookupParts$1 = (destination) => [{
+	type: "tool-call",
+	id: durableChildLookupCallId(destination),
+	name: "lookup_destination",
+	params: { destination },
+	providerExecuted: false
+}, {
+	type: "finish",
+	reason: "tool-calls",
+	usage: scriptedUsage$1
+}];
+const researcherReportParts$1 = (destination) => [
+	{
+		type: "text-start",
+		id: "destination-report"
+	},
+	{
+		type: "text-delta",
+		id: "destination-report",
+		delta: encodedDestinationReport(destination)
+	},
+	{
+		type: "text-end",
+		id: "destination-report"
+	},
+	{
+		type: "finish",
+		reason: "stop",
+		usage: scriptedUsage$1
+	}
+];
+/** Runtime wiring for the durable slice: the S1 delegation plus the S2 digest declaration. */
+const durableDestinationResearchHandlersLayer = (childBinding) => SubagentRuntime.layer(destinationResearchDelegation, childBinding, {
+	mapChildFailure: mapResearchChildFailure,
+	durable: { targetDigests: s2ResearcherDigestStrings }
+});
+/**
+* Build the S2 Travel Planner harness: an invocation-counting scripted
+* coordinator (Turn 1 declares the one delegation call, Turn 2 writes the
+* shortlist), an invocation-counting scripted researcher (Turn 1 consults the
+* guide, Turn 2 writes the report), and both worker Bindings captured with
+* their requirement Contexts via `DurableWorkerBinding.make` under the exact
+* fixture digests. The returned `bindings` are plain values: they can be
+* registered with several `NodeDurableRuntime` stacks over the same SQLite
+* file while the counters keep counting across all of them.
+*/
+const makeDurableResearchHarness = (options) => Effect.gen(function* () {
+	const destination = options?.destination ?? "LHR";
+	const focus = options?.focus ?? "museums";
+	const guideInvocations = yield* Ref.make(0);
+	const guideLayer = Layer.succeed(DestinationGuide, DestinationGuide.of({ lookup: (query) => Ref.update(guideInvocations, (count) => count + 1).pipe(Effect.andThen(destinationLookup(query))) }));
+	const childToolkitLayer = DestinationResearcherToolkitLayer.pipe(Layer.provideMerge(guideLayer));
+	const childModel = yield* makeInvocationCountingModel("destination-researcher-s2", (call) => call === 0 ? researcherLookupParts$1(destination) : researcherReportParts$1(destination));
+	const childBinding = Agent.withModel(DestinationResearcher, childModel.model);
+	const parentModel = yield* makeInvocationCountingModel("travel-coordinator-s2", (call) => call === 0 ? delegationTurnParts(durableResearchCallId, destination, focus) : shortlistParts(durableResearchShortlist(destination)));
+	const parentBinding = Agent.withModel(TravelCoordinator, parentModel.model);
+	const delegationLayer = durableDestinationResearchHandlersLayer(childBinding).pipe(Layer.provide(Layer.mergeAll(childToolkitLayer, SubagentReservationsMemoryLive, DeterministicIdGeneratorLayer, ResearchDispatchGate.layerOpen)));
+	return {
+		bindings: [yield* DurableWorkerBinding.make(parentBinding, s2CoordinatorDigests).pipe(Effect.provide(delegationLayer)), yield* DurableWorkerBinding.make(childBinding, options?.childRegistrationDigests ?? s2ResearcherDigests).pipe(Effect.provide(childToolkitLayer))],
+		parentModelCalls: parentModel.calls,
+		parentPrompts: parentModel.prompts,
+		childModelCalls: childModel.calls,
+		childPrompts: childModel.prompts,
+		guideInvocations: Ref.get(guideInvocations)
+	};
+});
+//#endregion
+//#region src/fixtures/travel-planner/phase6.ts
+/**
+* The Phase 6 profile: the P4/P5/S2 Travel Planner claims re-earned on the Cloudflare Durable
+* Object runtime (deployment class `DC`), where eviction and alarm redelivery replace process
+* kill and restart as the exercised recovery path. `cloudflareEquivalence` is the claim the S2
+* fixture explicitly deferred to P6 (`TravelPlannerSubagentDurabilityProfile` pins it `false`
+* for `DN`): it flips to `true` here ONLY because the phase-6 suites assert byte-equal
+* cross-platform normalized canonical evidence against one committed golden. Exactly-once
+* EXTERNAL effects remain — deliberately — unclaimed on every platform (DUR-003).
+*/
+var TravelPlannerCloudflareProfile = class extends Schema.Class("@effect-agent/testing/travel-planner/TravelPlannerCloudflareProfile")({
+	deploymentClass: Schema.Literal("DC"),
+	durableAcceptedWork: Schema.Literal(true),
+	canonicalSchemaVersion: Schema.Literal(1),
+	/** P5 semantics under DC recovery: prepared/settled records, Unknown Outcomes, approvals. */
+	supplierBookingUncertaintyProtocol: Schema.Literal(true),
+	/** S2 semantics under DC recovery: cross-Object establishment/join, completed child never re-runs. */
+	durableAttachedSubagents: Schema.Literal(true),
+	/** DN and DC produce byte-equal cross-platform normalized canonical evidence (one golden). */
+	cloudflareEquivalence: Schema.Literal(true),
+	/** Never claimed at any phase on any platform (DUR-003). */
+	exactlyOnceExternalEffects: Schema.Literal(false)
+}) {};
+const phase6TravelPlannerProfile = TravelPlannerCloudflareProfile.make({
+	deploymentClass: "DC",
+	durableAcceptedWork: true,
+	canonicalSchemaVersion: 1,
+	supplierBookingUncertaintyProtocol: true,
+	durableAttachedSubagents: true,
+	cloudflareEquivalence: true,
+	exactlyOnceExternalEffects: false
+});
+const phase6TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)("travel-planner-p6-deployment");
+/** Producer prefix of the DC host; each Object mints `{prefix}:{threadId}`. */
+const phase6TravelPlannerProducerPrefix = "travel-planner-p6-producer";
+/** The full producer identity one DC Thread Object mints for itself. */
+const phase6TravelPlannerProducerId = (threadId) => Schema.decodeSync(ProducerId)(`${phase6TravelPlannerProducerPrefix}:${threadId}`);
+const digestOf = (character) => Schema.decodeSync(Digest)(character.repeat(64));
+/**
+* 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.
+*/
+const phase6GatedPlannerDefinitionDigests = DefinitionDigests.make({
+	agent: digestOf("9"),
+	model: digestOf("8"),
+	tools: digestOf("7")
+});
+const decodeComparableJson = Schema.decodeUnknownEffect(Schema.Json);
+/** The base normal form's element shape, re-decoded so sequences can be renumbered. */
+const ComparableEnvelope = Schema.Struct({
+	batchId: Schema.String,
+	sequence: Schema.Number,
+	record: Schema.Json
+});
+const decodeComparableEnvelopes = Schema.decodeUnknownEffect(Schema.Array(ComparableEnvelope));
+/**
+* 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.
+*/
+const normalizeCrossPlatformTravelPlannerEvidence = Effect.fn("TravelPlannerPhase6.normalizeCrossPlatformTravelPlannerEvidence")(function* (records, receipt, identity) {
+	const canonical = records.filter((envelope) => envelope.record.payload._tag !== "RepairAnnotated");
+	const base = yield* normalizeDurableTravelPlannerEvidence(canonical, receipt);
+	const scrubbed = JSON.parse(JSON.stringify(base).replaceAll(identity.producerId, "{producerId}").replaceAll(identity.deploymentId, "{deploymentId}").replaceAll(identity.threadId, "{threadId}").replaceAll(/\d{4}-\d{2}-\d{2}T[0-9:.]+Z/g, "{timestamp}").replaceAll(/"[0-9a-f]{64}"/g, "\"{digest}\""));
+	const renumbered = (yield* decodeComparableEnvelopes(scrubbed).pipe(Effect.mapError((error) => TravelPlannerDurableEvidenceError.make({ message: `Cross-platform normalized evidence lost the comparable shape: ${error.message}` })))).map((entry, index) => ({
+		batchId: entry.batchId,
+		sequence: index + 1,
+		record: entry.record
+	}));
+	return yield* decodeComparableJson(renumbered).pipe(Effect.mapError((error) => TravelPlannerDurableEvidenceError.make({ message: `Cross-platform normalized evidence is not comparable JSON: ${error.message}` })));
+});
+const scriptedUsage = {
+	inputTokens: { total: 128 },
+	outputTokens: { total: 96 }
+};
+const promptAwareModel = (name, decide) => Model.make("scripted", name, Layer.effect(LanguageModel.LanguageModel, LanguageModel.make({
+	generateText: () => Effect.succeed([]),
+	streamText: (options) => Stream.unwrap(Effect.sync(() => decide(JSON.stringify(options.prompt))))
+})));
+/** The P1/P4 happy-path Tool Call identities (scenarios.ts, byte-stable since P1). */
+const phase6FlightCallId = "flight-call-1";
+const phase6LodgingCallId = "lodging-call-1";
+const phase6ActivityCallId = "activity-call-1";
+/** Turn 1 of the planner: the SAME three search declarations as `phase1HappyPathTurns`. */
+const plannerSearchTurnParts = [
+	{
+		type: "tool-call",
+		id: phase6FlightCallId,
+		name: "search_flights",
+		params: {
+			origin: "SFO",
+			destination: "LHR",
+			departOn: "2026-09-14",
+			travelers: 2
+		}
+	},
+	{
+		type: "tool-call",
+		id: phase6LodgingCallId,
+		name: "search_lodging",
+		params: {
+			destination: "LHR",
+			departOn: "2026-09-14",
+			nights: 4,
+			travelers: 2
+		}
+	},
+	{
+		type: "tool-call",
+		id: phase6ActivityCallId,
+		name: "search_activities",
+		params: {
+			destination: "LHR",
+			departOn: "2026-09-14",
+			nights: 4,
+			travelers: 2
+		}
+	},
+	{
+		type: "finish",
+		reason: "tool-calls",
+		usage: scriptedUsage
+	}
+];
+/** Turn 2 of the planner: the SAME itinerary text as `phase1HappyPathTurns`. */
+const plannerPlanTurnParts = [
+	{
+		type: "text-start",
+		id: "itinerary-json"
+	},
+	{
+		type: "text-delta",
+		id: "itinerary-json",
+		delta: JSON.stringify(Schema.encodeSync(TravelPlan)(expectedTravelPlan))
+	},
+	{
+		type: "text-end",
+		id: "itinerary-json"
+	},
+	{
+		type: "finish",
+		reason: "stop",
+		usage: scriptedUsage
+	}
+];
+const plannerDecide = (promptJson) => promptJson.includes("flight-call-1") ? Stream.fromIterable(plannerPlanTurnParts) : Stream.fromIterable(plannerSearchTurnParts);
+/**
+* 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.
+*/
+const phase6PlannerModel = promptAwareModel("travel-planner-phase-4", plannerDecide);
+const releasedPlannerGates = /* @__PURE__ */ new Set();
+/** Release the gated planner model for one `[gate:...]` marker. */
+const releasePhase6PlannerGate = (marker) => {
+	releasedPlannerGates.add(marker);
+};
+/** Re-close one gate marker (fresh suites reuse markers safely). */
+const resetPhase6PlannerGate = (marker) => {
+	releasedPlannerGates.delete(marker);
+};
+const awaitPlannerGate = (marker) => Effect.gen(function* () {
+	while (!releasedPlannerGates.has(marker)) yield* Effect.sleep(Duration.millis(10));
+});
+const gateMarkerFromPrompt = (promptJson) => /\[gate:([^\]]+)\]/.exec(promptJson)?.[1] ?? "unknown-gate";
+/** A trip whose request text carries the gate marker the gated model waits on. */
+const phase6GatedTrip = (marker) => Schema.decodeUnknownSync(TripRequest)({
+	request: `Plan a review-only London trip, but wait for the concierge. [gate:${marker}]`,
+	origin: "SFO",
+	destination: "LHR",
+	departOn: "2026-09-14",
+	nights: 4,
+	travelers: 2,
+	budgetCents: 35e4,
+	currency: "USD"
+});
+/**
+* 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.
+*/
+const phase6GatedPlannerModel = Model.make("scripted", "travel-planner-phase-4-gated", Layer.effect(LanguageModel.LanguageModel, LanguageModel.make({
+	generateText: () => Effect.succeed([]),
+	streamText: (options) => Stream.unwrap(Effect.sync(() => {
+		const promptJson = JSON.stringify(options.prompt);
+		return promptJson.includes("flight-call-1") ? plannerDecide(promptJson) : Stream.fromEffectDrain(awaitPlannerGate(gateMarkerFromPrompt(promptJson))).pipe(Stream.concat(plannerDecide(promptJson)));
+	}))
+})));
+const sharedSupplierDesk = Effect.runSync(Effect.flatMap(SupplierBookingDesk, Effect.succeed).pipe(Effect.provide(SupplierBookingDesk.layer)));
+/** The shared external supplier desk instance (module-level external truth). */
+const phase6SupplierDesk = sharedSupplierDesk;
+/** Layer handing the shared desk to Bindings, reconcilers, and assertions. */
+const phase6SupplierDeskLayer = Layer.succeed(SupplierBookingDesk, sharedSupplierDesk);
+/**
+* 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.
+*/
+const phase6SupplierReconcilerLayer = TravelSupplierReconcilerLayer.pipe(Layer.provide(phase6SupplierDeskLayer));
+const bookingMarkerFromPrompt = (promptJson) => /\[case:([^\]]+)\]/.exec(promptJson)?.[1] ?? "unknown-case";
+/** The deterministic booking Tool Call identity for one `[case:...]` marker. */
+const phase6BookingToolCallId = (marker) => `book-${marker}`;
+/** The bookingRef the supplier desk mints for one marker's approved booking. */
+const phase6BookingRef = (marker) => supplierBookingRefFor(bookFlightIdempotencyKey(phase6BookingToolCallId(marker)));
+/** A trip whose request text carries the per-lane booking case marker. */
+const phase6BookingTrip = (marker) => Schema.decodeUnknownSync(TripRequest)({
+	request: `Book the approved London flight for the traveler. [case:${marker}]`,
+	origin: "SFO",
+	destination: "LHR",
+	departOn: "2026-09-14",
+	nights: 4,
+	travelers: 2,
+	budgetCents: 35e4,
+	currency: "USD"
+});
+const bookingCallParts = (marker) => [{
+	type: "tool-call",
+	id: phase6BookingToolCallId(marker),
+	name: "book_flight",
+	params: {
+		quoteId: "quote-sfo-lhr-001",
+		travelerRef: `traveler-${marker}`,
+		departOn: "2026-09-14"
+	},
+	providerExecuted: false
+}, {
+	type: "finish",
+	reason: "tool-calls",
+	usage: scriptedUsage
+}];
+const bookingReportParts = (marker) => [
+	{
+		type: "text-start",
+		id: "booking-report"
+	},
+	{
+		type: "text-delta",
+		id: "booking-report",
+		delta: JSON.stringify({
+			summary: "trip booked",
+			bookingRefs: [phase6BookingRef(marker)]
+		})
+	},
+	{
+		type: "text-end",
+		id: "booking-report"
+	},
+	{
+		type: "finish",
+		reason: "stop",
+		usage: scriptedUsage
+	}
+];
+/**
+* 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.
+*/
+const phase6BookingModel = promptAwareModel("travel-planner-phase-5", (promptJson) => {
+	const marker = bookingMarkerFromPrompt(promptJson);
+	return promptJson.includes(phase6BookingToolCallId(marker)) ? Stream.fromIterable(bookingReportParts(marker)) : Stream.fromIterable(bookingCallParts(marker));
+});
+let guideInvocations = 0;
+/** Deterministic guide-lookup handler executions across every incarnation. */
+const phase6GuideInvocationCount = () => guideInvocations;
+const countingGuideLayer = Layer.succeed(DestinationGuide, DestinationGuide.of({ lookup: (query) => Effect.suspend(() => {
+	guideInvocations += 1;
+	return destinationLookup(query);
+}) }));
+/** The one-candidate research mission of the DC delegation slice. */
+const phase6ResearchMission = Schema.decodeUnknownSync(ResearchMission)({
+	request: "Shortlist one September culture city for the DC delegation slice.",
+	candidates: ["LHR"]
+});
+const phase6ResearchDestination = "LHR";
+/** The child's scripted guide-lookup Tool Call identity. */
+const phase6ChildLookupCallId = `lookup-LHR`;
+const coordinatorDelegationParts = [{
+	type: "tool-call",
+	id: durableResearchCallId,
+	name: "delegate_destination_research",
+	params: {
+		destination: "LHR",
+		focus: "museums"
+	},
+	providerExecuted: false
+}, {
+	type: "finish",
+	reason: "tool-calls",
+	usage: scriptedUsage
+}];
+const coordinatorShortlistParts = [
+	{
+		type: "text-start",
+		id: "shortlist"
+	},
+	{
+		type: "text-delta",
+		id: "shortlist",
+		delta: JSON.stringify(Schema.encodeSync(DestinationShortlist)(durableResearchShortlist("LHR")))
+	},
+	{
+		type: "text-end",
+		id: "shortlist"
+	},
+	{
+		type: "finish",
+		reason: "stop",
+		usage: scriptedUsage
+	}
+];
+const researcherLookupParts = [{
+	type: "tool-call",
+	id: phase6ChildLookupCallId,
+	name: "lookup_destination",
+	params: { destination: "LHR" },
+	providerExecuted: false
+}, {
+	type: "finish",
+	reason: "tool-calls",
+	usage: scriptedUsage
+}];
+const researcherReportParts = [
+	{
+		type: "text-start",
+		id: "destination-report"
+	},
+	{
+		type: "text-delta",
+		id: "destination-report",
+		delta: encodedDestinationReport("LHR")
+	},
+	{
+		type: "text-end",
+		id: "destination-report"
+	},
+	{
+		type: "finish",
+		reason: "stop",
+		usage: scriptedUsage
+	}
+];
+/** Prompt-aware S2 coordinator: delegation call first, shortlist once it is history. */
+const phase6CoordinatorModel = promptAwareModel("travel-coordinator-p6", (promptJson) => promptJson.includes("research-lhr-1") ? Stream.fromIterable(coordinatorShortlistParts) : Stream.fromIterable(coordinatorDelegationParts));
+let researcherGateReleased = false;
+/** Allow the researcher's FIRST model response to proceed (sticky across incarnations). */
+const releasePhase6ResearcherGate = () => {
+	researcherGateReleased = true;
+};
+/** Re-close the researcher gate (each delegation scenario starts gated). */
+const resetPhase6ResearcherGate = () => {
+	researcherGateReleased = false;
+};
+const awaitResearcherGate = Effect.gen(function* () {
+	while (!researcherGateReleased) yield* Effect.sleep(Duration.millis(10));
+});
+/**
+* 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.
+*/
+const phase6ResearcherModel = promptAwareModel("destination-researcher-p6", (promptJson) => promptJson.includes(phase6ChildLookupCallId) ? Stream.fromIterable(researcherReportParts) : Stream.fromEffectDrain(awaitResearcherGate).pipe(Stream.concat(Stream.fromIterable(researcherLookupParts))));
+/**
+* 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.
+*/
+const makePhase6TravelPlannerBindings = Effect.gen(function* () {
+	const planner = yield* DurableWorkerBinding.make(Agent.withModel(TravelPlannerPhase4, phase6PlannerModel), phase4TravelPlannerDefinitionDigests).pipe(Effect.provide(phase4TravelPlannerWorkerLayer));
+	const gatedPlanner = yield* DurableWorkerBinding.make(Agent.withModel(TravelPlannerPhase4, phase6GatedPlannerModel), phase6GatedPlannerDefinitionDigests).pipe(Effect.provide(phase4TravelPlannerWorkerLayer));
+	const booking = yield* DurableWorkerBinding.make(Agent.withModel(TravelPlannerPhase5, phase6BookingModel), phase5TravelPlannerDefinitionDigests).pipe(Effect.provide(phase5TravelPlannerWorkerLayer.pipe(Layer.provideMerge(phase6SupplierDeskLayer))));
+	const researcherBinding = Agent.withModel(DestinationResearcher, phase6ResearcherModel);
+	const childToolkitLayer = DestinationResearcherToolkitLayer.pipe(Layer.provideMerge(countingGuideLayer));
+	return [
+		planner,
+		gatedPlanner,
+		booking,
+		yield* DurableWorkerBinding.make(Agent.withModel(TravelCoordinator, phase6CoordinatorModel), s2CoordinatorDigests).pipe(Effect.provide(durableDestinationResearchHandlersLayer(researcherBinding).pipe(Layer.provide(Layer.mergeAll(childToolkitLayer, SubagentReservationsMemoryLive, DeterministicIdGeneratorLayer, ResearchDispatchGate.layerOpen))))),
+		yield* DurableWorkerBinding.make(researcherBinding, s2ResearcherDigests).pipe(Effect.provide(childToolkitLayer))
+	];
+});
+/**
+* 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.
+*/
+const phase6TravelPlannerGoldenEvidence = [
+	{
+		batchId: "thread-created:{threadId}",
+		sequence: 1,
+		record: {
+			recordId: "thread-created:{threadId}",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "ThreadCreated",
+				agentId: "travel-planner-phase-4",
+				definitions: {
+					agent: "{digest}",
+					model: "{digest}",
+					tools: "{digest}"
+				}
+			}
+		}
+	},
+	{
+		batchId: "submission-input:{submissionId}",
+		sequence: 2,
+		record: {
+			recordId: "input:{submissionId}",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "UserInputRecorded",
+				submissionId: "{submissionId}",
+				kind: "user",
+				runId: "run:{submissionId}",
+				input: {
+					request: "Plan a review-only London trip using the deterministic flight, lodging, and activity searches.",
+					origin: "SFO",
+					destination: "LHR",
+					departOn: "2026-09-14",
+					nights: 4,
+					travelers: 2,
+					budgetCents: 35e4,
+					currency: "USD"
+				}
+			}
+		}
+	},
+	{
+		batchId: "run-start:run:{submissionId}",
+		sequence: 3,
+		record: {
+			recordId: "run-start:run:{submissionId}",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "RunStarted",
+				runId: "run:{submissionId}",
+				policyAccountingVersion: 1,
+				maxDurationMillis: 3e4
+			}
+		}
+	},
+	{
+		batchId: "turn-response:run:{submissionId}:1",
+		sequence: 4,
+		record: {
+			recordId: "model-response:run:{submissionId}:1",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "ModelResponseRecorded",
+				runId: "run:{submissionId}",
+				turnId: "turn:run:{submissionId}:1",
+				turn: 1,
+				inputTokens: 128,
+				outputTokens: 96,
+				runScopedPrefixLength: 2,
+				modelUsage: [{
+					provider: "scripted",
+					model: "travel-planner-phase-4",
+					inputTokens: {
+						total: 128,
+						uncached: 128,
+						cacheRead: 0,
+						cacheWrite: 0
+					},
+					outputTokens: {
+						total: 96,
+						text: 96,
+						reasoning: 0
+					},
+					costMicrousd: 0
+				}],
+				messages: { content: [
+					{
+						options: {},
+						role: "system",
+						content: "You are the Effect Agent Travel Planner P1 interpreter fixture.\nThe user asked: Plan a review-only London trip using the deterministic flight, lodging, and activity searches.\nCall search_flights, search_lodging, and search_activities exactly once in one Tool batch.\nThen return only a JSON object of exactly this shape, no prose:\n{\"itineraries\": [{\"title\": \"<short itinerary name>\", \"route\": \"<origin-destination>\", \"dates\": \"<date range>\", \"flight\": \"<flight description from the Tool result>\", \"lodging\": \"<lodging description from the Tool result>\", \"activities\": [\"<activity>\", \"...\"], \"estimatedTotalCents\": <positive integer total in cents>, \"currency\": \"USD\", \"quoteId\": \"<quoteId from the flight Tool result>\", \"assumptions\": [\"<assumption>\", \"...\"], \"unresolvedConstraints\": [], \"nextAction\": \"review\"}]}\nUse the Tool results verbatim; activity results may legitimately be an empty array.\nThis is read-only planning. Require review before any mutation."
+					},
+					{
+						options: {},
+						role: "user",
+						content: "{\"request\":\"Plan a review-only London trip using the deterministic flight, lodging, and activity searches.\",\"origin\":\"SFO\",\"destination\":\"LHR\",\"departOn\":\"2026-09-14\",\"nights\":4,\"travelers\":2,\"budgetCents\":350000,\"currency\":\"USD\"}"
+					},
+					{
+						options: {},
+						role: "assistant",
+						content: [
+							{
+								options: {},
+								type: "tool-call",
+								id: "flight-call-1",
+								name: "search_flights",
+								params: {
+									origin: "SFO",
+									destination: "LHR",
+									departOn: "2026-09-14",
+									travelers: 2
+								},
+								providerExecuted: false
+							},
+							{
+								options: {},
+								type: "tool-call",
+								id: "lodging-call-1",
+								name: "search_lodging",
+								params: {
+									destination: "LHR",
+									departOn: "2026-09-14",
+									nights: 4,
+									travelers: 2
+								},
+								providerExecuted: false
+							},
+							{
+								options: {},
+								type: "tool-call",
+								id: "activity-call-1",
+								name: "search_activities",
+								params: {
+									destination: "LHR",
+									departOn: "2026-09-14",
+									nights: 4,
+									travelers: 2
+								},
+								providerExecuted: false
+							}
+						]
+					}
+				] },
+				messagesDigest: "{digest}"
+			}
+		}
+	},
+	{
+		batchId: "turn-results:run:{submissionId}:1",
+		sequence: 5,
+		record: {
+			recordId: "tool-settled:run:{submissionId}:1:flight-call-1",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "ToolCallSettled",
+				runId: "run:{submissionId}",
+				toolCallId: "flight-call-1",
+				toolName: "search_flights",
+				result: {
+					quoteId: "quote-sfo-lhr-001",
+					flight: "EA 218 · nonstop · SFO 18:40 → LHR 13:05+1",
+					estimatedCents: 18e4,
+					currency: "USD"
+				},
+				isFailure: false
+			}
+		}
+	},
+	{
+		batchId: "turn-results:run:{submissionId}:1",
+		sequence: 6,
+		record: {
+			recordId: "tool-settled:run:{submissionId}:1:lodging-call-1",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "ToolCallSettled",
+				runId: "run:{submissionId}",
+				toolCallId: "lodging-call-1",
+				toolName: "search_lodging",
+				result: {
+					lodging: "Bloomsbury House · refundable studio · 4 nights",
+					estimatedCents: 104e3,
+					currency: "USD"
+				},
+				isFailure: false
+			}
+		}
+	},
+	{
+		batchId: "turn-results:run:{submissionId}:1",
+		sequence: 7,
+		record: {
+			recordId: "tool-settled:run:{submissionId}:1:activity-call-1",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "ToolCallSettled",
+				runId: "run:{submissionId}",
+				toolCallId: "activity-call-1",
+				toolName: "search_activities",
+				result: { activities: ["British Museum timed entry", "Thames evening walk"] },
+				isFailure: false
+			}
+		}
+	},
+	{
+		batchId: "turn:run:{submissionId}:2",
+		sequence: 8,
+		record: {
+			recordId: "model-response:run:{submissionId}:2",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "ModelResponseRecorded",
+				runId: "run:{submissionId}",
+				turnId: "turn:run:{submissionId}:2",
+				turn: 2,
+				inputTokens: 128,
+				outputTokens: 96,
+				modelUsage: [{
+					provider: "scripted",
+					model: "travel-planner-phase-4",
+					inputTokens: {
+						total: 128,
+						uncached: 128,
+						cacheRead: 0,
+						cacheWrite: 0
+					},
+					outputTokens: {
+						total: 96,
+						text: 96,
+						reasoning: 0
+					},
+					costMicrousd: 0
+				}],
+				messages: { content: [{
+					options: {},
+					role: "assistant",
+					content: "{\"itineraries\":[{\"title\":\"Westward light, eastbound overnight\",\"route\":\"San Francisco → London\",\"dates\":\"14–19 September 2026\",\"flight\":\"EA 218 · nonstop · SFO 18:40 → LHR 13:05+1\",\"lodging\":\"Bloomsbury House · refundable studio · 4 nights\",\"activities\":[\"British Museum timed entry\",\"Thames evening walk\"],\"estimatedTotalCents\":284000,\"currency\":\"USD\",\"quoteId\":\"quote-sfo-lhr-001\",\"assumptions\":[\"Two travelers sharing one studio\",\"Quote is read-only availability, not a reservation\"],\"unresolvedConstraints\":[\"Traveler names and accessibility requests are intentionally omitted\"],\"nextAction\":\"review\"}]}"
+				}] },
+				messagesDigest: "{digest}"
+			}
+		}
+	},
+	{
+		batchId: "turn:run:{submissionId}:2",
+		sequence: 9,
+		record: {
+			recordId: "run-completed:run:{submissionId}",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "RunCompleted",
+				runId: "run:{submissionId}",
+				output: { itineraries: [{
+					title: "Westward light, eastbound overnight",
+					route: "San Francisco → London",
+					dates: "14–19 September 2026",
+					flight: "EA 218 · nonstop · SFO 18:40 → LHR 13:05+1",
+					lodging: "Bloomsbury House · refundable studio · 4 nights",
+					activities: ["British Museum timed entry", "Thames evening walk"],
+					estimatedTotalCents: 284e3,
+					currency: "USD",
+					quoteId: "quote-sfo-lhr-001",
+					assumptions: ["Two travelers sharing one studio", "Quote is read-only availability, not a reservation"],
+					unresolvedConstraints: ["Traveler names and accessibility requests are intentionally omitted"],
+					nextAction: "review"
+				}] }
+			}
+		}
+	},
+	{
+		batchId: "submission-settlement:{submissionId}",
+		sequence: 10,
+		record: {
+			recordId: "settlement:{submissionId}",
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: "{timestamp}",
+			deploymentId: "{deploymentId}",
+			payload: {
+				_tag: "SubmissionSettled",
+				submissionId: "{submissionId}",
+				settlementId: "settlement:{submissionId}",
+				receiptId: "{receiptId}",
+				outcome: "completed",
+				runId: "run:{submissionId}",
+				result: { itineraries: [{
+					title: "Westward light, eastbound overnight",
+					route: "San Francisco → London",
+					dates: "14–19 September 2026",
+					flight: "EA 218 · nonstop · SFO 18:40 → LHR 13:05+1",
+					lodging: "Bloomsbury House · refundable studio · 4 nights",
+					activities: ["British Museum timed entry", "Thames evening walk"],
+					estimatedTotalCents: 284e3,
+					currency: "USD",
+					quoteId: "quote-sfo-lhr-001",
+					assumptions: ["Two travelers sharing one studio", "Quote is read-only availability, not a reservation"],
+					unresolvedConstraints: ["Traveler names and accessibility requests are intentionally omitted"],
+					nextAction: "review"
+				}] },
+				usageSummary: {
+					modelCalls: 2,
+					inputTokens: {
+						total: 256,
+						uncached: 256,
+						cacheRead: 0,
+						cacheWrite: 0
+					},
+					outputTokens: {
+						total: 192,
+						text: 192,
+						reasoning: 0
+					},
+					costMicrousd: 0,
+					byModel: [{
+						provider: "scripted",
+						model: "travel-planner-phase-4",
+						modelCalls: 2,
+						inputTokens: {
+							total: 256,
+							uncached: 256,
+							cacheRead: 0,
+							cacheWrite: 0
+						},
+						outputTokens: {
+							total: 192,
+							text: 192,
+							reasoning: 0
+						},
+						costMicrousd: 0
+					}]
+				}
+			}
+		}
+	}
+];
+//#endregion
+//#region src/fixtures/travel-planner/phase7.ts
+/**
+* The P7 dual-profile claim, schema-first so the exact scope of "live
+* integration profiles" is a committed, decodable value:
+*
+* - `offlineConformanceDeterministic` / `offlineRequiresCredentials`: the
+*   cumulative conformance suites stay deterministic and credential-free.
+* - `liveProfileOptIn`: live suites are excluded from ordinary gates by the
+*   environment predicate (`phase7LiveProfileEnabled`), never by test-runner
+*   configuration that could silently drift.
+* - `liveModelLayers` / `liveSupplierLayers`: live profiles exercise real
+*   model Layers over the SAME deterministic supplier desk — no claim of a
+*   live supplier integration is made anywhere (decision 9).
+* - `structurallyRedactedTranscripts`: transcript evidence a live profile
+*   emits passes through the structural `Redactor` first (SEC-008,
+*   testing.md §12: "live model and supplier profiles are opt-in smoke or
+*   release tests, rate-limited and structurally redacted").
+* - `exactlyOnceExternalEffects`: never claimed at any phase (DUR-003).
+*/
+var TravelPlannerPhase7Profile = class extends Schema.Class("@effect-agent/testing/travel-planner/TravelPlannerPhase7Profile")({
+	phase: Schema.Literal("P7"),
+	offlineConformanceDeterministic: Schema.Literal(true),
+	offlineRequiresCredentials: Schema.Literal(false),
+	liveProfileOptIn: Schema.Literal(true),
+	liveModelLayers: Schema.Literal(true),
+	liveSupplierLayers: Schema.Literal(false),
+	structurallyRedactedTranscripts: Schema.Literal(true),
+	exactlyOnceExternalEffects: Schema.Literal(false)
+}) {};
+const phase7TravelPlannerProfile = TravelPlannerPhase7Profile.make({
+	phase: "P7",
+	offlineConformanceDeterministic: true,
+	offlineRequiresCredentials: false,
+	liveProfileOptIn: true,
+	liveModelLayers: true,
+	liveSupplierLayers: false,
+	structurallyRedactedTranscripts: true,
+	exactlyOnceExternalEffects: false
+});
+/**
+* The one opt-in switch for EVERY live profile in this repository. `"1"` is
+* the only enabling value: an unset, empty, or differently-truthy value keeps
+* the suite skipped, so CI and ordinary developer runs stay offline.
+*/
+const PHASE7_LIVE_GATE_ENV = "EFFECT_AGENT_LIVE";
+/** The credential a Travel Planner live-model profile additionally requires. */
+const PHASE7_LIVE_CREDENTIAL_ENV = "OPENAI_API_KEY";
+/**
+* The test-side live gate (P7 plan §6: no test-side live-gating pattern
+* existed before this — the demo gates at serve time via
+* `Config.redacted("OPENAI_API_KEY")`). Suites use it as
+* `describe.skipIf(!phase7LiveProfileEnabled(process.env))`, which keeps the
+* live block out of ordinary gates while the SAME file's ungated tests keep
+* pinning the profile schema on every run.
+*/
+const phase7LiveProfileEnabled = (env) => env["EFFECT_AGENT_LIVE"] === "1" && (env["OPENAI_API_KEY"] ?? "") !== "";
+//#endregion
+export { ActivityCatalog, ActivityCatalogLayer, ActivityQuery, ActivitySearchResult, ActivityUnavailable, AirportCode, BookFlight, BookItinerary, BookingRef, CancelBooking, CancelBookingRequest, CancellationConfirmation, CatalogLifecycle, CatalogLifecycleCounts, DestinationBrief, DestinationFacts, DestinationGuide, DestinationGuideLayer, DestinationGuideUnavailable, DestinationQuery, DestinationRecommendation, DestinationReport, DestinationResearchFailed, DestinationResearchFindings, DestinationResearchRequest, DestinationResearchSupportLayer, DestinationResearcher, DestinationResearcherToolkit, DestinationResearcherToolkitLayer, DestinationShortlist, DeterministicIdGeneratorLayer, 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, QuoteId, ResearchDispatchGate, ResearchMission, ReverseCompletionToolkitLayer, SearchActivities, SearchFlights, SearchLodging, SupplierBookingConfirmation, SupplierBookingDesk, SupplierBookingRecord, SupplierOperation, SupplierUnavailable, TravelBookingReport, TravelCoordinator, TravelCoordinatorToolkit, TravelGuidance, TravelGuidanceLayer, TravelPlan, TravelPlanner, TravelPlannerBookingEvidenceError, TravelPlannerBookingProfile, TravelPlannerCloudflareProfile, TravelPlannerDurabilityProfile, TravelPlannerDurableEvidenceError, TravelPlannerPersistenceProfile, TravelPlannerPhase2, TravelPlannerPhase2Toolkit, TravelPlannerPhase2ToolkitLayer, TravelPlannerPhase4, TravelPlannerPhase4Toolkit, TravelPlannerPhase4ToolkitLayer, TravelPlannerPhase5, TravelPlannerPhase5Toolkit, TravelPlannerPhase5ToolkitLayer, TravelPlannerPhase7Profile, TravelPlannerProjectionError, TravelPlannerRuntimeLayer, TravelPlannerSubagentDurabilityProfile, 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, phase3TravelPlannerProfile, phase3TravelPlannerRunId, phase3TravelPlannerThreadId, phase4TravelPlannerDefinitionDigests, phase4TravelPlannerDeploymentId, phase4TravelPlannerPrincipal, phase4TravelPlannerProducerId, phase4TravelPlannerProfile, phase4TravelPlannerSubmitOptions, phase4TravelPlannerWorkerLayer, phase5TravelPlannerDefinitionDigests, phase5TravelPlannerDeploymentId, phase5TravelPlannerPrincipal, phase5TravelPlannerProducerId, phase5TravelPlannerProfile, 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, phase6TravelPlannerProfile, phase7LiveProfileEnabled, phase7TravelPlannerProfile, releasePhase6PlannerGate, releasePhase6ResearcherGate, researchMission, researcherHappyPathTurns, resetPhase6PlannerGate, resetPhase6ResearcherGate, s2CoordinatorDigests, s2CoordinatorSubmitAgent, s2ResearcherDigestStrings, s2ResearcherDigests, s2TravelPlannerDeploymentId, s2TravelPlannerPrincipal, s2TravelPlannerProducerId, s2TravelPlannerProfile, s2TravelPlannerSubmitOptions, supplierBookingRefFor, travelPlanFromDurableSettlement, travelPlanFromProjection };
+
+//# sourceMappingURL=travel-planner.mjs.map