@ouro.bot/cli 0.1.0-alpha.586 → 0.1.0-alpha.587

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.587",
+      "changes": [
+        "Voice now has a pure duplex floor-control model with typed transitions, state summaries, and decision reasons for caller floor ownership, assistant speech, tool-running/tool-result states, stale suppression, and hangup terminal behavior.",
+        "Realtime Voice evals and trace replay now understand floor-state, speech-policy, and tool-result events, failing deterministic traces when assistant speech is allowed while the caller owns the floor, stale tool results are spoken, or responses are requested after hangup.",
+        "Voice trace reports now include floor diagnostics such as phase, floor owner, pending speech, pending/stale tool ids, interruption turn, and decision reason, with new golden fixtures for interruption, tool-duplex, stale suppression, progress acknowledgement, and hangup-with-pending-tool scenarios."
+      ]
+    },
     {
       "version": "0.1.0-alpha.586",
       "changes": [

package/dist/senses/voice/floor-control.js

@@ -0,0 +1,398 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialVoiceFloorState = createInitialVoiceFloorState;
+exports.canRequestVoiceResponse = canRequestVoiceResponse;
+exports.canSpeakToolHolding = canSpeakToolHolding;
+exports.canSpeakToolResult = canSpeakToolResult;
+exports.applyVoiceFloorEvent = applyVoiceFloorEvent;
+exports.replayVoiceFloorEvents = replayVoiceFloorEvents;
+exports.summarizeVoiceFloorState = summarizeVoiceFloorState;
+const runtime_1 = require("../../nerves/runtime");
+const MAX_TOOL_HOLDING_WORDS = 6;
+function createInitialVoiceFloorState() {
+    return {
+        phase: "idle",
+        floorOwner: "none",
+        terminal: false,
+        hangupRequested: false,
+        pendingToolCallIds: [],
+        staleToolCallIds: [],
+        spokenToolCallIds: [],
+        callerTurnIds: [],
+        toolCalls: {},
+    };
+}
+function decision(allowed, action, reason, details = {}) {
+    return { allowed, action, reason, ...details };
+}
+function copyState(state) {
+    return {
+        ...state,
+        pendingToolCallIds: [...state.pendingToolCallIds],
+        staleToolCallIds: [...state.staleToolCallIds],
+        spokenToolCallIds: [...state.spokenToolCallIds],
+        callerTurnIds: [...state.callerTurnIds],
+        toolCalls: { ...state.toolCalls },
+    };
+}
+function withUnique(values, value) {
+    return values.includes(value) ? values : [...values, value];
+}
+function withoutValue(values, value) {
+    return values.filter((candidate) => candidate !== value);
+}
+function rememberCallerTurn(state, turnId) {
+    state.latestCallerTurnId = turnId;
+    state.callerTurnIds = withUnique(state.callerTurnIds, turnId);
+}
+function hasNewerCallerTurn(state, turnId) {
+    if (!turnId || !state.latestCallerTurnId || state.latestCallerTurnId === turnId)
+        return false;
+    const originalIndex = state.callerTurnIds.indexOf(turnId);
+    const latestIndex = state.callerTurnIds.indexOf(state.latestCallerTurnId);
+    return originalIndex >= 0 && latestIndex > originalIndex;
+}
+function toolState(state, toolCallId) {
+    return state.toolCalls[toolCallId];
+}
+function setToolState(state, nextTool) {
+    state.toolCalls = { ...state.toolCalls, [nextTool.toolCallId]: nextTool };
+}
+function phaseAfterAssistantSpeech(state) {
+    const pendingTools = state.pendingToolCallIds.map((toolCallId) => state.toolCalls[toolCallId]).filter(Boolean);
+    if (pendingTools.some((tool) => tool.status === "ready"))
+        return "tool-result-ready";
+    if (pendingTools.some((tool) => tool.status === "running"))
+        return "tool-running";
+    return "listening";
+}
+function suppressForHangup(state, event) {
+    return {
+        event,
+        state,
+        decision: decision(false, "suppress", "hangup_terminal", { atMs: event.atMs }),
+    };
+}
+function canRequestVoiceResponse(state, input) {
+    if (state.terminal || state.hangupRequested || state.floorOwner === "terminal") {
+        return decision(false, "suppress", "hangup_terminal", { responseId: input.responseId });
+    }
+    if (state.floorOwner === "caller" || state.phase === "caller-speaking" || state.phase === "interrupted") {
+        return decision(false, "delay", "caller_has_floor", { responseId: input.responseId });
+    }
+    if (state.floorOwner === "assistant" || state.activeAssistantSpeechId) {
+        return decision(false, "delay", "assistant_has_floor", { responseId: input.responseId });
+    }
+    if (state.pendingSpeech) {
+        return decision(false, "delay", "response_pending", { responseId: input.responseId });
+    }
+    return decision(true, "allow", "ready_for_response", { responseId: input.responseId });
+}
+function canSpeakToolHolding(state, input) {
+    if (state.terminal || state.hangupRequested || state.floorOwner === "terminal") {
+        return decision(false, "suppress", "hangup_terminal", { toolCallId: input.toolCallId });
+    }
+    if (state.floorOwner === "caller" || state.phase === "caller-speaking" || state.phase === "interrupted") {
+        return decision(false, "delay", "caller_has_floor", { toolCallId: input.toolCallId });
+    }
+    const tool = toolState(state, input.toolCallId);
+    if (!tool || tool.status === "spoken") {
+        return decision(false, "suppress", "missing_tool_call", { toolCallId: input.toolCallId });
+    }
+    if (tool.status === "stale" || state.staleToolCallIds.includes(input.toolCallId)) {
+        return decision(false, "suppress", "stale_tool_result", { toolCallId: input.toolCallId });
+    }
+    const words = input.text?.trim().split(/\s+/).filter(Boolean).length ?? 0;
+    if (words > MAX_TOOL_HOLDING_WORDS) {
+        return decision(false, "suppress", "tool_holding_too_long", { toolCallId: input.toolCallId });
+    }
+    return decision(true, "allow", "tool_presence_allowed", { toolCallId: input.toolCallId });
+}
+function canSpeakToolResult(state, input) {
+    if (state.terminal || state.hangupRequested || state.floorOwner === "terminal") {
+        return decision(false, "suppress", "hangup_terminal", { toolCallId: input.toolCallId });
+    }
+    if (state.floorOwner === "caller" || state.phase === "caller-speaking" || state.phase === "interrupted") {
+        return decision(false, "delay", "caller_has_floor", { toolCallId: input.toolCallId });
+    }
+    const tool = toolState(state, input.toolCallId);
+    if (!tool || tool.status === "spoken") {
+        return decision(false, "suppress", "missing_tool_result", { toolCallId: input.toolCallId });
+    }
+    if (tool.status === "stale" || state.staleToolCallIds.includes(input.toolCallId)) {
+        return decision(false, "suppress", "stale_tool_result", { toolCallId: input.toolCallId });
+    }
+    if (tool.status !== "ready") {
+        return decision(false, "delay", "tool_still_running", { toolCallId: input.toolCallId });
+    }
+    return decision(true, "allow", "tool_result_ready", { toolCallId: input.toolCallId });
+}
+function applyConnected(state, event) {
+    const next = copyState(state);
+    next.phase = "listening";
+    next.floorOwner = "none";
+    next.terminal = false;
+    next.hangupRequested = false;
+    next.callId = event.callId;
+    return { event, state: next, decision: decision(true, "allow", "call_connected", { atMs: event.atMs }) };
+}
+function applyCallerSpeechStarted(state, event) {
+    const next = copyState(state);
+    rememberCallerTurn(next, event.turnId);
+    next.floorOwner = "caller";
+    if (state.activeAssistantSpeechId) {
+        next.phase = "interrupted";
+        next.interruption = {
+            turnId: event.turnId,
+            interruptedSpeechId: state.activeAssistantSpeechId,
+            atMs: event.atMs,
+        };
+        return {
+            event,
+            state: next,
+            decision: decision(false, "cancel", "caller_barge_in", {
+                atMs: event.atMs,
+                responseId: state.activeAssistantSpeechId,
+                interruptionTurnId: event.turnId,
+            }),
+        };
+    }
+    next.phase = "caller-speaking";
+    return { event, state: next, decision: decision(true, "allow", "caller_floor_started", { atMs: event.atMs }) };
+}
+function applyCallerSpeechEnded(state, event) {
+    const next = copyState(state);
+    rememberCallerTurn(next, event.turnId);
+    if (!next.activeAssistantSpeechId) {
+        next.floorOwner = "none";
+        next.phase = "listening";
+    }
+    return { event, state: next, decision: decision(true, "allow", "caller_floor_released", { atMs: event.atMs }) };
+}
+function applyCallerTranscriptFinal(state, event) {
+    const next = copyState(state);
+    rememberCallerTurn(next, event.turnId);
+    if (!next.activeAssistantSpeechId) {
+        next.floorOwner = "none";
+        next.phase = "thinking";
+    }
+    return { event, state: next, decision: decision(true, "allow", "caller_turn_ready", { atMs: event.atMs }) };
+}
+function applyAssistantResponseRequested(state, event) {
+    const requestDecision = canRequestVoiceResponse(state, { responseId: event.responseId, reason: event.reason });
+    if (!requestDecision.allowed)
+        return { event, state, decision: { ...requestDecision, atMs: event.atMs } };
+    const next = copyState(state);
+    next.phase = "thinking";
+    next.floorOwner = "none";
+    next.pendingSpeech = { responseId: event.responseId, reason: event.reason };
+    return { event, state: next, decision: { ...requestDecision, atMs: event.atMs } };
+}
+function applyAssistantSpeechStarted(state, event) {
+    const requestDecision = state.floorOwner === "caller"
+        ? decision(false, "delay", "caller_has_floor", { atMs: event.atMs, responseId: event.responseId })
+        : decision(true, "allow", "assistant_speech_allowed", { atMs: event.atMs, responseId: event.responseId });
+    if (!requestDecision.allowed)
+        return { event, state, decision: requestDecision };
+    const next = copyState(state);
+    next.phase = "speaking";
+    next.floorOwner = "assistant";
+    next.activeAssistantSpeechId = event.responseId;
+    next.pendingSpeech = undefined;
+    return { event, state: next, decision: requestDecision };
+}
+function applyAssistantSpeechDone(state, event) {
+    const next = copyState(state);
+    if (next.activeAssistantSpeechId === event.responseId)
+        next.activeAssistantSpeechId = undefined;
+    if (next.floorOwner === "assistant")
+        next.floorOwner = "none";
+    next.phase = phaseAfterAssistantSpeech(next);
+    return { event, state: next, decision: decision(true, "allow", "assistant_speech_done", { atMs: event.atMs, responseId: event.responseId }) };
+}
+function applyAssistantSpeechCancelled(state, event) {
+    const next = copyState(state);
+    if (next.activeAssistantSpeechId === event.responseId)
+        next.activeAssistantSpeechId = undefined;
+    if (next.interruption) {
+        next.floorOwner = "caller";
+        next.phase = "caller-speaking";
+    }
+    else {
+        next.floorOwner = "none";
+        next.phase = phaseAfterAssistantSpeech(next);
+    }
+    return {
+        event,
+        state: next,
+        decision: decision(true, "allow", "assistant_speech_cancelled", { atMs: event.atMs, responseId: event.responseId }),
+    };
+}
+function applyToolStarted(state, event) {
+    if (state.toolCalls[event.toolCallId]) {
+        return {
+            event,
+            state,
+            decision: decision(true, "allow", "duplicate_tool_start_ignored", { atMs: event.atMs, toolCallId: event.toolCallId }),
+        };
+    }
+    const next = copyState(state);
+    next.pendingToolCallIds = withUnique(next.pendingToolCallIds, event.toolCallId);
+    setToolState(next, {
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        turnId: event.turnId ?? next.latestCallerTurnId,
+        status: "running",
+        startedAtMs: event.atMs,
+    });
+    if (next.floorOwner === "none")
+        next.phase = "tool-running";
+    return { event, state: next, decision: decision(true, "allow", "tool_started", { atMs: event.atMs, toolCallId: event.toolCallId }) };
+}
+function applyToolHoldingSpoken(state, event) {
+    const holdingDecision = canSpeakToolHolding(state, { toolCallId: event.toolCallId, text: event.text });
+    if (!holdingDecision.allowed)
+        return { event, state, decision: { ...holdingDecision, atMs: event.atMs } };
+    return { event, state, decision: { ...holdingDecision, atMs: event.atMs } };
+}
+function applyToolCompleted(state, event) {
+    const existing = toolState(state, event.toolCallId);
+    if (!existing) {
+        return {
+            event,
+            state,
+            decision: decision(false, "suppress", "missing_tool_call", { atMs: event.atMs, toolCallId: event.toolCallId }),
+        };
+    }
+    if (existing.status !== "running") {
+        return {
+            event,
+            state,
+            decision: decision(true, "allow", "duplicate_tool_completion_ignored", { atMs: event.atMs, toolCallId: event.toolCallId }),
+        };
+    }
+    const turnId = event.turnId ?? existing.turnId;
+    const next = copyState(state);
+    if (hasNewerCallerTurn(next, turnId)) {
+        next.pendingToolCallIds = withoutValue(next.pendingToolCallIds, event.toolCallId);
+        next.staleToolCallIds = withUnique(next.staleToolCallIds, event.toolCallId);
+        setToolState(next, { ...existing, turnId, status: "stale", completedAtMs: event.atMs });
+        if (next.floorOwner === "none")
+            next.phase = "suppressing";
+        return {
+            event,
+            state: next,
+            decision: decision(false, "suppress", "newer_user_turn_started", { atMs: event.atMs, toolCallId: event.toolCallId }),
+        };
+    }
+    setToolState(next, { ...existing, turnId, status: "ready", completedAtMs: event.atMs });
+    next.pendingToolCallIds = withUnique(next.pendingToolCallIds, event.toolCallId);
+    if (next.floorOwner === "none")
+        next.phase = "tool-result-ready";
+    return { event, state: next, decision: decision(true, "allow", "tool_result_ready", { atMs: event.atMs, toolCallId: event.toolCallId }) };
+}
+function applyToolResultSpoken(state, event) {
+    const resultDecision = canSpeakToolResult(state, { toolCallId: event.toolCallId, text: event.text });
+    if (!resultDecision.allowed)
+        return { event, state, decision: { ...resultDecision, atMs: event.atMs } };
+    const existing = toolState(state, event.toolCallId);
+    const next = copyState(state);
+    setToolState(next, { ...existing, status: "spoken" });
+    next.pendingToolCallIds = withoutValue(next.pendingToolCallIds, event.toolCallId);
+    next.spokenToolCallIds = withUnique(next.spokenToolCallIds, event.toolCallId);
+    next.phase = phaseAfterAssistantSpeech(next);
+    return { event, state: next, decision: { ...resultDecision, atMs: event.atMs } };
+}
+function applyHangupRequested(state, event) {
+    const next = copyState(state);
+    next.phase = "hangup";
+    next.floorOwner = "terminal";
+    next.hangupRequested = true;
+    return { event, state: next, decision: decision(true, "allow", "hangup_requested", { atMs: event.atMs }) };
+}
+function applyCallEnded(state, event) {
+    const next = copyState(state);
+    next.phase = "ended";
+    next.floorOwner = "terminal";
+    next.terminal = true;
+    next.hangupRequested = true;
+    return { event, state: next, decision: decision(true, "allow", "call_ended", { atMs: event.atMs }) };
+}
+function applyVoiceFloorEvent(state, event) {
+    if (state.hangupRequested && event.type !== "call.ended" && event.type !== "hangup.requested")
+        return suppressForHangup(state, event);
+    switch (event.type) {
+        case "call.connected":
+            return applyConnected(state, event);
+        case "caller.speech.started":
+            return applyCallerSpeechStarted(state, event);
+        case "caller.speech.ended":
+            return applyCallerSpeechEnded(state, event);
+        case "caller.transcript.final":
+            return applyCallerTranscriptFinal(state, event);
+        case "assistant.response.requested":
+            return applyAssistantResponseRequested(state, event);
+        case "assistant.speech.started":
+            return applyAssistantSpeechStarted(state, event);
+        case "assistant.speech.done":
+            return applyAssistantSpeechDone(state, event);
+        case "assistant.speech.cancelled":
+            return applyAssistantSpeechCancelled(state, event);
+        case "tool.call.started":
+            return applyToolStarted(state, event);
+        case "tool.holding.spoken":
+            return applyToolHoldingSpoken(state, event);
+        case "tool.call.completed":
+            return applyToolCompleted(state, event);
+        case "tool.result.spoken":
+            return applyToolResultSpoken(state, event);
+        case "hangup.requested":
+            return applyHangupRequested(state, event);
+        case "call.ended":
+            return applyCallEnded(state, event);
+        default:
+            throw new Error(`unknown voice floor event: ${String(event.type)}`);
+    }
+}
+function replayVoiceFloorEvents(events) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_floor_replay_start",
+        message: "starting Voice floor-control replay",
+        meta: { events: events.length },
+    });
+    let state = createInitialVoiceFloorState();
+    const steps = [];
+    for (const event of events) {
+        const transition = applyVoiceFloorEvent(state, event);
+        steps.push(transition);
+        state = transition.state;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_floor_replay_end",
+        message: "finished Voice floor-control replay",
+        meta: { events: events.length, phase: state.phase, floorOwner: state.floorOwner },
+    });
+    return { state, steps };
+}
+function listSummary(values) {
+    return values.length > 0 ? values.join(",") : "none";
+}
+function summarizeVoiceFloorState(state) {
+    const parts = [
+        `phase=${state.phase}`,
+        `floor=${state.floorOwner}`,
+    ];
+    if (state.activeAssistantSpeechId)
+        parts.push(`activeSpeech=${state.activeAssistantSpeechId}`);
+    parts.push(`pendingTools=${listSummary(state.pendingToolCallIds)}`);
+    parts.push(`staleTools=${listSummary(state.staleToolCallIds)}`);
+    if (state.interruption)
+        parts.push(`interruption=${state.interruption.turnId}@${state.interruption.interruptedSpeechId}`);
+    if (state.hangupRequested)
+        parts.push("hangup=requested");
+    if (state.terminal)
+        parts.push("terminal=true");
+    return parts.join(" ");
+}

