@xema/omni-protocol 0.1.98 → 0.1.100

package/dist/index.d.ts

@@ -106,7 +106,7 @@ export type DialOutcome = "answered" | "busy" | "no-answer" | "unreachable" | "r
 export declare const DIAL_OUTCOMES: readonly ["answered", "busy", "no-answer", "unreachable", "rejected", "cancelled", "unexplained"];
 /**
  * How the agent hears the call: on a `softphone`, where the host owns the audio and opens it
- * through `openMedia`, or on a `deskPhone`, a handset the platform rings, where the host opens
+ * through `openAudio`, or on a `deskPhone`, a handset the platform rings, where the host opens
  * nothing and only shows the call. A voice manifest lists the phones its platform supports, and
  * the host picks one for the login at authentication.
  */
@@ -232,25 +232,6 @@ export interface AuthenticationFailure {
     /** Names a declared credentials field when the failure belongs to one. */
     field?: string;
 }
-/** What a lead may do with their team. Declared by presence. */
-export interface TeamCapabilities {
-    /**
-     * This lead may act on their team's breaks through `executeTeamBreak` -- force-break, end-forced-break, decide-break-request,
-     * set-break-policy -- as far as the provider supports; a command it lacks answers
-     * `omni.capability-not-enabled`. Requires `executeTeamBreak`.
-     */
-    breakControl?: true;
-    /** This lead may join a member's call on request. Requires `executeTeamLeadAssist`. */
-    leadAssistControl?: true;
-    /**
-     * This lead may listen to a member's call unasked, in these modes and no others. Coach and
-     * join-call begin with silent listening, so the list always includes `listen`. Nothing of it reaches the
-     * member's task. Requires `executeTeamListen`.
-     */
-    listeningControl?: ListeningMode[];
-    /** This lead sets the team's policy per capability -- on, off, or the agent's -- within what the queue allows. Requires `executeTeamPolicy`. */
-    policyControl?: true;
-}
 /**
  * How a lead listening to a member's call is heard: `listen` hears both sides in silence,
  * `coach` is heard by the agent alone, `join-call` by everyone on the call.
@@ -267,8 +248,14 @@ export interface UserCapabilities {
     breaks?: true;
     /** The choices the team left to this person, with where each stands. Omitted when there are none. Requires `setPreference`. */
     preferences?: AgentPreference[];
-    /** This login leads a team: a `TeamMembers` object is published to it on every snapshot, including `members: []`. */
-    team?: TeamCapabilities;
+    /**
+     * This login leads a team. The flag alone turns on the team feature in the agent application:
+     * the lead sees their members with their tasks and stats, and acts on them through `executeTeam`
+     * with the authority the flag carries. No per-action permission rides beside it. While the lead
+     * has the feature on, a `TeamMembers` object is published to them on every snapshot, `members: []`
+     * included; to nobody else, ever.
+     */
+    lead?: true;
 }
 /**
  * Only `authenticated` and `refreshing` know who the agent is and what they may do, and only
@@ -446,7 +433,7 @@ export interface RecordingActions {
 export interface TaskRecordingPolicy {
     provider?: RecordingActions;
     host?: RecordingActions & {
-        destinationId: string;
+        storageId: string;
     };
 }
 /** Current evidence only. Expiry/disconnect means unknown, never a historical stop. */
@@ -491,7 +478,7 @@ export interface HostRecording {
     announcesToCaller?: true;
     actions: RecordingAction[];
     /** Explicitly provisioned destinations. A task chooses one; no upload/storage fallback. */
-    destinationIds: string[];
+    storageIds: string[];
     execute(request: HostRecordingRequest): Promise<RecordingCommandResult>;
 }
 /** Recording applies or fails; it never dials. Rejection without result means unknown. */
@@ -668,6 +655,7 @@ export type TaskCapabilities<C extends Channel = Channel> = C extends "voice" ?
     hold?: Lockable<true>;
     /** The provider ends the caller connection and agent-added channels owned by this interaction, including inherited channels after transfer/takeover. Interaction completion remains separate. */
     endCall?: Lockable<true>;
