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

package/changelog.json

@@ -1,6 +1,19 @@
 {
   "_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.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

@@ -62,6 +62,7 @@ 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");
 function stringField(value) {
@@ -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()}`);
@@ -1338,6 +1365,7 @@ function executeReminderCommand(command, taskMod) {
             body: command.body,
             scheduledAt: command.scheduledAt,
             cadence: command.cadence,
+            requester: command.requester,
         });
         return `created: ${created}`;
     }
@@ -1536,6 +1564,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/thoughts.js

@@ -0,0 +1,225 @@
+"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.parseInnerDialogSession = parseInnerDialogSession;
+exports.formatThoughtTurns = formatThoughtTurns;
+exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
+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 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) {
+                if (tc.function?.name && tc.function.name !== "final_answer")
+                    names.push(tc.function.name);
+            }
+        }
+    }
+    return names;
+}
+/** 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) {
+            if (tc.function?.name !== "final_answer")
+                continue;
+            try {
+                const parsed = JSON.parse(tc.function.arguments ?? "{}");
+                if (typeof parsed.answer === "string" && parsed.answer.trim())
+                    return parsed.answer.trim();
+            }
+            catch {
+                // malformed arguments — skip
+            }
+        }
+    }
+    return "";
+}
+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 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 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");
+}
+/**
+ * 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/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: () => { },
@@ -208,19 +270,17 @@ async function runInnerDialogTurn(options) {
         ].filter(Boolean).join("\n\n");
     }
     else {
-        // Resumed session: instinct message with checkpoint context
+        // 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);
-        userContent = buildInstinctUserMessage(instincts, reason, state);
-    }
-    // ── 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}`;
+        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 ──────────────────
@@ -266,14 +326,28 @@ async function runInnerDialogTurn(options) {
             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 },
+        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: result.messages ?? [],
+        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.45",
+  "version": "0.1.0-alpha.46",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",