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

package/changelog.json

@@ -1,6 +1,15 @@
 {
   "_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": [

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");
@@ -65,6 +64,7 @@ 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;
 }
@@ -670,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], {
@@ -715,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);
@@ -1075,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,

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

@@ -35,9 +35,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 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"));
@@ -58,6 +63,20 @@ function contentToText(content) {
     })
         .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" };
@@ -71,13 +90,108 @@ function extractToolNames(messages) {
     for (const msg of messages) {
         if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
             for (const tc of msg.tool_calls) {
-                if (tc.function?.name && tc.function.name !== "final_answer")
-                    names.push(tc.function.name);
+                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--) {
@@ -85,10 +199,11 @@ function extractFinalAnswer(messages) {
         if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
             continue;
         for (const tc of msg.tool_calls) {
-            if (tc.function?.name !== "final_answer")
+            const toolFunction = extractToolFunction(tc);
+            if (toolFunction?.name !== "final_answer")
                 continue;
             try {
-                const parsed = JSON.parse(tc.function.arguments ?? "{}");
+                const parsed = JSON.parse(toolFunction.arguments ?? "{}");
                 if (typeof parsed.answer === "string" && parsed.answer.trim())
                     return parsed.answer.trim();
             }
@@ -99,6 +214,13 @@ function extractFinalAnswer(messages) {
     }
     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",
@@ -147,11 +269,7 @@ function parseInnerDialogSession(sessionPath) {
         }
         // Find the last assistant text response in this turn.
         // With tool_choice="required", the response may be inside a final_answer tool call.
-        const assistantMsgs = turnMessages.filter((m) => m.role === "assistant");
-        const lastAssistant = assistantMsgs.reverse().find((m) => contentToText(m.content).trim().length > 0);
-        const response = lastAssistant
-            ? contentToText(lastAssistant.content).trim()
-            : extractFinalAnswer(turnMessages);
+        const response = extractThoughtResponseFromMessages(turnMessages);
         const tools = extractToolNames(turnMessages);
         turns.push({
             type: classification.type,
@@ -193,6 +311,34 @@ function formatThoughtTurns(turns, lastN) {
 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.

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.js

@@ -219,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) {
@@ -249,106 +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: 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);
+    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 {
-            userContent = buildInstinctUserMessage(instincts, reason, state);
+            // 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,
+        };
+    }
+    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,
-        },
-    });
-    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,
-    };
 }

package/package.json

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