@ouro.bot/cli 0.1.0-alpha.147 → 0.1.0-alpha.148

package/dist/senses/inner-dialog-worker.js

@@ -1,33 +1,63 @@
 "use strict";
+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.createInnerDialogWorker = createInnerDialogWorker;
 exports.startInnerDialogWorker = startInnerDialogWorker;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const inner_dialog_1 = require("./inner-dialog");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
 const pending_1 = require("../mind/pending");
+const habit_parser_1 = require("../heart/daemon/habit-parser");
 function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options), hasPendingWork = () => (0, pending_1.hasPendingMessages)((0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)()))) {
     let running = false;
-    let rerunRequested = false;
-    let rerunReason = "instinct";
-    let rerunTaskId;
-    async function run(reason, taskId) {
+    const queue = [];
+    async function run(reason, taskId, habitName) {
         if (running) {
-            rerunRequested = true;
-            rerunReason = reason;
-            if (taskId !== undefined) {
-                rerunTaskId = taskId;
-            }
+            queue.push({ reason, taskId, habitName });
             return;
         }
         running = true;
         try {
             let nextReason = reason;
             let nextTaskId = taskId;
+            let nextHabitName = habitName;
             do {
-                rerunRequested = false;
                 try {
-                    await runTurn({ reason: nextReason, taskId: nextTaskId });
+                    await runTurn({ reason: nextReason, taskId: nextTaskId, habitName: nextHabitName });
                 }
                 catch (error) {
                     (0, runtime_1.emitNervesEvent)({
@@ -41,15 +71,44 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                         },
                     });
                 }
-                if (!rerunRequested && hasPendingWork()) {
-                    rerunRequested = true;
-                    rerunReason = "instinct";
+                // Update lastRun in habit frontmatter after a habit turn
+                if (nextReason === "habit" && nextHabitName) {
+                    try {
+                        const agentRoot = (0, identity_1.getAgentRoot)();
+                        const habitFilePath = path.join(agentRoot, "habits", `${nextHabitName}.md`);
+                        const content = fs.readFileSync(habitFilePath, "utf-8");
+                        const parsed = (0, habit_parser_1.parseHabitFile)(content, habitFilePath);
+                        const frontmatter = {
+                            title: parsed.title,
+                            cadence: parsed.cadence,
+                            status: parsed.status,
+                            lastRun: new Date().toISOString(),
+                            created: parsed.created,
+                        };
+                        const rendered = (0, habit_parser_1.renderHabitFile)(frontmatter, parsed.body);
+                        fs.writeFileSync(habitFilePath, rendered, "utf-8");
+                    }
+                    catch {
+                        // Habit file may have been deleted during the turn — skip gracefully
+                    }
+                }
+                // Drain queue first
+                if (queue.length > 0) {
+                    const next = queue.shift();
+                    nextReason = next.reason;
+                    nextTaskId = next.taskId;
+                    nextHabitName = next.habitName;
+                    continue;
+                }
+                // Then check hasPendingWork fallback
+                if (hasPendingWork()) {
+                    nextReason = "instinct";
+                    nextTaskId = undefined;
+                    nextHabitName = undefined;
+                    continue;
                 }
-                nextReason = rerunReason;
-                nextTaskId = rerunTaskId;
-                rerunReason = "instinct";
-                rerunTaskId = undefined;
-            } while (rerunRequested);
+                break;
+            } while (true);
         }
         finally {
             running = false;
@@ -59,8 +118,13 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
         if (!message || typeof message !== "object")
             return;
         const maybeMessage = message;
+        if (maybeMessage.type === "habit") {
+            await run("habit", undefined, maybeMessage.habitName);
+            return;
+        }
         if (maybeMessage.type === "heartbeat") {
-            await run("heartbeat");
+            // Backward compatibility: heartbeat -> habit/heartbeat
+            await run("habit", undefined, "heartbeat");
             return;
         }
         if (maybeMessage.type === "poke") {

package/dist/senses/inner-dialog.js

@@ -43,6 +43,7 @@ exports.deriveResumeCheckpoint = deriveResumeCheckpoint;
 exports.innerDialogSessionPath = innerDialogSessionPath;
 exports.enrichDelegatedFromWithBridge = enrichDelegatedFromWithBridge;
 exports.routeDelegatedCompletion = routeDelegatedCompletion;
+exports.buildParseErrorNudge = buildParseErrorNudge;
 exports.runInnerDialogTurn = runInnerDialogTurn;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -68,6 +69,8 @@ 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 habit_parser_1 = require("../heart/daemon/habit-parser");
+const cadence_1 = require("../heart/daemon/cadence");
 const DEFAULT_INNER_DIALOG_INSTINCTS = [
     {
         id: "heartbeat_checkin",
@@ -127,9 +130,10 @@ function buildInstinctUserMessage(instincts, _reason, state) {
     return lines.join("\n");
 }
 function readTaskFile(agentRoot, taskId) {
-    // Task files live in collection subdirectories (one-shots, ongoing, habits).
+    // Task files live in collection subdirectories (one-shots, ongoing).
     // Try each collection, then fall back to root tasks/ for legacy layout.
-    const collections = ["one-shots", "ongoing", "habits", ""];
+    // Habits are no longer in tasks/ — they live at bundle root habits/.
+    const collections = ["one-shots", "ongoing", ""];
     for (const collection of collections) {
         try {
             return fs.readFileSync(path.join(agentRoot, "tasks", collection, `${taskId}.md`), "utf8").trim();
@@ -460,9 +464,57 @@ function createNoOpFriendStore() {
         findByExternalId: async () => null,
     };
 }
+function buildParseErrorNudge(parseErrors) {
+    if (parseErrors.length === 0)
+        return "";
+    const lines = parseErrors.map((e) => `I noticed my habit file \`${e.file}\` has invalid frontmatter — I should fix it. (${e.error})`);
+    return lines.join("\n");
+}
+function buildAlsoDueLine(agentRoot, currentHabitName, now) {
+    const habitsDir = path.join(agentRoot, "habits");
+    let files;
+    try {
+        files = fs.readdirSync(habitsDir);
+    }
+    catch {
+        return "";
+    }
+    const nowMs = now().getTime();
+    const alsoDue = [];
+    for (const file of files) {
+        if (!file.endsWith(".md"))
+            continue;
+        const stem = file.replace(/\.md$/, "");
+        if (stem === currentHabitName)
+            continue;
+        try {
+            const content = fs.readFileSync(path.join(habitsDir, file), "utf-8");
+            const habit = (0, habit_parser_1.parseHabitFile)(content, path.join(habitsDir, file));
+            if (habit.status !== "active" || !habit.cadence)
+                continue;
+            const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
+            if (cadenceMs === null)
+                continue;
+            if (habit.lastRun === null) {
+                alsoDue.push(stem);
+                continue;
+            }
+            const lastRunMs = new Date(habit.lastRun).getTime();
+            if (nowMs - lastRunMs >= cadenceMs) {
+                alsoDue.push(stem);
+            }
+        }
+        catch {
+            // skip unreadable habits
+        }
+    }
+    if (alsoDue.length === 0)
+        return "";
+    return `also due: ${alsoDue.join(", ")}`;
+}
 async function runInnerDialogTurn(options) {
     const now = options?.now ?? (() => new Date());
-    const reason = options?.reason ?? "heartbeat";
+    const reason = options?.reason ?? "instinct";
     const sessionFilePath = innerDialogSessionPath();
     const agentName = (0, identity_1.getAgentName)();
     writeInnerDialogRuntimeState(sessionFilePath, {
@@ -500,47 +552,101 @@ async function runInnerDialogTurn(options) {
                 const taskContent = readTaskFile((0, identity_1.getAgentRoot)(), options.taskId);
                 userContent = buildTaskTriggeredMessage(options.taskId, taskContent, state.checkpoint);
             }
-            else if (reason === "heartbeat") {
+            else if (reason === "habit" && options?.habitName) {
                 const agentRoot = (0, identity_1.getAgentRoot)();
-                const journalDir = path.join(agentRoot, "journal");
-                const runtimeStatePath = innerDialogRuntimeStatePath(sessionFilePath);
-                // Read lastCompletedAt from current runtime state
-                let lastCompletedAt;
+                const habitName = options.habitName;
+                const habitFilePath = path.join(agentRoot, "habits", `${habitName}.md`);
+                // Read and parse the habit file
+                let habitBody;
+                let habitLastRun = null;
                 try {
-                    const raw = fs.readFileSync(runtimeStatePath, "utf-8");
-                    const runtimeState = JSON.parse(raw);
-                    lastCompletedAt = typeof runtimeState.lastCompletedAt === "string" ? runtimeState.lastCompletedAt : undefined;
+                    const habitContent = fs.readFileSync(habitFilePath, "utf-8");
+                    const parsed = (0, habit_parser_1.parseHabitFile)(habitContent, habitFilePath);
+                    habitBody = parsed.body;
+                    habitLastRun = parsed.lastRun;
                 }
                 catch {
-                    // no runtime state — will get cold start fallback
+                    // Habit file missing or unreadable
+                }
+                if (habitName === "heartbeat") {
+                    // Heartbeat habit: use contextual heartbeat builder with habit body
+                    const journalDir = path.join(agentRoot, "journal");
+                    const runtimeStatePath = innerDialogRuntimeStatePath(sessionFilePath);
+                    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
+                    }
+                    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,
+                    }));
+                    const heartbeatContent = (0, contextual_heartbeat_1.buildContextualHeartbeat)({
+                        journalDir,
+                        lastCompletedAt,
+                        pendingObligations,
+                        lastSurfaceAt: undefined,
+                        checkpoint: state.checkpoint,
+                        now,
+                        readJournalDir: () => (0, prompt_1.readJournalFiles)(journalDir),
+                        habitBody,
+                    });
+                    // Build also-due line
+                    const alsoDue = buildAlsoDueLine(agentRoot, habitName, now);
+                    userContent = alsoDue ? `${heartbeatContent}\n\n${alsoDue}` : heartbeatContent;
+                    // Parse error nudge
+                    const parseErrorNudge = buildParseErrorNudge(options?.parseErrors ?? []);
+                    if (parseErrorNudge)
+                        userContent = `${userContent}\n\n${parseErrorNudge}`;
+                    // 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 if (habitBody !== undefined) {
+                    // Non-heartbeat habit: basic context + body
+                    const sections = [];
+                    // Elapsed time since last run
+                    if (habitLastRun) {
+                        const lastRunMs = new Date(habitLastRun).getTime();
+                        const elapsed = now().getTime() - lastRunMs;
+                        const minutes = Math.floor(elapsed / 60000);
+                        if (minutes < 60) {
+                            sections.push(`it's been ${minutes} ${minutes === 1 ? "minute" : "minutes"} since ${habitName} last ran.`);
+                        }
+                        else {
+                            const hours = Math.floor(minutes / 60);
+                            sections.push(`it's been ${hours} ${hours === 1 ? "hour" : "hours"} since ${habitName} last ran.`);
+                        }
+                    }
+                    sections.push(`## habit: ${habitName}\n${habitBody}`);
+                    // Also due line
+                    const alsoDue = buildAlsoDueLine(agentRoot, habitName, now);
+                    if (alsoDue)
+                        sections.push(alsoDue);
+                    // Parse error nudge
+                    const parseErrorNudge = buildParseErrorNudge(options?.parseErrors ?? []);
+                    if (parseErrorNudge)
+                        sections.push(parseErrorNudge);
+                    userContent = sections.join("\n\n");
+                }
+                else {
+                    // Habit file not found
+                    userContent = `habit "${habitName}" could not be read (file not found or unreadable). check habits/${habitName}.md exists.`;
                 }
-                // 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.147",
+  "version": "0.1.0-alpha.148",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",

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

@@ -1,132 +0,0 @@
-"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 once after a full cadence (not immediately, to avoid spin loop
-            // when the agent has no inner dialog state to write lastCompletedAt)
-            delay = cadenceMs;
-        }
-        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;