@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.100

package/dist/senses/pipeline.js

@@ -0,0 +1,307 @@
+"use strict";
+// Shared per-turn pipeline for all senses.
+// Senses are thin transport adapters; this module owns the common lifecycle:
+//   resolve friend -> trust gate -> load session -> drain pending -> runAgent -> postTurn -> token accumulation.
+//
+// Transport-level concerns (BB API calls, Teams cards, readline) stay in sense adapters.
+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");
+const identity_1 = require("../heart/identity");
+const tasks_1 = require("../repertoire/tasks");
+const session_activity_1 = require("../heart/session-activity");
+const active_work_1 = require("../heart/active-work");
+const delegation_1 = require("../heart/delegation");
+const target_resolution_1 = require("../heart/target-resolution");
+const thoughts_1 = require("../heart/daemon/thoughts");
+const pending_1 = require("../mind/pending");
+const obligations_1 = require("../heart/obligations");
+function emptyTaskBoard() {
+    return {
+        compact: "",
+        full: "",
+        byStatus: {
+            drafting: [],
+            processing: [],
+            validating: [],
+            collaborating: [],
+            paused: [],
+            blocked: [],
+            done: [],
+        },
+        actionRequired: [],
+        unresolvedDependencies: [],
+        activeSessions: [],
+        activeBridges: [],
+    };
+}
+function readInnerWorkState() {
+    const defaultJob = {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
+        const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+        const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
+        const dialogStatus = (0, thoughts_1.deriveInnerDialogStatus)(pendingMessages, turns, runtimeState);
+        const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
+        // Derive obligationPending from both the pending message field and the obligation store
+        const storeObligationPending = (0, obligations_1.readPendingObligations)(agentRoot).length > 0;
+        return {
+            status: dialogStatus.processing === "started" ? "running" : "idle",
+            hasPending: dialogStatus.queue !== "clear",
+            origin: dialogStatus.origin,
+            contentSnippet: dialogStatus.contentSnippet,
+            obligationPending: dialogStatus.obligationPending || storeObligationPending,
+            job,
+        };
+    }
+    catch {
+        return {
+            status: "idle",
+            hasPending: false,
+            job: defaultJob,
+        };
+    }
+}
+// ── Pipeline ──────────────────────────────────────────────────────
+async function handleInboundTurn(input) {
+    // Step 1: Resolve friend
+    const resolvedContext = await input.friendResolver.resolve();
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.pipeline_start",
+        message: "inbound turn pipeline started",
+        meta: {
+            channel: input.channel,
+            friendId: resolvedContext.friend.id,
+            senseType: input.capabilities.senseType,
+        },
+    });
+    // Step 2: Trust gate
+    const gateInput = {
+        friend: resolvedContext.friend,
+        provider: input.provider ?? "local",
+        externalId: input.externalId ?? "",
+        tenantId: input.tenantId,
+        channel: input.channel,
+        senseType: input.capabilities.senseType,
+        isGroupChat: input.isGroupChat ?? false,
+        groupHasFamilyMember: input.groupHasFamilyMember ?? false,
+        hasExistingGroupWithFamily: input.hasExistingGroupWithFamily ?? false,
+    };
+    const gateResult = input.enforceTrustGate(gateInput);
+    // Gate rejection: return early, no agent turn
+    if (!gateResult.allowed) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.pipeline_gate_reject",
+            message: "trust gate rejected inbound turn",
+            meta: {
+                channel: input.channel,
+                friendId: resolvedContext.friend.id,
+                reason: gateResult.reason,
+            },
+        });
+        return {
+            resolvedContext,
+            gateResult,
+        };
+    }
+    // Step 3: Load/create session
+    const session = await input.sessionLoader.loadOrCreate();
+    const sessionMessages = session.messages;
+    let mustResolveBeforeHandoff = (0, continuity_1.resolveMustResolveBeforeHandoff)(session.state?.mustResolveBeforeHandoff === true, input.continuityIngressTexts);
+    const lastFriendActivityAt = input.channel === "inner"
+        ? session.state?.lastFriendActivityAt
+        : new Date().toISOString();
+    const currentObligation = input.continuityIngressTexts
+        ?.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;
+    let sessionActivity = [];
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        sessionActivity = (0, session_activity_1.listSessionActivity)({
+            sessionsDir: `${agentRoot}/state/sessions`,
+            friendsDir: `${agentRoot}/friends`,
+            agentName: (0, identity_1.getAgentName)(),
+            currentSession: {
+                friendId: currentSession.friendId,
+                channel: currentSession.channel,
+                key: currentSession.key,
+            },
+        });
+    }
+    catch {
+        sessionActivity = [];
+    }
+    let targetCandidates = [];
+    try {
+        if (input.channel !== "inner") {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            targetCandidates = await (0, target_resolution_1.listTargetSessionCandidates)({
+                sessionsDir: `${agentRoot}/state/sessions`,
+                friendsDir: `${agentRoot}/friends`,
+                agentName: (0, identity_1.getAgentName)(),
+                currentSession: {
+                    friendId: currentSession.friendId,
+                    channel: currentSession.channel,
+                    key: currentSession.key,
+                },
+                friendStore: input.friendStore,
+            });
+        }
+    }
+    catch {
+        targetCandidates = [];
+    }
+    let pendingObligations = [];
+    try {
+        pendingObligations = (0, obligations_1.readPendingObligations)((0, identity_1.getAgentRoot)());
+    }
+    catch {
+        pendingObligations = [];
+    }
+    const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
+        currentSession,
+        currentObligation,
+        mustResolveBeforeHandoff,
+        inner: readInnerWorkState(),
+        bridges: activeBridges,
+        pendingObligations,
+        taskBoard: (() => {
+            try {
+                return (0, tasks_1.getTaskModule)().getBoard();
+            }
+            catch {
+                return emptyTaskBoard();
+            }
+        })(),
+        friendActivity: sessionActivity,
+        targetCandidates,
+    });
+    const delegationDecision = (0, delegation_1.decideDelegation)({
+        channel: input.channel,
+        ingressTexts: input.continuityIngressTexts ?? [],
+        activeWork: activeWorkFrame,
+        mustResolveBeforeHandoff,
+    });
+    // Step 4: Drain deferred friend returns, then ordinary per-session pending.
+    const deferredReturns = input.channel === "inner"
+        ? []
+        : (input.drainDeferredReturns?.(resolvedContext.friend.id) ?? []);
+    const sessionPending = input.drainPending(input.pendingDir);
+    const pending = [...deferredReturns, ...sessionPending];
+    // Assemble messages: session messages + pending (formatted) + inbound user messages
+    if (pending.length > 0) {
+        // Format pending messages and prepend to the user content
+        const pendingSection = pending
+            .map((msg) => `[pending from ${msg.from}]: ${msg.content}`)
+            .join("\n");
+        // If there are inbound user messages, prepend pending to the first one
+        if (input.messages.length > 0) {
+            const firstMsg = input.messages[0];
+            if (firstMsg.role === "user") {
+                if (typeof firstMsg.content === "string") {
+                    input.messages[0] = {
+                        ...firstMsg,
+                        content: `## pending messages\n${pendingSection}\n\n${firstMsg.content}`,
+                    };
+                }
+                else {
+                    input.messages[0] = {
+                        ...firstMsg,
+                        content: [
+                            { type: "text", text: `## pending messages\n${pendingSection}\n\n` },
+                            ...firstMsg.content,
+                        ],
+                    };
+                }
+            }
+        }
+    }
+    // Append user messages from the inbound turn
+    for (const msg of input.messages) {
+        sessionMessages.push(msg);
+    }
+    // Step 5: runAgent
+    const existingToolContext = input.runAgentOptions?.toolContext;
+    const runAgentOptions = {
+        ...input.runAgentOptions,
+        bridgeContext,
+        activeWorkFrame,
+        delegationDecision,
+        currentSessionKey: currentSession.key,
+        currentObligation,
+        mustResolveBeforeHandoff,
+        setMustResolveBeforeHandoff: (value) => {
+            mustResolveBeforeHandoff = value;
+        },
+        toolContext: {
+            /* v8 ignore next -- default no-op signin satisfies interface; real signin injected by sense adapter @preserve */
+            signin: async () => undefined,
+            ...existingToolContext,
+            context: resolvedContext,
+            friendStore: input.friendStore,
+            currentSession,
+            activeBridges,
+        },
+    };
+    const result = await input.runAgent(sessionMessages, input.callbacks, input.channel, input.signal, runAgentOptions);
+    // Step 6: postTurn
+    const continuingState = {
+        ...(mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
+        ...(typeof lastFriendActivityAt === "string" ? { lastFriendActivityAt } : {}),
+    };
+    const nextState = result.outcome === "complete" || result.outcome === "blocked" || result.outcome === "superseded" || result.outcome === "no_response"
+        ? (typeof lastFriendActivityAt === "string"
+            ? { lastFriendActivityAt }
+            : undefined)
+        : (Object.keys(continuingState).length > 0 ? continuingState : undefined);
+    input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, nextState);
+    // Step 7: Token accumulation
+    await input.accumulateFriendTokens(input.friendStore, resolvedContext.friend.id, result.usage);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.pipeline_end",
+        message: "inbound turn pipeline completed",
+        meta: {
+            channel: input.channel,
+            friendId: resolvedContext.friend.id,
+        },
+    });
+    return {
+        resolvedContext,
+        gateResult,
+        usage: result.usage,
+        turnOutcome: result.outcome,
+        completion: result.completion,
+        sessionPath: session.sessionPath,
+        messages: sessionMessages,
+        drainedPending: pending,
+    };
+}