package/dist/senses/voice/realtime-eval.js

@@ -39,6 +39,25 @@ function lowerText(value) {
 function pushFinding(findings, finding) {
     findings.push(finding);
 }
+function floorDiagnostic(event, floor) {
+    return {
+        phase: event.floorPhase ?? floor?.floorPhase,
+        floorOwner: event.floorOwner ?? floor?.floorOwner,
+        speechDecision: event.speechDecision,
+        decisionReason: event.decisionReason ?? floor?.decisionReason,
+        responseId: event.type === "speech.policy.decision" || event.type === "response.requested"
+            ? event.correlationId
+            : undefined,
+        toolCallId: event.type === "tool.result.ready" || event.type === "tool.result.spoken"
+            ? event.correlationId
+            : undefined,
+        pendingSpeechId: event.pendingSpeechId ?? floor?.pendingSpeechId,
+        activeAssistantSpeechId: event.activeAssistantSpeechId ?? floor?.activeAssistantSpeechId,
+        pendingToolCallIds: event.pendingToolCallIds ?? floor?.pendingToolCallIds,
+        staleToolCallIds: event.staleToolCallIds ?? floor?.staleToolCallIds,
+        interruptionTurnId: event.interruptionTurnId ?? floor?.interruptionTurnId,
+    };
+}
 function gradeFirstAudio(events, expectation, findings) {
     const connected = firstEvent(events, "call.connected");
     const firstAudio = firstEvent(events, "assistant.audio.started");
@@ -256,6 +275,89 @@ function gradeOverlappingResponses(events, findings) {
         }
     }
 }
