@ouro.bot/cli 0.1.0-alpha.8 → 0.1.0-alpha.80

package/dist/senses/inner-dialog.js

@@ -37,8 +37,11 @@ exports.loadInnerDialogInstincts = loadInnerDialogInstincts;
 exports.buildInnerDialogBootstrapMessage = buildInnerDialogBootstrapMessage;
 exports.buildNonCanonicalCleanupNudge = buildNonCanonicalCleanupNudge;
 exports.buildInstinctUserMessage = buildInstinctUserMessage;
+exports.readTaskFile = readTaskFile;
+exports.buildTaskTriggeredMessage = buildTaskTriggeredMessage;
 exports.deriveResumeCheckpoint = deriveResumeCheckpoint;
 exports.innerDialogSessionPath = innerDialogSessionPath;
+exports.enrichDelegatedFromWithBridge = enrichDelegatedFromWithBridge;
 exports.runInnerDialogTurn = runInnerDialogTurn;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -47,13 +50,23 @@ const core_1 = require("../heart/core");
 const identity_1 = require("../heart/identity");
 const context_1 = require("../mind/context");
 const prompt_1 = require("../mind/prompt");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
+const pending_1 = require("../mind/pending");
+const channel_1 = require("../mind/friends/channel");
+const trust_gate_1 = require("./trust-gate");
+const tokens_1 = require("../mind/friends/tokens");
+const pipeline_1 = require("./pipeline");
 const nerves_1 = require("../nerves");
 const runtime_1 = require("../nerves/runtime");
+const manager_1 = require("../heart/bridges/manager");
+const session_activity_1 = require("../heart/session-activity");
+const bluebubbles_1 = require("./bluebubbles");
+const obligations_1 = require("../heart/obligations");
 const DEFAULT_INNER_DIALOG_INSTINCTS = [
     {
         id: "heartbeat_checkin",
-        prompt: "Heartbeat instinct: check what changed, review priorities, and decide whether to keep resting or act.",
+        prompt: "...time passing. anything stirring?",
         enabled: true,
     },
 ];
@@ -69,18 +82,15 @@ function loadInnerDialogInstincts() {
     return [...DEFAULT_INNER_DIALOG_INSTINCTS];
 }
 function buildInnerDialogBootstrapMessage(aspirations, stateSummary) {
-    const aspirationText = aspirations || "No explicit aspirations file found. Reflect and define what matters next.";
-    return [
-        "Inner dialog boot.",
-        "",
-        "## aspirations",
-        aspirationText,
-        "",
-        "## current state",
-        stateSummary,
-        "",
-        "Orient yourself, decide what to do next, and make meaningful progress.",
-    ].join("\n");
+    const lines = ["waking up."];
+    if (aspirations) {
+        lines.push("", "## what matters to me", aspirations);
+    }
+    if (stateSummary) {
+        lines.push("", "## what i know so far", stateSummary);
+    }
+    lines.push("", "what needs my attention?");
+    return lines.join("\n");
 }
 function buildNonCanonicalCleanupNudge(nonCanonicalPaths) {
     if (nonCanonicalPaths.length === 0)
@@ -95,17 +105,41 @@ function buildNonCanonicalCleanupNudge(nonCanonicalPaths) {
         ...listed,
     ].join("\n");
 }
