@ouro.bot/cli 0.1.0-alpha.31 → 0.1.0-alpha.32

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.32",
+      "changes": [
+        "BlueBubbles now treats thread-vs-top-level placement as an agent choice instead of a hard harness mirror. Slugger can deliberately stay in the current reply lane, widen back to top-level, or target another active thread when that makes the conversation flow better.",
+        "BlueBubbles turns now surface inbound lane metadata and recent active lanes from the shared chat trunk, so the model gets enough context to choose the right reply placement without splitting the conversation into separate persisted thread sessions."
+      ]
+    },
     {
       "version": "0.1.0-alpha.31",
       "changes": [

package/dist/mind/prompt.js

@@ -221,6 +221,7 @@ function runtimeInfoSection(channel) {
     }
     else if (channel === "bluebubbles") {
         lines.push("i am responding in iMessage through BlueBubbles. i keep replies short and phone-native. i do not use markdown. i do not introduce myself on boot.");
+        lines.push("when a bluebubbles turn arrives from a thread, the harness tells me the current lane and any recent active thread ids. if widening back to top-level or routing into a different active thread is the better move, i use bluebubbles_set_reply_target before final_answer.");
     }
     else {
         lines.push("i am responding in Microsoft Teams. i keep responses concise. i use markdown formatting. i do not introduce myself on boot.");

package/dist/repertoire/tools-bluebubbles.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bluebubblesToolDefinitions = void 0;
+const runtime_1 = require("../nerves/runtime");
+exports.bluebubblesToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "bluebubbles_set_reply_target",
+                description: "choose where the current iMessage turn should land. use this when you want to widen back to top-level or route your update into a specific active thread in the same chat.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        target: {
+                            type: "string",
+                            enum: ["current_lane", "top_level", "thread"],
+                            description: "current_lane mirrors the current inbound lane, top_level answers in the main chat, and thread targets a specific active thread.",
+                        },
+                        threadOriginatorGuid: {
+                            type: "string",
+                            description: "required when target=thread; use one of the thread ids surfaced in the inbound iMessage context.",
+                        },
+                    },
+                    required: ["target"],
+                },
+            },
+        },
+        handler: (args, ctx) => {
+            const target = typeof args.target === "string" ? args.target.trim() : "";
+            const controller = ctx?.bluebubblesReplyTarget;
+            if (!controller) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "tools",
+                    event: "tool.error",
+                    message: "bluebubbles reply target missing controller",
+                    meta: { target },
+                });
+                return "bluebubbles reply targeting is not available in this context.";
+            }
+            if (target === "current_lane") {
+                const result = controller.setSelection({ target: "current_lane" });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.end",
+                    message: "bluebubbles reply target updated",
+                    meta: { target: "current_lane", success: true },
+                });
+                return result;
+            }
+            if (target === "top_level") {
+                const result = controller.setSelection({ target: "top_level" });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.end",
+                    message: "bluebubbles reply target updated",
+                    meta: { target: "top_level", success: true },
+                });
+                return result;
+            }
+            if (target === "thread") {
+                const threadOriginatorGuid = typeof args.threadOriginatorGuid === "string" ? args.threadOriginatorGuid.trim() : "";
+                if (!threadOriginatorGuid) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "tools",
+                        event: "tool.error",
+                        message: "bluebubbles reply target missing thread id",
+                        meta: { target: "thread" },
+                    });
+                    return "threadOriginatorGuid is required when target=thread.";
+                }
+                const result = controller.setSelection({ target: "thread", threadOriginatorGuid });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.end",
+                    message: "bluebubbles reply target updated",
+                    meta: { target: "thread", success: true },
+                });
+                return result;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "tools",
+                event: "tool.error",
+                message: "bluebubbles reply target invalid target",
+                meta: { target },
+            });
+            return "target must be one of: current_lane, top_level, thread.";
+        },
+    },
+];

package/dist/repertoire/tools.js

@@ -7,6 +7,7 @@ exports.execTool = execTool;
 exports.summarizeArgs = summarizeArgs;
 const tools_base_1 = require("./tools-base");
 const tools_teams_1 = require("./tools-teams");
+const tools_bluebubbles_1 = require("./tools-bluebubbles");
 const ado_semantic_1 = require("./ado-semantic");
 const tools_github_1 = require("./tools-github");
 const runtime_1 = require("../nerves/runtime");
