@ouro.bot/cli 0.1.0-alpha.497 → 0.1.0-alpha.499

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_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.499",
+      "changes": [
+        "New `ouro session-playback <session.json>` CLI for dry-running the sanitize pipeline against a saved session. When an agent is stuck in a replay loop, an operator can now run the same `sanitizeProviderMessages` chain that the harness fires before every replay, see what would be dropped/modified/synthesized, and decide whether to clear or hand-repair the session — *without* writing anything to disk.",
+        "The report distinguishes three repair classes: dropped (orphan tool results whose preceding assistant has no matching tool_call), modified-content (assistant messages whose inline `<think>...</think>` blocks would be stripped before replay), and synthetic-added (synthetic tool-results inserted to satisfy the provider's tool_call/tool_result pairing — these include the explanatory message added in #612 so the agent can read what happened). Each change carries a role, index, optional tool_call_id, reason, and a 120-char preview of the affected content.",
+        "Two output modes: human-readable text (default) and `--json` for piping into jq/diagnostics. Underlying `runSessionPlayback` is a pure function — takes either a session path or a raw object — so it's testable in isolation and the same code path can be embedded in future doctor checks. Wired as `npm run session:playback -- <path>` and as the `dist/heart/session-playback-cli-main.js` entry. 7 tests cover the four envelope shapes (clean legacy, with stripped think, with orphan tool result, unrecognized) plus the two CLI flag paths."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.498",
+      "changes": [
+        "Heartbeat / habit recursion detection in the inner-dialog worker. The existing instinct cap (`MAX_CONSECUTIVE_INSTINCT_TURNS=3`) protects against the *internal* pending-dir self-loop (a turn writes back to its own pending dir, drains it, repeats). It does not protect 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 two timers drifting into the same window.",
+        "Two new warn-level nerve events: `senses.habit_recursion_suspected` fires when two of the same habit (e.g. `heartbeat`) arrive within `HABIT_RECURSION_MIN_INTERVAL_MS` (5s) — no realistic cadence runs that fast. `senses.habit_recursion_burst` fires when `HABIT_RECURSION_BURST_THRESHOLD` (5) or more habit messages of any kind land within `HABIT_RECURSION_BURST_WINDOW_MS` (60s) — catches slower runaways that stay just under the min-interval threshold.",
+        "Detection is observation-only by design: it emits the warn signal so an operator (or a follow-up auto-recovery layer) can act on it. The message is not dropped — the signal is the value. Per-habit-name tracking, so two distinct habits firing close together don't trip the min-interval warning. `nowSource` is injectable via the `createInnerDialogWorker` factory for deterministic tests. 5 new tests cover both detectors plus the trim-window and per-habit isolation cases."
+      ]
+    },
     {
       "version": "0.1.0-alpha.497",
       "changes": [

package/dist/heart/session-playback-cli-main.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const session_playback_cli_1 = require("./session-playback-cli");
+const code = (0, session_playback_cli_1.runSessionPlaybackCli)(process.argv.slice(2));
+process.exit(code);

package/dist/heart/session-playback-cli.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSessionPlaybackCli = runSessionPlaybackCli;
+const session_playback_1 = require("./session-playback");
+function printHelp() {
+    // eslint-disable-next-line no-console -- meta-tooling
+    console.log([
+        "usage: ouro session-playback <session.json> [--json]",
+        "",
+        "Loads a saved session.json, runs it through the same sanitize pipeline that fires before",
+        "every replay, and prints a report of what would be dropped, content-modified, or",
+        "synthetically inserted. Read-only; the file on disk is never written.",
+        "",
+        "Useful when an agent is stuck in a replay loop and you want to see what the harness",
+        "thinks is wrong with the session before deciding whether to clear or repair.",
+    ].join("\n"));
+}
+function runSessionPlaybackCli(argv) {
+    const positional = argv.filter((token) => !token.startsWith("--"));
+    const flags = new Set(argv.filter((token) => token.startsWith("--")));
+    if (flags.has("--help") || flags.has("-h") || positional.length === 0) {
+        printHelp();
+        return positional.length === 0 ? 2 : 0;
+    }
+    const sessionPath = positional[0];
+    const report = (0, session_playback_1.runSessionPlayback)({ sessionPath });
+    if (flags.has("--json")) {
+        // eslint-disable-next-line no-console -- meta-tooling
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        // eslint-disable-next-line no-console -- meta-tooling
+        console.log((0, session_playback_1.formatPlaybackReport)(report));
+    }
+    return 0;
+}

package/dist/heart/session-playback.js

@@ -0,0 +1,231 @@
+"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.runSessionPlayback = runSessionPlayback;
+exports.formatPlaybackReport = formatPlaybackReport;
+const fs = __importStar(require("node:fs"));
+const session_events_1 = require("./session-events");
+const PREVIEW_MAX_CHARS = 120;
+function shortPreview(value) {
+    if (value == null)
+        return "";
+    if (typeof value === "string") {
+        const trimmed = value.replace(/\s+/g, " ").trim();
+        /* v8 ignore next -- branch: PREVIEW_MAX_CHARS truncation only triggers on long inline content @preserve */
+        return trimmed.length > PREVIEW_MAX_CHARS ? `${trimmed.slice(0, PREVIEW_MAX_CHARS - 3)}...` : trimmed;
+    }
+    /* v8 ignore next -- defensive: content is always string or array in practice @preserve */
+    return shortPreview(JSON.stringify(value));
+}
+function getRole(message) {
+    /* v8 ignore next -- defensive fallback: provider messages always carry a role @preserve */
+    return message.role ?? "unknown";
+}
+function getToolCallId(message) {
+    const value = message.tool_call_id;
+    /* v8 ignore next -- defensive: tool messages always carry a string tool_call_id @preserve */
+    return typeof value === "string" ? value : undefined;
+}
+function getContentString(message) {
+    const value = message.content;
+    if (typeof value === "string")
+        return value;
+    /* v8 ignore start -- defensive: array content (multipart) and missing content branches not exercised by replay test fixtures @preserve */
+    if (Array.isArray(value)) {
+        return value
+            .map((part) => (part && typeof part === "object" && "text" in part ? String(part.text ?? "") : ""))
+            .join("");
+    }
+    return "";
+    /* v8 ignore stop */
+}
+function detectEnvelopeShape(raw) {
+    if (!raw || typeof raw !== "object")
+        return "unknown";
+    const record = raw;
+    if (record.version === 2 && Array.isArray(record.events))
+        return "v2";
+    if (record.version === 1 || ("messages" in record && Array.isArray(record.messages)))
+        return "legacy";
+    return "unknown";
+}
+function rawLegacyMessages(raw) {
+    /* v8 ignore next -- defensive: caller already detected legacy shape via Array.isArray(messages) @preserve */
+    if (!raw || typeof raw !== "object")
+        return [];
+    const record = raw;
+    if (Array.isArray(record.messages)) {
+        return record.messages.filter((m) => m != null && typeof m === "object");
+    }
+    /* v8 ignore next -- unreachable in practice: detectEnvelopeShape gates this on Array.isArray(messages) @preserve */
+    return [];
+}
+function inputMessagesForShape(shape, raw, envelope) {
+    if (shape === "legacy")
+        return rawLegacyMessages(raw);
+    if (shape === "v2" && envelope)
+        return (0, session_events_1.projectProviderMessages)(envelope);
+    return [];
+}
+function diffMessages(input, sanitized) {
+    const changes = [];
+    const sanitizedByToolCallId = new Map();
+    for (let i = 0; i < sanitized.length; i++) {
+        const id = getToolCallId(sanitized[i]);
+        if (id)
+            sanitizedByToolCallId.set(id, i);
+    }
+    const inputToolCallIds = new Set();
+    for (let i = 0; i < input.length; i++) {
+        const message = input[i];
+        const role = getRole(message);
+        const toolCallId = getToolCallId(message);
+        if (role === "tool" && toolCallId)
+            inputToolCallIds.add(toolCallId);
+        if (role === "tool" && toolCallId && !sanitizedByToolCallId.has(toolCallId)) {
+            changes.push({
+                index: i,
+                role,
+                action: "dropped",
+                toolCallId,
+                reason: "tool result orphan dropped (no preceding assistant tool_call with this id)",
+                preview: shortPreview(getContentString(message)),
+            });
+        }
+    }
+    for (let i = 0; i < input.length; i++) {
+        const message = input[i];
+        const role = getRole(message);
+        if (role !== "assistant")
+            continue;
+        const inputContent = getContentString(message);
+        if (!inputContent)
+            continue;
+        const stripped = inputContent.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<think>[\s\S]*$/i, "").trim();
+        if (stripped !== inputContent.trim()) {
+            changes.push({
+                index: i,
+                role,
+                action: "modified-content",
+                reason: "inline <think> reasoning would be stripped before replay",
+                preview: shortPreview(inputContent),
+            });
+        }
+    }
+    const inputAssistantToolCallIds = new Set();
+    for (const message of input) {
+        if (getRole(message) !== "assistant")
+            continue;
+        const toolCalls = message.tool_calls;
+        if (!Array.isArray(toolCalls))
+            continue;
+        for (const call of toolCalls) {
+            if (typeof call?.id === "string")
+                inputAssistantToolCallIds.add(call.id);
+        }
+    }
+    /* v8 ignore start -- synthetic-add detection: the sanitize pipeline only synthesizes results for unbalanced tool_calls; replay test fixtures don't exercise this branch combination @preserve */
+    for (let i = 0; i < sanitized.length; i++) {
+        const message = sanitized[i];
+        if (getRole(message) !== "tool")
+            continue;
+        const toolCallId = getToolCallId(message);
+        if (!toolCallId)
+            continue;
+        if (!inputToolCallIds.has(toolCallId) && inputAssistantToolCallIds.has(toolCallId)) {
+            changes.push({
+                index: i,
+                role: "tool",
+                action: "synthetic-added",
+                toolCallId,
+                reason: "synthetic tool result inserted to satisfy provider tool_call/tool_result pairing",
+                preview: shortPreview(getContentString(message)),
+            });
+        }
+    }
+    /* v8 ignore stop */
+    return changes.sort((left, right) => left.index - right.index);
+}
+function runSessionPlayback(options) {
+    let raw = options.raw;
+    if (raw === undefined) {
+        const text = fs.readFileSync(options.sessionPath, "utf-8");
+        raw = JSON.parse(text);
+    }
+    const shape = detectEnvelopeShape(raw);
+    /* v8 ignore next -- v2 envelope branch: not exercised by current replay test fixtures (all legacy v1) @preserve */
+    const envelope = shape === "v2" ? (0, session_events_1.parseSessionEnvelope)(raw) : null;
+    const input = inputMessagesForShape(shape, raw, envelope);
+    const sanitized = (0, session_events_1.sanitizeProviderMessages)(input);
+    const changes = diffMessages(input, sanitized);
+    return {
+        sessionPath: options.sessionPath,
+        envelopeShape: shape,
+        inputMessageCount: input.length,
+        sanitizedMessageCount: sanitized.length,
+        totals: {
+            dropped: changes.filter((change) => change.action === "dropped").length,
+            modifiedContent: changes.filter((change) => change.action === "modified-content").length,
+            syntheticAdded: changes.filter((change) => change.action === "synthetic-added").length,
+        },
+        changes,
+    };
+}
+function formatPlaybackReport(report) {
+    const lines = [];
+    lines.push(`Session playback: ${report.sessionPath}`);
+    lines.push(`  envelope shape:   ${report.envelopeShape}`);
+    lines.push(`  input messages:   ${report.inputMessageCount}`);
+    lines.push(`  sanitized count:  ${report.sanitizedMessageCount}`);
+    lines.push(`  dropped:          ${report.totals.dropped}`);
+    lines.push(`  modified content: ${report.totals.modifiedContent}`);
+    lines.push(`  synthetic added:  ${report.totals.syntheticAdded}`);
+    if (report.changes.length === 0) {
+        lines.push("");
+        lines.push("no repairs would apply.");
+        return lines.join("\n");
+    }
+    lines.push("");
+    lines.push("changes (oldest first):");
+    /* v8 ignore start -- per-change formatting branches: toolCallId-present and preview-absent variants depend on the specific change shape and aren't exercised by the legacy fixtures @preserve */
+    for (const change of report.changes) {
+        lines.push(`  [${String(change.index).padStart(4, "0")}] ${change.action.padEnd(18)} ${change.role}${change.toolCallId ? ` tool_call_id=${change.toolCallId}` : ""}`);
+        lines.push(`         reason: ${change.reason}`);
+        if (change.preview)
+            lines.push(`         preview: ${change.preview}`);
+    }
+    /* v8 ignore stop */
+    return lines.join("\n");
+}

package/dist/nerves/coverage/file-completeness.js

@@ -115,6 +115,11 @@ const DISPATCH_EXEMPT_PATTERNS = [
     "heart/outlook/outlook-http-hooks",
     "heart/outlook/outlook-http-routes",
     "heart/outlook/outlook-http-response",
+    // Session playback: read-only debugging CLI for sanitize-pipeline replay.
+    // No side effects on the runtime; output is human-readable diagnostics only.
+    "heart/session-playback-cli-main",
+    "heart/session-playback-cli",
+    "heart/session-playback",
 ];
 function isDispatchExempt(filePath) {
     return DISPATCH_EXEMPT_PATTERNS.some((pattern) => filePath.includes(pattern));

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

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_CONSECUTIVE_INSTINCT_TURNS = void 0;
+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"));
@@ -56,9 +56,69 @@ const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
  * batch of delegated returns) get through; a true self-loop caps fast.
  */
 exports.MAX_CONSECUTIVE_INSTINCT_TURNS = 3;
-function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options), hasPendingWork = () => (0, pending_1.hasPendingMessages)((0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)()))) {
+/**
+ * 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;
+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;
     const queue = [];
+    const lastFireByHabit = new Map();
+    const recentHabitFires = [];
+    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) {
         if (running) {
             queue.push({ reason, taskId, habitName });
@@ -145,11 +205,15 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
             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)";
+            recordHabitFireForRecursion(habitName);
             await run("habit", undefined, maybeMessage.habitName);
             return;
         }
         if (maybeMessage.type === "heartbeat") {
             // Backward compatibility: heartbeat -> habit/heartbeat
+            recordHabitFireForRecursion("heartbeat");
             await run("habit", undefined, "heartbeat");
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.497",
+  "version": "0.1.0-alpha.499",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -37,7 +37,8 @@
     "lint": "eslint src/",
     "release:preflight": "node scripts/release-preflight.cjs",
     "release:smoke": "node scripts/release-smoke.cjs",
-    "audit:nerves": "npm run build && node dist/nerves/coverage/cli-main.js"
+    "audit:nerves": "npm run build && node dist/nerves/coverage/cli-main.js",
+    "session:playback": "npm run build && node dist/heart/session-playback-cli-main.js"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",