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

package/src/{certification.ts → Certification.ts}

@@ -1,67 +1,72 @@
+import * as Subagent from "@effect-agent/capabilities/Subagent";
+import { SubagentPolicy, SubagentRuntime } from "@effect-agent/capabilities/Subagent";
+import { SubagentReservationsMemoryLive } from "@effect-agent/capabilities/SubagentReservations";
+import * as Agent from "@effect-agent/core/Agent";
+import { AgentPolicy } from "@effect-agent/core/AgentPolicy";
 import {
-  Subagent,
-  SubagentPolicy,
-  SubagentReservationsMemoryLive,
-  SubagentRuntime,
-} from "@effect-agent/capabilities";
-import {
-  Agent,
-  AgentPolicy,
-  ConversationId,
-  IdGenerator,
+  ThreadId,
   RunId,
   ToolCallId,
   TurnId,
   type AgentId,
   type SubmissionId,
-} from "@effect-agent/core";
-import { DurableStep, DurableStepError } from "@effect-agent/engine";
+} from "@effect-agent/core/Identifiers";
+import { IdGenerator } from "@effect-agent/core/IdGenerator";
+import { DurableStep, DurableStepError } from "@effect-agent/engine/DurableStep";
+import { RunToolAuthorization } from "@effect-agent/engine/RunOptions";
+import { DurableWorkerBinding, type ResolvedBinding } from "@effect-agent/thread/AgentRegistration";
 import {
-  AgentBindingResolver,
-  ApprovalDecisionCommand,
-  CertificationCaseResult,
-  CertificationReport,
-  CertificationSweepResult,
-  CertificationTierThreeReport,
-  CertifiedAdapterIdentity,
-  ConversationExportRequest,
-  ConversationStore,
-  DefinitionDigests,
-  DeploymentId,
-  Digest,
   DurableAgentRuntime,
   DurableRuntimeConfig,
-  DurableRuntimeFailpoint,
+  type DurableSubmitFailure,
+  type DurableSubmitOptions,
+  type Receipt,
+} from "@effect-agent/thread/DurableAgentRuntime";
+import {
   DurableRuntimeFailpointError,
   DurableRuntimeFailpointLocation,
-  DurableRuntimeFailpointTestControl,
-  DurableWorkerBinding,
+} from "@effect-agent/thread/DurableFailpoint";
+import {
+  DefinitionDigests,
+  DeploymentId,
+  Digest,
+  ProducerId,
+  type BatchId,
+} from "@effect-agent/thread/Records";
+import { childThreadIdFor } from "@effect-agent/thread/RunJournal";
+import {
+  ApprovalDecisionCommand,
   IdempotencyKey,
-  LoadCheckpointRequest,
   Principal,
-  ProducerId,
   ResolutionSafeToRetry,
   SubmissionLedger,
   SubmissionLookupById,
-  ToolReconciler,
   UnknownResolutionCommand,
-  WakeScheduler,
   DEFAULT_OWNERSHIP_LEASE_DURATION,
+  type SubmissionSnapshot,
+} from "@effect-agent/thread/SubmissionLedger";
+import {
+  type CertificationCaseResult,
+  CertificationReport,
+  CertificationSweepResult,
+  CertificationTierThreeReport,
+  CertifiedAdapterIdentity,
   certifyPorts,
-  childConversationIdFor,
-  verifyConversationInvariants,
-  type BatchId,
   type CertificationScenario,
-  type DurableSubmitFailure,
-  type DurableSubmitOptions,
-  type Receipt,
-  type ResolvedBinding,
-  type SubmissionSnapshot,
-} from "@effect-agent/session";
+} from "@effect-agent/thread/testing/Certification";
+import { DurableRuntimeFailpointTestControl } from "@effect-agent/thread/testing/DurableFailpointTestControl";
+import { verifyThreadInvariants } from "@effect-agent/thread/ThreadInvariants";
+import {
+  ThreadExportRequest,
+  ThreadStore,
+  LoadCheckpointRequest,
+} from "@effect-agent/thread/ThreadStore";
+import { ToolReconciler } from "@effect-agent/thread/ToolReconciler";
+import { WakeScheduler } from "@effect-agent/thread/WakeScheduler";
+import type { Crypto } from "effect";
 import {
   Cause,
   Clock,
-  Crypto,
   DateTime,
   Duration,
   Effect,
@@ -87,7 +92,7 @@ import { LanguageModel, Model, Tool, Toolkit, type Response } from "effect/unsta
  *   (plain / uncertain-tool / durable-steps / approval / join / delegation). After the injected
  *   fault the runner asserts the state stays CLASSIFIABLE (recovery + the public unblocking
  *   operations `resolveUnknown`/`resolveApproval` are the only levers used) and that the
- *   re-drive CONVERGES to `verifyConversationInvariants` with `requireAllSettled` — including a
+ *   re-drive CONVERGES to `verifyThreadInvariants` with `requireAllSettled` — including a
  *   fully discharged digest-chain check, because the runner captures per-batch producer
  *   identity at append time.
  * - **Tier 3 — real loss lever**: recorded honestly. A durable adapter either supplies a
@@ -126,7 +131,7 @@ export interface CertifyDurableAdaptersOptions<LedgerE = never, StoreE = never>
    * does); the certification's own environment supplies nothing else.
    */
   readonly submissionLedger: Layer.Layer<SubmissionLedger, LedgerE, Crypto.Crypto>;
