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

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_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.49",
+      "changes": [
+        "Inner dialog no longer drops self-directed wake signals that arrive mid-turn; overlapping inward requests now guarantee a truthful follow-up inner pass instead of mailbox-like limbo.",
+        "The harness now has a shared core bridge layer with lifecycle/runtime state, persistence, task linkage, and one `bridge_manage` path so already-live sessions can coordinate as one coherent piece of work.",
+        "`query_session` and bridge attachment now share one session-recall helper, reducing duplicate cross-session summarization logic and setting up thinner outer surfaces around a stronger inner/core."
+      ]
+    },
     {
       "version": "0.1.0-alpha.48",
       "changes": [

package/dist/heart/bridges/manager.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBridgeStatus = formatBridgeStatus;
+exports.formatBridgeContext = formatBridgeContext;
+exports.createBridgeManager = createBridgeManager;
+const runtime_1 = require("../../nerves/runtime");
+const state_machine_1 = require("./state-machine");
+const store_1 = require("./store");
+const turn_coordinator_1 = require("../turn-coordinator");
+const tasks_1 = require("../../repertoire/tasks");
+function defaultIdFactory() {
+    return `bridge-${Date.now().toString(36)}`;
+}
+function sessionIdentityKey(session) {
+    return `${session.friendId}/${session.channel}/${session.key}`;
+}
+function assertBridgeMutable(bridge, action) {
+    if (bridge.lifecycle === "completed" || bridge.lifecycle === "cancelled") {
+        throw new Error(`cannot ${action} a terminal bridge`);
+    }
+}
+function defaultTaskBody(bridge) {
+    const lines = [
+        "## scope",
+        bridge.objective,
+        "",
+        "## bridge",
+        `id: ${bridge.id}`,
+    ];
+    if (bridge.attachedSessions.length > 0) {
+        lines.push("sessions:");
+        for (const session of bridge.attachedSessions) {
+            lines.push(`- ${sessionIdentityKey(session)}`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatBridgeStatus(bridge) {
+    const summary = typeof bridge.summary === "string" ? bridge.summary.trim() : "";
+    const lines = [
+        `bridge: ${bridge.id}`,
+        `objective: ${bridge.objective}`,
+        `state: ${(0, state_machine_1.bridgeStateLabel)(bridge)}`,
+        `sessions: ${bridge.attachedSessions.length}`,
+        `task: ${bridge.task?.taskName ?? "none"}`,
+    ];
+    if (summary) {
+        lines.push(`summary: ${summary}`);
+    }
+    return lines.join("\n");
+}
+function formatBridgeContext(bridges) {
+    if (bridges.length === 0)
+        return "";
+    const lines = ["## active bridge work"];
+    for (const bridge of bridges) {
+        const task = bridge.task?.taskName ? ` (task: ${bridge.task.taskName})` : "";
+        const label = typeof bridge.summary === "string" && bridge.summary.trim().length > 0 ? bridge.summary.trim() : bridge.objective;
+        lines.push(`- ${bridge.id}: ${label} [${(0, state_machine_1.bridgeStateLabel)(bridge)}]${task}`);
+    }
+    return lines.join("\n");
+}
+function ensureRunnable(bridge, now, store) {
+    if (bridge.lifecycle === "forming" || bridge.lifecycle === "suspended") {
+        const activated = {
+            ...bridge,
+            ...(0, state_machine_1.activateBridge)(bridge),
+            updatedAt: now(),
+        };
+        return store.save(activated);
+    }
+    if (bridge.lifecycle === "completed" || bridge.lifecycle === "cancelled") {
+        throw new Error(`bridge is terminal: ${bridge.id}`);
+    }
+    return bridge;
+}
+function createBridgeManager(options = {}) {
+    const store = options.store ?? (0, store_1.createBridgeStore)();
+    const now = options.now ?? (() => new Date().toISOString());
+    const idFactory = options.idFactory ?? defaultIdFactory;
+    function requireBridge(bridgeId) {
+        const bridge = store.get(bridgeId);
+        if (!bridge) {
+            throw new Error(`bridge not found: ${bridgeId}`);
+        }
+        return bridge;
+    }
+    function save(bridge) {
+        return store.save(bridge);
+    }
+    return {
+        beginBridge(input) {
+            const timestamp = now();
+            const state = (0, state_machine_1.activateBridge)((0, state_machine_1.createBridgeState)());
+            const bridge = {
+                id: idFactory(),
+                objective: input.objective,
+                summary: input.summary,
+                lifecycle: state.lifecycle,
+                runtime: state.runtime,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                attachedSessions: [input.session],
+                task: null,
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_begin",
+                message: "created bridge",
+                meta: {
+                    bridgeId: bridge.id,
+                    session: sessionIdentityKey(input.session),
+                },
+            });
+            return save(bridge);
+        },
+        attachSession(bridgeId, session) {
+            const bridge = requireBridge(bridgeId);
+            assertBridgeMutable(bridge, "attach session to");
+            const existing = bridge.attachedSessions.some((candidate) => sessionIdentityKey(candidate) === sessionIdentityKey(session));
+            if (existing)
+                return bridge;
+            const updated = {
+                ...bridge,
+                attachedSessions: [...bridge.attachedSessions, session],
+                updatedAt: now(),
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_attach_session",
+                message: "attached canonical session to bridge",
+                meta: {
+                    bridgeId,
+                    session: sessionIdentityKey(session),
+                },
+            });
+            return save(updated);
+        },
+        detachSession(bridgeId, session) {
+            const bridge = requireBridge(bridgeId);
+            assertBridgeMutable(bridge, "detach session from");
+            const updated = {
+                ...bridge,
+                attachedSessions: bridge.attachedSessions.filter((candidate) => sessionIdentityKey(candidate) !== sessionIdentityKey(session)),
+                updatedAt: now(),
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_detach_session",
+                message: "detached canonical session from bridge",
+                meta: {
+                    bridgeId,
+                    session: sessionIdentityKey(session),
+                },
+            });
+            return save(updated);
+        },
+        getBridge(bridgeId) {
+            return store.get(bridgeId);
+        },
+        listBridges() {
+            return store.list();
+        },
+        findBridgesForSession(session) {
+            return store.findBySession(session)
+                .filter((bridge) => bridge.lifecycle !== "completed" && bridge.lifecycle !== "cancelled");
+        },
+        promoteBridgeToTask(bridgeId, input = {}) {
+            const bridge = requireBridge(bridgeId);
+            assertBridgeMutable(bridge, "promote");
+            if (bridge.task)
+                return bridge;
+            const taskPath = (0, tasks_1.getTaskModule)().createTask({
+                title: input.title?.trim() || bridge.objective,
+                type: "ongoing",
+                category: input.category?.trim() || "coordination",
+                status: "processing",
+                body: input.body?.trim() || defaultTaskBody(bridge),
+                activeBridge: bridge.id,
+                bridgeSessions: bridge.attachedSessions.map((session) => sessionIdentityKey(session)),
+            });
+            const taskName = taskPath.replace(/^.*\//, "").replace(/\.md$/, "");
+            const updated = save({
+                ...bridge,
+                task: {
+                    taskName,
+                    path: taskPath,
+                    mode: "promoted",
+                    boundAt: now(),
+                },
+                updatedAt: now(),
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_promote_task",
+                message: "promoted bridge to task-backed work",
+                meta: {
+                    bridgeId,
+                    taskName,
+                },
+            });
+            return updated;
+        },
+        completeBridge(bridgeId) {
+            const bridge = requireBridge(bridgeId);
+            const updated = save({
+                ...bridge,
+                ...(0, state_machine_1.completeBridge)(bridge),
+                updatedAt: now(),
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_complete",
+                message: "completed bridge",
+                meta: {
+                    bridgeId,
+                },
+            });
+            return updated;
+        },
+        cancelBridge(bridgeId) {
+            const bridge = requireBridge(bridgeId);
+            const updated = save({
+                ...bridge,
+                ...(0, state_machine_1.cancelBridge)(bridge),
+                updatedAt: now(),
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_cancel",
+                message: "cancelled bridge",
+                meta: {
+                    bridgeId,
+                },
+            });
+            return updated;
+        },
+        async runBridgeTurn(bridgeId, fn) {
+            if (!(0, turn_coordinator_1.tryBeginSharedTurn)("bridge", bridgeId)) {
+                const bridge = requireBridge(bridgeId);
+                const queued = bridge.runtime === "awaiting-follow-up"
+                    ? bridge
+                    : save({
+                        ...bridge,
+                        ...(0, state_machine_1.queueBridgeFollowUp)(bridge),
+                        updatedAt: now(),
+                    });
+                (0, turn_coordinator_1.enqueueSharedFollowUp)("bridge", bridgeId, {
+                    conversationId: bridgeId,
+                    text: "bridge follow-up",
+                    receivedAt: Date.now(),
+                    effect: "none",
+                });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "engine",
+                    event: "engine.bridge_turn_queued",
+                    message: "queued follow-up bridge turn",
+                    meta: {
+                        bridgeId,
+                    },
+                });
+                return {
+                    queued: true,
+                    bridge: queued,
+                };
+            }
+            try {
+                let current = ensureRunnable(requireBridge(bridgeId), now, store);
+                current = save({
+                    ...current,
+                    ...(0, state_machine_1.beginBridgeProcessing)(current),
+                    updatedAt: now(),
+                });
+                while (true) {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "engine",
+                        event: "engine.bridge_turn_start",
+                        message: "running bridge turn",
+                        meta: {
+                            bridgeId,
+                        },
+                    });
+                    await fn();
+                    let next = requireBridge(bridgeId);
+                    const bufferedFollowUps = (0, turn_coordinator_1.drainSharedFollowUps)("bridge", bridgeId);
+                    if (bufferedFollowUps.length > 0 && next.runtime !== "awaiting-follow-up") {
+                        next = save({
+                            ...next,
+                            ...(0, state_machine_1.queueBridgeFollowUp)(next),
+                            updatedAt: now(),
+                        });
+                    }
+                    const advanced = save({
+                        ...next,
+                        ...(0, state_machine_1.advanceBridgeAfterTurn)(next),
+                        updatedAt: now(),
+                    });
+                    if (advanced.runtime === "processing") {
+                        current = advanced;
+                        continue;
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "engine",
+                        event: "engine.bridge_turn_end",
+                        message: "bridge turn finished",
+                        meta: {
+                            bridgeId,
+                        },
+                    });
+                    return {
+                        queued: false,
+                        bridge: current = advanced,
+                    };
+                }
+            }
+            finally {
+                (0, turn_coordinator_1.endSharedTurn)("bridge", bridgeId);
+            }
+        },
+    };
+}

