@ouro.bot/cli 0.1.0-alpha.891 → 0.1.0-alpha.893

package/dist/senses/cmux/client.js

@@ -0,0 +1,196 @@
+"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.CmuxSocketError = void 0;
+exports.createCmuxClient = createCmuxClient;
+const node_crypto_1 = require("node:crypto");
+const net = __importStar(require("node:net"));
+const cmux_config_1 = require("../../heart/cmux-config");
+const runtime_1 = require("../../nerves/runtime");
+class CmuxSocketError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "CmuxSocketError";
+    }
+}
+exports.CmuxSocketError = CmuxSocketError;
+const ACCESS_REFUSED = /access denied|authentication required|invalid password|not authorized|unauthori[sz]ed/i;
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseRecord(line) {
+    try {
+        const value = JSON.parse(line);
+        return isRecord(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function createCmuxClient(connection, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const repair = (0, cmux_config_1.cmuxRepairHint)(options.agentName ?? "<agent>");
+    const wrap = (line) => connection.auth.kind === "capability"
+        ? `_cmux_capability_v1 ${connection.auth.token} ${line}`
+        : line;
+    const refusal = (text) => text.startsWith("ERROR:") && ACCESS_REFUSED.test(text)
+        ? new CmuxSocketError("auth", `cmux refused the socket connection (${text.slice(0, 200)}); ${repair}`)
+        : null;
+    const connectError = (error) => new CmuxSocketError("unavailable", `cmux socket is not reachable at ${connection.socketPath} (${String(error.code)}); is cmux running?`);
+    /** Opens a connection, runs the password handshake when needed, and hands back a line reader. */
+    function open(onLine, onEnd) {
+        return new Promise((resolve) => {
+            const socket = net.createConnection(connection.socketPath);
+            let buffer = "";
+            let handshake = connection.auth.kind === "password";
+            socket.setEncoding("utf-8");
+            socket.on("error", (error) => onEnd(connectError(error)));
+            socket.on("close", () => onEnd());
+            socket.on("data", (chunk) => {
+                buffer += chunk;
+                let index = buffer.indexOf("\n");
+                while (index >= 0) {
+                    const line = buffer.slice(0, index).trim();
+                    buffer = buffer.slice(index + 1);
+                    index = buffer.indexOf("\n");
+                    if (!line)
+                        continue;
+                    if (handshake) {
+                        handshake = false;
+                        if (line.startsWith("ERROR:") && !line.includes("Unknown command 'auth'")) {
+                            socket.destroy();
+                            onEnd(new CmuxSocketError("auth", `cmux rejected the socket password (${line.slice(0, 200)}); ${repair}`));
+                            continue;
+                        }
+                        resolve(socket);
+                        continue;
+                    }
+                    onLine(line);
+                }
+            });
+            socket.on("connect", () => {
+                if (connection.auth.kind === "password")
+                    socket.write(`auth ${connection.auth.password}\n`);
+                else
+                    resolve(socket);
+            });
+        });
+    }
+    function request(line) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let socket = null;
+            const finish = (error, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                socket?.destroy();
+                if (error)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            const timer = setTimeout(() => finish(new CmuxSocketError("timeout", `cmux did not answer within ${timeoutMs} ms`)), timeoutMs);
+            void open((response) => finish(refusal(response), response), (error) => finish(error ?? new CmuxSocketError("unavailable", "cmux closed the socket before answering"))).then((opened) => {
+                socket = opened;
+                opened.write(`${wrap(line)}\n`);
+            });
+        });
+    }
+    const v2Line = (method, params) => JSON.stringify({ id: (0, node_crypto_1.randomUUID)(), method, params });
+    function parseV2(text) {
+        const parsed = parseRecord(text);
+        if (!parsed)
+            throw new CmuxSocketError(text.startsWith("ERROR:") ? "command_failed" : "protocol", `unexpected cmux response: ${text.slice(0, 200)}`);
+        if (parsed.ok === true)
+            return isRecord(parsed.result) ? parsed.result : {};
+        const error = isRecord(parsed.error) ? parsed.error : {};
+        throw new CmuxSocketError(typeof error.code === "string" ? error.code : "error", typeof error.message === "string" && error.message ? error.message : "cmux error");
+    }
+    return {
+        async call(method, params = {}) {
+            const text = await request(v2Line(method, params));
+            const result = parseV2(text);
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_call", message: "cmux socket call answered", meta: { method } });
+            return result;
+        },
+        async command(line) {
+            const text = await request(line);
+            if (text.startsWith("ERROR:"))
+                throw new CmuxSocketError("command_failed", text.slice(0, 500));
+            return text;
+        },
+        stream(params, handlers) {
+            let closed = false;
+            let socket = null;
+            const end = (error) => {
+                if (closed)
+                    return;
+                closed = true;
+                socket?.destroy();
+                handlers.onClose(error);
+            };
+            void open((line) => {
+                if (closed)
+                    return;
+                const refused = refusal(line);
+                if (refused)
+                    return end(refused);
+                const frame = parseRecord(line);
+                if (!frame)
+                    return end(new CmuxSocketError("protocol", `unexpected cmux event frame: ${line.slice(0, 200)}`));
+                if (frame.ok === false) {
+                    try {
+                        parseV2(line);
+                    }
+                    catch (error) {
+                        return end(error);
+                    }
+                }
+                handlers.onFrame(frame);
+            }, end).then((opened) => {
+                socket = opened;
+                if (closed)
+                    opened.destroy();
+                else
+                    opened.write(`${wrap(v2Line("events.stream", params))}\n`);
+            });
+            return { close: () => end() };
+        },
+    };
+}

package/dist/senses/cmux/redact.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactSecrets = redactSecrets;
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Terminal screens and Feed tool input can show credentials. Everything the cmux sense hands to a
+ * model (screen text, request previews) goes through this first. It is a best-effort net for
+ * secret-shaped strings, not a guarantee, so callers also keep their output bounded.
+ */
+const REDACTED = "[redacted]";
+const WHOLE_MATCH = [
+    /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    /\bsk-[A-Za-z0-9_-]{16,}/g,
+    /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+    /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+    /\bv1\.[A-Za-z0-9_-]{40,}\.[A-Za-z0-9_-]{40,}/g,
+    /\bxox[abprs]-[A-Za-z0-9-]{10,}/g,
+];
+/** Keep the label (group 1), redact the value. */
+const LABELLED_VALUE = [
+    /(\b(?:Bearer|Basic)\s+)[A-Za-z0-9._~+/=-]{6,}/gi,
+    /(\b(?:password|passwd|pwd|secret|token|api[_-]?key|access[_-]?key|client[_-]?secret)\s*[=:]\s*)(?:"[^"]*"|'[^']*'|[^\s'"&]+)/gi,
+    /([?&](?:token|key|api_key|access_token|sig|signature)=)[^&\s]+/gi,
+];
+function redactSecrets(text) {
+    let result = text;
+    for (const pattern of WHOLE_MATCH)
+        result = result.replace(pattern, REDACTED);
+    for (const pattern of LABELLED_VALUE)
+        result = result.replace(pattern, `$1${REDACTED}`);
+    if (result !== text) {
+        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_redacted", message: "redacted secret-shaped text from cmux output", meta: { removedChars: text.length - result.length } });
+    }
+    return result;
+}

