@ouro.bot/cli 0.1.0-alpha.4 → 0.1.0-alpha.40

package/dist/senses/debug-activity.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDebugActivityController = createDebugActivityController;
+const format_1 = require("../mind/format");
+const phrases_1 = require("../mind/phrases");
+const runtime_1 = require("../nerves/runtime");
+function createDebugActivityController(options) {
+    let queue = Promise.resolve();
+    let statusMessageGuid;
+    let typingActive = false;
+    let hadToolRun = false;
+    let followupShown = false;
+    let lastPhrase = "";
+    function reportTransportError(operation, error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.debug_activity_transport_error",
+            message: "debug activity transport failed",
+            meta: {
+                operation,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        options.onTransportError?.(operation, error);
+    }
+    function enqueue(operation, task) {
+        queue = queue
+            .then(task)
+            .catch((error) => {
+            reportTransportError(operation, error);
+        });
+    }
+    function nextPhrase(pool) {
+        const phrase = (0, phrases_1.pickPhrase)(pool, lastPhrase);
+        lastPhrase = phrase;
+        return phrase;
+    }
+    function startTypingNow() {
+        if (typingActive) {
+            return;
+        }
+        typingActive = true;
+        enqueue("typing_start", async () => {
+            await options.transport.setTyping(true);
+        });
+    }
+    function setStatus(text) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.debug_activity_update",
+            message: "debug activity status updated",
+            meta: {
+                hasStatusGuid: Boolean(statusMessageGuid),
+                textLength: text.length,
+            },
+        });
+        const shouldStartTyping = !typingActive;
+        if (shouldStartTyping) {
+            typingActive = true;
+        }
+        enqueue("status_update", async () => {
+            if (statusMessageGuid) {
+                await options.transport.editStatus(statusMessageGuid, text);
+            }
+            else {
+                statusMessageGuid = await options.transport.sendStatus(text);
+            }
+            if (shouldStartTyping) {
+                await options.transport.setTyping(true);
+            }
+        });
+    }
+    return {
+        onModelStart() {
+            const pool = hadToolRun ? options.followupPhrases : options.thinkingPhrases;
+            if (options.startTypingOnModelStart) {
+                startTypingNow();
+            }
+            if (options.suppressInitialModelStatus && !statusMessageGuid && !hadToolRun) {
+                nextPhrase(pool);
+                return;
+            }
+            setStatus(`${nextPhrase(pool)}...`);
+        },
+        onToolStart(name, args) {
+            hadToolRun = true;
+            followupShown = false;
+            const argSummary = Object.values(args).join(", ");
+            const detail = argSummary ? ` (${argSummary})` : "";
+            setStatus(`running ${name}${detail}...`);
+        },
+        onToolEnd(name, summary, success) {
+            hadToolRun = true;
+            followupShown = false;
+            setStatus((0, format_1.formatToolResult)(name, summary, success));
+        },
+        onTextChunk(text) {
+            if (!text || !hadToolRun || followupShown) {
+                return;
+            }
+            followupShown = true;
+            if (options.suppressFollowupPhraseStatus) {
+                return;
+            }
+            setStatus(`${nextPhrase(options.followupPhrases)}...`);
+        },
+        onError(error) {
+            setStatus((0, format_1.formatError)(error));
+            this.finish();
+        },
+        async drain() {
+            await queue;
+        },
+        async finish() {
+            if (!typingActive) {
+                await queue;
+                return;
+            }
+            typingActive = false;
+            enqueue("typing_stop", async () => {
+                await options.transport.setTyping(false);
+            });
+            await queue;
+        },
+    };
+}

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