+    terminateCall?: Lockable<true>;
     /** Connect back to the party while `completing`, whoever placed the call; the task returns to `in-progress`. */
     connectBack?: Lockable<true>;
     coldTransfer?: Lockable<DestinationDirectory>;
@@ -741,9 +729,9 @@ export type TaskPhase =
 /** What the system does when a preview's deadline passes with no Call pressed. */
 export type PreviewDeadline = 
 /** Provider initiates dialing when preparation ends; never a host timer command. */
-"calls"
+"provider-dials"
 /** Host initiates the ordinary call command when preparation ends. */
- | "host-calls"
+ | "host-dials"
 /** Preparation target has elapsed; remain in preview until the agent presses Call. */
  | "waits";
 /** Who ends the task: the agent issuing `complete`, or the provider deciding it is over. */
@@ -875,27 +863,13 @@ export type TaskLeadAssist = {
     leadId: UserId;
 });
 /**
- * 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-call` and `leave` issuable.
+ * On a task that reached this agent by a lead's take-over: which member the call was taken from,
+ * and when. The provider moves the call from one agent to another, and the lead is the new agent,
+ * so the task is an ordinary assignment with the call's history -- offered whatever break the lead
+ * is on, counted against no capacity, provided their voice channel is free.
  */
-export interface TaskAssisting {
+export interface TaskTakenOver {
     memberId: UserId;
-    /** The member's assignment the lead joined: the lead's task has an assignment of its own. */
-    assignmentId: AssignmentId;
-    note?: string;
-    since: IsoTimestamp;
-}
-/**
- * On the lead's own task while they listen to a member's call: whose call, which call, and how the
- * lead is heard, restated on every change of mode. Nothing of it reaches the member's task. There
- * is no take-over here; a lead who wants the call uses lead assist. It is the lead's only task:
- * a lead listens while holding no work of their own, idle or on a break of a kind in
- * `LISTENING_BREAK_KINDS`.
- */
-export interface TaskListening {
-    memberId: UserId;
-    assignmentId: AssignmentId;
-    mode: ListeningMode;
     since: IsoTimestamp;
 }
 /**
@@ -943,12 +917,12 @@ export interface Locked {
  */
 export type Lockable<T> = T | Locked;
 /**
- * Who chose a task's capabilities. `undetermined` is a fault the provider states on the task rather
+ * Who chose a task's capabilities. `not-yet-read` is a fault the provider states on the task rather
  * than hides: the platform's terms could not be read, and the set published is what the provider
  * will honour, not what the platform permits.
  */
-export type CapabilitySource = "queue" | "ungoverned" | "undetermined";
-export declare const CAPABILITY_SOURCES: readonly ["queue", "ungoverned", "undetermined"];
+export type CapabilitySource = "queue" | "nobody" | "not-yet-read";
+export declare const CAPABILITY_SOURCES: readonly ["queue", "nobody", "not-yet-read"];
 export type Task<C extends Channel = Channel> = {
     /** The assignment this task is the record of, and its one identity. See `AssignmentId`. */
     assignmentId: AssignmentId;
@@ -959,8 +933,8 @@ export type Task<C extends Channel = Channel> = {
     capabilities: TaskCapabilities<C>;
     /**
      * Where the capabilities came from before the provider put them on the task, so a host can tell
-     * a fact from a fault: `queue` when somebody chose these terms, `ungoverned` when nothing handed
-     * the work over, `undetermined` when a queue was named and its terms could not be read -- the
+     * a fact from a fault: `queue` when somebody chose these terms, `nobody` when nothing handed
+     * the work over, `not-yet-read` when a queue was named and its terms could not be read -- the
      * provider then publishes what it will honour and says so here, where the controls are drawn.
      */
     capabilitySource: CapabilitySource;
@@ -979,7 +953,7 @@ export type Task<C extends Channel = Channel> = {
     acceptance?: AcceptanceMode;
     /**
      * In `preview` only, and together: the preparation target and behavior when it elapses,
-     * and who acts then -- `calls` makes the provider initiate dialing, `host-calls` makes the
+     * and who acts then -- `provider-dials` makes the provider initiate dialing, `host-dials` makes the
      * host issue Call, and `waits` keeps waiting for the agent without dialing or ending the task.
      * Absent, the agent has as long as they need, without a preparation countdown.
      */
@@ -995,16 +969,14 @@ export type Task<C extends Channel = Channel> = {
     };
     onCall?: OnCall[];
     leadAssist?: TaskLeadAssist;
-    assisting?: TaskAssisting;
-    listening?: TaskListening;
-    media?: TaskMediaState;
+    takenOver?: TaskTakenOver;
+    audio?: TaskAudioState;
 } : {
     recording?: never;
     onCall?: never;
     leadAssist?: never;
-    assisting?: never;
-    listening?: never;
-    media?: never;
+    takenOver?: never;
+    audio?: never;
 });
 /**
  * What the provider wants of Omni's acceptance policy for one offer. On routed work, present only
@@ -1022,7 +994,7 @@ export type TaskOutcome = {
     type: "transferred";
     destinationId?: string;
 }
-/** A lead took the call over: the agent's task ends and the lead's continues. Named by the lead, since a lead is not a directory item. */
+/** A lead took the call over and the agent has wrapped it: the outcome at the agent's own completion. Named by the lead, since a lead is not a directory item. */
  | {
     type: "taken-over";
     leadId: UserId;
@@ -1037,16 +1009,12 @@ export type TaskOutcome = {
  | {
     type: "expired";
     phase: "pending" | "confirmed" | "preview";
-}
-/** This agent left a call that continues without them: a lead who joined and dropped. */
- | {
-    type: "left";
 } | {
     type: "failed";
     failure: ProtocolFailure;
 };
 export declare const TASK_COMMAND_NAMES: {
-    readonly voice: readonly ["answer", "decline", "call", "hold", "resume", "end-call", "connect-back", "transfer", "lead-assist", "conference", "recording", "complete"];
+    readonly voice: readonly ["answer", "decline", "dial", "hold", "resume", "end-call", "terminate-call", "connect-back", "transfer", "lead-assist", "conference", "recording", "complete"];
     readonly chat: readonly ["accept", "decline", "pause", "resume", "complete"];
     readonly email: readonly ["accept", "decline", "complete"];
 };
@@ -1062,17 +1030,21 @@ export type VoiceTaskCommand = {
 }
 /** In `preview`: place the call to the party whose record the agent has read. A dial, gated by the phase alone. */
  | {
-    type: "call";
+    type: "dial";
     dialId: DialId;
 } | {
     type: "hold";
 } | {
     type: "resume";
 }
-/** End the caller connection and all agent-added channels owned or inherited by this interaction. Wrap/completion remain separate. Gated by `endCall`. */
+/** End the agent's channel and every channel the agent added; the caller continues on the provider's path. Gated by `endCall`. */
  | {
     type: "end-call";
 }
+/** End the caller channel. Gated by `terminateCall`. */
+ | {
+    type: "terminate-call";
+}
 /** Issuable only in `completing`, under the `connectBack` capability. Dials the party's own number, so it names none. */
  | {
     type: "connect-back";
@@ -1113,16 +1085,6 @@ export type VoiceTaskCommand = {
     type: "lead-assist";
     action: "cancel";
 }
-/** The lead keeps the customer; the agent's task ends `transferred`. Needs `Task.assisting`. */
- | {
-    type: "lead-assist";
-    action: "take-over-call";
-}
-/** The lead drops; the agent continues. The lead's task ends `left`. Needs `Task.assisting`. */
- | {
-    type: "lead-assist";
-    action: "leave";
-}
 /** Dial the directory item `destinationId` into the call. Gated by `conference`. */
  | {
     type: "conference";
@@ -1230,12 +1192,6 @@ export declare const BREAK_KINDS: readonly ["short-break", "meal", "rest", "trai
  * problem one level up. `other` matches nothing, including another provider's `other`.
  */
 export type BreakKind = (typeof BREAK_KINDS)[number];
-/**
- * The breaks during which a lead may listen to a member's call: work of another sort, not rest.
- * A listening task is the one task a break in effect may hold, and only on one of these.
- */
-export declare const LISTENING_BREAK_KINDS: readonly ["coaching", "administrative", "training"];
-export declare const breakKindAllowsListening: (kind: BreakKind | undefined) => boolean;
 export interface BreakReason {
     id: string;
     label: string;
@@ -1300,8 +1256,8 @@ export type BreakEndResult = {
     status: "failed";
     failure: ProtocolFailure;
 };
-/** `reserved`: signed in here, and the host holds this agent's capacity for another provider (`count: 0`, host-stopped); not receiving this provider's work. */
-export type TeamMemberAvailability = "ready" | "on-task" | "on-break" | "reserved" | "signed-out";
+/** `elsewhere`: signed in here, and the host holds this agent's capacity for another provider (`count: 0`, host-stopped); not receiving this provider's work. */
+export type TeamMemberAvailability = "ready" | "on-task" | "on-break" | "elsewhere" | "signed-out";
 export interface TeamMember {
     id: UserId;
     availability: TeamMemberAvailability;
@@ -1309,24 +1265,65 @@ export interface TeamMember {
     since?: IsoTimestamp;
     /** A request in flight or a grant not yet in effect. `not-requested` is absence, and `on-break` is `availability: "on-break"`. */
     break?: Extract<BreakStatus, "awaiting-approval" | "granted" | "starting-after-task">;
+    /** The member's open tasks, trimmed, kept current by the provider; `[]` when they hold none, omitted only where the provider cannot see them. */
+    tasks?: MemberTask[];
+    /** Present while this lead is on the member's call, listening, coaching or joined; absent otherwise. */
+    listening?: MemberListening;
 }
-/** A member asking this lead to join their call. */
+/** A member asking this lead to join their call, named by the member and the assignment. */
 export interface LeadRequest {
-    id: string;
     memberId: UserId;
     assignmentId: AssignmentId;
     note?: string;
     since: IsoTimestamp;
 }
 /**
- * The login is the permission: published to a login that declares `capabilities.team`, on every
- * snapshot, and to nobody else. What the lead may do with it is on the login too, not here.
+ * A member's task as the lead sees it: the same task the member's desk holds, trimmed by the
+ * provider. The assignment, what the call is and where it stands, the room and the full history
+ * are always here; the workspace -- browsers, controls, completion terms -- is the member's and
+ * travels only if the provider chooses to send it.
+ */
+export type MemberTask<C extends Channel = Channel> = {
+    assignmentId: AssignmentId;
+    title: string;
+    channel: C;
+    taskType: string;
+    phase: TaskPhase;
+    party?: Contact;
+    reference?: string;
+    attributes?: TaskAttribute[];
+    history?: TaskHistory;
+    capabilities?: TaskCapabilities<C>;
+    capabilitySource?: CapabilitySource;
+    browsers?: TaskBrowser[];
+    completionMode?: CompletionMode;
+    wrapAllowance?: DurationSeconds;
+} & (C extends "voice" ? {
+    onCall?: OnCall[];
+    leadAssist?: TaskLeadAssist;
+    takenOver?: TaskTakenOver;
+    audio?: TaskAudioState;
+} : {
+    onCall?: never;
+    leadAssist?: never;
+    takenOver?: never;
+    audio?: never;
+});
+/** The lead on this member's call, in the mode they are heard, since when. */
+export interface MemberListening {
+    mode: ListeningMode;
+    since: IsoTimestamp;
+}
+/**
+ * The lead's view of their team: published to a login that declares `capabilities.lead` while the
+ * lead has the team feature on, on every snapshot, and to nobody else. The provider keeps it
+ * current: when a member holds, mutes or is transferred, the list is republished whole.
  */
 export interface TeamMembers {
     members: TeamMember[];
-    /** 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`. */
+    /** Members asking a lead to join their call; `[]` when nobody is asking. */
+    requests: LeadRequest[];
+    /** The team's policy per capability, as it stands. Present where the provider offers policy control; absent where it does not. */
     policies?: TeamPolicies;
 }
 /** A capability a team policy can name: any task control, new call, or a skill by its provider id. */
@@ -1339,42 +1336,57 @@ export interface TeamPolicy extends Resolved {
 }
 export type TeamPolicies = Partial<Record<PolicyKey, TeamPolicy>>;
 export type TeamPolicyCommand = {
-    type: "set";
+    type: "set-policy";
     capability: PolicyKey;
     setting: TeamPolicySetting;
 };
-export interface TeamPolicyCommandRequest {
-    command: TeamPolicyCommand;
-}
-export type TeamLeadAssistCommand = {
+/**
+ * The team feature on or off. The lead flag enables it; the lead switches it on the fly, and the
+ * provider needs to know: while it is on, team events scoped to the lead's team arrive and the
+ * lead may act; while it is off, the lead is an ordinary agent and nothing of the team reaches them.
+ */
+export type TeamFeatureCommand = {
+    type: "lead-features";
+    enabled: boolean;
+};
+/**
+ * The lead's acts on a member's call, each naming the member and, where the lead has it, the
+ * member's assignment; the provider resolves the member's current assignment from the member alone.
+ * `join` answers a member's request and `decline` refuses it; `listen` starts unasked, silent,
+ * `coach` is heard by the member alone and `join-call` by everyone; `leave` takes the lead's channel
+ * off the call however it got there; `take-over-call` moves the call to the lead as its new agent,
+ * from a joined call or a listened one alike. One member's call at a time.
+ */
+export type TeamCallCommand = {
     type: "join";
-    requestId: string;
+    memberId: UserId;
+    assignmentId?: AssignmentId;
 } | {
     type: "decline";
-    requestId: string;
+    memberId: UserId;
+    assignmentId?: AssignmentId;
     reason?: string;
-};
-export interface TeamLeadAssistCommandRequest {
-    command: TeamLeadAssistCommand;
-}
-/**
- * A lead listening to a member's call. `listen` starts one, silent, on a member from the team member list;
- * `coach` and `join-call` change how the standing one is heard; `leave` ends it. One member at a
- * time, and only the modes the login's `listeningControl` lists.
- */
-export type TeamListenCommand = {
+} | {
     type: "listen";
     memberId: UserId;
+    assignmentId?: AssignmentId;
 } | {
     type: "coach";
+    memberId: UserId;
+    assignmentId?: AssignmentId;
 } | {
     type: "join-call";
+    memberId: UserId;
+    assignmentId?: AssignmentId;
 } | {
     type: "leave";
+    memberId: UserId;
+    assignmentId?: AssignmentId;
+} | {
+    type: "take-over-call";
+    memberId: UserId;
+    assignmentId?: AssignmentId;
 };
-export interface TeamListenCommandRequest {
-    command: TeamListenCommand;
-}
 export type TeamBreakCommand = {
     type: "decide-break-request";
     memberId: UserId;
@@ -1397,34 +1409,36 @@ export type TeamBreakCommand = {
     type: "end-forced-break";
     memberId: UserId;
 };
+/** Every lead act, as `execute` takes a `TaskCommand`: discriminated by `type`. */
+export type TeamCommand = TeamFeatureCommand | TeamBreakCommand | TeamCallCommand | TeamPolicyCommand;
+export interface TeamCommandRequest {
+    command: TeamCommand;
+}
 export type TeamCommandResult = {
     status: "applied";
 } | {
     status: "failed";
     failure: ProtocolFailure;
 };
-export interface TeamBreakCommandRequest {
-    command: TeamBreakCommand;
-}
 /**
  * The task's real-time audio as the provider holds it: `started` while audio should be attached,
  * `ended` once primary interaction's audio ended, and the field omitted while none should be. The
  * provider's word -- a desk attaches and renders audio from it, never from its own senses.
  */
-export type TaskMediaState = "started" | "ended";
-export interface VoiceMediaSession {
+export type TaskAudioState = "started" | "ended";
+export interface CallAudio {
     remoteAudio: MediaStream;
     setMuted(muted: boolean): void;
     close(): void;
 }
-export interface OpenMediaRequest {
+export interface OpenAudioRequest {
     assignmentId: AssignmentId;
     /** The agent's microphone as Omni captured it, `HostReport.audio.input.localAudio`; absent while that input is `unavailable`. */
     localAudio?: MediaStream;
 }
-export type OpenMediaResult = {
+export type OpenAudioResult = {
     status: "opened";
-    session: VoiceMediaSession;
+    audio: CallAudio;
 } | {
     status: "unavailable";
     failure: ProtocolFailure;
@@ -1516,7 +1530,7 @@ export interface Snapshot<C extends Channel = Channel> {
     /** The provider's own count of those tasks, stated rather than inferred: it must equal `tasks.length`, so a blank or unanswered state can never pass as a confirmed empty. */
     taskCount: number;
     contacts?: Contact[];
-    scheduledActivities?: ScheduledActivity[];
+    calendar?: ScheduledActivity[];
     team?: TeamMembers;
 }
 /**
@@ -1526,7 +1540,7 @@ export interface Snapshot<C extends Channel = Channel> {
  * tasks against it and needs no new signal when one ends. The agent is one person on several
  * providers, and the host divides their capacity among them: `0` is host-stopped -- the agent's
  * capacity is elsewhere for now, this provider assigns nothing and shows the member as
- * `reserved` -- and is not a break, which is the agent not working at all. The host restates a
+ * `elsewhere` -- and is not a break, which is the agent not working at all. The host restates a
  * count of one or more when this provider has the agent's capacity again.
  */
 export interface AgentCapacity {
@@ -1569,10 +1583,24 @@ export type ProviderEvent<C extends Channel = Channel> = {
     type: "task-updated";
     task: Task<C>;
 } | {
-    type: "task-media-started";
+    type: "task-audio-started";
     assignmentId: AssignmentId;
 } | {
-    type: "task-media-ended";
+    type: "task-audio-ended";
+    assignmentId: AssignmentId;
+}
+/**
+ * The lead's channel is in a member's call -- listening, coaching or joined -- and its audio should
+ * attach: on a softphone the application opens audio on the member's assignment as it does for a
+ * task. Voice, to a login that declares `lead`, never to the member.
+ */
+ | {
+    type: "team-audio-started";
+    memberId: UserId;
+    assignmentId: AssignmentId;
+} | {
+    type: "team-audio-ended";
+    memberId: UserId;
     assignmentId: AssignmentId;
 } | {
     type: "task-ended";
@@ -1615,7 +1643,7 @@ export type ProviderEvent<C extends Channel = Channel> = {
     contacts: Contact[];
 } | {
     type: "calendar-updated";
-    scheduledActivities: ScheduledActivity[];
+    calendar: ScheduledActivity[];
 };
 /**
  * The `Provider` prefix survives here for a mechanical reason rather than a naming one: `Event`
@@ -1687,16 +1715,10 @@ export interface Connection<C extends Channel = Channel> {
     commitBreak?(): Promise<BreakCommitResult>;
     cancelBreak?(): Promise<BreakCancelResult>;
     endBreak?(): Promise<BreakEndResult>;
-    /** Required when the login declares `capabilities.team.breakControl`. */
-    executeTeamBreak?(request: TeamBreakCommandRequest): Promise<TeamCommandResult>;
-    /** Required when the login declares `capabilities.team.leadAssistControl`. */
-    executeTeamLeadAssist?(request: TeamLeadAssistCommandRequest): Promise<TeamCommandResult>;
-    /** Required when the login declares `capabilities.team.listeningControl`. */
-    executeTeamListen?(request: TeamListenCommandRequest): Promise<TeamCommandResult>;
-    /** Required when the login declares `capabilities.team.policyControl`. */
-    executeTeamPolicy?(request: TeamPolicyCommandRequest): Promise<TeamCommandResult>;
+    /** Required when the login declares `capabilities.lead`: every lead act, on the team surface and nowhere else. */
+    executeTeam?(request: TeamCommandRequest): Promise<TeamCommandResult>;
     /** Required of a voice adapter whose manifest lists `softphone`: on one, the call's audio lands in Omni. */
-    openMedia?(request: OpenMediaRequest): Promise<OpenMediaResult>;
+    openAudio?(request: OpenAudioRequest): Promise<OpenAudioResult>;
     /** Required when the login declares `capabilities.preferences`: the person's own choice, kept by the provider and republished as `authenticated`. */
     setPreference?(request: SetPreferenceRequest): Promise<PreferenceResult>;
     /** Records an interaction leg the host performed. Required of a softphone login's connection: the host mutes its microphone on any call, and the record is the provider's. */
@@ -1791,7 +1813,7 @@ export interface BrowserSessionKeyInput {
  * Whether two logins declare the same capabilities, field by field. The comparison an adapter
  * makes before republishing `authenticated`: capabilities are current, not fixed, and the natural
  * guard -- comparing the identity -- never fires on a demotion, because the thing that changed is
- * not the thing being compared. Key order does not matter, and `team: {}` is not `team` absent.
+ * not the thing being compared. Key order does not matter, and a withdrawn `lead` is a change.
  */
 export declare function sameCapabilities(a: UserCapabilities, b: UserCapabilities): boolean;
 /**

package/dist/index.js

@@ -71,19 +71,19 @@ export const DEFAULT_LEVELS = [
 export function effectiveLevels(declared) {
     return [...(declared ?? DEFAULT_LEVELS)];
 }
-export const CAPABILITY_SOURCES = ["queue", "ungoverned", "undetermined"];
+export const CAPABILITY_SOURCES = ["queue", "nobody", "not-yet-read"];
 // ---------------------------------------------------------------------------
 // Task commands.
 // ---------------------------------------------------------------------------
 export const TASK_COMMAND_NAMES = {
-    voice: ["answer", "decline", "call", "hold", "resume", "end-call",
+    voice: ["answer", "decline", "dial", "hold", "resume", "end-call", "terminate-call",
         "connect-back", "transfer", "lead-assist", "conference", "recording", "complete"],
     chat: ["accept", "decline", "pause", "resume", "complete"],
     email: ["accept", "decline", "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 === "connect-back" || command.type === "call")
+    if (command.type === "connect-back" || command.type === "dial")
         return command.dialId;
     if (command.type === "transfer" && (command.action === "cold" || command.action === "warm"))
         return command.dialId;
@@ -95,12 +95,6 @@ export const BREAK_KINDS = [
     "short-break", "meal", "rest", "training", "coaching",
     "meeting", "administrative", "technical", "personal", "other",
 ];
-/**
- * The breaks during which a lead may listen to a member's call: work of another sort, not rest.
- * A listening task is the one task a break in effect may hold, and only on one of these.
- */
-export const LISTENING_BREAK_KINDS = ["coaching", "administrative", "training"];
-export const breakKindAllowsListening = (kind) => kind !== undefined && LISTENING_BREAK_KINDS.includes(kind);
 export const OMNI_FAILURE_CODES = [
     "omni.not-authenticated",
     "omni.capability-not-enabled",
@@ -177,19 +171,15 @@ export function historyStepExpectsAPerson(step) {
  * Whether two logins declare the same capabilities, field by field. The comparison an adapter
  * makes before republishing `authenticated`: capabilities are current, not fixed, and the natural
  * guard -- comparing the identity -- never fires on a demotion, because the thing that changed is
- * not the thing being compared. Key order does not matter, and `team: {}` is not `team` absent.
+ * not the thing being compared. Key order does not matter, and a withdrawn `lead` is a change.
  */
 export function sameCapabilities(a, b) {
-    const modes = (team) => team?.listeningControl === undefined ? undefined : [...team.listeningControl].sort().join(",");
     // Every field, so a capability added later cannot be missed here: `satisfies` pins the field
-    // lists to the types, and a new key is a compile error until it is compared.
-    const teamKeys = { breakControl: true, leadAssistControl: true, listeningControl: true, policyControl: true };
-    void { breaks: true, preferences: true, team: true };
+    // list to the type, and a new key is a compile error until it is compared.
+    void { breaks: true, preferences: true, lead: true };
     const preferences = (list) => list === undefined ? undefined : list.map(p => [p.id, p.label, p.enabled, p.setBy, p.lockedBy ?? "", p.reason ?? ""].join("\u0000")).sort().join("\u0001");
     return a.breaks === b.breaks &&
-        (a.team === undefined) === (b.team === undefined) &&
-        Object.keys(teamKeys).every(key => key === "listeningControl" || a.team?.[key] === b.team?.[key]) &&
-        modes(a.team) === modes(b.team) &&
+        a.lead === b.lead &&
         preferences(a.preferences) === preferences(b.preferences);
 }
 /**