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

package/dist/heart/session-events.js

@@ -0,0 +1,1504 @@
+"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.EVENT_CONTENT_MAX_CHARS = void 0;
+exports.materializeApprovalTerminal = materializeApprovalTerminal;
+exports.attachApprovalSuspensionCheckpoint = attachApprovalSuspensionCheckpoint;
+exports.listApprovalSuspensionCheckpoints = listApprovalSuspensionCheckpoints;
+exports.removeApprovalSuspensionCheckpoint = removeApprovalSuspensionCheckpoint;
+exports.truncateLargeEventContent = truncateLargeEventContent;
+exports.capStructuredRecordString = capStructuredRecordString;
+exports.capStructuredRecordStringArray = capStructuredRecordStringArray;
+exports.capStructuredRecordStringLeaves = capStructuredRecordStringLeaves;
+exports.normalizeContinuityState = normalizeContinuityState;
+exports.validateSessionMessages = validateSessionMessages;
+exports.detectDuplicateToolCallIds = detectDuplicateToolCallIds;
+exports.repairSessionMessages = repairSessionMessages;
+exports.migrateToolNames = migrateToolNames;
+exports.sanitizeProviderMessages = sanitizeProviderMessages;
+exports.stampIngressTime = stampIngressTime;
+exports.getIngressTime = getIngressTime;
+exports.stampIngressRelations = stampIngressRelations;
+exports.getIngressRelations = getIngressRelations;
+exports.projectedSessionEventIds = projectedSessionEventIds;
+exports.projectProviderMessages = projectProviderMessages;
+exports.annotateMessageTimestamps = annotateMessageTimestamps;
+exports.bestEventTimestamp = bestEventTimestamp;
+exports.formatSessionEventTimestamp = formatSessionEventTimestamp;
+exports.extractEventText = extractEventText;
+exports.deriveSessionChronology = deriveSessionChronology;
+exports.describeCurrentSessionTiming = describeCurrentSessionTiming;
+exports.migrateLegacySessionEnvelope = migrateLegacySessionEnvelope;
+exports.isExactRawSessionRedactionMarker = isExactRawSessionRedactionMarker;
+exports.selectEffectiveSessionEvents = selectEffectiveSessionEvents;
+exports.parseSessionEnvelope = parseSessionEnvelope;
+exports.loadSessionEnvelopeFile = loadSessionEnvelopeFile;
+exports.buildCanonicalSessionEnvelope = buildCanonicalSessionEnvelope;
+exports.appendSyntheticAssistantEvent = appendSyntheticAssistantEvent;
+const fs = __importStar(require("fs"));
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const runtime_1 = require("../nerves/runtime");
+const structured_output_1 = require("./structured-output");
+const APPROVAL_TERMINAL_TEXT = {
+    denied: "approval denied by requester; the protected action was not executed",
+    expired: "approval expired before execution; the protected action was not executed",
+    drifted: "approval became invalid before execution; the protected action was not executed",
+    abandoned_before_attempt: "approval was abandoned before execution; the protected action was not executed; request a fresh approval",
+    attempted_indeterminate: "execution may have occurred; do not retry automatically",
+};
+function messagesRevision(messages) {
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(messages), "utf8").digest("hex");
+}
+function hasExactMaterializedApprovalPair(messages, checkpoint, toolCallId, content) {
+    if (messages.length < 2)
+        return false;
+    const assistant = messages.at(-2);
+    const tool = messages.at(-1);
+    const expectedTool = {
+        role: "tool",
+        tool_call_id: toolCallId,
+        content,
+    };
+    return assistant.role === "assistant"
+        && tool.role === "tool"
+        && messageFingerprint(assistant) === messageFingerprint(checkpoint.frozenAssistantMessage)
+        && messageFingerprint(tool) === messageFingerprint(expectedTool);
+}
+function materializeApprovalTerminal(input) {
+    const messages = structuredClone(input.messages);
+    if (input.record.state === "session_head_changed") {
+        return {
+            messages,
+            materialized: false,
+            resumeProvider: false,
+            directNotice: "the session changed before this approval could be applied; the protected action was not executed",
+            revision: messagesRevision(messages),
+        };
+    }
+    const content = input.record.state === "succeeded" || input.record.state === "failed"
+        ? input.record.result
+        : APPROVAL_TERMINAL_TEXT[input.record.state];
+    if (!content)
+        throw new Error(`approval state ${input.record.state} cannot be materialized`);
+    const resumeProvider = input.record.state === "succeeded" || input.record.state === "failed" || input.record.state === "denied";
+    const exactPair = hasExactMaterializedApprovalPair(messages, input.checkpoint, input.record.toolCallId, content);
+    if (exactPair) {
+        return {
+            messages,
+            materialized: false,
+            resumeProvider,
+            ...(resumeProvider ? {} : { directNotice: content }),
+            ...(input.record.state === "attempted_indeterminate" ? { severity: "high" } : {}),
+            revision: messagesRevision(messages),
+        };
+    }
+    const advanced = input.currentSessionRevision !== input.checkpoint.suspendedSessionRevision;
+    if (advanced) {
+        const notice = input.record.state === "succeeded"
+            ? "the approved action completed, but the session changed; no model continuation was run"
+            : input.record.state === "failed"
+                ? "the approved action failed, but the session changed; no model continuation was run"
+                : input.record.state === "attempted_indeterminate"
+                    ? `${APPROVAL_TERMINAL_TEXT.attempted_indeterminate}; the session changed`
+                    : "the session changed before this approval could be applied; the protected action was not executed";
+        return {
+            messages,
+            materialized: false,
+            resumeProvider: false,
+            directNotice: notice,
+            revision: messagesRevision(messages),
+        };
+    }
+    if (input.materializedApprovalIds?.includes(input.record.approvalId)) {
+        return {
+            messages,
+            materialized: false,
+            resumeProvider,
+            ...(resumeProvider ? {} : { directNotice: content }),
+            ...(input.record.state === "attempted_indeterminate" ? { severity: "high" } : {}),
+            revision: messagesRevision(messages),
+        };
+    }
+    const frozen = structuredClone(input.checkpoint.frozenAssistantMessage);
+    messages.push(frozen, { role: "tool", tool_call_id: input.record.toolCallId, content });
+    const directNotice = resumeProvider ? undefined : content;
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.approval_terminal_materialized",
+        message: "materialized approval terminal transcript pair",
+        meta: { approvalId: input.record.approvalId, state: input.record.state, resumeProvider },
+    });
+    return {
+        messages,
+        materialized: true,
+        resumeProvider,
+        ...(directNotice ? { directNotice } : {}),
+        ...(input.record.state === "attempted_indeterminate" ? { severity: "high" } : {}),
+        revision: messagesRevision(messages),
+    };
+}
+const APPROVAL_HASH = /^[a-f0-9]{64}$/;
+function normalizeApprovalSuspensions(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return [];
+        const record = item;
+        if (typeof record.approvalId !== "string"
+            || typeof record.checkpointDigest !== "string"
+            || !APPROVAL_HASH.test(record.checkpointDigest)
+            || typeof record.baseSessionRevision !== "string"
+            || !APPROVAL_HASH.test(record.baseSessionRevision)
+            || typeof record.suspendedSessionRevision !== "string"
+            || !APPROVAL_HASH.test(record.suspendedSessionRevision)
+            || typeof record.argumentDigest !== "string"
+            || !APPROVAL_HASH.test(record.argumentDigest)
+            || typeof record.schemaDigest !== "string"
+            || !APPROVAL_HASH.test(record.schemaDigest)
+            || typeof record.toolDigest !== "string"
+            || !APPROVAL_HASH.test(record.toolDigest)
+            || typeof record.policyDigest !== "string"
+            || !APPROVAL_HASH.test(record.policyDigest)
+            || typeof record.preCallDigest !== "string"
+            || !APPROVAL_HASH.test(record.preCallDigest)
+            || !Array.isArray(record.preCallMessages)
+            || !record.frozenAssistantMessage
+            || typeof record.frozenAssistantMessage !== "object"
+            || Array.isArray(record.frozenAssistantMessage))
+            return [];
+        return [{
+                approvalId: record.approvalId,
+                checkpointDigest: record.checkpointDigest,
+                baseSessionRevision: record.baseSessionRevision,
+                suspendedSessionRevision: record.suspendedSessionRevision,
+                argumentDigest: record.argumentDigest,
+                schemaDigest: record.schemaDigest,
+                toolDigest: record.toolDigest,
+                policyDigest: record.policyDigest,
+                preCallDigest: record.preCallDigest,
+                preCallMessages: structuredClone(record.preCallMessages),
+                frozenAssistantMessage: structuredClone(record.frozenAssistantMessage),
+            }];
+    });
+}
+function attachApprovalSuspensionCheckpoint(envelope, checkpoint) {
+    const existing = envelope.approvalSuspensions ?? [];
+    const retained = existing.filter((item) => item.approvalId !== checkpoint.approvalId);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.approval_checkpoint_attached",
+        message: "approval suspension checkpoint attached outside provider projection",
+        meta: { approvalId: checkpoint.approvalId },
+    });
+    return { ...envelope, approvalSuspensions: [...retained, structuredClone(checkpoint)] };
+}
+function listApprovalSuspensionCheckpoints(envelope) {
+    return structuredClone(envelope.approvalSuspensions ?? []);
+}
+function removeApprovalSuspensionCheckpoint(envelope, approvalId) {
+    const approvalSuspensions = (envelope.approvalSuspensions ?? []).filter((item) => item.approvalId !== approvalId);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.approval_checkpoint_removed",
+        message: "approval suspension checkpoint removed",
+        meta: { approvalId },
+    });
+    return { ...envelope, approvalSuspensions };
+}
+// Native origins survive replay normalization, but never enter serialized provider or session data.
+const messageSourceEventIds = Symbol("messageSourceEventIds");
+function withMessageSourceEventIds(message, eventIds) {
+    if (eventIds)
+        Object.defineProperty(message, messageSourceEventIds, { value: eventIds });
+    return message;
+}
+exports.EVENT_CONTENT_MAX_CHARS = 256 * 1024;
+function truncateLargeEventContent(content, maxChars) {
+    if (typeof content !== "string") {
+        return { content, truncated: false, originalLength: 0 };
+    }
+    if (content.length <= maxChars) {
+        return { content, truncated: false, originalLength: content.length };
+    }
+    const marker = `[truncated — event content exceeded ${maxChars} chars; original length ${content.length} chars]`;
+    const remainingBudget = Math.max(0, maxChars - marker.length);
+    const headLength = Math.ceil(remainingBudget * 0.75);
+    const tailLength = Math.max(0, remainingBudget - headLength);
+    return {
+        content: `${content.slice(0, headLength)}${marker}${tailLength > 0 ? content.slice(-tailLength) : ""}`,
+        truncated: true,
+        originalLength: content.length,
+    };
+}
+function capStructuredRecordString(value) {
+    return truncateLargeEventContent(value, exports.EVENT_CONTENT_MAX_CHARS).content;
+}
+function capStructuredRecordStringArray(values) {
+    return values.map((value) => capStructuredRecordString(value));
+}
+function capStructuredRecordStringLeaves(value) {
+    if (typeof value === "string") {
+        return capStructuredRecordString(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => capStructuredRecordStringLeaves(item));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    const capped = {};
+    for (const [key, child] of Object.entries(value)) {
+        capped[key] = capStructuredRecordStringLeaves(child);
+    }
+    return capped;
+}
+function formatElapsed(ms) {
+    const minutes = Math.max(0, Math.floor(ms / 60000));
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+const LEGACY_WRITTEN_NOTE_PREFIX = "mem" + "ory";
+const TOOL_NAME_MIGRATIONS = {
+    final_answer: "settle",
+    no_response: "observe",
+    go_inward: "ponder",
+    descend: "ponder",
+    [`${LEGACY_WRITTEN_NOTE_PREFIX}_save`]: "diary_write",
+    [`${LEGACY_WRITTEN_NOTE_PREFIX}_search`]: "search_facts",
+};
+function normalizeUsage(usage) {
+    if (!usage || typeof usage !== "object")
+        return null;
+    const record = usage;
+    if (typeof record.input_tokens !== "number"
+        || typeof record.output_tokens !== "number"
+        || typeof record.reasoning_tokens !== "number"
+        || typeof record.total_tokens !== "number") {
+        return null;
+    }
+    return {
+        input_tokens: record.input_tokens,
+        output_tokens: record.output_tokens,
+        reasoning_tokens: record.reasoning_tokens,
+        total_tokens: record.total_tokens,
+    };
+}
+function normalizeContinuityState(state) {
+    const record = state && typeof state === "object"
+        ? state
+        : null;
+    return {
+        mustResolveBeforeHandoff: record?.mustResolveBeforeHandoff === true,
+        lastFriendActivityAt: typeof record?.lastFriendActivityAt === "string" ? record.lastFriendActivityAt : null,
+    };
+}
+function normalizeContent(content) {
+    if (content == null)
+        return null;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    return content
+        .filter((part) => part != null && typeof part === "object")
+        .map((part) => ({ ...part }));
+}
+const SYNTHETIC_TIMESTAMP_PREFIX_RE = /^(?:(?:\[(?:just now|-\d+[mhd])\])\s*)+/i;
+function stripSyntheticTimestampPrefix(text) {
+    return text.replace(SYNTHETIC_TIMESTAMP_PREFIX_RE, "");
+}
+function sanitizeConversationContent(role, content) {
+    if (role !== "user" && role !== "assistant")
+        return content;
+    if (typeof content === "string")
+        return stripSyntheticTimestampPrefix(content);
+    if (!Array.isArray(content))
+        return content;
+    return content.map((part) => {
+        if (part.type === "text" && typeof part.text === "string") {
+            return { ...part, text: stripSyntheticTimestampPrefix(part.text) };
+        }
+        return part;
+    });
+}
+function normalizeToolCalls(rawToolCalls) {
+    if (!Array.isArray(rawToolCalls))
+        return [];
+    return rawToolCalls
+        .filter((call) => call != null && typeof call === "object")
+        .map((call) => {
+        const fn = call.function;
+        const originalName = typeof fn?.name === "string" ? fn.name : "unknown";
+        const migratedName = TOOL_NAME_MIGRATIONS[originalName] ?? originalName;
+        return {
+            id: typeof call.id === "string" ? call.id : "",
+            type: typeof call.type === "string" ? call.type : "function",
+            function: {
+                name: migratedName,
+                arguments: typeof fn?.arguments === "string" ? fn.arguments : JSON.stringify(fn?.arguments ?? ""),
+            },
+        };
+    });
+}
+function normalizeRole(role) {
+    if (role === "developer")
+        return "system";
+    return role === "system" || role === "user" || role === "assistant" || role === "tool"
+        ? role
+        : "user";
+}
+function normalizeMessage(message) {
+    const record = message;
+    const role = normalizeRole(record.role);
+    const normalizedContent = sanitizeConversationContent(role, normalizeContent(record.content));
+    const sourceEventIds = message[messageSourceEventIds];
+    if (role === "assistant") {
+        return {
+            role,
+            content: normalizedContent,
+            name: typeof record.name === "string" ? record.name : null,
+            toolCallId: null,
+            toolCalls: normalizeToolCalls(record.tool_calls),
+            hadToolCallsField: Array.isArray(record.tool_calls),
+            sourceEventIds,
+        };
+    }
+    if (role === "tool") {
+        return {
+            role,
+            content: typeof record.content === "string" ? record.content : "",
+            name: null,
+            toolCallId: typeof record.tool_call_id === "string" ? record.tool_call_id : null,
+            toolCalls: [],
+            hadToolCallsField: false,
+            sourceEventIds,
+        };
+    }
+    return {
+        role,
+        content: normalizedContent ?? "",
+        name: typeof record.name === "string" ? record.name : null,
+        toolCallId: null,
+        toolCalls: [],
+        hadToolCallsField: false,
+        sourceEventIds,
+    };
+}
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => (part.type === "text" && typeof part.text === "string"
+        ? part.text
+        : ""))
+        .filter((text) => text.length > 0)
+        .join("");
+}
+function toProviderMessage(message) {
+    if (message.role === "assistant") {
+        const assistant = {
+            role: "assistant",
+            content: message.content,
+        };
+        if (message.name)
+            assistant.name = message.name;
+        if (message.hadToolCallsField || message.toolCalls.length > 0) {
+            assistant.tool_calls = message.toolCalls.map((call) => ({
+                id: call.id,
+                type: call.type,
+                function: {
+                    name: call.function.name,
+                    arguments: call.function.arguments,
+                },
+            }));
+        }
+        return withMessageSourceEventIds(assistant, message.sourceEventIds);
+    }
+    if (message.role === "tool") {
+        return withMessageSourceEventIds({
+            role: "tool",
+            content: typeof message.content === "string" ? message.content : contentText(message.content),
+            tool_call_id: message.toolCallId ?? "",
+        }, message.sourceEventIds);
+    }
+    if (message.role === "system") {
+        return withMessageSourceEventIds({
+            role: "system",
+            content: typeof message.content === "string" ? message.content : contentText(message.content),
+            ...(message.name ? { name: message.name } : {}),
+        }, message.sourceEventIds);
+    }
+    return withMessageSourceEventIds({
+        role: "user",
+        content: (typeof message.content === "string" || Array.isArray(message.content) ? message.content : ""),
+        ...(message.name ? { name: message.name } : {}),
+    }, message.sourceEventIds);
+}
+function messageSourcesAgree(left, right) {
+    const leftIds = left[messageSourceEventIds];
+    const rightIds = right[messageSourceEventIds];
+    return !leftIds || !rightIds || leftIds.length === rightIds.length && leftIds.every((id, index) => id === rightIds[index]);
+}
+function messageFingerprint(message, captureContent = false) {
+    const normalized = normalizeMessage(message);
+    return JSON.stringify({
+        role: normalized.role,
+        content: captureContent ? truncateLargeEventContent(normalized.content, exports.EVENT_CONTENT_MAX_CHARS).content : normalized.content,
+        name: normalized.name,
+        tool_call_id: normalized.toolCallId,
+        tool_calls: normalized.toolCalls,
+    });
+}
+function makeEventId(sequence) {
+    return `evt-${String(sequence).padStart(6, "0")}`;
+}
+/**
+ * Collapse duplicate event ids to a single entry, last-occurrence-wins.
+ *
+ * Concurrent writers in older versions of postTurnPersist could each load the
+ * envelope, compute `events.length + 1` for the next sequence, and both write
+ * an event with the same id. The duplicates would persist in the saved JSON
+ * and confuse downstream replay (the same outbound message could appear to
+ * have been sent twice from the agent's perspective without the agent knowing
+ * it sent it). We dedupe defensively on every load so corrupted sessions
+ * self-heal on the next save and so any future race produces a consistent
+ * view.
+ */
+function dedupeEventsByIdLastWins(events) {
+    // Index id → last position so we can preserve original order while
+    // collapsing duplicates to their final occurrence.
+    const lastIndexById = new Map();
+    for (let i = 0; i < events.length; i++) {
+        lastIndexById.set(events[i].id, i);
+    }
+    return events.filter((event, index) => lastIndexById.get(event.id) === index);
+}
+/**
+ * The next sequence to assign for a freshly-built event. Uses max(existing
+ * sequences) + 1 rather than `events.length + 1` so that gaps from earlier
+ * pruning, archive replay, or self-heal dedup never produce a colliding id.
+ */
+function nextEventSequence(existing) {
+    return existing.reduce((max, event) => Math.max(max, event.sequence), 0) + 1;
+}
+function validateSessionMessages(messages) {
+    const violations = [];
+    let prevNonToolRole = null;
+    let prevAssistantHadToolCalls = false;
+    let sawToolResultSincePrevAssistant = false;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = normalizeMessage(messages[i]);
+        if (msg.role === "system")
+            continue;
+        if (msg.role === "tool") {
+            sawToolResultSincePrevAssistant = true;
+            continue;
+        }
+        if (msg.role === "assistant" && prevNonToolRole === "assistant") {
+            if (!(prevAssistantHadToolCalls && sawToolResultSincePrevAssistant)) {
+                violations.push(`back-to-back assistant at index ${i}`);
+            }
+        }
+        prevAssistantHadToolCalls = msg.role === "assistant" && msg.toolCalls.length > 0;
+        sawToolResultSincePrevAssistant = false;
+        prevNonToolRole = msg.role;
+    }
+    for (const collision of detectDuplicateToolCallIds(messages)) {
+        violations.push(`duplicate tool_call_id '${collision.id}' across assistant messages at indices ${collision.indices.join(", ")} — provider may reject (MiniMax canonicalizes call_function_<hash>_<n> across turns)`);
+    }
+    return violations;
+}
+/**
+ * Detect tool_call_ids that appear in more than one assistant message
+ * within the conversation. MiniMax-M2.7 in particular emits canonical
+ * ids of the form `call_function_<hash>_<n>` and reuses the same id
+ * across turns when the same function is called — which causes provider
+ * rejections on replay because tool_call_id is supposed to be unique
+ * per request. We don't (yet) rewrite these here; this function exists
+ * so the sanitize pipeline can surface the collision through nerves
+ * (`mind.session_invariant_violation`) and operators can decide.
+ *
+ * Same-message duplicates (one assistant calling the same id twice)
+ * are not collisions — they're a legitimate parallel call shape and
+ * would be handled by the assistant's own emit logic. We only flag
+ * cross-message reuse.
+ */
+function detectDuplicateToolCallIds(messages) {
+    const idsByFirstIndex = new Map();
+    for (let i = 0; i < messages.length; i++) {
+        const msg = normalizeMessage(messages[i]);
+        if (msg.role !== "assistant")
+            continue;
+        const seenInThisMessage = new Set();
+        for (const call of msg.toolCalls) {
+            if (!call.id || seenInThisMessage.has(call.id))
+                continue;
+            seenInThisMessage.add(call.id);
+            const indices = idsByFirstIndex.get(call.id) ?? [];
+            indices.push(i);
+            idsByFirstIndex.set(call.id, indices);
+        }
+    }
+    const collisions = [];
+    for (const [id, indices] of idsByFirstIndex) {
+        if (indices.length > 1)
+            collisions.push({ id, indices });
+    }
+    return collisions;
+}
+function repairSessionMessages(messages) {
+    const normalized = messages.map(normalizeMessage);
+    const violations = validateSessionMessages(messages);
+    if (violations.length === 0)
+        return normalized.map(toProviderMessage);
+    const result = [];
+    let duplicateAssistantsDropped = 0;
+    for (const msg of normalized) {
+        if (msg.role === "assistant" && result.length > 0) {
+            const prev = result[result.length - 1];
+            if (prev.role === "assistant" && prev.toolCalls.length === 0) {
+                if (prev.sourceEventIds)
+                    prev.sourceEventIds = [...new Set([...prev.sourceEventIds, ...(msg.sourceEventIds ?? [])])];
+                const prevContent = contentText(prev.content);
+                const curContent = contentText(msg.content);
+                // Drop the second of two consecutive assistants when the content is
+                // byte-identical (after trim) — that's a retry/double-persist artifact,
+                // not legitimate continuation. Concatenating them produced visible
+                // duplicate text in surfaces. Empty strings still concatenate (could
+                // be "" + real content).
+                if (prevContent.trim().length > 0 && prevContent.trim() === curContent.trim() && msg.toolCalls.length === 0) {
+                    duplicateAssistantsDropped += 1;
+                    continue;
+                }
+                prev.content = `${prevContent}\n\n${curContent}`;
+                prev.toolCalls = msg.toolCalls;
+                continue;
+            }
+        }
+        result.push(msg);
+    }
+    if (duplicateAssistantsDropped > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_duplicate_assistant_dropped",
+            component: "mind",
+            message: "dropped consecutive assistant messages with identical content (retry/double-persist artifact)",
+            meta: { count: duplicateAssistantsDropped },
+        });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        event: "mind.session_invariant_repair",
+        component: "mind",
+        message: "repaired session invariant violations",
+        meta: { violations },
+    });
+    return result.map(toProviderMessage);
+}
+function repairToolCallSequences(messages, inlineReasoningStrippedCallIds = new Set()) {
+    const normalized = messages.map(normalizeMessage);
+    // Position-aware orphan detection. A tool result is orphaned if there is
+    // no preceding assistant message in the array whose tool_calls contain the
+    // matching id. (The previous logic checked all assistant messages
+    // globally, which kept tool results that appeared BEFORE their matching
+    // assistant — invalid order — and triggered MiniMax error 2013 on replay.)
+    let removed = 0;
+    const seenCallIds = new Set();
+    const repaired = normalized.filter((msg) => {
+        if (msg.role === "assistant") {
+            for (const tc of msg.toolCalls)
+                seenCallIds.add(tc.id);
+            return true;
+        }
+        if (msg.role !== "tool")
+            return true;
+        const keep = msg.toolCallId !== null && seenCallIds.has(msg.toolCallId);
+        if (!keep)
+            removed++;
+        return keep;
+    });
+    if (removed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_orphan_tool_result_repair",
+            component: "mind",
+            message: "removed orphaned tool results from session history",
+            meta: { removed },
+        });
+    }
+    let injected = 0;
+    for (let i = 0; i < repaired.length; i++) {
+        const msg = repaired[i];
+        if (msg.role !== "assistant" || msg.toolCalls.length === 0)
+            continue;
+        const resultIds = new Set();
+        for (let j = i + 1; j < repaired.length; j++) {
+            const following = repaired[j];
+            if (following.role === "tool" && following.toolCallId !== null) {
+                resultIds.add(following.toolCallId);
+                continue;
+            }
+            if (following.role === "assistant" || following.role === "user")
+                break;
+        }
+        const missing = msg.toolCalls.filter((toolCall) => !resultIds.has(toolCall.id));
+        if (missing.length === 0)
+            continue;
+        const syntheticResults = missing.map((toolCall) => ({
+            role: "tool",
+            content: buildSyntheticToolResultMessage(toolCall.id, inlineReasoningStrippedCallIds),
+            name: null,
+            toolCallId: toolCall.id,
+            toolCalls: [],
+            hadToolCallsField: false,
+        }));
+        let insertAt = i + 1;
+        while (insertAt < repaired.length && repaired[insertAt].role === "tool")
+            insertAt++;
+        repaired.splice(insertAt, 0, ...syntheticResults);
+        injected += syntheticResults.length;
+    }
+    if (injected > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_orphan_tool_call_repair",
+            component: "mind",
+            message: "injected synthetic tool results for orphaned tool calls",
+            meta: { injected },
+        });
+    }
+    return repaired.map(toProviderMessage);
+}
+function canonicalizeSystemMessageSequence(messages) {
+    const normalized = messages.map(normalizeMessage);
+    const firstSystemIndex = normalized.findIndex((msg) => msg.role === "system");
+    if (firstSystemIndex === -1)
+        return normalized.map(toProviderMessage);
+    const extraSystemCount = normalized.filter((msg) => msg.role === "system").length - 1;
+    if (firstSystemIndex === 0 && extraSystemCount === 0) {
+        return normalized.map(toProviderMessage);
+    }
+    const primarySystem = normalized[firstSystemIndex];
+    const nonSystemMessages = normalized.filter((msg) => msg.role !== "system");
+    const repaired = [primarySystem, ...nonSystemMessages].map(toProviderMessage);
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        event: "mind.session_system_prompt_repair",
+        component: "mind",
+        message: "canonicalized session system prompt sequence",
+        meta: {
+            firstSystemIndex,
+            extraSystemCount,
+            finalMessageCount: repaired.length,
+        },
+    });
+    return repaired;
+}
+function migrateToolNames(messages) {
+    const safeMessages = messages.filter((message) => Boolean(message) && typeof message === "object");
+    let migrated = 0;
+    for (const message of safeMessages) {
+        const record = message;
+        if (record.role !== "assistant" || !Array.isArray(record.tool_calls))
+            continue;
+        for (const toolCall of record.tool_calls) {
+            if (!toolCall || typeof toolCall !== "object")
+                continue;
+            const toolRecord = toolCall;
+            if (toolRecord.type !== "function")
+                continue;
+            const originalName = toolRecord.function?.name;
+            if (typeof originalName !== "string")
+                continue;
+            if (TOOL_NAME_MIGRATIONS[originalName])
+                migrated += 1;
+        }
+    }
+    if (migrated > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_tool_name_migration",
+            component: "mind",
+            message: "migrated deprecated tool names in session history",
+            meta: { migrated },
+        });
+    }
+    return safeMessages.map(normalizeMessage).map(toProviderMessage);
+}
+/**
+ * Strip inline `<think>...</think>` blocks from a string. Mirrors the
+ * helper at senses/shared-turn.ts (operator-facing) and core.ts
+ * (live-turn) — kept inline here because session-events.ts is the load-
+ * time repair path and needs its own copy to avoid sense/heart import
+ * cycles. If the close tag is missing, drops everything from the open
+ * tag onward.
+ */
+function stripInlineThinkBlocks(input) {
+    let out = input;
+    for (;;) {
+        const open = out.indexOf("<think>");
+        if (open === -1)
+            break;
+        const close = out.indexOf("</think>", open + "<think>".length);
+        if (close === -1) {
+            out = out.slice(0, open);
+            break;
+        }
+        out = out.slice(0, open) + out.slice(close + "</think>".length);
+    }
+    return out.trim();
+}
+/**
+ * Strip inline `<think>` content from any assistant message that ALSO has
+ * tool_calls. MiniMax-style models persist think-content + tool_calls on
+ * the same assistant turn; replaying that combination triggers MiniMax
+ * error 2013 ("tool result's tool id not found") and stalls the session.
+ *
+ * AX requirement: the agent MUST see that this happened. We don't silently
+ * paper over their previous turn — we strip for replay correctness AND
+ * collect the affected tool_call_ids in `inlineReasoningStrippedCallIds`
+ * so the downstream synthetic-tool-result repair can produce an
+ * explanatory message addressed to those specific calls. The agent sees:
+ * "your previous tool call's result was lost because the assistant message
+ * had inline reasoning blocks the provider couldn't replay — here's what
+ * happened, retry if needed." Full awareness, no silent corrections.
+ *
+ * This load-time repair self-heals existing sessions that were saved
+ * before the persist-time strip in core.ts landed.
+ */
+function repairInlineReasoningOnReplay(messages, inlineReasoningStrippedCallIds) {
+    let repaired = 0;
+    const result = messages.map((msg) => {
+        if (msg.role !== "assistant")
+            return msg;
+        const a = msg;
+        if (!a.tool_calls || a.tool_calls.length === 0)
+            return msg;
+        if (typeof a.content !== "string")
+            return msg;
+        if (!a.content.includes("<think>"))
+            return msg;
+        const stripped = stripInlineThinkBlocks(a.content);
+        repaired++;
+        for (const tc of a.tool_calls)
+            inlineReasoningStrippedCallIds.add(tc.id);
+        return withMessageSourceEventIds({ ...a, content: stripped.length > 0 ? stripped : null }, msg[messageSourceEventIds]);
+    });
+    if (repaired > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_inline_reasoning_repair",
+            component: "mind",
+            message: "stripped inline <think> blocks from assistant messages with tool_calls so replay is valid; agent will see explanatory tool-result messages",
+            meta: { repaired, affectedCallIds: inlineReasoningStrippedCallIds.size },
+        });
+    }
+    return result;
+}
+/**
+ * Compose the synthetic tool-result message the agent sees when their
+ * previous turn's tool call has no matching tool result. The default
+ * message tells the agent what happened (turn ended early, result lost)
+ * and what to do (retry if the work isn't done). When the parent
+ * assistant message had inline `<think>` reasoning that the provider
+ * rejected, the message is more specific so the agent can adjust.
+ *
+ * AX rule: every repair must produce a message the agent can read and
+ * act on. Silent strips are never OK.
+ */
+function buildSyntheticToolResultMessage(toolCallId, inlineReasoningStrippedCallIds) {
+    if (inlineReasoningStrippedCallIds.has(toolCallId)) {
+        return [
+            "error: this tool call's result was lost.",
+            "your previous assistant turn included inline `<think>...</think>` reasoning alongside tool_calls,",
+            "and the provider (likely MiniMax) rejects that combination on replay (error 2013).",
+            "the harness has stripped the inline reasoning from the persisted content so the next replay is valid;",
+            "your reasoning trace itself is preserved out-of-band and not lost.",
+            "if the underlying work still needs to be done, retry the tool call now —",
+            "the call may not have run, or it ran but the result didn't reach you.",
+        ].join(" ");
+    }
+    return [
+        "error: this tool call's result was lost — the previous turn ended before the tool finished",
+        "(provider rejection, daemon interrupt, or the tool itself errored).",
+        "if the work needs to be done, retry the tool call now.",
+    ].join(" ");
+}
+function sanitizeProviderMessages(messages) {
+    const safeMessages = messages.filter((message) => Boolean(message) && typeof message === "object");
+    const normalized = safeMessages.map(normalizeMessage);
+    const violations = validateSessionMessages(safeMessages);
+    if (violations.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_invariant_violation",
+            component: "mind",
+            message: "session invariant violated",
+            meta: { violations },
+        });
+    }
+    // Track which tool_call_ids belonged to assistant messages whose inline
+    // reasoning we just stripped. The synthetic-tool-result repair downstream
+    // uses this set to produce an explanatory message for those calls so the
+    // agent has full awareness of what happened.
+    const inlineReasoningStrippedCallIds = new Set();
+    return canonicalizeSystemMessageSequence(migrateToolNames(repairToolCallSequences(repairInlineReasoningOnReplay(repairSessionMessages(normalized.map(toProviderMessage)), inlineReasoningStrippedCallIds), inlineReasoningStrippedCallIds)));
+}
+function stampIngressTime(msg) {
+    msg._ingressAt = new Date().toISOString();
+}
+function getIngressTime(msg) {
+    const value = msg._ingressAt;
+    return typeof value === "string" ? value : null;
+}
+function stampIngressRelations(msg, relations) {
+    ;
+    msg._ingressRelations = structuredClone(relations);
+}
+function getIngressRelations(msg) {
+    const value = msg._ingressRelations;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const relations = value;
+    return {
+        replyToEventId: typeof relations.replyToEventId === "string" ? relations.replyToEventId : null,
+        threadRootEventId: typeof relations.threadRootEventId === "string" ? relations.threadRootEventId : null,
+        references: Array.isArray(relations.references) ? relations.references.filter((item) => typeof item === "string") : [],
+    };
+}
+function createEventTime(role, recordedAt, captureKind, ingressAt) {
+    if (captureKind === "migration") {
+        return {
+            authoredAt: null,
+            authoredAtSource: "migration",
+            observedAt: null,
+            observedAtSource: "migration",
+            recordedAt,
+            recordedAtSource: "migration",
+        };
+    }
+    if (role === "user") {
+        return {
+            authoredAt: null,
+            authoredAtSource: "unknown",
+            observedAt: ingressAt ?? recordedAt,
+            observedAtSource: "ingest",
+            recordedAt,
+            recordedAtSource: "save",
+        };
+    }
+    return {
+        authoredAt: recordedAt,
+        authoredAtSource: "local",
+        observedAt: recordedAt,
+        observedAtSource: "local",
+        recordedAt,
+        recordedAtSource: "save",
+    };
+}
+function buildEventFromMessage(message, sequence, recordedAt, captureKind, sourceMessageIndex, legacyVersion, ingressAt, ingressRelations) {
+    const normalized = normalizeMessage(message);
+    const role = normalized.role;
+    const cappedContent = truncateLargeEventContent(normalized.content, exports.EVENT_CONTENT_MAX_CHARS).content;
+    return {
+        id: makeEventId(sequence),
+        sequence,
+        role,
+        content: cappedContent,
+        name: normalized.name,
+        toolCallId: role === "tool" ? normalized.toolCallId : null,
+        toolCalls: role === "assistant" ? normalized.toolCalls : [],
+        attachments: [],
+        time: createEventTime(role, recordedAt, captureKind, ingressAt),
+        relations: {
+            replyToEventId: ingressRelations?.replyToEventId ?? null,
+            threadRootEventId: ingressRelations?.threadRootEventId ?? null,
+            references: ingressRelations?.references ?? [],
+            toolCallId: role === "tool" ? normalized.toolCallId : null,
+            supersedesEventId: null,
+            redactsEventId: null,
+        },
+        provenance: {
+            captureKind,
+            legacyVersion,
+            sourceMessageIndex,
+        },
+    };
+}
+function projectedSessionEventIds(envelope) {
+    return providerProjectionEvents(envelope).map((event) => event.id);
+}
+function providerProjectionEvents(envelope) {
+    const events = selectEffectiveSessionEvents(envelope.events);
+    if (envelope.projection.eventIds.length === 0)
+        return envelope.projection.trimmed ? [] : events;
+    const byId = new Map(events.map((event) => [event.id, event]));
+    return envelope.projection.eventIds
+        .map((id) => byId.get(id))
+        .filter((event) => Boolean(event));
+}
+function providerMessageFromEvent(event) {
+    return toProviderMessage({
+        role: event.role,
+        content: event.content,
+        name: event.name,
+        toolCallId: event.toolCallId,
+        toolCalls: event.toolCalls,
+        hadToolCallsField: event.toolCalls.length > 0,
+        sourceEventIds: [event.id],
+    });
+}
+function projectProviderMessages(envelope) {
+    return providerProjectionEvents(envelope).map(providerMessageFromEvent);
+}
+/**
+ * Annotate user and assistant messages with a relative time offset tag.
+ * System and tool messages are untouched.
+ */
+function annotateMessageTimestamps(envelope, messages, nowMs = Date.now()) {
+    const events = providerProjectionEvents(envelope);
+    return messages.map((msg, i) => {
+        const event = events[i];
+        if (!event)
+            return msg;
+        if (event.role !== "user" && event.role !== "assistant")
+            return msg;
+        const ts = bestEventTimestamp(event);
+        const elapsed = nowMs - Date.parse(ts);
+        if (elapsed < 0)
+            return msg;
+        const tag = elapsed < 60000 ? "[just now]" : `[-${formatElapsedCompact(elapsed)}]`;
+        if (typeof msg.content === "string" && msg.content.length > 0) {
+            return { ...msg, content: `${tag} ${msg.content}` };
+        }
+        return msg;
+    });
+}
+/** Compact elapsed format for message annotations: "3m", "2h", "1d". */
+function formatElapsedCompact(ms) {
+    const minutes = Math.max(1, Math.floor(ms / 60000));
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}
+function bestEventTimestamp(event) {
+    return event.time.authoredAt ?? event.time.observedAt ?? event.time.recordedAt;
+}
+function formatSessionEventTimestamp(event) {
+    const iso = bestEventTimestamp(event);
+    const date = new Date(iso);
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const hour = String(date.getUTCHours()).padStart(2, "0");
+    const minute = String(date.getUTCMinutes()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hour}:${minute}`;
+}
+function extractEventText(event) {
+    return contentText(event.content);
+}
+function deriveSessionChronology(events) {
+    events = selectEffectiveSessionEvents(events);
+    let lastInboundAt = null;
+    let lastOutboundAt = null;
+    let lastActivityAt = null;
+    let lastAssistantSequence = -1;
+    for (const event of events) {
+        if (event.role === "system")
+            continue;
+        const at = bestEventTimestamp(event);
+        lastActivityAt = at;
+        if (event.role === "user") {
+            lastInboundAt = at;
+        }
+        if (event.role === "assistant") {
+            lastOutboundAt = at;
+            lastAssistantSequence = event.sequence;
+        }
+    }
+    const unansweredInboundCount = events.filter((event) => event.role === "user" && event.sequence > lastAssistantSequence).length;
+    return {
+        lastInboundAt,
+        lastOutboundAt,
+        lastActivityAt,
+        unansweredInboundCount,
+    };
+}
+function describeCurrentSessionTiming(events, nowMs = Date.now()) {
+    const chronology = deriveSessionChronology(events);
+    const parts = [];
+    if (chronology.lastInboundAt) {
+        parts.push(`last inbound ${formatElapsed(nowMs - Date.parse(chronology.lastInboundAt))}`);
+    }
+    if (chronology.lastOutboundAt) {
+        parts.push(`i last replied ${formatElapsed(nowMs - Date.parse(chronology.lastOutboundAt))}`);
+    }
+    if (chronology.unansweredInboundCount > 0) {
+        const count = chronology.unansweredInboundCount;
+        parts.push(`${count} unanswered inbound message${count === 1 ? "" : "s"}`);
+    }
+    return parts.length > 0 ? `current thread: ${parts.join("; ")}` : "";
+}
+function migrateLegacySessionEnvelope(raw, options) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const legacy = raw;
+    const looksLegacy = legacy.version === 1
+        || (legacy.version == null && ("messages" in legacy || "lastUsage" in legacy || "state" in legacy));
+    if (!looksLegacy)
+        return null;
+    const messages = Array.isArray(legacy.messages)
+        ? sanitizeProviderMessages(legacy.messages)
+        : [];
+    const recordedAt = options.fileMtimeAt ?? options.recordedAt;
+    const events = messages.map((message, index) => buildEventFromMessage(message, index + 1, recordedAt, "migration", index, 1));
+    return {
+        version: 2,
+        events,
+        projection: {
+            eventIds: events.map((event) => event.id),
+            trimmed: false,
+            maxTokens: null,
+            contextMargin: null,
+            inputTokens: null,
+            projectedAt: recordedAt,
+        },
+        structuredOutputs: (0, structured_output_1.extractStructuredOutputsFromEvents)(events, { emitTelemetry: false }),
+        lastUsage: normalizeUsage(legacy.lastUsage),
+        state: normalizeContinuityState(legacy.state),
+    };
+}
+function normalizeSessionEvent(event, index, recordedAt) {
+    const role = normalizeRole(event.role);
+    const time = event.time;
+    const relations = event.relations;
+    const provenance = event.provenance;
+    const content = sanitizeConversationContent(role, normalizeContent(event.content));
+    return {
+        id: typeof event.id === "string" ? event.id : makeEventId(index + 1),
+        sequence: typeof event.sequence === "number" ? event.sequence : index + 1,
+        role,
+        content,
+        name: typeof event.name === "string" ? event.name : null,
+        toolCallId: typeof event.toolCallId === "string" ? event.toolCallId : null,
+        toolCalls: normalizeToolCalls(event.toolCalls),
+        attachments: Array.isArray(event.attachments) ? event.attachments.filter((item) => typeof item === "string") : [],
+        time: {
+            authoredAt: typeof time?.authoredAt === "string" ? time.authoredAt : null,
+            authoredAtSource: typeof time?.authoredAtSource === "string" ? time.authoredAtSource : "unknown",
+            observedAt: typeof time?.observedAt === "string" ? time.observedAt : null,
+            observedAtSource: typeof time?.observedAtSource === "string" ? time.observedAtSource : "unknown",
+            recordedAt: typeof time?.recordedAt === "string" ? time.recordedAt : recordedAt,
+            recordedAtSource: typeof time?.recordedAtSource === "string" ? time.recordedAtSource : "save",
+        },
+        relations: {
+            replyToEventId: typeof relations?.replyToEventId === "string" ? relations.replyToEventId : null,
+            threadRootEventId: typeof relations?.threadRootEventId === "string" ? relations.threadRootEventId : null,
+            references: Array.isArray(relations?.references) ? relations.references.filter((item) => typeof item === "string") : [],
+            toolCallId: typeof relations?.toolCallId === "string" ? relations.toolCallId : null,
+            supersedesEventId: typeof relations?.supersedesEventId === "string" ? relations.supersedesEventId : null,
+            redactsEventId: typeof relations?.redactsEventId === "string" ? relations.redactsEventId : null,
+        },
+        provenance: {
+            captureKind: typeof provenance?.captureKind === "string" ? provenance.captureKind : "live",
+            legacyVersion: typeof provenance?.legacyVersion === "number" ? provenance.legacyVersion : null,
+            sourceMessageIndex: typeof provenance?.sourceMessageIndex === "number" ? provenance.sourceMessageIndex : null,
+        },
+    };
+}
+function exactKeys(value, keys) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        && Reflect.ownKeys(value).length === keys.length
+        && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function nonblank(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function exactIsoTime(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+}
+function exactRawEvent(value, index) {
+    if (!exactKeys(value, ["id", "sequence", "role", "content", "name", "toolCallId", "toolCalls", "attachments", "time", "relations", "provenance"]))
+        return false;
+    if (!nonblank(value.id) || !Number.isSafeInteger(value.sequence) || Number(value.sequence) <= 0
+        || typeof value.role !== "string" || !["system", "user", "assistant", "tool"].includes(value.role)
+        || !(value.name === null || typeof value.name === "string") || !(value.toolCallId === null || typeof value.toolCallId === "string")
+        || !(value.content === null || typeof value.content === "string" || Array.isArray(value.content))
+        || !Array.isArray(value.attachments) || !value.attachments.every((item) => typeof item === "string")
+        || !Array.isArray(value.toolCalls))
+        return false;
+    for (const call of value.toolCalls) {
+        if (!exactKeys(call, ["id", "type", "function"]) || !nonblank(call.id) || call.type !== "function"
+            || !exactKeys(call.function, ["name", "arguments"]) || !nonblank(call.function.name) || typeof call.function.arguments !== "string")
+            return false;
+    }
+    const time = value.time;
+    if (!exactKeys(time, ["authoredAt", "authoredAtSource", "observedAt", "observedAtSource", "recordedAt", "recordedAtSource"])
+        || !(time.authoredAt === null || exactIsoTime(time.authoredAt))
+        || !(time.observedAt === null || exactIsoTime(time.observedAt)) || !exactIsoTime(time.recordedAt))
+        return false;
+    for (const key of ["authoredAtSource", "observedAtSource", "recordedAtSource"]) {
+        if (typeof time[key] !== "string" || !["unknown", "local", "ingest", "migration", "save"].includes(time[key]))
+            return false;
+    }
+    const relations = value.relations;
+    if (!exactKeys(relations, ["replyToEventId", "threadRootEventId", "references", "toolCallId", "supersedesEventId", "redactsEventId"])
+        || !Array.isArray(relations.references) || !relations.references.every((item) => typeof item === "string"))
+        return false;
+    for (const key of ["replyToEventId", "threadRootEventId", "toolCallId", "supersedesEventId", "redactsEventId"]) {
+        if (relations[key] !== null && typeof relations[key] !== "string")
+            return false;
+    }
+    const provenance = value.provenance;
+    if (!exactKeys(provenance, ["captureKind", "legacyVersion", "sourceMessageIndex"])
+        || typeof provenance.captureKind !== "string" || !["live", "synthetic", "migration"].includes(provenance.captureKind)
+        || !(provenance.legacyVersion === null || Number.isSafeInteger(provenance.legacyVersion) && Number(provenance.legacyVersion) > 0)
+        || !(provenance.sourceMessageIndex === null || Number.isSafeInteger(provenance.sourceMessageIndex) && Number(provenance.sourceMessageIndex) >= 0))
+        return false;
+    return (0, node_util_1.isDeepStrictEqual)(value, normalizeSessionEvent(value, index, time.recordedAt));
+}
+function isExactRawSessionRedactionMarker(candidate, rawEvents) {
+    if (!candidate || typeof candidate !== "object" || candidate.role !== "system"
+        || !exactRawEvent(candidate, 0) || candidate.content !== null || candidate.name !== null || candidate.toolCallId !== null
+        || candidate.toolCalls.length !== 0 || candidate.attachments.length !== 0
+        || candidate.time.authoredAt !== null || candidate.time.observedAt !== null
+        || candidate.time.authoredAtSource !== "migration" || candidate.time.observedAtSource !== "migration" || candidate.time.recordedAtSource !== "migration"
+        || candidate.provenance.captureKind !== "migration" || candidate.provenance.legacyVersion !== 2 || candidate.provenance.sourceMessageIndex !== null
+        || candidate.relations.replyToEventId !== null || candidate.relations.threadRootEventId !== null || candidate.relations.references.length !== 0
+        || candidate.relations.toolCallId !== null || candidate.relations.supersedesEventId !== null || !nonblank(candidate.relations.redactsEventId)
+        || !Array.isArray(rawEvents))
+        return false;
+    const ids = new Set();
+    let previousSequence = 0;
+    for (const raw of rawEvents) {
+        if (!raw || typeof raw !== "object")
+            return false;
+        const event = raw;
+        if (!nonblank(event.id) || ids.has(event.id) || !Number.isSafeInteger(event.sequence) || Number(event.sequence) <= previousSequence)
+            return false;
+        ids.add(event.id);
+        previousSequence = Number(event.sequence);
+    }
+    const candidateIndex = rawEvents.findIndex((raw) => raw.id === candidate.id);
+    if (candidateIndex < 0 || !(0, node_util_1.isDeepStrictEqual)(rawEvents[candidateIndex], candidate))
+        return false;
+    const targetIndex = rawEvents.findIndex((raw) => raw.id === candidate.relations.redactsEventId);
+    if (targetIndex < 0 || targetIndex >= candidateIndex)
+        return false;
+    const target = rawEvents[targetIndex];
+    if (!exactRawEvent(target, targetIndex) || target.role !== "user" || target.relations.redactsEventId !== null)
+        return false;
+    const attempts = rawEvents.map((raw) => raw.relations?.redactsEventId);
+    return attempts.filter((id) => id === target.id).length === 1 && !attempts.includes(candidate.id);
+}
+function selectEffectiveSessionEvents(events) {
+    const hidden = new Set();
+    for (const event of events) {
+        if (isExactRawSessionRedactionMarker(event, events)) {
+            hidden.add(event.id);
+            hidden.add(event.relations.redactsEventId);
+        }
+    }
+    return events.filter((event) => !hidden.has(event.id));
+}
+function parseSessionEnvelope(raw, options = {}) {
+    const recordedAt = options.recordedAt ?? new Date().toISOString();
+    const fileMtimeAt = options.fileMtimeAt ?? null;
+    const migrated = migrateLegacySessionEnvelope(raw, { recordedAt, fileMtimeAt });
+    if (migrated)
+        return migrated;
+    if (!raw || typeof raw !== "object")
+        return null;
+    const record = raw;
+    if (record.version !== 2 || !Array.isArray(record.events) || !record.projection || typeof record.projection !== "object") {
+        return null;
+    }
+    const validMarkers = new Set(record.events.filter((event) => isExactRawSessionRedactionMarker(event, record.events)));
+    let invalidMarkers = 0;
+    const rawEvents = record.events
+        .filter((event) => event != null && typeof event === "object")
+        .map((event, index) => {
+        const normalized = normalizeSessionEvent(event, index, recordedAt);
+        const attempted = event.relations?.redactsEventId;
+        if (attempted !== undefined && attempted !== null && !validMarkers.has(event)) {
+            normalized.relations.redactsEventId = null;
+            invalidMarkers++;
+        }
+        return normalized;
+    });
+    if (invalidMarkers > 0)
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn", component: "heart", event: "session.redaction_marker_invalid",
+            message: "invalid raw redaction authority ignored", meta: { count: invalidMarkers },
+        });
+    // Self-heal duplicate event ids that may have been written by concurrent
+    // writers in older harness versions. Last-occurrence-wins by id (later
+    // entries in the persisted file are the more recent state for that id).
+    // We preserve the original document order otherwise, so projection.eventIds
+    // still resolves predictably.
+    const events = dedupeEventsByIdLastWins(rawEvents);
+    const projection = record.projection;
+    const envelope = {
+        version: 2,
+        events,
+        projection: {
+            eventIds: Array.isArray(projection.eventIds) ? projection.eventIds.filter((item) => typeof item === "string") : [],
+            trimmed: projection.trimmed === true,
+            maxTokens: typeof projection.maxTokens === "number" ? projection.maxTokens : null,
+            contextMargin: typeof projection.contextMargin === "number" ? projection.contextMargin : null,
+            inputTokens: typeof projection.inputTokens === "number" ? projection.inputTokens : null,
+            projectedAt: typeof projection.projectedAt === "string" ? projection.projectedAt : null,
+        },
+        lastUsage: normalizeUsage(record.lastUsage),
+        state: normalizeContinuityState(record.state),
+        approvalSuspensions: normalizeApprovalSuspensions(record.approvalSuspensions),
+    };
+    envelope.structuredOutputs = (0, structured_output_1.extractStructuredOutputsFromEvents)(providerProjectionEvents(envelope), { emitTelemetry: false });
+    return envelope;
+}
+function loadSessionEnvelopeFile(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        let mtime;
+        try {
+            mtime = fs.statSync(filePath).mtime.toISOString();
+        }
+        catch {
+            mtime = new Date().toISOString();
+        }
+        return parseSessionEnvelope(JSON.parse(raw), {
+            recordedAt: mtime,
+            fileMtimeAt: mtime,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function messageRole(msg) {
+    return normalizeRole(msg.role);
+}
+function filterNonSystem(messages) {
+    return messages.filter((msg) => messageRole(msg) !== "system");
+}
+/**
+ * Compare two message arrays by their non-system messages only.
+ * Returns the number of matching non-system messages from the start.
+ * System messages (whose content changes every turn due to live world-state)
+ * are excluded so that prefix matching is not defeated by system prompt updates.
+ */
+function findCommonPrefixLength(a, b, captureContent = false) {
+    const aNonSys = filterNonSystem(a);
+    const bNonSys = filterNonSystem(b);
+    const max = Math.min(aNonSys.length, bNonSys.length);
+    for (let i = 0; i < max; i++) {
+        if (!messageSourcesAgree(aNonSys[i], bNonSys[i]))
+            return i;
+        if (messageFingerprint(aNonSys[i], captureContent) !== messageFingerprint(bNonSys[i], captureContent))
+            return i;
+    }
+    return max;
+}
+function selectProjectedEventIds(currentMessages, currentEventIds, trimmedMessages) {
+    if (trimmedMessages.length === 0)
+        return [];
+    const result = [];
+    const currentIdentities = new Set(currentMessages);
+    let needle = 0;
+    let trimmedFingerprint = null;
+    for (let i = 0; i < currentMessages.length && needle < trimmedMessages.length; i++) {
+        const currentMessage = currentMessages[i];
+        const trimmedMessage = trimmedMessages[needle];
+        if (currentMessage !== trimmedMessage) {
+            if (currentIdentities.has(trimmedMessage))
+                continue;
+            if (!messageSourcesAgree(currentMessage, trimmedMessage))
+                continue;
+            trimmedFingerprint ??= messageFingerprint(trimmedMessage);
+            if (messageFingerprint(currentMessage) !== trimmedFingerprint)
+                continue;
+        }
+        result.push(...currentEventIds[i]);
+        needle++;
+        trimmedFingerprint = null;
+    }
+    return result;
+}
+function retainedSourceEventIds(message, existing, used) {
+    const ids = message[messageSourceEventIds];
+    if (!ids?.length || ids.some((id) => !existing.has(id) || used.has(id)))
+        return null;
+    const originals = ids.map((id) => providerMessageFromEvent(existing.get(id)));
+    const fingerprint = messageFingerprint(message, true);
+    const matches = (candidate) => (candidate[messageSourceEventIds] !== undefined
+        && messageSourcesAgree(candidate, message)
+        && messageFingerprint(candidate, true) === fingerprint);
+    return originals.some(matches) || sanitizeProviderMessages(originals).some(matches) ? ids : null;
+}
+function buildCanonicalSessionEnvelope(options) {
+    const existing = options.existing;
+    // Callers pass pre-sanitized messages + pre-captured ingress times.
+    const currentIngressTimes = options.currentIngressTimes ?? options.currentMessages.map(getIngressTime);
+    const currentIngressRelations = options.currentIngressRelations ?? options.currentMessages.map(getIngressRelations);
+    let previousMessages = options.previousMessages;
+    const currentMessages = options.currentMessages;
+    const trimmedMessages = options.trimmedMessages;
+    let previousProjectionGroups = existing ? providerProjectionEvents(existing).map((event) => [event.id]) : [];
+    // Compare only non-system messages to find the common prefix.
+    // System messages change every turn (live world-state in system prompt)
+    // and must not defeat prefix matching of the actual conversation.
+    let nonSystemPrefix = findCommonPrefixLength(previousMessages, currentMessages, true);
+    // A repaired provider message can represent several original native records.
+    const repairedPrevious = sanitizeProviderMessages(previousMessages.map((message, index) => withMessageSourceEventIds({ ...message }, previousProjectionGroups[index])));
+    const repairedPrefix = findCommonPrefixLength(repairedPrevious, currentMessages);
+    if (repairedPrefix > nonSystemPrefix) {
+        previousMessages = repairedPrevious;
+        previousProjectionGroups = repairedPrevious.map((message) => message[messageSourceEventIds] ?? []);
+        nonSystemPrefix = repairedPrefix;
+    }
+    // Build a lookup of non-system previous projection IDs.
+    const prevNonSystemIds = [];
+    for (let i = 0; i < previousMessages.length; i++) {
+        if (messageRole(previousMessages[i]) !== "system") {
+            prevNonSystemIds.push(previousProjectionGroups[i]);
+        }
+    }
+    // Walk currentMessages and build currentEventIds + new events.
+    // Non-system messages within the prefix reuse old event IDs.
+    // Other messages reuse a matching native origin or create a new event.
+    const events = [...(existing?.events ?? [])];
+    const sourceEvents = new Map(selectEffectiveSessionEvents(events).map((event) => [event.id, event]));
+    const excludedSourceIds = new Set(events.filter((event) => !sourceEvents.has(event.id)).map((event) => event.id));
+    const usedEventIds = new Set();
+    const currentEventIds = [];
+    let nonSystemSeen = 0;
+    for (let i = 0; i < currentMessages.length; i++) {
+        const sourceIds = currentMessages[i][messageSourceEventIds];
+        if (sourceIds?.some((id) => excludedSourceIds.has(id))) {
+            throw new Error("cannot persist messages derived from redacted session events");
+        }
+        const role = messageRole(currentMessages[i]);
+        const isSystem = role === "system";
+        const inPrefix = !isSystem && nonSystemSeen < nonSystemPrefix;
+        if (inPrefix && prevNonSystemIds[nonSystemSeen].every((id) => !usedEventIds.has(id))) {
+            // Reuse existing event ID for this matched non-system message
+            currentEventIds.push(prevNonSystemIds[nonSystemSeen]);
+            nonSystemSeen++;
+        }
+        else if (isSystem && i < previousMessages.length
+            && messageRole(previousMessages[i]) === "system"
+            && messageSourcesAgree(currentMessages[i], previousMessages[i])
+            && previousProjectionGroups[i].every((id) => !usedEventIds.has(id))
+            && messageFingerprint(currentMessages[i], true) === messageFingerprint(previousMessages[i], true)) {
+            // System message at same position with identical content -- reuse event ID
+            currentEventIds.push(previousProjectionGroups[i]);
+        }
+        else {
+            if (!isSystem)
+                nonSystemSeen++;
+            const retainedIds = retainedSourceEventIds(currentMessages[i], sourceEvents, usedEventIds);
+            if (retainedIds) {
+                currentEventIds.push(retainedIds);
+                for (const id of retainedIds)
+                    usedEventIds.add(id);
+                continue;
+            }
+            // Create a new event. Use nextEventSequence(events) instead of
+            // `events.length + 1` so that any gap (from pruning, archive replay,
+            // or self-heal dedup) cannot collide with an existing id.
+            const event = buildEventFromMessage(currentMessages[i], nextEventSequence(events), options.recordedAt, "live", null, null, currentIngressTimes[i], currentIngressRelations[i]);
+            events.push(event);
+            currentEventIds.push([event.id]);
+        }
+        for (const id of currentEventIds.at(-1))
+            usedEventIds.add(id);
+    }
+    const projectionEventIds = selectProjectedEventIds(currentMessages, currentEventIds, trimmedMessages);
+    // Projection omissions are not authority to delete native history.
+    const projectionIdSet = new Set(projectionEventIds);
+    const effectiveEvents = selectEffectiveSessionEvents(events);
+    const effectiveIds = new Set(effectiveEvents.map((event) => event.id));
+    const evictedEvents = effectiveEvents.filter((event) => !projectionIdSet.has(event.id));
+    const envelope = {
+        version: 2,
+        events,
+        projection: {
+            eventIds: projectionEventIds.filter((id) => effectiveIds.has(id)),
+            trimmed: evictedEvents.length > 0,
+            maxTokens: options.projectionBasis.maxTokens,
+            contextMargin: options.projectionBasis.contextMargin,
+            inputTokens: options.projectionBasis.inputTokens,
+            projectedAt: options.recordedAt,
+        },
+        lastUsage: normalizeUsage(options.lastUsage),
+        state: normalizeContinuityState(options.state),
+        approvalSuspensions: structuredClone(options.existing?.approvalSuspensions ?? []),
+    };
+    envelope.structuredOutputs = (0, structured_output_1.extractStructuredOutputsFromEvents)(providerProjectionEvents(envelope));
+    return { envelope, evictedEvents };
+}
+function appendSyntheticAssistantEvent(envelope, content, recordedAt) {
+    // Use nextEventSequence(events) instead of `events.length + 1` so any gap
+    // (from pruning, archive replay, or self-heal dedup) cannot collide with
+    // an existing event id. Same fix pattern as line 1046.
+    const sequence = nextEventSequence(envelope.events);
+    const event = buildEventFromMessage({ role: "assistant", content }, sequence, recordedAt, "synthetic", null, null);
+    const priorIds = projectedSessionEventIds(envelope);
+    const updated = {
+        ...envelope,
+        events: [...envelope.events, event],
+        projection: {
+            ...envelope.projection,
+            eventIds: [...priorIds, event.id],
+            projectedAt: recordedAt,
+            trimmed: new Set(priorIds).size < selectEffectiveSessionEvents(envelope.events).length,
+        },
+    };
+    updated.structuredOutputs = (0, structured_output_1.extractStructuredOutputsFromEvents)(providerProjectionEvents(updated));
+    return updated;
+}