@ouro.bot/cli 0.1.0-alpha.47 → 0.1.0-alpha.49

package/dist/senses/bluebubbles.js

@@ -44,6 +44,7 @@ const path = __importStar(require("node:path"));
 const core_1 = require("../heart/core");
 const config_1 = require("../heart/config");
 const identity_1 = require("../heart/identity");
+const turn_coordinator_1 = require("../heart/turn-coordinator");
 const context_1 = require("../mind/context");
 const tokens_1 = require("../mind/friends/tokens");
 const resolver_1 = require("../mind/friends/resolver");
@@ -547,143 +548,146 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
             },
         });
     }
-    // Pre-load session (adapter needs existing messages for lane history in content building)
-    const existing = resolvedDeps.loadSession(sessPath);
-    const sessionMessages = existing?.messages && existing.messages.length > 0
-        ? existing.messages
-        : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", undefined, context) }];
-    if (event.kind === "message") {
-        const agentName = resolvedDeps.getAgentName();
-        if ((0, bluebubbles_inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_recovery_skip",
-                message: "skipped bluebubbles message already recorded as handled",
-                meta: {
-                    messageGuid: event.messageGuid,
-                    sessionKey: event.chat.sessionKey,
-                    source,
-                },
-            });
-            return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
+    return (0, turn_coordinator_1.withSharedTurnLock)("bluebubbles", sessPath, async () => {
+        // Pre-load session inside the turn lock so same-chat deliveries cannot race on stale trunk state.
+        const existing = resolvedDeps.loadSession(sessPath);
+        const sessionMessages = existing?.messages && existing.messages.length > 0
+            ? existing.messages
+            : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", undefined, context) }];
+        if (event.kind === "message") {
+            const agentName = resolvedDeps.getAgentName();
+            if ((0, bluebubbles_inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_recovery_skip",
+                    message: "skipped bluebubbles message already recorded as handled",
+                    meta: {
+                        messageGuid: event.messageGuid,
+                        sessionKey: event.chat.sessionKey,
+                        source,
+                    },
+                });
+                return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
+            }
+            if (source !== "webhook" && sessionLikelyContainsMessage(event, existing?.messages ?? sessionMessages)) {
+                (0, bluebubbles_inbound_log_1.recordBlueBubblesInbound)(agentName, event, "recovery-bootstrap");
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_recovery_skip",
+                    message: "skipped bluebubbles recovery because the session already contains the message text",
+                    meta: {
+                        messageGuid: event.messageGuid,
+                        sessionKey: event.chat.sessionKey,
+                        source,
+                    },
+                });
+                return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
+            }
         }
