@ouro.bot/cli 0.1.0-alpha.945 → 0.1.0-alpha.946

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_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.946",
+      "changes": [
+        "Shepherd's notices about your coding agents now reach you on the channel you use, such as iMessage, and every message the agent sends on its own is saved into that conversation, so your reply arrives with context.",
+        "On a machine linked to its owner, Shepherd's notices go only to that owner and never to other family members."
+      ]
+    },
     {
       "version": "0.1.0-alpha.945",
       "changes": [

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

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.945",
+  "runtimeVersion": "0.1.0-alpha.946",
   "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.945</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.946</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/reach-channel.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REACH_CHANNELS = void 0;
+exports.resolveReachTarget = resolveReachTarget;
+const runtime_1 = require("../nerves/runtime");
+const config_1 = require("./config");
+const session_activity_1 = require("./session-activity");
+/** Channels an agent can reach a person on outside a live conversation. */
+exports.REACH_CHANNELS = ["bluebubbles", "teams"];
+function isReachChannel(value) {
+    return typeof value === "string" && exports.REACH_CHANNELS.includes(value);
+}
+/** The friend's id on a channel, when that channel is enabled and the friend has one. */
+function reachableOn(friend, channel, enabled) {
+    if (!enabled.has(channel))
+        return null;
+    const provider = channel === "bluebubbles" ? "imessage-handle" : "aad";
+    const ids = Array.isArray(friend.externalIds) ? friend.externalIds : [];
+    // A `group:` id is a group chat the friend is in, never a way to reach them alone.
+    const id = ids.find(entry => entry?.provider === provider && typeof entry.externalId === "string" && entry.externalId.trim() !== "" &&
+        !entry.externalId.startsWith("group:"));
+    if (!id)
+        return null;
+    return { channel, handle: id.externalId.toLowerCase(), ...(channel === "teams" && id.tenantId ? { tenantId: id.tenantId } : {}) };
+}
+/**
+ * A 1:1 session key, read back from its sanitized filename. A BlueBubbles key is 1:1 when it is a DM chat GUID
+ * (`chat_<service>;-;<handle>`) or the chat-identifier fallback naming this friend's own handle; a group never is.
+ * A Teams key is 1:1 when it is a personal conversation id (`a:` sanitized to `a_`).
+ */
+function isOneToOne(channel, key, friend) {
+    if (channel === "teams")
+        return key.startsWith("a_");
+    if (key.includes(";+;"))
+        return false;
+    if (key.startsWith("chat_") && key.includes(";-;"))
+        return true;
+    const handle = reachableOn(friend, "bluebubbles", new Set(["bluebubbles"]))?.handle;
+    return handle !== undefined && key.toLowerCase() === `chat_identifier_${(0, config_1.sanitizeKey)(handle)}`;
+}
+/** The friend's own 1:1 sessions, newest inbound first. Messages the agent recorded never rank a session. */
+function friendSessions(input) {
+    return (0, session_activity_1.listSessionActivity)({ sessionsDir: input.sessionsDir, friendsDir: input.friendsDir, agentName: input.agentName,
+        activeThresholdMs: Number.POSITIVE_INFINITY, nowMs: input.nowMs, friendId: input.friend.id })
+        .filter((record) => record.friendId === input.friend.id && record.activitySource === "friend-facing" && record.lastInboundAt !== null &&
+        isReachChannel(record.channel) && isOneToOne(record.channel, record.key, input.friend))
+        .sort((a, b) => Date.parse(b.lastInboundAt) - Date.parse(a.lastInboundAt));
+}
+/**
+ * Chooses the channel that reaches a friend outside a live conversation: their stated preference when it is current and
+ * reachable, else the channel of their newest 1:1 session, else any reachable channel (BlueBubbles, then Teams).
+ */
+function resolveReachTarget(input) {
+    const { friend, enabledChannels } = input;
+    const nowMs = (input.now ?? Date.now)();
+    const sessions = friendSessions({ ...input, nowMs });
+    const target = (reach) => ({
+        channel: reach.channel, key: sessions.find(record => record.channel === reach.channel)?.key ?? null,
+        friendId: friend.id, handle: reach.handle, ...(reach.tenantId ? { tenantId: reach.tenantId } : {}),
+    });
+    const stated = friend.relationshipPolicy?.preferences.reachChannel;
+    const current = stated && (stated.provenance === "stated" || stated.provenance === "default") && isReachChannel(stated.value) &&
+        (!stated.expiresAt || Date.parse(stated.expiresAt) > nowMs);
+    const preferred = current ? stated.value : null;
+    const preferredReach = preferred ? reachableOn(friend, preferred, enabledChannels) : null;
+    if (preferredReach)
+        return target(preferredReach);
+    let chosen = null;
+    for (const record of sessions) {
+        chosen = reachableOn(friend, record.channel, enabledChannels);
+        if (chosen)
+            break;
+    }
+    for (const channel of exports.REACH_CHANNELS) {
+        if (chosen)
+            break;
+        chosen = reachableOn(friend, channel, enabledChannels);
+    }
+    if (preferred) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.reach_channel_fallback",
+            message: `${preferred} cannot reach this friend, so the notice goes ${chosen ? `on ${chosen.channel}` : "nowhere"}`,
+            meta: { friendId: friend.id, preferred, chosen: chosen?.channel ?? null } });
+    }
+    return chosen ? target(chosen) : { unreachable: `no reachable channel: enable BlueBubbles or Teams and link this friend's id`, friendId: friend.id };
+}

package/dist/heart/session-activity.js

