@ouro.bot/cli 0.1.0-alpha.887 → 0.1.0-alpha.889

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.889",
+      "changes": [
+        "Agents can join a call on this Mac (FaceTime, Zoom, Meet, a podcast recorder) through BlackHole virtual audio: ouro voice join/leave/status and a family-only voice_join_local_audio tool, with a spoken AI disclosure, room-level trust, a two-tool allowlist, a single-join lock and fail-loud device checks."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.888",
+      "changes": [
+        "Answer gates (source grounding and brevity) now hold a plain-text reply as well as a settle answer, so a reply with no settle call can no longer name an unsourced cast or ignore a brevity request."
+      ]
+    },
     {
       "version": "0.1.0-alpha.887",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.887",
+  "runtimeVersion": "0.1.0-alpha.889",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.887</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.889</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/core.js

@@ -1208,6 +1208,38 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         rejectedAttempt = [structuredClone(assistant)];
         nextAttemptControls = controls;
     };
+    // Answer gates run only for agents that opt in (ToolContext.answerGates), on every reply the person would receive: a settle answer
+    // and a plain-text reply with no tool call alike (alpha.886 replay: a plain-text reply skipped them and an invented cast went out).
+    // A request-specific contract (options.requiredToolCalls) already validates its own terminal answer. Each gate has its own bounded
+    // retry, and none spends the last provider iteration.
+    const answerGateVerdict = (answer, intent) => {
+        const gates = options?.requiredToolCalls ? undefined : options?.toolContext?.answerGates;
+        const retriesLeft = providerIterations < stepBudget - 1;
+        let groundingError = null;
+        let unverifiedNames = null;
+        const grounding = gates?.sourceGrounding ? (0, source_grounding_1.sourceGroundingFinding)({ answer, userText: userTexts(messages).join("\n"), latestUserText: latestUserMessageText(messages.slice(0, turnStartLength)), knownText: priorTurnsText(messages.slice(0, turnStartLength)), tools: turnToolRecords }) : null;
+        if (grounding) {
+            if (groundingRejections < ANSWER_GATE_MAX_REJECTIONS && retriesLeft) {
+                groundingRejections += 1;
+                groundingError = grounding.message;
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.answer_gate_rejected", message: "answer named things from a work that the turn did not look up; sending the model back", meta: { gate: "source_grounding", rejection: groundingRejections, cap: ANSWER_GATE_MAX_REJECTIONS, lookupsRun: grounding.lookups } });
+            }
+            else {
+                unverifiedNames = grounding.names;
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.answer_gate_disclosed", message: "unsourced names survived the retries; delivering with a disclosure", meta: { gate: "source_grounding", names: grounding.names.length } });
+            }
+        }
+        let brevityError = null;
+        if (!groundingError && gates?.brevity && !options?.toolContext?.context?.isGroupChat && brevityRejections < ANSWER_GATE_MAX_REJECTIONS && retriesLeft
+            && (0, reply_style_1.briefStyleRequested)(userTexts(messages), (0, reply_style_1.savedCommunicationPreference)(options?.toolContext?.context?.friend))) {
+            brevityError = (0, reply_style_1.briefStyleViolation)(answer, intent);
+            if (brevityError) {
+                brevityRejections += 1;
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.answer_gate_rejected", message: "answer broke the person's brevity request; sending the model back", meta: { gate: "brevity", rejection: brevityRejections, cap: ANSWER_GATE_MAX_REJECTIONS } });
+            }
+        }
+        return { error: groundingError ?? brevityError, unverifiedNames };
+    };
     const rejectToolBatch = (assistant, reasons) => {
         rejectAttempt(assistant, assistant.tool_calls.map((call, index) => ({
             role: "tool", tool_call_id: call.id, content: reasons[index],
@@ -1774,6 +1806,24 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             }]);
                         continue;
                     }
+                    // A plain-text reply reaches the person just as a settle answer does, so the answer gates hold it too.
+                    const textAnswer = isPrivateRuntimeChannel ? "" : stripThinkBlocksForViolationCheck(result.content).trim();
+                    const textVerdict = textAnswer ? answerGateVerdict(textAnswer) : null;
+                    if (textVerdict?.error) {
+                        streamCallbackBuffer?.discard();
+                        callbacks.onClearText?.();
+                        rejectAttempt(msg, [{ role: "user", content: textVerdict.error }]);
+                        continue;
+                    }
+                    if (textVerdict?.unverifiedNames) {
+                        const disclosed = (0, source_grounding_1.withUnverifiedDisclosure)(textAnswer, textVerdict.unverifiedNames);
+                        streamCallbackBuffer?.discard();
+                        callbacks.onClearText?.();
+                        callbacks.onTextChunk(disclosed);
+                        pushGenerated({ ...msg, content: disclosed });
+                        done = true;
+                        continue;
+                    }
                     // Legitimate text-only response, or cap reached — accept as-is.
                     await streamCallbackBuffer?.flush();
                     pushGenerated(msg);
@@ -1976,34 +2026,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             sawSettleContentMismatch = true;
                             (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.settle_content_mismatch", message: "settle answer differs from the reply text written beside it; asking once for the reply as the answer", meta: { answerLength: deliveredAnswer.length, contentLength: msg.content.length } });
                         }
-                        // Answer gates run only for agents that opt in (ToolContext.answerGates). A request-specific contract (options.requiredToolCalls)
-                        // already validates its own terminal answer. Each gate has its own bounded retry, and none spends the last provider iteration.
-                        const gates = options?.requiredToolCalls ? undefined : options?.toolContext?.answerGates;
-                        const retriesLeft = providerIterations < stepBudget - 1;
-                        let groundingError = null;
-                        let unverifiedNames = null;
-                        const grounding = gates?.sourceGrounding ? (0, source_grounding_1.sourceGroundingFinding)({ answer: deliveredAnswer, userText: userTexts(messages).join("\n"), latestUserText: latestUserMessageText(messages.slice(0, turnStartLength)), knownText: priorTurnsText(messages.slice(0, turnStartLength)), tools: turnToolRecords }) : null;
-                        if (grounding) {
-                            if (groundingRejections < ANSWER_GATE_MAX_REJECTIONS && retriesLeft) {
-                                groundingRejections += 1;
-                                groundingError = grounding.message;
-                                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.answer_gate_rejected", message: "settle answer named things from a work that the turn did not look up; sending the model back", meta: { gate: "source_grounding", rejection: groundingRejections, cap: ANSWER_GATE_MAX_REJECTIONS, lookupsRun: grounding.lookups } });
-                            }
-                            else {
-                                unverifiedNames = grounding.names;
-                                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.answer_gate_disclosed", message: "unsourced names survived the retries; delivering with a disclosure", meta: { gate: "source_grounding", names: grounding.names.length } });
-                            }
-                        }
-                        let brevityError = null;
-                        if (!groundingError && gates?.brevity && !options?.toolContext?.context?.isGroupChat && brevityRejections < ANSWER_GATE_MAX_REJECTIONS && retriesLeft
-                            && (0, reply_style_1.briefStyleRequested)(userTexts(messages), (0, reply_style_1.savedCommunicationPreference)(options?.toolContext?.context?.friend))) {
-                            brevityError = (0, reply_style_1.briefStyleViolation)(deliveredAnswer, intent);
-                            if (brevityError) {
-                                brevityRejections += 1;
-                                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.answer_gate_rejected", message: "settle answer broke the person's brevity request; sending the model back", meta: { gate: "brevity", rejection: brevityRejections, cap: ANSWER_GATE_MAX_REJECTIONS } });
-                            }
-                        }
-                        const answerGateError = groundingError ?? brevityError;
+                        const { error: answerGateError, unverifiedNames } = answerGateVerdict(deliveredAnswer, intent);
                         const retryError = contentMismatch
                             ?? answerGateError
                             ?? privateReturnAckLeakError(deliveredAnswer, privateReturnHeldTokens)

package/dist/heart/daemon/cli-exec.js

@@ -8220,6 +8220,24 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         return executeLegacyConfigModel(command, deps);
     }
     /* v8 ignore stop */