-  readonly conversationStore: Layer.Layer<ConversationStore, StoreE, Crypto.Crypto>;
+  readonly threadStore: Layer.Layer<ThreadStore, StoreE, Crypto.Crypto>;
   /** Defaults to `WakeScheduler.layerNoop`; the runner re-drives lanes explicitly. */
   readonly wakeScheduler?: Layer.Layer<WakeScheduler> | undefined;
   /** Executes Tier 3 in this run; takes precedence over `tierThreeEvidence`. */
@@ -156,8 +161,8 @@ export const CERTIFICATION_SCENARIOS: ReadonlyArray<CertificationScenario> = [
 
 /**
  * Coordinator failpoint locations that none of the six scenario shapes can reach, recorded
- * honestly instead of silently claimed: all three sit on operator/abort paths the shapes do
- * not take. They are pinned in-process by the P5/S2 suites
+ * honestly instead of silently claimed. These require operator, compaction, reservation, or
+ * background-worker paths the shapes do not take. They are pinned in-process by the P5/S2 suites
  * (`packages/testing/test/durable-tools.test.ts` "resolveUnknown is idempotent across the
  * intent failpoint", `durable-runtime.test.ts` abort rows,
  * `durable-subagents.test.ts` abort propagation) and by the process-kill/eviction crash
@@ -165,14 +170,40 @@ export const CERTIFICATION_SCENARIOS: ReadonlyArray<CertificationScenario> = [
  * protocol change that silently stops exercising a location fails the certification.
  */
 export const TIER2_UNREACHED_LOCATIONS: ReadonlyArray<DurableRuntimeFailpointLocation> = [
+  // Tier 2 has no native compaction; dedicated checkpoint process-loss tests cover these.
+  "checkpoint:before-save",
+  "checkpoint:after-save",
   "abort:after-intent",
   // Compaction requires a `contextTokenLimit` policy plus prior-Run history
   // none of the six scenario shapes carries; pinned in-process by the
   // RUN-026 rows in `packages/testing/test/durable-runtime.test.ts`
   // (compaction failpoint idempotence across re-drive).
+  "compaction:before-canonical-append",
   "compaction:after-canonical-append",
+  // These shapes use neither programmatic Tools nor grace finalization. Their reservations
+  // are exercised before/after append in the public durable-runtime regression suite.
+  "policy:before-reservation-append",
+  "policy:after-reservation-append",
   "resolve:after-intent",
   "subagent:after-child-abort-intent",
+  // Background workers use retained delivery, source capacity, and child-origin paths absent
+  // from these six attached/ordinary scenarios. The before/after creation and completion
+  // boundaries are exercised by packages/thread/test/worker-host.test.ts.
+  "worker:before-source-append",
+  "worker:after-source-append",
+  "worker:before-origin-append",
+  "worker:after-origin-append",
+  "worker:before-completion-append",
+  "worker:after-completion-append",
+  // Root attached declarations keep their independent pool; nested shared subtree mutations
+  // are covered by the same focused worker-host failpoint suite.
+  "worker:before-subtree-append",
+  "worker:after-subtree-append",
+  // Automatic report decisions and retained delivery insertion have dedicated worker crash tests.
+  "worker:before-report-append",
+  "worker:after-report-append",
+  "worker:before-report-delivery",
+  "worker:after-report-delivery",
 ];
 
 /** Locations of `tier2` rows whose armed fault never fired in ANY scenario, sorted. */
@@ -180,9 +211,11 @@ export const tier2NeverFiredLocations = (
   tier2: ReadonlyArray<CertificationSweepResult>,
 ): ReadonlyArray<DurableRuntimeFailpointLocation> => {
   const fired = new Set<DurableRuntimeFailpointLocation>();
+
   for (const row of tier2) {
     if (row.failpointFired) fired.add(row.location);
   }
+
   return DurableRuntimeFailpointLocation.literals.filter((location) => !fired.has(location)).sort();
 };
 
@@ -192,18 +225,21 @@ export const tier2NeverFiredLocations = (
 
 const SHA_A = Schema.decodeSync(Digest)("a".repeat(64));
 const DIGESTS = DefinitionDigests.make({ agent: SHA_A, model: SHA_A, tools: SHA_A });
+
 const CHILD_DIGEST_STRINGS = {
   agent: "b".repeat(64),
   model: "c".repeat(64),
   tools: "d".repeat(64),
 } as const;
+
 const CHILD_DIGESTS = DefinitionDigests.make({
   agent: Schema.decodeSync(Digest)(CHILD_DIGEST_STRINGS.agent),
   model: Schema.decodeSync(Digest)(CHILD_DIGEST_STRINGS.model),
   tools: Schema.decodeSync(Digest)(CHILD_DIGEST_STRINGS.tools),
 });
+
 const PRINCIPAL = Schema.decodeSync(Principal)("principal-certification");
-const decodeConversationId = Schema.decodeSync(ConversationId);
+const decodeThreadId = Schema.decodeSync(ThreadId);
 const decodeIdempotencyKey = Schema.decodeSync(IdempotencyKey);
 const decodeToolCallId = Schema.decodeSync(ToolCallId);
 
@@ -253,18 +289,26 @@ const promptShapeModel = (
         generateText: () => Effect.succeed([]),
         streamText: (request) => {
           const hasToolResult = request.prompt.content.some((message) => message.role === "tool");
+
           const parts =
             toolParts === undefined || hasToolResult ? finalParts(finalText) : toolParts;
+
           return Stream.fromIterable(parts);
         },
       }),
     ),
   );
 
