@ouro.bot/cli 0.1.0-alpha.42 → 0.1.0-alpha.421

package/dist/heart/daemon/task-scheduler.js

@@ -39,6 +39,7 @@ const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const parser_1 = require("../../repertoire/tasks/parser");
+const cadence_1 = require("./cadence");
 function walkMarkdownFiles(root, readdirSync, existsSync, files) {
     if (!existsSync(root))
         return;
@@ -53,29 +54,6 @@ function walkMarkdownFiles(root, readdirSync, existsSync, files) {
         }
     }
 }
-function parseCadence(raw) {
-    if (typeof raw !== "string")
-        return null;
-    const value = raw.trim();
-    if (!value)
-        return null;
-    // Cron format (minute hour day month weekday)
-    if (/^\S+\s+\S+\s+\S+\s+\S+\s+\S+$/.test(value)) {
-        return value;
-    }
-    const cadenceMatch = /^(\d+)(m|h|d)$/.exec(value);
-    if (!cadenceMatch)
-        return null;
-    const interval = Number.parseInt(cadenceMatch[1], 10);
-    if (!Number.isFinite(interval) || interval <= 0)
-        return null;
-    const unit = cadenceMatch[2];
-    if (unit === "m")
-        return `*/${interval} * * * *`;
-    if (unit === "h")
-        return `0 */${interval} * * *`;
-    return `0 0 */${interval} * *`;
-}
 function parseScheduledAt(raw) {
     if (typeof raw !== "string")
         return null;
@@ -140,7 +118,7 @@ class TaskDrivenScheduler {
         const nextTaskPaths = new Map();
         for (const agent of this.agents) {
             const taskRoot = path.join(this.bundlesRoot, `${agent}.ouro`, "tasks");
-            const collections = ["one-shots", "ongoing", "habits"];
+            const collections = ["one-shots", "ongoing"];
             const files = [];
             for (const collection of collections) {
                 walkMarkdownFiles(path.join(taskRoot, collection), this.readdirSync, this.existsSync, files);
@@ -157,7 +135,7 @@ class TaskDrivenScheduler {
                 nextTaskPaths.set(`${agent}:${taskId}`, filePath);
                 if (task.status === "done")
                     continue;
-                const cadence = parseCadence(task.frontmatter.cadence);
+                const cadence = (0, cadence_1.parseCadenceToCron)(task.frontmatter.cadence);
                 if (cadence) {
                     const id = `${agent}:${taskId}:cadence`;
                     nextJobs.set(id, {

package/dist/heart/daemon/thoughts.js

@@ -0,0 +1,510 @@
+"use strict";
+// Formats inner dialog session turns for human consumption.
+// Used by `ouro thoughts` CLI command to show what the agent has been thinking.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSurfacedValue = formatSurfacedValue;
+exports.deriveInnerDialogStatus = deriveInnerDialogStatus;
+exports.deriveInnerJob = deriveInnerJob;
+exports.formatInnerDialogStatus = formatInnerDialogStatus;
+exports.extractThoughtResponseFromMessages = extractThoughtResponseFromMessages;
+exports.parseInnerDialogSession = parseInnerDialogSession;
+exports.formatThoughtTurns = formatThoughtTurns;
+exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
+exports.readInnerDialogStatus = readInnerDialogStatus;
+exports.readInnerDialogRawData = readInnerDialogRawData;
+exports.followThoughts = followThoughts;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (typeof part === "string")
+            return part;
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .join("\n");
+}
+function extractToolFunction(toolCall) {
+    if (!toolCall || typeof toolCall !== "object" || !("function" in toolCall))
+        return null;
+    const maybeFunction = toolCall.function;
+    if (!maybeFunction || typeof maybeFunction !== "object")
+        return null;
+    const name = "name" in maybeFunction && typeof maybeFunction.name === "string"
+        ? maybeFunction.name
+        : undefined;
+    const argumentsValue = "arguments" in maybeFunction && typeof maybeFunction.arguments === "string"
+        ? maybeFunction.arguments
+        : undefined;
+    return { name, arguments: argumentsValue };
+}
+function classifyTurn(userText) {
+    if (userText.includes("waking up."))
+        return { type: "boot" };
+    const taskMatch = /## task: (.+)$/m.exec(userText);
+    if (taskMatch)
+        return { type: "task", taskId: taskMatch[1] };
+    return { type: "heartbeat" };
+}
+function extractToolNames(messages) {
+    const names = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
+            for (const tc of msg.tool_calls) {
+                const toolFunction = extractToolFunction(tc);
+                if (toolFunction?.name && toolFunction.name !== "settle")
+                    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 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 deriveInnerDialogStatus(pendingMessages, turns, runtimeState) {
+    if (runtimeState?.status === "running") {
+        if (pendingMessages.length > 0) {
+            return {
+                queue: "queued to inner/dialog",
+                wake: "queued behind active turn",
+                processing: "pending",
+                surfaced: "nothing yet",
+                ...extractEnrichedFields(pendingMessages),
+            };
+        }
+        return {
+            queue: "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",
+            ...extractEnrichedFields(pendingMessages),
+        };
+    }
+    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 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.inner_job_derive",
+            message: "derived inner 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.inner_job_derive",
+            message: "derived inner 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.inner_job_derive",
+            message: "derived inner 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.inner_job_derive",
+        message: "derived inner 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 formatInnerDialogStatus(status) {
+    const lines = [
+        `queue: ${status.queue}`,
+        `wake: ${status.wake}`,
+        `processing: ${status.processing}`,
+        `surfaced: ${status.surfaced}`,
+    ];
+    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 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 !== "settle")
+                continue;
+            try {
+                const parsed = JSON.parse(toolFunction.arguments ?? "{}");
+                if (typeof parsed.answer === "string" && parsed.answer.trim())
+                    return parsed.answer.trim();
+            }
+            catch {
+                // malformed arguments — skip
+            }
+        }
+    }
+    return "";
+}
+function extractThoughtResponseFromMessages(messages) {
+    const assistantMsgs = messages.filter((message) => message.role === "assistant");
+    const lastAssistant = assistantMsgs.reverse().find((message) => contentToText(message.content).trim().length > 0);
+    return lastAssistant
+        ? contentToText(lastAssistant.content).trim()
+        : extractSettleAnswer(messages);
+}
+function parseInnerDialogSession(sessionPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.thoughts_parse",
+        message: "parsing inner dialog session",
+        meta: { sessionPath },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(sessionPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (data.version !== 1 || !Array.isArray(data.messages))
+        return [];
+    const turns = [];
+    const messages = data.messages;
+    // Walk messages, pairing user → (tool calls) → assistant sequences
+    let i = 0;
+    while (i < messages.length) {
+        const msg = messages[i];
+        if (msg.role === "system") {
+            i++;
+            continue;
+        }
+        if (msg.role !== "user") {
+            i++;
+            continue;
+        }
+        const userText = contentToText(msg.content);
+        const classification = classifyTurn(userText);
+        // Collect all messages until the next user message (or end)
+        const turnMessages = [];
+        let j = i + 1;
+        while (j < messages.length && messages[j].role !== "user") {
+            turnMessages.push(messages[j]);
+            j++;
+        }
+        // Find the last assistant text response in this turn.
+        // With tool_choice="required", the response may be inside a settle tool call.
+        const response = extractThoughtResponseFromMessages(turnMessages);
+        const tools = extractToolNames(turnMessages);
+        turns.push({
+            type: classification.type,
+            prompt: userText.trim(),
+            response,
+            tools,
+            ...(classification.taskId ? { taskId: classification.taskId } : {}),
+        });
+        i = j;
+    }
+    return turns;
+}
+function formatThoughtTurns(turns, lastN) {
+    if (turns.length === 0)
+        return "no inner dialog activity";
+    const selected = lastN > 0 ? turns.slice(-lastN) : turns;
+    /* v8 ignore next -- unreachable: turns.length > 0 checked above, slice always returns ≥1 @preserve */
+    if (selected.length === 0)
+        return "no inner dialog activity";
+    const lines = [];
+    for (const turn of selected) {
+        const typeLabel = turn.type === "task" && turn.taskId
+            ? `task: ${turn.taskId}`
+            : turn.type;
+        lines.push(`--- ${typeLabel} ---`);
+        if (turn.tools.length > 0) {
+            lines.push(`tools: ${turn.tools.join(", ")}`);
+        }
+        if (turn.response) {
+            lines.push(turn.response);
+        }
+        else {
+            lines.push("(no response)");
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+function getInnerDialogSessionPath(agentRoot) {
+    return path.join(agentRoot, "state", "sessions", "self", "inner", "dialog.json");
+}
+function getInnerDialogRuntimeStatePath(sessionPath) {
+    return path.join(path.dirname(sessionPath), "runtime.json");
+}
+function readInnerDialogRuntimeState(runtimePath) {
+    try {
+        const raw = fs.readFileSync(runtimePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.status !== "running" && parsed.status !== "idle")
+            return null;
+        return {
+            status: parsed.status,
+            reason: parsed.reason === "boot" || parsed.reason === "heartbeat" || parsed.reason === "instinct"
+                ? parsed.reason
+                : undefined,
+            startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : undefined,
+            lastCompletedAt: typeof parsed.lastCompletedAt === "string" ? parsed.lastCompletedAt : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readInnerDialogStatus(sessionPath, pendingDir, runtimePath = getInnerDialogRuntimeStatePath(sessionPath)) {
+    const pendingMessages = readPendingMessagesForStatus(pendingDir);
+    const turns = parseInnerDialogSession(sessionPath);
+    const runtimeState = readInnerDialogRuntimeState(runtimePath);
+    return deriveInnerDialogStatus(pendingMessages, turns, runtimeState);
+}
+function readInnerDialogRawData(sessionPath, pendingDir) {
+    const runtimePath = getInnerDialogRuntimeStatePath(sessionPath);
+    const pendingMessages = readPendingMessagesForStatus(pendingDir);
+    const turns = parseInnerDialogSession(sessionPath);
+    const runtimeState = readInnerDialogRuntimeState(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;
+    (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);
+        // 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_end",
+            message: "stopped following inner dialog session",
+            meta: { sessionPath, totalTurns: displayedCount },
+        });
+    };
+}