@xema/omni-protocol 0.1.100 → 0.1.102

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, 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, SHIFT_EVENT_KINDS, 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") {
@@ -71,10 +71,10 @@ const DIAL_DESTINATION_POLICIES = membersOf({ "contacts-only": true, "any-number
 const DIAL_OUTCOMES = membersOf({ answered: true, busy: true, "no-answer": true, unreachable: true, rejected: true, cancelled: true, unexplained: true });
 /** The outcomes that name a cause. `unexplained` is declarable only beside one of these. */
 const EXPLAINED_FAILURES = ["busy", "no-answer", "unreachable", "rejected", "cancelled"];
-const ON_CALL_ROLES = membersOf({ party: true, agent: true, consulted: true, conferenced: true });
+const ON_CALL_ROLES = membersOf({ party: true, agent: true, conferenced: true });
 const ON_CALL_STAGES = membersOf({ ringing: true, joined: true });
 /** The task capabilities under which a command dials, and so need the manifest to say how a dial ends. */
-const DIALLING_CAPABILITIES = ["connectBack", "coldTransfer", "warmTransfer", "conference"];
+const DIALLING_CAPABILITIES = ["connectBack", "conference"];
 const SNAPSHOT_REASONS = membersOf({
     reconnected: true, "provider-requested": true,
 });
@@ -98,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, terminateCall: true, connectBack: true, coldTransfer: true, warmTransfer: true, leadAssist: true, conference: true, recording: true,
+        endCall: true, terminateCall: true, connectBack: true, schedule: 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 }),
@@ -579,7 +579,7 @@ export function validateManifest(manifest, path = "manifest") {
 // ---------------------------------------------------------------------------
 function validateDestinationDirectory(value, path, into) {
     if (!isPlainObject(value)) {
-        into.add("task.destinations.shape", path, "a transfer or conference control carries the directory it offers: { destinations: [...] }");
+        into.add("task.destinations.shape", path, "a conference control carries the directory it offers: { destinations: [...] }");
         return;
     }
     if (!Array.isArray(value.destinations)) {
@@ -982,7 +982,7 @@ const WORK_NOT_BEGUN = ["pending", "confirmed", "preview"];
 /**
  * Who is on the call, as the provider states it. Voice only. Each entry is a role with what that
  * role needs and nothing another role would: a party or an agent dialled nowhere, so neither
- * carries a destination; somebody consulted or conferenced came from one, so both do.
+ * carries a destination; somebody conferenced came from one, so they do.
  */
 function validateOnCall(value, channel, path, into) {
     if (value === undefined)
@@ -993,7 +993,7 @@ function validateOnCall(value, channel, path, into) {
         into.add("task.onCall.shape", path, "onCall is an array of who is on the call, when the provider knows");
         return;
     }
-    const counted = { party: 0, consulted: 0 };
+    let parties = 0;
     value.forEach((entry, index) => {
         const at = `${path}[${index}]`;
         if (!isPlainObject(entry)) {
@@ -1007,15 +1007,15 @@ function validateOnCall(value, channel, path, into) {
         if (entry.held !== undefined) {
             into.require(entry.held === true, "task.onCall.held", `${at}.held`, "held is stated by presence: send true or omit it");
         }
-        if (role === "party" || role === "consulted")
-            counted[role] += 1;
+        if (role === "party")
+            parties += 1;
         if (role === "agent") {
             into.require(isUserId(entry.userId), "task.onCall.userId", `${at}.userId`, "an agent on the call is named by their user id");
         }
         else {
             into.require(entry.userId === undefined, "task.onCall.userId.unexpected", `${at}.userId`, `a ${role} is not named by a user id`);
         }
-        if (role === "consulted" || role === "conferenced") {
+        if (role === "conferenced") {
             into.filled(entry.destinationId, "task.onCall.destinationId", `${at}.destinationId`, `a ${role} entry names the directory item that was dialled`);
             // Stated, so a snapshot says who is present without anyone having seen the dial's outcome.
             if (into.oneOf(entry.stage, ON_CALL_STAGES, "task.onCall.stage", `${at}.stage`)) {
@@ -1037,17 +1037,16 @@ function validateOnCall(value, channel, path, into) {
                 into.require(!(entry.stage === "ringing" && entry.held === true), "task.onCall.held.ringing", `${at}.held`, "nobody ringing is held; held belongs to somebody who has joined");
             }
             for (const field of ["destinationId", "label"]) {
-                into.require(entry[field] === undefined, `task.onCall.${field}.unexpected`, `${at}.${field}`, `a party is not a directory item; ${field} belongs on consulted or conferenced`);
+                into.require(entry[field] === undefined, `task.onCall.${field}.unexpected`, `${at}.${field}`, `a party is not a directory item; ${field} belongs on conferenced`);
             }
         }
         else {
             for (const field of ["destinationId", "dialId", "label", "stage"]) {
-                into.require(entry[field] === undefined, `task.onCall.${field}.unexpected`, `${at}.${field}`, role === "party" ? `a party carries ${field} on a connect-back alone, with its dial and stage together` : `a ${role} was dialled from nowhere; ${field} belongs on consulted or conferenced`);
+                into.require(entry[field] === undefined, `task.onCall.${field}.unexpected`, `${at}.${field}`, role === "party" ? `a party carries ${field} on a connect-back alone, with its dial and stage together` : `a ${role} was dialled from nowhere; ${field} belongs on conferenced`);
             }
         }
     });
-    into.require(counted.party <= 1, "task.onCall.party.single", path, "a call has one party; a second is somebody else's role");
-    into.require(counted.consulted <= 1, "task.onCall.consulted.single", path, "one consultation at a time: transfer complete and cancel name no destination because there is exactly one");
+    into.require(parties <= 1, "task.onCall.party.single", path, "a call has one party; a second is somebody else's role");
 }
 const LEAD_STAGES = membersOf({ requested: true, joined: true });
 /** The agent's request for a lead. Voice only; `joined` names the lead, `requested` cannot. */
@@ -1122,13 +1121,13 @@ function validateTaskInto(task, context, path, into) {
         into.require(context.dialOutcomesDeclared !== false, "task.preview.dialOutcomes.required", `${path}.phase`, "a preview ends in the agent pressing Call, which dials, and the manifest declares no dialOutcomes to say how a dial ends");
     }
     // The deadline and what happens at it travel together, and only while the record is being previewed.
-    if (task.previewEndsAt !== undefined || task.atDeadline !== undefined) {
-        into.require(task.phase === "preview", "task.preview.deadline.unexpected", `${path}.previewEndsAt`, "previewEndsAt and atDeadline belong to a task in preview; past it there is nothing to wait for");
-        if (task.previewEndsAt === undefined) {
-            into.add("task.preview.previewEndsAt.required", `${path}.previewEndsAt`, "atDeadline says what happens at a deadline, so there has to be one");
+    if (task.previewEndsInSeconds !== undefined || task.atDeadline !== undefined) {
+        into.require(task.phase === "preview", "task.preview.deadline.unexpected", `${path}.previewEndsInSeconds`, "previewEndsInSeconds and atDeadline belong to a task in preview; past it there is nothing to wait for");
+        if (task.previewEndsInSeconds === undefined) {
+            into.add("task.preview.previewEndsInSeconds.required", `${path}.previewEndsInSeconds`, "atDeadline says what happens at a deadline, so there has to be one");
         }
         else {
-            into.timestamp(task.previewEndsAt, "task.preview.previewEndsAt", `${path}.previewEndsAt`);
+            into.require(isDurationSeconds(task.previewEndsInSeconds), "task.preview.previewEndsInSeconds", `${path}.previewEndsInSeconds`, "previewEndsInSeconds is how long the preview has left: a whole number of seconds, zero or more, counted from this publication");
         }
         if (task.atDeadline === undefined) {
             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");
@@ -1235,6 +1234,14 @@ function validateTaskInto(task, context, path, into) {
     if (capabilities.browsers === true && Array.isArray(task.browsers) && task.browsers.length === 0) {
         into.add("task.browsers.required", `${path}.browsers`, "a task that declares capabilities.browsers supplies at least one; with none, omit the capability");
     }
+    // An outcome is given in wrap, by the agent: a provider that completes the task itself cannot
+    // wait for one, and a task with no wrap has nowhere to take one.
+    if (isPlainObject(capabilities.outcomes) && capabilities.outcomes.required === true) {
+        into.require(task.completionMode !== "provider-automatic", "task.outcomes.required.mode", `${path}.capabilities.outcomes.required`, "a required outcome is the agent's to give, so the task completes on the agent's command; provider-automatic completion cannot wait for it");
+    }
+    if (capabilities.outcomes !== undefined) {
+        into.require(task.wrapAllowance !== 0, "task.outcomes.wrapAllowance", `${path}.capabilities.outcomes`, "outcomes are collected in wrap, and wrapAllowance 0 gives none: publish a wrap or no outcomes");
+    }
     for (const [name, declared] of Object.entries(capabilities)) {
         if (declared === undefined)
             continue;
@@ -1267,8 +1274,6 @@ function validateTaskInto(task, context, path, into) {
             case "custom":
                 validateCustomCapabilities(declared, `${path}.capabilities.custom`, into);
                 break;
-            case "coldTransfer":
-            case "warmTransfer":
             case "conference":
                 validateDestinationDirectory(declared, `${path}.capabilities.${name}`, into);
                 break;
@@ -1287,7 +1292,7 @@ function validateForcedBreak(value, path, into) {
         into.add("break.forced.shape", path, "a forced break must be an object");
         return;
     }
-    into.require(isUserId(value.by), "break.forced.by", `${path}.by`, "a forced break must say who forced it");
+    into.require(isUserId(value.by) || value.by === "provider", "break.forced.by", `${path}.by`, "a forced break says who forced it: the lead by user id, or provider where the platform did");
     for (const field of ["endsAutomatically", "endsAt"]) {
         into.require(!Object.hasOwn(value, field), "break.forced.manualResume", `${path}.${field}`, "automatic ending fields are unsupported; the agent must resume manually");
     }
@@ -1406,9 +1411,8 @@ export function validateTeamCommand(request, context, path = "teamCommand") {
         }
     }
     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`);
+        const asked = isPlainObject(target) && isPlainObject(target.request) ? target.request : undefined;
+        into.require(asked !== undefined && (command.assignmentId === undefined || asked.assignmentId === command.assignmentId), "team.command.request", path, `${command.type} answers a request the team member list carries on the member, 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`);
@@ -1593,32 +1597,6 @@ function validateTeamMembersInto(teamMembers, path, context, into) {
     // 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);
-    // 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 {
-        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");
         return;
@@ -1626,61 +1604,94 @@ function validateTeamMembersInto(teamMembers, path, context, into) {
     const seen = new Set();
     teamMembers.members.forEach((member, index) => {
         const at = `${path}.members[${index}]`;
-        if (!isPlainObject(member)) {
-            into.add("team.member.shape", at, "each team member must be an object");
-            return;
-        }
-        if (into.require(isUserId(member.id), "team.member.id", `${at}.id`, "a team member needs a user id")) {
+        if (isPlainObject(member) && isUserId(member.id)) {
             if (seen.has(member.id))
                 into.add("team.member.unique", `${at}.id`, `duplicate team member: ${member.id}`);
             seen.add(member.id);
-            into.require(member.id !== context.self, "team.member.self", `${at}.id`, "the team member list carries the agent it is published to: a lead does not report to themself");
-        }
-        into.oneOf(member.availability, TEAM_AVAILABILITIES, "team.member.availability", `${at}.availability`);
-        if (member.since !== undefined)
-            into.timestamp(member.since, "team.member.since", `${at}.since`);
-        if (member.break !== undefined) {
-            // Only an outstanding request appears here: `not-requested` is absence, `on-break` is
-            // `availability: "on-break"`, and a denial never survives to be reported.
-            if (into.oneOf(member.break, MEMBER_BREAKS, "team.member.break", `${at}.break`)) {
-                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`);
-            }
         }
+        validateTeamMemberInto(member, at, context, into);
     });
     // 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");
 }
+/** One member as the lead sees them, whole: on the list, and on `team-member-updated` alone. */
+export function validateTeamMember(member, path = "member", context = {}) {
+    const into = new Collector();
+    validateTeamMemberInto(member, path, context, into);
+    return into.violations;
+}
+function validateTeamMemberInto(member, at, context, into) {
+    if (!isPlainObject(member)) {
+        into.add("team.member.shape", at, "each team member must be an object");
+        return;
+    }
+    if (into.require(isUserId(member.id), "team.member.id", `${at}.id`, "a team member needs a user id")) {
+        into.require(member.id !== context.self, "team.member.self", `${at}.id`, "the team member list carries the agent it is published to: a lead does not report to themself");
+    }
+    into.oneOf(member.availability, TEAM_AVAILABILITIES, "team.member.availability", `${at}.availability`);
+    if (member.since !== undefined)
+        into.timestamp(member.since, "team.member.since", `${at}.since`);
+    if (member.break !== undefined) {
+        // Only an outstanding request appears here: `not-requested` is absence, `on-break` is
+        // `availability: "on-break"`, and a denial never survives to be reported.
+        if (into.oneOf(member.break, MEMBER_BREAKS, "team.member.break", `${at}.break`)) {
+            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 {
+            const listened = member.listening;
+            if (into.require(isAssignmentId(member.listening.assignmentId), "team.member.listening.assignmentId", `${at}.listening.assignmentId`, "listening names which of the member's calls the lead is on: the application opens the lead's audio on it") && Array.isArray(member.tasks)) {
+                into.require(member.tasks.some((task) => isPlainObject(task) && task.assignmentId === listened.assignmentId), "team.member.listening.assignment", `${at}.listening.assignmentId`, "the call the lead is on is one the member's tasks carry");
+            }
+            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`);
+        }
+    }
+    // The member's own history for the day: about the person, not any one call.
+    if (member.shift !== undefined)
+        validateShiftInto(member.shift, `${at}.shift`, into);
+    // The member's standing ask for a lead, on one of the calls they hold.
+    if (member.request !== undefined) {
+        if (!isPlainObject(member.request)) {
+            into.add("team.member.request.shape", `${at}.request`, "request must be an object when present");
+        }
+        else {
+            const asked = member.request;
+            if (into.require(isAssignmentId(asked.assignmentId), "team.member.request.assignmentId", `${at}.request.assignmentId`, "a request names the member's assignment the lead would join") && Array.isArray(member.tasks)) {
+                into.require(member.tasks.some((task) => isPlainObject(task) && task.assignmentId === asked.assignmentId), "team.member.request.assignment", `${at}.request.assignmentId`, "the call the member asks a lead onto is one their tasks carry");
+            }
+            if (asked.note !== undefined)
+                into.filled(asked.note, "team.member.request.note", `${at}.request.note`, "a note must not be empty when present");
+            into.timestamp(asked.since, "team.member.request.since", `${at}.request.since`);
+        }
+    }
+}
 export function validateSnapshot(snapshot, manifest, path = "snapshot", context = {}) {
     const into = new Collector();
     if (!isPlainObject(snapshot)) {
@@ -1754,14 +1765,15 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
             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, `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");
+    // The switch is the permission: once the application has said the team feature is on, a
+    // snapshot carries the team, `members: []` included. Before it has said, the provider assumes
+    // nothing and owes nothing. 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.leadFeatures === true && snapshot.team === undefined) {
+        into.add("team.required", `${path}.team`, "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");
+        into.add("team.unexpected", `${path}.team`, "the team feature is not on for this lead: nothing of the team reaches them until the application switches it on, and nothing after it switches it off");
     }
     if (snapshot.team !== undefined)
         validateTeamMembersInto(snapshot.team, `${path}.team`, { ...context, levels, channel: isChannel(channel) ? channel : undefined }, into);
@@ -1779,11 +1791,6 @@ function validateTaskOutcome(value, path, into) {
         case "completed":
             into.oneOf(value.by, COMPLETED_BY, "event.taskEnded.outcome.completed", `${path}.by`);
             break;
-        case "transferred":
-            if (value.destinationId !== undefined) {
-                into.filled(value.destinationId, "event.taskEnded.outcome.transferred", `${path}.destinationId`, "a destinationId must not be empty when present");
-            }
-            break;
         case "taken-over":
             // A lead is not a directory item: the ending names the lead, and the host resolves the name.
             into.require(isUserId(value.leadId), "event.taskEnded.outcome.takenOver", `${path}.leadId`, "a take-over names the lead who took the call, by user id");
@@ -1897,8 +1904,8 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
             if (isPlainObject(event.task) && typeof event.task.phase === "string") {
                 into.require(OFFERABLE_PHASES.includes(event.task.phase), "event.taskOffered.phase", `${at}.task.phase`, `task-offered introduces a task as ${OFFERABLE_PHASES.join(", ")}, never as ${event.task.phase}`);
             }
-            if (event.assignmentExpiresAt !== undefined)
-                into.timestamp(event.assignmentExpiresAt, "event.taskOffered.assignmentExpiresAt", `${at}.assignmentExpiresAt`);
+            if (event.expiresInSeconds !== undefined)
+                into.require(isDurationSeconds(event.expiresInSeconds), "event.taskOffered.expiresInSeconds", `${at}.expiresInSeconds`, "expiresInSeconds is how long the offer stands: a whole number of seconds, zero or more, counted from this event");
             break;
         case "task-updated":
             validateTaskInto(event.task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), locked: context.locked }, `${at}.task`, into);
@@ -1949,18 +1956,26 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
             validateQueueSummary(event.summary, `${at}.summary`, into);
             break;
         case "team-updated":
-            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");
+        case "team-member-updated":
+        case "team-member-removed":
+        case "team-policies-updated": {
+            const field = event.type === "team-updated" ? "team" : event.type === "team-member-updated" ? "member" : event.type === "team-member-removed" ? "memberId" : "policies";
+            into.require(context.capabilities === undefined || context.capabilities.lead === true, "event.team.capability", `${at}.${field}`, `${event.type} reaches a login that declares lead, and nobody else`);
+            into.require(context.leadFeatures !== false, "event.team.features", `${at}.${field}`, "the team feature is not on for this lead: nothing of the team reaches them until the application switches it on, and nothing after it switches it off");
+            const teamContext = { ...context, levels, channel: isChannel(channel) ? channel : undefined };
+            if (event.type === "team-updated")
+                validateTeamMembersInto(event.team, `${at}.team`, teamContext, into);
+            else if (event.type === "team-member-updated")
+                validateTeamMemberInto(event.member, `${at}.member`, teamContext, into);
+            else if (event.type === "team-member-removed") {
+                if (into.require(isUserId(event.memberId), "event.teamMemberRemoved.memberId", `${at}.memberId`, "team-member-removed names the member taken off, by user id")) {
+                    into.require(event.memberId !== context.self, "team.member.self", `${at}.memberId`, "a lead does not report to themself, so is never removed from their own team");
+                }
+            }
+            else
+                validateTeamPoliciesInto(event.policies, `${at}.policies`, into, levels);
             break;
+        }
         case "contacts-updated":
             into.require(idle.contacts === true, "event.contacts.capability", `${at}.contacts`, "contacts-updated requires the contacts idle capability");
             if (!Array.isArray(event.contacts)) {
@@ -2021,6 +2036,43 @@ function validatePreferencesInto(value, path, into, levels) {
     });
 }
 /** The team's policy per capability as the lead sees it: the setting, who set it, who locked it. */
+function validateShiftInto(value, path, into) {
+    if (!isPlainObject(value)) {
+        into.add("team.member.shift.shape", path, "shift must be an object when present");
+        return;
+    }
+    const signedIn = into.timestamp(value.signedInAt, "team.member.shift.signedInAt", `${path}.signedInAt`);
+    if (value.signedOutAt !== undefined && into.timestamp(value.signedOutAt, "team.member.shift.signedOutAt", `${path}.signedOutAt`) && signedIn) {
+        into.require(Date.parse(value.signedOutAt) >= Date.parse(value.signedInAt), "team.member.shift.signedOutAt.order", `${path}.signedOutAt`, "a member signs out after signing in");
+    }
+    for (const field of ["talkSeconds", "holdSeconds", "breakSeconds"]) {
+        if (value[field] !== undefined)
+            into.require(isDurationSeconds(value[field]), `team.member.shift.${field}`, `${path}.${field}`, `${field} must be a whole number of seconds, zero or more, or omitted when unknown`);
+    }
+    if (value.tasksHandled !== undefined)
+        into.require(Number.isInteger(value.tasksHandled) && value.tasksHandled >= 0, "team.member.shift.tasksHandled", `${path}.tasksHandled`, "tasksHandled must be a whole number, zero or more, or omitted when unknown");
+    if (value.events !== undefined) {
+        if (!Array.isArray(value.events)) {
+            into.add("team.member.shift.events.shape", `${path}.events`, "events must be an array when present");
+            return;
+        }
+        let previous;
+        value.events.forEach((event, index) => {
+            const at = `${path}.events[${index}]`;
+            if (!isPlainObject(event)) {
+                into.add("team.member.shift.event.shape", at, "each shift event must be an object");
+                return;
+            }
+            into.oneOf(event.kind, SHIFT_EVENT_KINDS, "team.member.shift.event.kind", `${at}.kind`);
+            if (into.timestamp(event.at, "team.member.shift.event.at", `${at}.at`)) {
+                const instant = Date.parse(event.at);
+                if (previous !== undefined && instant < previous)
+                    into.add("team.member.shift.events.order", `${at}.at`, "shift events are oldest first; this event is earlier than the one before it");
+                previous = instant;
+            }
+        });
+    }
+}
 function validateTeamPoliciesInto(value, path, into, levels) {
     if (!isPlainObject(value)) {
         into.add("team.policies.shape", path, "policies must be an object keyed by capability");
@@ -2246,7 +2298,6 @@ export function validateHostReport(report, path = "host") {
 // ---------------------------------------------------------------------------
 // Commands.
 // ---------------------------------------------------------------------------
-const TRANSFER_ACTIONS = ["cold", "warm", "complete", "cancel"];
 const LEAD_ASSIST_ACTIONS = ["request", "cancel"];
 const CONFERENCE_ACTIONS = ["add", "remove"];
 /** Validate the exact interaction/assignment target before provider command dispatch. */
@@ -2267,7 +2318,7 @@ export function validateTaskCommandRequest(request, task, path = "request", task
 /**
  * What a command needs to be issuable, checked against the task it names: the capability the
  * guide's table gates it on, the phase it belongs to, and the state that has to stand -- a
- * consulted entry, a lead requested, somebody else on the call. Without a task only the command's
+ * lead requested, somebody else on the call. Without a task only the command's
  * own shape is checked. A host validates before sending, and an adapter before acting: a command
  * for a control the task never offered is the host's error, and this names it.
  */
@@ -2300,10 +2351,8 @@ export function validateTaskCommand(command, task, path = "command", taskContext
             case "complete":
                 fields.push("outcome", "notes");
                 break;
-            case "transfer":
-                fields.push("action");
-                if (command.action === "cold" || command.action === "warm")
-                    fields.push("dialId", "destinationId");
+            case "schedule":
+                fields.push("at", "note");
                 break;
             case "lead-assist":
                 fields.push("action");
@@ -2326,16 +2375,10 @@ export function validateTaskCommand(command, task, path = "command", taskContext
         case "connect-back":
             dial("command.connectBack.dialId");
             break;
-        case "transfer":
-            if (into.oneOf(command.action, TRANSFER_ACTIONS, "command.transfer.action", `${path}.action`)) {
-                if (command.action === "cold" || command.action === "warm") {
-                    dial("command.transfer.dialId");
-                    into.filled(command.destinationId, "command.transfer.destinationId", `${path}.destinationId`, "a transfer names the directory item it goes to");
-                }
-                else {
-                    into.require(command.dialId === undefined && command.destinationId === undefined, "command.transfer.unexpected", path, `${describeValue(command.action)} names no destination: there is exactly one it could mean`);
-                }
-            }
+        case "schedule":
+            into.timestamp(command.at, "command.schedule.at", `${path}.at`);
+            if (command.note !== undefined)
+                into.filled(command.note, "command.schedule.note", `${path}.note`, "a note must not be empty when present");
             break;
         case "lead-assist":
             into.oneOf(command.action, LEAD_ASSIST_ACTIONS, "command.leadAssist.action", `${path}.action`);
@@ -2468,19 +2511,10 @@ export function validateTaskCommand(command, task, path = "command", taskContext
             offered("connectBack");
             inPhase("command.phase.completing", "completing");
             break;
-        case "transfer":
-            interaction();
-            if (command.action === "cold") {
-                if (offered("coldTransfer"))
-                    listed("coldTransfer");
-            }
-            else if (command.action === "warm") {
-                if (offered("warmTransfer"))
-                    listed("warmTransfer");
-            }
-            else if (command.action === "complete" || command.action === "cancel") {
-                into.require(onCall.some(entry => entry.role === "consulted"), "command.transfer.consulted", path, `${describeValue(command.action)} needs a consulted entry on onCall: without one there is nothing to complete or cancel`);
-            }
+        case "schedule":
+            // A follow-up is promised on the call and written up in wrap alike.
+            offered("schedule");
+            inPhase("command.phase.interaction", "in-progress", "paused", "completing");
             break;
         case "lead-assist":
             interaction();
@@ -2507,7 +2541,9 @@ export function validateTaskCommand(command, task, path = "command", taskContext
             break;
         }
         case "complete": {
-            into.require(task.completionMode === "agent-command", "command.complete.mode", path, "complete belongs to agent-command; a provider-automatic task completes itself");
+            // The agent may finish early under either mode; the provider is free to end at once. With
+            // no wrap at all there is no window to cut short, and nothing for the command to do.
+            into.require(task.wrapAllowance !== 0, "command.complete.wrapAllowance", path, "the task has no wrap: with wrapAllowance 0 the provider ends it itself, and there is nothing to complete");
             // What travels with complete is what the outcomes capability published: a code from its
             // list where it has one, a code at all where it requires one, notes as it said, nothing where it published nothing.
             const outcomes = capabilities.outcomes;
@@ -2963,10 +2999,10 @@ export function validateRecordingCommandShape(value, source, path = "command") {
         check(false, "command.shape", path, "expected recording command");
         return violations;
     }
-    keys(value, ["type", "source", "requestId", "observationId", "action", ...(value.action === "start" ? [] : ["recordingId"])], path);
+    keys(value, ["type", "source", "observationId", "action", ...(value.action === "start" ? [] : ["recordingId"])], path);
     check(value.type === "recording" && value.source === source, "command.source", path, `this executor accepts only ${source} recording commands`);
     check(RECORDING_ACTIONS.includes(value.action), "command.action", `${path}.action`, "unsupported recording action");
-    for (const key of ["requestId", "observationId", ...(value.action === "start" ? [] : ["recordingId"])])
+    for (const key of ["observationId", ...(value.action === "start" ? [] : ["recordingId"])])
         check(filled(value[key]), "command.identity", `${path}.${key}`, "expected nonempty scoped identity");
     return violations;
 }