@ouro.bot/cli 0.1.0-alpha.45 → 0.1.0-alpha.47

package/changelog.json

@@ -1,6 +1,28 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.47",
+      "changes": [
+        "Self-messages now wake inner dialog now/soon instead of only queueing: the harness requests a daemon-managed inner wake when available and falls back to an inline inner turn when it is not.",
+        "`send_message(friendId=self)` and `query_session(friendId=self, channel=inner, mode=status)` now share a truthful four-line status contract: `queue`, `wake`, `processing`, and `surfaced`.",
+        "Inner dialog persists live runtime activity beside the transcript, so status checks can report active processing instead of stale last-turn history.",
+        "Inline fallback surfaced previews now extract `final_answer` text too, so completed inner turns no longer show `no outward result` when the response lived in the final tool call."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.46",
+      "changes": [
+        "Inner dialog now knows which task triggered it: taskId flows from daemon poke through the worker into the turn, and the agent gets the full task file content instead of a generic heartbeat prompt.",
+        "Inner dialog boot message includes aspirations and state summary instead of a vacuous placeholder, so the agent wakes up with context about what matters and what's happening.",
+        "Vestigial `drainInbox` removed from inner dialog — pipeline already handles pending drain correctly.",
+        "Inner dialog nerves events now include assistant response preview, tool call names, token usage, and taskId for meaningful observability.",
+        "`ouro thoughts` command reads and formats inner dialog session turns with `--last`, `--json`, `--follow`, and `--agent` flags — humans can now see what the agent has been thinking.",
+        "`readTaskFile` searches collection subdirectories (one-shots, ongoing, habits) since the scheduler sends bare task stems without collection prefixes.",
+        "`ouro reminder create` accepts `--requester` to track who requested a reminder for notification round-trip.",
+        "Response extraction handles `tool_choice=required` models by falling back to `final_answer` tool call arguments when assistant message content is empty."
+      ]
+    },
     {
       "version": "0.1.0-alpha.45",
       "changes": [

package/dist/heart/daemon/daemon-cli.js

@@ -41,7 +41,6 @@ exports.runOuroCli = runOuroCli;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
 const fs = __importStar(require("fs"));
-const net = __importStar(require("net"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
@@ -62,8 +61,10 @@ const update_hooks_1 = require("./update-hooks");
 const bundle_meta_1 = require("./hooks/bundle-meta");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const tasks_1 = require("../../repertoire/tasks");
+const thoughts_1 = require("./thoughts");
 const ouro_bot_global_installer_1 = require("./ouro-bot-global-installer");
 const launchd_1 = require("./launchd");
+const socket_client_1 = require("./socket-client");
 function stringField(value) {
     return typeof value === "string" ? value : null;
 }
@@ -258,6 +259,7 @@ function usage() {
         "  ouro friend list [--agent <name>]",
         "  ouro friend show <id> [--agent <name>]",
         "  ouro friend create --name <name> [--trust <level>] [--agent <name>]",
+        "  ouro thoughts [--last <n>] [--json] [--follow] [--agent <name>]",
         "  ouro friend link <agent> --friend <id> --provider <p> --external-id <eid>",
         "  ouro friend unlink <agent> --friend <id> --provider <p> --external-id <eid>",
         "  ouro whoami [--agent <name>]",
@@ -520,6 +522,7 @@ function parseReminderCommand(args) {
         let scheduledAt;
         let cadence;
         let category;
+        let requester;
         for (let i = 1; i < rest.length; i++) {
             if (rest[i] === "--body" && rest[i + 1]) {
                 body = rest[i + 1];
@@ -537,6 +540,10 @@ function parseReminderCommand(args) {
                 category = rest[i + 1];
                 i += 1;
             }
+            else if (rest[i] === "--requester" && rest[i + 1]) {
+                requester = rest[i + 1];
+                i += 1;
+            }
         }
         if (!body)
             throw new Error(`Usage\n${usage()}`);
@@ -549,6 +556,7 @@ function parseReminderCommand(args) {
             ...(scheduledAt ? { scheduledAt } : {}),
             ...(cadence ? { cadence } : {}),
             ...(category ? { category } : {}),
+            ...(requester ? { requester } : {}),
             ...(agent ? { agent } : {}),
         };
     }
@@ -563,6 +571,23 @@ function parseSessionCommand(args) {
         return { kind: "session.list", ...(agent ? { agent } : {}) };
     throw new Error(`Usage\n${usage()}`);
 }
+function parseThoughtsCommand(args) {
+    const { agent, rest: cleaned } = extractAgentFlag(args);
+    let last;
+    let json = false;
+    let follow = false;
+    for (let i = 0; i < cleaned.length; i++) {
+        if (cleaned[i] === "--last" && i + 1 < cleaned.length) {
+            last = Number.parseInt(cleaned[i + 1], 10);
+            i++;
+        }
+        if (cleaned[i] === "--json")
+            json = true;
+        if (cleaned[i] === "--follow" || cleaned[i] === "-f")
+            follow = true;
+    }
+    return { kind: "thoughts", ...(agent ? { agent } : {}), ...(last ? { last } : {}), ...(json ? { json } : {}), ...(follow ? { follow } : {}) };
+}
 function parseFriendCommand(args) {
     const { agent, rest: cleaned } = extractAgentFlag(args);
     const [sub, ...rest] = cleaned;
@@ -630,6 +655,8 @@ function parseOuroCommand(args) {
     }
     if (head === "session")
         return parseSessionCommand(args.slice(1));
+    if (head === "thoughts")
+        return parseThoughtsCommand(args.slice(1));
     if (head === "chat") {
         if (!second)
             throw new Error(`Usage\n${usage()}`);
@@ -643,38 +670,6 @@ function parseOuroCommand(args) {
         return parseLinkCommand(args.slice(1));
     throw new Error(`Unknown command '${args.join(" ")}'.\n${usage()}`);
 }
-function defaultSendCommand(socketPath, command) {
-    return new Promise((resolve, reject) => {
-        const client = net.createConnection(socketPath);
-        let raw = "";
-        client.on("connect", () => {
-            client.write(JSON.stringify(command));
-            client.end();
-        });
-        client.on("data", (chunk) => {
-            raw += chunk.toString("utf-8");
-        });
-        client.on("error", reject);
-        client.on("end", () => {
-            const trimmed = raw.trim();
-            if (trimmed.length === 0 && command.kind === "daemon.stop") {
-                resolve({ ok: true, message: "daemon stopped" });
-                return;
-            }
-            if (trimmed.length === 0) {
-                reject(new Error("Daemon returned empty response."));
-                return;
-            }
-            try {
-                const parsed = JSON.parse(trimmed);
-                resolve(parsed);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    });
-}
 function defaultStartDaemonProcess(socketPath) {
     const entry = path.join((0, identity_1.getRepoRoot)(), "dist", "heart", "daemon", "daemon-entry.js");
     const child = (0, child_process_1.spawn)("node", [entry, "--socket", socketPath], {
@@ -688,46 +683,6 @@ function defaultWriteStdout(text) {
     // eslint-disable-next-line no-console -- terminal UX: CLI command output
     console.log(text);
 }
-function defaultCheckSocketAlive(socketPath) {
-    return new Promise((resolve) => {
-        const client = net.createConnection(socketPath);
-        let raw = "";
-        let done = false;
-        const finalize = (alive) => {
-            if (done)
-                return;
-            done = true;
-            resolve(alive);
-        };
-        if ("setTimeout" in client && typeof client.setTimeout === "function") {
-            client.setTimeout(800, () => {
-                client.destroy();
-                finalize(false);
-            });
-        }
-        client.on("connect", () => {
-            client.write(JSON.stringify({ kind: "daemon.status" }));
-            client.end();
-        });
-        client.on("data", (chunk) => {
-            raw += chunk.toString("utf-8");
-        });
-        client.on("error", () => finalize(false));
-        client.on("end", () => {
-            if (raw.trim().length === 0) {
-                finalize(false);
-                return;
-            }
-            try {
-                JSON.parse(raw);
-                finalize(true);
-            }
-            catch {
-                finalize(false);
-            }
-        });
-    });
-}
 function defaultCleanupStaleSocket(socketPath) {
     if (fs.existsSync(socketPath)) {
         fs.unlinkSync(socketPath);
@@ -1048,13 +1003,13 @@ async function defaultRunAdoptionSpecialist() {
     }
 }
 /* v8 ignore stop */
-function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
+function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SOCKET_PATH) {
     return {
         socketPath,
-        sendCommand: defaultSendCommand,
+        sendCommand: socket_client_1.sendDaemonCommand,
         startDaemonProcess: defaultStartDaemonProcess,
         writeStdout: defaultWriteStdout,
-        checkSocketAlive: defaultCheckSocketAlive,
+        checkSocketAlive: socket_client_1.checkDaemonSocketAlive,
         cleanupStaleSocket: defaultCleanupStaleSocket,
         fallbackPendingMessage: defaultFallbackPendingMessage,
         installSubagents: defaultInstallSubagents,
@@ -1338,6 +1293,7 @@ function executeReminderCommand(command, taskMod) {
             body: command.body,
             scheduledAt: command.scheduledAt,
             cadence: command.cadence,
+            requester: command.requester,
         });
         return `created: ${created}`;
     }
@@ -1536,6 +1492,49 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         }
         /* v8 ignore stop */
     }
+    // ── thoughts (local, no daemon socket needed) ──
+    if (command.kind === "thoughts") {
+        try {
+            const agentName = command.agent ?? (0, identity_1.getAgentName)();
+            const agentRoot = path.join((0, identity_1.getAgentBundlesRoot)(), `${agentName}.ouro`);
+            const sessionFilePath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+            if (command.json) {
+                try {
+                    const raw = fs.readFileSync(sessionFilePath, "utf-8");
+                    deps.writeStdout(raw);
+                    return raw;
+                }
+                catch {
+                    const message = "no inner dialog session found";
+                    deps.writeStdout(message);
+                    return message;
+                }
+            }
+            const turns = (0, thoughts_1.parseInnerDialogSession)(sessionFilePath);
+            const message = (0, thoughts_1.formatThoughtTurns)(turns, command.last ?? 10);
+            deps.writeStdout(message);
+            if (command.follow) {
+                deps.writeStdout("\n\n--- following (ctrl+c to stop) ---\n");
+                /* v8 ignore start -- callback tested via followThoughts unit tests @preserve */
+                const stop = (0, thoughts_1.followThoughts)(sessionFilePath, (formatted) => {
+                    deps.writeStdout("\n" + formatted);
+                });
+                /* v8 ignore stop */
+                // Block until process exit; cleanup watcher on SIGINT/SIGTERM
+                return new Promise((resolve) => {
+                    const cleanup = () => { stop(); resolve(message); };
+                    process.once("SIGINT", cleanup);
+                    process.once("SIGTERM", cleanup);
+                });
+            }
+            return message;
+        }
+        catch {
+            const message = "error: no agent context — use --agent <name> to specify";
+            deps.writeStdout(message);
+            return message;
+        }
+    }
     // ── session list (local, no daemon socket needed) ──
     if (command.kind === "session.list") {
         /* v8 ignore start -- production default: requires full identity setup @preserve */

package/dist/heart/daemon/daemon.js

@@ -443,6 +443,13 @@ class OuroDaemon {
                     data: messages,
                 };
             }
+            case "inner.wake":
+                await this.processManager.startAgent(command.agent);
+                this.processManager.sendToAgent?.(command.agent, { type: "message" });
+                return {
+                    ok: true,
+                    message: `woke inner dialog for ${command.agent}`,
+                };
             case "chat.connect":
                 await this.processManager.startAgent(command.agent);
                 return {

package/dist/heart/daemon/socket-client.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DAEMON_SOCKET_PATH = void 0;
+exports.sendDaemonCommand = sendDaemonCommand;
+exports.checkDaemonSocketAlive = checkDaemonSocketAlive;
+exports.requestInnerWake = requestInnerWake;
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const runtime_1 = require("../../nerves/runtime");
+exports.DEFAULT_DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
+function sendDaemonCommand(socketPath, command) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.socket_command_start",
+        message: "sending daemon command over socket",
+        meta: { socketPath, kind: command.kind },
+    });
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        let raw = "";
+        client.on("connect", () => {
+            client.write(JSON.stringify(command));
+            client.end();
+        });
+        client.on("data", (chunk) => {
+            raw += chunk.toString("utf-8");
+        });
+        client.on("error", (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.socket_command_error",
+                message: "daemon socket command failed",
+                meta: {
+                    socketPath,
+                    kind: command.kind,
+                    error: error.message,
+                },
+            });
+            reject(error);
+        });
+        client.on("end", () => {
+            const trimmed = raw.trim();
+            if (trimmed.length === 0 && command.kind === "daemon.stop") {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.socket_command_end",
+                    message: "daemon socket command completed",
+                    meta: { socketPath, kind: command.kind, ok: true },
+                });
+                resolve({ ok: true, message: "daemon stopped" });
+                return;
+            }
+            if (trimmed.length === 0) {
+                const error = new Error("Daemon returned empty response.");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.socket_command_error",
+                    message: "daemon socket command returned empty response",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        error: error.message,
+                    },
+                });
+                reject(error);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.socket_command_end",
+                    message: "daemon socket command completed",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        ok: parsed.ok,
+                    },
+                });
+                resolve(parsed);
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.socket_command_error",
+                    message: "daemon socket command returned invalid JSON",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+                reject(error);
+            }
+        });
+    });
+}
+function checkDaemonSocketAlive(socketPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.socket_alive_check_start",
+        message: "checking daemon socket health",
+        meta: { socketPath },
+    });
+    return new Promise((resolve) => {
+        const client = net.createConnection(socketPath);
+        let raw = "";
+        let done = false;
+        const finalize = (alive) => {
+            if (done)
+                return;
+            done = true;
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.socket_alive_check_end",
+                message: "daemon socket health check completed",
+                meta: { socketPath, alive },
+            });
+            resolve(alive);
+        };
+        if ("setTimeout" in client && typeof client.setTimeout === "function") {
+            client.setTimeout(800, () => {
+                client.destroy();
+                finalize(false);
+            });
+        }
+        client.on("connect", () => {
+            client.write(JSON.stringify({ kind: "daemon.status" }));
+            client.end();
+        });
+        client.on("data", (chunk) => {
+            raw += chunk.toString("utf-8");
+        });
+        client.on("error", () => finalize(false));
+        client.on("end", () => {
+            if (raw.trim().length === 0) {
+                finalize(false);
+                return;
+            }
+            try {
+                JSON.parse(raw);
+                finalize(true);
+            }
+            catch {
+                finalize(false);
+            }
+        });
+    });
+}
+async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKET_PATH) {
+    const socketAvailable = fs.existsSync(socketPath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.inner_wake_request",
+        message: "requesting daemon-managed inner wake",
+        meta: {
+            agent,
+            socketPath,
+            socketAvailable,
+        },
+    });
+    if (!socketAvailable) {
+        return null;
+    }
+    return sendDaemonCommand(socketPath, { kind: "inner.wake", agent });
+}

