@ouro.bot/cli 0.1.0-alpha.69 → 0.1.0-alpha.690

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,16 +36,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSurfacedValue = formatSurfacedValue;
-exports.deriveInnerDialogStatus = deriveInnerDialogStatus;
-exports.formatInnerDialogStatus = formatInnerDialogStatus;
+exports.derivePrivateRuntimeStatus = derivePrivateRuntimeStatus;
+exports.deriveInnerJob = deriveInnerJob;
+exports.formatPrivateRuntimeStatus = formatPrivateRuntimeStatus;
 exports.extractThoughtResponseFromMessages = extractThoughtResponseFromMessages;
-exports.parseInnerDialogSession = parseInnerDialogSession;
+exports.parsePrivateRuntimeSession = parsePrivateRuntimeSession;
 exports.formatThoughtTurns = formatThoughtTurns;
-exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
-exports.readInnerDialogStatus = readInnerDialogStatus;
+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")
@@ -91,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);
             }
         }
@@ -149,14 +152,30 @@ function formatSurfacedValue(text, maxLength = 120) {
         return `"${firstLine}"`;
     return `"${firstLine.slice(0, maxLength - 3)}..."`;
 }
-function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
+function extractEnrichedFields(pendingMessages) {
+    const delegated = pendingMessages.find((msg) => msg.delegatedFrom);
+    if (!delegated?.delegatedFrom)
+        return {};
+    const snippet = delegated.content.length > 80 ? delegated.content.slice(0, 77) + "..." : delegated.content;
+    return {
+        origin: {
+            friendId: delegated.delegatedFrom.friendId,
+            channel: delegated.delegatedFrom.channel,
+            key: delegated.delegatedFrom.key,
+        },
+        contentSnippet: snippet,
+        ...(delegated.obligationStatus === "pending" ? { obligationPending: true } : {}),
+    };
+}
+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",
+                ...extractEnrichedFields(pendingMessages),
             };
         }
         return {
@@ -168,10 +187,11 @@ 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),
         };
     }
     const latestProcessedPendingTurn = [...turns]
@@ -192,23 +212,125 @@ function deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
         surfaced: formatSurfacedValue(latestProcessedPendingTurn.response),
     };
 }
-function formatInnerDialogStatus(status) {
-    return [
+function deriveInnerJob(pendingMessages, turns, runtimeState) {
+    const isRunning = runtimeState?.status === "running";
+    const delegated = pendingMessages.find((msg) => msg.delegatedFrom);
+    const enriched = extractEnrichedFields(pendingMessages);
+    const pendingMode = delegated && "mode" in delegated && delegated.mode ? delegated.mode : "reflect";
+    const origin = enriched.origin ?? null;
+    const content = delegated?.content ?? null;
+    const obligationStatus = delegated?.obligationStatus ?? null;
+    const queuedAt = delegated?.timestamp ?? null;
+    if (isRunning) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.private_runtime_job_derive",
+            message: "derived private-runtime job state",
+            meta: { status: "running", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
+        });
+        return {
+            status: "running",
+            content,
+            origin,
+            mode: pendingMode,
+            obligationStatus,
+            surfacedResult: null,
+            queuedAt,
+            startedAt: runtimeState?.startedAt ?? null,
+            surfacedAt: null,
+        };
+    }
+    if (pendingMessages.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.private_runtime_job_derive",
+            message: "derived private-runtime job state",
+            meta: { status: "queued", mode: pendingMode, hasOrigin: origin !== null, hasObligation: obligationStatus !== null },
+        });
+        return {
+            status: "queued",
+            content,
+            origin,
+            mode: pendingMode,
+            obligationStatus,
+            surfacedResult: null,
+            queuedAt,
+            startedAt: null,
+            surfacedAt: null,
+        };
+    }
+    // No pending, not running -- check for surfaced result
+    const latestProcessedPendingTurn = [...turns]
+        .reverse()
+        .find((turn) => extractPendingPromptMessages(turn.prompt).length > 0);
+    if (latestProcessedPendingTurn) {
+        const surfacedResult = extractThoughtResponseFromMessages([
+            { role: "assistant", content: latestProcessedPendingTurn.response },
+        ]);
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.private_runtime_job_derive",
+            message: "derived private-runtime job state",
+            meta: { status: "surfaced", mode: "reflect", hasOrigin: false, hasObligation: false },
+        });
+        return {
+            status: "surfaced",
+            content: null,
+            origin: null,
+            mode: "reflect",
+            obligationStatus: null,
+            /* v8 ignore next -- defensive: surfacedResult fallback @preserve */
+            surfacedResult: surfacedResult || null,
+            queuedAt: null,
+            startedAt: null,
+            surfacedAt: null,
+        };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.private_runtime_job_derive",
+        message: "derived private-runtime job state",
+        meta: { status: "idle", mode: "reflect", hasOrigin: false, hasObligation: false },
+    });
+    return {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+}
+function formatPrivateRuntimeStatus(status) {
+    const lines = [
         `queue: ${status.queue}`,
         `wake: ${status.wake}`,
         `processing: ${status.processing}`,
         `surfaced: ${status.surfaced}`,
-    ].join("\n");
+    ];
+    if (status.origin) {
+        lines.push(`origin: ${status.origin.friendId}/${status.origin.channel}/${status.origin.key}`);
+    }
+    if (status.contentSnippet) {
+        lines.push(`asked: ${status.contentSnippet}`);
+    }
+    if (status.obligationPending) {
+        lines.push("obligation: pending");
+    }
+    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 ?? "{}");
@@ -222,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;
@@ -243,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;
@@ -271,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({
@@ -292,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
@@ -316,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);
@@ -341,26 +543,33 @@ 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 = parsePrivateRuntimeSession(sessionPath);
+    const runtimeState = readPrivateRuntimeState(runtimePath);
+    return derivePrivateRuntimeStatus(pendingMessages, turns, runtimeState);
+}
+function readPrivateRuntimeRawData(sessionPath, pendingDir) {
+    const 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 { 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;
+    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));
@@ -369,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 },
         });
     };