@wildorder/nightshift 0.16.0 → 0.17.0

package/dist/run-analytics-report.js

@@ -0,0 +1,650 @@
+import { BUCKETS, KNOWN_OUTCOMES, } from "./run-analytics.js";
+function compareIntervals(a, b) {
+    return a.start - b.start || a.end - b.end || a.span.id.localeCompare(b.span.id);
+}
+function attemptKeyOf(dims) {
+    if (dims.workstream === undefined || dims.attemptSeat === undefined || dims.attemptIndex === undefined) {
+        return undefined;
+    }
+    return `${dims.workstream} ${dims.attemptSeat} ${dims.attemptIndex}`;
+}
+function bump(map, key, durationMs) {
+    const cur = map.get(key) ?? { count: 0, durationMs: 0 };
+    cur.count += 1;
+    cur.durationMs += durationMs;
+    map.set(key, cur);
+}
+function rankedFromGroups(map) {
+    return [...map.entries()]
+        .map(([key, v]) => ({ key, durationMs: v.durationMs, count: v.count }))
+        .sort((a, b) => b.durationMs - a.durationMs || a.key.localeCompare(b.key));
+}
+/**
+ * Walks a span's `parentId` chain until it reaches a top-level span id.
+ * Returns `undefined` for an orphan chain (a dangling `parentId` — already
+ * flagged as its own diagnostic — or a chain that never reaches a top-level
+ * ancestor), never throws, and is bounded against a cyclic `parentId` a
+ * malformed artifact might otherwise loop on forever.
+ */
+function findTopLevelAncestor(span, byId, topLevelIds) {
+    let parentId = span.parentId;
+    let hops = 0;
+    while (parentId !== undefined && hops < 10_000) {
+        if (topLevelIds.has(parentId))
+            return parentId;
+        const parent = byId.get(parentId);
+        if (parent === undefined)
+            return undefined;
+        parentId = parent.parentId;
+        hops += 1;
+    }
+    return undefined;
+}
+/**
+ * Sweeps the sorted endpoints of every top-level interval and assigns each
+ * covered elementary sub-interval to exactly one owner — the covering span
+ * that sorts first by `(startOffsetMs, endOffsetMs, id)` — so
+ * `Σ(bucket durations)` equals the interval union exactly, even when
+ * top-level spans overlap (D2). Any sub-interval covered by more than one
+ * span is recorded as an `overlap` diagnostic.
+ */
+function sweepBucketOwnership(intervals, diagnostics) {
+    const totals = new Map(BUCKETS.map((bucket) => [bucket, 0]));
+    if (intervals.length === 0)
+        return totals;
+    const boundarySet = new Set();
+    for (const interval of intervals) {
+        boundarySet.add(interval.start);
+        boundarySet.add(interval.end);
+    }
+    const boundaries = [...boundarySet].sort((a, b) => a - b);
+    const seenOverlaps = new Set();
+    for (let i = 0; i < boundaries.length - 1; i++) {
+        const a = boundaries[i];
+        const b = boundaries[i + 1];
+        if (b <= a)
+            continue;
+        const covering = intervals.filter((interval) => interval.start <= a && interval.end >= b);
+        if (covering.length === 0)
+            continue;
+        covering.sort(compareIntervals);
+        const owner = covering[0];
+        totals.set(owner.span.bucket, (totals.get(owner.span.bucket) ?? 0) + (b - a));
+        if (covering.length > 1) {
+            const ids = covering.map((interval) => interval.span.id).sort();
+            const key = ids.join(",");
+            if (!seenOverlaps.has(key)) {
+                seenOverlaps.add(key);
+                diagnostics.push({
+                    kind: "overlap",
+                    message: `top-level spans overlap in [${a}, ${b}]ms: ${ids.join(", ")} — ` +
+                        `attributed once, to ${owner.span.id} (${owner.span.bucket})`,
+                    spanIds: ids,
+                });
+            }
+        }
+    }
+    return totals;
+}
+const AGENT_ATTEMPT_STAGES = new Set(["implementer", "recovery", "informed-retry", "fix-now", "test-critique-fix"]);
+const AGENT_REPEAT_REASONS = new Set([
+    "verify-failure",
+    "informed-by-diagnosis",
+    "critique-finding",
+    "fix-now-finding",
+]);
+const ALWAYS_RERUN_VERIFY_PHASES = new Set(["post-recovery", "post-informed-retry", "test-critique-fix", "fix-now"]);
+const VERIFY_COMMAND_STAGES = new Set(["verification-command", "baseline-verification"]);
+const TELEMETRY_KINDS = new Set(["provider-telemetry", "prompt-component-size"]);
+/**
+ * Deterministically reconciles a `RunAnalytics` artifact into conserved
+ * wall-clock and repetition analytics (SC-09). Pure: no clock, no I/O, no
+ * randomness. A shuffled `spans`/`points` array yields a byte-identical
+ * summary, because every grouping keys off span/point fields — never array
+ * position — and every list is explicitly sorted before it is returned.
+ */
+export function aggregateRunAnalytics(artifact) {
+    const diagnostics = [];
+    const totalElapsedMs = artifact.anchors.finalizedOffsetMs ?? 0;
+    const byId = new Map(artifact.spans.map((span) => [span.id, span]));
+    for (const span of artifact.spans) {
+        if (span.parentId !== undefined && !byId.has(span.parentId)) {
+            diagnostics.push({
+                kind: "unresolved-parent",
+                message: `span ${span.id} (${span.stage}) has parentId "${span.parentId}", which does not resolve`,
+                spanIds: [span.id],
+            });
+        }
+        if (span.endOffsetMs !== undefined && span.endOffsetMs < span.startOffsetMs) {
+            diagnostics.push({
+                kind: "invalid-interval",
+                message: `span ${span.id} (${span.stage}) has endOffsetMs < startOffsetMs`,
+                spanIds: [span.id],
+            });
+        }
+    }
+    const runSpan = artifact.spans.find((span) => span.stage === "run");
+    const runId = runSpan?.id;
+    if (runSpan === undefined) {
+        diagnostics.push({
+            kind: "unresolved-parent",
+            message: "no run-stage span was found; treating root spans (no parentId) as top-level",
+            spanIds: [],
+        });
+    }
+    const topLevelSpans = artifact.spans.filter((span) => span.stage !== "run" && (runId !== undefined ? span.parentId === runId : span.parentId === undefined));
+    const topLevelIntervals = topLevelSpans.map((span) => {
+        if (span.endOffsetMs === undefined) {
+            diagnostics.push({
+                kind: "open-span",
+                // No raw span id in the human-facing message (the report never
+                // prints internal ids — `spanIds` below carries it for machine
+                // consumers/tests instead): this fires on effectively every real
+                // run, since `report-assembly` is deliberately still open when the
+                // snapshot is taken (§2.3/§3.2), not just on a genuine crash.
+                message: `the \`${span.stage}\` span has no endOffsetMs — open (still in progress, or interrupted) at ` +
+                    `snapshot/finalize time, clamped to the total elapsed ${Math.round(totalElapsedMs)}ms`,
+                spanIds: [span.id],
+            });
+        }
+        const rawEnd = span.endOffsetMs ?? totalElapsedMs;
+        let end = rawEnd;
+        if (end > totalElapsedMs) {
+            diagnostics.push({
+                kind: "interval-exceeds-total",
+                message: `span ${span.id} (${span.stage}) ends at ${end}ms, past the total elapsed ${totalElapsedMs}ms`,
+                spanIds: [span.id],
+            });
+            end = totalElapsedMs;
+        }
+        const start = span.startOffsetMs;
+        return { span, start, end: Math.max(start, end) };
+    });
+    const bucketTotals = sweepBucketOwnership(topLevelIntervals, diagnostics);
+    let attributedMs = 0;
+    for (const bucket of BUCKETS) {
+        if (bucket !== "unattributed")
+            attributedMs += bucketTotals.get(bucket) ?? 0;
+    }
+    const unattributedMs = Math.max(0, totalElapsedMs - attributedMs);
+    bucketTotals.set("unattributed", unattributedMs);
+    const spanCountByBucket = new Map(BUCKETS.map((bucket) => [bucket, 0]));
+    for (const interval of topLevelIntervals) {
+        spanCountByBucket.set(interval.span.bucket, (spanCountByBucket.get(interval.span.bucket) ?? 0) + 1);
+    }
+    const buckets = BUCKETS.map((bucket) => ({
+        bucket,
+        durationMs: bucketTotals.get(bucket) ?? 0,
+        percent: totalElapsedMs > 0 ? ((bucketTotals.get(bucket) ?? 0) / totalElapsedMs) * 100 : 0,
+        spanCount: spanCountByBucket.get(bucket) ?? 0,
+    }));
+    // Drill-downs: every non-top-level, non-run span, grouped under its
+    // nearest top-level ancestor — detail, never summed into any bucket.
+    const topLevelIds = new Set(topLevelIntervals.map((interval) => interval.span.id));
+    const drillGroups = new Map();
+    for (const span of artifact.spans) {
+        if (span.id === runId || topLevelIds.has(span.id))
+            continue;
+        const owner = findTopLevelAncestor(span, byId, topLevelIds);
+        if (owner === undefined)
+            continue;
+        const durationMs = Math.max(0, (span.endOffsetMs ?? totalElapsedMs) - span.startOffsetMs);
+        const list = drillGroups.get(owner) ?? [];
+        list.push({
+            id: span.id,
+            stage: span.stage,
+            ...(span.dimensions.workstream !== undefined ? { workstream: span.dimensions.workstream } : {}),
+            ...(span.dimensions.role !== undefined ? { role: span.dimensions.role } : {}),
+            ...(span.dimensions.outcome !== undefined ? { outcome: span.dimensions.outcome } : {}),
+            durationMs,
+        });
+        drillGroups.set(owner, list);
+    }
+    const drillDowns = [...drillGroups.entries()]
+        .map(([ownerSpanId, spans]) => ({
+        ownerSpanId,
+        ownerStage: byId.get(ownerSpanId)?.stage ?? "",
+        spans: [...spans].sort((a, b) => b.durationMs - a.durationMs || a.id.localeCompare(b.id)),
+    }))
+        .sort((a, b) => a.ownerSpanId.localeCompare(b.ownerSpanId));
+    // Dispositions: the five point-backed outcomes join `attempt-outcome`
+    // points to their spawn span on (workstream, attemptSeat, attemptIndex);
+    // `interrupted` is span-derived (D3) since WS-02 emits no point for it.
+    // Restricted to the actual attempt-spawn stages: a `verification-command`
+    // span carries the very same (workstream, attemptSeat, attemptIndex) triple
+    // as the attempt that provoked it (WS-02 §3.4/§3.6, so a rerun pass can be
+    // correlated back to its trigger) — without this filter it would collide
+    // with, and could nondeterministically shadow, the real spawn span.
+    const spawnByAttemptKey = new Map();
+    for (const interval of topLevelIntervals) {
+        if (!AGENT_ATTEMPT_STAGES.has(interval.span.stage))
+            continue;
+        const key = attemptKeyOf(interval.span.dimensions);
+        if (key === undefined)
+            continue;
+        const existing = spawnByAttemptKey.get(key);
+        if (existing === undefined || interval.span.id < existing.span.id)
+            spawnByAttemptKey.set(key, interval);
+    }
+    const dispositionTotals = new Map(KNOWN_OUTCOMES.map((outcome) => [outcome, { count: 0, durationMs: 0 }]));
+    const coveredAttemptKeys = new Set();
+    for (const point of artifact.points) {
+        if (point.kind !== "attempt-outcome")
+            continue;
+        const outcome = point.dimensions?.outcome ?? "unknown";
+        const key = attemptKeyOf(point.dimensions ?? {});
+        if (key !== undefined)
+            coveredAttemptKeys.add(key);
+        const matched = key === undefined ? undefined : spawnByAttemptKey.get(key);
+        const durationMs = matched === undefined ? 0 : matched.end - matched.start;
+        bump(dispositionTotals, outcome, durationMs);
+    }
+    let interruptedCount = 0;
+    let interruptedMs = 0;
+    for (const [key, interval] of spawnByAttemptKey) {
+        if (coveredAttemptKeys.has(key))
+            continue;
+        const isOpen = interval.span.endOffsetMs === undefined;
+        if (interval.span.dimensions.outcome === "interrupted" || isOpen) {
+            interruptedCount += 1;
+            interruptedMs += interval.end - interval.start;
+        }
+    }
+    dispositionTotals.set("interrupted", { count: interruptedCount, durationMs: interruptedMs });
+    // `bump` above may have created outcome keys outside the known vocabulary
+    // (SC-04's open outcome vocabulary) — surfaced after the known six, sorted.
+    const extraOutcomes = [...dispositionTotals.keys()]
+        .filter((outcome) => !KNOWN_OUTCOMES.includes(outcome))
+        .sort();
+    const dispositions = [...KNOWN_OUTCOMES, ...extraOutcomes].map((outcome) => ({
+        outcome,
+        ...(dispositionTotals.get(outcome) ?? { count: 0, durationMs: 0 }),
+    }));
+    // Rerun cost, grouped by trigger — never a single "waste" number (SC-06).
+    const agentRerunByReason = new Map();
+    let agentRerunTotalMs = 0;
+    for (const interval of topLevelIntervals) {
+        if (!AGENT_ATTEMPT_STAGES.has(interval.span.stage))
+            continue;
+        const reason = interval.span.dimensions.attemptReason;
+        if (reason === undefined || !AGENT_REPEAT_REASONS.has(reason))
+            continue;
+        const durationMs = interval.end - interval.start;
+        bump(agentRerunByReason, reason, durationMs);
+        agentRerunTotalMs += durationMs;
+    }
+    const verifyByWorkstreamPhase = new Map();
+    for (const interval of topLevelIntervals) {
+        if (interval.span.stage !== "verification-command")
+            continue;
+        const workstream = interval.span.dimensions.workstream ?? "";
+        const phase = interval.span.dimensions.attemptReason ?? "";
+        const key = `${workstream} ${phase}`;
+        const list = verifyByWorkstreamPhase.get(key) ?? [];
+        list.push(interval);
+        verifyByWorkstreamPhase.set(key, list);
+    }
+    const verifyRerunByPhase = new Map();
+    const verifyRerunByCommand = new Map();
+    let verifyRerunTotalMs = 0;
+    for (const [key, group] of verifyByWorkstreamPhase) {
+        const phase = key.split(" ")[1] ?? "";
+        const sorted = [...group].sort(compareIntervals);
+        sorted.forEach((interval, index) => {
+            // `post-implementer` verifies the initial attempt — only a rerun if it
+            // somehow fires again for the same workstream; every other phase this
+            // runner emits (post-recovery, post-informed-retry, test-critique-fix,
+            // fix-now) exists only because a prior attempt failed, so every
+            // occurrence counts (WS-02's phase vocabulary, §3.4).
+            const isRerun = phase === "post-implementer" ? index > 0 : ALWAYS_RERUN_VERIFY_PHASES.has(phase);
+            if (!isRerun)
+                return;
+            const durationMs = interval.end - interval.start;
+            verifyRerunTotalMs += durationMs;
+            bump(verifyRerunByPhase, phase, durationMs);
+            bump(verifyRerunByCommand, interval.span.dimensions.verifyCommand ?? "(unknown)", durationMs);
+        });
+    }
+    // Rankings — largest measured contributors, never graded (§3.5). Only
+    // top-level spans participate, so parent/child durations are never summed.
+    const stageGroups = new Map();
+    const workstreamGroups = new Map();
+    const roleGroups = new Map();
+    const verifyCommandGroups = new Map();
+    let largestAgentAttempt;
+    for (const interval of topLevelIntervals) {
+        const durationMs = interval.end - interval.start;
+        bump(stageGroups, interval.span.stage, durationMs);
+        bump(workstreamGroups, interval.span.dimensions.workstream ?? "run-level", durationMs);
+        if (interval.span.dimensions.role !== undefined)
+            bump(roleGroups, interval.span.dimensions.role, durationMs);
+        if (VERIFY_COMMAND_STAGES.has(interval.span.stage) && interval.span.dimensions.verifyCommand !== undefined) {
+            const command = interval.span.dimensions.verifyCommand;
+            const cur = verifyCommandGroups.get(command) ?? { count: 0, durationMs: 0, largestMs: 0 };
+            cur.count += 1;
+            cur.durationMs += durationMs;
+            cur.largestMs = Math.max(cur.largestMs, durationMs);
+            verifyCommandGroups.set(command, cur);
+        }
+        if (AGENT_ATTEMPT_STAGES.has(interval.span.stage) && interval.span.dimensions.attemptSeat !== undefined) {
+            if (largestAgentAttempt === undefined ||
+                durationMs > largestAgentAttempt.durationMs ||
+                (durationMs === largestAgentAttempt.durationMs && interval.span.id < largestAgentAttempt.spanId)) {
+                largestAgentAttempt = {
+                    spanId: interval.span.id,
+                    stage: interval.span.stage,
+                    ...(interval.span.dimensions.workstream !== undefined ? { workstream: interval.span.dimensions.workstream } : {}),
+                    ...(interval.span.dimensions.attemptSeat !== undefined ? { attemptSeat: interval.span.dimensions.attemptSeat } : {}),
+                    ...(interval.span.dimensions.attemptIndex !== undefined ? { attemptIndex: interval.span.dimensions.attemptIndex } : {}),
+                    durationMs,
+                };
+            }
+        }
+    }
+    const byVerifyCommand = [...verifyCommandGroups.entries()]
+        .map(([command, v]) => ({ command, invocations: v.count, totalMs: v.durationMs, largestMs: v.largestMs }))
+        .sort((a, b) => b.totalMs - a.totalMs || a.command.localeCompare(b.command));
+    // Observability coverage (§3.6) — over WS-03's own points only.
+    const coverageCounts = { observed: 0, estimated: 0, unavailable: 0, incomplete: 0 };
+    const unavailableRoles = new Set();
+    const providerPoints = [...artifact.points]
+        .filter((point) => point.kind === "provider-telemetry")
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const roleInfo = new Map();
+    for (const point of artifact.points) {
+        if (!TELEMETRY_KINDS.has(point.kind))
+            continue;
+        coverageCounts[point.coverage] += 1;
+        if (point.kind === "provider-telemetry" && point.coverage === "unavailable" && point.dimensions?.role !== undefined) {
+            unavailableRoles.add(point.dimensions.role);
+        }
+    }
+    for (const point of providerPoints) {
+        const role = point.dimensions?.role;
+        if (role === undefined || (point.label !== "provider" && point.label !== "model"))
+            continue;
+        const info = roleInfo.get(role) ?? { role };
+        const field = point.label === "provider" ? "provider" : "model";
+        if (info[field] === undefined) {
+            info[field] = { coverage: point.coverage, ...(point.detail !== undefined ? { value: point.detail } : {}) };
+        }
+        roleInfo.set(role, info);
+    }
+    const byRoleCoverage = [...roleInfo.values()].sort((a, b) => a.role.localeCompare(b.role));
+    // Provider/model duration totals (§3.5): each role's already-computed
+    // duration total (`roleGroups`) is attributed to the provider/model
+    // identity WS-03 observed for that role — labelled `"unavailable"`, never
+    // dropped or blanked, when a role's provider telemetry is unavailable
+    // (e.g. a non-Claude role), so an entire role's measured time is never
+    // silently missing from these totals.
+    const providerGroups = new Map();
+    const modelGroups = new Map();
+    function labelFor(field) {
+        return field === undefined || field.coverage === "unavailable" ? "unavailable" : (field.value ?? "unavailable");
+    }
+    for (const [role, group] of roleGroups) {
+        const info = roleInfo.get(role);
+        const providerKey = labelFor(info?.provider);
+        const modelKey = labelFor(info?.model);
+        for (const [target, key] of [
+            [providerGroups, providerKey],
+            [modelGroups, modelKey],
+        ]) {
+            const cur = target.get(key) ?? { count: 0, durationMs: 0 };
+            cur.count += group.count;
+            cur.durationMs += group.durationMs;
+            target.set(key, cur);
+        }
+    }
+    const bytesByLabel = new Map();
+    for (const point of artifact.points) {
+        if (point.kind !== "prompt-component-size" || point.unit !== "bytes")
+            continue;
+        bytesByLabel.set(point.label ?? "(unlabeled)", (bytesByLabel.get(point.label ?? "(unlabeled)") ?? 0) + (point.value ?? 0));
+    }
+    const promptComponents = [...bytesByLabel.entries()]
+        .map(([label, bytes]) => ({ label, bytes }))
+        .sort((a, b) => b.bytes - a.bytes || a.label.localeCompare(b.label))
+        .slice(0, 5);
+    const overheadPoints = artifact.points.filter((point) => point.kind === "analytics-overhead");
+    const analyticsOverheadMs = overheadPoints.length > 0 ? overheadPoints.reduce((sum, point) => sum + (point.value ?? 0), 0) : undefined;
+    const publishPoints = artifact.points.filter((point) => point.kind === "publish-duration");
+    const publish = publishPoints.length > 0
+        ? { durationMs: publishPoints.reduce((sum, point) => sum + (point.value ?? 0), 0), invocations: publishPoints.length }
+        : undefined;
+    const evidenceMap = new Map();
+    for (const span of artifact.spans) {
+        for (const ref of span.dimensions.evidence ?? [])
+            evidenceMap.set(`${ref.kind}:${ref.ref}`, ref);
+    }
+    for (const point of artifact.points) {
+        for (const ref of point.evidence ?? [])
+            evidenceMap.set(`${ref.kind}:${ref.ref}`, ref);
+    }
+    const sortedEvidence = [...evidenceMap.values()].sort((a, b) => a.ref.localeCompare(b.ref));
+    const evidence = sortedEvidence.slice(0, 8).map((ref) => ({
+        kind: ref.kind,
+        locality: ref.locality,
+        ref: ref.ref,
+        ...(ref.note !== undefined ? { note: ref.note } : {}),
+    }));
+    // Diagnostics are pushed as each condition is discovered while walking
+    // `artifact.spans` in array order (unresolved-parent, invalid-interval,
+    // interval-exceeds-total); `sweepBucketOwnership`'s overlap diagnostics are
+    // already order-independent (found via sorted interval boundaries), but the
+    // other three are not — sorted here so the full summary stays
+    // order-independent (SC-09): a shuffled `spans` array must never change
+    // which diagnostics were found or their relative order, only the pass that
+    // happened to find them first.
+    diagnostics.sort((a, b) => a.kind.localeCompare(b.kind) ||
+        a.spanIds.join(",").localeCompare(b.spanIds.join(",")) ||
+        a.message.localeCompare(b.message));
+    return {
+        totalElapsedMs,
+        attributedMs,
+        unattributedMs,
+        buckets,
+        diagnostics,
+        drillDowns,
+        dispositions,
+        rerun: {
+            agent: { totalMs: agentRerunTotalMs, byReason: rankedFromGroups(agentRerunByReason).map((r) => ({ key: r.key, count: r.count, durationMs: r.durationMs })) },
+            verification: {
+                totalMs: verifyRerunTotalMs,
+                byPhase: rankedFromGroups(verifyRerunByPhase).map((r) => ({ key: r.key, count: r.count, durationMs: r.durationMs })),
+                byCommand: rankedFromGroups(verifyRerunByCommand).map((r) => ({ key: r.key, count: r.count, durationMs: r.durationMs })),
+            },
+        },
+        rankings: {
+            byStage: rankedFromGroups(stageGroups),
+            byWorkstream: rankedFromGroups(workstreamGroups),
+            byRole: rankedFromGroups(roleGroups),
+            byProvider: rankedFromGroups(providerGroups),
+            byModel: rankedFromGroups(modelGroups),
+            byVerifyCommand,
+            ...(largestAgentAttempt !== undefined ? { largestAgentAttempt } : {}),
+        },
+        coverage: { counts: coverageCounts, unavailableRoles: [...unavailableRoles].sort(), byRole: byRoleCoverage },
+        promptComponents,
+        ...(analyticsOverheadMs !== undefined ? { analyticsOverheadMs } : {}),
+        ...(publish !== undefined ? { publish } : {}),
+        evidence,
+        evidenceTotalCount: evidenceMap.size,
+    };
+}
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        ms = 0;
+    if (ms < 1000)
+        return `${Math.round(ms)}ms`;
+    const totalSeconds = ms / 1000;
+    if (totalSeconds < 60)
+        return `${totalSeconds.toFixed(1)}s`;
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = Math.round(totalSeconds - minutes * 60);
+    return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+}
+function plural(count, noun) {
+    return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+/**
+ * Renders the aggregated summary into the "Where the time went" section
+ * (SC-10, SC-11) — human-first, concise, and never a score or a grade.
+ */
+export function renderWhereTheTimeWent(summary) {
+    const lines = ["## Where the time went", ""];
+    lines.push(`Total elapsed: **${formatDuration(summary.totalElapsedMs)}** — run start to the analytics snapshot taken ` +
+        "just before finalize and the report commit. The report write, the report commit, and publish are " +
+        "excluded from this total and, when observed, recorded separately (see Publish below).", "");
+    lines.push("### Time by bucket", "");
+    for (const bucket of summary.buckets) {
+        lines.push(`- **${bucket.bucket}**: ${formatDuration(bucket.durationMs)} (${bucket.percent.toFixed(1)}%, ${plural(bucket.spanCount, "span")})`);
+    }
+    lines.push("");
+    lines.push("### Largest contributors", "");
+    const topStage = summary.rankings.byStage[0];
+    lines.push(topStage
+        ? `- Stage: \`${topStage.key}\` — ${formatDuration(topStage.durationMs)} across ${plural(topStage.count, "span")}`
+        : "- Stage: none observed.");
+    const topWorkstream = summary.rankings.byWorkstream[0];
+    lines.push(topWorkstream
+        ? `- Workstream: ${topWorkstream.key} — ${formatDuration(topWorkstream.durationMs)}`
+        : "- Workstream: none observed.");
+    const attempt = summary.rankings.largestAgentAttempt;
+    lines.push(attempt
+        ? `- Largest single agent attempt: \`${attempt.stage}\`` +
+            (attempt.workstream ? ` (${attempt.workstream}` : " (") +
+            `${attempt.attemptSeat ? `, ${attempt.attemptSeat}` : ""}` +
+            `${attempt.attemptIndex !== undefined ? ` #${attempt.attemptIndex}` : ""})` +
+            ` — ${formatDuration(attempt.durationMs)}`
+        : "- Largest single agent attempt: none observed.");
+    const topCommand = summary.rankings.byVerifyCommand[0];
+    lines.push(topCommand
+        ? `- Largest verification command: \`${topCommand.command}\` — ${formatDuration(topCommand.totalMs)} across ` +
+            `${plural(topCommand.invocations, "invocation")} (largest single run ${formatDuration(topCommand.largestMs)})`
+        : "- Largest verification command: none observed.");
+    lines.push("");
+    lines.push("### Attempts", "");
+    for (const disposition of summary.dispositions) {
+        lines.push(`- ${disposition.outcome}: ${plural(disposition.count, "attempt")} (${formatDuration(disposition.durationMs)})`);
+    }
+    lines.push("", `Agent time spent re-running after a prior attempt: **${formatDuration(summary.rerun.agent.totalMs)}**, by trigger:`);
+    if (summary.rerun.agent.byReason.length === 0) {
+        lines.push("- none observed");
+    }
+    else {
+        for (const group of summary.rerun.agent.byReason) {
+            lines.push(`- ${group.key}: ${plural(group.count, "attempt")} (${formatDuration(group.durationMs)})`);
+        }
+    }
+    lines.push("");
+    lines.push("### Verification", "");
+    lines.push(`Verification rerun time (passes caused by a retry, recovery, or fix — never the first pass over fresh ` +
+        `work): **${formatDuration(summary.rerun.verification.totalMs)}**`);
+    if (summary.rerun.verification.byPhase.length > 0) {
+        lines.push("", "By phase:");
+        for (const group of summary.rerun.verification.byPhase) {
+            lines.push(`- ${group.key}: ${plural(group.count, "invocation")} (${formatDuration(group.durationMs)})`);
+        }
+    }
+    if (summary.rankings.byVerifyCommand.length > 0) {
+        lines.push("", "Every configured command, all invocations:");
+        for (const command of summary.rankings.byVerifyCommand) {
+            lines.push(`- \`${command.command}\`: ${plural(command.invocations, "invocation")}, ${formatDuration(command.totalMs)} total`);
+        }
+    }
+    lines.push("");
+    lines.push("### Observability gaps", "");
+    lines.push(`Provider/prompt telemetry: ${summary.coverage.counts.observed} observed, ${summary.coverage.counts.estimated} ` +
+        `estimated, ${summary.coverage.counts.unavailable} unavailable, ${summary.coverage.counts.incomplete} incomplete.`);
+    if (summary.coverage.unavailableRoles.length > 0) {
+        lines.push(`Roles reporting unavailable provider telemetry (expected coverage for a non-Claude provider, never a ` +
+            `missing-time signal — their elapsed spans are still fully attributed above): ` +
+            `${summary.coverage.unavailableRoles.join(", ")}.`);
+    }
+    if (summary.rankings.byProvider.length > 0) {
+        lines.push("", "Time by provider (`unavailable` when a role's provider telemetry is unavailable, never a dropped total):");
+        for (const p of summary.rankings.byProvider) {
+            lines.push(`- ${p.key}: ${formatDuration(p.durationMs)} across ${plural(p.count, "span")}`);
+        }
+    }
+    if (summary.rankings.byModel.length > 0) {
+        lines.push("", "Time by model:");
+        for (const m of summary.rankings.byModel) {
+            lines.push(`- ${m.key}: ${formatDuration(m.durationMs)} across ${plural(m.count, "span")}`);
+        }
+    }
+    if (summary.promptComponents.length > 0) {
+        lines.push("", "Largest initial-context components: " +
+            summary.promptComponents.map((c) => `${c.label} (${c.bytes.toLocaleString("en-US")} bytes)`).join(", ") +
+            ".");
+    }
+    if (summary.diagnostics.length > 0) {
+        lines.push("", "Interval-consistency notes:");
+        for (const diagnostic of summary.diagnostics)
+            lines.push(`- ${diagnostic.message}`);
+    }
+    if (summary.analyticsOverheadMs !== undefined) {
+        lines.push("", `Analytics-recorder overhead (a diagnostic footnote, not part of the total above): ${formatDuration(summary.analyticsOverheadMs)}.`);
+    }
+    lines.push("");
+    lines.push("### Evidence", "");
+    if (summary.evidence.length === 0) {
+        lines.push("No canonical evidence references were recorded for this run.");
+    }
+    else {
+        for (const ref of summary.evidence) {
+            lines.push(`- local ${ref.kind}: \`${ref.ref}\`${ref.note ? ` — ${ref.note}` : ""}`);
+        }
+        if (summary.evidenceTotalCount > summary.evidence.length) {
+            lines.push(`(showing ${summary.evidence.length} of ${summary.evidenceTotalCount} recorded references)`);
+        }
+    }
+    lines.push("", "Every reference above resolves only on the machine that ran this build — it is local evidence, not a " +
+        "durable CI artifact.", "");
+    if (summary.publish !== undefined) {
+        lines.push("### Publish", "", `Publish ran after this report was already committed, so it is never reconciled into the total above: ` +
+            `${formatDuration(summary.publish.durationMs)} across ${plural(summary.publish.invocations, "invocation")}.`, "");
+    }
+    return lines;
+}
+function unavailableSection(reason) {
+    return ["## Where the time went", "", `Analytics unavailable — ${reason}.`, ""];
+}
+/**
+ * The run's own fail-open isolation boundary for analytics (D4, SC-13):
+ * always returns a `## Where the time went` section, never throws. A throw
+ * from `aggregate` (real or injected via `deps`, for tests), an `undefined`
+ * snapshot, or a throw while *obtaining* the snapshot all degrade to an
+ * explicit "analytics unavailable" placeholder — never suppress the rest of
+ * the report, which is built independently of this function's output.
+ *
+ * `artifact` accepts either a plain value (the common case, and every
+ * existing pure test) or a thunk. The thunk form matters at the real call
+ * site: `recorder.snapshot()` is documented as non-throwing, but evaluating
+ * it as a plain argument — `renderAnalyticsSection(recorder.snapshot())` —
+ * would run it *before* this function's own try/catch is reached, so any
+ * violation of that contract (a bug, or a test double standing in for the
+ * recorder) would still escape this boundary and, through the caller's own
+ * try/catch, suppress the whole report. Wrapping it in a thunk —
+ * `renderAnalyticsSection(() => recorder.snapshot())` — keeps that call
+ * inside the try below, so this function's "never throws" is true no matter
+ * what actually produced the artifact.
+ */
+export function renderAnalyticsSection(artifact, deps = {}) {
+    const aggregate = deps.aggregate ?? aggregateRunAnalytics;
+    try {
+        const resolved = typeof artifact === "function" ? artifact() : artifact;
+        if (resolved === undefined) {
+            return unavailableSection("no analytics snapshot was available when the report was rendered");
+        }
+        return renderWhereTheTimeWent(aggregate(resolved));
+    }
+    catch (error) {
+        return unavailableSection(error.message);
+    }
+}
+//# sourceMappingURL=run-analytics-report.js.map