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

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/elevenlabs.js

@@ -0,0 +1,125 @@
+"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.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 (typeof payload === "string")
+        return payload;
+    if (Buffer.isBuffer(payload))
+        return payload.toString("utf8");
+    return String(payload ?? "");
+}
+function createElevenLabsTtsClient(options) {
+    const modelId = options.modelId ?? exports.DEFAULT_ELEVENLABS_MODEL_ID;
+    const outputFormat = options.outputFormat ?? exports.DEFAULT_ELEVENLABS_OUTPUT_FORMAT;
+    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 = options.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/index.js

@@ -0,0 +1,22 @@
+"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);

package/dist/senses/voice/transcript.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVoiceTranscript = buildVoiceTranscript;
+exports.transcriptToPromptText = transcriptToPromptText;
+exports.normalizeVoiceSessionKey = normalizeVoiceSessionKey;
+const runtime_1 = require("../../nerves/runtime");
+function compactSpeechText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function buildVoiceTranscript(input) {
+    const text = compactSpeechText(input.text);
+    if (!text) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_transcript_error",
+            message: "voice transcript text is empty",
+            meta: { utteranceId: input.utteranceId },
+        });
+        throw new Error("voice transcript text is empty");
+    }
+    const transcript = {
+        utteranceId: input.utteranceId,
+        text,
+        source: input.source,
+        audioPath: input.audioPath ?? null,
+        language: input.language ?? null,
+        startedAt: input.startedAt ?? null,
+        endedAt: input.endedAt ?? null,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_transcript_built",
+        message: "built voice transcript",
+        meta: { utteranceId: transcript.utteranceId, source: transcript.source, length: transcript.text.length },
+    });
+    return transcript;
+}
+function transcriptToPromptText(transcript) {
+    const text = compactSpeechText(transcript.text);
+    if (!text) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_transcript_error",
+            message: "voice prompt text is empty",
+            meta: { utteranceId: transcript.utteranceId },
+        });
+        throw new Error("voice transcript text is empty");
+    }
+    return text;
+}
+function normalizeVoiceSessionKey(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!normalized) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_transcript_error",
+            message: "voice session key is empty",
+            meta: { inputLength: value.length },
+        });
+        throw new Error("voice session key is empty");
+    }
+    return normalized;
+}

package/dist/senses/voice/turn.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVoiceLoopbackTurn = runVoiceLoopbackTurn;
+const runtime_1 = require("../../nerves/runtime");
+const shared_turn_1 = require("../shared-turn");
+const transcript_1 = require("./transcript");
+async function runVoiceLoopbackTurn(options) {
+    const runSenseTurn = options.runSenseTurn ?? shared_turn_1.runSenseTurn;
+    let userMessage;
+    try {
+        userMessage = (0, transcript_1.transcriptToPromptText)(options.transcript);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_turn_error",
+            message: "voice turn rejected transcript",
+            meta: { utteranceId: options.transcript.utteranceId, error: error instanceof Error ? error.message : String(error) },
+        });
+        throw error;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_turn_start",
+        message: "starting voice loopback turn",
+        meta: {
+            agentName: options.agentName,
+            friendId: options.friendId,
+            sessionKey: options.sessionKey,
+            utteranceId: options.transcript.utteranceId,
+        },
+    });
+    const turn = await runSenseTurn({
+        agentName: options.agentName,
+        channel: "voice",
+        friendId: options.friendId,
+        sessionKey: options.sessionKey,
+        userMessage,
+    });
+    try {
+        const spoken = await options.tts.synthesize({
+            utteranceId: options.transcript.utteranceId,
+            text: turn.response,
+        });
+        const result = {
+            responseText: turn.response,
+            ponderDeferred: turn.ponderDeferred,
+            tts: {
+                status: "delivered",
+                audio: spoken.audio,
+                byteLength: spoken.byteLength,
+                chunkCount: spoken.chunkCount,
+                mimeType: spoken.mimeType,
+                modelId: spoken.modelId,
+                voiceId: spoken.voiceId,
+            },
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_turn_end",
+            message: "voice loopback turn delivered speech",
+            meta: { utteranceId: options.transcript.utteranceId, responseLength: turn.response.length, byteLength: spoken.byteLength },
+        });
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_turn_tts_error",
+            message: "voice loopback TTS failed after text response",
+            meta: { utteranceId: options.transcript.utteranceId, error: message, responseLength: turn.response.length },
+        });
+        return {
+            responseText: turn.response,
+            ponderDeferred: turn.ponderDeferred,
+            tts: {
+                status: "failed",
+                error: message,
+            },
+        };
+    }
+}

package/dist/senses/voice/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/senses/voice/whisper.js

