@ouro.bot/cli 0.1.0-alpha.19 → 0.1.0-alpha.190

package/dist/heart/tool-activity-callbacks.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolActivityCallbacks = createToolActivityCallbacks;
+const tool_description_1 = require("./tool-description");
+const runtime_1 = require("../nerves/runtime");
+function createToolActivityCallbacks(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.tool_activity_callbacks_created",
+        message: "tool activity callbacks initialized",
+        meta: {},
+    });
+    // Track the last description so we can reference it in END messages
+    let lastDescription = null;
+    return {
+        onToolStart(name, args) {
+            const description = (0, tool_description_1.humanReadableToolDescription)(name, args);
+            if (description === null)
+                return; // hidden tool (settle, rest, descend)
+            lastDescription = description;
+            options.onDescription(description);
+        },
+        onToolEnd(name, summary, success) {
+            const desc = lastDescription ?? name;
+            // Strip trailing "..." from description for the result line
+            const cleanDesc = desc.endsWith("...") ? desc.slice(0, -3) : desc;
+            if (!success) {
+                options.onFailure(`\u2717 ${cleanDesc} — ${summary}`);
+                return;
+            }
+            if (options.isDebug()) {
+                options.onResult(`\u2713 ${cleanDesc}`);
+            }
+        },
+    };
+}

package/dist/heart/tool-description.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.humanReadableToolDescription = humanReadableToolDescription;
+const runtime_1 = require("../nerves/runtime");
+function basename(filePath) {
+    const idx = filePath.lastIndexOf("/");
+    return idx >= 0 ? filePath.slice(idx + 1) : filePath;
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    // Cut at last space before maxLen to avoid mid-word truncation
+    const slice = text.slice(0, max - 1);
+    const lastSpace = slice.lastIndexOf(" ");
+    if (lastSpace > 0)
+        return text.slice(0, lastSpace) + "\u2026";
+    // No space found (single long word) — hard truncate
+    return slice + "\u2026";
+}
+const TOOL_DESCRIPTIONS = {
+    // File operations
+    shell: (args) => {
+        const cmd = args.command;
+        if (!cmd)
+            return "running a command...";
+        return `running ${truncate(cmd, 50)}...`;
+    },
+    read_file: (args) => {
+        const fp = args.path || args.file_path;
+        if (!fp)
+            return "reading a file...";
+        return `reading ${basename(fp)}...`;
+    },
+    write_file: (args) => {
+        const fp = args.path || args.file_path;
+        if (!fp)
+            return "writing a file...";
+        return `writing ${basename(fp)}...`;
+    },
+    edit_file: (args) => {
+        const fp = args.path || args.file_path;
+        if (!fp)
+            return "editing a file...";
+        return `editing ${basename(fp)}...`;
+    },
+    glob: (args) => {
+        const p = args.pattern;
+        if (!p)
+            return "searching for files...";
+        return `searching for ${truncate(p, 40)}...`;
+    },
+    grep: (args) => {
+        const p = args.pattern;
+        if (!p)
+            return "searching code...";
+        return `searching code for '${truncate(p, 40)}'...`;
+    },
+    // Memory and knowledge
+    recall: (args) => {
+        const q = args.query;
+        if (!q)
+            return "searching memory...";
+        return `searching memory for '${truncate(q, 40)}'...`;
+    },
+    diary_write: (args) => {
+        const about = args.about;
+        return about ? `noting something about ${truncate(about, 30)}...` : "noting something down...";
+    },
+    save_friend_note: () => "making a note about you...",
+    get_friend_note: () => "checking my notes...",
+    load_skill: (args) => {
+        const name = args.name || args.skill;
+        return name ? `loading ${name} skill...` : "loading a skill...";
+    },
+    // Session and context
+    query_session: (args) => {
+        const mode = args.mode;
+        if (mode === "search")
+            return `searching session for '${truncate(args.query || "", 30)}'...`;
+        if (mode === "status")
+            return "checking inner dialog status...";
+        return "checking session history...";
+    },
+    web_search: (args) => {
+        const q = args.query;
+        return q ? `searching the web for '${truncate(q, 35)}'...` : "searching the web...";
+    },
+    coding_spawn: (args) => {
+        const runner = args.runner;
+        return runner ? `starting ${runner} coding session...` : "starting coding session...";
+    },
+    coding_status: () => "checking coding sessions...",
+    coding_tail: () => "reading coding output...",
+    coding_kill: () => "stopping coding session...",
+    bridge_manage: () => "managing conversation bridge...",
+    // Communication
+    send_message: (args) => {
+        const to = args.to;
+        return to ? `sending a message to ${to}...` : "sending a message...";
+    },
+    surface: () => "sharing a thought...",
+    // Metacognitive (agent's inner life)
+    ponder: (args) => {
+        const thought = args.thought;
+        return thought ? `thinking about ${truncate(thought, 40)}...` : "thinking deeper...";
+    },
+    observe: () => null,
+    claude: () => "reasoning...",
+    set_reasoning_effort: (args) => {
+        const level = args.level;
+        return level ? `setting thinking depth to ${level}...` : "adjusting thinking depth...";
+    },
+    // Hidden — these ARE the response or end-of-turn
+    settle: () => null,
+    rest: () => null,
+    descend: () => null,
+};
+function humanReadableToolDescription(name, args) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.tool_description",
+        message: "generated human-readable tool description",
+        meta: { tool: name },
+    });
+    const builder = TOOL_DESCRIPTIONS[name];
+    if (builder)
+        return builder(args);
+    // MCP tools: mcp__server__toolname — extract last segment
+    if (name.startsWith("mcp__")) {
+        const parts = name.split("__");
+        const toolName = parts[parts.length - 1];
+        return `using ${toolName}...`;
+    }
+    return `using ${name}...`;
+}

