@matteeh/osq 0.2.1 → 0.2.2

package/dist/core/report/report.js

@@ -1,16 +1,26 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { DEFAULT_CONFIG } from '../foundation/config.js';
+import { readManifestApprovedAt } from '../run/manifest-approval.js';
 import { parseFrontmatter, parseTaskMd } from '../spec/parser.js';
-import { getArchiveDir, getChangesDir, getRejectedDir } from '../status/layout.js';
+import { changeTrees, listChanges } from '../status/change-locations.js';
 import { readQueueReport } from '../status/queue-report.js';
 import { compareNumericPrefix, deriveSpecState } from '../status/state.js';
 import { collectApprovalFlagOutcomes, formatApprovalFlagOutcomes, } from './approval-flags.js';
+import { readBriefToApprovalSeconds } from './brief-to-approval.js';
 import { buildPlanningComparison, computePlanningByChange, } from './planning-economics.js';
 import { readPlanningSessions } from './planning.js';
+import { collectDisclosures, formatDisclosures, } from './record-disclosures.js';
+import { collectCostBySource, formatPlanningCostBySource, } from './record-estimates.js';
+import { collectRework, formatRework } from './record-rework.js';
+import { collectVerificationCounts, formatVerificationCounts, } from './record-verification.js';
+import { collectDependencies, formatDependencies, } from './report-dependencies.js';
 import { asData, eventTimestampMs, observeAttempts, observeTaskStream, parseEventLines, parseTokenEvent, } from './report-events.js';
+import { collectMutationScores, formatMutation, } from './report-mutation.js';
 import { observePreSpawnEvents } from './report-pre-spawn.js';
 import { addRetryHistory, emptyRetryHistory, observeRetries, } from './report-retries.js';
