@sentry/warden 0.36.1 → 0.38.0

package/dist/cli/output/jsonl.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import type { SkillReport, SkillError } from '../../types/index.js';
+export { JsonlUsageBreakdownEntrySchema, JsonlUsageBreakdownSchema, auxiliaryUsageFromBreakdown, buildJsonlUsageBreakdown, scanUsageFromBreakdown, usageStatsHaveValue, type JsonlUsageBreakdown, type JsonlUsageBreakdownEntry, } from './usage-breakdown.js';
 /**
  * Sentinel value recorded in JSONL metadata when no model is explicitly configured.
  */
@@ -62,7 +63,7 @@ export declare const JsonlFileRecordSchema: z.ZodPreprocess<z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>>;
 export type JsonlFileRecord = z.infer<typeof JsonlFileRecordSchema>;
-/** Unit of work scanned by Warden. New run logs contain only this record type. */
+/** Unit of work scanned by Warden, emitted during streaming and finalization. */
 export declare const JsonlChunkRecordSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     run: z.ZodObject<{
@@ -112,10 +113,6 @@ export declare const JsonlChunkRecordSchema: z.ZodObject<{
             startLine: z.ZodNumber;
             endLine: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>>;
-        suggestedFix: z.ZodOptional<z.ZodObject<{
-            description: z.ZodString;
-            diff: z.ZodString;
-        }, z.core.$strip>>;
         sourceSnippet: z.ZodOptional<z.ZodObject<{
             path: z.ZodString;
             language: z.ZodOptional<z.ZodString>;
@@ -131,27 +128,57 @@ export declare const JsonlChunkRecordSchema: z.ZodObject<{
         }, z.core.$strip>>;
         elapsedMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    usage: z.ZodOptional<z.ZodObject<{
-        inputTokens: z.ZodNumber;
-        outputTokens: z.ZodNumber;
-        cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
-        webSearchRequests: z.ZodOptional<z.ZodNumber>;
-        costUSD: z.ZodNumber;
+    usageBreakdown: z.ZodOptional<z.ZodObject<{
+        scan: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodString>;
+            runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
+                webSearchRequests: z.ZodOptional<z.ZodNumber>;
+                costUSD: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        auxiliary: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodString>;
+            runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
+                webSearchRequests: z.ZodOptional<z.ZodNumber>;
+                costUSD: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        total: z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodString>;
+            runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
+                webSearchRequests: z.ZodOptional<z.ZodNumber>;
+                costUSD: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
     }, z.core.$strip>>;
     durationMs: z.ZodNumber;
-    auxiliaryUsage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        inputTokens: z.ZodNumber;
-        outputTokens: z.ZodNumber;
-        cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
-        webSearchRequests: z.ZodOptional<z.ZodNumber>;
-        costUSD: z.ZodNumber;
-    }, z.core.$strip>>>;
     error: z.ZodOptional<z.ZodObject<{
         code: z.ZodEnum<{
             unknown: "unknown";
@@ -181,6 +208,15 @@ export declare const JsonlChunkRecordSchema: z.ZodObject<{
         reason: z.ZodEnum<{
             pattern: "pattern";
             builtin: "builtin";
+            "ignored:builtin": "ignored:builtin";
+            "ignored:user": "ignored:user";
+            "ignored:generated": "ignored:generated";
+            "limit:file_size": "limit:file_size";
+            "limit:file_lines": "limit:file_lines";
+            "limit:file_read": "limit:file_read";
+            "limit:file_count": "limit:file_count";
+            "limit:changed_lines": "limit:changed_lines";
+            "limit:missing_patch": "limit:missing_patch";
         }>;
         pattern: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
@@ -213,6 +249,7 @@ export declare const JsonlChunkRecordSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type JsonlChunkRecord = z.infer<typeof JsonlChunkRecordSchema>;
+export declare function parseJsonlChunkRecord(value: unknown): JsonlChunkRecord | undefined;
 /**
  * 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
@@ -246,10 +283,6 @@ export declare const JsonlRecordSchema: z.ZodObject<{
             startLine: z.ZodNumber;
             endLine: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>>;
-        suggestedFix: z.ZodOptional<z.ZodObject<{
-            description: z.ZodString;
-            diff: z.ZodString;
-        }, z.core.$strip>>;
         sourceSnippet: z.ZodOptional<z.ZodObject<{
             path: z.ZodString;
             language: z.ZodOptional<z.ZodString>;
@@ -282,6 +315,15 @@ export declare const JsonlRecordSchema: z.ZodObject<{
         reason: z.ZodEnum<{
             pattern: "pattern";
             builtin: "builtin";
+            "ignored:builtin": "ignored:builtin";
+            "ignored:user": "ignored:user";
+            "ignored:generated": "ignored:generated";
+            "limit:file_size": "limit:file_size";
+            "limit:file_lines": "limit:file_lines";
+            "limit:file_read": "limit:file_read";
+            "limit:file_count": "limit:file_count";
+            "limit:changed_lines": "limit:changed_lines";
+            "limit:missing_patch": "limit:missing_patch";
         }>;
         pattern: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
@@ -379,6 +421,12 @@ export declare const JsonlRecordSchema: z.ZodObject<{
         webSearchRequests: z.ZodOptional<z.ZodNumber>;
         costUSD: z.ZodNumber;
     }, z.core.$strip>>>;
+    auxiliaryUsageAttribution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        runtime: z.ZodOptional<z.ZodString>;
+        runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
     files: z.ZodOptional<z.ZodArray<z.ZodPreprocess<z.ZodObject<{
         filename: z.ZodString;
         findings: z.ZodNumber;
@@ -405,6 +453,56 @@ export declare const JsonlRecordSchema: z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         headSha: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    usageBreakdown: z.ZodOptional<z.ZodObject<{
+        scan: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodString>;
+            runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
+                webSearchRequests: z.ZodOptional<z.ZodNumber>;
+                costUSD: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        auxiliary: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodString>;
+            runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
+                webSearchRequests: z.ZodOptional<z.ZodNumber>;
+                costUSD: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        total: z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodString>;
+            runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
+                webSearchRequests: z.ZodOptional<z.ZodNumber>;
+                costUSD: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type JsonlRecord = z.infer<typeof JsonlRecordSchema>;
 /** Aggregate summary across all skills (always the last JSONL line). */
@@ -429,27 +527,57 @@ export declare const JsonlSummaryRecordSchema: z.ZodObject<{
         medium: z.ZodNumber;
         low: z.ZodNumber;
     }, z.core.$strip>>;
-    usage: z.ZodOptional<z.ZodObject<{
-        inputTokens: z.ZodNumber;
-        outputTokens: z.ZodNumber;
-        cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
-        webSearchRequests: z.ZodOptional<z.ZodNumber>;
-        costUSD: z.ZodNumber;
+    usageBreakdown: z.ZodOptional<z.ZodObject<{
+        scan: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodString>;
+            runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
+                webSearchRequests: z.ZodOptional<z.ZodNumber>;
+                costUSD: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        auxiliary: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodString>;
+            runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
+                webSearchRequests: z.ZodOptional<z.ZodNumber>;
+                costUSD: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        total: z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodString>;
+            runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
+                webSearchRequests: z.ZodOptional<z.ZodNumber>;
+                costUSD: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
     }, z.core.$strip>>;
     totalSkippedFiles: z.ZodOptional<z.ZodNumber>;
-    auxiliaryUsage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        inputTokens: z.ZodNumber;
-        outputTokens: z.ZodNumber;
-        cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreation5mInputTokens: z.ZodOptional<z.ZodNumber>;
-        cacheCreation1hInputTokens: z.ZodOptional<z.ZodNumber>;
-        webSearchRequests: z.ZodOptional<z.ZodNumber>;
-        costUSD: z.ZodNumber;
-    }, z.core.$strip>>>;
     failedSkills: z.ZodOptional<z.ZodArray<z.ZodString>>;
     totalFailedHunks: z.ZodOptional<z.ZodNumber>;
     totalFailedExtractions: z.ZodOptional<z.ZodNumber>;
@@ -479,6 +607,7 @@ export declare const JsonlSummaryRecordSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type JsonlSummaryRecord = z.infer<typeof JsonlSummaryRecordSchema>;
+export declare function parseJsonlSummaryRecord(value: unknown): JsonlSummaryRecord | undefined;
 /** Per-evaluation detail for fix evaluation records. */
 export declare const JsonlFixEvalDetailSchema: z.ZodObject<{
     path: z.ZodString;

package/dist/cli/output/jsonl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../../../src/cli/output/jsonl.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../../../src/cli/output/jsonl.ts"],"names":[],"mappings":"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"}

package/dist/cli/output/jsonl.js

@@ -3,9 +3,11 @@ import { randomUUID } from 'node:crypto';
 import { dirname, join, resolve } from 'node:path';
 import { z } from 'zod';
 import { UsageStatsSchema, SkillReportSchema, FileReportSchema, FindingSchema, AuxiliaryUsageMapSchema, FixStatusSchema, isExtractionErrorCode, SkillErrorSchema, SkippedFileSchema, HunkTraceSchema, } from '../../types/index.js';
-import { mergeAuxiliaryUsage } from '../../sdk/usage.js';
+import { mergeAuxiliaryUsage, mergeAuxiliaryUsageAttribution } from '../../sdk/usage.js';
 import { logger } from '../../sentry.js';
 import { countBySeverity } from './formatters.js';
+import { JsonlUsageBreakdownSchema, aggregateReportAuxiliaryUsageAttribution, aggregateUsageStatsPreservingOptional, auxiliaryUsageAttributionFromBreakdown, auxiliaryUsageFromBreakdown, buildJsonlUsageBreakdown, scanUsageFromBreakdown, usageAttributionFromReports, } from './usage-breakdown.js';
+export { JsonlUsageBreakdownEntrySchema, JsonlUsageBreakdownSchema, auxiliaryUsageFromBreakdown, buildJsonlUsageBreakdown, scanUsageFromBreakdown, usageStatsHaveValue, } from './usage-breakdown.js';
 /**
  * Sentinel value recorded in JSONL metadata when no model is explicitly configured.
  */
@@ -59,7 +61,7 @@ export const JsonlRunMetadataSchema = 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. */
+/** Unit of work scanned by Warden, emitted during streaming and finalization. */
 export const JsonlChunkRecordSchema = z.object({
     schemaVersion: z.literal(1),
     run: JsonlRunMetadataSchema,
@@ -73,13 +75,29 @@ export const JsonlChunkRecordSchema = z.object({
     }),
     status: z.enum(['ok', 'error', 'skipped']),
     findings: z.array(FindingSchema),
-    usage: UsageStatsSchema.optional(),
+    usageBreakdown: JsonlUsageBreakdownSchema.optional(),
     durationMs: z.number().nonnegative(),
-    auxiliaryUsage: AuxiliaryUsageMapSchema.optional(),
     error: SkillErrorSchema.optional(),
     skippedFiles: z.array(SkippedFileSchema).optional(),
     trace: HunkTraceSchema.optional(),
 });
+const JsonlLegacyChunkRecordSchema = JsonlChunkRecordSchema.extend({
+    usage: UsageStatsSchema.optional(),
+    auxiliaryUsage: AuxiliaryUsageMapSchema.optional(),
+});
+function normalizeChunkRecord(record) {
+    const { usage, auxiliaryUsage, ...chunk } = record;
+    return {
+        ...chunk,
+        usageBreakdown: chunk.usageBreakdown ?? buildJsonlUsageBreakdown(usage, auxiliaryUsage, {
+            scan: { model: chunk.model },
+        }),
+    };
+}
+export function parseJsonlChunkRecord(value) {
+    const result = JsonlLegacyChunkRecordSchema.safeParse(value);
+    return result.success ? normalizeChunkRecord(result.data) : undefined;
+}
 /**
  * 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
@@ -87,6 +105,7 @@ export const JsonlChunkRecordSchema = z.object({
  */
 export const JsonlRecordSchema = SkillReportSchema.extend({
     run: JsonlRunMetadataSchema,
+    usageBreakdown: JsonlUsageBreakdownSchema.optional(),
 });
 /** Normalized output shape — what we emit. */
 const BySeverityOutputSchema = z.object({
@@ -122,9 +141,8 @@ export const JsonlSummaryRecordSchema = z.object({
     type: z.literal('summary'),
     totalFindings: z.number().int().nonnegative(),
     bySeverity: BySeveritySchema,
-    usage: UsageStatsSchema.optional(),
+    usageBreakdown: JsonlUsageBreakdownSchema.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(),
@@ -135,6 +153,21 @@ export const JsonlSummaryRecordSchema = z.object({
      */
     error: SkillErrorSchema.optional(),
 });
+const JsonlLegacySummaryRecordSchema = JsonlSummaryRecordSchema.extend({
+    usage: UsageStatsSchema.optional(),
+    auxiliaryUsage: AuxiliaryUsageMapSchema.optional(),
+});
+function normalizeSummaryRecord(record) {
+    const { usage, auxiliaryUsage, ...summary } = record;
+    return {
+        ...summary,
+        usageBreakdown: summary.usageBreakdown ?? buildJsonlUsageBreakdown(usage, auxiliaryUsage),
+    };
+}
+export function parseJsonlSummaryRecord(value) {
+    const result = JsonlLegacySummaryRecordSchema.safeParse(value);
+    return result.success ? normalizeSummaryRecord(result.data) : undefined;
+}
 /** Per-evaluation detail for fix evaluation records. */
 export const JsonlFixEvalDetailSchema = z.object({
     path: z.string(),
@@ -165,16 +198,7 @@ function aggregateUsage(reports) {
     const usages = reports.map((r) => r.usage).filter((u) => u !== undefined);
     if (usages.length === 0)
         return undefined;
-    return usages.reduce((acc, u) => ({
-        inputTokens: acc.inputTokens + u.inputTokens,
-        outputTokens: acc.outputTokens + u.outputTokens,
-        cacheReadInputTokens: (acc.cacheReadInputTokens ?? 0) + (u.cacheReadInputTokens ?? 0),
-        cacheCreationInputTokens: (acc.cacheCreationInputTokens ?? 0) + (u.cacheCreationInputTokens ?? 0),
-        cacheCreation5mInputTokens: (acc.cacheCreation5mInputTokens ?? 0) + (u.cacheCreation5mInputTokens ?? 0),
-        cacheCreation1hInputTokens: (acc.cacheCreation1hInputTokens ?? 0) + (u.cacheCreation1hInputTokens ?? 0),
-        webSearchRequests: (acc.webSearchRequests ?? 0) + (u.webSearchRequests ?? 0),
-        costUSD: acc.costUSD + u.costUSD,
-    }));
+    return aggregateUsageStatsPreservingOptional(usages);
 }
 /**
  * Build a JSONL run metadata block. `durationMs` is a snapshot at write
@@ -201,13 +225,22 @@ export function buildSkillJsonlRecord(report, run) {
         hunkFailures: report.hunkFailures?.length ? report.hunkFailures : undefined,
         traces: report.traces?.length ? report.traces : undefined,
     };
-    return { ...trimmed, run };
+    return {
+        ...trimmed,
+        run,
+        usageBreakdown: buildJsonlUsageBreakdown(report.usage, report.auxiliaryUsage, {
+            scan: { model: report.model, runtime: report.runtime },
+            auxiliary: report.auxiliaryUsageAttribution,
+        }),
+    };
 }
 /** 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 totalAuxiliaryUsageAttribution = aggregateReportAuxiliaryUsageAttribution(reports);
+    const usage = aggregateUsage(reports);
     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);
@@ -216,9 +249,11 @@ export function buildSummaryJsonlRecord(reports, run, error) {
         type: 'summary',
         totalFindings: allFindings.length,
         bySeverity: countBySeverity(allFindings),
-        usage: aggregateUsage(reports),
+        usageBreakdown: buildJsonlUsageBreakdown(usage, totalAuxiliaryUsage, {
+            scan: usageAttributionFromReports(reports),
+            auxiliary: totalAuxiliaryUsageAttribution,
+        }),
         totalSkippedFiles: totalSkippedFiles > 0 ? totalSkippedFiles : undefined,
-        auxiliaryUsage: totalAuxiliaryUsage,
         failedSkills: failedSkills.length > 0 ? failedSkills : undefined,
         totalFailedHunks: totalFailedHunks > 0 ? totalFailedHunks : undefined,
         totalFailedExtractions: totalFailedExtractions > 0 ? totalFailedExtractions : undefined,
@@ -339,10 +374,12 @@ function reportsFromChunks(chunks) {
     for (const [skill, records] of bySkill) {
         const reportLevelError = records.find(isReportLevelErrorRecord)?.error;
         const chunkRecords = records.filter((record) => !isReportLevelErrorRecord(record));
+        const analysisChunkRecords = chunkRecords.filter(isAnalysisChunkRecord);
         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 usage = aggregateRecords.reduce((acc, r) => addUsage(acc, scanUsageFromBreakdown(r.usageBreakdown)), undefined);
+        const auxiliaryUsage = aggregateRecords.reduce((acc, r) => mergeAuxiliaryUsage(acc, auxiliaryUsageFromBreakdown(r.usageBreakdown)), undefined);
+        const auxiliaryUsageAttribution = aggregateRecords.reduce((acc, r) => mergeAuxiliaryUsageAttribution(acc, auxiliaryUsageAttributionFromBreakdown(r.usageBreakdown)), undefined);
         const traces = aggregateRecords.flatMap((r) => r.trace ? [r.trace] : []);
         const filesByName = new Map();
         const hunkFailures = [];
@@ -354,7 +391,7 @@ function reportsFromChunks(chunks) {
                     filename: record.chunk.file,
                     findings: (existing?.findings ?? 0) + record.findings.length,
                     durationMs: (existing?.durationMs ?? 0) + record.durationMs,
-                    usage: addUsage(existing?.usage, record.usage),
+                    usage: addUsage(existing?.usage, scanUsageFromBreakdown(record.usageBreakdown)),
                 });
             }
             if (record.status === 'error' && record.error && !isReportLevelErrorRecord(record)) {
@@ -367,11 +404,11 @@ function reportsFromChunks(chunks) {
                 });
             }
         }
-        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 &&
+        const failedHunks = analysisChunkRecords.filter((r) => r.status === 'error' && r.error && !isExtractionErrorCode(r.error.code)).length;
+        const failedExtractions = analysisChunkRecords.filter((r) => r.status === 'error' && r.error && isExtractionErrorCode(r.error.code)).length;
+        const allChunksFailed = analysisChunkRecords.length > 0 &&
             findings.length === 0 &&
-            chunkRecords.every((record) => record.status === 'error');
+            analysisChunkRecords.every((record) => record.status === 'error');
         const report = {
             skill,
             summary: summarizeFindings(skill, findings),
@@ -387,11 +424,13 @@ function reportsFromChunks(chunks) {
         else if (allChunksFailed) {
             report.error = {
                 code: 'all_hunks_failed',
-                message: `All ${chunkRecords.length} ${chunkRecords.length === 1 ? 'chunk' : 'chunks'} failed to analyze.`,
+                message: `All ${analysisChunkRecords.length} ${analysisChunkRecords.length === 1 ? 'chunk' : 'chunks'} failed to analyze.`,
             };
         }
         if (auxiliaryUsage)
             report.auxiliaryUsage = auxiliaryUsage;
+        if (auxiliaryUsageAttribution)
+            report.auxiliaryUsageAttribution = auxiliaryUsageAttribution;
         if (failedHunks > 0)
             report.failedHunks = failedHunks;
         if (failedExtractions > 0)
@@ -409,6 +448,15 @@ function reportsFromChunks(chunks) {
 function isReportLevelErrorRecord(record) {
     return record.status === 'error' && record.chunk.file === '' && Boolean(record.error);
 }
+function isUsageOnlyPostProcessingRecord(record) {
+    return record.chunk.file === '' && record.chunk.lineRange === 'post-processing';
+}
+function isSkippedFilesMetadataRecord(record) {
+    return record.status === 'skipped' && record.chunk.lineRange === '' && (record.skippedFiles?.length ?? 0) > 0;
+}
+function isAnalysisChunkRecord(record) {
+    return !isUsageOnlyPostProcessingRecord(record) && !isSkippedFilesMetadataRecord(record);
+}
 export function parseJsonlReports(content) {
     const lines = content.trim().split('\n').filter((line) => line.trim());
     const reports = [];
@@ -418,17 +466,19 @@ export function parseJsonlReports(content) {
     for (const line of lines) {
         try {
             const parsed = JSON.parse(line);
-            const chunk = JsonlChunkRecordSchema.safeParse(parsed);
-            if (chunk.success) {
-                chunks.push(chunk.data);
+            const chunk = parseJsonlChunkRecord(parsed);
+            if (chunk) {
+                chunks.push(chunk);
                 if (!runMetadata)
-                    runMetadata = chunk.data.run;
-                totalDurationMs = Math.max(totalDurationMs, chunk.data.run.durationMs);
+                    runMetadata = chunk.run;
+                totalDurationMs = Math.max(totalDurationMs, chunk.run.durationMs);
                 continue;
             }
             // Skip summary record (but capture metadata from it)
             if (parsed.type === 'summary') {
-                const summary = JsonlSummaryRecordSchema.parse(parsed);
+                const summary = parseJsonlSummaryRecord(parsed);
+                if (!summary)
+                    throw new Error('Invalid summary record');
                 runMetadata = summary.run;
                 totalDurationMs = summary.run.durationMs;
                 continue;
@@ -440,7 +490,7 @@ export function parseJsonlReports(content) {
                 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);
+            const { run, usageBreakdown: _usageBreakdown, ...report } = JsonlRecordSchema.parse(parsed);
             reports.push(report);
             // Capture run metadata from first record if no summary yet
             if (!runMetadata) {
@@ -482,30 +532,33 @@ export function parseLogMetadata(filePath) {
     for (const line of lines) {
         try {
             const parsed = JSON.parse(line);
-            const chunk = JsonlChunkRecordSchema.safeParse(parsed);
-            if (chunk.success) {
-                chunks.push(chunk.data);
+            const chunk = parseJsonlChunkRecord(parsed);
+            if (chunk) {
+                chunks.push(chunk);
                 recognizedRecords++;
-                if (!skills.includes(chunk.data.skill)) {
-                    skills.push(chunk.data.skill);
+                if (!skills.includes(chunk.skill)) {
+                    skills.push(chunk.skill);
                 }
-                if (!model && chunk.data.model) {
-                    model = chunk.data.model;
+                if (!model && chunk.model) {
+                    model = chunk.model;
                 }
-                if (!model && chunk.data.run.model) {
-                    model = chunk.data.run.model;
+                if (!model && chunk.run.model) {
+                    model = chunk.run.model;
                 }
-                if (!headSha && chunk.data.run.headSha) {
-                    headSha = chunk.data.run.headSha;
+                if (!headSha && chunk.run.headSha) {
+                    headSha = chunk.run.headSha;
                 }
                 if (!firstRun)
-                    firstRun = chunk.data.run;
-                if (chunk.data.chunk.file) {
-                    uniqueFiles.add(chunk.data.chunk.file);
+                    firstRun = chunk.run;
+                if (chunk.chunk.file) {
+                    uniqueFiles.add(chunk.chunk.file);
                 }
             }
             else if (parsed.type === 'summary') {
-                summary = JsonlSummaryRecordSchema.parse(parsed);
+                const parsedSummary = parseJsonlSummaryRecord(parsed);
+                if (!parsedSummary)
+                    throw new Error('Invalid summary record');
+                summary = parsedSummary;
                 recognizedRecords++;
                 if (!model && parsed.run?.model && typeof parsed.run.model === 'string') {
                     model = parsed.run.model;