@akagilnc/pi-workflow-roles 0.1.4800 → 0.1.4870

package/dist/analyst-metric-families/acceptance-success-rework.js

@@ -0,0 +1,249 @@
+import { medianNumber } from "../analyst-median.js";
+import { packagedAnalystTerminal } from "../packaged-role-registry.js";
+const WORKER_ROLES = new Set(["coder", "fixer"]);
+/** Lawful acceptance vocabulary by role (PRD 受理终态映射). */
+const ACCEPTED_STATUS = {
+    coder: new Set(["completed", "refused", "partially_completed", "unfinished", "planned"]),
+    fixer: new Set(["completed", "refused", "partially_completed", "unfinished", "planned"]),
+    judge: new Set(["converged", "continue", "escalate"]),
+    reviewer: new Set(["completed", "refused"]),
+    doctor: new Set(["completed", "refused"]),
+    merger: new Set(["completed", "escalate"]),
+};
+/** Success vocabulary by role (PRD 成功集合). planned excluded for workers. */
+const SUCCESS_STATUS = {
+    coder: new Set(["completed"]),
+    fixer: new Set(["completed"]),
+    // Judge: producing any of the three verdicts completes the duty.
+    judge: new Set(["converged", "continue", "escalate"]),
+    reviewer: new Set(["completed"]),
+    doctor: new Set(["completed"]),
+    merger: new Set(["completed"]),
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function wallMsFromSpan(span) {
+    return Date.parse(span.endedAt) - Date.parse(span.startedAt);
+}
+/** Locate collector groups array: receipt.groups or top-level groups. */
+function findCollectorGroups(body) {
+    if (Array.isArray(body.groups))
+        return body.groups;
+    const receipt = body.receipt;
+    if (isRecord(receipt) && Array.isArray(receipt.groups))
+        return receipt.groups;
+    const outcome = body.outcome;
+    if (isRecord(outcome)) {
+        const facts = outcome.decisiveFacts;
+        if (isRecord(facts) && Array.isArray(facts.groups))
+            return facts.groups;
+    }
+    return undefined;
+}
+/** Extract role receipt status from canonical terminal body faces. */
+function extractStatus(body) {
+    const outcome = body.outcome;
+    if (isRecord(outcome) && typeof outcome.status === "string" && outcome.status.trim() !== "") {
+        return outcome.status;
+    }
+    const receipt = body.receipt;
+    if (isRecord(receipt) && typeof receipt.status === "string" && receipt.status.trim() !== "") {
+        return receipt.status;
+    }
+    if (typeof body.status === "string" && body.status.trim() !== "") {
+        return body.status;
+    }
+    return undefined;
+}
+function mapTerminal(role, terminal) {
+    if (terminal.status === "absent") {
+        return {
+            terminalLabel: "no-receipt",
+            accepted: false,
+            success: false,
+            successEligible: false,
+            noReceipt: true,
+        };
+    }
+    const body = terminal.body;
+    // Seat-declared terminal: typed groups array presence is the sole acceptance discriminator.
+    if (packagedAnalystTerminal(role) === "groups") {
+        const groups = findCollectorGroups(body);
+        if (Array.isArray(groups)) {
+            return {
+                terminalLabel: "groups",
+                accepted: true,
+                success: true,
+                successEligible: true,
+                noReceipt: false,
+            };
+        }
+        return {
+            terminalLabel: "non-accepted",
+            accepted: false,
+            success: false,
+            successEligible: false,
+            noReceipt: false,
+        };
+    }
+    const status = extractStatus(body);
+    if (status === undefined) {
+        return {
+            terminalLabel: "non-accepted",
+            accepted: false,
+            success: false,
+            successEligible: false,
+            noReceipt: false,
+        };
+    }
+    const acceptedSet = ACCEPTED_STATUS[role];
+    if (acceptedSet === undefined || !acceptedSet.has(status)) {
+        return {
+            terminalLabel: status,
+            accepted: false,
+            success: false,
+            successEligible: false,
+            noReceipt: false,
+        };
+    }
+    const plannedDuty = WORKER_ROLES.has(role) && status === "planned";
+    const successSet = SUCCESS_STATUS[role] ?? new Set();
+    const success = !plannedDuty && successSet.has(status);
+    const successEligible = !plannedDuty;
+    return {
+        terminalLabel: status,
+        accepted: true,
+        success,
+        successEligible,
+        noReceipt: false,
+    };
+}
+function projectLegs(runs) {
+    // Order within lane+role by startedAt (then runId) to assign ordinals / rework.
+    const sorted = [...runs].sort((a, b) => {
+        if (a.book !== b.book)
+            return a.book.localeCompare(b.book);
+        if (a.role !== b.role)
+            return a.role.localeCompare(b.role);
+        if (a.frameSpan.startedAt !== b.frameSpan.startedAt) {
+            return a.frameSpan.startedAt.localeCompare(b.frameSpan.startedAt);
+        }
+        return a.runId.localeCompare(b.runId);
+    });
+    const ordinalByKey = new Map();
+    const legs = [];
+    for (const run of sorted) {
+        const key = `${run.book}\0${run.role}`;
+        const ordinal = (ordinalByKey.get(key) ?? 0) + 1;
+        ordinalByKey.set(key, ordinal);
+        const mapped = mapTerminal(run.role, run.terminal);
+        legs.push({
+            runId: run.runId,
+            book: run.book,
+            role: run.role,
+            startedAt: run.frameSpan.startedAt,
+            wallMs: wallMsFromSpan(run.frameSpan),
+            terminalLabel: mapped.terminalLabel,
+            accepted: mapped.accepted,
+            success: mapped.success,
+            successEligible: mapped.successEligible,
+            noReceipt: mapped.noReceipt,
+            ordinalInLaneRole: ordinal,
+            rework: ordinal >= 2,
+        });
+    }
+    // Stable page order: book, role, runId (match A1 leg sort).
+    return legs.sort((a, b) => {
+        if (a.book !== b.book)
+            return a.book.localeCompare(b.book);
+        if (a.role !== b.role)
+            return a.role.localeCompare(b.role);
+        return a.runId.localeCompare(b.runId);
+    });
+}
+function aggregateByRole(legs) {
+    const roles = [...new Set(legs.map((leg) => leg.role))].sort((a, b) => a.localeCompare(b));
+    return roles.map((role) => {
+        const roleLegs = legs.filter((leg) => leg.role === role);
+        const acceptedCount = roleLegs.filter((leg) => leg.accepted).length;
+        const successEligibleCount = roleLegs.filter((leg) => leg.successEligible).length;
+        const successCount = roleLegs.filter((leg) => leg.success).length;
+        const noReceiptCount = roleLegs.filter((leg) => leg.noReceipt).length;
+        // Appearance lanes + first-pass: first call by startedAt within each book.
+        const byBook = new Map();
+        for (const leg of roleLegs) {
+            const list = byBook.get(leg.book) ?? [];
+            list.push(leg);
+            byBook.set(leg.book, list);
+        }
+        const books = [...byBook.keys()].sort((a, b) => a.localeCompare(b));
+        const convergenceRounds = [];
+        let firstPassLaneCount = 0;
+        for (const book of books) {
+            const laneLegs = [...byBook.get(book)].sort((a, b) => {
+                if (a.startedAt !== b.startedAt)
+                    return a.startedAt.localeCompare(b.startedAt);
+                return a.runId.localeCompare(b.runId);
+            });
+            convergenceRounds.push(laneLegs.length);
+            const first = laneLegs[0];
+            if (first.accepted)
+                firstPassLaneCount += 1;
+        }
+        const appearanceLaneCount = books.length;
+        return {
+            role,
+            acceptedCount,
+            successEligibleCount,
+            successCount,
+            noReceiptCount,
+            successRate: successEligibleCount === 0 ? undefined : successCount / successEligibleCount,
+            appearanceLaneCount,
+            firstPassLaneCount,
+            firstPassRate: appearanceLaneCount === 0 ? undefined : firstPassLaneCount / appearanceLaneCount,
+            convergenceRounds,
+            convergenceRoundsMedian: medianNumber(convergenceRounds),
+        };
+    });
+}
+function reworkLens(legs) {
+    let reworkWallMs = 0;
+    let totalWallMs = 0;
+    let reworkLegCount = 0;
+    for (const leg of legs) {
+        totalWallMs += leg.wallMs;
+        if (leg.rework) {
+            reworkWallMs += leg.wallMs;
+            reworkLegCount += 1;
+        }
+    }
+    return {
+        reworkWallMs,
+        totalWallMs,
+        reworkRatio: totalWallMs === 0 ? undefined : reworkWallMs / totalWallMs,
+        reworkLegCount,
+        totalLegCount: legs.length,
+    };
+}
+export function buildAcceptanceSuccessReworkSection(runs) {
+    if (runs.length === 0)
+        return undefined;
+    const legs = projectLegs(runs);
+    return {
+        kind: "analyst-acceptance-success-rework",
+        legs,
+        byRole: aggregateByRole(legs),
+        rework: reworkLens(legs),
+    };
+}
+const acceptanceSuccessReworkFamily = {
+    id: "acceptance-success-rework",
+    contribute(input) {
+        const section = buildAcceptanceSuccessReworkSection(input.runs);
+        if (section === undefined)
+            return undefined;
+        return { acceptanceSuccessRework: section };
+    },
+};
+export default acceptanceSuccessReworkFamily;

package/dist/analyst-metric-families/b2-frame-buckets-actions.js

@@ -0,0 +1,189 @@
+import { medianNumber } from "../analyst-median.js";
+function timestampMs(iso) {
+    const ms = Date.parse(iso);
+    if (!Number.isFinite(ms)) {
+        throw new Error(`unparseable timestamp: ${iso}`);
+    }
+    return ms;
+}
+function toIso(ms) {
+    return new Date(ms).toISOString();
+}
+function closedTools(intervals) {
+    const out = [];
+    for (const interval of intervals) {
+        if (interval.endedAt === undefined)
+            continue;
+        const startMs = timestampMs(interval.startedAt);
+        const endMs = timestampMs(interval.endedAt);
+        if (endMs <= startMs)
+            continue;
+        out.push({
+            toolCallId: interval.toolCallId,
+            toolName: interval.toolName,
+            startedAt: interval.startedAt,
+            endedAt: interval.endedAt,
+            startMs,
+            endMs,
+            ...(interval.command !== undefined ? { command: interval.command } : {}),
+        });
+    }
+    return out;
+}
+/**
+ * Clip closed tools to the leg frame. Empty after clip are dropped.
+ * Bucket, complement, and tool actions all consume this same bounded set.
+ */
+function clipToolsToFrame(tools, frameStartMs, frameEndMs) {
+    if (frameEndMs <= frameStartMs)
+        return [];
+    const out = [];
+    for (const tool of tools) {
+        const startMs = Math.max(tool.startMs, frameStartMs);
+        const endMs = Math.min(tool.endMs, frameEndMs);
+        if (endMs <= startMs)
+            continue;
+        out.push({
+            toolCallId: tool.toolCallId,
+            toolName: tool.toolName,
+            startMs,
+            endMs,
+            startedAt: startMs === tool.startMs ? tool.startedAt : toIso(startMs),
+            endedAt: endMs === tool.endMs ? tool.endedAt : toIso(endMs),
+            ...(tool.command !== undefined ? { command: tool.command } : {}),
+        });
+    }
+    return out;
+}
+/** Merge overlapping/adjacent [start,end) intervals; return sorted disjoint union. */
+function mergeUnion(intervals) {
+    if (intervals.length === 0)
+        return [];
+    const sorted = [...intervals].sort((a, b) => a.startMs - b.startMs || a.endMs - b.endMs);
+    const merged = [
+        { startMs: sorted[0].startMs, endMs: sorted[0].endMs },
+    ];
+    for (let i = 1; i < sorted.length; i += 1) {
+        const cur = sorted[i];
+        const last = merged[merged.length - 1];
+        if (cur.startMs <= last.endMs) {
+            last.endMs = Math.max(last.endMs, cur.endMs);
+        }
+        else {
+            merged.push({ startMs: cur.startMs, endMs: cur.endMs });
+        }
+    }
+    return merged;
+}
+/**
+ * Maximal continuous complement of (already frame-clipped) tool union
+ * inside [frameStart, frameEnd]. Includes leading and trailing gaps.
+ */
+function modelMaximalIntervals(frameStartMs, frameEndMs, toolUnion) {
+    if (frameEndMs <= frameStartMs)
+        return [];
+    const gaps = [];
+    let cursor = frameStartMs;
+    for (const interval of toolUnion) {
+        // Union is produced from frame-clipped tools, so bounds already lie in frame.
+        if (interval.startMs > cursor) {
+            gaps.push({ startMs: cursor, endMs: interval.startMs });
+        }
+        cursor = Math.max(cursor, interval.endMs);
+    }
+    if (cursor < frameEndMs) {
+        gaps.push({ startMs: cursor, endMs: frameEndMs });
+    }
+    return gaps;
+}
+function toolAction(tool) {
+    const action = {
+        kind: "tool",
+        toolCallId: tool.toolCallId,
+        toolName: tool.toolName,
+        durationMs: tool.endMs - tool.startMs,
+        startedAt: tool.startedAt,
+        endedAt: tool.endedAt,
+    };
+    // A2 already owns bash first-line summary; B2 only projects it.
+    if (tool.toolName === "bash" && tool.command !== undefined) {
+        return {
+            ...action,
+            commandSummary: tool.command,
+        };
+    }
+    return action;
+}
+function modelAction(gap) {
+    return {
+        kind: "model",
+        durationMs: gap.endMs - gap.startMs,
+        startedAt: toIso(gap.startMs),
+        endedAt: toIso(gap.endMs),
+    };
+}
+function sortActionsDescending(actions) {
+    return [...actions].sort((a, b) => {
+        if (b.durationMs !== a.durationMs)
+            return b.durationMs - a.durationMs;
+        // Stable tie-break: earlier start first, then kind/toolCallId for determinism.
+        if (a.startedAt !== b.startedAt)
+            return a.startedAt.localeCompare(b.startedAt);
+        if (a.kind !== b.kind)
+            return a.kind.localeCompare(b.kind);
+        if (a.kind === "tool" && b.kind === "tool") {
+            return a.toolCallId.localeCompare(b.toolCallId);
+        }
+        return 0;
+    });
+}
+/** Pure B2 kernel over one readable run's A2 facts. */
+export function computeAnalystB2RunMetrics(facts) {
+    const frameStartMs = timestampMs(facts.frameSpan.startedAt);
+    const frameEndMs = timestampMs(facts.frameSpan.endedAt);
+    const wallMs = Math.max(0, frameEndMs - frameStartMs);
+    // Single frame-bounded core: clip → union once → bucket/complement/actions.
+    const tools = clipToolsToFrame(closedTools(facts.toolIntervals), frameStartMs, frameEndMs);
+    const toolUnion = mergeUnion(tools);
+    const toolBucketMs = toolUnion.reduce((sum, interval) => sum + (interval.endMs - interval.startMs), 0);
+    // Mutual exclusion: model is exact complement duration (no independent recount).
+    const modelBucketMs = wallMs - toolBucketMs;
+    const modelGaps = modelMaximalIntervals(frameStartMs, frameEndMs, toolUnion);
+    const actions = sortActionsDescending([
+        ...tools.map(toolAction),
+        ...modelGaps.map(modelAction),
+    ]);
+    const actionDurationMedianMs = medianNumber(actions.map((action) => action.durationMs));
+    return {
+        runId: facts.runId,
+        book: facts.book,
+        role: facts.role,
+        wallMs,
+        toolBucketMs,
+        modelBucketMs,
+        actions,
+        actionDurationMedianMs,
+    };
+}
+const b2FrameBucketsActionsFamily = {
+    id: "b2-frame-buckets-actions",
+    contribute(input) {
+        if (input.runs.length === 0)
+            return undefined;
+        const runs = [...input.runs]
+            .map(computeAnalystB2RunMetrics)
+            .sort((a, b) => {
+            if (a.book !== b.book)
+                return a.book.localeCompare(b.book);
+            if (a.role !== b.role)
+                return a.role.localeCompare(b.role);
+            return a.runId.localeCompare(b.runId);
+        });
+        const section = {
+            kind: "analyst-b2-frame-buckets-actions",
+            runs,
+        };
+        return { b2FrameBucketsActions: section };
+    },
+};
+export default b2FrameBucketsActionsFamily;

package/dist/analyst-metric-families/gate-cycles.js

@@ -0,0 +1,77 @@
+function projectRound(round) {
+    return {
+        roundIndex: round.roundIndex,
+        officer: round.officer,
+        status: round.status,
+        officerWallMs: round.officerWallMs,
+        findingsCount: round.findingsCount,
+        origin: round.origin,
+    };
+}
+function projectLeg(facts) {
+    const rounds = facts.gateCycles.map(projectRound);
+    return {
+        runId: facts.runId,
+        book: facts.book,
+        role: facts.role,
+        roundCount: rounds.length,
+        rounds,
+    };
+}
+function compareLegs(a, b) {
+    if (a.book !== b.book)
+        return a.book.localeCompare(b.book);
+    if (a.role !== b.role)
+        return a.role.localeCompare(b.role);
+    return a.runId.localeCompare(b.runId);
+}
+function emptyAccum() {
+    return { rounds: 0, bounceCount: 0, passCount: 0, wallSum: 0 };
+}
+function absorbRound(accum, round) {
+    accum.rounds += 1;
+    accum.wallSum += round.officerWallMs;
+    if (round.status === "bounce")
+        accum.bounceCount += 1;
+    if (round.status === "pass")
+        accum.passCount += 1;
+}
+function finishOfficer(officer, accum) {
+    return {
+        officer,
+        rounds: accum.rounds,
+        bounceCount: accum.bounceCount,
+        passCount: accum.passCount,
+        bounceRate: accum.rounds === 0 ? undefined : accum.bounceCount / accum.rounds,
+        meanOfficerWallMs: accum.rounds === 0 ? undefined : accum.wallSum / accum.rounds,
+    };
+}
+function summarizeByOfficer(legs) {
+    const byOfficer = new Map();
+    for (const leg of legs) {
+        for (const round of leg.rounds) {
+            const accum = byOfficer.get(round.officer) ?? emptyAccum();
+            absorbRound(accum, round);
+            byOfficer.set(round.officer, accum);
+        }
+    }
+    // Stable officer order; only officers that appeared on the board.
+    const officers = ["inspector", "notary"].filter((o) => byOfficer.has(o));
+    return officers.map((officer) => finishOfficer(officer, byOfficer.get(officer)));
+}
+/** Discovered by analyst-metric-families loader (default export). */
+const gateCyclesFamily = {
+    id: "gate-cycles",
+    contribute(input) {
+        if (input.runs.length === 0)
+            return undefined;
+        const legs = input.runs.map(projectLeg).sort(compareLegs);
+        const section = {
+            kind: "analyst-gate-cycles",
+            legs,
+            byOfficer: summarizeByOfficer(legs),
+        };
+        return { gateCycles: section };
+    },
+};
+export default gateCyclesFamily;

package/dist/analyst-metric-families/leg-wall-clock.js

@@ -0,0 +1,56 @@
+/**
+ * B1 leg wall-clock metric family (#325).
+ *
+ * Consumes A2 typed per-run frame spans only — no second ledger scan.
+ * Emits: per-leg wallMs, ranking by wall clock desc, median, total elapsed.
+ * Registers by file drop under analyst-metric-families/ (A2 discovery).
+ */
+import { medianNumber } from "../analyst-median.js";
+function frameSpanWallMs(span) {
+    return Date.parse(span.endedAt) - Date.parse(span.startedAt);
+}
+function projectEntry(facts) {
+    return {
+        runId: facts.runId,
+        book: facts.book,
+        role: facts.role,
+        wallMs: frameSpanWallMs(facts.frameSpan),
+    };
+}
+function compareRankingDesc(a, b) {
+    if (b.wallMs !== a.wallMs)
+        return b.wallMs - a.wallMs;
+    if (a.book !== b.book)
+        return a.book.localeCompare(b.book);
+    if (a.role !== b.role)
+        return a.role.localeCompare(b.role);
+    return a.runId.localeCompare(b.runId);
+}
+/** Discovered by analyst-metric-families loader (default export). */
+const legWallClockFamily = {
+    id: "leg-wall-clock",
+    contribute(input) {
+        if (input.runs.length === 0) {
+            // No readable runs — omit section rather than invent zero metrics.
+            return undefined;
+        }
+        const ranking = input.runs.map(projectEntry).sort(compareRankingDesc);
+        const walls = ranking.map((leg) => leg.wallMs);
+        const medianWallMs = medianNumber(walls);
+        // runs.length > 0 ⇒ medianNumber returns a defined number.
+        if (medianWallMs === undefined) {
+            return undefined;
+        }
+        let totalElapsedMs = 0;
+        for (const wallMs of walls)
+            totalElapsedMs += wallMs;
+        const section = {
+            kind: "analyst-leg-wall-clock",
+            ranking,
+            medianWallMs,
+            totalElapsedMs,
+        };
+        return { legWallClock: section };
+    },
+};
+export default legWallClockFamily;

package/dist/analyst-metric-families/round-timeline.js

@@ -0,0 +1,126 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function wallMsFromSpan(startedAt, endedAt) {
+    return Date.parse(endedAt) - Date.parse(startedAt);
+}
+function readOutcomeStatus(body) {
+    if (!isRecord(body.outcome))
+        return undefined;
+    const status = body.outcome.status;
+    if (typeof status !== "string" || status.trim() === "")
+        return undefined;
+    return status;
+}
+function readClassCount(body) {
+    if (!isRecord(body.outcome))
+        return undefined;
+    if (!isRecord(body.outcome.decisiveFacts))
+        return undefined;
+    const classCount = body.outcome.decisiveFacts.classCount;
+    if (typeof classCount !== "number" || !Number.isFinite(classCount)) {
+        return undefined;
+    }
+    return classCount;
+}
+function projectTerminal(facts) {
+    if (facts.terminal.status === "absent") {
+        return { kind: "death", channel: "no-receipt" };
+    }
+    if (facts.terminal.file === "error.json") {
+        return { kind: "death", channel: "error" };
+    }
+    if (facts.terminal.file === "audit-incomplete.json") {
+        return { kind: "death", channel: "audit-incomplete" };
+    }
+    // report.json — receipt face; classCount only when producer wrote a number.
+    const status = readOutcomeStatus(facts.terminal.body);
+    const classCount = readClassCount(facts.terminal.body);
+    const receiptStatus = status ?? "unparsed";
+    if (classCount === undefined) {
+        return { kind: "receipt", status: receiptStatus };
+    }
+    return { kind: "receipt", status: receiptStatus, classCount };
+}
+function projectRunRow(facts) {
+    const { startedAt, endedAt } = facts.frameSpan;
+    return {
+        kind: "run",
+        runId: facts.runId,
+        book: facts.book,
+        role: facts.role,
+        startedAt,
+        endedAt,
+        wallMs: wallMsFromSpan(startedAt, endedAt),
+        terminal: projectTerminal(facts),
+    };
+}
+function projectUnreadableRow(entry) {
+    return {
+        kind: "unreadable",
+        runId: entry.runId,
+        book: entry.book,
+        missingSources: entry.missingSources,
+        reason: entry.reason,
+        firstFrameAt: entry.firstFrameAt,
+    };
+}
+/** Sort key: startedAt / present firstFrameAt ascending; absent → +∞ (lane tail). */
+function rowSortStartedAt(row) {
+    if (row.kind === "run")
+        return row.startedAt;
+    if (row.firstFrameAt.status === "present")
+        return row.firstFrameAt.at;
+    return undefined;
+}
+function compareRows(a, b) {
+    const aStart = rowSortStartedAt(a);
+    const bStart = rowSortStartedAt(b);
+    if (aStart === undefined && bStart === undefined) {
+        return a.runId.localeCompare(b.runId);
+    }
+    if (aStart === undefined)
+        return 1;
+    if (bStart === undefined)
+        return -1;
+    if (aStart !== bStart)
+        return aStart.localeCompare(bStart);
+    return a.runId.localeCompare(b.runId);
+}
+function buildLanes(runs, unreadable) {
+    const byLane = new Map();
+    const push = (lane, row) => {
+        const list = byLane.get(lane);
+        if (list === undefined)
+            byLane.set(lane, [row]);
+        else
+            list.push(row);
+    };
+    for (const facts of runs) {
+        push(facts.book, projectRunRow(facts));
+    }
+    for (const entry of unreadable) {
+        push(entry.book, projectUnreadableRow(entry));
+    }
+    return [...byLane.keys()]
+        .sort((a, b) => a.localeCompare(b))
+        .map((lane) => ({
+        lane,
+        rows: [...(byLane.get(lane) ?? [])].sort(compareRows),
+    }));
+}
+/** Discovered by analyst-metric-families loader (default export). */
+const roundTimelineFamily = {
+    id: "round-timeline",
+    contribute(input) {
+        if (input.runs.length === 0 && input.unreadable.length === 0) {
+            return undefined;
+        }
+        const section = {
+            kind: "analyst-round-timeline",
+            lanes: buildLanes(input.runs, input.unreadable),
+        };
+        return { roundTimeline: section };
+    },
+};
+export default roundTimelineFamily;