@ouro.bot/cli 0.1.0-alpha.560 → 0.1.0-alpha.561

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.561",
+      "changes": [
+        "Voice golden-path orchestration now accepts meeting URLs, checks local BlackHole/Multi-Output readiness, runs Whisper.cpp STT, routes text through ordinary `voice` sessions, streams ElevenLabs TTS, and writes playback-ready audio artifacts.",
+        "Voice runtime edges now include default Node Whisper.cpp process execution, default Node WebSocket adaptation for ElevenLabs, and tested playback artifact handling while keeping credentials injected at runtime.",
+        "Shared sense turns now store sessions under the explicit agent's bundle instead of depending on process argv for the session path, and voice setup guidance now reflects meeting URL intake plus live-browser handoff limits truthfully."
+      ]
+    },
     {
       "version": "0.1.0-alpha.560",
       "changes": [

package/dist/heart/daemon/cli-exec.js

@@ -4276,7 +4276,7 @@ async function executeConnectVoice(agent, deps) {
         `  ouro vault config set --agent ${agent} --scope machine --key voice.whisperCliPath`,
         `  ouro vault config set --agent ${agent} --scope machine --key voice.whisperModelPath`,
         "Then enable agent.json: senses.voice.enabled = true and restart with `ouro up`.",
-        "Meeting-link joining and browser/system audio routing are tracked as the next milestone.",
+        "Meeting links use URL intake plus BlackHole/Multi-Output readiness checks. Live browser join/injection is a handoff edge until provider automation lands.",
     ].join("\n");
     deps.writeStdout(message);
     return message;

package/dist/mind/prompt.js

@@ -502,7 +502,7 @@ function senseRuntimeGuidance(channel, preReadStatusLines) {
     lines.push("mail validation diagnostics: health checks, bounded mail tools, access logs, and UI inspection can support validation, but they are evidence inside those paths, not additional paths. If asked to name golden paths, do not include diagnostic commands, tool names, or status checks in the answer.");
     lines.push("mail diagnostic naming: `ouro doctor` is installation-wide; do not invent `ouro doctor --agent <agent>`.");
     lines.push("mail setup boundaries: do not invent `ouro auth verify --provider mail`, HEY OAuth, HEY IMAP, `ouro mcp call mail ...`, policy flags, autonomous sending, destructive mail actions, or production MX/DNS/forwarding changes. HEY export, HEY forwarding, DNS, MX cutover, sending, and destructive actions require explicit human confirmation.");
-    lines.push("voice setup truth: voice sessions are transcript-first local sessions. ElevenLabs credentials belong in portable runtime/config at `integrations.elevenLabsApiKey`; Whisper.cpp CLI/model paths belong in the machine runtime item under `voice.whisperCliPath` and `voice.whisperModelPath`. Meeting-link joining and browser/system audio routing are a later milestone, not current setup truth.");
+    lines.push("voice setup truth: voice sessions are transcript-first local sessions. ElevenLabs credentials belong in portable runtime/config at `integrations.elevenLabsApiKey`; Whisper.cpp CLI/model paths belong in the machine runtime item under `voice.whisperCliPath` and `voice.whisperModelPath`. Meeting links now have URL intake and local BlackHole/Multi-Output readiness checks; live browser join/injection remains an explicit handoff edge until provider automation lands.");
     if (channel === "cli") {
         lines.push("cli is interactive: it is available when the user opens it, not something `ouro up` daemonizes.");
     }

package/dist/senses/shared-turn.js

@@ -43,6 +43,7 @@ exports.stripThinkBlocks = stripThinkBlocks;
 exports.runSenseTurn = runSenseTurn;
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 const core_1 = require("../heart/core");
 const identity_1 = require("../heart/identity");
 const config_1 = require("../heart/config");
@@ -130,7 +131,9 @@ async function runSenseTurn(options) {
     // Initialize MCP manager so MCP tools appear as first-class tools in the agent's tool list
     const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
     // Session path and loading
-    const sessPath = (0, config_1.sessionPath)(friendId, channel, sessionKey);
+    const sessionDir = path.join(agentRoot, "state", "sessions", friendId, channel);
+    fs.mkdirSync(sessionDir, { recursive: true });
+    const sessPath = path.join(sessionDir, `${(0, config_1.sanitizeKey)(sessionKey)}.json`);
     const existing = (0, context_1.loadSession)(sessPath);
     let sessionState = existing?.state;
     let persistPromise;

package/dist/senses/voice/audio-routing.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeVoiceCommandRunner = createNodeVoiceCommandRunner;
+exports.inspectVoiceAudioRouting = inspectVoiceAudioRouting;
+const child_process_1 = require("child_process");
+const runtime_1 = require("../../nerves/runtime");
+function createNodeVoiceCommandRunner() {
+    return (command, args, options) => new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error(`command timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (exitCode) => {
+            clearTimeout(timer);
+            resolve({
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8"),
+                exitCode: exitCode ?? 0,
+            });
+        });
+    });
+}
+function parseDeviceLines(output) {
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function commandFailureMessage(exitCode, result) {
+    const stderr = result.stderr?.trim();
+    if (stderr)
+        return stderr;
+    const stdout = result.stdout?.trim();
+    if (stdout)
+        return stdout;
+    return `exit ${exitCode}`;
+}
+function setupGuidance(missing, currentOutput, outputDeviceName) {
+    const guidance = missing.map((device) => `Install or configure the local audio device: ${device}.`);
+    if (currentOutput && currentOutput !== outputDeviceName) {
+        guidance.push(`Browser meeting audio should be routed through ${outputDeviceName}; current output is ${currentOutput}.`);
+    }
+    return guidance;
+}
+async function inspectVoiceAudioRouting(options = {}) {
+    const commandRunner = options.commandRunner ?? createNodeVoiceCommandRunner();
+    const switchAudioSourcePath = options.switchAudioSourcePath ?? "SwitchAudioSource";
+    const captureDeviceName = options.captureDeviceName ?? "BlackHole 2ch";
+    const outputDeviceName = options.outputDeviceName ?? "Multi-Output Device";
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    try {
+        const devicesResult = await commandRunner(switchAudioSourcePath, ["-a"], { timeoutMs });
+        if (typeof devicesResult.exitCode === "number" && devicesResult.exitCode !== 0) {
+            throw new Error(commandFailureMessage(devicesResult.exitCode, devicesResult));
+        }
+        const currentResult = await commandRunner(switchAudioSourcePath, ["-c"], { timeoutMs });
+        if (typeof currentResult.exitCode === "number" && currentResult.exitCode !== 0) {
+            throw new Error(commandFailureMessage(currentResult.exitCode, currentResult));
+        }
+        const devices = parseDeviceLines(devicesResult.stdout ?? "");
+        const currentOutput = parseDeviceLines(currentResult.stdout ?? "")[0] ?? null;
+        const hasCaptureDevice = devices.includes(captureDeviceName);
+        const hasOutputDevice = devices.includes(outputDeviceName);
+        const missing = [
+            ...(hasCaptureDevice ? [] : [captureDeviceName]),
+            ...(hasOutputDevice ? [] : [outputDeviceName]),
+        ];
+        const result = {
+            status: missing.length === 0 ? "ready" : "needs_setup",
+            hasCaptureDevice,
+            hasOutputDevice,
+            currentOutput,
+            missing,
+            guidance: setupGuidance(missing, currentOutput, outputDeviceName),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_audio_routing_checked",
+            message: "voice audio routing readiness checked",
+            meta: {
+                status: result.status,
+                hasCaptureDevice,
+                hasOutputDevice,
+                currentOutput,
+                missing,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const result = {
+            status: "unknown",
+            hasCaptureDevice: false,
+            hasOutputDevice: false,
+            currentOutput: null,
+            missing: [captureDeviceName, outputDeviceName],
+            guidance: setupGuidance([captureDeviceName, outputDeviceName], null, outputDeviceName),
+            error: message,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_audio_routing_error",
+            message: "voice audio routing readiness check failed",
+            meta: { error: message, missing: result.missing },
+        });
+        return result;
+    }
+}

package/dist/senses/voice/elevenlabs.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_ELEVENLABS_MIME_TYPE = exports.DEFAULT_ELEVENLABS_OUTPUT_FORMAT = exports.DEFAULT_ELEVENLABS_MODEL_ID = void 0;
+exports.createNodeElevenLabsSocketFactory = createNodeElevenLabsSocketFactory;
 exports.createElevenLabsTtsClient = createElevenLabsTtsClient;
 const runtime_1 = require("../../nerves/runtime");
 exports.DEFAULT_ELEVENLABS_MODEL_ID = "eleven_flash_v2_5";
@@ -14,15 +15,67 @@ function elevenLabsStreamUrl(voiceId, modelId, outputFormat) {
     return `wss://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voiceId)}/stream-input?${params.toString()}`;
 }
 function payloadText(payload) {
+    if (payload && typeof payload === "object" && "data" in payload) {
+        return payloadText(payload.data);
+    }
     if (typeof payload === "string")
         return payload;
     if (Buffer.isBuffer(payload))
         return payload.toString("utf8");
     return String(payload ?? "");
 }
+function createNodeElevenLabsSocketFactory(webSocketConstructor) {
+    const WebSocketConstructor = webSocketConstructor
+        ?? globalThis.WebSocket;
+    if (!WebSocketConstructor) {
+        throw new Error("global WebSocket is unavailable; inject an ElevenLabs socketFactory");
+    }
+    return (url) => {
+        const socket = new WebSocketConstructor(url);
+        const handlers = {
+            open: [],
+            message: [],
+            error: [],
+            close: [],
+        };
+        const emit = (event, payload) => {
+            for (const handler of handlers[event]) {
+                handler(payload);
+            }
+        };
+        const attach = (event) => {
+            const listener = (payload) => emit(event, payload);
+            if (typeof socket.addEventListener === "function") {
+                socket.addEventListener(event, listener);
+            }
+            else if (typeof socket.on === "function") {
+                socket.on(event, listener);
+            }
+            else {
+                socket[`on${event}`] = listener;
+            }
+        };
+        attach("open");
+        attach("message");
+        attach("error");
+        attach("close");
+        return {
+            on(event, handler) {
+                handlers[event].push(handler);
+            },
+            send(payload) {
+                socket.send(payload);
+            },
+            close() {
+                socket.close();
+            },
+        };
+    };
+}
 function createElevenLabsTtsClient(options) {
     const modelId = options.modelId ?? exports.DEFAULT_ELEVENLABS_MODEL_ID;
     const outputFormat = options.outputFormat ?? exports.DEFAULT_ELEVENLABS_OUTPUT_FORMAT;
+    const socketFactory = options.socketFactory ?? createNodeElevenLabsSocketFactory();
     const mimeType = outputFormat === exports.DEFAULT_ELEVENLABS_OUTPUT_FORMAT
         ? exports.DEFAULT_ELEVENLABS_MIME_TYPE
         : "audio/mpeg";
@@ -40,7 +93,7 @@ function createElevenLabsTtsClient(options) {
                 throw new Error("voice TTS text is empty");
             }
             const url = elevenLabsStreamUrl(options.voiceId, modelId, outputFormat);
-            const socket = options.socketFactory(url);
+            const socket = socketFactory(url);
             const chunks = [];
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",

package/dist/senses/voice/golden-path.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVoiceGoldenPath = runVoiceGoldenPath;
+const runtime_1 = require("../../nerves/runtime");
+const audio_routing_1 = require("./audio-routing");
+const meeting_1 = require("./meeting");
+const playback_1 = require("./playback");
+const turn_1 = require("./turn");
+const defaultVoiceMeetingJoiner = {
+    async join(request) {
+        const result = {
+            status: "manual_required",
+            detail: `Open ${request.meeting.redactedUrl} in a browser profile whose meeting audio is routed through Multi-Output Device.`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_meeting_join_manual_required",
+            message: "voice meeting join requires browser handoff",
+            meta: {
+                provider: request.meeting.provider,
+                sessionKey: request.meeting.sessionKey,
+                routingStatus: request.audioRouting.status,
+            },
+        });
+        return result;
+    },
+};
+function defaultUtteranceId() {
+    return `voice-${Date.now().toString(36)}`;
+}
+function playbackSkipped() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_golden_path_playback_skipped",
+        message: "voice golden path skipped playback because TTS failed",
+        meta: { reason: "tts_failed" },
+    });
+    return {
+        status: "skipped",
+        reason: "tts_failed",
+        playbackAttempted: false,
+    };
+}
+async function runVoiceGoldenPath(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_golden_path_start",
+        message: "starting voice golden path",
+        meta: { agentName: options.agentName, friendId: options.friendId },
+    });
+    try {
+        const meeting = (0, meeting_1.parseVoiceMeetingUrl)(options.meetingUrl);
+        const audioRouting = await (options.inspectAudioRouting ?? audio_routing_1.inspectVoiceAudioRouting)();
+        const joiner = options.meetingJoiner ?? defaultVoiceMeetingJoiner;
+        const join = await joiner.join({ meeting, audioRouting });
+        const utteranceId = options.utteranceId ?? defaultUtteranceId();
+        const transcript = await options.transcriber.transcribe({
+            utteranceId,
+            audioPath: options.audioPath,
+            language: options.language,
+        });
+        const sessionKey = options.sessionKey ?? meeting.sessionKey;
+        const runSenseTurn = options.runSenseTurn;
+        const turn = await (0, turn_1.runVoiceLoopbackTurn)({
+            agentName: options.agentName,
+            friendId: options.friendId,
+            sessionKey,
+            transcript,
+            tts: options.tts,
+            runSenseTurn,
+        });
+        const writePlaybackArtifact = options.writePlaybackArtifact ?? playback_1.writeVoicePlaybackArtifact;
+        const playback = turn.tts.status === "delivered"
+            ? await writePlaybackArtifact({
+                utteranceId,
+                delivery: turn.tts,
+                outputDir: options.outputDir,
+                playAudio: options.playAudio ?? false,
+            })
+            : playbackSkipped();
+        const result = {
+            meeting,
+            audioRouting,
+            join,
+            transcript,
+            responseText: turn.responseText,
+            ponderDeferred: turn.ponderDeferred,
+            tts: turn.tts,
+            playback,
+            sessionKey,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_golden_path_end",
+            message: "finished voice golden path",
+            meta: {
+                sessionKey,
+                joinStatus: join.status,
+                ttsStatus: turn.tts.status,
+                playbackStatus: playback.status,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_golden_path_error",
+            message: "voice golden path failed",
+            meta: { error: message },
+        });
+        throw new Error(`voice golden path failed: ${message}`);
+    }
+}