@@ -17,7 +18,13 @@ Object.defineProperty(exports, "finalAnswerTool", { enumerable: true, get: funct
 var tools_teams_2 = require("./tools-teams");
 Object.defineProperty(exports, "teamsTools", { enumerable: true, get: function () { return tools_teams_2.teamsTools; } });
 // All tool definitions in a single registry
-const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
+const allDefinitions = [
+    ...tools_base_1.baseToolDefinitions,
+    ...tools_bluebubbles_1.bluebubblesToolDefinitions,
+    ...tools_teams_1.teamsToolDefinitions,
+    ...ado_semantic_1.adoSemanticToolDefinitions,
+    ...tools_github_1.githubToolDefinitions,
+];
 const REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "git_commit", "gh_cli"]);
 function isRemoteChannel(capabilities) {
     return capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
@@ -61,15 +68,18 @@ function applyPreference(tool, pref) {
 // When toolPreferences is provided, matching preferences are appended to tool descriptions.
 function getToolsForChannel(capabilities, toolPreferences, context) {
     const baseTools = baseToolsForCapabilities(capabilities, context);
+    const bluebubblesTools = capabilities?.channel === "bluebubbles"
+        ? tools_bluebubbles_1.bluebubblesToolDefinitions.map((d) => d.tool)
+        : [];
     if (!capabilities || capabilities.availableIntegrations.length === 0) {
-        return baseTools;
+        return [...baseTools, ...bluebubblesTools];
     }
     const available = new Set(capabilities.availableIntegrations);
     const channelDefs = [...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
     // Include tools whose integration is available, plus channel tools with no integration gate (e.g. teams_send_message)
     const integrationDefs = channelDefs.filter((d) => d.integration ? available.has(d.integration) : capabilities.channel === "teams");
     if (!toolPreferences || Object.keys(toolPreferences).length === 0) {
-        return [...baseTools, ...integrationDefs.map((d) => d.tool)];
+        return [...baseTools, ...bluebubblesTools, ...integrationDefs.map((d) => d.tool)];
     }
     // Build a map of integration -> preference text for fast lookup
     const prefMap = new Map();
@@ -82,7 +92,7 @@ function getToolsForChannel(capabilities, toolPreferences, context) {
         const pref = prefMap.get(d.integration);
         return pref ? applyPreference(d.tool, pref) : d.tool;
     });
-    return [...baseTools, ...enrichedIntegrationTools];
+    return [...baseTools, ...bluebubblesTools, ...enrichedIntegrationTools];
 }
 // Check whether a tool requires user confirmation before execution.
 // Reads from ToolDefinition.confirmationRequired instead of a separate Set.
@@ -205,6 +215,8 @@ function summarizeArgs(name, args) {
         return summarizeKeyValues(args, ["sessionId", "input"]);
     if (name === "coding_kill")
         return summarizeKeyValues(args, ["sessionId"]);
+    if (name === "bluebubbles_set_reply_target")
+        return summarizeKeyValues(args, ["target", "threadOriginatorGuid"]);
     if (name === "claude")
         return summarizeKeyValues(args, ["prompt"]);
     if (name === "web_search")

package/dist/senses/bluebubbles.js

@@ -84,8 +84,82 @@ function resolveFriendParams(event) {
         channel: "bluebubbles",
     };
 }
-function buildInboundText(event) {
-    const metadataPrefix = buildConversationScopePrefix(event);
+function extractMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (part && typeof part === "object" && "type" in part && part.type === "text" && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function extractHistoricalLaneSummary(messages) {
+    const seen = new Set();
+    const summaries = [];
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== "user")
+            continue;
+        const text = extractMessageText(message.content);
+        if (!text)
+            continue;
+        const firstLine = text.split("\n")[0].trim();
+        const threadMatch = firstLine.match(/thread id: ([^\]|]+)/i);
+        const laneKey = threadMatch
+            ? `thread:${threadMatch[1].trim()}`
+            : /top[-_]level/i.test(firstLine)
+                ? "top_level"
+                : null;
+        if (!laneKey || seen.has(laneKey))
+            continue;
+        seen.add(laneKey);
+        const snippet = text
+            .split("\n")
+            .slice(1)
+            .map((line) => line.trim())
+            .find(Boolean)
+            ?.slice(0, 80) ?? "(no recent text)";
+        summaries.push({
+            key: laneKey,
+            label: laneKey === "top_level" ? "top_level" : laneKey,
+            snippet,
+        });
+        if (summaries.length >= 5)
+            break;
+    }
+    return summaries;
+}
+function buildConversationScopePrefix(event, existingMessages) {
+    if (event.kind !== "message") {
+        return "";
+    }
+    const summaries = extractHistoricalLaneSummary(existingMessages);
+    const lines = [];
+    if (event.threadOriginatorGuid?.trim()) {
+        lines.push(`[conversation scope: existing chat trunk | current inbound lane: thread | current thread id: ${event.threadOriginatorGuid.trim()} | default outbound target: current_lane]`);
+    }
+    else {
+        lines.push("[conversation scope: existing chat trunk | current inbound lane: top_level | default outbound target: top_level]");
+    }
+    if (summaries.length > 0) {
+        lines.push("[recent active lanes]");
+        for (const summary of summaries) {
+            lines.push(`- ${summary.label}: ${summary.snippet}`);
+        }
+    }
+    if (event.threadOriginatorGuid?.trim() || summaries.some((summary) => summary.key.startsWith("thread:"))) {
+        lines.push("[routing control: use bluebubbles_set_reply_target with target=top_level to widen back out, or target=thread plus a listed thread id to route into a specific active thread]");
+    }
+    return lines.join("\n");
+}
+function buildInboundText(event, existingMessages) {
+    const metadataPrefix = buildConversationScopePrefix(event, existingMessages);
     const baseText = event.repairNotice?.trim()
         ? `${event.textForAgent}\n[${event.repairNotice.trim()}]`
         : event.textForAgent;
@@ -98,17 +172,8 @@ function buildInboundText(event) {
     }
     return `${event.sender.displayName}: ${scopedText}`;
 }
-function buildConversationScopePrefix(event) {
-    if (event.kind !== "message") {
-        return "";
-    }
-    if (event.threadOriginatorGuid?.trim()) {
-        return `[conversation scope: existing chat trunk | current turn: thread reply | thread id: ${event.threadOriginatorGuid.trim()}]`;
-    }
-    return "[conversation scope: existing chat trunk | current turn: top-level]";
-}
-function buildInboundContent(event) {
-    const text = buildInboundText(event);
+function buildInboundContent(event, existingMessages) {
+    const text = buildInboundText(event, existingMessages);
     if (event.kind !== "message" || !event.inputPartsForAgent || event.inputPartsForAgent.length === 0) {
         return text;
     }
@@ -117,7 +182,33 @@ function buildInboundContent(event) {
         ...event.inputPartsForAgent,
     ];
 }
-function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
+function createReplyTargetController(event) {
+    let selection = event.kind === "message" && event.threadOriginatorGuid?.trim()
+        ? { target: "current_lane" }
+        : { target: "top_level" };
+    return {
+        getReplyToMessageGuid() {
+            if (event.kind !== "message")
+                return undefined;
+            if (selection.target === "top_level")
+                return undefined;
+            if (selection.target === "thread")
+                return selection.threadOriginatorGuid.trim();
+            return event.threadOriginatorGuid?.trim() ? event.messageGuid : undefined;
+        },
+        setSelection(next) {
+            selection = next;
+            if (next.target === "top_level") {
+                return "bluebubbles reply target set to top_level";
+            }
+            if (next.target === "thread") {
+                return `bluebubbles reply target set to thread:${next.threadOriginatorGuid}`;
+            }
+            return "bluebubbles reply target set to current_lane";
+        },
+    };
+}
+function createBlueBubblesCallbacks(client, chat, replyTarget) {
     let textBuffer = "";
     const phrases = (0, phrases_1.getPhrases)();
     const activity = (0, debug_activity_1.createDebugActivityController)({
@@ -128,7 +219,7 @@ function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
                 const sent = await client.sendText({
                     chat,
                     text,
-                    replyToMessageGuid,
+                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
                 });
                 return sent.messageGuid;
             },
@@ -136,7 +227,7 @@ function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
                 await client.sendText({
                     chat,
                     text,
-                    replyToMessageGuid,
+                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
                 });
             },
             setTyping: async (active) => {
@@ -222,7 +313,7 @@ function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
             await client.sendText({
                 chat,
                 text: trimmed,
-                replyToMessageGuid,
+                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
             });
         },
         async finish() {
@@ -295,17 +386,21 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
     const store = resolvedDeps.createFriendStore();
     const resolver = resolvedDeps.createFriendResolver(store, resolveFriendParams(event));
     const context = await resolver.resolve();
+    const replyTarget = createReplyTargetController(event);
     const toolContext = {
         signin: async () => undefined,
         friendStore: store,
         summarize: (0, core_1.createSummarize)(),
         context,
+        bluebubblesReplyTarget: {
+            setSelection: (selection) => replyTarget.setSelection(selection),
+        },
         codingFeedback: {
             send: async (message) => {
                 await client.sendText({
                     chat: event.chat,
                     text: message,
-                    replyToMessageGuid: event.kind === "message" ? event.messageGuid : undefined,
+                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
                 });
             },
         },
@@ -331,8 +426,8 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
     const messages = existing?.messages && existing.messages.length > 0
         ? existing.messages
         : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", undefined, context) }];
-    messages.push({ role: "user", content: buildInboundContent(event) });
-    const callbacks = createBlueBubblesCallbacks(client, event.chat, event.kind === "message" ? event.messageGuid : undefined);
+    messages.push({ role: "user", content: buildInboundContent(event, existing?.messages ?? messages) });
+    const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget);
     const controller = new AbortController();
     const agentOptions = {
         toolContext,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.31",
+  "version": "0.1.0-alpha.32",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",