@xema/omni-protocol 0.1.83 → 0.1.84

package/dist/index.d.ts

@@ -29,7 +29,7 @@ export type TaskId = string;
 /**
  * One life of a task on the wire. A platform retires a task id minutes after closing it and a
  * requeue takes seconds, so the same `TaskId` comes back for another customer while a late dial
- * outcome or a late handling report for the first is still in flight. The allocation id is minted
+ * outcome or a late interaction report for the first is still in flight. The allocation id is minted
  * once per offer and never reused for the life of the login, and every event, command and report
  * that names a task names its allocation too, so nothing lands on the next life of the id.
  */
@@ -180,13 +180,13 @@ export interface Manifest<C extends Channel = Channel> {
      */
     runningStepReports?: true;
     /**
-     * How long after an applied disposal -- `complete`, or a lead's `take-over` -- the provider's
+     * How long after an applied completion -- `complete`, or a lead's `take-over` -- the provider's
      * `task-ended` is owed, in milliseconds. A warm transfer's `complete` is not one: the agent's
      * wrap runs after it as after any call. `applied` says the provider
-     * has disposed of the task; the ending follows within this, or the host resyncs and shows the
+     * has completed the task; the ending follows within this, or the host resyncs and shows the
      * task as unsettled. Stated per provider, since platforms settle at different speeds.
      */
-    disposalSettleMs: number;
+    completionSettleMs: number;
 }
 export interface SecretStore {
     get(key: string): Promise<string | undefined>;
@@ -195,7 +195,7 @@ export interface SecretStore {
 }
 /**
  * A small store for one login's operational state -- what an adapter holds about open work that
- * its platform cannot hold for it, such as the handling legs a host reported. Kept by the host for
+ * its platform cannot hold for it, such as the interaction legs a host reported. Kept by the host for
  * the life of the login, across a reload of the host, and cleared at sign-out. Never for anything
  * sensitive: that is `SecretStore`, whose contract is that a host may clear it aggressively.
  */
@@ -370,7 +370,7 @@ export interface AuthenticationSession {
 /**
  * Who silenced a device that is present and permitted: the host, by its own Mute, or the station --
  * a slider on the headset, the operating system -- which the host observes and, on a browser,
- * cannot touch. The same word on a `muted` handling leg says whose the silence was.
+ * cannot touch. The same word on a `muted` interaction leg says whose the silence was.
  */
 export type MutedBy = "host" | "station";
 export declare const MUTED_BY: readonly ["host", "station"];
@@ -669,7 +669,7 @@ export interface SharedTaskCapabilities {
 export type TaskCapabilities<C extends Channel = Channel> = C extends "voice" ? SharedTaskCapabilities & {
     decline?: Lockable<true>;
     hold?: Lockable<true>;
-    /** The provider ends the caller connection and agent-added channels owned by this handling, including inherited channels after transfer/takeover. Handling disposal remains separate. */
+    /** The provider ends the caller connection and agent-added channels owned by this interaction, including inherited channels after transfer/takeover. Interaction completion remains separate. */
     endCall?: Lockable<true>;
     /** Connect back to the party while `completing`, whoever placed the call; the task returns to `in-progress`. */
     connectBack?: Lockable<true>;
@@ -765,7 +765,7 @@ export type TaskAttribute = TaskAttributeBase & ({
     type: "timestamp";
     at: IsoTimestamp;
 });
-export type HandlingStep = "queued" | "offered" | "answered" | "held" | "muted" | "transferred" | "conferenced" | "unanswered";
+export type InteractionStep = "queued" | "offered" | "answered" | "held" | "muted" | "transferred" | "conferenced" | "unanswered";
 /**
  * The call record: the steps that brought the task here, one entry per occurrence and oldest
  * first, and what they add up to before this agent -- stated by the provider from its own record,
@@ -773,10 +773,10 @@ export type HandlingStep = "queued" | "offered" | "answered" | "held" | "muted"
  * absent when it does not; a plausible nought is the fallback the no-fallbacks rule forbids. The
  * record rides on the task and is replaced with it, so a late entry corrects the sums.
  */
-export interface TaskHandlingHistory {
-    steps: TaskHandlingStep[];
-    /** Seconds others spent handling it before this agent. */
-    handleSeconds?: DurationSeconds;
+export interface TaskInteractionHistory {
+    steps: TaskInteractionStep[];
+    /** Seconds others spent working on it before this agent. */
+    interactionSeconds?: DurationSeconds;
     /** Seconds the caller spent on hold at others' hands. */
     holdSeconds?: DurationSeconds;
     /** Seconds waiting before anyone answered. */
@@ -784,8 +784,8 @@ export interface TaskHandlingHistory {
     /** How many times the task changed hands. */
     transfers?: number;
 }
-export interface TaskHandlingStep {
-    step: HandlingStep;
+export interface TaskInteractionStep {
+    step: InteractionStep;
     at: IsoTimestamp;
     /**
      * On a step that dialled -- `transferred`, `conferenced`, `unanswered` -- the host's identity for
@@ -808,7 +808,7 @@ export interface TaskHandlingStep {
     mutedBy?: MutedBy;
 }
 /**
- * How the task ends, and how long after handling the provider allows for it.
+ * How the task ends, and how long after interaction the provider allows for it.
  *
  * The allowance is coupled to the mode. Under `provider-automatic` the provider acts on it, so it
  * is required. Under `agent-command` the provider will not complete the task itself, so it may
@@ -991,7 +991,7 @@ export type Task<C extends Channel = Channel> = {
     /** The identifier an agent reads back to a customer, where the provider has one. */
     reference?: string;
     attributes?: TaskAttribute[];
-    handlingHistory?: TaskHandlingHistory;
+    interactionHistory?: TaskInteractionHistory;
 } & TaskCompletion & (C extends "voice" ? {
     recording?: {
         provider?: RecordingState;
@@ -1072,7 +1072,7 @@ export type VoiceTaskCommand = {
 } | {
     type: "resume";
 }
-/** End the caller connection and all agent-added channels owned or inherited by this handling. Wrap/disposal remain separate. Gated by `endCall`. */
+/** End the caller connection and all agent-added channels owned or inherited by this interaction. Wrap/completion remain separate. Gated by `endCall`. */
  | {
     type: "end-call";
 }
@@ -1419,7 +1419,7 @@ export interface TeamBreakCommandRequest {
 }
 /**
  * The task's real-time audio as the provider holds it: `started` while audio should be attached,
- * `ended` once primary handling's audio ended, and the field omitted while none should be. The
+ * `ended` once primary interaction's audio ended, and the field omitted while none should be. The
  * provider's word -- a desk attaches and renders audio from it, never from its own senses.
  */
 export type TaskMediaState = "started" | "ended";
@@ -1481,14 +1481,14 @@ export type SetPreferenceRequest = {
     inherit: true;
 };
 /**
- * The host's report of a handling leg it performed itself -- a mute, which is the host's and
+ * The host's report of an interaction leg it performed itself -- a mute, which is the host's and
  * never the provider's -- so the provider's record has an account of it. Keyed by `step` and `at`: the
  * same entry is reported when it begins, as often as the host cares to while it runs, and once
  * more with `ended`, when `seconds` is the final duration. The host is the authority for the
  * legs it performs, so `seconds` may say how long so far at any time; the end is stated, never
  * inferred from a number's presence. What the adapter forwards upstream, and how often, is its own.
  */
-export type HandlingReport = {
+export type InteractionReport = {
     taskId: TaskId;
     allocationId: AllocationId;
     at: IsoTimestamp;
@@ -1498,7 +1498,7 @@ export type HandlingReport = {
     step: "muted";
     mutedBy: MutedBy;
 } | {
-    step: Exclude<HandlingStep, "muted">;
+    step: Exclude<InteractionStep, "muted">;
     mutedBy?: never;
 }) & ({
     ended: true;
@@ -1507,7 +1507,7 @@ export type HandlingReport = {
     ended?: never;
     seconds?: DurationSeconds;
 });
-export type HandlingReportResult = {
+export type InteractionReportResult = {
     status: "recorded";
     at: IsoTimestamp;
 } | {
@@ -1717,8 +1717,8 @@ export interface Connection<C extends Channel = Channel> {
     openMedia?(request: OpenMediaRequest): Promise<OpenMediaResult>;
     /** Required when the login declares `capabilities.preferences`: the person's own choice, kept by the provider and republished as `authenticated`. */
     setPreference?(request: SetPreferenceRequest): Promise<PreferenceResult>;
-    /** Records a handling leg the host performed. Required of a softphone login's connection: the host mutes its microphone on any call, and the record is the provider's. */
-    recordStep?(report: HandlingReport): Promise<HandlingReportResult>;
+    /** Records an interaction leg the host performed. Required of a softphone login's connection: the host mutes its microphone on any call, and the record is the provider's. */
+    recordStep?(report: InteractionReport): Promise<InteractionReportResult>;
 }
 export interface Adapter<C extends Channel = Channel> {
     manifest: Manifest<C>;
@@ -1789,13 +1789,13 @@ export declare const taskKey: (providerId: string, taskId: TaskId) => string;
  * same provider; anything wider goes through this.
  */
 export declare const userKey: (providerId: string, userId: UserId) => string;
-/** Every handling step somebody takes part in. `queued` is the one nobody does. */
-export declare const HANDLING_STEPS_WITH_A_PERSON: readonly ["offered", "answered", "held", "muted", "transferred", "conferenced", "unanswered"];
+/** Every interaction step somebody takes part in. `queued` is the one nobody does. */
+export declare const INTERACTION_STEPS_WITH_A_PERSON: readonly ["offered", "answered", "held", "muted", "transferred", "conferenced", "unanswered"];
 /** The steps a dial writes, and so the only ones that carry a `dialId` and a `destinationId`. */
-export declare const HANDLING_STEPS_THAT_DIAL: readonly ["transferred", "conferenced", "unanswered"];
-export declare const handlingStepDials: (step: HandlingStep) => boolean;
+export declare const INTERACTION_STEPS_THAT_DIAL: readonly ["transferred", "conferenced", "unanswered"];
+export declare const interactionStepDials: (step: InteractionStep) => boolean;
 /** Whether an absent `by` means "could not attribute" rather than "nobody was involved". */
-export declare function handlingStepExpectsAPerson(step: HandlingStep): boolean;
+export declare function interactionStepExpectsAPerson(step: InteractionStep): boolean;
 export interface BrowserSessionKeyInput {
     /** `Manifest.id`, never `displayName`: only the id is unique across an installation and stable. */
     providerId: string;

package/dist/index.js

@@ -159,19 +159,19 @@ export const taskKey = (providerId, taskId) => `${encodeURIComponent(providerId)
  * same provider; anything wider goes through this.
  */
 export const userKey = (providerId, userId) => `${encodeURIComponent(providerId)}:${encodeURIComponent(userId)}`;
-/** Every handling step somebody takes part in. `queued` is the one nobody does. */
-export const HANDLING_STEPS_WITH_A_PERSON = [
+/** Every interaction step somebody takes part in. `queued` is the one nobody does. */
+export const INTERACTION_STEPS_WITH_A_PERSON = [
     "offered", "answered", "held", "muted", "transferred", "conferenced", "unanswered",
 ];
 /** The steps a dial writes, and so the only ones that carry a `dialId` and a `destinationId`. */
-export const HANDLING_STEPS_THAT_DIAL = ["transferred", "conferenced", "unanswered"];
-export const handlingStepDials = (step) => HANDLING_STEPS_THAT_DIAL.includes(step);
-// Pinned both ways: a step added to `HandlingStep` has to be placed here, and a step listed here
+export const INTERACTION_STEPS_THAT_DIAL = ["transferred", "conferenced", "unanswered"];
+export const interactionStepDials = (step) => INTERACTION_STEPS_THAT_DIAL.includes(step);
+// Pinned both ways: a step added to `InteractionStep` has to be placed here, and a step listed here
 // has to exist there. `satisfies` on the list covers the second; this statement covers the first.
 true;
 /** Whether an absent `by` means "could not attribute" rather than "nobody was involved". */
-export function handlingStepExpectsAPerson(step) {
-    return HANDLING_STEPS_WITH_A_PERSON.includes(step);
+export function interactionStepExpectsAPerson(step) {
+    return INTERACTION_STEPS_WITH_A_PERSON.includes(step);
 }
 /**
  * Whether two logins declare the same capabilities, field by field. The comparison an adapter

package/dist/testing.d.ts

@@ -7,7 +7,7 @@ export { ProtocolConformanceError, assertNoViolations, type ProtocolViolation }
  * rules -- each optional part of a task, each optional part of the break state and roster, each
  * declared contribution, and each event type.
  */
-declare const STATE_SUBJECTS: readonly ["tasks", "task.browsers", "task.attributes", "task.handlingHistory", "task.onCall", "task.leadAssist", "task.assisting", "task.monitoring", "task.media", "task.acceptance", "task.dispositions", "task.destinations", "task.custom", "task.locked", "break.reasons", "break.imposed", "team.members", "team.requests", "contacts", "scheduledActivities", "team.policies"];
+declare const STATE_SUBJECTS: readonly ["tasks", "task.browsers", "task.attributes", "task.interactionHistory", "task.onCall", "task.leadAssist", "task.assisting", "task.monitoring", "task.media", "task.acceptance", "task.dispositions", "task.destinations", "task.custom", "task.locked", "break.reasons", "break.imposed", "team.members", "team.requests", "contacts", "scheduledActivities", "team.policies"];
 export type ContractSubject = (typeof STATE_SUBJECTS)[number] | `event.${ProviderEvent["type"]}`;
 export interface AdapterContractResult {
     events: ProviderEventEnvelope[];

package/dist/testing.js

@@ -1,5 +1,5 @@
 import { browserSessionKey, effectiveLevels, sameCapabilities, } from "./index.js";
-import { assertNoViolations, validateAuthenticationState, validateBreakTransition, validateEventEnvelope, validateHostGuarantees, validateHostReport, validateDescribedUsers, observeRules, ruleEvaluated, validateHostMute, validateHostRecording, validateLoginStore, validateHandlingReport, validateManifest, validateResult, validateSnapshot, validateTask, validateTimeZone, validatePhone, validateTaskCommand, isTimeZone, sameTimeZone, } from "./validation.js";
+import { assertNoViolations, validateAuthenticationState, validateBreakTransition, validateEventEnvelope, validateHostGuarantees, validateHostReport, validateDescribedUsers, observeRules, ruleEvaluated, validateHostMute, validateHostRecording, validateLoginStore, validateInteractionReport, 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
@@ -11,7 +11,7 @@ const STATE_SUBJECTS = [
     "tasks",
     "task.browsers",
     "task.attributes",
-    "task.handlingHistory",
+    "task.interactionHistory",
     "task.onCall",
     "task.leadAssist",
     "task.assisting",
@@ -53,8 +53,8 @@ function observeTask(value, seen) {
         seen.add("task.browsers");
     if (some(value.attributes))
         seen.add("task.attributes");
-    if (isRecord(value.handlingHistory) && some(value.handlingHistory.steps))
-        seen.add("task.handlingHistory");
+    if (isRecord(value.interactionHistory) && some(value.interactionHistory.steps))
+        seen.add("task.interactionHistory");
     if (some(value.onCall))
         seen.add("task.onCall");
     if (value.leadAssist !== undefined)
@@ -661,8 +661,8 @@ function userIdsIn(snapshot) {
     }
     for (const task of Array.isArray(snapshot?.tasks) ? snapshot.tasks : []) {
         const t = task;
-        if (isRecord(t.handlingHistory) && Array.isArray(t.handlingHistory.steps))
-            for (const step of t.handlingHistory.steps)
+        if (isRecord(t.interactionHistory) && Array.isArray(t.interactionHistory.steps))
+            for (const step of t.interactionHistory.steps)
                 if (isRecord(step))
                     add(step.by);
         if (Array.isArray(t.onCall))
@@ -681,7 +681,7 @@ function userIdsIn(snapshot) {
     return [...ids];
 }
 const teamNamesUsers = (team) => isRecord(team) && (some(team.members) || some(team.requests));
-const taskNamesUsers = (task) => isRecord(task) && ((isRecord(task.handlingHistory) && Array.isArray(task.handlingHistory.steps) && task.handlingHistory.steps.some(step => isRecord(step) && step.by !== undefined)) ||
+const taskNamesUsers = (task) => isRecord(task) && ((isRecord(task.interactionHistory) && Array.isArray(task.interactionHistory.steps) && task.interactionHistory.steps.some(step => isRecord(step) && step.by !== undefined)) ||
     (isRecord(task.leadAssist) && task.leadAssist.leadId !== undefined) ||
     isRecord(task.assisting) ||
     isRecord(task.monitoring));
@@ -1007,7 +1007,7 @@ export class TaskStream {
             return;
         const entries = [
             ...(Array.isArray(task.onCall) ? task.onCall : []),
-            ...(isRecord(task.handlingHistory) && Array.isArray(task.handlingHistory.steps) ? task.handlingHistory.steps : []),
+            ...(isRecord(task.interactionHistory) && Array.isArray(task.interactionHistory.steps) ? task.interactionHistory.steps : []),
         ];
         for (const entry of entries) {
             if (isRecord(entry) && typeof entry.dialId === "string")
@@ -1052,9 +1052,9 @@ export class TaskStream {
     }
     /** The entries of a task's record, each by step and instant, or undefined where the task carries no record. */
     static record(task) {
-        if (!isRecord(task) || !isRecord(task.handlingHistory) || !Array.isArray(task.handlingHistory.steps))
+        if (!isRecord(task) || !isRecord(task.interactionHistory) || !Array.isArray(task.interactionHistory.steps))
             return undefined;
-        return new Set(task.handlingHistory.steps.filter(isRecord).map(entry => `${String(entry.step)}@${String(entry.at)}`));
+        return new Set(task.interactionHistory.steps.filter(isRecord).map(entry => `${String(entry.step)}@${String(entry.at)}`));
     }
     /** What a restated record lost of the one read before it: nothing, or the entries by step and instant. */
     static lost(was, now) {
@@ -1092,7 +1092,7 @@ 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.handlingHistory", "stream.snapshot.phase", "stream.snapshot.media");
+        ruleEvaluated("stream.snapshot.capabilitySource", "stream.snapshot.interactionHistory", "stream.snapshot.phase", "stream.snapshot.media");
         if (isRecord(snapshot) && Array.isArray(snapshot.tasks)) {
             snapshot.tasks.forEach((task, index) => {
                 if (!isRecord(task) || typeof task.id !== "string")
@@ -1106,7 +1106,7 @@ export class TaskStream {
                 // A record once read is not unread: a resync restates it whole, or with more, never with less.
                 const lost = TaskStream.lost(was.record, TaskStream.record(task));
                 if (lost.length > 0) {
-                    refuse("stream.snapshot.handlingHistory", `${at}.tasks[${index}].handlingHistory`, `${task.id}'s record lost ${lost.join(", ")} on the snapshot: an entry read by the host stays in the record until the task ends`);
+                    refuse("stream.snapshot.interactionHistory", `${at}.tasks[${index}].interactionHistory`, `${task.id}'s record lost ${lost.join(", ")} on the snapshot: an entry read by the host stays in the record until the task ends`);
                 }
                 const to = String(task.phase);
                 const reachable = REACHABLE_PHASES[was.phase];
@@ -1178,7 +1178,7 @@ export class TaskStream {
                     break;
                 }
                 // The rules about a known task are evaluated only once there is one.
-                ruleEvaluated("stream.taskUpdated.capabilitySource", "stream.taskUpdated.phase", "stream.taskUpdated.allocation", "stream.taskUpdated.mediaOpen", "stream.taskUpdated.handlingHistory", "stream.taskMediaEnded.follow", "stream.taskUpdated.media", "stream.taskUpdated.stage", "stream.taskUpdated.stage.lingering");
+                ruleEvaluated("stream.taskUpdated.capabilitySource", "stream.taskUpdated.phase", "stream.taskUpdated.allocation", "stream.taskUpdated.mediaOpen", "stream.taskUpdated.interactionHistory", "stream.taskMediaEnded.follow", "stream.taskUpdated.media", "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; undetermined is a place a task
                 // starts from, never one it returns to.
@@ -1210,7 +1210,7 @@ export class TaskStream {
                 {
                     const lost = TaskStream.lost(known.record, TaskStream.record(event.task));
                     if (lost.length > 0) {
-                        refuse("stream.taskUpdated.handlingHistory", `${at}.task.handlingHistory`, `${id}'s record lost ${lost.join(", ")} on the update: an entry read by the host stays in the record until the task ends`);
+                        refuse("stream.taskUpdated.interactionHistory", `${at}.task.interactionHistory`, `${id}'s record lost ${lost.join(", ")} on the update: an entry read by the host stays in the record until the task ends`);
                     }
                 }
                 // A task completes after its media ends, never around it: an update that moves a task to
@@ -1319,13 +1319,13 @@ export class TaskStream {
                     refuse("stream.taskEnded.mediaOpen", `${at}.taskId`, `${id} ended with its media still started: the audio ends first, on task-media-ended, whatever the outcome`);
                 }
                 // Off voice there is no media event, so the update that moves a task to completing is the
-                // provider's word that handling ended and the moment the wrap allowance starts. A provider
+                // 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");
                 if (known.channel !== "voice" && known.completionMode === "provider-automatic" && known.wrapAllowance !== undefined && known.wrapAllowance > 0
                     && known.phase !== "completing" && isRecord(event.outcome) && event.outcome.type === "completed") {
-                    refuse("stream.taskEnded.unwrapped", `${at}.outcome`, `${id} was completed from ${known.phase} with a wrap allowance of ${known.wrapAllowance}s under provider-automatic: off voice, completing is the provider's word that handling ended and the allowance's start, and it was never published`);
+                    refuse("stream.taskEnded.unwrapped", `${at}.outcome`, `${id} was completed from ${known.phase} with a wrap allowance of ${known.wrapAllowance}s under provider-automatic: off voice, completing is the provider's word that interaction ended and the allowance's start, and it was never published`);
                 }
                 this.endedAllocations.add(known.allocation);
                 this.tasks.delete(id);
@@ -1456,10 +1456,10 @@ async function driveOneCall(drive) {
             if (carried.allocationId !== allocationOf()) {
                 refuse("drive.reload.allocation", "drive.reload.allocation", `a second adapter built from the same login carries ${taskId} as allocation ${String(carried.allocationId)}; the first published ${allocationOf()}, and a life does not change its name on a reload`);
             }
-            const history = carried.handlingHistory;
+            const history = carried.interactionHistory;
             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.
-            const before = latestTask().handlingHistory;
+            const before = latestTask().interactionHistory;
             const wasRead = isRecord(before) && Array.isArray(before.steps) ? before.steps.filter(isRecord) : [];
             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)}`);
@@ -1612,11 +1612,11 @@ async function driveOneCall(drive) {
         if (await updated(t => t.phase === "in-progress" || t.phase === "completing", "the task leaving preview after Call") === undefined)
             return found;
     }
-    // The other direction of step 4, wherever the task stands outside the handling phases with the
-    // control still declared: a host holds it back (command.phase.handling), and an adapter that
+    // 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.
-    const holdRefusedOutsideHandling = async () => {
-        ruleEvaluated("drive.command.rejected", "drive.command.handling");
+    const holdRefusedOutsideInteraction = async () => {
+        ruleEvaluated("drive.command.rejected", "drive.command.interaction");
         const phase = String(latestTask().phase);
         let answer;
         try {
@@ -1626,12 +1626,12 @@ async function driveOneCall(drive) {
             refuse("drive.command.rejected", "drive.command.hold", `execute rejected rather than answered: ${String(error)}`);
         }
         if (isRecord(answer) && answer.status !== "failed") {
-            refuse("drive.command.handling", "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("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`);
         }
     };
     if (latestTask().phase === "confirmed") {
         if (offers("hold"))
-            await holdRefusedOutsideHandling();
+            await holdRefusedOutsideInteraction();
         if (await updated(t => t.phase !== "confirmed", "the task leaving confirmed") === undefined)
             return found;
     }
@@ -1661,7 +1661,7 @@ async function driveOneCall(drive) {
     const reportedLegs = [];
     /** The duration the provider's record states for the leg at `at`, as the task stands now. */
     const closedAs = (at) => {
-        const history = latestTask().handlingHistory;
+        const history = latestTask().interactionHistory;
         const leg = isRecord(history) && Array.isArray(history.steps)
             ? history.steps.find(entry => isRecord(entry) && entry.step === "muted" && entry.at === canonicalTimes.get(at)) : undefined;
         return typeof leg?.seconds === "number" ? leg.seconds : undefined;
@@ -1671,7 +1671,7 @@ async function driveOneCall(drive) {
         ruleEvaluated("drive.recordStep.rejected", "drive.recordStep.failed");
         // The drive holds its own report to the contract before it crosses, as a host must.
         const leg = { taskId, allocationId: allocationOf(), step: "muted", mutedBy: "host", ...body };
-        const own = validateHandlingReport(leg, "drive.recordStep.report", drive.manifest);
+        const own = validateInteractionReport(leg, "drive.recordStep.report", drive.manifest);
         found.push(...own);
         if (own.length > 0)
             return;
@@ -1775,7 +1775,7 @@ async function driveOneCall(drive) {
                 reportedLegs.push({ at: canonicalTimes.get(openLeg.at), task: openLeg.task, closedAs: before });
             }
             if (completing !== undefined && offers("hold")) {
-                await holdRefusedOutsideHandling();
+                await holdRefusedOutsideInteraction();
             }
         }
     }
@@ -1798,11 +1798,11 @@ async function driveOneCall(drive) {
             command.disposition = dispositions.codes[0].id;
         }
         if (await send(command) !== undefined) {
-            // applied says the provider has disposed of the task, and its ending follows within the bound
+            // 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.disposal.unsettled");
-            const settle = Number(drive.manifest.disposalSettleMs);
+            ruleEvaluated("drive.completion.unsettled");
+            const settle = Number(drive.manifest.completionSettleMs);
             let unsettled = false;
             const end = await ended({ ms: settle, onExpiry: () => { unsettled = true; } });
             if (end !== undefined)
@@ -1813,11 +1813,11 @@ async function driveOneCall(drive) {
                     resync = await drive.connection.snapshot();
                 }
                 catch (error) {
-                    refuse("drive.command.rejected", "drive.disposal", `snapshot() after an unsettled disposal rejected: ${String(error)}`);
+                    refuse("drive.command.rejected", "drive.completion", `snapshot() after an unsettled completion rejected: ${String(error)}`);
                 }
                 const still = isRecord(resync) && Array.isArray(resync.tasks) && resync.tasks.some(t => isRecord(t) && t.id === taskId && t.allocationId === allocationOf());
-                refuse("drive.disposal.unsettled", "drive.disposal", still
-                    ? `complete was applied and ${settle}ms later the task-ended has not come and a snapshot still carries ${taskId}: applied says the provider disposed of the task, and it has not`
+                refuse("drive.completion.unsettled", "drive.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`);
             }
         }
@@ -1842,7 +1842,7 @@ async function driveOneCall(drive) {
         const published = lastPublished();
         if (published === reported.task)
             continue;
-        const history = published.handlingHistory;
+        const history = published.interactionHistory;
         if (isRecord(history) && Array.isArray(history.steps)) {
             const { at } = reported;
             const leg = history.steps.find(entry => isRecord(entry) && entry.step === "muted" && entry.at === at);

package/dist/validation.d.ts

@@ -122,9 +122,9 @@ export declare function validateHostGuarantees(guarantees: unknown, path?: strin
  * a task, a step, when it began, how long so far if the host says, and an explicit end that
  * carries the final duration.
  */
-export declare function validateHandlingReport(report: unknown, path?: string, manifest?: unknown): ProtocolViolation[];
+export declare function validateInteractionReport(report: unknown, path?: string, manifest?: unknown): ProtocolViolation[];
 export declare function validateHostReport(report: unknown, path?: string): ProtocolViolation[];
-/** Validate the exact handling/allocation target before provider command dispatch. */
+/** Validate the exact interaction/allocation target before provider command dispatch. */
 export declare function validateTaskCommandRequest(request: unknown, task: unknown, path?: string, taskContext?: Omit<TaskValidationContext, "channel">): ProtocolViolation[];
 /**
  * What a command needs to be issuable, checked against the task it names: the capability the