package/dist/senses/voice/index.js

@@ -20,3 +20,7 @@ __exportStar(require("./transcript"), exports);
 __exportStar(require("./whisper"), exports);
 __exportStar(require("./elevenlabs"), exports);
 __exportStar(require("./turn"), exports);
+__exportStar(require("./meeting"), exports);
+__exportStar(require("./audio-routing"), exports);
+__exportStar(require("./playback"), exports);
+__exportStar(require("./golden-path"), exports);

package/dist/senses/voice/meeting.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactVoiceMeetingUrl = redactVoiceMeetingUrl;
+exports.parseVoiceMeetingUrl = parseVoiceMeetingUrl;
+const crypto_1 = require("crypto");
+const runtime_1 = require("../../nerves/runtime");
+function isRiversideHost(host) {
+    return host === "riverside.fm" || host === "riverside.com";
+}
+function stableMeetingHash(provider, url) {
+    return (0, crypto_1.createHash)("sha256")
+        .update(`${provider}:${url.protocol}//${url.host}${url.pathname}`)
+        .digest("hex")
+        .slice(0, 12);
+}
+function redactPath(pathname) {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return "/";
+    if (parts.length === 1)
+        return "/:redacted";
+    return `/${parts[0]}/:redacted`;
+}
+function redactVoiceMeetingUrl(input) {
+    try {
+        const url = new URL(input);
+        return `${url.protocol}//${url.host}${redactPath(url.pathname)}`;
+    }
+    catch {
+        return ":invalid";
+    }
+}
+function parseVoiceMeetingUrl(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "voice meeting URL is empty",
+            meta: { reason: "empty" },
+        });
+        throw new Error("voice meeting URL is empty");
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "voice meeting URL is invalid",
+            meta: { reason: "invalid_url" },
+        });
+        throw new Error("voice meeting URL is invalid");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "voice meeting URL must be http or https",
+            meta: { protocol: url.protocol },
+        });
+        throw new Error("voice meeting URL must be http or https");
+    }
+    const host = url.hostname.toLowerCase();
+    const provider = isRiversideHost(host) ? "riverside" : "generic";
+    if (provider === "riverside" && !url.pathname.startsWith("/studio/")) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "Riverside voice meeting URLs must use /studio/",
+            meta: { host, redactedUrl: redactVoiceMeetingUrl(trimmed) },
+        });
+        throw new Error("Riverside voice meeting URLs must use /studio/");
+    }
+    if (provider === "generic" && url.protocol !== "https:") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "generic voice meeting URLs must use https",
+            meta: { host, redactedUrl: redactVoiceMeetingUrl(trimmed) },
+        });
+        throw new Error("generic voice meeting URLs must use https");
+    }
+    const hash = stableMeetingHash(provider, url);
+    const meeting = {
+        originalUrl: trimmed,
+        provider,
+        host,
+        pathname: url.pathname,
+        redactedUrl: redactVoiceMeetingUrl(trimmed),
+        sessionKey: `voice-${provider}-${hash}`,
+        requiresBrowserJoin: true,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_meeting_parsed",
+        message: "voice meeting URL parsed",
+        meta: {
+            provider: meeting.provider,
+            host: meeting.host,
+            sessionKey: meeting.sessionKey,
+            redactedUrl: meeting.redactedUrl,
+        },
+    });
+    return meeting;
+}

