@xema/omni-protocol 0.1.84 → 0.1.85

package/dist/index.d.ts

@@ -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;

package/dist/testing.d.ts

@@ -7,7 +7,7 @@ export { ProtocolConformanceError, assertNoViolations, type ProtocolViolation }
  * rules -- each optional part of a task, each optional part of the break state and roster, 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[];

package/dist/testing.js

@@ -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))
@@ -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.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);
@@ -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");
                 }
             }

package/guide.md

@@ -527,12 +527,12 @@ type DialResult =
 ### Task capabilities
 
 ```ts
-type DispositionCode = { id: string; label: string; group?: string };
+type OutcomeCode = { id: string; label: string; group?: string };
 
-type DispositionRules = {
+type OutcomeRules = {
   required?: boolean;
   notes?: "required" | "optional" | "none";
-  codes?: DispositionCode[];
+  codes?: OutcomeCode[];
 };
 
 type Destination = {
@@ -557,7 +557,7 @@ type CustomCapability = {
 
 type SharedTaskCapabilities = {
   browsers?: true;
-  dispositions?: true | DispositionRules;
+  outcomes?: true | OutcomeRules;
   custom?: CustomCapability[];
 };
 
@@ -793,7 +793,7 @@ const TASK_COMMAND_NAMES = {
 type TaskCommandName<C extends keyof typeof TASK_COMMAND_NAMES> =
   (typeof TASK_COMMAND_NAMES)[C][number];
 
-type DispositionPayload = { disposition?: string; notes?: string };
+type OutcomePayload = { outcome?: string; notes?: string };
 
 type VoiceTaskCommand =
   | { type: "answer" }
@@ -815,19 +815,19 @@ type VoiceTaskCommand =
   | { type: "conference"; action: "remove"; destinationId: string; party?: never }
   | { type: "conference"; action: "remove"; party: true; destinationId?: never }
   | (RecordingCommand & { source: "provider" })
-  | ({ type: "complete" } & DispositionPayload);
+  | ({ type: "complete" } & OutcomePayload);
 
 type ChatTaskCommand =
   | { type: "accept" }
   | { type: "decline" }
   | { type: "pause" }
   | { type: "resume" }
-  | ({ type: "complete" } & DispositionPayload);
+  | ({ type: "complete" } & OutcomePayload);
 
 type EmailTaskCommand =
   | { type: "accept" }
   | { type: "decline" }
-  | ({ type: "complete" } & DispositionPayload);
+  | ({ type: "complete" } & OutcomePayload);
 
 type CustomTaskCommand = { type: "custom"; name: string; [key: string]: unknown };
 
@@ -898,7 +898,7 @@ The adapter is the one that knows the value, so it is the one held to it: given
 queue locked, the validator refuses any other field carrying one, digits compared as digits so no
 formatting hides them (`task.locked.leak`), and a conformance run whose tasks lock a party's number
 or email states those values in `lockedValues`, since a run that cannot ask the question is not a
-pass. A host never has the value and never asks. A name is not locked. What the queue provides rather than permits — browsers, dispositions, custom
+pass. A host never has the value and never asks. A name is not locked. What the queue provides rather than permits — browsers, outcomes, custom
 controls — is content, and is never locked.
 
 **A lead sets the team's policy from their roster.** A login that declares
@@ -1499,7 +1499,7 @@ normative definition; matching names alone do not establish shared meaning.
 
 ### 10. Order on the wire is display order
 
-A list the provider publishes — a destination directory, disposition codes, a task's custom
+A list the provider publishes — a destination directory, outcome codes, a task's custom
 controls, its browsers — is in the order the provider wants it shown, and a host keeps that order.
 A reader will find meaning in position unless something says there is none, so the provider
 decides: where it has an intention, an administrator's sequence, it lists in that order; where it
@@ -2368,7 +2368,7 @@ into a new session.
 `task-offered` introduces a new task and does not imply acceptance.
 
 `Task<C>` is channel-discriminated. For example, `Task<"email">` accepts
-`browsers` and `dispositions`, but rejects voice-only controls such as `hold` and `endCall` at compile
+`browsers` and `outcomes`, but rejects voice-only controls such as `hold` and `endCall` at compile
 time. Runtime conformance checks also require the task channel to match its provider manifest.
 
 | Field | Contract |
@@ -2493,7 +2493,7 @@ ring-back is audio the agent hears -- so `task-media-started` arrives on the `pr
 its party ringing. On `answered` the task is `in-progress`; on any other outcome the media ends,
 `task-media-ended` starts the wrap clock as on every voice task, and the task goes to
 `completing`, so the agent records the
