@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.660

package/dist/senses/commands.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCommandRegistry = createCommandRegistry;
 exports.getToolChoiceRequired = getToolChoiceRequired;
 exports.resetToolChoiceRequired = resetToolChoiceRequired;
+exports.getDebugMode = getDebugMode;
+exports.resetDebugMode = resetDebugMode;
 exports.registerDefaultCommands = registerDefaultCommands;
+exports.getSharedCommandRegistry = getSharedCommandRegistry;
+exports.resetSharedCommandRegistry = resetSharedCommandRegistry;
 exports.parseSlashCommand = parseSlashCommand;
 const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
@@ -21,7 +25,7 @@ function createCommandRegistry() {
         },
         dispatch(name, ctx) {
             const cmd = commands.get(name);
-            if (!cmd)
+            if (!cmd || !cmd.channels.includes(ctx.channel))
                 return { handled: false };
             return { handled: true, result: cmd.handler(ctx) };
         },
@@ -35,6 +39,14 @@ function getToolChoiceRequired() {
 function resetToolChoiceRequired() {
     _toolChoiceRequired = false;
 }
+// Module-level toggle for debug mode
+let _debugMode = false;
+function getDebugMode() {
+    return _debugMode;
+}
+function resetDebugMode() {
+    _debugMode = false;
+}
 function registerDefaultCommands(registry) {
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_start",
@@ -51,7 +63,7 @@ function registerDefaultCommands(registry) {
     registry.register({
         name: "new",
         description: "start a new conversation",
-        channels: ["cli", "teams"],
+        channels: ["teams"],
         handler: () => ({ action: "new" }),
     });
     registry.register({
@@ -60,10 +72,36 @@ function registerDefaultCommands(registry) {
         channels: ["cli", "teams"],
         handler: (ctx) => {
             const cmds = registry.list(ctx.channel);
-            const lines = cmds.map((c) => `/${c.name} - ${c.description}`);
+            const lines = cmds.map((c) => `/${c.name} \u2014 ${c.description}`);
             return { action: "response", message: lines.join("\n") };
         },
     });
+    registry.register({
+        name: "help",
+        description: "show keyboard shortcuts and tips",
+        channels: ["cli"],
+        /* v8 ignore start -- integration: /help command tested via E2E @preserve */
+        handler: () => ({
+            action: "response",
+            message: [
+                "Keyboard shortcuts:",
+                "  Ctrl-C        abort current generation / clear input / exit (twice within 2s)",
+                "  Escape        clear input",
+                "  ↑ / ↓         browse input history (includes previous sessions)",
+                "  Option+← / →  jump between words",
+                "  Ctrl+A / E    jump to start / end of line",
+                "  Option+Delete  delete word backward",
+                "  Option+D      delete word forward",
+                "  Alt+Enter     insert newline (multi-line input)",
+                "",
+                "Commands:",
+                "  /help         this help",
+                "  /commands     list all commands",
+                "  /exit         quit",
+            ].join("\n"),
+        }),
+        /* v8 ignore stop */
+    });
     registry.register({
         name: "tool-required",
         description: "toggle tool_choice required mode (forces tool calls)",
@@ -73,6 +111,20 @@ function registerDefaultCommands(registry) {
             return { action: "response", message: `tool-required mode: ${_toolChoiceRequired ? "ON" : "OFF"}` };
         },
     });
+    registry.register({
+        name: "debug",
+        description: "toggle debug mode — see more detail about what I'm doing",
+        channels: ["cli", "teams", "bluebubbles", "mail", "mcp"],
+        handler: () => {
+            _debugMode = !_debugMode;
+            return {
+                action: "response",
+                message: _debugMode
+                    ? "debug mode on — you'll see more detail about what I'm doing"
+                    : "debug mode off — back to clean output",
+            };
+        },
+    });
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",
         component: "repertoire",
@@ -80,6 +132,17 @@ function registerDefaultCommands(registry) {
         meta: {},
     });
 }
+let _sharedRegistry = null;
+function getSharedCommandRegistry() {
+    if (!_sharedRegistry) {
+        _sharedRegistry = createCommandRegistry();
+        registerDefaultCommands(_sharedRegistry);
+    }
+    return _sharedRegistry;
+}
+function resetSharedCommandRegistry() {
+    _sharedRegistry = null;
+}
 function parseSlashCommand(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith("/"))

package/dist/senses/habit-turn-message.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHabitTurnMessage = buildHabitTurnMessage;
+const runtime_1 = require("../nerves/runtime");
+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 buildHabitTurnMessage(options) {
+    const { habitName, habitTitle, habitBody, lastRun, checkpoint, alsoDue, staleObligations, parseErrors, degradedComponents, arcResume, deskOrientation, surfacePolicy, now, } = options;
+    const hasBody = habitBody !== undefined && habitBody !== "";
+    const leadingSections = buildLeadingSections(arcResume, deskOrientation, surfacePolicy);
+    // First beat: lastRun is null
+    if (lastRun === null) {
+        // Cold start: no checkpoint, no body — bare awareness
+        if (!checkpoint && !hasBody) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.habit_turn_message_built",
+                message: "habit turn message built (cold start)",
+                meta: { habitName, coldStart: true },
+            });
+            return joinSections(leadingSections, ["...time passing. anything stirring?"]);
+        }
+        if (!hasBody) {
+            // First beat with no body: nudge
+            const sections = [
+                `your ${habitTitle} fired but has no instructions \u2014 add a body to \`habits/${habitName}.md\``,
+            ];
+            appendTrailingExtras(sections, alsoDue, staleObligations, parseErrors, degradedComponents);
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.habit_turn_message_built",
+                message: "habit turn message built (first beat, no body)",
+                meta: { habitName, firstBeat: true, hasBody: false },
+            });
+            return joinSections(leadingSections, sections);
+        }
+        const sections = [
+            `your ${habitTitle} is alive. this is its first breath.`,
+            habitBody,
+        ];
+        appendTrailingExtras(sections, alsoDue, staleObligations, parseErrors, degradedComponents);
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.habit_turn_message_built",
+            message: "habit turn message built (first beat)",
+            meta: { habitName, firstBeat: true },
+        });
+        return joinSections(leadingSections, sections);
+    }
+    // Normal turn
+    const sections = [];
+    // 1. Checkpoint
+    if (checkpoint) {
+        sections.push(`you were thinking about ${checkpoint}.`);
+    }
+    // 2. Elapsed time
+    const nowMs = now().getTime();
+    const lastRunMs = new Date(lastRun).getTime();
+    const elapsed = nowMs - lastRunMs;
+    sections.push(`${formatElapsed(elapsed)} have passed.`);
+    // 3. Body or no-body nudge
+    if (hasBody) {
+        sections.push(habitBody);
+    }
+    else {
+        sections.push(`your ${habitTitle} fired but has no instructions \u2014 add a body to \`habits/${habitName}.md\``);
+    }
+    // 4-7. Trailing extras
+    appendTrailingExtras(sections, alsoDue, staleObligations, parseErrors, degradedComponents);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.habit_turn_message_built",
+        message: "habit turn message built",
+        meta: {
+            habitName,
+            hasCheckpoint: !!checkpoint,
+            hasBody: hasBody,
+            staleObligationCount: staleObligations.length,
+        },
+    });
+    return joinSections(leadingSections, sections);
+}
+function buildLeadingSections(arcResume, deskOrientation, surfacePolicy) {
+    const sections = [];
+    if (arcResume?.trim())
+        sections.push(arcResume.trim());
+    if (deskOrientation?.trim())
+        sections.push(deskOrientation.trim());
+    if (surfacePolicy?.trim())
+        sections.push(surfacePolicy.trim());
+    return sections;
+}
+function joinSections(leadingSections, sections) {
+    return [...leadingSections, ...sections].filter((section) => section.trim().length > 0).join("\n\n");
+}
+function appendTrailingExtras(sections, alsoDue, staleObligations, parseErrors, degradedComponents) {
+    // 4. Also-due
+    if (alsoDue) {
+        sections.push(alsoDue);
+    }
+    // 5. Stale obligations
+    if (staleObligations.length > 0) {
+        const lines = staleObligations.map((o) => `[internal] obligation: ${o.friendName} — waiting ${formatElapsed(o.stalenessMs)}`);
+        sections.push(lines.join("\n"));
+    }
+    // 6. Parse errors
+    if (parseErrors.length > 0) {
+        const lines = parseErrors.map((e) => `I noticed my habit file \`${e.file}\` has invalid frontmatter \u2014 I should fix it. (${e.error})`);
+        sections.push(lines.join("\n"));
+    }
+    // 7. Degraded state
+    if (degradedComponents.length > 0) {
+        const reasons = degradedComponents.map((d) => `${d.component}: ${d.reason}`).join("; ");
+        sections.push(`[note: my scheduling is degraded: ${reasons}]`);
+    }
+}

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

