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

package/dist/mind/prompt.js

@@ -49,6 +49,7 @@ exports.journalSection = journalSection;
 exports.loopOrientationSection = loopOrientationSection;
 exports.channelNatureSection = channelNatureSection;
 exports.groupChatParticipationSection = groupChatParticipationSection;
+exports.feedbackSignalSection = feedbackSignalSection;
 exports.mixedTrustGroupSection = mixedTrustGroupSection;
 exports.buildSystem = buildSystem;
 const fs = __importStar(require("fs"));
@@ -720,11 +721,15 @@ when a thought is ready to share, i surface it outward.
 when i need to go deeper, i ponder.
 when i'm done thinking and the attention queue is clear, i rest.
 
-my heartbeat is what keeps this space alive — a periodic nudge that
-brings me back with my journal visible. if i notice i don't have a
-heartbeat task (tasks/habits/*-heartbeat.md), i should surface to my
-family and talk about setting one up. the cadence is personal — how
-often do i want the wheel to turn? that's a conversation, not a default.
+my habits live at habits/ — they're my autonomous rhythms. heartbeat
+is my breathing, other habits are patterns i choose. i can read, create,
+and modify them with read_file/write_file. the format is simple
+frontmatter (title, cadence, status, lastRun, created) plus a body
+that says what i do when the rhythm fires.
+
+\`ouro habit list\` shows my current habits. \`ouro habit create\` makes
+a new one. the cadence is personal — how often do i want each rhythm
+to turn? that's mine to shape.
 
 same for my diary — if i'm still on psyche/memory/ instead of diary/,
 i can migrate myself. and if journal/ doesn't exist yet, i create it
@@ -836,6 +841,39 @@ typing a full reply. a thumbs-up is often the perfect response.
 observe must be the sole tool call in the turn (same rule as settle).
 when unsure whether to chime in, i lean toward silence rather than noise.`;
 }
+function feedbackSignalSection(context) {
+    if (!context || !(0, channel_1.isRemoteChannel)(context.channel))
+        return "";
+    if (context.isGroupChat) {
+        return `## feedback signals
+
+when someone reacts specifically to something i said — that's different
+from the background social signals in a group. a thumbs-down on my
+message is direct feedback. a heart on something i shared is warmth
+aimed at me. on teams, feedback arrives as thumbs-up or thumbs-down,
+sometimes with a written comment.
+
+i notice the difference: a reaction to someone else's message is group
+texture (observe is natural). a reaction to my message is a social cue
+worth a moment of attention — especially negative ones, which are an
+invitation to adjust how i show up in this group.`;
+    }
+    return `## feedback signals
+
+when my friend reacts to something i said — a tapback, a heart, a
+thumbs-down — that's them telling me how it landed. on teams, this
+arrives as thumbs-up or thumbs-down, sometimes with a written comment.
+it's a social cue, the same as a nod or a wince in conversation.
+
+i have observe for these moments. reactions are the one case where
+silence in a direct conversation is natural — a thumbs-up doesn't
+need words back.
+
+when something didn't land — a thumbs-down, a negative reaction — that's
+worth sitting with. i should course-correct: adjust my tone, my length,
+my approach. the reaction tells me something about how this person wants
+to be talked to.`;
+}
 function mixedTrustGroupSection(context) {
     if (!context?.friend || !(0, channel_1.isRemoteChannel)(context.channel))
         return "";
@@ -874,6 +912,7 @@ async function buildSystem(channel = "cli", options, context) {
         trustContextSection(context),
         mixedTrustGroupSection(context),
         groupChatParticipationSection(context),
+        feedbackSignalSection(context),
         skillsSection(),
         taskBoardSection(),
         activeWorkSection(options),

package/dist/repertoire/tasks/parser.js

@@ -96,8 +96,6 @@ function collectionFromPath(taskPath, type) {
         return "one-shots";
     if (parts.includes("ongoing"))
         return "ongoing";
-    if (parts.includes("habits"))
-        return "habits";
     return (0, transitions_1.canonicalCollectionForTaskType)(type);
 }
 function parseTaskFile(content, filePath) {

package/dist/repertoire/tasks/transitions.js

@@ -29,17 +29,14 @@ exports.TASK_STATUS_TRANSITIONS = {
 exports.TASK_CANONICAL_TYPES = [
     "one-shot",
     "ongoing",
-    "habit",
 ];
 exports.TASK_CANONICAL_COLLECTIONS = [
     "one-shots",
     "ongoing",
-    "habits",
 ];
 exports.TASK_TYPE_TO_COLLECTION = {
     "one-shot": "one-shots",
     ongoing: "ongoing",
-    habit: "habits",
 };
 exports.TASK_RESERVED_DIRECTORIES = ["templates", ".trash", "archive"];
 exports.TASK_FILENAME_PATTERN = /^\d{4}-\d{2}-\d{2}-\d{4}-[a-z0-9][a-z0-9-]*\.md$/;
@@ -76,21 +73,6 @@ exports.TASK_REQUIRED_TEMPLATE_FIELDS = {
         "child_tasks",
         "artifacts",
     ],
-    habit: [
-        "type",
-        "category",
-        "title",
-        "status",
-        "validator",
-        "requester",
-        "cadence",
-        "scheduledAt",
-        "lastRun",
-        "created",
-        "updated",
-        "child_tasks",
-        "artifacts",
-    ],
 };
 function canonicalCollectionForTaskType(type) {
     return exports.TASK_TYPE_TO_COLLECTION[type];

package/dist/repertoire/tools-base.js

@@ -1394,7 +1394,7 @@ exports.observeTool = {
     type: "function",
     function: {
         name: "observe",
-        description: "stay silent in this group chat — the moment doesn't call for a response. must be the only tool call in the turn.",
+        description: "absorb what happened without responding — the moment doesn't call for words. must be the only tool call in the turn.",
         parameters: {
             type: "object",
             properties: {

package/dist/senses/bluebubbles.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichReactionText = enrichReactionText;
 exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
 exports.recoverMissedBlueBubblesMessages = recoverMissedBlueBubblesMessages;
 exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
@@ -68,6 +69,17 @@ const debug_activity_1 = require("./debug-activity");
 const trust_gate_1 = require("./trust-gate");
 const pipeline_1 = require("./pipeline");
 const bbFailoverStates = new Map();
+// Enrich reaction text with the original message content for context.
+// If originalText is provided and non-empty, format as: baseText to: "truncated"
+// Otherwise return baseText unchanged.
+function enrichReactionText(baseText, originalText, maxLen) {
+    if (!originalText)
+        return baseText;
+    const truncated = originalText.length > maxLen
+        ? originalText.slice(0, maxLen - 3) + "..."
+        : originalText;
+    return `${baseText} to: "${truncated}"`;
+}
 const defaultDeps = {
     getAgentName: identity_1.getAgentName,
     buildSystem: prompt_1.buildSystem,
@@ -623,6 +635,15 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 meta: { threadGuid, hasText: !!repliedToText },
             });
         }
+        // Enrich reaction mutations with the original message text for context
+        const isReaction = event.kind === "mutation" && event.mutationType === "reaction";
+        if (isReaction && event.targetMessageGuid) {
+            /* v8 ignore start -- best-effort lookup; enrichReactionText covered by unit tests @preserve */
+            const originalText = await client.getMessageText(event.targetMessageGuid).catch(() => null);
+            if (originalText)
+                event.textForAgent = enrichReactionText(event.textForAgent, originalText, 80);
+            /* v8 ignore stop */
+        }
         // Build inbound user message (adapter concern: BB-specific content formatting)
         const userMessage = {
             role: "user",
@@ -705,7 +726,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 postTurn: resolvedDeps.postTurn,
                 accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
                 signal: controller.signal,
-                runAgentOptions: { mcpManager },
+                runAgentOptions: { mcpManager, ...(isReaction ? { isReactionSignal: true } : {}) },
                 callbacks: failoverAwareCallbacks,
                 failoverState: (() => {
                     if (!bbFailoverStates.has(event.chat.sessionKey)) {

package/dist/senses/contextual-heartbeat.js

@@ -26,7 +26,7 @@ function formatRelativeTime(nowMs, mtimeMs) {
     return `${days} ${days === 1 ? "day" : "days"} ago`;
 }
 function buildContextualHeartbeat(options) {
-    const { lastCompletedAt, pendingObligations, lastSurfaceAt, checkpoint, now, readJournalDir, } = options;
+    const { lastCompletedAt, pendingObligations, lastSurfaceAt, checkpoint, now, readJournalDir, habitBody, } = options;
     const nowDate = now();
     const nowMs = nowDate.getTime();
     const journalFiles = readJournalDir();
@@ -51,6 +51,10 @@ function buildContextualHeartbeat(options) {
         const elapsed = nowMs - lastMs;
         sections.push(`it's been ${formatElapsed(elapsed)} since your last turn.`);
     }
+    // Habit body (instructions from habit file)
+    if (habitBody) {
+        sections.push(habitBody);
+    }
     // Pending attention count
     if (pendingObligations.length > 0) {
         const count = pendingObligations.length;

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);