@xema/omni-protocol 0.1.111 → 0.1.113

package/dist/testing.js

@@ -1,5 +1,5 @@
 import { browserSessionKey, effectiveLevels, sameCapabilities, } from "./index.js";
-import { assertNoViolations, validateAuthenticationState, validateBreakTransition, validateEventEnvelope, validateHostGuarantees, validateHostReport, validateUserDetails, observeRules, ruleEvaluated, validateHostMute, validateHostRecording, validateLoginStore, validateHistoryReport, validateManifest, validateResult, validateSnapshot, validateTask, validateTimeZone, validatePhone, validateTaskCommand, isTimeZone, sameTimeZone, } from "./validation.js";
+import { assertNoViolations, validateAuthenticationState, validateBreakTransition, validateEventEnvelope, validateHostGuarantees, validateHostReport, validateUserDetails, observeRules, ruleTested, validateHostMute, validateHostRecording, validateLoginStore, validateHistoryReport, validateManifest, validateResult, validateSnapshot, validateTask, validateTimeZone, validatePhone, validateTaskCommand, isTimeZone, sameTimeZone, } from "./validation.js";
 export { ProtocolConformanceError, assertNoViolations } from "./validation.js";
 /**
  * A part of the contract a run may never reach: state nothing obliges an adapter to publish, so
@@ -212,9 +212,9 @@ function observeEvent(envelope, seen) {
  * for a synchronous emitter, and is swallowed as an unhandled rejection for an
  * asynchronous one — which would let a non-conforming async adapter pass.
  */
