@xema/omni-protocol 0.1.37 → 0.1.39

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;
 }
@@ -437,13 +437,13 @@ export type TaskCapabilities<C extends Channel = Channel> = C extends "voice" ?
     mute?: Lockable<true>;
     hold?: Lockable<true>;
     agentDisconnect?: Lockable<true>;
-    /** Reach the party again while `completing`; the task returns to `in-progress`. */
-    callback?: Lockable<true>;
+    /** Connect back to the party while `completing`, whoever placed the call; the task returns to `in-progress`. */
+    connectBack?: Lockable<true>;
     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", "connect-back", "transfer", "lead-assist", "conference", "recording", "complete"];
     readonly chat: readonly ["accept", "reject", "pause", "resume", "complete"];
     readonly email: readonly ["accept", "reject", "complete"];
 };
@@ -755,9 +755,9 @@ export type VoiceTaskCommand = {
 } | {
     type: "disconnect";
 }
-/** Issuable only in `completing`, under the `callback` capability. Dials the party's own number, so it names none. */
+/** Issuable only in `completing`, under the `connectBack` capability. Dials the party's own number, so it names none. */
  | {
-    type: "callback";
+    type: "connect-back";
     dialId: DialId;
 }
 /** Blind: hand the customer to `destination` with nobody consulted. Gated by `blindTransfer`. */
