@xema/omni-protocol 0.1.87 → 0.1.89

package/dist/index.d.ts

@@ -244,20 +244,20 @@ export interface TeamCapabilities {
     /** This lead may join a member's call on request. Requires `executeTeamLeadAssist`. */
     leadAssistControl?: true;
     /**
-     * This lead may listen to a member's call unasked, in these modes and no others. Whisper and
-     * join-call begin from a monitor, so the list always includes `monitor`. Nothing of it reaches the
-     * member's task. Requires `executeTeamMonitor`.
+     * This lead may listen to a member's call unasked, in these modes and no others. Coach and
+     * join-call begin with silent listening, so the list always includes `listen`. Nothing of it reaches the
+     * member's task. Requires `executeTeamListen`.
      */
-    monitorControl?: MonitorMode[];
+    listeningControl?: ListeningMode[];
     /** This lead sets the team's policy per capability -- on, off, or the agent's -- within what the queue allows. Requires `executeTeamPolicy`. */
     policyControl?: true;
 }
 /**
- * How a lead listening to a member's call is heard: `monitor` hears both sides in silence,
- * `whisper` is heard by the agent alone, `join-call` by everyone on the call.
+ * How a lead listening to a member's call is heard: `listen` hears both sides in silence,
+ * `coach` is heard by the agent alone, `join-call` by everyone on the call.
  */
-export type MonitorMode = "monitor" | "whisper" | "join-call";
-export declare const MONITOR_MODES: readonly ["monitor", "whisper", "join-call"];
+export type ListeningMode = "listen" | "coach" | "join-call";
+export declare const LISTENING_MODES: readonly ["listen", "coach", "join-call"];
 /**
  * What this login may do, beyond any one task. It travels with the identity because it is part
  * of who the agent is on this provider: the provider knows the roles and says so at sign-in.
@@ -891,13 +891,13 @@ export interface TaskAssisting {
  * lead is heard, restated on every change of mode. Nothing of it reaches the member's task. There
  * is no take-over here; a lead who wants the call uses lead assist. It is the lead's only task:
  * a lead listens while holding no work of their own, idle or on a break of a kind in
- * `MONITORING_BREAK_KINDS`.
+ * `LISTENING_BREAK_KINDS`.
  */
-export interface TaskMonitoring {
+export interface TaskListening {
     memberId: UserId;
     taskId: TaskId;
     allocationId: AllocationId;
-    mode: MonitorMode;
+    mode: ListeningMode;
     since: IsoTimestamp;
 }
 /**
@@ -976,7 +976,7 @@ export type Task<C extends Channel = Channel> = {
      * snapshot says it too: an offer the host never received is not accepted on the person's behalf
      * for want of a word. Required while `pending` when Omni said it may auto-accept
      * (`autoAcceptTasks: true`) or the work is the agent's own -- a dial, a connect-back, a join, a
-     * monitor, which then say `automatic` under either provisioning -- forbidden on routed work when
+     * listen, which then say `automatic` under either provisioning -- forbidden on routed work when
      * Omni said not, and absent past `pending`.
      */
     acceptance?: AcceptanceMode;
@@ -999,14 +999,14 @@ export type Task<C extends Channel = Channel> = {
     onCall?: OnCall[];
     leadAssist?: TaskLeadAssist;
     assisting?: TaskAssisting;
-    monitoring?: TaskMonitoring;
+    listening?: TaskListening;
     media?: TaskMediaState;
 } : {
     recording?: never;
     onCall?: never;
     leadAssist?: never;
     assisting?: never;
-    monitoring?: never;
+    listening?: never;
     media?: never;
 });
 /**
@@ -1236,10 +1236,10 @@ export declare const BREAK_KINDS: readonly ["short-break", "meal", "rest", "trai
 export type BreakKind = (typeof BREAK_KINDS)[number];
 /**
  * The breaks during which a lead may listen to a member's call: work of another sort, not rest.
- * A monitoring task is the one task a break in effect may hold, and only on one of these.
+ * A listening task is the one task a break in effect may hold, and only on one of these.
  */