package/dist/senses/voice/playback.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeVoicePlaybackArtifact = writeVoicePlaybackArtifact;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const audio_routing_1 = require("./audio-routing");
+function audioExtension(mimeType) {
+    if (mimeType === "audio/mpeg")
+        return "mp3";
+    if (mimeType === "audio/wav" || mimeType === "audio/x-wav")
+        return "wav";
+    if (mimeType.startsWith("audio/pcm"))
+        return "pcm";
+    return "audio";
+}
+function safeFileStem(input) {
+    const stem = input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return stem || "utterance";
+}
+function commandFailureMessage(exitCode, result) {
+    const stderr = result.stderr?.trim();
+    if (stderr)
+        return `exit ${exitCode}: ${stderr}`;
+    const stdout = result.stdout?.trim();
+    if (stdout)
+        return `exit ${exitCode}: ${stdout}`;
+    return `exit ${exitCode}`;
+}
+async function writeVoicePlaybackArtifact(request) {
+    const mkdir = request.mkdir ?? fs.mkdir;
+    const writeFile = request.writeFile ?? fs.writeFile;
+    const commandRunner = request.commandRunner ?? (0, audio_routing_1.createNodeVoiceCommandRunner)();
+    const timeoutMs = request.timeoutMs ?? 30_000;
+    const playbackCommandPath = request.playbackCommandPath ?? "afplay";
+    const audioPath = path.join(request.outputDir, `${safeFileStem(request.utteranceId)}.${audioExtension(request.delivery.mimeType)}`);
+    await mkdir(request.outputDir, { recursive: true });
+    await writeFile(audioPath, request.delivery.audio);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_playback_artifact_written",
+        message: "voice playback artifact written",
+        meta: {
+            utteranceId: request.utteranceId,
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+        },
+    });
+    if (request.playAudio !== true) {
+        return {
+            status: "written",
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+            playbackAttempted: false,
+        };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_playback_start",
+        message: "starting voice playback",
+        meta: { utteranceId: request.utteranceId, audioPath, playbackCommandPath },
+    });
+    try {
+        const result = await commandRunner(playbackCommandPath, [audioPath], { timeoutMs });
+        if (typeof result.exitCode === "number" && result.exitCode !== 0) {
+            throw new Error(commandFailureMessage(result.exitCode, result));
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_playback_end",
+            message: "finished voice playback",
+            meta: { utteranceId: request.utteranceId, audioPath },
+        });
+        return {
+            status: "played",
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+            playbackAttempted: true,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_playback_error",
+            message: "voice playback failed",
+            meta: { utteranceId: request.utteranceId, audioPath, error: message },
+        });
+        return {
+            status: "failed",
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+            playbackAttempted: true,
+            error: message,
+        };
+    }
+}

