@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.921

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

@@ -0,0 +1,103 @@
+"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.capLocalTrust = capLocalTrust;
+exports.resolveLocalAudioFriend = resolveLocalAudioFriend;
+const path = __importStar(require("path"));
+const friends_1 = require("@ouro.bot/friends");
+const runtime_1 = require("../../nerves/runtime");
+const SAFE_FRIEND_ID = /^[A-Za-z0-9._-]{1,128}$/;
+const LOCAL_ROOM_FRIEND_ID = "local-audio-room";
+const TRUST_RANK = { stranger: 0, acquaintance: 1, friend: 2, family: 3 };
+/**
+ * A local session runs at acquaintance unless the join says the room is the owner alone. The cap
+ * only lowers: a record already below acquaintance stays where it is, and an unrecorded trust is
+ * treated as acquaintance.
+ */
+function capLocalTrust(recorded, ownerAlone) {
+    const effective = recorded ?? "acquaintance";
+    if (ownerAlone)
+        return effective;
+    return TRUST_RANK[effective] > TRUST_RANK.acquaintance ? "acquaintance" : effective;
+}
+function roomRecord() {
+    const now = new Date().toISOString();
+    return {
+        id: LOCAL_ROOM_FRIEND_ID,
+        name: "Local audio room",
+        trustLevel: "acquaintance",
+        externalIds: [],
+        tenantMemberships: [],
+        toolPreferences: {},
+        notes: {},
+        totalTokens: 0,
+        createdAt: now,
+        updatedAt: now,
+        schemaVersion: 1,
+    };
+}
+/**
+ * Resolves who a local audio session is with. `friendId` comes from the join request (a local
+ * pidfile/socket command or the family text tool), is validated as a safe id, and must match a
+ * record id exactly (never a display name). Anything else maps to one stable room record. The
+ * returned friend carries the capped effective trust for the whole session.
+ */
+async function resolveLocalAudioFriend(options) {
+    const friendStore = new friends_1.FileFriendStore(path.join(options.agentRoot, "friends"));
+    const requested = options.friendId?.trim();
+    let friend = null;
+    if (requested && SAFE_FRIEND_ID.test(requested) && requested !== "." && requested !== "..") {
+        const existing = await friendStore.get(requested);
+        if (existing && existing.id === requested)
+            friend = existing;
+    }
+    // No identified friend: the room is a stable, unprivileged record. It is built in memory rather
+    // than resolved through FriendResolver, which would persist it (and treat the first friend ever
+    // seen in an empty store as family).
+    const identified = friend !== null;
+    friend ??= (await friendStore.get(LOCAL_ROOM_FRIEND_ID)) ?? roomRecord();
+    const trustLevel = capLocalTrust(friend.trustLevel, identified && options.ownerAlone);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_local_identity_resolved",
+        message: "local audio session identity resolved",
+        meta: { friendId: friend.id, recordedTrust: String(friend.trustLevel), effectiveTrust: trustLevel, ownerAlone: options.ownerAlone },
+    });
+    return {
+        friendId: friend.id,
+        friendStore,
+        resolved: { friend: { ...friend, trustLevel }, channel: (0, friends_1.getChannelCapabilities)("voice") },
+    };
+}

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