package/dist/heart/daemon/thoughts.js

@@ -0,0 +1,371 @@
+"use strict";
+// Formats inner dialog session turns for human consumption.
+// Used by `ouro thoughts` CLI command to show what the agent has been thinking.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSurfacedValue = formatSurfacedValue;
+exports.deriveInnerDialogStatus = deriveInnerDialogStatus;
+exports.formatInnerDialogStatus = formatInnerDialogStatus;
+exports.extractThoughtResponseFromMessages = extractThoughtResponseFromMessages;
+exports.parseInnerDialogSession = parseInnerDialogSession;
+exports.formatThoughtTurns = formatThoughtTurns;
+exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
+exports.readInnerDialogStatus = readInnerDialogStatus;
+exports.followThoughts = followThoughts;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (typeof part === "string")
+            return part;
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .join("\n");
+}
+function extractToolFunction(toolCall) {
+    if (!toolCall || typeof toolCall !== "object" || !("function" in toolCall))
+        return null;
+    const maybeFunction = toolCall.function;
+    if (!maybeFunction || typeof maybeFunction !== "object")
+        return null;
+    const name = "name" in maybeFunction && typeof maybeFunction.name === "string"
+        ? maybeFunction.name
+        : undefined;
+    const argumentsValue = "arguments" in maybeFunction && typeof maybeFunction.arguments === "string"
+        ? maybeFunction.arguments
+        : undefined;
+    return { name, arguments: argumentsValue };
+}
+function classifyTurn(userText) {
+    if (userText.includes("waking up."))
+        return { type: "boot" };
+    const taskMatch = /## task: (.+)$/m.exec(userText);
+    if (taskMatch)
+        return { type: "task", taskId: taskMatch[1] };
+    return { type: "heartbeat" };
+}
+function extractToolNames(messages) {
+    const names = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
+            for (const tc of msg.tool_calls) {
+                const toolFunction = extractToolFunction(tc);
+                if (toolFunction?.name && toolFunction.name !== "final_answer")
+                    names.push(toolFunction.name);
+            }
+        }
+    }
+    return names;
+}
+function extractPendingPromptMessages(prompt) {
+    return prompt
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("[pending from "))
+        .map((line) => {
+        const separator = line.indexOf("]: ");
+        return separator >= 0 ? line.slice(separator + 3).trim() : "";
+    })
+        .filter((line) => line.length > 0);
+}
+function readPendingMessagesForStatus(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(pendingDir);
+    }
+    catch {
+        return [];
+    }
+    const files = [
+        ...entries.filter((entry) => entry.endsWith(".json.processing")),
+        ...entries.filter((entry) => entry.endsWith(".json") && !entry.endsWith(".json.processing")),
+    ].sort((a, b) => a.localeCompare(b));
+    const messages = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(pendingDir, file), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.content === "string") {
+                messages.push(parsed);
+            }
+        }
+        catch {
+            // unreadable pending files should not break status queries
+        }
+    }
+    return messages;
+}
+function formatSurfacedValue(text, maxLength = 120) {
+    const firstLine = text
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstLine)
+        return "no outward result";
+    if (firstLine.length <= maxLength)
+        return `"${firstLine}"`;
+    return `"${firstLine.slice(0, maxLength - 3)}..."`;
+}
+function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
+    if (runtimeState?.status === "running") {
+        return {
+            queue: pendingMessages.length > 0 ? "queued to inner/dialog" : "clear",
+            wake: "in progress",
+            processing: "started",
+            surfaced: "nothing yet",
+        };
+    }
+    if (pendingMessages.length > 0) {
+        return {
+            queue: "queued to inner/dialog",
+            wake: "awaiting inner session",
+            processing: "pending",
+            surfaced: "nothing yet",
+        };
+    }
+    const latestProcessedPendingTurn = [...turns]
+        .reverse()
+        .find((turn) => extractPendingPromptMessages(turn.prompt).length > 0);
+    if (!latestProcessedPendingTurn) {
+        return {
+            queue: "clear",
+            wake: "idle",
+            processing: "idle",
+            surfaced: "nothing recent",
+        };
+    }
+    return {
+        queue: "clear",
+        wake: "completed",
+        processing: "processed",
+        surfaced: formatSurfacedValue(latestProcessedPendingTurn.response),
+    };
+}
+function formatInnerDialogStatus(status) {
+    return [
+        `queue: ${status.queue}`,
+        `wake: ${status.wake}`,
+        `processing: ${status.processing}`,
+        `surfaced: ${status.surfaced}`,
+    ].join("\n");
+}
+/** Extract text from a final_answer tool call's arguments. */
+function extractFinalAnswer(messages) {
+    for (let k = messages.length - 1; k >= 0; k--) {
+        const msg = messages[k];
+        if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
+            continue;
+        for (const tc of msg.tool_calls) {
+            const toolFunction = extractToolFunction(tc);
+            if (toolFunction?.name !== "final_answer")
+                continue;
+            try {
+                const parsed = JSON.parse(toolFunction.arguments ?? "{}");
+                if (typeof parsed.answer === "string" && parsed.answer.trim())
+                    return parsed.answer.trim();
+            }
+            catch {
+                // malformed arguments — skip
+            }
+        }
+    }
+    return "";
+}
+function extractThoughtResponseFromMessages(messages) {
+    const assistantMsgs = messages.filter((message) => message.role === "assistant");
+    const lastAssistant = assistantMsgs.reverse().find((message) => contentToText(message.content).trim().length > 0);
+    return lastAssistant
+        ? contentToText(lastAssistant.content).trim()
+        : extractFinalAnswer(messages);
+}
+function parseInnerDialogSession(sessionPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.thoughts_parse",
+        message: "parsing inner dialog session",
+        meta: { sessionPath },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(sessionPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (data.version !== 1 || !Array.isArray(data.messages))
+        return [];
+    const turns = [];
+    const messages = data.messages;
+    // Walk messages, pairing user → (tool calls) → assistant sequences
+    let i = 0;
+    while (i < messages.length) {
+        const msg = messages[i];
+        if (msg.role === "system") {
+            i++;
+            continue;
+        }
+        if (msg.role !== "user") {
+            i++;
+            continue;
+        }
+        const userText = contentToText(msg.content);
+        const classification = classifyTurn(userText);
+        // Collect all messages until the next user message (or end)
+        const turnMessages = [];
+        let j = i + 1;
+        while (j < messages.length && messages[j].role !== "user") {
+            turnMessages.push(messages[j]);
+            j++;
+        }
+        // Find the last assistant text response in this turn.
+        // With tool_choice="required", the response may be inside a final_answer tool call.
+        const response = extractThoughtResponseFromMessages(turnMessages);
+        const tools = extractToolNames(turnMessages);
+        turns.push({
+            type: classification.type,
+            prompt: userText.trim(),
+            response,
+            tools,
+            ...(classification.taskId ? { taskId: classification.taskId } : {}),
+        });
+        i = j;
+    }
+    return turns;
+}
+function formatThoughtTurns(turns, lastN) {
+    if (turns.length === 0)
+        return "no inner dialog activity";
+    const selected = lastN > 0 ? turns.slice(-lastN) : turns;
+    /* v8 ignore next -- unreachable: turns.length > 0 checked above, slice always returns ≥1 @preserve */
+    if (selected.length === 0)
+        return "no inner dialog activity";
+    const lines = [];
+    for (const turn of selected) {
+        const typeLabel = turn.type === "task" && turn.taskId
+            ? `task: ${turn.taskId}`
+            : turn.type;
+        lines.push(`--- ${typeLabel} ---`);
+        if (turn.tools.length > 0) {
+            lines.push(`tools: ${turn.tools.join(", ")}`);
+        }
+        if (turn.response) {
+            lines.push(turn.response);
+        }
+        else {
+            lines.push("(no response)");
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+function getInnerDialogSessionPath(agentRoot) {
+    return path.join(agentRoot, "state", "sessions", "self", "inner", "dialog.json");
+}
+function getInnerDialogRuntimeStatePath(sessionPath) {
+    return path.join(path.dirname(sessionPath), "runtime.json");
+}
+function readInnerDialogRuntimeState(runtimePath) {
+    try {
+        const raw = fs.readFileSync(runtimePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.status !== "running" && parsed.status !== "idle")
+            return null;
+        return {
+            status: parsed.status,
+            reason: parsed.reason === "boot" || parsed.reason === "heartbeat" || parsed.reason === "instinct"
+                ? parsed.reason
+                : undefined,
+            startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : undefined,
+            lastCompletedAt: typeof parsed.lastCompletedAt === "string" ? parsed.lastCompletedAt : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readInnerDialogStatus(sessionPath, pendingDir, runtimePath = getInnerDialogRuntimeStatePath(sessionPath)) {
+    const pendingMessages = readPendingMessagesForStatus(pendingDir);
+    const turns = parseInnerDialogSession(sessionPath);
+    const runtimeState = readInnerDialogRuntimeState(runtimePath);
+    return deriveInnerDialogStatus(pendingMessages, turns, runtimeState);
+}
+/**
+ * Watch a session file and emit new turns as they appear.
+ * Returns a cleanup function that stops the watcher.
+ */
+function followThoughts(sessionPath, onNewTurns, pollIntervalMs = 1000) {
+    let displayedCount = parseInnerDialogSession(sessionPath).length;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.thoughts_follow_start",
+        message: "started following inner dialog session",
+        meta: { sessionPath, initialTurns: displayedCount },
+    });
+    fs.watchFile(sessionPath, { interval: pollIntervalMs }, () => {
+        const turns = parseInnerDialogSession(sessionPath);
+        if (turns.length > displayedCount) {
+            const newTurns = turns.slice(displayedCount);
+            onNewTurns(formatThoughtTurns(newTurns, 0));
+            displayedCount = turns.length;
+        }
+    });
+    return () => {
+        fs.unwatchFile(sessionPath);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.thoughts_follow_stop",
+            message: "stopped following inner dialog session",
+            meta: { sessionPath, totalTurns: displayedCount },
+        });
+    };
+}

package/dist/repertoire/tools-base.js

@@ -42,6 +42,8 @@ const skills_1 = require("./skills");
 const config_1 = require("../heart/config");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
+const socket_client_1 = require("../heart/daemon/socket-client");
+const thoughts_1 = require("../heart/daemon/thoughts");
 const tools_1 = require("./coding/tools");
 const memory_1 = require("../mind/memory");
 const pending_1 = require("../mind/pending");
@@ -596,6 +598,7 @@ exports.baseToolDefinitions = [
                         channel: { type: "string", description: "the channel: cli, teams, or inner" },
                         key: { type: "string", description: "session key (defaults to 'session')" },
                         messageCount: { type: "string", description: "how many recent messages to return (default 20)" },
+                        mode: { type: "string", enum: ["transcript", "status"], description: "transcript (default) or lightweight status for self/inner checks" },
                     },
                     required: ["friendId", "channel"],
                 },
@@ -607,6 +610,15 @@ exports.baseToolDefinitions = [
                 const channel = args.channel;
                 const key = args.key || "session";
                 const count = parseInt(args.messageCount || "20", 10);
+                const mode = args.mode || "transcript";
+                if (mode === "status") {
+                    if (friendId !== "self" || channel !== "inner") {
+                        return "status mode is only available for self/inner dialog.";
+                    }
+                    const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)((0, identity_1.getAgentRoot)());
+                    const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
+                    return (0, thoughts_1.formatInnerDialogStatus)((0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir));
+                }
                 const sessFile = (0, config_1.resolveSessionPath)(friendId, channel, key);
                 const raw = fs.readFileSync(sessFile, "utf-8");
                 const data = JSON.parse(raw);
@@ -650,7 +662,7 @@ exports.baseToolDefinitions = [
                 },
             },
         },
