@xema/omni-protocol 0.1.36 → 0.1.38

package/dist/index.d.ts

@@ -173,8 +173,8 @@ export interface TeamCapabilities {
      * `omni.capability-not-enabled`. Requires `executeTeamBreak`.
      */
     breakControl?: true;
-    /** This lead may join a member's call on request. Requires `executeTeamConsult`. */
-    consultControl?: true;
+    /** This lead may join a member's call on request. Requires `executeTeamLeadAssist`. */
+    leadAssistControl?: true;
     /** This lead sets the team's policy per capability -- on, off, or the agent's -- within what the queue allows. Requires `executeTeamPolicy`. */
     policyControl?: true;
 }
@@ -442,8 +442,8 @@ export type TaskCapabilities<C extends Channel = Channel> = C extends "voice" ?
     blindTransfer?: Lockable<true | DestinationDirectory>;
     /** Park the customer and call a destination first; then `complete` or `cancel`. */
     consultTransfer?: Lockable<true | DestinationDirectory>;
-    /** Ask a lead to join this call, with a note. The lead's decision arrives on `Task.lead`. */
-    consultLead?: Lockable<true>;
+    /** Ask a lead to join this call, with a note. The lead's decision arrives on `Task.leadAssist`. */
+    leadAssist?: Lockable<true>;
     conference?: Lockable<true | DestinationDirectory>;
     recording?: Lockable<true>;
 } : C extends "chat" ? SharedTaskCapabilities & {
@@ -608,7 +608,7 @@ export type OnCall = {
  * The agent's request for a lead, from asking until the lead leaves or the request ends.
  * `requested` while nobody has joined; `joined`, with `leadId`, once somebody has.
  */
-export interface TaskLead {
+export interface TaskLeadAssist {
     stage: "requested" | "joined";
     leadId?: UserId;
     note?: string;
@@ -616,7 +616,7 @@ export interface TaskLead {
 }
 /**
  * On the lead's own task for a call they joined: which member asked, with their note. Its
- * presence is what makes `lead` `take-over` and `leave` issuable.
+ * presence is what makes `lead-assist` `take-over` and `leave` issuable.
  */
 export interface TaskAssisting {
     memberId: UserId;
@@ -691,12 +691,12 @@ export type Task<C extends Channel = Channel> = {
     handlingHistory?: TaskHandlingHistory;
 } & TaskCompletion & (C extends "voice" ? {
     onCall?: OnCall[];
-    lead?: TaskLead;
+    leadAssist?: TaskLeadAssist;
     assisting?: TaskAssisting;
     media?: TaskMediaState;
 } : {
     onCall?: never;
-    lead?: never;
+    leadAssist?: never;
     assisting?: never;
     media?: never;
 });
@@ -730,7 +730,7 @@ export type TaskOutcome = {
     failure: ProtocolFailure;
 };
 export declare const TASK_COMMAND_NAMES: {
-    readonly voice: readonly ["answer", "decline", "start-call", "mute", "hold", "resume", "disconnect", "callback", "transfer", "lead", "conference", "recording", "complete"];
+    readonly voice: readonly ["answer", "decline", "start-call", "mute", "hold", "resume", "disconnect", "callback", "transfer", "lead-assist", "conference", "recording", "complete"];
     readonly chat: readonly ["accept", "reject", "pause", "resume", "complete"];
     readonly email: readonly ["accept", "reject", "complete"];
 };
@@ -784,25 +784,25 @@ export type VoiceTaskCommand = {
     type: "transfer";
     action: "cancel";
 }
-/** Ask a lead to join, with a note. Gated by `consultLead`. */
+/** Ask a lead to join, with a note. Gated by `leadAssist`. */
  | {
-    type: "lead";
+    type: "lead-assist";
     action: "request";
     note?: string;
 }
-/** Withdraw a standing request. Needs `Task.lead` with status `requested`. */
+/** Withdraw a standing request. Needs `Task.leadAssist` with status `requested`. */
  | {
-    type: "lead";
+    type: "lead-assist";
     action: "cancel";
 }
 /** The lead keeps the customer; the agent's task ends `transferred`. Needs `Task.assisting`. */
  | {
-    type: "lead";
+    type: "lead-assist";
     action: "take-over";
 }
 /** The lead drops; the agent continues. The lead's task ends `left`. Needs `Task.assisting`. */
  | {
-    type: "lead";
+    type: "lead-assist";
     action: "leave";
 }
 /** Dial `destination` into the call. Gated by `conference`. */
@@ -999,7 +999,7 @@ export interface LeadRequest {
  */
 export interface TeamRoster {
     members: TeamMember[];
-    /** Omitted when the login lacks `team.consultControl`; `[]` when nobody is asking. */
+    /** Omitted when the login lacks `team.leadAssistControl`; `[]` when nobody is asking. */
     requests?: LeadRequest[];
     /** The team's policy per capability, as it stands. Present exactly when the login declares `team.policyControl`. */
     policies?: TeamPolicies;
@@ -1021,7 +1021,7 @@ export type TeamPolicyCommand = {
 export interface TeamPolicyCommandRequest {
     command: TeamPolicyCommand;
 }
-export type TeamConsultCommand = {
+export type TeamLeadAssistCommand = {
     type: "join";
     requestId: string;
 } | {
@@ -1029,8 +1029,8 @@ export type TeamConsultCommand = {
     requestId: string;
     reason?: string;
 };
-export interface TeamConsultCommandRequest {
-    command: TeamConsultCommand;
+export interface TeamLeadAssistCommandRequest {
+    command: TeamLeadAssistCommand;
 }
 export type TeamBreakCommand = {
     type: "decide";
@@ -1294,8 +1294,8 @@ export interface Connection<C extends Channel = Channel> {
     endBreak?(): Promise<BreakEndResult>;
     /** Required when the login declares `capabilities.team.breakControl`. */
     executeTeamBreak?(request: TeamBreakCommandRequest): Promise<TeamCommandResult>;
-    /** Required when the login declares `capabilities.team.consultControl`. */
-    executeTeamConsult?(request: TeamConsultCommandRequest): Promise<TeamCommandResult>;
+    /** Required when the login declares `capabilities.team.leadAssistControl`. */
+    executeTeamLeadAssist?(request: TeamLeadAssistCommandRequest): Promise<TeamCommandResult>;
     /** Required when the login declares `capabilities.team.policyControl`. */
     executeTeamPolicy?(request: TeamPolicyCommandRequest): Promise<TeamCommandResult>;
     /** Required of every voice adapter: all voice audio lands in Omni. */

package/dist/index.js

@@ -71,7 +71,7 @@ export function effectiveLevels(declared) {
 // ---------------------------------------------------------------------------
 export const TASK_COMMAND_NAMES = {
     voice: ["answer", "decline", "start-call", "mute", "hold", "resume", "disconnect",
-        "callback", "transfer", "lead", "conference", "recording", "complete"],
+        "callback", "transfer", "lead-assist", "conference", "recording", "complete"],
     chat: ["accept", "reject", "pause", "resume", "complete"],
     email: ["accept", "reject", "complete"],
 };
@@ -170,7 +170,7 @@ export function sameCapabilities(a, b) {
     return a.breaks === b.breaks &&
         (a.team === undefined) === (b.team === undefined) &&
         a.team?.breakControl === b.team?.breakControl &&
-        a.team?.consultControl === b.team?.consultControl;
+        a.team?.leadAssistControl === b.team?.leadAssistControl;
 }
 /**
  * The storage-profile key a reusing browser shares, or `undefined` where it shares nothing.

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.lead", "task.assisting", "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.handlingHistory", "task.onCall", "task.leadAssist", "task.assisting", "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

@@ -13,7 +13,7 @@ const STATE_SUBJECTS = [
     "task.attributes",
     "task.handlingHistory",
     "task.onCall",
-    "task.lead",
+    "task.leadAssist",
     "task.assisting",
     "task.media",
     "task.acceptance",
@@ -56,8 +56,8 @@ function observeTask(value, seen) {
         seen.add("task.handlingHistory");
     if (some(value.onCall))
         seen.add("task.onCall");
-    if (value.lead !== undefined)
-        seen.add("task.lead");
+    if (value.leadAssist !== undefined)
+        seen.add("task.leadAssist");
     if (value.assisting !== undefined)
         seen.add("task.assisting");
     if (value.media !== undefined)
@@ -223,8 +223,8 @@ export async function exerciseAdapter(adapter, context, options = {}) {
             }
             if (capabilities.team?.breakControl === true)
                 requireMethod(on, "executeTeamBreak", "the login declares capabilities.team.breakControl");
-            if (capabilities.team?.consultControl === true)
-                requireMethod(on, "executeTeamConsult", "the login declares capabilities.team.consultControl");
+            if (capabilities.team?.leadAssistControl === true)
+                requireMethod(on, "executeTeamLeadAssist", "the login declares capabilities.team.leadAssistControl");
             if (capabilities.team?.policyControl === true)
                 requireMethod(on, "executeTeamPolicy", "the login declares capabilities.team.policyControl");
             if (some(capabilities.preferences))
@@ -404,7 +404,7 @@ function publishesUserIds(snapshot) {
 }
 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)) ||
-    (isRecord(task.lead) && task.lead.leadId !== undefined) ||
+    (isRecord(task.leadAssist) && task.leadAssist.leadId !== undefined) ||
     isRecord(task.assisting));
 /** Mute is the leg the host performs, so a task that allows it obliges the provider to take the record. */
 const taskDeclaresMute = (task) => isRecord(task) && isRecord(task.capabilities) && task.capabilities.mute !== undefined;
@@ -517,7 +517,7 @@ export function assertCapabilityWithdrawal(states, snapshot, manifest) {
     const withdrawn = (before.breaks === true && after.breaks !== true) ||
         (before.team !== undefined && after.team === undefined) ||
         (before.team?.breakControl === true && after.team?.breakControl !== true) ||
-        (before.team?.consultControl === true && after.team?.consultControl !== true);
+        (before.team?.leadAssistControl === true && after.team?.leadAssistControl !== true);
     if (!withdrawn) {
         throw new Error("Capability withdrawal must end with at least one capability the first login declared withdrawn");
     }
@@ -619,7 +619,7 @@ export class TaskStream {
     tasks = new Map();
     // Every dial the stream can place an outcome against: one the host said it placed, or one a
     // task carried on `onCall` or in its record -- which is how a dial made before a transfer is known
-    // to whoever holds the task now. `ended` once its outcome arrived, since an outcome comes once.
+    // to whoever holds the task now. `answered` or `ended` once its outcome arrived, since it comes once.
     dials = new Map();
     /** The host placed a dial: its outcome, whenever it arrives, is one the stream expects. */
     dialled(dialId) {
@@ -640,7 +640,16 @@ export class TaskStream {
     }
     static stated(task) {
         const media = isRecord(task) && (task.media === "started" || task.media === "ended") ? task.media : "none";
-        return { phase: String(isRecord(task) ? task.phase : undefined), media };
+        // The stage of every dialled entry the room names by its dial, so an update can be held to the
+        // outcome that moves it.
+        const stages = new Map();
+        if (isRecord(task) && Array.isArray(task.onCall)) {
+            for (const entry of task.onCall) {
+                if (isRecord(entry) && typeof entry.dialId === "string" && typeof entry.stage === "string")
+                    stages.set(entry.dialId, entry.stage);
+            }
+        }
+        return { phase: String(isRecord(task) ? task.phase : undefined), media, stages };
     }
     /** Replaces what is known with a snapshot's tasks, as a snapshot replaces Omni's state. */
     seed(snapshot) {
@@ -696,6 +705,14 @@ export class TaskStream {
                     if (known.media !== next.media && !(known.media === "ended" && next.media === "none")) {
                         refuse("stream.taskUpdated.media", `${at}.task.media`, `a task-updated re-states media, it does not move it: ${id} held ${known.media} and the update says ${next.media}; audio arrives on task-media-started and ends on task-media-ended`);
                     }
+                    // The same pairing for a dialled entry: the dial-outcome is the transition, the stage is
+                    // the state, and the outcome comes first. An update that joins an entry on its own is
+                    // moving what only an answered outcome moves.
+                    for (const [dialId, stage] of next.stages) {
+                        if (stage === "joined" && known.stages.get(dialId) === "ringing" && this.dials.get(dialId) !== "answered") {
+                            refuse("stream.taskUpdated.stage", `${at}.task.onCall`, `a task-updated re-states a stage, it does not move it: ${dialId} was ringing and the update says joined before any answered dial-outcome for it`);
+                        }
+                    }
                     this.tasks.set(id, next);
                 }
                 this.noteDials(event.task);
@@ -746,10 +763,10 @@ export class TaskStream {
                 if (dial === undefined) {
                     refuse("stream.dialOutcome.unknown", `${at}.dialId`, `${event.dialId} is not a dial the host placed or a task carried: an outcome ends a dial somebody made`);
                 }
-                else if (dial === "ended") {
+                else if (dial !== "placed") {
                     refuse("stream.dialOutcome.duplicate", `${at}.dialId`, `${event.dialId} already has its outcome; a dial ends once`);
                 }
-                this.dials.set(event.dialId, "ended");
+                this.dials.set(event.dialId, event.outcome === "answered" ? "answered" : "ended");
                 break;
             }
             default:

package/dist/validation.d.ts

@@ -33,7 +33,7 @@ export interface ReaderContext {
     self?: UserId;
     /**
      * The login's `AuthenticationState.capabilities`. The login is the permission: a lead's
-     * snapshot carries a roster, nobody else's does, and `requests` need `team.consultControl`.
+     * snapshot carries a roster, nobody else's does, and `requests` need `team.leadAssistControl`.
      */
     capabilities?: UserCapabilities;
     /** The level ids in force. Filled from the manifest by `validateSnapshot` and `validateEventEnvelope`; the defaults otherwise. */
@@ -59,7 +59,7 @@ export declare function validateHostGuarantees(guarantees: unknown, path?: strin
 export declare function validateHandlingReport(report: unknown, path?: string, manifest?: unknown): ProtocolViolation[];
 export declare function validateHostReport(report: unknown, path?: string): ProtocolViolation[];
 /** The connection methods whose results `validateResult` knows. */
-export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak" | "executeTeamBreak" | "executeTeamConsult" | "openMedia" | "setPreference" | "recordStep" | "executeTeamPolicy";
+export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak" | "executeTeamBreak" | "executeTeamLeadAssist" | "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

@@ -84,7 +84,7 @@ const MEMBER_BREAKS = membersOf({
 const OFFERABLE_PHASES = membersOf({
     pending: true, confirmed: true, preparing: true,
 });
-const TEAM_CAPABILITIES = membersOf({ breakControl: true, consultControl: true, policyControl: true });
+const TEAM_CAPABILITIES = membersOf({ breakControl: true, leadAssistControl: true, policyControl: true });
 const COMPLETED_BY = membersOf({ agent: true, provider: true });
 const EXPIRABLE_PHASES = membersOf({
     pending: true, confirmed: true, preparing: true,
@@ -94,7 +94,7 @@ const ISOLATION_SCHEME_VALUES = Object.values(BROWSER_ISOLATION_SCHEMES);
 const TASK_CAPABILITIES = {
     voice: membersOf({
         browsers: true, dispositions: true, custom: true, decline: true, mute: true, hold: true,
-        agentDisconnect: true, callback: true, blindTransfer: true, consultTransfer: true, consultLead: true, conference: true, recording: true,
+        agentDisconnect: true, callback: true, blindTransfer: true, consultTransfer: true, leadAssist: true, conference: true, recording: true,
     }),
     chat: membersOf({ browsers: true, dispositions: true, custom: true, reject: true, hold: true }),
     email: membersOf({ browsers: true, dispositions: true, custom: true, reject: true }),
@@ -799,26 +799,26 @@ function validateOnCall(value, channel, path, into) {
 }
 const LEAD_STAGES = membersOf({ requested: true, joined: true });
 /** The agent's request for a lead. Voice only; `joined` names the lead, `requested` cannot. */
-function validateLead(value, channel, path, into) {
+function validateLeadAssist(value, channel, path, into) {
     if (value === undefined)
         return;
-    if (!into.require(channel === "voice", "task.lead.channel", path, `a ${channel} task cannot carry a lead request`))
+    if (!into.require(channel === "voice", "task.leadAssist.channel", path, `a ${channel} task cannot carry a lead request`))
         return;
     if (!isPlainObject(value)) {
-        into.add("task.lead.shape", path, "lead must be an object when present");
+        into.add("task.leadAssist.shape", path, "lead must be an object when present");
         return;
     }
-    if (into.oneOf(value.stage, LEAD_STAGES, "task.lead.stage", `${path}.stage`)) {
+    if (into.oneOf(value.stage, LEAD_STAGES, "task.leadAssist.stage", `${path}.stage`)) {
         if (value.stage === "joined") {
-            into.require(isUserId(value.leadId), "task.lead.leadId", `${path}.leadId`, "a joined lead is named by their user id");
+            into.require(isUserId(value.leadId), "task.leadAssist.leadId", `${path}.leadId`, "a joined lead is named by their user id");
         }
         else {
-            into.require(value.leadId === undefined, "task.lead.leadId.unexpected", `${path}.leadId`, "nobody has joined a requested lead, so there is no lead to name");
+            into.require(value.leadId === undefined, "task.leadAssist.leadId.unexpected", `${path}.leadId`, "nobody has joined a requested lead, so there is no lead to name");
         }
     }
     if (value.note !== undefined)
-        into.filled(value.note, "task.lead.note", `${path}.note`, "a note must not be empty when present");
-    into.timestamp(value.since, "task.lead.since", `${path}.since`);
+        into.filled(value.note, "task.leadAssist.note", `${path}.note`, "a note must not be empty when present");
+    into.timestamp(value.since, "task.leadAssist.since", `${path}.since`);
 }
 /** The lead's own task for a call they joined. Voice only. */
 function validateAssisting(value, channel, path, into) {
@@ -886,7 +886,7 @@ function validateTaskInto(task, context, path, into) {
     validateHandlingHistory(task.handlingHistory, `${path}.handlingHistory`, into);
     validateOnCall(task.onCall, context.channel, `${path}.onCall`, into);
     validateTaskMedia(task.media, context.channel, `${path}.media`, into);
-    validateLead(task.lead, context.channel, `${path}.lead`, into);
+    validateLeadAssist(task.leadAssist, context.channel, `${path}.leadAssist`, into);
     validateAssisting(task.assisting, context.channel, `${path}.assisting`, into);
     const capabilities = task.capabilities;
     if (!isPlainObject(capabilities)) {
@@ -1055,15 +1055,15 @@ function validateTeamRosterInto(roster, path, context, into) {
     if (roster.requests === undefined) {
         // `[]` says nobody is asking; omission says the lead may not be asked. A login that may be
         // asked therefore always carries the list.
-        if (context.capabilities?.team?.consultControl === true) {
-            into.add("team.requests.required", `${path}.requests`, "the login declares team.consultControl, so the roster carries requests: [] when nobody is asking");
+        if (context.capabilities?.team?.leadAssistControl === true) {
+            into.add("team.requests.required", `${path}.requests`, "the login declares team.leadAssistControl, so the roster carries requests: [] when nobody is asking");
         }
     }
     else {
         // Requests are what a lead acts on, so a lead who may not act has no business receiving them.
         // Whether they may is on the login, so the check needs the login in hand.
         if (context.capabilities !== undefined) {
-            into.require(context.capabilities.team?.consultControl === true, "team.requests.capability", `${path}.requests`, "requests require team.consultControl on the login: a lead who may not join has nothing to decide");
+            into.require(context.capabilities.team?.leadAssistControl === true, "team.requests.capability", `${path}.requests`, "requests require team.leadAssistControl on the login: a lead who may not join has nothing to decide");
         }
         if (!Array.isArray(roster.requests)) {
             into.add("team.requests.shape", `${path}.requests`, "requests must be an array when present");
@@ -1621,7 +1621,7 @@ const RESULT_STATUSES = {
     cancelBreak: { success: "cancelled", failure: "failed" },
     endBreak: { success: "ended", failure: "failed" },
     executeTeamBreak: { success: "applied", failure: "failed" },
-    executeTeamConsult: { success: "applied", failure: "failed" },
+    executeTeamLeadAssist: { success: "applied", failure: "failed" },
     openMedia: { success: "opened", failure: "unavailable" },
     setPreference: { success: "applied", failure: "failed" },
     recordStep: { success: "recorded", failure: "failed" },

package/guide.md

@@ -231,7 +231,7 @@ type AuthenticationContext = {
 
 type TeamCapabilities = {
   breakControl?: true;
-  consultControl?: true;
+  leadAssistControl?: true;
   policyControl?: true;
 };
 
@@ -479,7 +479,7 @@ type TaskCapabilities<C extends Channel = Channel> =
         callback?: Lockable<true>;
         blindTransfer?: Lockable<true | DestinationDirectory>;
         consultTransfer?: Lockable<true | DestinationDirectory>;
-        consultLead?: Lockable<true>;
+        leadAssist?: Lockable<true>;
         conference?: Lockable<true | DestinationDirectory>;
         recording?: Lockable<true>;
       }
@@ -597,7 +597,7 @@ type OnCall = { since: IsoTimestamp; held?: true } & (
   | { role: "consulted" | "conferenced"; destination: string; stage: OnCallStage; dialId?: DialId; label?: string }
 );
 
-type TaskLead = {
+type TaskLeadAssist = {
   stage: "requested" | "joined";
   leadId?: UserId;
   note?: string;
@@ -641,8 +641,8 @@ type Task<C extends Channel = Channel> = {
   handlingHistory?: TaskHandlingHistory;
 } & TaskCompletion & (
   C extends "voice"
-    ? { onCall?: OnCall[]; lead?: TaskLead; assisting?: TaskAssisting; media?: TaskMediaState }
-    : { onCall?: never; lead?: never; assisting?: never; media?: never }
+    ? { onCall?: OnCall[]; leadAssist?: TaskLeadAssist; assisting?: TaskAssisting; media?: TaskMediaState }
+    : { onCall?: never; leadAssist?: never; assisting?: never; media?: never }
 );
 
 type AcceptanceMode =
@@ -673,7 +673,7 @@ const TASK_COMMAND_NAMES = {
     "disconnect",
     "callback",
     "transfer",
-    "lead",
+    "lead-assist",
     "conference",
     "recording",
     "complete",
@@ -700,10 +700,10 @@ type VoiceTaskCommand =
   | { type: "transfer"; action: "consult"; dialId: DialId; destination: string }
   | { type: "transfer"; action: "complete" }
   | { type: "transfer"; action: "cancel" }
-  | { type: "lead"; action: "request"; note?: string }
-  | { type: "lead"; action: "cancel" }
-  | { type: "lead"; action: "take-over" }
-  | { type: "lead"; action: "leave" }
+  | { type: "lead-assist"; action: "request"; note?: string }
+  | { type: "lead-assist"; action: "cancel" }
+  | { type: "lead-assist"; action: "take-over" }
+  | { type: "lead-assist"; action: "leave" }
   | { type: "conference"; action: "add"; dialId: DialId; destination: string }
   | { type: "conference"; action: "remove"; destination: string }
   | { type: "recording"; action: "start" | "pause" | "resume" | "stop" }
@@ -910,7 +910,7 @@ type TeamPolicyCommandRequest = {
   command: TeamPolicyCommand;
 };
 
-type TeamConsultCommand =
+type TeamLeadAssistCommand =
   | { type: "join"; requestId: string }
   | { type: "decline"; requestId: string; reason?: string };
 
@@ -924,8 +924,8 @@ type TeamBreakCommandRequest = {
   command: TeamBreakCommand;
 };
 
-type TeamConsultCommandRequest = {
-  command: TeamConsultCommand;
+type TeamLeadAssistCommandRequest = {
+  command: TeamLeadAssistCommand;
 };
 
 type TeamCommandResult =
@@ -1021,7 +1021,7 @@ type Connection<C extends Channel = Channel> = {
   endBreak?(): Promise<BreakEndResult>;
 
   executeTeamBreak?(request: TeamBreakCommandRequest): Promise<TeamCommandResult>;
-  executeTeamConsult?(request: TeamConsultCommandRequest): Promise<TeamCommandResult>;
+  executeTeamLeadAssist?(request: TeamLeadAssistCommandRequest): Promise<TeamCommandResult>;
   openMedia?(request: OpenMediaRequest): Promise<OpenMediaResult>;
   setPreference?(request: SetPreferenceRequest): Promise<PreferenceResult>;
   recordStep?(report: HandlingReport): Promise<HandlingReportResult>;
@@ -1731,7 +1731,7 @@ them from what arrives later.
 | `breaks` | This login may request a break. Requires the four break methods on the connection. |
 | `team` | This login leads a team. The provider publishes a `TeamRoster` to it on every snapshot — `[]` 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.consultControl` | This lead may join a member's call on request. Requires `executeTeamConsult`. |
+| `team.leadAssistControl` | This lead may join a member's call on request. Requires `executeTeamLeadAssist`. |
 | `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 roster 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**. |
 
@@ -1927,7 +1927,7 @@ surface in one place, and what obliges an adapter to implement each one.
 | `cancelBreak()` | The login declares `capabilities.breaks`. |
 | `endBreak()` | The login declares `capabilities.breaks`. |
 | `executeTeamBreak(command)` | The login declares `capabilities.team.breakControl`. |
-| `executeTeamConsult(command)` | The login declares `capabilities.team.consultControl`. |
+| `executeTeamLeadAssist(command)` | The login declares `capabilities.team.leadAssistControl`. |
 | `setPreference(request)` | The login declares `capabilities.preferences`: the person's choice has to have somewhere to go. |
 | `recordStep(report)` | A task declares `mute`: the host performs that leg, and the provider's record has to have somewhere to take it. See **The host records what it performs**. |
 | `executeTeamPolicy(command)` | The login declares `capabilities.team.policyControl`. |
@@ -2136,8 +2136,8 @@ time. Runtime conformance checks also require the task channel to match its prov
 | `attributes` | Optional ordered, typed `TaskAttribute` entries with keys unique within the task. Each contact or timestamp is a separate array item; new attribute shapes require new union members. |
 | `handlingHistory` | The call record: `steps` — the ordered handling history of this open task, one entry per occurrence, oldest first — and what they add up to before this agent, `handleSeconds`, `holdSeconds`, `queueSeconds`, `transfers`, each present when the provider knows it. Live task data restated with the task, not a permanent archive. See **How a task has been handled**. |
 | `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, `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 `destination` 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**. |
-| `lead` | 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 **Consulting a lead**. |
-| `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` `take-over` and `leave` issuable. See **Consulting a lead**. |
+| `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**. |
 
 `TaskAttribute` entries carry typed detail alongside the task:
 
@@ -2563,7 +2563,7 @@ const taskCapabilities = {
 | `callback` | Completing-task button: Call back | Omni may have the provider call the task's party back 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 disposes at provider end. See **Calling back during completion**. |
 | `blindTransfer` | Secondary menu item: Blind transfer | Omni may transfer the caller directly to a destination. |
 | `consultTransfer` | Secondary menu item: Consult transfer | Omni may park the customer and call a destination first, then hand the customer over or cancel back. See **Consult transfer**. |
-| `consultLead` | Secondary menu item: Consult lead | Omni may ask a lead to join this call, with a note. The lead's decision reaches the agent on `Task.lead`. See **Consulting a lead**. |
+| `leadAssist` | Secondary menu item: Lead assist | Omni may ask a lead to join this call, with a note. The lead's decision reaches the agent on `Task.leadAssist`. See **Lead assist**. |
 | `conference` | Secondary button: Conference | Omni may dial a destination into the active call, and drop a `conferenced` entry from it -- one still ringing included, which calls the dial off. |
 | `recording` | Overflow menu item: Recording | Omni may expose start, pause, resume, and stop recording controls. |
 | `dispositions` | Primary button: Complete | Omni may request task disposal with a provider disposition and notes. |
@@ -2859,7 +2859,11 @@ still-ringing `destination` calls that dial off, with `cancelled` as its outcome
 **The entry says where it stands.** A dialled entry carries `stage`: `ringing` until its dial is
 answered, `joined` after. The `dial-outcome` is the transition and the stage is the state, the same
 pairing as `task-media-started` and `media`: an `answered` outcome and the task restated with the
-entry `joined` say one thing twice, and any other outcome removes the entry. It is stated rather
+entry `joined` say one thing twice, and any other outcome removes the entry. The outcome comes
+first: a `task-updated` that itself moves an entry from `ringing` to `joined` before an `answered`
+outcome for its dial is refused (`stream.taskUpdated.stage`), as an update that moves `media` is.
+The rule keys on the entry's `dialId`, so an entry the platform added itself, with none, is one
+whose move the stream cannot hold to an outcome: a clean stream proves nothing about ordering there. It is stated rather
 than left to whoever placed the dial because that knowledge lives in one process: after a reload,
 on a second session, or on a supervisor's screen the snapshot is the only source, and a room that
 cannot tell ringing from joined says it contains someone who may never arrive. Nobody ringing is
@@ -3248,7 +3252,7 @@ A lead who also takes calls sees their team on the idle dashboard. `Snapshot.tea
 | Field | Contract |
 | --- | --- |
 | `members` | Every member of this lead's team, whatever their state. `[]` says the lead has a team with nobody in it; omitting the roster says something else entirely — see **The login is the permission** below. |
-| `requests` | The members currently asking this lead to join a call, each with the task and the note. Required when the login declares `team.consultControl`, `[]` when nobody is asking; omitted when it does not. See **Consulting a lead**. |
+| `requests` | The members currently asking this lead to join a call, each with the task and the note. Required when the login declares `team.leadAssistControl`, `[]` when nobody is asking; omitted when it does not. See **Lead assist**. |
 | `policies` | The team's policy per capability as it stands — the setting, who set it, and `lockedBy` where a level above the team made it theirs to keep. Required when the login declares `team.policyControl`; omitted when it does not. See **Who decides what an agent may do**. |
 
 | `TeamMember` field | Contract |
@@ -3282,12 +3286,12 @@ that value does.
 every snapshot, and to nobody else. Omni never decides who leads a team: the provider said so at
 sign-in, and the roster agrees with it — present, `[]` included, for a lead; absent for everybody
 else, which is the correct rendering for an agent who leads nobody. What the lead may do with the
-roster is on the login too, `team.breakControl` and `team.consultControl`, never on the roster.
+roster is on the login too, `team.breakControl` and `team.leadAssistControl`, never on the roster.
 
 **The roster never carries the agent it is published to — not in `members`, and not in
 `requests`.** A lead does not report to themself: their own break request and their own ask for a
 lead go up to whoever leads them and appear on *that* person's roster, while the requester sees
-only their own `BreakState` and their task's `lead` move. An adapter whose platform lists the lead
+only their own `BreakState` and their task's `leadAssist` move. An adapter whose platform lists the lead
 among their own members filters the signed-in identity out before publishing. **Being a lead is a
 role the provider knows, never inferred from who is listed:** it is declared at sign-in, a lead
 with nobody in their team publishes `[]`, an agent with no such role publishes nothing, and no
@@ -3317,37 +3321,37 @@ on their own `BreakState`, or they are stopped from working with no way to see w
 What happens when no lead is online — auto-approving, for instance — is the provider's decision and is
 never expressed here.
 
-### Consulting a lead
+### Lead assist
 
 An agent on a call may ask a lead to join it -- a dispute that needs approval, a customer who
-asks for a manager, a moment the agent wants a second pair of ears. The capability is
-`consultLead` on the task; the lead's side is the roster, which is already the lead's view of the
+asks for a manager, a moment the agent wants a second pair of ears. A call centre calls this
+assistance or escalation, and the name says who assists: the capability is `leadAssist` on the task; the lead's side is the roster, which is already the lead's view of the
 team, and a second lead method beside `executeTeamBreak`:
 
 ```ts
-executeTeamConsult({ command: TeamConsultCommand }): Promise<TeamCommandResult>
+executeTeamLeadAssist({ command: TeamLeadAssistCommand }): Promise<TeamCommandResult>
 ```
 
-Required when the login declares `capabilities.team.consultControl`, and gated by it exactly as
+Required when the login declares `capabilities.team.leadAssistControl`, and gated by it exactly as
 `executeTeamBreak` is by `team.breakControl`. The flow, in order:
 
 ```ts
-// 1. The agent asks, with a small note. Their task carries `lead` from here on.
-execute({ taskId: "call-42", command: { type: "lead", action: "request", note: "Refund dispute, needs approval" } })
-//    task.lead = { status: "requested", note: "Refund dispute, needs approval", since }
+// 1. The agent asks, with a small note. Their task carries `leadAssist` from here on.
+execute({ taskId: "call-42", command: { type: "lead-assist", action: "request", note: "Refund dispute, needs approval" } })
+//    task.leadAssist = { status: "requested", note: "Refund dispute, needs approval", since }
 
 // 2. Every lead entitled to it sees the request on their roster.
 //    team-updated: requests: [{ id: "req-7", memberId: "A-1", taskId: "call-42", note, since }]
 
 // 3. A lead joins, or declines.
-executeTeamConsult({ command: { type: "join", requestId: "req-7" } })
-executeTeamConsult({ command: { type: "decline", requestId: "req-7", reason: "In a call" } })
+executeTeamLeadAssist({ command: { type: "join", requestId: "req-7" } })
+executeTeamLeadAssist({ command: { type: "decline", requestId: "req-7", reason: "In a call" } })
 ```
 
 **On `join` the provider bridges three parties and the lead is on a task of their own**, on the
 same task id, arriving on the lead's connection as `task-offered` with `automatic`
 -- the way a call an agent placed themselves arrives -- and carrying `assisting`. The agent's task
-moves to `lead: { stage: "joined", leadId }`. A join is the lead's own act, so capacity does not
+moves to `leadAssist: { stage: "joined", leadId }`. A join is the lead's own act, so capacity does not
 trigger it; but from then on it is an outstanding task the provider counts against the lead's
 stated ceiling like any other, nothing more is allocated to the lead while it stands, and a
 provider whose lead is already at the ceiling answers the join `failed`.
@@ -3362,8 +3366,8 @@ and a join is work. Omni offers Join to a lead only while their own `BreakState.
 finish is not given more -- and a provider answers a `join` from a lead on such a break `failed`.
 The request stands for another lead, as it does when this one is already on a call.
 
-**On `decline`, or a request the agent withdraws with `{ type: "lead", action: "cancel" }`, the
-provider clears `lead` from the agent's task** and drops the request from every roster. Nothing
+**On `decline`, or a request the agent withdraws with `{ type: "lead-assist", action: "cancel" }`, the
+provider clears `leadAssist` from the agent's task** and drops the request from every roster. Nothing
 else changes; the agent is still on the call.
 
 The lead then has two commands on their copy, gated by `assisting` being present, and a third
@@ -3371,8 +3375,8 @@ choice that is no command at all:
 
 | The lead | The agent's task | The lead's task |
 | --- | --- | --- |
-| `{ type: "lead", action: "take-over" }` | `task-ended` with `{ type: "transferred", destination: leadId }`, straight from `in-progress`: **no `completing` window**, the agent is idle at once | Continues alone, and ends as any call does |
-| `{ type: "lead", action: "leave" }` | Continues; `lead` is cleared | `task-ended` with `{ type: "left" }` -- the call goes on without them |
+| `{ type: "lead-assist", action: "take-over" }` | `task-ended` with `{ type: "transferred", destination: leadId }`, straight from `in-progress`: **no `completing` window**, the agent is idle at once | Continues alone, and ends as any call does |
+| `{ type: "lead-assist", action: "leave" }` | Continues; `leadAssist` is cleared | `task-ended` with `{ type: "left" }` -- the call goes on without them |
 | Stays until the customer hangs up | `task-media-ended`, `completing`, its own disposition | The same, independently: **both have the disposal window** |
 
 `left` is the one outcome that ends a task without ending the call: this agent left a call that
@@ -3380,12 +3384,12 @@ continues without them. It reads as neither a completion nor a cancellation, bec
 neither.
 
 ```ts
-const consultLeadCapable = {
+const leadAssistCapable = {
   channel: "voice",
-  capabilities: { hold: true, consultLead: true, dispositions: true },
+  capabilities: { hold: true, leadAssist: true, dispositions: true },
   phase: "in-progress",
-  lead: { stage: "joined", leadId: "L-9", note: "Refund dispute, needs approval", since: "2026-08-21T09:04:00Z" },
-} satisfies Pick<Task<"voice">, "channel" | "capabilities" | "phase" | "lead">;
+  leadAssist: { stage: "joined", leadId: "L-9", note: "Refund dispute, needs approval", since: "2026-08-21T09:04:00Z" },
+} satisfies Pick<Task<"voice">, "channel" | "capabilities" | "phase" | "leadAssist">;
 ```
 
 Lead and member alike are `UserId`s of this provider, so an adapter publishing them implements
@@ -3610,8 +3614,8 @@ declared:
 | `callback` | The `callback` capability **and** the `completing` phase. It exists to reach the party again after the call, so it has no meaning while the call is up. |
 | `transfer` with `action: "consult"` | The `consultTransfer` capability. Blind `transfer` is gated by `blindTransfer`; the two are declared and offered separately. |
 | `transfer` with `action: "complete"` or `"cancel"` | A consultation in progress -- a `consulted` entry on `Task.onCall`. Without one there is nothing to complete or cancel, and a provider that receives either answers `failed`. |
-| `lead` with `action: "request"` or `"cancel"` | The `consultLead` capability. `cancel` needs a request standing -- `Task.lead` with status `requested`. |
-| `lead` with `action: "take-over"` or `"leave"` | The lead's own task, on a call they joined -- `Task.assisting` present. An agent's task never has it, and a provider that receives either without it answers `failed`. |
+| `lead-assist` with `action: "request"` or `"cancel"` | The `leadAssist` capability. `cancel` needs a request standing -- `Task.leadAssist` with status `requested`. |
+| `lead-assist` with `action: "take-over"` or `"leave"` | The lead's own task, on a call they joined -- `Task.assisting` present. An agent's task never has it, and a provider that receives either without it answers `failed`. |
 | Everything else | Its own named capability. |
 
 Declining or rejecting a pending offer ends it without accepting or completing it. The provider
@@ -3854,7 +3858,7 @@ Every outcome ends the task for this agent. On `task-ended`, Omni:
 - selects another task or returns to the idle workspace.
 
 A `left` outcome ends the task for this agent alone: the call continues without them, as it does
-when a lead who joined it leaves -- see **Consulting a lead**.
+when a lead who joined it leaves -- see **Lead assist**.
 
 A successful `complete` or `transfer` command does not clear the task. Omni waits for `task-ended`.
 The `task-media-ended` event and the `completing` phase are likewise non-terminal. A replacement
@@ -3978,7 +3982,7 @@ Some rules need to know who is reading. `validateTeamRoster`, `validateSnapshot`
 `AuthenticationState.identity.id` and their login's `capabilities`. Given `self`, a roster that
 carries that agent reports `team.member.self` or `team.request.self`. Given `capabilities`, a lead's
 snapshot without a roster reports `team.required`, a roster published to a login that does not lead
-reports `team.unentitled`, `requests` on a roster whose login lacks `team.consultControl` reports
+reports `team.unentitled`, `requests` on a roster whose login lacks `team.leadAssistControl` reports
 `team.requests.capability`, and a roster without them on a login that declares it reports
 `team.requests.required`. Without them those rules are not checked, because they cannot be.
 `exerciseAdapter` always passes both.
@@ -4020,7 +4024,7 @@ latest the session published during the run, which differs only when the adapter
 A capability granted by a later login requires its methods just as one declared at sign-in does.
 
 `result.notExercised` lists what the run never reached — one subject per family of rules: each
-optional part of a task (`task.browsers`, `task.handlingHistory`, `task.lead`, …), the break's
+optional part of a task (`task.browsers`, `task.handlingHistory`, `task.leadAssist`, …), the break's
 `reasons` and `imposed`, the roster's `members` and `requests`, each declared contribution, and
 each event type (`event.task-ended`, …) — and so what a clean `violations` says nothing about.
 Nothing there is a violation: an adapter with no team has nothing to exercise. But a fixture with

package/package.json

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