-function buildInstinctUserMessage(instincts, reason, state) {
+function buildInstinctUserMessage(instincts, _reason, state) {
     const active = instincts.find((instinct) => instinct.enabled !== false) ?? DEFAULT_INNER_DIALOG_INSTINCTS[0];
-    const checkpoint = state.checkpoint?.trim() || "no prior checkpoint recorded";
-    return [
-        active.prompt,
-        `reason: ${reason}`,
-        `cycle: ${state.cycleCount}`,
-        `resting: ${state.resting ? "yes" : "no"}`,
-        `checkpoint: ${checkpoint}`,
-        "resume_instruction: continue from the checkpoint if still valid; otherwise revise and proceed.",
-    ].join("\n");
+    const checkpoint = state.checkpoint?.trim();
+    const lines = [active.prompt];
+    if (checkpoint) {
+        lines.push(`\nlast i remember: ${checkpoint}`);
+    }
+    return lines.join("\n");
+}
+function readTaskFile(agentRoot, taskId) {
+    // Task files live in collection subdirectories (one-shots, ongoing, habits).
+    // Try each collection, then fall back to root tasks/ for legacy layout.
+    const collections = ["one-shots", "ongoing", "habits", ""];
+    for (const collection of collections) {
+        try {
+            return fs.readFileSync(path.join(agentRoot, "tasks", collection, `${taskId}.md`), "utf8").trim();
+        }
+        catch {
+            // not in this collection — try next
+        }
+    }
+    return "";
+}
+function buildTaskTriggeredMessage(taskId, taskContent, checkpoint) {
+    const lines = ["a task needs my attention."];
+    if (taskContent) {
+        lines.push("", `## task: ${taskId}`, taskContent);
+    }
+    else {
+        lines.push("", `## task: ${taskId}`, "(task file not found)");
+    }
+    if (checkpoint) {
+        lines.push("", `last i remember: ${checkpoint}`);
+    }
+    return lines.join("\n");
 }
 function contentToText(content) {
     if (typeof content === "string")
@@ -144,11 +178,39 @@ function deriveResumeCheckpoint(messages) {
     const firstLine = assistantText
         .split("\n")
         .map((line) => line.trim())
-        .filter((line) => line.length > 0)[0];
+        .find((line) => line.length > 0);
+    /* v8 ignore next -- unreachable: contentToText().trim() guarantees a non-empty line @preserve */
+    if (!firstLine)
+        return "no prior checkpoint recorded";
     if (firstLine.length <= 220)
         return firstLine;
     return `${firstLine.slice(0, 217)}...`;
 }
+function extractAssistantPreview(messages, maxLength = 120) {
+    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+    if (!lastAssistant)
+        return "";
+    const text = contentToText(lastAssistant.content);
+    if (!text)
+        return "";
+    /* v8 ignore next -- unreachable: contentToText().trim() guarantees a non-empty line @preserve */
+    const firstLine = text.split("\n").find((line) => line.trim().length > 0) ?? "";
+    if (firstLine.length <= maxLength)
+        return firstLine;
+    return `${firstLine.slice(0, maxLength - 3)}...`;
+}
+function extractToolCallNames(messages) {
+    const names = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && "tool_calls" in msg && Array.isArray(msg.tool_calls)) {
+            for (const tc of msg.tool_calls) {
+                if ("function" in tc && tc.function?.name)
+                    names.push(tc.function.name);
+            }
+        }
+    }
+    return [...new Set(names)];
+}
 function createInnerDialogCallbacks() {
     return {
         onModelStart: () => { },
@@ -161,71 +223,303 @@ function createInnerDialogCallbacks() {
     };
 }
 function innerDialogSessionPath() {
-    return (0, config_1.sessionPath)("self", "inner", "dialog");
+    return (0, config_1.sessionPath)(pending_1.INNER_DIALOG_PENDING.friendId, pending_1.INNER_DIALOG_PENDING.channel, pending_1.INNER_DIALOG_PENDING.key);
 }
-async function runInnerDialogTurn(options) {
-    const now = options?.now ?? (() => new Date());
-    const reason = options?.reason ?? "heartbeat";
-    const sessionFilePath = innerDialogSessionPath();
-    const loaded = (0, context_1.loadSession)(sessionFilePath);
-    const messages = loaded?.messages ? [...loaded.messages] : [];
-    const instincts = options?.instincts ?? loadInnerDialogInstincts();
-    const state = {
-        cycleCount: 1,
-        resting: false,
-        lastHeartbeatAt: now().toISOString(),
-    };
-    if (messages.length === 0) {
-        const systemPrompt = await (0, prompt_1.buildSystem)("cli", { toolChoiceRequired: true });
-        messages.push({ role: "system", content: systemPrompt });
-        const aspirations = readAspirations((0, identity_1.getAgentRoot)());
-        const nonCanonical = (0, bundle_manifest_1.findNonCanonicalBundlePaths)((0, identity_1.getAgentRoot)());
-        const cleanupNudge = buildNonCanonicalCleanupNudge(nonCanonical);
-        const bootstrapMessage = [
-            buildInnerDialogBootstrapMessage(aspirations, "No prior inner dialog session found."),
-            cleanupNudge,
-        ].filter(Boolean).join("\n\n");
-        messages.push({ role: "user", content: bootstrapMessage });
+function innerDialogRuntimeStatePath(sessionFilePath) {
+    return path.join(path.dirname(sessionFilePath), "runtime.json");
+}
+function writeInnerDialogRuntimeState(sessionFilePath, state) {
+    const filePath = innerDialogRuntimeStatePath(sessionFilePath);
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + "\n", "utf8");
     }
-    else {
-        const assistantTurns = messages.filter((message) => message.role === "assistant").length;
-        state.cycleCount = assistantTurns + 1;
-        state.checkpoint = deriveResumeCheckpoint(messages);
-        const instinctPrompt = buildInstinctUserMessage(instincts, reason, state);
-        messages.push({ role: "user", content: instinctPrompt });
-    }
-    const inboxMessages = options?.drainInbox?.() ?? [];
-    if (inboxMessages.length > 0) {
-        const lastUserIdx = messages.length - 1;
-        const lastUser = messages[lastUserIdx];
-        /* v8 ignore next -- defensive: all code paths push a user message before here @preserve */
-        if (lastUser?.role === "user" && typeof lastUser.content === "string") {
-            const section = inboxMessages
-                .map((msg) => `- **${msg.from}**: ${msg.content}`)
-                .join("\n");
-            messages[lastUserIdx] = {
-                ...lastUser,
-                content: `${lastUser.content}\n\n## incoming messages\n${section}`,
-            };
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.inner_dialog_runtime_state_error",
+            message: "failed to write inner dialog runtime state",
+            meta: {
+                status: state.status,
+                reason: state.reason ?? null,
+                path: filePath,
+                /* v8 ignore next -- Node fs APIs throw Error objects for mkdirSync/writeFileSync failures @preserve */
+                error: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+function writePendingEnvelope(pendingDir, message) {
+    fs.mkdirSync(pendingDir, { recursive: true });
+    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
+    const filePath = path.join(pendingDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify(message, null, 2), "utf8");
+}
+function sessionMatchesActivity(activity, session) {
+    return activity.friendId === session.friendId
+        && activity.channel === session.channel
+        && activity.key === session.key;
+}
+function resolveBridgePreferredSession(delegatedFrom, sessionActivity) {
+    if (!delegatedFrom.bridgeId)
+        return null;
+    const bridge = (0, manager_1.createBridgeManager)().getBridge(delegatedFrom.bridgeId);
+    if (!bridge || bridge.lifecycle === "completed" || bridge.lifecycle === "cancelled") {
+        return null;
+    }
+    return sessionActivity.find((activity) => activity.friendId === delegatedFrom.friendId
+        && activity.channel !== "inner"
+        && bridge.attachedSessions.some((session) => sessionMatchesActivity(activity, session))) ?? null;
+}
+async function tryDeliverDelegatedCompletion(target, outboundEnvelope) {
+    if (target.channel !== "bluebubbles") {
+        return false;
+    }
+    const result = await (0, bluebubbles_1.sendProactiveBlueBubblesMessageToSession)({
+        friendId: target.friendId,
+        sessionKey: target.key,
+        text: outboundEnvelope.content,
+    });
+    return result.delivered;
+}
+function enrichDelegatedFromWithBridge(delegatedFrom) {
+    if (delegatedFrom.bridgeId) {
+        return delegatedFrom;
+    }
+    const bridgeManager = (0, manager_1.createBridgeManager)();
+    const originBridges = bridgeManager.findBridgesForSession({
+        friendId: delegatedFrom.friendId,
+        channel: delegatedFrom.channel,
+        key: delegatedFrom.key,
+    });
+    const activeBridge = originBridges.find((b) => b.lifecycle === "active");
+    if (activeBridge) {
+        return { ...delegatedFrom, bridgeId: activeBridge.id };
+    }
+    return delegatedFrom;
+}
+async function routeDelegatedCompletion(agentRoot, agentName, completion, drainedPending, timestamp) {
+    const delegated = (drainedPending ?? []).find((message) => message.delegatedFrom);
+    if (!delegated?.delegatedFrom || !completion?.answer?.trim()) {
+        return;
+    }
+    const delegatedFrom = enrichDelegatedFromWithBridge(delegated.delegatedFrom);
+    if (delegated.obligationStatus === "pending") {
+        // Fulfill the persistent obligation in the store
+        try {
+            const pending = (0, obligations_1.findPendingObligationForOrigin)(agentRoot, {
+                friendId: delegatedFrom.friendId,
+                channel: delegatedFrom.channel,
+                key: delegatedFrom.key,
+            });
+            /* v8 ignore next 2 -- obligation fulfillment tested via obligations.test.ts; integration requires real disk state @preserve */
+            if (pending) {
+                (0, obligations_1.fulfillObligation)(agentRoot, pending.id);
+            }
+        }
+        catch {
+            /* v8 ignore next -- defensive: obligation store read failure should not break delivery @preserve */
         }
+        (0, runtime_1.emitNervesEvent)({
+            event: "senses.obligation_fulfilled",
+            component: "senses",
+            message: "obligation fulfilled via delegated completion",
+            meta: {
+                friendId: delegatedFrom.friendId,
+                channel: delegatedFrom.channel,
+                key: delegatedFrom.key,
+            },
+        });
     }
-    const callbacks = createInnerDialogCallbacks();
-    const traceId = (0, nerves_1.createTraceId)();
-    const result = await (0, core_1.runAgent)(messages, callbacks, "cli", options?.signal, {
-        traceId,
-        toolChoiceRequired: true,
-        skipConfirmation: true,
+    const outboundEnvelope = {
+        from: agentName,
+        friendId: delegatedFrom.friendId,
+        channel: delegatedFrom.channel,
+        key: delegatedFrom.key,
+        content: completion.answer.trim(),
+        timestamp,
+        delegatedFrom,
+    };
+    const sessionActivity = (0, session_activity_1.listSessionActivity)({
+        sessionsDir: path.join(agentRoot, "state", "sessions"),
+        friendsDir: path.join(agentRoot, "friends"),
+        agentName,
     });
-    (0, context_1.postTurn)(messages, sessionFilePath, result.usage);
-    (0, runtime_1.emitNervesEvent)({
-        component: "senses",
-        event: "senses.inner_dialog_turn",
-        message: "inner dialog turn completed",
-        meta: { reason, session: sessionFilePath },
+    const bridgeTarget = resolveBridgePreferredSession(delegatedFrom, sessionActivity);
+    if (bridgeTarget) {
+        if (await tryDeliverDelegatedCompletion(bridgeTarget, outboundEnvelope)) {
+            return;
+        }
+        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, bridgeTarget.friendId, bridgeTarget.channel, bridgeTarget.key), outboundEnvelope);
+        return;
+    }
+    const freshest = (0, session_activity_1.findFreshestFriendSession)({
+        sessionsDir: path.join(agentRoot, "state", "sessions"),
+        friendsDir: path.join(agentRoot, "friends"),
+        agentName,
+        friendId: delegatedFrom.friendId,
+        activeOnly: true,
     });
+    if (freshest && freshest.channel !== "inner") {
+        if (await tryDeliverDelegatedCompletion(freshest, outboundEnvelope)) {
+            return;
+        }
+        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, freshest.friendId, freshest.channel, freshest.key), outboundEnvelope);
+        return;
+    }
+    writePendingEnvelope((0, pending_1.getDeferredReturnDir)(agentName, delegatedFrom.friendId), outboundEnvelope);
+}
+// Self-referencing friend record for inner dialog (agent talking to itself).
+// No real friend to resolve -- this satisfies the pipeline's friend resolver contract.
+function createSelfFriend(agentName) {
     return {
-        messages,
-        usage: result.usage,
-        sessionPath: sessionFilePath,
+        id: "self",
+        name: agentName,
+        trustLevel: "family",
+        externalIds: [],
+        tenantMemberships: [],
+        toolPreferences: {},
+        notes: {},
+        totalTokens: 0,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        schemaVersion: 1,
     };
 }
+// No-op friend store for inner dialog. Inner dialog doesn't track token usage per-friend.
+function createNoOpFriendStore() {
+    return {
+        get: async () => null,
+        put: async () => { },
+        delete: async () => { },
+        findByExternalId: async () => null,
+    };
+}
+async function runInnerDialogTurn(options) {
+    const now = options?.now ?? (() => new Date());
+    const reason = options?.reason ?? "heartbeat";
+    const sessionFilePath = innerDialogSessionPath();
+    const agentName = (0, identity_1.getAgentName)();
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    writeInnerDialogRuntimeState(sessionFilePath, {
+        status: "running",
+        reason,
+        startedAt: now().toISOString(),
+    });
+    try {
+        const loaded = (0, context_1.loadSession)(sessionFilePath);
+        const existingMessages = loaded?.messages ? [...loaded.messages] : [];
+        const instincts = options?.instincts ?? loadInnerDialogInstincts();
+        const state = {
+            cycleCount: 1,
+            resting: false,
+            lastHeartbeatAt: now().toISOString(),
+        };
+        // ── Adapter concern: build user message ──────────────────────────
+        let userContent;
+        if (existingMessages.length === 0) {
+            // Fresh session: bootstrap message with non-canonical cleanup nudge
+            const aspirations = readAspirations((0, identity_1.getAgentRoot)());
+            const nonCanonical = (0, bundle_manifest_1.findNonCanonicalBundlePaths)((0, identity_1.getAgentRoot)());
+            const cleanupNudge = buildNonCanonicalCleanupNudge(nonCanonical);
+            userContent = [
+                buildInnerDialogBootstrapMessage(aspirations, "No prior inner dialog session found."),
+                cleanupNudge,
+            ].filter(Boolean).join("\n\n");
+        }
+        else {
+            // Resumed session: task-triggered or instinct message with checkpoint context
+            const assistantTurns = existingMessages.filter((message) => message.role === "assistant").length;
+            state.cycleCount = assistantTurns + 1;
+            state.checkpoint = deriveResumeCheckpoint(existingMessages);
+            if (options?.taskId) {
+                const taskContent = readTaskFile((0, identity_1.getAgentRoot)(), options.taskId);
+                userContent = buildTaskTriggeredMessage(options.taskId, taskContent, state.checkpoint);
+            }
+            else {
+                userContent = buildInstinctUserMessage(instincts, reason, state);
+            }
+        }
+        const userMessage = { role: "user", content: userContent };
+        // ── Session loader: wraps existing session logic ──────────────────
+        const innerCapabilities = (0, channel_1.getChannelCapabilities)("inner");
+        const pendingDir = (0, pending_1.getInnerDialogPendingDir)(agentName);
+        const selfFriend = createSelfFriend(agentName);
+        const selfContext = { friend: selfFriend, channel: innerCapabilities };
+        const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
+        const sessionLoader = {
+            loadOrCreate: async () => {
+                if (existingMessages.length > 0) {
+                    return { messages: existingMessages, sessionPath: sessionFilePath };
+                }
+                // Fresh session: build system prompt
+                const systemPrompt = await (0, prompt_1.buildSystem)("inner", { toolChoiceRequired: true, mcpManager });
+                return {
+                    messages: [{ role: "system", content: systemPrompt }],
+                    sessionPath: sessionFilePath,
+                };
+            },
+        };
+        // ── Call shared pipeline ──────────────────────────────────────────
+        const callbacks = createInnerDialogCallbacks();
+        const traceId = (0, nerves_1.createTraceId)();
+        const result = await (0, pipeline_1.handleInboundTurn)({
+            channel: "inner",
+            sessionKey: "dialog",
+            capabilities: innerCapabilities,
+            messages: [userMessage],
+            continuityIngressTexts: [],
+            callbacks,
+            friendResolver: { resolve: () => Promise.resolve(selfContext) },
+            sessionLoader,
+            pendingDir,
+            friendStore: createNoOpFriendStore(),
+            enforceTrustGate: trust_gate_1.enforceTrustGate,
+            drainPending: pending_1.drainPending,
+            runAgent: core_1.runAgent,
+            postTurn: context_1.postTurn,
+            accumulateFriendTokens: tokens_1.accumulateFriendTokens,
+            signal: options?.signal,
+            runAgentOptions: {
+                traceId,
+                toolChoiceRequired: true,
+                skipConfirmation: true,
+                mcpManager,
+            },
+        });
+        await routeDelegatedCompletion(agentRoot, agentName, result.completion, result.drainedPending, now().getTime());
+        const resultMessages = result.messages ?? [];
+        const assistantPreview = extractAssistantPreview(resultMessages);
+        const toolCalls = extractToolCallNames(resultMessages);
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.inner_dialog_turn",
+            message: "inner dialog turn completed",
+            meta: {
+                reason,
+                session: sessionFilePath,
+                ...(options?.taskId && { taskId: options.taskId }),
+                ...(assistantPreview && { assistantPreview }),
+                ...(toolCalls.length > 0 && { toolCalls }),
+                ...(result.usage && {
+                    promptTokens: result.usage.input_tokens,
+                    completionTokens: result.usage.output_tokens,
+                    totalTokens: result.usage.total_tokens,
+                }),
+            },
+        });
+        return {
+            messages: resultMessages,
+            usage: result.usage,
+            sessionPath: result.sessionPath ?? sessionFilePath,
+            completion: result.completion,
+        };
+    }
+    finally {
+        writeInnerDialogRuntimeState(sessionFilePath, {
+            status: "idle",
+            lastCompletedAt: now().toISOString(),
+        });
+    }
+}