@@ -0,0 +1,133 @@
+"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.parseWhisperCppTranscriptJson = parseWhisperCppTranscriptJson;
+exports.createWhisperCppTranscriber = createWhisperCppTranscriber;
+const fs = __importStar(require("fs/promises"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const transcript_1 = require("./transcript");
+function parseWhisperCppTranscriptJson(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`invalid whisper.cpp JSON: ${String(error)}`);
+    }
+    const text = typeof parsed.text === "string"
+        ? parsed.text.trim()
+        : Array.isArray(parsed.transcription)
+            ? parsed.transcription
+                .map((entry) => typeof entry.text === "string" ? entry.text.trim() : "")
+                .filter(Boolean)
+                .join(" ")
+                .trim()
+            : "";
+    if (!text) {
+        throw new Error("empty whisper.cpp transcript");
+    }
+    return text;
+}
+async function defaultMakeTempDir() {
+    return fs.mkdtemp(path.join(os.tmpdir(), "ouro-voice-whisper-"));
+}
+async function defaultRemoveDir(dir) {
+    await fs.rm(dir, { recursive: true, force: true });
+}
+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;
+    return {
+        async transcribe(request) {
+            const workDir = await makeTempDir();
+            const outputBase = path.join(workDir, "transcript");
+            const args = [
+                "-m",
+                options.modelPath,
+                "-f",
+                request.audioPath,
+                "-oj",
+                "-of",
+                outputBase,
+                ...(request.language ? ["-l", request.language] : []),
+            ];
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.voice_stt_start",
+                message: "starting Whisper.cpp transcription",
+                meta: { utteranceId: request.utteranceId, audioPath: request.audioPath },
+            });
+            try {
+                const result = await options.processRunner(options.whisperCliPath, args, { timeoutMs });
+                if (typeof result.exitCode === "number" && result.exitCode !== 0) {
+                    throw new Error(`exit ${result.exitCode}${result.stderr ? `: ${result.stderr}` : ""}`);
+                }
+                const raw = await readFile(`${outputBase}.json`, "utf8");
+                const text = parseWhisperCppTranscriptJson(raw);
+                const transcript = (0, transcript_1.buildVoiceTranscript)({
+                    utteranceId: request.utteranceId,
+                    text,
+                    audioPath: request.audioPath,
+                    language: request.language,
+                    source: "whisper.cpp",
+                });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.voice_stt_end",
+                    message: "finished Whisper.cpp transcription",
+                    meta: { utteranceId: request.utteranceId, length: transcript.text.length },
+                });
+                return transcript;
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.voice_stt_error",
+                    message: "Whisper.cpp transcription failed",
+                    meta: { utteranceId: request.utteranceId, error: error instanceof Error ? error.message : String(error) },
+                });
+                throw new Error(`whisper.cpp transcription failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                await removeDir(workDir);
+            }
+        },
+    };
+}

package/dist/senses/voice-entry.js

@@ -0,0 +1,80 @@
+"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 });
+const agentArgIndex = process.argv.indexOf("--agent");
+const agentName = agentArgIndex >= 0 ? process.argv[agentArgIndex + 1] : undefined;
+if (!agentName) {
+    // eslint-disable-next-line no-console -- pre-boot guard: --agent check before imports
+    console.error("Missing required --agent <name> argument.\nUsage: node dist/senses/voice-entry.js --agent ouroboros");
+    process.exit(1);
+}
+const runtime_logging_1 = require("../heart/daemon/runtime-logging");
+const runtime_1 = require("../nerves/runtime");
+(0, runtime_logging_1.configureDaemonRuntimeLogger)("voice");
+(0, runtime_1.emitNervesEvent)({
+    component: "senses",
+    event: "senses.entry_boot",
+    message: "booting Voice entrypoint",
+    meta: { entry: "voice", agentName },
+});
+Promise.resolve().then(() => __importStar(require("../heart/runtime-credentials"))).then(async ({ readMachineRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, refreshRuntimeCredentialConfig, waitForRuntimeCredentialBootstrap, }) => {
+    await waitForRuntimeCredentialBootstrap(agentName);
+    const { loadOrCreateMachineIdentity } = await Promise.resolve().then(() => __importStar(require("../heart/machine-identity")));
+    const machine = loadOrCreateMachineIdentity();
+    const machineConfig = readMachineRuntimeCredentialConfig(agentName);
+    if (!machineConfig.ok) {
+        await refreshMachineRuntimeCredentialConfig(agentName, machine.machineId, { preserveCachedOnFailure: true }).catch(() => undefined);
+    }
+    void refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_entry_ready",
+        message: "Voice entrypoint is ready for managed voice turns",
+        meta: { entry: "voice", agentName, machineId: machine.machineId },
+    });
+    setInterval(() => undefined, 60_000);
+})
+    .catch((error) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "senses.entry_error",
+        message: "Voice entrypoint failed",
+        meta: { entry: "voice", agentName, error: error instanceof Error ? error.message : String(error) },
+    });
+    // eslint-disable-next-line no-console -- fatal startup guard for sense process
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});