package/dist/heart/bridges/state-machine.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBridgeState = createBridgeState;
+exports.bridgeStateLabel = bridgeStateLabel;
+exports.activateBridge = activateBridge;
+exports.beginBridgeProcessing = beginBridgeProcessing;
+exports.queueBridgeFollowUp = queueBridgeFollowUp;
+exports.advanceBridgeAfterTurn = advanceBridgeAfterTurn;
+exports.suspendBridge = suspendBridge;
+exports.completeBridge = completeBridge;
+exports.cancelBridge = cancelBridge;
+const runtime_1 = require("../../nerves/runtime");
+function transition(state, next, action) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.bridge_state_transition",
+        message: "bridge state transitioned",
+        meta: {
+            action,
+            from: bridgeStateLabel(state),
+            to: bridgeStateLabel(next),
+        },
+    });
+    return next;
+}
+function assertNonTerminal(state, action) {
+    if (state.lifecycle === "completed" || state.lifecycle === "cancelled") {
+        throw new Error(`cannot ${action} a terminal bridge`);
+    }
+}
+function createBridgeState() {
+    return {
+        lifecycle: "forming",
+        runtime: "idle",
+    };
+}
+function bridgeStateLabel(state) {
+    switch (state.lifecycle) {
+        case "forming":
+            return "forming";
+        case "suspended":
+            return "suspended";
+        case "completed":
+            return "completed";
+        case "cancelled":
+            return "cancelled";
+        case "active":
+            if (state.runtime === "processing")
+                return "active-processing";
+            if (state.runtime === "awaiting-follow-up")
+                return "awaiting-follow-up";
+            return "active-idle";
+    }
+}
+function activateBridge(state) {
+    assertNonTerminal(state, "activate");
+    if (state.lifecycle !== "forming" && state.lifecycle !== "suspended") {
+        throw new Error("cannot activate bridge from current state");
+    }
+    return transition(state, { lifecycle: "active", runtime: "idle" }, "activate");
+}
+function beginBridgeProcessing(state) {
+    assertNonTerminal(state, "process");
+    if (state.lifecycle !== "active" || state.runtime !== "idle") {
+        throw new Error("cannot process bridge from current state");
+    }
+    return transition(state, { lifecycle: "active", runtime: "processing" }, "begin-processing");
+}
+function queueBridgeFollowUp(state) {
+    assertNonTerminal(state, "queue");
+    if (state.lifecycle !== "active") {
+        throw new Error("cannot queue follow-up for non-active bridge");
+    }
+    if (state.runtime === "processing") {
+        return transition(state, { lifecycle: "active", runtime: "awaiting-follow-up" }, "queue-follow-up");
+    }
+    if (state.runtime === "awaiting-follow-up") {
+        return state;
+    }
+    throw new Error("cannot queue follow-up when bridge is not processing");
+}
+function advanceBridgeAfterTurn(state) {
+    assertNonTerminal(state, "advance");
+    if (state.lifecycle !== "active") {
+        throw new Error("cannot advance non-active bridge");
+    }
+    if (state.runtime === "processing") {
+        return transition(state, { lifecycle: "active", runtime: "idle" }, "finish-processing");
+    }
+    if (state.runtime === "awaiting-follow-up") {
+        return transition(state, { lifecycle: "active", runtime: "processing" }, "resume-follow-up");
+    }
+    throw new Error("cannot advance an idle bridge");
+}
+function suspendBridge(state) {
+    assertNonTerminal(state, "suspend");
+    if ((state.lifecycle !== "forming" && state.lifecycle !== "active") || state.runtime !== "idle") {
+        throw new Error("cannot suspend bridge from current state");
+    }
+    return transition(state, { lifecycle: "suspended", runtime: "idle" }, "suspend");
+}
+function completeBridge(state) {
+    assertNonTerminal(state, "complete");
+    if (state.runtime !== "idle") {
+        throw new Error("cannot complete a bridge mid-turn");
+    }
+    return transition(state, { lifecycle: "completed", runtime: "idle" }, "complete");
+}
+function cancelBridge(state) {
+    assertNonTerminal(state, "cancel");
+    if (state.runtime !== "idle") {
+        throw new Error("cannot cancel a bridge mid-turn");
+    }
+    return transition(state, { lifecycle: "cancelled", runtime: "idle" }, "cancel");
+}

