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

package/dist/repertoire/tools.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.teamsTools = exports.finalAnswerTool = exports.tools = void 0;
+exports.REMOTE_BLOCKED_LOCAL_TOOLS = exports.teamsTools = exports.finalAnswerTool = exports.tools = void 0;
 exports.getToolsForChannel = getToolsForChannel;
 exports.isConfirmationRequired = isConfirmationRequired;
 exports.execTool = execTool;
@@ -10,6 +10,8 @@ const tools_teams_1 = require("./tools-teams");
 const tools_bluebubbles_1 = require("./tools-bluebubbles");
 const ado_semantic_1 = require("./ado-semantic");
 const tools_github_1 = require("./tools-github");
+const types_1 = require("../mind/friends/types");
+const channel_1 = require("../mind/friends/channel");
 const runtime_1 = require("../nerves/runtime");
 // Re-export types and constants used by the rest of the codebase
 var tools_base_2 = require("./tools-base");
@@ -19,32 +21,25 @@ var tools_teams_2 = require("./tools-teams");
 Object.defineProperty(exports, "teamsTools", { enumerable: true, get: function () { return tools_teams_2.teamsTools; } });
 // All tool definitions in a single registry
 const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_bluebubbles_1.bluebubblesToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
-const REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "edit_file", "glob", "grep"]);
-function isRemoteChannel(capabilities) {
-    return capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
-}
-function isSharedRemoteContext(friend) {
-    const externalIds = friend.externalIds ?? [];
-    return externalIds.some((externalId) => externalId.externalId.startsWith("group:") || externalId.provider === "teams-conversation");
-}
+/** Tool names blocked for untrusted remote contexts. Shared with prompt.ts for restriction messaging. */
+exports.REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "edit_file", "glob", "grep"]);
 function isTrustedRemoteContext(context) {
-    if (!context?.friend || !isRemoteChannel(context.channel))
+    if (!context?.friend || !(0, channel_1.isRemoteChannel)(context.channel))
         return false;
-    const trustLevel = context.friend.trustLevel ?? "stranger";
-    return trustLevel !== "stranger" && !isSharedRemoteContext(context.friend);
+    return (0, types_1.isTrustedLevel)(context.friend.trustLevel);
 }
 function shouldBlockLocalTools(capabilities, context) {
-    if (!isRemoteChannel(capabilities))
+    if (!(0, channel_1.isRemoteChannel)(capabilities))
         return false;
     return !isTrustedRemoteContext(context);
 }
 function blockedLocalToolMessage() {
-    return "I can't do that from here because I'm talking to multiple people in a shared remote channel, and local shell/file/git/gh operations could let conversations interfere with each other. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
+    return "I can't do that because my trust level with you isn't high enough for local shell/file operations. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
 }
 function baseToolsForCapabilities(capabilities, context) {
     if (!shouldBlockLocalTools(capabilities, context))
         return tools_base_1.tools;
-    return tools_base_1.tools.filter((tool) => !REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
+    return tools_base_1.tools.filter((tool) => !exports.REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
 }
 // Apply a single tool preference to a tool schema, returning a new object.
 function applyPreference(tool, pref) {
@@ -113,7 +108,7 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
-    if (shouldBlockLocalTools(ctx?.context?.channel, ctx?.context) && REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
+    if (shouldBlockLocalTools(ctx?.context?.channel, ctx?.context) && exports.REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
         const message = blockedLocalToolMessage();
         (0, runtime_1.emitNervesEvent)({
             level: "warn",

package/dist/senses/bluebubbles-model.js

@@ -52,6 +52,15 @@ function buildChatRef(data, threadOriginatorGuid) {
     const sessionKey = chatGuid?.trim()
         ? `chat:${chatGuid.trim()}`
         : `chat_identifier:${(chatIdentifier ?? "unknown").trim()}`;
+    // Extract participant handles from chat.participants (when available from BB API)
+    const rawParticipants = Array.isArray(chat?.participants) ? chat.participants : [];
+    const participantHandles = rawParticipants
+        .map((p) => {
+        const rec = asRecord(p);
+        const addr = readString(rec, "address") ?? readString(rec, "id");
+        return addr ? normalizeHandle(addr) : "";
+    })
+        .filter(Boolean);
     return {
         chatGuid: chatGuid?.trim() || undefined,
         chatIdentifier: chatIdentifier?.trim() || undefined,
@@ -61,6 +70,7 @@ function buildChatRef(data, threadOriginatorGuid) {
         sendTarget: chatGuid?.trim()
             ? { kind: "chat_guid", value: chatGuid.trim() }
             : { kind: "chat_identifier", value: (chatIdentifier ?? "unknown").trim() },
+        participantHandles,
     };
 }
 function extractSender(data, chat) {

package/dist/senses/bluebubbles.js

@@ -47,6 +47,9 @@ const context_1 = require("../mind/context");
 const tokens_1 = require("../mind/friends/tokens");
 const resolver_1 = require("../mind/friends/resolver");
 const store_file_1 = require("../mind/friends/store-file");
+const types_1 = require("../mind/friends/types");
+const channel_1 = require("../mind/friends/channel");
+const pending_1 = require("../mind/pending");
 const prompt_1 = require("../mind/prompt");
 const phrases_1 = require("../mind/phrases");
 const runtime_1 = require("../nerves/runtime");
@@ -55,6 +58,8 @@ const bluebubbles_client_1 = require("./bluebubbles-client");
 const bluebubbles_mutation_log_1 = require("./bluebubbles-mutation-log");
 const bluebubbles_session_cleanup_1 = require("./bluebubbles-session-cleanup");
 const debug_activity_1 = require("./debug-activity");
+const trust_gate_1 = require("./trust-gate");
+const pipeline_1 = require("./pipeline");
 const defaultDeps = {
     getAgentName: identity_1.getAgentName,
     buildSystem: prompt_1.buildSystem,
@@ -86,6 +91,47 @@ function resolveFriendParams(event) {
         channel: "bluebubbles",
     };
 }
+/**
+ * Check if any participant in a group chat is a known family member.
+ * Looks up each participant handle in the friend store.
+ */
+async function checkGroupHasFamilyMember(store, event) {
+    if (!event.chat.isGroup)
+        return false;
+    for (const handle of event.chat.participantHandles ?? []) {
+        const friend = await store.findByExternalId("imessage-handle", handle);
+        if (friend?.trustLevel === "family")
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if an acquaintance shares any group chat with a family member.
+ * Compares group-prefixed externalIds between the acquaintance and all family members.
+ */
+async function checkHasExistingGroupWithFamily(store, senderFriend) {
+    const trustLevel = senderFriend.trustLevel ?? "friend";
+    if (trustLevel !== "acquaintance")
+        return false;
+    const acquaintanceGroups = new Set((senderFriend.externalIds ?? [])
+        .filter((eid) => eid.externalId.startsWith("group:"))
+        .map((eid) => eid.externalId));
+    if (acquaintanceGroups.size === 0)
+        return false;
+    const allFriends = await (store.listAll?.() ?? Promise.resolve([]));
+    for (const friend of allFriends) {
+        if (friend.trustLevel !== "family")
+            continue;
+        const friendGroups = (friend.externalIds ?? [])
+            .filter((eid) => eid.externalId.startsWith("group:"))
+            .map((eid) => eid.externalId);
+        for (const group of friendGroups) {
+            if (acquaintanceGroups.has(group))
+                return true;
+        }
+    }
+    return false;
+}
 function extractMessageText(content) {
     if (typeof content === "string")
         return content;
@@ -414,28 +460,12 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
         });
         return { handled: true, notifiedAgent: false, kind: event.kind, reason: "mutation_state_only" };
     }
+    // ── Adapter setup: friend, session, content, callbacks ──────────
     const store = resolvedDeps.createFriendStore();
     const resolver = resolvedDeps.createFriendResolver(store, resolveFriendParams(event));
-    const context = await resolver.resolve();
+    const baseContext = await resolver.resolve();
+    const context = { ...baseContext, isGroupChat: event.chat.isGroup };
     const replyTarget = createReplyTargetController(event);
-    const toolContext = {
-        signin: async () => undefined,
-        friendStore: store,
-        summarize: (0, core_1.createSummarize)(),
-        context,
-        bluebubblesReplyTarget: {
-            setSelection: (selection) => replyTarget.setSelection(selection),
-        },
-        codingFeedback: {
-            send: async (message) => {
-                await client.sendText({
-                    chat: event.chat,
-                    text: message,
-                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                });
-            },
-        },
-    };
     const friendId = context.friend.id;
     const sessPath = resolvedDeps.sessionPath(friendId, "bluebubbles", event.chat.sessionKey);
     try {
@@ -453,21 +483,87 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
             },
         });
     }
+    // Pre-load session (adapter needs existing messages for lane history in content building)
     const existing = resolvedDeps.loadSession(sessPath);
-    const messages = existing?.messages && existing.messages.length > 0
+    const sessionMessages = existing?.messages && existing.messages.length > 0
         ? existing.messages
         : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", undefined, context) }];
-    messages.push({ role: "user", content: buildInboundContent(event, existing?.messages ?? messages) });
+    // Build inbound user message (adapter concern: BB-specific content formatting)
+    const userMessage = {
+        role: "user",
+        content: buildInboundContent(event, existing?.messages ?? sessionMessages),
+    };
     const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget);
     const controller = new AbortController();
-    const agentOptions = {
-        toolContext,
-    };
+    // BB-specific tool context wrappers
+    const summarize = (0, core_1.createSummarize)();
+    const bbCapabilities = (0, channel_1.getChannelCapabilities)("bluebubbles");
+    const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
+    // ── Compute trust gate context for group/acquaintance rules ─────
+    const groupHasFamilyMember = await checkGroupHasFamilyMember(store, event);
+    const hasExistingGroupWithFamily = event.chat.isGroup
+        ? false
+        : await checkHasExistingGroupWithFamily(store, context.friend);
+    // ── Call shared pipeline ──────────────────────────────────────────
     try {
-        const result = await resolvedDeps.runAgent(messages, callbacks, "bluebubbles", controller.signal, agentOptions);
+        const result = await (0, pipeline_1.handleInboundTurn)({
+            channel: "bluebubbles",
+            capabilities: bbCapabilities,
+            messages: [userMessage],
+            callbacks,
+            friendResolver: { resolve: () => Promise.resolve(context) },
+            sessionLoader: { loadOrCreate: () => Promise.resolve({ messages: sessionMessages, sessionPath: sessPath }) },
+            pendingDir,
+            friendStore: store,
+            provider: "imessage-handle",
+            externalId: event.sender.externalId || event.sender.rawId,
+            isGroupChat: event.chat.isGroup,
+            groupHasFamilyMember,
+            hasExistingGroupWithFamily,
+            enforceTrustGate: trust_gate_1.enforceTrustGate,
+            drainPending: pending_1.drainPending,
+            runAgent: (msgs, cb, channel, sig, opts) => resolvedDeps.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,
+                    bluebubblesReplyTarget: {
+                        setSelection: (selection) => replyTarget.setSelection(selection),
+                    },
+                    codingFeedback: {
+                        send: async (message) => {
+                            await client.sendText({
+                                chat: event.chat,
+                                text: message,
+                                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
+                            });
+                        },
+                    },
+                },
+            }),
+            postTurn: resolvedDeps.postTurn,
+            accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
+            signal: controller.signal,
+        });
+        // ── Handle gate result ────────────────────────────────────────
+        if (!result.gateResult.allowed) {
+            // Send auto-reply via BB API if the gate provides one
+            if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
+                await client.sendText({
+                    chat: event.chat,
+                    text: result.gateResult.autoReply,
+                });
+            }
+            return {
+                handled: true,
+                notifiedAgent: false,
+                kind: event.kind,
+            };
+        }
+        // Gate allowed — flush the agent's reply
         await callbacks.flush();
-        resolvedDeps.postTurn(messages, sessPath, result.usage);
-        await resolvedDeps.accumulateFriendTokens(store, friendId, result.usage);
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.bluebubbles_turn_end",
@@ -543,7 +639,6 @@ function createBlueBubblesWebhookHandler(deps = {}) {
         }
     };
 }
