@xema/omni-protocol 0.1.100 → 0.1.101

package/dist/index.d.ts

@@ -866,7 +866,7 @@ export type TaskLeadAssist = {
  * On a task that reached this agent by a lead's take-over: which member the call was taken from,
  * and when. The provider moves the call from one agent to another, and the lead is the new agent,
  * so the task is an ordinary assignment with the call's history -- offered whatever break the lead
- * is on, counted against no capacity, provided their voice channel is free.
+ * is on, counted against their capacity like any other call, provided they are under it and their voice channel is free.
  */
 export interface TaskTakenOver {
     memberId: UserId;
@@ -1041,7 +1041,7 @@ export type VoiceTaskCommand = {
  | {
     type: "end-call";
 }
-/** End the caller channel. Gated by `terminateCall`. */
+/** End the whole call at the provider: every channel on it, the agent's, the caller's and anyone else's. Gated by `terminateCall`. */
  | {
     type: "terminate-call";
 }
@@ -1269,6 +1269,8 @@ export interface TeamMember {
     tasks?: MemberTask[];
     /** Present while this lead is on the member's call, listening, coaching or joined; absent otherwise. */
     listening?: MemberListening;
+    /** The member's own history for the day: sign-in, sign-out, breaks and productivity. Omitted where the provider cannot say. */
+    shift?: MemberShift;
 }
 /** A member asking this lead to join their call, named by the member and the assignment. */
 export interface LeadRequest {
@@ -1309,11 +1311,36 @@ export type MemberTask<C extends Channel = Channel> = {
     takenOver?: never;
     audio?: never;
 });
-/** The lead on this member's call, in the mode they are heard, since when. */
+/**
+ * The lead on this member's call: which of the member's calls, in the mode they are heard, since
+ * when. Its appearance on the team member list is the provider's word that the lead's audio is up,
+ * and the application opens `openAudio` on the assignment named; its disappearance closes it.
+ */
 export interface MemberListening {
+    assignmentId: AssignmentId;
     mode: ListeningMode;
     since: IsoTimestamp;
 }
+export type ShiftEventKind = "signed-in" | "signed-out" | "break-started" | "break-ended";
+export declare const SHIFT_EVENT_KINDS: readonly ["signed-in", "signed-out", "break-started", "break-ended"];
+export interface ShiftEvent {
+    at: IsoTimestamp;
+    kind: ShiftEventKind;
+}
+/**
+ * The member's own history for the day, about the person rather than any one call: when they
+ * signed in and out, today's totals as the provider counts them, each present only when the
+ * provider knows it, and the day's sign-in, sign-out and break events, oldest first.
+ */
+export interface MemberShift {
+    signedInAt: IsoTimestamp;
+    signedOutAt?: IsoTimestamp;
+    talkSeconds?: DurationSeconds;
+    holdSeconds?: DurationSeconds;
+    breakSeconds?: DurationSeconds;
+    tasksHandled?: number;
+    events?: ShiftEvent[];
+}
 /**
  * The lead's view of their team: published to a login that declares `capabilities.lead` while the
  * lead has the team feature on, on every snapshot, and to nobody else. The provider keeps it
@@ -1588,20 +1615,6 @@ export type ProviderEvent<C extends Channel = Channel> = {
 } | {
     type: "task-audio-ended";
     assignmentId: AssignmentId;
-}
-/**
- * The lead's channel is in a member's call -- listening, coaching or joined -- and its audio should
- * attach: on a softphone the application opens audio on the member's assignment as it does for a
- * task. Voice, to a login that declares `lead`, never to the member.
- */
- | {
-    type: "team-audio-started";
-    memberId: UserId;
-    assignmentId: AssignmentId;
-} | {
-    type: "team-audio-ended";
-    memberId: UserId;
-    assignmentId: AssignmentId;
 } | {
     type: "task-ended";
     assignmentId: AssignmentId;

package/dist/index.js

@@ -95,6 +95,7 @@ export const BREAK_KINDS = [
     "short-break", "meal", "rest", "training", "coaching",
     "meeting", "administrative", "technical", "personal", "other",
 ];
+export const SHIFT_EVENT_KINDS = ["signed-in", "signed-out", "break-started", "break-ended"];
 export const OMNI_FAILURE_CODES = [
     "omni.not-authenticated",
     "omni.capability-not-enabled",

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.history", "task.onCall", "task.leadAssist", "task.takenOver", "task.audio", "task.acceptance", "task.outcomes", "task.destinations", "task.custom", "task.locked", "break.reasons", "break.forced", "team.members", "team.requests", "team.tasks", "team.listening", "contacts", "calendar", "team.policies"];
+declare const STATE_SUBJECTS: readonly ["tasks", "task.browsers", "task.attributes", "task.history", "task.onCall", "task.leadAssist", "task.takenOver", "task.audio", "task.acceptance", "task.outcomes", "task.destinations", "task.custom", "task.locked", "break.reasons", "break.forced", "team.members", "team.requests", "team.tasks", "team.listening", "team.shift", "contacts", "calendar", "team.policies"];
 export type ContractSubject = (typeof STATE_SUBJECTS)[number] | `event.${ProviderEvent["type"]}`;
 export interface AdapterContractResult {
     events: ProviderEventEnvelope[];

package/dist/testing.js

@@ -27,6 +27,7 @@ const STATE_SUBJECTS = [
     "team.requests",
     "team.tasks",
     "team.listening",
+    "team.shift",
     "contacts",
     "calendar",
     "team.policies",
@@ -36,7 +37,7 @@ const STATE_SUBJECTS = [
 const EVENT_TYPES = {
     snapshot: true, "transport-status": true, "break-state": true, "task-offered": true, "task-updated": true,
     "task-audio-started": true, "task-audio-ended": true, "task-ended": true, "dial-outcome": true, announcement: true, "queue-summary": true, diagnostic: true,
-    "team-updated": true, "team-audio-started": true, "team-audio-ended": true, "contacts-updated": true, "calendar-updated": true,
+    "team-updated": true, "contacts-updated": true, "calendar-updated": true,
 };
 const CONTRACT_SUBJECTS = [
     ...STATE_SUBJECTS,
@@ -102,6 +103,8 @@ function observeTeam(value, seen) {
                 seen.add("team.tasks");
             if (member.listening !== undefined)
                 seen.add("team.listening");
+            if (member.shift !== undefined)
+                seen.add("team.shift");
         }
     if (isRecord(value.policies) && Object.keys(value.policies).length > 0)
         seen.add("team.policies");

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, BROWSER_ISOLATION_SCHEMES, HISTORY_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, SHIFT_EVENT_KINDS, ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, HISTORY_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") {
@@ -1671,10 +1671,17 @@ function validateTeamMembersInto(teamMembers, path, context, into) {
                 into.add("team.member.listening.shape", `${at}.listening`, "listening must be an object when present");
             }
             else {
+                const listened = member.listening;
+                if (into.require(isAssignmentId(member.listening.assignmentId), "team.member.listening.assignmentId", `${at}.listening.assignmentId`, "listening names which of the member's calls the lead is on: the application opens the lead's audio on it") && Array.isArray(member.tasks)) {
+                    into.require(member.tasks.some((task) => isPlainObject(task) && task.assignmentId === listened.assignmentId), "team.member.listening.assignment", `${at}.listening.assignmentId`, "the call the lead is on is one the member's tasks carry");
+                }
                 into.oneOf(member.listening.mode, LISTENING_MODES, "team.member.listening.mode", `${at}.listening.mode`);
                 into.timestamp(member.listening.since, "team.member.listening.since", `${at}.listening.since`);
             }
         }
+        // The member's own history for the day: about the person, not any one call.
+        if (member.shift !== undefined)
+            validateShiftInto(member.shift, `${at}.shift`, into);
     });
     // One member's call at a time.
     const listened = teamMembers.members.filter((member) => isPlainObject(member) && member.listening !== undefined);
@@ -1953,14 +1960,6 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
             into.require(context.leadFeatures !== false, "event.team.features", `${at}.team`, "the lead turned the team feature off, so nothing of the team reaches them");
             validateTeamMembersInto(event.team, `${at}.team`, { ...context, levels, channel: isChannel(channel) ? channel : undefined }, into);
             break;
-        case "team-audio-started":
-        case "team-audio-ended":
-            // The lead's channel in a member's call: audio the application opens on the member's assignment.
-            into.require(channel === "voice", "event.audio.channel", `${at}.type`, "only a voice provider publishes audio transitions");
-            into.require(context.capabilities === undefined || context.capabilities.lead === true, "event.teamAudio.capability", `${at}.type`, "team audio reaches a login that declares lead, and nobody else");
-            into.require(isUserId(event.memberId), "event.teamAudio.memberId", `${at}.memberId`, "team audio names the member whose call the lead is on");
-            into.require(isAssignmentId(event.assignmentId), "event.teamAudio.assignmentId", `${at}.assignmentId`, "team audio names the member's assignment");
-            break;
         case "contacts-updated":
             into.require(idle.contacts === true, "event.contacts.capability", `${at}.contacts`, "contacts-updated requires the contacts idle capability");
             if (!Array.isArray(event.contacts)) {
@@ -2021,6 +2020,43 @@ function validatePreferencesInto(value, path, into, levels) {
     });
 }
 /** The team's policy per capability as the lead sees it: the setting, who set it, who locked it. */
+function validateShiftInto(value, path, into) {
+    if (!isPlainObject(value)) {
+        into.add("team.member.shift.shape", path, "shift must be an object when present");
+        return;
+    }
+    const signedIn = into.timestamp(value.signedInAt, "team.member.shift.signedInAt", `${path}.signedInAt`);
+    if (value.signedOutAt !== undefined && into.timestamp(value.signedOutAt, "team.member.shift.signedOutAt", `${path}.signedOutAt`) && signedIn) {
+        into.require(Date.parse(value.signedOutAt) >= Date.parse(value.signedInAt), "team.member.shift.signedOutAt.order", `${path}.signedOutAt`, "a member signs out after signing in");
+    }
+    for (const field of ["talkSeconds", "holdSeconds", "breakSeconds"]) {
+        if (value[field] !== undefined)
+            into.require(isDurationSeconds(value[field]), `team.member.shift.${field}`, `${path}.${field}`, `${field} must be a whole number of seconds, zero or more, or omitted when unknown`);
+    }
+    if (value.tasksHandled !== undefined)
+        into.require(Number.isInteger(value.tasksHandled) && value.tasksHandled >= 0, "team.member.shift.tasksHandled", `${path}.tasksHandled`, "tasksHandled must be a whole number, zero or more, or omitted when unknown");
+    if (value.events !== undefined) {
+        if (!Array.isArray(value.events)) {
+            into.add("team.member.shift.events.shape", `${path}.events`, "events must be an array when present");
+            return;
+        }
+        let previous;
+        value.events.forEach((event, index) => {
+            const at = `${path}.events[${index}]`;
+            if (!isPlainObject(event)) {
+                into.add("team.member.shift.event.shape", at, "each shift event must be an object");
+                return;
+            }
+            into.oneOf(event.kind, SHIFT_EVENT_KINDS, "team.member.shift.event.kind", `${at}.kind`);
+            if (into.timestamp(event.at, "team.member.shift.event.at", `${at}.at`)) {
+                const instant = Date.parse(event.at);
+                if (previous !== undefined && instant < previous)
+                    into.add("team.member.shift.events.order", `${at}.at`, "shift events are oldest first; this event is earlier than the one before it");
+                previous = instant;
+            }
+        });
+    }
+}
 function validateTeamPoliciesInto(value, path, into, levels) {
     if (!isPlainObject(value)) {
         into.add("team.policies.shape", path, "policies must be an object keyed by capability");

package/guide.md

@@ -977,6 +977,7 @@ type TeamMember = {
   break?: Extract<BreakStatus, "awaiting-approval" | "granted" | "starting-after-task">;
   tasks?: MemberTask[];
   listening?: MemberListening;
+  shift?: MemberShift;
 };
 
 type LeadRequest = {
@@ -1006,10 +1007,28 @@ type MemberTask<C extends Channel = Channel> = {
   : { onCall?: never; leadAssist?: never; takenOver?: never; audio?: never });
 
 type MemberListening = {
+  assignmentId: AssignmentId;
   mode: ListeningMode;
   since: IsoTimestamp;
 };
 
+type ShiftEventKind = "signed-in" | "signed-out" | "break-started" | "break-ended";
+
+type ShiftEvent = {
+  at: IsoTimestamp;
+  kind: ShiftEventKind;
+};
+
+type MemberShift = {
+  signedInAt: IsoTimestamp;
+  signedOutAt?: IsoTimestamp;
+  talkSeconds?: DurationSeconds;
+  holdSeconds?: DurationSeconds;
+  breakSeconds?: DurationSeconds;
+  tasksHandled?: number;
+  events?: ShiftEvent[];
+};
+
 type TeamMembers = {
   members: TeamMember[];
   requests: LeadRequest[];
@@ -1108,8 +1127,6 @@ type ProviderEvent =
   | { type: "task-updated"; task: Task }
   | { type: "task-audio-started"; assignmentId: AssignmentId }
   | { type: "task-audio-ended"; assignmentId: AssignmentId }
-  | { type: "team-audio-started"; memberId: UserId; assignmentId: AssignmentId }
-  | { type: "team-audio-ended"; memberId: UserId; assignmentId: AssignmentId }
   | { type: "task-ended"; assignmentId: AssignmentId; outcome: TaskOutcome }
   | { type: "dial-outcome"; dialId: DialId; outcome: DialOutcome; assignmentId?: AssignmentId; destinationId?: string; reason?: string }
   | { type: "announcement"; text: string; html?: string; announcedAt: IsoTimestamp; expiresAt?: IsoTimestamp }
@@ -2382,7 +2399,7 @@ time. Runtime conformance checks also require the task channel to match its prov
 | `history` | The call record: `steps` — the ordered interaction history of this open task, one entry per occurrence, oldest first — and what they add up to before this agent, `interactionSeconds`, `holdSeconds`, `queueSeconds`, `transfers`, each present when the provider knows it. Live task data restated with the task, not a permanent archive. See **Interaction history**. |
 | `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 agent application'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 an agent application 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 agent application 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**. |
-| `takenOver` | Voice only, on a task that reached this agent by a lead's take-over: which member the call was taken from, and when. It is an ordinary assignment with the call's history, offered whatever break the lead is on and counted against no capacity. See **Lead assist**. |
+| `takenOver` | Voice only, on a task that reached this agent by a lead's take-over: which member the call was taken from, and when. It is an ordinary assignment with the call's history, offered whatever break the lead is on and counted against their capacity like any other call. See **Lead assist**. |
 
 `TaskAttribute` entries carry typed detail alongside the task:
 
@@ -2730,7 +2747,7 @@ Migration from the earlier spellings:
 | taskKey, omni.task-not-found, PROVIDER_NAME__TASK_ID__TAB_NAME (ProviderName.TaskId.TabName) | `assignmentKey`, `omni.assignment-not-found`, `PROVIDER_NAME__ASSIGNMENT_ID__TAB_NAME` (`ProviderName.AssignmentId.TabName`) |
 | Manifest.disposalSettleMs | `Manifest.completionSettleMs` |
 | the call command, atDeadline calls and host-calls | `dial`, `"provider-dials"`, `"host-dials"` |
-| media: task-media-started/-ended, team-media-*, Task.media, TaskMediaState, openMedia, OpenMediaRequest/Result, VoiceMediaSession and its session field | audio: `task-audio-started`, `task-audio-ended`, `team-audio-started`, `team-audio-ended`, `audio` on the task, `TaskAudioState`, `openAudio`, `OpenAudioRequest`, `OpenAudioResult`, `CallAudio` on the result's `audio` |
+| media: task-media-started/-ended, team-media-*, Task.media, TaskMediaState, openMedia, OpenMediaRequest/Result, VoiceMediaSession and its session field | audio: `task-audio-started`, `task-audio-ended`, `audio` on the task, `TaskAudioState`, `openAudio`, `OpenAudioRequest`, `OpenAudioResult`, `CallAudio` on the result's `audio`; there is no team audio, the lead's follows `listening` on the member |
 | capabilitySource values ungoverned and undetermined | `nobody`, `not-yet-read` (`capabilitySource.notYetRead`) |
 | Snapshot.scheduledActivities, and scheduledActivities on calendar-updated | `calendar` in both |
 | availability reserved | `elsewhere` |
@@ -3194,7 +3211,7 @@ See **Which commands need a capability**.
 | `decline` | Pending-task button: Decline | The provider can decline a pending voice offer. Omni shows it only when local policy also permits declining. |
 | `hold` | Primary toggle: Hold | Omni may issue voice-task `hold` and `resume` commands. |
 | `endCall` | Primary button: End call | The provider ends the agent's channel and every channel the agent added; the caller continues on the provider's path. The task goes to its wrap. See **Ending a call, and removing one person from it**. |
-| `terminateCall` | Primary button: Terminate call | The provider ends the caller channel. The task goes to its wrap. See **Ending a call, and removing one person from it**. |
+| `terminateCall` | Primary button: Terminate call | The provider ends the whole call: every channel on it, the agent's, the caller's, any colleague's and anyone else's. The task goes to its wrap. See **Ending a call, and removing one person from it**. |
 | `connectBack` | Completing-task button: Connect back | Omni may have the provider connect the agent back to the task's party while the task is `completing`, returning it to `in-progress` on the same task. Not offered where there is no `completing` window: `provider-automatic` with a zero allowance completes the task at provider end. See **Connecting back during completion**. |
 | `coldTransfer` | Secondary menu item: Cold transfer | Omni may hand the customer straight to a destination, with nobody spoken to first. |
 | `warmTransfer` | Secondary menu item: Warm transfer | Omni may park the customer and call a destination first, then hand the customer over or cancel back. See **Warm transfer**. |
@@ -3294,7 +3311,7 @@ provider. Two of them end the agent's part; they differ in what happens to the c
 
 ```ts
 { type: "end-call" }                                             // the agent's channel and the channels the agent added end; the caller continues
-{ type: "terminate-call" }                                       // the caller channel ends
+{ type: "terminate-call" }                                       // every channel on the call ends
 { type: "conference", action: "remove", party: true }            // the customer leaves; the agent stays with the colleague
 { type: "conference", action: "remove", destinationId: "tier2" } // the conferenced person leaves; ringing, this calls the dial off
 ```
@@ -3303,9 +3320,10 @@ provider. Two of them end the agent's part; they differ in what happens to the c
 conferenced colleague, a consulted destination -- end, and the caller continues on the path the
 provider decides: another IVR, a queue, a survey, or the end of the call. Gated by `endCall`.
 
-**`terminate-call` ends the caller channel.** The call is over for the caller. Gated by
-`terminateCall`, a separate permission, since ending a customer's call is a different thing from
-putting my own side down.
+**`terminate-call` ends the whole call.** Every channel on it ends at the provider: the agent's,
+the caller's, any colleague the agent added, and anyone else on the call. Nobody is left on the
+line. Gated by `terminateCall`, a separate permission, since ending a customer's call is a
+different thing from putting my own side down.
 
 Both are commands to the provider through `execute`, and nothing happens on the desk until the
 provider reports it: the agent's audio ends on `task-audio-ended`, the task moves to `completing`,
@@ -4131,8 +4149,9 @@ for nothing and computes nothing.
 | `availability` | Required. What the member is doing now. |
 | `since` | Optional. When the current `availability` began — not when they signed in, and not when the team member list was read. |
 | `break` | Present only while the member has an outstanding break request. See **A member waiting for a break**. |
-| `tasks` | The member's open tasks as `MemberTask`s: the same task the member's desk holds, trimmed by the provider. The assignment, title, task type, phase, party, room, audio and the full history are what the lead reads; the workspace — controls, their source, browsers, completion terms — is the member's and travels only if the provider sends it. `[]` when the member holds none; omitted only where the provider cannot see them. |
-| `listening` | Present while this lead's channel is in this member's call — listening, coaching or joined — with the `mode` they are heard in and since when. One member's call at a time (`team.listening.single`). |
+| `tasks` | The member's open tasks as `MemberTask`s: the same task the member's desk holds, trimmed by the provider. The assignment, title, task type, phase, party, room and audio are what the lead reads; the task's history is carried in the same shape as on the member's desk, as much of it as the provider chooses to send; the workspace — controls, their source, browsers, completion terms — is the member's and travels only if the provider sends it. `[]` when the member holds none; omitted only where the provider cannot see them. |
+| `listening` | Present while this lead's channel is in this member's call — listening, coaching or joined — naming which of the member's calls by `assignmentId`, the `mode` they are heard in, and since when. Its appearance is what the lead's audio opens on. One member's call at a time (`team.listening.single`). |
+| `shift` | The member's own history for the day, about the person rather than any one call: `signedInAt`, `signedOutAt` once it has happened, today's totals as the provider counts them — `talkSeconds`, `holdSeconds`, `breakSeconds`, `tasksHandled`, each present only when the provider knows it — and the day's sign-in, sign-out and break `events`, oldest first. Omitted where the provider cannot say. |
 
 Each availability value means one thing:
 
@@ -4239,8 +4258,8 @@ executeTeam({ command: { type: "decline", memberId: "A-1", reason: "In a call" }
 
 **On `join` the provider bridges the lead's channel into the call.** The member's task moves to
 `leadAssist: { stage: "joined", leadId }`, the member on the team member list carries
-`listening: { mode: "join-call", since }`, and the lead's audio arrives as **Listening to a call**
-describes. Nothing is a task on the lead's desk: a join is the lead's act on the team surface, not
+`listening: { assignmentId, mode: "join-call", since }`, and the lead's audio opens on it as
+**Listening to a call** describes. Nothing is a task on the lead's desk: a join is the lead's act on the team surface, not
 work assigned to them.
 
 **A lead is on one member's call at a time.** A `join` from a lead already on a call -- their own
@@ -4261,15 +4280,17 @@ listening unasked -- and one act at the end of either. What follows is the same
 
 | | The member's task | The lead's desk |
 | --- | --- | --- |
-| Take-over | `task-audio-ended`, then `completing`: the member's interaction is over and their wrap runs, exactly as after `end-call`. The audio ends first, as before every voice ending (`stream.taskEnded.audioOpen`). | An ordinary assignment arrives: `task-offered` with `acceptance: "automatic"`, carrying the call's history and `takenOver: { memberId, since }`. |
+| Take-over | `task-audio-ended`, then `completing`: the member's interaction is over and their wrap runs, exactly as after `end-call`. The audio ends first, as before every voice ending (`stream.taskEnded.audioOpen`). The member loses `listening` on the team member list no later than the offer, and the lead's listening audio closes. | An ordinary assignment arrives: `task-offered` with `acceptance: "automatic"`, carrying the call's history and `takenOver: { memberId, since }`, within the lead's capacity. |
 | The member completes | `task-ended` with `{ type: "taken-over", leadId }`, at the member's own completion. The lead is named by user id, since a lead is not a directory item. | The lead works the call as any agent would, and ends it as any call ends. |
 
-**The taken-over call is offered whatever break the lead is on.** A lead working as lead alone is
-on a break of a working kind, and the provider assigns the call regardless: it is the one task a
-break in effect may hold (`break.on-break.tasks` allows it, and nothing else). It is the lead's own
-act, so it counts against no capacity, like the agent's own dial; the only conditions are that the
-lead is not already on another call and their voice channel is free. A lead with the team feature
-off cannot take over, since they have no member's assignment to name.
+**The taken-over call is offered whatever break the lead is on, and counted like any other.** A
+lead working as lead alone is on a break of a working kind, and the provider assigns the call
+regardless: it is the one task a break in effect may hold (`break.on-break.tasks` allows it, and
+nothing else). It is a call landing on the lead's desk, so it counts against their capacity as
+every call does, with no exemption: a lead at capacity cannot take over, and the provider answers
+`failed`. The other conditions are that the lead is not already on another call and their voice
+channel is free. A lead with the team feature off cannot take over, since they have no member's
+assignment to name.
 
 ```ts
 const leadAssistCapable = {
@@ -4303,34 +4324,47 @@ history. The three modes determine who hears the lead:
 | `coach` | The agent alone. The customer hears nothing. |
 | `join-call` | Everyone on the call. |
 
-All three come with the `lead` flag; a centre reserves none of them per lead. The flow:
+All three come with the `lead` flag; a centre reserves none of them per lead.
 
-```ts
-// 1. The lead picks a member from the team member list and starts silent.
-executeTeam({ command: { type: "listen", memberId: "A-1" } })
-//    team-updated: the member carries listening: { mode: "listen", since }
-//    team-audio-started: { memberId: "A-1", assignmentId: "alloc-42" } -- the lead's audio attaches
+**There is no team audio.** Audio is the agent's or the lead's, and the lead's audio while
+listening follows the provider's published state exactly as a task's does: `listening` on the
+member is the provider's word that the lead's channel is in the call. When it appears, the
+application opens `openAudio({ assignmentId })` on the lead's connection for the call it names,
+and plays the `CallAudio` returned; when it goes, the application closes it. Nothing else says
+when the lead's audio is up, and a reload reopens it from the snapshot's team member list as a task
+carried with `audio: "started"` is reopened.
+
+The flow, end to end:
 
-// 2. The lead changes how they are heard; the provider restates the member with the new mode.
+```ts
+// 1. The lead, with the feature on, sees a member on-task with their tasks, and picks a call.
+// 2. The lead's channel joins it in silence. Conditions: the lead's voice channel is free --
+//    not on a call, not listening elsewhere. Capacity is not involved: nothing is assigned.
+executeTeam({ command: { type: "listen", memberId: "A-1", assignmentId: "alloc-42" } })
+// 3. The provider republishes the team member list; the member carries
+//    listening: { assignmentId: "alloc-42", mode: "listen", since }
+//    -- the application opens openAudio({ assignmentId: "alloc-42" }) on the lead's connection.
+// 4. The lead changes how they are heard; the provider restates listening.mode. The audio stays open.
 executeTeam({ command: { type: "coach", memberId: "A-1" } })
 executeTeam({ command: { type: "join-call", memberId: "A-1" } })
-
-// 3. The lead leaves, or takes the call.
+// 5. The lead leaves: the provider republishes the member without listening; the application closes the audio.
 executeTeam({ command: { type: "leave", memberId: "A-1" } })
+// 6. The member's call ends: the same as leave, from the provider's side.
+// 7. The lead takes the call: the member loses listening no later than the offer, the application
+//    closes the listening audio, and the lead's own call arrives as an ordinary assignment marked
+//    takenOver, counted against capacity, with its audio following task-audio-started as any call's does.
+//    At capacity the take-over is refused and the lead stays listening.
 executeTeam({ command: { type: "take-over-call", memberId: "A-1" } })
+// 8. A join on the member's request is the same flow entered at step 3 with mode: "join-call",
+//    and the member's task shows leadAssist: joined.
+// 9. A reload of the lead's application: the snapshot's team member list still carries listening,
+//    so the audio is reopened.
 ```
 
-**The lead's audio arrives through team audio.** While the lead's channel is in a member's call
--- listening, coaching or joined on request -- the lead's connection receives `team-audio-started`
-naming the member and the member's assignment, and on a softphone the agent application opens
-`openAudio` on that assignment as it does for a task; `team-audio-ended` closes it. Voice only, and
-to a login that declares `lead` (`event.teamAudio.*`). The member's own audio events are the
-member's and never reach the lead.
-
-**`listening` on the member is the state**, restated on every change of mode, and a lead is on
-one member's call at a time (`team.listening.single`). The member's call ending ends the lead's
-listening with it: the provider republishes the member without `listening` and sends
-`team-audio-ended`.
+**`listening` on the member is the state**, restated on every change of mode, naming the call so
+the application knows which audio to open (`team.member.listening.assignmentId`, and one the
+member's tasks carry, `team.member.listening.assignment`), and a lead is on one member's call at a
+time (`team.listening.single`).
 
 **A lead listens while holding no call of their own.** Omni offers Listen to a lead whose voice
 channel is free, and a provider answers a `listen` from one whose channel is not `failed`. That
@@ -4689,7 +4723,7 @@ declared:
 | --- | --- |
 | `answer`, `accept` | Nothing. A task that was offered can be accepted, or offering it meant nothing. |
 | `end-call` | The `endCall` capability: ends my part, the caller continues. |
-| `terminate-call` | The `terminateCall` capability: ends the caller channel. |
+| `terminate-call` | The `terminateCall` capability: ends the whole call, every channel on it. |
 | `conference` with `action: "remove"` | The `conference` capability, and somebody else on the call: a remove that would leave the agent alone is `end-call`, and a provider answers it `failed`. |
 | `decline` | The `decline` capability on any channel, **and** Omni local policy permitting it. One word for refusing an offer, whatever the channel. |
 | `dial` | The `preview` phase. A record put in front of an agent is there to be called, so the phase is the gate and there is no capability. It is a dial, with a `dialId` and a `dial-outcome`. |

package/package.json

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