@ouro.bot/cli 0.1.0-alpha.141 → 0.1.0-alpha.142

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_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.142",
+      "changes": [
+        "Surface tool fulfills heart obligations on successful routing: findPendingObligationForOrigin + fulfillObligation called after inner obligation advance, wrapped in try/catch.",
+        "New fulfillHeartObligation callback on HandleSurfaceInput — origin-based lookup independent of inner obligationId.",
+        "ouro inner status command: reads runtime.json, journal dir, heartbeat cadence, attention count. Shows last turn, status, heartbeat health, journal listing, held thoughts."
+      ]
+    },
     {
       "version": "0.1.0-alpha.141",
       "changes": [

package/dist/heart/daemon/daemon-cli.js

@@ -295,6 +295,7 @@ function usage() {
         "  ouro friend create --name <name> [--trust <level>] [--agent <name>]",
         "  ouro friend update <id> --trust <level> [--agent <name>]",
         "  ouro thoughts [--last <n>] [--json] [--follow] [--agent <name>]",
+        "  ouro inner [--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>]",
@@ -987,6 +988,10 @@ function parseOuroCommand(args) {
         return parseThoughtsCommand(args.slice(1));
     if (head === "attention")
         return parseAttentionCommand(args.slice(1));
+    if (head === "inner") {
+        const { agent } = extractAgentFlag(args.slice(1));
+        return { kind: "inner.status", ...(agent ? { agent } : {}) };
+    }
     if (head === "chat") {
         if (!second)
             throw new Error(`Usage\n${usage()}`);
@@ -2607,6 +2612,89 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         }
     }
     /* v8 ignore stop */
+    // ── inner dialog status (local, no daemon socket needed) ──
+    /* v8 ignore start -- inner status handler: requires real agent state on disk @preserve */
+    if (command.kind === "inner.status") {
+        try {
+            const agentName = command.agent ?? (0, identity_1.getAgentName)();
+            const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+            const { buildInnerStatusOutput } = await Promise.resolve().then(() => __importStar(require("./inner-status")));
+            const { sessionPath: getSessionPath } = await Promise.resolve().then(() => __importStar(require("../config")));
+            const { parseCadenceMs, DEFAULT_CADENCE_MS } = await Promise.resolve().then(() => __importStar(require("./heartbeat-timer")));
+            const { parseFrontmatter } = await Promise.resolve().then(() => __importStar(require("../../repertoire/tasks/parser")));
+            const { listActiveObligations } = await Promise.resolve().then(() => __importStar(require("../../mind/obligations")));
+            // Read runtime state
+            const innerSessionPath = getSessionPath("inner-dialog", "inner", "session");
+            const runtimeJsonPath = path.join(path.dirname(innerSessionPath), "runtime.json");
+            let runtimeState = null;
+            try {
+                const raw = fs.readFileSync(runtimeJsonPath, "utf-8");
+                runtimeState = JSON.parse(raw);
+            }
+            catch { /* missing or corrupt — will show "unknown" */ }
+            // Read journal files
+            const journalDir = path.join(agentRoot, "journal");
+            let journalFiles = [];
+            try {
+                const entries = fs.readdirSync(journalDir, { withFileTypes: true });
+                journalFiles = entries
+                    .filter((e) => e.isFile() && !e.name.startsWith("."))
+                    .map((e) => {
+                    const stat = fs.statSync(path.join(journalDir, e.name));
+                    return { name: e.name, mtimeMs: stat.mtimeMs };
+                });
+            }
+            catch { /* missing dir — will show (empty) */ }
+            // Read heartbeat cadence
+            let heartbeat = null;
+            try {
+                const habitsDir = path.join(agentRoot, "habits");
+                const habitFiles = fs.readdirSync(habitsDir);
+                const heartbeatFile = habitFiles.find((f) => f.endsWith("-heartbeat.md"));
+                let cadenceMs = DEFAULT_CADENCE_MS;
+                if (heartbeatFile) {
+                    const content = fs.readFileSync(path.join(habitsDir, heartbeatFile), "utf-8");
+                    const lines = content.split(/\r?\n/);
+                    if (lines[0]?.trim() === "---") {
+                        const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+                        if (closing !== -1) {
+                            const rawFrontmatter = lines.slice(1, closing).join("\n");
+                            const frontmatter = parseFrontmatter(rawFrontmatter);
+                            const parsed = parseCadenceMs(frontmatter.cadence);
+                            if (parsed !== null)
+                                cadenceMs = parsed;
+                        }
+                    }
+                }
+                let lastCompletedAt = null;
+                if (runtimeState?.lastCompletedAt) {
+                    const ms = new Date(runtimeState.lastCompletedAt).getTime();
+                    if (!Number.isNaN(ms))
+                        lastCompletedAt = ms;
+                }
+                heartbeat = { cadenceMs, lastCompletedAt };
+            }
+            catch { /* no habits — heartbeat unknown */ }
+            // Attention count
+            const activeObligations = listActiveObligations(agentName);
+            const message = buildInnerStatusOutput({
+                agentName,
+                runtimeState,
+                journalFiles,
+                heartbeat,
+                attentionCount: activeObligations.length,
+                now: Date.now(),
+            });
+            deps.writeStdout(message);
+            return message;
+        }
+        catch {
+            const message = "error: no agent context — use --agent <name> to specify";
+            deps.writeStdout(message);
+            return message;
+        }
+    }
+    /* v8 ignore stop */
     // ── 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/inner-status.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInnerStatusOutput = buildInnerStatusOutput;
+const runtime_1 = require("../../nerves/runtime");
+function formatRelativeTime(elapsedMs) {
+    const minutes = Math.floor(elapsedMs / (60 * 1000));
+    if (minutes < 1)
+        return "just now";
+    if (minutes === 1)
+        return "1 minute ago";
+    if (minutes < 60)
+        return `${minutes} minutes ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours === 1)
+        return "1 hour ago";
+    return `${hours} hours ago`;
+}
+function formatCadence(cadenceMs) {
+    const minutes = Math.round(cadenceMs / (60 * 1000));
+    if (minutes >= 60) {
+        const hours = Math.round(minutes / 60);
+        return `${hours}h`;
+    }
+    return `${minutes}m`;
+}
+function buildInnerStatusOutput(input) {
+    const { agentName, runtimeState, journalFiles, heartbeat, attentionCount, now } = input;
+    const lines = [];
+    lines.push(`inner dialog status: ${agentName}`);
+    // Last turn
+    if (runtimeState?.lastCompletedAt) {
+        const lastMs = new Date(runtimeState.lastCompletedAt).getTime();
+        const elapsed = now - lastMs;
+        const relativeTime = formatRelativeTime(elapsed);
+        const reasonSuffix = runtimeState.reason ? ` (${runtimeState.reason})` : "";
+        lines.push(`  last turn: ${relativeTime}${reasonSuffix}`);
+    }
+    else {
+        lines.push("  last turn: unknown");
+    }
+    // Status
+    if (runtimeState) {
+        const reasonSuffix = runtimeState.status === "running" && runtimeState.reason ? ` (${runtimeState.reason})` : "";
+        lines.push(`  status: ${runtimeState.status}${reasonSuffix}`);
+    }
+    else {
+        lines.push("  status: unknown");
+    }
+    // Heartbeat health
+    if (heartbeat && heartbeat.lastCompletedAt !== null) {
+        const elapsed = now - heartbeat.lastCompletedAt;
+        const threshold = heartbeat.cadenceMs * 1.5;
+        const health = elapsed < threshold ? "healthy" : "overdue";
+        const cadenceStr = formatCadence(heartbeat.cadenceMs);
+        const sinceStr = formatRelativeTime(elapsed);
+        lines.push(`  heartbeat: ${health} (cadence ${cadenceStr}, ${sinceStr})`);
+    }
+    else {
+        lines.push("  heartbeat: unknown");
+    }
+    // Journal
+    if (journalFiles.length === 0) {
+        lines.push("  journal: (empty)");
+    }
+    else {
+        lines.push("  journal:");
+        const sorted = [...journalFiles].sort((a, b) => b.mtimeMs - a.mtimeMs);
+        for (const file of sorted) {
+            const elapsed = now - file.mtimeMs;
+            const relativeTime = formatRelativeTime(elapsed);
+            lines.push(`    - ${file.name} (${relativeTime})`);
+        }
+    }
+    // Attention
+    const thoughtWord = attentionCount === 1 ? "thought" : "thoughts";
+    lines.push(`  attention: ${attentionCount} held ${thoughtWord}`);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.inner_status_read",
+        message: "inner dialog status read",
+        meta: {
+            agentName,
+            status: runtimeState?.status ?? "unknown",
+            journalCount: journalFiles.length,
+            attentionCount,
+        },
+    });
+    return lines.join("\n");
+}

package/dist/repertoire/tools.js

@@ -48,6 +48,7 @@ const guardrails_1 = require("./guardrails");
 const identity_1 = require("../heart/identity");
 const surface_tool_1 = require("../senses/surface-tool");
 const obligations_1 = require("../mind/obligations");
+const obligations_2 = require("../heart/obligations");
 const session_activity_1 = require("../heart/session-activity");
 const path = __importStar(require("path"));
 function safeGetAgentRoot() {
@@ -207,6 +208,20 @@ const surfaceToolDefinition = {
                 }
                 /* v8 ignore stop */
             },
+            fulfillHeartObligation: (origin) => {
+                /* v8 ignore start -- heart obligation fulfillment: tested via surface-tool.test.ts @preserve */
+                try {
+                    const agentRoot = (0, identity_1.getAgentRoot)();
+                    const heartObligation = (0, obligations_2.findPendingObligationForOrigin)(agentRoot, origin);
+                    if (heartObligation) {
+                        (0, obligations_2.fulfillObligation)(agentRoot, heartObligation.id);
+                    }
+                }
+                catch {
+                    // swallowed — heart obligation fulfillment must never break surface delivery
+                }
+                /* v8 ignore stop */
+            },
         });
     },
     summaryKeys: ["content", "delegationId"],

package/dist/senses/surface-tool.js

@@ -31,7 +31,7 @@ exports.surfaceToolDef = {
     },
 };
 async function handleSurface(input) {
-    const { content, delegationId, friendId, queue, routeToFriend, advanceObligation } = input;
+    const { content, delegationId, friendId, queue, routeToFriend, advanceObligation, fulfillHeartObligation } = input;
     // Resolve target friend
     let targetFriendId;
     let queueItem;
@@ -74,6 +74,19 @@ async function handleSurface(input) {
                 returnTarget: "surface",
             });
         }
+        // Fulfill the heart obligation for this origin (separate from inner/mind obligation)
+        if (fulfillHeartObligation) {
+            try {
+                fulfillHeartObligation({
+                    friendId: queueItem.friendId,
+                    channel: queueItem.channel,
+                    key: queueItem.key,
+                });
+            }
+            catch {
+                // swallowed — heart obligation fulfillment must never break surface delivery
+            }
+        }
         (0, attention_queue_1.dequeueAttentionItem)(queue, delegationId);
     }
     // Return delivery status

package/package.json

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