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

package/dist/senses/trust-gate.js

@@ -93,6 +93,91 @@ function writeInnerPendingNotice(bundleRoot, noticeContent, 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
@@ -104,6 +189,20 @@ function enforceTrustGate(input) {
         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";
     // Family and friend — always allow on open
     if ((0, types_1.isTrustedLevel)(trustLevel)) {
@@ -119,11 +218,7 @@ function enforceTrustGate(input) {
     return handleStranger(input, bundleRoot, nowIso);
 }
 function handleAcquaintance(input, bundleRoot, nowIso) {
-    const { isGroupChat, groupHasFamilyMember, hasExistingGroupWithFamily } = input;
-    // Group chat with family member present — allow
-    if (isGroupChat && groupHasFamilyMember) {
-        return { allowed: true };
-    }
+    const { isGroupChat, hasExistingGroupWithFamily } = input;
     let result;
     let noticeDetail;
     if (isGroupChat) {

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

@@ -0,0 +1,178 @@
+"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";
+exports.DEFAULT_ELEVENLABS_OUTPUT_FORMAT = "pcm_16000";
+exports.DEFAULT_ELEVENLABS_MIME_TYPE = "audio/pcm;rate=16000";
+function cleanTtsText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function elevenLabsStreamUrl(voiceId, modelId, outputFormat) {
+    const params = new URLSearchParams({ model_id: modelId, output_format: 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";
+    return {
+        async synthesize(request) {
+            const text = cleanTtsText(request.text);
+            if (!text) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.voice_tts_error",
+                    message: "voice TTS text is empty",
+                    meta: { utteranceId: request.utteranceId },
+                });
+                throw new Error("voice TTS text is empty");
+            }
+            const url = elevenLabsStreamUrl(options.voiceId, modelId, outputFormat);
+            const socket = socketFactory(url);
+            const chunks = [];
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.voice_tts_start",
+                message: "starting ElevenLabs TTS",
+                meta: { utteranceId: request.utteranceId, modelId, voiceId: options.voiceId },
+            });
+            return new Promise((resolve, reject) => {
+                let settled = false;
+                const fail = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    const message = error instanceof Error ? error.message : String(error);
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "senses",
+                        event: "senses.voice_tts_error",
+                        message: "ElevenLabs TTS failed",
+                        meta: { utteranceId: request.utteranceId, error: message },
+                    });
+                    reject(new Error(`ElevenLabs TTS failed: ${message}`));
+                };
+                const finish = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    const audio = Buffer.concat(chunks);
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "senses",
+                        event: "senses.voice_tts_end",
+                        message: "finished ElevenLabs TTS",
+                        meta: { utteranceId: request.utteranceId, chunkCount: chunks.length, byteLength: audio.byteLength },
+                    });
+                    socket.close();
+                    resolve({
+                        utteranceId: request.utteranceId,
+                        audio,
+                        byteLength: audio.byteLength,
+                        chunkCount: chunks.length,
+                        modelId,
+                        voiceId: options.voiceId,
+                        mimeType,
+                    });
+                };
+                socket.on("open", () => {
+                    socket.send(JSON.stringify({
+                        text: " ",
+                        xi_api_key: options.apiKey,
+                        voice_settings: {
+                            stability: 0.5,
+                            similarity_boost: 0.8,
+                            use_speaker_boost: true,
+                        },
+                    }));
+                    socket.send(JSON.stringify({ text, try_trigger_generation: true }));
+                    socket.send(JSON.stringify({ text: "" }));
+                });
+                socket.on("message", (payload) => {
+                    try {
+                        const parsed = JSON.parse(payloadText(payload));
+                        if (typeof parsed.audio === "string" && parsed.audio.length > 0) {
+                            chunks.push(Buffer.from(parsed.audio, "base64"));
+                        }
+                        if (parsed.isFinal === true) {
+                            finish();
+                        }
+                    }
+                    catch (error) {
+                        fail(error);
+                    }
+                });
+                socket.on("error", fail);
+                socket.on("close", () => {
+                    if (!settled) {
+                        fail(new Error("socket closed before final audio"));
+                    }
+                });
+            });
+        },
+    };
+}

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

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* v8 ignore file -- barrel exports only; executable voice helpers are covered directly. @preserve */
+__exportStar(require("./types"), exports);
+__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;
+}