-        handler: async (args) => {
+        handler: async (args, ctx) => {
             const friendId = args.friendId;
             const channel = args.channel;
             const key = args.key || "session";
@@ -675,8 +687,46 @@ exports.baseToolDefinitions = [
                 timestamp: now,
             };
             fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
+            if (isSelf) {
+                let wakeResponse = null;
+                try {
+                    wakeResponse = await (0, socket_client_1.requestInnerWake)(agentName);
+                }
+                catch {
+                    wakeResponse = null;
+                }
+                if (!wakeResponse?.ok) {
+                    const { runInnerDialogTurn } = await Promise.resolve().then(() => __importStar(require("../senses/inner-dialog")));
+                    if (ctx?.context?.channel.channel === "inner") {
+                        queueMicrotask(() => {
+                            void runInnerDialogTurn({ reason: "instinct" });
+                        });
+                        return (0, thoughts_1.formatInnerDialogStatus)({
+                            queue: "queued to inner/dialog",
+                            wake: "inline scheduled",
+                            processing: "pending",
+                            surfaced: "nothing yet",
+                        });
+                    }
+                    else {
+                        const turnResult = await runInnerDialogTurn({ reason: "instinct" });
+                        return (0, thoughts_1.formatInnerDialogStatus)({
+                            queue: "queued to inner/dialog",
+                            wake: "inline fallback",
+                            processing: "processed",
+                            surfaced: (0, thoughts_1.formatSurfacedValue)((0, thoughts_1.extractThoughtResponseFromMessages)(turnResult?.messages ?? [])),
+                        });
+                    }
+                }
+                return (0, thoughts_1.formatInnerDialogStatus)({
+                    queue: "queued to inner/dialog",
+                    wake: "daemon requested",
+                    processing: "pending",
+                    surfaced: "nothing yet",
+                });
+            }
             const preview = content.length > 80 ? content.slice(0, 80) + "…" : content;
-            const target = isSelf ? "inner/dialog" : `${channel}/${key}`;
+            const target = `${channel}/${key}`;
             return `message queued for delivery to ${friendId} on ${target}. preview: "${preview}". it will be delivered when their session is next active.`;
         },
     },