package/dist/heart/bridges/store.js

@@ -0,0 +1,123 @@
+"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.getBridgeStateRoot = getBridgeStateRoot;
+exports.createBridgeStore = createBridgeStore;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function sessionIdentityMatches(session, candidate) {
+    return (session.friendId === candidate.friendId
+        && session.channel === candidate.channel
+        && session.key === candidate.key);
+}
+function bridgeFilePath(rootDir, id) {
+    return path.join(rootDir, `${id}.json`);
+}
+function getBridgeStateRoot() {
+    return path.join((0, identity_1.getAgentStateRoot)(), "bridges");
+}
+function createBridgeStore(options = {}) {
+    const rootDir = options.rootDir ?? getBridgeStateRoot();
+    function ensureRoot() {
+        fs.mkdirSync(rootDir, { recursive: true });
+    }
+    return {
+        save(bridge) {
+            ensureRoot();
+            fs.writeFileSync(bridgeFilePath(rootDir, bridge.id), JSON.stringify(bridge, null, 2), "utf-8");
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_store_save",
+                message: "saved bridge record",
+                meta: {
+                    bridgeId: bridge.id,
+                    rootDir,
+                },
+            });
+            return bridge;
+        },
+        get(id) {
+            const filePath = bridgeFilePath(rootDir, id);
+            try {
+                const raw = fs.readFileSync(filePath, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        },
+        list() {
+            ensureRoot();
+            const files = fs.readdirSync(rootDir).filter((entry) => entry.endsWith(".json")).sort();
+            const bridges = files
+                .map((fileName) => {
+                try {
+                    return JSON.parse(fs.readFileSync(path.join(rootDir, fileName), "utf-8"));
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((bridge) => bridge !== null);
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_store_list",
+                message: "listed bridge records",
+                meta: {
+                    rootDir,
+                    count: bridges.length,
+                },
+            });
+            return bridges;
+        },
+        findBySession(session) {
+            const matches = this.list().filter((bridge) => bridge.attachedSessions.some((candidate) => sessionIdentityMatches(session, candidate)));
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_store_find_by_session",
+                message: "located bridges for canonical session",
+                meta: {
+                    friendId: session.friendId,
+                    channel: session.channel,
+                    key: session.key,
+                    count: matches.length,
+                },
+            });
+            return matches;
+        },
+    };
+}

