@ouro.bot/cli 0.1.0-alpha.75 → 0.1.0-alpha.751

package/dist/heart/daemon/thoughts.js

@@ -1,5 +1,5 @@
 "use strict";
-// Formats inner dialog session turns for human consumption.
+// Formats private-runtime 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;
@@ -36,18 +36,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSurfacedValue = formatSurfacedValue;
-exports.deriveInnerDialogStatus = deriveInnerDialogStatus;
+exports.derivePrivateRuntimeStatus = derivePrivateRuntimeStatus;
 exports.deriveInnerJob = deriveInnerJob;
-exports.formatInnerDialogStatus = formatInnerDialogStatus;
+exports.formatPrivateRuntimeStatus = formatPrivateRuntimeStatus;
 exports.extractThoughtResponseFromMessages = extractThoughtResponseFromMessages;
-exports.parseInnerDialogSession = parseInnerDialogSession;
+exports.parsePrivateRuntimeSession = parsePrivateRuntimeSession;
 exports.formatThoughtTurns = formatThoughtTurns;
-exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
-exports.readInnerDialogStatus = readInnerDialogStatus;
-exports.readInnerDialogRawData = readInnerDialogRawData;
+exports.getPrivateRuntimeSessionPath = getPrivateRuntimeSessionPath;
+exports.readPrivateRuntimeStatus = readPrivateRuntimeStatus;
+exports.readPrivateRuntimeRawData = readPrivateRuntimeRawData;
 exports.followThoughts = followThoughts;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const session_events_1 = require("../session-events");
 const runtime_1 = require("../../nerves/runtime");
 function contentToText(content) {
     if (typeof content === "string")
@@ -93,7 +94,7 @@ function extractToolNames(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")
+                if (toolFunction?.name && toolFunction.name !== "settle")
                     names.push(toolFunction.name);
             }
         }
@@ -166,11 +167,11 @@ function extractEnrichedFields(pendingMessages) {
         ...(delegated.obligationStatus === "pending" ? { obligationPending: true } : {}),
     };
 }
