@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/heart/session-stats.js

@@ -0,0 +1,183 @@
+"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.computeSessionStats = computeSessionStats;
+exports.runSessionStats = runSessionStats;
+exports.formatStatsReport = formatStatsReport;
+exports.runSessionStatsCli = runSessionStatsCli;
+const fs = __importStar(require("node:fs"));
+const session_events_1 = require("./session-events");
+const ROLES = ["system", "user", "assistant", "tool"];
+function emptyByRole() {
+    const counts = {};
+    for (const role of ROLES)
+        counts[role] = 0;
+    return counts;
+}
+function eventTimeMs(event) {
+    const value = event.time.authoredAt ?? event.time.observedAt ?? null;
+    if (!value)
+        return null;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : null;
+}
+function computeSessionStats(envelope, sessionPath) {
+    const byRole = emptyByRole();
+    const projectionCount = (0, session_events_1.projectedSessionEventIds)(envelope).length;
+    let toolCallTotal = 0;
+    let attachments = 0;
+    const toolNameCounts = new Map();
+    let earliestMs = null;
+    let latestMs = null;
+    for (const event of envelope.events) {
+        byRole[event.role] = (byRole[event.role] ?? 0) + 1;
+        attachments += event.attachments.length;
+        for (const call of event.toolCalls) {
+            toolCallTotal += 1;
+            const name = call.function.name;
+            toolNameCounts.set(name, (toolNameCounts.get(name) ?? 0) + 1);
+        }
+        const ms = eventTimeMs(event);
+        if (ms !== null) {
+            if (earliestMs === null || ms < earliestMs)
+                earliestMs = ms;
+            if (latestMs === null || ms > latestMs)
+                latestMs = ms;
+        }
+    }
+    const top = [...toolNameCounts.entries()]
+        .sort((left, right) => right[1] - left[1])
+        .slice(0, 5)
+        .map(([name, count]) => ({ name, count }));
+    return {
+        sessionPath,
+        envelopeVersion: envelope.version,
+        totalEvents: envelope.events.length,
+        byRole,
+        toolCalls: {
+            total: toolCallTotal,
+            distinctNames: toolNameCounts.size,
+            topByFrequency: top,
+        },
+        attachments,
+        timeRange: {
+            earliest: earliestMs !== null ? new Date(earliestMs).toISOString() : null,
+            latest: latestMs !== null ? new Date(latestMs).toISOString() : null,
+            durationMs: earliestMs !== null && latestMs !== null ? latestMs - earliestMs : null,
+        },
+        projection: {
+            eventCount: projectionCount,
+            omittedFromProjection: Math.max(0, envelope.events.length - projectionCount),
+            inputTokens: envelope.projection.inputTokens,
+            maxTokens: envelope.projection.maxTokens,
+            trimmed: envelope.projection.trimmed,
+        },
+        lastUsage: envelope.lastUsage,
+    };
+}
+function runSessionStats(sessionPath) {
+    const text = fs.readFileSync(sessionPath, "utf-8");
+    const raw = JSON.parse(text);
+    const envelope = (0, session_events_1.parseSessionEnvelope)(raw);
+    if (!envelope) {
+        return {
+            sessionPath,
+            envelopeVersion: null,
+            totalEvents: 0,
+            byRole: emptyByRole(),
+            toolCalls: { total: 0, distinctNames: 0, topByFrequency: [] },
+            attachments: 0,
+            timeRange: { earliest: null, latest: null, durationMs: null },
+            projection: { eventCount: 0, omittedFromProjection: 0, inputTokens: null, maxTokens: null, trimmed: false },
+            lastUsage: null,
+        };
+    }
+    return computeSessionStats(envelope, sessionPath);
+}
+function formatStatsReport(report) {
+    const lines = [];
+    lines.push(`Session stats: ${report.sessionPath}`);
+    if (report.envelopeVersion === null) {
+        lines.push("  envelope: unrecognized (could not parse)");
+        return lines.join("\n");
+    }
+    lines.push(`  envelope version: ${report.envelopeVersion}`);
+    lines.push(`  total events:     ${report.totalEvents}`);
+    lines.push(`  by role:          system=${report.byRole.system} user=${report.byRole.user} assistant=${report.byRole.assistant} tool=${report.byRole.tool}`);
+    lines.push(`  tool calls:       ${report.toolCalls.total} (${report.toolCalls.distinctNames} distinct names)`);
+    if (report.toolCalls.topByFrequency.length > 0) {
+        lines.push("  top tools:");
+        for (const { name, count } of report.toolCalls.topByFrequency) {
+            lines.push(`    ${name}: ${count}`);
+        }
+    }
+    lines.push(`  attachments:      ${report.attachments}`);
+    if (report.timeRange.earliest && report.timeRange.latest) {
+        const durationSec = report.timeRange.durationMs !== null ? Math.round(report.timeRange.durationMs / 1000) : null;
+        lines.push(`  time range:       ${report.timeRange.earliest} → ${report.timeRange.latest}${durationSec !== null ? ` (${durationSec}s)` : ""}`);
+    }
+    lines.push("  projection:");
+    lines.push(`    in projection:  ${report.projection.eventCount}`);
+    lines.push(`    omitted:        ${report.projection.omittedFromProjection}`);
+    if (report.projection.inputTokens !== null)
+        lines.push(`    input tokens:   ${report.projection.inputTokens}`);
+    if (report.projection.maxTokens !== null)
+        lines.push(`    max tokens:     ${report.projection.maxTokens}`);
+    if (report.projection.trimmed)
+        lines.push("    trimmed:        true");
+    if (report.lastUsage) {
+        lines.push(`  last usage:       ${JSON.stringify(report.lastUsage)}`);
+    }
+    return lines.join("\n");
+}
+function runSessionStatsCli(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) {
+        // eslint-disable-next-line no-console -- meta-tooling
+        console.log("usage: ouro session-stats <session.json> [--json]");
+        return positional.length === 0 ? 2 : 0;
+    }
+    const report = runSessionStats(positional[0]);
+    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(formatStatsReport(report));
+    }
+    return 0;
+}