-export declare const MONITORING_BREAK_KINDS: readonly ["coaching", "administrative", "training"];
-export declare const breakKindAllowsMonitoring: (kind: BreakKind | undefined) => boolean;
+export declare const LISTENING_BREAK_KINDS: readonly ["coaching", "administrative", "training"];
+export declare const breakKindAllowsListening: (kind: BreakKind | undefined) => boolean;
 export interface BreakReason {
     id: string;
     label: string;
@@ -1372,22 +1372,22 @@ export interface TeamLeadAssistCommandRequest {
     command: TeamLeadAssistCommand;
 }
 /**
- * A lead listening to a member's call. `monitor` starts one, silent, on a member from the team member list;
- * `whisper` and `join-call` change how the standing one is heard; `leave` ends it. One member at a
- * time, and only the modes the login's `monitorControl` lists.
+ * A lead listening to a member's call. `listen` starts one, silent, on a member from the team member list;
+ * `coach` and `join-call` change how the standing one is heard; `leave` ends it. One member at a
+ * time, and only the modes the login's `listeningControl` lists.
  */
-export type TeamMonitorCommand = {
-    type: "monitor";
+export type TeamListenCommand = {
+    type: "listen";
     memberId: UserId;
 } | {
-    type: "whisper";
+    type: "coach";
 } | {
     type: "join-call";
 } | {
     type: "leave";
 };
-export interface TeamMonitorCommandRequest {
-    command: TeamMonitorCommand;
+export interface TeamListenCommandRequest {
+    command: TeamListenCommand;
 }
 export type TeamBreakCommand = {
     type: "decide";
@@ -1709,8 +1709,8 @@ export interface Connection<C extends Channel = Channel> {
     executeTeamBreak?(request: TeamBreakCommandRequest): Promise<TeamCommandResult>;
     /** Required when the login declares `capabilities.team.leadAssistControl`. */
     executeTeamLeadAssist?(request: TeamLeadAssistCommandRequest): Promise<TeamCommandResult>;
-    /** Required when the login declares `capabilities.team.monitorControl`. */
-    executeTeamMonitor?(request: TeamMonitorCommandRequest): Promise<TeamCommandResult>;
+    /** Required when the login declares `capabilities.team.listeningControl`. */
+    executeTeamListen?(request: TeamListenCommandRequest): Promise<TeamCommandResult>;
     /** Required when the login declares `capabilities.team.policyControl`. */
     executeTeamPolicy?(request: TeamPolicyCommandRequest): Promise<TeamCommandResult>;
     /** Required of a voice adapter whose manifest lists `softphone`: on one, the call's audio lands in Omni. */

package/dist/index.js

@@ -26,7 +26,7 @@ export const IDLE_CAPABILITY_UI = {
     calendar: "Calendar",
     contacts: "Contacts",
 };
-export const MONITOR_MODES = ["monitor", "whisper", "join-call"];
+export const LISTENING_MODES = ["listen", "coach", "join-call"];
 export const MUTED_BY = ["host", "station"];
 export const HOST_MUTES = ["stream", "station"];
 export const RECORDING_ACTIONS = ["start", "pause", "resume", "stop", "cancel"];
@@ -97,10 +97,10 @@ export const BREAK_KINDS = [
 ];
 /**
  * The breaks during which a lead may listen to a member's call: work of another sort, not rest.
- * A monitoring task is the one task a break in effect may hold, and only on one of these.
+ * A listening task is the one task a break in effect may hold, and only on one of these.
  */
-export const MONITORING_BREAK_KINDS = ["coaching", "administrative", "training"];
-export const breakKindAllowsMonitoring = (kind) => kind !== undefined && MONITORING_BREAK_KINDS.includes(kind);
+export const LISTENING_BREAK_KINDS = ["coaching", "administrative", "training"];
+export const breakKindAllowsListening = (kind) => kind !== undefined && LISTENING_BREAK_KINDS.includes(kind);
 export const OMNI_FAILURE_CODES = [
     "omni.not-authenticated",
     "omni.capability-not-enabled",
@@ -180,15 +180,15 @@ export function interactionStepExpectsAPerson(step) {
  * not the thing being compared. Key order does not matter, and `team: {}` is not `team` absent.
  */
 export function sameCapabilities(a, b) {
-    const modes = (team) => team?.monitorControl === undefined ? undefined : [...team.monitorControl].sort().join(",");
+    const modes = (team) => team?.listeningControl === undefined ? undefined : [...team.listeningControl].sort().join(",");
     // Every field, so a capability added later cannot be missed here: `satisfies` pins the field
     // lists to the types, and a new key is a compile error until it is compared.
-    const teamKeys = { breakControl: true, leadAssistControl: true, monitorControl: true, policyControl: true };
+    const teamKeys = { breakControl: true, leadAssistControl: true, listeningControl: true, policyControl: true };
     void { breaks: true, preferences: true, team: true };
     const preferences = (list) => list === undefined ? undefined : list.map(p => [p.id, p.label, p.enabled, p.setBy, p.lockedBy ?? "", p.reason ?? ""].join("\u0000")).sort().join("\u0001");
     return a.breaks === b.breaks &&
         (a.team === undefined) === (b.team === undefined) &&
-        Object.keys(teamKeys).every(key => key === "monitorControl" || a.team?.[key] === b.team?.[key]) &&
+        Object.keys(teamKeys).every(key => key === "listeningControl" || a.team?.[key] === b.team?.[key]) &&
         modes(a.team) === modes(b.team) &&
         preferences(a.preferences) === preferences(b.preferences);
 }

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 team member list, each
  * declared contribution, and each event type.
  */
-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.outcomes", "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.listening", "task.media", "task.acceptance", "task.outcomes", "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

@@ -15,7 +15,7 @@ const STATE_SUBJECTS = [
     "task.onCall",
     "task.leadAssist",
     "task.assisting",
-    "task.monitoring",
+    "task.listening",
     "task.media",
     "task.acceptance",
     "task.outcomes",
@@ -61,8 +61,8 @@ function observeTask(value, seen) {
         seen.add("task.leadAssist");
     if (value.assisting !== undefined)
         seen.add("task.assisting");
-    if (value.monitoring !== undefined)
-        seen.add("task.monitoring");
+    if (value.listening !== undefined)
+        seen.add("task.listening");
     if (value.media !== undefined)
         seen.add("task.media");
     if (value.acceptance !== undefined)
@@ -233,8 +233,8 @@ export async function exerciseAdapter(adapter, context, options = {}) {
                 requireMethod(on, "executeTeamBreak", "the login declares capabilities.team.breakControl");
             if (capabilities.team?.leadAssistControl === true)
                 requireMethod(on, "executeTeamLeadAssist", "the login declares capabilities.team.leadAssistControl");
-            if (capabilities.team?.monitorControl !== undefined)
-                requireMethod(on, "executeTeamMonitor", "the login declares capabilities.team.monitorControl");
+            if (capabilities.team?.listeningControl !== undefined)
+                requireMethod(on, "executeTeamListen", "the login declares capabilities.team.listeningControl");
             if (capabilities.team?.policyControl === true)
                 requireMethod(on, "executeTeamPolicy", "the login declares capabilities.team.policyControl");
             if (some(capabilities.preferences))
@@ -673,9 +673,9 @@ function userIdsIn(snapshot) {
             add(t.leadAssist.leadId);
         if (isRecord(t.assisting))
             add(t.assisting.memberId);
-        if (isRecord(t.monitoring)) {
-            add(t.monitoring.memberId);
-            add(t.monitoring.agentId);
+        if (isRecord(t.listening)) {
+            add(t.listening.memberId);
+            add(t.listening.agentId);
         }
     }
     return [...ids];
@@ -684,7 +684,7 @@ const teamNamesUsers = (team) => isRecord(team) && (some(team.members) || some(t
 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));
+    isRecord(task.listening));
 /** Whether an event publishes a `UserId`, on a team member list, a task, or the snapshot a reconnect carries. */
 function eventNamesUsers(envelope) {
     const event = isRecord(envelope) ? envelope.event : undefined;
@@ -818,7 +818,7 @@ export function assertCapabilityWithdrawal(states, snapshot, manifest) {
         (before.team !== undefined && after.team === undefined) ||
         (before.team?.breakControl === true && after.team?.breakControl !== true) ||
         (before.team?.leadAssistControl === true && after.team?.leadAssistControl !== true) ||
-        (before.team?.monitorControl !== undefined && after.team?.monitorControl === undefined) ||
+        (before.team?.listeningControl !== undefined && after.team?.listeningControl === undefined) ||
         (before.team?.policyControl === true && after.team?.policyControl !== true) ||
         (before.preferences ?? []).some(was => !(after.preferences ?? []).some(now => now.id === was.id));
     if (!withdrawn) {

package/dist/validation.d.ts

@@ -135,7 +135,7 @@ export declare function validateTaskCommandRequest(request: unknown, task: unkno
  */
 export declare function validateTaskCommand(command: unknown, task?: unknown, path?: string, taskContext?: Omit<TaskValidationContext, "channel">): ProtocolViolation[];
 /** The connection methods whose results `validateResult` knows. */
-export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak" | "executeTeamBreak" | "executeTeamLeadAssist" | "executeTeamMonitor" | "openMedia" | "setPreference" | "recordStep" | "executeTeamPolicy";
+export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak" | "executeTeamBreak" | "executeTeamLeadAssist" | "executeTeamListen" | "openMedia" | "setPreference" | "recordStep" | "executeTeamPolicy";
 /**
  * Validates what a connection method answered. A result is untrusted for the same reason a
  * snapshot is: it comes from an adapter that may be compiled against another version, and Omni

package/dist/validation.js

@@ -9,7 +9,7 @@
 // Each list is pinned to its type both ways -- a member the type lacks, or a member the list
 // lacks, fails to compile -- so what the validators accept cannot drift from what the
 // declarations say.
-import { RECORDING_ACTIONS, ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, MONITORING_BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, INTERACTION_STEPS_THAT_DIAL, IDLE_CAPABILITIES, OMNI_FAILURE_CODES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, TASK_COMMAND_NAMES, negotiateProtocolVersion, DEFAULT_LEVELS, effectiveLevels, } from "./index.js";
+import { RECORDING_ACTIONS, ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, LISTENING_BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, INTERACTION_STEPS_THAT_DIAL, IDLE_CAPABILITIES, OMNI_FAILURE_CODES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, TASK_COMMAND_NAMES, negotiateProtocolVersion, DEFAULT_LEVELS, effectiveLevels, } from "./index.js";
 export class ProtocolConformanceError extends Error {
     violations;
     constructor(violations, summary = "Adapter violates the Omni protocol") {
@@ -87,8 +87,8 @@ const OFFERABLE_PHASES = membersOf({
 });
 const PREVIEW_DEADLINES = membersOf({ calls: true, "host-calls": true, waits: true });
 const PHONES = membersOf({ softphone: true, deskPhone: true });
-const TEAM_CAPABILITIES = membersOf({ breakControl: true, leadAssistControl: true, policyControl: true, monitorControl: true });
-const MONITOR_MODES = membersOf({ monitor: true, whisper: true, "join-call": true });
+const TEAM_CAPABILITIES = membersOf({ breakControl: true, leadAssistControl: true, policyControl: true, listeningControl: true });
+const LISTENING_MODES = membersOf({ listen: true, coach: true, "join-call": true });
 const COMPLETED_BY = membersOf({ agent: true, provider: true });
 const CANCELLED_BY = membersOf({ agent: true, provider: true, party: true });
 const EXPIRABLE_PHASES = membersOf({
@@ -1090,26 +1090,26 @@ function validateAssisting(value, channel, path, into) {
     into.timestamp(value.since, "task.assisting.since", `${path}.since`);
 }
 /** The lead's own task while they listen: whose call, which call, and how they are heard. Voice only. */
-function validateMonitoring(value, channel, path, into) {
+function validateListening(value, channel, path, into) {
     if (value === undefined)
         return;
-    if (!into.require(channel === "voice", "task.monitoring.channel", path, `a ${channel} task has no call to listen to`))
+    if (!into.require(channel === "voice", "task.listening.channel", path, `a ${channel} task has no call to listen to`))
         return;
     if (!isPlainObject(value)) {
-        into.add("task.monitoring.shape", path, "monitoring must be an object when present");
+        into.add("task.listening.shape", path, "listening must be an object when present");
         return;
     }
-    into.require(isUserId(value.memberId), "task.monitoring.memberId", `${path}.memberId`, "a monitored call names the member on it");
-    into.require(isTaskId(value.taskId), "task.monitoring.taskId", `${path}.taskId`, "a monitored call names the member's task");
-    into.require(isAllocationId(value.allocationId), "task.monitoring.allocationId", `${path}.allocationId`, "a monitored call names the member's task by its allocation too");
-    into.oneOf(value.mode, MONITOR_MODES, "task.monitoring.mode", `${path}.mode`);
-    into.timestamp(value.since, "task.monitoring.since", `${path}.since`);
+    into.require(isUserId(value.memberId), "task.listening.memberId", `${path}.memberId`, "a call being listened to names the member on it");
+    into.require(isTaskId(value.taskId), "task.listening.taskId", `${path}.taskId`, "a call being listened to names the member's task");
+    into.require(isAllocationId(value.allocationId), "task.listening.allocationId", `${path}.allocationId`, "a call being listened to names the member's task by its allocation too");
+    into.oneOf(value.mode, LISTENING_MODES, "task.listening.mode", `${path}.mode`);
+    into.timestamp(value.since, "task.listening.since", `${path}.since`);
 }
-/** Whether a task is the agent's own doing: a dial the host placed on its onCall, a lead's join, a lead's monitor. */
+/** Whether a task is the agent's own doing: a dial the host placed on its onCall, a lead's join, a lead's listen. */
 function originatedByTheAgent(task) {
     if (Array.isArray(task.onCall) && task.onCall.some(entry => isPlainObject(entry) && typeof entry.dialId === "string"))
         return true;
-    return task.assisting !== undefined || task.monitoring !== undefined;
+    return task.assisting !== undefined || task.listening !== undefined;
 }
 export function validateTask(task, context, path = "task") {
     const into = new Collector();
@@ -1121,6 +1121,7 @@ function validateTaskInto(task, context, path, into) {
         into.add("task.shape", path, "a task must be an object");
         return;
     }
+    into.require(!Object.hasOwn(task, "monitoring"), "task.listening.renamed", `${path}.monitoring`, "use listening; the former field is not accepted");
     into.require(!Object.hasOwn(task, "handlingHistory"), "task.interactionHistory.renamed", `${path}.handlingHistory`, "use interactionHistory; the former field is not accepted");
     into.require(isTaskId(task.id), "task.id", `${path}.id`, "a task needs a non-empty id");
     into.require(isAllocationId(task.allocationId), "task.allocationId", `${path}.allocationId`, "a task names this life of itself: an allocation id minted once per offer, never reused for the life of the login");
@@ -1151,7 +1152,7 @@ function validateTaskInto(task, context, path, into) {
     // Acceptance is the offer's word, carried on the pending task so a snapshot can say it: it
     // travels exactly when Omni said tasks may be auto-accepted, and only while the task is pending.
     // Work the agent originated -- a dial or connect-back, carrying the host's dialId on onCall; a
-    // lead's join, carrying assisting; a monitor, carrying monitoring -- was accepted by the command
+    // lead's join, carrying assisting; a listen, carrying listening -- was accepted by the command
     // that created it, and says so whatever the provisioning: the desk shows no Accept for a call
     // the agent placed. The provisioning governs work the queue routes, and nothing else.
     const originated = task.phase === "pending" && originatedByTheAgent(task);
@@ -1162,14 +1163,14 @@ function validateTaskInto(task, context, path, into) {
             into.add("task.acceptance.unexpected", `${path}.acceptance`, "acceptance is an offer's word; a task past pending has been accepted");
         }
         else if (originated) {
-            into.require(task.acceptance === "automatic", "task.acceptance.originated", `${path}.acceptance`, "work the agent originated -- a dial, a connect-back, a join, a monitor -- was accepted by the command that created it, and says automatic whatever the provisioning");
+            into.require(task.acceptance === "automatic", "task.acceptance.originated", `${path}.acceptance`, "work the agent originated -- a dial, a connect-back, a join, a listen -- was accepted by the command that created it, and says automatic whatever the provisioning");
         }
         else if (context.autoAcceptTasks === false) {
             into.add("task.acceptance.unexpected", `${path}.acceptance`, "autoAcceptTasks is off, so every task the queue routes requires agent acceptance and a pending task carries no acceptance");
         }
     }
     else if (originated) {
-        into.add("task.acceptance.originated", `${path}.acceptance`, "work the agent originated -- a dial, a connect-back, a join, a monitor -- says acceptance: automatic whatever the provisioning: the command that created it accepted it");
+        into.add("task.acceptance.originated", `${path}.acceptance`, "work the agent originated -- a dial, a connect-back, a join, a listen -- says acceptance: automatic whatever the provisioning: the command that created it accepted it");
     }
     else if (task.phase === "pending" && context.autoAcceptTasks === true) {
         into.add("task.acceptance.required", `${path}.acceptance`, "autoAcceptTasks is on, so a pending task states how it is accepted");
@@ -1222,10 +1223,10 @@ function validateTaskInto(task, context, path, into) {
     validateTaskMedia(task, task.media, context.channel, task.phase, `${path}.media`, into);
     validateLeadAssist(task.leadAssist, context.channel, `${path}.leadAssist`, into);
     validateAssisting(task.assisting, context.channel, `${path}.assisting`, into);
-    validateMonitoring(task.monitoring, context.channel, `${path}.monitoring`, into);
+    validateListening(task.listening, context.channel, `${path}.listening`, into);
     // A lead's task is one thing: a call they joined on request, or a call they listen to unasked.
-    if (task.assisting !== undefined && task.monitoring !== undefined) {
-        into.add("task.monitoring.assisting", `${path}.monitoring`, "a task is a joined call or a monitored one, never both");
+    if (task.assisting !== undefined && task.listening !== undefined) {
+        into.add("task.listening.assisting", `${path}.listening`, "a task is a joined call or a listened one, never both");
     }
     // Where the terms came from is stated with them: a host cannot tell "the platform permits
     // nothing" from "the terms could not be read" from the set alone, and the provider knows which.
@@ -1334,7 +1335,7 @@ export function validateBreakStatus(state, tasks, path = "snapshot") {
     }
     if (isPlainObject(state) && state.approval === "in-effect"
         && Array.isArray(tasks) && tasks.length > 0) {
-        const listening = tasks.every((task) => isPlainObject(task) && task.monitoring !== undefined);
+        const listening = tasks.every((task) => isPlainObject(task) && task.listening !== undefined);
         if (!listening) {
             into.add("break.in-effect.tasks", `${path}.tasks`, "a break in effect holds no task: it begins when the work ends, and until then the state is starting-after-task");
         }
@@ -1342,7 +1343,7 @@ export function validateBreakStatus(state, tasks, path = "snapshot") {
             const reasons = Array.isArray(state.reasons) ? state.reasons : [];
             const active = reasons.find((reason) => isPlainObject(reason) && reason.id === state.activeReasonId);
             const kind = isPlainObject(active) ? active.kind : undefined;
-            into.require(typeof kind === "string" && MONITORING_BREAK_KINDS.includes(kind), "snapshot.monitoring.break", `${path}.tasks`, `a lead listens during a ${MONITORING_BREAK_KINDS.join(", ")} break and no other; the active reason is ${kind === undefined ? "unstated" : describeValue(kind)}`);
+            into.require(typeof kind === "string" && LISTENING_BREAK_KINDS.includes(kind), "snapshot.listening.break", `${path}.tasks`, `a lead listens during a ${LISTENING_BREAK_KINDS.join(", ")} break and no other; the active reason is ${kind === undefined ? "unstated" : describeValue(kind)}`);
         }
     }
     return into.violations;
@@ -1556,7 +1557,7 @@ function validateBreakState(value, path, into) {
     }
     // A break in effect, or about to be, on a provider that publishes reasons is on one of them: an
     // imposed one included, since the lead's place named it. A break of no kind is a break whose
-    // rules -- who may monitor through it, whether it counts -- nobody can apply.
+    // rules -- who may listen through it, whether it counts -- nobody can apply.
     ruleEvaluated("break.activeReasonId.required");
     if (seen.size > 0 && (value.approval === "in-effect" || value.approval === "starting-after-task")) {
         into.require(typeof value.activeReasonId === "string" && value.activeReasonId.length > 0, "break.activeReasonId.required", `${path}.activeReasonId`, `a break ${describeValue(value.approval)} on a provider that publishes reasons names the one it is on`);
@@ -1683,7 +1684,7 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
     else {
         const seen = new Set();
         let assisting;
-        let monitoring;
+        let listening;
         snapshot.tasks.forEach((task, index) => {
             validateTaskInto(task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), locked: context.locked }, `${path}.tasks[${index}]`, into);
             // A lead assists one call at a time, and listens to one at a time.
@@ -1692,10 +1693,10 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
                     into.add("snapshot.assisting.single", `${path}.tasks[${index}].assisting`, "a lead assists one call at a time");
                 assisting = index;
             }
-            if (isPlainObject(task) && task.monitoring !== undefined) {
-                if (monitoring !== undefined)
-                    into.add("snapshot.monitoring.single", `${path}.tasks[${index}].monitoring`, "a lead listens to one call at a time");
-                monitoring = index;
+            if (isPlainObject(task) && task.listening !== undefined) {
+                if (listening !== undefined)
+                    into.add("snapshot.listening.single", `${path}.tasks[${index}].listening`, "a lead listens to one call at a time");
+                listening = index;
             }
             if (isPlainObject(task) && isTaskId(task.id)) {
                 if (seen.has(task.id))
@@ -1704,11 +1705,11 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
             }
         });
     }
-    // A lead listens while holding no work of their own: a monitoring task is the only task.
+    // A lead listens while holding no work of their own: a listening task is the only task.
     if (Array.isArray(snapshot.tasks) && snapshot.tasks.length > 1) {
         snapshot.tasks.forEach((task, index) => {
-            if (isPlainObject(task) && task.monitoring !== undefined) {
-                into.add("snapshot.monitoring.alone", `${path}.tasks[${index}].monitoring`, "a lead listens only while holding no task of their own");
+            if (isPlainObject(task) && task.listening !== undefined) {
+                into.add("snapshot.listening.alone", `${path}.tasks[${index}].listening`, "a lead listens only while holding no task of their own");
             }
         });
     }
@@ -2553,7 +2554,7 @@ const RESULT_STATUSES = {
     endBreak: { success: "ended", failure: "failed" },
     executeTeamBreak: { success: "applied", failure: "failed" },
     executeTeamLeadAssist: { success: "applied", failure: "failed" },
-    executeTeamMonitor: { success: "applied", failure: "failed" },
+    executeTeamListen: { success: "applied", failure: "failed" },
     openMedia: { success: "opened", failure: "unavailable" },
     setPreference: { success: "applied", failure: "failed" },
     recordStep: { success: "recorded", failure: "failed" },
@@ -2704,8 +2705,8 @@ function validateUserCapabilitiesInto(value, path, into, levels) {
                     continue;
                 if (!into.require(TEAM_CAPABILITIES.includes(control), "authentication.capability.team.unknown", `${path}.team.${control}`, `unsupported team capability: ${control}`))
                     continue;
-                if (control === "monitorControl") {
-                    validateMonitorControl(on, `${path}.team.monitorControl`, into);
+                if (control === "listeningControl") {
+                    validateListeningControl(on, `${path}.team.listeningControl`, into);
                     continue;
                 }
                 into.require(on === true, "authentication.capability.value", `${path}.team.${control}`, `${control} is declared by presence: send true or omit it`);
@@ -2716,20 +2717,20 @@ function validateUserCapabilitiesInto(value, path, into, levels) {
     }
 }
 /**
- * The modes a lead may listen in, as a list: whisper and join-call begin from a monitor, so a list
- * without `monitor` names modes the lead could never reach.
+ * The modes a lead may listen in, as a list: coach and join-call begin with silent listening, so a list
+ * without `listen` names modes the lead could never reach.
  */
-function validateMonitorControl(value, path, into) {
+function validateListeningControl(value, path, into) {
     if (!Array.isArray(value) || value.length === 0) {
-        into.add("authentication.capability.team.monitorControl.shape", path, "monitorControl lists the modes this lead may listen in: a non-empty array, or omitted for a lead who may not");
+        into.add("authentication.capability.team.listeningControl.shape", path, "listeningControl lists the modes this lead may listen in: a non-empty array, or omitted for a lead who may not");
         return;
     }
     value.forEach((mode, index) => {
-        if (into.oneOf(mode, MONITOR_MODES, "authentication.capability.team.monitorControl.mode", `${path}[${index}]`) && value.indexOf(mode) !== index) {
-            into.add("authentication.capability.team.monitorControl.unique", `${path}[${index}]`, `duplicate monitor mode: ${describeValue(mode)}`);
+        if (into.oneOf(mode, LISTENING_MODES, "authentication.capability.team.listeningControl.mode", `${path}[${index}]`) && value.indexOf(mode) !== index) {
+            into.add("authentication.capability.team.listeningControl.unique", `${path}[${index}]`, `duplicate listen mode: ${describeValue(mode)}`);
         }
     });
-    into.require(value.includes("monitor"), "authentication.capability.team.monitorControl.monitor", path, "whisper and join-call begin from a monitor: a lead who may listen in any mode may monitor");
+    into.require(value.includes("listen"), "authentication.capability.team.listeningControl.listen", path, "coach and join-call begin with silent listening: a lead who may listen in any mode may listen");
 }
 /**
  * A failure an authentication reports: on a `rejected` start or completion, or on an `expired`

package/guide.md

@@ -40,7 +40,7 @@ are used precisely throughout and mean nothing looser here.
 | **Break** | A reported, supervised state in which the agent is not working — one with a reason, a decision behind it and a return. It covers what a platform may call *not-ready*, including equipment trouble. An agent who is merely at capacity is not on a break. |
 | **Workspace** | What Omni shows the agent. The **task workspace** holds the selected task, its controls and its browsers; the **idle workspace** holds what a provider contributes when no task is selected — dialpad, contacts, calendar, team member list. |
 | **Dial** | One outbound call the host asks a provider to place — from the idle dialpad, a cold or warm transfer, a conference add, or a connect-back. Identified by the host's `dialId`, accepted as `dialling`, and ended by exactly one `dial-outcome`. See **Every dial has an outcome**. |
-| **Monitor** | A lead listening to a member's call unasked, from the team member list: `monitor` in silence, `whisper` heard by the agent alone, `join-call` heard by everyone. Nothing of it reaches the member's task, and there is no take-over in it. See **Monitoring a call**. |
+| **Listen** | A lead listening to a member's call unasked, from the team member list: `listen` in silence, `coach` heard by the agent alone, `join-call` heard by everyone. Nothing of it reaches the member's task, and there is no take-over in it. See **Listening to a call**. |
 | **On the call** | Who a voice task's audio joins, or is bringing in, as the provider states it on `Task.onCall`: the party, the agents, and anyone consulted or conferenced in from the moment their dial is placed. |
 
 Six words describe *what state a thing is in*, and they are not interchangeable: each belongs to
@@ -246,12 +246,12 @@ type AuthenticationContext = {
   log?: (entry: unknown) => void;
 };
 
-type MonitorMode = "monitor" | "whisper" | "join-call";
+type ListeningMode = "listen" | "coach" | "join-call";
 
 type TeamCapabilities = {
   breakControl?: true;
   leadAssistControl?: true;
-  monitorControl?: MonitorMode[];
+  listeningControl?: ListeningMode[];
   policyControl?: true;
 };
 
@@ -702,11 +702,11 @@ type TaskAssisting = {
   since: IsoTimestamp;
 };
 
-type TaskMonitoring = {
+type TaskListening = {
   memberId: UserId;
   taskId: TaskId;
   allocationId: AllocationId;
-  mode: MonitorMode;
+  mode: ListeningMode;
   since: IsoTimestamp;
 };
 
@@ -747,8 +747,8 @@ type Task<C extends Channel = Channel> = {
   interactionHistory?: TaskInteractionHistory;
 } & TaskCompletion & (
   C extends "voice"
-    ? { recording?: { provider?: RecordingState }; onCall?: OnCall[]; leadAssist?: TaskLeadAssist; assisting?: TaskAssisting; monitoring?: TaskMonitoring; media?: TaskMediaState }
-    : { recording?: never; onCall?: never; leadAssist?: never; assisting?: never; monitoring?: never; media?: never }
+    ? { recording?: { provider?: RecordingState }; onCall?: OnCall[]; leadAssist?: TaskLeadAssist; assisting?: TaskAssisting; listening?: TaskListening; media?: TaskMediaState }
+    : { recording?: never; onCall?: never; leadAssist?: never; assisting?: never; listening?: never; media?: never }
 );
 
 type PreviewDeadline = "calls" | "host-calls" | "waits";
@@ -1047,14 +1047,14 @@ type TeamLeadAssistCommandRequest = {
   command: TeamLeadAssistCommand;
 };
 
-type TeamMonitorCommand =
-  | { type: "monitor"; memberId: UserId }
-  | { type: "whisper" }
+type TeamListenCommand =
+  | { type: "listen"; memberId: UserId }
+  | { type: "coach" }
   | { type: "join-call" }
   | { type: "leave" };
 
-type TeamMonitorCommandRequest = {
-  command: TeamMonitorCommand;
+type TeamListenCommandRequest = {
+  command: TeamListenCommand;
 };
 
 type TeamCommandResult =
@@ -1173,7 +1173,7 @@ type Connection<C extends Channel = Channel> = {
 
   executeTeamBreak?(request: TeamBreakCommandRequest): Promise<TeamCommandResult>;
   executeTeamLeadAssist?(request: TeamLeadAssistCommandRequest): Promise<TeamCommandResult>;
-  executeTeamMonitor?(request: TeamMonitorCommandRequest): Promise<TeamCommandResult>;
+  executeTeamListen?(request: TeamListenCommandRequest): Promise<TeamCommandResult>;
   openMedia?(request: OpenMediaRequest): Promise<OpenMediaResult>;
   setPreference?(request: SetPreferenceRequest): Promise<PreferenceResult>;
   recordStep?(report: InteractionReport): Promise<InteractionReportResult>;
@@ -1926,7 +1926,7 @@ them from what arrives later.
 | `team` | This login leads a team. The provider publishes a `TeamMembers` object to it on every snapshot — `members: []` when nobody is in it — and to nobody else. |
 | `team.breakControl` | This lead may act on their team's breaks through `executeTeamBreak` — place, release, decide, set policy — as far as the provider supports; a command it lacks answers `omni.capability-not-enabled`. Omni asks for a decision only against a member whose `break` is `awaiting-decision`, so a provider that grants on request is never asked to decide. Requires `executeTeamBreak`. |
 | `team.leadAssistControl` | This lead may join a member's call on request. Requires `executeTeamLeadAssist`. |
-| `team.monitorControl` | This lead may listen to a member's call unasked, in the listed modes and no others: `monitor`, `whisper`, `join-call`. The list always includes `monitor`, since the other two begin from one. Requires `executeTeamMonitor`. See **Monitoring a call**. |
+| `team.listeningControl` | This lead may listen to a member's call unasked, in the listed modes and no others: `listen`, `coach`, `join-call`. The list always includes `listen`, since the other two begin from one. Requires `executeTeamListen`. See **Listening to a call**. |
 | `team.policyControl` | This lead sets the team's policy per capability — on, off, or the person's — within what the queue allows. Requires `executeTeamPolicy`; the team member list carries `policies`. |
 | `preferences` | What the team left to this person, with where each stands and who set it. Omitted when nothing was. Requires `setPreference`. See **Who decides what an agent may do**. |
 
@@ -2161,7 +2161,7 @@ surface in one place, and what obliges an adapter to implement each one.
 | `endBreak()` | The login declares `capabilities.breaks`. |
 | `executeTeamBreak(command)` | The login declares `capabilities.team.breakControl`. |
 | `executeTeamLeadAssist(command)` | The login declares `capabilities.team.leadAssistControl`. |
-| `executeTeamMonitor(command)` | The login declares `capabilities.team.monitorControl`. |
+| `executeTeamListen(command)` | The login declares `capabilities.team.listeningControl`. |
 | `setPreference(request)` | The login declares `capabilities.preferences`: the person's choice has to have somewhere to go. |
 | `recordStep(report)` | The manifest lists `softphone` among its `phones`. On a softphone the host mutes its own microphone on any call, and the provider's record has to have somewhere to take that leg; a desk phone's microphone is the phone's. See **The host records what it performs**. |
 | `executeTeamPolicy(command)` | The login declares `capabilities.team.policyControl`. |
@@ -2297,7 +2297,7 @@ An automatically accepted task still arrives through `task-offered`.
 
 **Work the agent originated is accepted by the command that created it.** A task born of the
 agent's own act — a dialpad call or a connect-back, recognisable by the host's `dialId` on
-`onCall`; a lead's join, carrying `assisting`; a lead's monitor, carrying `monitoring` — arrives
+`onCall`; a lead's join, carrying `assisting`; a lead's listen, carrying `listening` — arrives
 through `task-offered` with `acceptance: "automatic"` whatever `autoAcceptTasks` says, and the
 validator holds it there under either provisioning and under none (`task.acceptance.originated`):
 the desk shows no **Accept** for a call the agent placed. The provisioning governs work the queue
@@ -2395,7 +2395,7 @@ time. Runtime conformance checks also require the task channel to match its prov
 | `onCall` | Voice only. Who is on the call, or being brought onto it, as the provider states it, replaced whole with the task: `party` is the customer -- carrying a `stage` while being dialled again on the same task, a connect-back with the host's `dialId` or a platform's callback without, ringing from the moment the dial is placed and joined on its answered outcome --, `agent` a person by user id, `consulted` and `conferenced` somebody a dial is bringing in, listed from the moment the dial is placed -- with the `destinationId` dialled, the `dialId` where a host placed it, the `stage` reached (`ringing` until answered, `joined` after), and `held: true` on anyone joined and parked. A `consulted` entry is what makes `transfer` `complete` and `cancel` issuable. `label` names a destination -- a person, a queue -- not a phrase; the host supplies the verb. Present when the provider knows the room, absent when it does not. See **Every dial has an outcome**. |
 | `leadAssist` | Voice only. Present from the agent's request for a lead until the lead leaves or the request ends: `requested` while nobody has joined, `joined` with the lead's `leadId` once somebody has. See **Lead assist**. |
 | `assisting` | Voice only, on the lead's own task for a call they joined: which member asked, with their note. Its presence is what makes `lead-assist` `take-over` and `leave` issuable. See **Lead assist**. |
-| `monitoring` | Voice only, on the lead's own task while they listen to a member's call: whose call, which call, and the `mode` they are heard in, restated on every change. Never on the member's task, and never together with `assisting`. See **Monitoring a call**. |
+| `listening` | Voice only, on the lead's own task while they listen to a member's call: whose call, which call, and the `mode` they are heard in, restated on every change. Never on the member's task, and never together with `assisting`. See **Listening to a call**. |
 
 `TaskAttribute` entries carry typed detail alongside the task:
 
@@ -3625,7 +3625,7 @@ rendering one as the other tells an agent to wait for somebody who is never comi
 | `awaiting-decision` | A person has to decide. The agent is waiting on somebody. |
 | `granted` | A person decided yes. Omni may now tell this provider to stop the agent; until it does, work continues normally, and this says nothing about why Omni has not. |
 | `starting-after-task` | Omni has told the provider to stop; the break begins when the current task ends. No new work arrives meanwhile, and nobody needs to act. It waits on a task, so beside no task it is refused (`break.starting-after-task.tasks`): a committed break with nothing outstanding is `in-effect`. |
-| `in-effect` | The agent is on the break now. It holds no task: a break begins when the work ends, so a snapshot reporting `in-effect` beside a task is refused as `break.in-effect.tasks`. The one exception is a lead's monitoring task during a `coaching`, `administrative` or `training` break -- see **Monitoring a call**. |
+| `in-effect` | The agent is on the break now. It holds no task: a break begins when the work ends, so a snapshot reporting `in-effect` beside a task is refused as `break.in-effect.tasks`. The one exception is a lead's listening task during a `coaching`, `administrative` or `training` break -- see **Listening to a call**. |
 
 A denial is a decision, not a standing approval state. The provider transitions the request directly
 to `not-requested`; Omni returns the agent to idle and never asks again on their behalf. They saw the
@@ -3771,7 +3771,7 @@ that association and backend authorization are provider responsibilities.
 
 Use `validateBreakStatus(state, tasks)` on the complete retained task view after each transaction,
 as well as `validateBreakTransition` for event ordering. Snapshot validation shares the status
-checks. Pending and completing tasks still count as work. Only the existing monitoring exception
+checks. Pending and completing tasks still count as work. Only the existing listening exception
 allows tasks beside a break in effect. Validate full task shapes and the envelope separately.
 
 These validators report violations without dispatching, rewriting state or proving freshness.
@@ -4183,13 +4183,40 @@ const leadAssistCapable = {
 Lead and member alike are `UserId`s of this provider, so an adapter publishing them implements
 `describeUsers()`; names never travel on a task or a team member list.
 
-### Monitoring a call
+### Listening to a call
 
-The user-facing action is **Join call**. The command and monitoring mode are `join-call`.
-Migration: replace the former barge literal in `TeamMonitorCommand`, `MonitorMode`,
-`team.monitorControl`, and the task’s `monitoring.mode`. `MONITOR_MODES` exports the new literal;
+**Listen** lets the lead hear the call without being heard. The modes are `listen`, `coach`
+(agent-only lead audio), and `join-call` (lead audio heard by everyone).
+
+| Former API | Current API |
+| --- | --- |
+| MonitorMode / MONITOR_MODES | `ListeningMode` / `LISTENING_MODES` |
+| TeamMonitorCommand / TeamMonitorCommandRequest | `TeamListenCommand` / `TeamListenCommandRequest` |
+| executeTeamMonitor | `executeTeamListen` |
+| team.monitorControl | `team.listeningControl` |
+| TaskMonitoring / task.monitoring | `TaskListening` / the task’s `listening` field |
+| MONITORING_BREAK_KINDS / breakKindAllowsMonitoring | `LISTENING_BREAK_KINDS` / `breakKindAllowsListening` |
+| monitor action and mode | `listen` action and mode |
+
+Update command dispatch, allowed modes, task snapshots, imports and diagnostics together.
+The former names are not aliases. Old task and permission fields are rejected even alongside
+new fields. Validation rule segments now use `listening`, `listeningControl`, and `listen`.
+The existing login permissions, single-call limits, allowed break kinds and audio effects
+remain unchanged. Listening includes its coach/join-call modes and does not imply takeover.
+
+
+**Coach** lets the lead speak privately to the agent; the caller cannot hear the lead.
+The command and listening mode are `coach`. Migration: replace the former whisper literal
+in `TeamListenCommand`, `ListeningMode`, `team.listeningControl`, and the task’s `listening.mode`.
+`LISTENING_MODES` exports `coach`; update command producers, permissions and retained snapshots
+together. No legacy alias is accepted. The lead must already be listening and permitted to
+coach. This mode does not join the audible caller conversation or take over the task.
+
+The user-facing action is **Join call**. The command and listening mode are `join-call`.
+Migration: replace the former barge literal in `TeamListenCommand`, `ListeningMode`,
+`team.listeningControl`, and the task’s `listening.mode`. `LISTENING_MODES` exports the new literal;
 no legacy alias is accepted. Update commands, capability declarations and retained snapshots
-together. The lead must already be monitoring and permitted to use this mode. Everyone on the
+together. The lead must already be listening and permitted to use this mode. Everyone on the
 call hears the lead; this does not transfer ownership or invoke lead-assist takeover.
 
 A lead may listen to a member's call without being asked -- to coach, to check quality, to step in
@@ -4199,63 +4226,63 @@ three modes determine who hears the lead:
 
 | Mode | Who hears the lead |
 | --- | --- |
-| `monitor` | Nobody. The lead hears both sides in silence. |
-| `whisper` | The agent alone. The customer hears nothing. |
+| `listen` | Nobody. The lead hears both sides in silence. |
+| `coach` | The agent alone. The customer hears nothing. |
 | `join-call` | Everyone on the call. |
 
-The login says which modes this lead has, as a list on `team.monitorControl`, and it always
-includes `monitor`, because whisper and join-call begin from one
-(`authentication.capability.team.monitorControl.monitor`). A centre that lets every lead listen but
-reserves joining the call declares `["monitor", "whisper"]`, and Omni offers no Join call to that lead. The
-declaration requires `executeTeamMonitor`, gated exactly as `executeTeamLeadAssist` is by
+The login says which modes this lead has, as a list on `team.listeningControl`, and it always
+includes `listen`, because coach and join-call begin from one
+(`authentication.capability.team.listeningControl.listen`). A centre that lets every lead listen but
+reserves joining the call declares `["listen", "coach"]`, and Omni offers no Join call to that lead. The
+declaration requires `executeTeamListen`, gated exactly as `executeTeamLeadAssist` is by
 `team.leadAssistControl`.
 
 ```ts
 // 1. The lead picks a member from the team member list and starts silent.
-executeTeamMonitor({ command: { type: "monitor", memberId: "A-1" } })
+executeTeamListen({ command: { type: "listen", memberId: "A-1" } })
 
 // 2. The lead's own task arrives -- task-offered with `automatic`, as a joined call does -- and
-//    carries `monitoring`; the task id is the lead's, the member's call is named inside it.
-//    monitoring: { memberId: "A-1", taskId: "call-42", allocationId: "alloc-42", mode: "monitor", since }
+//    carries `listening`; the task id is the lead's, the member's call is named inside it.
+//    listening: { memberId: "A-1", taskId: "call-42", allocationId: "alloc-42", mode: "listen", since }
 
 // 3. The lead changes how they are heard; the provider restates the task with the new mode.
-executeTeamMonitor({ command: { type: "whisper" } })
-executeTeamMonitor({ command: { type: "join-call" } })
+executeTeamListen({ command: { type: "coach" } })
+executeTeamListen({ command: { type: "join-call" } })
 
 // 4. The lead leaves; their task ends with `{ type: "left" }`. The member's call goes on.
-executeTeamMonitor({ command: { type: "leave" } })
+executeTeamListen({ command: { type: "leave" } })
 ```
 
 **The lead's task is what gives them audio**: Omni opens media on it as on any voice task, and the
-provider bridges the lead's leg into the member's call in the mode stated. `monitoring.mode` is
-the state, restated on every change, and a `whisper` or `join-call` the login's list does not include
-is answered `failed`. **A lead listens to one call at a time** (`snapshot.monitoring.single`), and
-a task carries lead assistance or monitoring, never both (`task.monitoring.assisting`).
-The `join-call` mode still belongs to monitoring; it does not create `assisting`. The member's
+provider bridges the lead's leg into the member's call in the mode stated. `listening.mode` is
+the state, restated on every change, and a `coach` or `join-call` the login's list does not include
+is answered `failed`. **A lead listens to one call at a time** (`snapshot.listening.single`), and
+a task carries lead assistance or listening, never both (`task.listening.assisting`).
+The `join-call` mode still belongs to listening; it does not create `assisting`. The member's
 call ending ends the lead's task as it ends the member's, with `left`, since the lead was never
 working on it.
 
-**A lead listens only while holding no work of their own.** A monitoring task is the lead's only
-task, and a snapshot carrying one beside any other is refused (`snapshot.monitoring.alone`); Omni
-offers Monitor to a lead with no task. That includes a lead on a break -- unlike joining, which a
+**A lead listens only while holding no work of their own.** A listening task is the lead's only
+task, and a snapshot carrying one beside any other is refused (`snapshot.listening.alone`); Omni
+offers Listen to a lead with no task. That includes a lead on a break -- unlike joining, which a
 break forbids -- but only a break that is work of another sort: `coaching`, `administrative` or
-`training`, the kinds in `MONITORING_BREAK_KINDS`, and never a meal or a rest. A break in effect
-otherwise holds no task; the monitoring task is its one exception, and a snapshot carrying one
+`training`, the kinds in `LISTENING_BREAK_KINDS`, and never a meal or a rest. A break in effect
+otherwise holds no task; the listening task is its one exception, and a snapshot carrying one
 during a break whose active reason is of any other kind, or of no stated kind, is refused
-(`snapshot.monitoring.break`). The kind decides, not the reason's name: a centre that wants leads
+(`snapshot.listening.break`). The kind decides, not the reason's name: a centre that wants leads
 listening during a break declares that break `coaching`, `administrative` or `training`.
 
-**Nothing reaches the member.** The member's task carries no trace of a monitoring lead in any
-mode: not on `onCall`, not in the record. Whether a whisper is announced to the agent is the
+**Nothing reaches the member.** The member's task carries no trace of a listening lead in any
+mode: not on `onCall`, not in the record. Whether coaching is announced to the agent is the
 platform's business and travels on the audio, not on this wire.
 
 ```ts
-const monitoringLead = {
+const listeningLead = {
   channel: "voice",
   capabilities: {},
   phase: "in-progress",
-  monitoring: { memberId: "A-1", taskId: "call-42", allocationId: "alloc-42", mode: "whisper", since: "2026-08-21T09:04:00Z" },
-} satisfies Pick<Task<"voice">, "channel" | "capabilities" | "phase" | "monitoring">;
+  listening: { memberId: "A-1", taskId: "call-42", allocationId: "alloc-42", mode: "coach", since: "2026-08-21T09:04:00Z" },
+} satisfies Pick<Task<"voice">, "channel" | "capabilities" | "phase" | "listening">;
 ```
 
 ### A member waiting for a break

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xema/omni-protocol",
-  "version": "0.1.87",
+  "version": "0.1.89",
   "description": "The Omni protocol: the contract every provider adapter implements",
   "type": "module",
   "license": "MIT",