@xema/omni-protocol 0.1.81 → 0.1.82

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /** The protocol version implemented by this package. */
-export declare const OMNI_PROTOCOL_VERSION: 2;
+export declare const OMNI_PROTOCOL_VERSION: 1;
 /** Every version this package can interoperate with. */
 export declare const OMNI_SUPPORTED_PROTOCOL_VERSIONS: readonly number[];
 /**
@@ -431,16 +431,13 @@ export type UrlVisibility = "full" | "domain" | "hidden";
 export type RecordingSource = "provider" | "host";
 export type RecordingAction = "start" | "pause" | "resume" | "stop" | "cancel";
 export declare const RECORDING_ACTIONS: readonly ["start", "pause", "resume", "stop", "cancel"];
-/** Cancel's captured-audio disposition is explicit; stop always retains captured audio. */
-export type RecordingCancelEffect = "retain" | "discard";
 export interface RecordingActions {
     start?: true;
     pause?: true;
     resume?: true;
     stop?: true;
-    cancel?: {
-        effect: RecordingCancelEffect;
-    };
+    /** Abandon this recording and discard its captured audio. */
+    cancel?: true;
 }
 /** Per-task permission, not a provider-wide recording switch. Absence grants nothing. */
 export interface TaskRecordingPolicy {
@@ -477,15 +474,9 @@ export type RecordingCommand = {
 } & ({
     action: "start";
     recordingId?: never;
-    cancelEffect?: never;
-} | {
-    action: "pause" | "resume" | "stop";
-    recordingId: string;
-    cancelEffect?: never;
 } | {
-    action: "cancel";
+    action: "pause" | "resume" | "stop" | "cancel";
     recordingId: string;
-    cancelEffect: RecordingCancelEffect;
 });
 export interface HostRecordingReport {
     taskId: TaskId;
@@ -494,8 +485,9 @@ export interface HostRecordingReport {
 }
 /** Host declaration in ConnectContext, not the provider-owned Manifest. */
 export interface HostRecording {
+    /** Audible recording status announcements to the remote party, for host-owned capture only. */
+    announcesToCaller?: true;
     actions: RecordingAction[];
-    cancelEffects: RecordingCancelEffect[];
     /** Explicitly provisioned destinations. A task chooses one; no upload/storage fallback. */
     destinationIds: string[];
     execute(request: HostRecordingRequest): Promise<RecordingCommandResult>;

package/dist/index.js

@@ -2,7 +2,7 @@
 //
 // Where this file and guide.md disagree, the guide is right and this is a defect.
 /** The protocol version implemented by this package. */
-export const OMNI_PROTOCOL_VERSION = 2;
+export const OMNI_PROTOCOL_VERSION = 1;
 /** Every version this package can interoperate with. */
 export const OMNI_SUPPORTED_PROTOCOL_VERSIONS = [OMNI_PROTOCOL_VERSION];
 /**

package/dist/testing.js

@@ -872,11 +872,11 @@ export function assertTaskCapabilityWithdrawal(tasks, manifest, command) {
     if (withdrawn.length === 0) {
         throw new Error("Task capability withdrawal must end with at least one capability the offer declared withdrawn; a locked control is present without permission, not withdrawn");
     }
-    const before = validateTaskCommand(command, first, "command");
+    const before = validateTaskCommand(command, first, "command", context);
     if (before.length > 0) {
         throw new Error(`Task capability withdrawal: the command must be issuable against the task as offered, or its later refusal proves nothing (${before.map(v => v.rule).join(", ")})`);
     }
-    const after = validateTaskCommand(command, last, "command");
+    const after = validateTaskCommand(command, last, "command", context);
     const forWant = after.filter(v => withdrawn.some(name => v.rule === `command.capability.${name}`));
     if (forWant.length === 0) {
         throw new Error(`Task capability withdrawal: the command must be refused against the republished task for want of ${withdrawn.join(" or ")}; it was ${after.length === 0 ? "accepted" : `refused for ${after.map(v => v.rule).join(", ")}`}`);
@@ -1560,7 +1560,11 @@ async function driveOneCall(drive) {
     // Every command the drive sends is validated against the task as published, and its answer for its method.
     ruleEvaluated("drive.timeout");
     const send = async (command, dialId) => {
-        const own = validateTaskCommand(command, latestTask(), `drive.command.${String(command.type)}`);
+        const own = validateTaskCommand(command, latestTask(), `drive.command.${String(command.type)}`, {
+            levels: effectiveLevels(drive.manifest.orgLevels).map(level => level.id),
+            dialOutcomesDeclared: drive.manifest.dialOutcomes !== undefined,
+            autoAcceptTasks: drive.context.autoAcceptTasks,
+        });
         found.push(...own);
         if (own.length > 0)
             return undefined;

package/dist/validation.d.ts

@@ -100,7 +100,7 @@ export declare function validateHostReport(report: unknown, path?: string): Prot
  * own shape is checked. A host validates before sending, and an adapter before acting: a command
  * for a control the task never offered is the host's error, and this names it.
  */
-export declare function validateTaskCommand(command: unknown, task?: unknown, path?: string): ProtocolViolation[];
+export declare function validateTaskCommand(command: unknown, task?: unknown, path?: string, taskContext?: Omit<TaskValidationContext, "channel">): ProtocolViolation[];
 /** The connection methods whose results `validateResult` knows. */
 export type ResultMethod = "execute" | "dial" | "setCapacity" | "requestBreak" | "commitBreak" | "cancelBreak" | "endBreak" | "executeTeamBreak" | "executeTeamLeadAssist" | "executeTeamMonitor" | "openMedia" | "setPreference" | "recordStep" | "executeTeamPolicy";
 /**
@@ -151,6 +151,8 @@ export declare function validateRecordingRequest(request: unknown, task: unknown
     host?: unknown;
     hostReport?: unknown;
     softphone?: boolean;
+    /** The same provider/task context used to validate the published task. */
+    taskContext?: Omit<TaskValidationContext, "channel">;
 }, path?: string): ProtocolViolation[];
 /** Check recording-specific result semantics against the owner's confirming observations. */
 export declare function validateRecordingOutcome(command: unknown, before: unknown, after: unknown, result: unknown, path?: string): ProtocolViolation[];

package/dist/validation.js

@@ -2027,7 +2027,7 @@ const CONFERENCE_ACTIONS = ["add", "remove"];
  * own shape is checked. A host validates before sending, and an adapter before acting: a command
  * for a control the task never offered is the host's error, and this names it.
  */
-export function validateTaskCommand(command, task, path = "command") {
+export function validateTaskCommand(command, task, path = "command", taskContext) {
     const into = new Collector();
     if (!isPlainObject(command)) {
         into.add("command.shape", path, "a command must be an object");
@@ -2100,7 +2100,7 @@ export function validateTaskCommand(command, task, path = "command") {
     // checking against a task nobody has -- so the task is validated first, and a command is held
     // only to a task that stands.
     const published = new Collector();
-    validateTaskInto(task, { channel: channel ?? "voice" }, `${path}.task`, published);
+    validateTaskInto(task, { ...taskContext, channel: channel ?? "voice" }, `${path}.task`, published);
     if (published.violations.length > 0 || !isPlainObject(task)) {
         into.add("command.task", `${path}.task`, `the task the command is held to is not one the wire published (${published.violations.map(v => v.rule).join(", ")}): pass the task as the provider sent it, or validate the command's shape alone`);
         return into.violations;
@@ -2173,7 +2173,8 @@ export function validateTaskCommand(command, task, path = "command") {
             handling();
             break;
         case "recording": {
-            offered("recording");
+            if (!offered("recording"))
+                break;
             const policy = isPlainObject(capabilities.recording) ? capabilities.recording.provider : undefined;
             const state = isPlainObject(task.recording) ? task.recording.provider : undefined;
             into.violations.push(...validateRecordingCommandState(command, policy, state, path));
@@ -2589,7 +2590,6 @@ export function validateAuthenticationState(state, path = "authentication", cont
 // Independent current recording evidence and dispatch validation.
 const object = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const filled = (v) => typeof v === "string" && v.trim().length > 0;
-const effects = ["retain", "discard"];
 function collector() {
     const violations = [];
     const check = (ok, rule, path, message) => {
@@ -2660,14 +2660,7 @@ export function validateRecordingPolicy(value, path = "capabilities.recording")
         for (const action of RECORDING_ACTIONS) {
             if (policy[action] === undefined)
                 continue;
-            if (action === "cancel") {
-                const cancel = policy.cancel;
-                check(object(cancel) && effects.includes(cancel.effect), "cancel.effect", `${at}.cancel`, "cancel explicitly retains or discards this recording's captured audio");
-                if (object(cancel))
-                    keys(cancel, ["effect"], `${at}.cancel`);
-            }
-            else
-                check(policy[action] === true, "policy.action", `${at}.${action}`, "permission is true or absent");
+            check(policy[action] === true, "policy.action", `${at}.${action}`, "permission is true or absent");
         }
         if (source === "host")
             check(filled(policy.destinationId), "destination", `${at}.destinationId`, "host storage destination must be explicit per task");
@@ -2683,8 +2676,10 @@ export function validateHostRecording(value, softphone, path = "host.recording")
         check(false, "host.shape", path, "expected host recording declaration and executor");
         return violations;
     }
-    keys(value, ["actions", "cancelEffects", "destinationIds", "execute"], path);
-    for (const [key, allowed] of [["actions", RECORDING_ACTIONS], ["cancelEffects", effects], ["destinationIds", undefined]]) {
+    keys(value, ["actions", "destinationIds", "execute", "announcesToCaller"], path);
+    if (value.announcesToCaller !== undefined)
+        check(value.announcesToCaller === true, "host.announcesToCaller", `${path}.announcesToCaller`, "caller announcement guarantee is true or absent");
+    for (const [key, allowed] of [["actions", RECORDING_ACTIONS], ["destinationIds", undefined]]) {
         const list = value[key];
         if (!Array.isArray(list)) {
             check(false, "host.list", `${path}.${key}`, "expected explicit array");
@@ -2692,11 +2687,9 @@ export function validateHostRecording(value, softphone, path = "host.recording")
         }
         check(new Set(list).size === list.length, "host.duplicate", `${path}.${key}`, "duplicate declaration");
         check(list.every(item => filled(item) && (allowed === undefined || allowed.includes(item))), "host.list", `${path}.${key}`, "unsupported or empty declaration");
-        if (key !== "cancelEffects")
-            check(list.length > 0, "host.empty", `${path}.${key}`, "declare at least one supported value");
+        check(list.length > 0, "host.empty", `${path}.${key}`, "declare at least one supported value");
     }
-    if (Array.isArray(value.actions) && Array.isArray(value.cancelEffects)) {
-        check(value.actions.includes("cancel") === (value.cancelEffects.length > 0), "host.cancel", path, "cancel support and explicit effects must agree");
+    if (Array.isArray(value.actions)) {
         check(value.actions.includes("pause") === value.actions.includes("resume"), "host.pause", path, "a pausable host supports resume; task permissions may independently restrict it");
     }
     check(typeof value.execute === "function", "host.execute", `${path}.execute`, "host recording requires its own executor");
@@ -2732,32 +2725,47 @@ export function validateRecordingCommandShape(value, source, path = "command") {
         check(false, "command.shape", path, "expected recording command");
         return violations;
     }
-    keys(value, ["type", "source", "requestId", "observationId", "action", ...(value.action === "start" ? [] : ["recordingId"]), ...(value.action === "cancel" ? ["cancelEffect"] : [])], path);
+    keys(value, ["type", "source", "requestId", "observationId", "action", ...(value.action === "start" ? [] : ["recordingId"])], path);
     check(value.type === "recording" && value.source === source, "command.source", path, `this executor accepts only ${source} recording commands`);
     check(RECORDING_ACTIONS.includes(value.action), "command.action", `${path}.action`, "unsupported recording action");
     for (const key of ["requestId", "observationId", ...(value.action === "start" ? [] : ["recordingId"])])
         check(filled(value[key]), "command.identity", `${path}.${key}`, "expected nonempty scoped identity");
-    if (value.action === "cancel")
-        check(effects.includes(value.cancelEffect), "cancel.effect", `${path}.cancelEffect`, "explicit captured-audio disposition required");
     return violations;
 }
+/** One transition table shared by dispatch checks and outcome checks. */
+const RECORDING_TRANSITIONS = {
+    start: { from: ["inactive"], to: "active" },
+    pause: { from: ["active"], to: "paused" },
+    resume: { from: ["paused"], to: "active" },
+    stop: { from: ["active", "paused"], to: "inactive" },
+    cancel: { from: ["active", "paused"], to: "inactive" },
+};
+function recordingTransition(action) {
+    return typeof action === "string" && Object.hasOwn(RECORDING_TRANSITIONS, action)
+        ? RECORDING_TRANSITIONS[action] : undefined;
+}
 /** Structural/state permission check. Dispatch MUST also call validateRecordingRequest for scope and freshness. */
 export function validateRecordingCommandState(command, policy, state, path = "command") {
     const { violations, check } = collector();
-    if (!object(command))
+    if (!object(command)) {
+        check(false, "command.shape", path, "expected recording command");
+        return violations;
+    }
+    const transition = recordingTransition(command.action);
+    if (transition === undefined) {
+        check(false, "command.action", `${path}.action`, "unsupported recording action");
         return violations;
-    check(object(policy) && policy[command.action] !== undefined, "command.permission", path, "task does not permit this action on this recorder");
+    }
+    const permitted = object(policy) && policy[command.action] === true;
+    check(permitted, "command.permission", path, "task does not permit this action on this recorder");
     if (!object(state) || validateRecordingState(state).length) {
         check(false, "command.state", path, "no validated current recorder observation");
         return violations;
     }
-    const allowed = command.action === "start" ? ["inactive"] : command.action === "pause" ? ["active"] : command.action === "resume" ? ["paused"] : ["active", "paused"];
-    check(allowed.includes(state.status), "command.state", path, "action is invalid in the observed recorder state");
+    check(transition.from.includes(state.status), "command.state", path, "action is invalid in the observed recorder state");
     check(command.observationId === state.observationId, "command.stale", path, "observation changed; reconcile before acting");
     if (command.action !== "start")
         check(command.recordingId === state.recordingId, "command.recordingId", path, "command targets another recording");
-    if (command.action === "cancel" && object(policy))
-        check(object(policy.cancel) && command.cancelEffect === policy.cancel.effect, "command.cancelEffect", path, "cancel disposition must match task policy");
     return violations;
 }
 /** Validate immediately before dispatch using current task, host report and trusted observer-domain time. */
@@ -2767,7 +2775,7 @@ export function validateRecordingRequest(request, task, context, path = "request
         check(false, "request.shape", path, "request and current task required");
         return violations;
     }
-    violations.push(...validateTask(task, { channel: "voice" }, `${path}.task`));
+    violations.push(...validateTask(task, { ...context.taskContext, channel: "voice" }, `${path}.task`));
     keys(request, ["taskId", "allocationId", "command"], path);
     check(filled(request.taskId) && filled(request.allocationId) && request.taskId === task.id && request.allocationId === task.allocationId, "request.scope", path, "task allocation changed or scope missing");
     check(task.channel === "voice", "request.channel", path, "recording is voice-only");
@@ -2788,8 +2796,6 @@ export function validateRecordingRequest(request, task, context, path = "request
         if (object(context.host)) {
             check(Array.isArray(context.host.actions) && context.host.actions.includes(command.action), "host.action", path, "host does not support action");
             check(object(policy) && Array.isArray(context.host.destinationIds) && context.host.destinationIds.includes(policy.destinationId), "host.destination", path, "task destination is not provisioned by this host");
-            if (command.action === "cancel")
-                check(Array.isArray(context.host.cancelEffects) && context.host.cancelEffects.includes(command.cancelEffect), "host.cancelEffect", path, "host does not support cancel disposition");
         }
     }
     const fresh = effectiveRecordingState(state, context.now);
@@ -2819,12 +2825,13 @@ export function validateRecordingOutcome(command, before, after, result, path =
         check(before.status !== "unknown" && after.status === before.status && after.recordingId === before.recordingId, "outcome.noEffect", path, "failed promises confirmed no effect; ambiguous or partial effects have no result");
     }
     else if (result.status === "applied") {
-        const expected = command.action === "pause" ? "paused" : command.action === "start" || command.action === "resume" ? "active" : "inactive";
-        check(after.status === expected, "outcome.state", path, "applied requires the confirming requested state");
+        const transition = recordingTransition(command.action);
+        if (transition === undefined)
+            return violations; // shape validation already reported the unknown action
+        check(after.status === transition.to, "outcome.state", path, "applied requires the confirming requested state");
         check(after.observationId !== before.observationId, "outcome.observation", path, "an applied transition needs new confirming evidence");
         check(before.observationId === command.observationId, "outcome.stale", path, "command must act against its named observation");
-        const origin = command.action === "start" ? ["inactive"] : command.action === "pause" ? ["active"] : command.action === "resume" ? ["paused"] : ["active", "paused"];
-        check(origin.includes(before.status), "outcome.origin", path, "applied cannot claim an impossible transition");
+        check(transition.from.includes(before.status), "outcome.origin", path, "applied cannot claim an impossible transition");
         if (command.action !== "start")
             check(command.recordingId === before.recordingId, "outcome.recordingId", path, "command must target the prior recording");
         if (command.action === "pause" || command.action === "resume")

package/guide.md

@@ -58,7 +58,7 @@ transport, a task, a break and a call each have a word of their own:
 
 ### `OMNI_PROTOCOL_VERSION`
 
-The exact protocol version implemented by this package. The current value is `2`. Version 2 replaces the broad recording flag and untargeted recording command; version 1 is not negotiated by this package. Hosts and adapters must explicitly migrate together or retain their own version-1 implementation.
+The exact protocol version implemented by this package. The current value remains `1` during pre-release development. Recording contract changes do not introduce a new protocol version. Hosts and adapters adopt the current declarations together; this does not provide compatibility mapping for older recording shapes.
 
 ### `Manifest.supportedProtocolVersions`
 
@@ -292,13 +292,12 @@ type UrlVisibility = "full" | "domain" | "hidden";
 type RecordingSource = "provider" | "host";
 type RecordingAction = "start" | "pause" | "resume" | "stop" | "cancel";
 const RECORDING_ACTIONS = ["start", "pause", "resume", "stop", "cancel"] as const satisfies readonly RecordingAction[];
-type RecordingCancelEffect = "retain" | "discard";
 interface RecordingActions {
   start?: true;
   pause?: true;
   resume?: true;
   stop?: true;
-  cancel?: { effect: RecordingCancelEffect };
+  cancel?: true;
 }
 interface TaskRecordingPolicy {
   provider?: RecordingActions;
@@ -316,9 +315,8 @@ type RecordingCommand = {
   requestId: string;
   observationId: string;
 } & (
-  | { action: "start"; recordingId?: never; cancelEffect?: never }
-  | { action: "pause" | "resume" | "stop"; recordingId: string; cancelEffect?: never }
-  | { action: "cancel"; recordingId: string; cancelEffect: RecordingCancelEffect }
+  | { action: "start"; recordingId?: never }
+  | { action: "pause" | "resume" | "stop" | "cancel"; recordingId: string }
 );
 interface HostRecordingReport {
   taskId: TaskId;
@@ -326,8 +324,8 @@ interface HostRecordingReport {
   state: RecordingState;
 }
 interface HostRecording {
+  announcesToCaller?: true;
   actions: RecordingAction[];
-  cancelEffects: RecordingCancelEffect[];
   destinationIds: string[];
   execute(request: HostRecordingRequest): Promise<RecordingCommandResult>;
 }
@@ -4992,7 +4990,7 @@ capabilities and what its work is **called** through `phaseLabels` and `taskType
 any of it is drawn is Omni's. A task cannot select a design language, inject a component, or
 override the agent's theme and font preferences.
 
-## Independent task recording (protocol 2)
+## Independent task recording
 
 Recording is voice-only. A task can arrive already recording, including while pending, and offer
 no recording controls. The provider publishes only its own current state on
@@ -5019,14 +5017,14 @@ This package declares that contract; it supplies no recorder, media mixing, stor
 | pause | active | paused, preserving recording identity and captured audio |
 | resume | paused | active with the same recording identity |
 | stop | active or paused | inactive; finish and retain captured audio |
-| cancel | active or paused | inactive; abandon with the explicitly declared captured-audio disposition |
-
-Cancel must declare retain or discard in task policy and echo that exact effect in the command.
-Retain abandons further capture while preserving captured audio; discard additionally requires
-confirmed disposal of that recording's audio under the recorder's storage contract. Neither
-means cancelling an in-flight start request or deleting arbitrary past recordings. A recorder
-unable to guarantee the offered effect must not advertise it. Stop can be applied only after
-finalization/retention succeeds; cancel-discard only after cessation and disposition succeed.
+| cancel | active or paused | inactive; abandon and discard captured audio |
+
+Stop finishes the recording and retains captured audio. Cancel abandons the recording and discards
+its captured audio; the task policy offers it with `cancel: true`. There is no configurable cancel
+effect. A recorder that cannot confirm disposal must not offer Cancel; it can offer Stop instead.
+Cancel never means cancelling an in-flight start request or deleting arbitrary past recordings.
+Stop can be applied only after finalization/retention succeeds; Cancel only after both cessation
+and disposal of this recording's audio succeed under the recorder's storage contract.
 Partial success (capture stopped but storage outcome unknown) cannot return failed with a claim
 of no effect. It rejects with unknown outcome, reports the failure visibly and publishes whatever
 current capture state is actually known. Retention is not a promise of sample-perfect audio.
@@ -5075,8 +5073,9 @@ updates remain full current task/host views, not replayed provider events. These
 create no handling-history entries and infer no actors, durations or historical capture boundaries.
 
 Migration is explicit: replace the old true recording capability with per-path action policies,
-replace untargeted commands with scoped commands, and declare protocol 2 only after implementing
-these semantics. Existing version-1 adapters are refused by negotiation rather than silently mapped.
+replace untargeted commands with scoped commands, and retain protocol version 1. During pre-release
+development, hosts and adapters must align their recording contracts; negotiation does not detect
+differences between package revisions that share that protocol number. No legacy-shape fallback is provided.
 This change does not publish a package or enable recording in any existing host/provider by itself.
 
 `validateRecordingOutcome` checks confirming observations against recording-specific applied/failed
@@ -5088,3 +5087,48 @@ keep that binding through pause/resume/stop/cancel; a later policy cannot redire
 The executor rejects a mismatched destination rather than moving or discarding another binding.
 Action permission does not authorize unattended invocation: host controls require the agent's explicit
 act, and provider authorization remains enforced at its authenticated command boundary.
+
+
+Recording dispatch must receive the same known task-validation context as the published task.
+Pass organisation levels and other known restrictions through the optional fourth argument of
+`validateTaskCommand`, and through `taskContext` in `validateRecordingRequest`. This keeps a valid
+custom organisation lock from being rejected against the default ladder, and prevents known
+capability restrictions from disappearing at dispatch. The standalone `validateRecordingCommandState`
+requires an affirmative permission; false, malformed permission declarations and unknown actions grant nothing.
+
+
+### Host recording announcements to the caller
+
+`HostRecording.announcesToCaller`, when true, is a guarantee that the host delivers audible recording
+status messages to the remote party over the call's outgoing audio. It belongs inside the optional
+host recording capability: without that capability there is no such guarantee. Omission makes no
+promise; false is invalid. It does not belong in the provider manifest, the task's recording policy
+or the general `HostGuarantees` object. A provider can inspect this host guarantee when deciding
+whether to permit host recording on a task.
+
+The guarantee applies only to host-owned recordings. Providers implement announcements for their
+own recordings at their end; provider state updates must not cause the host to announce those
+recordings. Both recorders can operate independently on the same call.
+
+On a confirmed host start, the remote party hears that recording started. On a confirmed stop or
+cancel, they hear that recording stopped. If pause/resume is supported, say paused/resumed so a
+pause is not presented as a finished recording. Announcements follow actual capture transitions,
+not button clicks, accepted requests or task-policy changes. When attaching to an already-active
+host recording, announce that recording is active, without inventing its original start time.
+Repeated observations of the same state do not repeat announcements. Unknown or expired evidence
+must never produce a stopped announcement.
+
+A local sound, UI indicator, screen-reader message to the agent, or sound leaking through the
+microphone does not fulfil this guarantee. The host must deliver the message directly in the audio
+sent to the remote party, even when the agent microphone is muted. It may also notify the agent.
+Only declare the guarantee when the host can provide that outgoing audio path. An announcement
+that cannot be delivered, including after the remote party has disconnected, is a visible failure;
+never claim delivery or replay the notice into a different call.
+
+For a command under this guarantee, applied requires both the recording action and its announcement
+to succeed. If capture changes but announcement delivery fails, publish the actual recording state,
+report the announcement failure visibly and reject with unknown command outcome. Do not claim no
+effect, automatically repeat the recording action or silently switch to an agent-only notice.
+
+`validateHostRecording` checks the declaration, including its true-or-absent guarantee. Actual audio
+delivery remains the host implementation's responsibility and must be exercised in its own tests.

package/package.json

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