@xema/omni-protocol 0.1.102 → 0.1.104

package/dist/validation.js

@@ -91,7 +91,7 @@ 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 });
 const EXPIRABLE_PHASES = membersOf({
-    pending: true, confirmed: true, preview: true,
+    pending: true, confirmed: true,
 });
 const ISOLATION_SCHEME_VALUES = Object.values(BROWSER_ISOLATION_SCHEMES);
 /** The capabilities each channel arm of `TaskCapabilities` declares, keyed off the type itself. */
@@ -100,8 +100,8 @@ const TASK_CAPABILITIES = {
         browsers: true, outcomes: true, custom: true, decline: true, hold: 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 }),
+    chat: membersOf({ browsers: true, outcomes: true, custom: true, decline: true, hold: true, schedule: true }),
+    email: membersOf({ browsers: true, outcomes: true, custom: true, decline: true, schedule: true }),
 };
 // The published list and the type's keys are the same set, or one of them is wrong.
 true;
@@ -393,6 +393,10 @@ export function validatePhone(value, manifest, path = "context.phone") {
 function manifestDials(manifest) {
     return isPlainObject(manifest) ? Array.isArray(manifest.dialOutcomes) : undefined;
 }
+/** Whether a manifest declares a calendar, and so may publish tasks that schedule onto it. `undefined` where there is no manifest to ask. */
+function manifestCalendar(manifest) {
+    return isPlainObject(manifest) ? isPlainObject(manifest.idleCapabilities) && manifest.idleCapabilities.calendar === true : undefined;
+}
 /** Undefined explicitly means unavailable; a returned estimate is not a clock guarantee. */
 export function validateProviderTimeEstimate(value, scope, path = "estimate") {
     const into = new Collector();
@@ -520,8 +524,10 @@ export function validateManifest(manifest, path = "manifest") {
     if (manifest.runningStepReports !== undefined) {
         into.require(manifest.runningStepReports === true, "manifest.runningStepReports", `${path}.runningStepReports`, "runningStepReports is declared by presence, as true; a provider that takes begin and end only omits it");
     }
-    into.require(!Object.hasOwn(manifest, "disposalSettleMs"), "manifest.completionSettleMs.renamed", `${path}.disposalSettleMs`, "use completionSettleMs; the former field is not accepted");
-    into.require(typeof manifest.completionSettleMs === "number" && Number.isInteger(manifest.completionSettleMs) && manifest.completionSettleMs > 0, "manifest.completionSettleMs", `${path}.completionSettleMs`, "completionSettleMs is how long after an applied completion the task-ended is owed, a positive whole number of milliseconds, stated by every provider");
+    for (const former of ["disposalSettleMs", "completionSettleMs"]) {
+        into.require(!Object.hasOwn(manifest, former), "manifest.settleMs.renamed", `${path}.${former}`, "use settleMs; the former field is not accepted");
+    }
+    into.require(typeof manifest.settleMs === "number" && Number.isInteger(manifest.settleMs) && manifest.settleMs > 0, "manifest.settleMs", `${path}.settleMs`, "settleMs is how long after applied the wire shows what the provider did -- the task-ended after a complete, the calendar-updated after a schedule -- a positive whole number of milliseconds, stated by every provider");
     if (manifest.orgLevels !== undefined) {
         if (!Array.isArray(manifest.orgLevels)) {
             into.add("manifest.orgLevels.shape", `${path}.orgLevels`, "orgLevels must be an array when present");
@@ -1120,6 +1126,11 @@ function validateTaskInto(task, context, path, into) {
         into.require(context.channel === "voice", "task.phase.channel", `${path}.phase`, `a ${context.channel} task has no call to preview`);
         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");
     }
+    // How long the offer has left travels on the pending task, so a reconnect snapshot restates it.
+    if (task.expiresInSeconds !== undefined) {
+        into.require(task.phase === "pending", "task.pending.expiresInSeconds.unexpected", `${path}.expiresInSeconds`, "expiresInSeconds is how long an offer has left, and belongs to a pending task; accepted, there is no offer to run out");
+        into.require(isDurationSeconds(task.expiresInSeconds), "task.pending.expiresInSeconds", `${path}.expiresInSeconds`, "expiresInSeconds is how long the offer has left: a whole number of seconds, zero or more, counted from this publication");
+    }
     // The deadline and what happens at it travel together, and only while the record is being previewed.
     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");
@@ -1239,8 +1250,10 @@ function validateTaskInto(task, context, path, into) {
     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");
     }
+    // Under agent-command the allowance is the expected wrap, shown and never acted on: the agent
+    // completes whenever they are done, so there is always a wrap to collect the code in.
     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");
+        into.require(!(task.completionMode === "provider-automatic" && task.wrapAllowance === 0), "task.outcomes.wrapAllowance", `${path}.capabilities.outcomes`, "outcomes are collected in wrap, and provider-automatic with wrapAllowance 0 gives none: publish a wrap or no outcomes");
     }
     for (const [name, declared] of Object.entries(capabilities)) {
         if (declared === undefined)
@@ -1256,6 +1269,10 @@ function validateTaskInto(task, context, path, into) {
         if (DIALLING_CAPABILITIES.includes(name) && context.dialOutcomesDeclared === false) {
             into.add("task.capability.dialOutcomes.required", `${path}.capabilities.${name}`, `${name} dials, and the manifest declares no dialOutcomes to say how a dial ends`);
         }
+        // A follow-up lands on the calendar, so the manifest has to have one for it to land on.
+        if (name === "schedule" && context.calendarDeclared === false) {
+            into.add("task.capability.calendar.required", `${path}.capabilities.schedule`, "schedule puts a follow-up on the calendar, and the manifest declares no calendar for it to land on");
+        }
         // A control the queue could allow may stand locked in its place, saying whose. What the
         // queue provides -- browsers, outcomes, custom controls -- is content, not a control.
         if (isLocked(declared)) {
@@ -1296,8 +1313,9 @@ function validateForcedBreak(value, path, into) {
     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");
     }
-    if (value.expectedDurationMs !== undefined)
-        into.require(typeof value.expectedDurationMs === "number" && Number.isFinite(value.expectedDurationMs) && value.expectedDurationMs > 0, "break.forced.expectedDurationMs", `${path}.expectedDurationMs`, "expectedDurationMs must be a positive finite number of milliseconds");
+    into.require(!Object.hasOwn(value, "expectedDurationMs"), "break.forced.expectedDurationMs.renamed", `${path}.expectedDurationMs`, "the state says how long is left, as expectedEndsInSeconds; the duration asked for travels on the lead's command alone");
+    if (value.expectedEndsInSeconds !== undefined)
+        into.require(isDurationSeconds(value.expectedEndsInSeconds), "break.forced.expectedEndsInSeconds", `${path}.expectedEndsInSeconds`, "expectedEndsInSeconds is how long the break is expected to run yet: a whole number of seconds, zero or more, counted from this publication");
 }
 /** Checks break status against the full currently retained task set, after a transaction. */
 export function validateBreakStatus(state, tasks, path = "snapshot") {
@@ -1399,8 +1417,11 @@ export function validateTeamCommand(request, context, path = "teamCommand") {
     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")
+        if (command.type === "end-forced-break") {
             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");
+            // The platform lifts a break it imposed itself; a lead lifts one a lead asked for.
+            into.require(!(isPlainObject(state.forced) && state.forced.by === "provider"), "team.command.endForcedBreak.provider", path, "the platform put this member on the break, and it lifts it: a lead ends a break a lead forced");
+        }
         if (command.type === "force-break") {
             if (command.expectedDurationMs !== undefined)
                 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");
@@ -1415,7 +1436,8 @@ export function validateTeamCommand(request, context, path = "teamCommand") {
         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`);
+        // Every lead's entry is on the member; the one this command moves is the signed-in lead's.
+        into.require(isPlainObject(target) && Array.isArray(target.listening) && target.listening.some((entry) => isPlainObject(entry) && entry.leadId === self), "team.command.listening", path, `${command.type} needs this lead on this member's call: the team member list shows listening on them naming this lead`);
     }
     return into.violations;
 }
@@ -1611,10 +1633,19 @@ function validateTeamMembersInto(teamMembers, path, context, into) {
         }
         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's call at a time, per lead.
+    const onCalls = new Map();
+    for (const member of teamMembers.members) {
+        if (!isPlainObject(member) || !Array.isArray(member.listening))
+            continue;
+        const leads = new Set(member.listening.filter(isPlainObject).map(entry => entry.leadId).filter((id) => typeof id === "string"));
+        for (const leadId of leads)
+            onCalls.set(leadId, (onCalls.get(leadId) ?? 0) + 1);
+    }
+    for (const [leadId, count] of onCalls) {
+        if (count > 1)
+            into.add("team.listening.single", `${path}.members`, `${leadId} is on ${count} members' calls: 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 = {}) {
@@ -1659,23 +1690,41 @@ function validateTeamMemberInto(member, at, context, into) {
             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.
+    // Every lead on this member's call, in the mode they are heard, published to every lead alike.
     if (member.listening !== undefined) {
-        if (!isPlainObject(member.listening)) {
-            into.add("team.member.listening.shape", `${at}.listening`, "listening must be an object when present");
+        if (!Array.isArray(member.listening)) {
+            into.add("team.member.listening.shape", `${at}.listening`, "listening is an array of the leads on the member's call: absent while none is");
         }
         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`);
+            into.require(member.listening.length > 0, "team.member.listening.empty", `${at}.listening`, "nobody on the call is absence, not an empty list");
+            const leads = new Set();
+            member.listening.forEach((entry, index) => {
+                const here = `${at}.listening[${index}]`;
+                if (!isPlainObject(entry)) {
+                    into.add("team.member.listening.entry", here, "each listening entry must be an object");
+                    return;
+                }
+                if (into.require(isUserId(entry.leadId), "team.member.listening.leadId", `${here}.leadId`, "a listening entry names the lead on the call, by user id")) {
+                    if (leads.has(entry.leadId))
+                        into.add("team.member.listening.unique", `${here}.leadId`, `${entry.leadId} is listed twice on one member: a lead is on a member's call once`);
+                    leads.add(entry.leadId);
+                }
+                const task = Array.isArray(member.tasks) ? member.tasks.find((task) => isPlainObject(task) && task.assignmentId === entry.assignmentId) : undefined;
+                if (into.require(isAssignmentId(entry.assignmentId), "team.member.listening.assignmentId", `${here}.assignmentId`, "a listening entry names which of the member's calls the lead is on: the application opens its own audio on it") && Array.isArray(member.tasks)) {
+                    into.require(task !== undefined, "team.member.listening.assignment", `${here}.assignmentId`, "the call the lead is on is one the member's tasks carry");
+                }
+                if (into.oneOf(entry.mode, LISTENING_MODES, "team.member.listening.mode", `${here}.mode`) && entry.mode === "join-call"
+                    && isPlainObject(task) && Array.isArray(task.onCall) && isUserId(entry.leadId)) {
+                    // A lead who is heard is in the room the member sees; a silent one is not.
+                    into.require(task.onCall.some((who) => isPlainObject(who) && who.role === "agent" && who.userId === entry.leadId), "team.member.listening.heard", `${here}.mode`, `${entry.leadId} has joined the call and is heard, so the task's onCall carries them as an agent`);
+                }
+                into.timestamp(entry.since, "team.member.listening.since", `${here}.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);
+        validateShiftInto(member.shift, `${at}.shift`, into, "team.member.shift");
     // The member's standing ask for a lead, on one of the calls they hold.
     if (member.request !== undefined) {
         if (!isPlainObject(member.request)) {
@@ -1701,6 +1750,18 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
     const channel = isPlainObject(manifest) && typeof manifest.channel === "string" ? manifest.channel : "voice";
     const levels = context.levels ?? manifestLevels(manifest);
     into.oneOf(snapshot.transport, TRANSPORT_STATUSES, "snapshot.transport", `${path}.transport`);
+    // The provider's own instant of the read: required where the provider has a clock to state, and
+    // a clock nobody declared is not one the desk may count from.
+    if (isPlainObject(manifest) && manifest.timeCheck === true) {
+        into.timestamp(snapshot.providerTime, "snapshot.providerTime", `${path}.providerTime`);
+    }
+    else if (snapshot.providerTime !== undefined) {
+        into.add("snapshot.providerTime.unexpected", `${path}.providerTime`, "providerTime is the clock of a provider that declares timeCheck; declare it, or send none");
+    }
+    requireClockInto(snapshot, manifest, path, into);
+    // The agent's own day, as the provider counts it: the same numbers their lead sees.
+    if (snapshot.shift !== undefined)
+        validateShiftInto(snapshot.shift, `${path}.shift`, into, "shift");
     if (into.filled(snapshot.loginId, "snapshot.loginId", `${path}.loginId`, "a snapshot needs the login id it belongs to")
         && context.loginId !== undefined) {
         into.require(snapshot.loginId === context.loginId, "snapshot.loginId.mismatch", `${path}.loginId`, `a snapshot for session ${describeValue(snapshot.loginId)} on a login whose session is ${context.loginId}`);
@@ -1717,7 +1778,7 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
     else {
         const seen = new Set();
         snapshot.tasks.forEach((task, index) => {
-            validateTaskInto(task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), locked: context.locked }, `${path}.tasks[${index}]`, into);
+            validateTaskInto(task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), calendarDeclared: manifestCalendar(manifest), locked: context.locked }, `${path}.tasks[${index}]`, into);
             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}`);
@@ -1874,6 +1935,9 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
         return into.violations;
     }
     const at = `${path}.event`;
+    // A snapshot event is read by validateSnapshot, which asks the clock question of it there.
+    if (event.type !== "snapshot")
+        requireClockInto(event, manifest, at, into);
     into.require(!Object.hasOwn(event, "taskId"), "event.assignmentId.renamed", `${at}.taskId`, "an event names a task by its assignment alone; the former field is not accepted");
     switch (event.type) {
         case "snapshot":
@@ -1899,16 +1963,15 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
             validateBreakState(event.break, `${at}.break`, into);
             break;
         case "task-offered":
-            validateTaskInto(event.task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), locked: context.locked }, `${at}.task`, into);
+            validateTaskInto(event.task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), calendarDeclared: manifestCalendar(manifest), locked: context.locked }, `${at}.task`, into);
             // An offer introduces work that is not yet under way; work in progress arrives only on a snapshot.
             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.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");
+            into.require(event.expiresInSeconds === undefined, "event.taskOffered.expiresInSeconds.unexpected", `${at}.expiresInSeconds`, "expiresInSeconds travels on the pending task, where a reconnect snapshot restates it, not on the event");
             break;
         case "task-updated":
-            validateTaskInto(event.task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), locked: context.locked }, `${at}.task`, into);
+            validateTaskInto(event.task, { channel, levels, autoAcceptTasks: context.autoAcceptTasks, dialOutcomesDeclared: manifestDials(manifest), calendarDeclared: manifestCalendar(manifest), locked: context.locked }, `${at}.task`, into);
             break;
         case "task-audio-started":
             into.require(channel === "voice", "event.audio.channel", `${at}.type`, "only a voice provider publishes audio transitions");
@@ -1985,6 +2048,9 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
                 event.contacts.forEach((contact, index) => validateContactInto(contact, `${at}.contacts[${index}]`, into, levels));
             }
             break;
+        case "shift-updated":
+            validateShiftInto(event.shift, `${at}.shift`, into, "shift");
+            break;
         case "calendar-updated":
             into.require(idle.calendar === true, "event.calendar.capability", `${at}.calendar`, "calendar-updated requires the calendar idle capability");
             if (!Array.isArray(event.calendar)) {
@@ -2036,38 +2102,65 @@ 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) {
+/** Whether a publication carries an instant the desk renders as a running duration, which the provider's clock reads. */
+function carriesRunningInstant(value) {
+    if (!isPlainObject(value))
+        return false;
+    if (isPlainObject(value.shift) && value.shift.signedInAt !== undefined)
+        return true;
+    const tasks = [
+        ...(Array.isArray(value.tasks) ? value.tasks : []),
+        ...(isPlainObject(value.task) ? [value.task] : []),
+    ];
+    if (tasks.some(task => isPlainObject(task) && Array.isArray(task.onCall) && task.onCall.some((who) => isPlainObject(who) && who.since !== undefined)))
+        return true;
+    const members = [
+        ...(isPlainObject(value.team) && Array.isArray(value.team.members) ? value.team.members : []),
+        ...(isPlainObject(value.member) ? [value.member] : []),
+    ];
+    return members.some(member => isPlainObject(member) && (member.since !== undefined
+        || (Array.isArray(member.listening) && member.listening.some((entry) => isPlainObject(entry) && entry.since !== undefined))
+        || (isPlainObject(member.shift) && member.shift.signedInAt !== undefined)
+        || (Array.isArray(member.tasks) && member.tasks.some((task) => isPlainObject(task) && Array.isArray(task.onCall) && task.onCall.some((who) => isPlainObject(who) && who.since !== undefined)))));
+}
+/** A running duration is counted from the provider's clock: a provider that publishes one declares timeCheck. */
+function requireClockInto(value, manifest, path, into) {
+    if (!isPlainObject(manifest) || manifest.timeCheck === true || !carriesRunningInstant(value))
+        return;
+    into.add("manifest.timeCheck.required", path, "this publishes an instant the desk renders as a running duration -- a since, a signedInAt -- and the manifest declares no timeCheck: every screen counts such a duration from the provider's clock, so the provider states one");
+}
+function validateShiftInto(value, path, into, rule) {
     if (!isPlainObject(value)) {
-        into.add("team.member.shift.shape", path, "shift must be an object when present");
+        into.add(`${rule}.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");
+    const signedIn = into.timestamp(value.signedInAt, `${rule}.signedInAt`, `${path}.signedInAt`);
+    if (value.signedOutAt !== undefined && into.timestamp(value.signedOutAt, `${rule}.signedOutAt`, `${path}.signedOutAt`) && signedIn) {
+        into.require(Date.parse(value.signedOutAt) >= Date.parse(value.signedInAt), `${rule}.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");
+        into.require(Number.isInteger(value.tasksHandled) && value.tasksHandled >= 0, `${rule}.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");
+            into.add(`${rule}.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");
+                into.add(`${rule}.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`)) {
+            into.oneOf(event.kind, SHIFT_EVENT_KINDS, `${rule}.event.kind`, `${at}.kind`);
+            if (into.timestamp(event.at, `${rule}.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");
+                    into.add(`${rule}.events.order`, `${at}.at`, "shift events are oldest first; this event is earlier than the one before it");
                 previous = instant;
             }
         });
@@ -2543,7 +2636,7 @@ export function validateTaskCommand(command, task, path = "command", taskContext
         case "complete": {
             // 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");
+            into.require(!(task.completionMode === "provider-automatic" && task.wrapAllowance === 0), "command.complete.wrapAllowance", path, "the task has no wrap: under provider-automatic 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;