@ouro.bot/cli 0.1.0-alpha.37 → 0.1.0-alpha.39

package/dist/senses/cli.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MarkdownStreamer = exports.InputController = exports.Spinner = void 0;
+exports.formatPendingPrefix = formatPendingPrefix;
 exports.handleSigint = handleSigint;
 exports.addHistory = addHistory;
 exports.renderMarkdown = renderMarkdown;
@@ -51,7 +52,6 @@ const format_1 = require("../mind/format");
 const config_1 = require("../heart/config");
 const context_1 = require("../mind/context");
 const pending_1 = require("../mind/pending");
-const prompt_refresh_1 = require("../mind/prompt-refresh");
 const commands_1 = require("./commands");
 const identity_1 = require("../heart/identity");
 const nerves_1 = require("../nerves");
@@ -61,10 +61,25 @@ const tokens_1 = require("../mind/friends/tokens");
 const cli_logging_1 = require("../nerves/cli-logging");
 const runtime_1 = require("../nerves/runtime");
 const trust_gate_1 = require("./trust-gate");
+const pipeline_1 = require("./pipeline");
+const channel_1 = require("../mind/friends/channel");
 const session_lock_1 = require("./session-lock");
 const update_hooks_1 = require("../heart/daemon/update-hooks");
 const bundle_meta_1 = require("../heart/daemon/hooks/bundle-meta");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