+import { collectTraceabilityGaps, formatTraceability, } from './report-traceability.js';
+import { taskScopeSize } from './scope-size.js';
 export function formatDuration(ms) {
     if (ms <= 0)
         return '0s';
@@ -123,7 +133,7 @@ async function readTaskMetadata(folderPath, taskNumber) {
  * start-to-end pairs and is null when no pair completes.
  */
 function deriveMeasuredTask(change, task, events) {
-    let scopeFiles = null;
+    let startScopeFiles = null;
     let scopeResolver;
     let pendingStartMs = null;
     let coveredMs = 0;
@@ -134,11 +144,11 @@ function deriveMeasuredTask(change, task, events) {
         const data = asData(event);
         if (data?.phase === 'start') {
             const rawScopeFiles = data.scopeFiles;
-            if (scopeFiles === null &&
+            if (startScopeFiles === null &&
                 typeof rawScopeFiles === 'number' &&
                 Number.isFinite(rawScopeFiles) &&
                 rawScopeFiles >= 0) {
-                scopeFiles = rawScopeFiles;
+                startScopeFiles = rawScopeFiles;
                 scopeResolver = data.scopeResolver;
             }
             pendingStartMs = eventTimestampMs(event);
@@ -152,14 +162,14 @@ function deriveMeasuredTask(change, task, events) {
             pendingStartMs = null;
         }
     }
-    if (scopeFiles === null)
+    if (startScopeFiles === null)
         return null;
     const { attempts, firstAttemptPass } = observeAttempts(events);
     return {
         change,
         task,
         scopeResolver,
-        scopeFiles,
+        scopeFiles: taskScopeSize(events, startScopeFiles),
         attempts,
         firstAttemptPass,
         durationSeconds: hasDuration ? coveredMs / 1000 : null,
@@ -304,45 +314,16 @@ function formatSizeBucketLines(rows) {
     }
     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. */
+/**
+ * Trusted manifest `approvedAt` in milliseconds: the value counts only when the
+ * change folder holds `.run/approved`. Null when missing, untrusted, or invalid.
+ */
 async function readApprovedAtMs(folderPath) {
-    const content = await fs
-        .readFile(path.join(folderPath, '.run', 'manifest.json'), 'utf8')
-        .catch(() => null);
-    if (content === null)
+    const approvedAt = await readManifestApprovedAt(folderPath);
+    if (approvedAt === 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;
-    }
+    const ms = Date.parse(approvedAt);
+    return Number.isFinite(ms) ? ms : null;
 }
 /**
  * Earliest `started` event timestamp across numeric `<n>.jsonl` task streams.
@@ -455,62 +436,78 @@ function aggregatePhase(rows, key) {
     };
 }
 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 [tree] = await changeTrees(projectRoot, config);
+    let specsDir = tree.changesDir;
+    let archiveDir = tree.archiveDir;
+    let rejectedDir = tree.rejectedDir;
     const specsDirStat = await fs.stat(specsDir).catch(() => null);
     const archiveDirStat = await fs.stat(archiveDir).catch(() => null);
+    let legacy = false;
     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) {
+            legacy = true;
             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);
+    const archivedFolders = [];
+    let rejectedFolders = [];
+    if (legacy) {
+        // 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);
+        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 = [];
+        }
+        for (const folder of archiveEntries) {
+            if (folder.startsWith('_') || folder.startsWith('.'))
+                continue;
+            const fullPath = path.join(archiveDir, folder);
+            const stat = await fs.stat(fullPath).catch(() => null);
+            if (stat?.isDirectory())
+                archivedFolders.push(fullPath);
+        }
+        rejectedFolders = await listRejectedFolders(rejectedDir);
     }
-    // 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);
+    else {
+        for (const change of await listChanges(projectRoot, config)) {
+            if (change.location === 'active')
+                activeFolders.push(change.folderPath);
+            else if (change.location === 'archived')
+                archivedFolders.push(change.folderPath);
+            else
+                rejectedFolders.push(change.folderPath);
         }
     }
     const allSpecFolders = [...activeFolders, ...archivedFolders];
@@ -519,7 +516,7 @@ export async function getMetricsReport(projectRoot, config = DEFAULT_CONFIG) {
     // other aggregate. A folder counts once, only with a valid `rejected` event.
     let rejectionTotal = 0;
     const rejectionsByPlanner = {};
-    for (const folderPath of await listRejectedFolders(rejectedDir)) {
+    for (const folderPath of rejectedFolders) {
         if (!(await hasRejectedEvent(folderPath)))
             continue;
         rejectionTotal++;
@@ -637,6 +634,7 @@ export async function getMetricsReport(projectRoot, config = DEFAULT_CONFIG) {
     let scopeVerificationPassed = 0;
     let scopeVerificationFailed = 0;
     let scopeRecertifiedByHuman = 0;
+    let scopeRecertifiedAutomatically = 0;
     let scopeRequeuedForAgent = 0;
     let withEventsCount = 0;
     let withoutEventsCount = 0;
@@ -688,6 +686,7 @@ export async function getMetricsReport(projectRoot, config = DEFAULT_CONFIG) {
         scopeVerificationPassed += observation.scopeVerificationPassed;
         scopeVerificationFailed += observation.scopeVerificationFailed;
         scopeRecertifiedByHuman += observation.scopeRecertifiedByHuman;
+        scopeRecertifiedAutomatically += observation.scopeRecertifiedAutomatically;
         scopeRequeuedForAgent += observation.scopeRequeuedForAgent;
         attemptsByTask[task.id] = taskAttempts;
         if (taskAttempts > 1)
@@ -872,11 +871,10 @@ export async function getMetricsReport(projectRoot, config = DEFAULT_CONFIG) {
     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 briefToApprovalSeconds = await readBriefToApprovalSeconds(folderPath);
         const approvalToFirstTaskSeconds = phaseSeconds(approvedMs, firstStartMs);
         const firstTaskToArchiveSeconds = phaseSeconds(firstStartMs, archivedMs);
         const totalSeconds = briefToApprovalSeconds !== null &&
@@ -909,7 +907,14 @@ export async function getMetricsReport(projectRoot, config = DEFAULT_CONFIG) {
     const formattedTotal = formatDuration(totalDurationMs);
     const formattedAvg = formatDuration(avgDurationMs);
     const queue = await readQueueReport(projectRoot, config);
-    const approvalFlags = await collectApprovalFlagOutcomes(allSpecFolders);
+    const rework = await collectRework(allSpecFolders);
+    const approvalFlags = await collectApprovalFlagOutcomes(allSpecFolders, rework);
+    const disclosures = await collectDisclosures(allSpecFolders);
+    const dependencies = await collectDependencies(allSpecFolders);
+    const verification = await collectVerificationCounts(archivedFolders);
+    const planningCostBySource = await collectCostBySource(allSpecFolders, config.planning?.prices);
+    const traceability = await collectTraceabilityGaps(projectRoot, config);
+    const mutation = await collectMutationScores(allSpecFolders, config);
     const measuredTasks = await projectMeasuredTasks(allSpecFolders);
     const sizes = {
         scopeFileSeries: deriveScopeFileSeries(measuredTasks),
@@ -984,8 +989,13 @@ export async function getMetricsReport(projectRoot, config = DEFAULT_CONFIG) {
                 verificationPassedAtDetection: scopeVerificationPassed,
                 verificationFailedAtDetection: scopeVerificationFailed,
                 recertifiedByHuman: scopeRecertifiedByHuman,
+                recertifiedAutomatically: scopeRecertifiedAutomatically,
                 requeuedForAgent: scopeRequeuedForAgent,
             },
+            rework,
+            disclosures,
+            ...(dependencies.length > 0 ? { dependencies } : {}),
+            ...(verification ? { verification } : {}),
         },
         coverage: {
             withEvents: withEventsCount,
@@ -1034,6 +1044,7 @@ export async function getMetricsReport(projectRoot, config = DEFAULT_CONFIG) {
                 total: planningCost,
                 formattedTotal: formatReportedCost(planningCost, planningCostReportedSessions),
                 provenance: 'harness-reported',
+                bySource: planningCostBySource,
             },
             coverage: {
                 reportedSessions: planningReportedSessions,
@@ -1043,6 +1054,8 @@ export async function getMetricsReport(projectRoot, config = DEFAULT_CONFIG) {
             comparison: planningComparison,
         },
         queue,
+        ...(traceability ? { traceability } : {}),
+        ...(mutation ? { mutation } : {}),
     };
 }
 /**
@@ -1057,25 +1070,9 @@ 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) => {
+/** Newest archived folders first by numeric prefix, capped at `limit`. */
+function listRecentArchiveFolders(folders, limit) {
+    const sorted = [...folders].sort((a, b) => {
         const nameA = path.basename(a);
         const nameB = path.basename(b);
         const numA = numericPrefix(nameA);
@@ -1091,7 +1088,7 @@ async function listRecentArchiveFolders(archiveDir, limit) {
             return 1;
         return nameA.localeCompare(nameB);
     });
-    return folders.slice(0, limit);
+    return sorted.slice(0, limit);
 }
 /** Every typed `dead` event in the window, in change/task/event order. */
 async function collectDeadOutcomes(folders) {
@@ -1132,8 +1129,8 @@ async function collectDeadOutcomes(folders) {
  * 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 archived = await listChanges(projectRoot, config, ['archived']);
+    const folders = listRecentArchiveFolders(archived.map((change) => change.folderPath), REPOSITORY_RECORD_MAX_ARCHIVED_CHANGES);
     const measured = await projectMeasuredTasks(folders);
     const deadOutcomes = await collectDeadOutcomes(folders);
     const passed = measured.filter((task) => task.firstAttemptPass).length;
@@ -1150,7 +1147,7 @@ export async function getRepositoryRecord(projectRoot, config = DEFAULT_CONFIG)
     const scopeFileResolver = scopeTasks.length > 0 ? (useResolver2 ? 'resolver-2' : 'legacy') : null;
     return {
         measuredTasks: measured.length,
-        firstAttemptPassRate: measured.length > 0 ? round2(passed / measured.length) : 0,
+        firstAttemptPasses: passed,
         medianDurationSeconds: medianSeconds(durations),
         largestFirstAttemptPass: selectLargestFirstAttemptPass(scopeTasks),
         scopeFileResolver,
@@ -1166,7 +1163,7 @@ export function formatRepositoryRecordBody(record) {
         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}`);
+    lines.push(`First-attempt passes: ${record.firstAttemptPasses}/${record.measuredTasks}`);
     const largest = record.largestFirstAttemptPass;
     if (largest) {
         const scopeLabel = record.scopeFileResolver === 'legacy'
@@ -1275,7 +1272,16 @@ export function formatMetricsReport(report, config = DEFAULT_CONFIG) {
     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(`    Recertified automatically: ${report.history.scopeRegressions.recertifiedAutomatically}`);
     lines.push(`    Requeued for agent: ${report.history.scopeRegressions.requeuedForAgent}`);
+    lines.push(...formatRework(report.history.rework ?? []));
+    lines.push(...formatDisclosures(report.history.disclosures ?? []));
+    if ((report.history.dependencies ?? []).length > 0) {
+        lines.push(...formatDependencies(report.history.dependencies ?? []));
+    }
+    if (report.history.verification) {
+        lines.push(formatVerificationCounts(report.history.verification));
+    }
     const scopeSeries = report.history.sizes.scopeFileSeries;
     const legacySeries = scopeSeries.find((entry) => entry.resolver === 'legacy');
     const resolver2Series = scopeSeries.find((entry) => entry.resolver === 'resolver-2');
@@ -1299,6 +1305,14 @@ export function formatMetricsReport(report, config = DEFAULT_CONFIG) {
             lines.push(`  Size hint: largest first-attempt pass ${largestPass.change}/${largestPass.task} — ${matching.join('; ')}`);
         }
     }
+    if (report.traceability) {
+        lines.push('');
+        lines.push(...formatTraceability(report.traceability));
+    }
+    if (report.mutation) {
+        lines.push('');
+        lines.push(...formatMutation(report.mutation));
+    }
     lines.push('');
     lines.push('Coverage:');
     lines.push(`  Tasks with event files: ${report.coverage.withEvents}`);
@@ -1322,6 +1336,7 @@ export function formatMetricsReport(report, config = DEFAULT_CONFIG) {
     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(...formatPlanningCostBySource(report.planning.cost.bySource));
     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));
@@ -1359,6 +1374,10 @@ export function formatMetricsReport(report, config = DEFAULT_CONFIG) {
         ['Total', report.cycle.phases.total],
     ];
     for (const [label, phase] of cyclePhaseLines) {
+        if (phase.coveredChanges === 0) {
+            lines.push(`  ${label}: not reported (0 of ${phase.totalChanges} archived changes)`);
+            continue;
+        }
         lines.push(`  ${label}: total ${formatDuration(phase.totalSeconds * 1000)}, average ${formatDuration(phase.averageSeconds * 1000)} (${phase.coveredChanges} of ${phase.totalChanges} archived changes)`);
     }
     lines.push('');