package/dist/senses/cmux/sense.js

@@ -0,0 +1,248 @@
+"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.CMUX_WAKE_TRIGGER = void 0;
+exports.cmuxStatePath = cmuxStatePath;
+exports.queueEscalation = queueEscalation;
+exports.wakeForEscalations = wakeForEscalations;
+exports.startCmuxSenseApp = startCmuxSenseApp;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const cmux_config_1 = require("../../heart/cmux-config");
+const socket_client_1 = require("../../heart/daemon/socket-client");
+const identity_1 = require("../../heart/identity");
+const runtime_credentials_1 = require("../../heart/runtime-credentials");
+const pending_1 = require("../../mind/pending");
+const runtime_1 = require("../../nerves/runtime");
+const attention_1 = require("./attention");
+const client_1 = require("./client");
+const RECONNECT_DELAYS_MS = [1_000, 2_000, 5_000, 10_000, 30_000];
+const FEED_POLL_MS = 30_000;
+const SAVE_DELAY_MS = 1_000;
+function cmuxStatePath(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "cmux", "state.json");
+}
+/** The private-turn trigger the daemon's policy accepts for a cmux escalation wake. */
+exports.CMUX_WAKE_TRIGGER = "cmux-feed";
+/** cmux waits about 120 seconds; a notice the agent has not read within 30 minutes is dropped unread. */
+const ESCALATION_TTL_MS = 30 * 60_000;
+/** Queues the escalation in the agent's private runtime, as the mail sense queues its notices. */
+function queueEscalation(agent, escalation, nowMs) {
+    (0, pending_1.queuePendingMessage)((0, pending_1.getPrivateRuntimePendingDir)(agent), {
+        from: "cmux",
+        friendId: "self",
+        channel: "cmux",
+        key: "feed",
+        content: escalation.content,
+        timestamp: nowMs,
+        expiresAt: nowMs + ESCALATION_TTL_MS,
+        mode: "reflect",
+    });
+}
+/** How many request ids one wake names in its origin references. */
+const WAKE_REF_LIMIT = 20;
+/**
+ * Asks the daemon for one private turn for everything a check pass queued: the turn reads every
+ * pending message at once, so a burst of Feed requests costs one turn, not one each. A refused or
+ * failed wake leaves the messages for the next private turn.
+ */
+async function wakeForEscalations(agent, requestIds) {
+    const key = requestIds.length === 1 ? requestIds[0] : `${requestIds.length}:${(0, node_crypto_1.createHash)("sha256").update(requestIds.join("\n")).digest("hex").slice(0, 32)}`;
+    try {
+        const response = await (0, socket_client_1.requestPrivateWake)(agent, undefined, {
+            reason: requestIds.length === 1 ? "cmux Feed request" : `${requestIds.length} cmux Feed requests`,
+            triggerSource: exports.CMUX_WAKE_TRIGGER,
+            budgetClass: "interactive",
+            idempotencyKey: `cmux-feed:${agent}:${key}`,
+            originRefs: [...requestIds.slice(0, WAKE_REF_LIMIT).map((id) => ({ kind: "cmux-feed", id })), { kind: "sense", id: "cmux" }],
+        });
+        if (response && !response.ok)
+            throw new Error(response.error ?? "the daemon refused the wake");
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.cmux_wake_error", message: "could not wake the private runtime for cmux escalations; they wait for the next private turn", meta: { agent, error: error.message } });
+    }
+}
+async function startCmuxSenseApp(options) {
+    const agent = options.agentName;
+    const nowMs = options.now ?? Date.now;
+    const now = () => new Date(nowMs()).toISOString();
+    const machine = (0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(agent);
+    const resolved = (0, cmux_config_1.resolveCmuxConnection)(agent, machine.ok ? machine.config : {});
+    if (!resolved.ok)
+        throw new Error(resolved.error);
+    const client = (options.createClient ?? ((connection) => (0, client_1.createCmuxClient)(connection, { agentName: agent })))(resolved.connection);
+    const escalate = options.escalate ?? ((escalation) => queueEscalation(agent, escalation, nowMs()));
+    const wake = options.wake ?? ((requestIds) => wakeForEscalations(agent, requestIds));
+    const schedule = options.schedule ?? ((fn, ms) => {
+        const timer = setTimeout(fn, ms);
+        return () => clearTimeout(timer);
+    });
+    const statePath = cmuxStatePath(agent);
+    const state = (0, attention_1.readCmuxState)(statePath, now());
+    state.connected = false;
+    let stopped = false;
+    let stream = null;
+    let attempt = 0;
+    let cancelReconnect = null;
+    let cancelPoll = null;
+    let cancelSave = null;
+    let feedChain = Promise.resolve();
+    let feedQueued = false;
+    let lastWritten = null;
+    /** Writes the state file only when something other than the timestamp changed. */
+    const save = () => {
+        cancelSave?.();
+        cancelSave = null;
+        const body = JSON.stringify({ ...state, updatedAt: null });
+        if (body === lastWritten)
+            return;
+        state.updatedAt = now();
+        // A failed write is retried by the next save; it never breaks the Feed check chain.
+        try {
+            (0, attention_1.writeCmuxState)(statePath, state);
+            lastWritten = body;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.cmux_state_write_error", message: "could not write the cmux sense state; the next save retries", meta: { agent, error: error.message } });
+        }
+    };
+    const saveSoon = () => {
+        cancelSave ??= schedule(save, SAVE_DELAY_MS);
+    };
+    async function checkFeed() {
+        try {
+            const items = (0, attention_1.pendingFeedItems)(await client.call("feed.list", { pending_only: true }));
+            const queued = [];
+            for (const item of items.filter((entry) => !state.escalated.includes(entry.requestId))) {
+                // One failing item never blocks the others; it stays unremembered, so the next check retries it.
+                try {
+                    const escalation = (0, attention_1.escalationMessage)(agent, item, (0, attention_1.surfaceForSession)(state, item.workstreamId));
+                    await escalate(escalation);
+                    queued.push(escalation.requestId);
+                    (0, attention_1.rememberEscalation)(state, item.requestId);
+                    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_escalated", message: "brought a cmux Feed request to the agent", meta: { agent, kind: item.kind, source: item.source } });
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.cmux_escalation_error", message: "could not record a cmux Feed request; the next check retries", meta: { agent, error: error.message } });
+                }
+            }
+            // One wake per check pass: the private turn reads every queued escalation at once.
+            if (queued.length > 0)
+                await wake(queued);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.cmux_feed_check_error", message: "cmux Feed check failed; the next check retries", meta: { agent, error: error.message } });
+        }
+        save();
+    }
+    /** Bursts of waiting events share one queued `feed.list` read instead of stacking reads. */
+    const requestFeedCheck = () => {
+        if (feedQueued)
+            return;
+        feedQueued = true;
+        feedChain = feedChain.then(() => {
+            feedQueued = false;
+            return checkFeed();
+        });
+    };
+    /** Records the cmux version once per connection; observing works on any version. */
+    async function identify() {
+        try {
+            const result = await client.call("system.identify", {});
+            state.cmuxVersion = typeof result.version === "string" ? result.version : null;
+        }
+        catch {
+            state.cmuxVersion = null;
+        }
+        saveSoon();
+    }
+    const poll = () => {
+        cancelPoll = schedule(() => {
+            requestFeedCheck();
+            poll();
+        }, FEED_POLL_MS);
+    };
+    function connect() {
+        cancelReconnect = null;
+        stream = client.stream({ ...(state.seq !== null ? { after_seq: state.seq } : {}), categories: ["feed", "surface"] }, {
+            onFrame: (frame) => {
+                if (frame.type === "ack") {
+                    attempt = 0;
+                    const { reset } = (0, attention_1.applyAck)(state, frame);
+                    state.connected = true;
+                    state.lastError = null;
+                    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_stream_connected", message: "cmux event stream connected", meta: { agent, reset } });
+                    void identify();
+                    requestFeedCheck();
+                    return;
+                }
+                if (frame.type !== "event")
+                    return;
+                if ((0, attention_1.applyEventFrame)(state, frame, now()).feedCheck)
+                    requestFeedCheck();
+                saveSoon();
+            },
+            onClose: (error) => {
+                stream = null;
+                state.connected = false;
+                state.lastError = error?.message ?? null;
+                if (stopped)
+                    return;
+                const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
+                attempt += 1;
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.cmux_stream_closed", message: "cmux event stream closed; reconnecting", meta: { agent, delay, error: error?.message ?? null } });
+                save();
+                cancelReconnect = schedule(connect, delay);
+            },
+        });
+    }
+    connect();
+    poll();
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_sense_started", message: "cmux sense started", meta: { agent, auth: resolved.connection.auth.kind } });
+    return {
+        statePath,
+        async stop() {
+            stopped = true;
+            cancelReconnect?.();
+            cancelPoll?.();
+            stream?.close();
+            await feedChain;
+            state.connected = false;
+            save();
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.cmux_sense_stopped", message: "cmux sense stopped", meta: { agent } });
+        },
+    };
+}

package/dist/senses/cmux-entry.js

@@ -0,0 +1,77 @@
+"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/cmux-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)("cmux");
+(0, runtime_1.emitNervesEvent)({
+    component: "senses",
+    event: "senses.entry_boot",
+    message: "booting cmux entrypoint",
+    meta: { entry: "cmux", agentName },
+});
+Promise.resolve().then(() => __importStar(require("../heart/runtime-credentials"))).then(async ({ readMachineRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, waitForRuntimeCredentialBootstrap }) => {
+    await waitForRuntimeCredentialBootstrap(agentName);
+    if (!readMachineRuntimeCredentialConfig(agentName).ok) {
+        const { loadOrCreateMachineIdentity } = await Promise.resolve().then(() => __importStar(require("../heart/machine-identity")));
+        await refreshMachineRuntimeCredentialConfig(agentName, loadOrCreateMachineIdentity().machineId, { preserveCachedOnFailure: true }).catch(() => undefined);
+    }
+    const { startCmuxSenseApp } = await Promise.resolve().then(() => __importStar(require("./cmux/sense")));
+    const app = await startCmuxSenseApp({ agentName: agentName });
+    const shutdown = () => {
+        void app.stop().finally(() => process.exit(0));
+    };
+    process.once("SIGTERM", shutdown);
+    process.once("SIGINT", shutdown);
+})
+    .catch((error) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "senses.entry_error",
+        message: "cmux entrypoint failed",
+        meta: { entry: "cmux", 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);
+});