-const PROACTIVE_SEND_ALLOWED_TRUST = new Set(["family", "friend"]);
 function findImessageHandle(friend) {
     for (const ext of friend.externalIds) {
         if (ext.provider === "imessage-handle" && !ext.externalId.startsWith("group:")) {
@@ -644,7 +739,7 @@ async function drainAndSendPendingBlueBubbles(deps = {}, pendingRoot) {
             });
             continue;
         }
-        if (!PROACTIVE_SEND_ALLOWED_TRUST.has(friend.trustLevel ?? "stranger")) {
+        if (!types_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
             result.skipped++;
             try {
                 fs.unlinkSync(filePath);
@@ -679,6 +774,7 @@ async function drainAndSendPendingBlueBubbles(deps = {}, pendingRoot) {
             isGroup: false,
             sessionKey: friendId,
             sendTarget: { kind: "chat_identifier", value: handle },
+            participantHandles: [],
         };
         try {
             await client.sendText({ chat, text: messageText });

package/dist/senses/cli.js

@@ -52,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");
@@ -62,6 +61,8 @@ 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");
@@ -620,21 +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`);
-            const prefix = options.getContentPrefix?.();
-            messages.push({ role: "user", content: prefix ? `${prefix}\n\n${input}` : 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
@@ -698,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, {
@@ -730,52 +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: format as content-prefix for next user message
+    // 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");
-    let pendingPrefix;
-    const drainToPrefix = () => {
-        const pending = (0, pending_1.drainPending)(pendingDir);
-        if (pending.length === 0)
-            return 0;
-        pendingPrefix = formatPendingPrefix(pending, (0, identity_1.getAgentName)());
-        return pending.length;
-    };
-    // Startup drain: collect offline messages as prefix for next user message
-    const startupCount = drainToPrefix();
-    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 };
-            },
-            getContentPrefix: () => {
-                const prefix = pendingPrefix;
-                pendingPrefix = undefined;
-                return prefix;
-            },
-            onTurnEnd: async (msgs, result) => {
-                (0, context_1.postTurn)(msgs, sessPath, result.usage);
-                await (0, tokens_1.accumulateFriendTokens)(friendStore, resolvedContext.friend.id, result.usage);
-                drainToPrefix();
-                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

@@ -49,6 +49,10 @@ 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 = [
@@ -148,77 +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)("inner", { 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 });
-    }
-    const pendingMessages = (0, pending_1.drainPending)((0, pending_1.getPendingDir)((0, identity_1.getAgentName)(), "self", "inner", "dialog"));
-    if (pendingMessages.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 = pendingMessages
-                .map((msg) => `- **${msg.from}**: ${msg.content}`)
-                .join("\n");
-            messages[lastUserIdx] = {
-                ...lastUser,
-                content: `${lastUser.content}\n\n## pending messages\n${section}`,
-            };
-        }
+        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, "inner", 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",
@@ -226,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,
     };
 }