-        if (source !== "webhook" && sessionLikelyContainsMessage(event, existing?.messages ?? sessionMessages)) {
-            (0, bluebubbles_inbound_log_1.recordBlueBubblesInbound)(agentName, event, "recovery-bootstrap");
+        // Build inbound user message (adapter concern: BB-specific content formatting)
+        const userMessage = {
+            role: "user",
+            content: buildInboundContent(event, existing?.messages ?? sessionMessages),
+        };
+        const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget);
+        const controller = new AbortController();
+        // BB-specific tool context wrappers
+        const summarize = (0, core_1.createSummarize)();
+        const bbCapabilities = (0, channel_1.getChannelCapabilities)("bluebubbles");
+        const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
+        // ── Compute trust gate context for group/acquaintance rules ─────
+        const groupHasFamilyMember = await checkGroupHasFamilyMember(store, event);
+        const hasExistingGroupWithFamily = event.chat.isGroup
+            ? false
+            : await checkHasExistingGroupWithFamily(store, context.friend);
+        // ── Call shared pipeline ──────────────────────────────────────────
+        try {
+            const result = await (0, pipeline_1.handleInboundTurn)({
+                channel: "bluebubbles",
+                sessionKey: event.chat.sessionKey,
+                capabilities: bbCapabilities,
+                messages: [userMessage],
+                continuityIngressTexts: getBlueBubblesContinuityIngressTexts(event),
+                callbacks,
+                friendResolver: { resolve: () => Promise.resolve(context) },
+                sessionLoader: { loadOrCreate: () => Promise.resolve({ messages: sessionMessages, sessionPath: sessPath, state: existing?.state }) },
+                pendingDir,
+                friendStore: store,
+                provider: "imessage-handle",
+                externalId: event.sender.externalId || event.sender.rawId,
+                isGroupChat: event.chat.isGroup,
+                groupHasFamilyMember,
+                hasExistingGroupWithFamily,
+                enforceTrustGate: trust_gate_1.enforceTrustGate,
+                drainPending: pending_1.drainPending,
+                runAgent: (msgs, cb, channel, sig, opts) => resolvedDeps.runAgent(msgs, cb, channel, sig, {
+                    ...opts,
+                    toolContext: {
+                        /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                        signin: async () => undefined,
+                        ...opts?.toolContext,
+                        summarize,
+                        bluebubblesReplyTarget: {
+                            setSelection: (selection) => replyTarget.setSelection(selection),
+                        },
+                        codingFeedback: {
+                            send: async (message) => {
+                                await client.sendText({
+                                    chat: event.chat,
+                                    text: message,
+                                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
+                                });
+                            },
+                        },
+                    },
+                }),
+                postTurn: resolvedDeps.postTurn,
+                accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
+                signal: controller.signal,
+            });
+            // ── Handle gate result ────────────────────────────────────────
+            if (!result.gateResult.allowed) {
+                // Send auto-reply via BB API if the gate provides one
+                if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
+                    await client.sendText({
+                        chat: event.chat,
+                        text: result.gateResult.autoReply,
+                    });
+                }
+                if (event.kind === "message") {
+                    (0, bluebubbles_inbound_log_1.recordBlueBubblesInbound)(resolvedDeps.getAgentName(), event, source);
+                }
+                return {
+                    handled: true,
+                    notifiedAgent: false,
+                    kind: event.kind,
+                };
+            }
+            // Gate allowed — flush the agent's reply
+            await callbacks.flush();
+            if (event.kind === "message") {
+                (0, bluebubbles_inbound_log_1.recordBlueBubblesInbound)(resolvedDeps.getAgentName(), event, source);
+            }
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
-                event: "senses.bluebubbles_recovery_skip",
-                message: "skipped bluebubbles recovery because the session already contains the message text",
+                event: "senses.bluebubbles_turn_end",
+                message: "bluebubbles event handled",
                 meta: {
                     messageGuid: event.messageGuid,
+                    kind: event.kind,
                     sessionKey: event.chat.sessionKey,
-                    source,
                 },
             });
-            return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
-        }
-    }
-    // Build inbound user message (adapter concern: BB-specific content formatting)
-    const userMessage = {
-        role: "user",
-        content: buildInboundContent(event, existing?.messages ?? sessionMessages),
-    };
-    const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget);
-    const controller = new AbortController();
-    // BB-specific tool context wrappers
-    const summarize = (0, core_1.createSummarize)();
-    const bbCapabilities = (0, channel_1.getChannelCapabilities)("bluebubbles");
-    const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
-    // ── Compute trust gate context for group/acquaintance rules ─────
-    const groupHasFamilyMember = await checkGroupHasFamilyMember(store, event);
-    const hasExistingGroupWithFamily = event.chat.isGroup
-        ? false
-        : await checkHasExistingGroupWithFamily(store, context.friend);
-    // ── Call shared pipeline ──────────────────────────────────────────
-    try {
-        const result = await (0, pipeline_1.handleInboundTurn)({
-            channel: "bluebubbles",
-            capabilities: bbCapabilities,
-            messages: [userMessage],
-            continuityIngressTexts: getBlueBubblesContinuityIngressTexts(event),
-            callbacks,
-            friendResolver: { resolve: () => Promise.resolve(context) },
-            sessionLoader: { loadOrCreate: () => Promise.resolve({ messages: sessionMessages, sessionPath: sessPath, state: existing?.state }) },
-            pendingDir,
-            friendStore: store,
-            provider: "imessage-handle",
-            externalId: event.sender.externalId || event.sender.rawId,
-            isGroupChat: event.chat.isGroup,
-            groupHasFamilyMember,
-            hasExistingGroupWithFamily,
-            enforceTrustGate: trust_gate_1.enforceTrustGate,
-            drainPending: pending_1.drainPending,
-            runAgent: (msgs, cb, channel, sig, opts) => resolvedDeps.runAgent(msgs, cb, channel, sig, {
-                ...opts,
-                toolContext: {
-                    /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
-                    signin: async () => undefined,
-                    ...opts?.toolContext,
-                    summarize,
-                    bluebubblesReplyTarget: {
-                        setSelection: (selection) => replyTarget.setSelection(selection),
-                    },
-                    codingFeedback: {
-                        send: async (message) => {
-                            await client.sendText({
-                                chat: event.chat,
-                                text: message,
-                                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                            });
-                        },
-                    },
-                },
-            }),
-            postTurn: resolvedDeps.postTurn,
-            accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
-            signal: controller.signal,
-        });
-        // ── Handle gate result ────────────────────────────────────────
-        if (!result.gateResult.allowed) {
-            // Send auto-reply via BB API if the gate provides one
-            if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
-                await client.sendText({
-                    chat: event.chat,
-                    text: result.gateResult.autoReply,
-                });
-            }
-            if (event.kind === "message") {
-                (0, bluebubbles_inbound_log_1.recordBlueBubblesInbound)(resolvedDeps.getAgentName(), event, source);
-            }
             return {
                 handled: true,
-                notifiedAgent: false,
+                notifiedAgent: true,
                 kind: event.kind,
             };
         }