-no-answer as the disposition it is -- in a campaign that is the commonest outcome there is, and it
+no-answer as the outcome it is -- in a campaign that is the commonest outcome there is, and it
 is work, not a cancellation. A `preview` task therefore needs a manifest that says how a dial ends
 (`task.preview.dialOutcomes.required`).
 
@@ -2631,7 +2631,7 @@ const emailCompletion = {
 ```
 
 In this example, the agent has two minutes after sending the email to add notes, select a
-disposition, and complete the task.
+outcome, and complete the task.
 
 `0` means completion may happen immediately. With `provider-automatic`, the provider may complete
 without waiting for a command; with `agent-command`, it still waits for `complete`.
@@ -2694,7 +2694,7 @@ window it cannot, and declaring it there changes nothing.
 ```ts
 const connectBackCapable = {
   channel: "voice",
-  capabilities: { hold: true, connectBack: true, dispositions: true },
+  capabilities: { hold: true, connectBack: true, outcomes: true },
   phase: "completing",
   completionMode: "provider-automatic",
   wrapAllowance: 30,
@@ -2737,8 +2737,7 @@ Migration from the earlier spelling:
 Update producers, consumers, saved task snapshots, and validation-rule assertions together.
 History/report rule names now use `interactionHistory`/`interactionReport`; phase and conformance
 rules use `interaction` and final-task rules use `completion`. Legacy fields are rejected even
-when the new field is also supplied. `DispositionCode`, `DispositionRules`, `DispositionPayload`,
-`dispositions`, and `disposition` still describe outcome codes and are unchanged.
+when the new field is also supplied.
 
 
 `Task.interactionHistory` is the call record: the steps that brought the task to the agent, oldest
@@ -3079,7 +3078,7 @@ source is one more published fact about them, and the one that lets a host tell
 
 **Completing the task is not a capability, and no capability set withholds it.** `complete` is
 governed by `completionMode` alone: under `agent-command` it is always available, whatever the set
-says, and the `dispositions` capability decides only whether a code travels with it. Likewise
+says, and the `outcomes` capability decides only whether a code travels with it. Likewise
 Answer on a pending task and Call on a preview are the phase's controls, not the set's. The
 capability set governs what the agent may do *with* the task; completing it is never on the
 list.
@@ -3173,7 +3172,7 @@ const taskCapabilities = {
   channel: "voice",
   capabilities: {
     hold: true,
-    dispositions: true,
+    outcomes: true,
   },
   browsers: [],
 } satisfies Pick<Task<"voice">, "channel" | "capabilities" | "browsers">;
@@ -3181,7 +3180,7 @@ const taskCapabilities = {
 
 A capability says the control may be offered; the task's phase says whether there is anything to use
 it on. Every control below that acts on the call or the conversation -- everything but `decline`,
-`connectBack` and `dispositions` -- is offered only while the task is `in-progress` or `paused`.
+`connectBack` and `outcomes` -- is offered only while the task is `in-progress` or `paused`.
 See **Which commands need a capability**.
 
 ### Voice capabilities
@@ -3197,20 +3196,40 @@ See **Which commands need a capability**.
 | `leadAssist` | Secondary menu item: Lead assist | Omni may ask a lead to join this call, with a note. The lead's decision reaches the agent on `Task.leadAssist`. See **Lead assist**. |
 | `conference` | Secondary button: Conference | Omni may dial a destination into the active call, and remove one person from it -- a conferenced entry, one still ringing included, which calls the dial off, or the party, leaving the agent with the colleague. See **Ending a call, and removing one person from it**. |
 | `recording` | Overflow menu item: Recording | Per-task provider and host policies expose only their permitted recording actions; each has independent state and routing. |
-| `dispositions` | Primary button: Complete | Omni may request task completion with a provider disposition and notes. |
+| `outcomes` | Primary button: Complete | Omni may request task completion with a provider outcome and notes. |
 
 ### Publishing codes and destinations
 
 Four capabilities accept an object when the provider wants Omni to render real choices. For
-`dispositions` alone, `true` remains valid and means "offer the control with nothing published";
+`outcomes` alone, `true` remains valid and means "offer the control with nothing published";
 the three directory controls -- `coldTransfer`, `warmTransfer`, `conference` -- carry their
 directory or are refused, since once nothing is typed the directory is the control.
 
-#### `dispositions`
+#### `outcomes`
+
+An outcome describes what happened; completion finishes the task. Outcome codes are selected
+from the task's own published list. They are distinct from `DialOutcome`, which reports the
+result of a dial attempt.
+
+Migration requires providers and hosts to adopt the renamed types and fields together:
+
+| Former API | Current API |
+| --- | --- |
+| DispositionCode | `OutcomeCode` |
+| DispositionRules | `OutcomeRules` |
+| DispositionPayload | `OutcomePayload` |
+| Task.capabilities.dispositions | `Task.capabilities.outcomes` |
+| complete.disposition | `complete.outcome` |
+
+Validation and conformance diagnostics use `task.outcomes`, `task.outcome`, and
+`command.complete.outcome` in place of the former names. Update retained task snapshots and
+command producers as well as imports. Old capability and command fields are rejected, including
+payloads containing both names; there are no compatibility aliases. Code IDs, notes, required
+selection rules, and completion behavior are unchanged.
 
 ```ts
 capabilities: {
-  dispositions: {
+  outcomes: {
     required: true,
     notes: "optional",
     codes: [
@@ -3225,9 +3244,9 @@ capabilities: {
 | --- | --- |
 | `required` | When `true`, Omni must collect a code before issuing `complete`. A required policy must publish at least one code. |
 | `notes` | `required`, `optional`, or `none`; controls the free-text field beside the code. |
-| `codes` | Codes Omni offers. `id` values are non-empty and unique; Omni sends the chosen `id` as `TaskCommand.complete.disposition`. |
+| `codes` | Codes Omni offers. `id` values are non-empty and unique; Omni sends the chosen `id` as `TaskCommand.complete.outcome`. |
 
-With `dispositions: true` Omni shows a Complete control and sends `complete` with no code, because
+With `outcomes: true` Omni shows a Complete control and sends `complete` with no code, because
 the provider published none.
 
 #### `coldTransfer`, `warmTransfer` and `conference`
@@ -3360,14 +3379,14 @@ customer.
 | --- | --- | --- |
 | `decline` | Pending-task button: Decline | The provider can decline a pending chat offer. Omni shows it only when provisioning also permits declining. |
 | `hold` | Primary toggle: Hold | Omni may pause and resume the agent’s interaction in the chat. |
-| `dispositions` | Primary button: Complete | Omni may request task completion with a provider disposition and notes. |
+| `outcomes` | Primary button: Complete | Omni may request task completion with a provider outcome and notes. |
 
 ### Email capabilities
 
 | Capability | Omni UI | Contract |
 | --- | --- | --- |
 | `decline` | Pending-task button: Decline | The provider can decline a pending email offer. Omni shows it only when provisioning also permits declining. |
-| `dispositions` | Primary button: Complete | Omni may request task completion with a provider disposition and notes. |
+| `outcomes` | Primary button: Complete | Omni may request task completion with a provider outcome and notes. |
 
 ### Custom capabilities
 
@@ -4138,7 +4157,7 @@ choice that is no command at all:
 | --- | --- | --- |
 | `{ type: "lead-assist", action: "take-over" }` | `task-media-ended`, then `task-ended` with `{ type: "taken-over", leadId }`: **no `completing` window**, the agent is idle at once. The audio ends first, as before every voice ending (`stream.taskEnded.mediaOpen`), and the lead is named by user id, since a lead is not a directory item | Continues alone, and ends as any call does |
 | `{ type: "lead-assist", action: "leave" }` | Continues; `leadAssist` is cleared | `task-media-ended`, then `task-ended` with `{ type: "left" }` -- the call goes on without them |
-| Stays until the customer hangs up | `task-media-ended`, `completing`, its own disposition | The same, independently: **both have the completion window** |
+| Stays until the customer hangs up | `task-media-ended`, `completing`, its own outcome | The same, independently: **both have the completion window** |
 
 `left` is the one outcome that ends a task without ending the call: this agent left a call that
 continues without them. It reads as neither a completion nor a cancellation, because it is
@@ -4147,7 +4166,7 @@ neither.
 ```ts
 const leadAssistCapable = {
   channel: "voice",
-  capabilities: { hold: true, leadAssist: true, dispositions: true },
+  capabilities: { hold: true, leadAssist: true, outcomes: true },
   phase: "in-progress",
   leadAssist: { stage: "joined", leadId: "L-9", note: "Refund dispute, needs approval", since: "2026-08-21T09:04:00Z" },
 } satisfies Pick<Task<"voice">, "channel" | "capabilities" | "phase" | "leadAssist">;
@@ -4468,8 +4487,8 @@ with a stale view: a flip against a state the provider has already changed turns
 then off again. A custom `toggle` control therefore carries its own boolean. `hold` and `resume`,
 `pause` and `resume` need no flag, being pairs rather than toggles.
 
-**`complete` sends a disposition only where one was published.** `disposition` is a
-`DispositionCode.id` from the task's own `dispositions` capability, and `notes` obeys that
+**`complete` sends an outcome only where one was published.** `outcome` is a
+`OutcomeCode.id` from the task's own `outcomes` capability, and `notes` obeys that
 capability's `notes` setting. A task publishing no codes still receives `complete`, with neither.
 
 ### Where a command executes
@@ -4574,7 +4593,7 @@ declared:
 | `conference` with `action: "remove"` | The `conference` capability, and somebody else on the call: a remove that would leave the agent alone is `end-call`, and a provider answers it `failed`. |
 | `decline` | The `decline` capability on any channel, **and** Omni provisioning permitting it. One word for refusing an offer, whatever the channel. |
 | `call` | The `preview` phase. A record put in front of an agent is there to be called, so the phase is the gate and there is no capability. It is a dial, with a `dialId` and a `dial-outcome`. |
-| `complete` | `completionMode: "agent-command"`. The `dispositions` capability decides whether a code travels with the command, never whether the command exists — a task Omni cannot complete never ends. What travels is what the capability published: a code from its list where it has one (`command.complete.disposition.unknown`), a code at all where it requires one (`.disposition.required`), notes as it said (`.notes.required`, `.notes.unexpected`), and neither where the task declares no dispositions (`.disposition.unexpected`). |
+| `complete` | `completionMode: "agent-command"`. The `outcomes` capability decides whether a code travels with the command, never whether the command exists — a task Omni cannot complete never ends. What travels is what the capability published: a code from its list where it has one (`command.complete.outcome.unknown`), a code at all where it requires one (`.outcome.required`), notes as it said (`.notes.required`, `.notes.unexpected`), and neither where the task declares no outcomes (`.outcome.unexpected`). |
 | `connect-back` | The `connectBack` capability **and** the `completing` phase. It exists to reach the party again after the call, so it has no meaning while the call is up. |
 | `transfer` with `action: "warm"` | The `warmTransfer` capability. `action: "cold"` is gated by `coldTransfer`; the two are declared and offered separately. |
 | `transfer` with `action: "complete"` or `"cancel"` | A consultation in progress -- a `consulted` entry on `Task.onCall`. Without one there is nothing to complete or cancel, and a provider that receives either answers `failed`. |
@@ -5198,7 +5217,7 @@ outcome -- stays in `notExercised` for every adapter, and a rule about a live ca
 in each adopter's own tests. `{ drive: true }` closes that: the exercise takes the first task the
 provider offers through one ordinary lifecycle -- accept it, wait for its media and open it on a
 softphone, hold and resume where the task offers `hold`, end the call where it offers `endCall`,
-complete it with a disposition where the agent completes -- and holds every step to the rules a
+complete it with an outcome where the agent completes -- and holds every step to the rules a
 host holds a provider to. Each command is validated against the task as published
 (`drive.command.*`), each answer for its method, a refusal of a control the task offered is a
 violation (`drive.command.failed`), and an event the provider owes and never sends is one too
@@ -5405,7 +5424,7 @@ same operation; reuse with different contents is refused. It never silently retr
 operation. Implementations without reliable request correlation must refuse controls.
 
 Keep command progress in host UI separately from authoritative state. Applied means the requested
-transition and disposition actually completed; publish the confirming task or host report before
+recording transition and any retain/discard effect actually completed; publish the confirming task or host report before
 resolving applied. Failed means confirmed no effect. Rejected promise means outcome unknown:
 show the failure, reconcile that path and do not automatically retry or pretend inactive. Authoritative
 updates remain full current task/host views, not replayed provider events. These current-state fields

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xema/omni-protocol",
-  "version": "0.1.84",
+  "version": "0.1.85",
   "description": "The Omni protocol: the contract every provider adapter implements",
   "type": "module",
   "license": "MIT",