@@ -1,35 +1,242 @@
 "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.HEARTBEAT_OK_REST_SUPPRESSION_MS = exports.HABIT_RECURSION_BURST_THRESHOLD = exports.HABIT_RECURSION_BURST_WINDOW_MS = exports.HABIT_RECURSION_MIN_INTERVAL_MS = exports.MAX_CONSECUTIVE_INSTINCT_TURNS = void 0;
 exports.createInnerDialogWorker = createInnerDialogWorker;
 exports.startInnerDialogWorker = startInnerDialogWorker;
+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");
-function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options), hasPendingWork = () => (0, pending_1.hasPendingMessages)((0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)()))) {
+const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
+const flight_recorder_1 = require("../arc/flight-recorder");
+/**
+ * Cap on consecutive `instinct` follow-on turns triggered by `hasPendingWork()`
+ * with no externally-queued work in between. Without this cap, a turn that
+ * writes anything back into the inner-dialog pending dir as a side effect of
+ * processing (e.g. a surface tool routing a response) puts the worker into
+ * a self-sustaining loop where the next turn's drain produces another write,
+ * and so on. Real workflows rarely chain more than 2–3 instinct turns; an
+ * external trigger (habit, poke, chat) resets the counter so legitimate
+ * follow-on work is unaffected.
+ *
+ * Three feels right: legitimate cascading follow-ups (e.g. processing a
+ * batch of delegated returns) get through; a true self-loop caps fast.
+ */
+exports.MAX_CONSECUTIVE_INSTINCT_TURNS = 3;
+/**
+ * Habit recursion detector thresholds. The instinct cap above protects
+ * against pending-dir self-loops; this protects against the *external*
+ * IPC self-loop where heartbeat-shaped messages get re-issued faster
+ * than their cadence — e.g. a hook misconfigured to repost on every
+ * heartbeat, a daemon retry storm, or a stuck timer firing back-to-back.
+ *
+ * MIN_INTERVAL_MS — two of the same habit within this window is suspect
+ * regardless of cadence (no realistic habit fires every few seconds).
+ * BURST_THRESHOLD over BURST_WINDOW_MS catches slower runaways that stay
+ * just under MIN_INTERVAL_MS.
+ *
+ * Detection is observation-only: it emits warn-level nerves events, it
+ * does not drop the message. An operator (or follow-up auto-recovery)
+ * decides what to do with the signal.
+ */
+exports.HABIT_RECURSION_MIN_INTERVAL_MS = 5_000;
+exports.HABIT_RECURSION_BURST_WINDOW_MS = 60_000;
+exports.HABIT_RECURSION_BURST_THRESHOLD = 5;
+exports.HEARTBEAT_OK_REST_SUPPRESSION_MS = 20 * 60_000;
+function isHeartbeatOkRestResult(result) {
+    if (!result || typeof result !== "object")
+        return false;
+    const maybeResult = result;
+    return maybeResult.turnOutcome === "rested" && maybeResult.restStatus === "HEARTBEAT_OK";
+}
+function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options), hasPendingWork = () => (0, pending_1.hasPendingMessages)((0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)())), nowSource = () => Date.now()) {
     let running = false;
-    let rerunRequested = false;
-    let rerunReason = "instinct";
-    let rerunTaskId;
-    async function run(reason, taskId) {
-        if (running) {
-            rerunRequested = true;
-            rerunReason = reason;
-            if (taskId !== undefined) {
-                rerunTaskId = taskId;
+    const queue = [];
+    const lastFireByHabit = new Map();
+    const recentHabitFires = [];
+    let heartbeatOkRestedAt = null;
+    function habitOutcomeForTurn(result, errors) {
+        if (errors.length > 0)
+            return { outcome: "error", producedRefs: [] };
+        const toolNames = new Set();
+        if (result && typeof result === "object" && Array.isArray(result.messages)) {
+            for (const message of result.messages) {
+                const toolCalls = message.tool_calls;
+                if (!Array.isArray(toolCalls))
+                    continue;
+                for (const call of toolCalls) {
+                    const functionName = call.function?.name;
+                    if (typeof functionName === "string")
+                        toolNames.add(functionName);
+                }
             }
+        }
+        if (toolNames.has("send_message") || toolNames.has("surface")) {
+            return { outcome: "surfaced", producedRefs: [{ kind: "surface", locator: "tool:send_message_or_surface" }] };
+        }
+        if (toolNames.has("diary_write") || toolNames.has("note")) {
+            return { outcome: "wrote_record", producedRefs: [{ kind: "desk_record", locator: "desk/_record" }] };
+        }
+        if ([...toolNames].some((name) => name.startsWith("mcp__desk__"))) {
+            return { outcome: "updated_desk", producedRefs: [{ kind: "desk_task", locator: "desk/" }] };
+        }
+        return { outcome: "no_change", producedRefs: [] };
+    }
+    function recordHabitCompletion(habitName, startedAt = new Date(nowSource()).toISOString(), endedAt = startedAt, trigger = "overdue", result, errors = []) {
+        try {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            (0, habit_runtime_state_1.recordHabitRun)(agentRoot, habitName, endedAt, {
+                definitionPath: path.join(agentRoot, "habits", `${habitName}.md`),
+            });
+            const { outcome, producedRefs } = habitOutcomeForTurn(result, errors);
+            (0, flight_recorder_1.writeHabitRunReceipt)(agentRoot, {
+                schemaVersion: 1,
+                runId: (0, flight_recorder_1.createHabitRunId)(habitName, new Date(startedAt)),
+                habitName,
+                trigger,
+                startedAt,
+                endedAt,
+                outcome,
+                producedRefs,
+                surfaceAttempts: [],
+                errors,
+            });
+        }
+        catch {
+            // Habit file/state may be unavailable during the turn — skip gracefully
+        }
+    }
+    function clearHeartbeatRestShield() {
+        heartbeatOkRestedAt = null;
+    }
+    function shouldReuseHeartbeatOkRest(habitName) {
+        if (habitName !== "heartbeat" || heartbeatOkRestedAt === null)
+            return false;
+        if (nowSource() - heartbeatOkRestedAt > exports.HEARTBEAT_OK_REST_SUPPRESSION_MS)
+            return false;
+        if (hasPendingWork()) {
+            clearHeartbeatRestShield();
+            return false;
+        }
+        return true;
+    }
+    function reuseHeartbeatOkRest(habitName) {
+        const nowIso = new Date(nowSource()).toISOString();
+        recordHabitCompletion(habitName, nowIso, nowIso, "overdue", { turnOutcome: "rested", restStatus: "HEARTBEAT_OK" });
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "senses",
+            event: "senses.heartbeat_ok_rest_reused",
+            message: "heartbeat skipped because previous HEARTBEAT_OK rest is still valid and no pending work exists",
+            meta: {
+                habitName,
+                quietWindowMs: exports.HEARTBEAT_OK_REST_SUPPRESSION_MS,
+                restedAgoMs: nowSource() - heartbeatOkRestedAt,
+            },
+        });
+    }
+    function recordHabitFireForRecursion(habitName) {
+        const now = nowSource();
+        const previous = lastFireByHabit.get(habitName);
+        if (previous !== undefined) {
+            const intervalMs = now - previous;
+            if (intervalMs < exports.HABIT_RECURSION_MIN_INTERVAL_MS) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.habit_recursion_suspected",
+                    message: "habit fired suspiciously fast after the previous fire — possible self-recursion or duplicate dispatch",
+                    meta: {
+                        habitName,
+                        intervalMs,
+                        thresholdMs: exports.HABIT_RECURSION_MIN_INTERVAL_MS,
+                    },
+                });
+            }
+        }
+        lastFireByHabit.set(habitName, now);
+        recentHabitFires.push(now);
+        while (recentHabitFires.length > 0 && now - recentHabitFires[0] > exports.HABIT_RECURSION_BURST_WINDOW_MS) {
+            recentHabitFires.shift();
+        }
+        if (recentHabitFires.length >= exports.HABIT_RECURSION_BURST_THRESHOLD) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.habit_recursion_burst",
+                message: "habit messages arriving in a burst — possible runaway loop",
+                meta: {
+                    count: recentHabitFires.length,
+                    windowMs: exports.HABIT_RECURSION_BURST_WINDOW_MS,
+                    thresholdCount: exports.HABIT_RECURSION_BURST_THRESHOLD,
+                    lastHabitName: habitName,
+                },
+            });
+        }
+    }
+    async function run(reason, taskId, habitName, awaitName, trigger) {
+        if (running) {
+            queue.push({ reason, taskId, habitName, awaitName, trigger });
             return;
         }
         running = true;
         try {
             let nextReason = reason;
             let nextTaskId = taskId;
-            do {
-                rerunRequested = false;
+            let nextHabitName = habitName;
+            let nextAwaitName = awaitName;
+            let nextTrigger = trigger;
+            let consecutiveInstinctTurns = reason === "instinct" ? 1 : 0;
+            runLoop: do {
+                const currentReason = nextReason;
+                const currentHabitName = nextHabitName;
+                const currentTrigger = nextTrigger ?? "overdue";
+                const habitStartedAt = currentReason === "habit" && currentHabitName ? new Date(nowSource()).toISOString() : null;
+                const turnErrors = [];
+                if (!(currentReason === "habit" && currentHabitName === "heartbeat")) {
+                    clearHeartbeatRestShield();
+                }
+                let turnResult;
                 try {
-                    await runTurn({ reason: nextReason, taskId: nextTaskId });
+                    turnResult = await runTurn({ reason: nextReason, taskId: nextTaskId, habitName: nextHabitName, awaitName: nextAwaitName });
                 }
                 catch (error) {
+                    clearHeartbeatRestShield();
+                    turnErrors.push(error instanceof Error ? error.message : String(error));
                     (0, runtime_1.emitNervesEvent)({
                         level: "error",
                         component: "senses",
@@ -41,15 +248,62 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                         },
                     });
                 }
-                if (!rerunRequested && hasPendingWork()) {
-                    rerunRequested = true;
-                    rerunReason = "instinct";
+                if (currentReason === "habit" && currentHabitName === "heartbeat") {
+                    heartbeatOkRestedAt = isHeartbeatOkRestResult(turnResult) ? nowSource() : null;
+                }
+                // Record lastRun after a habit turn without dirtying the tracked habit file.
+                if (currentReason === "habit" && currentHabitName && habitStartedAt) {
+                    recordHabitCompletion(currentHabitName, habitStartedAt, new Date(nowSource()).toISOString(), currentTrigger, turnResult, turnErrors);
                 }
-                nextReason = rerunReason;
-                nextTaskId = rerunTaskId;
-                rerunReason = "instinct";
-                rerunTaskId = undefined;
-            } while (rerunRequested);
+                // Drain queue first. Externally-queued work resets the instinct cap
+                // because a real outside trigger arrived between turns.
+                while (queue.length > 0) {
+                    const next = queue.shift();
+                    if (next.reason === "habit" && next.habitName === "heartbeat" && shouldReuseHeartbeatOkRest(next.habitName)) {
+                        reuseHeartbeatOkRest(next.habitName);
+                        continue;
+                    }
+                    if (!(next.reason === "habit" && next.habitName === "heartbeat")) {
+                        clearHeartbeatRestShield();
+                    }
+                    nextReason = next.reason;
+                    nextTaskId = next.taskId;
+                    nextHabitName = next.habitName;
+                    nextAwaitName = next.awaitName;
+                    nextTrigger = next.trigger;
+                    consecutiveInstinctTurns = nextReason === "instinct" ? consecutiveInstinctTurns + 1 : 0;
+                    continue runLoop;
+                }
+                // Then check hasPendingWork fallback. This is the loop site: any
+                // tool that writes to the inner-dialog pending dir during a turn
+                // would cause hasPendingWork() to be true here, producing a
+                // self-sustaining "instinct" loop with no external input. Cap it.
+                if (hasPendingWork()) {
+                    clearHeartbeatRestShield();
+                    if (consecutiveInstinctTurns >= exports.MAX_CONSECUTIVE_INSTINCT_TURNS) {
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "senses",
+                            event: "senses.inner_dialog_worker_instinct_loop_capped",
+                            message: "inner dialog worker stopped chaining instinct turns; pending work remains for next external trigger",
+                            meta: {
+                                consecutiveInstinctTurns,
+                                cap: exports.MAX_CONSECUTIVE_INSTINCT_TURNS,
+                                lastReason: nextReason,
+                            },
+                        });
+                        break;
+                    }
+                    consecutiveInstinctTurns += 1;
+                    nextReason = "instinct";
+                    nextTaskId = undefined;
+                    nextHabitName = undefined;
+                    nextAwaitName = undefined;
+                    nextTrigger = undefined;
+                    continue;
+                }
+                break;
+            } while (true);
         }
         finally {
             running = false;
@@ -59,16 +313,43 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
         if (!message || typeof message !== "object")
             return;
         const maybeMessage = message;
+        if (maybeMessage.type === "habit") {
+            /* v8 ignore next -- defensive fallback: live habit dispatch always sets habitName @preserve */
+            const habitName = maybeMessage.habitName ?? "(unnamed)";
+            if (shouldReuseHeartbeatOkRest(habitName)) {
+                reuseHeartbeatOkRest(habitName);
+                return;
+            }
+            recordHabitFireForRecursion(habitName);
+            await run("habit", undefined, maybeMessage.habitName, undefined, maybeMessage.trigger ?? "overdue");
+            return;
+        }
+        if (maybeMessage.type === "await") {
+            clearHeartbeatRestShield();
+            /* v8 ignore next -- defensive fallback: live await dispatch always sets awaitName @preserve */
+            const awaitName = maybeMessage.awaitName ?? "(unnamed)";
+            recordHabitFireForRecursion(`await:${awaitName}`);
+            await run("await", undefined, undefined, maybeMessage.awaitName);
+            return;
+        }
         if (maybeMessage.type === "heartbeat") {
-            await run("heartbeat");
+            // Backward compatibility: heartbeat -> habit/heartbeat
+            if (shouldReuseHeartbeatOkRest("heartbeat")) {
+                reuseHeartbeatOkRest("heartbeat");
+                return;
+            }
+            recordHabitFireForRecursion("heartbeat");
+            await run("habit", undefined, "heartbeat", undefined, "overdue");
             return;
         }
         if (maybeMessage.type === "poke") {
+            clearHeartbeatRestShield();
             await run("instinct", maybeMessage.taskId);
             return;
         }
         if (maybeMessage.type === "chat" ||
             maybeMessage.type === "message") {
+            clearHeartbeatRestShield();
             await run("instinct");
             return;
         }