-        // Gate allowed — flush the agent's reply
-        await callbacks.flush();
-        if (event.kind === "message") {
-            (0, bluebubbles_inbound_log_1.recordBlueBubblesInbound)(resolvedDeps.getAgentName(), event, source);
+        finally {
+            await callbacks.finish();
         }
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.bluebubbles_turn_end",
-            message: "bluebubbles event handled",
-            meta: {
-                messageGuid: event.messageGuid,
-                kind: event.kind,
-                sessionKey: event.chat.sessionKey,
-            },
-        });
-        return {
-            handled: true,
-            notifiedAgent: true,
-            kind: event.kind,
-        };
-    }
-    finally {
-        await callbacks.finish();
-    }
+    });
 }
 async function handleBlueBubblesEvent(payload, deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };

package/dist/senses/cli.js

@@ -752,6 +752,7 @@ async function main(agentName, options) {
                 // User message passed via input.messages so the pipeline can prepend pending messages to it.
                 const result = await (0, pipeline_1.handleInboundTurn)({
                     channel: "cli",
+                    sessionKey: "session",
                     capabilities: cliCapabilities,
                     messages: [{ role: "user", content: userInput }],
                     continuityIngressTexts: getCliContinuityIngressTexts(userInput),

package/dist/senses/inner-dialog-worker.js

@@ -4,26 +4,52 @@ exports.createInnerDialogWorker = createInnerDialogWorker;
 exports.startInnerDialogWorker = startInnerDialogWorker;
 const inner_dialog_1 = require("./inner-dialog");
 const runtime_1 = require("../nerves/runtime");
-function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options)) {
+const identity_1 = require("../heart/identity");
+const pending_1 = require("../mind/pending");
+function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options), hasPendingWork = () => (0, pending_1.hasPendingMessages)((0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)()))) {
     let running = false;
+    let rerunRequested = false;
+    let rerunReason = "instinct";
+    let rerunTaskId;
     async function run(reason, taskId) {
-        if (running)
+        if (running) {
+            rerunRequested = true;
+            rerunReason = reason;
+            if (taskId !== undefined) {
+                rerunTaskId = taskId;
+            }
             return;
+        }
         running = true;
         try {
-            await runTurn({ reason, taskId });
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "senses",
-                event: "senses.inner_dialog_worker_error",
-                message: "inner dialog worker turn failed",
-                meta: {
-                    reason,
-                    error: error instanceof Error ? error.message : String(error),
-                },
-            });
+            let nextReason = reason;
+            let nextTaskId = taskId;
+            do {
+                rerunRequested = false;
+                try {
+                    await runTurn({ reason: nextReason, taskId: nextTaskId });
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "senses",
+                        event: "senses.inner_dialog_worker_error",
+                        message: "inner dialog worker turn failed",
+                        meta: {
+                            reason: nextReason,
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                }
+                if (!rerunRequested && hasPendingWork()) {
+                    rerunRequested = true;
+                    rerunReason = "instinct";
+                }
+                nextReason = rerunReason;
+                nextTaskId = rerunTaskId;
+                rerunReason = "instinct";
+                rerunTaskId = undefined;
+            } while (rerunRequested);
         }
         finally {
             running = false;

package/dist/senses/inner-dialog.js

@@ -337,6 +337,7 @@ async function runInnerDialogTurn(options) {
         const traceId = (0, nerves_1.createTraceId)();
         const result = await (0, pipeline_1.handleInboundTurn)({
             channel: "inner",
+            sessionKey: "dialog",
             capabilities: innerCapabilities,
             messages: [userMessage],
             continuityIngressTexts: [],

package/dist/senses/pipeline.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleInboundTurn = handleInboundTurn;
 const runtime_1 = require("../nerves/runtime");
 const continuity_1 = require("./continuity");
+const manager_1 = require("../heart/bridges/manager");
 // ── Pipeline ──────────────────────────────────────────────────────
 async function handleInboundTurn(input) {
     // Step 1: Resolve friend
@@ -60,6 +61,18 @@ async function handleInboundTurn(input) {
         ?.map((text) => text.trim())
         .filter((text) => text.length > 0)
         .at(-1);
+    const currentSession = {
+        friendId: resolvedContext.friend.id,
+        channel: input.channel,
+        key: input.sessionKey ?? "session",
+        sessionPath: session.sessionPath,
+    };
+    const activeBridges = (0, manager_1.createBridgeManager)().findBridgesForSession({
+        friendId: currentSession.friendId,
+        channel: currentSession.channel,
+        key: currentSession.key,
+    });
+    const bridgeContext = (0, manager_1.formatBridgeContext)(activeBridges) || undefined;
     // Step 4: Drain pending messages
     const pending = input.drainPending(input.pendingDir);
     // Assemble messages: session messages + pending (formatted) + inbound user messages
@@ -98,6 +111,8 @@ async function handleInboundTurn(input) {
     const existingToolContext = input.runAgentOptions?.toolContext;
     const runAgentOptions = {
         ...input.runAgentOptions,
+        bridgeContext,
+        currentSessionKey: currentSession.key,
         currentObligation,
         mustResolveBeforeHandoff,
         setMustResolveBeforeHandoff: (value) => {
@@ -109,6 +124,8 @@ async function handleInboundTurn(input) {
             ...existingToolContext,
             context: resolvedContext,
             friendStore: input.friendStore,
+            currentSession,
+            activeBridges,
         },
     };
     const result = await input.runAgent(sessionMessages, input.callbacks, input.channel, input.signal, runAgentOptions);

package/dist/senses/teams.js

@@ -534,6 +534,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
         // ── Call shared pipeline ──────────────────────────────────────────
         const result = await (0, pipeline_1.handleInboundTurn)({
             channel: "teams",
+            sessionKey: conversationId,
             capabilities: teamsCapabilities,
             messages: [{ role: "user", content: currentText }],
             continuityIngressTexts: [currentText],

package/package.json

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

package/subagents/work-doer.md

@@ -9,7 +9,7 @@ You are a task executor. Read a doing.md file and execute all units sequentially
 ## On Startup
 
 1. **Find task-doc directory**: Read project instructions (for example `AGENTS.md`) to determine where planning/doing docs live for this repo
-2. **Confirm worktree**: Run from the dedicated task worktree required by the project. If the current checkout is shared, ambiguous, or not on the task branch, STOP and switch/create the correct worktree first.
+2. **Confirm worktree**: Run from the dedicated task worktree required by the project. If the current checkout is shared, ambiguous, or not on the task branch, switch/create the correct worktree first when project instructions allow it. Only STOP to ask the user when they explicitly want to control naming/layout or automatic creation fails.
 3. **Find doing doc**: Look for `YYYY-MM-DD-HHMM-doing-*.md` in that project-defined task-doc directory
 4. If multiple found, ask which one
 5. If none found, ask user for location

package/subagents/work-planner.md

@@ -11,7 +11,7 @@ You are a task planner for coding work. Help the user define scope, then convert
 **Determine task doc directory:**
 1. Read project instructions (for example `AGENTS.md`) to find the canonical task-doc location for the current repo
 2. Derive `AGENT` from the current git branch when the project uses agent-scoped task docs
-3. Confirm the task is running from a dedicated task worktree when the project requires parallel agent work; if the checkout is shared or ambiguous, STOP and tell the caller to create/switch to a dedicated worktree first
+3. Confirm the task is running from a dedicated task worktree when the project requires parallel agent work; if the checkout is shared or ambiguous, create/switch to the dedicated worktree yourself when project instructions allow it, and only STOP to ask the caller when they explicitly want to control naming/layout or automatic creation fails
 4. Set `TASK_DIR` to the project-defined planning/doing directory
 5. If the project-defined parent location exists but `TASK_DIR` does not, create it
 6. If the project does not define a task-doc location, STOP and ask the user or caller where planning/doing docs should live