package/dist/heart/tool-loop.js

@@ -0,0 +1,200 @@
+"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.GLOBAL_CIRCUIT_BREAKER_LIMIT = exports.PING_PONG_WINDOW = exports.GENERIC_REPEAT_LIMIT = exports.POLL_NO_PROGRESS_LIMIT = exports.TOOL_LOOP_HISTORY_LIMIT = void 0;
+exports.createToolLoopState = createToolLoopState;
+exports.recordToolOutcome = recordToolOutcome;
+exports.detectToolLoop = detectToolLoop;
+const crypto = __importStar(require("crypto"));
+const runtime_1 = require("../nerves/runtime");
+exports.TOOL_LOOP_HISTORY_LIMIT = 30;
+exports.POLL_NO_PROGRESS_LIMIT = 3;
+exports.GENERIC_REPEAT_LIMIT = 4;
+exports.PING_PONG_WINDOW = 6;
+exports.GLOBAL_CIRCUIT_BREAKER_LIMIT = 24;
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    /* v8 ignore next -- stableStringify currently receives only objects/strings from normalized loop inputs @preserve */
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function digest(value) {
+    return crypto.createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function normalizeArgs(toolName, args) {
+    if (toolName === "query_active_work") {
+        return { toolName };
+    }
+    if (toolName === "coding_status" || toolName === "coding_tail") {
+        return {
+            toolName,
+            sessionId: args.sessionId ?? "",
+        };
+    }
+    if (toolName === "query_session") {
+        return {
+            toolName,
+            mode: args.mode ?? "",
+            friendId: args.friendId ?? "",
+            channel: args.channel ?? "",
+            key: args.key ?? "",
+            query: args.query ?? "",
+        };
+    }
+    return {
+        toolName,
+        args,
+    };
+}
+function normalizeOutcome(result, success) {
+    return {
+        success,
+        result: result.replace(/\s+/g, " ").trim(),
+    };
+}
+function isKnownPollTool(toolName, args) {
+    return toolName === "query_active_work"
+        || toolName === "coding_status"
+        || toolName === "coding_tail"
+        || (toolName === "query_session" && (args.mode ?? "").trim() === "status");
+}
+function emitDetection(detector, toolName, count, message, pairedToolName) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "engine",
+        event: "engine.tool_loop_detected",
+        message: "tool loop guard detected repeated non-progress work",
+        meta: {
+            detector,
+            toolName,
+            count,
+            pairedToolName: pairedToolName ?? null,
+        },
+    });
+    return {
+        stuck: true,
+        detector,
+        count,
+        message,
+        pairedToolName,
+    };
+}
+function countTrailingRepeats(history, toolName, callHash) {
+    let count = 0;
+    let outcomeHash;
+    for (let index = history.length - 1; index >= 0; index--) {
+        const record = history[index];
+        if (record.toolName !== toolName || record.callHash !== callHash) {
+            break;
+        }
+        if (!outcomeHash) {
+            outcomeHash = record.outcomeHash;
+        }
+        if (record.outcomeHash !== outcomeHash) {
+            break;
+        }
+        count += 1;
+    }
+    return { count, outcomeHash };
+}
+function detectPingPong(history, toolName, callHash) {
+    if (history.length < exports.PING_PONG_WINDOW) {
+        return { stuck: false };
+    }
+    const recent = history.slice(-exports.PING_PONG_WINDOW);
+    const first = recent[0];
+    const second = recent[1];
+    if (!first.isKnownPoll || !second.isKnownPoll) {
+        return { stuck: false };
+    }
+    if (first.toolName === second.toolName && first.callHash === second.callHash) {
+        return { stuck: false };
+    }
+    for (let index = 0; index < recent.length; index++) {
+        const expected = index % 2 === 0 ? first : second;
+        const actual = recent[index];
+        if (actual.toolName !== expected.toolName
+            || actual.callHash !== expected.callHash
+            || actual.outcomeHash !== expected.outcomeHash) {
+            return { stuck: false };
+        }
+    }
+    const matchesPair = (toolName === first.toolName && callHash === first.callHash)
+        || (toolName === second.toolName && callHash === second.callHash);
+    if (!matchesPair) {
+        return { stuck: false };
+    }
+    const pairedToolName = toolName === first.toolName ? second.toolName : first.toolName;
+    return emitDetection("ping_pong", toolName, exports.PING_PONG_WINDOW, `repeated ${first.toolName}/${second.toolName} polling is not changing. stop cycling between status checks and either act on the current state, change approach, or answer truthfully with what is known.`, pairedToolName);
+}
+function createToolLoopState() {
+    return { history: [] };
+}
+function recordToolOutcome(state, toolName, args, result, success) {
+    state.history.push({
+        toolName,
+        callHash: digest(normalizeArgs(toolName, args)),
+        outcomeHash: digest(normalizeOutcome(result, success)),
+        isKnownPoll: isKnownPollTool(toolName, args),
+    });
+    if (state.history.length > exports.TOOL_LOOP_HISTORY_LIMIT) {
+        state.history.splice(0, state.history.length - exports.TOOL_LOOP_HISTORY_LIMIT);
+    }
+}
+// Tools that must never be blocked by the circuit breaker.
+// settle = end the turn, surface = deliver results outward.
+// ponder = continue thinking (inner dialog) or hand off to inner dialog (outer).
+// rest = end inner dialog turn (added in Unit 8b).
+// Blocking these traps the agent: it can think all it wants but can never speak or stop.
+const CIRCUIT_BREAKER_EXEMPT = new Set(["settle", "surface", "ponder", "rest"]);
+function detectToolLoop(state, toolName, args) {
+    if (state.history.length >= exports.GLOBAL_CIRCUIT_BREAKER_LIMIT && !CIRCUIT_BREAKER_EXEMPT.has(toolName)) {
+        return emitDetection("global_circuit_breaker", toolName, state.history.length, `this turn has already made ${state.history.length} tool calls. stop thrashing, use the current evidence, and either change approach or answer truthfully with the best grounded status.`);
+    }
+    const callHash = digest(normalizeArgs(toolName, args));
+    const trailing = countTrailingRepeats(state.history, toolName, callHash);
+    if (isKnownPollTool(toolName, args) && trailing.count >= exports.POLL_NO_PROGRESS_LIMIT) {
+        return emitDetection("known_poll_no_progress", toolName, trailing.count, `repeated ${toolName} calls have returned the same state ${trailing.count} times. stop polling and either act on the current state, wait for a meaningful change, or answer truthfully with what is known.`);
+    }
+    if (trailing.count >= exports.GENERIC_REPEAT_LIMIT) {
+        return emitDetection("generic_repeat", toolName, trailing.count, `repeating ${toolName} with the same inputs is not producing new information. change approach, use the evidence already gathered, or answer truthfully with what is known.`);
+    }
+    return detectPingPong(state.history, toolName, callHash);
+}