@@ -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";
@@ -1084,8 +1084,8 @@ export type OpenMediaResult = {
 /**
  * What the team may leave to the person: a capability by its own name -- `hold`, `mute` -- or a
  * skill by its provider id. The same key as in `Task.capabilities`, because it is the same
- * capability seen at another level. Callback and new call are never the person's; they are the
- * team's, on or off, within what the queue allows.
+ * capability seen at another level. Connecting back and a new call are never the person's; they
+ * are the team's, on or off, within what the queue allows.
  */
 export type PreferenceId = "hold" | "mute" | `skill:${string}`;
 /**
@@ -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,13 +71,13 @@ export function effectiveLevels(declared) {
 // ---------------------------------------------------------------------------
 export const TASK_COMMAND_NAMES = {
     voice: ["answer", "decline", "start-call", "mute", "hold", "resume", "disconnect",
-        "callback", "transfer", "lead", "conference", "recording", "complete"],
+        "connect-back", "transfer", "lead-assist", "conference", "recording", "complete"],
     chat: ["accept", "reject", "pause", "resume", "complete"],
     email: ["accept", "reject", "complete"],
 };
 /** The dial a command places, by the host's identity for it; `undefined` for a command that dials nothing. */
 export function commandDialId(command) {
-    if (command.type === "callback")
+    if (command.type === "connect-back")
         return command.dialId;
     if (command.type === "transfer" && (command.action === undefined || command.action === "consult"))
         return command.dialId;
@@ -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");
     }

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

@@ -73,7 +73,7 @@ const EXPLAINED_FAILURES = ["busy", "no-answer", "unreachable", "rejected", "can
 const ON_CALL_ROLES = membersOf({ party: true, agent: true, consulted: true, conferenced: true });
 const ON_CALL_STAGES = membersOf({ ringing: true, joined: true });
 /** The task capabilities under which a command dials, and so need the manifest to say how a dial ends. */
-const DIALLING_CAPABILITIES = ["callback", "blindTransfer", "consultTransfer", "conference"];
+const DIALLING_CAPABILITIES = ["connectBack", "blindTransfer", "consultTransfer", "conference"];
 const SNAPSHOT_REASONS = membersOf({
     reconnected: true, "provider-requested": true,
 });
@@ -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, connectBack: 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

@@ -35,7 +35,7 @@ are used precisely throughout and mean nothing looser here.
 | **Event** | One completed transaction reported after a snapshot established the baseline. |
 | **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, roster. |
-| **Dial** | One outbound call the host asks a provider to place — from the idle dialpad, a transfer, a conference add, or a callback. Identified by the host's `dialId`, accepted as `dialling`, and ended by exactly one `dial-outcome`. See **Every dial has an outcome**. |
+| **Dial** | One outbound call the host asks a provider to place — from the idle dialpad, a 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**. |
 | **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
@@ -231,7 +231,7 @@ type AuthenticationContext = {
 
 type TeamCapabilities = {
   breakControl?: true;
-  consultControl?: true;
+  leadAssistControl?: true;
   policyControl?: true;
 };
 
@@ -476,10 +476,10 @@ type TaskCapabilities<C extends Channel = Channel> =
         mute?: Lockable<true>;
         hold?: Lockable<true>;
         agentDisconnect?: Lockable<true>;
-        callback?: Lockable<true>;
+        connectBack?: 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 =
@@ -671,9 +671,9 @@ const TASK_COMMAND_NAMES = {
     "hold",
     "resume",
     "disconnect",
-    "callback",
+    "connect-back",
     "transfer",
-    "lead",
+    "lead-assist",
     "conference",
     "recording",
     "complete",
@@ -695,15 +695,15 @@ type VoiceTaskCommand =
   | { type: "hold" }
   | { type: "resume" }
   | { type: "disconnect" }
-  | { type: "callback"; dialId: DialId }
+  | { type: "connect-back"; dialId: DialId }
   | { type: "transfer"; dialId: DialId; destination: string; action?: never }
   | { 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" }
@@ -741,7 +741,7 @@ type TaskCommandResult =
 ### Who decides what an agent may do
 
 An agent desk has two managers, not one. **The queue** — a process, a work type — is owned by a
-process manager and **allows** a set of capabilities: hold, mute, callback, new call, conference,
+process manager and **allows** a set of capabilities: hold, mute, connect back, new call, conference,
 whether the number is visible, the actions it offers, the skills it needs. **The people** are
 managed through the organisation's structure — a team, a location, the organisation itself, in
 whatever combination the structure defines for a person — and **decide** per capability within
@@ -788,7 +788,7 @@ controls — is content, and is never locked.
 **A lead sets the team's policy from their roster.** A login that declares
 `capabilities.team.policyControl` may `executeTeamPolicy({ type: "set", capability, setting })`
 with `on`, `off`, or `person`, for any task control, `dial`, or a skill — and only `hold`, `mute`
-and skills may be `person`; callback and new call are the team's, on or off, within what the queue
+and skills may be `person`; connect back and new call are the team's, on or off, within what the queue
 allows. The roster carries `policies` for such a login: every policy as it stands, who set it, and
 `lockedBy` where a level above the team made it theirs to keep, which the lead sees and cannot
 change — `executeTeamPolicy` on it answers `failed` with `omni.capability-not-enabled`.
@@ -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:
 
@@ -2177,7 +2177,7 @@ The canonical task transitions are:
 | `paused` | Provider or agent resumes the task | `in-progress` |
 | `paused` | Agent cancels a consultation (`transfer` `cancel`) | `in-progress` |
 | `in-progress` or `paused` | Contact handling ends and follow-up work remains | `completing` |
-| `completing` | Agent calls the party back (`callback`) | `in-progress` |
+| `completing` | Agent connects back to the party (`connect-back`) | `in-progress` |
 | Any phase | Provider emits `task-ended` | Removed |
 
 Allocation, acceptance, and progress are distinct. Acceptance follows `autoAcceptTasks` and the
@@ -2188,7 +2188,7 @@ command.
 **A task is never its audio.** A voice task is the allocation: the call is offered when it is
 routed to the agent and accepted as its `acceptance` dictates, and its presence and phase follow
 the provider's reports about the work — never the audio. Wherever audio moves — an offer, a hold, a
-consult, a conference leg joining or leaving, a transfer, a callback — the media follows
+consult, a conference leg joining or leaving, a transfer, a connect-back — the media follows
 separately, arriving on `task-media-started`, attaching through `openMedia` and ending with
 `task-media-ended`. Omni does not ring,
 bridge, or hold a line. How the phone rings, whether it rings at all, and where legs join and leave
@@ -2197,7 +2197,7 @@ phase it is in.
 
 The line runs between the provider's word and Omni's own senses. `task-media-ended` is the
 provider's report that primary handling ended — a fact about the work, which is why the completion
-allowance starts on it and the callback control appears on it — and Omni follows that report as it
+allowance starts on it and the Connect back control appears on it — and Omni follows that report as it
 follows any other. What Omni never does is derive a task's state from its own media session: a
 stream that drops, a track that ends, a transport that disconnects, a microphone that fails, an
 endpoint re-registering change nothing about the task until the provider says so. Structurally:
@@ -2253,39 +2253,44 @@ and the agent takes as long as the work needs. Moving the task to `completing` l
 deadline is not an alternative on a media channel: the clock starts at a real event, and delaying
 that event would falsify the phase and everything timed from it.
 
-#### Calling back during completion
+#### Connecting back during completion
 
-A task that declares `callback` lets the agent reach the party again while the task is
-`completing` -- to finish what the call left unfinished, on the same task rather than a new one.
-Omni issues `{ type: "callback" }`; it is issuable only in `completing`, and only where the
-capability is declared. The provider knows who the party is; the command carries no destination.
+A task that declares `connectBack` lets the agent connect back to the party while the task is
+`completing` -- to finish what the call left unfinished, on the same task rather than a new one,
+whoever placed the call in the first place. Most such calls came in, so this is not a redial: the
+agent rings a party who rang them. Omni issues `{ type: "connect-back", dialId }`; it is issuable
+only in `completing`, and only where the capability is declared. The provider knows who the party
+is; the command carries no destination, and it is a dial like any other, so it carries the host's
+`dialId`, is answered `dialling`, and ends in one `dial-outcome`.
 
-On `applied` the provider is placing the call and the task returns to `in-progress`: the agent is
+On `dialling` the provider is placing the call and the task returns to `in-progress`: the agent is
 working again, and the wrap allowance is **discarded, not paused**. From there the call is
 reported as any call is -- `paused`, `in-progress`, and when its media ends, `task-media-ended`
-again, which starts a fresh allowance from that instant. A party who does not answer is a call
-whose media ended: the task returns to `completing` through the same event and the clock starts
-again from there. At no point is an agent dialling against a deadline.
+again, which starts a fresh allowance from that instant. A party who does not answer is a dial
+whose outcome says so and a call whose media ended: the task returns to `completing` through the
+same event and the clock starts again from there. At no point is an agent dialling against a
+deadline.
 
 **The control exists only while there is a window to use it in.** Under `agent-command` the task
 stays `completing` until the agent completes it, so the window is open for as long as they need.
 Under `provider-automatic` the window is the allowance -- and with `wrapAllowance: 0` there
-is none: the provider disposes the task at provider end, and Omni does not offer Call back, whatever
-the task declares. A capability names a control that can be used; on a task with no `completing`
+is none: the provider disposes the task at provider end, and Omni does not offer Connect back,
+whatever the task declares. A capability names a control that can be used; on a task with no `completing`
 window it cannot, and declaring it there changes nothing.
 
 ```ts
-const callbackCapable = {
+const connectBackCapable = {
   channel: "voice",
-  capabilities: { hold: true, callback: true, dispositions: true },
+  capabilities: { hold: true, connectBack: true, dispositions: true },
   phase: "completing",
   completionMode: "provider-automatic",
   wrapAllowance: 30,
 } satisfies Pick<Task<"voice">, "channel" | "capabilities" | "phase" | "completionMode" | "wrapAllowance">;
 ```
 
-With ten seconds of the thirty left, the agent presses Call back: `execute({ command: { type:
-"callback" } })` returns `applied`, the task is `in-progress`, and the thirty seconds are gone.
+With ten seconds of the thirty left, the agent presses Connect back: `execute({ command: { type:
+"connect-back", dialId } })` returns `dialling`, the task is `in-progress`, and the thirty seconds
+are gone.
 The second call ends: `task-media-ended`, the task is `completing`, and a new thirty seconds runs
 from that instant.
 
@@ -2560,10 +2565,10 @@ const taskCapabilities = {
 | `mute` | Primary toggle: Mute | Omni may mute and unmute the agent's outbound audio. |
 | `hold` | Primary toggle: Hold | Omni may issue voice-task `hold` and `resume` commands. |
 | `agentDisconnect` | Primary button: Disconnect | Omni may disconnect real-time media without disposing the task. |
-| `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**. |
+| `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 disposes at provider end. See **Connecting 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. |
@@ -2746,7 +2751,7 @@ inside Omni.
 ## Every dial has an outcome
 
 Four commands place a call: `dial` from the idle dialpad, a blind or consult `transfer`, a
-`conference` `add`, and `callback`. Each is accepted or refused at once, and each then ends later
+`conference` `add`, and `connect-back`. Each is accepted or refused at once, and each then ends later
 and apart from its answer -- the destination picks up, is busy, or never does -- and a dial placed
 late in a call routinely outlives the call. Nothing in between is reported: the wire says
 `dialling`, then says how it ended, once.
@@ -2806,7 +2811,7 @@ call it belonged to and never against the next one.
 The stream knows a dial from three places: `TaskStream.dialled(dialId)`, which a host calls when it
 places one; an entry on a task's `onCall`; and a step in its `handlingHistory`. Since a dialled entry
 is listed from placement, `dialled()` is load-bearing only for a dial that never has an entry -- a
-blind transfer, a callback, an idle dialpad call -- or whose entry has already left the room; an
+blind transfer, a connect-back, an idle dialpad call -- or whose entry has already left the room; an
 outcome for a dial nobody placed and no task mentions is what `stream.dialOutcome.unknown` refuses.
 
 **`answered` says what happened to the dial; `onCall` says who is in the room.** They are two
@@ -2824,7 +2829,7 @@ provider does report -- `busy`, `no-answer`, `unreachable`, `rejected` or `cance
 (`manifest.dialOutcomes.unexplained.alone`): a provider that reports causes may honestly say the
 switch gave none, while one that reports none would be sending the generic failure this set exists
 to refuse. A provider that dials at all declares it: an idle
-dialpad requires it (`manifest.dialOutcomes.required`), and a task that declares `callback`,
+dialpad requires it (`manifest.dialOutcomes.required`), and a task that declares `connectBack`,
 `blindTransfer`, `consultTransfer` or `conference` under a manifest without it is refused
 (`task.capability.dialOutcomes.required`). Off voice nothing dials, and the field is a compile
 error there.
@@ -2861,7 +2866,9 @@ answered, `joined` after. The `dial-outcome` is the transition and the stage is
 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. 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. It is stated rather
+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
@@ -3250,7 +3257,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 |
@@ -3284,12 +3291,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
@@ -3319,37 +3326,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`.
@@ -3364,8 +3371,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
@@ -3373,8 +3380,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
@@ -3382,12 +3389,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
@@ -3609,11 +3616,11 @@ declared:
 | `decline`, `reject` | The channel's decline or reject capability, **and** Omni provisioning permitting rejection. |
 | `start-call` | The `preparing` phase. It starts the contact a preview gave the agent time to read, so the phase is the gate and there is no capability. |
 | `complete` | `completionMode: "agent-command"`. The `dispositions` capability decides whether a code travels with the command, never whether the command exists — a task Omni cannot complete never ends. |
-| `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. |
+| `connect-back` | The `connectBack` 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
@@ -3856,7 +3863,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
@@ -3980,7 +3987,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.
@@ -4022,7 +4029,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.37",
+  "version": "0.1.39",
   "description": "The Omni protocol: the contract every provider adapter implements",
   "type": "module",
   "license": "MIT",