package/dist/senses/voice/whisper.js

@@ -34,10 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWhisperCppTranscriptJson = parseWhisperCppTranscriptJson;
+exports.createNodeWhisperCppProcessRunner = createNodeWhisperCppProcessRunner;
 exports.createWhisperCppTranscriber = createWhisperCppTranscriber;
 const fs = __importStar(require("fs/promises"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const runtime_1 = require("../../nerves/runtime");
 const transcript_1 = require("./transcript");
 function parseWhisperCppTranscriptJson(raw) {
@@ -68,11 +70,37 @@ async function defaultMakeTempDir() {
 async function defaultRemoveDir(dir) {
     await fs.rm(dir, { recursive: true, force: true });
 }
+function createNodeWhisperCppProcessRunner() {
+    return (command, args, options) => new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error(`command timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (exitCode) => {
+            clearTimeout(timer);
+            resolve({
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8"),
+                exitCode: exitCode ?? 0,
+            });
+        });
+    });
+}
 function createWhisperCppTranscriber(options) {
     const timeoutMs = options.timeoutMs ?? 120_000;
     const readFile = options.readFile ?? fs.readFile;
     const makeTempDir = options.makeTempDir ?? defaultMakeTempDir;
     const removeDir = options.removeDir ?? defaultRemoveDir;
+    const processRunner = options.processRunner ?? createNodeWhisperCppProcessRunner();
     return {
         async transcribe(request) {
             const workDir = await makeTempDir();
@@ -94,7 +122,7 @@ function createWhisperCppTranscriber(options) {
                 meta: { utteranceId: request.utteranceId, audioPath: request.audioPath },
             });
             try {
-                const result = await options.processRunner(options.whisperCliPath, args, { timeoutMs });
+                const result = await processRunner(options.whisperCliPath, args, { timeoutMs });
                 if (typeof result.exitCode === "number" && result.exitCode !== 0) {
                     throw new Error(`exit ${result.exitCode}${result.stderr ? `: ${result.stderr}` : ""}`);
                 }

package/package.json

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