@effect-agent/testing 0.1.0-beta.8 → 0.1.0-beta.80

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

@@ -1,16 +1,15 @@
-import { SubagentReservationsMemoryLive } from "@effect-agent/capabilities";
-import { Agent } from "@effect-agent/core";
+import { SubagentReservationsMemoryLive } from "@effect-agent/capabilities/SubagentReservations";
+import * as Agent from "@effect-agent/core/Agent";
+import { DurableWorkerBinding, type ResolvedBinding } from "@effect-agent/thread/AgentRegistration";
+import { type Receipt } from "@effect-agent/thread/DurableAgentRuntime";
 import {
   DefinitionDigests,
   DeploymentId,
   Digest,
-  DurableWorkerBinding,
   ProducerId,
   type CanonicalRecordEnvelope,
-  type Receipt,
-  type ResolvedBinding,
-  type ToolReconciler,
-} from "@effect-agent/session";
+} from "@effect-agent/thread/Records";
+import { type ToolReconciler } from "@effect-agent/thread/ToolReconciler";
 import { Duration, Effect, Layer, Schema, Stream } from "effect";
 import { LanguageModel, Model, type Response } from "effect/unstable/ai";
 
@@ -54,58 +53,17 @@ import {
   encodedDestinationReport,
 } from "./subagents.ts";
 
-// ---------------------------------------------------------------------------
-// Phase 6 (P6): the SAME cumulative Travel Planner on the Cloudflare Durable
-// Object runtime, deployment class DC. This module is deliberately
-// platform-neutral (it imports no Cloudflare types): the worker Bindings it
-// builds are plain `ResolvedBinding` values a Conversation Object registers,
-// and the cross-platform evidence normal form is shared by the DN and DC
-// halves of the equivalence suite (plan §1.8, D-P6-6).
-// ---------------------------------------------------------------------------
-
-/**
- * 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).
- */
-export class TravelPlannerCloudflareProfile extends Schema.Class<TravelPlannerCloudflareProfile>(
-  "@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),
-}) {}
-
-export const phase6TravelPlannerProfile = TravelPlannerCloudflareProfile.make({
-  deploymentClass: "DC",
-  durableAcceptedWork: true,
-  canonicalSchemaVersion: 1,
-  supplierBookingUncertaintyProtocol: true,
-  durableAttachedSubagents: true,
-  cloudflareEquivalence: true,
-  exactlyOnceExternalEffects: false,
-});
-
+/** Platform-neutral bindings and canonical evidence shared by Node and Cloudflare tests. */
 export const phase6TravelPlannerDeploymentId = Schema.decodeSync(DeploymentId)(
   "travel-planner-p6-deployment",
 );
-/** Producer prefix of the DC host; each Object mints `{prefix}:{conversationId}`. */
+
+/** Producer prefix of the DC host; each Object mints `{prefix}:{threadId}`. */
 export const phase6TravelPlannerProducerPrefix = "travel-planner-p6-producer";
-/** The full producer identity one DC Conversation Object mints for itself. */
-export const phase6TravelPlannerProducerId = (conversationId: string): ProducerId =>
-  Schema.decodeSync(ProducerId)(`${phase6TravelPlannerProducerPrefix}:${conversationId}`);
+
+/** The full producer identity one DC Thread Object mints for itself. */
+export const phase6TravelPlannerProducerId = (threadId: string): ProducerId =>
+  Schema.decodeSync(ProducerId)(`${phase6TravelPlannerProducerPrefix}:${threadId}`);
 
 const digestOf = (character: string) => Schema.decodeSync(Digest)(character.repeat(64));
 