+function floorIsCallerOwned(floor) {
+    return floor?.floorOwner === "caller" || floor?.floorPhase === "caller-speaking" || floor?.floorPhase === "interrupted";
+}
+function floorIsTerminal(floor) {
+    return floor?.floorOwner === "terminal" || floor?.floorPhase === "hangup" || floor?.floorPhase === "ended";
+}
+function gradeDuplexFloorPolicy(events, findings) {
+    let floor;
+    let hangupAtMs;
+    for (const event of events) {
+        if (event.type === "floor.state.changed") {
+            floor = event;
+            continue;
+        }
+        if (event.type === "call.hangup.requested")
+            hangupAtMs = event.atMs;
+        if (event.type === "speech.policy.decision" && event.speechDecision === "allow") {
+            if (floorIsCallerOwned(floor)) {
+                pushFinding(findings, {
+                    code: "speech_allowed_while_caller_has_floor",
+                    severity: "fail",
+                    message: "Voice speech policy allowed assistant speech while the caller owned the floor.",
+                    source: event.source,
+                    atMs: event.atMs,
+                    floor: floorDiagnostic(event, floor),
+                });
+            }
+            else if (floorIsTerminal(floor) || hangupAtMs !== undefined) {
+                pushFinding(findings, {
+                    code: "speech_allowed_after_hangup",
+                    severity: "fail",
+                    message: "Voice speech policy allowed assistant speech after hangup began.",
+                    source: event.source,
+                    atMs: event.atMs,
+                    floor: floorDiagnostic(event, floor),
+                });
+            }
+        }
+        if (event.type === "tool.result.spoken") {
+            const diagnostic = floorDiagnostic(event, floor);
+            if (event.correlationId && floor?.staleToolCallIds?.includes(event.correlationId)) {
+                pushFinding(findings, {
+                    code: "stale_tool_result_spoken",
+                    severity: "fail",
+                    message: "Voice spoke a tool result that the floor model had already marked stale.",
+                    source: event.source,
+                    atMs: event.atMs,
+                    floor: diagnostic,
+                });
+            }
+            else if (floorIsCallerOwned(floor)) {
+                pushFinding(findings, {
+                    code: "tool_result_spoken_while_caller_has_floor",
+                    severity: "fail",
+                    message: "Voice spoke a tool result while the caller owned the floor.",
+                    source: event.source,
+                    atMs: event.atMs,
+                    floor: diagnostic,
+                });
+            }
+            else if (floorIsTerminal(floor) || hangupAtMs !== undefined) {
+                pushFinding(findings, {
+                    code: "tool_result_spoken_after_hangup",
+                    severity: "fail",
+                    message: "Voice spoke a tool result after hangup began.",
+                    source: event.source,
+                    atMs: event.atMs,
+                    floor: diagnostic,
+                });
+            }
+        }
+        if (event.type === "response.requested" && hangupAtMs !== undefined && event.atMs > hangupAtMs) {
+            pushFinding(findings, {
+                code: "response_after_hangup",
+                severity: "fail",
+                message: "Voice requested a new response after hangup had already been requested.",
+                source: event.source,
+                atMs: event.atMs,
+                floor: floorDiagnostic(event, floor),
+            });
+        }
+    }
+}
 function collectTransportSources(events) {
     return [...new Set(events.flatMap((event) => event.source ? [event.source.transport] : []))].sort();
 }
