@sentry/warden 0.20.0 → 0.22.0

package/dist/cli/output/jsonl.js

@@ -1,9 +1,10 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname, join, resolve } from 'node:path';
 import { z } from 'zod';
-import { UsageStatsSchema, FindingSchema, SkippedFileSchema, AuxiliaryUsageMapSchema, FixStatusSchema, } from '../../types/index.js';
+import { UsageStatsSchema, SkillReportSchema, FileReportSchema, FindingSchema, AuxiliaryUsageMapSchema, FixStatusSchema, isExtractionErrorCode, SkillErrorSchema, SkippedFileSchema, } from '../../types/index.js';
 import { mergeAuxiliaryUsage } from '../../sdk/usage.js';
+import { logger } from '../../sentry.js';
 import { countBySeverity } from './formatters.js';
 /**
  * Sentinel value recorded in JSONL metadata when no model is explicitly configured.
@@ -35,6 +36,16 @@ export function getRepoLogPath(repoRoot, runId, timestamp = new Date()) {
  * Formal JSON Schema: specs/jsonl-schema.json
  * Example payloads:   specs/jsonl-examples.jsonl
  * Reporter spec:      specs/reporters.md Section 3 "JSONL Specification"
+ *
+ * BACKWARD COMPATIBILITY: breaking on-disk JSONL log formats is NEVER
+ * ALLOWED. Users keep .warden/logs/*.jsonl across versions. The schema
+ * may evolve — new optional fields, additive enum values, normalization
+ * — but every historical shape must continue to parse cleanly. Field
+ * renames require a preprocess that maps the old name to the new one
+ * (see FileReportSchema's `findingCount → findings` preprocess in
+ * src/types/index.ts). Removing a field is fine; making it optional in
+ * the schema preserves old logs. If you can't reconcile an old shape
+ * with a preprocess, the change is wrong — find a different path.
  */
 /** Metadata common to every JSONL record. */
 export const JsonlRunMetadataSchema = z.object({
@@ -46,44 +57,64 @@ export const JsonlRunMetadataSchema = z.object({
     model: z.string().optional(),
     headSha: z.string().optional(),
 });
-/** Per-file breakdown within a skill record. */
-export const JsonlFileRecordSchema = z.object({
-    filename: z.string(),
-    findings: z.number().int().nonnegative(),
-    durationMs: z.number().nonnegative().optional(),
-    usage: UsageStatsSchema.optional(),
-});
-/** One skill's analysis results. */
-export const JsonlRecordSchema = z.object({
+/** Per-file breakdown within a skill record (re-exported from shared types). */
+export const JsonlFileRecordSchema = FileReportSchema;
+/** Unit of work scanned by Warden. New run logs contain only this record type. */
+export const JsonlChunkRecordSchema = z.object({
+    schemaVersion: z.literal(1),
     run: JsonlRunMetadataSchema,
     skill: z.string(),
-    summary: z.string(),
-    findings: z.array(FindingSchema),
-    metadata: z.record(z.string(), z.unknown()).optional(),
     model: z.string().optional(),
-    durationMs: z.number().nonnegative().optional(),
+    chunk: z.object({
+        file: z.string(),
+        index: z.number().int().positive(),
+        total: z.number().int().positive(),
+        lineRange: z.string(),
+    }),
+    status: z.enum(['ok', 'error', 'skipped']),
+    findings: z.array(FindingSchema),
     usage: UsageStatsSchema.optional(),
+    durationMs: z.number().nonnegative(),
     auxiliaryUsage: AuxiliaryUsageMapSchema.optional(),
-    files: z.array(JsonlFileRecordSchema).optional(),
+    error: SkillErrorSchema.optional(),
     skippedFiles: z.array(SkippedFileSchema).optional(),
-    failedHunks: z.number().int().nonnegative().optional(),
-    failedExtractions: z.number().int().nonnegative().optional(),
+});
+/**
+ * One skill's analysis results. This is the shared SkillReport plus a `run`
+ * block of run-wide metadata, so any new SkillReport field is automatically
+ * part of the JSONL contract without a parallel schema.
+ */
+export const JsonlRecordSchema = SkillReportSchema.extend({
+    run: JsonlRunMetadataSchema,
+});
+/** Normalized output shape — what we emit. */
+const BySeverityOutputSchema = z.object({
+    high: z.number().int().nonnegative(),
+    medium: z.number().int().nonnegative(),
+    low: z.number().int().nonnegative(),
 });
 /**
  * Severity breakdown in the summary record.
- * Uses a transform to normalize legacy keys ('critical' → 'high', 'info' → 'low')
- * so old JSONL logs parse correctly. Accepts any string keys to handle old 5-level logs.
+ *
+ * Parse-time accepts any string keys (legacy logs may emit 5-level severities
+ * like 'critical'/'info'); a transform normalizes 'critical' → 'high' and
+ * 'info' → 'low' and drops unknown keys. The piped output shape is the
+ * strict `{ high, medium, low }` triple we emit going forward, so
+ * JSON-Schema derivation describes the output contract (not the lax input).
  */
-const BySeveritySchema = z.record(z.string(), z.number().int().nonnegative()).transform((obj) => {
-    const result = {};
+const BySeveritySchema = z
+    .record(z.string(), z.number().int().nonnegative())
+    .transform((obj) => {
+    const result = { high: 0, medium: 0, low: 0 };
     for (const [key, value] of Object.entries(obj)) {
         const normalized = key === 'critical' ? 'high' : key === 'info' ? 'low' : key;
         if (normalized === 'high' || normalized === 'medium' || normalized === 'low') {
-            result[normalized] = (result[normalized] ?? 0) + value;
+            result[normalized] += value;
         }
     }
     return result;
-});
+})
+    .pipe(BySeverityOutputSchema);
 /** Aggregate summary across all skills (always the last JSONL line). */
 export const JsonlSummaryRecordSchema = z.object({
     run: JsonlRunMetadataSchema,
@@ -93,6 +124,15 @@ export const JsonlSummaryRecordSchema = z.object({
     usage: UsageStatsSchema.optional(),
     totalSkippedFiles: z.number().int().nonnegative().optional(),
     auxiliaryUsage: AuxiliaryUsageMapSchema.optional(),
+    failedSkills: z.array(z.string()).optional(),
+    totalFailedHunks: z.number().int().nonnegative().optional(),
+    totalFailedExtractions: z.number().int().nonnegative().optional(),
+    /**
+     * Top-level run error captured before any skill ran (e.g. auth failure,
+     * config load error). Skill-level errors live on the SkillRecord; this
+     * is for failures that prevent the per-skill loop from starting.
+     */
+    error: SkillErrorSchema.optional(),
 });
 /** Per-evaluation detail for fix evaluation records. */
 export const JsonlFixEvalDetailSchema = z.object({
@@ -132,59 +172,104 @@ function aggregateUsage(reports) {
     }));
 }
 /**
- * Render skill reports as a JSONL string.
- * Each line contains one skill report with run metadata.
- * A final summary line is appended at the end.
+ * Build a JSONL run metadata block. `durationMs` is a snapshot at write
+ * time for skill records, the run total on the trailing summary record.
  */
-export function renderJsonlString(reports, durationMs, options) {
-    const timestamp = (options?.timestamp ?? new Date()).toISOString();
-    const cwd = options?.cwd ?? process.cwd();
-    const runMetadata = {
-        timestamp,
-        durationMs,
-        cwd,
-        runId: options?.runId ?? generateRunId(),
-        traceId: options?.traceId,
-        model: options?.model,
-        headSha: options?.headSha,
+export function buildRunMetadata(options) {
+    return {
+        timestamp: (options.timestamp ?? new Date()).toISOString(),
+        durationMs: options.durationMs,
+        cwd: options.cwd ?? process.cwd(),
+        runId: options.runId,
+        traceId: options.traceId,
+        model: options.model,
+        headSha: options.headSha,
     };
-    const lines = [];
-    for (const report of reports) {
-        const record = {
-            run: runMetadata,
-            skill: report.skill,
-            summary: report.summary,
-            findings: report.findings,
-            metadata: report.metadata,
-            model: report.model,
-            durationMs: report.durationMs,
-            usage: report.usage,
-            auxiliaryUsage: report.auxiliaryUsage,
-            files: report.files?.map((f) => ({
-                filename: f.filename,
-                findings: f.findingCount,
-                durationMs: f.durationMs,
-                usage: f.usage,
-            })),
-            skippedFiles: report.skippedFiles?.length ? report.skippedFiles : undefined,
-            failedHunks: report.failedHunks || undefined,
-            failedExtractions: report.failedExtractions || undefined,
-        };
-        lines.push(JSON.stringify(record));
-    }
+}
+/** Build a skill JSONL record, dropping zero-valued optional fields. */
+export function buildSkillJsonlRecord(report, run) {
+    const trimmed = {
+        ...report,
+        skippedFiles: report.skippedFiles?.length ? report.skippedFiles : undefined,
+        failedHunks: report.failedHunks || undefined,
+        failedExtractions: report.failedExtractions || undefined,
+        hunkFailures: report.hunkFailures?.length ? report.hunkFailures : undefined,
+    };
+    return { ...trimmed, run };
+}
+/** Build the aggregate summary JSONL record. */
+export function buildSummaryJsonlRecord(reports, run, error) {
     const allFindings = reports.flatMap((r) => r.findings);
     const totalSkippedFiles = reports.reduce((n, r) => n + (r.skippedFiles?.length ?? 0), 0);
     const totalAuxiliaryUsage = reports.reduce((acc, r) => mergeAuxiliaryUsage(acc, r.auxiliaryUsage), undefined);
-    const summaryRecord = {
-        run: runMetadata,
+    const failedSkills = reports.filter((r) => r.error).map((r) => r.skill);
+    const totalFailedHunks = reports.reduce((n, r) => n + (r.failedHunks ?? 0), 0);
+    const totalFailedExtractions = reports.reduce((n, r) => n + (r.failedExtractions ?? 0), 0);
+    return {
+        run,
         type: 'summary',
         totalFindings: allFindings.length,
         bySeverity: countBySeverity(allFindings),
         usage: aggregateUsage(reports),
         totalSkippedFiles: totalSkippedFiles > 0 ? totalSkippedFiles : undefined,
         auxiliaryUsage: totalAuxiliaryUsage,
+        failedSkills: failedSkills.length > 0 ? failedSkills : undefined,
+        totalFailedHunks: totalFailedHunks > 0 ? totalFailedHunks : undefined,
+        totalFailedExtractions: totalFailedExtractions > 0 ? totalFailedExtractions : undefined,
+        error,
     };
-    lines.push(JSON.stringify(summaryRecord));
+}
+/** Render a single skill JSONL record as one line including trailing newline. */
+export function renderJsonlSkillLine(report, run) {
+    return JSON.stringify(buildSkillJsonlRecord(report, run)) + '\n';
+}
+/** Render the summary JSONL record as one line including trailing newline. */
+export function renderJsonlSummaryLine(reports, run, error) {
+    return JSON.stringify(buildSummaryJsonlRecord(reports, run, error)) + '\n';
+}
+/** Render one chunk result record as one JSONL line. */
+export function renderJsonlChunkLine(record) {
+    return JSON.stringify(JsonlChunkRecordSchema.parse(record)) + '\n';
+}
+export function renderJsonlChunkRecords(records) {
+    return records.map((record) => renderJsonlChunkLine(record)).join('');
+}
+/** Create parent dirs and truncate the file to empty. */
+export function initJsonlFile(outputPath) {
+    const resolvedPath = resolve(process.cwd(), outputPath);
+    mkdirSync(dirname(resolvedPath), { recursive: true });
+    writeFileSync(resolvedPath, '');
+}
+/**
+ * Append a pre-rendered line (must include its trailing newline).
+ * This uses one synchronous append call so parallel skill callbacks in this
+ * process cannot interleave partial JSON records.
+ */
+export function appendJsonlLine(outputPath, line) {
+    const resolvedPath = resolve(process.cwd(), outputPath);
+    mkdirSync(dirname(resolvedPath), { recursive: true });
+    appendFileSync(resolvedPath, line);
+}
+/**
+ * Render skill reports as a JSONL string.
+ * Each line contains one skill report with run metadata.
+ * A final summary line is appended at the end.
+ */
+export function renderJsonlString(reports, durationMs, options) {
+    const runMetadata = buildRunMetadata({
+        runId: options?.runId ?? generateRunId(),
+        durationMs,
+        timestamp: options?.timestamp,
+        traceId: options?.traceId,
+        model: options?.model,
+        headSha: options?.headSha,
+        cwd: options?.cwd,
+    });
+    const lines = [];
+    for (const report of reports) {
+        lines.push(JSON.stringify(buildSkillJsonlRecord(report, runMetadata)));
+    }
+    lines.push(JSON.stringify(buildSummaryJsonlRecord(reports, runMetadata, options?.error)));
     return lines.join('\n') + '\n';
 }
 /**
@@ -210,14 +295,125 @@ export function writeJsonlContent(outputPath, content) {
 export function readJsonlLog(logPath) {
     return readFileSync(logPath, 'utf-8');
 }
+function summarizeFindings(skill, findings) {
+    if (findings.length === 0)
+        return `${skill}: No issues found`;
+    const counts = countBySeverity(findings);
+    const parts = [
+        counts.high ? `${counts.high} high` : undefined,
+        counts.medium ? `${counts.medium} medium` : undefined,
+        counts.low ? `${counts.low} low` : undefined,
+    ].filter(Boolean);
+    return `${skill}: Found ${findings.length} ${findings.length === 1 ? 'issue' : 'issues'} (${parts.join(', ')})`;
+}
+function addUsage(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return {
+        inputTokens: a.inputTokens + b.inputTokens,
+        outputTokens: a.outputTokens + b.outputTokens,
+        cacheReadInputTokens: (a.cacheReadInputTokens ?? 0) + (b.cacheReadInputTokens ?? 0),
+        cacheCreationInputTokens: (a.cacheCreationInputTokens ?? 0) + (b.cacheCreationInputTokens ?? 0),
+        costUSD: a.costUSD + b.costUSD,
+    };
+}
+function reportsFromChunks(chunks) {
+    const bySkill = new Map();
+    for (const chunk of chunks) {
+        const records = bySkill.get(chunk.skill) ?? [];
+        records.push(chunk);
+        bySkill.set(chunk.skill, records);
+    }
+    const reports = [];
+    for (const [skill, records] of bySkill) {
+        const reportLevelError = records.find(isReportLevelErrorRecord)?.error;
+        const chunkRecords = records.filter((record) => !isReportLevelErrorRecord(record));
+        const aggregateRecords = chunkRecords.length > 0 ? chunkRecords : records;
+        const findings = aggregateRecords.flatMap((r) => r.findings);
+        const usage = aggregateRecords.reduce((acc, r) => addUsage(acc, r.usage), undefined);
+        const auxiliaryUsage = aggregateRecords.reduce((acc, r) => mergeAuxiliaryUsage(acc, r.auxiliaryUsage), undefined);
+        const filesByName = new Map();
+        const hunkFailures = [];
+        const skippedFiles = records.flatMap((r) => r.skippedFiles ?? []);
+        for (const record of aggregateRecords) {
+            const existing = filesByName.get(record.chunk.file);
+            if (record.chunk.file) {
+                filesByName.set(record.chunk.file, {
+                    filename: record.chunk.file,
+                    findings: (existing?.findings ?? 0) + record.findings.length,
+                    durationMs: (existing?.durationMs ?? 0) + record.durationMs,
+                    usage: addUsage(existing?.usage, record.usage),
+                });
+            }
+            if (record.status === 'error' && record.error && !isReportLevelErrorRecord(record)) {
+                hunkFailures.push({
+                    type: isExtractionErrorCode(record.error.code) ? 'extraction' : 'analysis',
+                    filename: record.chunk.file,
+                    lineRange: record.chunk.lineRange,
+                    code: record.error.code,
+                    message: record.error.message,
+                });
+            }
+        }
+        const failedHunks = chunkRecords.filter((r) => r.status === 'error' && r.error && !isExtractionErrorCode(r.error.code)).length;
+        const failedExtractions = chunkRecords.filter((r) => r.status === 'error' && r.error && isExtractionErrorCode(r.error.code)).length;
+        const allChunksFailed = chunkRecords.length > 0 &&
+            findings.length === 0 &&
+            chunkRecords.every((record) => record.status === 'error');
+        const report = {
+            skill,
+            summary: summarizeFindings(skill, findings),
+            findings,
+            durationMs: aggregateRecords.reduce((sum, r) => sum + r.durationMs, 0),
+            usage,
+            files: [...filesByName.values()],
+            model: aggregateRecords.find((r) => r.model)?.model,
+        };
+        if (reportLevelError) {
+            report.error = reportLevelError;
+        }
+        else if (allChunksFailed) {
+            report.error = {
+                code: 'all_hunks_failed',
+                message: `All ${chunkRecords.length} ${chunkRecords.length === 1 ? 'chunk' : 'chunks'} failed to analyze.`,
+            };
+        }
+        if (auxiliaryUsage)
+            report.auxiliaryUsage = auxiliaryUsage;
+        if (failedHunks > 0)
+            report.failedHunks = failedHunks;
+        if (failedExtractions > 0)
+            report.failedExtractions = failedExtractions;
+        if (hunkFailures.length > 0)
+            report.hunkFailures = hunkFailures;
+        if (skippedFiles.length > 0)
+            report.skippedFiles = skippedFiles;
+        reports.push(report);
+    }
+    return reports;
+}
+function isReportLevelErrorRecord(record) {
+    return record.status === 'error' && record.chunk.file === '' && Boolean(record.error);
+}
 export function parseJsonlReports(content) {
     const lines = content.trim().split('\n').filter((line) => line.trim());
     const reports = [];
+    const chunks = [];
     let runMetadata;
     let totalDurationMs = 0;
     for (const line of lines) {
         try {
             const parsed = JSON.parse(line);
+            const chunk = JsonlChunkRecordSchema.safeParse(parsed);
+            if (chunk.success) {
+                chunks.push(chunk.data);
+                if (!runMetadata)
+                    runMetadata = chunk.data.run;
+                totalDurationMs = Math.max(totalDurationMs, chunk.data.run.durationMs);
+                continue;
+            }
             // Skip summary record (but capture metadata from it)
             if (parsed.type === 'summary') {
                 const summary = JsonlSummaryRecordSchema.parse(parsed);
@@ -225,99 +421,141 @@ export function parseJsonlReports(content) {
                 totalDurationMs = summary.run.durationMs;
                 continue;
             }
-            // Parse skill record and convert to SkillReport
-            const record = JsonlRecordSchema.parse(parsed);
-            reports.push({
-                skill: record.skill,
-                summary: record.summary,
-                findings: record.findings,
-                metadata: record.metadata,
-                model: record.model,
-                durationMs: record.durationMs,
-                usage: record.usage,
-                auxiliaryUsage: record.auxiliaryUsage,
-                skippedFiles: record.skippedFiles,
-                failedHunks: record.failedHunks,
-                failedExtractions: record.failedExtractions,
-                files: record.files?.map((f) => ({
-                    filename: f.filename,
-                    findingCount: f.findings,
-                    durationMs: f.durationMs,
-                    usage: f.usage,
-                })),
-            });
+            // Fix-evaluation records are valid JSONL but not SkillReports; let
+            // them pass through silently so we don't warn on every line of a log
+            // that contains them.
+            if (parsed.type === 'fix-evaluation')
+                continue;
+            // A JsonlRecord is a SkillReport + { run }. Strip `run` to get the
+            // SkillReport without rebuilding it field-by-field.
+            const { run, ...report } = JsonlRecordSchema.parse(parsed);
+            reports.push(report);
             // Capture run metadata from first record if no summary yet
             if (!runMetadata) {
-                runMetadata = record.run;
-                totalDurationMs = record.run.durationMs;
+                runMetadata = run;
+                totalDurationMs = run.durationMs;
             }
         }
-        catch {
-            // Skip invalid lines
+        catch (err) {
+            logger.warn('Skipping malformed JSONL line', {
+                error: err instanceof Error ? err.message : String(err),
+            });
         }
     }
-    return { reports, runMetadata, totalDurationMs };
+    return { reports: [...reports, ...reportsFromChunks(chunks)], runMetadata, totalDurationMs };
 }
 /**
- * Parse a JSONL log file for its summary and skill names.
- * Reads all lines but only fully parses the summary; extracts skill names
- * from non-summary lines with minimal parsing.
+ * Parse a JSONL log file's summary, skill names, and high-level metadata.
+ * Returns undefined when the file can't be read or contains no parseable
+ * records; in-progress files (valid records but no summary yet) return
+ * metadata with `inProgress: true`.
  */
 export function parseLogMetadata(filePath) {
+    let content;
     try {
-        const content = readFileSync(filePath, 'utf-8');
-        const lines = content.trim().split('\n');
-        let summary;
-        const skills = [];
-        let model;
-        let headSha;
-        const uniqueFiles = new Set();
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                const parsed = JSON.parse(line);
-                if (parsed.type === 'summary') {
-                    summary = JsonlSummaryRecordSchema.parse(parsed);
-                    // Fall back to summary's run metadata for model/headSha (empty runs have no skill records)
-                    if (!model && parsed.run?.model && typeof parsed.run.model === 'string') {
-                        model = parsed.run.model;
-                    }
-                    if (!headSha && parsed.run?.headSha && typeof parsed.run.headSha === 'string') {
-                        headSha = parsed.run.headSha;
-                    }
+        content = readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+    const lines = content.trim().split('\n').filter((l) => l.trim());
+    let summary;
+    let firstRun;
+    const skills = [];
+    let model;
+    let headSha;
+    const uniqueFiles = new Set();
+    const chunks = [];
+    let recognizedRecords = 0;
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            const chunk = JsonlChunkRecordSchema.safeParse(parsed);
+            if (chunk.success) {
+                chunks.push(chunk.data);
+                recognizedRecords++;
+                if (!skills.includes(chunk.data.skill)) {
+                    skills.push(chunk.data.skill);
                 }
-                else if (parsed.skill && typeof parsed.skill === 'string') {
-                    if (!skills.includes(parsed.skill)) {
-                        skills.push(parsed.skill);
-                    }
-                    // Extract model and headSha from first record's run metadata
-                    if (!model && parsed.run?.model && typeof parsed.run.model === 'string') {
-                        model = parsed.run.model;
-                    }
-                    if (!headSha && parsed.run?.headSha && typeof parsed.run.headSha === 'string') {
-                        headSha = parsed.run.headSha;
-                    }
-                    // Count unique filenames across skill records' files arrays
-                    if (Array.isArray(parsed.files)) {
-                        for (const f of parsed.files) {
-                            if (f && typeof f.filename === 'string') {
-                                uniqueFiles.add(f.filename);
-                            }
+                if (!model && chunk.data.model) {
+                    model = chunk.data.model;
+                }
+                if (!model && chunk.data.run.model) {
+                    model = chunk.data.run.model;
+                }
+                if (!headSha && chunk.data.run.headSha) {
+                    headSha = chunk.data.run.headSha;
+                }
+                if (!firstRun)
+                    firstRun = chunk.data.run;
+                if (chunk.data.chunk.file) {
+                    uniqueFiles.add(chunk.data.chunk.file);
+                }
+            }
+            else if (parsed.type === 'summary') {
+                summary = JsonlSummaryRecordSchema.parse(parsed);
+                recognizedRecords++;
+                if (!model && parsed.run?.model && typeof parsed.run.model === 'string') {
+                    model = parsed.run.model;
+                }
+                if (!headSha && parsed.run?.headSha && typeof parsed.run.headSha === 'string') {
+                    headSha = parsed.run.headSha;
+                }
+                if (!firstRun)
+                    firstRun = summary.run;
+            }
+            else if (parsed.skill && typeof parsed.skill === 'string') {
+                recognizedRecords++;
+                if (!skills.includes(parsed.skill)) {
+                    skills.push(parsed.skill);
+                }
+                if (!model && parsed.run?.model && typeof parsed.run.model === 'string') {
+                    model = parsed.run.model;
+                }
+                if (!headSha && parsed.run?.headSha && typeof parsed.run.headSha === 'string') {
+                    headSha = parsed.run.headSha;
+                }
+                if (!firstRun && parsed.run) {
+                    const runResult = JsonlRunMetadataSchema.safeParse(parsed.run);
+                    if (runResult.success)
+                        firstRun = runResult.data;
+                }
+                if (Array.isArray(parsed.files)) {
+                    for (const f of parsed.files) {
+                        if (f && typeof f.filename === 'string') {
+                            uniqueFiles.add(f.filename);
                         }
                     }
                 }
             }
-            catch {
-                // Skip unparseable lines
-            }
         }
-        if (!summary)
-            return undefined;
-        return { summary, skills, model, headSha, totalFiles: uniqueFiles.size };
+        catch (err) {
+            logger.warn('Skipping malformed JSONL line', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
     }
-    catch {
+    // Empty or fully corrupt files (no parseable records) surface as
+    // "parse error" in the list, not as in-progress runs.
+    if (recognizedRecords === 0 && lines.length > 0)
         return undefined;
+    if (!summary && chunks.length > 0) {
+        const reports = reportsFromChunks(chunks);
+        const lastDuration = chunks.reduce((max, chunk) => Math.max(max, chunk.run.durationMs), 0);
+        const firstChunk = chunks[0];
+        if (!firstChunk)
+            return undefined;
+        const run = { ...(firstRun ?? firstChunk.run), durationMs: lastDuration };
+        summary = buildSummaryJsonlRecord(reports, run);
     }
+    return {
+        summary,
+        inProgress: chunks.length > 0 ? !existsSync(`${filePath}.done`) : !summary && !existsSync(`${filePath}.done`),
+        runMetadata: summary?.run ?? firstRun,
+        skills,
+        model,
+        headSha,
+        totalFiles: uniqueFiles.size,
+    };
 }
 //# sourceMappingURL=jsonl.js.map