@ouro.bot/cli 0.1.0-alpha.6 → 0.1.0-alpha.600

package/dist/senses/trust-gate.js

@@ -39,6 +39,9 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
+const types_1 = require("../mind/friends/types");
+const pending_1 = require("../mind/pending");
+// Canned reply; eventually agents should compose their own first-contact message
 exports.STRANGER_AUTO_REPLY = "I'm sorry, I'm not allowed to talk to strangers";
 function buildExternalKey(provider, externalId, tenantId) {
     return `${provider}:${tenantId ?? ""}:${externalId}`;
@@ -77,16 +80,202 @@ function appendPrimaryNotification(bundleRoot, provider, externalId, tenantId, n
     fs.mkdirSync(inboxDir, { recursive: true });
     fs.appendFileSync(notificationsPath, `${JSON.stringify(payload)}\n`, "utf8");
 }
+function writeInnerPendingNotice(bundleRoot, noticeContent, nowIso) {
+    const innerPendingDir = path.join(bundleRoot, "state", "pending", pending_1.INNER_DIALOG_PENDING.friendId, pending_1.INNER_DIALOG_PENDING.channel, pending_1.INNER_DIALOG_PENDING.key);
+    const fileName = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`;
+    const filePath = path.join(innerPendingDir, fileName);
+    const payload = {
+        from: "instinct",
+        content: noticeContent,
+        timestamp: Date.now(),
+        at: nowIso,
+    };
+    fs.mkdirSync(innerPendingDir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(payload), "utf-8");
+}
+const ACKNOWLEDGED_GROUPS_FILENAME = "acknowledged-auto-groups.json";
+function acknowledgedGroupsPath(bundleRoot) {
+    return path.join(bundleRoot, "state", ACKNOWLEDGED_GROUPS_FILENAME);
+}
+function loadAcknowledgedGroupsState(bundleRoot) {
+    try {
+        const raw = fs.readFileSync(acknowledgedGroupsPath(bundleRoot), "utf-8");
+        if (!raw.trim())
+            return {};
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+function persistAcknowledgedGroupsState(bundleRoot, state) {
+    const target = acknowledgedGroupsPath(bundleRoot);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+}
+/**
+ * For BlueBubbles group chats that were auto-created at stranger trust (no
+ * explicit operator/agent action ever bound the harness to this group), the
+ * gate's family-member bypass would otherwise let messages flow through
+ * silently and the agent would accumulate a session it has no mental model
+ * for. Surface the relationship as an inner-pending notice exactly once so
+ * the agent can categorize / rename / dismiss the group on its next turn.
+ *
+ * Returns true if a notice was written so callers can emit a telemetry event.
+ */
+function maybeSurfaceAutoCreatedGroup(input, bundleRoot, nowIso) {
+    // Caller guarantees isGroupChat = true (only invoked from the family-member
+    // bypass branch); skip a redundant guard here.
+    if (input.friend.trustLevel !== "stranger")
+        return false;
+    if (!input.friend.notes?.["autoCreatedGroup"])
+        return false;
+    // loadAcknowledgedGroupsState is defensive (its own try/catch returns {})
+    // so we don't wrap it in another try here.
+    const state = loadAcknowledgedGroupsState(bundleRoot);
+    if (state[input.friend.id])
+        return false;
+    const noticeContent = `New BlueBubbles group "${input.friend.name}" became active without explicit acknowledgment. ` +
+        `It was auto-created at stranger trust the first time a message routed through it. ` +
+        `If you recognize the group, label or rename it (and consider promoting trust); if not, you can leave it as a stranger group or rename it for clarity. ` +
+        `external id: ${input.externalId}; friend id: ${input.friend.id}.`;
+    try {
+        writeInnerPendingNotice(bundleRoot, noticeContent, nowIso);
+        persistAcknowledgedGroupsState(bundleRoot, {
+            ...state,
+            [input.friend.id]: { surfacedAt: nowIso },
+        });
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "senses",
+            event: "senses.trust_gate_group_acknowledgment_surfaced",
+            message: "auto-created group surfaced for agent acknowledgment",
+            meta: {
+                friendId: input.friend.id,
+                friendName: input.friend.name,
+                externalId: input.externalId,
+                provider: input.provider,
+            },
+        });
+        return true;
+        /* v8 ignore start -- defensive: surfacing failure must not block the gate decision @preserve */
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.trust_gate_error",
+            message: "failed to surface auto-created group for acknowledgment",
+            meta: {
+                friendId: input.friend.id,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return false;
+    }
+    /* v8 ignore stop */
+}
 function enforceTrustGate(input) {
+    const { senseType } = input;
+    // Local (CLI) and internal (inner dialog) — always allow
+    if (senseType === "local" || senseType === "internal") {
+        return { allowed: true };
+    }
+    // Closed senses (Teams) — org already gates access, allow all trust levels
+    if (senseType === "closed") {
+        return { allowed: true };
+    }
+    // Open senses (BlueBubbles/iMessage) — enforce trust rules
+    // Group chat with a family member present — allow regardless of trust level.
+    // BUT if this is an auto-created stranger group (the harness picked it up
+    // silently via the family-member shortcut and the agent never explicitly
+    // acknowledged it), surface a one-time inner-pending notice so the agent
+    // gets a chance to categorize / rename / dismiss the relationship instead
+    // of accumulating activity invisibly.
+    if (input.isGroupChat && input.groupHasFamilyMember) {
+        /* v8 ignore start -- defaults shared with the rest of the gate; tested via the stranger-trust path */
+        const bundleRoot = input.bundleRoot ?? (0, identity_1.getAgentRoot)();
+        const nowIso = (input.now ?? (() => new Date()))().toISOString();
+        /* v8 ignore stop */
+        maybeSurfaceAutoCreatedGroup(input, bundleRoot, nowIso);
+        return { allowed: true };
+    }
     const trustLevel = input.friend.trustLevel ?? "friend";
-    if (trustLevel !== "stranger") {
+    // Family and friend — always allow on open
+    if ((0, types_1.isTrustedLevel)(trustLevel)) {
         return { allowed: true };
     }
     const bundleRoot = input.bundleRoot ?? (0, identity_1.getAgentRoot)();
-    const repliesPath = path.join(bundleRoot, "stranger-replies.json");
     const nowIso = (input.now ?? (() => new Date()))().toISOString();
+    // Acquaintance rules
+    if (trustLevel === "acquaintance") {
+        return handleAcquaintance(input, bundleRoot, nowIso);
+    }
+    // Stranger rules (trustLevel === "stranger")
+    return handleStranger(input, bundleRoot, nowIso);
+}
+function handleAcquaintance(input, bundleRoot, nowIso) {
+    const { isGroupChat, hasExistingGroupWithFamily } = input;
+    let result;
+    let noticeDetail;
+    if (isGroupChat) {
+        // Group chat without family member — reject silently
+        result = { allowed: false, reason: "acquaintance_group_no_family" };
+        noticeDetail = `acquaintance "${input.friend.name}" messaged in a group chat without a family member present`;
+    }
+    else if (hasExistingGroupWithFamily) {
+        // 1:1 but shares a group with family — redirect
+        result = {
+            allowed: false,
+            reason: "acquaintance_1on1_has_group",
+            autoReply: "Hey! Reach me in our group chat instead.",
+        };
+        noticeDetail = `acquaintance "${input.friend.name}" DMed me directly — redirected to our group chat`;
+    }
+    else {
+        // 1:1, no shared group with family — redirect to any group
+        result = {
+            allowed: false,
+            reason: "acquaintance_1on1_no_group",
+            autoReply: "Hey! Reach me in a group chat instead.",
+        };
+        noticeDetail = `acquaintance "${input.friend.name}" DMed me directly — asked to reach me in a group chat`;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.trust_gate",
+        message: "acquaintance message blocked",
+        meta: {
+            channel: input.channel,
+            provider: input.provider,
+            reason: result.reason,
+        },
+    });
+    try {
+        writeInnerPendingNotice(bundleRoot, noticeDetail, nowIso);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.trust_gate_error",
+            message: "failed to write inner pending notice",
+            meta: {
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+    return result;
+}
+function handleStranger(input, bundleRoot, nowIso) {
+    const repliesPath = path.join(bundleRoot, "stranger-replies.json");
     const externalKey = buildExternalKey(input.provider, input.externalId, input.tenantId);
     const state = loadRepliesState(repliesPath);
+    // Subsequent contact — silent drop
     if (state[externalKey]) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
@@ -103,6 +292,7 @@ function enforceTrustGate(input) {
             reason: "stranger_silent_drop",
         };
     }
+    // First contact — auto-reply, persist state, notify agent
     state[externalKey] = nowIso;
     try {
         persistRepliesState(repliesPath, state);
@@ -132,6 +322,21 @@ function enforceTrustGate(input) {
             },
         });
     }
+    const noticeDetail = `stranger "${input.friend.name}" tried to reach me via ${input.channel}. Auto-replied once.`;
+    try {
+        writeInnerPendingNotice(bundleRoot, noticeDetail, nowIso);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.trust_gate_error",
+            message: "failed to write inner pending notice",
+            meta: {
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
     (0, runtime_1.emitNervesEvent)({
         level: "warn",
         component: "senses",

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

@@ -0,0 +1,237 @@
+"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.prepareVoiceCallAudio = prepareVoiceCallAudio;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("fs/promises"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const SAMPLE_RATE = 8_000;
+const DEFAULT_TONE_MS = 700;
+const DEFAULT_CLIP_MS = 5_000;
+const MAX_AUDIO_MS = 20_000;
+const MAX_AUDIO_BYTES = 10 * 1024 * 1024;
+function clampDuration(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.min(MAX_AUDIO_MS, Math.max(80, Math.round(value)));
+}
+function clampToneHz(value) {
+    if (value === undefined || !Number.isFinite(value))
+        return 660;
+    return Math.min(3_000, Math.max(80, value));
+}
+function pcm16ToMulaw(sample) {
+    const BIAS = 0x84;
+    const CLIP = 32635;
+    let sign = 0;
+    let magnitude = Math.round(sample);
+    if (magnitude < 0) {
+        magnitude = -magnitude;
+        sign = 0x80;
+    }
+    magnitude = Math.min(CLIP, magnitude) + BIAS;
+    let exponent = 7;
+    for (let mask = 0x4000; exponent > 0 && (magnitude & mask) === 0; mask >>= 1) {
+        exponent -= 1;
+    }
+    const mantissa = (magnitude >> (exponent + 3)) & 0x0f;
+    return (~(sign | (exponent << 4) | mantissa)) & 0xff;
+}
+function generateToneMulaw(toneHz, durationMs) {
+    const sampleCount = Math.max(1, Math.round((SAMPLE_RATE * durationMs) / 1000));
+    const out = new Uint8Array(sampleCount);
+    for (let i = 0; i < sampleCount; i += 1) {
+        const envelope = Math.min(1, i / 160, (sampleCount - i) / 160);
+        const sample = Math.sin((2 * Math.PI * toneHz * i) / SAMPLE_RATE) * 9000 * Math.max(0, envelope);
+        out[i] = pcm16ToMulaw(sample);
+    }
+    return out;
+}
+function execFileText(file, args, timeout = 30_000) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(file, args, { timeout }, (error, stdout = "", stderr = "") => {
+            if (error) {
+                const message = stderr.toString().trim() || error.message;
+                reject(new Error(message));
+                return;
+            }
+            resolve(stdout.toString());
+        });
+    });
+}
+async function convertWithFfmpeg(input, durationMs, options) {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "ouro-voice-audio-"));
+    const inputPath = path.join(tmpDir, "input.audio");
+    const outputPath = path.join(tmpDir, "output.ulaw");
+    await fs.writeFile(inputPath, input);
+    const args = [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-y",
+        "-t",
+        (durationMs / 1000).toFixed(3),
+        "-i",
+        inputPath,
+        "-ac",
+        "1",
+        "-ar",
+        String(SAMPLE_RATE),
+        "-f",
+        "mulaw",
+        outputPath,
+    ];
+    const candidates = [
+        ...(options.ffmpegCandidates ?? [
+            options.ffmpegPath,
+            "ffmpeg",
+            "/opt/homebrew/bin/ffmpeg",
+            "/usr/local/bin/ffmpeg",
+            "/usr/bin/ffmpeg",
+        ]),
+    ].filter((value) => typeof value === "string" && value.trim().length > 0);
+    let lastError = null;
+    try {
+        for (const candidate of candidates) {
+            try {
+                await execFileText(candidate, args);
+                return await fs.readFile(outputPath);
+            }
+            catch (error) {
+                /* v8 ignore next -- child_process errors are Error instances in supported Node runtimes @preserve */
+                lastError = error instanceof Error ? error : new Error(String(error));
+            }
+        }
+        /* v8 ignore next -- either a candidate error or an empty candidate list is covered; v8 counts the nullish join as a branch @preserve */
+        throw lastError ?? new Error("ffmpeg unavailable");
+    }
+    finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+}
+async function readUrlAudio(url, fetchImpl) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+        throw new Error("voice audio URL must be http(s)");
+    }
+    const response = await fetchImpl(parsed.toString());
+    if (!response.ok)
+        throw new Error(`voice audio URL fetch failed: ${response.status}`);
+    const contentLength = Number(response.headers.get("content-length") ?? "0");
+    if (Number.isFinite(contentLength) && contentLength > MAX_AUDIO_BYTES) {
+        throw new Error("voice audio URL is too large");
+    }
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    /* v8 ignore next -- oversized response bodies are covered; v8 under-reports the positive branch for arrayBuffer-backed Response @preserve */
+    if (bytes.byteLength > MAX_AUDIO_BYTES)
+        throw new Error("voice audio URL is too large");
+    return bytes;
+}
+async function readFileAudio(inputPath, agentRoot) {
+    const resolved = path.resolve(inputPath);
+    const allowedRoots = [
+        agentRoot ? path.resolve(agentRoot) : "",
+        path.resolve(os.tmpdir()),
+    ].filter(Boolean);
+    if (!allowedRoots.some((root) => resolved === root || resolved.startsWith(`${root}${path.sep}`))) {
+        throw new Error("voice audio files must live under the agent bundle or temp directory");
+    }
+    const stat = await fs.stat(resolved);
+    if (!stat.isFile())
+        throw new Error("voice audio path is not a file");
+    if (stat.size > MAX_AUDIO_BYTES)
+        throw new Error("voice audio file is too large");
+    return fs.readFile(resolved);
+}
+async function prepareVoiceCallAudio(request, options = {}) {
+    const source = request.source ?? "tone";
+    const label = request.label?.trim() || (source === "tone" ? "tone" : "audio clip");
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_audio_prepare_start",
+        message: "preparing voice call audio clip",
+        meta: { source, label },
+    });
+    try {
+        if (source === "tone") {
+            const durationMs = clampDuration(request.durationMs, DEFAULT_TONE_MS);
+            const prepared = {
+                label,
+                durationMs,
+                mimeType: "audio/x-mulaw;rate=8000",
+                audio: generateToneMulaw(clampToneHz(request.toneHz), durationMs),
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.voice_audio_prepare_end",
+                message: "prepared voice call audio clip",
+                meta: { source, label, durationMs: String(prepared.durationMs), byteLength: String(prepared.audio.byteLength) },
+            });
+            return prepared;
+        }
+        const durationMs = clampDuration(request.durationMs, DEFAULT_CLIP_MS);
+        /* v8 ignore next 3 -- URL and file branches are both covered; optional missing-field fallbacks are defensive @preserve */
+        const input = source === "url"
+            ? await readUrlAudio(request.url?.trim() || "", options.fetchImpl ?? fetch)
+            : await readFileAudio(request.path?.trim() || "", options.agentRoot);
+        const audio = await convertWithFfmpeg(input, durationMs, options);
+        const prepared = {
+            label,
+            durationMs: Math.min(durationMs, Math.round((audio.byteLength / SAMPLE_RATE) * 1000)),
+            mimeType: "audio/x-mulaw;rate=8000",
+            audio,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_audio_prepare_end",
+            message: "prepared voice call audio clip",
+            meta: { source, label, durationMs: String(prepared.durationMs), byteLength: String(prepared.audio.byteLength) },
+        });
+        return prepared;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_audio_prepare_error",
+            message: "failed to prepare voice call audio clip",
+            /* v8 ignore next -- catches in this module throw Error objects @preserve */
+            meta: { source, label, error: error instanceof Error ? error.message : String(error) },
+        });
+        throw error;
+    }
+}

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;
+    }
+}