package/dist/senses/voice/local-audio-devices.js

@@ -35,7 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalAudioDevices = exports.KILL_GRACE_MS = exports.defaultProcessHost = exports.PS_ENV = exports.PLAYBACK_DEVICE_NAME = exports.CAPTURE_DEVICE_NAME = void 0;
 exports.soxCaptureArgs = soxCaptureArgs;
-exports.soxPlaybackArgs = soxPlaybackArgs;
+exports.ffmpegPlaybackArgs = ffmpegPlaybackArgs;
+exports.audioToolboxListArgs = audioToolboxListArgs;
+exports.findAudioToolboxDeviceIndex = findAudioToolboxDeviceIndex;
+exports.defaultListAudioToolboxDevices = defaultListAudioToolboxDevices;
 exports.fileCaptureArgs = fileCaptureArgs;
 exports.filePlaybackArgs = filePlaybackArgs;
 exports.defaultKillGroup = defaultKillGroup;
@@ -52,6 +55,7 @@ const runtime_1 = require("../../nerves/runtime");
 const local_audio_1 = require("./local-audio");
 const local_audio_mute_1 = require("./local-audio-mute");
 const RAW_MULAW = ["-t", "raw", "-r", "8000", "-e", "mu-law", "-b", "8", "-c", "1"];