-export async function exerciseAdapter(adapter, context, options = {}) {
-    const rulesEvaluated = new Set();
-    const stopObserving = observeRules(rule => { rulesEvaluated.add(rule); });
+export async function testAdapter(adapter, context, options = {}) {
+    const rulesTested = new Set();
+    const stopObserving = observeRules(rule => { rulesTested.add(rule); });
     const violations = [...validateManifest(adapter.manifest)];
     const events = [];
     const seen = new Set();
@@ -388,7 +388,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
         const tellRefused = (report) => {
             if (typeof live.refused !== "function")
                 return;
-            ruleEvaluated("connection.refused.rejected");
+            ruleTested("connection.refused.rejected");
             try {
                 live.refused(report);
             }
@@ -398,7 +398,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
         };
         const eventPayloads = new Map();
         let capacityStated;
-        // The drive waits on events: each waiter is offered every envelope as it lands.
+        // The test waits on events: each waiter is offered every envelope as it lands.
         const waiters = new Set();
         const onEnvelope = (envelope) => {
             observeEvent(envelope, seen);
@@ -408,10 +408,10 @@ export async function exerciseAdapter(adapter, context, options = {}) {
                 tellRefused({ artefact: "event", envelopeId: typeof envelope?.id === "string" ? envelope.id : undefined, violations: broken });
             // A diagnostic is informational to a host and a failure to a conformance run: the platform
             // under test broke a rule the adapter relies on, and a green result must not paper over it.
-            // A reload in life has no first connection: the page is gone. The drive keeps its first
+            // A reload in life has no first connection: the page is gone. The test keeps its first
             // connection up while the second reads, so a platform that pushes the open task to the new
             // client pushes it to the old one too, and an adapter that calls a re-offer of answered work a
-            // defect is right to. That diagnostic is the drive's own artefact, and is not counted while the
+            // defect is right to. That diagnostic is the test's own artefact, and is not counted while the
             // second adapter is up; every other moment it is.
             if (isRecord(envelope?.event) && envelope.event.type === "diagnostic") {
                 violations.push({ rule: "diagnostic.raised", path: "event.diagnostic",
@@ -469,7 +469,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
                 waiter(envelope);
         };
         unsubscribe = connection.subscribe(onEnvelope);
-        // A host reload is the first client dying and a second coming up in its place. The drive hands
+        // A host reload is the first client dying and a second coming up in its place. The test hands
         // the run over: the first connection is unsubscribed, disconnected and its session closed before
         // the second connects, and the run continues on the second -- so there is no first client for a
         // platform to push the open task back to, and nothing to exempt.
@@ -519,8 +519,8 @@ export async function exerciseAdapter(adapter, context, options = {}) {
                 // holds its connect snapshot to no team until it is sent again, after its capacity.
                 leadFeaturesOn = false;
                 const restated = await second.setCapacity({ count: capacityStated ?? 1 });
-                violations.push(...validateResult(restated, "setCapacity", "drive.reload.setCapacity"));
-                await switchOnLeadFeatures(second, "drive.reload");
+                violations.push(...validateResult(restated, "setCapacity", "test.reload.setCapacity"));
+                await switchOnLeadFeatures(second, "test.reload");
             },
         };
         // Every snapshot the run reads, the connect snapshot and a reloaded client's, is read the same
@@ -578,7 +578,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
                 continue;
             }
             // Evaluated where a superseded event was held: with none, the question was never asked.
-            ruleEvaluated("snapshot.accounts.task", "snapshot.accounts.ended");
+            ruleTested("snapshot.accounts.task", "snapshot.accounts.ended");
             if ((event.type === "task-offered" || event.type === "task-updated") && isRecord(event.task) && typeof event.task.assignmentId === "string" && !carried.has(event.task.assignmentId)) {
                 violations.push({ rule: "snapshot.accounts.task", path: "snapshot.tasks",
                     message: `${String(event.task.assignmentId)} (${event.task.assignmentId}) was published while the snapshot was read and the snapshot does not carry it: a snapshot accounts for everything the adapter emitted before it resolved` });
@@ -596,7 +596,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
         // ready, and on every change. An adapter that never asked cannot have.
         // The obligation has two halves: read the report before declaring the agent ready, and hear of
         // every change after. An adapter that did one and not the other consulted the host once, or never.
-        ruleEvaluated("connection.host.consulted", "connection.host.subscribed");
+        ruleTested("connection.host.consulted", "connection.host.subscribed");
         if (adapter.manifest.channel === "voice" && !consulted.report) {
             violations.push({ rule: "connection.host.consulted", path: "connection.host",
                 message: "a voice adapter reads the host's report before it declares the agent ready to its platform, and this one never asked" });
@@ -642,8 +642,8 @@ export async function exerciseAdapter(adapter, context, options = {}) {
             if (switched === undefined)
                 return;
             violations.push(...validateResult(switched, "executeTeam", `${at}.executeTeam`));
-            ruleEvaluated("team.required");
-            const ms = options.driveTimeoutMs ?? 5000;
+            ruleTested("team.required");
+            const ms = options.timeoutMs ?? 5000;
             const isBaseline = (envelope) => isRecord(envelope?.event) && envelope.event.type === "team-updated";
             const baseline = events.slice(from).some(isBaseline) || await new Promise(resolve => {
                 const timer = setTimeout(() => { waiters.delete(waiter); resolve(false); }, ms);
@@ -661,19 +661,19 @@ export async function exerciseAdapter(adapter, context, options = {}) {
                     message: `the application switched the team feature on and no team-updated followed within ${ms}ms: the whole team is owed once it is on, members: [] when nobody is in it` });
         };
         await switchOnLeadFeatures(live, "connection");
-        if (options.drive) {
+        if (options.withCall) {
             const localAudio = isRecord(first) && isRecord(first.audio) && isRecord(first.audio.input) && first.audio.input.status === "available"
                 ? first.audio.input.localAudio : undefined;
-            violations.push(...await driveOneCall({
+            violations.push(...await testOneCall({
                 connection: live, manifest: adapter.manifest, channel: adapter.manifest.channel, softphone, snapshot, events, waiters, stream, localAudio,
                 everHeldForTask: (taskId) => [...watched.everHeld].some(key => namesTask(key, taskId)), snapshotRead,
-                timeoutMs: options.driveTimeoutMs ?? 5000,
+                timeoutMs: options.timeoutMs ?? 5000,
                 context: connected, secrets: authenticationSecrets, reader, rebuild: options.rebuild, held: watched.held, handOver,
                 streams: { stream, breaks, team },
             }));
-            // Every offer is owed an ending. The drive ends the call it drove; anything else the
+            // Every offer is owed an ending. The test ends the call it drove; anything else the
             // provider offered and left open is an assignment whose ending never came.
-            ruleEvaluated("stream.taskOffered.unended");
+            ruleTested("stream.taskOffered.unended");
             for (const id of stream.unended()) {
                 violations.push({ rule: "stream.taskOffered.unended", path: "event.task-ended",
                     message: `${id} was offered and never ended: every offer is owed a task-ended, whatever became of the call` });
@@ -750,10 +750,10 @@ export async function exerciseAdapter(adapter, context, options = {}) {
         events: events,
         authenticationState: authenticationState,
         login: (login ?? authenticationState),
-        notExercised: CONTRACT_SUBJECTS.filter(subject => !seen.has(subject)),
+        notTested: CONTRACT_SUBJECTS.filter(subject => !seen.has(subject)),
         disconnectWasClean,
         violations,
-        rulesEvaluated,
+        rulesTested,
     };
 }
 /**
@@ -1036,7 +1036,7 @@ export function assertTaskCapabilityWithdrawal(tasks, manifest, command) {
  * so a fixture that never produced a team member list cannot pass a test that meant to check one.
  */
 export function assertReached(result, subjects) {
-    const missed = subjects.filter(subject => result.notExercised.includes(subject));
+    const missed = subjects.filter(subject => result.notTested.includes(subject));
     if (missed.length > 0) {
         throw new Error(`The exercise never reached ${missed.join(", ")}: its clean result says nothing about them`);
     }
@@ -1139,6 +1139,36 @@ export class TaskStream {
     endedAssignments = new Set();
     /** Every assignment a `task-offered` introduced, as against one a snapshot carried: each is owed its ending. */
     offered = new Set();
+    /** The last seconds-left value the stream read per task and field, with the provider instant it was published at. */
+    countdowns = new Map();
+    /**
+     * A seconds-left value is the provider's arithmetic at the instant of the publication, never a
+     * value copied from an earlier one: between two publications the countdown loses at least the
+     * seconds the provider's own clock says passed, within a second of rounding.
+     */
+    holdCountdowns(id, task, publishedAt, at, refuse) {
+        const atMs = typeof publishedAt === "string" ? Date.parse(publishedAt) : Number.NaN;
+        if (!isRecord(task) || Number.isNaN(atMs))
+            return;
+        const known = this.countdowns.get(id) ?? new Map();
+        for (const field of ["expiresInSeconds", "previewEndsInSeconds", "wrapEndsInSeconds"]) {
+            const value = task[field];
+            if (typeof value !== "number") {
+                known.delete(field);
+                continue;
+            }
+            const before = known.get(field);
+            if (before !== undefined) {
+                ruleTested("stream.countdown.copied");
+                const elapsed = Math.floor((atMs - before.atMs) / 1000);
+                if (elapsed > 0 && value > before.value - elapsed + 1) {
+                    refuse("stream.countdown.copied", `${at}.${field}`, `${id} said ${field} ${before.value} at ${new Date(before.atMs).toISOString()} and ${value} at ${new Date(atMs).toISOString()}: ${elapsed}s passed on the provider's clock and the countdown lost fewer; seconds left are worked out at each publication, never copied from the one before`);
+                }
+            }
+            known.set(field, { value, atMs });
+        }
+        this.countdowns.set(id, known);
+    }
     // Every dial the stream can place an outcome against: one the host said it placed, or one a
     // task carried on `onCall` or in its record -- which is how a dial made before a take-over is known
     // to whoever holds the task now. `answered` or `ended` once its outcome arrived, since it comes once.
@@ -1235,11 +1265,16 @@ export class TaskStream {
     resync(snapshot, at) {
         const found = [];
         const refuse = (rule, where, message) => found.push({ rule, path: where, message });
-        ruleEvaluated("stream.snapshot.capabilitySource", "stream.snapshot.history", "stream.snapshot.phase", "stream.snapshot.audio");
+        ruleTested("stream.snapshot.capabilitySource", "stream.snapshot.history", "stream.snapshot.phase", "stream.snapshot.audio");
         if (isRecord(snapshot) && Array.isArray(snapshot.tasks)) {
             snapshot.tasks.forEach((task, index) => {
                 if (!isRecord(task) || typeof task.assignmentId !== "string")
                     return;
+                // A snapshot from a provider with a clock is a publication at providerTime; the countdowns it carries are held to it.
+                if (typeof snapshot.providerTime === "string")
+                    this.holdCountdowns(task.assignmentId, task, snapshot.providerTime, `${at}.tasks[${index}]`, refuse);
+                else
+                    this.countdowns.delete(task.assignmentId);
                 const was = this.tasks.get(task.assignmentId);
                 if (was === undefined)
                     return;
@@ -1296,7 +1331,7 @@ export class TaskStream {
                 found.push(...this.resync(event.snapshot, `${at}.snapshot`));
                 break;
             case "task-offered": {
-                ruleEvaluated("stream.taskOffered.duplicate");
+                ruleTested("stream.taskOffered.duplicate");
                 if (id === undefined)
                     break;
                 // An assignment is introduced once: not while it is open, and never again once it has ended,
@@ -1308,18 +1343,20 @@ export class TaskStream {
                 this.offered.add(id);
                 this.tasks.set(id, TaskStream.stated(event.task));
                 this.noteDials(event.task);
+                this.holdCountdowns(id, event.task, isRecord(envelope) ? envelope.occurredAt : undefined, `${at}.task`, refuse);
                 break;
             }
             case "task-updated":
                 if (id === undefined)
                     break;
-                ruleEvaluated("stream.taskUpdated.unknown");
+                ruleTested("stream.taskUpdated.unknown");
                 if (known === undefined) {
                     refuse("stream.taskUpdated.unknown", `${at}.task.assignmentId`, `${id} was never offered or carried on a snapshot`);
                     break;
                 }
                 // The rules about a known task are evaluated only once there is one.
-                ruleEvaluated("stream.taskUpdated.capabilitySource", "stream.taskUpdated.phase", "stream.taskUpdated.audioOpen", "stream.taskUpdated.history", "stream.taskAudioEnded.follow", "stream.taskUpdated.audio", "stream.taskUpdated.stage", "stream.taskUpdated.stage.lingering");
+                this.holdCountdowns(id, event.task, isRecord(envelope) ? envelope.occurredAt : undefined, `${at}.task`, refuse);
+                ruleTested("stream.taskUpdated.capabilitySource", "stream.taskUpdated.phase", "stream.taskUpdated.audioOpen", "stream.taskUpdated.history", "stream.taskAudioEnded.follow", "stream.taskUpdated.audio", "stream.taskUpdated.stage", "stream.taskUpdated.stage.lingering");
                 // Terms once read stay read. A re-read that fails is not a new fact about the task, so the
                 // last statement stands and the failure is a diagnostic; not-yet-read is a place a task
                 // starts from, never one it returns to.
@@ -1351,7 +1388,7 @@ export class TaskStream {
                 }
                 // A task completes after its audio ends, never around it: an update that moves a task to
                 // completing while the stream holds its audio as started is a call whose audio never ended,
-                // whoever caused the ending -- the drive's end-call, a take-over, the provider's own hand.
+                // whoever caused the ending -- the test's end-call, a take-over, the provider's own hand.
                 {
                     const to = isRecord(event.task) ? String(event.task.phase) : "";
                     if (to === "completing" && known.audio === "started" && known.phase !== "completing") {
@@ -1391,7 +1428,7 @@ export class TaskStream {
                 this.noteDials(event.task);
                 break;
             case "task-audio-started":
-                ruleEvaluated("stream.taskAudioStarted.beforeWork", "stream.taskAudioStarted.duplicate", "stream.taskAudio.channel", "stream.assignment.ended", "stream.assignment.unknown");
+                ruleTested("stream.taskAudioStarted.beforeWork", "stream.taskAudioStarted.duplicate", "stream.taskAudio.channel", "stream.assignment.ended", "stream.assignment.unknown");
                 if (id === undefined)
                     break;
                 if (known === undefined) {
@@ -1413,7 +1450,7 @@ export class TaskStream {
                 known.audio = "started";
                 break;
             case "task-audio-ended":
-                ruleEvaluated("stream.taskAudioEnded.beforeWork", "stream.taskAudioEnded.silent", "stream.taskAudio.channel", "stream.assignment.ended", "stream.assignment.unknown");
+                ruleTested("stream.taskAudioEnded.beforeWork", "stream.taskAudioEnded.silent", "stream.taskAudio.channel", "stream.assignment.ended", "stream.assignment.unknown");
                 if (id === undefined)
                     break;
                 if (known === undefined) {
@@ -1433,7 +1470,7 @@ export class TaskStream {
                 known.audio = "ended";
                 break;
             case "task-ended":
-                ruleEvaluated("stream.assignment.ended", "stream.assignment.unknown");
+                ruleTested("stream.assignment.ended", "stream.assignment.unknown");
                 if (id === undefined)
                     break;
                 if (known === undefined) {
@@ -1443,7 +1480,7 @@ export class TaskStream {
                 // A voice task ends after its audio ends, never around it, whatever the outcome: a take-over
                 // and a lead leaving included. An ending with the audio still up leaves the host holding an
                 // open audio session and an open leg on a task that no longer exists.
-                ruleEvaluated("stream.taskEnded.audioOpen");
+                ruleTested("stream.taskEnded.audioOpen");
                 if (known.audio === "started") {
                     refuse("stream.taskEnded.audioOpen", `${at}.assignmentId`, `${id} ended with its audio still started: the audio ends first, on task-audio-ended, whatever the outcome`);
                 }
@@ -1451,7 +1488,7 @@ export class TaskStream {
                 // provider's word that interaction ended and the moment the wrap allowance starts. A provider
                 // that completes the task itself with an allowance to run has to have started the clock:
                 // completed from in-progress, the allowance it stated was never given.
-                ruleEvaluated("stream.taskEnded.unwrapped");
+                ruleTested("stream.taskEnded.unwrapped");
                 // An agent's own complete cuts the wrap short from wherever the task stands, so that ending says by agent and is not this.
                 if (known.channel !== "voice" && known.completionMode === "provider-automatic" && known.wrapAllowance !== undefined && known.wrapAllowance > 0
                     && known.phase !== "completing" && isRecord(event.outcome) && event.outcome.type === "completed" && event.outcome.by === "provider") {
@@ -1464,7 +1501,7 @@ export class TaskStream {
                 // An outcome ends a dial somebody placed, once. The task it names may already have ended;
                 // a dial placed late routinely outlives its call, which is why the dial has its own identity,
                 // and why the outcome names the assignment: the host routes it to that life, ended or not.
-                ruleEvaluated("stream.assignment.unknown");
+                ruleTested("stream.assignment.unknown");
                 if (typeof event.assignmentId === "string" && !this.assignments.has(event.assignmentId)) {
                     refuse("stream.assignment.unknown", `${at}.assignmentId`, `${event.assignmentId} is not an assignment this stream has seen`);
                 }
@@ -1490,24 +1527,24 @@ export class TaskStream {
  * One ordinary lifecycle on the first task offered, each step held to the rules a host holds a
  * provider to: the command validated against the task as published, the result validated for the
  * method, and the event the provider owes in return awaited -- a step that never arrives is a
- * violation naming what was owed. The drive stops where the task offers no way on (no `endCall`,
+ * violation naming what was owed. The test stops where the task offers no way on (no `endCall`,
  * a provider that completes for itself) and says nothing about what it could not reach.
  */
-async function driveOneCall(drive) {
+async function testOneCall(call) {
     const found = [];
     const refuse = (rule, path, message) => found.push({ rule, path, message });
     const isTask = (value) => isRecord(value) && typeof value.assignmentId === "string";
     // Wait for an envelope that satisfies `matches`, looking first at what already arrived.
-    const waitFor = (what, matches, from, within = { ms: drive.timeoutMs, onExpiry: () => refuse("drive.timeout", "drive", `the provider owed ${what} within ${drive.timeoutMs}ms and it never arrived`) }) => new Promise(resolve => {
-        for (let index = from; index < drive.events.length; index += 1) {
-            const hit = matches(drive.events[index]);
+    const waitFor = (what, matches, from, within = { ms: call.timeoutMs, onExpiry: () => refuse("test.timeout", "test", `the provider owed ${what} within ${call.timeoutMs}ms and it never arrived`) }) => new Promise(resolve => {
+        for (let index = from; index < call.events.length; index += 1) {
+            const hit = matches(call.events[index]);
             if (hit !== undefined) {
                 resolve({ found: hit, at: index + 1 });
                 return;
             }
         }
         const timer = setTimeout(() => {
-            drive.waiters.delete(waiter);
+            call.waiters.delete(waiter);
             within.onExpiry();
             resolve(undefined);
         }, within.ms);
@@ -1516,45 +1553,45 @@ async function driveOneCall(drive) {
             if (hit === undefined)
                 return;
             clearTimeout(timer);
-            drive.waiters.delete(waiter);
-            resolve({ found: hit, at: drive.events.length });
+            call.waiters.delete(waiter);
+            resolve({ found: hit, at: call.events.length });
         };
-        drive.waiters.add(waiter);
+        call.waiters.add(waiter);
     });
     // The call's audio session, opened on the first client and opened again on a reloaded second.
     let session;
     const recordSurvivesReload = async (at) => {
         // Each reload rule is marked where it is decided, never up front: a rebuild that throws has looked at nothing else.
-        ruleEvaluated("drive.reload.rejected");
+        ruleTested("test.reload.rejected");
         let again;
         try {
-            again = drive.rebuild();
+            again = call.rebuild();
         }
         catch (error) {
-            refuse("drive.reload.rejected", "drive.reload", `building the adapter again threw: ${String(error)}`);
+            refuse("test.reload.rejected", "test.reload", `building the adapter again threw: ${String(error)}`);
             return;
         }
         // The same provider, built again: a different manifest is a different adapter, and proves nothing about this one.
-        ruleEvaluated("drive.reload.manifest");
-        if (again.manifest.id !== drive.manifest.id) {
-            refuse("drive.reload.manifest", "drive.reload.manifest", `rebuild returned an adapter for ${String(again.manifest.id)}; the reload is of ${String(drive.manifest.id)}`);
+        ruleTested("test.reload.manifest");
+        if (again.manifest.id !== call.manifest.id) {
+            refuse("test.reload.manifest", "test.reload.manifest", `rebuild returned an adapter for ${String(again.manifest.id)}; the reload is of ${String(call.manifest.id)}`);
             return;
         }
         // The first client dies first, as it does on a reload: from here the run has no connection until the second stands.
-        ruleEvaluated("drive.reload.handover");
-        if (!await drive.handOver.down()) {
-            refuse("drive.reload.handover", "drive.reload", "taking the first client down threw: an unsubscribe, disconnect() or close() failed");
+        ruleTested("test.reload.handover");
+        if (!await call.handOver.down()) {
+            refuse("test.reload.handover", "test.reload", "taking the first client down threw: an unsubscribe, disconnect() or close() failed");
         }
         try {
-            const restoredSession = await again.createAuthenticationSession({ ...drive.context, secrets: drive.secrets });
+            const restoredSession = await again.createAuthenticationSession({ ...call.context, secrets: call.secrets });
             // The reload is a restore before it is anything else: the second session stands authenticated
             // as the same person, from the secrets alone, or nothing it reads afterwards is this login's.
             const restored = await restoredSession.state();
-            found.push(...validateAuthenticationState(restored, "drive.reload.login"));
-            ruleEvaluated("drive.reload.login");
-            const same = isRecord(restored) && restored.status === "authenticated" && isRecord(restored.identity) && restored.identity.id === drive.reader().self;
+            found.push(...validateAuthenticationState(restored, "test.reload.login"));
+            ruleTested("test.reload.login");
+            const same = isRecord(restored) && restored.status === "authenticated" && isRecord(restored.identity) && restored.identity.id === call.reader().self;
             if (!same) {
-                refuse("drive.reload.login", "drive.reload.login", `a second adapter built from the same login and secrets did not restore it: the session says ${String(isRecord(restored) ? restored.status : restored)}${isRecord(restored) && isRecord(restored.identity) ? ` as ${String(restored.identity.id)}` : ""}, and the login is ${String(drive.reader().self)}`);
+                refuse("test.reload.login", "test.reload.login", `a second adapter built from the same login and secrets did not restore it: the session says ${String(isRecord(restored) ? restored.status : restored)}${isRecord(restored) && isRecord(restored.identity) ? ` as ${String(restored.identity.id)}` : ""}, and the login is ${String(call.reader().self)}`);
                 // A reload that cannot restore the login is a sign-in screen, not a connection: the run ends here.
                 try {
                     await restoredSession.close();
@@ -1562,27 +1599,27 @@ async function driveOneCall(drive) {
                 catch { /* the session that would not restore is closed as far as it can be */ }
                 return;
             }
-            const second = await again.connect(drive.context);
+            const second = await again.connect(call.context);
             // From here the second client is the run's connection, held to everything the first was on
             // connect: what it publishes is validated as before.
-            await drive.handOver.up(restoredSession, second);
-            drive.connection = second;
+            await call.handOver.up(restoredSession, second);
+            call.connection = second;
             const snapshot = await second.snapshot();
             // The second adapter's snapshot is read as the connect snapshot was, and the streams take it
             // as the state now the way they take any resync: held to what they knew, then replaced. A reload
             // is a place the stream's rules keep working, not one where they all stop.
-            await drive.snapshotRead(second, snapshot, "drive.reload.snapshot");
-            found.push(...drive.streams.stream.resync(snapshot, "drive.reload.snapshot"));
-            found.push(...drive.streams.breaks.seed(snapshot));
-            drive.streams.team.seed(snapshot);
+            await call.snapshotRead(second, snapshot, "test.reload.snapshot");
+            found.push(...call.streams.stream.resync(snapshot, "test.reload.snapshot"));
+            found.push(...call.streams.breaks.seed(snapshot));
+            call.streams.team.seed(snapshot);
             const carried = isRecord(snapshot) && Array.isArray(snapshot.tasks)
                 ? snapshot.tasks.find(task => isRecord(task) && task.assignmentId === taskId) : undefined;
-            ruleEvaluated("drive.reload.snapshot");
+            ruleTested("test.reload.snapshot");
             if (carried === undefined) {
-                refuse("drive.reload.snapshot", "drive.reload.snapshot", `a second adapter built from the same login does not carry ${taskId} on its snapshot, and the task is still open`);
+                refuse("test.reload.snapshot", "test.reload.snapshot", `a second adapter built from the same login does not carry ${taskId} on its snapshot, and the task is still open`);
                 return;
             }
-            ruleEvaluated("drive.reload.history");
+            ruleTested("test.reload.history");
             const history = carried.history;
             const steps = isRecord(history) && Array.isArray(history.steps) ? history.steps : [];
             // A record once read is not unread across a reload either: every entry the first adapter published is here.
@@ -1591,41 +1628,41 @@ async function driveOneCall(drive) {
             const lost = wasRead.filter(entry => !steps.some(now => isRecord(now) && now.step === entry.step && now.at === entry.at))
                 .map(entry => `${String(entry.step)}@${String(entry.at)}`);
             if (lost.length > 0) {
-                refuse("drive.reload.history", "drive.reload.history", `a second adapter built from the same login carries ${taskId} without ${lost.join(", ")}, which the first had published: a record once read is not unread`);
+                refuse("test.reload.history", "test.reload.history", `a second adapter built from the same login carries ${taskId} without ${lost.join(", ")}, which the first had published: a record once read is not unread`);
             }
             const leg = steps.find(entry => isRecord(entry) && entry.step === "muted" && entry.at === at);
             if (leg === undefined) {
-                refuse("drive.reload.history", "drive.reload.history", `a second adapter built from the same login carries ${taskId} without the muted leg at ${at}: the record was composed in memory and died with the adapter; the login's store is where it lives`);
+                refuse("test.reload.history", "test.reload.history", `a second adapter built from the same login carries ${taskId} without the muted leg at ${at}: the record was composed in memory and died with the adapter; the login's store is where it lives`);
             }
             else if (leg.mutedBy !== "host") {
-                refuse("drive.reload.history", "drive.reload.history", `the reloaded record's muted leg at ${at} says mutedBy ${String(leg.mutedBy)}; the host reported host`);
+                refuse("test.reload.history", "test.reload.history", `the reloaded record's muted leg at ${at} says mutedBy ${String(leg.mutedBy)}; the host reported host`);
             }
-            // The drive goes on with the task as the reloaded client holds it. The first client's audio
+            // The test goes on with the task as the reloaded client holds it. The first client's audio
             // session died with it: a host opens audio on a task arriving with audio started on a
-            // snapshot, so the drive opens it again on the second and holds the answer as it held the first.
+            // snapshot, so the test opens it again on the second and holds the answer as it held the first.
             task = carried;
-            if (drive.softphone && carried.audio === "started") {
+            if (call.softphone && carried.audio === "started") {
                 if (session !== undefined && typeof session.close === "function") {
                     try {
                         session.close();
                     }
                     catch {
-                        refuse("drive.openAudio.close", "drive.openAudio", "the first client's audio session threw on close");
+                        refuse("test.openAudio.close", "test.openAudio", "the first client's audio session threw on close");
                     }
                 }
                 session = undefined;
-                ruleEvaluated("drive.reload.openAudio");
-                const reopened = await second.openAudio?.({ assignmentId: taskId, localAudio: drive.localAudio });
-                const malformed = validateResult(reopened, "openAudio", "drive.reload.openAudio");
+                ruleTested("test.reload.openAudio");
+                const reopened = await second.openAudio?.({ assignmentId: taskId, localAudio: call.localAudio });
+                const malformed = validateResult(reopened, "openAudio", "test.reload.openAudio");
                 found.push(...malformed);
                 if (malformed.length === 0 && isRecord(reopened) && reopened.status === "opened")
                     session = reopened.audio;
                 else if (malformed.length === 0)
-                    refuse("drive.reload.openAudio", "drive.reload.openAudio", `a second adapter built from the same login could not open the audio of ${taskId}, which its own snapshot carries with audio started`);
+                    refuse("test.reload.openAudio", "test.reload.openAudio", `a second adapter built from the same login could not open the audio of ${taskId}, which its own snapshot carries with audio started`);
             }
         }
         catch (error) {
-            refuse("drive.reload.rejected", "drive.reload", `the second adapter rejected rather than answered: ${String(error)}`);
+            refuse("test.reload.rejected", "test.reload", `the second adapter rejected rather than answered: ${String(error)}`);
         }
     };
     // A task's keys are gone with the task. A task-scoped key carries the task id, so the watched
@@ -1638,28 +1675,28 @@ async function driveOneCall(drive) {
         // A task's key names the task delimited, not as a run of characters inside another id, and the
         // rule is evaluated only where the store was ever seen to hold such a key: an adapter whose keys
         // name nothing the harness can see leaves the rule unasked, which the result says.
-        const retained = [...drive.held].filter(key => namesTask(key, taskId));
+        const retained = [...call.held].filter(key => namesTask(key, taskId));
         retainedAtEnd = new Set(retained);
-        if (drive.everHeldForTask(taskId))
-            ruleEvaluated("drive.store.retained");
+        if (call.everHeldForTask(taskId))
+            ruleTested("test.store.retained");
         if (retained.length > 0) {
-            refuse("drive.store.retained", "drive.store", `${taskId} has ended and the login's store still holds ${retained.join(", ")}: a task's keys go with the task, or the next offer of the same id inherits them`);
+            refuse("test.store.retained", "test.store", `${taskId} has ended and the login's store still holds ${retained.join(", ")}: a task's keys go with the task, or the next offer of the same id inherits them`);
         }
     };
     // A key written about the task after its end -- a persist hung off a timer, a late command -- is the
-    // same hazard arriving later, so the store is read once more when the drive is done.
+    // same hazard arriving later, so the store is read once more when the test is done.
     const nothingLate = () => {
         if (retainedAtEnd === undefined)
             return;
-        ruleEvaluated("drive.store.late");
-        const late = [...drive.held].filter(key => namesTask(key, taskId) && !retainedAtEnd.has(key));
+        ruleTested("test.store.late");
+        const late = [...call.held].filter(key => namesTask(key, taskId) && !retainedAtEnd.has(key));
         if (late.length > 0) {
-            refuse("drive.store.late", "drive.store", `${taskId} had ended with its keys gone, and the login's store now holds ${late.join(", ")}: something wrote about the task after its end`);
+            refuse("test.store.late", "test.store", `${taskId} had ended with its keys gone, and the login's store now holds ${late.join(", ")}: something wrote about the task after its end`);
         }
     };
     // The task, as first seen: on the snapshot, or on the first offer.
     let cursor = 0;
-    let task = isRecord(drive.snapshot) && Array.isArray(drive.snapshot.tasks) ? drive.snapshot.tasks.find(isTask) : undefined;
+    let task = isRecord(call.snapshot) && Array.isArray(call.snapshot.tasks) ? call.snapshot.tasks.find(isTask) : undefined;
     if (task === undefined) {
         const offered = await waitFor("a task-offered", envelope => {
             const event = envelope.event;
@@ -1670,46 +1707,46 @@ async function driveOneCall(drive) {
         task = offered.found;
         cursor = offered.at;
     }
-    const taskId = task.assignmentId;
+    let taskId = task.assignmentId;
     const latestTask = () => task;
-    const updated = (until, what) => waitFor(what, envelope => {
+    const updated = (until, what, within) => waitFor(what, envelope => {
         const event = envelope.event;
         if ((event.type === "task-updated" || event.type === "task-offered") && isTask(event.task) && event.task.assignmentId === taskId) {
             task = event.task;
             return until(event.task) ? event.task : undefined;
         }
         return undefined;
-    }, cursor).then(hit => { if (hit)
+    }, cursor, within).then(hit => { if (hit)
         cursor = hit.at; return hit; });
-    const ended = (within) => waitFor("a task-ended for the driven task", envelope => {
+    const ended = (within) => waitFor("a task-ended for the tested task", envelope => {
         const event = envelope.event;
         return event.type === "task-ended" && event.assignmentId === taskId ? event : undefined;
     }, cursor, within);
-    // Every command the drive sends is validated against the task as published, and its answer for its method.
-    ruleEvaluated("drive.timeout");
+    // Every command the test sends is validated against the task as published, and its answer for its method.
+    ruleTested("test.timeout");
     const send = async (command, dialId) => {
-        const own = validateTaskCommand(command, latestTask(), `drive.command.${String(command.type)}`, {
-            levels: effectiveLevels(drive.manifest.orgLevels).map(level => level.id),
-            dialOutcomesDeclared: drive.manifest.dialOutcomes !== undefined,
-            calendarDeclared: drive.manifest.idleCapabilities?.calendar === true,
-            autoAcceptTasks: drive.context.autoAcceptTasks,
+        const own = validateTaskCommand(command, latestTask(), `test.command.${String(command.type)}`, {
+            levels: effectiveLevels(call.manifest.orgLevels).map(level => level.id),
+            dialOutcomesDeclared: call.manifest.dialOutcomes !== undefined,
+            calendarDeclared: call.manifest.idleCapabilities?.calendar === true,
+            autoAcceptTasks: call.context.autoAcceptTasks,
         });
         found.push(...own);
         if (own.length > 0)
             return undefined;
-        ruleEvaluated("drive.command.rejected");
+        ruleTested("test.command.rejected");
         let result;
         try {
-            result = await drive.connection.execute({ assignmentId: taskId, command });
+            result = await call.connection.execute({ assignmentId: taskId, command });
         }
         catch (error) {
-            refuse("drive.command.rejected", `drive.command.${String(command.type)}`, `execute rejected rather than answered: ${String(error)}`);
+            refuse("test.command.rejected", `test.command.${String(command.type)}`, `execute rejected rather than answered: ${String(error)}`);
             return undefined;
         }
-        ruleEvaluated("drive.command.failed");
-        found.push(...validateResult(result, "execute", `drive.command.${String(command.type)}.result`, dialId));
+        ruleTested("test.command.failed");
+        found.push(...validateResult(result, "execute", `test.command.${String(command.type)}.result`, dialId));
         if (isRecord(result) && result.status === "failed") {
-            refuse("drive.command.failed", `drive.command.${String(command.type)}`, `the provider refused ${String(command.type)} on a task that offered it: ${String(isRecord(result.failure) ? result.failure.code : result.failure)}`);
+            refuse("test.command.failed", `test.command.${String(command.type)}`, `the provider refused ${String(command.type)} on a task that offered it: ${String(isRecord(result.failure) ? result.failure.code : result.failure)}`);
             return undefined;
         }
         return isRecord(result) ? result : undefined;
@@ -1721,39 +1758,107 @@ async function driveOneCall(drive) {
     };
     // Audio may arrive any time after the accept, before or after the task's own update says
     // in-progress: the event is the provider's word that the audio should attach, never a reply to
-    // openAudio, so the drive looks for it from the accept rather than from the last update it read.
-    const acceptedAt = drive.events.length;
+    // openAudio, so the test looks for it from the accept rather than from the last update it read.
+    // 0. A deadline stated is a deadline kept. Where the first offer says how long it has, within
+    // what the test will wait, the test leaves it alone and expects the provider to end it expired
+    // when it runs out; the next offer is the one tested. Offers with no deadline, or a longer one,
+    // leave this rule unreached, and the result says so.
+    const settleMs = Number(call.manifest.settleMs);
+    const lapse = latestTask().phase === "pending" ? latestTask().expiresInSeconds : undefined;
+    if (typeof lapse === "number" && lapse * 1000 <= call.timeoutMs) {
+        ruleTested("test.offer.expired");
+        const lapsedId = taskId;
+        let missed = false;
+        const ending = await waitFor(`the expired ending of ${lapsedId}`, envelope => {
+            const event = envelope.event;
+            return event.type === "task-ended" && event.assignmentId === lapsedId ? event : undefined;
+        }, cursor, { ms: lapse * 1000 + settleMs, onExpiry: () => { missed = true; } });
+        if (ending === undefined) {
+            if (missed)
+                refuse("test.offer.expired", "test.offer", `${lapsedId} was offered with ${lapse}s to answer and ${lapse * 1000 + settleMs}ms later it has not ended: a deadline stated is a deadline kept, and the offer ends expired naming pending`);
+            return found;
+        }
+        const outcome = isRecord(ending.found.outcome) ? ending.found.outcome : {};
+        if (!(outcome.type === "expired" && outcome.phase === "pending")) {
+            refuse("test.offer.expired", "test.offer", `${lapsedId} lapsed unanswered and ended ${String(outcome.type)}: an offer nobody answered before its deadline ends expired naming pending`);
+        }
+        // The next offer is the one tested; a provider with nothing more to offer ends the test here.
+        const next = await waitFor("a task-offered after the lapsed one", envelope => {
+            const event = envelope.event;
+            return event.type === "task-offered" && isTask(event.task) && event.task.assignmentId !== lapsedId ? event.task : undefined;
+        }, ending.at);
+        if (next === undefined)
+            return found;
+        task = next.found;
+        cursor = next.at;
+        taskId = task.assignmentId;
+    }
+    const acceptedAt = call.events.length;
     // 1. Accept the offer, if it is one.
     if (latestTask().phase === "pending") {
-        if (await send({ type: drive.channel === "voice" ? "answer" : "accept" }) === undefined)
+        if (await send({ type: call.channel === "voice" ? "answer" : "accept" }) === undefined)
             return found;
         if (await updated(t => t.phase !== "pending", "the task leaving pending after it was accepted") === undefined)
             return found;
     }
-    // 2. A preview: press Call, which is a dial.
+    // 2. A preview: press Call, which is a dial. Where the preview says how long it has, within what
+    // the test will wait, the deadline is kept to its atDeadline first: under provider-dials the
+    // provider dials when it runs out and the test presses nothing; under host-dials and waits the
+    // preview stands until then, and the test presses Call at zero as the desk would.
     if (latestTask().phase === "preview") {
-        const dialId = `drive-${taskId}`;
-        drive.stream.dialled(dialId);
-        if (await send({ type: "dial", dialId }, dialId) === undefined)
-            return found;
-        if (await updated(t => t.phase === "in-progress" || t.phase === "completing", "the task leaving preview after Call") === undefined)
+        const left = latestTask().previewEndsInSeconds;
+        const atDeadline = latestTask().atDeadline;
+        // Under provider-dials the provider places the call, and the desk presses nothing.
+        let pressCall = true;
+        if (typeof left === "number" && left * 1000 <= call.timeoutMs && typeof atDeadline === "string") {
+            ruleTested("test.preview.deadline");
+            const ringing = (t) => t.phase !== "preview"
+                || (Array.isArray(t.onCall) && t.onCall.some(who => isRecord(who) && who.role === "party" && who.stage === "ringing"));
+            if (atDeadline === "provider-dials") {
+                let missed = false;
+                const dialled = await updated(ringing, "the provider dialling at the preview's deadline", { ms: left * 1000 + settleMs, onExpiry: () => { missed = true; } });
+                if (dialled === undefined) {
+                    if (!missed)
+                        return found;
+                    refuse("test.preview.deadline", "test.preview", `${taskId} is a preview under provider-dials with ${left}s left, and the provider did not dial when it ran out: the party rings on onCall, or the task leaves preview`);
+                    return found;
+                }
+                pressCall = false;
+            }
+            else {
+                // Nothing may move the preview before its deadline under host-dials or waits: the test
+                // waits the seconds out and expects the task where it left it.
+                const moved = await updated(t => t.phase !== "preview", "nothing", { ms: left * 1000, onExpiry: () => undefined });
+                if (moved !== undefined) {
+                    refuse("test.preview.deadline", "test.preview", `${taskId} is a preview under ${atDeadline} with ${left}s left, and the provider moved it to ${String(moved.found.phase)} before the deadline: under ${atDeadline} the preview stands until the desk dials, or for as long as the agent needs`);
+                    return found;
+                }
+            }
+        }
+        if (pressCall && latestTask().phase === "preview") {
+            const dialId = `test-${taskId}`;
+            call.stream.dialled(dialId);
+            if (await send({ type: "dial", dialId }, dialId) === undefined)
+                return found;
+        }
+        if (latestTask().phase === "preview" && await updated(t => t.phase === "in-progress" || t.phase === "completing", pressCall ? "the task leaving preview after Call" : "the task leaving preview after the provider's dial") === undefined)
             return found;
     }
     // The other direction of step 4, wherever the task stands outside the interaction phases with the
     // control still declared: a host holds it back (command.phase.interaction), and an adapter that
-    // receives it anyway must refuse it -- so the drive sends it past the validator and expects failed.
+    // receives it anyway must refuse it -- so the test sends it past the validator and expects failed.
     const holdRefusedOutsideInteraction = async () => {
-        ruleEvaluated("drive.command.rejected", "drive.command.interaction");
+        ruleTested("test.command.rejected", "test.command.interaction");
         const phase = String(latestTask().phase);
         let answer;
         try {
-            answer = await drive.connection.execute({ assignmentId: taskId, command: { type: "hold" } });
+            answer = await call.connection.execute({ assignmentId: taskId, command: { type: "hold" } });
         }
         catch (error) {
-            refuse("drive.command.rejected", "drive.command.hold", `execute rejected rather than answered: ${String(error)}`);
+            refuse("test.command.rejected", "test.command.hold", `execute rejected rather than answered: ${String(error)}`);
         }
         if (isRecord(answer) && answer.status !== "failed") {
-            refuse("drive.command.interaction", "drive.command.hold", `the provider applied hold on a ${phase} task: a control on the contact belongs to in-progress or paused, and the adapter is the second gate`);
+            refuse("test.command.interaction", "test.command.hold", `the provider applied hold on a ${phase} task: a control on the contact belongs to in-progress or paused, and the adapter is the second gate`);
         }
     };
     if (latestTask().phase === "confirmed") {
@@ -1763,9 +1868,9 @@ async function driveOneCall(drive) {
             return found;
     }
     // 3. On a softphone, the audio arrives and the host opens it.
-    if (drive.softphone && latestTask().phase === "in-progress") {
+    if (call.softphone && latestTask().phase === "in-progress") {
         if (latestTask().audio !== "started") {
-            const started = await waitFor("task-audio-started for the driven task", envelope => {
+            const started = await waitFor("task-audio-started for the tested task", envelope => {
                 const event = envelope.event;
                 return event.type === "task-audio-started" && event.assignmentId === taskId ? event : undefined;
             }, acceptedAt);
@@ -1773,15 +1878,15 @@ async function driveOneCall(drive) {
                 return found;
             cursor = Math.max(cursor, started.at);
         }
-        const opened = await drive.connection.openAudio?.({ assignmentId: taskId, localAudio: drive.localAudio });
-        const malformed = validateResult(opened, "openAudio", "drive.openAudio");
+        const opened = await call.connection.openAudio?.({ assignmentId: taskId, localAudio: call.localAudio });
+        const malformed = validateResult(opened, "openAudio", "test.openAudio");
         found.push(...malformed);
         if (malformed.length === 0 && isRecord(opened) && opened.status === "opened")
             session = opened.audio;
         else if (malformed.length === 0 && isRecord(opened))
-            refuse("drive.openAudio.unavailable", "drive.openAudio", "a softphone login's adapter could not open the call's audio");
+            refuse("test.openAudio.unavailable", "test.openAudio", "a softphone login's adapter could not open the call's audio");
     }
-    // 3b. The microphone is the host's. With the audio open, the drive mutes it for a moment and
+    // 3b. The microphone is the host's. With the audio open, the test mutes it for a moment and
     // reports the leg the provider's record would otherwise miss -- begun, then ended -- and
     // expects each report recorded. If the provider restates the task's record afterwards, the leg is in it.
     const canonicalTimes = new Map();
@@ -1793,34 +1898,34 @@ async function driveOneCall(drive) {
             ? history.steps.find(entry => isRecord(entry) && entry.step === "muted" && entry.at === canonicalTimes.get(at)) : undefined;
         return typeof leg?.seconds === "number" ? leg.seconds : undefined;
     };
-    const canRecordMute = session !== undefined && typeof session.setMuted === "function" && typeof drive.connection.recordStep === "function";
+    const canRecordMute = session !== undefined && typeof session.setMuted === "function" && typeof call.connection.recordStep === "function";
     const report = async (body) => {
-        ruleEvaluated("drive.recordStep.rejected", "drive.recordStep.failed");
-        // The drive holds its own report to the contract before it crosses, as a host must.
+        ruleTested("test.recordStep.rejected", "test.recordStep.failed");
+        // The test holds its own report to the contract before it crosses, as a host must.
         const leg = { assignmentId: taskId, step: "muted", mutedBy: "host", ...body };
-        const own = validateHistoryReport(leg, "drive.recordStep.report", drive.manifest);
+        const own = validateHistoryReport(leg, "test.recordStep.report", call.manifest);
         found.push(...own);
         if (own.length > 0)
             return;
         let answer;
         try {
-            answer = await drive.connection.recordStep(leg);
+            answer = await call.connection.recordStep(leg);
         }
         catch (error) {
-            refuse("drive.recordStep.rejected", "drive.recordStep", `recordStep rejected rather than answered: ${String(error)}`);
+            refuse("test.recordStep.rejected", "test.recordStep", `recordStep rejected rather than answered: ${String(error)}`);
             return;
         }
-        const resultErrors = validateResult(answer, "recordStep", "drive.recordStep.result");
+        const resultErrors = validateResult(answer, "recordStep", "test.recordStep.result");
         found.push(...resultErrors);
         if (!resultErrors.length && isRecord(answer) && answer.status === "recorded" && typeof answer.at === "string" && typeof body.at === "string") {
             const prior = canonicalTimes.get(body.at);
             if (prior !== undefined && prior !== answer.at)
-                refuse("drive.recordStep.identity", "drive.recordStep.result.at", "one reported leg must retain its provider-assigned history instant");
+                refuse("test.recordStep.identity", "test.recordStep.result.at", "one reported leg must retain its provider-assigned history instant");
             else
                 canonicalTimes.set(body.at, answer.at);
         }
         if (isRecord(answer) && answer.status === "failed") {
-            refuse("drive.recordStep.failed", "drive.recordStep", `the provider refused to record the host's muted leg: ${String(isRecord(answer.failure) ? answer.failure.code : answer.failure)}`);
+            refuse("test.recordStep.failed", "test.recordStep", `the provider refused to record the host's muted leg: ${String(isRecord(answer.failure) ? answer.failure.code : answer.failure)}`);
         }
     };
     const setMuted = (muted) => {
@@ -1831,7 +1936,7 @@ async function driveOneCall(drive) {
             session.setMuted(muted);
         }
         catch {
-            refuse("drive.openAudio.setMuted", "drive.openAudio", `the audio session threw on setMuted(${String(muted)})`);
+            refuse("test.openAudio.setMuted", "test.openAudio", `the audio session threw on setMuted(${String(muted)})`);
         }
     };
     if (canRecordMute) {
@@ -1847,16 +1952,16 @@ async function driveOneCall(drive) {
         // 3c. A host reload destroys the adapter object and keeps the login's store. Built again from
         // the same login, a second adapter carries the task and the leg -- from its platform, or from
         // the store -- or it composed the record in memory and the record died with it.
-        if (drive.rebuild !== undefined && canonicalTimes.has(at)) {
+        if (call.rebuild !== undefined && canonicalTimes.has(at)) {
             await recordSurvivesReload(canonicalTimes.get(at));
-            // A reload that stood no client ends the run: there is nothing left to drive.
-            if (!drive.handOver.isLive())
+            // A reload that stood no client ends the run: there is nothing left to call.
+            if (!call.handOver.isLive())
                 return found;
         }
     }
     // 4. Hold and resume, where offered.
     if (latestTask().phase === "in-progress" && offers("hold")) {
-        if (await send({ type: drive.channel === "chat" ? "pause" : "hold" }) !== undefined) {
+        if (await send({ type: call.channel === "chat" ? "pause" : "hold" }) !== undefined) {
             if (await updated(t => t.phase === "paused", "the task pausing after hold") !== undefined) {
                 if (await send({ type: "resume" }) !== undefined) {
                     await updated(t => t.phase === "in-progress", "the task resuming after resume");
@@ -1868,14 +1973,14 @@ async function driveOneCall(drive) {
     // calendar-updated that shows it is owed within the manifest's bound. The time is the provider's
     // own: a day after the instant it published the offer, so no clock of the runner's is read.
     if (latestTask().phase === "in-progress" && offers("schedule")) {
-        const publishedAt = drive.events.slice(0, cursor).reverse().find(envelope => {
+        const publishedAt = call.events.slice(0, cursor).reverse().find(envelope => {
             const event = envelope.event;
             return (event.type === "task-offered" || event.type === "task-updated") && isTask(event.task) && event.task.assignmentId === taskId;
         })?.occurredAt;
         const at = new Date(Date.parse(String(publishedAt ?? "2026-01-01T00:00:00Z")) + 24 * 60 * 60 * 1000).toISOString();
         if (await send({ type: "schedule", at, note: "Follow-up promised on the call" }) !== undefined) {
-            ruleEvaluated("drive.schedule.unsettled");
-            const settle = Number(drive.manifest.settleMs);
+            ruleTested("test.schedule.unsettled");
+            const settle = Number(call.manifest.settleMs);
             const carries = (calendar) => Array.isArray(calendar) && calendar.some(activity => isRecord(activity) && activity.startsAt === at);
             let unsettled = false;
             const shown = await waitFor("a calendar-updated carrying the follow-up", envelope => {
@@ -1885,13 +1990,13 @@ async function driveOneCall(drive) {
             if (shown === undefined && unsettled) {
                 let resync;
                 try {
-                    resync = await drive.connection.snapshot();
+                    resync = await call.connection.snapshot();
                 }
                 catch (error) {
-                    refuse("drive.command.rejected", "drive.schedule", `snapshot() after an unsettled schedule rejected: ${String(error)}`);
+                    refuse("test.command.rejected", "test.schedule", `snapshot() after an unsettled schedule rejected: ${String(error)}`);
                 }
                 if (!(isRecord(resync) && carries(resync.calendar))) {
-                    refuse("drive.schedule.unsettled", "drive.schedule", `schedule was applied and ${settle}ms later no calendar-updated carries a follow-up at ${at}, and a snapshot does not either: applied says the follow-up is on the calendar, and it is not`);
+                    refuse("test.schedule.unsettled", "test.schedule", `schedule was applied and ${settle}ms later no calendar-updated carries a follow-up at ${at}, and a snapshot does not either: applied says the follow-up is on the calendar, and it is not`);
                 }
             }
         }
@@ -1899,9 +2004,9 @@ async function driveOneCall(drive) {
     // 5. End the call, where the agent may -- with the microphone muted, as agents do. The leg left
     // open at audio end is the provider's to close, since the provider knows the instant the audio
     // ended; the host's own closing report can only follow what it hears, is answered recorded, and
-    // changes nothing. So the drive mutes, does not report the end before end-call, and reports it
+    // changes nothing. So the test mutes, does not report the end before end-call, and reports it
     // after the audio has ended.
-    if (drive.channel === "voice" && latestTask().phase === "in-progress" && offers("endCall")) {
+    if (call.channel === "voice" && latestTask().phase === "in-progress" && offers("endCall")) {
         let openLeg;
         if (canRecordMute && session !== undefined) {
             // The task as published before the call ends: the completing publication that follows is the restatement held to carrying this leg.
@@ -1911,7 +2016,7 @@ async function driveOneCall(drive) {
         }
         if (await send({ type: "end-call" }) !== undefined) {
             // A task that completes with its audio still up is refused by the stream as it passes
-            // (stream.taskUpdated.audioOpen); the drive does not also wait out the clock for an ending
+            // (stream.taskUpdated.audioOpen); the test does not also wait out the clock for an ending
             // that is not coming, so the run reads by the rule and not by its timeout.
             const audioEnded = await waitFor("task-audio-ended after end-call", envelope => {
                 const event = envelope.event;
@@ -1943,11 +2048,11 @@ async function driveOneCall(drive) {
             session.close();
         }
         catch {
-            refuse("drive.openAudio.close", "drive.openAudio", "the audio session threw on close");
+            refuse("test.openAudio.close", "test.openAudio", "the audio session threw on close");
         }
     }
     // 6. Complete, under either mode: the agent may finish early and the provider is free to end at
-    // once. Only a task with no wrap at all has nothing to complete, and there the drive waits for the
+    // once. Only a task with no wrap at all has nothing to complete, and there the test waits for the
     // provider. A conversation has no audio to end and no completing phase to wait for: a chat or an
     // email, and a voice task offering no end-call, is completed from where it stands.
     const completable = latestTask().phase === "completing" || latestTask().phase === "in-progress" || latestTask().phase === "paused";
@@ -1961,8 +2066,8 @@ async function driveOneCall(drive) {
             // applied says the provider has completed the task, and its ending follows within the bound
             // the manifest stated. Past it the host resyncs: a snapshot still carrying the task is a task
             // held open by a provider that said it was done, and the desk shows it as unsettled.
-            ruleEvaluated("drive.completion.unsettled");
-            const settle = Number(drive.manifest.settleMs);
+            ruleTested("test.completion.unsettled");
+            const settle = Number(call.manifest.settleMs);
             let unsettled = false;
             const end = await ended({ ms: settle, onExpiry: () => { unsettled = true; } });
             if (end !== undefined)
@@ -1970,13 +2075,13 @@ async function driveOneCall(drive) {
             else if (unsettled) {
                 let resync;
                 try {
-                    resync = await drive.connection.snapshot();
+                    resync = await call.connection.snapshot();
                 }
                 catch (error) {
-                    refuse("drive.command.rejected", "drive.completion", `snapshot() after an unsettled completion rejected: ${String(error)}`);
+                    refuse("test.command.rejected", "test.completion", `snapshot() after an unsettled completion rejected: ${String(error)}`);
                 }
                 const still = isRecord(resync) && Array.isArray(resync.tasks) && resync.tasks.some(t => isRecord(t) && t.assignmentId === taskId);
-                refuse("drive.completion.unsettled", "drive.completion", still
+                refuse("test.completion.unsettled", "test.completion", still
                     ? `complete was applied and ${settle}ms later the task-ended has not come and a snapshot still carries ${taskId}: applied says the provider completed the task, and it has not`
                     : `complete was applied and ${settle}ms later the task-ended has not come; a snapshot no longer carries ${taskId}, so the ending was owed and never sent`);
             }
@@ -1987,10 +2092,10 @@ async function driveOneCall(drive) {
             await storeReleased();
     }
     // The record kept by the provider has every leg the host reported, wherever the provider restated it:
-    // the last publication of the task is read, whether or not the drive was waiting on it.
+    // the last publication of the task is read, whether or not the test was waiting on it.
     const lastPublished = () => {
-        for (let index = drive.events.length - 1; index >= 0; index -= 1) {
-            const event = drive.events[index].event;
+        for (let index = call.events.length - 1; index >= 0; index -= 1) {
+            const event = call.events[index].event;
             if ((event.type === "task-updated" || event.type === "task-offered") && isTask(event.task) && event.task.assignmentId === taskId)
                 return event.task;
         }
@@ -2007,15 +2112,15 @@ async function driveOneCall(drive) {
             const { at } = reported;
             const leg = history.steps.find(entry => isRecord(entry) && entry.step === "muted" && entry.at === at);
             if (leg === undefined) {
-                refuse("drive.recordStep.history", "drive.recordStep", `the provider restated the task's record after the host reported a muted leg at ${at}, and the leg is not in it`);
+                refuse("test.recordStep.history", "test.recordStep", `the provider restated the task's record after the host reported a muted leg at ${at}, and the leg is not in it`);
             }
             else if (leg.mutedBy !== "host") {
-                refuse("drive.recordStep.history", "drive.recordStep", `the record's muted leg at ${at} says mutedBy ${String(leg.mutedBy)}; the host reported host, and the record keeps the host's word`);
+                refuse("test.recordStep.history", "test.recordStep", `the record's muted leg at ${at} says mutedBy ${String(leg.mutedBy)}; the host reported host, and the record keeps the host's word`);
             }
             else if (reported.closedAs !== undefined) {
-                ruleEvaluated("drive.recordStep.overwritten");
+                ruleTested("test.recordStep.overwritten");
                 if (leg.seconds !== reported.closedAs) {
-                    refuse("drive.recordStep.overwritten", "drive.recordStep", `the provider closed the leg at ${at} with ${reported.closedAs}s at audio end and the record now says ${String(leg.seconds)}s: the host's closing report changes nothing`);
+                    refuse("test.recordStep.overwritten", "test.recordStep", `the provider closed the leg at ${at} with ${reported.closedAs}s at audio end and the record now says ${String(leg.seconds)}s: the host's closing report changes nothing`);
                 }
             }
         }
@@ -2064,7 +2169,7 @@ export class TeamStream {
             case "team-member-updated":
             case "team-member-removed":
             case "team-policies-updated": {
-                ruleEvaluated("stream.team.baseline");
+                ruleTested("stream.team.baseline");
                 if (this.members === undefined) {
                     return [{ rule: "stream.team.baseline", path: `${at}.type`,
                             message: `${event.type} arrived before the team: team-updated carries the whole team first, and it changes one member at a time after that` }];
@@ -2075,7 +2180,7 @@ export class TeamStream {
                     return [];
                 }
                 if (event.type === "team-member-removed") {
-                    ruleEvaluated("stream.teamMember.unknown");
+                    ruleTested("stream.teamMember.unknown");
                     const id = String(event.memberId);
                     if (!this.members.has(id)) {
                         return [{ rule: "stream.teamMember.unknown", path: `${at}.memberId`, message: `${id} is not a member the team carried: a removal takes off somebody the lead was given` }];
@@ -2168,7 +2273,7 @@ function watchStore(store) {
         },
     };
 }
-/** A login store that lives in memory for the test: what most adapter tests hand `exerciseAdapter` as `context.store`. */
+/** A login store that lives in memory for the test: what most adapter tests hand `testAdapter` as `context.store`. */
 export function memoryStore() {
     const kept = new Map();
     return {