@@ -0,0 +1,325 @@
+"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.parseNotifySession = void 0;
+exports.localAudioJoinArgs = localAudioJoinArgs;
+exports.runLocalAudioJoin = runLocalAudioJoin;
+exports.runLocalAudioLeave = runLocalAudioLeave;
+exports.runLocalAudioStatus = runLocalAudioStatus;
+exports.defaultLaunchSpawn = defaultLaunchSpawn;
+exports.launchLocalAudioJoin = launchLocalAudioJoin;
+exports.defaultLocalAudioJoinDeps = defaultLocalAudioJoinDeps;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+const audio_routing_1 = require("./audio-routing");
+const local_audio_control_1 = require("./local-audio-control");
+Object.defineProperty(exports, "parseNotifySession", { enumerable: true, get: function () { return local_audio_control_1.parseNotifySession; } });
+const local_audio_mute_1 = require("./local-audio-mute");
+const local_audio_notify_1 = require("./local-audio-notify");
+const local_audio_transport_1 = require("./local-audio-transport");
+const twilio_phone_runtime_1 = require("./twilio-phone-runtime");
+const NO_SESSION = "No local audio session is running.";
+/** The CLI arguments that make `ouro voice join` reproduce this request. */
+function localAudioJoinArgs(request) {
+    const args = ["voice", "join", "--agent", request.agentName];
+    const flag = (name, value) => {
+        if (value !== undefined)
+            args.push(name, String(value));
+    };
+    flag("--friend", request.friendId);
+    flag("--participants", request.participants);
+    flag("--occasion", request.occasion);
+    flag("--mode", request.mode);
+    if (request.ownerAlone)
+        args.push("--owner-alone");
+    flag("--owner-name", request.ownerName);
+    flag("--silent-consent", request.silentConsent);
+    if (request.notify)
+        flag("--notify-session", `${request.notify.friendId}:${request.notify.channel}:${request.notify.key}`);
+    flag("--input-file", request.files?.inputPath);
+    flag("--output-file", request.files?.outputPath);
+    flag("--idle-silence-ms", request.idleSilenceMs);
+    flag("--max-duration-ms", request.maxDurationMs);
+    return args;
+}
+const END_PHRASES = {
+    left: "I left the call on request",
+    session_ended: "the audio session ended",
+    capture_ended: "the capture device stopped",
+    playback_failed: "the playback device failed",
+    disclosure_failed: "I could not confirm I announced myself aloud within 20 seconds, so I left",
+    idle_silence: "the room went idle (long silence), so I left",
+    max_duration: "it reached the maximum call length, so I left",
+};
+function joinedNotice(request, callSid) {
+    const parts = [`I joined a local audio session (${callSid}) as ${request.agentName}.`];
+    if (request.participants)
+        parts.push(`Participants: ${request.participants}.`);
+    if (request.occasion)
+        parts.push(`Occasion: ${request.occasion}.`);
+    const consent = request.silentConsent?.trim();
+    parts.push(consent
+        ? `This is a silent join on your recorded consent: "${consent}".`
+        : "I am announcing myself aloud as an AI assistant that is transcribing; if I cannot confirm that announcement was spoken, I will leave and tell you.");
+    parts.push("Say leave, or run `ouro voice leave`, to end it.");
+    return parts.join(" ");
+}
+function endedNotice(summary) {
+    const seconds = Math.round(summary.durationMs / 1000);
+    return `Local audio session ${summary.callSid} ended after ${seconds}s: ${END_PHRASES[summary.reason] ?? summary.reason}.`;
+}
+async function runLocalAudioJoin(request, deps) {
+    const agentRoot = deps.agentRoot(request.agentName);
+    const paths = (0, local_audio_control_1.localAudioPaths)(agentRoot);
+    const refuse = (what) => {
+        throw new Error(`A local audio session is already running (${what}). Run \`ouro voice leave\` first.`);
+    };
+    // Only one join may run per agent. A refused join touches nothing of the running one.
+    const lock = (0, local_audio_control_1.acquireJoinLock)(paths);
+    if (!lock.ok) {
+        const running = await (0, local_audio_control_1.sendLocalAudioControl)(paths, "status", 2_000);
+        return refuse(running.ok ? running.status.callSid : `starting, process ${lock.holderPid ?? "unknown"}`);
+    }
+    let server;
+    let transport;
+    // Registered as soon as we hold the lock, so a stop signal at any point ends the call and releases the lock.
+    let stopRequested = false;
+    const stopListening = deps.onStopSignal(() => {
+        stopRequested = true;
+        if (transport)
+            void transport.leave("left");
+    });
+    try {
+        // A server from before the lock existed, or one that answers without owning the lock.
+        const legacy = await (0, local_audio_control_1.sendLocalAudioControl)(paths, "status", 2_000);
+        if (legacy.ok)
+            refuse(legacy.status.callSid);
+        (0, local_audio_control_1.writeJoinStatus)(paths, { state: "starting" });
+        try {
+            const openaiRealtime = await deps.resolveRealtime(request.agentName);
+            if (stopRequested)
+                return await endBeforeJoining(request, deps, paths);
+            const bridge = localBridgeOptions(request.agentName, agentRoot, paths, openaiRealtime);
+            transport = deps.createTransport(request, bridge);
+            const live = transport;
+            server = new local_audio_control_1.LocalAudioControlServer(paths, { status: () => live.status(), leave: () => live.leave("left") });
+            await server.start();
+            await live.start();
+        }
+        catch (error) {
+            await server?.close();
+            // A stop signal during startup makes the start fail; that is a cancelled join, not a failure.
+            if (stopRequested)
+                return await endBeforeJoining(request, deps, paths);
+            const reason = error instanceof Error ? error.message : String(error);
+            (0, local_audio_control_1.writeJoinStatus)(paths, { state: "failed", reason });
+            if (request.notify)
+                await deps.notifyOwner(request.agentName, request.notify, `I could not join the local audio session: ${reason}`);
+            throw error;
+        }
+        const { callSid, state } = transport.status();
+        // A leave or stop signal during startup cancels the start: it ended without ever joining.
+        const joined = state !== "ended";
+        if (joined) {
+            (0, local_audio_control_1.writeJoinStatus)(paths, { state: "joined", callSid });
+            deps.write(`Joined local audio session ${callSid} as ${request.agentName}. Run \`ouro voice leave\` to end it.\n`);
+            if (request.notify)
+                await deps.notifyOwner(request.agentName, request.notify, joinedNotice(request, callSid));
+        }
+        const summary = await transport.ended;
+        (0, local_audio_control_1.writeJoinStatus)(paths, { state: "ended", callSid, reason: summary.reason });
+        await server.close();
+        if (request.notify)
+            await deps.notifyOwner(request.agentName, request.notify, endedNotice(summary));
+        return summary;
+    }
+    finally {
+        stopListening();
+        lock.release();
+    }
+}
+async function endBeforeJoining(request, deps, paths) {
+    (0, local_audio_control_1.writeJoinStatus)(paths, { state: "ended", reason: "left" });
+    if (request.notify)
+        await deps.notifyOwner(request.agentName, request.notify, "I was told to stop before joining the local audio session, so I did not join.");
+    return { reason: "left", callSid: "not-joined", durationMs: 0 };
+}
+function localBridgeOptions(agentName, agentRoot, paths, openaiRealtime) {
+    const unused = (what) => async () => { throw new Error(`${what} is not used by local audio`); };
+    return {
+        agentName,
+        agentRoot,
+        publicBaseUrl: "https://local-audio.invalid",
+        outputDir: paths.dir,
+        transcriber: { transcribe: unused("the transcriber") },
+        tts: { synthesize: unused("text to speech") },
+        transportMode: "media-stream",
+        conversationEngine: "openai-realtime",
+        outboundConversationEngine: "openai-realtime",
+        openaiRealtime,
+    };
+}
+async function runLocalAudioLeave(agentName, deps) {
+    const paths = (0, local_audio_control_1.localAudioPaths)(deps.agentRoot(agentName));
+    const active = await (0, local_audio_control_1.inspectActiveJoin)(paths);
+    if (!active)
+        return NO_SESSION;
+    const reply = await (0, local_audio_control_1.sendLocalAudioControl)(paths, "leave");
+    if (!reply.ok && active.state === "starting") {
+        // The join has not opened its control socket yet; its stop-signal handler is already registered.
+        const pid = (0, local_audio_control_1.stopLockHolder)(paths);
+        if (pid !== null)
+            return `Told the local audio session that is still starting (process ${pid}) to stop.`;
+    }
+    if (!reply.ok)
+        return `Could not leave the local audio session: ${reply.error}`;
+    return `Left local audio session ${active.callSid}.`;
+}
+async function runLocalAudioStatus(agentName, deps) {
+    const active = await (0, local_audio_control_1.inspectActiveJoin)((0, local_audio_control_1.localAudioPaths)(deps.agentRoot(agentName)));
+    if (!active)
+        return NO_SESSION;
+    return `Local audio session ${active.callSid} is ${active.state}${active.startedAt ? ` (since ${active.startedAt})` : ""}.`;
+}
+/** A detached child with stdout and stderr appended to the join log. */
+function defaultLaunchSpawn(paths) {
+    return (command, args) => {
+        fs.mkdirSync(paths.dir, { recursive: true, mode: 0o700 });
+        const log = fs.openSync(paths.logFile, "a", 0o600);
+        try {
+            return (0, child_process_1.spawn)(command, args, { detached: true, stdio: ["ignore", log, log] });
+        }
+        finally {
+            fs.closeSync(log);
+        }
+    };
+}
+const POLL_MS = 250;
+/**
+ * The launcher gave up waiting, so the detached join must not be left running unsupervised. If it
+ * already opened its control socket it is asked to leave (a clean stop); otherwise its process group
+ * gets SIGTERM, which its stop handler turns into a clean end.
+ */
+async function stopTimedOutJoin(paths, pid, kill) {
+    const reply = await (0, local_audio_control_1.sendLocalAudioControl)(paths, "leave", 10_000);
+    if (reply.ok)
+        return "I asked it to leave.";
+    if (pid === undefined)
+        return "I could not stop it (no process id), so check for a stray join.";
+    try {
+        kill(-pid, "SIGTERM");
+        return "I stopped it.";
+    }
+    catch {
+        return "I could not stop it, so check for a stray join.";
+    }
+}
+/** Starts `ouro voice join` as a detached process and waits for it to report joined or failed. */
+async function launchLocalAudioJoin(request, deps) {
+    const paths = (0, local_audio_control_1.localAudioPaths)(deps.agentRoot(request.agentName));
+    const active = await (0, local_audio_control_1.inspectActiveJoin)(paths);
+    if (active)
+        return { ok: false, message: `A local audio session is already running (${active.callSid}). Run \`ouro voice leave\` first.` };
+    fs.rmSync(paths.statusFile, { force: true });
+    const child = deps.spawn(deps.execPath, [deps.cliEntry, ...localAudioJoinArgs(request)]);
+    let exitCode;
+    child.on("exit", (code) => { exitCode = code; });
+    child.unref();
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_local_launch",
+        message: "launched a detached local audio join",
+        meta: { agentName: request.agentName, pid: child.pid },
+    });
+    const deadline = deps.now() + deps.timeoutMs;
+    for (;;) {
+        const status = (0, local_audio_control_1.readJoinStatus)(paths);
+        if (status?.state === "joined") {
+            return { ok: true, callSid: status.callSid, message: `Joined local audio session ${status.callSid}.` };
+        }
+        if (status?.state === "failed")
+            return { ok: false, message: status.reason ?? "The local audio join failed." };
+        if (status?.state === "ended")
+            return { ok: false, message: `The local audio join ended before it finished starting (${status.reason ?? "no reason recorded"}).` };
+        if (exitCode !== undefined) {
+            return { ok: false, message: `The local audio join process exited (code ${exitCode}) before joining. See ${paths.logFile}.` };
+        }
+        if (deps.now() >= deadline) {
+            const outcome = await stopTimedOutJoin(paths, child.pid, deps.kill ?? process.kill.bind(process));
+            return { ok: false, message: `The local audio join did not report within ${Math.round(deps.timeoutMs / 1000)}s, so ${outcome} See ${paths.logFile}.` };
+        }
+        await deps.sleep(POLL_MS);
+    }
+}
+/** `OURO_LOCAL_AUDIO_OUTPUT_LATENCY_MS`: the owner's own estimate of speaker latency, in milliseconds. */
+function configuredOutputLatencyMs() {
+    const value = Number(process.env.OURO_LOCAL_AUDIO_OUTPUT_LATENCY_MS);
+    return process.env.OURO_LOCAL_AUDIO_OUTPUT_LATENCY_MS !== undefined && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function defaultLocalAudioJoinDeps(overrides = {}) {
+    const agentRoot = overrides.agentRoot ?? ((agentName) => (0, identity_1.getAgentRoot)(agentName));
+    return {
+        agentRoot,
+        resolveRealtime: (agentName) => (0, twilio_phone_runtime_1.resolveLocalAudioRealtimeOptions)(agentName),
+        createTransport: (request, bridge) => {
+            const paths = (0, local_audio_control_1.localAudioPaths)(bridge.agentRoot ?? agentRoot(request.agentName));
+            return new local_audio_transport_1.LocalAudioDeviceTransport(request, {
+                spawner: { spawn: (command, args, options) => (0, child_process_1.spawn)(command, args, { detached: options.detached, stdio: ["pipe", "pipe", "ignore"] }) },
+                bridgeOptions: bridge,
+                pidFile: paths.soxPidFile,
+                metadataDir: paths.callsDir,
+                inspectRouting: audio_routing_1.inspectVoiceAudioRouting,
+                queryMute: (0, local_audio_mute_1.createSwiftMuteQuery)({ dir: path.join(paths.dir, "tools") }),
+                outputLatencyMs: configuredOutputLatencyMs(),
+            });
+        },
+        notifyOwner: async (agentName, target, text) => {
+            await (0, local_audio_notify_1.notifyOwnerLive)(agentName, target, text, { agentRoot: agentRoot(agentName) });
+        },
+        write: (text) => { process.stdout.write(text); },
+        onStopSignal: (callback) => {
+            process.on("SIGINT", callback);
+            process.on("SIGTERM", callback);
+            return () => {
+                process.off("SIGINT", callback);
+                process.off("SIGTERM", callback);
+            };
+        },
+        ...overrides,
+    };
+}

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

@@ -0,0 +1,199 @@
+"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.MUTE_PROBE_SWIFT = void 0;
+exports.parseMuteProbeOutput = parseMuteProbeOutput;
+exports.muteFixSteps = muteFixSteps;
+exports.defaultRun = defaultRun;
+exports.createSwiftMuteQuery = createSwiftMuteQuery;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+exports.MUTE_PROBE_SWIFT = `import CoreAudio
+import Foundation
+
+func deviceIds() -> [AudioObjectID] {
+  var addr = AudioObjectPropertyAddress(mSelector: kAudioHardwarePropertyDevices, mScope: kAudioObjectPropertyScopeGlobal, mElement: kAudioObjectPropertyElementMain)
+  var size: UInt32 = 0
+  AudioObjectGetPropertyDataSize(AudioObjectID(kAudioObjectSystemObject), &addr, 0, nil, &size)
+  var ids = [AudioObjectID](repeating: 0, count: Int(size) / MemoryLayout<AudioObjectID>.size)
+  AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject), &addr, 0, nil, &size, &ids)
+  return ids
+}
+
+func deviceName(_ id: AudioObjectID) -> String {
+  var addr = AudioObjectPropertyAddress(mSelector: kAudioObjectPropertyName, mScope: kAudioObjectPropertyScopeGlobal, mElement: kAudioObjectPropertyElementMain)
+  var name: Unmanaged<CFString>? = nil
+  var size = UInt32(MemoryLayout<Unmanaged<CFString>?>.size)
+  AudioObjectGetPropertyData(id, &addr, 0, nil, &size, &name)
+  return (name?.takeRetainedValue() as String?) ?? ""
+}
+
+func muteState(_ id: AudioObjectID, scope: AudioObjectPropertyScope) -> String {
+  var result: Bool? = nil
+  for element in [kAudioObjectPropertyElementMain, 1, 2] as [UInt32] {
+    var addr = AudioObjectPropertyAddress(mSelector: kAudioDevicePropertyMute, mScope: scope, mElement: element)
+    if !AudioObjectHasProperty(id, &addr) { continue }
+    var value: UInt32 = 0
+    var size = UInt32(MemoryLayout<UInt32>.size)
+    if AudioObjectGetPropertyData(id, &addr, 0, nil, &size, &value) == 0 { result = (result ?? false) || value != 0 }
+  }
+  guard let muted = result else { return "n/a" }
+  return muted ? "muted" : "unmuted"
+}
+
+let wanted = Set(CommandLine.arguments.dropFirst())
+for id in deviceIds() {
+  let name = deviceName(id)
+  if wanted.contains(name) {
+    print("\\(name)\\tinput=\\(muteState(id, scope: kAudioObjectPropertyScopeInput))\\toutput=\\(muteState(id, scope: kAudioObjectPropertyScopeOutput))")
+  }
+}
+`;
+function scopeState(text) {
+    const value = text.split("=")[1];
+    if (value === "muted")
+        return true;
+    if (value === "unmuted")
+        return false;
+    return null;
+}
+function parseMuteProbeOutput(text) {
+    const states = [];
+    for (const line of text.split("\n")) {
+        const [device = "", input = "", output = ""] = line.split("\t");
+        if (!device || !input.startsWith("input=") || !output.startsWith("output="))
+            continue;
+        states.push({ device, inputMuted: scopeState(input), outputMuted: scopeState(output) });
+    }
+    return states;
+}
+/** Exact steps for each device that is muted at the device level. */
+function muteFixSteps(states) {
+    const steps = [];
+    for (const state of states) {
+        const scopes = [state.inputMuted ? "input" : "", state.outputMuted ? "output" : ""].filter(Boolean);
+        if (scopes.length === 0)
+            continue;
+        steps.push(`${state.device} is muted (${scopes.join(" and ")}), so it loops back pure silence. Unmute it: open Audio MIDI Setup, select ${state.device}, open the ${scopes.join(" and ")} tab${scopes.length > 1 ? "s" : ""}, and uncheck Mute on the Main channel.`);
+    }
+    return steps;
+}
+function defaultRun(command, args) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)(command, args, { encoding: "utf8", timeout: 60_000 }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+    });
+}
+function privateDirectory(dir, uid) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const stat = fs.lstatSync(dir);
+    if (!stat.isDirectory() || (uid !== undefined && stat.uid !== uid)) {
+        throw new Error(`mute probe directory ${dir} is not a directory owned by this user`);
+    }
+    if (stat.mode & 0o077)
+        fs.chmodSync(dir, 0o700);
+}
+/** A regular file (not a link), owned by us, executable, and writable by nobody else. */
+function trustedBinary(file, uid) {
+    try {
+        const stat = fs.lstatSync(file);
+        return stat.isFile() && (uid === undefined || stat.uid === uid) && (stat.mode & 0o022) === 0 && (stat.mode & 0o100) !== 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Compiles the probe once with `swiftc` (a few seconds) into the agent's private directory and
+ * caches the binary, so later joins read mute state in milliseconds. The binary's name carries a
+ * hash of the script, the build writes only new exclusive files and renames the result into place,
+ * and the owner and mode are checked again before every run. Partial builds are deleted.
+ */
+function createSwiftMuteQuery(options) {
+    const run = options.run ?? defaultRun;
+    const swiftcPath = options.swiftcPath ?? "swiftc";
+    const uid = options.uid ?? process.getuid?.();
+    const hash = (0, crypto_1.createHash)("sha256").update(exports.MUTE_PROBE_SWIFT).digest("hex").slice(0, 16);
+    const binaryPath = path.join(options.dir, `mute-probe-${hash}`);
+    const build = async () => {
+        const token = `${process.pid}.${(0, crypto_1.randomBytes)(4).toString("hex")}`;
+        const script = path.join(options.dir, `${hash}.${token}.swift`);
+        const output = path.join(options.dir, `${hash}.${token}.bin`);
+        try {
+            fs.writeFileSync(script, exports.MUTE_PROBE_SWIFT, { flag: "wx", mode: 0o600 });
+            await run(swiftcPath, ["-O", script, "-o", output]);
+            fs.chmodSync(output, 0o700);
+            fs.renameSync(output, binaryPath);
+        }
+        finally {
+            fs.rmSync(script, { force: true });
+            fs.rmSync(output, { force: true });
+        }
+    };
+    return async (devices) => {
+        try {
+            privateDirectory(options.dir, uid);
+            if (!trustedBinary(binaryPath, uid)) {
+                fs.rmSync(binaryPath, { force: true });
+                await build();
+            }
+            const states = parseMuteProbeOutput(await run(binaryPath, devices));
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.voice_local_mute_checked",
+                message: "local audio device mute state read",
+                meta: { devices: devices.length, muted: states.filter((s) => s.inputMuted || s.outputMuted).length },
+            });
+            return states;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.voice_local_mute_check_unavailable",
+                message: "local audio device mute state could not be read",
+                meta: { error: error instanceof Error ? error.message : String(error) },
+            });
+            return null;
+        }
+    };
+}