package/dist/heart/daemon/thoughts.js

@@ -151,8 +151,16 @@ function formatSurfacedValue(text, maxLength = 120) {
 }
 function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
     if (runtimeState?.status === "running") {
+        if (pendingMessages.length > 0) {
+            return {
+                queue: "queued to inner/dialog",
+                wake: "queued behind active turn",
+                processing: "pending",
+                surfaced: "nothing yet",
+            };
+        }
         return {
-            queue: pendingMessages.length > 0 ? "queued to inner/dialog" : "clear",
+            queue: "clear",
             wake: "in progress",
             processing: "started",
             surfaced: "nothing yet",

package/dist/heart/session-recall.js

@@ -0,0 +1,116 @@
+"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.recallSession = recallSession;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+function normalizeContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part
+        ? String(part.text ?? "")
+        : ""))
+        .filter((text) => text.length > 0)
+        .join("");
+}
+function buildSummaryInstruction(friendId, channel, trustLevel) {
+    if (friendId === "self" && channel === "inner") {
+        return "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning.";
+    }
+    return `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
+}
+function clip(text, limit = 160) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    return compact.length > limit ? compact.slice(0, limit - 1) + "…" : compact;
+}
+function buildSnapshot(summary, tailMessages) {
+    const lines = [`recent focus: ${clip(summary, 240)}`];
+    const latestUser = [...tailMessages].reverse().find((message) => message.role === "user")?.content;
+    const latestAssistant = [...tailMessages].reverse().find((message) => message.role === "assistant")?.content;
+    if (latestUser) {
+        lines.push(`latest user: ${clip(latestUser)}`);
+    }
+    if (latestAssistant) {
+        lines.push(`latest assistant: ${clip(latestAssistant)}`);
+    }
+    return lines.join("\n");
+}
+async function recallSession(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_recall",
+        message: "recalling session transcript tail",
+        meta: {
+            friendId: options.friendId,
+            channel: options.channel,
+            key: options.key,
+            messageCount: options.messageCount,
+        },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(options.sessionPath, "utf-8");
+    }
+    catch {
+        return { kind: "missing" };
+    }
+    const parsed = JSON.parse(raw);
+    const tailMessages = (parsed.messages ?? [])
+        .map((message) => ({
+        role: typeof message.role === "string" ? message.role : "",
+        content: normalizeContent(message.content),
+    }))
+        .filter((message) => message.role !== "system" && message.content.length > 0)
+        .slice(-options.messageCount);
+    if (tailMessages.length === 0) {
+        return { kind: "empty" };
+    }
+    const transcript = tailMessages
+        .map((message) => `[${message.role}] ${message.content}`)
+        .join("\n");
+    const summary = options.summarize
+        ? await options.summarize(transcript, buildSummaryInstruction(options.friendId, options.channel, options.trustLevel ?? "family"))
+        : transcript;
+    return {
+        kind: "ok",
+        transcript,
+        summary,
+        snapshot: buildSnapshot(summary, tailMessages),
+        tailMessages,
+    };
+}

package/dist/heart/turn-coordinator.js

@@ -2,7 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTurnCoordinator = createTurnCoordinator;
 exports.withSharedTurnLock = withSharedTurnLock;
+exports.tryBeginSharedTurn = tryBeginSharedTurn;
+exports.endSharedTurn = endSharedTurn;
+exports.isSharedTurnActive = isSharedTurnActive;
+exports.enqueueSharedFollowUp = enqueueSharedFollowUp;
+exports.drainSharedFollowUps = drainSharedFollowUps;
 const runtime_1 = require("../nerves/runtime");
+function scopedKey(scope, key) {
+    return `${scope}:${key}`;
+}
 function createTurnCoordinator() {
     const turnLocks = new Map();
     const activeTurns = new Set();
@@ -63,5 +71,20 @@ function createTurnCoordinator() {
 }
 const _sharedTurnCoordinator = createTurnCoordinator();
 function withSharedTurnLock(scope, key, fn) {
-    return _sharedTurnCoordinator.withTurnLock(`${scope}:${key}`, fn);
+    return _sharedTurnCoordinator.withTurnLock(scopedKey(scope, key), fn);
+}
+function tryBeginSharedTurn(scope, key) {
+    return _sharedTurnCoordinator.tryBeginTurn(scopedKey(scope, key));
+}
+function endSharedTurn(scope, key) {
+    _sharedTurnCoordinator.endTurn(scopedKey(scope, key));
+}
+function isSharedTurnActive(scope, key) {
+    return _sharedTurnCoordinator.isTurnActive(scopedKey(scope, key));
+}
+function enqueueSharedFollowUp(scope, key, followUp) {
+    _sharedTurnCoordinator.enqueueFollowUp(scopedKey(scope, key), followUp);
+}
+function drainSharedFollowUps(scope, key) {
+    return _sharedTurnCoordinator.drainFollowUps(scopedKey(scope, key));
 }

package/dist/mind/pending.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.INNER_DIALOG_PENDING = void 0;
 exports.getPendingDir = getPendingDir;
 exports.getInnerDialogPendingDir = getInnerDialogPendingDir;
+exports.hasPendingMessages = hasPendingMessages;
 exports.drainPending = drainPending;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -50,6 +51,16 @@ exports.INNER_DIALOG_PENDING = { friendId: "self", channel: "inner", key: "dialo
 function getInnerDialogPendingDir(agentName) {
     return getPendingDir(agentName, exports.INNER_DIALOG_PENDING.friendId, exports.INNER_DIALOG_PENDING.channel, exports.INNER_DIALOG_PENDING.key);
 }
+function hasPendingMessages(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return false;
+    try {
+        return fs.readdirSync(pendingDir).some((entry) => entry.endsWith(".json") || entry.endsWith(".json.processing"));
+    }
+    catch {
+        return false;
+    }
+}
 function drainPending(pendingDir) {
     if (!fs.existsSync(pendingDir))
         return [];

package/dist/mind/prompt.js

@@ -412,6 +412,12 @@ function memoryFriendToolContractSection() {
 - My psyche files (SOUL, IDENTITY, TACIT, LORE, ASPIRATIONS) are always loaded - I already know who I am.
 - My task board is always loaded - I already know my work.`;
 }
