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

package/src/chaos.ts

@@ -7,7 +7,7 @@ import {
 import {
   Agent,
   AgentPolicy,
-  ConversationId,
+  ThreadId,
   IdGenerator,
   RunId,
   ToolCallId,
@@ -17,17 +17,15 @@ import {
 import { DurableStep, DurableStepError, ToolExecutionClass } from "@effect-agent/engine";
 import {
   AbortCommand,
-  AgentBindingResolver,
   ApprovalDecisionCommand,
-  ConversationExportRequest,
-  ConversationStore,
+  ThreadExportRequest,
+  ThreadStore,
   DefinitionDigests,
   Digest,
   DurableAgentRuntime,
   DurableRuntimeConfig,
   DurableRuntimeFailpointError,
   DurableRuntimeFailpointLocation,
-  DurableRuntimeFailpointTestControl,
   DurableWorkerBinding,
   IdempotencyKey,
   ObligationThresholds,
@@ -38,8 +36,8 @@ import {
   SubmissionLedger,
   SubmissionLookupById,
   UnknownResolutionCommand,
-  childConversationIdFor,
-  verifyConversationInvariants,
+  childThreadIdFor,
+  verifyThreadInvariants,
   type CanonicalRecordEnvelope,
   type BatchId,
   type DurableBindingFailure,
@@ -51,7 +49,8 @@ import {
   type Settlement,
   type SubmissionSnapshot,
   type UnknownResolution,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
+import { DurableRuntimeFailpointTestControl } from "@effect-agent/thread/testing";
 import { Cause, Effect, Exit, Layer, Option, Ref, Schema, Stream } from "effect";
 import { FastCheck } from "effect/testing";
 import {
@@ -69,7 +68,7 @@ import {
  * deterministic runner that drives the durable coordinator over whatever adapter pair the test
  * provides. Every plan ends in the SAME claims the crash matrices make:
  *
- * 1. `verifyConversationInvariants` in convergence mode over every touched Conversation (the
+ * 1. `verifyThreadInvariants` in convergence mode over every touched Thread (the
  *    shared WP1 checker — one set of claims for admin verify, certification, chaos, and soak);
  * 2. `scanObligations` returning ZERO entries (everything settled; nothing invisibly stuck);
  * 3. supplier non-fabrication wherever the deterministic desk was in play (durability §10: no
@@ -152,10 +151,10 @@ export class ChaosPlan extends Schema.Class<ChaosPlan>("@effect-agent/testing/Ch
 export class ChaosLaneReport extends Schema.Class<ChaosLaneReport>(
   "@effect-agent/testing/ChaosLaneReport",
 )({
-  conversationId: ConversationId,
+  threadId: ThreadId,
   kind: ChaosScenarioKind,
   submissionCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  /** Verdict of `verifyConversationInvariants` in convergence mode. */
+  /** Verdict of `verifyThreadInvariants` in convergence mode. */
   verified: Schema.Boolean,
 }) {}
 
@@ -371,7 +370,7 @@ const policy = AgentPolicy.make({
 const PlainInput = Schema.Struct({ question: Schema.String });
 const PlainOutput = Schema.Struct({ answer: Schema.String });
 
-const plainDefinition = Agent.define("chaos-plain", {
+const plainDefinition = Agent.make("chaos-plain", {
   input: PlainInput,
   output: PlainOutput,
   instructions: "Answer as JSON.",
@@ -385,7 +384,7 @@ const BookUncertain = Tool.make("book", {
   success: Schema.Struct({ confirmation: Schema.String }),
 });
 const bookTools = Toolkit.make(BookUncertain);
-const bookDefinition = Agent.define("chaos-book", {
+const bookDefinition = Agent.make("chaos-book", {
   input: PlainInput,
   output: PlainOutput,
   instructions: "Book it.",
@@ -399,7 +398,7 @@ const BookApproval = Tool.make("book", {
   needsApproval: true,
 });
 const approvalTools = Toolkit.make(BookApproval);
-const approvalDefinition = Agent.define("chaos-approval", {
+const approvalDefinition = Agent.make("chaos-approval", {
   input: PlainInput,
   output: PlainOutput,
   instructions: "Book after approval.",
@@ -414,7 +413,7 @@ const Itinerary = Tool.make("itinerary", {
   dependencies: [DurableStep],
 }).annotate(ToolExecutionClass, "uncertain");
 const itineraryTools = Toolkit.make(Itinerary);
-const itineraryDefinition = Agent.define("chaos-itinerary", {
+const itineraryDefinition = Agent.make("chaos-itinerary", {
   input: PlainInput,
   output: PlainOutput,
   instructions: "Reserve the itinerary.",
@@ -422,7 +421,7 @@ const itineraryDefinition = Agent.define("chaos-itinerary", {
   policy,
 });
 
-const childDefinition = Agent.define("chaos-child", {
+const childDefinition = Agent.make("chaos-child", {
   input: PlainInput,
   output: PlainOutput,
   instructions: "Answer as JSON.",
@@ -457,7 +456,7 @@ const chaosDelegation = Subagent.define("delegate_chaos", {
   }),
 });
 
-const coordinatorDefinition = Agent.define("chaos-coordinator", {
+const coordinatorDefinition = Agent.make("chaos-coordinator", {
   input: Schema.Struct({ mission: Schema.String }),
   output: Schema.Struct({ report: Schema.String }),
   instructions: "Delegate, then report as JSON.",
@@ -487,7 +486,7 @@ const childLaneDigests = (lane: number): DefinitionDigests => {
 };
 
 const CHAOS_PRINCIPAL = Schema.decodeSync(Principal)("principal-chaos");
-const decodeConversationId = Schema.decodeSync(ConversationId);
+const decodeThreadId = Schema.decodeSync(ThreadId);
 const decodeIdempotencyKey = Schema.decodeSync(IdempotencyKey);
 const decodeToolCallId = Schema.decodeSync(ToolCallId);
 const decodeRunId = Schema.decodeSync(RunId);
@@ -503,7 +502,7 @@ const chaosIdentifiers = Layer.effect(
         Effect.map((value) => decode(`${prefix}-${value}`)),
       );
     return {
-      nextConversationId: next(decodeConversationId, "chaos-fixture-conversation"),
+      nextThreadId: next(decodeThreadId, "chaos-fixture-thread"),
       nextRunId: next(decodeRunId, "chaos-fixture-run"),
       nextTurnId: next(decodeTurnId, "chaos-fixture-turn"),
     };
@@ -573,7 +572,7 @@ const tolerateTyped = <A, E, R>(
 interface LaneFixture {
   readonly index: number;
   readonly kind: ChaosScenarioKind;
-  readonly conversationId: ConversationId;
+  readonly threadId: ThreadId;
   readonly ref: string;
   readonly deskInPlay: boolean;
   readonly submissionIndexes: ReadonlyArray<number>;
@@ -583,7 +582,7 @@ interface LaneFixture {
   ) => ReadonlyArray<
     Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure>
   >;
-  readonly childConversationOf: (firstReceipt: Receipt) => ConversationId | undefined;
+  readonly childThreadOf: (firstReceipt: Receipt) => ThreadId | undefined;
 }
 
 interface SubmissionState {
@@ -627,14 +626,14 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
   desk: ChaosDesk,
 ) {
   const runtime = yield* DurableAgentRuntime;
-  const conversationId = decodeConversationId(`chaos-${plan.seed}-lane-${laneIndex}`);
+  const threadId = decodeThreadId(`chaos-${plan.seed}-lane-${laneIndex}`);
   const ref = `ref-l${laneIndex}`;
   const script = scriptFor(kind, ref);
   const model = promptScriptedModel(`chaos-${kind}-${laneIndex}`, script);
   const digests = laneDigests(laneIndex);
 
   const submitOptionsFor = (flatIndex: number) => ({
-    conversationId,
+    threadId,
     principal: CHAOS_PRINCIPAL,
     idempotencyKey: decodeIdempotencyKey(`chaos-${plan.seed}-s${flatIndex}`),
     definitions: digests,
@@ -655,33 +654,28 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
   ): LaneFixture => ({
     index: laneIndex,
     kind,
-    conversationId,
+    threadId,
     ref,
     deskInPlay,
     submissionIndexes,
     submitOne,
     drives: () => [drive],
-    childConversationOf: () => undefined,
+    childThreadOf: () => undefined,
   });
 
   switch (kind) {
     case "plain":
     case "join": {
       const agent = Agent.withModel(plainDefinition, model);
-      return plainLaneFixture(
-        false,
-        runtime.processConversation(agent, conversationId),
-        (flatIndex) =>
-          runtime.submit(agent, { question: `chaos ${flatIndex}` }, submitOptionsFor(flatIndex)),
+      return plainLaneFixture(false, runtime.processThread(agent, threadId), (flatIndex) =>
+        runtime.submit(agent, { question: `chaos ${flatIndex}` }, submitOptionsFor(flatIndex)),
       );
     }
     case "uncertain-tool": {
       const agent = Agent.withModel(bookDefinition, model);
       return plainLaneFixture(
         true,
-        runtime
-          .processConversation(agent, conversationId)
-          .pipe(Effect.provide(bookToolLayerFor(bookTools))),
+        runtime.processThread(agent, threadId).pipe(Effect.provide(bookToolLayerFor(bookTools))),
         (flatIndex) =>
           runtime.submit(agent, { question: `chaos ${flatIndex}` }, submitOptionsFor(flatIndex)),
       );
@@ -691,7 +685,7 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
       return plainLaneFixture(
         true,
         runtime
-          .processConversation(agent, conversationId)
+          .processThread(agent, threadId)
           .pipe(Effect.provide(bookToolLayerFor(approvalTools))),
         (flatIndex) =>
           runtime.submit(agent, { question: `chaos ${flatIndex}` }, submitOptionsFor(flatIndex)),
@@ -718,7 +712,7 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
       });
       return plainLaneFixture(
         true,
-        runtime.processConversation(agent, conversationId).pipe(Effect.provide(toolLayer)),
+        runtime.processThread(agent, threadId).pipe(Effect.provide(toolLayer)),
         (flatIndex) =>
           runtime.submit(agent, { question: `chaos ${flatIndex}` }, submitOptionsFor(flatIndex)),
       );
@@ -741,15 +735,12 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
         childBinding,
         childLaneDigests(laneIndex),
       );
-      const resolver = AgentBindingResolver.fromBindings([parentResolved, childResolved]);
-      const driveResolved = (conversation: ConversationId) =>
-        runtime
-          .processConversationResolved(conversation)
-          .pipe(Effect.provideService(AgentBindingResolver, resolver));
+      const bindings = [parentResolved, childResolved];
+      const driveResolved = (thread: ThreadId) => runtime.processThreadResolved(thread, bindings);
       const fixture: LaneFixture = {
         index: laneIndex,
         kind,
-        conversationId,
+        threadId,
         ref,
         deskInPlay: false,
         submissionIndexes,
@@ -762,21 +753,18 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
         drives: (firstReceipt) => {
           const drives: Array<
             Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure>
-          > = [driveResolved(conversationId)];
+          > = [driveResolved(threadId)];
           if (firstReceipt !== undefined) {
             drives.push(
               driveResolved(
-                childConversationIdFor(
-                  firstReceipt.submissionId,
-                  decodeToolCallId(DELEGATE_CALL_ID),
-                ),
+                childThreadIdFor(firstReceipt.submissionId, decodeToolCallId(DELEGATE_CALL_ID)),
               ),
             );
           }
           return drives;
         },
-        childConversationOf: (firstReceipt) =>
-          childConversationIdFor(firstReceipt.submissionId, decodeToolCallId(DELEGATE_CALL_ID)),
+        childThreadOf: (firstReceipt) =>
+          childThreadIdFor(firstReceipt.submissionId, decodeToolCallId(DELEGATE_CALL_ID)),
       };
       return fixture;
     }
@@ -902,7 +890,7 @@ const submissionIdsNamedBy = (
       payload._tag === "SubmissionSettled" ||
       payload._tag === "AbortRequested"
     ) {
-      named.add(payload.submissionId);
+      if (payload.submissionId !== undefined) named.add(payload.submissionId);
     }
   }
   return named;
@@ -968,7 +956,7 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
 ) {
   const runtime = yield* DurableAgentRuntime;
   const ledger = yield* SubmissionLedger;
-  const store = yield* ConversationStore;
+  const store = yield* ThreadStore;
   const config = yield* DurableRuntimeConfig;
   const failpoints = yield* DurableRuntimeFailpointTestControl;
   const random = mulberry32(plan.seed);
@@ -1036,7 +1024,7 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
     }
 
     // Admission chaos: pending submissions retry under the active arm until a Receipt lands;
-    // the identical (conversation, principal, key) triple reattaches, never duplicates.
+    // the identical (thread, principal, key) triple reattaches, never duplicates.
     for (const state of states) {
       if (state.receipt !== undefined) continue;
       const receipt = yield* tolerateTyped(state.lane.submitOne(state.flatIndex));
@@ -1106,20 +1094,20 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
     });
   }
 
-  // Final claims: the shared invariant checker per touched Conversation, in convergence mode,
+  // Final claims: the shared invariant checker per touched Thread, in convergence mode,
   // with the full digest chain (single known producer), plus the desk non-fabrication sweep.
   const produced = yield* desk.produced;
   const laneReports: Array<ChaosLaneReport> = [];
-  const verifyConversation = Effect.fn("Chaos.verifyConversation")(function* (
-    conversationId: ConversationId,
+  const verifyThread = Effect.fn("Chaos.verifyThread")(function* (
+    threadId: ThreadId,
     kind: ChaosScenarioKind,
     deskInPlay: boolean,
   ) {
-    const exported = yield* store.export(ConversationExportRequest.make({ conversationId })).pipe(
+    const exported = yield* store.export(ThreadExportRequest.make({ threadId })).pipe(
       Effect.mapError((error) =>
         ChaosConvergenceFailure.make({
           seed: plan.seed,
-          message: `export of ${conversationId} failed: ${String(error)}`,
+          message: `export of ${threadId} failed: ${String(error)}`,
         }),
       ),
     );
@@ -1138,7 +1126,7 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
     const batchProducers = new Map<BatchId, ProducerId>(
       exported.records.map((envelope) => [envelope.batchId, config.producerId]),
     );
-    const report = yield* verifyConversationInvariants({
+    const report = yield* verifyThreadInvariants({
       export: exported,
       submissions: rows,
       batchProducers,
@@ -1151,7 +1139,7 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
         .join("; ");
       return yield* ChaosConvergenceFailure.make({
         seed: plan.seed,
-        message: `invariants failed for ${conversationId} (${kind}): ${failed}`,
+        message: `invariants failed for ${threadId} (${kind}): ${failed}`,
       });
     }
     if (deskInPlay) {
@@ -1159,7 +1147,7 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
     }
     laneReports.push(
       ChaosLaneReport.make({
-        conversationId,
+        threadId,
         kind,
         submissionCount: rows.length,
         verified: report.ok,
@@ -1168,18 +1156,18 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
   });
 
   for (const lane of lanes) {
-    yield* verifyConversation(lane.conversationId, lane.kind, lane.deskInPlay);
-    // Delegation lanes: verify every materialized child Conversation too.
+    yield* verifyThread(lane.threadId, lane.kind, lane.deskInPlay);
+    // Delegation lanes: verify every materialized child Thread too.
     for (const flatIndex of lane.submissionIndexes) {
       const receipt = states[flatIndex]?.receipt;
       if (receipt === undefined) continue;
-      const child = lane.childConversationOf(receipt);
+      const child = lane.childThreadOf(receipt);
       if (child === undefined) continue;
       const childExport = yield* Effect.exit(
-        store.export(ConversationExportRequest.make({ conversationId: child })),
+        store.export(ThreadExportRequest.make({ threadId: child })),
       );
       if (Exit.isSuccess(childExport) && childExport.value.records.length > 0) {
-        yield* verifyConversation(child, "plain", false);
+        yield* verifyThread(child, "plain", false);
       }
     }
   }

package/src/code-executor.ts

@@ -0,0 +1,3 @@
+/** CodeExecutor adapter conformance and the deterministic in-process substitute. */
+export * from "./code-executor-conformance.ts";
+export * from "./code-executor-substitute.ts";

package/src/docs-researcher.ts

@@ -0,0 +1,2 @@
+/** Shared Docs Researcher definitions and MCP delegation fixtures. */
+export * from "./fixtures/docs-researcher/index.ts";

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

@@ -73,11 +73,11 @@ export const docContentToolkitLayer = DocContentToolkit.toLayer({
 // ---------------------------------------------------------------------------
 // Deterministic corpus. Every body deliberately embeds BOTH a secret marker
 // and a distinctive body phrase: the tests assert that neither ever reaches
-// the parent Conversation, the parent prompts, or a redacted preview — only
+// the parent Thread, the parent prompts, or a redacted preview — only
 // the bounded summary crosses the delegation boundary (SUB-015, SEC-008).
 // ---------------------------------------------------------------------------
 
-/** Never allowed outside a child Conversation or an unredacted fixture value. */
+/** Never allowed outside a child Thread or an unredacted fixture value. */
 export const docsDocumentBodySecret = "docs-vault-secret-771";
 
 const decodeDocumentId = Schema.decodeSync(ResearchDocumentId);
@@ -109,7 +109,7 @@ const corpusEntries = new Map<string, CorpusEntry>(
       document: ResearchDocument.make({
         documentId: decodeDocumentId(entry.documentId),
         title: entry.title,
-        body: `${entry.bodyPhrase}: internal working notes. ${docsDocumentBodySecret}. ${entry.summary} Raw notes stay inside the child Conversation.`,
+        body: `${entry.bodyPhrase}: internal working notes. ${docsDocumentBodySecret}. ${entry.summary} Raw notes stay inside the child Thread.`,
       }),
       bodyPhrase: entry.bodyPhrase,
       summary: entry.summary,
@@ -180,7 +180,7 @@ export const documentSummaryFor = (documentId: string): DocumentSummary =>
 export const encodedDocumentSummary = (documentId: string): string =>
   JSON.stringify(Schema.encodeSync(DocumentSummary)(documentSummaryFor(documentId)));
 
-export const DocSummarizer = Agent.define("doc-summarizer", {
+export const DocSummarizer = Agent.make("doc-summarizer", {
   input: SummaryBrief,
   output: DocumentSummary,
   instructions:
@@ -200,7 +200,7 @@ export const DocSummarizer = Agent.define("doc-summarizer", {
 // Delegation Definition: the coordinator sees exactly one Tool with explicit
 // projections and finite bounds. `projectResult` is the declassification
 // boundary (SUB-015): only the bounded summary crosses; the fetched body —
-// secret marker included — stays in the child Conversation.
+// secret marker included — stays in the child Thread.
 // ---------------------------------------------------------------------------
 
 export class SummaryRequest extends Schema.Class<SummaryRequest>("SummaryRequest")({
@@ -300,7 +300,7 @@ export const docsMissionConfidentialMarker = "docs-mission-dossier-42f";
 
 export const DocsResearcherToolkit = Toolkit.make(delegateDocumentSummary.tool);
 
-export const DocsResearcher = Agent.define("docs-researcher", {
+export const DocsResearcher = Agent.make("docs-researcher", {
   input: ResearchRequest,
   output: ResearchDigest,
   instructions: [
@@ -322,7 +322,7 @@ export const DocsResearcher = Agent.define("docs-researcher", {
 
 /** The default two-document research mission. */
 export const researchMissionRequest = ResearchRequest.make({
-  question: `Summarize the durability and subagent notes; keep ${docsMissionConfidentialMarker} inside the coordinator conversation.`,
+  question: `Summarize the durability and subagent notes; keep ${docsMissionConfidentialMarker} inside the coordinator thread.`,
   documentIds: researchCorpusDocumentIds,
 });
 

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

@@ -6,7 +6,7 @@ import {
   type RedactedPreview,
   type RedactionError,
 } from "@effect-agent/capabilities";
-import { Agent, type ConversationId } from "@effect-agent/core";
+import { Agent, type ThreadId } from "@effect-agent/core";
 import {
   DefinitionDigests,
   DeploymentId,
@@ -17,7 +17,7 @@ import {
   type DurableSubmitOptions,
   type IdempotencyKey,
   type ResolvedBinding,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
 import type { Crypto } from "effect";
 import { Effect, Layer, Ref, Schema, Stream } from "effect";
 import { LanguageModel, Model, type Response } from "effect/unstable/ai";
@@ -76,10 +76,10 @@ export const docsSummarizerDigests = DefinitionDigests.make({
 
 /** Durable admission options for one docs-researcher Submission on one mission lane. */
 export const docsResearcherSubmitOptions = (
-  conversationId: ConversationId,
+  threadId: ThreadId,
   idempotencyKey: IdempotencyKey,
 ): DurableSubmitOptions => ({
-  conversationId,
+  threadId,
   principal: docsResearcherPrincipal,
   idempotencyKey,
   definitions: docsCoordinatorDigests,
@@ -298,7 +298,7 @@ const encodeResearchDocument = Schema.encodeEffect(ResearchDocument);
 /**
  * The audit-surface preview of one fetched document: the raw document —
  * secret marker and all — passes through the configured structural `Redactor`
- * before anything may quote it outside the child Conversation (SEC-008,
+ * before anything may quote it outside the child Thread (SEC-008,
  * CAP-013). Tests assert the preview keeps shape but no scalar content.
  */
 export const redactedDocumentPreview = Effect.fn("DocsResearcher.redactedDocumentPreview")(

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

@@ -7,7 +7,7 @@
 //
 // 1. MCP discovery and Agent authoring do not meet in the type system. The
 //    connector's validated Toolkit arrives as `Toolkit.Any`, while
-//    `Agent.define` needs the statically typed toolkit — so the binding
+//    `Agent.make` needs the statically typed toolkit — so the binding
 //    between "what discovery served" and "what the child was authored
 //    against" had to be re-proved by hand (`assertDiscoveryMatchesAuthoredToolkit`
 //    re-deriving `Tool.getJsonSchema` on both sides). A framework helper that

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

@@ -150,7 +150,7 @@ export const TravelPlannerToolkitLayer = TravelPlannerToolkit.toLayer({
   search_activities: (query) => Effect.flatMap(ActivityCatalog, (catalog) => catalog.search(query)),
 });
 
-export const TravelPlanner = Agent.define("travel-planner", {
+export const TravelPlanner = Agent.make("travel-planner", {
   input: TripRequest,
   output: TravelPlan,
   instructions: (input) =>

package/src/fixtures/travel-planner/deterministic-layers.ts

@@ -1,4 +1,5 @@
-import { ConversationId, IdGenerator, RunId, TurnId } from "@effect-agent/core";
+import { ThreadId, IdGenerator, RunId, TurnId } from "@effect-agent/core";
+import { ThreadHistory } from "@effect-agent/engine";
 import { Context, Deferred, Effect, Layer, Option, Ref, Schema } from "effect";
 
 import {
@@ -405,12 +406,12 @@ export const TravelGuidanceLayer = Layer.succeed(
 export const DeterministicIdGeneratorLayer = Layer.effect(
   IdGenerator,
   Effect.gen(function* () {
-    const conversation = yield* Ref.make(0);
+    const thread = yield* Ref.make(0);
     const run = yield* Ref.make(0);
     const turn = yield* Ref.make(0);
     return IdGenerator.of({
-      nextConversationId: Ref.updateAndGet(conversation, (n) => n + 1).pipe(
-        Effect.map((n) => Schema.decodeSync(ConversationId)(`conversation-${n}`)),
+      nextThreadId: Ref.updateAndGet(thread, (n) => n + 1).pipe(
+        Effect.map((n) => Schema.decodeSync(ThreadId)(`thread-${n}`)),
       ),
       nextRunId: Ref.updateAndGet(run, (n) => n + 1).pipe(
         Effect.map((n) => Schema.decodeSync(RunId)(`run-${n}`)),
@@ -422,6 +423,7 @@ export const DeterministicIdGeneratorLayer = Layer.effect(
   }),
 );
 export const TravelPlannerRuntimeLayer = Layer.mergeAll(
+  ThreadHistory.layerTransient,
   TravelPlannerToolkitLayer,
   FlightCatalogLayer,
   LodgingCatalogLayer,

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

@@ -75,7 +75,7 @@ export const TravelPlannerPhase2ToolkitLayer = TravelPlannerPhase2Toolkit.toLaye
     Effect.flatMap(ItineraryHoldGateway, (gateway) => gateway.hold(request)),
 });
 
-export const TravelPlannerPhase2 = Agent.define("travel-planner-phase-2", {
+export const TravelPlannerPhase2 = Agent.make("travel-planner-phase-2", {
   input: TripRequest,
   output: TravelPlan,
   instructions: (input) =>

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

@@ -1,23 +1,23 @@
-import { AgentId, ConversationId, RunId, SubmissionId } from "@effect-agent/core";
+import { AgentId, ThreadId, RunId, SubmissionId } from "@effect-agent/core";
 import {
   BatchId,
   CanonicalBatch,
-  ConversationCheckpoint,
-  ConversationProjection,
+  ThreadCheckpoint,
+  ThreadProjection,
   DefinitionDigests,
   DeploymentId,
   Digest,
   ProducerId,
   RecordEnvelope,
   RecordId,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
 import { Effect, Schema } from "effect";
 
 import { TravelPlan, TripRequest } from "./definition.ts";
 import { expectedTravelPlan, phase1Trip } from "./scenarios.ts";
 
 /**
- * The Phase 3 profile persists Conversation history but deliberately does not
+ * The Phase 3 profile persists Thread history but deliberately does not
  * claim durable admission or recovery of accepted work.
  */
 export class TravelPlannerPersistenceProfile extends Schema.Class<TravelPlannerPersistenceProfile>(
@@ -34,9 +34,7 @@ export const phase3TravelPlannerProfile = TravelPlannerPersistenceProfile.make({
   canonicalSchemaVersion: 1,
 });
 
-export const phase3TravelPlannerConversationId = Schema.decodeSync(ConversationId)(
-  "travel-planner-p3-conversation",
-);
+export const phase3TravelPlannerThreadId = Schema.decodeSync(ThreadId)("travel-planner-p3-thread");
 export const phase3TravelPlannerProducerId = Schema.decodeSync(ProducerId)(
   "travel-planner-p3-producer",
 );
@@ -61,7 +59,7 @@ const travelPlanOutput = Schema.encodeSync(TravelPlan)(expectedTravelPlan);
 const record = (recordId: string, createdAt: string, payload: unknown) =>
   Schema.decodeUnknownSync(RecordEnvelope)({
     recordId: Schema.decodeSync(RecordId)(recordId),
-    family: "conversation",
+    family: "thread",
     schemaVersion: 1,
     createdAt,
     deploymentId,
@@ -69,7 +67,7 @@ const record = (recordId: string, createdAt: string, payload: unknown) =>
   });
 
 /**
- * The first atomic append establishes the Conversation and records its input.
+ * The first atomic append establishes the Thread and records its input.
  * Its encoded value is the redacted current-version persistence fixture.
  */
 export const phase3TravelPlannerInitialBatch = CanonicalBatch.make({
@@ -77,7 +75,7 @@ export const phase3TravelPlannerInitialBatch = CanonicalBatch.make({
   producerId: phase3TravelPlannerProducerId,
   records: [
     record("travel-planner-p3-created", "2026-09-01T00:00:00.000Z", {
-      _tag: "ConversationCreated",
+      _tag: "ThreadCreated",
       agentId,
       definitions: phase3TravelPlannerDefinitionDigests,
     }),
@@ -125,7 +123,7 @@ export class TravelPlannerProjectionError extends Schema.TaggedError<TravelPlann
 
 /** Decode the itinerary projection rebuilt from canonical model-completion records. */
 export const travelPlanFromProjection = (
-  projection: ConversationProjection,
+  projection: ThreadProjection,
 ): Effect.Effect<TravelPlan, TravelPlannerProjectionError> => {
   const output = projection.modelOutputs.at(-1);
   if (output === undefined) {
@@ -141,18 +139,16 @@ export const travelPlanFromProjection = (
 };
 
 /** Build a disposable checkpoint bound to a validated canonical prefix. */
-export const makePhase3TravelPlannerCheckpoint = (
-  projection: ConversationProjection,
-): ConversationCheckpoint =>
-  Schema.decodeSync(ConversationCheckpoint)({
+export const makePhase3TravelPlannerCheckpoint = (projection: ThreadProjection): ThreadCheckpoint =>
+  Schema.decodeSync(ThreadCheckpoint)({
     schemaVersion: 1,
-    conversationId: projection.conversationId,
+    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(ConversationProjection)(projection),
+    state: Schema.encodeSync(ThreadProjection)(projection),
     createdAt: "2026-09-01T00:00:04.000Z",
   });