package/dist/heart/session-transcript.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeSessionTail = summarizeSessionTail;
+const runtime_1 = require("../nerves/runtime");
+const session_events_1 = require("./session-events");
+function shouldIncludeToolMessages(friendId, channel) {
+    return friendId === "self" && channel === "inner";
+}
+function sortEventsForTranscript(events) {
+    return [...events].sort((a, b) => {
+        const byTime = Date.parse((0, session_events_1.bestEventTimestamp)(a)) - Date.parse((0, session_events_1.bestEventTimestamp)(b));
+        return byTime === 0 ? a.sequence - b.sequence : byTime;
+    });
+}
+function parseToolArguments(toolCall) {
+    try {
+        const parsed = JSON.parse(toolCall.function.arguments);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractHumanVisibleToolText(event, context) {
+    if (event.role !== "assistant" || event.toolCalls.length === 0)
+        return "";
+    for (const toolCall of event.toolCalls) {
+        const args = parseToolArguments(toolCall);
+        if (!args)
+            continue;
+        if (toolCall.function.name === "settle" && typeof args.answer === "string") {
+            return args.answer.trim();
+        }
+        if (toolCall.function.name === "send_message" && typeof args.content === "string") {
+            const targetChannel = typeof args.channel === "string" ? args.channel : "";
+            const targetFriendId = typeof args.friendId === "string" ? args.friendId : "";
+            const targetKey = typeof args.key === "string" ? args.key : "session";
+            if (targetChannel === context.channel && targetFriendId === context.friendId && targetKey === context.key) {
+                return args.content.trim();
+            }
+        }
+    }
+    return "";
+}
+function normalizeSessionMessages(events, context) {
+    return sortEventsForTranscript((0, session_events_1.selectEffectiveSessionEvents)(events))
+        .map((event) => ({
+        id: event.id,
+        role: event.role,
+        content: (0, session_events_1.extractEventText)(event) || extractHumanVisibleToolText(event, context),
+        timestamp: (0, session_events_1.formatSessionEventTimestamp)(event),
+    }))
+        .filter((message) => {
+        if (message.role === "system")
+            return false;
+        if (message.role === "tool" && !context.includeToolMessages)
+            return false;
+        return message.content.length > 0;
+    });
+}
+function buildSummaryInstruction(friendId, channel, trustLevel) {
+    if (friendId === "self" && channel === "inner") {
+        return "summarize this session transcript fully and transparently. this is my own private runtime — include all details, decisions, and reasoning.";
+    }
+    return `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
+}
+function clip(text, limit = 160) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    return compact.length > limit ? compact.slice(0, limit - 1) + "…" : compact;
+}
+function buildSnapshot(summary, tailMessages) {
+    const lines = [`recent focus: ${clip(summary, 240)}`];
+    const latestUser = [...tailMessages].reverse().find((message) => message.role === "user").content;
+    const latestAssistant = [...tailMessages].reverse().find((message) => message.role === "assistant")?.content;
+    lines.push(`latest user: ${clip(latestUser)}`);
+    if (latestAssistant) {
+        lines.push(`latest assistant: ${clip(latestAssistant)}`);
+    }
+    return lines.join("\n");
+}
+function selectSessionTailMessages(messages, messageCount) {
+    const requestedCount = Number.isFinite(messageCount) && messageCount > 0 ? Math.floor(messageCount) : 20;
+    const tail = messages.slice(-requestedCount);
+    const selectedIds = new Set(tail.map((message) => message.id));
+    const latestUser = [...messages].reverse().find((message) => message.role === "user");
+    const latestAssistant = [...messages].reverse().find((message) => message.role === "assistant");
+    selectedIds.add(latestUser.id);
+    if (latestAssistant)
+        selectedIds.add(latestAssistant.id);
+    return messages.filter((message) => selectedIds.has(message.id));
+}
+async function summarizeSessionTail(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_tail_summary",
+        message: "summarizing session transcript tail",
+        meta: {
+            friendId: options.friendId,
+            channel: options.channel,
+            key: options.key,
+            messageCount: options.messageCount,
+        },
+    });
+    const envelope = (0, session_events_1.loadSessionEnvelopeFile)(options.sessionPath);
+    if (!envelope)
+        return { kind: "missing" };
+    const transcriptContext = {
+        friendId: options.friendId,
+        channel: options.channel,
+        key: options.key,
+        includeToolMessages: shouldIncludeToolMessages(options.friendId, options.channel),
+    };
+    const visibleMessages = normalizeSessionMessages(envelope.events, transcriptContext);
+    if (!visibleMessages.some((message) => message.role === "user")) {
+        return { kind: "empty", reason: "envelope_trimmed" };
+    }
+    const tailMessages = selectSessionTailMessages(visibleMessages, options.messageCount);
+    const transcript = tailMessages
+        .map((message) => `[${message.timestamp} | ${message.role} | ${message.id}] ${message.content}`)
+        .join("\n");
+    const summary = options.summarize
+        ? await options.summarize(transcript, buildSummaryInstruction(options.friendId, options.channel, options.trustLevel ?? "family"))
+        : transcript;
+    return {
+        kind: "ok",
+        transcript,
+        summary,
+        snapshot: buildSnapshot(summary, tailMessages),
+        tailMessages,
+    };
+}

package/dist/heart/start-of-turn-packet.js

@@ -0,0 +1,372 @@
+"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.buildCapabilitiesSection = buildCapabilitiesSection;
+exports.buildStartOfTurnPacket = buildStartOfTurnPacket;
+exports.renderStartOfTurnPacket = renderStartOfTurnPacket;
+exports.renderCompactStartOfTurnPacket = renderCompactStartOfTurnPacket;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const bundle_state_1 = require("./bundle-state");
+const tempo_1 = require("./tempo");
+const cares_1 = require("../arc/cares");
+const flight_recorder_1 = require("../arc/flight-recorder");
+const context_loss_sentinel_1 = require("./context-loss-sentinel");
+const orientation_frame_1 = require("./orientation-frame");
+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, now) {
+    if (cares.length === 0)
+        return "";
+    return cares
+        .map((care) => {
+        const c = (0, cares_1.projectCareEvidence)(care, now);
+        if ("recheckRequired" in c)
+            return `- system care [${c.salience}] evidence stale; recheck required`;
+        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, obligations) {
+    // Compose from authored obligation resumeHints and top intentions
+    const hints = [];
+    const effectiveObligations = obligations ?? view.activeObligations;
+    for (const ob of effectiveObligations) {
+        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 (effectiveObligations.length > 0) {
+            hints.push(effectiveObligations[0].content);
+        }
+    }
+    if (hints.length === 0)
+        return "";
+    return hints.join("; ");
+}
+/**
+ * Build a compact summary of capability changes between runtime versions.
+ * Reads bundle-meta.json for version info and changelog.json for change descriptions.
+ * Returns undefined if no version change detected or files are missing/malformed.
+ */
+function buildCapabilitiesSection(bundleRoot) {
+    let meta;
+    try {
+        const raw = fs.readFileSync(path.join(bundleRoot, "bundle-meta.json"), "utf-8");
+        meta = JSON.parse(raw);
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.capabilities_check",
+            message: "bundle-meta.json missing or malformed",
+            meta: { bundleRoot },
+        });
+        return undefined;
+    }
+    const currentVersion = meta.runtimeVersion;
+    const previousVersion = meta.previousRuntimeVersion;
+    if (typeof currentVersion !== "string" || typeof previousVersion !== "string") {
+        return undefined;
+    }
+    if (currentVersion === previousVersion) {
+        return undefined;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.capabilities_version_change",
+        message: `runtime version changed from ${previousVersion} to ${currentVersion}`,
+        meta: { previousVersion, currentVersion },
+    });
+    let changelog;
+    try {
+        const raw = fs.readFileSync(path.join(bundleRoot, "changelog.json"), "utf-8");
+        changelog = JSON.parse(raw);
+    }
+    catch {
+        // changelog missing -- still report the version change
+    }
+    const parts = [`Updated from ${previousVersion} to ${currentVersion}`];
+    if (changelog && Array.isArray(changelog)) {
+        const relevantChanges = [];
+        for (const entry of changelog) {
+            if (entry.version === previousVersion)
+                break;
+            if (Array.isArray(entry.changes)) {
+                relevantChanges.push(...entry.changes);
+            }
+        }
+        if (relevantChanges.length > 0) {
+            parts.push(`: ${relevantChanges.join("; ")}`);
+        }
+    }
+    return parts.join("");
+}
+function buildStartOfTurnPacket(view, opts) {
+    const tempo = view.tempo;
+    const tokenBudget = tempo_1.TEMPO_BUDGETS[tempo];
+    const effectiveObligations = opts?.canonicalObligations ? opts.canonicalObligations.all : view.activeObligations;
+    const packet = {
+        plotLine: buildPlotLine(view.recentEpisodes, tempo),
+        obligations: buildObligationsSection(effectiveObligations),
+        cares: buildCaresSection(view.activeCares, opts?.careEvidenceNow ?? Date.now()),
+        presence: buildPresenceSection(view.peerPresence),
+        arcResume: opts?.flightRecorderResume ? (0, flight_recorder_1.formatFlightRecorderResume)(opts.flightRecorderResume) : undefined,
+        recoverySentinel: opts?.recoverySentinel,
+        resumeHint: buildResumeHint(view, opts?.canonicalObligations ? effectiveObligations : undefined),
+        currentSessionTiming: opts?.currentSessionTiming,
+        friendContactTiming: opts?.friendContactTiming,
+        tempo,
+        tokenBudget,
+        assembledAt: new Date().toISOString(),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.start_of_turn_packet_built",
+        message: `start-of-turn 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 start-of-turn 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 renderStartOfTurnPacket(packet, options = {}) {
+    const budget = packet.tokenBudget;
+    const resumePriorWork = options.resumePriorWork === true;
+    // 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 = [
+        // bundleState and syncFailure share the top remediation tier — both
+        // are actionable "fix your git" signals. bundleState is preferred
+        // because it's structured (array of enum values) while syncFailure is
+        // a legacy free-form string; both render when populated.
+        { label: "provider", content: packet.providerSelection ?? "", priority: 8 },
+        { label: "bundleState", content: (0, bundle_state_1.renderBundleStateHint)(packet.bundleState ?? []), priority: 7 },
+        { label: "syncFailure", content: packet.syncFailure ?? "", priority: 7 },
+        { label: "arc", content: packet.arcResume ?? "", priority: 7 },
+        { label: "recoverySentinel", content: packet.recoverySentinel ? (0, context_loss_sentinel_1.formatContextLossSentinelText)(packet.recoverySentinel) : "", priority: 7 },
+        { label: "resume", content: packet.resumeHint, priority: 6 },
+        { label: "friendContact", content: packet.friendContactTiming ?? "", priority: 6 },
+        { label: "sessionTiming", content: packet.currentSessionTiming ?? "", priority: 5 },
+        { label: "obligations", content: packet.obligations, priority: 5 },
+        { label: "cares", content: packet.cares, priority: 4 },
+        { label: "plot", content: packet.plotLine, priority: 3 },
+        { label: "capabilities", content: packet.capabilities ?? "", 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.start_of_turn_packet_rendered",
+            message: "start-of-turn packet rendered: empty",
+            meta: { tokens: 0, tempo: packet.tempo },
+        });
+        return "";
+    }
+    // Build the rendered output, truncating lower-priority sections first
+    let rendered = formatSections(sections, resumePriorWork);
+    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 continuity sections — they are protected.
+        if (section.label === "resume" || section.label === "arc" || section.label === "recoverySentinel" || section.label === "friendContact" || section.label === "sessionTiming")
+            continue;
+        // Remove this section entirely
+        const idx = sections.findIndex((s) => s.label === section.label);
+        sections.splice(idx, 1);
+        rendered = formatSections(sections, resumePriorWork);
+        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.start_of_turn_packet_rendered",
+        message: `start-of-turn packet rendered: ${tokens} tokens`,
+        meta: { tokens, tempo: packet.tempo, sectionCount: sections.length },
+    });
+    return rendered;
+}
+function formatSections(sections, resumePriorWork) {
+    const parts = [];
+    for (const section of sections) {
+        switch (section.label) {
+            case "resume":
+                parts.push((0, orientation_frame_1.labelPriorWorkSurface)(`**Next:**\n${section.content}`, resumePriorWork));
+                break;
+            case "arc":
+                parts.push((0, orientation_frame_1.labelPriorWorkSurface)(`**Arc:**\n${section.content}`, resumePriorWork));
+                break;
+            case "recoverySentinel":
+                parts.push((0, orientation_frame_1.labelPriorWorkSurface)(`**Recovery Sentinel:**\n${section.content}`, resumePriorWork));
+                break;
+            case "sessionTiming":
+                parts.push(`**Thread timing:** ${section.content}`);
+                break;
+            case "friendContact":
+                parts.push(`**Recent contact:** ${section.content}`);
+                break;
+            case "obligations":
+                parts.push((0, orientation_frame_1.labelPriorWorkSurface)(`**Owed:**\n${section.content}`, resumePriorWork));
+                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;
+            case "capabilities":
+                parts.push(`**Capabilities:** ${section.content}`);
+                break;
+            case "syncFailure":
+                parts.push(`**Sync warning:** ${section.content}`);
+                break;
+            case "bundleState":
+                parts.push(`**Bundle:** ${section.content}`);
+                break;
+            case "provider":
+                parts.push(`**Provider:**\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 renderCompactStartOfTurnPacket(packet, options = {}) {
+    const parts = [];
+    const instruction = (0, orientation_frame_1.priorWorkInstruction)(options.resumePriorWork === true);
+    if (packet.resumeHint) {
+        parts.push(`next:\n${instruction}\n${packet.resumeHint}`);
+    }
+    if (packet.obligations) {
+        // Just first line of obligations
+        const firstOb = packet.obligations.split("\n")[0];
+        parts.push(`owed:\n${instruction}\n${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.start_of_turn_packet_compact_rendered",
+        message: `compact start-of-turn packet: ${estimateTokens(result)} tokens`,
+        meta: { tokens: estimateTokens(result) },
+    });
+    return result;
+}