@xema/omni-protocol 0.1.98 → 0.1.100

package/dist/validation.js

@@ -9,7 +9,7 @@
 // Each list is pinned to its type both ways -- a member the type lacks, or a member the list
 // lacks, fails to compile -- so what the validators accept cannot drift from what the
 // declarations say.
-import { RECORDING_ACTIONS, ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, LISTENING_BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, HISTORY_STEPS_THAT_DIAL, IDLE_CAPABILITIES, OMNI_FAILURE_CODES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, TASK_COMMAND_NAMES, negotiateProtocolVersion, DEFAULT_LEVELS, effectiveLevels, } from "./index.js";
+import { RECORDING_ACTIONS, ALLOWED_BROWSER_URL_SCHEMES, BREAK_KINDS, BROWSER_ISOLATION_SCHEMES, HISTORY_STEPS_THAT_DIAL, IDLE_CAPABILITIES, OMNI_FAILURE_CODES, OMNI_SUPPORTED_PROTOCOL_VERSIONS, TASK_COMMAND_NAMES, negotiateProtocolVersion, DEFAULT_LEVELS, effectiveLevels, } from "./index.js";
 export class ProtocolConformanceError extends Error {
     violations;
     constructor(violations, summary = "Adapter violates the Omni protocol") {
@@ -41,7 +41,7 @@ const TASK_PHASES = membersOf({
     pending: true, confirmed: true, preview: true, "in-progress": true, paused: true, completing: true,
 });
 const COMPLETION_MODES = membersOf({ "agent-command": true, "provider-automatic": true });
-const CAPABILITY_SOURCES = membersOf({ queue: true, ungoverned: true, undetermined: true });
+const CAPABILITY_SOURCES = membersOf({ queue: true, nobody: true, "not-yet-read": true });
 const ACCEPTANCE_MODES = membersOf({
     "no-preference": true, "consent": true, "automatic": true,
 });
@@ -55,7 +55,7 @@ const BREAK_APPROVALS = membersOf({
     "not-requested": true, "awaiting-approval": true, granted: true, "starting-after-task": true, "on-break": true,
 });
 const TEAM_AVAILABILITIES = membersOf({
-    ready: true, "on-task": true, "on-break": true, reserved: true, "signed-out": true,
+    ready: true, "on-task": true, "on-break": true, elsewhere: true, "signed-out": true,
 });
 const HISTORY_STEPS = membersOf({
     queued: true, offered: true, answered: true, held: true, muted: true, transferred: true, conferenced: true, unanswered: true,
@@ -78,16 +78,15 @@ const DIALLING_CAPABILITIES = ["connectBack", "coldTransfer", "warmTransfer", "c
 const SNAPSHOT_REASONS = membersOf({
     reconnected: true, "provider-requested": true,
 });
-const SESSION_CAPABILITIES = membersOf({ breaks: true, team: true, preferences: true });
+const SESSION_CAPABILITIES = membersOf({ breaks: true, lead: true, preferences: true });
 const MEMBER_BREAKS = membersOf({
     "awaiting-approval": true, granted: true, "starting-after-task": true,
 });
 const OFFERABLE_PHASES = membersOf({
     pending: true,
 });
-const PREVIEW_DEADLINES = membersOf({ calls: true, "host-calls": true, waits: true });
+const PREVIEW_DEADLINES = membersOf({ "provider-dials": true, "host-dials": true, waits: true });
 const PHONES = membersOf({ softphone: true, deskPhone: true });
-const TEAM_CAPABILITIES = membersOf({ breakControl: true, leadAssistControl: true, policyControl: true, listeningControl: true });
 const LISTENING_MODES = membersOf({ listen: true, coach: true, "join-call": true });
 const COMPLETED_BY = membersOf({ agent: true, provider: true });
 const CANCELLED_BY = membersOf({ agent: true, provider: true, party: true });
@@ -99,7 +98,7 @@ const ISOLATION_SCHEME_VALUES = Object.values(BROWSER_ISOLATION_SCHEMES);
 const TASK_CAPABILITIES = {
     voice: membersOf({
         browsers: true, outcomes: true, custom: true, decline: true, hold: true,
-        endCall: true, connectBack: true, coldTransfer: true, warmTransfer: true, leadAssist: true, conference: true, recording: true,
+        endCall: true, terminateCall: true, connectBack: true, coldTransfer: true, warmTransfer: true, leadAssist: true, conference: true, recording: true,
     }),
     chat: membersOf({ browsers: true, outcomes: true, custom: true, decline: true, hold: true }),
     email: membersOf({ browsers: true, outcomes: true, custom: true, decline: true }),
@@ -924,13 +923,13 @@ function validateHistory(value, path, into, task = {}) {
         }
         else {
             // An open leg is one still running, and the task says whether it can be: a hold runs only while
-            // the task is paused, and a mute only while its media is up. An open entry after that is a leg
+            // the task is paused, and a mute only while its audio is up. An open entry after that is a leg
             // nobody closed, which reads exactly like a leg running now.
             if (entry.step === "held") {
                 into.require(task.phase === "paused", "task.history.held.open", `${at}.seconds`, `a held entry without seconds is a hold still running, and the task is ${describeValue(task.phase)}: the hold has ended, and its duration is stated`);
             }
             if (entry.step === "muted") {
-                into.require(task.media !== "ended" && task.phase !== "completing", "task.history.muted.open", `${at}.seconds`, "a muted entry without seconds is still running, but this interaction's media has ended: the provider closes its open leg and states the duration; other channels may continue");
+                into.require(task.audio !== "ended" && task.phase !== "completing", "task.history.muted.open", `${at}.seconds`, "a muted entry without seconds is still running, but this interaction's audio has ended: the provider closes its open leg and states the duration; other channels may continue");
             }
         }
         // A muted entry carries whose the silence was, as the host reported it; no other step has it.
@@ -961,22 +960,22 @@ function validateHistory(value, path, into, task = {}) {
 }
 /** Present only while consulting, and only on voice: elsewhere there is nobody to consult. */
 const TASK_MEDIA_STATES = membersOf({ started: true, ended: true });
-/** Real-time media is a voice affair, and its state is one of two words. */
+/** Real-time audio is a voice affair, and its state is one of two words. */
 /** A host dial, or explicitly provider-triggered preview dial, is ringing the party. */
 function partyRingingBeforeWork(task) {
-    return Array.isArray(task.onCall) && task.onCall.some(entry => isPlainObject(entry) && entry.role === "party" && entry.stage === "ringing" && (isFilled(entry.dialId) || (task.phase === "preview" && task.atDeadline === "calls" && entry.dialId === undefined)));
+    return Array.isArray(task.onCall) && task.onCall.some(entry => isPlainObject(entry) && entry.role === "party" && entry.stage === "ringing" && (isFilled(entry.dialId) || (task.phase === "preview" && task.atDeadline === "provider-dials" && entry.dialId === undefined)));
 }
-function validateTaskMedia(task, value, channel, phase, path, into) {
+function validateTaskAudio(task, value, channel, phase, path, into) {
     if (value === undefined)
         return;
-    if (!into.require(channel === "voice", "task.media.channel", path, `a ${channel} task carries no real-time media state`))
+    if (!into.require(channel === "voice", "task.audio.channel", path, `a ${channel} task carries no real-time audio state`))
         return;
-    if (into.oneOf(value, TASK_MEDIA_STATES, "task.media", path)) {
-        // Nothing is acquired while pending, and a preview has placed no call: media names a task whose
+    if (into.oneOf(value, TASK_MEDIA_STATES, "task.audio", path)) {
+        // Nothing is acquired while pending, and a preview has placed no call: audio names a task whose
         // work has begun, on a snapshot as on the event, or a host would open the microphone on an offer.
         // Ring-back may precede answer for a host dial or an explicitly provider-triggered preview.
-        // A deadline alone is never evidence that media started.
-        into.require(!WORK_NOT_BEGUN.includes(phase) || partyRingingBeforeWork(task), "task.media.beforeWork", path, `a ${describeValue(phase)} task has no media: audio arrives once its work has begun, or once an evidenced host/provider preview dial is ringing its party`);
+        // A deadline alone is never evidence that audio started.
+        into.require(!WORK_NOT_BEGUN.includes(phase) || partyRingingBeforeWork(task), "task.audio.beforeWork", path, `a ${describeValue(phase)} task has no audio: audio arrives once its work has begun, or once an evidenced host/provider preview dial is ringing its party`);
     }
 }
 const WORK_NOT_BEGUN = ["pending", "confirmed", "preview"];
@@ -1073,42 +1072,24 @@ function validateLeadAssist(value, channel, path, into) {
         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) {
+/** A call a lead took over: which member it came from, and when. Voice only. */
+function validateTakenOver(value, channel, path, into) {
     if (value === undefined)
         return;
-    if (!into.require(channel === "voice", "task.assisting.channel", path, `a ${channel} task cannot be a joined call`))
+    if (!into.require(channel === "voice", "task.takenOver.channel", path, `a ${channel} task has no call to take over`))
         return;
     if (!isPlainObject(value)) {
-        into.add("task.assisting.shape", path, "assisting must be an object when present");
+        into.add("task.takenOver.shape", path, "takenOver must be an object when present");
         return;
     }
-    into.require(isUserId(value.memberId), "task.assisting.memberId", `${path}.memberId`, "a joined call names the member who asked");
-    into.require(isAssignmentId(value.assignmentId), "task.assisting.assignmentId", `${path}.assignmentId`, "a joined call names the member's assignment");
-    if (value.note !== undefined)
-        into.filled(value.note, "task.assisting.note", `${path}.note`, "a note must not be empty when present");
-    into.timestamp(value.since, "task.assisting.since", `${path}.since`);
+    into.require(isUserId(value.memberId), "task.takenOver.memberId", `${path}.memberId`, "a taken-over call names the member it was taken from");
+    into.timestamp(value.since, "task.takenOver.since", `${path}.since`);
 }
-/** The lead's own task while they listen: whose call, which call, and how they are heard. Voice only. */
-function validateListening(value, channel, path, into) {
-    if (value === undefined)
-        return;
-    if (!into.require(channel === "voice", "task.listening.channel", path, `a ${channel} task has no call to listen to`))
-        return;
-    if (!isPlainObject(value)) {
-        into.add("task.listening.shape", path, "listening must be an object when present");
-        return;
-    }
-    into.require(isUserId(value.memberId), "task.listening.memberId", `${path}.memberId`, "a call being listened to names the member on it");
-    into.require(isAssignmentId(value.assignmentId), "task.listening.assignmentId", `${path}.assignmentId`, "a call being listened to names the member's assignment");
-    into.oneOf(value.mode, LISTENING_MODES, "task.listening.mode", `${path}.mode`);
-    into.timestamp(value.since, "task.listening.since", `${path}.since`);
-}
-/** Whether a task is the agent's own doing: a dial the host placed on its onCall, a lead's join, a lead's listen. */
+/** Whether a task is the agent's own doing: a dial the host placed on its onCall, or a call a lead took over. */
 function originatedByTheAgent(task) {
     if (Array.isArray(task.onCall) && task.onCall.some(entry => isPlainObject(entry) && typeof entry.dialId === "string"))
         return true;
-    return task.assisting !== undefined || task.listening !== undefined;
+    return task.takenOver !== undefined;
 }
 export function validateTask(task, context, path = "task") {
     const into = new Collector();
@@ -1120,7 +1101,11 @@ function validateTaskInto(task, context, path, into) {
         into.add("task.shape", path, "a task must be an object");
         return;
     }
-    into.require(!Object.hasOwn(task, "monitoring"), "task.listening.renamed", `${path}.monitoring`, "use listening; the former field is not accepted");
+    // A task carries no lead state: the lead's view is the team member list, and a lead's own call
+    // is an ordinary assignment marked takenOver.
+    for (const retired of ["assisting", "listening", "monitoring"]) {
+        into.require(!Object.hasOwn(task, retired), "task.leadState.retired", `${path}.${retired}`, "a task carries no lead state; a call a lead took over says takenOver, and the lead's view is the team member list");
+    }
     for (const former of ["handlingHistory", "interactionHistory"]) {
         into.require(!Object.hasOwn(task, former), "task.history.renamed", `${path}.${former}`, "use history; the former field is not accepted");
     }
@@ -1146,7 +1131,7 @@ function validateTaskInto(task, context, path, into) {
             into.timestamp(task.previewEndsAt, "task.preview.previewEndsAt", `${path}.previewEndsAt`);
         }
         if (task.atDeadline === undefined) {
-            into.add("task.preview.atDeadline.required", `${path}.atDeadline`, "a preview with a deadline says what happens at it: provider calls, host calls, or waits for the agent -- an agent counting down has to know which");
+            into.add("task.preview.atDeadline.required", `${path}.atDeadline`, "a preview with a deadline says what happens at it: provider dials, host dials, or waits for the agent -- an agent counting down has to know which");
         }
         else {
             into.oneOf(task.atDeadline, PREVIEW_DEADLINES, "task.preview.atDeadline", `${path}.atDeadline`);
@@ -1166,24 +1151,26 @@ function validateTaskInto(task, context, path, into) {
             into.add("task.acceptance.unexpected", `${path}.acceptance`, "acceptance is an offer's word; a task past pending has been accepted");
         }
         else if (originated) {
-            into.require(task.acceptance === "automatic", "task.acceptance.originated", `${path}.acceptance`, "work the agent originated -- a dial, a connect-back, a join, a listen -- was accepted by the command that created it, and says automatic whatever the provisioning");
+            into.require(task.acceptance === "automatic", "task.acceptance.originated", `${path}.acceptance`, "work the agent originated -- a dial, a connect-back, a call taken over -- was accepted by the command that created it, and says automatic whatever the provisioning");
         }
         else if (context.autoAcceptTasks === false) {
             into.add("task.acceptance.unexpected", `${path}.acceptance`, "autoAcceptTasks is off, so every task the queue routes requires agent acceptance and a pending task carries no acceptance");
         }
     }
     else if (originated) {
-        into.add("task.acceptance.originated", `${path}.acceptance`, "work the agent originated -- a dial, a connect-back, a join, a listen -- says acceptance: automatic whatever the provisioning: the command that created it accepted it");
+        into.add("task.acceptance.originated", `${path}.acceptance`, "work the agent originated -- a dial, a connect-back, a call taken over -- says acceptance: automatic whatever the provisioning: the command that created it accepted it");
     }
     else if (task.phase === "pending" && context.autoAcceptTasks === true) {
         into.add("task.acceptance.required", `${path}.acceptance`, "autoAcceptTasks is on, so a pending task states how it is accepted");
     }
-    into.oneOf(task.completionMode, COMPLETION_MODES, "task.completionMode", `${path}.completionMode`);
+    if (context.member !== true || task.completionMode !== undefined)
+        into.oneOf(task.completionMode, COMPLETION_MODES, "task.completionMode", `${path}.completionMode`);
     // The allowance is coupled to the mode: a provider that will complete the task itself is going
     // to act on the allowance, so it must state one; a provider waiting for `complete` may omit it
     // to say it imposes no deadline. Present, it is a duration either way.
     if (task.wrapAllowance === undefined) {
-        into.require(task.completionMode !== "provider-automatic", "task.wrapAllowance.required", `${path}.wrapAllowance`, "provider-automatic completion needs an allowance to act on");
+        if (context.member !== true)
+            into.require(task.completionMode !== "provider-automatic", "task.wrapAllowance.required", `${path}.wrapAllowance`, "provider-automatic completion needs an allowance to act on");
     }
     else {
         into.require(isDurationSeconds(task.wrapAllowance), "task.wrapAllowance", `${path}.wrapAllowance`, "wrapAllowance must be a whole number of seconds, zero or more, or omitted under agent-command");
@@ -1210,31 +1197,30 @@ function validateTaskInto(task, context, path, into) {
                 into.violations.push(...validateRecordingState(task.recording.provider, `${path}.recording.provider`));
         }
     }
-    validateBrowsers(task.browsers, `${path}.browsers`, into);
+    if (context.member !== true || task.browsers !== undefined)
+        validateBrowsers(task.browsers, `${path}.browsers`, into);
     validateTaskAttributes(task.attributes, `${path}.attributes`, into, context.levels);
-    validateHistory(task.history, `${path}.history`, into, { phase: task.phase, media: task.media });
+    validateHistory(task.history, `${path}.history`, into, { phase: task.phase, audio: task.audio });
     validateOnCall(task.onCall, context.channel, `${path}.onCall`, into);
-    // Media and onCall describe this agent's interaction, not the continuing caller journey.
-    // Once the interaction's media ends or it enters wrap, its live room is cleared. Other
+    // Audio and onCall describe this agent's interaction, not the continuing caller journey.
+    // Once the interaction's audio ends or it enters wrap, its live room is cleared. Other
     // channels may remain connected under another interaction or in IVR/queue stages.
-    if (task.phase === "completing" && task.media === "started") {
-        into.add("task.media.completing", `${path}.media`, "a completing task's interaction media has ended or never started; it cannot still be started during wrap");
+    if (task.phase === "completing" && task.audio === "started") {
+        into.add("task.audio.completing", `${path}.audio`, "a completing task's interaction audio has ended or never started; it cannot still be started during wrap");
     }
-    if (Array.isArray(task.onCall) && task.onCall.length > 0 && (task.phase === "completing" || task.media === "ended")) {
-        into.add("task.onCall.ended", `${path}.onCall`, `this interaction is no longer connected (${task.phase === "completing" ? "the task is completing" : "its media ended"}); clear its onCall view without implying that other channels ended`);
+    if (Array.isArray(task.onCall) && task.onCall.length > 0 && (task.phase === "completing" || task.audio === "ended")) {
+        into.add("task.onCall.ended", `${path}.onCall`, `this interaction is no longer connected (${task.phase === "completing" ? "the task is completing" : "its audio ended"}); clear its onCall view without implying that other channels ended`);
     }
-    validateTaskMedia(task, task.media, context.channel, task.phase, `${path}.media`, into);
+    validateTaskAudio(task, task.audio, context.channel, task.phase, `${path}.audio`, into);
     validateLeadAssist(task.leadAssist, context.channel, `${path}.leadAssist`, into);
-    validateAssisting(task.assisting, context.channel, `${path}.assisting`, into);
-    validateListening(task.listening, context.channel, `${path}.listening`, into);
-    // A lead's task is one thing: a call they joined on request, or a call they listen to unasked.
-    if (task.assisting !== undefined && task.listening !== undefined) {
-        into.add("task.listening.assisting", `${path}.listening`, "a task is a joined call or a listened one, never both");
-    }
+    validateTakenOver(task.takenOver, context.channel, `${path}.takenOver`, into);
     // Where the terms came from is stated with them: a host cannot tell "the platform permits
     // nothing" from "the terms could not be read" from the set alone, and the provider knows which.
-    into.oneOf(task.capabilitySource, CAPABILITY_SOURCES, "task.capabilitySource", `${path}.capabilitySource`);
+    if (context.member !== true || task.capabilitySource !== undefined)
+        into.oneOf(task.capabilitySource, CAPABILITY_SOURCES, "task.capabilitySource", `${path}.capabilitySource`);
     const capabilities = task.capabilities;
+    if (context.member === true && capabilities === undefined && task.browsers === undefined)
+        return;
     if (!isPlainObject(capabilities)) {
         into.add("task.capabilities.shape", `${path}.capabilities`, "a task needs a capabilities object");
         return;
@@ -1319,8 +1305,7 @@ export function validateBreakStatus(state, tasks, path = "snapshot") {
         });
     // A break in effect begins when the work ends, so it holds no task. A snapshot reporting both
     // describes a state the agent cannot be in, whichever half is stale. The one exception is a
-    // lead listening to a call during a break that is work of another sort -- coaching,
-    // administrative, training -- and on no other.
+    // call a lead took over: the provider assigns it whatever break the lead is on.
     // The converse: a committed break with nothing outstanding has begun. starting-after-task beside
     // no task is a break waiting on work that does not exist, and an empty list reading as "still
     // finishing" is the plausible nought.
@@ -1331,79 +1316,103 @@ export function validateBreakStatus(state, tasks, path = "snapshot") {
     }
     if (isPlainObject(state) && state.status === "on-break"
         && Array.isArray(tasks) && tasks.length > 0) {
-        const listening = tasks.every((task) => isPlainObject(task) && task.listening !== undefined);
-        if (!listening) {
-            into.add("break.on-break.tasks", `${path}.tasks`, "a break in effect holds no task: it begins when the work ends, and until then the state is starting-after-task");
-        }
-        else {
-            const reasons = Array.isArray(state.reasons) ? state.reasons : [];
-            const active = reasons.find((reason) => isPlainObject(reason) && reason.id === state.activeReasonId);
-            const kind = isPlainObject(active) ? active.kind : undefined;
-            into.require(typeof kind === "string" && LISTENING_BREAK_KINDS.includes(kind), "snapshot.listening.break", `${path}.tasks`, `a lead listens during a ${LISTENING_BREAK_KINDS.join(", ")} break and no other; the active reason is ${kind === undefined ? "unstated" : describeValue(kind)}`);
+        const takenOver = tasks.every((task) => isPlainObject(task) && task.takenOver !== undefined);
+        if (!takenOver) {
+            into.add("break.on-break.tasks", `${path}.tasks`, "a break in effect holds no task: it begins when the work ends, and until then the state is starting-after-task; the one exception is a call a lead took over");
         }
     }
     return into.violations;
 }
 /**
- * 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 function validateTeamBreakCommand(request, context, path = "teamBreakCommand") {
+export function validateTeamCommand(request, context, path = "teamCommand") {
     const into = new Collector();
     if (!isPlainObject(context) || !isPlainObject(request) || !isPlainObject(request.command)) {
-        into.add("team.break.command.shape", path, "a command and current authentication/transport/team context are required");
+        into.add("team.command.shape", path, "a command and current authentication/transport/team context are required");
         return into.violations;
     }
     const auth = isPlainObject(context.authentication) ? context.authentication : {};
     into.violations.push(...validateAuthenticationState(auth, `${path}.authentication`));
     const caps = isPlainObject(auth.capabilities) ? auth.capabilities : {};
-    into.require((auth.status === "authenticated" || auth.status === "refreshing") && context.transport === "active", "team.break.command.connection", path, "lead commands require a live login and active transport");
-    into.require(isPlainObject(caps.team) && caps.team.breakControl === true, "team.break.command.capability", path, "the login must declare team.breakControl");
+    into.require((auth.status === "authenticated" || auth.status === "refreshing") && context.transport === "active", "team.command.connection", path, "lead commands require a live login and active transport");
+    into.require(caps.lead === true, "team.command.capability", path, "the login must declare lead");
     const command = request.command;
+    const member = ["type", "memberId", "assignmentId"];
     const allowed = {
+        "lead-features": ["type", "enabled"],
         "decide-break-request": ["type", "memberId", "decision", "reason"], "set-break-policy": ["type", "policy"],
         "force-break": ["type", "memberId", "reasonId", "reason", "expectedDurationMs"], "end-forced-break": ["type", "memberId"],
+        join: member, decline: [...member, "reason"], listen: member, coach: member, "join-call": member, leave: member, "take-over-call": member,
+        "set-policy": ["type", "capability", "setting"],
     };
     const fields = typeof command.type === "string" && Object.hasOwn(allowed, command.type) ? allowed[command.type] : undefined;
     if (!fields) {
-        into.add("team.break.command.type", path, "unknown lead break command");
+        into.add("team.command.type", path, `unknown lead command: ${describeValue(command.type)}`);
         return into.violations;
     }
     for (const key of Object.keys(request))
-        into.require(key === "command", "team.break.request.field", `${path}.${key}`, "only command is supported");
+        into.require(key === "command", "team.request.field", `${path}.${key}`, "only command is supported");
     for (const key of Object.keys(command))
-        into.require(fields.includes(key), "team.break.command.field", `${path}.${key}`, "field is not supported for this command");
+        into.require(fields.includes(key), "team.command.field", `${path}.${key}`, "field is not supported for this command");
     if (command.reason !== undefined)
-        into.filled(command.reason, "team.break.command.reason", path, "reason must not be empty");
+        into.filled(command.reason, "team.command.reason", path, "reason must not be empty");
+    if (command.type === "lead-features") {
+        into.require(typeof command.enabled === "boolean", "team.command.enabled", `${path}.enabled`, "lead-features says on or off, as a boolean");
+        return into.violations;
+    }
     if (command.type === "set-break-policy") {
-        into.require(["approval-required", "automatically-approved", "requests-suspended"].includes(command.policy), "team.break.command.policy", path, "unknown break policy");
+        into.require(["approval-required", "automatically-approved", "requests-suspended"].includes(command.policy), "team.command.policy", path, "unknown break policy");
         return into.violations;
     }
-    into.filled(command.memberId, "team.break.command.member", path, "name the target member");
+    if (command.type === "set-policy") {
+        into.require(typeof command.capability === "string" && (POLICY_KEYS.has(command.capability) || /^skill:.+$/.test(command.capability)), "team.command.capability.key", `${path}.capability`, "a policy names a task control, dial, or a skill");
+        if (into.oneOf(command.setting, POLICY_SETTINGS, "team.command.setting", `${path}.setting`)) {
+            into.require(command.setting !== "person" || (typeof command.capability === "string" && PERSON_SETTABLE.test(command.capability)), "team.command.setting.person", `${path}.setting`, "only hold and skills may be left to the person");
+        }
+        return into.violations;
+    }
+    into.filled(command.memberId, "team.command.member", path, "name the target member");
     const team = isPlainObject(context.team) ? context.team : {};
     const members = Array.isArray(team.members) ? team.members : [];
-    const member = members.find((m) => isPlainObject(m) && m.id === command.memberId);
+    const target = members.find((m) => isPlainObject(m) && m.id === command.memberId);
     const self = isPlainObject(auth.identity) ? auth.identity.id : undefined;
-    into.require(isPlainObject(member) && command.memberId !== self, "team.break.command.member", path, "the target must be another member of the current authorized team member list");
+    into.require(isPlainObject(target) && command.memberId !== self, "team.command.member", path, "the target must be another member of the current team member list");
+    if (command.assignmentId !== undefined) {
+        into.require(isAssignmentId(command.assignmentId), "team.command.assignmentId", `${path}.assignmentId`, "an assignment id must be non-empty when present");
+        const tasks = isPlainObject(target) && Array.isArray(target.tasks) ? target.tasks : undefined;
+        if (tasks !== undefined)
+            into.require(tasks.some((task) => isPlainObject(task) && task.assignmentId === command.assignmentId), "team.command.assignmentId.unknown", `${path}.assignmentId`, "the assignment named is not one the team member list shows the member holding");
+    }
     if (command.type === "decide-break-request") {
-        into.require(command.decision === "granted" || command.decision === "denied", "team.break.command.decision", path, "decide granted or denied");
-        into.require(isPlainObject(member) && member.break === "awaiting-approval", "team.break.command.awaiting", path, "decide only a currently awaiting-approval request");
+        into.require(command.decision === "granted" || command.decision === "denied", "team.command.decision", path, "decide granted or denied");
+        into.require(isPlainObject(target) && target.break === "awaiting-approval", "team.command.awaiting", path, "decide only a currently awaiting-approval request");
     }
-    else {
+    else if (command.type === "force-break" || command.type === "end-forced-break") {
         validateBreakState(context.memberBreak, `${path}.memberBreak`, into);
         const state = isPlainObject(context.memberBreak) ? context.memberBreak : {};
         if (command.type === "end-forced-break")
-            into.require(state.forced !== undefined && (state.status === "on-break" || state.status === "starting-after-task"), "team.break.command.endForcedBreak", path, "lift a current forced-break restriction without resuming the agent");
+            into.require(state.forced !== undefined && (state.status === "on-break" || state.status === "starting-after-task"), "team.command.endForcedBreak", path, "lift a current forced-break restriction without resuming the agent");
         if (command.type === "force-break") {
             if (command.expectedDurationMs !== undefined)
-                into.require(typeof command.expectedDurationMs === "number" && Number.isFinite(command.expectedDurationMs) && command.expectedDurationMs > 0, "team.break.command.expectedDurationMs", `${path}.expectedDurationMs`, "expectedDurationMs must be positive finite milliseconds; it never resumes the agent");
+                into.require(typeof command.expectedDurationMs === "number" && Number.isFinite(command.expectedDurationMs) && command.expectedDurationMs > 0, "team.command.expectedDurationMs", `${path}.expectedDurationMs`, "expectedDurationMs must be positive finite milliseconds; it never resumes the agent");
             if (command.reasonId !== undefined)
-                into.filled(command.reasonId, "team.break.command.reasonId", path, "reasonId must not be empty");
+                into.filled(command.reasonId, "team.command.reasonId", path, "reasonId must not be empty");
             const reasons = Array.isArray(state.reasons) ? state.reasons : [];
-            into.require(state.reasons === undefined ? command.reasonId === undefined : reasons.some((r) => isPlainObject(r) && r.id === command.reasonId), "team.break.command.reasonId", path, "force-break uses the target's currently published reason codes");
+            into.require(state.reasons === undefined ? command.reasonId === undefined : reasons.some((r) => isPlainObject(r) && r.id === command.reasonId), "team.command.reasonId", path, "force-break uses the target's currently published reason codes");
         }
     }
+    else if (command.type === "join" || command.type === "decline") {
+        const requests = Array.isArray(team.requests) ? team.requests : [];
+        into.require(requests.some((r) => isPlainObject(r) && r.memberId === command.memberId
+            && (command.assignmentId === undefined || r.assignmentId === command.assignmentId)), "team.command.request", path, `${command.type} answers a request the team member list carries, and this member has none`);
+    }
+    else if (command.type === "coach" || command.type === "join-call" || command.type === "leave") {
+        into.require(isPlainObject(target) && target.listening !== undefined, "team.command.listening", path, `${command.type} needs the lead on this member's call: the team member list shows listening on them`);
+    }
     return into.violations;
 }
 /**
@@ -1576,61 +1585,39 @@ function validateTeamMembersInto(teamMembers, path, context, into) {
         into.add("team.shape", path, "a team member list must be an object");
         return;
     }
-    // The login is the permission: a team member list reaches a login that declares `capabilities.team` and
-    // nobody else. Only a caller holding the login can check it.
-    if (context.capabilities !== undefined && context.capabilities.team === undefined) {
-        into.add("team.unentitled", path, "a team member list published to a login that does not declare capabilities.team: the login is the permission");
-    }
-    // The team's policies travel with the team member list exactly when the login may set them.
-    if (context.capabilities !== undefined) {
-        const may = context.capabilities.team?.policyControl === true;
-        if (may && teamMembers.policies === undefined) {
-            into.add("team.policies.required", `${path}.policies`, "the login declares team.policyControl, so the team member list carries the team's policies");
-        }
-        if (!may && teamMembers.policies !== undefined) {
-            into.add("team.policies.capability", `${path}.policies`, "policies require team.policyControl on the login: a lead who may not set them has nothing to see");
-        }
+    // The login is the permission: a team member list reaches a login that declares `capabilities.lead`
+    // and nobody else. Only a caller holding the login can check it.
+    if (context.capabilities !== undefined && context.capabilities.lead !== true) {
+        into.add("team.unentitled", path, "a team member list published to a login that does not declare capabilities.lead: the login is the permission");
     }
+    // Policies are present where the provider offers policy control, absent where it does not.
     if (teamMembers.policies !== undefined)
         validateTeamPoliciesInto(teamMembers.policies, `${path}.policies`, into, context.levels);
-    if (teamMembers.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?.leadAssistControl === true) {
-            into.add("team.requests.required", `${path}.requests`, "the login declares team.leadAssistControl, so the team member list carries requests: [] when nobody is asking");
-        }
+    // Requests are what a lead acts on: always carried, `[]` when nobody is asking.
+    if (!Array.isArray(teamMembers.requests)) {
+        into.add("team.requests.shape", `${path}.requests`, "a team member list carries its 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?.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(teamMembers.requests)) {
-            into.add("team.requests.shape", `${path}.requests`, "requests must be an array when present");
-        }
-        else {
-            const seenRequests = new Set();
-            teamMembers.requests.forEach((request, index) => {
-                const at = `${path}.requests[${index}]`;
-                if (!isPlainObject(request)) {
-                    into.add("team.request.shape", at, "each request must be an object");
-                    return;
-                }
-                if (into.filled(request.id, "team.request.id", `${at}.id`, "a request needs an id")) {
-                    if (seenRequests.has(request.id))
-                        into.add("team.request.unique", `${at}.id`, `duplicate request id: ${request.id}`);
-                    seenRequests.add(request.id);
-                }
-                if (into.require(isUserId(request.memberId), "team.request.memberId", `${at}.memberId`, "a request names the member asking")) {
-                    into.require(request.memberId !== context.self, "team.request.self", `${at}.memberId`, "the team member list carries the reader's own ask: an agent's request for a lead goes to whoever leads them");
-                }
-                into.require(isAssignmentId(request.assignmentId), "team.request.assignmentId", `${at}.assignmentId`, "a request names the member's assignment the lead would join");
-                if (request.note !== undefined)
-                    into.filled(request.note, "team.request.note", `${at}.note`, "a note must not be empty when present");
-                into.timestamp(request.since, "team.request.since", `${at}.since`);
-            });
-        }
+        const seenRequests = new Set();
+        teamMembers.requests.forEach((request, index) => {
+            const at = `${path}.requests[${index}]`;
+            if (!isPlainObject(request)) {
+                into.add("team.request.shape", at, "each request must be an object");
+                return;
+            }
+            if (into.require(isUserId(request.memberId), "team.request.memberId", `${at}.memberId`, "a request names the member asking")) {
+                into.require(request.memberId !== context.self, "team.request.self", `${at}.memberId`, "the team member list carries the reader's own ask: an agent's request for a lead goes to whoever leads them");
+            }
+            if (into.require(isAssignmentId(request.assignmentId), "team.request.assignmentId", `${at}.assignmentId`, "a request names the member's assignment the lead would join")) {
+                const key = `${String(request.memberId)}@${String(request.assignmentId)}`;
+                if (seenRequests.has(key))
+                    into.add("team.request.unique", at, `duplicate request: ${key}`);
+                seenRequests.add(key);
+            }
+            if (request.note !== undefined)
+                into.filled(request.note, "team.request.note", `${at}.note`, "a note must not be empty when present");
+            into.timestamp(request.since, "team.request.since", `${at}.since`);
+        });
     }
     if (!Array.isArray(teamMembers.members)) {
         into.add("team.members.shape", `${path}.members`, "a team member list must carry a members array");
@@ -1659,7 +1646,40 @@ function validateTeamMembersInto(teamMembers, path, context, into) {
                 into.require(member.availability !== "signed-out" && member.availability !== "on-break", "team.member.break.availability", `${at}.break`, "a member on a break or signed out has no request outstanding");
             }
         }
+        // The member's open tasks, as the lead sees them: trimmed by the provider, held to the task rules otherwise.
+        if (member.tasks !== undefined) {
+            if (!Array.isArray(member.tasks)) {
+                into.add("team.member.tasks.shape", `${at}.tasks`, "a member's tasks are an array: [] when they hold none, omitted only where the provider cannot see them");
+            }
+            else {
+                const held = new Set();
+                member.tasks.forEach((task, index) => {
+                    const channel = isPlainObject(task) && typeof task.channel === "string" && isChannel(task.channel) ? task.channel : context.channel ?? "voice";
+                    validateTaskInto(task, { channel, levels: context.levels, member: true }, `${at}.tasks[${index}]`, into);
+                    if (isPlainObject(task) && isAssignmentId(task.assignmentId)) {
+                        if (held.has(task.assignmentId))
+                            into.add("team.member.tasks.unique", `${at}.tasks[${index}].assignmentId`, `duplicate assignment on one member: ${task.assignmentId}`);
+                        held.add(task.assignmentId);
+                    }
+                });
+                into.require(member.availability !== "signed-out" || member.tasks.length === 0, "team.member.tasks.availability", `${at}.tasks`, "a member signed out holds no task");
+            }
+        }
+        // The lead on this member's call, in the mode they are heard.
+        if (member.listening !== undefined) {
+            if (!isPlainObject(member.listening)) {
+                into.add("team.member.listening.shape", `${at}.listening`, "listening must be an object when present");
+            }
+            else {
+                into.oneOf(member.listening.mode, LISTENING_MODES, "team.member.listening.mode", `${at}.listening.mode`);
+                into.timestamp(member.listening.since, "team.member.listening.since", `${at}.listening.since`);
+            }
+        }
     });
+    // One member's call at a time.
+    const listened = teamMembers.members.filter((member) => isPlainObject(member) && member.listening !== undefined);
+    if (listened.length > 1)
+        into.add("team.listening.single", `${path}.members`, "a lead is on one member's call at a time");
 }
 export function validateSnapshot(snapshot, manifest, path = "snapshot", context = {}) {
     const into = new Collector();
@@ -1685,21 +1705,8 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
     }
     else {
         const seen = new Set();
-        let assisting;
-        let listening;
         snapshot.tasks.forEach((task, index) => {
             validateTaskInto(task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), locked: context.locked }, `${path}.tasks[${index}]`, into);
-            // A lead assists one call at a time, and listens to one at a time.
-            if (isPlainObject(task) && task.assisting !== undefined) {
-                if (assisting !== undefined)
-                    into.add("snapshot.assisting.single", `${path}.tasks[${index}].assisting`, "a lead assists one call at a time");
-                assisting = index;
-            }
-            if (isPlainObject(task) && task.listening !== undefined) {
-                if (listening !== undefined)
-                    into.add("snapshot.listening.single", `${path}.tasks[${index}].listening`, "a lead listens to one call at a time");
-                listening = index;
-            }
             if (isPlainObject(task) && isAssignmentId(task.assignmentId)) {
                 if (seen.has(task.assignmentId))
                     into.add("task.assignmentId.unique", `${path}.tasks[${index}].assignmentId`, `duplicate assignment id: ${task.assignmentId}`);
@@ -1707,14 +1714,6 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
             }
         });
     }
-    // A lead listens while holding no work of their own: a listening task is the only task.
-    if (Array.isArray(snapshot.tasks) && snapshot.tasks.length > 1) {
-        snapshot.tasks.forEach((task, index) => {
-            if (isPlainObject(task) && task.listening !== undefined) {
-                into.add("snapshot.listening.alone", `${path}.tasks[${index}].listening`, "a lead listens only while holding no task of their own");
-            }
-        });
-    }
     into.violations.push(...validateBreakStatus(snapshot.break, snapshot.tasks, path));
     // Presence is the permission, and it cuts both ways: data a provider never declared a
     // capability for is data Omni would show against a control the agent does not have.
@@ -1725,8 +1724,8 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
     if (snapshot.contacts === undefined && idle.contacts === true) {
         into.add("snapshot.contacts.required", `${path}.contacts`, "the manifest declares contacts, so every snapshot carries the contribution: [] when there are none");
     }
-    if (snapshot.scheduledActivities === undefined && idle.calendar === true) {
-        into.add("snapshot.calendar.required", `${path}.scheduledActivities`, "the manifest declares calendar, so every snapshot carries the contribution: [] when there are none");
+    if (snapshot.calendar === undefined && idle.calendar === true) {
+        into.add("snapshot.calendar.required", `${path}.calendar`, "the manifest declares calendar, so every snapshot carries the contribution: [] when there are none");
     }
     if (snapshot.contacts !== undefined) {
         into.require(idle.contacts === true, "snapshot.contacts.capability", `${path}.contacts`, "contacts require the contacts idle capability");
@@ -1737,31 +1736,35 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
             into.add("snapshot.contacts.shape", `${path}.contacts`, "contacts must be an array when present");
         }
     }
-    if (snapshot.scheduledActivities !== undefined) {
-        into.require(idle.calendar === true, "snapshot.calendar.capability", `${path}.scheduledActivities`, "scheduled activities require the calendar idle capability");
-        if (Array.isArray(snapshot.scheduledActivities)) {
+    if (snapshot.calendar !== undefined) {
+        into.require(idle.calendar === true, "snapshot.calendar.capability", `${path}.calendar`, "scheduled activities require the calendar idle capability");
+        if (Array.isArray(snapshot.calendar)) {
             const seen = new Set();
-            snapshot.scheduledActivities.forEach((activity, index) => {
-                validateScheduledActivityInto(activity, `${path}.scheduledActivities[${index}]`, into, levels);
+            snapshot.calendar.forEach((activity, index) => {
+                validateScheduledActivityInto(activity, `${path}.calendar[${index}]`, into, levels);
                 if (isPlainObject(activity) && isFilled(activity.id)) {
                     if (seen.has(activity.id)) {
-                        into.add("activity.id.unique", `${path}.scheduledActivities[${index}].id`, `duplicate activity id: ${activity.id}`);
+                        into.add("activity.id.unique", `${path}.calendar[${index}].id`, `duplicate activity id: ${activity.id}`);
                     }
                     seen.add(activity.id);
                 }
             });
         }
         else {
-            into.add("snapshot.calendar.shape", `${path}.scheduledActivities`, "scheduledActivities must be an array when present");
+            into.add("snapshot.calendar.shape", `${path}.calendar`, "calendar must be an array when present");
         }
     }
-    // The login is the permission: a lead's snapshot carries a team member list, `[]` included. The other
-    // direction -- a team member list to a login that does not lead -- is the team member list's own rule.
-    if (context.capabilities?.team !== undefined && snapshot.team === undefined) {
-        into.add("team.required", `${path}.team`, "the login declares capabilities.team, so every snapshot carries a team member list: [] when nobody is in it");
+    // The login is the permission: a lead's snapshot carries a team member list, `members: []` included,
+    // while the team feature is on. The other direction -- a team member list to a login that does
+    // not lead, or to a lead who turned the feature off -- is the team member list's own rule.
+    if (context.capabilities?.lead === true && context.leadFeatures !== false && snapshot.team === undefined) {
+        into.add("team.required", `${path}.team`, "the login declares lead and the team feature is on, so every snapshot carries a team member list: members: [] when nobody is in it");
+    }
+    if (context.leadFeatures === false && snapshot.team !== undefined) {
+        into.add("team.unexpected", `${path}.team`, "the lead turned the team feature off, so nothing of the team reaches them");
     }
     if (snapshot.team !== undefined)
-        validateTeamMembersInto(snapshot.team, `${path}.team`, { ...context, levels }, into);
+        validateTeamMembersInto(snapshot.team, `${path}.team`, { ...context, levels, channel: isChannel(channel) ? channel : undefined }, into);
     return into.violations;
 }
 // ---------------------------------------------------------------------------
@@ -1797,8 +1800,6 @@ function validateTaskOutcome(value, path, into) {
             // Only the phases in which a task is still waiting on somebody can expire.
             into.oneOf(value.phase, EXPIRABLE_PHASES, "event.taskEnded.outcome.expired", `${path}.phase`);
             break;
-        case "left":
-            break;
         case "failed":
             if (!isPlainObject(value.failure)) {
                 into.add("event.taskEnded.outcome.failed", `${path}.failure`, "a failed outcome must carry a failure");
@@ -1902,13 +1903,13 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
         case "task-updated":
             validateTaskInto(event.task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), locked: context.locked }, `${at}.task`, into);
             break;
-        case "task-media-started":
-            into.require(channel === "voice", "event.media.channel", `${at}.type`, "only a voice provider publishes media transitions");
-            into.require(isAssignmentId(event.assignmentId), "event.taskMediaStarted.assignmentId", `${at}.assignmentId`, "an event about a task names its assignment");
+        case "task-audio-started":
+            into.require(channel === "voice", "event.audio.channel", `${at}.type`, "only a voice provider publishes audio transitions");
+            into.require(isAssignmentId(event.assignmentId), "event.taskAudioStarted.assignmentId", `${at}.assignmentId`, "an event about a task names its assignment");
             break;
-        case "task-media-ended":
-            into.require(channel === "voice", "event.media.channel", `${at}.type`, "only a voice provider publishes media transitions");
-            into.require(isAssignmentId(event.assignmentId), "event.taskMediaEnded.assignmentId", `${at}.assignmentId`, "an event about a task names its assignment");
+        case "task-audio-ended":
+            into.require(channel === "voice", "event.audio.channel", `${at}.type`, "only a voice provider publishes audio transitions");
+            into.require(isAssignmentId(event.assignmentId), "event.taskAudioEnded.assignmentId", `${at}.assignmentId`, "an event about a task names its assignment");
             break;
         case "task-ended":
             into.require(isAssignmentId(event.assignmentId), "event.taskEnded.assignmentId", `${at}.assignmentId`, "an event about a task names its assignment");
@@ -1948,7 +1949,17 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
             validateQueueSummary(event.summary, `${at}.summary`, into);
             break;
         case "team-updated":
-            validateTeamMembersInto(event.team, `${at}.team`, { ...context, levels }, into);
+            into.require(context.capabilities === undefined || context.capabilities.lead === true, "event.team.capability", `${at}.team`, "team-updated reaches a login that declares lead, and nobody else");
+            into.require(context.leadFeatures !== false, "event.team.features", `${at}.team`, "the lead turned the team feature off, so nothing of the team reaches them");
+            validateTeamMembersInto(event.team, `${at}.team`, { ...context, levels, channel: isChannel(channel) ? channel : undefined }, into);
+            break;
+        case "team-audio-started":
+        case "team-audio-ended":
+            // The lead's channel in a member's call: audio the application opens on the member's assignment.
+            into.require(channel === "voice", "event.audio.channel", `${at}.type`, "only a voice provider publishes audio transitions");
+            into.require(context.capabilities === undefined || context.capabilities.lead === true, "event.teamAudio.capability", `${at}.type`, "team audio reaches a login that declares lead, and nobody else");
+            into.require(isUserId(event.memberId), "event.teamAudio.memberId", `${at}.memberId`, "team audio names the member whose call the lead is on");
+            into.require(isAssignmentId(event.assignmentId), "event.teamAudio.assignmentId", `${at}.assignmentId`, "team audio names the member's assignment");
             break;
         case "contacts-updated":
             into.require(idle.contacts === true, "event.contacts.capability", `${at}.contacts`, "contacts-updated requires the contacts idle capability");
@@ -1960,17 +1971,17 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
             }
             break;
         case "calendar-updated":
-            into.require(idle.calendar === true, "event.calendar.capability", `${at}.scheduledActivities`, "calendar-updated requires the calendar idle capability");
-            if (!Array.isArray(event.scheduledActivities)) {
-                into.add("event.calendar.shape", `${at}.scheduledActivities`, "scheduledActivities must be an array");
+            into.require(idle.calendar === true, "event.calendar.capability", `${at}.calendar`, "calendar-updated requires the calendar idle capability");
+            if (!Array.isArray(event.calendar)) {
+                into.add("event.calendar.shape", `${at}.calendar`, "calendar must be an array");
             }
             else {
                 const ids = new Set();
-                event.scheduledActivities.forEach((activity, index) => {
-                    validateScheduledActivityInto(activity, `${at}.scheduledActivities[${index}]`, into, levels);
+                event.calendar.forEach((activity, index) => {
+                    validateScheduledActivityInto(activity, `${at}.calendar[${index}]`, into, levels);
                     if (isPlainObject(activity) && isFilled(activity.id)) {
                         if (ids.has(activity.id))
-                            into.add("activity.id.unique", `${at}.scheduledActivities[${index}].id`, `duplicate activity id: ${activity.id}`);
+                            into.add("activity.id.unique", `${at}.calendar[${index}].id`, `duplicate activity id: ${activity.id}`);
                         ids.add(activity.id);
                     }
                 });
@@ -2236,7 +2247,7 @@ export function validateHostReport(report, path = "host") {
 // Commands.
 // ---------------------------------------------------------------------------
 const TRANSFER_ACTIONS = ["cold", "warm", "complete", "cancel"];
-const LEAD_ASSIST_ACTIONS = ["request", "cancel", "take-over-call", "leave"];
+const LEAD_ASSIST_ACTIONS = ["request", "cancel"];
 const CONFERENCE_ACTIONS = ["add", "remove"];
 /** Validate the exact interaction/assignment target before provider command dispatch. */
 export function validateTaskCommandRequest(request, task, path = "request", taskContext) {
@@ -2282,7 +2293,7 @@ export function validateTaskCommand(command, task, path = "command", taskContext
     if (type !== "custom" && type !== "recording") {
         let fields = ["type"];
         switch (type) {
-            case "call":
+            case "dial":
             case "connect-back":
                 fields.push("dialId");
                 break;
@@ -2309,8 +2320,8 @@ export function validateTaskCommand(command, task, path = "command", taskContext
     }
     const dial = (rule) => into.filled(command.dialId, rule, `${path}.dialId`, "a command that dials carries the host's dialId");
     switch (type) {
-        case "call":
-            dial("command.call.dialId");
+        case "dial":
+            dial("command.dial.dialId");
             break;
         case "connect-back":
             dial("command.connectBack.dialId");
@@ -2422,7 +2433,7 @@ export function validateTaskCommand(command, task, path = "command", taskContext
             if (type === "decline")
                 offered("decline");
             break;
-        case "call":
+        case "dial":
             inPhase("command.phase.preview", "preview");
             break;
         case "hold":
@@ -2435,6 +2446,10 @@ export function validateTaskCommand(command, task, path = "command", taskContext
             offered("endCall");
             interaction();
             break;
+        case "terminate-call":
+            offered("terminateCall");
+            interaction();
+            break;
         case "recording": {
             if (!offered("recording"))
                 break;
@@ -2443,7 +2458,7 @@ export function validateTaskCommand(command, task, path = "command", taskContext
             into.violations.push(...validateRecordingCommandState(command, policy, state, path));
             if (command.action === "start" || command.action === "resume") {
                 interaction();
-                into.require(task.media === "started", "recording.request.phase", path, "capture needs live media");
+                into.require(task.audio === "started", "recording.request.phase", path, "capture needs live audio");
             }
             else
                 inPhase("command.phase.interaction", "in-progress", "paused", "completing");
@@ -2469,14 +2484,9 @@ export function validateTaskCommand(command, task, path = "command", taskContext
             break;
         case "lead-assist":
             interaction();
-            if (command.action === "request" || command.action === "cancel") {
-                offered("leadAssist");
-                if (command.action === "cancel") {
-                    into.require(isPlainObject(task.leadAssist) && task.leadAssist.stage === "requested", "command.leadAssist.requested", path, "cancel needs a request standing: leadAssist with stage requested");
-                }
-            }
-            else {
-                into.require(task.assisting !== undefined, "command.leadAssist.assisting", path, `${describeValue(command.action)} is the lead's own act on a call they joined: the task carries assisting`);
+            offered("leadAssist");
+            if (command.action === "cancel") {
+                into.require(isPlainObject(task.leadAssist) && task.leadAssist.stage === "requested", "command.leadAssist.requested", path, "cancel needs a request standing: leadAssist with stage requested");
             }
             break;
         case "conference": {
@@ -2540,13 +2550,10 @@ const RESULT_STATUSES = {
     commitBreak: { success: "committed", failure: "failed" },
     cancelBreak: { success: "cancelled", failure: "failed" },
     endBreak: { success: "ended", failure: "failed" },
-    executeTeamBreak: { success: "applied", failure: "failed" },
-    executeTeamLeadAssist: { success: "applied", failure: "failed" },
-    executeTeamListen: { success: "applied", failure: "failed" },
-    openMedia: { success: "opened", failure: "unavailable" },
+    executeTeam: { success: "applied", failure: "failed" },
+    openAudio: { success: "opened", failure: "unavailable" },
     setPreference: { success: "applied", failure: "failed" },
     recordStep: { success: "recorded", failure: "failed" },
-    executeTeamPolicy: { success: "applied", failure: "failed" },
 };
 /**
  * Validates what a connection method answered. A result is untrusted for the same reason a
@@ -2564,22 +2571,22 @@ export function validateResult(result, method, path = "result", dialId) {
         into.add("result.shape", path, `${method} must answer an object`);
         return into.violations;
     }
-    if (method === "openMedia" && result.status !== "opened") {
-        into.require(result.session === undefined, "result.session.unexpected", `${path}.session`, "only opened carries a media session");
+    if (method === "openAudio" && result.status !== "opened") {
+        into.require(result.audio === undefined, "result.audio.unexpected", `${path}.audio`, "only opened carries an audio session");
     }
     if (result.status === statuses.success) {
         into.require(result.failure === undefined, "result.failure.unexpected", `${path}.failure`, `${statuses.success} carries no failure`);
-        if (method === "openMedia") {
-            if (isPlainObject(result.session)) {
+        if (method === "openAudio") {
+            if (isPlainObject(result.audio)) {
                 // Streams may come from another realm, and Node conformance runs have no MediaStream
                 // constructor. Check the boundary shape without claiming to verify live audio.
-                into.require(isPlainObject(result.session.remoteAudio), "result.session.remoteAudio", `${path}.session.remoteAudio`, "an opened session carries its remote audio stream");
+                into.require(isPlainObject(result.audio.remoteAudio), "result.audio.remoteAudio", `${path}.audio.remoteAudio`, "an opened session carries its remote audio stream");
                 for (const method of ["setMuted", "close"]) {
-                    into.require(typeof result.session[method] === "function", `result.session.${method}`, `${path}.session.${method}`, `a media session implements ${method}`);
+                    into.require(typeof result.audio[method] === "function", `result.audio.${method}`, `${path}.audio.${method}`, `an audio session implements ${method}`);
                 }
             }
             else {
-                into.add("result.session", `${path}.session`, "opened carries the media session");
+                into.add("result.audio", `${path}.audio`, "opened carries the audio session");
             }
         }
         if (dials) {
@@ -2683,43 +2690,9 @@ function validateUserCapabilitiesInto(value, path, into, levels) {
             validatePreferencesInto(declared, `${path}.preferences`, into, levels);
             continue;
         }
-        if (name === "team") {
-            if (!isPlainObject(declared)) {
-                into.add("authentication.capability.team.shape", `${path}.team`, "team names what the lead may do: an object, {} for a lead with no controls");
-                continue;
-            }
-            for (const [control, on] of Object.entries(declared)) {
-                if (on === undefined)
-                    continue;
-                if (!into.require(TEAM_CAPABILITIES.includes(control), "authentication.capability.team.unknown", `${path}.team.${control}`, `unsupported team capability: ${control}`))
-                    continue;
-                if (control === "listeningControl") {
-                    validateListeningControl(on, `${path}.team.listeningControl`, into);
-                    continue;
-                }
-                into.require(on === true, "authentication.capability.value", `${path}.team.${control}`, `${control} is declared by presence: send true or omit it`);
-            }
-            continue;
-        }
         into.require(declared === true, "authentication.capability.value", `${path}.${name}`, `${name} is declared by presence: send true or omit it`);
     }
 }
-/**
- * The modes a lead may listen in, as a list: coach and join-call begin with silent listening, so a list
- * without `listen` names modes the lead could never reach.
- */
-function validateListeningControl(value, path, into) {
-    if (!Array.isArray(value) || value.length === 0) {
-        into.add("authentication.capability.team.listeningControl.shape", path, "listeningControl lists the modes this lead may listen in: a non-empty array, or omitted for a lead who may not");
-        return;
-    }
-    value.forEach((mode, index) => {
-        if (into.oneOf(mode, LISTENING_MODES, "authentication.capability.team.listeningControl.mode", `${path}[${index}]`) && value.indexOf(mode) !== index) {
-            into.add("authentication.capability.team.listeningControl.unique", `${path}[${index}]`, `duplicate listen mode: ${describeValue(mode)}`);
-        }
-    });
-    into.require(value.includes("listen"), "authentication.capability.team.listeningControl.listen", path, "coach and join-call begin with silent listening: a lead who may listen in any mode may listen");
-}
 /**
  * A failure an authentication reports: on a `rejected` start or completion, or on an `expired`
  * state. A provider names its own codes freely; an `omni.` code is the contract's and has to be one
@@ -2920,7 +2893,7 @@ export function validateRecordingPolicy(value, path = "capabilities.recording")
             check(false, "policy.shape", at, "expected permitted actions");
             continue;
         }
-        keys(policy, [...RECORDING_ACTIONS, ...(source === "host" ? ["destinationId"] : [])], at);
+        keys(policy, [...RECORDING_ACTIONS, ...(source === "host" ? ["storageId"] : [])], at);
         check(RECORDING_ACTIONS.some(action => policy[action] !== undefined), "policy.empty", at, "omit paths offering no actions");
         for (const action of RECORDING_ACTIONS) {
             if (policy[action] === undefined)
@@ -2928,7 +2901,7 @@ export function validateRecordingPolicy(value, path = "capabilities.recording")
             check(policy[action] === true, "policy.action", `${at}.${action}`, "permission is true or absent");
         }
         if (source === "host")
-            check(filled(policy.destinationId), "destination", `${at}.destinationId`, "host storage destination must be explicit per task");
+            check(filled(policy.storageId), "storage", `${at}.storageId`, "host storage must be named per task");
     }
     return violations;
 }
@@ -2936,15 +2909,15 @@ export function validateHostRecording(value, softphone, path = "host.recording")
     if (value === undefined)
         return [];
     const { violations, check, keys } = collector();
-    check(softphone, "host.channel", path, "initial host recording requires voice softphone media");
+    check(softphone, "host.channel", path, "initial host recording requires voice softphone audio");
     if (!object(value)) {
         check(false, "host.shape", path, "expected host recording declaration and executor");
         return violations;
     }
-    keys(value, ["actions", "destinationIds", "execute", "announcesToCaller"], path);
+    keys(value, ["actions", "storageIds", "execute", "announcesToCaller"], path);
     if (value.announcesToCaller !== undefined)
         check(value.announcesToCaller === true, "host.announcesToCaller", `${path}.announcesToCaller`, "caller announcement guarantee is true or absent");
-    for (const [key, allowed] of [["actions", RECORDING_ACTIONS], ["destinationIds", undefined]]) {
+    for (const [key, allowed] of [["actions", RECORDING_ACTIONS], ["storageIds", undefined]]) {
         const list = value[key];
         if (!Array.isArray(list)) {
             check(false, "host.list", `${path}.${key}`, "expected explicit array");
@@ -3060,14 +3033,14 @@ export function validateRecordingRequest(request, task, context, path = "request
         state = Array.isArray(reports) ? reports.find(r => object(r) && r.assignmentId === task.assignmentId)?.state : undefined;
         if (object(context.host)) {
             check(Array.isArray(context.host.actions) && context.host.actions.includes(command.action), "host.action", path, "host does not support action");
-            check(object(policy) && Array.isArray(context.host.destinationIds) && context.host.destinationIds.includes(policy.destinationId), "host.destination", path, "task destination is not provisioned by this host");
+            check(object(policy) && Array.isArray(context.host.storageIds) && context.host.storageIds.includes(policy.storageId), "host.storage", path, "task storage is not one this host provisions");
         }
     }
     const fresh = effectiveRecordingState(state, context.now);
     check(fresh.status !== "unknown", "request.freshness", path, "current state or trusted observer time unavailable/expired");
     violations.push(...validateRecordingCommandState(command, policy, fresh, `${path}.command`));
     const opening = command.action === "start" || command.action === "resume";
-    check(opening ? ["in-progress", "paused"].includes(task.phase) && task.media === "started" : ["in-progress", "paused", "completing"].includes(task.phase), "request.phase", path, "capture needs live task media; terminal controls may finish recordings during wrap-up");
+    check(opening ? ["in-progress", "paused"].includes(task.phase) && task.audio === "started" : ["in-progress", "paused", "completing"].includes(task.phase), "request.phase", path, "capture needs live task audio; terminal controls may finish recordings during wrap-up");
     return violations;
 }
 /** Check recording-specific result semantics against the owner's confirming observations. */