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

package/dist/heart/bridges/manager.js

@@ -0,0 +1,358 @@
+"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 sessionMatches(left, right) {
+    return left.friendId === right.friendId && left.channel === right.channel && left.key === right.key;
+}
+function hasAttachedSessionActivity(bridge, sessionActivity) {
+    return sessionActivity.some((activity) => activity.channel !== "inner"
+        && bridge.attachedSessions.some((session) => sessionMatches(activity, session)));
+}
+function hasLiveTaskStatus(bridge, taskBoard) {
+    const taskName = bridge.task?.taskName;
+    if (!taskName)
+        return false;
+    return (taskBoard.byStatus.processing.includes(taskName)
+        || taskBoard.byStatus.collaborating.includes(taskName)
+        || taskBoard.byStatus.validating.includes(taskName));
+}
+function isCurrentSessionAttached(bridge, currentSession) {
+    if (!currentSession)
+        return false;
+    return bridge.attachedSessions.some((session) => sessionMatches(session, currentSession));
+}
+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");
+        },
+        reconcileLifecycles(input) {
+            return store.list().map((bridge) => {
+                const nextState = (0, state_machine_1.reconcileBridgeState)(bridge, {
+                    hasAttachedSessionActivity: hasAttachedSessionActivity(bridge, input.sessionActivity),
+                    hasLiveTask: hasLiveTaskStatus(bridge, input.taskBoard),
+                    currentSessionAttached: isCurrentSessionAttached(bridge, input.currentSession),
+                });
+                if (nextState.lifecycle === bridge.lifecycle && nextState.runtime === bridge.runtime) {
+                    return bridge;
+                }
+                return save({
+                    ...bridge,
+                    ...nextState,
+                    updatedAt: now(),
+                });
+            });
+        },
+        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,135 @@
+"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;
+exports.reconcileBridgeState = reconcileBridgeState;
+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");
+}
+function reconcileBridgeState(state, input) {
+    if (state.lifecycle === "completed" || state.lifecycle === "cancelled") {
+        return state;
+    }
+    if (state.runtime !== "idle") {
+        return state;
+    }
+    const hasLiveSignal = input.hasAttachedSessionActivity || input.hasLiveTask || input.currentSessionAttached;
+    if (state.lifecycle === "suspended") {
+        return hasLiveSignal ? activateBridge(state) : state;
+    }
+    if (state.lifecycle === "forming") {
+        return hasLiveSignal ? activateBridge(state) : suspendBridge(state);
+    }
+    if (state.lifecycle === "active") {
+        return hasLiveSignal ? state : suspendBridge(state);
+    }
+    return state;
+}

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;
+        },
+    };
+}