@matteeh/osq 0.1.0 → 0.2.0

package/dist/core/report/report.js

@@ -0,0 +1,1421 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { DEFAULT_CONFIG } from '../foundation/config.js';
+import { parseFrontmatter, parseTaskMd } from '../spec/parser.js';
+import { getArchiveDir, getChangesDir, getRejectedDir } from '../status/layout.js';
+import { readQueueReport } from '../status/queue-report.js';
+import { compareNumericPrefix, deriveSpecState } from '../status/state.js';
+import { collectApprovalFlagOutcomes, formatApprovalFlagOutcomes, } from './approval-flags.js';
+import { buildPlanningComparison, computePlanningByChange, } from './planning-economics.js';
+import { readPlanningSessions } from './planning.js';
+import { asData, eventTimestampMs, observeAttempts, observeTaskStream, parseEventLines, parseTokenEvent, } from './report-events.js';
+import { observePreSpawnEvents } from './report-pre-spawn.js';
+import { addRetryHistory, emptyRetryHistory, observeRetries, } from './report-retries.js';
+export function formatDuration(ms) {
+    if (ms <= 0)
+        return '0s';
+    const totalSec = Math.round(ms / 1000);
+    if (totalSec < 60)
+        return `${totalSec}s`;
+    const mins = Math.floor(totalSec / 60);
+    const secs = totalSec % 60;
+    return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+}
+export function formatCost(total) {
+    const fixed = total >= 0.01 ? total.toFixed(2) : total.toFixed(4);
+    return `$${fixed}`;
+}
+/**
+ * Formats a cost only when something was actually reported. A non-zero sum
+ * proves a reported value even when it was not attributed to a counted attempt;
+ * a counted reporter with a zero sum proves a reported zero. Otherwise the
+ * honest label is `not reported` rather than a dollar amount summed from nothing.
+ */
+function formatReportedCost(total, reportedCount) {
+    return total !== 0 || reportedCount > 0 ? formatCost(total) : 'not reported';
+}
+/**
+ * Whether the queue's planning spend has at least one reported value. Complete
+ * coverage with sessions proves every session reported, including recorded
+ * zeros; a non-zero sum proves one did and is handled by the formatter. An
+ * incomplete zero sum cannot tell an unrecorded cost from a reported zero, so
+ * it is treated as unreported rather than invented.
+ */
+function queuePlanningCostReported(queue) {
+    return queue.planning.sessions > 0 && queue.planning.costCoverageComplete;
+}
+const FILE_CHANGE_TOOLS = new Set(['edit', 'write']);
+/**
+ * Trims surrounding whitespace and strips a leading `./` so paths written by
+ * different harnesses collapse to a single canonical form before deduplication.
+ */
+function normalizeFilePath(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const cleaned = trimmed.replace(/^(?:\.\/)+/, '');
+    return cleaned || null;
+}
+/**
+ * Extracts a file path from a tool or file_changed event payload. The summary
+ * field carries the target path for file tools such as edit and write.
+ */
+function extractFilePath(data) {
+    for (const candidate of [data.summary, data.path, data.filePath, data.file, data.filename]) {
+        const filePath = normalizeFilePath(candidate);
+        if (filePath !== null)
+            return filePath;
+    }
+    return null;
+}
+/** A done marker declares manual completion when its frontmatter has `manual: true`. */
+async function doneMarkerIsManual(markerPath) {
+    const content = await fs.readFile(markerPath, 'utf8').catch(() => null);
+    if (content === null)
+        return false;
+    return parseFrontmatter(content).data.manual === true;
+}
+async function fileExists(filePath) {
+    return fs
+        .stat(filePath)
+        .then(() => true)
+        .catch(() => false);
+}
+const SIZE_BUCKETS = ['1-2', '3-4', '5-8', 'over-8'];
+function round2(value) {
+    return Math.round(value * 100) / 100;
+}
+/** Ordered bucket label for a non-negative size observation. */
+function bucketForSize(value) {
+    if (value <= 2)
+        return '1-2';
+    if (value <= 4)
+        return '3-4';
+    if (value <= 8)
+        return '5-8';
+    return 'over-8';
+}
+/** Resolver generation for scope-file evidence; malformed versions fit neither. */
+function scopeFileGeneration(task) {
+    if (task.scopeResolver === undefined)
+        return 'legacy';
+    if (task.scopeResolver === 2)
+        return 'resolver-2';
+    return null;
+}
+/** Title and acceptance-line count from a task file; missing files yield empties. */
+async function readTaskMetadata(folderPath, taskNumber) {
+    const content = await fs
+        .readFile(path.join(folderPath, 'tasks', `${taskNumber}.md`), 'utf8')
+        .catch(() => null);
+    if (content === null)
+        return { title: '', acceptanceLines: 0 };
+    const task = parseTaskMd(content);
+    return { title: task.title, acceptanceLines: task.acceptance.length };
+}
+/**
+ * Projects one task's event stream. A task contributes only with a valid first
+ * `measures` start carrying a finite `scopeFiles`. Attempts count `started`
+ * events; the first attempt passes only when a typed `done` arrives before the
+ * next `started`, `dead`, or `regressed` outcome. Duration sums valid measures
+ * start-to-end pairs and is null when no pair completes.
+ */
+function deriveMeasuredTask(change, task, events) {
+    let scopeFiles = null;
+    let scopeResolver;
+    let pendingStartMs = null;
+    let coveredMs = 0;
+    let hasDuration = false;
+    for (const event of events) {
+        if (event.type !== 'measures')
+            continue;
+        const data = asData(event);
+        if (data?.phase === 'start') {
+            const rawScopeFiles = data.scopeFiles;
+            if (scopeFiles === null &&
+                typeof rawScopeFiles === 'number' &&
+                Number.isFinite(rawScopeFiles) &&
+                rawScopeFiles >= 0) {
+                scopeFiles = rawScopeFiles;
+                scopeResolver = data.scopeResolver;
+            }
+            pendingStartMs = eventTimestampMs(event);
+        }
+        else if (data?.phase === 'end') {
+            const endMs = eventTimestampMs(event);
+            if (pendingStartMs !== null && endMs !== null && endMs >= pendingStartMs) {
+                coveredMs += endMs - pendingStartMs;
+                hasDuration = true;
+            }
+            pendingStartMs = null;
+        }
+    }
+    if (scopeFiles === null)
+        return null;
+    const { attempts, firstAttemptPass } = observeAttempts(events);
+    return {
+        change,
+        task,
+        scopeResolver,
+        scopeFiles,
+        attempts,
+        firstAttemptPass,
+        durationSeconds: hasDuration ? coveredMs / 1000 : null,
+    };
+}
+/** Every measured task across the given change folders, in stable folder order. */
+async function projectMeasuredTasks(folders) {
+    const measured = [];
+    for (const folderPath of folders) {
+        const change = path.basename(folderPath);
+        const tasksDir = path.join(folderPath, 'tasks');
+        let taskFiles = [];
+        try {
+            taskFiles = (await fs.readdir(tasksDir))
+                .filter((entry) => entry.endsWith('.md'))
+                .sort(compareNumericPrefix);
+        }
+        catch {
+            continue;
+        }
+        for (const taskFile of taskFiles) {
+            const taskNumber = taskFile.replace(/\.md$/, '');
+            const eventContent = await fs
+                .readFile(path.join(folderPath, '.run', 'events', `${taskNumber}.jsonl`), 'utf8')
+                .catch(() => null);
+            if (eventContent === null)
+                continue;
+            const derived = deriveMeasuredTask(change, taskNumber, parseEventLines(eventContent));
+            if (!derived)
+                continue;
+            const metadata = await readTaskMetadata(folderPath, taskNumber);
+            measured.push({
+                ...derived,
+                title: metadata.title,
+                acceptanceLines: metadata.acceptanceLines,
+            });
+        }
+    }
+    return measured;
+}
+/** Ordinary sorted median rounded to two decimals, or null for no values. */
+function medianSeconds(values) {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    const median = sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
+    return round2(median);
+}
+/** Ordered bucket rows for one size key; empty buckets report zero and null. */
+function aggregateSizeBuckets(tasks, key) {
+    return SIZE_BUCKETS.map((bucket) => {
+        const rows = tasks.filter((task) => bucketForSize(task[key]) === bucket);
+        const count = rows.length;
+        const passed = rows.filter((task) => task.firstAttemptPass).length;
+        const durations = rows
+            .map((task) => task.durationSeconds)
+            .filter((value) => value !== null);
+        return {
+            bucket,
+            tasks: count,
+            firstAttemptPassRate: count > 0 ? round2(passed / count) : 0,
+            meanAttempts: count > 0 ? round2(rows.reduce((sum, task) => sum + task.attempts, 0) / count) : 0,
+            medianDurationSeconds: medianSeconds(durations),
+        };
+    });
+}
+/** The first-attempt pass with the greatest scope files, then acceptance lines. */
+function selectLargestFirstAttemptPass(tasks) {
+    const passing = tasks.filter((task) => task.firstAttemptPass);
+    if (passing.length === 0)
+        return null;
+    const [top] = [...passing].sort((a, b) => {
+        if (b.scopeFiles !== a.scopeFiles)
+            return b.scopeFiles - a.scopeFiles;
+        if (b.acceptanceLines !== a.acceptanceLines)
+            return b.acceptanceLines - a.acceptanceLines;
+        const byChange = compareNumericPrefix(a.change, b.change);
+        return byChange !== 0 ? byChange : compareNumericPrefix(a.task, b.task);
+    });
+    return {
+        change: top.change,
+        task: top.task,
+        title: top.title,
+        scopeFiles: top.scopeFiles,
+        acceptanceLines: top.acceptanceLines,
+    };
+}
+/** The smallest change id by stable numeric ordering, or null for no tasks. */
+function earliestChange(tasks) {
+    let earliest = null;
+    for (const task of tasks) {
+        if (earliest === null || compareNumericPrefix(task.change, earliest) < 0) {
+            earliest = task.change;
+        }
+    }
+    return earliest;
+}
+/** Build one resolver generation's scope-file bucket and largest-pass evidence. */
+function buildScopeFileSeries(tasks, resolver) {
+    return {
+        resolver,
+        startsAtChange: resolver === 'resolver-2' ? earliestChange(tasks) : null,
+        byScopeFiles: aggregateSizeBuckets(tasks, 'scopeFiles'),
+        largestFirstAttemptPass: selectLargestFirstAttemptPass(tasks),
+    };
+}
+/** Ordered legacy then resolver-2 scope-file series, excluding malformed versions. */
+function deriveScopeFileSeries(tasks) {
+    const legacy = tasks.filter((task) => scopeFileGeneration(task) === 'legacy');
+    const resolver2 = tasks.filter((task) => scopeFileGeneration(task) === 'resolver-2');
+    return [buildScopeFileSeries(legacy, 'legacy'), buildScopeFileSeries(resolver2, 'resolver-2')];
+}
+/** The scope-file series whose largest pass drives the near-limit hint. */
+function selectHintSeries(series) {
+    const resolver2 = series.find((entry) => entry.resolver === 'resolver-2');
+    if (resolver2?.byScopeFiles.some((row) => row.tasks > 0))
+        return resolver2;
+    return series.find((entry) => entry.resolver === 'legacy');
+}
+/** One retry-group line in the `Automatic retries:` block. */
+function formatRetryGroupLine(name, group) {
+    return `  ${name}: ${group.count} retries, ${group.reachedDone} reached done, cost ${formatReportedCost(group.cost, group.costReportedAttempts)} (${group.costReportedAttempts} of ${group.count} attempts reported cost)`;
+}
+/** The retry block printed after the verification lines. */
+function formatRetryHistoryLines(retries) {
+    return [
+        '  Automatic retries:',
+        formatRetryGroupLine('automatic', retries.automatic),
+        formatRetryGroupLine('manual', retries.manual),
+        `  Stuck: ${retries.stuck}`,
+    ];
+}
+/** Rows printed for one size-against-outcome table. */
+function formatSizeBucketLines(rows) {
+    const lines = ['    bucket     tasks  first-attempt pass rate  mean attempts  median duration'];
+    for (const row of rows) {
+        const median = row.medianDurationSeconds === null
+            ? 'unavailable'
+            : formatDuration(row.medianDurationSeconds * 1000);
+        lines.push(`    ${row.bucket.padEnd(10)} ${String(row.tasks).padEnd(6)} ${String(row.firstAttemptPassRate).padEnd(23)} ${String(row.meanAttempts).padEnd(14)} ${median}`);
+    }
+    return lines;
+}
+/** Parses a `brief.md` frontmatter `date` value into epoch milliseconds. */
+function parseBriefDateMs(data) {
+    const value = data.date;
+    if (value instanceof Date) {
+        const ms = value.getTime();
+        return Number.isFinite(ms) ? ms : null;
+    }
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const ms = Date.parse(trimmed);
+    return Number.isFinite(ms) ? ms : null;
+}
+/** Brief frontmatter date in milliseconds, or null when missing or invalid. */
+async function readBriefDateMs(folderPath) {
+    const content = await fs.readFile(path.join(folderPath, 'brief.md'), 'utf8').catch(() => null);
+    if (content === null)
+        return null;
+    return parseBriefDateMs(parseFrontmatter(content).data);
+}
+/** Manifest `approvedAt` in milliseconds, or null when missing or invalid. */
+async function readApprovedAtMs(folderPath) {
+    const content = await fs
+        .readFile(path.join(folderPath, '.run', 'manifest.json'), 'utf8')
+        .catch(() => null);
+    if (content === null)
+        return null;
+    try {
+        const parsed = JSON.parse(content);
+        if (typeof parsed.approvedAt !== 'string')
+            return null;
+        const ms = Date.parse(parsed.approvedAt);
+        return Number.isFinite(ms) ? ms : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Earliest `started` event timestamp across numeric `<n>.jsonl` task streams.
+ * The change-level `change.jsonl` is never a task stream.
+ */
+async function readFirstTaskStartMs(folderPath) {
+    const eventsDir = path.join(folderPath, '.run', 'events');
+    let entries = [];
+    try {
+        entries = (await fs.readdir(eventsDir)).filter((entry) => /^\d+\.jsonl$/.test(entry));
+    }
+    catch {
+        return null;
+    }
+    let earliest = null;
+    for (const entry of entries) {
+        const content = await fs.readFile(path.join(eventsDir, entry), 'utf8').catch(() => '');
+        for (const event of parseEventLines(content)) {
+            if (event.type !== 'started' || typeof event.timestamp !== 'string')
+                continue;
+            const ms = Date.parse(event.timestamp);
+            if (!Number.isFinite(ms))
+                continue;
+            if (earliest === null || ms < earliest)
+                earliest = ms;
+        }
+    }
+    return earliest;
+}
+/** Authoritative archive time from a `change.jsonl` `archived` event, if any. */
+async function readArchivedAtMs(folderPath) {
+    const content = await fs
+        .readFile(path.join(folderPath, '.run', 'events', 'change.jsonl'), 'utf8')
+        .catch(() => null);
+    if (content === null)
+        return null;
+    for (const event of parseEventLines(content)) {
+        if (event.type !== 'archived' || typeof event.timestamp !== 'string')
+            continue;
+        const ms = Date.parse(event.timestamp);
+        if (Number.isFinite(ms))
+            return ms;
+    }
+    return null;
+}
+/** Non-negative rounded seconds between two endpoints, or null when invalid. */
+function phaseSeconds(startMs, endMs) {
+    if (startMs === null || endMs === null)
+        return null;
+    const delta = endMs - startMs;
+    if (delta < 0)
+        return null;
+    return Math.round(delta / 1000);
+}
+/** True when a change-level stream contains at least one valid `rejected` event. */
+async function hasRejectedEvent(folderPath) {
+    const content = await fs
+        .readFile(path.join(folderPath, '.run', 'events', 'change.jsonl'), 'utf8')
+        .catch(() => null);
+    if (content === null)
+        return false;
+    return parseEventLines(content).some((event) => event.type === 'rejected');
+}
+/** Non-empty `planner` value from `brief.md` frontmatter, else `unknown`. */
+async function readPlannerModel(folderPath) {
+    const content = await fs.readFile(path.join(folderPath, 'brief.md'), 'utf8').catch(() => null);
+    if (content === null)
+        return 'unknown';
+    const value = parseFrontmatter(content).data.planner;
+    if (typeof value === 'string' && value.trim())
+        return value.trim();
+    return 'unknown';
+}
+/** Rejected change folders, sorted deterministically by numeric prefix. */
+async function listRejectedFolders(rejectedDir) {
+    let entries = [];
+    try {
+        entries = await fs.readdir(rejectedDir);
+    }
+    catch {
+        return [];
+    }
+    const folders = [];
+    for (const entry of entries) {
+        if (entry.startsWith('.') || entry.startsWith('_'))
+            continue;
+        const fullPath = path.join(rejectedDir, entry);
+        const stat = await fs.stat(fullPath).catch(() => null);
+        if (stat?.isDirectory())
+            folders.push(fullPath);
+    }
+    return folders.sort((a, b) => compareNumericPrefix(path.basename(a), path.basename(b)));
+}
+/** Total, average, and coverage over the rows that report a finite phase. */
+function aggregatePhase(rows, key) {
+    let totalSeconds = 0;
+    let coveredChanges = 0;
+    for (const row of rows) {
+        const value = row[key];
+        if (value !== null) {
+            totalSeconds += value;
+            coveredChanges++;
+        }
+    }
+    return {
+        totalSeconds,
+        averageSeconds: coveredChanges > 0 ? Math.round(totalSeconds / coveredChanges) : 0,
+        coveredChanges,
+        totalChanges: rows.length,
+    };
+}
+export async function getMetricsReport(projectRoot, config = DEFAULT_CONFIG) {
+    let specsDir = getChangesDir(config.paths.openspecRoot, projectRoot);
+    let archiveDir = getArchiveDir(config.paths.openspecRoot, projectRoot);
+    let rejectedDir = getRejectedDir(config.paths.openspecRoot, projectRoot);
+    const specsDirStat = await fs.stat(specsDir).catch(() => null);
+    const archiveDirStat = await fs.stat(archiveDir).catch(() => null);
+    if (!specsDirStat && !archiveDirStat) {
+        const legacySpecs = path.join(projectRoot, 'specs');
+        const legacyArchive = path.join(projectRoot, 'specs', 'archive');
+        const legacySpecsStat = await fs.stat(legacySpecs).catch(() => null);
+        const legacyArchiveStat = await fs.stat(legacyArchive).catch(() => null);
+        if (legacySpecsStat || legacyArchiveStat) {
+            specsDir = legacySpecs;
+            archiveDir = legacyArchive;
+            rejectedDir = path.join(legacySpecs, 'rejected');
+        }
+    }
+    // 1. Identify active specs
+    let activeEntries = [];
+    try {
+        activeEntries = await fs.readdir(specsDir);
+    }
+    catch {
+        activeEntries = [];
+    }
+    const archiveRel = path.relative(specsDir, archiveDir);
+    const archiveFolder = !archiveRel.startsWith('..') && !path.isAbsolute(archiveRel)
+        ? archiveRel.split(path.sep)[0]
+        : 'archive';
+    const rejectedRel = path.relative(specsDir, rejectedDir);
+    const rejectedFolder = !rejectedRel.startsWith('..') && !path.isAbsolute(rejectedRel)
+        ? rejectedRel.split(path.sep)[0]
+        : 'rejected';
+    const candidateActive = activeEntries.filter((e) => !e.startsWith('_') && !e.startsWith('.') && e !== archiveFolder && e !== rejectedFolder);
+    const activeFolders = [];
+    for (const folder of candidateActive) {
+        const fullPath = path.join(specsDir, folder);
+        const stat = await fs.stat(fullPath).catch(() => null);
+        if (stat?.isDirectory()) {
+            activeFolders.push(fullPath);
+        }
+    }
+    // 2. Identify archived specs
+    let archiveEntries = [];
+    try {
+        archiveEntries = await fs.readdir(archiveDir);
+    }
+    catch {
+        archiveEntries = [];
+    }
+    const candidateArchived = archiveEntries.filter((e) => !e.startsWith('_') && !e.startsWith('.'));
+    const archivedFolders = [];
+    for (const folder of candidateArchived) {
+        const fullPath = path.join(archiveDir, folder);
+        const stat = await fs.stat(fullPath).catch(() => null);
+        if (stat?.isDirectory()) {
+            archivedFolders.push(fullPath);
+        }
+    }
+    const allSpecFolders = [...activeFolders, ...archivedFolders];
+    // Rejected history is discovered separately from the active and archive
+    // scans, so preserved tasks, planning logs, and events never leak into any
+    // other aggregate. A folder counts once, only with a valid `rejected` event.
+    let rejectionTotal = 0;
+    const rejectionsByPlanner = {};
+    for (const folderPath of await listRejectedFolders(rejectedDir)) {
+        if (!(await hasRejectedEvent(folderPath)))
+            continue;
+        rejectionTotal++;
+        const model = await readPlannerModel(folderPath);
+        rejectionsByPlanner[model] = (rejectionsByPlanner[model] ?? 0) + 1;
+    }
+    const rejectionsByPlannerModel = Object.fromEntries(Object.entries(rejectionsByPlanner).sort(([a], [b]) => a.localeCompare(b)));
+    // 3. Shared task discovery. Both the marker and event views iterate this same
+    // set, so current state and history can never disagree about which tasks exist.
+    const archivedFolderSet = new Set(archivedFolders);
+    const discoveredTasks = [];
+    for (const folderPath of allSpecFolders) {
+        const changeId = path.basename(folderPath);
+        const tasksDir = path.join(folderPath, 'tasks');
+        let taskFiles = [];
+        try {
+            taskFiles = (await fs.readdir(tasksDir))
+                .filter((e) => e.endsWith('.md'))
+                .sort(compareNumericPrefix);
+        }
+        catch {
+            taskFiles = [];
+        }
+        const statusByTask = new Map();
+        try {
+            const specState = await deriveSpecState(projectRoot, folderPath);
+            for (const task of specState.tasks) {
+                statusByTask.set(task.taskNumber, task.status);
+            }
+        }
+        catch { }
+        for (const taskFile of taskFiles) {
+            const taskNumber = taskFile.replace(/\.md$/, '');
+            discoveredTasks.push({
+                changeId,
+                taskNumber,
+                id: `${changeId}/${taskNumber}`,
+                folderPath,
+                eventFilePath: path.join(folderPath, '.run', 'events', `${taskNumber}.jsonl`),
+                archived: archivedFolderSet.has(folderPath),
+                status: statusByTask.get(taskNumber) ?? 'pending',
+            });
+        }
+    }
+    // 4. Current state: markers only. A task in an archived change that carries no
+    // terminal or running marker can never run again, so it is unmarked rather
+    // than pending.
+    let doneTasks = 0;
+    let verifiedTasks = 0;
+    let manualTasks = 0;
+    let deadTasks = 0;
+    let regressedTasks = 0;
+    let runningTasks = 0;
+    let pendingTasks = 0;
+    let unmarkedTasks = 0;
+    const manualCache = new Map();
+    for (const task of discoveredTasks) {
+        switch (task.status) {
+            case 'done': {
+                doneTasks++;
+                const markerPath = path.join(task.folderPath, '.run', 'done', task.taskNumber);
+                let manual = manualCache.get(markerPath);
+                if (manual === undefined) {
+                    manual = await doneMarkerIsManual(markerPath);
+                    manualCache.set(markerPath, manual);
+                }
+                if (manual)
+                    manualTasks++;
+                else
+                    verifiedTasks++;
+                break;
+            }
+            case 'dead':
+                deadTasks++;
+                break;
+            case 'regressed':
+                regressedTasks++;
+                break;
+            case 'running':
+                runningTasks++;
+                break;
+            case 'pending':
+                if (task.archived)
+                    unmarkedTasks++;
+                else
+                    pendingTasks++;
+                break;
+        }
+    }
+    const totalTasks = discoveredTasks.length;
+    // 5. History and coverage: task event files only.
+    let attemptsTotal = 0;
+    const attemptsByTask = {};
+    const multipleAttempts = [];
+    let unexplainedTotal = 0;
+    const unexplainedByTask = {};
+    const deadByReason = {};
+    let verifyTotal = 0;
+    let verifyMissingExitCode = 0;
+    const verifyByTask = {};
+    let preSpawnRuns = 0;
+    let preSpawnMismatches = 0;
+    const preSpawnMismatchedTasks = [];
+    let preSpawnMissingPathRuns = 0;
+    const preSpawnByStart = {
+        red: { runs: 0, passed: 0 },
+        green: { runs: 0, passed: 0 },
+        any: { runs: 0, passed: 0 },
+    };
+    let totalCost = 0;
+    const perSpecCost = {};
+    let reportedCostAttempts = 0;
+    let retries = emptyRetryHistory();
+    let scopeDetected = 0;
+    let scopeVerificationPassed = 0;
+    let scopeVerificationFailed = 0;
+    let scopeRecertifiedByHuman = 0;
+    let scopeRequeuedForAgent = 0;
+    let withEventsCount = 0;
+    let withoutEventsCount = 0;
+    const coverageByChange = {};
+    for (const task of discoveredTasks) {
+        if (!coverageByChange[task.changeId]) {
+            coverageByChange[task.changeId] = { withEvents: [], withoutEvents: [] };
+        }
+        const changeCoverage = coverageByChange[task.changeId];
+        const hasEventFile = await fileExists(task.eventFilePath);
+        if (hasEventFile) {
+            withEventsCount++;
+            changeCoverage.withEvents.push(task.taskNumber);
+        }
+        else {
+            withoutEventsCount++;
+            changeCoverage.withoutEvents.push(task.taskNumber);
+        }
+        const content = hasEventFile
+            ? await fs.readFile(task.eventFilePath, 'utf8').catch(() => '')
+            : '';
+        const events = parseEventLines(content);
+        const observation = observeTaskStream(events);
+        const preSpawnEvents = observePreSpawnEvents(events);
+        preSpawnMissingPathRuns += preSpawnEvents.missingPathRuns;
+        for (const start of ['red', 'green', 'any']) {
+            preSpawnByStart[start].runs += preSpawnEvents.byStart[start].runs;
+            preSpawnByStart[start].passed += preSpawnEvents.byStart[start].passed;
+        }
+        retries = addRetryHistory(retries, observeRetries(events));
+        const taskAttempts = observation.attempts;
+        attemptsTotal += taskAttempts;
+        unexplainedTotal += observation.unexplained;
+        for (const [reason, count] of Object.entries(observation.deadByReason)) {
+            deadByReason[reason] = (deadByReason[reason] ?? 0) + count;
+        }
+        verifyTotal += observation.verifyCodes.length;
+        verifyMissingExitCode += observation.verifyCodes.filter((code) => code === null).length;
+        preSpawnRuns += observation.preSpawnRuns;
+        preSpawnMismatches += observation.preSpawnMismatches;
+        if (observation.preSpawnMismatches > 0)
+            preSpawnMismatchedTasks.push(task.id);
+        for (const value of observation.costValues) {
+            totalCost += value;
+            perSpecCost[task.changeId] = (perSpecCost[task.changeId] ?? 0) + value;
+        }
+        reportedCostAttempts += observation.costReportedAttempts;
+        scopeDetected += observation.scopeDetected;
+        scopeVerificationPassed += observation.scopeVerificationPassed;
+        scopeVerificationFailed += observation.scopeVerificationFailed;
+        scopeRecertifiedByHuman += observation.scopeRecertifiedByHuman;
+        scopeRequeuedForAgent += observation.scopeRequeuedForAgent;
+        attemptsByTask[task.id] = taskAttempts;
+        if (taskAttempts > 1)
+            multipleAttempts.push(task.id);
+        if (observation.unexplained > 0)
+            unexplainedByTask[task.id] = observation.unexplained;
+        if (observation.verifyCodes.length > 0)
+            verifyByTask[task.id] = [...observation.verifyCodes];
+    }
+    for (const changeCoverage of Object.values(coverageByChange)) {
+        changeCoverage.withEvents.sort(compareNumericPrefix);
+        changeCoverage.withoutEvents.sort(compareNumericPrefix);
+    }
+    multipleAttempts.sort();
+    preSpawnMismatchedTasks.sort();
+    // 6. Unrelated aggregate metrics still read every event stream, including
+    // legacy `change.jsonl`, exactly as before. The change-level stream is
+    // excluded from execution durations: since 035 it can carry archive events
+    // whose span is not a task duration.
+    let totalDurationMs = 0;
+    let tasksWithDurationCount = 0;
+    let totalInput = 0;
+    let totalCachedInput = 0;
+    let totalOutput = 0;
+    let totalReasoning = 0;
+    let totalTokens = 0;
+    let totalFileChanges = 0;
+    const uniqueFiles = new Set();
+    for (const folderPath of allSpecFolders) {
+        const eventsDir = path.join(folderPath, '.run', 'events');
+        let eventFiles = [];
+        try {
+            eventFiles = (await fs.readdir(eventsDir)).filter((e) => e.endsWith('.jsonl'));
+        }
+        catch {
+            eventFiles = [];
+        }
+        for (const eventFile of eventFiles) {
+            const isChangeStream = eventFile === 'change.jsonl';
+            const eventFilePath = path.join(eventsDir, eventFile);
+            const fileContent = await fs.readFile(eventFilePath, 'utf8').catch(() => '');
+            if (!fileContent)
+                continue;
+            let startedTime = null;
+            let exitedTime = null;
+            let minTime = null;
+            let maxTime = null;
+            for (const event of parseEventLines(fileContent)) {
+                const data = asData(event);
+                const ts = event.timestamp ? new Date(String(event.timestamp)).getTime() : Number.NaN;
+                if (!Number.isNaN(ts)) {
+                    if (minTime === null || ts < minTime)
+                        minTime = ts;
+                    if (maxTime === null || ts > maxTime)
+                        maxTime = ts;
+                    if (event.type === 'started' && startedTime === null) {
+                        startedTime = ts;
+                    }
+                    if (event.type === 'exited') {
+                        exitedTime = ts;
+                    }
+                }
+                if (event.type === 'tokens' && data) {
+                    const delta = parseTokenEvent(data);
+                    totalInput += delta.input;
+                    totalCachedInput += delta.cachedInput;
+                    totalOutput += delta.output;
+                    totalReasoning += delta.reasoning;
+                    totalTokens += delta.total;
+                }
+                if (event.type === 'tool' && data) {
+                    const tool = data.tool;
+                    if (typeof tool === 'string' && FILE_CHANGE_TOOLS.has(tool.toLowerCase())) {
+                        totalFileChanges++;
+                        const filePath = extractFilePath(data);
+                        if (filePath !== null)
+                            uniqueFiles.add(filePath);
+                    }
+                }
+                if (event.type === 'file_changed' && data) {
+                    totalFileChanges++;
+                    const filePath = extractFilePath(data);
+                    if (filePath !== null)
+                        uniqueFiles.add(filePath);
+                    if (Array.isArray(data.files)) {
+                        for (const f of data.files) {
+                            const normalized = normalizeFilePath(f);
+                            if (normalized !== null)
+                                uniqueFiles.add(normalized);
+                        }
+                    }
+                }
+            }
+            if (!isChangeStream && (startedTime !== null || minTime !== null)) {
+                let taskDuration = 0;
+                if (startedTime !== null && exitedTime !== null && exitedTime >= startedTime) {
+                    taskDuration = exitedTime - startedTime;
+                }
+                else if (minTime !== null && maxTime !== null && maxTime > minTime) {
+                    taskDuration = maxTime - minTime;
+                }
+                if (taskDuration > 0) {
+                    totalDurationMs += taskDuration;
+                    tasksWithDurationCount++;
+                }
+            }
+        }
+    }
+    // 7. Planning telemetry: correlated `.run/plan.jsonl` pairs across every
+    // active and archived change. Only a valid start counts as a session.
+    let planningSessions = 0;
+    let changesWithPlanningRecords = 0;
+    let planningWallSeconds = 0;
+    const planningWallByChange = {};
+    let planningInput = null;
+    let planningOutput = null;
+    let planningCached = null;
+    let planningReasoning = null;
+    let planningCost = 0;
+    let planningReportedSessions = 0;
+    let planningCostReportedSessions = 0;
+    for (const folderPath of allSpecFolders) {
+        const changeId = path.basename(folderPath);
+        let changeHasPlanningRecord = false;
+        for (const session of await readPlanningSessions(folderPath)) {
+            if (!session.started)
+                continue;
+            planningSessions++;
+            changeHasPlanningRecord = true;
+            planningWallByChange[changeId] ??= 0;
+            const exited = session.exited;
+            if (!exited)
+                continue;
+            planningWallSeconds += exited.data.wallSeconds;
+            planningWallByChange[changeId] += exited.data.wallSeconds;
+            const usage = exited.data.usage;
+            let reported = false;
+            if (usage.inputTokens !== null) {
+                planningInput = (planningInput ?? 0) + usage.inputTokens;
+                reported = true;
+            }
+            if (usage.outputTokens !== null) {
+                planningOutput = (planningOutput ?? 0) + usage.outputTokens;
+                reported = true;
+            }
+            if (usage.cachedTokens !== null) {
+                planningCached = (planningCached ?? 0) + usage.cachedTokens;
+                reported = true;
+            }
+            if (usage.reasoningTokens !== null) {
+                planningReasoning = (planningReasoning ?? 0) + usage.reasoningTokens;
+                reported = true;
+            }
+            if (usage.cost !== null) {
+                planningCost += usage.cost;
+                reported = true;
+                planningCostReportedSessions++;
+            }
+            if (reported)
+                planningReportedSessions++;
+        }
+        if (changeHasPlanningRecord)
+            changesWithPlanningRecords++;
+    }
+    const planningWallSecondsByChange = Object.fromEntries(Object.entries(planningWallByChange).sort(([a], [b]) => a.localeCompare(b)));
+    const planningByChange = await computePlanningByChange(allSpecFolders);
+    const planningComparison = buildPlanningComparison({
+        input: planningInput,
+        output: planningOutput,
+        cached: planningCached,
+        reasoning: planningReasoning,
+        cost: planningCostReportedSessions > 0 ? planningCost : null,
+    }, {
+        input: totalInput,
+        output: totalOutput,
+        cached: totalCachedInput,
+        reasoning: totalReasoning,
+        cost: reportedCostAttempts > 0 || totalCost !== 0 ? totalCost : null,
+    });
+    // 8. Archived change cycle time. Only archived folders get a row; every phase
+    // is null unless both endpoints exist, parse, and are ordered correctly.
+    const cycleRows = [];
+    for (const folderPath of archivedFolders) {
+        const change = path.basename(folderPath);
+        const briefMs = await readBriefDateMs(folderPath);
+        const approvedMs = await readApprovedAtMs(folderPath);
+        const firstStartMs = await readFirstTaskStartMs(folderPath);
+        const archivedMs = await readArchivedAtMs(folderPath);
+        const briefToApprovalSeconds = phaseSeconds(briefMs, approvedMs);
+        const approvalToFirstTaskSeconds = phaseSeconds(approvedMs, firstStartMs);
+        const firstTaskToArchiveSeconds = phaseSeconds(firstStartMs, archivedMs);
+        const totalSeconds = briefToApprovalSeconds !== null &&
+            approvalToFirstTaskSeconds !== null &&
+            firstTaskToArchiveSeconds !== null
+            ? briefToApprovalSeconds + approvalToFirstTaskSeconds + firstTaskToArchiveSeconds
+            : null;
+        cycleRows.push({
+            change,
+            briefToApprovalSeconds,
+            approvalToFirstTaskSeconds,
+            firstTaskToArchiveSeconds,
+            totalSeconds,
+        });
+    }
+    cycleRows.sort((a, b) => a.change.localeCompare(b.change));
+    const cyclePhases = {
+        briefToApproval: aggregatePhase(cycleRows, 'briefToApprovalSeconds'),
+        approvalToFirstTask: aggregatePhase(cycleRows, 'approvalToFirstTaskSeconds'),
+        firstTaskToArchive: aggregatePhase(cycleRows, 'firstTaskToArchiveSeconds'),
+        total: aggregatePhase(cycleRows, 'totalSeconds'),
+    };
+    const activeSpecs = activeFolders.length;
+    const archivedSpecs = archivedFolders.length;
+    const totalSpecs = activeSpecs + archivedSpecs;
+    const completionRate = totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 10000) / 100 : 0;
+    const avgDurationMs = tasksWithDurationCount > 0 ? Math.round(totalDurationMs / tasksWithDurationCount) : 0;
+    const totalSeconds = Math.round(totalDurationMs / 1000);
+    const avgSeconds = Math.round(avgDurationMs / 1000);
+    const formattedTotal = formatDuration(totalDurationMs);
+    const formattedAvg = formatDuration(avgDurationMs);
+    const queue = await readQueueReport(projectRoot, config);
+    const approvalFlags = await collectApprovalFlagOutcomes(allSpecFolders);
+    const measuredTasks = await projectMeasuredTasks(allSpecFolders);
+    const sizes = {
+        scopeFileSeries: deriveScopeFileSeries(measuredTasks),
+        byAcceptanceLines: aggregateSizeBuckets(measuredTasks, 'acceptanceLines'),
+    };
+    const perSpec = {};
+    for (const [spec, value] of Object.entries(perSpecCost)) {
+        if (value > 0)
+            perSpec[spec] = value;
+    }
+    const sortedPerSpec = Object.fromEntries(Object.entries(perSpec).sort(([a], [b]) => a.localeCompare(b)));
+    return {
+        approvalFlags,
+        specs: {
+            total: totalSpecs,
+            active: activeSpecs,
+            archived: archivedSpecs,
+        },
+        now: {
+            total: totalTasks,
+            done: doneTasks,
+            verified: verifiedTasks,
+            manual: manualTasks,
+            dead: deadTasks,
+            regressed: regressedTasks,
+            running: runningTasks,
+            pending: pendingTasks,
+            unmarked: unmarkedTasks,
+        },
+        completionRate,
+        history: {
+            attempts: {
+                total: attemptsTotal,
+                byTask: attemptsByTask,
+                multipleAttempts,
+            },
+            deadByReason,
+            unexplainedReruns: {
+                total: unexplainedTotal,
+                byTask: unexplainedByTask,
+            },
+            verifyRuns: {
+                total: verifyTotal,
+                missingExitCode: verifyMissingExitCode,
+                byTask: verifyByTask,
+            },
+            preSpawnVerify: {
+                runs: preSpawnRuns,
+                mismatches: preSpawnMismatches,
+                mismatchedTasks: preSpawnMismatchedTasks,
+                missingPathRuns: preSpawnMissingPathRuns,
+                byStart: preSpawnByStart,
+            },
+            cost: {
+                total: totalCost,
+                perSpec: sortedPerSpec,
+                formattedTotal: formatReportedCost(totalCost, reportedCostAttempts),
+                provenance: 'harness-reported',
+                coverage: {
+                    reportedAttempts: reportedCostAttempts,
+                    totalAttempts: attemptsTotal,
+                },
+            },
+            retries,
+            rejections: {
+                total: rejectionTotal,
+                byPlannerModel: rejectionsByPlannerModel,
+            },
+            sizes,
+            scopeRegressions: {
+                detected: scopeDetected,
+                verificationPassedAtDetection: scopeVerificationPassed,
+                verificationFailedAtDetection: scopeVerificationFailed,
+                recertifiedByHuman: scopeRecertifiedByHuman,
+                requeuedForAgent: scopeRequeuedForAgent,
+            },
+        },
+        coverage: {
+            withEvents: withEventsCount,
+            withoutEvents: withoutEventsCount,
+            byChange: coverageByChange,
+        },
+        cycle: {
+            phases: cyclePhases,
+            byChange: cycleRows,
+        },
+        durations: {
+            totalMs: totalDurationMs,
+            totalSeconds,
+            avgMs: avgDurationMs,
+            avgSeconds,
+            formattedTotal,
+            formattedAvg,
+        },
+        tokens: {
+            input: totalInput,
+            cached_input: totalCachedInput,
+            output: totalOutput,
+            reasoning: totalReasoning,
+            total: totalTokens,
+            cacheSharePercent: totalInput + totalCachedInput > 0
+                ? Math.round((totalCachedInput / (totalInput + totalCachedInput)) * 1000) / 10
+                : 0,
+        },
+        fileChanges: {
+            totalChanges: totalFileChanges,
+            uniqueFiles: Array.from(uniqueFiles).sort(),
+            uniqueCount: uniqueFiles.size,
+        },
+        planning: {
+            sessions: planningSessions,
+            changesWithPlanningRecords,
+            wallSeconds: planningWallSeconds,
+            wallSecondsByChange: planningWallSecondsByChange,
+            tokens: {
+                input: planningInput ?? 0,
+                output: planningOutput ?? 0,
+                cached: planningCached ?? 0,
+                reasoning: planningReasoning ?? 0,
+            },
+            cost: {
+                total: planningCost,
+                formattedTotal: formatReportedCost(planningCost, planningCostReportedSessions),
+                provenance: 'harness-reported',
+            },
+            coverage: {
+                reportedSessions: planningReportedSessions,
+                totalSessions: planningSessions,
+            },
+            byChange: planningByChange,
+            comparison: planningComparison,
+        },
+        queue,
+    };
+}
+/**
+ * Alias for {@link getMetricsReport} matching the report-generation name used
+ * by the metrics-and-reporting spec.
+ */
+export const generateReport = getMetricsReport;
+export const REPOSITORY_RECORD_MIN_MEASURED_TASKS = 5;
+export const REPOSITORY_RECORD_MAX_ARCHIVED_CHANGES = 20;
+export const REPOSITORY_RECORD_MAX_DEAD_OUTCOMES = 10;
+function numericPrefix(name) {
+    const match = name.match(/^(\d+)/);
+    return match ? Number.parseInt(match[1], 10) : null;
+}
+/** Canonical archive folders, newest numeric first, hidden entries excluded. */
+async function listRecentArchiveFolders(archiveDir, limit) {
+    let entries = [];
+    try {
+        entries = await fs.readdir(archiveDir);
+    }
+    catch {
+        return [];
+    }
+    const folders = [];
+    for (const entry of entries) {
+        if (entry.startsWith('.') || entry.startsWith('_'))
+            continue;
+        const fullPath = path.join(archiveDir, entry);
+        const stat = await fs.stat(fullPath).catch(() => null);
+        if (stat?.isDirectory())
+            folders.push(fullPath);
+    }
+    folders.sort((a, b) => {
+        const nameA = path.basename(a);
+        const nameB = path.basename(b);
+        const numA = numericPrefix(nameA);
+        const numB = numericPrefix(nameB);
+        if (numA !== null && numB !== null) {
+            if (numA !== numB)
+                return numB - numA;
+            return nameA.localeCompare(nameB);
+        }
+        if (numA !== null)
+            return -1;
+        if (numB !== null)
+            return 1;
+        return nameA.localeCompare(nameB);
+    });
+    return folders.slice(0, limit);
+}
+/** Every typed `dead` event in the window, in change/task/event order. */
+async function collectDeadOutcomes(folders) {
+    const outcomes = [];
+    for (const folderPath of folders) {
+        const change = path.basename(folderPath);
+        const tasksDir = path.join(folderPath, 'tasks');
+        let taskFiles = [];
+        try {
+            taskFiles = (await fs.readdir(tasksDir))
+                .filter((entry) => entry.endsWith('.md'))
+                .sort(compareNumericPrefix);
+        }
+        catch {
+            continue;
+        }
+        for (const taskFile of taskFiles) {
+            const taskNumber = taskFile.replace(/\.md$/, '');
+            const eventContent = await fs
+                .readFile(path.join(folderPath, '.run', 'events', `${taskNumber}.jsonl`), 'utf8')
+                .catch(() => null);
+            if (eventContent === null)
+                continue;
+            const metadata = await readTaskMetadata(folderPath, taskNumber);
+            for (const event of parseEventLines(eventContent)) {
+                if (event.type !== 'dead')
+                    continue;
+                const rawReason = asData(event)?.reason;
+                const reason = typeof rawReason === 'string' && rawReason.trim() ? rawReason.trim() : 'unknown';
+                outcomes.push({ change, title: metadata.title, reason });
+            }
+        }
+    }
+    return outcomes;
+}
+/**
+ * Shared bounded repository record: at most the 20 newest canonical archived
+ * changes by numeric id, with measured outcomes and up to ten dead rows.
+ */
+export async function getRepositoryRecord(projectRoot, config = DEFAULT_CONFIG) {
+    const archiveDir = getArchiveDir(config.paths.openspecRoot, projectRoot);
+    const folders = await listRecentArchiveFolders(archiveDir, REPOSITORY_RECORD_MAX_ARCHIVED_CHANGES);
+    const measured = await projectMeasuredTasks(folders);
+    const deadOutcomes = await collectDeadOutcomes(folders);
+    const passed = measured.filter((task) => task.firstAttemptPass).length;
+    const durations = measured
+        .map((task) => task.durationSeconds)
+        .filter((value) => value !== null);
+    // Scope-sized evidence uses exactly one resolver generation: resolver-2 when
+    // the archive window has any, otherwise the labeled legacy fallback. Malformed
+    // resolver versions never contribute a cross-generation comparison.
+    const resolver2Tasks = measured.filter((task) => scopeFileGeneration(task) === 'resolver-2');
+    const legacyTasks = measured.filter((task) => scopeFileGeneration(task) === 'legacy');
+    const useResolver2 = resolver2Tasks.length > 0;
+    const scopeTasks = useResolver2 ? resolver2Tasks : legacyTasks;
+    const scopeFileResolver = scopeTasks.length > 0 ? (useResolver2 ? 'resolver-2' : 'legacy') : null;
+    return {
+        measuredTasks: measured.length,
+        firstAttemptPassRate: measured.length > 0 ? round2(passed / measured.length) : 0,
+        medianDurationSeconds: medianSeconds(durations),
+        largestFirstAttemptPass: selectLargestFirstAttemptPass(scopeTasks),
+        scopeFileResolver,
+        deadOutcomes: deadOutcomes.slice(0, REPOSITORY_RECORD_MAX_DEAD_OUTCOMES),
+    };
+}
+/**
+ * Body of the planning prompt's repository-record section. The caller owns the
+ * heading. Fewer than five measured tasks print only the too-small sentence.
+ */
+export function formatRepositoryRecordBody(record) {
+    if (record.measuredTasks < REPOSITORY_RECORD_MIN_MEASURED_TASKS) {
+        return `This repository's measured record is too small (fewer than ${REPOSITORY_RECORD_MIN_MEASURED_TASKS} tasks).`;
+    }
+    const lines = [];
+    lines.push(`First-attempt pass rate: ${record.firstAttemptPassRate}`);
+    const largest = record.largestFirstAttemptPass;
+    if (largest) {
+        const scopeLabel = record.scopeFileResolver === 'legacy'
+            ? ' [legacy scope]'
+            : record.scopeFileResolver === 'resolver-2'
+                ? ' [resolver 2 scope]'
+                : '';
+        lines.push(`Largest first-attempt pass: ${largest.change}/${largest.task} "${largest.title}" (scope files: ${largest.scopeFiles}, acceptance lines: ${largest.acceptanceLines})${scopeLabel}`);
+    }
+    else {
+        lines.push('Largest first-attempt pass: unavailable');
+    }
+    lines.push(`Median task duration: ${record.medianDurationSeconds === null
+        ? 'unavailable'
+        : formatDuration(record.medianDurationSeconds * 1000)}`);
+    lines.push('Dead outcomes:');
+    if (record.deadOutcomes.length === 0) {
+        lines.push('  (none)');
+    }
+    else {
+        for (const outcome of record.deadOutcomes) {
+            lines.push(`- ${outcome.change}, ${outcome.title}, ${outcome.reason}`);
+        }
+    }
+    return lines.join('\n');
+}
+/** A nullable measured value: `unavailable` when nothing reported it. */
+function formatOptionalValue(value) {
+    return value === null ? 'unavailable' : String(value);
+}
+/** A nullable comparison cost: `not reported` when nothing on its side did. */
+function formatComparisonCost(cost) {
+    return formatReportedCost(cost ?? 0, cost === null ? 0 : 1);
+}
+/** A nullable comparison token total: `not reported` when nothing on its side did. */
+function formatComparisonToken(value) {
+    return value === null ? 'not reported' : String(value);
+}
+/** One `Planning by change:` row for a single change's economics. */
+function formatPlanningChangeLine(entry) {
+    const tokens = entry.tokens;
+    return [
+        `sessions ${entry.sessions}`,
+        `active ${formatOptionalValue(entry.activeMinutes)} min`,
+        `tokens in ${formatOptionalValue(tokens.input)} out ${formatOptionalValue(tokens.output)} cache-read ${formatOptionalValue(tokens.cacheRead)} cache-write ${formatOptionalValue(tokens.cacheWrite)} reasoning ${formatOptionalValue(tokens.reasoning)}`,
+        `cost ${formatComparisonCost(entry.cost)}`,
+        `spec words ${formatOptionalValue(entry.specWords)}`,
+        `changed lines ${formatOptionalValue(entry.changedLines)} (${formatOptionalValue(entry.specWordsPerChangedLine)} words/line)`,
+        `last edit to approval ${formatOptionalValue(entry.minutesLastEditToApproval)} min`,
+    ].join(', ');
+}
+export function formatMetricsReport(report, config = DEFAULT_CONFIG) {
+    const lines = [];
+    lines.push('osq Delivery Metrics Report');
+    lines.push('');
+    lines.push('Specs Summary:');
+    lines.push(`  Total specs: ${report.specs.total} (${report.specs.active} active, ${report.specs.archived} archived)`);
+    lines.push('');
+    lines.push('Now:');
+    lines.push(`  Total tasks: ${report.now.total}`);
+    lines.push(`  Done: ${report.now.done}`);
+    lines.push(`  Verified done: ${report.now.verified}`);
+    lines.push(`  Manual done: ${report.now.manual}`);
+    lines.push(`  Dead: ${report.now.dead}`);
+    lines.push(`  Regressed: ${report.now.regressed}`);
+    lines.push(`  Running: ${report.now.running}`);
+    lines.push(`  Pending: ${report.now.pending}`);
+    lines.push(`  Unmarked: ${report.now.unmarked}`);
+    lines.push(`  Completion rate: ${report.completionRate}%`);
+    lines.push('');
+    lines.push('History:');
+    lines.push(`  Total attempts: ${report.history.attempts.total}`);
+    lines.push(`  Tasks with multiple attempts: ${report.history.attempts.multipleAttempts.length}`);
+    lines.push(`  Unexplained re-runs: ${report.history.unexplainedReruns.total}`);
+    lines.push(`  Verification runs: ${report.history.verifyRuns.total}`);
+    lines.push(`  Verification runs missing exit code: ${report.history.verifyRuns.missingExitCode}`);
+    lines.push(`  Pre-spawn verify mismatches: ${report.history.preSpawnVerify.mismatches} of ${report.history.preSpawnVerify.runs} runs`);
+    lines.push(`  Pre-spawn verify with missing paths: ${report.history.preSpawnVerify.missingPathRuns} of ${report.history.preSpawnVerify.runs} runs`);
+    const preSpawnByStart = report.history.preSpawnVerify.byStart;
+    lines.push(`  Pre-spawn verify by declared start: red ${preSpawnByStart.red.passed} of ${preSpawnByStart.red.runs} passed, green ${preSpawnByStart.green.passed} of ${preSpawnByStart.green.runs} passed, any ${preSpawnByStart.any.passed} of ${preSpawnByStart.any.runs} passed`);
+    lines.push(...formatRetryHistoryLines(report.history.retries));
+    lines.push(`  Harness-reported cost: ${report.history.cost.formattedTotal} (${report.history.cost.coverage.reportedAttempts} of ${report.history.cost.coverage.totalAttempts} attempts reported cost)`);
+    lines.push('  Dead by reason:');
+    const deadEntries = Object.entries(report.history.deadByReason).sort(([a], [b]) => a.localeCompare(b));
+    if (deadEntries.length === 0) {
+        lines.push('    (none)');
+    }
+    else {
+        for (const [reason, count] of deadEntries) {
+            lines.push(`    ${reason}: ${count}`);
+        }
+    }
+    lines.push(`  Rejections: ${report.history.rejections.total}`);
+    lines.push('  Rejections by planner model:');
+    const rejectionEntries = Object.entries(report.history.rejections.byPlannerModel).sort(([a], [b]) => a.localeCompare(b));
+    if (rejectionEntries.length === 0) {
+        lines.push('    (none)');
+    }
+    else {
+        for (const [model, count] of rejectionEntries) {
+            lines.push(`    ${model}: ${count}`);
+        }
+    }
+    lines.push('  Scope regressions:');
+    lines.push(`    Detected: ${report.history.scopeRegressions.detected}`);
+    lines.push(`    Verification passed at detection: ${report.history.scopeRegressions.verificationPassedAtDetection}`);
+    lines.push(`    Verification failed at detection: ${report.history.scopeRegressions.verificationFailedAtDetection}`);
+    lines.push(`    Recertified by human: ${report.history.scopeRegressions.recertifiedByHuman}`);
+    lines.push(`    Requeued for agent: ${report.history.scopeRegressions.requeuedForAgent}`);
+    const scopeSeries = report.history.sizes.scopeFileSeries;
+    const legacySeries = scopeSeries.find((entry) => entry.resolver === 'legacy');
+    const resolver2Series = scopeSeries.find((entry) => entry.resolver === 'resolver-2');
+    lines.push('  Size by scope files (legacy):');
+    lines.push(...formatSizeBucketLines(legacySeries?.byScopeFiles ?? []));
+    lines.push('  Size by scope files (resolver-2):');
+    lines.push(...formatSizeBucketLines(resolver2Series?.byScopeFiles ?? []));
+    lines.push(`  Resolver 2 starts at: ${resolver2Series?.startsAtChange ?? 'unavailable'}`);
+    lines.push('  Size by acceptance lines:');
+    lines.push(...formatSizeBucketLines(report.history.sizes.byAcceptanceLines));
+    const largestPass = selectHintSeries(scopeSeries)?.largestFirstAttemptPass ?? null;
+    if (largestPass) {
+        const matching = [];
+        if (Math.abs(config.limits.maxScopeFiles - largestPass.scopeFiles) <= 1) {
+            matching.push(`scope files ${largestPass.scopeFiles} is within 1 of configured maxScopeFiles ${config.limits.maxScopeFiles}`);
+        }
+        if (Math.abs(config.limits.maxAcceptanceLines - largestPass.acceptanceLines) <= 1) {
+            matching.push(`acceptance lines ${largestPass.acceptanceLines} is within 1 of configured maxAcceptanceLines ${config.limits.maxAcceptanceLines}`);
+        }
+        if (matching.length > 0) {
+            lines.push(`  Size hint: largest first-attempt pass ${largestPass.change}/${largestPass.task} — ${matching.join('; ')}`);
+        }
+    }
+    lines.push('');
+    lines.push('Coverage:');
+    lines.push(`  Tasks with event files: ${report.coverage.withEvents}`);
+    lines.push(`  Tasks without event files: ${report.coverage.withoutEvents}`);
+    lines.push('');
+    lines.push('Planning:');
+    lines.push(`  Sessions: ${report.planning.sessions}`);
+    lines.push(`  Total wall time: ${formatDuration(report.planning.wallSeconds * 1000)}`);
+    lines.push('  Wall time by change:');
+    const wallEntries = Object.entries(report.planning.wallSecondsByChange).sort(([a], [b]) => a.localeCompare(b));
+    if (wallEntries.length === 0) {
+        lines.push('    (none)');
+    }
+    else {
+        for (const [change, seconds] of wallEntries) {
+            lines.push(`    ${change}: ${formatDuration(seconds * 1000)}`);
+        }
+    }
+    lines.push(`  Input tokens: ${report.planning.tokens.input}`);
+    lines.push(`  Output tokens: ${report.planning.tokens.output}`);
+    lines.push(`  Cached tokens: ${report.planning.tokens.cached}`);
+    lines.push(`  Reasoning tokens: ${report.planning.tokens.reasoning}`);
+    lines.push(`  Harness-reported cost: ${report.planning.cost.formattedTotal}`);
+    lines.push(`  ${report.planning.coverage.reportedSessions} of ${report.planning.coverage.totalSessions} sessions reported usage`);
+    lines.push(`  ${report.planning.changesWithPlanningRecords} changes have a planning record`);
+    const planningChangeEntries = Object.entries(report.planning.byChange).sort(([a], [b]) => a.localeCompare(b));
+    // A repository with no planning at all prints only the totals above; the
+    // per-change and comparison sections need at least one planning record.
+    if (report.planning.sessions > 0 || planningChangeEntries.length > 0) {
+        lines.push('');
+        lines.push('Planning by change:');
+        if (planningChangeEntries.length === 0) {
+            lines.push('  (none)');
+        }
+        else {
+            for (const [change, entry] of planningChangeEntries) {
+                lines.push(`  ${change}: ${formatPlanningChangeLine(entry)}`);
+            }
+        }
+        lines.push('Planning vs execution:');
+        const planningSide = report.planning.comparison.planning;
+        const executionSide = report.planning.comparison.execution;
+        lines.push(`  Input tokens: planning ${formatComparisonToken(planningSide.input)}, execution ${formatComparisonToken(executionSide.input)}`);
+        lines.push(`  Output tokens: planning ${formatComparisonToken(planningSide.output)}, execution ${formatComparisonToken(executionSide.output)}`);
+        lines.push(`  Cached tokens: planning ${formatComparisonToken(planningSide.cached)}, execution ${formatComparisonToken(executionSide.cached)}`);
+        lines.push(`  Reasoning tokens: planning ${formatComparisonToken(planningSide.reasoning)}, execution ${formatComparisonToken(executionSide.reasoning)}`);
+        lines.push(`  Cost: planning ${formatComparisonCost(planningSide.cost)}, execution ${formatComparisonCost(executionSide.cost)}`);
+    }
+    lines.push('');
+    lines.push('Approval flags:');
+    lines.push(...formatApprovalFlagOutcomes(report.approvalFlags));
+    lines.push('');
+    lines.push('Cycle:');
+    const cyclePhaseLines = [
+        ['Brief to approval', report.cycle.phases.briefToApproval],
+        ['Approval to first task', report.cycle.phases.approvalToFirstTask],
+        ['First task to archive', report.cycle.phases.firstTaskToArchive],
+        ['Total', report.cycle.phases.total],
+    ];
+    for (const [label, phase] of cyclePhaseLines) {
+        lines.push(`  ${label}: total ${formatDuration(phase.totalSeconds * 1000)}, average ${formatDuration(phase.averageSeconds * 1000)} (${phase.coveredChanges} of ${phase.totalChanges} archived changes)`);
+    }
+    lines.push('');
+    lines.push('Queue:');
+    const queue = report.queue;
+    if (!queue?.configured) {
+        lines.push('  (not configured)');
+    }
+    else {
+        lines.push(`  Landed: ${queue.landed} of ${queue.total} items`);
+        const queueCost = formatReportedCost(queue.planning.cost, queuePlanningCostReported(queue) ? 1 : 0);
+        lines.push(`  Planning sessions: ${queue.planning.sessions}, recorded cost: ${queueCost}`);
+        lines.push(`  Cost coverage: ${queue.planning.costCoverageComplete ? 'complete' : 'incomplete'}`);
+        lines.push('  Covered item wall times:');
+        const timedItems = queue.items.filter((item) => item.plannedToLandedSeconds !== null);
+        if (timedItems.length === 0) {
+            lines.push('    (none)');
+        }
+        else {
+            for (const item of timedItems) {
+                lines.push(`    ${item.slug}: ${formatDuration(item.plannedToLandedSeconds * 1000)}`);
+            }
+        }
+        lines.push('  Active failures:');
+        if (queue.failures.length === 0) {
+            lines.push('    (none)');
+        }
+        else {
+            for (const failure of queue.failures) {
+                lines.push(`    ${failure.change} ${failure.target} (reason: ${failure.reason})`);
+            }
+        }
+        lines.push('  Retained rejections:');
+        if (queue.rejections.length === 0) {
+            lines.push('    (none)');
+        }
+        else {
+            for (const rejection of queue.rejections) {
+                lines.push(`    ${rejection.slug} ${rejection.change} (reason: ${rejection.reason}, at: ${rejection.timestamp ?? 'unavailable'})`);
+            }
+        }
+    }
+    lines.push('');
+    lines.push('Execution Durations:');
+    lines.push(`  Total duration: ${report.durations.formattedTotal}`);
+    lines.push(`  Average duration: ${report.durations.formattedAvg}`);
+    lines.push('');
+    lines.push('Token Usage:');
+    lines.push(`  Input: ${report.tokens.input}`);
+    lines.push(`  Cached input: ${report.tokens.cached_input} (${report.tokens.cacheSharePercent}% cache share)`);
+    lines.push(`  Output: ${report.tokens.output}`);
+    lines.push(`  Reasoning: ${report.tokens.reasoning}`);
+    lines.push(`  Total tokens: ${report.tokens.total}`);
+    lines.push('');
+    lines.push('File Changes:');
+    lines.push(`  Total change events: ${report.fileChanges.totalChanges}`);
+    lines.push(`  Unique files modified: ${report.fileChanges.uniqueCount}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=report.js.map