+    // ── voice join / leave / status (local audio lane; no daemon socket, control is a local unix socket) ──
+    if (command.kind === "voice.join" || command.kind === "voice.leave" || command.kind === "voice.status") {
+        const voice = await Promise.resolve().then(() => __importStar(require("../../senses/voice/local-audio-join")));
+        const voiceDeps = voice.defaultLocalAudioJoinDeps();
+        let message;
+        if (command.kind === "voice.join") {
+            const summary = await voice.runLocalAudioJoin(command.request, voiceDeps);
+            message = `Local audio session ${summary.callSid} ended (${summary.reason}) after ${Math.round(summary.durationMs / 1000)}s.`;
+        }
+        else if (command.kind === "voice.leave") {
+            message = await voice.runLocalAudioLeave(command.agent, voiceDeps);
+        }
+        else {
+            message = await voice.runLocalAudioStatus(command.agent, voiceDeps);
+        }
+        deps.writeStdout(message);
+        return message;
+    }
     // ── whoami (local, no daemon socket needed) ──
     if (command.kind === "whoami") {
         const formatWhoami = (agentName, homePath, bonesVersion) => {

package/dist/heart/daemon/cli-help.js

@@ -99,6 +99,13 @@ exports.COMMAND_REGISTRY = {
         usage: "ouro whoami [--agent <name>]",
         example: "ouro whoami",
     },
+    voice: {
+        category: "Agents",
+        description: "Join a call on this Mac through the BlackHole audio devices, or leave it",
+        usage: "ouro voice join --agent <name> [--friend <id>] [--participants <text>] [--occasion <text>] [--mode conversation] | ouro voice leave --agent <name> | ouro voice status --agent <name>",
+        example: "ouro voice join --agent slugger --participants \"Ari and Sam\" --occasion \"podcast prep\"",
+        subcommands: ["join", "leave", "status"],
+    },
     config: {
         category: "Agents",
         description: "Legacy model compatibility helpers; prefer `ouro use` and `ouro check`",

package/dist/heart/daemon/cli-parse.js

@@ -5,6 +5,39 @@
  * Pure functions: no side effects, no daemon communication.
  * Each command group has its own parser; parseOuroCommand dispatches.
  */
+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.extractAgentFlag = extractAgentFlag;
 exports.extractFacingFlag = extractFacingFlag;
@@ -15,8 +48,11 @@ exports.inferAgentNameFromRemote = inferAgentNameFromRemote;
 exports.parseMcpServeCommand = parseMcpServeCommand;
 exports.parseAcpServeCommand = parseAcpServeCommand;
 exports.parseOuroCommand = parseOuroCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const friends_1 = require("@ouro.bot/friends");
 const cli_help_1 = require("./cli-help");
+const local_audio_control_1 = require("../../senses/voice/local-audio-control");
 const cli_desk_1 = require("./cli-desk");
 const flight_recorder_1 = require("../../arc/flight-recorder");
 const core_1 = require("../../nerves/review/core");
@@ -31,6 +67,119 @@ function extractAgentFlag(args) {
     const rest = [...args.slice(0, idx), ...args.slice(idx + 2)];
     return { agent, rest };
 }
+const VOICE_USAGE = "Usage: ouro voice join --agent <name> [--friend <id>] [--participants <text>] [--occasion <text>] [--mode conversation] | ouro voice leave --agent <name> | ouro voice status --agent <name>";
+const VOICE_TEXT_FLAGS = {
+    "--friend": "friendId",
+    "--participants": "participants",
+    "--occasion": "occasion",
+    "--owner-name": "ownerName",
+    "--silent-consent": "silentConsent",
+};
+function parseVoicePositiveInt(value) {
+    if (!value || !/^[1-9]\d*$/.test(value))
+        throw new Error(VOICE_USAGE);
+    return Number(value);
+}
+/**
+ * File mode hands these paths to sox, which treats a bare `-` as standard input and `-d` or `-t`
+ * style words as devices and options. Only a real file path is allowed: absolute after resolving, a
+ * regular file for input, and a regular file (or new file) in an existing directory for output.
+ */
+function validateVoiceFile(flag, value, kind) {
+    const fail = (why) => { throw new Error(`${flag} ${why}. ${VOICE_USAGE}`); };
+    if (value.startsWith("-"))
+        return fail("must be a regular file path, not a dash or option");
+    const resolved = path.resolve(value);
+    const describe = (file) => {
+        try {
+            return fs.statSync(file);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const stat = describe(resolved);
+    if (kind === "input") {
+        if (!stat)
+            return fail(`file ${resolved} does not exist`);
+        if (!stat.isFile())
+            return fail(`must be a regular file, and ${resolved} is not`);
+        return resolved;
+    }
+    if (stat) {
+        if (!stat.isFile())
+            return fail(`must be a regular file, and ${resolved} is not (no devices or directories)`);
+        return resolved;
+    }
+    const parent = describe(path.dirname(resolved));
+    if (!parent?.isDirectory())
+        return fail(`needs an existing directory, and ${path.dirname(resolved)} is not one`);
+    return resolved;
+}
+/** `ouro voice join|leave|status`: the local audio lane. Device names are never arguments. */
+function parseVoiceCommand(args) {
+    const [sub, ...flags] = args;
+    if (sub !== "join" && sub !== "leave" && sub !== "status")
+        throw new Error(VOICE_USAGE);
+    const request = { agentName: "" };
+    let inputPath;
+    let outputPath;
+    for (let i = 0; i < flags.length; i += 1) {
+        const flag = flags[i];
+        if (flag === "--owner-alone" && sub === "join") {
+            request.ownerAlone = true;
+            continue;
+        }
+        const value = flags[i + 1];
+        if (value === undefined || value.startsWith("--"))
+            throw new Error(VOICE_USAGE);
+        i += 1;
+        if (flag === "--agent") {
+            request.agentName = value;
+        }
+        else if (sub !== "join") {
+            throw new Error(VOICE_USAGE);
+        }
+        else if (flag in VOICE_TEXT_FLAGS) {
+            request[VOICE_TEXT_FLAGS[flag]] = value;
+        }
+        else if (flag === "--mode") {
+            if (value !== "conversation")
+                throw new Error(VOICE_USAGE);
+            request.mode = "conversation";
+        }
+        else if (flag === "--notify-session") {
+            const notify = (0, local_audio_control_1.parseNotifySession)(value);
+            if (!notify)
+                throw new Error(VOICE_USAGE);
+            request.notify = notify;
+        }
+        else if (flag === "--input-file") {
+            inputPath = validateVoiceFile(flag, value, "input");
+        }
+        else if (flag === "--output-file") {
+            outputPath = validateVoiceFile(flag, value, "output");
+        }
+        else if (flag === "--idle-silence-ms") {
+            request.idleSilenceMs = parseVoicePositiveInt(value);
+        }
+        else if (flag === "--max-duration-ms") {
+            request.maxDurationMs = parseVoicePositiveInt(value);
+        }
+        else {
+            throw new Error(VOICE_USAGE);
+        }
+    }
+    if (!request.agentName)
+        throw new Error(VOICE_USAGE);
+    if (sub !== "join")
+        return { kind: sub === "leave" ? "voice.leave" : "voice.status", agent: request.agentName };
+    if ((inputPath === undefined) !== (outputPath === undefined))
+        throw new Error(VOICE_USAGE);
+    if (inputPath !== undefined && outputPath !== undefined)
+        request.files = { inputPath, outputPath };
+    return { kind: "voice.join", request };
+}
 function parseLogsCommand(args) {
     if (args.length === 0)
         return { kind: "daemon.logs" };
@@ -164,6 +313,9 @@ function usage() {
         "  ouro a2a delegated-commands revoke --friend <id> [--agent <name>]   (run as root)",
         "  ouro a2a delegated-commands list [--json] [--agent <name>]",
         "  ouro whoami [--agent <name>]",
+        "  ouro voice join --agent <name> [--friend <id>] [--participants <text>] [--occasion <text>] [--mode conversation] [--owner-alone] [--owner-name <name>] [--silent-consent <statement>]",
+        "  ouro voice leave --agent <name>",
+        "  ouro voice status --agent <name>",
         "  ouro session list [--agent <name>]",
         "  ouro mcp list",
         "  ouro mcp call <server> <tool> [--args '{...}']",
@@ -2892,6 +3044,8 @@ function parseOuroCommand(args) {
         return parseConfigCommand(args.slice(1));
     if (head === "mcp")
         return parseMcpCommand(args.slice(1));
+    if (head === "voice")
+        return parseVoiceCommand(args.slice(1));
     if (head === "whoami") {
         const { agent } = extractAgentFlag(args.slice(1));
         return { kind: "whoami", ...(agent ? { agent } : {}) };

package/dist/repertoire/tools-voice-local.js

@@ -0,0 +1,198 @@
+"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.voiceLocalAudioToolDefinition = void 0;
+exports.localAudioToolGate = localAudioToolGate;
+exports.ownerConsentsToSilentJoin = ownerConsentsToSilentJoin;
+exports.createVoiceLocalAudioToolDefinition = createVoiceLocalAudioToolDefinition;
+exports.defaultLocalAudioToolDeps = defaultLocalAudioToolDeps;
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+/**
+ * The tool that lets a family-trusted owner ask the agent to join a call on this Mac through the
+ * BlackHole virtual devices. It has no device arguments: the lane always captures BlackHole 16ch
+ * and plays into BlackHole 2ch, so it can never listen to a physical microphone.
+ */
+const TOOL_NAME = "voice_join_local_audio";
+/** Direct (one person to one agent) text channels. Voice, inner, mail, a2a and mcp never get this tool. */
+const DIRECT_TEXT_CHANNELS = new Set(["cli", "bluebubbles", "telegram"]);
+const DEVICE_ARGUMENTS = new Set(["device", "input_device", "output_device", "microphone", "input", "output", "capture_device", "playback_device"]);
+const ACTIONS = new Set(["join", "leave", "status"]);
+/** One predicate for both the offer (tool selection) and the execution-time re-check. */
+function localAudioToolGate(input) {
+    const context = input.context;
+    if (!context?.friend || !context.channel)
+        return { ok: false, reason: "no resolved friend for this session" };
+    if (input.habitSession || input.autonomousTurnKind || input.currentExternalEvent || input.delegatedCommand || input.relationshipAuthorization || input.voiceCall) {
+        return { ok: false, reason: "this turn is automatic, delegated, relationship-scoped or a live call, not a direct conversation" };
+    }
+    if (!DIRECT_TEXT_CHANNELS.has(context.channel.channel)) {
+        return { ok: false, reason: "it works only in a direct text session (cli, bluebubbles, telegram); Teams cannot confirm a one-to-one chat yet" };
+    }
+    if (context.isGroupChat)
+        return { ok: false, reason: "it is not available in a group chat" };
+    if (context.friend.trustLevel !== "family")
+        return { ok: false, reason: "only a family-trust friend can start it" };
+    return { ok: true };
+}
+const normalizeSentence = (text) => text.replace(/\s+/g, " ").trim().replace(/[.!?;:,\s]+$/u, "").toLowerCase();
+const CONSENT_WORDING = /\b(consent(s|ed)?|agree[sd]?|okay with|ok with|fine with|permission)\b/iu;
+const SILENT_WORDING = /\b(silent(ly)?|quiet(ly)?|no announcement|without (an |the )?announc\w*|don'?t announce|do not announce|skip the announcement)\b/iu;
+const MIN_CONSENT_WORDS = 5;
+/**
+ * True only when the statement is one whole sentence of the owner's current message, word for word,
+ * and that sentence both states consent and asks for a silent join. A fragment ("the call") or a
+ * sentence about something else never counts, so text the model was steered into quoting cannot
+ * turn an ordinary request into a covert recording.
+ */
+function ownerConsentsToSilentJoin(message, statement) {
+    const wanted = normalizeSentence(statement);
+    if (wanted.split(" ").length < MIN_CONSENT_WORDS || !CONSENT_WORDING.test(wanted) || !SILENT_WORDING.test(wanted))
+        return false;
+    const sentences = (message ?? "").split(/(?<=[.!?])\s+|\n+/u).map(normalizeSentence);
+    return sentences.includes(wanted);
+}
+function readString(args, key) {
+    const value = args[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function createVoiceLocalAudioToolDefinition(deps) {
+    return {
+        tool: {
+            type: "function",
+            function: {
+                name: TOOL_NAME,
+                description: [
+                    "join, leave, or check a call on this Mac through the BlackHole virtual audio devices (any call app: FaceTime, Zoom, Meet, a recorder).",
+                    "The call app must use BlackHole 2ch as its microphone and BlackHole 16ch as its speaker. This tool never listens to a physical microphone and takes no device names.",
+                    "Joining announces you aloud as an AI assistant that is transcribing. Skip the announcement only when the owner's current message has a sentence saying everyone consented to a silent join; pass that whole sentence in silent_consent exactly as they wrote it. A paraphrase or a fragment is refused.",
+                    "Several people may share this audio, and you cannot tell voices apart. Use action=leave to hang up.",
+                ].join(" "),
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["join", "leave", "status"], description: "join (default), leave, or status" },
+                        participants: { type: "string", description: "who is on the call, as the owner described them" },
+                        occasion: { type: "string", description: "what the call is for" },
+                        owner_alone: { type: "boolean", description: "true only when the owner said they are alone on the call" },
+                        silent_consent: { type: "string", description: "the owner's own words consenting to a silent join (no spoken announcement), copied verbatim from their current message; omit otherwise" },
+                    },
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const gate = ctx ? localAudioToolGate(ctx) : { ok: false, reason: "no session context" };
+            if (!gate.ok)
+                return `${TOOL_NAME} is not available: ${gate.reason}.`;
+            const provided = Object.keys(args).find((key) => DEVICE_ARGUMENTS.has(key));
+            if (provided) {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "tools", event: "tool.voice_local_audio_device_refused", message: "local audio tool refused a device argument", meta: { argument: provided } });
+                return "This tool only uses the BlackHole virtual devices and never listens to a physical microphone or any other device. Remove the device argument.";
+            }
+            const action = readString(args, "action") ?? "join";
+            if (!ACTIONS.has(action))
+                return "action must be join, leave, or status.";
+            const agentName = ctx?.agentName;
+            if (!agentName)
+                return `${TOOL_NAME} is not available: no agent name for this session.`;
+            if (action === "leave")
+                return deps.leave(agentName);
+            if (action === "status")
+                return deps.status(agentName);
+            const silentConsent = readString(args, "silent_consent");
+            if (silentConsent && !ownerConsentsToSilentJoin(ctx.currentUserMessage, silentConsent)) {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "tools", event: "tool.voice_local_audio_silent_refused", message: "silent join refused: consent not in the owner's current message", meta: { agentName } });
+                return "I can't do a silent join from here: the consent has to be one whole sentence of the owner's current message, copied exactly, that says everyone consented to a silent join, and I can't confirm that. Join with the spoken announcement instead, or the owner can run `ouro voice join --silent-consent \"...\"` themselves.";
+            }
+            const friend = ctx.context.friend;
+            const channel = ctx.context.channel.channel;
+            const session = ctx.currentSession;
+            const notify = session
+                ? { friendId: session.friendId, channel: session.channel, key: session.key }
+                : channel === "cli" ? { friendId: friend.id, channel: "cli", key: "session" } : undefined;
+            const request = {
+                agentName,
+                friendId: friend.id,
+                mode: "conversation",
+                ownerName: friend.name,
+                ...(readString(args, "participants") ? { participants: readString(args, "participants") } : {}),
+                ...(readString(args, "occasion") ? { occasion: readString(args, "occasion") } : {}),
+                ...(String(args.owner_alone) === "true" ? { ownerAlone: true } : {}),
+                ...(silentConsent ? { silentConsent } : {}),
+                ...(notify ? { notify } : {}),
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "tools",
+                event: "tool.voice_local_audio_join_requested",
+                message: "local audio join requested by the owner",
+                meta: { agentName, silent: String(Boolean(request.silentConsent)), ownerAlone: String(Boolean(request.ownerAlone)), notify: String(Boolean(notify)) },
+            });
+            const result = await deps.launch(request);
+            if (!result.ok)
+                return `I did not join the call: ${result.message}`;
+            return [
+                result.message,
+                request.silentConsent
+                    ? "I joined silently on the owner's stated consent."
+                    : "I am announcing myself aloud as an AI assistant that is transcribing; if I cannot confirm that was spoken I leave and tell the owner.",
+                "The call app must use BlackHole 2ch as its microphone and BlackHole 16ch as its speaker for me to hear and be heard.",
+                notify ? "The owner is notified when I join and when I leave." : "I could not notify the owner's session (no session to notify), so tell them yourself.",
+            ].join(" ");
+        },
+    };
+}
+/** Loaded lazily: the join runner pulls in the whole Realtime session, which itself imports the tool registry. */
+function defaultLocalAudioToolDeps(options = {}) {
+    const agentRoot = options.agentRoot ?? ((agentName) => (0, identity_1.getAgentRoot)(agentName));
+    return {
+        launch: async (request) => {
+            const join = await Promise.resolve().then(() => __importStar(require("../senses/voice/local-audio-join")));
+            const control = await Promise.resolve().then(() => __importStar(require("../senses/voice/local-audio-control")));
+            const launch = options.launch ?? {
+                execPath: process.execPath,
+                cliEntry: path.resolve(__dirname, "../heart/daemon/ouro-entry.js"),
+                spawn: join.defaultLaunchSpawn(control.localAudioPaths(agentRoot(request.agentName))),
+                sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+                now: Date.now,
+                timeoutMs: 300_000,
+            };
+            return join.launchLocalAudioJoin(request, { agentRoot, ...launch });
+        },
+        leave: async (agentName) => (await Promise.resolve().then(() => __importStar(require("../senses/voice/local-audio-join")))).runLocalAudioLeave(agentName, { agentRoot }),
+        status: async (agentName) => (await Promise.resolve().then(() => __importStar(require("../senses/voice/local-audio-join")))).runLocalAudioStatus(agentName, { agentRoot }),
+    };
+}
+exports.voiceLocalAudioToolDefinition = createVoiceLocalAudioToolDefinition(defaultLocalAudioToolDeps());

package/dist/repertoire/tools.js

@@ -40,6 +40,7 @@ const tools_house_care_1 = require("./tools-house-care");
 const steward_policy_1 = require("../heart/steward-policy");
 const relationship_authorization_1 = require("./relationship-authorization");
 const tool_approval_1 = require("../heart/tool-approval");
+const tools_voice_local_1 = require("./tools-voice-local");
 const tools_sanctuary_host_1 = require("./tools-sanctuary-host");
 function safeGetAgentRoot() {
     try {
@@ -172,6 +173,7 @@ function selectToolsForChannel(capabilities, toolPreferences, _context, provider
             ...tools_base_1.baseToolDefinitions,
             ...(capabilities?.channel === "bluebubbles" ? tools_bluebubbles_1.bluebubblesToolDefinitions : []),
             ...(capabilities?.channel === "voice" ? tools_voice_1.voiceToolDefinitions : []),
+            ...((0, tools_voice_local_1.localAudioToolGate)({ ...context, context: _context }).ok ? [tools_voice_local_1.voiceLocalAudioToolDefinition] : []),
             ...integrations, ...mcp,
         ];
     }

package/dist/senses/voice/call-auth.js

@@ -139,7 +139,9 @@ class PendingVoiceCalls {
         this.maxEntries = options.maxEntries ?? exports.DEFAULT_PENDING_VOICE_CALL_MAX_ENTRIES;
         this.now = options.now ?? Date.now;
     }
-    record(identity, nonce) {
+    record(candidate, nonce) {
+        // The network registry never carries local-audio identity; only the local transport sets it.
+        const { local: _local, ...identity } = candidate;
         const existing = this.live(identity.callSid);
         const nonces = existing?.nonces ?? new Set();
         nonces.add(nonce);