package/dist/senses/inner-dialog-worker.js

@@ -6,12 +6,12 @@ const inner_dialog_1 = require("./inner-dialog");
 const runtime_1 = require("../nerves/runtime");
 function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options)) {
     let running = false;
-    async function run(reason) {
+    async function run(reason, taskId) {
         if (running)
             return;
         running = true;
         try {
-            await runTurn({ reason });
+            await runTurn({ reason, taskId });
         }
         catch (error) {
             (0, runtime_1.emitNervesEvent)({
@@ -37,8 +37,11 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
             await run("heartbeat");
             return;
         }
-        if (maybeMessage.type === "poke" ||
-            maybeMessage.type === "chat" ||
+        if (maybeMessage.type === "poke") {
+            await run("instinct", maybeMessage.taskId);
+            return;
+        }
+        if (maybeMessage.type === "chat" ||
             maybeMessage.type === "message") {
             await run("instinct");
             return;

package/dist/senses/inner-dialog.js

@@ -37,6 +37,8 @@ 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.runInnerDialogTurn = runInnerDialogTurn;
@@ -73,8 +75,16 @@ function readAspirations(agentRoot) {
 function loadInnerDialogInstincts() {
     return [...DEFAULT_INNER_DIALOG_INSTINCTS];
 }
-function buildInnerDialogBootstrapMessage(_aspirations, _stateSummary) {
-    return "waking up. settling in.\n\nwhat needs my attention?";
+function buildInnerDialogBootstrapMessage(aspirations, stateSummary) {
+    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)
@@ -98,6 +108,33 @@ function buildInstinctUserMessage(instincts, _reason, state) {
     }
     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")
         return content.trim();
@@ -143,6 +180,31 @@ function deriveResumeCheckpoint(messages) {
         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: () => { },
@@ -157,6 +219,31 @@ function createInnerDialogCallbacks() {
 function innerDialogSessionPath() {
     return (0, config_1.sessionPath)(pending_1.INNER_DIALOG_PENDING.friendId, pending_1.INNER_DIALOG_PENDING.channel, pending_1.INNER_DIALOG_PENDING.key);
 }
+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");
+    }
+    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),
+            },
+        });
+    }
+}
 // 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) {
@@ -187,94 +274,119 @@ 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 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: instinct message with checkpoint context
-        const assistantTurns = existingMessages.filter((message) => message.role === "assistant").length;
-        state.cycleCount = assistantTurns + 1;
-        state.checkpoint = deriveResumeCheckpoint(existingMessages);
-        userContent = buildInstinctUserMessage(instincts, reason, state);
+    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)((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, pipeline_1.handleInboundTurn)({
+            channel: "inner",
+            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,
+            },
+        });
+        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,
+        };
     }
-    // ── Adapter concern: inbox drain (inner-dialog-specific) ─────────
-    const inboxMessages = options?.drainInbox?.() ?? [];
-    if (inboxMessages.length > 0) {
-        const section = inboxMessages
-            .map((msg) => `- **${msg.from}**: ${msg.content}`)
-            .join("\n");
-        userContent = `${userContent}\n\n## incoming messages\n${section}`;
+    finally {
+        writeInnerDialogRuntimeState(sessionFilePath, {
+            status: "idle",
+            lastCompletedAt: now().toISOString(),
+        });
     }
-    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, pipeline_1.handleInboundTurn)({
-        channel: "inner",
-        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,
-        },
-    });
-    (0, runtime_1.emitNervesEvent)({
-        component: "senses",
-        event: "senses.inner_dialog_turn",
-        message: "inner dialog turn completed",
-        meta: { reason, session: sessionFilePath },
-    });
-    return {
-        messages: result.messages ?? [],
-        usage: result.usage,
-        sessionPath: result.sessionPath ?? sessionFilePath,
-    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.45",
+  "version": "0.1.0-alpha.47",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",