package/dist/heart/turn-coordinator.js

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTurnCoordinator = createTurnCoordinator;
+exports.withSharedTurnLock = withSharedTurnLock;
+exports.tryBeginSharedTurn = tryBeginSharedTurn;
+exports.endSharedTurn = endSharedTurn;
+exports.isSharedTurnActive = isSharedTurnActive;
+exports.enqueueSharedFollowUp = enqueueSharedFollowUp;
+exports.drainSharedFollowUps = drainSharedFollowUps;
 const runtime_1 = require("../nerves/runtime");
+function scopedKey(scope, key) {
+    return `${scope}:${key}`;
+}
 function createTurnCoordinator() {
     const turnLocks = new Map();
     const activeTurns = new Set();
@@ -60,3 +69,22 @@ function createTurnCoordinator() {
         },
     };
 }
+const _sharedTurnCoordinator = createTurnCoordinator();
+function withSharedTurnLock(scope, key, fn) {
+    return _sharedTurnCoordinator.withTurnLock(scopedKey(scope, key), fn);
+}
+function tryBeginSharedTurn(scope, key) {
+    return _sharedTurnCoordinator.tryBeginTurn(scopedKey(scope, key));
+}
+function endSharedTurn(scope, key) {
+    _sharedTurnCoordinator.endTurn(scopedKey(scope, key));
+}
+function isSharedTurnActive(scope, key) {
+    return _sharedTurnCoordinator.isTurnActive(scopedKey(scope, key));
+}
+function enqueueSharedFollowUp(scope, key, followUp) {
+    _sharedTurnCoordinator.enqueueFollowUp(scopedKey(scope, key), followUp);
+}
+function drainSharedFollowUps(scope, key) {
+    return _sharedTurnCoordinator.drainFollowUps(scopedKey(scope, key));
+}