+/**
+ * Format pending messages as content-prefix strings for injection into
+ * the next user message. Self-messages (from === agentName) become
+ * `[inner thought: {content}]`, inter-agent messages become
+ * `[message from {name}: {content}]`.
+ */
+function formatPendingPrefix(messages, agentName) {
+    return messages
+        .map((msg) => msg.from === agentName
+        ? `[inner thought: ${msg.content}]`
+        : `[message from ${msg.from}: ${msg.content}]`)
+        .join("\n");
+}
 // spinner that only touches stderr, cleans up after itself
 // exported for direct testability (stop-without-start branch)
 class Spinner {
@@ -606,20 +621,29 @@ async function runCliSession(options) {
                 echoRows += Math.ceil((2 + line.length) / cols);
             }
             process.stdout.write(`\x1b[${echoRows}A\x1b[K` + `\x1b[1m> ${inputLines[0]}${inputLines.length > 1 ? ` (+${inputLines.length - 1} lines)` : ""}\x1b[0m\n\n`);
-            messages.push({ role: "user", content: input });
             addHistory(history, input);
             currentAbort = new AbortController();
-            const traceId = (0, nerves_1.createTraceId)();
             ctrl.suppress(() => currentAbort.abort());
             let result;
             try {
-                result = await (0, core_1.runAgent)(messages, cliCallbacks, options.skipSystemPromptRefresh ? undefined : "cli", currentAbort.signal, {
-                    toolChoiceRequired: getEffectiveToolChoiceRequired(),
-                    traceId,
-                    tools: options.tools,
-                    execTool: wrappedExecTool,
-                    toolContext: options.toolContext,
-                });
+                if (options.runTurn) {
+                    // Pipeline-based turn: the runTurn callback handles user message assembly,
+                    // pending drain, trust gate, runAgent, postTurn, and token accumulation.
+                    result = await options.runTurn(messages, input, cliCallbacks, currentAbort.signal);
+                }
+                else {
+                    // Legacy path: inline runAgent (used by adoption specialist and tests)
+                    const prefix = options.getContentPrefix?.();
+                    messages.push({ role: "user", content: prefix ? `${prefix}\n\n${input}` : input });
+                    const traceId = (0, nerves_1.createTraceId)();
+                    result = await (0, core_1.runAgent)(messages, cliCallbacks, options.skipSystemPromptRefresh ? undefined : "cli", currentAbort.signal, {
+                        toolChoiceRequired: getEffectiveToolChoiceRequired(),
+                        traceId,
+                        tools: options.tools,
+                        execTool: wrappedExecTool,
+                        toolContext: options.toolContext,
+                    });
+                }
             }
             catch (err) {
                 // AbortError (Ctrl-C) -- silently return to prompt
@@ -683,13 +707,6 @@ async function main(agentName, options) {
         channel: "cli",
     });
     const resolvedContext = await resolver.resolve();
-    const cliToolContext = {
-        /* v8 ignore next -- CLI has no OAuth sign-in; this no-op satisfies the interface @preserve */
-        signin: async () => undefined,
-        context: resolvedContext,
-        friendStore,
-        summarize: (0, core_1.createSummarize)(),
-    };
     const friendId = resolvedContext.friend.id;
     const agentConfig = (0, identity_1.loadAgentConfig)();
     (0, cli_logging_1.configureCliRuntimeLogger)(friendId, {
@@ -715,49 +732,55 @@ async function main(agentName, options) {
     const sessionMessages = existing?.messages && existing.messages.length > 0
         ? existing.messages
         : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", undefined, resolvedContext) }];
-    // Pending queue drain: inject pending messages as harness-context + assistant-content pairs
+    // Per-turn pipeline input: CLI capabilities and pending dir
+    const cliCapabilities = (0, channel_1.getChannelCapabilities)("cli");
     const pendingDir = (0, pending_1.getPendingDir)((0, identity_1.getAgentName)(), friendId, "cli", "session");
-    const drainToMessages = () => {
-        const pending = (0, pending_1.drainPending)(pendingDir);
-        if (pending.length === 0)
-            return 0;
-        for (const msg of pending) {
-            sessionMessages.push({ role: "user", name: "harness", content: `[proactive message from ${msg.from}]` });
-            sessionMessages.push({ role: "assistant", content: msg.content });
-        }
-        return pending.length;
-    };
-    // Startup drain: deliver offline messages
-    const startupCount = drainToMessages();
-    if (startupCount > 0) {
-        (0, context_1.saveSession)(sessPath, sessionMessages);
-    }
+    const summarize = (0, core_1.createSummarize)();
     try {
         await runCliSession({
             agentName: (0, identity_1.getAgentName)(),
             pasteDebounceMs,
             messages: sessionMessages,
-            toolContext: cliToolContext,
-            onInput: () => {
-                const trustGate = (0, trust_gate_1.enforceTrustGate)({
-                    friend: resolvedContext.friend,
+            runTurn: async (messages, userInput, callbacks, signal) => {
+                // Run the full per-turn pipeline: resolve -> gate -> session -> drain -> runAgent -> postTurn -> tokens
+                // User message passed via input.messages so the pipeline can prepend pending messages to it.
+                const result = await (0, pipeline_1.handleInboundTurn)({
+                    channel: "cli",
+                    capabilities: cliCapabilities,
+                    messages: [{ role: "user", content: userInput }],
+                    callbacks,
+                    friendResolver: { resolve: () => Promise.resolve(resolvedContext) },
+                    sessionLoader: { loadOrCreate: () => Promise.resolve({ messages, sessionPath: sessPath }) },
+                    pendingDir,
+                    friendStore,
                     provider: "local",
                     externalId: localExternalId,
-                    channel: "cli",
+                    enforceTrustGate: trust_gate_1.enforceTrustGate,
+                    drainPending: pending_1.drainPending,
+                    runAgent: (msgs, cb, channel, sig, opts) => (0, core_1.runAgent)(msgs, cb, channel, sig, {
+                        ...opts,
+                        toolContext: {
+                            /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                            signin: async () => undefined,
+                            ...opts?.toolContext,
+                            summarize,
+                        },
+                    }),
+                    postTurn: context_1.postTurn,
+                    accumulateFriendTokens: tokens_1.accumulateFriendTokens,
+                    signal,
+                    runAgentOptions: {
+                        toolChoiceRequired: (0, commands_1.getToolChoiceRequired)(),
+                        traceId: (0, nerves_1.createTraceId)(),
+                    },
                 });
-                if (!trustGate.allowed) {
-                    return {
-                        allowed: false,
-                        reply: trustGate.reason === "stranger_first_reply" ? trustGate.autoReply : undefined,
-                    };
+                // Handle gate rejection: display auto-reply if present
+                if (!result.gateResult.allowed) {
+                    if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
+                        process.stdout.write(`${result.gateResult.autoReply}\n`);
+                    }
                 }
-                return { allowed: true };
-            },
-            onTurnEnd: async (msgs, result) => {
-                (0, context_1.postTurn)(msgs, sessPath, result.usage);
-                await (0, tokens_1.accumulateFriendTokens)(friendStore, resolvedContext.friend.id, result.usage);
-                drainToMessages();
-                await (0, prompt_refresh_1.refreshSystemPrompt)(msgs, "cli", undefined, resolvedContext);
+                return { usage: result.usage };
             },
             onNewSession: () => {
                 (0, context_1.deleteSession)(sessPath);

package/dist/senses/inner-dialog.js

@@ -48,12 +48,17 @@ const identity_1 = require("../heart/identity");
 const context_1 = require("../mind/context");
 const prompt_1 = require("../mind/prompt");
 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 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,
     },
 ];
@@ -68,19 +73,8 @@ function readAspirations(agentRoot) {
 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");
+function buildInnerDialogBootstrapMessage(_aspirations, _stateSummary) {
+    return "waking up. settling in.\n\nwhat needs my attention?";
 }
 function buildNonCanonicalCleanupNudge(nonCanonicalPaths) {
     if (nonCanonicalPaths.length === 0)
@@ -95,17 +89,14 @@ 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 contentToText(content) {
     if (typeof content === "string")
@@ -161,62 +152,116 @@ 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);
+}
+// 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 {
+        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 loaded = (0, context_1.loadSession)(sessionFilePath);
-    const messages = loaded?.messages ? [...loaded.messages] : [];
+    const existingMessages = 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 });
+    // ── 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);
-        const bootstrapMessage = [
+        userContent = [
             buildInnerDialogBootstrapMessage(aspirations, "No prior inner dialog session found."),
             cleanupNudge,
         ].filter(Boolean).join("\n\n");
-        messages.push({ role: "user", content: bootstrapMessage });
     }
     else {
-        const assistantTurns = messages.filter((message) => message.role === "assistant").length;
+        // Resumed session: instinct message with checkpoint context
+        const assistantTurns = existingMessages.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 });
+        state.checkpoint = deriveResumeCheckpoint(existingMessages);
+        userContent = buildInstinctUserMessage(instincts, reason, state);
     }
+    // ── Adapter concern: inbox drain (inner-dialog-specific) ─────────
     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}`,
-            };
-        }
+        const section = inboxMessages
+            .map((msg) => `- **${msg.from}**: ${msg.content}`)
+            .join("\n");
+        userContent = `${userContent}\n\n## incoming messages\n${section}`;
     }
+    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)((0, identity_1.getAgentName)());
+    const selfFriend = createSelfFriend((0, identity_1.getAgentName)());
+    const selfContext = { friend: selfFriend, channel: innerCapabilities };
+    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 });
+            return {
+                messages: [{ role: "system", content: systemPrompt }],
+                sessionPath: sessionFilePath,
+            };
+        },
+    };
+    // ── Call shared pipeline ──────────────────────────────────────────
     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 result = await (0, pipeline_1.handleInboundTurn)({
+        channel: "inner",
+        capabilities: innerCapabilities,
+        messages: [userMessage],
+        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,
+        },
     });
-    (0, context_1.postTurn)(messages, sessionFilePath, result.usage);
     (0, runtime_1.emitNervesEvent)({
         component: "senses",
         event: "senses.inner_dialog_turn",
@@ -224,8 +269,8 @@ async function runInnerDialogTurn(options) {
         meta: { reason, session: sessionFilePath },
     });
     return {
-        messages,
+        messages: result.messages ?? [],
         usage: result.usage,
-        sessionPath: sessionFilePath,
+        sessionPath: result.sessionPath ?? sessionFilePath,
     };
 }

package/dist/senses/pipeline.js

@@ -0,0 +1,124 @@
+"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");
+// ── 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;
+    // Step 4: Drain pending messages
+    const pending = input.drainPending(input.pendingDir);
+    // 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,
+        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,
+        },
+    };
+    const result = await input.runAgent(sessionMessages, input.callbacks, input.channel, input.signal, runAgentOptions);
+    // Step 6: postTurn
+    input.postTurn(sessionMessages, session.sessionPath, result.usage);
+    // 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,
+        sessionPath: session.sessionPath,
+        messages: sessionMessages,
+    };
+}