@xema/omni-protocol 0.1.98 → 0.1.99

package/dist/index.d.ts

@@ -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
@@ -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>;
@@ -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.
- */
-export interface TaskAssisting {
-    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`.
+ * 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 TaskListening {
+export interface TaskTakenOver {
     memberId: UserId;
-    assignmentId: AssignmentId;
-    mode: ListeningMode;
     since: IsoTimestamp;
 }
 /**
@@ -995,15 +969,13 @@ export type Task<C extends Channel = Channel> = {
     };
     onCall?: OnCall[];
     leadAssist?: TaskLeadAssist;
-    assisting?: TaskAssisting;
-    listening?: TaskListening;
+    takenOver?: TaskTakenOver;
     media?: TaskMediaState;
 } : {
     recording?: never;
     onCall?: never;
     leadAssist?: never;
-    assisting?: never;
-    listening?: never;
+    takenOver?: never;
     media?: never;
 });
 /**
@@ -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", "call", "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"];
 };
@@ -1069,10 +1037,14 @@ export type VoiceTaskCommand = {
 } | {
     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;
@@ -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;
+    media?: TaskMediaState;
+} : {
+    onCall?: never;
+    leadAssist?: never;
+    takenOver?: never;
+    media?: 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,15 +1409,17 @@ 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
@@ -1574,6 +1588,20 @@ export type ProviderEvent<C extends Channel = Channel> = {
 } | {
     type: "task-media-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 media on the member's assignment as it does for a
+ * task. Voice, to a login that declares `lead`, never to the member.
+ */
+ | {
+    type: "team-media-started";
+    memberId: UserId;
+    assignmentId: AssignmentId;
+} | {
+    type: "team-media-ended";
+    memberId: UserId;
+    assignmentId: AssignmentId;
 } | {
     type: "task-ended";
     assignmentId: AssignmentId;
@@ -1687,14 +1715,8 @@ 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>;
     /** Required when the login declares `capabilities.preferences`: the person's own choice, kept by the provider and republished as `authenticated`. */
@@ -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

@@ -76,7 +76,7 @@ export const CAPABILITY_SOURCES = ["queue", "ungoverned", "undetermined"];
 // Task commands.
 // ---------------------------------------------------------------------------
 export const TASK_COMMAND_NAMES = {
-    voice: ["answer", "decline", "call", "hold", "resume", "end-call",
+    voice: ["answer", "decline", "call", "hold", "resume", "end-call", "terminate-call",
         "connect-back", "transfer", "lead-assist", "conference", "recording", "complete"],
     chat: ["accept", "decline", "pause", "resume", "complete"],
     email: ["accept", "decline", "complete"],
@@ -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);
 }
 /**

package/dist/testing.d.ts

@@ -7,7 +7,7 @@ export { ProtocolConformanceError, assertNoViolations, type ProtocolViolation }
  * rules -- each optional part of a task, each optional part of the break state and team member list, each
  * declared contribution, and each event type.
  */
-declare const STATE_SUBJECTS: readonly ["tasks", "task.browsers", "task.attributes", "task.history", "task.onCall", "task.leadAssist", "task.assisting", "task.listening", "task.media", "task.acceptance", "task.outcomes", "task.destinations", "task.custom", "task.locked", "break.reasons", "break.forced", "team.members", "team.requests", "contacts", "scheduledActivities", "team.policies"];
+declare const STATE_SUBJECTS: readonly ["tasks", "task.browsers", "task.attributes", "task.history", "task.onCall", "task.leadAssist", "task.takenOver", "task.media", "task.acceptance", "task.outcomes", "task.destinations", "task.custom", "task.locked", "break.reasons", "break.forced", "team.members", "team.requests", "team.tasks", "team.listening", "contacts", "scheduledActivities", "team.policies"];
 export type ContractSubject = (typeof STATE_SUBJECTS)[number] | `event.${ProviderEvent["type"]}`;
 export interface AdapterContractResult {
     events: ProviderEventEnvelope[];

package/dist/testing.js

@@ -14,8 +14,7 @@ const STATE_SUBJECTS = [
     "task.history",
     "task.onCall",
     "task.leadAssist",
-    "task.assisting",
-    "task.listening",
+    "task.takenOver",
     "task.media",
     "task.acceptance",
     "task.outcomes",
@@ -26,6 +25,8 @@ const STATE_SUBJECTS = [
     "break.forced",
     "team.members",
     "team.requests",
+    "team.tasks",
+    "team.listening",
     "contacts",
     "scheduledActivities",
     "team.policies",
@@ -35,7 +36,7 @@ const STATE_SUBJECTS = [
 const EVENT_TYPES = {
     snapshot: true, "transport-status": true, "break-state": true, "task-offered": true, "task-updated": true,
     "task-media-started": true, "task-media-ended": true, "task-ended": true, "dial-outcome": true, announcement: true, "queue-summary": true, diagnostic: true,
-    "team-updated": true, "contacts-updated": true, "calendar-updated": true,
+    "team-updated": true, "team-media-started": true, "team-media-ended": true, "contacts-updated": true, "calendar-updated": true,
 };
 const CONTRACT_SUBJECTS = [
     ...STATE_SUBJECTS,
@@ -59,10 +60,8 @@ function observeTask(value, seen) {
         seen.add("task.onCall");
     if (value.leadAssist !== undefined)
         seen.add("task.leadAssist");
-    if (value.assisting !== undefined)
-        seen.add("task.assisting");
-    if (value.listening !== undefined)
-        seen.add("task.listening");
+    if (value.takenOver !== undefined)
+        seen.add("task.takenOver");
     if (value.media !== undefined)
         seen.add("task.media");
     if (value.acceptance !== undefined)
@@ -95,6 +94,15 @@ function observeTeam(value, seen) {
         seen.add("team.members");
     if (some(value.requests))
         seen.add("team.requests");
+    if (Array.isArray(value.members))
+        for (const member of value.members) {
+            if (!isRecord(member))
+                continue;
+            if (some(member.tasks))
+                seen.add("team.tasks");
+            if (member.listening !== undefined)
+                seen.add("team.listening");
+        }
     if (isRecord(value.policies) && Object.keys(value.policies).length > 0)
         seen.add("team.policies");
 }
@@ -229,14 +237,8 @@ export async function exerciseAdapter(adapter, context, options = {}) {
                     requireMethod(on, method, "the login declares capabilities.breaks");
                 }
             }
-            if (capabilities.team?.breakControl === true)
-                requireMethod(on, "executeTeamBreak", "the login declares capabilities.team.breakControl");
-            if (capabilities.team?.leadAssistControl === true)
-                requireMethod(on, "executeTeamLeadAssist", "the login declares capabilities.team.leadAssistControl");
-            if (capabilities.team?.listeningControl !== undefined)
-                requireMethod(on, "executeTeamListen", "the login declares capabilities.team.listeningControl");
-            if (capabilities.team?.policyControl === true)
-                requireMethod(on, "executeTeamPolicy", "the login declares capabilities.team.policyControl");
+            if (capabilities.lead === true)
+                requireMethod(on, "executeTeam", "the login declares capabilities.lead");
             if (some(capabilities.preferences))
                 requireMethod(on, "setPreference", "the login declares capabilities.preferences");
         };
@@ -671,11 +673,28 @@ function userIdsIn(snapshot) {
                     add(entry.userId);
         if (isRecord(t.leadAssist))
             add(t.leadAssist.leadId);
-        if (isRecord(t.assisting))
-            add(t.assisting.memberId);
-        if (isRecord(t.listening)) {
-            add(t.listening.memberId);
-            add(t.listening.agentId);
+        if (isRecord(t.takenOver))
+            add(t.takenOver.memberId);
+    }
+    if (isRecord(team)) {
+        for (const member of Array.isArray(team.members) ? team.members : []) {
+            if (!isRecord(member) || !Array.isArray(member.tasks))
+                continue;
+            for (const task of member.tasks) {
+                const t = task;
+                if (isRecord(t.history) && Array.isArray(t.history.steps))
+                    for (const step of t.history.steps)
+                        if (isRecord(step))
+                            add(step.by);
+                if (Array.isArray(t.onCall))
+                    for (const entry of t.onCall)
+                        if (isRecord(entry))
+                            add(entry.userId);
+                if (isRecord(t.leadAssist))
+                    add(t.leadAssist.leadId);
+                if (isRecord(t.takenOver))
+                    add(t.takenOver.memberId);
+            }
         }
     }
     return [...ids];
@@ -683,8 +702,7 @@ function userIdsIn(snapshot) {
 const teamNamesUsers = (team) => isRecord(team) && (some(team.members) || some(team.requests));
 const taskNamesUsers = (task) => isRecord(task) && ((isRecord(task.history) && Array.isArray(task.history.steps) && task.history.steps.some(step => isRecord(step) && step.by !== undefined)) ||
     (isRecord(task.leadAssist) && task.leadAssist.leadId !== undefined) ||
-    isRecord(task.assisting) ||
-    isRecord(task.listening));
+    isRecord(task.takenOver));
 /** Whether an event publishes a `UserId`, on a team member list, a task, or the snapshot a reconnect carries. */
 function eventNamesUsers(envelope) {
     const event = isRecord(envelope) ? envelope.event : undefined;
@@ -815,11 +833,7 @@ export function assertCapabilityWithdrawal(states, snapshot, manifest) {
     const before = first.capabilities;
     const after = last.capabilities;
     const withdrawn = (before.breaks === true && after.breaks !== true) ||
-        (before.team !== undefined && after.team === undefined) ||
-        (before.team?.breakControl === true && after.team?.breakControl !== true) ||
-        (before.team?.leadAssistControl === true && after.team?.leadAssistControl !== true) ||
-        (before.team?.listeningControl !== undefined && after.team?.listeningControl === undefined) ||
-        (before.team?.policyControl === true && after.team?.policyControl !== true) ||
+        (before.lead === true && after.lead !== true) ||
         (before.preferences ?? []).some(was => !(after.preferences ?? []).some(now => now.id === was.id));
     if (!withdrawn) {
         throw new Error("Capability withdrawal must end with at least one capability the first login declared withdrawn");

package/dist/validation.d.ts

@@ -1,4 +1,4 @@
-import { type RecordingState, type ProtocolViolation, type UserCapabilities, type UserId } from "./index.js";
+import { type RecordingState, type Channel, type ProtocolViolation, type UserCapabilities, type UserId } from "./index.js";
 export type { ProtocolViolation } from "./index.js";
 export declare class ProtocolConformanceError extends Error {
     readonly violations: readonly ProtocolViolation[];
@@ -45,16 +45,23 @@ export interface TaskValidationContext {
      * carry one of these. Unknown to a host, which never sees the value, and then unchecked.
      */
     locked?: readonly string[];
+    /**
+     * A member's task on the team member list, trimmed by the provider: the workspace -- controls,
+     * their source, browsers, completion terms -- is the member's and may be absent; what is present
+     * is held to the same rules as on the member's own desk.
+     */
+    member?: true;
 }
 export declare function validateTask(task: unknown, context: TaskValidationContext, path?: string): ProtocolViolation[];
 /** Checks break status against the full currently retained task set, after a transaction. */
 export declare function validateBreakStatus(state: unknown, tasks: unknown, path?: string): ProtocolViolation[];
 /**
- * Checks lead break dispatch using current authentication, transport, team member list (`team`) and,
- * for force-break/end-forced-break, the target's full `memberBreak`. The provider must authorize the target
- * and recheck the decision atomically; a team member list is not authority to act after it has changed.
+ * Checks a lead command before dispatch, against the current authentication, transport and team
+ * member list (`team`) and, for force-break and end-forced-break, the target's full `memberBreak`.
+ * The authority is the login's `lead` flag; the provider rechecks the target and the state
+ * atomically, since a team member list is not authority to act after it has changed.
  */
-export declare function validateTeamBreakCommand(request: unknown, context: unknown, path?: string): ProtocolViolation[];
+export declare function validateTeamCommand(request: unknown, context: unknown, path?: string): ProtocolViolation[];
 /** The four agent break methods; this is a validation API, not a wire command. */
 export type BreakMethod = "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak";
 /**
@@ -90,6 +97,13 @@ export interface ReaderContext {
     levels?: readonly string[];
     /** The login's `loginId`. A snapshot or event naming another belongs to a login that is gone. */
     loginId?: string;
+    /**
+     * Whether the lead has the team feature on, as the application last told the provider. On by
+     * default for a lead; off, no team member list is owed or expected. Unknown to a caller without it.
+     */
+    leadFeatures?: boolean;
+    /** The provider's channel, for a member's task that states none. Filled from the manifest by `validateSnapshot` and `validateEventEnvelope`. */
+    channel?: Channel;
     /**
      * The values the queue locked on this login's tasks, as whoever runs the validator knows them:
      * a conformance run states them, a host never has them. Where a task's party stands locked, no
@@ -135,7 +149,7 @@ export declare function validateTaskCommandRequest(request: unknown, task: unkno
  */
 export declare function validateTaskCommand(command: unknown, task?: unknown, path?: string, taskContext?: Omit<TaskValidationContext, "channel">): ProtocolViolation[];
 /** The connection methods whose results `validateResult` knows. */
-export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak" | "executeTeamBreak" | "executeTeamLeadAssist" | "executeTeamListen" | "openMedia" | "setPreference" | "recordStep" | "executeTeamPolicy";
+export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak" | "executeTeam" | "openMedia" | "setPreference" | "recordStep";
 /**
  * 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