@@ -284,6 +386,7 @@ function gradeVoiceRealtimeEvalTimeline(scenarioId, timeline, expectation) {
     if (expectation.requireHangup)
         gradeHangup(events, findings);
     gradeOverlappingResponses(events, findings);
+    gradeDuplexFloorPolicy(events, findings);
     const report = {
         scenarioId: normalizedScenarioId,
         passed: findings.every((finding) => finding.severity !== "fail"),

package/dist/senses/voice/realtime-trace.js

@@ -57,17 +57,22 @@ const normalizedEvents = new Set([
     "call.connected",
     "call.ended",
     "call.hangup.requested",
+    "floor.state.changed",
     "response.requested",
     "response.truncated",
     "session.updated",
+    "speech.policy.decision",
     "tool.call.completed",
     "tool.call.started",
     "tool.holding.started",
+    "tool.result.ready",
+    "tool.result.spoken",
     "transport.playback_cleared",
     "user.transcript.done",
     "voice.context.injected",
 ]);
 const rawEventMap = new Map([
+    ["voice.floor.state.changed", "floor.state.changed"],
     ["openai.realtime.call.hangup.sent", "call.hangup.requested"],
     ["openai.realtime.conversation.item.truncate.sent", "response.truncated"],
     ["openai.realtime.input_audio_buffer.speech_started", "barge_in.detected"],
@@ -85,10 +90,28 @@ const rawEventMap = new Map([
     ["twilio.media.clear.sent", "transport.playback_cleared"],
     ["twilio.media.start", "call.connected"],
     ["voice.hangup.requested", "call.hangup.requested"],
+    ["voice.speech.policy.decision", "speech.policy.decision"],
     ["voice.tool_holding.started", "tool.holding.started"],
+    ["voice.tool.result.ready", "tool.result.ready"],
+    ["voice.tool.result.spoken", "tool.result.spoken"],
 ]);
 const expectedOutcomes = new Set(["expected-fail", "fail", "pass"]);
 const expectationProfiles = new Set(["voice-phone-default"]);
+const floorOwners = new Set(["assistant", "caller", "none", "terminal"]);
+const floorPhases = new Set([
+    "caller-speaking",
+    "ended",
+    "hangup",
+    "idle",
+    "interrupted",
+    "listening",
+    "speaking",
+    "suppressing",
+    "thinking",
+    "tool-result-ready",
+    "tool-running",
+]);
+const speechDecisions = new Set(["allow", "cancel", "delay", "suppress"]);
 function objectRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
@@ -107,6 +130,35 @@ function optionalString(value, name, sourceLabel) {
         throw new Error(label(sourceLabel, `${name} must be a string`));
     return value;
 }
+function optionalStringArray(value, name, sourceLabel) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new Error(label(sourceLabel, `${name} must be an array of strings`));
+    }
+    return [...value];
+}
+function optionalFloorOwner(value, sourceLabel) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !floorOwners.has(value))
+        throw new Error(label(sourceLabel, "floorOwner is unsupported"));
+    return value;
+}
+function optionalFloorPhase(value, sourceLabel) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !floorPhases.has(value))
+        throw new Error(label(sourceLabel, "floorPhase is unsupported"));
+    return value;
+}
+function optionalSpeechDecision(value, sourceLabel) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !speechDecisions.has(value))
+        throw new Error(label(sourceLabel, "speechDecision is unsupported"));
+    return value;
+}
 function parseSource(value, sourceLabel) {
     if (value === undefined)
         return undefined;
@@ -191,6 +243,15 @@ function parseTraceEvent(value, index, sourceLabel) {
         friendId: optionalString(raw.friendId, "friendId", eventLabel),
         sessionKey: optionalString(raw.sessionKey, "sessionKey", eventLabel),
         session: parseTurnDetection(raw.session, eventLabel),
+        floorOwner: optionalFloorOwner(raw.floorOwner, eventLabel),
+        floorPhase: optionalFloorPhase(raw.floorPhase, eventLabel),
+        speechDecision: optionalSpeechDecision(raw.speechDecision, eventLabel),
+        decisionReason: optionalString(raw.decisionReason, "decisionReason", eventLabel),
+        pendingSpeechId: optionalString(raw.pendingSpeechId, "pendingSpeechId", eventLabel),
+        activeAssistantSpeechId: optionalString(raw.activeAssistantSpeechId, "activeAssistantSpeechId", eventLabel),
+        pendingToolCallIds: optionalStringArray(raw.pendingToolCallIds, "pendingToolCallIds", eventLabel),
+        staleToolCallIds: optionalStringArray(raw.staleToolCallIds, "staleToolCallIds", eventLabel),
+        interruptionTurnId: optionalString(raw.interruptionTurnId, "interruptionTurnId", eventLabel),
         ignored: ignored || undefined,
         ignoreReason: optionalString(raw.ignoreReason, "ignoreReason", eventLabel),
     };
@@ -276,6 +337,15 @@ function toTimelineEvent(event, redacted) {
         friendId: event.friendId,
         sessionKey: event.sessionKey,
         session: event.session,
+        floorOwner: event.floorOwner,
+        floorPhase: event.floorPhase,
+        speechDecision: event.speechDecision,
+        decisionReason: event.decisionReason,
+        pendingSpeechId: event.pendingSpeechId,
+        activeAssistantSpeechId: event.activeAssistantSpeechId,
+        pendingToolCallIds: event.pendingToolCallIds,
+        staleToolCallIds: event.staleToolCallIds,
+        interruptionTurnId: event.interruptionTurnId,
     };
 }
 function sortedTimeline(events) {
@@ -376,6 +446,63 @@ function sourceForSummary(source) {
         return "";
     return source.id ? ` ${source.transport}/${source.id}` : ` ${source.transport}`;
 }
+function listForSummary(values) {
+    return values && values.length > 0 ? values.join(",") : undefined;
+}
+function floorForSummary(floor) {
+    const parts = [];
+    if (floor.phase)
+        parts.push(`phase=${floor.phase}`);
+    if (floor.floorOwner)
+        parts.push(`floor=${floor.floorOwner}`);
+    if (floor.pendingSpeechId)
+        parts.push(`pendingSpeech=${floor.pendingSpeechId}`);
+    const pendingTools = listForSummary(floor.pendingToolCallIds);
+    if (pendingTools)
+        parts.push(`pendingTools=${pendingTools}`);
+    const staleTools = listForSummary(floor.staleToolCallIds);
+    if (staleTools)
+        parts.push(`staleTools=${staleTools}`);
+    if (floor.interruptionTurnId)
+        parts.push(`interruption=${floor.interruptionTurnId}`);
+    if (floor.decisionReason)
+        parts.push(`reason=${floor.decisionReason}`);
+    if (floor.activeAssistantSpeechId)
+        parts.push(`activeSpeech=${floor.activeAssistantSpeechId}`);
+    if (floor.speechDecision)
+        parts.push(`decision=${floor.speechDecision}`);
+    if (floor.responseId)
+        parts.push(`response=${floor.responseId}`);
+    if (floor.toolCallId)
+        parts.push(`tool=${floor.toolCallId}`);
+    return parts.join(" ") || "none";
+}
+function floorEventForSummary(event) {
+    if (event.floorPhase === undefined
+        && event.floorOwner === undefined
+        && event.speechDecision === undefined
+        && event.decisionReason === undefined
+        && event.pendingSpeechId === undefined
+        && event.activeAssistantSpeechId === undefined
+        && event.pendingToolCallIds === undefined
+        && event.staleToolCallIds === undefined
+        && event.interruptionTurnId === undefined) {
+        return "";
+    }
+    return ` floor(${floorForSummary({
+        phase: event.floorPhase,
+        floorOwner: event.floorOwner,
+        speechDecision: event.speechDecision,
+        decisionReason: event.decisionReason,
+        responseId: event.type === "response.requested" || event.type === "speech.policy.decision" ? event.correlationId : undefined,
+        toolCallId: event.type === "tool.result.ready" || event.type === "tool.result.spoken" ? event.correlationId : undefined,
+        pendingSpeechId: event.pendingSpeechId,
+        activeAssistantSpeechId: event.activeAssistantSpeechId,
+        pendingToolCallIds: event.pendingToolCallIds,
+        staleToolCallIds: event.staleToolCallIds,
+        interruptionTurnId: event.interruptionTurnId,
+    })})`;
+}
 function formatVoiceRealtimeEvalTraceReport(result) {
     const lines = [
         `trace ${result.traceId} scenario ${result.scenarioId}`,
@@ -388,11 +515,13 @@ function formatVoiceRealtimeEvalTraceReport(result) {
         for (const finding of result.report.findings) {
             const message = result.artifact.redacted ? "[redacted]" : finding.message;
             lines.push(`- ${finding.code}${finding.atMs === undefined ? "" : ` at ${finding.atMs}ms`}: ${message}`);
+            if (finding.floor)
+                lines.push(`  floor: ${floorForSummary(finding.floor)}`);
         }
     }
     lines.push("events:");
     for (const event of result.timeline) {
-        lines.push(`- ${event.atMs}ms ${event.type}${sourceForSummary(event.source)}${textForSummary(result, event)}`);
+        lines.push(`- ${event.atMs}ms ${event.type}${sourceForSummary(event.source)}${textForSummary(result, event)}${floorEventForSummary(event)}`);
     }
     lines.push(`ignored provider events: ${result.ignoredEvents.length}`);
     for (const event of result.ignoredEvents) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.586",
+  "version": "0.1.0-alpha.587",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",