@effect-agent/testing 0.1.0-beta.11 → 0.1.0-beta.110

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

@@ -1,36 +1,42 @@
+import { Cause, Effect, Exit, Layer, Option, Ref, Schema, Stream } from "effect";
+import { ObligationThresholds } from "effect-agent/admin";
+import * as Agent from "effect-agent/agent";
+import { AgentPolicy } from "effect-agent/agent-policy";
 import {
-  Subagent,
-  SubagentPolicy,
-  SubagentReservationsMemoryLive,
-  SubagentRuntime,
-} from "@effect-agent/capabilities";
-import {
-  Agent,
-  AgentPolicy,
-  ConversationId,
-  IdGenerator,
-  RunId,
-  SubmissionId,
-  ToolCallId,
-  TurnId,
-} from "@effect-agent/core";
-import { DurableStep, DurableStepError, ToolExecutionClass } from "@effect-agent/engine";
+  DurableWorkerBinding,
+  type DurableBindingFailure,
+  type ResolvedBinding,
+} from "effect-agent/agent-registration";
 import {
-  AbortCommand,
-  AgentBindingResolver,
-  ApprovalDecisionCommand,
-  ConversationExportRequest,
-  ConversationStore,
-  DefinitionDigests,
-  Digest,
   DurableAgentRuntime,
   DurableRuntimeConfig,
+  type DurableSubmitFailure,
+  type DurableWorkerFailure,
+  type Receipt,
+} from "effect-agent/durable-agent-runtime";
+import {
   DurableRuntimeFailpointError,
   DurableRuntimeFailpointLocation,
-  DurableRuntimeFailpointTestControl,
-  DurableWorkerBinding,
+} from "effect-agent/durable-failpoint";
+import { DurableStep, DurableStepError, ToolExecutionClass } from "effect-agent/durable-step";
+import { IdGenerator } from "effect-agent/id-generator";
+import { ThreadId, RunId, ToolCallId, TurnId, type SubmissionId } from "effect-agent/identifiers";
+import {
+  DefinitionDigests,
+  Digest,
+  type CanonicalRecordEnvelope,
+  type BatchId,
+  type ProducerId,
+} from "effect-agent/records";
+import { childThreadIdFor } from "effect-agent/run-journal";
+import { RunToolAuthorization } from "effect-agent/run-options";
+import * as Subagent from "effect-agent/subagent";
+import { SubagentPolicy } from "effect-agent/subagent";
+import { SubagentReservationsMemoryLive } from "effect-agent/subagent-reservations";
+import {
+  AbortCommand,
+  ApprovalDecisionCommand,
   IdempotencyKey,
-  ObligationThresholds,
   Principal,
   ResolutionAbortSubmission,
   ResolutionCompletedWithResult,
@@ -38,28 +44,30 @@ import {
   SubmissionLedger,
   SubmissionLookupById,
   UnknownResolutionCommand,
-  childConversationIdFor,
-  verifyConversationInvariants,
-  type CanonicalRecordEnvelope,
-  type BatchId,
-  type ProducerId,
-  type Receipt,
-  type ResolvedBinding,
   type Settlement,
   type SubmissionSnapshot,
   type UnknownResolution,
-} from "@effect-agent/session";
-import { Cause, Effect, Exit, Layer, Option, Ref, Schema, Stream } from "effect";
-import { FastCheck } from "effect/testing";
-import { LanguageModel, Model, Prompt, Tool, Toolkit, type Response } from "effect/unstable/ai";
+} from "effect-agent/submission-ledger";
+import { DurableRuntimeFailpointTestControl } from "effect-agent/testing/durable-failpoint-test-control";
+import { verifyThreadInvariants } from "effect-agent/thread-invariants";
+import { ThreadExportRequest, ThreadStore } from "effect-agent/thread-store";
+import {
+  LanguageModel,
+  Model,
+  Tool,
+  Toolkit,
+  type Prompt,
+  type Response,
+} from "effect/unstable/ai";
+import { Arbitrary } from "effect/unstable/arbitrary";
 
 /**
  * P7 WP4 chaos machinery (plan §5): a Schema-first `ChaosPlan`, a seeded generator over
- * `effect/testing/FastCheck` (already inside the pinned Effect — no new dependency), and a
+ * `effect/unstable/arbitrary`, and a
  * 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
@@ -83,6 +91,7 @@ export const ChaosScenarioKind = Schema.Literals([
   "join",
   "delegation",
 ]);
+
 export type ChaosScenarioKind = typeof ChaosScenarioKind.Type;
 
 const LaneIndex = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(7));
@@ -108,6 +117,7 @@ export const ChaosResolutionKind = Schema.Literals([
   /** Unresolvable: route into the abort path (settles aborted, audit retained). */
   "abort-submission",
 ]);
