@martinloop/mcp 0.3.6 → 0.3.8

package/dist/vendor/adapters/core/src/persistence/integrity.js

@@ -0,0 +1,252 @@
+import { createHash, createHmac, randomBytes } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const RECEIPT_INTEGRITY_SCHEMA_VERSION = "martin.receipt-integrity.v1";
+const RECEIPT_INTEGRITY_KEY_DIR_MODE = 0o700;
+const RECEIPT_INTEGRITY_KEY_FILE_MODE = 0o600;
+export function resolveReceiptIntegrityRoot(env = process.env) {
+    return env["MARTIN_INTEGRITY_KEY_DIR"]?.trim() ??
+        join(homedir(), ".martin", "receipt-integrity");
+}
+export async function writeReceiptIntegrityMaterial(input) {
+    const signedAt = input.signedAt ?? new Date().toISOString();
+    const keyMaterial = await ensureReceiptIntegrityKey(input.runsRoot, input.runId);
+    if (!keyMaterial) {
+        return undefined;
+    }
+    const [key, keyId] = keyMaterial;
+    const chain = buildReceiptIntegrityChain(input.ledgerEntries);
+    const loopRecordRaw = serializeStoredJson(input.loopRecord);
+    const ledgerRaw = serializeStoredJsonl(input.ledgerEntries);
+    const materialBase = {
+        schemaVersion: RECEIPT_INTEGRITY_SCHEMA_VERSION,
+        runId: input.runId,
+        keyId,
+        signedAt,
+        ...(input.scope ? { scope: input.scope } : {}),
+        loopRecordSha256: sha256(loopRecordRaw),
+        ledgerSha256: sha256(ledgerRaw),
+        ledgerHeadHash: chain.at(-1)?.entryHash ?? "root",
+        entryCount: chain.length,
+        chain
+    };
+    const material = {
+        ...materialBase,
+        signatureHmacSha256: createReceiptIntegritySignature(key, materialBase)
+    };
+    await mkdir(join(input.runsRoot, input.runId), { recursive: true });
+    await writeFile(resolveReceiptIntegrityPath(input.runsRoot, input.runId), serializeStoredJson(material), "utf8");
+    return material;
+}
+export async function verifyReceiptIntegrityFromFiles(input) {
+    const integrityPath = resolveReceiptIntegrityPath(input.runsRoot, input.runId);
+    const [rawMaterial, rawLoopRecord, rawLedger, key] = await Promise.all([
+        readFile(integrityPath, "utf8").catch(() => null),
+        readFile(input.loopRecordPath, "utf8").catch(() => null),
+        readFile(input.ledgerPath, "utf8").catch(() => null),
+        readReceiptIntegrityKey(input.runsRoot, input.runId).catch(() => null)
+    ]);
+    if (!rawMaterial || !rawLoopRecord || rawLedger === null || !key) {
+        return {
+            state: "material_missing",
+            reason: "Receipt integrity material is missing for this run.",
+            warnings: ["Receipt integrity material is incomplete; trust claims are unavailable."]
+        };
+    }
+    let material;
+    try {
+        material = JSON.parse(rawMaterial);
+    }
+    catch {
+        return {
+            state: "tamper_detected",
+            reason: "Receipt integrity metadata is unreadable."
+        };
+    }
+    const actualLoopRecordSha256 = sha256(rawLoopRecord);
+    if (actualLoopRecordSha256 !== material.loopRecordSha256) {
+        return {
+            state: "tamper_detected",
+            keyId: material.keyId,
+            signedAt: material.signedAt,
+            loopRecordSha256: material.loopRecordSha256,
+            ledgerSha256: material.ledgerSha256,
+            ledgerHeadHash: material.ledgerHeadHash,
+            entryCount: material.entryCount,
+            reason: "loop_record_hash_mismatch"
+        };
+    }
+    const actualLedgerSha256 = sha256(rawLedger);
+    if (actualLedgerSha256 !== material.ledgerSha256) {
+        return {
+            state: "tamper_detected",
+            keyId: material.keyId,
+            signedAt: material.signedAt,
+            loopRecordSha256: material.loopRecordSha256,
+            ledgerSha256: material.ledgerSha256,
+            ledgerHeadHash: material.ledgerHeadHash,
+            entryCount: material.entryCount,
+            reason: "ledger_hash_mismatch"
+        };
+    }
+    let parsedLedgerEntries;
+    try {
+        parsedLedgerEntries = rawLedger
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return {
+            state: "tamper_detected",
+            keyId: material.keyId,
+            signedAt: material.signedAt,
+            loopRecordSha256: material.loopRecordSha256,
+            ledgerSha256: material.ledgerSha256,
+            ledgerHeadHash: material.ledgerHeadHash,
+            entryCount: material.entryCount,
+            reason: "ledger_entry_parse_error"
+        };
+    }
+    const actualChain = buildReceiptIntegrityChain(parsedLedgerEntries);
+    if (actualChain.length !== material.chain.length) {
+        return {
+            state: "tamper_detected",
+            keyId: material.keyId,
+            signedAt: material.signedAt,
+            loopRecordSha256: material.loopRecordSha256,
+            ledgerSha256: material.ledgerSha256,
+            ledgerHeadHash: material.ledgerHeadHash,
+            entryCount: material.entryCount,
+            reason: "ledger_entry_count_mismatch"
+        };
+    }
+    for (let index = 0; index < actualChain.length; index += 1) {
+        const expected = material.chain[index];
+        const actual = actualChain[index];
+        if (!expected ||
+            !actual ||
+            expected.entryHash !== actual.entryHash ||
+            expected.prevHash !== actual.prevHash) {
+            return {
+                state: "tamper_detected",
+                keyId: material.keyId,
+                signedAt: material.signedAt,
+                loopRecordSha256: material.loopRecordSha256,
+                ledgerSha256: material.ledgerSha256,
+                ledgerHeadHash: material.ledgerHeadHash,
+                entryCount: material.entryCount,
+                reason: `ledger_chain_mismatch:${index}`
+            };
+        }
+    }
+    const signatureBase = {
+        schemaVersion: material.schemaVersion,
+        runId: material.runId,
+        keyId: material.keyId,
+        signedAt: material.signedAt,
+        ...(material.scope ? { scope: material.scope } : {}),
+        loopRecordSha256: material.loopRecordSha256,
+        ledgerSha256: material.ledgerSha256,
+        ledgerHeadHash: material.ledgerHeadHash,
+        entryCount: material.entryCount,
+        chain: material.chain
+    };
+    const expectedSignature = createReceiptIntegritySignature(key, signatureBase);
+    if (expectedSignature !== material.signatureHmacSha256) {
+        return {
+            state: "tamper_detected",
+            keyId: material.keyId,
+            signedAt: material.signedAt,
+            loopRecordSha256: material.loopRecordSha256,
+            ledgerSha256: material.ledgerSha256,
+            ledgerHeadHash: material.ledgerHeadHash,
+            entryCount: material.entryCount,
+            reason: "signature_mismatch"
+        };
+    }
+    return {
+        state: "verified",
+        keyId: material.keyId,
+        signedAt: material.signedAt,
+        loopRecordSha256: material.loopRecordSha256,
+        ledgerSha256: material.ledgerSha256,
+        ledgerHeadHash: material.ledgerHeadHash,
+        entryCount: material.entryCount
+    };
+}
+export function resolveReceiptIntegrityPath(runsRoot, runId) {
+    return join(runsRoot, runId, "receipt-integrity.json");
+}
+function buildReceiptIntegrityChain(entries) {
+    let previousHash = "root";
+    return entries.map((entry, index) => {
+        const normalizedEntry = JSON.stringify(entry);
+        const entryHash = sha256(`${previousHash}\n${normalizedEntry}`);
+        const candidate = entry;
+        const chainEntry = {
+            index,
+            prevHash: previousHash,
+            entryHash
+        };
+        if (typeof candidate.eventId === "string") {
+            chainEntry.eventId = candidate.eventId;
+        }
+        if (typeof candidate.type === "string") {
+            chainEntry.type = candidate.type;
+        }
+        if (typeof candidate.kind === "string") {
+            chainEntry.kind = candidate.kind;
+        }
+        if (typeof candidate.timestamp === "string") {
+            chainEntry.timestamp = candidate.timestamp;
+        }
+        previousHash = entryHash;
+        return chainEntry;
+    });
+}
+function createReceiptIntegritySignature(key, material) {
+    return createHmac("sha256", key).update(JSON.stringify(material)).digest("hex");
+}
+async function ensureReceiptIntegrityKey(runsRoot, runId) {
+    const keyPath = resolveReceiptIntegrityKeyPath(runsRoot, runId);
+    const existing = await readFile(keyPath, "utf8").catch(() => null);
+    if (existing) {
+        const trimmed = existing.trim();
+        return [trimmed, sha256(trimmed).slice(0, 16)];
+    }
+    const generated = randomBytes(32).toString("hex");
+    try {
+        await mkdir(dirname(keyPath), { recursive: true, mode: RECEIPT_INTEGRITY_KEY_DIR_MODE });
+        await writeFile(keyPath, `${generated}\n`, {
+            encoding: "utf8",
+            mode: RECEIPT_INTEGRITY_KEY_FILE_MODE
+        });
+    }
+    catch {
+        return undefined;
+    }
+    return [generated, sha256(generated).slice(0, 16)];
+}
+async function readReceiptIntegrityKey(runsRoot, runId) {
+    const raw = await readFile(resolveReceiptIntegrityKeyPath(runsRoot, runId), "utf8");
+    return raw.trim();
+}
+function resolveReceiptIntegrityKeyPath(runsRoot, runId) {
+    const rootHash = sha256(runsRoot).slice(0, 16);
+    return join(resolveReceiptIntegrityRoot(), rootHash, `${runId}.key`);
+}
+function serializeStoredJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function serializeStoredJsonl(entries) {
+    if (entries.length === 0) {
+        return "";
+    }
+    return `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}

package/dist/vendor/adapters/core/src/persistence/ledger.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Ledger event types for the Phase 3 persistence stack.
+ * These are WRITE-side events that go into ledger.jsonl — separate from the
+ * read-model LoopEventType used by the control plane.
+ */
+export type LedgerEventKind = "contract.created" | "attempt.admitted" | "attempt.rejected" | "prompt.compiled" | "patch.generated" | "verification.completed" | "grounding.violations_found" | "safety.violations_found" | "budget.settled" | "attempt.kept" | "attempt.discarded" | "run.exited";
+export interface LedgerEvent {
+    kind: LedgerEventKind;
+    runId: string;
+    attemptIndex?: number;
+    timestamp: string;
+    payload: Record<string, unknown>;
+}
+export interface LedgerEventDraft {
+    kind: LedgerEventKind;
+    runId: string;
+    attemptIndex?: number;
+    payload: Record<string, unknown>;
+    timestamp?: string;
+}
+export declare function makeLedgerEvent(draft: LedgerEventDraft, options?: {
+    now?: string;
+}): LedgerEvent;

package/dist/vendor/adapters/core/src/persistence/ledger.js

@@ -0,0 +1,9 @@
+export function makeLedgerEvent(draft, options = {}) {
+    return {
+        kind: draft.kind,
+        runId: draft.runId,
+        timestamp: draft.timestamp ?? options.now ?? new Date().toISOString(),
+        payload: draft.payload,
+        ...(draft.attemptIndex !== undefined ? { attemptIndex: draft.attemptIndex } : {})
+    };
+}

package/dist/vendor/adapters/core/src/persistence/memory-store.d.ts

@@ -0,0 +1,63 @@
+/**
+ * MartinLoop Memory Store
+ *
+ * Append-only, never-overwriting persistent memory. Records user consent
+ * signals, preferences, behavioral patterns, and learning outcomes so
+ * MartinLoop gets smarter with every session.
+ *
+ * Design principles:
+ * - Append-only JSONL — entries are never deleted or overwritten
+ * - Structured by kind — each memory entry has a type and a key
+ * - Source-aware — distinguishes explicit user input from inferred patterns
+ * - Confidence-scored — inferred memories degrade gracefully
+ *
+ * Storage: <runsRoot>/_martin/memory.jsonl
+ */
+export type MemoryKind = "consent" | "preference" | "pattern" | "feedback" | "budget" | "model";
+export interface MemoryEntry {
+    /** ISO-8601 timestamp */
+    timestamp: string;
+    /** What kind of memory this is */
+    kind: MemoryKind;
+    /** Dot-notated key, e.g. "model.direct.claude", "budget.auth.usd", "gate.bypassed" */
+    key: string;
+    /** The memory payload */
+    value: unknown;
+    /** Did the user say it explicitly, or did Martin observe it? */
+    source: "explicit" | "inferred";
+    /** Confidence score 0-1 — inferred memories should be < 0.8 */
+    confidence: number;
+}
+export interface MemorySummary {
+    totalEntries: number;
+    byKind: Partial<Record<MemoryKind, MemoryEntry[]>>;
+    recentPreferences: MemoryEntry[];
+    recentConsents: MemoryEntry[];
+    recentFeedback: MemoryEntry[];
+}
+/**
+ * Append a memory entry. Never overwrites — always appends.
+ */
+export declare function appendMemory(runsRoot: string, entry: MemoryEntry): Promise<void>;
+/**
+ * Read all memory entries in order (oldest first).
+ */
+export declare function readMemoryEntries(runsRoot: string): Promise<MemoryEntry[]>;
+/**
+ * Get the most recent memory entry for a specific key.
+ * Returns undefined if no entry exists for that key.
+ */
+export declare function getPreference(runsRoot: string, key: string): Promise<MemoryEntry | undefined>;
+/**
+ * Build a summary of memory entries for MCP resource and MartinLoop context injection.
+ * Returns the top 20 most recent entries per kind.
+ */
+export declare function buildMemorySummary(entries: MemoryEntry[]): MemorySummary;
+/**
+ * Record a preference from user input.
+ */
+export declare function recordPreference(runsRoot: string, key: string, value: unknown, source?: "explicit" | "inferred"): Promise<void>;
+/**
+ * Record a consent signal (user approved or denied a governance action).
+ */
+export declare function recordConsent(runsRoot: string, action: string, approved: boolean, context?: Record<string, unknown>): Promise<void>;

package/dist/vendor/adapters/core/src/persistence/memory-store.js

@@ -0,0 +1,115 @@
+/**
+ * MartinLoop Memory Store
+ *
+ * Append-only, never-overwriting persistent memory. Records user consent
+ * signals, preferences, behavioral patterns, and learning outcomes so
+ * MartinLoop gets smarter with every session.
+ *
+ * Design principles:
+ * - Append-only JSONL — entries are never deleted or overwritten
+ * - Structured by kind — each memory entry has a type and a key
+ * - Source-aware — distinguishes explicit user input from inferred patterns
+ * - Confidence-scored — inferred memories degrade gracefully
+ *
+ * Storage: <runsRoot>/_martin/memory.jsonl
+ */
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const MEMORY_DIRECTORY = "_martin";
+const MEMORY_FILENAME = "memory.jsonl";
+function resolveMemoryPath(runsRoot) {
+    return join(resolve(runsRoot), MEMORY_DIRECTORY, MEMORY_FILENAME);
+}
+/**
+ * Append a memory entry. Never overwrites — always appends.
+ */
+export async function appendMemory(runsRoot, entry) {
+    const memPath = resolveMemoryPath(runsRoot);
+    await mkdir(join(resolve(runsRoot), MEMORY_DIRECTORY), { recursive: true });
+    await appendFile(memPath, JSON.stringify(entry) + "\n", "utf8");
+}
+/**
+ * Read all memory entries in order (oldest first).
+ */
+export async function readMemoryEntries(runsRoot) {
+    const memPath = resolveMemoryPath(runsRoot);
+    try {
+        const raw = await readFile(memPath, "utf8");
+        return raw
+            .split("\n")
+            .filter((line) => line.trim().length > 0)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get the most recent memory entry for a specific key.
+ * Returns undefined if no entry exists for that key.
+ */
+export async function getPreference(runsRoot, key) {
+    const entries = await readMemoryEntries(runsRoot);
+    // Return the most recent entry for this key (last in file)
+    const matches = entries.filter((e) => e.key === key);
+    return matches[matches.length - 1];
+}
+/**
+ * Build a summary of memory entries for MCP resource and MartinLoop context injection.
+ * Returns the top 20 most recent entries per kind.
+ */
+export function buildMemorySummary(entries) {
+    const byKind = {};
+    for (const entry of entries) {
+        if (!byKind[entry.kind]) {
+            byKind[entry.kind] = [];
+        }
+        byKind[entry.kind].push(entry);
+    }
+    // Keep only the 20 most recent per kind
+    for (const kind of Object.keys(byKind)) {
+        byKind[kind] = byKind[kind].slice(-20);
+    }
+    const recent = entries.slice(-50);
+    return {
+        totalEntries: entries.length,
+        byKind,
+        recentPreferences: recent.filter((e) => e.kind === "preference"),
+        recentConsents: recent.filter((e) => e.kind === "consent"),
+        recentFeedback: recent.filter((e) => e.kind === "feedback")
+    };
+}
+/**
+ * Record a preference from user input.
+ */
+export async function recordPreference(runsRoot, key, value, source = "explicit") {
+    await appendMemory(runsRoot, {
+        timestamp: new Date().toISOString(),
+        kind: "preference",
+        key,
+        value,
+        source,
+        confidence: source === "explicit" ? 1.0 : 0.6
+    });
+}
+/**
+ * Record a consent signal (user approved or denied a governance action).
+ */
+export async function recordConsent(runsRoot, action, approved, context) {
+    await appendMemory(runsRoot, {
+        timestamp: new Date().toISOString(),
+        kind: "consent",
+        key: `consent.${action}`,
+        value: { approved, context },
+        source: "explicit",
+        confidence: 1.0
+    });
+}

package/dist/vendor/adapters/core/src/persistence/runs-reader.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Reads completed loop records from ~/.martin/runs/ for analysis.
+ * Used by the Trust Calibration Engine and other offline analytics.
+ *
+ * Supports both storage layouts:
+ * - legacy root JSONL files: <runsRoot>/*.jsonl
+ * - canonical run trees: <runsRoot>/<loopId>/loop-record.json
+ */
+export interface LoopAttemptRecord {
+    index: number;
+    model?: string;
+    adapterId?: string;
+    failureClass?: string;
+    intervention?: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface LoopRunRecord {
+    loopId: string;
+    status: string;
+    lifecycleState: string;
+    createdAt: string;
+    updatedAt: string;
+    budget: {
+        maxUsd: number;
+        softLimitUsd: number;
+        maxIterations: number;
+        maxTokens: number;
+    };
+    cost: {
+        actualUsd: number;
+        tokensIn: number;
+        tokensOut: number;
+        avoidedUsd?: number;
+    };
+    attempts: LoopAttemptRecord[];
+    task: {
+        title: string;
+        objective: string;
+    };
+}
+export interface LoopRecordsRollup {
+    generatedAt: string;
+    totalRuns: number;
+    statusBreakdown: Record<string, number>;
+    lifecycleBreakdown: Record<string, number>;
+    latestByLoopId: Record<string, {
+        status: string;
+        lifecycleState: string;
+        updatedAt: string;
+        costUsd: number;
+        attempts: number;
+    }>;
+}
+export declare function readLoopRecordsFromFile(file: string): Promise<LoopRunRecord[]>;
+export declare function readLatestLoopRecordFromFile(file: string): Promise<LoopRunRecord | null>;
+/**
+ * Reads all loop records from the given directory (default: ~/.martin/runs/).
+ * Returns an empty array if the directory doesn't exist or has no records.
+ */
+export declare function readAllLoopRecords(runsDir?: string): Promise<LoopRunRecord[]>;
+/**
+ * Returns the most recently updated loop record, or null if none exist.
+ */
+export declare function readLatestLoopRecord(runsDir?: string): Promise<LoopRunRecord | null>;
+export declare function buildLoopRecordsRollup(records: LoopRunRecord[]): LoopRecordsRollup;

package/dist/vendor/adapters/core/src/persistence/runs-reader.js

@@ -0,0 +1,140 @@
+/**
+ * Reads completed loop records from ~/.martin/runs/ for analysis.
+ * Used by the Trust Calibration Engine and other offline analytics.
+ *
+ * Supports both storage layouts:
+ * - legacy root JSONL files: <runsRoot>/*.jsonl
+ * - canonical run trees: <runsRoot>/<loopId>/loop-record.json
+ */
+import { readFile, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { extname, join } from "node:path";
+export async function readLoopRecordsFromFile(file) {
+    const text = await readFile(file, "utf8");
+    const extension = extname(file).toLowerCase();
+    if (extension === ".jsonl") {
+        return text
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed) ? parsed : [parsed];
+}
+export async function readLatestLoopRecordFromFile(file) {
+    const records = await readLoopRecordsFromFile(file);
+    if (records.length === 0)
+        return null;
+    return records.reduce((latest, record) => {
+        const currentTimestamp = new Date(record.updatedAt ?? record.createdAt).getTime();
+        const latestTimestamp = new Date(latest.updatedAt ?? latest.createdAt).getTime();
+        return currentTimestamp > latestTimestamp ? record : latest;
+    }, records[0]);
+}
+/**
+ * Reads all loop records from the given directory (default: ~/.martin/runs/).
+ * Returns an empty array if the directory doesn't exist or has no records.
+ */
+export async function readAllLoopRecords(runsDir) {
+    const dir = runsDir ?? join(homedir(), ".martin", "runs");
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const recordsByLoopId = new Map();
+    const jsonlFiles = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+        .map((entry) => entry.name);
+    for (const file of jsonlFiles) {
+        try {
+            const fromFile = await readLoopRecordsFromFile(join(dir, file));
+            for (const record of fromFile) {
+                ingestRecord(recordsByLoopId, record, "legacy_jsonl");
+            }
+        }
+        catch {
+            // skip malformed files or lines
+        }
+    }
+    const runDirectories = entries.filter((entry) => entry.isDirectory());
+    for (const entry of runDirectories) {
+        try {
+            const canonical = await readLoopRecordsFromFile(join(dir, entry.name, "loop-record.json"));
+            for (const record of canonical) {
+                ingestRecord(recordsByLoopId, record, "canonical_tree");
+            }
+        }
+        catch {
+            // skip missing or malformed canonical records
+        }
+    }
+    return [...recordsByLoopId.values()].map((entry) => entry.record);
+}
+/**
+ * Returns the most recently updated loop record, or null if none exist.
+ */
+export async function readLatestLoopRecord(runsDir) {
+    const records = await readAllLoopRecords(runsDir);
+    if (records.length === 0)
+        return null;
+    return records.reduce((latest, r) => {
+        const a = new Date(r.updatedAt ?? r.createdAt).getTime();
+        const b = new Date(latest.updatedAt ?? latest.createdAt).getTime();
+        return a > b ? r : latest;
+    }, records[0]);
+}
+export function buildLoopRecordsRollup(records) {
+    const statusBreakdown = {};
+    const lifecycleBreakdown = {};
+    const latestByLoopId = {};
+    for (const record of records) {
+        statusBreakdown[record.status] = (statusBreakdown[record.status] ?? 0) + 1;
+        lifecycleBreakdown[record.lifecycleState] = (lifecycleBreakdown[record.lifecycleState] ?? 0) + 1;
+        latestByLoopId[record.loopId] = {
+            status: record.status,
+            lifecycleState: record.lifecycleState,
+            updatedAt: record.updatedAt,
+            costUsd: record.cost.actualUsd,
+            attempts: record.attempts.length
+        };
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        totalRuns: records.length,
+        statusBreakdown,
+        lifecycleBreakdown,
+        latestByLoopId
+    };
+}
+function ingestRecord(recordsByLoopId, record, source) {
+    const existing = recordsByLoopId.get(record.loopId);
+    if (!existing) {
+        recordsByLoopId.set(record.loopId, { record, source });
+        return;
+    }
+    const candidateTimestamp = resolveRecordTimestamp(record);
+    const existingTimestamp = resolveRecordTimestamp(existing.record);
+    if (candidateTimestamp > existingTimestamp) {
+        recordsByLoopId.set(record.loopId, { record, source });
+        return;
+    }
+    if (candidateTimestamp === existingTimestamp &&
+        sourcePrecedence(source) > sourcePrecedence(existing.source)) {
+        recordsByLoopId.set(record.loopId, { record, source });
+    }
+}
+function resolveRecordTimestamp(record) {
+    const updated = Date.parse(record.updatedAt ?? "");
+    if (Number.isFinite(updated)) {
+        return updated;
+    }
+    const created = Date.parse(record.createdAt ?? "");
+    return Number.isFinite(created) ? created : 0;
+}
+function sourcePrecedence(source) {
+    return source === "canonical_tree" ? 2 : 1;
+}