+const AUDIO_PROCESS_NAMES = new Set(["sox", "ffmpeg"]);
 exports.CAPTURE_DEVICE_NAME = "BlackHole 16ch";
 exports.PLAYBACK_DEVICE_NAME = "BlackHole 2ch";
 /** Capture a CoreAudio device as mono 8 kHz mu-law on stdout (channels 1 and 2 mixed). */
@@ -62,9 +66,50 @@ function soxCaptureArgs(device) {
     // `--buffer 8192` delayed everything the agent heard by about a second.
     return ["-q", "--buffer", "1024", "--input-buffer", "8192", "-t", "coreaudio", device, ...RAW_MULAW, "-", "remix", "1,2"];
 }
-/** Play raw mono 8 kHz mu-law from stdin to a CoreAudio device. */
-function soxPlaybackArgs(device) {
-    return ["-q", "--buffer", "160", ...RAW_MULAW, "-", "-t", "coreaudio", device];
+/**
+ * Play raw mono 8 kHz mu-law from stdin to an AudioToolbox output device, chosen by index.
+ *
+ * sox's CoreAudio output can deadlock when the process runs at lowered priority (a zsh background
+ * job is niced by default, and so is a launchd Background job): its main thread holds a lock inside
+ * `AudioDeviceStart` while the device IO thread waits for that lock, so nothing is ever played.
+ * Observed live: 5 of 5 niced joins were silent with sox and 2 of 2 spoke with ffmpeg. The probe
+ * flags keep ffmpeg from buffering input before it starts playing.
+ */
+function ffmpegPlaybackArgs(deviceIndex) {
+    return [
+        "-hide_banner", "-loglevel", "error", "-nostdin",
+        "-probesize", "32", "-analyzeduration", "0", "-fflags", "nobuffer",
+        "-f", "mulaw", "-ar", "8000", "-ac", "1", "-i", "pipe:0",
+        "-f", "audiotoolbox", "-audio_device_index", String(deviceIndex), "-",
+    ];
+}
+/** ffmpeg prints the AudioToolbox devices to its log; `-t 0` means nothing is played. */
+function audioToolboxListArgs() {
+    return ["-hide_banner", "-f", "lavfi", "-i", "anullsrc", "-t", "0", "-f", "audiotoolbox", "-list_devices", "true", "-"];
+}
+// "[AudioToolbox @ 0x7b514003c0] [1]                  BlackHole 2ch, BlackHole2ch_UID"
+const AUDIOTOOLBOX_DEVICE_LINE = /\[(\d+)\]\s+(.+),\s*[^,]*$/;
+/** The index ffmpeg uses for a device with exactly this name, or undefined when it is not listed. */
+function findAudioToolboxDeviceIndex(listing, deviceName) {
+    for (const line of listing.split("\n")) {
+        const match = AUDIOTOOLBOX_DEVICE_LINE.exec(line.trim());
+        if (match && match[2].trim() === deviceName)
+            return Number(match[1]);
+    }
+    return undefined;
+}
+/** Runs ffmpeg's device listing and returns its log. Rejects only when ffmpeg itself cannot run. */
+function defaultListAudioToolboxDevices(ffmpegPath = "ffmpeg", run = (file, args, callback) => {
+    (0, child_process_1.execFile)(file, args, { encoding: "utf8", timeout: 5000 }, (error, stdout, stderr) => callback(error, stdout, stderr));
+}) {
+    return new Promise((resolve, reject) => {
+        run(ffmpegPath, audioToolboxListArgs(), (error, _stdout, stderr) => {
+            if (error && typeof error.code !== "number")
+                reject(error);
+            else
+                resolve(stderr);
+        });
+    });
 }
 /** Decode any audio file to the capture stream format (stdout). The caller paces it. */
 function fileCaptureArgs(inputPath) {
@@ -145,7 +190,7 @@ class LocalAudioDevices {
         this.stop();
         const command = this.options.soxPath ?? "sox";
         const capture = this.spawnTracked(command, this.options.captureArgs);
-        const playback = this.spawnTracked(command, this.options.playbackArgs);
+        const playback = this.spawnTracked(this.options.playbackCommand ?? command, this.options.playbackArgs);
         this.writePidFile();
         this.recordStartTimes([...this.running]);
         this.watchParentSignals();
@@ -254,10 +299,10 @@ class LocalAudioDevices {
         });
         return killed;
     }
-    /** Only a process that is still sox AND started when we recorded it is ours to kill (pids get reused). */
+    /** Only a process that is still one of our audio tools AND started when we recorded it is ours to kill (pids get reused). */
     isRecordedSox(pid, recordedStart) {
         const info = this.inspectProcess(pid);
-        if (!info || path.basename(info.command) !== "sox")
+        if (!info || !AUDIO_PROCESS_NAMES.has(path.basename(info.command)))
             return false;
         return recordedStart !== "" && info.startTime === recordedStart;
     }