@xema/omni-protocol 0.1.71 → 0.1.72

package/dist/testing.js

@@ -1055,7 +1055,7 @@ export class TaskStream {
             case "task-updated":
                 if (id === undefined)
                     break;
-                ruleEvaluated("stream.taskUpdated.unknown", "stream.taskUpdated.capabilitySource", "stream.taskUpdated.phase", "stream.taskUpdated.allocation", "stream.taskUpdated.handlingHistory", "stream.taskMediaEnded.follow", "stream.taskUpdated.media", "stream.taskUpdated.stage");
+                ruleEvaluated("stream.taskUpdated.unknown", "stream.taskUpdated.capabilitySource", "stream.taskUpdated.phase", "stream.taskUpdated.allocation", "stream.taskUpdated.mediaOpen", "stream.taskUpdated.handlingHistory", "stream.taskMediaEnded.follow", "stream.taskUpdated.media", "stream.taskUpdated.stage");
                 if (known === undefined) {
                     refuse("stream.taskUpdated.unknown", `${at}.task.id`, `${id} was never offered or carried on a snapshot`);
                     break;
@@ -1094,6 +1094,15 @@ export class TaskStream {
                         refuse("stream.taskUpdated.handlingHistory", `${at}.task.handlingHistory`, `${id}'s record lost ${lost.join(", ")} on the update: an entry read by the host stays in the record until the task ends`);
                     }
                 }
+                // A task completes after its media ends, never around it: an update that moves a task to
+                // completing while the stream holds its audio as started is a call whose audio never ended,
+                // whoever caused the ending -- the drive's end-call, a transfer, the provider's own hand.
+                {
+                    const to = isRecord(event.task) ? String(event.task.phase) : "";
+                    if (to === "completing" && known.media === "started" && known.phase !== "completing") {
+                        refuse("stream.taskUpdated.mediaOpen", `${at}.task.phase`, `${id} moves to completing with its media still started: the audio ends first, on task-media-ended, and a wrap-up with the call still up is audio that never ended`);
+                    }
+                }
                 if (known.media === "ended") {
                     const phase = isRecord(event.task) ? String(event.task.phase) : "";
                     if (phase !== "completing") {
@@ -1519,11 +1528,18 @@ async function driveOneCall(drive) {
     // 5. End the call, where the agent may.
     if (drive.channel === "voice" && latestTask().phase === "in-progress" && offers("endCall")) {
         if (await send({ type: "end-call" }) !== undefined) {
+            // A task that completes with its audio still up is refused by the stream as it passes
+            // (stream.taskUpdated.mediaOpen); the drive does not also wait out the clock for an ending
+            // that is not coming, so the run reads by the rule and not by its timeout.
             const mediaEnded = await waitFor("task-media-ended after end-call", envelope => {
                 const event = envelope.event;
-                return event.type === "task-media-ended" && event.taskId === taskId ? event : undefined;
+                if (event.type === "task-media-ended" && event.taskId === taskId)
+                    return "ended";
+                if (event.type === "task-updated" && isTask(event.task) && event.task.id === taskId && event.task.phase === "completing")
+                    return "completing";
+                return undefined;
             }, cursor);
-            if (mediaEnded !== undefined)
+            if (mediaEnded?.found === "ended")
                 cursor = mediaEnded.at;
             if (await updated(t => t.phase === "completing", "the task completing after its media ended") !== undefined && offers("hold")) {
                 await holdRefusedOutsideHandling();

package/dist/validation.js

@@ -1021,6 +1021,12 @@ function validateTaskInto(task, context, path, into) {
     // The room is who is on the call now, and a task outlives its call by the whole of wrap-up: a
     // task whose call has ended -- completing, or media ended -- carries nobody, or the last thing the
     // wire said about the call stays true for ever. Empty and absent both say nobody.
+    // A completing task's call is over: its media has ended, or it never started. Audio still stated
+    // as started on a task in wrap-up is a call whose audio never ended -- the customer heard through
+    // the agent's notes -- and a task stating it contradicts itself.
+    if (task.phase === "completing" && task.media === "started") {
+        into.add("task.media.completing", `${path}.media`, "a completing task's media has ended or never started: the call is over, and media still started is audio that never ended");
+    }
     if (Array.isArray(task.onCall) && task.onCall.length > 0 && (task.phase === "completing" || task.media === "ended")) {
         into.add("task.onCall.ended", `${path}.onCall`, `the call has ended (${task.phase === "completing" ? "the task is completing" : "its media ended"}) and onCall still names people on it: the room is who is on the call now, and now nobody is`);
     }

package/guide.md

@@ -2854,7 +2854,12 @@ which the update itself shows: the party on the call carrying a `stage`. A compl
 republished as `in-progress` from a stale copy carries no such stage, and that is the ending the
 agent never saw. Audio arrives only on a task at work: `task-media-started` on a `completing` task
 is refused as it is on a pending one (`stream.taskMediaStarted.beforeWork`), since a connect-back
-returns the task to `in-progress` before any media.
+returns the task to `in-progress` before any media. And a task completes after its audio ends,
+never around it: an update moving a task to `completing` while the stream holds its media as
+started is refused (`stream.taskUpdated.mediaOpen`), whoever caused the ending, and a task stating
+`completing` with `media: "started"` contradicts itself on any snapshot or update
+(`task.media.completing`). The consequence the rule exists for is concrete: the customer's audio
+keeps playing through the agent's wrap-up.
 
 What the agent is told differs by source, and only one source tells them anything. Under `queue`
 and `ungoverned` the agent sees controls and nothing about where they came from: both are facts,

package/package.json

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