+function bridgeContextSection(options) {
+    const bridgeContext = options?.bridgeContext?.trim() ?? "";
+    if (!bridgeContext)
+        return "";
+    return bridgeContext.startsWith("## ") ? bridgeContext : `## active bridge work\n${bridgeContext}`;
+}
 function toolBehaviorSection(options) {
     if (!(options?.toolChoiceRequired ?? true))
         return "";
@@ -543,13 +549,14 @@ async function buildSystem(channel = "cli", options, context) {
         mixedTrustGroupSection(context),
         skillsSection(),
         taskBoardSection(),
+        bridgeContextSection(options),
         buildSessionSummary({
             sessionsDir: path.join((0, identity_1.getAgentRoot)(), "state", "sessions"),
             friendsDir: path.join((0, identity_1.getAgentRoot)(), "friends"),
             agentName: (0, identity_1.getAgentName)(),
             currentFriendId: context?.friend?.id,
             currentChannel: channel,
-            currentKey: "session",
+            currentKey: options?.currentSessionKey ?? "session",
         }),
         memoryFriendToolContractSection(),
         toolBehaviorSection(options),

package/dist/repertoire/tasks/board.js

@@ -59,6 +59,12 @@ function activeSessionLines(tasks) {
     });
     return active.map((task) => task.stem).sort();
 }