+
 export type ChaosResolutionKind = typeof ChaosResolutionKind.Type;
 
 export const ChaosApprovalDecision = Schema.Literals(["approved", "denied"]);
@@ -142,10 +152,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,
 }) {}
 
@@ -176,12 +186,16 @@ export class ChaosConvergenceFailure extends Schema.TaggedError<ChaosConvergence
 /** Default root seed for chaos suites; override with the `CHAOS_SEED` environment variable. */
 export const DEFAULT_CHAOS_SEED = 20260813;
 
+const ChaosSeedFromEnvironment = Schema.FiniteFromString.check(Schema.isInt());
+const decodeChaosSeedFromEnvironment = Schema.decodeUnknownOption(ChaosSeedFromEnvironment);
+
 /** The root seed for this run: `CHAOS_SEED` when set to an integer, the default otherwise. */
 export const chaosSeedFromEnv = (env: Record<string, string | undefined>): number => {
   const raw = env["CHAOS_SEED"];
+
   if (raw === undefined || raw === "") return DEFAULT_CHAOS_SEED;
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isSafeInteger(parsed) ? parsed : DEFAULT_CHAOS_SEED;
+
+  return Option.getOrElse(decodeChaosSeedFromEnvironment(raw), () => DEFAULT_CHAOS_SEED);
 };
 
 export interface ChaosGeneratorOptions {
@@ -193,26 +207,14 @@ export interface ChaosGeneratorOptions {
   readonly adapterArms?: ReadonlyArray<string> | undefined;
 }
 
-interface GeneratedLane {
-  readonly kind: ChaosScenarioKind;
-  readonly depth: number;
-}
-
-const laneArbitrary: FastCheck.Arbitrary<GeneratedLane> = FastCheck.constantFrom<ChaosScenarioKind>(
-  "plain",
-  "uncertain-tool",
-  "durable-steps",
-  "approval",
-  "join",
-  "delegation",
-).chain(
-  (kind): FastCheck.Arbitrary<GeneratedLane> =>
-    kind === "join"
-      ? FastCheck.integer({ min: 2, max: 3 }).map((depth): GeneratedLane => ({ kind, depth }))
-      : kind === "plain"
-        ? FastCheck.integer({ min: 1, max: 2 }).map((depth): GeneratedLane => ({ kind, depth }))
-        : FastCheck.constant<GeneratedLane>({ kind, depth: 1 }),
-);
+const GeneratedLane = Schema.Union([
+  Schema.Struct({ kind: Schema.Literal("join"), depth: Schema.Literals([2, 3]) }),
+  Schema.Struct({ kind: Schema.Literal("plain"), depth: Schema.Literals([1, 2]) }),
+  Schema.Struct({
+    kind: Schema.Literals(["uncertain-tool", "durable-steps", "approval", "delegation"]),
+    depth: Schema.Literal(1),
+  }),
+]);
 
 interface ChaosPlanShape {
   readonly lanes: number;
@@ -226,74 +228,77 @@ interface ChaosPlanShape {
 
 const planShapeArbitrary = (
   adapterArms: ReadonlyArray<string>,
-): FastCheck.Arbitrary<ChaosPlanShape> =>
-  FastCheck.record({
-    lanes: FastCheck.array(laneArbitrary, { minLength: 1, maxLength: 3 }),
-    failpointArms: FastCheck.uniqueArray(
-      FastCheck.constantFrom(...DurableRuntimeFailpointLocation.literals),
-      { maxLength: 3 },
-    ),
-    adapterArms:
-      adapterArms.length === 0
-        ? FastCheck.constant<Array<string>>([])
-        : FastCheck.uniqueArray(FastCheck.constantFrom(...adapterArms), { maxLength: 2 }),
-    abortInjections: FastCheck.uniqueArray(FastCheck.integer({ min: 0, max: 15 }), {
-      maxLength: 2,
-    }),
-    resolutionInjections: FastCheck.array(
-      FastCheck.constantFrom<ChaosResolutionKind>(
-        "never-happened",
-        "completed-from-supplier",
-        "abort-submission",
+): Arbitrary.Arbitrary<ChaosPlanShape> =>
+  Arbitrary.schema(
+    Schema.Struct({
+      lanes: Schema.Array(GeneratedLane).check(Schema.isMinLength(1), Schema.isMaxLength(3)),
+      failpointArms: Schema.Array(DurableRuntimeFailpointLocation).check(
+        Schema.isUnique(),
+        Schema.isMaxLength(3),
       ),
-      { maxLength: 4 },
-    ),
-    approvalDecisions: FastCheck.array(
-      FastCheck.constantFrom<ChaosApprovalDecision>("approved", "denied"),
-      { maxLength: 2 },
-    ),
-  }).map((shape) => {
-    const submissions = shape.lanes.flatMap((lane, index) =>
-      Array.from({ length: lane.depth }, () =>
-        ChaosSubmissionSpec.make({ lane: index, kind: lane.kind }),
-      ),
-    );
-    const [first, ...rest] = submissions;
-    // `lanes` >= 1 and every lane has depth >= 1, so `first` always exists.
-    if (first === undefined) throw new Error("chaos generator produced an empty plan");
-    return {
-      lanes: shape.lanes.length,
-      submissions: [first, ...rest] as const,
-      failpointArms: shape.failpointArms,
-      adapterArms: shape.adapterArms,
-      abortInjections: shape.abortInjections,
-      resolutionInjections: shape.resolutionInjections,
-      approvalDecisions: shape.approvalDecisions,
-    };
-  });
+      adapterArms: Schema.Array(
+        adapterArms.length === 0 ? Schema.String : Schema.Literals(adapterArms),
+      ).check(Schema.isUnique(), Schema.isMaxLength(adapterArms.length === 0 ? 0 : 2)),
+      abortInjections: Schema.Array(
+        Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 15 })),
+      ).check(Schema.isUnique(), Schema.isMaxLength(2)),
+      resolutionInjections: Schema.Array(ChaosResolutionKind).check(Schema.isMaxLength(4)),
+      approvalDecisions: Schema.Array(ChaosApprovalDecision).check(Schema.isMaxLength(2)),
+    }),
+  ).pipe(
+    Arbitrary.map((shape) => {
+      const submissions = shape.lanes.flatMap((lane, index) =>
+        Array.from({ length: lane.depth }, () =>
+          ChaosSubmissionSpec.make({ lane: index, kind: lane.kind }),
+        ),
+      );
+
+      const [first, ...rest] = submissions;
+
+      // `lanes` >= 1 and every lane has depth >= 1, so `first` always exists.
+      if (first === undefined) throw new Error("chaos generator produced an empty plan");
+
+      return {
+        lanes: shape.lanes.length,
+        submissions: [first, ...rest] as const,
+        failpointArms: shape.failpointArms,
+        adapterArms: shape.adapterArms,
+        abortInjections: shape.abortInjections,
+        resolutionInjections: shape.resolutionInjections,
+        approvalDecisions: shape.approvalDecisions,
+      };
+    }),
+  );
 
 /**
  * Derive `count` chaos plans deterministically from one root seed. The same
  * `{seed, count, adapterArms}` triple always yields byte-identical plans, so a failure line
- * `CHAOS_SEED=<seed>` replays the exact schedule.
+ * `CHAOS_SEED=<seed>` replays the exact schedule with the same pinned generator version.
+ * Sampling is interruptible and reports bounded generation exhaustion as Arbitrary.SampleError.
  */