package/dist/heart/wake-packet.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWakePacket = buildWakePacket;
+exports.renderWakePacket = renderWakePacket;
+exports.renderCompactWakePacket = renderCompactWakePacket;
+const runtime_1 = require("../nerves/runtime");
+const tempo_1 = require("./tempo");
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// --- Section builders (pure derivation from authored data, no embellishment) ---
+function buildPlotLine(episodes, tempo) {
+    if (episodes.length === 0)
+        return "";
+    const limit = tempo === "crisis" ? 3 : tempo === "brief" ? 2 : 5;
+    const selected = episodes.slice(0, limit);
+    const lines = selected.map((ep) => {
+        const parts = [`- ${ep.summary}`];
+        if (ep.whyItMattered && tempo !== "brief") {
+            parts[0] += ` (${ep.whyItMattered})`;
+        }
+        return parts[0];
+    });
+    return lines.join("\n");
+}
+function buildObligationsSection(obligations) {
+    if (obligations.length === 0)
+        return "";
+    return obligations
+        .map((ob) => {
+        const parts = [`- ${ob.content}`];
+        if (ob.meaning?.resumeHint) {
+            parts.push(` [hint: ${ob.meaning.resumeHint}]`);
+        }
+        if (ob.meaning?.stalenessClass && ob.meaning.stalenessClass !== "fresh") {
+            parts.push(` (${ob.meaning.stalenessClass})`);
+        }
+        if (ob.meaning?.waitingOn) {
+            parts.push(` waiting on ${ob.meaning.waitingOn.kind}: ${ob.meaning.waitingOn.target}`);
+        }
+        return parts.join("");
+    })
+        .join("\n");
+}
+function buildCaresSection(cares) {
+    if (cares.length === 0)
+        return "";
+    return cares
+        .map((c) => {
+        const parts = [`- ${c.label}`];
+        if (c.salience !== "low") {
+            parts.push(` [${c.salience}]`);
+        }
+        if (c.currentRisk) {
+            parts.push(` risk: ${c.currentRisk}`);
+        }
+        return parts.join("");
+    })
+        .join("\n");
+}
+function buildPresenceSection(peers) {
+    if (peers.length === 0)
+        return "";
+    return peers
+        .map((p) => `- ${p.agentName}: ${p.availability}/${p.lane}`)
+        .join("\n");
+}
+function buildResumeHint(view) {
+    // Compose from authored obligation resumeHints and top intentions
+    const hints = [];
+    for (const ob of view.activeObligations) {
+        if (ob.meaning?.resumeHint) {
+            hints.push(ob.meaning.resumeHint);
+        }
+    }
+    for (const intent of view.openIntentions.slice(0, 3)) {
+        hints.push(intent.content);
+    }
+    if (hints.length === 0) {
+        // Fall back to top obligation content
+        if (view.activeObligations.length > 0) {
+            hints.push(view.activeObligations[0].content);
+        }
+    }
+    if (hints.length === 0)
+        return "";
+    return hints.join("; ");
+}
+function buildWakePacket(view) {
+    const tempo = view.tempo;
+    const tokenBudget = tempo_1.TEMPO_BUDGETS[tempo];
+    const packet = {
+        plotLine: buildPlotLine(view.recentEpisodes, tempo),
+        obligations: buildObligationsSection(view.activeObligations),
+        cares: buildCaresSection(view.activeCares),
+        presence: buildPresenceSection(view.peerPresence),
+        resumeHint: buildResumeHint(view),
+        tempo,
+        tokenBudget,
+        assembledAt: new Date().toISOString(),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.wake_packet_built",
+        message: `wake packet built: tempo=${tempo}`,
+        meta: {
+            tempo,
+            plotLineTokens: estimateTokens(packet.plotLine),
+            obligationsTokens: estimateTokens(packet.obligations),
+            caresTokens: estimateTokens(packet.cares),
+            presenceTokens: estimateTokens(packet.presence),
+            resumeHintTokens: estimateTokens(packet.resumeHint),
+        },
+    });
+    return packet;
+}
+/**
+ * Renders a wake packet to prompt text, respecting token budget.
+ * Truncation priority (last truncated first):
+ *   resumeHint (PROTECTED) > obligations > cares > plotLine > presence
+ * So presence is truncated first, then plotLine, then cares, then obligations.
+ * resumeHint is never truncated.
+ */
+function renderWakePacket(packet) {
+    const budget = packet.tokenBudget;
+    // Assemble sections in priority order (highest priority first for budget allocation)
+    // Each section is { label, content, priority } where lower priority number = truncated first
+    const sections = [
+        { label: "resume", content: packet.resumeHint, priority: 5 },
+        { label: "obligations", content: packet.obligations, priority: 4 },
+        { label: "cares", content: packet.cares, priority: 3 },
+        { label: "plot", content: packet.plotLine, priority: 2 },
+        { label: "presence", content: packet.presence, priority: 1 },
+    ].filter((s) => s.content.length > 0);
+    if (sections.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.wake_packet_rendered",
+            message: "wake packet rendered: empty",
+            meta: { tokens: 0, tempo: packet.tempo },
+        });
+        return "";
+    }
+    // Build the rendered output, truncating lower-priority sections first
+    let rendered = formatSections(sections);
+    let tokens = estimateTokens(rendered);
+    // Truncate sections from lowest priority until we fit budget
+    const sortedByPriority = [...sections].sort((a, b) => a.priority - b.priority);
+    for (const section of sortedByPriority) {
+        if (tokens <= budget.max)
+            break;
+        // Skip resumeHint — it's PROTECTED
+        if (section.label === "resume")
+            continue;
+        // Remove this section entirely
+        const idx = sections.findIndex((s) => s.label === section.label);
+        sections.splice(idx, 1);
+        rendered = formatSections(sections);
+        tokens = estimateTokens(rendered);
+    }
+    // If still over budget after removing all non-protected sections, trim what's left
+    if (tokens > budget.max) {
+        const maxChars = budget.max * 4;
+        rendered = rendered.slice(0, maxChars);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.wake_packet_rendered",
+        message: `wake packet rendered: ${tokens} tokens`,
+        meta: { tokens, tempo: packet.tempo, sectionCount: sections.length },
+    });
+    return rendered;
+}
+function formatSections(sections) {
+    const parts = [];
+    for (const section of sections) {
+        switch (section.label) {
+            case "resume":
+                parts.push(`**Next:** ${section.content}`);
+                break;
+            case "obligations":
+                parts.push(`**Owed:**\n${section.content}`);
+                break;
+            case "cares":
+                parts.push(`**Cares:**\n${section.content}`);
+                break;
+            case "plot":
+                parts.push(`**Recent:**\n${section.content}`);
+                break;
+            case "presence":
+                parts.push(`**Peers:**\n${section.content}`);
+                break;
+        }
+    }
+    return parts.join("\n\n");
+}
+/**
+ * Ultra-compact version for coding context (max 200 tokens).
+ * Just resumeHint + top obligation + top care, single-line bullets.
+ */
+function renderCompactWakePacket(packet) {
+    const parts = [];
+    if (packet.resumeHint) {
+        parts.push(`next: ${packet.resumeHint}`);
+    }
+    if (packet.obligations) {
+        // Just first line of obligations
+        const firstOb = packet.obligations.split("\n")[0];
+        parts.push(`owed: ${firstOb.replace(/^- /, "")}`);
+    }
+    if (packet.cares) {
+        const firstCare = packet.cares.split("\n")[0];
+        parts.push(`care: ${firstCare.replace(/^- /, "")}`);
+    }
+    const compact = parts.join(" | ");
+    // Hard cap at 200 tokens (800 chars)
+    const maxChars = 200 * 4;
+    const result = compact.length > maxChars ? compact.slice(0, maxChars) : compact;
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.wake_packet_compact_rendered",
+        message: `compact wake packet: ${estimateTokens(result)} tokens`,
+        meta: { tokens: estimateTokens(result) },
+    });
+    return result;
+}