@ouro.bot/cli 0.1.0-alpha.138 → 0.1.0-alpha.139

package/changelog.json

@@ -1,6 +1,16 @@
 {
   "_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.139",
+      "changes": [
+        "Daemon-internal heartbeat timer: self-correcting setTimeout loop reads cadence from heartbeat task file, computes delay from lastCompletedAt, fires IPC {type: heartbeat}. One timer per managed agent.",
+        "Heartbeat fires immediately when agent is overdue (elapsed > cadence) or has never run (no runtime state).",
+        "Contextual heartbeat message: journal index (up to 10 files with recency and preview), elapsed time since last turn, pending attention count, journal entries since last surface, stale obligation alerts (>30 min).",
+        "Bare instinct prompt now cold-start fallback only; resumed heartbeat sessions get contextual message.",
+        "Journal embedding indexing piggybacked during heartbeat turns (best-effort, fire-and-forget)."
+      ]
+    },
     {
       "version": "0.1.0-alpha.138",
       "changes": [

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

@@ -47,6 +47,7 @@ const sense_manager_1 = require("./sense-manager");
 const agent_discovery_1 = require("./agent-discovery");
 const identity_1 = require("../identity");
 const runtime_mode_1 = require("./runtime-mode");
+const heartbeat_timer_1 = require("./heartbeat-timer");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -115,7 +116,27 @@ const daemon = new daemon_1.OuroDaemon({
     router,
     mode,
 });
-void daemon.start().catch(async () => {
+const heartbeatTimers = [];
+/* v8 ignore start -- heartbeat wiring: lambdas delegate to processManager/fs; tested via HeartbeatTimer unit tests @preserve */
+void daemon.start().then(() => {
+    const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+    for (const agent of managedAgents) {
+        const bundleRoot = path.join(bundlesRoot, `${agent}.ouro`);
+        const timer = new heartbeat_timer_1.HeartbeatTimer({
+            agent,
+            sendToAgent: (a, msg) => processManager.sendToAgent(a, msg),
+            deps: {
+                readFileSync: (p, enc) => fs.readFileSync(p, enc),
+                readdirSync: (p) => fs.readdirSync(p).map((e) => (typeof e === "string" ? e : e)),
+                heartbeatTaskDir: path.join(bundleRoot, "tasks", "habits"),
+                runtimeStatePath: path.join(bundleRoot, "state", "sessions", "self", "inner", "runtime.json"),
+            },
+        });
+        timer.start();
+        heartbeatTimers.push(timer);
+    }
+}).catch(async () => {
+    /* v8 ignore stop */
     (0, runtime_1.emitNervesEvent)({
         level: "error",
         component: "daemon",
@@ -127,8 +148,12 @@ void daemon.start().catch(async () => {
     process.exit(1);
 });
 process.on("SIGINT", () => {
+    for (const timer of heartbeatTimers)
+        timer.stop();
     void daemon.stop().then(() => process.exit(0));
 });
 process.on("SIGTERM", () => {
+    for (const timer of heartbeatTimers)
+        timer.stop();
     void daemon.stop().then(() => process.exit(0));
 });

package/dist/heart/daemon/heartbeat-timer.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeartbeatTimer = exports.DEFAULT_CADENCE_MS = void 0;
+exports.parseCadenceMs = parseCadenceMs;
+const runtime_1 = require("../../nerves/runtime");
+const parser_1 = require("../../repertoire/tasks/parser");
+exports.DEFAULT_CADENCE_MS = 30 * 60 * 1000; // 30 minutes
+function parseCadenceMs(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    const match = /^(\d+)(m|h|d)$/.exec(value);
+    if (!match)
+        return null;
+    const interval = Number.parseInt(match[1], 10);
+    if (!Number.isFinite(interval) || interval <= 0)
+        return null;
+    const unit = match[2];
+    if (unit === "m")
+        return interval * 60 * 1000;
+    if (unit === "h")
+        return interval * 60 * 60 * 1000;
+    return interval * 24 * 60 * 60 * 1000;
+}
+class HeartbeatTimer {
+    agent;
+    sendToAgent;
+    readFileSync;
+    readdirSync;
+    heartbeatTaskDir;
+    runtimeStatePath;
+    now;
+    pendingTimer = null;
+    constructor(options) {
+        this.agent = options.agent;
+        this.sendToAgent = options.sendToAgent;
+        this.readFileSync = options.deps.readFileSync;
+        this.readdirSync = options.deps.readdirSync;
+        this.heartbeatTaskDir = options.deps.heartbeatTaskDir;
+        this.runtimeStatePath = options.deps.runtimeStatePath;
+        this.now = options.deps.now ?? (() => Date.now());
+    }
+    start() {
+        this.scheduleNext();
+    }
+    stop() {
+        if (this.pendingTimer !== null) {
+            clearTimeout(this.pendingTimer);
+            this.pendingTimer = null;
+        }
+    }
+    scheduleNext() {
+        const cadenceMs = this.readCadence();
+        const lastCompletedAt = this.readLastCompletedAt();
+        const nowMs = this.now();
+        let delay;
+        if (lastCompletedAt === null) {
+            // Never run before — fire immediately
+            delay = 0;
+        }
+        else {
+            const elapsed = nowMs - lastCompletedAt;
+            delay = Math.max(0, cadenceMs - elapsed);
+        }
+        this.pendingTimer = setTimeout(() => {
+            this.fire();
+        }, delay);
+    }
+    fire() {
+        this.pendingTimer = null;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.heartbeat_fire",
+            message: "heartbeat timer fired",
+            meta: { agent: this.agent },
+        });
+        this.sendToAgent(this.agent, { type: "heartbeat" });
+        this.scheduleNext();
+    }
+    readCadence() {
+        // Scan habits dir for *-heartbeat.md
+        let files;
+        try {
+            files = this.readdirSync(this.heartbeatTaskDir);
+        }
+        catch {
+            return exports.DEFAULT_CADENCE_MS;
+        }
+        const heartbeatFile = files.find((f) => f.endsWith("-heartbeat.md"));
+        if (!heartbeatFile)
+            return exports.DEFAULT_CADENCE_MS;
+        try {
+            const content = this.readFileSync(`${this.heartbeatTaskDir}/${heartbeatFile}`, "utf-8");
+            const cadence = this.extractCadenceFromTaskFile(content);
+            return cadence ?? exports.DEFAULT_CADENCE_MS;
+        }
+        catch {
+            return exports.DEFAULT_CADENCE_MS;
+        }
+    }
+    extractCadenceFromTaskFile(content) {
+        // Parse frontmatter from task file to get cadence value
+        const lines = content.split(/\r?\n/);
+        if (lines[0]?.trim() !== "---")
+            return null;
+        const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+        if (closing === -1)
+            return null;
+        const rawFrontmatter = lines.slice(1, closing).join("\n");
+        const frontmatter = (0, parser_1.parseFrontmatter)(rawFrontmatter);
+        return parseCadenceMs(frontmatter.cadence);
+    }
+    readLastCompletedAt() {
+        try {
+            const raw = this.readFileSync(this.runtimeStatePath, "utf-8");
+            const state = JSON.parse(raw);
+            if (typeof state.lastCompletedAt !== "string")
+                return null;
+            const ms = new Date(state.lastCompletedAt).getTime();
+            if (Number.isNaN(ms))
+                return null;
+            return ms;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.HeartbeatTimer = HeartbeatTimer;

package/dist/mind/prompt.js

@@ -44,6 +44,7 @@ exports.commitmentsSection = commitmentsSection;
 exports.delegationHintSection = delegationHintSection;
 exports.contextSection = contextSection;
 exports.metacognitiveFramingSection = metacognitiveFramingSection;
+exports.readJournalFiles = readJournalFiles;
 exports.journalSection = journalSection;
 exports.loopOrientationSection = loopOrientationSection;
 exports.channelNatureSection = channelNatureSection;

package/dist/senses/contextual-heartbeat.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContextualHeartbeat = buildContextualHeartbeat;
+const runtime_1 = require("../nerves/runtime");
+const STALE_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
+const MAX_JOURNAL_FILES = 10;
+function formatElapsed(ms) {
+    const minutes = Math.floor(ms / 60000);
+    if (minutes < 60) {
+        return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+    }
+    const hours = Math.floor(minutes / 60);
+    return `${hours} ${hours === 1 ? "hour" : "hours"}`;
+}
+function formatRelativeTime(nowMs, mtimeMs) {
+    const diffMs = nowMs - mtimeMs;
+    const minutes = Math.floor(diffMs / 60000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} ${minutes === 1 ? "minute" : "minutes"} ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} ${hours === 1 ? "hour" : "hours"} ago`;
+    const days = Math.floor(hours / 24);
+    return `${days} ${days === 1 ? "day" : "days"} ago`;
+}
+function buildContextualHeartbeat(options) {
+    const { lastCompletedAt, pendingObligations, lastSurfaceAt, checkpoint, now, readJournalDir, } = options;
+    const nowDate = now();
+    const nowMs = nowDate.getTime();
+    const journalFiles = readJournalDir();
+    // Cold start: no journal files and no runtime state
+    if (journalFiles.length === 0 && !lastCompletedAt) {
+        const lines = ["...time passing. anything stirring?"];
+        if (checkpoint) {
+            lines.push(`\nlast i remember: ${checkpoint}`);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.contextual_heartbeat_built",
+            message: "contextual heartbeat built (cold start)",
+            meta: { coldStart: true },
+        });
+        return lines.join("\n");
+    }
+    const sections = [];
+    // Elapsed time since last turn
+    if (lastCompletedAt) {
+        const lastMs = new Date(lastCompletedAt).getTime();
+        const elapsed = nowMs - lastMs;
+        sections.push(`it's been ${formatElapsed(elapsed)} since your last turn.`);
+    }
+    // Pending attention count
+    if (pendingObligations.length > 0) {
+        const count = pendingObligations.length;
+        sections.push(`you're holding ${count} ${count === 1 ? "thought" : "thoughts"}.`);
+    }
+    // Journal index
+    if (journalFiles.length > 0) {
+        const sorted = [...journalFiles].sort((a, b) => b.mtime - a.mtime).slice(0, MAX_JOURNAL_FILES);
+        const indexLines = ["## journal"];
+        for (const file of sorted) {
+            const ago = formatRelativeTime(nowMs, file.mtime);
+            const previewClause = file.preview ? ` — ${file.preview}` : "";
+            indexLines.push(`- ${file.name} (${ago})${previewClause}`);
+        }
+        sections.push(indexLines.join("\n"));
+    }
+    // Journal entries since last surface
+    if (lastSurfaceAt && journalFiles.length > 0) {
+        const surfaceMs = new Date(lastSurfaceAt).getTime();
+        const entriesSinceSurface = journalFiles.filter((f) => f.mtime > surfaceMs).length;
+        if (entriesSinceSurface > 0) {
+            const surfaceElapsed = formatElapsed(nowMs - surfaceMs);
+            sections.push(`${entriesSinceSurface} journal ${entriesSinceSurface === 1 ? "entry" : "entries"} since you last surfaced, ${surfaceElapsed} ago.`);
+        }
+    }
+    // Stale obligation alerts
+    const staleObligations = pendingObligations.filter((o) => o.staleness >= STALE_THRESHOLD_MS);
+    if (staleObligations.length > 0) {
+        for (const obligation of staleObligations) {
+            sections.push(`this has been sitting for ${formatElapsed(obligation.staleness)}: ${obligation.content}`);
+        }
+    }
+    // Checkpoint
+    if (checkpoint) {
+        sections.push(`last i remember: ${checkpoint}`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.contextual_heartbeat_built",
+        message: "contextual heartbeat built",
+        meta: {
+            hasJournal: journalFiles.length > 0,
+            hasLastCompleted: !!lastCompletedAt,
+            obligationCount: pendingObligations.length,
+            staleCount: staleObligations.length,
+        },
+    });
+    return sections.join("\n\n");
+}

package/dist/senses/inner-dialog.js

@@ -66,6 +66,8 @@ const manager_1 = require("../heart/bridges/manager");
 const session_activity_1 = require("../heart/session-activity");
 const bluebubbles_1 = require("./bluebubbles");
 const obligations_2 = require("../heart/obligations");
+const contextual_heartbeat_1 = require("./contextual-heartbeat");
+const journal_index_1 = require("../mind/journal-index");
 const DEFAULT_INNER_DIALOG_INSTINCTS = [
     {
         id: "heartbeat_checkin",
@@ -483,6 +485,48 @@ async function runInnerDialogTurn(options) {
                 const taskContent = readTaskFile((0, identity_1.getAgentRoot)(), options.taskId);
                 userContent = buildTaskTriggeredMessage(options.taskId, taskContent, state.checkpoint);
             }
+            else if (reason === "heartbeat") {
+                const agentRoot = (0, identity_1.getAgentRoot)();
+                const journalDir = path.join(agentRoot, "journal");
+                const runtimeStatePath = innerDialogRuntimeStatePath(sessionFilePath);
+                // Read lastCompletedAt from current runtime state
+                let lastCompletedAt;
+                try {
+                    const raw = fs.readFileSync(runtimeStatePath, "utf-8");
+                    const runtimeState = JSON.parse(raw);
+                    lastCompletedAt = typeof runtimeState.lastCompletedAt === "string" ? runtimeState.lastCompletedAt : undefined;
+                }
+                catch {
+                    // no runtime state — will get cold start fallback
+                }
+                // Gather pending obligations for display
+                const obligations = (0, obligations_1.listActiveObligations)(agentName);
+                const nowMs = now().getTime();
+                const pendingObligations = obligations.map((o) => ({
+                    id: o.id,
+                    content: o.delegatedContent,
+                    friendName: o.origin.friendId,
+                    timestamp: o.createdAt,
+                    staleness: nowMs - o.createdAt,
+                }));
+                userContent = (0, contextual_heartbeat_1.buildContextualHeartbeat)({
+                    journalDir,
+                    lastCompletedAt,
+                    pendingObligations,
+                    lastSurfaceAt: undefined, // TODO: wire when surface tracking is added
+                    checkpoint: state.checkpoint,
+                    now,
+                    readJournalDir: () => (0, prompt_1.readJournalFiles)(journalDir),
+                });
+                // Piggyback journal embedding indexing (best-effort, fire-and-forget)
+                /* v8 ignore start -- journal indexing piggyback: embedding provider may not be available; tested via journal-index unit tests @preserve */
+                void (0, journal_index_1.indexJournalFiles)(journalDir, path.join(journalDir, ".index.json"), {
+                    embed: async () => [],
+                }).catch(() => {
+                    // swallowed: indexing failure must never block heartbeat
+                });
+                /* v8 ignore stop */
+            }
             else {
                 userContent = buildInstinctUserMessage(instincts, reason, state);
             }

package/package.json

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