-export const generateChaosPlans = (options: ChaosGeneratorOptions): ReadonlyArray<ChaosPlan> => {
-  const sampled = FastCheck.sample(planShapeArbitrary(options.adapterArms ?? []), {
+export const generateChaosPlans = Effect.fnUntraced(function* (
+  options: ChaosGeneratorOptions,
+): Effect.fn.Return<ReadonlyArray<ChaosPlan>, Arbitrary.SampleError> {
+  const sampled = yield* Arbitrary.sampleEffect(planShapeArbitrary(options.adapterArms ?? []), {
     seed: options.seed,
-    numRuns: options.count,
+    count: options.count,
   });
+
   return sampled.map((shape, index) =>
     ChaosPlan.make({ ...shape, seed: (Math.imul(options.seed, 31) + index) | 0 }),
   );
-};
+});
 
 /** Deterministic PRNG for the runner's small ordering choices (lane drive order). */
 const mulberry32 = (seed: number): (() => number) => {
   let state = seed | 0;
+
   return () => {
     state = (state + 0x6d2b79f5) | 0;
     let t = Math.imul(state ^ (state >>> 15), 1 | state);
+
     t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+
     return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
   };
 };
@@ -359,7 +364,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.",
@@ -372,8 +377,10 @@ const BookUncertain = Tool.make("book", {
   parameters: Schema.Struct({ ref: Schema.String }),
   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.",
@@ -386,8 +393,10 @@ const BookApproval = Tool.make("book", {
   success: Schema.Struct({ confirmation: Schema.String }),
   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.",
@@ -401,8 +410,10 @@ const Itinerary = Tool.make("itinerary", {
   failure: DurableStepError,
   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.",
@@ -410,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.",
@@ -445,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.",
@@ -457,16 +468,22 @@ const DELEGATE_CALL_ID = "chaos-delegate-1";
 
 const HEX = "0123456789abcdef";
 const decodeDigest = Schema.decodeSync(Digest);
+
 const laneDigests = (lane: number): DefinitionDigests => {
-  const digest = decodeDigest(HEX[lane % 8]!.repeat(64));
+  const digest = decodeDigest(HEX.charAt(lane % 8).repeat(64));
+
   return DefinitionDigests.make({ agent: digest, model: digest, tools: digest });
 };
+
 const childDigestStrings = (lane: number) => {
-  const char = HEX[8 + (lane % 8)]!;
+  const char = HEX.charAt(8 + (lane % 8));
+
   return { agent: char.repeat(64), model: char.repeat(64), tools: char.repeat(64) } as const;
 };
+
 const childLaneDigests = (lane: number): DefinitionDigests => {
   const strings = childDigestStrings(lane);
+
   return DefinitionDigests.make({
     agent: decodeDigest(strings.agent),
     model: decodeDigest(strings.model),
@@ -475,7 +492,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);
@@ -486,12 +503,14 @@ const chaosIdentifiers = Layer.effect(
   IdGenerator,
   Effect.gen(function* () {
     const counter = yield* Ref.make(0);
+
     const next = <A>(decode: (value: string) => A, prefix: string) =>
       Ref.getAndUpdate(counter, (value) => value + 1).pipe(
         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"),
     };
@@ -511,6 +530,7 @@ interface ChaosDesk {
 
 const makeChaosDesk: Effect.Effect<ChaosDesk> = Effect.gen(function* () {
   const produced = yield* Ref.make<ReadonlySet<string>>(new Set());
+
   return {
     produced: Ref.get(produced),
     record: (value: string) => Ref.update(produced, (current) => new Set(current).add(value)),
@@ -543,7 +563,7 @@ export interface ChaosRunOptions {
   readonly betweenRounds?: Effect.Effect<void> | undefined;
 }
 
-/** Success → Some; typed failure → None (chaos tolerates it); defect → rethrown loudly. */
+/** Tolerate typed failures while preserving every defect and interruption reason. */
 const tolerateTyped = <A, E, R>(
   effect: Effect.Effect<A, E, R>,
 ): Effect.Effect<Option.Option<A>, never, R> =>
@@ -551,25 +571,28 @@ const tolerateTyped = <A, E, R>(
     Effect.exit,
     Effect.flatMap((exit) => {
       if (Exit.isSuccess(exit)) return Effect.succeed(Option.some(exit.value));
-      if (Option.isSome(Cause.findErrorOption(exit.cause))) {
-        return Effect.succeed(Option.none<A>());
-      }
-      return Effect.die(new Error(`chaos step died: ${Cause.pretty(exit.cause)}`));
+      const unexpected = exit.cause.reasons.filter((reason) => reason._tag !== "Fail");
+
+      return unexpected.length === 0
+        ? Effect.succeed(Option.none<A>())
+        : Effect.failCause(Cause.fromReasons<never>(unexpected));
     }),
   );
 
 interface LaneFixture {
   readonly index: number;
   readonly kind: ChaosScenarioKind;
-  readonly conversationId: ConversationId;
+  readonly threadId: ThreadId;
   readonly ref: string;
   readonly deskInPlay: boolean;
   readonly submissionIndexes: ReadonlyArray<number>;
-  readonly submitOne: (flatIndex: number) => Effect.Effect<Receipt, unknown>;
+  readonly submitOne: (flatIndex: number) => Effect.Effect<Receipt, DurableSubmitFailure>;
   readonly drives: (
     firstReceipt: Receipt | undefined,
-  ) => ReadonlyArray<Effect.Effect<ReadonlyArray<Settlement>, unknown>>;
-  readonly childConversationOf: (firstReceipt: Receipt) => ConversationId | undefined;
+  ) => ReadonlyArray<
+    Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure>
+  >;
+  readonly childThreadOf: (firstReceipt: Receipt) => ThreadId | undefined;
 }
 
 interface SubmissionState {
@@ -613,14 +636,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,
@@ -636,48 +659,46 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
 
   const plainLaneFixture = (
     deskInPlay: boolean,
-    drive: Effect.Effect<ReadonlyArray<Settlement>, unknown>,
-    submitOne: (flatIndex: number) => Effect.Effect<Receipt, unknown>,
+    drive: Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure>,
+    submitOne: (flatIndex: number) => Effect.Effect<Receipt, DurableSubmitFailure>,
   ): 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)),
       );
     }
     case "approval": {
       const agent = Agent.withModel(approvalDefinition, model);
+
       return plainLaneFixture(
         true,
         runtime
-          .processConversation(agent, conversationId)
+          .processThread(agent, threadId)
           .pipe(Effect.provide(bookToolLayerFor(approvalTools))),
         (flatIndex) =>
           runtime.submit(agent, { question: `chaos ${flatIndex}` }, submitOptionsFor(flatIndex)),
@@ -685,57 +706,73 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
     }
     case "durable-steps": {
       const agent = Agent.withModel(itineraryDefinition, model);
+
       const toolLayer = itineraryTools.toLayer({
         itinerary: ({ ref: called }) =>
           Effect.gen(function* () {
             const step = yield* DurableStep;
+
             const flight = yield* step.do(
               "reserve-flight",
               Schema.String,
               desk.record(flightValue(called)).pipe(Effect.as(flightValue(called))),
             );
+
             const lodging = yield* step.do(
               "reserve-lodging",
               Schema.String,
               desk.record(lodgingValue(called)).pipe(Effect.as(lodgingValue(called))),
             );
+
             return { state: `${flight}+${lodging}` };
           }),
       });
+
       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)),
       );
     }
     case "delegation": {
       const parentBinding = Agent.withModel(coordinatorDefinition, model);
+
       const childModel = promptScriptedModel(`chaos-child-${laneIndex}`, () =>
         finalParts('{"answer":"child"}'),
       );
+
       const childBinding = Agent.withModel(childDefinition, childModel);
-      const delegationLayer = SubagentRuntime.layer(chaosDelegation, childBinding, {
+
+      const delegationLayer = Subagent.layer(chaosDelegation, childBinding, {
         mapChildFailure: (failure) => ChaosDelegationFailed.make({ childErrorTag: failure._tag }),
         durable: { targetDigests: childDigestStrings(laneIndex) },
       }).pipe(Layer.provide(delegationSupport));
+
       const parentResolved: ResolvedBinding = yield* DurableWorkerBinding.make(
         parentBinding,
         digests,
       ).pipe(Effect.provide(delegationLayer));
+
       const childResolved: ResolvedBinding = yield* DurableWorkerBinding.make(
         childBinding,
         childLaneDigests(laneIndex),
       );
-      const resolver = AgentBindingResolver.fromBindings([parentResolved, childResolved]);
-      const driveResolved = (conversation: ConversationId) =>
-        runtime
-          .processConversationResolved(conversation)
-          .pipe(Effect.provideService(AgentBindingResolver, resolver));
+
+      const registeredRuntime = yield* DurableAgentRuntime.pipe(
+        Effect.provide(
+          DurableAgentRuntime.layerWithBindings([parentResolved, childResolved]).pipe(
+            Layer.provide(RunToolAuthorization.allowAll),
+          ),
+        ),
+      );
+
+      const driveResolved = (thread: ThreadId) => registeredRuntime.processThreadResolved(thread);
+
       const fixture: LaneFixture = {
         index: laneIndex,
         kind,
-        conversationId,
+        threadId,
         ref,
         deskInPlay: false,
         submissionIndexes,
@@ -746,24 +783,24 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
             submitOptionsFor(flatIndex),
           ),
         drives: (firstReceipt) => {
-          const drives: Array<Effect.Effect<ReadonlyArray<Settlement>, unknown>> = [
-            driveResolved(conversationId),
-          ];
+          const drives: Array<
+            Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure>
+          > = [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;
     }
   }
@@ -772,7 +809,9 @@ const makeLaneFixture = Effect.fn("Chaos.makeLaneFixture")(function* (
 /** Stable per-call index into an injection list (identical across resolution passes). */
 const injectionIndex = (submissionFlatIndex: number, callId: string, length: number): number => {
   let hash = submissionFlatIndex + 1;
+
   for (const char of callId) hash = (Math.imul(hash, 31) + char.charCodeAt(0)) | 0;
+
   return ((hash % length) + length) % length;
 };
 
@@ -802,6 +841,7 @@ const resolutionFor = (
           isFailure: false,
         });
       }
+
       // The desk never produced a value for this call — resolving "completed" would fabricate.
       return ResolutionNeverHappened.make();
     }
@@ -820,8 +860,10 @@ const resolutionPass = Effect.fn("Chaos.resolutionPass")(function* (
   const ledger = yield* SubmissionLedger;
   const produced = yield* desk.produced;
   const nonterminal = yield* tolerateTyped(Stream.runCollect(ledger.scanNonterminal));
+
   if (Option.isNone(nonterminal)) return;
   const byId = new Map<SubmissionId, SubmissionState>();
+
   for (const state of states) {
     if (state.receipt !== undefined) byId.set(state.receipt.submissionId, state);
   }
@@ -829,18 +871,22 @@ const resolutionPass = Effect.fn("Chaos.resolutionPass")(function* (
     if (row.state !== "unknown" && row.state !== "suspended") continue;
     const state = byId.get(row.submissionId);
     const explanation = yield* tolerateTyped(runtime.explain(row.submissionId));
+
     if (Option.isNone(explanation)) continue;
     const flatIndex = state?.flatIndex ?? 0;
     const ref = state?.lane.ref ?? "ref-child";
+
     if (row.state === "unknown") {
       for (const call of explanation.value.evidence.unknownCalls) {
         if (call.resolved) continue;
+
         const kind =
           plan.resolutionInjections.length === 0
             ? "never-happened"
-            : plan.resolutionInjections[
-                injectionIndex(flatIndex, call.toolCallId, plan.resolutionInjections.length)
-              ]!;
+            : (plan.resolutionInjections.at(
+                injectionIndex(flatIndex, call.toolCallId, plan.resolutionInjections.length),
+              ) ?? "never-happened");
+
         yield* tolerateTyped(
           runtime.resolveUnknown(
             UnknownResolutionCommand.make({
@@ -858,9 +904,10 @@ const resolutionPass = Effect.fn("Chaos.resolutionPass")(function* (
         const decision =
           plan.approvalDecisions.length === 0
             ? "approved"
-            : plan.approvalDecisions[
-                injectionIndex(flatIndex, pending.toolCallId, plan.approvalDecisions.length)
-              ]!;
+            : (plan.approvalDecisions.at(
+                injectionIndex(flatIndex, pending.toolCallId, plan.approvalDecisions.length),
+              ) ?? "approved");
+
         yield* tolerateTyped(
           runtime.resolveApproval(
             ApprovalDecisionCommand.make({
@@ -881,16 +928,19 @@ const submissionIdsNamedBy = (
   records: ReadonlyArray<CanonicalRecordEnvelope>,
 ): ReadonlySet<SubmissionId> => {
   const named = new Set<SubmissionId>();
+
   for (const envelope of records) {
     const payload = envelope.record.payload;
+
     if (
       payload._tag === "UserInputRecorded" ||
       payload._tag === "SubmissionSettled" ||
       payload._tag === "AbortRequested"
     ) {
-      named.add(payload.submissionId);
+      if (payload.submissionId !== undefined) named.add(payload.submissionId);
     }
   }
+
   return named;
 };
 
@@ -910,18 +960,23 @@ const assertNoFabrication = (
   produced: ReadonlySet<string>,
 ): Effect.Effect<void, ChaosConvergenceFailure> => {
   const fabricated: Array<string> = [];
+
   const requireProduced = (value: string, label: string): void => {
     if (!produced.has(value)) fabricated.push(`${label} "${value}"`);
   };
+
   for (const envelope of records) {
     const payload = envelope.record.payload;
+
     if (payload._tag === "ToolCallSettled" && !payload.isFailure) {
       if (payload.toolName === "book") {
         const result = decodeBookResult(payload.result);
+
         if (Option.isSome(result)) requireProduced(result.value.confirmation, "book result");
       }
       if (payload.toolName === "itinerary") {
         const result = decodeItineraryResult(payload.result);
+
         if (Option.isSome(result)) {
           for (const part of result.value.state.split("+")) {
             requireProduced(part, "itinerary step result");
@@ -931,9 +986,11 @@ const assertNoFabrication = (
     }
     if (payload._tag === "ToolStepSettled") {
       const output = decodeStepOutput(payload.output);
+
       if (Option.isSome(output)) requireProduced(output.value, "step output");
     }
   }
+
   return fabricated.length === 0
     ? Effect.void
     : Effect.fail(
@@ -954,7 +1011,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);
@@ -963,28 +1020,43 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
   // Lane fixtures: the FIRST spec of each lane fixes the lane's agent kind.
   const laneKinds = new Map<number, ChaosScenarioKind>();
   const laneSubmissions = new Map<number, Array<number>>();
+
   plan.submissions.forEach((spec, flatIndex) => {
     const lane = spec.lane % plan.lanes;
+
     if (!laneKinds.has(lane)) laneKinds.set(lane, spec.kind);
     const list = laneSubmissions.get(lane) ?? [];
+
     list.push(flatIndex);
     laneSubmissions.set(lane, list);
   });
   const lanes: Array<LaneFixture> = [];
+
   for (const [lane, kind] of laneKinds) {
     lanes.push(yield* makeLaneFixture(plan, lane, kind, laneSubmissions.get(lane) ?? [], desk));
   }
 
-  const states: Array<SubmissionState> = plan.submissions.map((spec, flatIndex) => ({
-    flatIndex,
-    lane: lanes.find((fixture) => fixture.index === spec.lane % plan.lanes)!,
-    receipt: undefined,
-  }));
+  const lanesByIndex = new Map(lanes.map((lane) => [lane.index, lane]));
+  const states: Array<SubmissionState> = [];
+
+  for (const [flatIndex, spec] of plan.submissions.entries()) {
+    const laneIndex = spec.lane % plan.lanes;
+    const lane = lanesByIndex.get(laneIndex);
+
+    if (lane === undefined) {
+      return yield* ChaosConvergenceFailure.make({
+        seed: plan.seed,
+        message: `submission ${flatIndex} addresses missing lane ${laneIndex}`,
+      });
+    }
+    states.push({ flatIndex, lane, receipt: undefined });
+  }
   const appliedAborts = new Set<number>();
 
   type ArmEntry =
     | { readonly family: "coordinator"; readonly location: DurableRuntimeFailpointLocation }
     | { readonly family: "adapter"; readonly location: string };
+
   const armQueue: Array<ArmEntry> = [
     ...plan.failpointArms.map((location): ArmEntry => ({ family: "coordinator", location })),
     ...plan.adapterArms.map((location): ArmEntry => ({ family: "adapter", location })),
@@ -993,17 +1065,21 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
   const allSettled = Effect.gen(function* () {
     if (states.some((state) => state.receipt === undefined)) return false;
     const nonterminal = yield* tolerateTyped(Stream.runCollect(ledger.scanNonterminal));
+
     return Option.isSome(nonterminal) && Array.from(nonterminal.value).length === 0;
   });
 
   const maxRounds = armQueue.length + states.length * 2 + 12;
   let rounds = 0;
   let converged = false;
+
   for (let round = 0; round < maxRounds; round++) {
     rounds = round + 1;
     const arm = armQueue[round];
+
     if (arm?.family === "coordinator") {
       const location = arm.location;
+
       yield* failpoints.setHandler((hit) =>
         hit === location
           ? Effect.fail(DurableRuntimeFailpointError.make({ location: hit }))
@@ -1014,18 +1090,24 @@ 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));
+
       if (Option.isSome(receipt)) state.receipt = receipt.value;
     }
 
     // Drive every lane (and discovered child lanes) in seeded order under the active arm.
-    const order = [...lanes].sort(() => random() - 0.5);
+    const order = lanes
+      .map((lane) => ({ lane, rank: random() }))
+      .sort((left, right) => left.rank - right.rank || left.lane.index - right.lane.index)
+      .map(({ lane }) => lane);
+
     for (const lane of order) {
       const firstFlat = lane.submissionIndexes[0];
       const firstReceipt = firstFlat === undefined ? undefined : states[firstFlat]?.receipt;
+
       for (const drive of lane.drives(firstReceipt)) {
         yield* tolerateTyped(drive);
       }
@@ -1035,8 +1117,10 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
     if (round >= 1) {
       for (const rawIndex of plan.abortInjections) {
         const index = rawIndex % states.length;
+
         if (appliedAborts.has(index)) continue;
         const receipt = states[index]?.receipt;
+
         if (receipt === undefined) continue;
         appliedAborts.add(index);
         yield* tolerateTyped(
@@ -1070,35 +1154,40 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
 
   if (!converged) {
     const nonterminal = yield* tolerateTyped(Stream.runCollect(ledger.scanNonterminal));
+
     const detail = Option.isSome(nonterminal)
       ? Array.from(nonterminal.value)
           .map((row: SubmissionSnapshot) => `${row.submissionId}(${row.state})`)
           .join(", ")
       : "ledger scan failed";
+
     return yield* ChaosConvergenceFailure.make({
       seed: plan.seed,
       message: `plan did not converge within ${maxRounds} rounds; nonterminal: [${detail}]; pending receipts: ${states.filter((state) => state.receipt === undefined).length}`,
     });
   }
 
-  // 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)}`,
         }),
       ),
     );
+
     const rows: Array<SubmissionSnapshot> = [];
+
     for (const submissionId of submissionIdsNamedBy(exported.records)) {
       const found = yield* ledger.lookup(SubmissionLookupById.make({ submissionId })).pipe(
         Effect.mapError((error) =>
@@ -1108,25 +1197,30 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
           }),
         ),
       );
+
       if (Option.isSome(found)) rows.push(found.value);
     }
+
     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,
       requireAllSettled: true,
     });
+
     if (!report.ok) {
       const failed = report.checks
         .filter((check) => check.status === "failed")
         .map((check) => `${check.name}: ${check.detail ?? "failed"}`)
         .join("; ");
+
       return yield* ChaosConvergenceFailure.make({
         seed: plan.seed,
-        message: `invariants failed for ${conversationId} (${kind}): ${failed}`,
+        message: `invariants failed for ${threadId} (${kind}): ${failed}`,
       });
     }
     if (deskInPlay) {
@@ -1134,7 +1228,7 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
     }
     laneReports.push(
       ChaosLaneReport.make({
-        conversationId,
+        threadId,
         kind,
         submissionCount: rows.length,
         verified: report.ok,
@@ -1143,18 +1237,22 @@ 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);
       }
     }
   }
@@ -1169,6 +1267,7 @@ export const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (
         }),
       ),
     );
+
   if (obligations.entries.length > 0) {
     return yield* ChaosConvergenceFailure.make({
       seed: plan.seed,