@@ -141,6 +141,8 @@ function listSessionActivity(query) {
         return [];
     }
     for (const friendId of friendDirs) {
+        if (query.friendId !== undefined && friendId !== query.friendId)
+            continue;
         const friendPath = path.join(sessionsDir, friendId);
         let channels;
         try {

package/dist/heart/session-events.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVENT_CONTENT_MAX_CHARS = void 0;
+exports.EVENT_CONTENT_MAX_CHARS = exports.OUTBOUND_ORIGINS = void 0;
 exports.materializeApprovalTerminal = materializeApprovalTerminal;
 exports.attachApprovalSuspensionCheckpoint = attachApprovalSuspensionCheckpoint;
 exports.listApprovalSuspensionCheckpoints = listApprovalSuspensionCheckpoints;
@@ -72,6 +72,18 @@ const node_crypto_1 = require("node:crypto");
 const node_util_1 = require("node:util");
 const runtime_1 = require("../nerves/runtime");
 const structured_output_1 = require("./structured-output");
+exports.OUTBOUND_ORIGINS = ["shepherd", "send_message", "voice", "reminder", "proactive"];
+/**
+ * A readable outbound marker. Any non-empty origin is kept, so a marker written by a newer harness with an origin this
+ * one does not know still dedupes by its deliveryId; extra fields are dropped on normalization.
+ */
+function isSessionEventOutbound(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.origin === "string" && record.origin.length > 0
+        && typeof record.deliveryId === "string" && record.deliveryId.length > 0;
+}
 const APPROVAL_TERMINAL_TEXT = {
     denied: "approval denied by requester; the protected action was not executed",
     expired: "approval expired before execution; the protected action was not executed",
@@ -1148,6 +1160,9 @@ function normalizeSessionEvent(event, index, recordedAt) {
             captureKind: typeof provenance?.captureKind === "string" ? provenance.captureKind : "live",
             legacyVersion: typeof provenance?.legacyVersion === "number" ? provenance.legacyVersion : null,
             sourceMessageIndex: typeof provenance?.sourceMessageIndex === "number" ? provenance.sourceMessageIndex : null,
+            ...(isSessionEventOutbound(provenance?.outbound)
+                ? { outbound: { origin: provenance.outbound.origin, deliveryId: provenance.outbound.deliveryId } }
+                : {}),
         },
     };
 }
@@ -1482,12 +1497,14 @@ function buildCanonicalSessionEnvelope(options) {
     envelope.structuredOutputs = (0, structured_output_1.extractStructuredOutputsFromEvents)(providerProjectionEvents(envelope));
     return { envelope, evictedEvents };
 }
-function appendSyntheticAssistantEvent(envelope, content, recordedAt) {
+function appendSyntheticAssistantEvent(envelope, content, recordedAt, outbound) {
     // Use nextEventSequence(events) instead of `events.length + 1` so any gap
     // (from pruning, archive replay, or self-heal dedup) cannot collide with
     // an existing event id. Same fix pattern as line 1046.
     const sequence = nextEventSequence(envelope.events);
     const event = buildEventFromMessage({ role: "assistant", content }, sequence, recordedAt, "synthetic", null, null);
+    if (outbound)
+        event.provenance = { ...event.provenance, outbound: { origin: outbound.origin, deliveryId: outbound.deliveryId } };
     const priorIds = projectedSessionEventIds(envelope);
     const updated = {
         ...envelope,

package/dist/mind/context.js

@@ -318,15 +318,24 @@ function saveSession(filePath, messages, lastUsage, state, lease) {
         return envelope.events;
     });
 }
-function appendSyntheticAssistantMessage(filePath, content, lease) {
+/**
+ * Appends an assistant message the agent did not produce in this session's own turn. With `createIfMissing`, a missing
+ * session starts as an empty envelope. With `outbound`, a delivery already recorded here is not recorded again.
+ */
+function appendSyntheticAssistantMessage(filePath, content, lease, options = {}) {
     try {
         return withMutationLease(filePath, lease, (owned) => {
-            if (!fs.existsSync(filePath))
+            const recordedAt = new Date().toISOString();
+            const exists = fs.existsSync(filePath);
+            if (!exists && !options.createIfMissing)
                 return false;
-            const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+            const envelope = exists ? (0, session_events_1.loadSessionEnvelopeFile)(filePath) : emptySessionEnvelope(recordedAt);
             if (!envelope)
                 return false;
-            const updated = (0, session_events_1.appendSyntheticAssistantEvent)(envelope, content, new Date().toISOString());
+            const deliveryId = options.outbound?.deliveryId;
+            if (deliveryId && envelope.events.some((event) => event.provenance.outbound?.deliveryId === deliveryId))
+                return true;
+            const updated = (0, session_events_1.appendSyntheticAssistantEvent)(envelope, content, recordedAt, options.outbound);
             writeSessionEnvelopeUnderLease(filePath, updated, owned);
             (0, runtime_1.emitNervesEvent)({
                 component: "mind",
@@ -341,6 +350,18 @@ function appendSyntheticAssistantMessage(filePath, content, lease) {
         return false;
     }
 }
+function emptySessionEnvelope(recordedAt) {
+    return (0, session_events_1.buildCanonicalSessionEnvelope)({
+        existing: null,
+        previousMessages: [],
+        currentMessages: [],
+        trimmedMessages: [],
+        recordedAt,
+        lastUsage: null,
+        state: null,
+        projectionBasis: { maxTokens: null, contextMargin: null, inputTokens: null },
+    }).envelope;
+}
 function loadSession(filePath) {
     try {
         const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);

package/dist/mind/outbound-record.js

@@ -0,0 +1,165 @@
+"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.OUTBOUND_ORIGIN_LABELS = void 0;
+exports.drainOutboundRecords = drainOutboundRecords;
+exports.recordOutboundInSession = recordOutboundInSession;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../heart/config");
+const runtime_1 = require("../nerves/runtime");
+const context_1 = require("./context");
+const session_transaction_1 = require("./session-transaction");
+/** The folder deferred records for one session wait in; coordinates that would leave or alias it are refused. */
+function deferredDir(agentRoot, friendId, channel, key) {
+    const folder = (0, config_1.sanitizeKey)(key);
+    if (!(0, config_1.isValidSessionCoordinate)(friendId) || !(0, config_1.isValidSessionCoordinate)(channel) || !(0, config_1.isValidSessionCoordinate)(folder)) {
+        throw new Error("invalid outbound record coordinates");
+    }
+    return path.join(agentRoot, "state", "outbound-records", friendId, channel, folder);
+}
+/** A fixed-length file name per delivery, so long or similar ids neither fail nor collide. */
+function deferredFileName(deliveryId) {
+    return `${(0, crypto_1.createHash)("sha256").update(deliveryId).digest("hex").slice(0, 32)}.json`;
+}
+function recordedText(record) {
+    return `[sent by ${record.originLabel}] ${record.content}`;
+}
+function recordError(message, meta) {
+    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "mind", event: "mind.outbound_record_error", message, meta });
+}
+function parseDeferred(raw) {
+    const value = JSON.parse(raw);
+    if (!value || typeof value.content !== "string" || typeof value.origin !== "string" || typeof value.deliveryId !== "string"
+        || typeof value.originLabel !== "string" || typeof value.recordedAt !== "string")
+        return null;
+    return value;
+}
+/** How a recorded message names who sent it: `[sent by <label>]`. */
+exports.OUTBOUND_ORIGIN_LABELS = {
+    shepherd: "Shepherd",
+    send_message: "send_message",
+    voice: "voice",
+    reminder: "a reminder",
+    proactive: "a proactive message",
+};
+/**
+ * Appends every deferred record for this session in `recordedAt` order under the caller's lease, moving each file to
+ * `applied/` beside it. Unreadable files are moved too, with an error event. Returns how many records were appended.
+ * It never throws, so a turn that drains first is never stopped by it.
+ */
+function drainOutboundRecords(agentRoot, friendId, channel, key, lease) {
+    try {
+        return drainUnderLease(agentRoot, friendId, channel, key, lease);
+    }
+    catch (error) {
+        recordError("could not drain deferred outbound records", { friendId, channel, error: error instanceof Error ? error.message : String(error) });
+        return 0;
+    }
+}
+function drainUnderLease(agentRoot, friendId, channel, key, lease) {
+    const dir = deferredDir(agentRoot, friendId, channel, key);
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((name) => name.endsWith(".json"));
+    }
+    catch {
+        return 0;
+    }
+    if (names.length === 0)
+        return 0;
+    const applied = path.join(dir, "applied");
+    fs.mkdirSync(applied, { recursive: true });
+    const entries = names.map((name) => {
+        try {
+            return { name, record: parseDeferred(fs.readFileSync(path.join(dir, name), "utf8")) };
+        }
+        catch {
+            return { name, record: null };
+        }
+    });
+    entries.sort((a, b) => (a.record?.recordedAt ?? "").localeCompare(b.record?.recordedAt ?? ""));
+    let count = 0;
+    for (const { name, record } of entries) {
+        if (!record) {
+            recordError("skipped an unreadable deferred outbound record", { friendId, channel, file: name });
+        }
+        else if ((0, context_1.appendSyntheticAssistantMessage)(lease.sessionPath, recordedText(record), lease, { outbound: { origin: record.origin, deliveryId: record.deliveryId }, createIfMissing: true })) {
+            count += 1;
+        }
+        else {
+            recordError("could not append a deferred outbound record", { friendId, channel, file: name });
+        }
+        fs.renameSync(path.join(dir, name), path.join(applied, name));
+    }
+    return count;
+}
+/** Records a delivered message in the friend's session on that channel. Never throws. */
+function recordOutboundInSession(input) {
+    const { agentRoot, friendId, channel, key, origin, deliveryId } = input;
+    try {
+        const dir = deferredDir(agentRoot, friendId, channel, key);
+        const sessionPath = (0, config_1.resolveSessionPath)(friendId, channel, key, { agentRoot, confined: true });
+        if ((0, session_transaction_1.currentSessionTurnLease)(sessionPath))
+            return "skipped_current_session";
+        try {
+            return (0, session_transaction_1.withImmediateSessionTurnLease)(sessionPath, (lease) => {
+                drainOutboundRecords(agentRoot, friendId, channel, key, lease);
+                const appended = (0, context_1.appendSyntheticAssistantMessage)(sessionPath, recordedText(input), lease, { outbound: { origin, deliveryId }, createIfMissing: true });
+                if (appended)
+                    return "recorded";
+                recordError("could not append an outbound record to its session", { friendId, channel, deliveryId });
+                return "failed";
+            });
+        }
+        catch (error) {
+            if (!(error instanceof session_transaction_1.SessionTurnBusyError))
+                throw error;
+            fs.mkdirSync(dir, { recursive: true });
+            const file = path.join(dir, deferredFileName(deliveryId));
+            const record = { content: input.content, origin, deliveryId, originLabel: input.originLabel, recordedAt: new Date().toISOString() };
+            fs.writeFileSync(`${file}.tmp`, JSON.stringify(record), { mode: 0o600 });
+            fs.renameSync(`${file}.tmp`, file);
+            return "deferred";
+        }
+    }
+    catch (error) {
+        recordError("could not record an outbound message in its session", {
+            friendId, channel, deliveryId, error: error instanceof Error ? error.message : String(error),
+        });
+        return "failed";
+    }
+}

package/dist/repertoire/tools-notes.js

@@ -46,6 +46,7 @@ const diary_1 = require("../mind/diary");
 const record_paths_1 = require("../mind/record-paths");
 const provenance_trust_1 = require("../mind/provenance-trust");
 const relationship_authorization_1 = require("./relationship-authorization");
+const reach_channel_1 = require("../heart/reach-channel");
 const CLAUDE_READ_ONLY_TOOLS = "Read,Grep,Glob,LS";
 function bundleRelativeLocator(filePath, ctx) {
     const agentRoot = ctx?.agentRoot ?? (0, identity_1.getAgentRoot)();
@@ -396,13 +397,13 @@ exports.notesToolDefinitions = [
             type: "function",
             function: {
                 name: "save_friend_note",
-                description: "save something i learned about my friend. use type 'name' to update their display name, 'tool_preference' for presentation preferences, or 'note' for general context. For Sanctuary relationships, preference source is stated (the person said or confirmed it), observed (a revisable pattern i inferred), or default (a fallback until better evidence), and only communication or timing are accepted. Other agents retain their existing integration-preference behavior and do not persist this provenance field. desired state and action authority belong in steward policy. notes and preferences improve orientation but never grant authority. set override=true when replacing an existing value.",
+                description: "save something i learned about my friend. use type 'name' to update their display name, 'tool_preference' for presentation preferences, or 'note' for general context. For Sanctuary relationships, preference source is stated (the person said or confirmed it), observed (a revisable pattern i inferred), or default (a fallback until better evidence), and only communication or timing are accepted. Any friend may save key reachChannel (with source) to say which channel to reach them on outside a conversation: bluebubbles or teams; iMessage means bluebubbles. Other agents retain their existing integration-preference behavior and do not persist this provenance field. desired state and action authority belong in steward policy. notes and preferences improve orientation but never grant authority. set override=true when replacing an existing value.",
                 parameters: {
                     type: "object",
                     properties: {
                         type: { type: "string", enum: ["name", "tool_preference", "note"], description: "what kind of information to save" },
-                        key: { type: "string", description: "category key (required for tool_preference and note; Sanctuary relationship preferences use communication or timing)" },
-                        source: { type: "string", enum: ["stated", "observed", "default"], description: "preference provenance; required for Sanctuary relationship preferences" },
+                        key: { type: "string", description: "category key (required for tool_preference and note; Sanctuary relationship preferences use communication or timing; reachChannel names the channel to reach this person on: bluebubbles or teams)" },
+                        source: { type: "string", enum: ["stated", "observed", "default"], description: "preference provenance; required for Sanctuary relationship preferences and for reachChannel" },
                         content: { type: "string", description: "the value to save" },
                         override: { type: "string", enum: ["true", "false"], description: "set to 'true' to overwrite an existing value" },
                     },
@@ -431,13 +432,17 @@ exports.notesToolDefinitions = [
             const actor = ctx.relationshipAuthorization?.actor;
             const isSanctuaryRelationship = ctx.context.friend?.capabilityProfileId?.startsWith("sanctuary-") === true;
             const preferenceSource = a.source;
-            if (isSanctuaryRelationship && a.type === "tool_preference" && !["stated", "observed", "default"].includes(String(preferenceSource))) {
+            const isReachChannel = a.type === "tool_preference" && a.key === "reachChannel";
+            if ((isSanctuaryRelationship || isReachChannel) && a.type === "tool_preference" && !["stated", "observed", "default"].includes(String(preferenceSource))) {
                 return "i need exact preference provenance: source must be stated, observed, or default";
             }
-            if (isSanctuaryRelationship && a.type === "tool_preference" && !["communication", "timing"].includes(a.key ?? "")) {
+            if (isReachChannel && !reach_channel_1.REACH_CHANNELS.includes(a.content ?? "")) {
+                return "i can only reach people on bluebubbles or teams";
+            }
+            if (isSanctuaryRelationship && a.type === "tool_preference" && !isReachChannel && !["communication", "timing"].includes(a.key ?? "")) {
                 return "Sanctuary relationship preferences are limited to communication or timing; desired state and action authority belong in steward policy";
             }
-            if (actor?.trustLevel === "friend" && (actor.friendId !== friendId || a.type !== "tool_preference" || !["communication", "timing"].includes(a.key ?? ""))) {
+            if (actor?.trustLevel === "friend" && (actor.friendId !== friendId || a.type !== "tool_preference" || !["communication", "timing", "reachChannel"].includes(a.key ?? ""))) {
                 return "household members may only save their own communication or timing preferences; preferences never grant authority";
             }
             // Validate parameters (input-shape guards stay harness-side so we keep the
@@ -451,7 +456,7 @@ exports.notesToolDefinitions = [
                 return "i need a key for tool_preference or note type";
             // Record-domain logic lives in @ouro.bot/friends; this wrapper maps the
             // structured FriendOpResult back to the tool's first-person strings.
-            if (isSanctuaryRelationship && a.type === "tool_preference" && preferenceSource) {
+            if ((isSanctuaryRelationship || isReachChannel) && a.type === "tool_preference" && preferenceSource) {
                 const current = await ctx.friendStore.get(friendId);
                 if (!current)
                     return "i can't find the friend record on disk";

package/dist/repertoire/tools-session.js

@@ -1006,6 +1006,7 @@ exports.sessionToolDefinitions = [
                             text: request.content,
                             intent: request.intent,
                             authorizingSession: request.authorizingSession,
+                            origin: "send_message",
                         });
                         if (result.delivered) {
                             return {
@@ -1031,6 +1032,12 @@ exports.sessionToolDefinitions = [
                                 detail: "bluebubbles send failed",
                             };
                         }
+                        if (result.reason === "host_account_refused") {
+                            return {
+                                status: "failed",
+                                detail: "the BlueBubbles server is not signed in to this agent's account, so nothing was sent",
+                            };
+                        }
                         return {
                             status: "unavailable",
                             detail: "live delivery unavailable right now; queued for the next active turn",
@@ -1050,6 +1057,7 @@ exports.sessionToolDefinitions = [
                             text: request.content,
                             intent: request.intent,
                             authorizingSession: request.authorizingSession,
+                            origin: "send_message",
                         }, {
                             botApi: ctx.botApi,
                         });

package/dist/senses/bluebubbles/client.js

@@ -327,7 +327,11 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
             await assertHostAccount({ fresh: true });
             const resolvedChatGuid = await resolveChatGuid(params.chat, config, channelConfig);
             if (!resolvedChatGuid) {
-                throw new Error("BlueBubbles send currently requires chat.chatGuid from the inbound event.");
+                // Nothing reached the server, so a caller may safely send again once the chat exists.
+                throw new BlueBubblesSendError({
+                    message: "BlueBubbles send currently requires chat.chatGuid from the inbound event.",
+                    httpStatus: null, errorCode: "chat_unresolved", transportInvoked: false,
+                });
             }
             const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/message/text", config.password);
             const body = {
@@ -423,7 +427,7 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                     messageGuid: messageGuid ?? null,
                 },
             });
-            return { messageGuid };
+            return { messageGuid, chatGuid: resolvedChatGuid };
         },
         async editMessage(params) {
             await assertHostAccount();

package/dist/senses/bluebubbles/index.js

@@ -73,6 +73,8 @@ const prompt_1 = require("../../mind/prompt");
 const mcp_manager_1 = require("../../repertoire/mcp-manager");
 const runtime_1 = require("../../nerves/runtime");
 const session_transaction_1 = require("../../mind/session-transaction");
+const outbound_record_1 = require("../../mind/outbound-record");
+const await_alert_1 = require("../../heart/awaiting/await-alert");
 const orientation_frame_1 = require("../../heart/orientation-frame");
 const proactive_content_guard_1 = require("../proactive-content-guard");
 const bluebubbles_meta_guard_1 = require("../bluebubbles-meta-guard");
@@ -1527,6 +1529,8 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
             const friendId = context.friend.id;
             const sessPath = resolvedDeps.sessionPath(friendId, "bluebubbles", event.chat.sessionKey);
             return await resolvedDeps.withSessionTurnLease(sessPath, async (sessionTurnLease) => {
+                // Messages sent into this chat while another turn held it wait outside the session; they go in first.
+                (0, outbound_record_1.drainOutboundRecords)((0, identity_1.getAgentRoot)(), friendId, "bluebubbles", event.chat.sessionKey, sessionTurnLease);
                 try {
                     (0, session_cleanup_1.findObsoleteBlueBubblesThreadSessions)(sessPath);
                 }
@@ -3409,6 +3413,43 @@ function buildChatRefForSessionKey(friend, sessionKey) {
         participantHandles: [],
     };
 }
+/**
+ * The session a proactive send is saved into: the chat key it was sent on, else the friend's existing DM session, else
+ * the DM key an inbound message from their handle would use (`chat:any;-;<handle>`), so their reply loads it.
+ */
+function proactiveRecordKey(friend, sessionKey, chat, sentChatGuid) {
+    if (normalizeBlueBubblesSessionKey(sessionKey).startsWith("chat:"))
+        return sessionKey;
+    // The DM the server actually sent into is where the friend's reply will be keyed.
+    if (sentChatGuid?.includes(";-;"))
+        return `chat:${sentChatGuid}`;
+    const existing = (0, await_alert_1.resolveAlertKey)((0, identity_1.getAgentRoot)(), friend.id, "bluebubbles");
+    if (existing?.includes(";-;"))
+        return existing;
+    /* v8 ignore start -- a non-chat key is routed by the friend's handle, so a delivered send always had one @preserve */
+    const handle = findImessageHandle(friend) ?? chat.chatIdentifier;
+    return handle ? `chat:any;-;${handle}` : null;
+    /* v8 ignore stop */
+}
+/** Saves a delivered message into its chat. Never throws: recording never changes the result of a send that went out. */
+function recordBlueBubblesProactiveSend(friend, params, chat, sentChatGuid) {
+    try {
+        const key = proactiveRecordKey(friend, params.sessionKey, chat, sentChatGuid);
+        /* v8 ignore next -- a delivered send always had a chat GUID or identifier to send to @preserve */
+        if (!key)
+            return;
+        const origin = params.origin ?? "proactive";
+        (0, outbound_record_1.recordOutboundInSession)({
+            agentRoot: (0, identity_1.getAgentRoot)(), friendId: friend.id, channel: "bluebubbles", key, content: params.text, origin,
+            deliveryId: params.deliveryId ?? `proactive:${(0, node_crypto_1.randomUUID)()}`, originLabel: outbound_record_1.OUTBOUND_ORIGIN_LABELS[origin],
+        });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.bluebubbles_proactive_record_error",
+            message: "the BlueBubbles message was sent, but could not be saved into its chat",
+            meta: { friendId: friend.id, error: error instanceof Error ? error.message : String(error) } });
+    }
+}
 async function sendProactiveBlueBubblesMessageToSession(params, deps = {}) {
     if ((0, bluebubbles_meta_guard_1.containsInternalMetaMarkers)(params.text)) {
         (0, bluebubbles_meta_guard_1.emitBluebubblesMetaBlocked)({
@@ -3528,7 +3569,7 @@ async function sendProactiveBlueBubblesMessageToSession(params, deps = {}) {
         return { delivered: false, reason: "internal_content_blocked" };
     }
     try {
-        await client.sendText({ chat, text: params.text });
+        const sent = await client.sendText({ chat, text: params.text });
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.bluebubbles_proactive_sent",
@@ -3540,9 +3581,30 @@ async function sendProactiveBlueBubblesMessageToSession(params, deps = {}) {
                 chatIdentifier: chat.chatIdentifier ?? null,
             },
         });
+        recordBlueBubblesProactiveSend(friend, params, chat, sent?.chatGuid);
         return { delivered: true };
     }
     catch (error) {
+        if (error instanceof client_1.BlueBubblesSendError && error.errorCode === "chat_unresolved") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_no_chat",
+                message: "no BlueBubbles chat matched this friend, so nothing was sent",
+                meta: { friendId: params.friendId, sessionKey: params.sessionKey },
+            });
+            return { delivered: false, reason: "missing_target" };
+        }
+        if (error instanceof host_account_verifier_1.BlueBubblesHostAccountError) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_host_account_refused",
+                message: "proactive bluebubbles send refused: the server is signed in to another account",
+                meta: { friendId: params.friendId, sessionKey: params.sessionKey, reason: error.message },
+            });
+            return { delivered: false, reason: "host_account_refused" };
+        }
         (0, runtime_1.emitNervesEvent)({
             level: "error",
             component: "senses",

package/dist/senses/shepherd/feedback-worker.js

@@ -82,7 +82,7 @@ function feedbackReviewOptions(record, signal) {
 function startFeedbackWorker(options) {
     const file = (0, feedback_store_1.feedbackStorePath)(options.agentRoot);
     const friendStore = options.friendStore ?? new friends_1.FileFriendStore(path.join(options.agentRoot, "friends"));
-    const send = options.send ?? (0, owner_notice_1.createTeamsNoticeSender)(options.agentRoot);
+    const send = options.send ?? (0, owner_notice_1.createNoticeSender)(options.agentRoot);
     const run = options.run ?? (async (input) => (await Promise.resolve().then(() => __importStar(require("../shared-turn")))).runSenseTurn(input));
     const owner = (0, node_crypto_1.randomUUID)();
     const controller = new AbortController();
@@ -137,8 +137,9 @@ function startFeedbackWorker(options) {
             const name = (0, agent_presentation_1.readAgentPresentation)(options.agent, options.agentRoot).name;
             const text = `${name} — session feedback\n${record.source.label}\n${record.id}\n\n${record.review.response}`;
             attempted = true;
-            const result = await send({ friendId: recipient.friendId, name: record.actorId, key: record.id,
-                ...(recipient.tenantId ? { tenantId: recipient.tenantId } : {}) }, text);
+            // Feedback answers the Teams chat it came from, so it stays on Teams.
+            const result = await send({ friendId: recipient.friendId, name: record.actorId, channel: "teams", key: record.id,
+                ...(recipient.tenantId ? { tenantId: recipient.tenantId } : {}) }, text, [record.id]);
             if (result.delivered && result.delivery?.state === "accepted" && result.delivery.conversationId && result.delivery.messageId) {
                 store.completeDelivery(record.id, record.actorId, owner, { state: "sent",
                     conversationId: result.delivery.conversationId, messageId: result.delivery.messageId });

package/dist/senses/shepherd/owner-notice.js

@@ -38,14 +38,19 @@ exports.noticeWanted = noticeWanted;
 exports.plain = plain;
 exports.noticeLine = noticeLine;
 exports.noticeMessage = noticeMessage;
+exports.readEnabledReachChannels = readEnabledReachChannels;
 exports.resolveNoticeTargets = resolveNoticeTargets;
+exports.noticeDeliveryId = noticeDeliveryId;
 exports.chooseTeamsBot = chooseTeamsBot;
-exports.createTeamsNoticeSender = createTeamsNoticeSender;
+exports.createNoticeSender = createNoticeSender;
 exports.createOwnerNotifier = createOwnerNotifier;
+const node_crypto_1 = require("node:crypto");
 const path = __importStar(require("node:path"));
 const friends_1 = require("@ouro.bot/friends");
 const await_alert_1 = require("../../heart/awaiting/await-alert");
 const config_1 = require("../../heart/config");
+const identity_1 = require("../../heart/identity");
+const reach_channel_1 = require("../../heart/reach-channel");
 const runtime_1 = require("../../nerves/runtime");
 const notice_outbox_1 = require("./notice-outbox");
 /**
@@ -157,29 +162,89 @@ function noticeMessage(records, refs = new Map(), context = {}) {
         : [`Updates from ${sessions.length} coding sessions:`, ...lines.map(line => `- ${line}`), ...(more > 0 ? [`- and ${more} more.`] : [])].join("\n");
     return context.recovered ? `Includes recovered historical observations, not live status:\n${body}` : body;
 }
-function teamsAadId(friend) {
-    const ext = friend.externalIds.find((entry) => entry.provider === "aad" && !entry.externalId.startsWith("group:"));
-    return ext ? { id: ext.externalId.toLowerCase(), tenantId: ext.tenantId } : null;
+/**
+ * The channels this agent can reach people on from this machine: its enabled Teams sense, and its enabled BlueBubbles
+ * sense when this machine has a BlueBubbles connection (credentials live per machine, so another machine may own it).
+ */
+function readEnabledReachChannels(agent, agentRoot, blueBubblesConfig = config_1.getBlueBubblesConfig) {
+    const enabled = new Set();
+    try {
+        const senses = (0, identity_1.loadAgentConfig)({ agentName: agent, agentRoot }).senses;
+        if (senses?.bluebubbles?.enabled) {
+            try {
+                blueBubblesConfig();
+                enabled.add("bluebubbles");
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_notice_bluebubbles_not_attached", message: "BlueBubbles is enabled but not connected on this machine, so owner notices use another channel", meta: { agent, error: error.message } });
+            }
+        }
+        if (senses?.teams?.enabled)
+            enabled.add("teams");
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_notice_channels_unreadable", message: "could not read which channels are enabled, so no owner notice channel is reachable", meta: { agent, error: error.message } });
+    }
+    return enabled;
+}
+/** Every channel id a friend record holds, in the same `channel:handle` form `resolveReachTarget` returns. */
+function personIdentities(friend) {
+    const identities = new Set();
+    // Only called for a reachable friend, whose externalIds is therefore a list.
+    for (const entry of friend.externalIds) {
+        // A `group:` id names a group chat the friend is in, which other people share; it never identifies the person.
+        if (typeof entry?.externalId !== "string" || entry.externalId.trim() === "" || entry.externalId.startsWith("group:"))
+            continue;
+        if (entry.provider === "imessage-handle")
+            identities.add(`bluebubbles:${entry.externalId.toLowerCase()}`);
+        if (entry.provider === "aad")
+            identities.add(`teams:${entry.externalId.toLowerCase()}`);
+    }
+    return identities;
 }
 /**
- * Who hears the notice: every family friend reachable on Teams (a Teams user id the bot can open a chat with), once per
- * Teams user even when several friend records share one. Teams is the only proactive channel wired today.
+ * Who hears the notice, and where: the family friend who is this machine's own user (`local` id), else every family
+ * friend, on the channel `resolveReachTarget` chooses for them, once per
+ * person on that channel even when several friend records share one id. With no 1:1 session yet, the send opens one:
+ * BlueBubbles by the friend's handle, Teams by a new 1:1 conversation.
  */
-async function resolveNoticeTargets(agentRoot, store = new friends_1.FileFriendStore(path.join(agentRoot, "friends"))) {
+async function resolveNoticeTargets(agentRoot, store = new friends_1.FileFriendStore(path.join(agentRoot, "friends")), enabledChannels = new Set(), username = (0, friends_1.machineOwnerUsername)()) {
     const seen = new Set();
     const targets = [];
-    for (const friend of await store.listAll()) {
-        if (friend.trustLevel !== "family")
+    const family = (await store.listAll()).filter(friend => friend.trustLevel === "family");
+    // The notice is the owner's: when family friends are linked to this machine's own user, only they hear it, never
+    // their relatives, even when none of them is reachable yet.
+    const owners = family.filter(friend => (Array.isArray(friend.externalIds) ? friend.externalIds : [])
+        .some(entry => typeof entry?.provider === "string" && typeof entry.externalId === "string" && (0, friends_1.isLocalMachineOwnerIdentity)(entry.provider, entry.externalId, username)));
+    for (const friend of owners.length > 0 ? owners : family) {
+        const reach = (0, reach_channel_1.resolveReachTarget)({
+            friend, enabledChannels, sessionsDir: path.join(agentRoot, "state", "sessions"), friendsDir: path.join(agentRoot, "friends"),
+            agentName: path.basename(agentRoot, ".ouro"),
+        });
+        if ("unreachable" in reach)
             continue;
-        const aad = teamsAadId(friend);
-        if (!aad || seen.has(aad.id))
+        // One notice per person: a friend whose iMessage handle or Teams id another target already has is that person.
+        const identities = personIdentities(friend);
+        identities.add(`${reach.channel}:${reach.handle}`);
+        if ([...identities].some(identity => seen.has(identity)))
             continue;
-        seen.add(aad.id);
-        targets.push({ friendId: friend.id, name: friend.name, key: (0, await_alert_1.resolveAlertKey)(agentRoot, friend.id, "teams") ?? "shepherd", ...(aad.tenantId ? { tenantId: aad.tenantId } : {}) });
+        for (const identity of identities)
+            seen.add(identity);
+        const alertKey = (0, await_alert_1.resolveAlertKey)(agentRoot, friend.id, reach.channel);
+        // A BlueBubbles fallback key must be a DM: a group key would be refused, and "shepherd" sends to the handle.
+        const fallback = reach.channel === "bluebubbles" ? (alertKey?.includes(";-;") ? alertKey : null) : alertKey;
+        targets.push({ friendId: friend.id, name: friend.name, channel: reach.channel, key: reach.key ?? fallback ?? "shepherd", ...(reach.tenantId ? { tenantId: reach.tenantId } : {}) });
+    }
+    if (owners.length > 0 && targets.length === 0) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_notice_owner_unreachable", message: "this machine's owner has no reachable channel, so the Shepherd owner notice waits; link their iMessage handle or Teams id", meta: { owners: owners.length } });
     }
     (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.shepherd_notice_targets", message: "resolved Shepherd owner notice targets", meta: { count: targets.length } });
     return targets;
 }
+/** One id per batch and person, so a retried batch is saved into the conversation once. */
+function noticeDeliveryId(friendId, noticeIds) {
+    return `shepherd:${(0, node_crypto_1.createHash)("sha256").update(`${friendId}\0${[...noticeIds].sort().join(",")}`).digest("hex")}`;
+}
 /** The bot whose tenant is the friend's: the secondary bot when it serves that tenant, else the primary. */
 function chooseTeamsBot(tenantId, primary, secondary) {
     if (tenantId && secondary.clientId && secondary.tenantId === tenantId)
@@ -199,13 +264,33 @@ async function liveBotApi(config) {
 }
 /* v8 ignore stop */
 /**
- * Sends through the Teams sense's own proactive path (`sendProactiveTeamsMessageToSession`: trust check, internal-content
- * guard, 1:1 chat with the friend's Teams id) with a bot client of this process's own, built from the agent's Teams
- * credentials. Nothing listens on a port: the client only acquires a bot token and calls the Bot Framework.
+ * Sends on the target's channel through that sense's own proactive path, which applies its trust check, internal-content
+ * guard and 1:1 rule, and saves the notice into the friend's conversation.
+ *
+ * - Teams: `sendProactiveTeamsMessageToSession` with a bot client of this process's own, built from the agent's Teams
+ *   credentials. Nothing listens on a port: the client only acquires a bot token and calls the Bot Framework.
+ * - BlueBubbles: `sendProactiveBlueBubblesMessageToSession` over the BlueBubbles REST API, which checks the server's
+ *   account before sending. When the client cannot be set up (no credentials, say), the notice stays pending.
  */
-function createTeamsNoticeSender(agentRoot, deps = {}) {
+function createNoticeSender(agentRoot, deps = {}) {
     const bots = new Map();
-    return async (target, text) => {
+    return async (target, text, noticeIds) => {
+        const deliveryId = noticeDeliveryId(target.friendId, noticeIds);
+        if (target.channel === "bluebubbles") {
+            let client;
+            let send;
+            try {
+                /* v8 ignore next 2 -- tests inject the client and sender; the live ones need BlueBubbles credentials @preserve */
+                client = deps.createBlueBubblesClient ? deps.createBlueBubblesClient() : (await Promise.resolve().then(() => __importStar(require("../bluebubbles/client")))).createBlueBubblesClient();
+                send = deps.sendBlueBubbles ?? (await Promise.resolve().then(() => __importStar(require("../bluebubbles")))).sendProactiveBlueBubblesMessageToSession;
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_notice_bluebubbles_unavailable", message: "BlueBubbles could not be set up for the Shepherd owner notice; it stays waiting", meta: { friendId: target.friendId, error: error.message } });
+                return { delivered: false, reason: "bluebubbles_unavailable" };
+            }
+            const store = new friends_1.FileFriendStore(path.join(agentRoot, "friends"));
+            return send({ friendId: target.friendId, sessionKey: target.key, text, intent: "generic_outreach", deliveryId, origin: "shepherd" }, { createClient: () => client, createFriendStore: () => store });
+        }
         const config = chooseTeamsBot(target.tenantId, (deps.primary ?? config_1.getTeamsConfig)(), (deps.secondary ?? config_1.getTeamsSecondaryConfig)());
         if (!config)
             return { delivered: false, reason: "no_teams_bot" };
@@ -218,14 +303,15 @@ function createTeamsNoticeSender(agentRoot, deps = {}) {
             bot.catch(() => bots.delete(config.clientId));
         }
         const { sendProactiveTeamsMessageToSession } = await Promise.resolve().then(() => __importStar(require("../teams")));
-        return sendProactiveTeamsMessageToSession({ friendId: target.friendId, sessionKey: target.key, text, textFormat: "plain", intent: "generic_outreach", captureReceipt: true }, { botApi: await bot, store: new friends_1.FileFriendStore(path.join(agentRoot, "friends")) });
+        return sendProactiveTeamsMessageToSession({ friendId: target.friendId, sessionKey: target.key, text, textFormat: "plain", intent: "generic_outreach", captureReceipt: true, deliveryId, origin: "shepherd" }, { botApi: await bot, store: new friends_1.FileFriendStore(path.join(agentRoot, "friends")) });
     };
 }
 /** Collects durable notice intents; acceptance is distinct from transport delivery. */
 function createOwnerNotifier(options) {
     const { agent, policy } = options;
-    const resolveTargets = options.resolveTargets ?? (() => resolveNoticeTargets(options.agentRoot));
-    const send = options.send ?? createTeamsNoticeSender(options.agentRoot);
+    const enabledChannels = options.enabledChannels ?? (() => readEnabledReachChannels(agent, options.agentRoot));
+    const resolveTargets = options.resolveTargets ?? (() => resolveNoticeTargets(options.agentRoot, undefined, enabledChannels()));
+    const send = options.send ?? createNoticeSender(options.agentRoot);
     const retryWrites = new Map();
     const recoveredNoticeIds = new Set();
     const writes = new Set();
@@ -285,7 +371,7 @@ function createOwnerNotifier(options) {
             if (stopped)
                 return;
             if (targets.length === 0) {
-                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_notice_no_target", message: "no family friend is reachable on Teams, so the Shepherd owner notice was not sent", meta: { agent, returns: entries.length } });
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.shepherd_notice_no_target", message: "no family friend is reachable on any enabled channel, so the Shepherd owner notice was not sent", meta: { agent, returns: entries.length } });
                 schedule(exports.NOTICE_RETRY_MS);
                 return;
             }
@@ -307,7 +393,7 @@ function createOwnerNotifier(options) {
                         break;
                     }
                     try {
-                        const result = await send(target, noticeMessage(batch.map(entry => entry.record), refs, { recovered: ids.some(id => recoveredNoticeIds.has(id)) }));
+                        const result = await send(target, noticeMessage(batch.map(entry => entry.record), refs, { recovered: ids.some(id => recoveredNoticeIds.has(id)) }), ids);
                         const state = result.delivered ? "sent"
                             : result.delivery ? result.delivery.state === "not_sent" ? "pending" : "unknown"
                                 : result.reason && result.reason !== "send_error" ? "pending" : "unknown";

package/dist/senses/teams.js

@@ -73,6 +73,7 @@ const commands_2 = require("./commands");
 const http = __importStar(require("http"));
 const path = __importStar(require("path"));
 const node_crypto_1 = require("node:crypto");
+const outbound_record_1 = require("../mind/outbound-record");
 const trust_gate_1 = require("./trust-gate");
 const pipeline_1 = require("./pipeline");
 const session_transaction_1 = require("../mind/session-transaction");
@@ -818,6 +819,8 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
     try {
         await runWithLease(sessPath, async (sessionTurnLease) => {
             reportTeamsRequest("running", conversationId, teamsContext, { traceId, friendId });
+            // Messages sent into this conversation while another turn held it wait outside the session; they go in first.
+            (0, outbound_record_1.drainOutboundRecords)(owner.agentRoot, friendId, "teams", conversationId, sessionTurnLease);
             // Proactive feedback acknowledgements are not magically in this model session's
             // history. Recover their frozen packet only after identity and lease ownership.
             let feedbackReply;
@@ -1511,6 +1514,20 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
             meta: { friendId: params.friendId, aadObjectId: aadInfo.aadObjectId, sessionKey: params.sessionKey },
         });
         const messageId = activity && typeof activity === "object" && "id" in activity && typeof activity.id === "string" ? activity.id : undefined;
+        // Saved into the conversation it was sent into, so the friend's reply there carries it.
+        const origin = params.origin ?? "proactive";
+        // Recording never changes the result of a send that already went out.
+        try {
+            (0, outbound_record_1.recordOutboundInSession)({
+                agentRoot: (0, identity_1.getAgentRoot)(), friendId: friend.id, channel: "teams", key: conversation.id, content: params.text, origin,
+                deliveryId: params.deliveryId ?? `proactive:${(0, node_crypto_1.randomUUID)()}`, originLabel: outbound_record_1.OUTBOUND_ORIGIN_LABELS[origin],
+            });
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.teams_proactive_record_error",
+                message: "the Teams message was sent, but could not be saved into its conversation",
+                meta: { friendId: friend.id, error: error instanceof Error ? error.message : String(error) } });
+        }
         return {
             delivered: true,
             ...(params.captureReceipt ? { delivery: { state: "accepted", conversationId, ...(messageId ? { messageId } : {}) } } : {}),

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

@@ -55,6 +55,7 @@ function defaultOwnerNoticeDeliverers(agentName) {
                 text: request.content,
                 intent: request.intent,
                 authorizingSession: request.authorizingSession,
+                origin: "voice",
             });
             if (result.delivered)
                 return { status: "delivered_now", detail: "sent to the bluebubbles chat now" };
@@ -64,6 +65,8 @@ function defaultOwnerNoticeDeliverers(agentName) {
                 return { status: "blocked", detail: "blocked: contains internal meta markers" };
             if (result.reason === "send_error")
                 return { status: "failed", detail: "bluebubbles send failed" };
+            if (result.reason === "host_account_refused")
+                return { status: "failed", detail: "the BlueBubbles server is not signed in to this agent's account, so nothing was sent" };
             return { status: "unavailable", detail: "live delivery unavailable right now; queued for the next active turn" };
         },
         telegram: async (request) => {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.945",
+  "version": "0.1.0-alpha.946",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.945",
+      "version": "0.1.0-alpha.946",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.945",
+  "version": "0.1.0-alpha.946",
   "engines": {
     "node": ">=22"
   },