+function activeBridgeLines(tasks) {
+    return tasks
+        .filter((task) => typeof task.frontmatter.active_bridge === "string" && String(task.frontmatter.active_bridge).trim())
+        .map((task) => `${task.stem} -> ${String(task.frontmatter.active_bridge).trim()}`)
+        .sort();
+}
 function actionRequired(index, byStatus) {
     const actions = [...index.parseErrors, ...index.invalidFilenames.map((filePath) => `bad filename: ${filePath}`)];
     if (byStatus.blocked.length > 0) {
@@ -99,6 +105,11 @@ function buildTaskBoard(index) {
         fullLines.push("## active sessions");
         fullLines.push(active.map((line) => `- ${line}`).join("\n"));
     }
+    const activeBridges = activeBridgeLines(index.tasks);
+    if (activeBridges.length > 0) {
+        fullLines.push("## active bridges");
+        fullLines.push(activeBridges.map((line) => `- ${line}`).join("\n"));
+    }
     return {
         compact,
         full: fullLines.join("\n\n"),
@@ -106,6 +117,7 @@ function buildTaskBoard(index) {
         actionRequired: actionRequired(index, byStatus),
         unresolvedDependencies: unresolved,
         activeSessions: active,
+        activeBridges,
     };
 }
 function boardStatus(board, status) {

package/dist/repertoire/tasks/index.js

@@ -115,6 +115,12 @@ class FileTaskModule {
             frontmatter.parent_task = null;
             frontmatter.depends_on = [];
         }
+        if (input.activeBridge && input.activeBridge.trim()) {
+            frontmatter.active_bridge = input.activeBridge.trim();
+        }
+        if (Array.isArray(input.bridgeSessions) && input.bridgeSessions.length > 0) {
+            frontmatter.bridge_sessions = input.bridgeSessions.filter((value) => typeof value === "string" && value.trim());
+        }
         const content = (0, parser_1.renderTaskFile)(frontmatter, input.body);
         const validation = (0, middleware_1.validateWrite)(filePath, content);
         if (!validation.ok) {
@@ -125,6 +131,21 @@ class FileTaskModule {
         (0, scanner_1.clearTaskScanCache)();
         return filePath;
     }
+    bindBridge(name, input) {
+        const task = this.getTask(name);
+        if (!task) {
+            return { ok: false, reason: `task not found: ${name}` };
+        }
+        const content = fs.readFileSync(task.path, "utf-8");
+        const parsed = (0, parser_1.parseTaskFile)(content, task.path);
+        const frontmatter = removeRuntimeFrontmatter(parsed.frontmatter);
+        frontmatter.active_bridge = input.bridgeId.trim();
+        frontmatter.bridge_sessions = input.sessionRefs.filter((value) => value.trim().length > 0);
+        frontmatter.updated = formatDate();
+        fs.writeFileSync(task.path, (0, parser_1.renderTaskFile)(frontmatter, parsed.body), "utf-8");
+        (0, scanner_1.clearTaskScanCache)();
+        return { ok: true, path: task.path };
+    }
     updateStatus(name, toStatus) {
         const normalized = (0, transitions_1.normalizeTaskStatus)(toStatus);
         if (!normalized) {

package/dist/repertoire/tools-base.js

@@ -44,6 +44,8 @@ const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
 const socket_client_1 = require("../heart/daemon/socket-client");
 const thoughts_1 = require("../heart/daemon/thoughts");
+const manager_1 = require("../heart/bridges/manager");
+const session_recall_1 = require("../heart/session-recall");
 const tools_1 = require("./coding/tools");
 const memory_1 = require("../mind/memory");
 const pending_1 = require("../mind/pending");
@@ -61,6 +63,16 @@ function buildContextDiff(lines, changeStart, changeEnd, contextSize = 3) {
     }
     return result.join("\n");
 }
+const NO_SESSION_FOUND_MESSAGE = "no session found for that friend/channel/key combination.";
+const EMPTY_SESSION_MESSAGE = "session exists but has no non-system messages.";
+async function recallSessionSafely(options) {
+    try {
+        return await (0, session_recall_1.recallSession)(options);
+    }
+    catch {
+        return { kind: "missing" };
+    }
+}
 exports.baseToolDefinitions = [
     {
         tool: {
@@ -585,6 +597,103 @@ exports.baseToolDefinitions = [
         },
     },
     // -- cross-session awareness --
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "bridge_manage",
+                description: "create and manage shared live-work bridges across already-active sessions.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: {
+                            type: "string",
+                            enum: ["begin", "attach", "status", "promote_task", "complete", "cancel"],
+                        },
+                        bridgeId: { type: "string", description: "bridge id for all actions except begin" },
+                        objective: { type: "string", description: "objective for begin" },
+                        summary: { type: "string", description: "optional concise shared-work summary" },
+                        friendId: { type: "string", description: "target friend id for attach" },
+                        channel: { type: "string", description: "target channel for attach" },
+                        key: { type: "string", description: "target session key for attach (defaults to 'session')" },
+                        title: { type: "string", description: "task title override for promote_task" },
+                        category: { type: "string", description: "task category override for promote_task" },
+                        body: { type: "string", description: "task body override for promote_task" },
+                    },
+                    required: ["action"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const manager = (0, manager_1.createBridgeManager)();
+            const action = (args.action || "").trim();
+            if (action === "begin") {
+                if (!ctx?.currentSession) {
+                    return "bridge_manage begin requires an active session context.";
+                }
+                const objective = (args.objective || "").trim();
+                if (!objective)
+                    return "objective is required for bridge begin.";
+                return (0, manager_1.formatBridgeStatus)(manager.beginBridge({
+                    objective,
+                    summary: (args.summary || objective).trim(),
+                    session: ctx.currentSession,
+                }));
+            }
+            const bridgeId = (args.bridgeId || "").trim();
+            if (!bridgeId) {
+                return "bridgeId is required for this bridge action.";
+            }
+            if (action === "attach") {
+                const friendId = (args.friendId || "").trim();
+                const channel = (args.channel || "").trim();
+                const key = (args.key || "session").trim();
+                if (!friendId || !channel) {
+                    return "friendId and channel are required for bridge attach.";
+                }
+                const sessionPath = (0, config_1.resolveSessionPath)(friendId, channel, key);
+                const recall = await recallSessionSafely({
+                    sessionPath,
+                    friendId,
+                    channel,
+                    key,
+                    messageCount: 20,
+                    trustLevel: ctx?.context?.friend?.trustLevel,
+                    summarize: ctx?.summarize,
+                });
+                if (recall.kind === "missing") {
+                    return NO_SESSION_FOUND_MESSAGE;
+                }
+                return (0, manager_1.formatBridgeStatus)(manager.attachSession(bridgeId, {
+                    friendId,
+                    channel,
+                    key,
+                    sessionPath,
+                    snapshot: recall.kind === "ok" ? recall.snapshot : EMPTY_SESSION_MESSAGE,
+                }));
+            }
+            if (action === "status") {
+                const bridge = manager.getBridge(bridgeId);
+                if (!bridge)
+                    return `bridge not found: ${bridgeId}`;
+                return (0, manager_1.formatBridgeStatus)(bridge);
+            }
+            if (action === "promote_task") {
+                return (0, manager_1.formatBridgeStatus)(manager.promoteBridgeToTask(bridgeId, {
+                    title: args.title,
+                    category: args.category,
+                    body: args.body,
+                }));
+            }
+            if (action === "complete") {
+                return (0, manager_1.formatBridgeStatus)(manager.completeBridge(bridgeId));
+            }
+            if (action === "cancel") {
+                return (0, manager_1.formatBridgeStatus)(manager.cancelBridge(bridgeId));
+            }
+            return `unknown bridge action: ${action}`;
+        },
+    },
     {
         tool: {
             type: "function",
@@ -605,43 +714,36 @@ exports.baseToolDefinitions = [
             },
         },
         handler: async (args, ctx) => {
-            try {
-                const friendId = args.friendId;
-                const channel = args.channel;
-                const key = args.key || "session";
-                const count = parseInt(args.messageCount || "20", 10);
-                const mode = args.mode || "transcript";
-                if (mode === "status") {
-                    if (friendId !== "self" || channel !== "inner") {
-                        return "status mode is only available for self/inner dialog.";
-                    }
-                    const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)((0, identity_1.getAgentRoot)());
-                    const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
-                    return (0, thoughts_1.formatInnerDialogStatus)((0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir));
-                }
-                const sessFile = (0, config_1.resolveSessionPath)(friendId, channel, key);
-                const raw = fs.readFileSync(sessFile, "utf-8");
-                const data = JSON.parse(raw);
-                const messages = (data.messages || [])
-                    .filter((m) => m.role !== "system");
-                const tail = messages.slice(-count);
-                if (tail.length === 0)
-                    return "session exists but has no non-system messages.";
-                const transcript = tail.map((m) => `[${m.role}] ${m.content}`).join("\n");
-                // LLM summarization when summarize function is available
-                if (ctx?.summarize) {
-                    const trustLevel = ctx.context?.friend?.trustLevel ?? "family";
-                    const isSelfQuery = friendId === "self";
-                    const instruction = isSelfQuery
-                        ? "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning."
-                        : `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
-                    return await ctx.summarize(transcript, instruction);
+            const friendId = args.friendId;
+            const channel = args.channel;
+            const key = args.key || "session";
+            const count = parseInt(args.messageCount || "20", 10);
+            const mode = args.mode || "transcript";
+            if (mode === "status") {
+                if (friendId !== "self" || channel !== "inner") {
+                    return "status mode is only available for self/inner dialog.";
                 }
-                return transcript;
+                const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)((0, identity_1.getAgentRoot)());
+                const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
+                return (0, thoughts_1.formatInnerDialogStatus)((0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir));
+            }
+            const sessFile = (0, config_1.resolveSessionPath)(friendId, channel, key);
+            const recall = await recallSessionSafely({
+                sessionPath: sessFile,
+                friendId,
+                channel,
+                key,
+                messageCount: count,
+                trustLevel: ctx?.context?.friend?.trustLevel,
+                summarize: ctx?.summarize,
+            });
+            if (recall.kind === "missing") {
+                return NO_SESSION_FOUND_MESSAGE;
             }
-            catch {
-                return "no session found for that friend/channel/key combination.";
+            if (recall.kind === "empty") {
+                return EMPTY_SESSION_MESSAGE;
             }
+            return recall.summary;
         },
     },
     {

package/dist/repertoire/tools.js

@@ -205,6 +205,8 @@ function summarizeArgs(name, args) {
     if (name === "save_friend_note") {
         return summarizeKeyValues(args, ["type", "key", "content"]);
     }
+    if (name === "bridge_manage")
+        return summarizeKeyValues(args, ["action", "bridgeId", "objective", "friendId", "channel", "key"]);
     if (name === "ado_backlog_list")
         return summarizeKeyValues(args, ["organization", "project"]);
     if (name === "ado_batch_update")

package/dist/senses/bluebubbles.js

@@ -604,6 +604,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
         try {
             const result = await (0, pipeline_1.handleInboundTurn)({
                 channel: "bluebubbles",
+                sessionKey: event.chat.sessionKey,
                 capabilities: bbCapabilities,
                 messages: [userMessage],
                 continuityIngressTexts: getBlueBubblesContinuityIngressTexts(event),

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.48",
+  "version": "0.1.0-alpha.49",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",