@xema/omni-protocol 0.1.84 → 0.1.86

package/README.md

@@ -42,9 +42,9 @@ assertNoViolations(violations);
 A violation carries a stable `rule` id such as `task.browser.url.scheme`, the `path` it was found
 at such as `snapshot.tasks[0].browsers[1].url`, and a `message`.
 
-Some rules need more than the object in hand. A roster never carries the agent it is published to,
+Some rules need more than the object in hand. A team member list never carries the agent it is published to,
 a lead's snapshot always carries one and nobody else's ever does — and a validator cannot know who
-is reading, or what their login declares, from the snapshot alone. `validateTeamRoster`,
+is reading, or what their login declares, from the snapshot alone. `validateTeamMembers`,
 `validateSnapshot`, and `validateEventEnvelope` each take an optional final `{ self, capabilities }`
 from the `authenticated` state; given them, they report `team.member.self`, `team.request.self`,
 `team.required`, `team.unentitled`, `team.requests.capability`, and `team.requests.required`.
@@ -61,7 +61,7 @@ validateSnapshot(snapshot, manifest, "snapshot", { self: identity.id, capabiliti
 required capability methods, subscribes, validates the snapshot, every delivered event, and every
 authentication state published during the run — against the latest login — states a capacity,
 then unsubscribes and disconnects. `result.notExercised` names what the run never reached — each
-optional part of a task, of the break state and roster, each contribution, each event type — so a
+optional part of a task, of the break state and team member list, each contribution, each event type — so a
 clean result is read for what it covers and not for the whole contract; `assertReached(result,
 subjects)` is the paired assertion.
 

package/dist/index.d.ts

@@ -268,7 +268,7 @@ export interface UserCapabilities {
     breaks?: true;
     /** The choices the team left to this person, with where each stands. Omitted when there are none. Requires `setPreference`. */
     preferences?: AgentPreference[];
-    /** This login leads a team: a `TeamRoster` is published to it on every snapshot, `[]` included. */
+    /** This login leads a team: a `TeamMembers` object is published to it on every snapshot, including `members: []`. */
     team?: TeamCapabilities;
 }
 /**
@@ -619,15 +619,15 @@ export interface ScheduledActivity {
     party?: Contact;
     attributes?: Attribute[];
 }
-export interface DispositionCode {
+export interface OutcomeCode {
     id: string;
     label: string;
     group?: string;
 }
-export interface DispositionRules {
+export interface OutcomeRules {
     required?: boolean;
     notes?: "required" | "optional" | "none";
-    codes?: DispositionCode[];
+    codes?: OutcomeCode[];
 }
 /**
  * One item the queue configured for the agent to send a contact to: a button or a menu item. The
@@ -658,7 +658,7 @@ export interface CustomCapability {
 }
 export interface SharedTaskCapabilities {
     browsers?: true;
-    dispositions?: true | DispositionRules;
+    outcomes?: true | OutcomeRules;
     custom?: CustomCapability[];
 }
 /**
@@ -1054,8 +1054,8 @@ export declare const TASK_COMMAND_NAMES: {
     readonly email: readonly ["accept", "decline", "complete"];
 };
 export type TaskCommandName<C extends keyof typeof TASK_COMMAND_NAMES> = (typeof TASK_COMMAND_NAMES)[C][number];
-export interface DispositionPayload {
-    disposition?: string;
+export interface OutcomePayload {
+    outcome?: string;
     notes?: string;
 }
 export type VoiceTaskCommand = {
@@ -1153,7 +1153,7 @@ export type VoiceTaskCommand = {
     source: "provider";
 }) | ({
     type: "complete";
-} & DispositionPayload);
+} & OutcomePayload);
 export type ChatTaskCommand = {
     type: "accept";
 } | {
@@ -1164,14 +1164,14 @@ export type ChatTaskCommand = {
     type: "resume";
 } | ({
     type: "complete";
-} & DispositionPayload);
+} & OutcomePayload);
 export type EmailTaskCommand = {
     type: "accept";
 } | {
     type: "decline";
 } | ({
     type: "complete";
-} & DispositionPayload);
+} & OutcomePayload);
 export interface CustomTaskCommand {
     type: "custom";
     name: string;
@@ -1336,7 +1336,7 @@ export interface LeadRequest {
  * The login is the permission: published to a login that declares `capabilities.team`, on every
  * snapshot, and to nobody else. What the lead may do with it is on the login too, not here.
  */
-export interface TeamRoster {
+export interface TeamMembers {
     members: TeamMember[];
     /** Omitted when the login lacks `team.leadAssistControl`; `[]` when nobody is asking. */
     requests?: LeadRequest[];
@@ -1372,7 +1372,7 @@ export interface TeamLeadAssistCommandRequest {
     command: TeamLeadAssistCommand;
 }
 /**
- * A lead listening to a member's call. `monitor` starts one, silent, on a member from the roster;
+ * A lead listening to a member's call. `monitor` starts one, silent, on a member from the team member list;
  * `whisper` and `barge` change how the standing one is heard; `leave` ends it. One member at a
  * time, and only the modes the login's `monitorControl` lists.
  */
@@ -1530,7 +1530,7 @@ export interface Snapshot<C extends Channel = Channel> {
     taskCount: number;
     contacts?: Contact[];
     scheduledActivities?: ScheduledActivity[];
-    team?: TeamRoster;
+    team?: TeamMembers;
 }
 /**
  * How many tasks this provider may have allocated to the agent at once.
@@ -1627,7 +1627,7 @@ export type ProviderEvent<C extends Channel = Channel> = {
     allocationId?: AllocationId;
 } | {
     type: "team-updated";
-    team: TeamRoster;
+    team: TeamMembers;
 } | {
     type: "contacts-updated";
     contacts: Contact[];
@@ -1692,7 +1692,7 @@ export interface Connection<C extends Channel = Channel> {
     setCapacity(capacity: AgentCapacity): Promise<CapacityResult>;
     execute(request: TaskCommandRequest<C>): Promise<TaskCommandResult>;
     disconnect(): Promise<void>;
-    /** Required of any adapter publishing a `UserId` -- on an imposed break, a roster, or history. */
+    /** Required of any adapter publishing a `UserId` -- on an imposed break, a team member list, or history. */
     describeUsers?(ids: UserId[]): Promise<User[]>;
     /** Required when the manifest declares `idleCapabilities.dial`. */
     dial?(request: DialRequest): Promise<DialResult>;

package/dist/testing.d.ts

@@ -4,10 +4,10 @@ export { ProtocolConformanceError, assertNoViolations, type ProtocolViolation }
 /**
  * A part of the contract a run may never reach: state nothing obliges an adapter to publish, so
  * a fixture without it exercises none of its rules and passes clean. One subject per family of
- * rules -- each optional part of a task, each optional part of the break state and roster, each
+ * rules -- each optional part of a task, each optional part of the break state and team member list, each
  * declared contribution, and each event type.
  */
-declare const STATE_SUBJECTS: readonly ["tasks", "task.browsers", "task.attributes", "task.interactionHistory", "task.onCall", "task.leadAssist", "task.assisting", "task.monitoring", "task.media", "task.acceptance", "task.dispositions", "task.destinations", "task.custom", "task.locked", "break.reasons", "break.imposed", "team.members", "team.requests", "contacts", "scheduledActivities", "team.policies"];
+declare const STATE_SUBJECTS: readonly ["tasks", "task.browsers", "task.attributes", "task.interactionHistory", "task.onCall", "task.leadAssist", "task.assisting", "task.monitoring", "task.media", "task.acceptance", "task.outcomes", "task.destinations", "task.custom", "task.locked", "break.reasons", "break.imposed", "team.members", "team.requests", "contacts", "scheduledActivities", "team.policies"];
 export type ContractSubject = (typeof STATE_SUBJECTS)[number] | `event.${ProviderEvent["type"]}`;
 export interface AdapterContractResult {
     events: ProviderEventEnvelope[];
@@ -89,7 +89,7 @@ export declare function assertAuthenticationRestoreAndExpiry(states: readonly Au
  * session published, first to last: beginning and ending `authenticated` for the same identity,
  * passing only through usable states (`expired` or `signed-out` ends the login instead), with at
  * least one capability gone by the end. `snapshot` is the first snapshot published after the last
- * state, validated against that login -- so a roster still published to a login that no longer
+ * state, validated against that login -- so a team member list still published to a login that no longer
  * leads, or requests to one that may no longer join, is the failure.
  */
 export declare function assertCapabilityWithdrawal(states: readonly AuthenticationState[], snapshot: Snapshot, manifest: Manifest): void;
@@ -121,7 +121,7 @@ export declare function assertCommandRefusedAfterWithdrawal(result: {
 export declare function assertTaskCapabilityWithdrawal(tasks: readonly Task[], manifest: Manifest, command: Record<string, unknown>): void;
 /**
  * Throws unless the run reached every subject named: the paired assertion beside a clean result,
- * so a fixture that never produced a roster cannot pass a test that meant to check one.
+ * so a fixture that never produced a team member list cannot pass a test that meant to check one.
  */
 export declare function assertReached(result: AdapterContractResult, subjects: readonly ContractSubject[]): void;
 /** Validates duplicate delivery and returns the event sequence Omni applies once per ID. */

package/dist/testing.js

@@ -4,7 +4,7 @@ export { ProtocolConformanceError, assertNoViolations } from "./validation.js";
 /**
  * A part of the contract a run may never reach: state nothing obliges an adapter to publish, so
  * a fixture without it exercises none of its rules and passes clean. One subject per family of
- * rules -- each optional part of a task, each optional part of the break state and roster, each
+ * rules -- each optional part of a task, each optional part of the break state and team member list, each
  * declared contribution, and each event type.
  */
 const STATE_SUBJECTS = [
@@ -18,7 +18,7 @@ const STATE_SUBJECTS = [
     "task.monitoring",
     "task.media",
     "task.acceptance",
-    "task.dispositions",
+    "task.outcomes",
     "task.destinations",
     "task.custom",
     "task.locked",
@@ -68,8 +68,8 @@ function observeTask(value, seen) {
     if (value.acceptance !== undefined)
         seen.add("task.acceptance");
     const capabilities = isRecord(value.capabilities) ? value.capabilities : {};
-    if (isRecord(capabilities.dispositions))
-        seen.add("task.dispositions");
+    if (isRecord(capabilities.outcomes))
+        seen.add("task.outcomes");
     for (const directory of ["coldTransfer", "warmTransfer", "conference"]) {
         const declared = capabilities[directory];
         if (isRecord(declared) && some(declared.destinations))
@@ -188,7 +188,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
             throw new Error(`Adapter contract exercise requires authenticated test state, received ${authenticationState.status}`);
         }
         // The harness knows who is signed in and what their login declares, so it can hold the
-        // adapter to rules the structural validators cannot check alone: a roster never carries the
+        // adapter to rules the structural validators cannot check alone: a team member list never carries the
         // agent it is published to, a lead's snapshot always carries one, nobody else's ever does.
         // Capabilities are current, not fixed, so the login is read when something is validated,
         // never captured at sign-in: a provider that withdraws one republishes `authenticated`, and
@@ -460,7 +460,7 @@ export async function exerciseAdapter(adapter, context, options = {}) {
             if (publishesUserIds(read)) {
                 requireMethod(source, "describeUsers", "the snapshot publishes a UserId");
                 // Required by presence is not enough: the names the snapshot published are looked up, and what
-                // comes back is held to the shape -- an empty answer to a roster of colleagues is named.
+                // comes back is held to the shape -- an empty answer to a team member list of colleagues is named.
                 const named = userIdsIn(read);
                 if (typeof source.describeUsers === "function" && named.length > 0) {
                     let described;
@@ -644,7 +644,7 @@ function publishesUserIds(snapshot) {
         return false;
     return snapshot.tasks.some(taskNamesUsers);
 }
-/** Every UserId a snapshot publishes: on the record, the room, a lead request, an imposed break, the roster. */
+/** Every UserId a snapshot publishes: on the record, the room, a lead request, an imposed break, the team member list. */
 function userIdsIn(snapshot) {
     const ids = new Set();
     const add = (value) => { if (typeof value === "string" && value.length > 0)
@@ -685,7 +685,7 @@ const taskNamesUsers = (task) => isRecord(task) && ((isRecord(task.interactionHi
     (isRecord(task.leadAssist) && task.leadAssist.leadId !== undefined) ||
     isRecord(task.assisting) ||
     isRecord(task.monitoring));
-/** Whether an event publishes a `UserId`, on a roster, a task, or the snapshot a reconnect carries. */
+/** Whether an event publishes a `UserId`, on a team member list, a task, or the snapshot a reconnect carries. */
 function eventNamesUsers(envelope) {
     const event = isRecord(envelope) ? envelope.event : undefined;
     if (!isRecord(event))
@@ -795,7 +795,7 @@ function undeterminedTasks(tasks, path) {
  * session published, first to last: beginning and ending `authenticated` for the same identity,
  * passing only through usable states (`expired` or `signed-out` ends the login instead), with at
  * least one capability gone by the end. `snapshot` is the first snapshot published after the last
- * state, validated against that login -- so a roster still published to a login that no longer
+ * state, validated against that login -- so a team member list still published to a login that no longer
  * leads, or requests to one that may no longer join, is the failure.
  */
 export function assertCapabilityWithdrawal(states, snapshot, manifest) {
@@ -890,7 +890,7 @@ export function assertTaskCapabilityWithdrawal(tasks, manifest, command) {
 }
 /**
  * Throws unless the run reached every subject named: the paired assertion beside a clean result,
- * so a fixture that never produced a roster cannot pass a test that meant to check one.
+ * so a fixture that never produced a team member list cannot pass a test that meant to check one.
  */
 export function assertReached(result, subjects) {
     const missed = subjects.filter(subject => result.notExercised.includes(subject));
@@ -1793,9 +1793,9 @@ async function driveOneCall(drive) {
     const completable = latestTask().phase === "completing" || latestTask().phase === "in-progress" || latestTask().phase === "paused";
     if (latestTask().completionMode === "agent-command" && completable) {
         const command = { type: "complete" };
-        const dispositions = isRecord(latestTask().capabilities) ? latestTask().capabilities.dispositions : undefined;
-        if (isRecord(dispositions) && dispositions.required === true && Array.isArray(dispositions.codes) && isRecord(dispositions.codes[0])) {
-            command.disposition = dispositions.codes[0].id;
+        const outcomes = isRecord(latestTask().capabilities) ? latestTask().capabilities.outcomes : undefined;
+        if (isRecord(outcomes) && outcomes.required === true && Array.isArray(outcomes.codes) && isRecord(outcomes.codes[0])) {
+            command.outcome = outcomes.codes[0].id;
         }
         if (await send(command) !== undefined) {
             // applied says the provider has completed the task, and its ending follows within the bound

package/dist/validation.d.ts

@@ -50,9 +50,9 @@ export declare function validateTask(task: unknown, context: TaskValidationConte
 /** Checks break status against the full currently retained task set, after a transaction. */
 export declare function validateBreakStatus(state: unknown, tasks: unknown, path?: string): ProtocolViolation[];
 /**
- * Checks lead break dispatch using current authentication, transport, roster (`team`) and,
+ * Checks lead break dispatch using current authentication, transport, team member list (`team`) and,
  * for place/release, the target's full `memberBreak`. The provider must authorize the target
- * and recheck the decision atomically; a roster is not authority to act after it has changed.
+ * and recheck the decision atomically; a team member list is not authority to act after it has changed.
  */
 export declare function validateTeamBreakCommand(request: unknown, context: unknown, path?: string): ProtocolViolation[];
 /** The four agent break methods; this is a validation API, not a wire command. */
@@ -78,12 +78,12 @@ export declare function validateBreakTransition(before: unknown, after: unknown,
 export interface ReaderContext {
     /**
      * The signed-in agent, `AuthenticationState.identity.id`. A lead does not report to themself:
-     * a roster that lists them in `members`, or their own ask in `requests`, is a violation.
+     * a team member list that lists them in `members`, or their own ask in `requests`, is a violation.
      */
     self?: UserId;
     /**
      * The login's `AuthenticationState.capabilities`. The login is the permission: a lead's
-     * snapshot carries a roster, nobody else's does, and `requests` need `team.leadAssistControl`.
+     * snapshot carries a team member list, nobody else's does, and `requests` need `team.leadAssistControl`.
      */
     capabilities?: UserCapabilities;
     /** The level ids in force. Filled from the manifest by `validateSnapshot` and `validateEventEnvelope`; the defaults otherwise. */
@@ -99,7 +99,7 @@ export interface ReaderContext {
     /** `ConnectContext.autoAcceptTasks` as sent: whether a pending task states its `acceptance`. Unknown to a caller without the context, and then unchecked. */
     autoAcceptTasks?: boolean;
 }
-export declare function validateTeamRoster(roster: unknown, path?: string, context?: ReaderContext): ProtocolViolation[];
+export declare function validateTeamMembers(teamMembers: unknown, path?: string, context?: ReaderContext): ProtocolViolation[];
 export declare function validateSnapshot(snapshot: unknown, manifest: unknown, path?: string, context?: ReaderContext): ProtocolViolation[];
 export declare function validateEventEnvelope(envelope: unknown, manifest: unknown, path?: string, context?: ReaderContext): ProtocolViolation[];
 /**

package/dist/validation.js

@@ -98,11 +98,11 @@ const ISOLATION_SCHEME_VALUES = Object.values(BROWSER_ISOLATION_SCHEMES);
 /** The capabilities each channel arm of `TaskCapabilities` declares, keyed off the type itself. */
 const TASK_CAPABILITIES = {
     voice: membersOf({
-        browsers: true, dispositions: true, custom: true, decline: true, hold: true,
+        browsers: true, outcomes: true, custom: true, decline: true, hold: true,
         endCall: true, connectBack: true, coldTransfer: true, warmTransfer: true, leadAssist: true, conference: true, recording: true,
     }),
-    chat: membersOf({ browsers: true, dispositions: true, custom: true, decline: true, hold: true }),
-    email: membersOf({ browsers: true, dispositions: true, custom: true, decline: true }),
+    chat: membersOf({ browsers: true, outcomes: true, custom: true, decline: true, hold: true }),
+    email: membersOf({ browsers: true, outcomes: true, custom: true, decline: true }),
 };
 // The published list and the type's keys are the same set, or one of them is wrong.
 true;
@@ -607,41 +607,41 @@ function validateDestinationDirectory(value, path, into) {
         into.filled(destination.label, "task.destination.label", `${at}.label`, "a destination needs a label");
     });
 }
-function validateDispositions(value, path, into) {
+function validateOutcomes(value, path, into) {
     if (value === true)
         return;
     if (!isPlainObject(value)) {
-        into.add("task.dispositions.shape", path, "must be true or a disposition policy");
+        into.add("task.outcomes.shape", path, "must be true or an outcome policy");
         return;
     }
     if (value.required !== undefined) {
-        into.require(typeof value.required === "boolean", "task.dispositions.required", `${path}.required`, "required must be a boolean when present");
+        into.require(typeof value.required === "boolean", "task.outcomes.required", `${path}.required`, "required must be a boolean when present");
     }
     // A code must be collected before completion, so there must be one to collect.
     if (value.required === true && !(Array.isArray(value.codes) && value.codes.length > 0)) {
-        into.add("task.dispositions.required.codes", `${path}.codes`, "a required disposition policy must publish at least one code");
+        into.add("task.outcomes.required.codes", `${path}.codes`, "a required outcome policy must publish at least one code");
     }
     if (value.notes !== undefined)
-        into.oneOf(value.notes, NOTES_RULES, "task.dispositions.notes", `${path}.notes`);
+        into.oneOf(value.notes, NOTES_RULES, "task.outcomes.notes", `${path}.notes`);
     if (value.codes === undefined)
         return;
     if (!Array.isArray(value.codes)) {
-        into.add("task.dispositions.codes", `${path}.codes`, "codes must be an array when present");
+        into.add("task.outcomes.codes", `${path}.codes`, "codes must be an array when present");
         return;
     }
     const seen = new Set();
     value.codes.forEach((code, index) => {
         const at = `${path}.codes[${index}]`;
         if (!isPlainObject(code)) {
-            into.add("task.disposition.shape", at, "each disposition code must be an object");
+            into.add("task.outcome.shape", at, "each outcome code must be an object");
             return;
         }
-        if (into.filled(code.id, "task.disposition.id", `${at}.id`, "a disposition code needs an id")) {
+        if (into.filled(code.id, "task.outcome.id", `${at}.id`, "an outcome code needs an id")) {
             if (seen.has(code.id))
-                into.add("task.disposition.unique", `${at}.id`, `duplicate disposition code: ${code.id}`);
+                into.add("task.outcome.unique", `${at}.id`, `duplicate outcome code: ${code.id}`);
             seen.add(code.id);
         }
-        into.filled(code.label, "task.disposition.label", `${at}.label`, "a disposition code needs a label");
+        into.filled(code.label, "task.outcome.label", `${at}.label`, "an outcome code needs a label");
     });
 }
 function validateCustomCapabilities(value, path, into) {
@@ -697,7 +697,7 @@ const DEFAULT_LEVEL_IDS = DEFAULT_LEVELS.map(level => level.id);
 const POLICY_SETTINGS = membersOf({ on: true, off: true, person: true });
 const POLICY_KEYS = new Set([
     ...TASK_CAPABILITIES.voice, ...TASK_CAPABILITIES.chat, ...TASK_CAPABILITIES.email, "dial",
-].filter(name => name !== "browsers" && name !== "dispositions" && name !== "custom"));
+].filter(name => name !== "browsers" && name !== "outcomes" && name !== "custom"));
 const PERSON_SETTABLE = /^(hold|skill:.+)$/;
 const isLocked = (value) => isPlainObject(value) && value.lockedBy !== undefined;
 /** The level ids in force: the manifest's, or the defaults when the caller holds no manifest. */
@@ -1260,9 +1260,9 @@ function validateTaskInto(task, context, path, into) {
             into.add("task.capability.dialOutcomes.required", `${path}.capabilities.${name}`, `${name} dials, and the manifest declares no dialOutcomes to say how a dial ends`);
         }
         // A control the queue could allow may stand locked in its place, saying whose. What the
-        // queue provides -- browsers, dispositions, custom controls -- is content, not a control.
+        // queue provides -- browsers, outcomes, custom controls -- is content, not a control.
         if (isLocked(declared)) {
-            if (into.require(name !== "browsers" && name !== "dispositions" && name !== "custom", "task.capability.locked.unexpected", `${path}.capabilities.${name}`, `${name} is what the queue provides, not a control anyone locks`)) {
+            if (into.require(name !== "browsers" && name !== "outcomes" && name !== "custom", "task.capability.locked.unexpected", `${path}.capabilities.${name}`, `${name} is what the queue provides, not a control anyone locks`)) {
                 validateLockedInto(declared, "task.capability.locked", `${path}.capabilities.${name}`, context.levels, into);
             }
             continue;
@@ -1271,8 +1271,8 @@ function validateTaskInto(task, context, path, into) {
             case "recording":
                 into.violations.push(...validateRecordingPolicy(declared, `${path}.capabilities.recording`));
                 break;
-            case "dispositions":
-                validateDispositions(declared, `${path}.capabilities.dispositions`, into);
+            case "outcomes":
+                validateOutcomes(declared, `${path}.capabilities.outcomes`, into);
                 break;
             case "custom":
                 validateCustomCapabilities(declared, `${path}.capabilities.custom`, into);
@@ -1348,9 +1348,9 @@ export function validateBreakStatus(state, tasks, path = "snapshot") {
     return into.violations;
 }
 /**
- * Checks lead break dispatch using current authentication, transport, roster (`team`) and,
+ * Checks lead break dispatch using current authentication, transport, team member list (`team`) and,
  * for place/release, the target's full `memberBreak`. The provider must authorize the target
- * and recheck the decision atomically; a roster is not authority to act after it has changed.
+ * and recheck the decision atomically; a team member list is not authority to act after it has changed.
  */
 export function validateTeamBreakCommand(request, context, path = "teamBreakCommand") {
     const into = new Collector();
@@ -1388,7 +1388,7 @@ export function validateTeamBreakCommand(request, context, path = "teamBreakComm
     const members = Array.isArray(team.members) ? team.members : [];
     const member = 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 roster");
+    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");
     if (command.type === "decide") {
         into.require(command.decision === "granted" || command.decision === "denied", "team.break.command.decision", path, "decide granted or denied");
         into.require(isPlainObject(member) && member.break === "awaiting-decision", "team.break.command.awaiting", path, "decide only a currently awaiting-decision request");
@@ -1562,38 +1562,38 @@ function validateBreakState(value, path, into) {
         into.require(typeof value.activeReasonId === "string" && value.activeReasonId.length > 0, "break.activeReasonId.required", `${path}.activeReasonId`, `a break ${describeValue(value.approval)} on a provider that publishes reasons names the one it is on`);
     }
 }
-export function validateTeamRoster(roster, path = "team", context = {}) {
+export function validateTeamMembers(teamMembers, path = "team", context = {}) {
     const into = new Collector();
-    validateTeamRosterInto(roster, path, context, into);
+    validateTeamMembersInto(teamMembers, path, context, into);
     return into.violations;
 }
-function validateTeamRosterInto(roster, path, context, into) {
-    if (!isPlainObject(roster)) {
-        into.add("team.shape", path, "a team roster must be an object");
+function validateTeamMembersInto(teamMembers, path, context, into) {
+    if (!isPlainObject(teamMembers)) {
+        into.add("team.shape", path, "a team member list must be an object");
         return;
     }
-    // The login is the permission: a roster reaches a login that declares `capabilities.team` and
+    // 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 roster published to a login that does not declare capabilities.team: the login is the permission");
+        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 roster exactly when the login may set them.
+    // 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 && roster.policies === undefined) {
-            into.add("team.policies.required", `${path}.policies`, "the login declares team.policyControl, so the roster carries the team's policies");
+        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 && roster.policies !== undefined) {
+        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");
         }
     }
-    if (roster.policies !== undefined)
-        validateTeamPoliciesInto(roster.policies, `${path}.policies`, into, context.levels);
-    if (roster.requests === undefined) {
+    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 roster carries requests: [] when nobody is asking");
+            into.add("team.requests.required", `${path}.requests`, "the login declares team.leadAssistControl, so the team member list carries requests: [] when nobody is asking");
         }
     }
     else {
@@ -1602,12 +1602,12 @@ function validateTeamRosterInto(roster, path, context, into) {
         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(roster.requests)) {
+        if (!Array.isArray(teamMembers.requests)) {
             into.add("team.requests.shape", `${path}.requests`, "requests must be an array when present");
         }
         else {
             const seenRequests = new Set();
-            roster.requests.forEach((request, index) => {
+            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");
@@ -1619,7 +1619,7 @@ function validateTeamRosterInto(roster, path, context, into) {
                     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 roster carries the reader's own ask: an agent's request for a lead goes to whoever leads them");
+                    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(isTaskId(request.taskId), "team.request.taskId", `${at}.taskId`, "a request names the task the lead would join");
                 into.require(isAllocationId(request.allocationId), "team.request.allocationId", `${at}.allocationId`, "a request names the task by its allocation too");
@@ -1629,22 +1629,22 @@ function validateTeamRosterInto(roster, path, context, into) {
             });
         }
     }
-    if (!Array.isArray(roster.members)) {
-        into.add("team.members.shape", `${path}.members`, "a roster must carry a members array");
+    if (!Array.isArray(teamMembers.members)) {
+        into.add("team.members.shape", `${path}.members`, "a team member list must carry a members array");
         return;
     }
     const seen = new Set();
-    roster.members.forEach((member, index) => {
+    teamMembers.members.forEach((member, index) => {
         const at = `${path}.members[${index}]`;
         if (!isPlainObject(member)) {
-            into.add("team.member.shape", at, "each roster member must be an object");
+            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 roster member needs a user id")) {
+        if (into.require(isUserId(member.id), "team.member.id", `${at}.id`, "a team member needs a user id")) {
             if (seen.has(member.id))
-                into.add("team.member.unique", `${at}.id`, `duplicate roster member: ${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 roster carries the agent it is published to: a lead does not report to themself");
+            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)
@@ -1752,13 +1752,13 @@ export function validateSnapshot(snapshot, manifest, path = "snapshot", context
             into.add("snapshot.calendar.shape", `${path}.scheduledActivities`, "scheduledActivities must be an array when present");
         }
     }
-    // The login is the permission: a lead's snapshot carries a roster, `[]` included. The other
-    // direction -- a roster to a login that does not lead -- is the roster's own rule.
+    // 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 roster: [] when nobody is in it");
+        into.add("team.required", `${path}.team`, "the login declares capabilities.team, so every snapshot carries a team member list: [] when nobody is in it");
     }
     if (snapshot.team !== undefined)
-        validateTeamRosterInto(snapshot.team, `${path}.team`, { ...context, levels }, into);
+        validateTeamMembersInto(snapshot.team, `${path}.team`, { ...context, levels }, into);
     return into.violations;
 }
 // ---------------------------------------------------------------------------
@@ -1949,7 +1949,7 @@ export function validateEventEnvelope(envelope, manifest, path = "event", contex
             validateQueueSummary(event.summary, `${at}.summary`, into);
             break;
         case "team-updated":
-            validateTeamRosterInto(event.team, `${at}.team`, { ...context, levels }, into);
+            validateTeamMembersInto(event.team, `${at}.team`, { ...context, levels }, into);
             break;
         case "contacts-updated":
             into.require(idle.contacts === true, "event.contacts.capability", `${at}.contacts`, "contacts-updated requires the contacts idle capability");
@@ -2298,7 +2298,7 @@ export function validateTaskCommand(command, task, path = "command", taskContext
                 fields.push("dialId");
                 break;
             case "complete":
-                fields.push("disposition", "notes");
+                fields.push("outcome", "notes");
                 break;
             case "transfer":
                 fields.push("action");
@@ -2359,8 +2359,8 @@ export function validateTaskCommand(command, task, path = "command", taskContext
             into.violations.push(...validateRecordingCommandShape(command, "provider", path));
             break;
         case "complete":
-            if (command.disposition !== undefined)
-                into.filled(command.disposition, "command.complete.disposition", `${path}.disposition`, "a disposition must not be empty when present");
+            if (command.outcome !== undefined)
+                into.filled(command.outcome, "command.complete.outcome", `${path}.outcome`, "an outcome must not be empty when present");
             if (command.notes !== undefined)
                 into.require(typeof command.notes === "string", "command.complete.notes", `${path}.notes`, "notes must be a string when present");
             break;
@@ -2509,27 +2509,27 @@ export function validateTaskCommand(command, task, path = "command", taskContext
         }
         case "complete": {
             into.require(task.completionMode === "agent-command", "command.complete.mode", path, "complete belongs to agent-command; a provider-automatic task completes itself");
-            // What travels with complete is what the dispositions capability published: a code from its
+            // 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 dispositions = capabilities.dispositions;
-            if (dispositions === undefined) {
-                into.require(command.disposition === undefined, "command.complete.disposition.unexpected", `${path}.disposition`, "the task declares no dispositions; complete travels with no code");
-                into.require(command.notes === undefined, "command.complete.notes.unexpected", `${path}.notes`, "the task declares no dispositions; complete travels with no notes");
+            const outcomes = capabilities.outcomes;
+            if (outcomes === undefined) {
+                into.require(command.outcome === undefined, "command.complete.outcome.unexpected", `${path}.outcome`, "the task declares no outcomes; complete travels with no code");
+                into.require(command.notes === undefined, "command.complete.notes.unexpected", `${path}.notes`, "the task declares no outcomes; complete travels with no notes");
             }
-            else if (dispositions === true) {
-                into.require(command.disposition === undefined, "command.complete.disposition.unexpected", `${path}.disposition`, "a bare dispositions control publishes no code, so complete carries none");
+            else if (outcomes === true) {
+                into.require(command.outcome === undefined, "command.complete.outcome.unexpected", `${path}.outcome`, "a bare outcomes control publishes no code, so complete carries none");
             }
-            else if (isPlainObject(dispositions)) {
-                if (Array.isArray(dispositions.codes) && command.disposition !== undefined) {
-                    into.require(dispositions.codes.some(code => isPlainObject(code) && code.id === command.disposition), "command.complete.disposition.unknown", `${path}.disposition`, `${describeValue(command.disposition)} is not a code the task published`);
+            else if (isPlainObject(outcomes)) {
+                if (Array.isArray(outcomes.codes) && command.outcome !== undefined) {
+                    into.require(outcomes.codes.some(code => isPlainObject(code) && code.id === command.outcome), "command.complete.outcome.unknown", `${path}.outcome`, `${describeValue(command.outcome)} is not a code the task published`);
                 }
-                if (dispositions.required === true) {
-                    into.require(command.disposition !== undefined, "command.complete.disposition.required", `${path}.disposition`, "the task requires a disposition and complete carries none");
+                if (outcomes.required === true) {
+                    into.require(command.outcome !== undefined, "command.complete.outcome.required", `${path}.outcome`, "the task requires an outcome and complete carries none");
                 }
-                if (dispositions.notes === "none") {
+                if (outcomes.notes === "none") {
                     into.require(command.notes === undefined, "command.complete.notes.unexpected", `${path}.notes`, "the task takes no notes");
                 }
-                else if (dispositions.notes === "required") {
+                else if (outcomes.notes === "required") {
                     into.require(typeof command.notes === "string" && command.notes.length > 0, "command.complete.notes.required", `${path}.notes`, "the task requires notes and complete carries none");
                 }
             }