-function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
+function derivePrivateRuntimeStatus(pendingMessages, turns, runtimeState) {
     if (runtimeState?.status === "running") {
         if (pendingMessages.length > 0) {
             return {
-                queue: "queued to inner/dialog",
+                queue: "queued to private runtime",
                 wake: "queued behind active turn",
                 processing: "pending",
                 surfaced: "nothing yet",
@@ -186,8 +187,8 @@ function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
     }
     if (pendingMessages.length > 0) {
         return {
-            queue: "queued to inner/dialog",
-            wake: "awaiting inner session",
+            queue: "queued to private runtime",
+            wake: "awaiting private-runtime turn",
             processing: "pending",
             surfaced: "nothing yet",
             ...extractEnrichedFields(pendingMessages),
@@ -223,8 +224,8 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
     if (isRunning) {
         (0, runtime_1.emitNervesEvent)({
             component: "engine",
-            event: "engine.inner_job_derive",
-            message: "derived inner job state",
+            event: "engine.private_runtime_job_derive",
+            message: "derived private-runtime job state",
             meta: { status: "running", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
         });
         return {
@@ -242,8 +243,8 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
     if (pendingMessages.length > 0) {
         (0, runtime_1.emitNervesEvent)({
             component: "engine",
-            event: "engine.inner_job_derive",
-            message: "derived inner job state",
+            event: "engine.private_runtime_job_derive",
+            message: "derived private-runtime job state",
             meta: { status: "queued", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
         });
         return {
@@ -268,8 +269,8 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
         ]);
         (0, runtime_1.emitNervesEvent)({
             component: "engine",
-            event: "engine.inner_job_derive",
-            message: "derived inner job state",
+            event: "engine.private_runtime_job_derive",
+            message: "derived private-runtime job state",
             meta: { status: "surfaced", mode: "reflect", hasOrigin: false, hasObligation: false },
         });
         return {
@@ -287,8 +288,8 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
     }
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
-        event: "engine.inner_job_derive",
-        message: "derived inner job state",
+        event: "engine.private_runtime_job_derive",
+        message: "derived private-runtime job state",
         meta: { status: "idle", mode: "reflect", hasOrigin: false, hasObligation: false },
     });
     return {
@@ -303,7 +304,7 @@ function deriveInnerJob(pendingMessages, turns, runtimeState) {
         surfacedAt: null,
     };
 }
-function formatInnerDialogStatus(status) {
+function formatPrivateRuntimeStatus(status) {
     const lines = [
         `queue: ${status.queue}`,
         `wake: ${status.wake}`,
@@ -321,15 +322,15 @@ function formatInnerDialogStatus(status) {
     }
     return lines.join("\n");
 }
-/** Extract text from a final_answer tool call's arguments. */
-function extractFinalAnswer(messages) {
+/** Extract text from a settle tool call's arguments. */
+function extractSettleAnswer(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")
+            if (toolFunction?.name !== "settle")
                 continue;
             try {
                 const parsed = JSON.parse(toolFunction.arguments ?? "{}");
@@ -343,18 +344,85 @@ function extractFinalAnswer(messages) {
     }
     return "";
 }
+function parseToolArguments(argumentsValue) {
+    if (!argumentsValue)
+        return {};
+    try {
+        const parsed = JSON.parse(argumentsValue);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function toolArgumentText(args, keys) {
+    for (const key of keys) {
+        const value = args[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return "";
+}
+function truncateToolSummary(summary) {
+    if (summary.length <= 220)
+        return summary;
+    return `${summary.slice(0, 217)}...`;
+}
+function summarizeToolAction(name, argumentsValue) {
+    if (!name)
+        return null;
+    const args = parseToolArguments(argumentsValue);
+    if (name === "surface") {
+        const message = toolArgumentText(args, ["message", "text", "content"]);
+        return message ? `surfaced: ${message}` : null;
+    }
+    if (name === "ponder") {
+        const thought = toolArgumentText(args, ["summary", "question", "topic", "prompt"]);
+        return thought ? `pondered: ${thought}` : null;
+    }
+    if (name === "diary_write") {
+        const note = toolArgumentText(args, ["text", "content", "note", "entry"]);
+        return note ? `diary: ${note}` : null;
+    }
+    if (name === "let_go") {
+        const reason = toolArgumentText(args, ["reason", "note", "status"]);
+        return reason ? `let go: ${reason}` : null;
+    }
+    if (name === "rest") {
+        const note = toolArgumentText(args, ["note", "status"]);
+        return note ? `rested: ${note}` : null;
+    }
+    return null;
+}
+function extractToolActionSummary(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 (let i = msg.tool_calls.length - 1; i >= 0; i--) {
+            const toolFunction = extractToolFunction(msg.tool_calls[i]);
+            const summary = summarizeToolAction(toolFunction?.name, toolFunction?.arguments);
+            if (summary)
+                return truncateToolSummary(summary);
+        }
+    }
+    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);
+        : extractSettleAnswer(messages) || extractToolActionSummary(messages);
 }
-function parseInnerDialogSession(sessionPath) {
+function parsePrivateRuntimeSession(sessionPath) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.thoughts_parse",
-        message: "parsing inner dialog session",
+        message: "parsing private-runtime session",
         meta: { sessionPath },
     });
     let raw;
@@ -364,21 +432,34 @@ function parseInnerDialogSession(sessionPath) {
     catch {
         return [];
     }
-    let data;
+    let parsedRaw;
     try {
-        data = JSON.parse(raw);
+        parsedRaw = JSON.parse(raw);
     }
     catch {
         return [];
     }
-    if (data.version !== 1 || !Array.isArray(data.messages))
+    const legacyRecord = parsedRaw && typeof parsedRaw === "object"
+        ? parsedRaw
+        : null;
+    const messages = legacyRecord?.version === 1 && Array.isArray(legacyRecord.messages)
+        ? legacyRecord.messages
+        : (() => {
+            const envelope = (0, session_events_1.parseSessionEnvelope)(parsedRaw, {
+                recordedAt: new Date().toISOString(),
+            });
+            if (!envelope)
+                return null;
+            return (0, session_events_1.projectProviderMessages)(envelope);
+        })();
+    if (!messages)
         return [];
+    const normalizedMessages = messages;
     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];
+    while (i < normalizedMessages.length) {
+        const msg = normalizedMessages[i];
         if (msg.role === "system") {
             i++;
             continue;
@@ -392,12 +473,12 @@ function parseInnerDialogSession(sessionPath) {
         // 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]);
+        while (j < normalizedMessages.length && normalizedMessages[j].role !== "user") {
+            turnMessages.push(normalizedMessages[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.
+        // With tool_choice="required", the response may be inside a settle tool call.
         const response = extractThoughtResponseFromMessages(turnMessages);
         const tools = extractToolNames(turnMessages);
         turns.push({
@@ -413,11 +494,11 @@ function parseInnerDialogSession(sessionPath) {
 }
 function formatThoughtTurns(turns, lastN) {
     if (turns.length === 0)
-        return "no inner dialog activity";
+        return "no private-runtime 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";
+        return "no private-runtime activity";
     const lines = [];
     for (const turn of selected) {
         const typeLabel = turn.type === "task" && turn.taskId
@@ -437,13 +518,13 @@ function formatThoughtTurns(turns, lastN) {
     }
     return lines.join("\n").trim();
 }
-function getInnerDialogSessionPath(agentRoot) {
+function getPrivateRuntimeSessionPath(agentRoot) {
     return path.join(agentRoot, "state", "sessions", "self", "inner", "dialog.json");
 }
-function getInnerDialogRuntimeStatePath(sessionPath) {
+function getPrivateRuntimeStatePath(sessionPath) {
     return path.join(path.dirname(sessionPath), "runtime.json");
 }
-function readInnerDialogRuntimeState(runtimePath) {
+function readPrivateRuntimeState(runtimePath) {
     try {
         const raw = fs.readFileSync(runtimePath, "utf-8");
         const parsed = JSON.parse(raw);
@@ -462,17 +543,17 @@ function readInnerDialogRuntimeState(runtimePath) {
         return null;
     }
 }
-function readInnerDialogStatus(sessionPath, pendingDir, runtimePath = getInnerDialogRuntimeStatePath(sessionPath)) {
+function readPrivateRuntimeStatus(sessionPath, pendingDir, runtimePath = getPrivateRuntimeStatePath(sessionPath)) {
     const pendingMessages = readPendingMessagesForStatus(pendingDir);
-    const turns = parseInnerDialogSession(sessionPath);
-    const runtimeState = readInnerDialogRuntimeState(runtimePath);
-    return deriveInnerDialogStatus(pendingMessages, turns, runtimeState);
+    const turns = parsePrivateRuntimeSession(sessionPath);
+    const runtimeState = readPrivateRuntimeState(runtimePath);
+    return derivePrivateRuntimeStatus(pendingMessages, turns, runtimeState);
 }
-function readInnerDialogRawData(sessionPath, pendingDir) {
-    const runtimePath = getInnerDialogRuntimeStatePath(sessionPath);
+function readPrivateRuntimeRawData(sessionPath, pendingDir) {
+    const runtimePath = getPrivateRuntimeStatePath(sessionPath);
     const pendingMessages = readPendingMessagesForStatus(pendingDir);
-    const turns = parseInnerDialogSession(sessionPath);
-    const runtimeState = readInnerDialogRuntimeState(runtimePath);
+    const turns = parsePrivateRuntimeSession(sessionPath);
+    const runtimeState = readPrivateRuntimeState(runtimePath);
     return { pendingMessages, turns, runtimeState };
 }
 /**
@@ -480,15 +561,15 @@ function readInnerDialogRawData(sessionPath, pendingDir) {
  * Returns a cleanup function that stops the watcher.
  */
 function followThoughts(sessionPath, onNewTurns, pollIntervalMs = 1000) {
-    let displayedCount = parseInnerDialogSession(sessionPath).length;
+    let displayedCount = parsePrivateRuntimeSession(sessionPath).length;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.thoughts_follow_start",
-        message: "started following inner dialog session",
+        message: "started following private-runtime session",
         meta: { sessionPath, initialTurns: displayedCount },
     });
     fs.watchFile(sessionPath, { interval: pollIntervalMs }, () => {
-        const turns = parseInnerDialogSession(sessionPath);
+        const turns = parsePrivateRuntimeSession(sessionPath);
         if (turns.length > displayedCount) {
             const newTurns = turns.slice(displayedCount);
             onNewTurns(formatThoughtTurns(newTurns, 0));
@@ -497,10 +578,13 @@ function followThoughts(sessionPath, onNewTurns, pollIntervalMs = 1000) {
     });
     return () => {
         fs.unwatchFile(sessionPath);
+        // Must be named `_end` (not `_stop`) to satisfy the nerves audit's
+        // start/end pairing rule — see src/nerves/coverage/audit-rules.ts which
+        // pairs `<prefix>_start` with `<prefix>_end` or `<prefix>_error`.
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
-            event: "daemon.thoughts_follow_stop",
-            message: "stopped following inner dialog session",
+            event: "daemon.thoughts_follow_end",
+            message: "stopped following private-runtime session",
             meta: { sessionPath, totalTurns: displayedCount },
         });
     };