+// Tier-2 intentionally advances virtual time past a 30-second ownership lease on every
+// re-drive round. Keep its business-policy duration above the full eight-round sweep so this
+// fixture certifies crash convergence rather than accidentally relying on a fresh duration
+// allowance per replacement Attempt. RUN-030 owns the dedicated duration-expiry coverage.
+const CERTIFICATION_MAX_DURATION = "10 minutes" as const;
+
 const policy = AgentPolicy.make({
   maxTurns: 4,
   maxToolCalls: 4,
-  maxDuration: "30 seconds",
+  maxDuration: CERTIFICATION_MAX_DURATION,
   toolConcurrency: 2,
 });
 
@@ -272,7 +316,7 @@ const QuestionInput = Schema.Struct({ question: Schema.String });
 const AnswerOutput = Schema.Struct({ answer: Schema.String });
 
 /** plain / join: no tools — the pure Turn/submission/join seams. */
-const plainDefinition = Agent.define("certify-plain", {
+const plainDefinition = Agent.make("certify-plain", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Answer as JSON.",
@@ -285,8 +329,10 @@ const Book = Tool.make("book", {
   parameters: Schema.Struct({ ref: Schema.String }),
   success: Schema.Struct({ confirmation: Schema.String }),
 });
+
 const bookToolkit = Toolkit.make(Book);
-const uncertainDefinition = Agent.define("certify-uncertain", {
+
+const uncertainDefinition = Agent.make("certify-uncertain", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Book it.",
@@ -301,8 +347,10 @@ const Itinerary = Tool.make("itinerary", {
   failure: DurableStepError,
   dependencies: [DurableStep],
 });
+
 const itineraryToolkit = Toolkit.make(Itinerary);
-const stepsDefinition = Agent.define("certify-steps", {
+
+const stepsDefinition = Agent.make("certify-steps", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Reserve the itinerary.",
@@ -316,8 +364,10 @@ const BookApproval = Tool.make("book", {
   success: Schema.Struct({ confirmation: Schema.String }),
   needsApproval: true,
 });
+
 const approvalToolkit = Toolkit.make(BookApproval);
-const approvalDefinition = Agent.define("certify-approval", {
+
+const approvalDefinition = Agent.make("certify-approval", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Book after approval.",
@@ -326,7 +376,7 @@ const approvalDefinition = Agent.define("certify-approval", {
 });
 
 /** delegation: durable attached child plus an ordinary uncertain sibling in ONE batch. */
-const childDefinition = Agent.define("certify-child", {
+const childDefinition = Agent.make("certify-child", {
   input: QuestionInput,
   output: AnswerOutput,
   instructions: "Answer as JSON.",
@@ -334,7 +384,7 @@ const childDefinition = Agent.define("certify-child", {
   policy: AgentPolicy.make({
     maxTurns: 2,
     maxToolCalls: 1,
-    maxDuration: "30 seconds",
+    maxDuration: CERTIFICATION_MAX_DURATION,
     toolConcurrency: 1,
   }),
 });
@@ -357,7 +407,7 @@ const researchDelegation = Subagent.define("delegate_research", {
     maxConcurrency: 2,
     maxTurns: 4,
     maxToolCalls: 4,
-    maxDuration: "10 seconds",
+    maxDuration: CERTIFICATION_MAX_DURATION,
   }),
 });
 
@@ -366,7 +416,7 @@ const Lookup = Tool.make("lookup", {
   success: Schema.Struct({ value: Schema.String }),
 });
 
-const coordinatorDefinition = Agent.define("certify-coordinator", {
+const coordinatorDefinition = Agent.make("certify-coordinator", {
   input: Schema.Struct({ mission: Schema.String }),
   output: Schema.Struct({ report: Schema.String }),
   instructions: "Delegate and look up, then answer as JSON.",
@@ -374,7 +424,7 @@ const coordinatorDefinition = Agent.define("certify-coordinator", {
   policy: AgentPolicy.make({
     maxTurns: 4,
     maxToolCalls: 3,
-    maxDuration: "30 seconds",
+    maxDuration: CERTIFICATION_MAX_DURATION,
     toolConcurrency: 2,
   }),
 });
@@ -389,12 +439,14 @@ const identifiers = 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, "certify-fixture-conversation"),
+      nextThreadId: next(decodeThreadId, "certify-fixture-thread"),
       nextRunId: next(Schema.decodeSync(RunId), "certify-fixture-run"),
       nextTurnId: next(Schema.decodeSync(TurnId), "certify-fixture-turn"),
     };
@@ -408,15 +460,15 @@ const delegationSupport = Layer.mergeAll(SubagentReservationsMemoryLive, identif
 // ---------------------------------------------------------------------------
 
 interface CertificationCell {
-  readonly resolver: (typeof AgentBindingResolver)["Service"];
+  readonly bindings: ReadonlyArray<ResolvedBinding>;
   /** Idempotent submission batch — safe to replay verbatim after a submit-boundary fault. */
   readonly submit: Effect.Effect<ReadonlyArray<Receipt>, DurableSubmitFailure, DurableAgentRuntime>;
   /** All lanes of the cell in drive order, computed from the (possibly replayed) receipts. */
-  readonly lanes: (receipts: ReadonlyArray<Receipt>) => ReadonlyArray<ConversationId>;
+  readonly lanes: (receipts: ReadonlyArray<Receipt>) => ReadonlyArray<ThreadId>;
 }
 
-const submitOptionsFor = (slug: string, conversationId: ConversationId): DurableSubmitOptions => ({
-  conversationId,
+const submitOptionsFor = (slug: string, threadId: ThreadId): DurableSubmitOptions => ({
+  threadId,
   principal: PRINCIPAL,
   idempotencyKey: decodeIdempotencyKey(`certify-key-${slug}`),
   definitions: DIGESTS,
@@ -428,20 +480,24 @@ const makeSingleAgentCell = (
   resolved: ResolvedBinding,
   slug: string,
 ): CertificationCell => {
-  const conversationId = decodeConversationId(`certify-${slug}`);
+  const threadId = decodeThreadId(`certify-${slug}`);
+
   const submit = Effect.gen(function* () {
     const runtime = yield* DurableAgentRuntime;
+
     const receipt = yield* runtime.submit(
       { definition: { id: definition.id, input: definition.input } },
       { question: `certify ${slug}` },
-      submitOptionsFor(slug, conversationId),
+      submitOptionsFor(slug, threadId),
     );
+
     return [receipt];
   });
+
   return {
-    resolver: AgentBindingResolver.fromBindings([resolved]),
+    bindings: [resolved],
     submit,
-    lanes: () => [conversationId],
+    lanes: () => [threadId],
   };
 };
 
@@ -455,7 +511,9 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
         plainDefinition,
         promptShapeModel("certify-plain", '{"answer":"done"}'),
       );
+
       const resolved = yield* DurableWorkerBinding.make(binding, DIGESTS);
+
       return makeSingleAgentCell(plainDefinition, resolved, slug);
     }
     case "uncertain-tool": {
@@ -467,12 +525,15 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
           toolTurn(toolCallPart("book-1", "book", { ref: `r-${slug}` })),
         ),
       );
+
       const toolLayer = bookToolkit.toLayer({
         book: ({ ref }) => Effect.succeed({ confirmation: `confirmed-${ref}` }),
       });
+
       const resolved = yield* DurableWorkerBinding.make(binding, DIGESTS).pipe(
         Effect.provide(toolLayer),
       );
+
       return makeSingleAgentCell(uncertainDefinition, resolved, slug);
     }
     case "durable-steps": {
@@ -484,26 +545,32 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
           toolTurn(toolCallPart("itinerary-1", "itinerary", { ref: `trip-${slug}` })),
         ),
       );
+
       const toolLayer = itineraryToolkit.toLayer({
         itinerary: ({ ref }) =>
           Effect.gen(function* () {
             const step = yield* DurableStep;
+
             const flight = yield* step.do(
               "reserve-flight",
               Schema.String,
               Effect.succeed(`flight-${ref}`),
             );
+
             const lodging = yield* step.do(
               "reserve-lodging",
               Schema.String,
               Effect.succeed(`lodging-${ref}`),
             );
+
             return { state: `${flight}+${lodging}` };
           }),
       });
+
       const resolved = yield* DurableWorkerBinding.make(binding, DIGESTS).pipe(
         Effect.provide(toolLayer),
       );
+
       return makeSingleAgentCell(stepsDefinition, resolved, slug);
     }
     case "approval": {
@@ -515,12 +582,15 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
           toolTurn(toolCallPart("book-1", "book", { ref: `r-${slug}` })),
         ),
       );
+
       const toolLayer = approvalToolkit.toLayer({
         book: ({ ref }) => Effect.succeed({ confirmation: `confirmed-${ref}` }),
       });
+
       const resolved = yield* DurableWorkerBinding.make(binding, DIGESTS).pipe(
         Effect.provide(toolLayer),
       );
+
       return makeSingleAgentCell(approvalDefinition, resolved, slug);
     }
     case "join": {
@@ -528,31 +598,39 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
         plainDefinition,
         promptShapeModel("certify-join", '{"answer":"host answer"}'),
       );
+
       const resolved = yield* DurableWorkerBinding.make(binding, DIGESTS);
-      const conversationId = decodeConversationId(`certify-${slug}`);
-      const submitOne = (key: string, question: string) =>
-        Effect.gen(function* () {
-          const runtime = yield* DurableAgentRuntime;
-          return yield* runtime.submit(
-            { definition: { id: plainDefinition.id, input: plainDefinition.input } },
-            { question },
-            {
-              conversationId,
-              principal: PRINCIPAL,
-              idempotencyKey: decodeIdempotencyKey(key),
-              definitions: DIGESTS,
-            },
-          );
-        });
+      const threadId = decodeThreadId(`certify-${slug}`);
+
+      const submitOne = Effect.fn("Certification.submitOne")(function* (
+        key: string,
+        question: string,
+      ) {
+        const runtime = yield* DurableAgentRuntime;
+
+        return yield* runtime.submit(
+          { definition: { id: plainDefinition.id, input: plainDefinition.input } },
+          { question },
+          {
+            threadId,
+            principal: PRINCIPAL,
+            idempotencyKey: decodeIdempotencyKey(key),
+            definitions: DIGESTS,
+          },
+        );
+      });
+
       const cell: CertificationCell = {
-        resolver: AgentBindingResolver.fromBindings([resolved]),
+        bindings: [resolved],
         submit: Effect.gen(function* () {
           const host = yield* submitOne(`certify-key-${slug}-host`, "host question");
           const queued = yield* submitOne(`certify-key-${slug}-queued`, "queued question");
+
           return [host, queued];
         }),
-        lanes: () => [conversationId],
+        lanes: () => [threadId],
       };
+
       return cell;
     }
     case "delegation": {
@@ -560,6 +638,7 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
         childDefinition,
         promptShapeModel("certify-child", '{"answer":"child-answer"}'),
       );
+
       const parentBinding = Agent.withModel(
         coordinatorDefinition,
         promptShapeModel(
@@ -571,36 +650,45 @@ const makeCell = Effect.fn("Certification.makeCell")(function* (
           ),
         ),
       );
+
       const delegationLayer = SubagentRuntime.layer(researchDelegation, childBinding, {
         mapChildFailure,
         durable: { targetDigests: CHILD_DIGEST_STRINGS },
       }).pipe(Layer.provide(delegationSupport));
+
       const lookupLayer = Toolkit.make(Lookup).toLayer({
         lookup: ({ key }) => Effect.succeed({ value: `found-${key}` }),
       });
+
       const parentResolved = yield* DurableWorkerBinding.make(parentBinding, DIGESTS).pipe(
         Effect.provide(Layer.mergeAll(delegationLayer, lookupLayer)),
       );
+
       const childResolved = yield* DurableWorkerBinding.make(childBinding, CHILD_DIGESTS);
-      const conversationId = decodeConversationId(`certify-${slug}`);
+      const threadId = decodeThreadId(`certify-${slug}`);
+
       const cell: CertificationCell = {
-        resolver: AgentBindingResolver.fromBindings([parentResolved, childResolved]),
+        bindings: [parentResolved, childResolved],
         submit: Effect.gen(function* () {
           const runtime = yield* DurableAgentRuntime;
+
           const receipt = yield* runtime.submit(
             { definition: { id: coordinatorDefinition.id, input: coordinatorDefinition.input } },
             { mission: "plan" },
-            submitOptionsFor(slug, conversationId),
+            submitOptionsFor(slug, threadId),
           );
+
           return [receipt];
         }),
         lanes: (receipts) => {
           const parent = receipts.at(0);
+
           return parent === undefined
-            ? [conversationId]
-            : [conversationId, childConversationIdFor(parent.submissionId, DELEGATE_CALL)];
+            ? [threadId]
+            : [threadId, childThreadIdFor(parent.submissionId, DELEGATE_CALL)];
         },
       };
+
       return cell;
     }
   }
@@ -616,56 +704,68 @@ const MAX_REDRIVE_ROUNDS = 8;
  * the digest chain is fully recomputed instead of skipped.
  */
 const verifyLane = Effect.fn("Certification.verifyLane")(function* (
-  lane: ConversationId,
+  lane: ThreadId,
   batchProducers: ReadonlyMap<BatchId, ProducerId>,
 ) {
-  const store = yield* ConversationStore;
+  const store = yield* ThreadStore;
   const ledger = yield* SubmissionLedger;
-  const exported = yield* store.export(ConversationExportRequest.make({ conversationId: lane }));
+  const exported = yield* store.export(ThreadExportRequest.make({ threadId: lane }));
   const rows = new Map<SubmissionId, SubmissionSnapshot>();
   const nonterminal = yield* Stream.runCollect(ledger.scanNonterminal);
+
   for (const submission of nonterminal) {
-    if (submission.conversationId === lane) rows.set(submission.submissionId, submission);
+    if (submission.threadId === lane) rows.set(submission.submissionId, submission);
   }
   const named = new Set<SubmissionId>();
+
   for (const envelope of exported.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);
     }
   }
   for (const submissionId of named) {
     if (rows.has(submissionId)) continue;
     const found = yield* ledger.lookup(SubmissionLookupById.make({ submissionId }));
-    if (Option.isSome(found) && found.value.conversationId === lane) {
+
+    if (Option.isSome(found) && found.value.threadId === lane) {
       rows.set(submissionId, found.value);
     }
   }
-  const checkpoint = yield* store.loadCheckpoint(
-    LoadCheckpointRequest.make({ conversationId: lane }),
-  );
-  return yield* verifyConversationInvariants({
+
+  const checkpoint =
+    store.checkpoints === undefined
+      ? Option.none()
+      : yield* store.checkpoints.load(LoadCheckpointRequest.make({ threadId: lane }));
+
+  return yield* verifyThreadInvariants({
     export: exported,
     submissions: [...rows.values()],
     batchProducers,
     checkpoint: Option.getOrUndefined(checkpoint),
+    checkpointsSupported: store.checkpoints !== undefined,
     requireAllSettled: true,
   });
 });
 
 const failureTagOf = <E>(cause: Cause.Cause<E>): string => {
   const failure = Cause.findErrorOption(cause);
+
   if (Option.isSome(failure)) {
     const error: unknown = failure.value;
+
     if (typeof error === "object" && error !== null && "_tag" in error) {
-      return String((error as { _tag: unknown })._tag);
+      return String(error._tag);
     }
+
     return String(error).slice(0, 256);
   }
+
   return "defect";
 };
 
@@ -676,7 +776,6 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
   batchProducers: ReadonlyMap<BatchId, ProducerId>,
   leaseAdvance: Duration.Duration,
 ) {
-  const runtime = yield* DurableAgentRuntime;
   const ledger = yield* SubmissionLedger;
   const control = yield* DurableRuntimeFailpointTestControl;
   const slug = `${scenario}-${location.replaceAll(":", "-")}`;
@@ -693,9 +792,20 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
 
   const cell = yield* makeCell(scenario, slug);
 
+  const runtime = yield* DurableAgentRuntime.pipe(
+    Effect.provide(
+      DurableAgentRuntime.layerWithBindings(cell.bindings).pipe(
+        Layer.provide(RunToolAuthorization.allowAll),
+      ),
+    ),
+  );
+
+  const submit = cell.submit.pipe(Effect.provideService(DurableAgentRuntime, runtime));
+
   // One-shot arm: the fault fires at most once anywhere in the cell (initial drive OR a
   // re-drive round's public unblocking operation), modelling one crash at this boundary.
   const fired = yield* Ref.make(false);
+
   yield* control.setHandler((hit) =>
     hit !== location
       ? Effect.void
@@ -710,13 +820,16 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
 
   // Submissions are idempotent (DUR-001): one replay recovers a submit-boundary fault.
   let receipts: ReadonlyArray<Receipt>;
-  const firstSubmit = yield* Effect.exit(cell.submit);
+  const firstSubmit = yield* Effect.exit(submit);
+
   if (Exit.isSuccess(firstSubmit)) {
     receipts = firstSubmit.value;
   } else {
-    const secondSubmit = yield* Effect.exit(cell.submit);
+    const secondSubmit = yield* Effect.exit(submit);
+
     if (Exit.isFailure(secondSubmit)) {
       yield* control.clear;
+
       return failed(
         `submission replay did not recover: ${failureTagOf(secondSubmit.cause)}`,
         yield* Ref.get(fired),
@@ -726,24 +839,24 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
   }
   const lanes = cell.lanes(receipts);
 
-  const driveLane = (lane: ConversationId) =>
-    runtime
-      .processConversationResolved(lane)
-      .pipe(Effect.provideService(AgentBindingResolver, cell.resolver));
+  const driveLane = (lane: ThreadId) => runtime.processThreadResolved(lane);
 
   const allSettled = Effect.gen(function* () {
     for (const receipt of receipts) {
       const snapshot = yield* ledger.lookup(
         SubmissionLookupById.make({ submissionId: receipt.submissionId }),
       );
+
       if (Option.isNone(snapshot) || snapshot.value.state !== "settled") return false;
     }
+
     return true;
   });
 
   // Re-drive to convergence using ONLY public operations: worker drives, recovery passes,
-  // and the authorized DUR-017/approval unblocking paths chosen from `explainConversation`.
+  // and the authorized DUR-017/approval unblocking paths chosen from `explainThread`.
   let converged = false;
+
   for (let round = 0; round < MAX_REDRIVE_ROUNDS && !converged; round++) {
     // Expire any lease a faulted Attempt left behind (D5): virtual time is the
     // adapter-neutral reclaim lever — a live lease may block every new claim.
@@ -753,7 +866,8 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
       yield* Effect.exit(driveLane(lane));
     }
     for (const lane of lanes) {
-      const explains = yield* Effect.exit(runtime.explainConversation(lane));
+      const explains = yield* Effect.exit(runtime.explainThread(lane));
+
       if (Exit.isFailure(explains)) continue;
       for (const explanation of explains.value) {
         for (const unknown of explanation.evidence.unknownCalls) {
@@ -774,6 +888,7 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
           const decided = explanation.evidence.approvalDecisions.some(
             (decision) => decision.toolCallId === pending.toolCallId,
           );
+
           if (decided) continue;
           yield* Effect.exit(
             runtime.resolveApproval(
@@ -790,6 +905,7 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
       }
     }
     const settled = yield* Effect.exit(allSettled);
+
     converged = Exit.isSuccess(settled) && settled.value;
   }
   yield* control.clear;
@@ -802,8 +918,10 @@ const runSweepCell = Effect.fn("Certification.runSweepCell")(function* (
   // Every lane of the cell must verify in convergence mode with a recomputed digest chain.
   let digestChainVerified = true;
   const failedChecks: Array<string> = [];
+
   for (const lane of lanes) {
     const verdict = yield* Effect.exit(verifyLane(lane, batchProducers));
+
     if (Exit.isFailure(verdict)) {
       return failed(`lane ${lane} could not be verified: ${failureTagOf(verdict.cause)}`, wasFired);
     }
@@ -864,10 +982,14 @@ export const resolveTierThree = Effect.fn("Certification.resolveTierThree")(func
   }
   if (options.crashLever !== undefined) {
     const cases = yield* options.crashLever;
+
     return CertificationTierThreeReport.make({
-      status: "exercised",
+      status: cases.length === 0 ? "not-exercised" : "exercised",
       evidence: options.tierThreeEvidence ?? [],
       cases,
+      ...(cases.length === 0
+        ? { detail: "the supplied crash lever executed no real-loss cases" }
+        : {}),
     });
   }
   if (options.tierThreeEvidence !== undefined && options.tierThreeEvidence.length > 0) {
@@ -877,6 +999,7 @@ export const resolveTierThree = Effect.fn("Certification.resolveTierThree")(func
       cases: [],
     });
   }
+
   return CertificationTierThreeReport.make({
     status: "not-exercised",
     evidence: [],
@@ -905,13 +1028,15 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
   options: CertifyDurableAdaptersOptions<LedgerE, StoreE>,
 ): Effect.Effect<CertificationReport, LedgerE | StoreE, Crypto.Crypto> => {
   const batchProducers = new Map<BatchId, ProducerId>();
+
   // Interpose the candidate store with an append-time capture of each batch's producer
-  // identity — the one value the ConversationStore port deliberately does not export — so
+  // identity — the one value the ThreadStore port deliberately does not export — so
   // Tier 2's invariant verification recomputes the FULL digest chain instead of skipping it.
-  const capturingStore = Layer.effect(ConversationStore)(
+  const capturingStore = Layer.effect(ThreadStore)(
     Effect.gen(function* () {
-      const inner = yield* ConversationStore;
-      return ConversationStore.of({
+      const inner = yield* ThreadStore;
+
+      return ThreadStore.of({
         ...inner,
         append: (request) =>
           Effect.sync(() => {
@@ -919,13 +1044,15 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
           }).pipe(Effect.andThen(inner.append(request))),
       });
     }),
-  ).pipe(Layer.provide(options.conversationStore));
+  ).pipe(Layer.provide(options.threadStore));
 
-  const support = Layer.mergeAll(
+  // RUN-036: certification uses the default-none Tool failure observer. Trusted application
+  // reporting adds no durable transition and is verified separately from adapter certification.
+  const environment = Layer.mergeAll(
     options.submissionLedger,
     capturingStore,
     options.wakeScheduler ?? WakeScheduler.layerNoop,
-    DurableRuntimeFailpoint.layerTest,
+    DurableRuntimeFailpointTestControl.layer,
     ToolReconciler.uncertain,
     DurableRuntimeConfig.layer({
       deploymentId: Schema.decodeSync(DeploymentId)("deployment-certification"),
@@ -935,7 +1062,6 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
       abortPollInterval: Duration.millis(50),
     }),
   );
-  const environment = DurableAgentRuntime.layer.pipe(Layer.provideMerge(support));
 
   const leaseAdvance = Duration.millis(
     Duration.toMillis(options.ownershipLeaseDuration ?? DEFAULT_OWNERSHIP_LEASE_DURATION) + 1_000,
@@ -946,6 +1072,7 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
 
     // Tier 2 — coordinator failpoint convergence sweep.
     const tier2: Array<CertificationSweepResult> = [];
+
     for (const scenario of CERTIFICATION_SCENARIOS) {
       for (const location of DurableRuntimeFailpointLocation.literals) {
         tier2.push(yield* runSweepCell(scenario, location, batchProducers, leaseAdvance));
@@ -960,13 +1087,14 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
     const tier3 = yield* resolveTierThree(capabilities.durability, options);
 
     const generatedAt = yield* nowUtc;
+
     const ok =
       tier1.every((result) => result.status === "passed") &&
       tier2.every((result) => result.status !== "failed") &&
       tier3.cases.every((result) => result.status === "passed");
 
     return CertificationReport.make({
-      format: "effect-agent/certification@1",
+      format: "effect-agent/certification@2",
       adapter: CertifiedAdapterIdentity.make({
         name: options.adapter.name,
         ...(options.adapter.version === undefined ? {} : { version: options.adapter.version }),
@@ -977,6 +1105,12 @@ export const certifyDurableAdapters = <LedgerE = never, StoreE = never>(
       tier2,
       tier3,
       ok,
+      fullyCertified:
+        ok &&
+        capabilities.durability !== "non-durable" &&
+        tier3.status === "exercised" &&
+        tier3.cases.length > 0 &&
+        tier3.cases.every((result) => result.suite === "real-loss"),
     });
   });