package/dist/senses/session-lock.js

@@ -0,0 +1,119 @@
+"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.SessionLockError = void 0;
+exports.acquireSessionLock = acquireSessionLock;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+class SessionLockError extends Error {
+    agentName;
+    constructor(agentName) {
+        super(`already chatting with ${agentName} in another terminal`);
+        this.name = "SessionLockError";
+        this.agentName = agentName;
+    }
+}
+exports.SessionLockError = SessionLockError;
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const defaultDeps = {
+    writeFileSync: (p, d, o) => fs.writeFileSync(p, d, o),
+    readFileSync: (p, e) => fs.readFileSync(p, e),
+    unlinkSync: (p) => fs.unlinkSync(p),
+    pid: process.pid,
+    isProcessAlive: defaultIsProcessAlive,
+};
+function acquireSessionLock(lockPath, agentName, deps = defaultDeps) {
+    const tryWrite = () => {
+        try {
+            deps.writeFileSync(lockPath, String(deps.pid), { flag: "wx" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (!tryWrite()) {
+        // Lock file exists — check if stale
+        let existingPid;
+        try {
+            existingPid = parseInt(deps.readFileSync(lockPath, "utf-8").trim(), 10);
+        }
+        catch {
+            // Can't read lock file — try removing and retrying
+            try {
+                deps.unlinkSync(lockPath);
+            }
+            catch { /* ignore */ }
+            if (!tryWrite())
+                throw new SessionLockError(agentName);
+            return makeRelease(lockPath, deps);
+        }
+        if (Number.isNaN(existingPid) || !deps.isProcessAlive(existingPid)) {
+            // Stale lock — remove and retry
+            try {
+                deps.unlinkSync(lockPath);
+            }
+            catch { /* ignore */ }
+            if (!tryWrite())
+                throw new SessionLockError(agentName);
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.session_lock_stolen", message: "stole stale session lock from dead process", meta: { agentName, existingPid } });
+            return makeRelease(lockPath, deps);
+        }
+        throw new SessionLockError(agentName);
+    }
+    return makeRelease(lockPath, deps);
+}
+function makeRelease(lockPath, deps) {
+    let released = false;
+    return {
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            try {
+                deps.unlinkSync(lockPath);
+            }
+            catch { /* ignore */ }
+        },
+    };
+}