@@ -127,11 +85,11 @@ export const phase6GatedPlannerDefinitionDigests = DefinitionDigests.make({
 
 /** The run-specific identities the cross-platform normal form scrubs. */
 export interface CrossPlatformEvidenceIdentity {
-  /** The Conversation lane the evidence came from. */
-  readonly conversationId: string;
+  /** The Thread lane the evidence came from. */
+  readonly threadId: string;
   /** The host's deployment identity (`DeploymentId` on every record envelope). */
   readonly deploymentId: string;
-  /** The full producer identity of the run (DN: configured; DC: `{prefix}:{conversationId}`). */
+  /** The full producer identity of the run (DN: configured; DC: `{prefix}:{threadId}`). */
   readonly producerId: string;
 }
 
@@ -143,12 +101,13 @@ const ComparableEnvelope = Schema.Struct({
   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}:{conversationId}` Submission identities and everything derived
+ * 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:
  *
@@ -158,7 +117,7 @@ const decodeComparableEnvelopes = Schema.decodeUnknownEffect(Schema.Array(Compar
  *   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 Conversation identity (DC lanes mint unique names per test run);
+ * - 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
@@ -180,15 +139,18 @@ export const normalizeCrossPlatformTravelPlannerEvidence = Effect.fn(
   const canonical = records.filter(
     (envelope) => envelope.record.payload._tag !== "RepairAnnotated",
   );
+
   const base = yield* normalizeDurableTravelPlannerEvidence(canonical, receipt);
+
   const scrubbed: unknown = JSON.parse(
     JSON.stringify(base)
       .replaceAll(identity.producerId, "{producerId}")
       .replaceAll(identity.deploymentId, "{deploymentId}")
-      .replaceAll(identity.conversationId, "{conversationId}")
+      .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 comparable = yield* decodeComparableEnvelopes(scrubbed).pipe(
     Effect.mapError((error) =>
       TravelPlannerDurableEvidenceError.make({
@@ -196,11 +158,13 @@ export const normalizeCrossPlatformTravelPlannerEvidence = Effect.fn(
       }),
     ),
   );
+
   const renumbered = comparable.map((entry, index) => ({
     batchId: entry.batchId,
     sequence: index + 1,
     record: entry.record,
   }));
+
   return yield* decodeComparableJson(renumbered).pipe(
     Effect.mapError((error) =>
       TravelPlannerDurableEvidenceError.make({
@@ -291,7 +255,7 @@ export const phase6PlannerModel = promptAwareModel("travel-planner-phase-4", pla
 // ---------------------------------------------------------------------------
 // Deterministic test gate for the admission-limits rows. Module state is
 // intentionally NOT durable: it plays the external world's role (a slow
-// upstream model), never Conversation state.
+// upstream model), never Thread state.
 // ---------------------------------------------------------------------------
 
 const releasedPlannerGates = new Set<string>();
@@ -345,6 +309,7 @@ export const phase6GatedPlannerModel = Model.make(
         Stream.unwrap(
           Effect.sync(() => {
             const promptJson = JSON.stringify(options.prompt);
+
             return promptJson.includes(phase6FlightCallId)
               ? plannerDecide(promptJson)
               : Stream.fromEffectDrain(awaitPlannerGate(gateMarkerFromPrompt(promptJson))).pipe(
@@ -381,7 +346,7 @@ export const phase6SupplierDeskLayer: Layer.Layer<SupplierBookingDesk> = Layer.s
 
 /**
  * The REAL P5 supplier reconciliation policy over the shared desk, closed to no requirements
- * so a Conversation Object can install it directly: `book_flight` recovers only from supplier
+ * 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.
  */
@@ -448,6 +413,7 @@ const bookingReportParts = (marker: string): ReadonlyArray<Response.StreamPartEn
  */
 export 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));
@@ -471,6 +437,7 @@ const countingGuideLayer = Layer.succeed(
     lookup: (query) =>
       Effect.suspend(() => {
         guideInvocations += 1;
+
         return destinationLookup(query);
       }),
   }),
@@ -576,14 +543,14 @@ export const phase6ResearcherModel = promptAwareModel("destination-researcher-p6
 );
 
 // ---------------------------------------------------------------------------
-// Worker Binding registrations for the DC Conversation Object
+// Worker Binding registrations for the DC Thread Object
 // ---------------------------------------------------------------------------
 
 /**
- * Every phase-6 Travel Planner worker Binding, captured with its requirement Contexts
- * (spec/subagents.md §11): the P4 planner and its gated twin, the P5 booking agent over the
+ * 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 Conversation Object registers these via its `bindings` option; the
+ * 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.
  */
@@ -609,6 +576,7 @@ export const makePhase6TravelPlannerBindings: Effect.Effect<ReadonlyArray<Resolv
     );
 
     const researcherBinding = Agent.withModel(DestinationResearcher, phase6ResearcherModel);
+
     const childToolkitLayer = DestinationResearcherToolkitLayer.pipe(
       Layer.provideMerge(countingGuideLayer),
     );
@@ -656,16 +624,16 @@ export const makePhase6TravelPlannerBindings: Effect.Effect<ReadonlyArray<Resolv
  */
 export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   {
-    batchId: "conversation-created:{conversationId}",
+    batchId: "thread-created:{threadId}",
     sequence: 1,
     record: {
-      recordId: "conversation-created:{conversationId}",
-      family: "conversation",
+      recordId: "thread-created:{threadId}",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
       payload: {
-        _tag: "ConversationCreated",
+        _tag: "ThreadCreated",
         agentId: "travel-planner-phase-4",
         definitions: {
           agent: "{digest}",
@@ -680,7 +648,7 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
     sequence: 2,
     record: {
       recordId: "input:{submissionId}",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -704,11 +672,28 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
     },
   },
   {
-    batchId: "turn-response:run:{submissionId}:1",
+    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: 30_000,
+      },
+    },
+  },
+  {
+    batchId: "turn-response:run:{submissionId}:1",
+    sequence: 4,
     record: {
       recordId: "model-response:run:{submissionId}:1",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -719,6 +704,28 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
         turn: 1,
         inputTokens: 128,
         outputTokens: 96,
+        runScopedPrefixLength: 2,
+        modelUsage: [
+          {
+            provider: "scripted",
+            model: "travel-planner-phase-4",
+            purpose: "turn",
+            usageStatus: "partial",
+            pricingStatus: "unknown",
+            inputTokens: {
+              total: 128,
+              uncached: 128,
+              cacheRead: 0,
+              cacheWrite: 0,
+            },
+            outputTokens: {
+              total: 96,
+              text: 96,
+              reasoning: 0,
+            },
+            costMicrousd: 0,
+          },
+        ],
         messages: {
           content: [
             {
@@ -786,10 +793,10 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   },
   {
     batchId: "turn-results:run:{submissionId}:1",
-    sequence: 4,
+    sequence: 5,
     record: {
       recordId: "tool-settled:run:{submissionId}:1:flight-call-1",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -810,10 +817,10 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   },
   {
     batchId: "turn-results:run:{submissionId}:1",
-    sequence: 5,
+    sequence: 6,
     record: {
       recordId: "tool-settled:run:{submissionId}:1:lodging-call-1",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -833,10 +840,10 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   },
   {
     batchId: "turn-results:run:{submissionId}:1",
-    sequence: 6,
+    sequence: 7,
     record: {
       recordId: "tool-settled:run:{submissionId}:1:activity-call-1",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -854,10 +861,10 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
   },
   {
     batchId: "turn:run:{submissionId}:2",
-    sequence: 7,
+    sequence: 8,
     record: {
       recordId: "model-response:run:{submissionId}:2",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -868,6 +875,27 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
         turn: 2,
         inputTokens: 128,
         outputTokens: 96,
+        modelUsage: [
+          {
+            provider: "scripted",
+            model: "travel-planner-phase-4",
+            purpose: "turn",
+            usageStatus: "partial",
+            pricingStatus: "unknown",
+            inputTokens: {
+              total: 128,
+              uncached: 128,
+              cacheRead: 0,
+              cacheWrite: 0,
+            },
+            outputTokens: {
+              total: 96,
+              text: 96,
+              reasoning: 0,
+            },
+            costMicrousd: 0,
+          },
+        ],
         messages: {
           content: [
             {
@@ -882,12 +910,50 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
       },
     },
   },
+  {
+    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: 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",
+            },
+          ],
+        },
+      },
+    },
+  },
   {
     batchId: "submission-settlement:{submissionId}",
-    sequence: 8,
+    sequence: 10,
     record: {
       recordId: "settlement:{submissionId}",
-      family: "conversation",
+      family: "thread",
       schemaVersion: 1,
       createdAt: "{timestamp}",
       deploymentId: "{deploymentId}",
@@ -921,6 +987,43 @@ export const phase6TravelPlannerGoldenEvidence: Schema.Json = [
             },
           ],
         },
+        usageSummary: {
+          usageStatus: "partial",
+          pricingStatus: "unknown",
+          unobservedModelCalls: 0,
+          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,
+            },
+          ],
+        },
       },
     },
   },

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

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

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

@@ -1,9 +1,10 @@
 import { Schema } from "effect";
 
-import type { ScriptedTurnInput } from "../../scripted-model.ts";
+import type { ScriptedTurnInput } from "../../ScriptedModel.ts";
 import { TravelPlan, TripRequest, type TravelPlan as TravelPlanValue } from "./definition.ts";
 
 const usage = { inputTokens: { total: 128 }, outputTokens: { total: 96 } };
+
 export const phase1Trip = Schema.decodeSync(TripRequest)({
   request:
     "Plan a review-only London trip using the deterministic flight, lodging, and activity searches.",
@@ -15,8 +16,7 @@ export const phase1Trip = Schema.decodeSync(TripRequest)({
   budgetCents: 350_000,
   currency: "USD",
 });
-/** Backward-compatible fixture alias while consumers transition to the P1 name. */
-export const phase0Trip = phase1Trip;
+
 export const expectedTravelPlan: TravelPlanValue = Schema.decodeSync(TravelPlan)({
   itineraries: [
     {
@@ -82,4 +82,3 @@ export const phase1HappyPathTurns = [
     termination: { _tag: "Complete" },
   },
 ] satisfies readonly [ScriptedTurnInput, ScriptedTurnInput];
-export const phase0HappyPathTurns = phase1HappyPathTurns;