peaks-loop 3.0.0

package/dist/src/services/mut/production-stryker.js

@@ -0,0 +1,66 @@
+export function createProductionStrykerInvoker() {
+    return async ({ project, testFiles }) => {
+        // Lazy-load Stryker so unit tests don't need it installed.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const Stryker = (await import('@stryker-mutator/core')).Stryker;
+        const options = {
+            // Project-rooted config; explicit overrides here are minimal.
+            mutate: [...testFiles],
+        };
+        // Single cast derives from Stryker's actual constructor signature.
+        // Stryker 8's MutantResult extends our local StrykerMutant structurally.
+        const stryker = new Stryker(options);
+        const mutants = (await stryker.runMutationTest());
+        return normalize(mutants, project);
+    };
+}
+function normalize(mutants, _project) {
+    let mutantsKilled = 0;
+    let mutantsSurvived = 0;
+    let mutantsTimeout = 0;
+    for (const m of mutants) {
+        if (m.status === 'Killed')
+            mutantsKilled++;
+        else if (m.status === 'Survived')
+            mutantsSurvived++;
+        else if (m.status === 'Timeout')
+            mutantsTimeout++;
+    }
+    // Bucket mutants by fileName to populate perFile. deriveFollowups iterates
+    // m.byFile to emit per-file followups (e.g. low_kill_rate) — leaving this
+    // empty (as v0 did) silently swallowed those followups in production.
+    const byFile = new Map();
+    for (const m of mutants) {
+        const file = m.fileName;
+        let bucket = byFile.get(file);
+        if (!bucket) {
+            bucket = { killed: 0, survived: 0, survivedEntries: [] };
+            byFile.set(file, bucket);
+        }
+        if (m.status === 'Killed')
+            bucket.killed++;
+        else if (m.status === 'Survived') {
+            bucket.survived++;
+            bucket.survivedEntries.push({
+                line: m.location.start.line + 1, // Stryker is 0-based; reports are 1-based.
+                mutation: m.replacement,
+                survivedBecause: m.statusReason ?? '',
+            });
+        }
+    }
+    const perFile = [...byFile.entries()]
+        .map(([file, b]) => {
+        const total = b.killed + b.survived;
+        const killRate = total === 0 ? 0 : b.killed / total;
+        return { file, killRate, survived: b.survivedEntries };
+    })
+        // Stable order for MUT.sig / reports.
+        .sort((a, b) => a.file.localeCompare(b.file));
+    return {
+        mutantsTotal: mutants.length,
+        mutantsKilled,
+        mutantsSurvived,
+        mutantsTimeout,
+        perFile,
+    };
+}

package/dist/src/services/mut/report-builder.d.ts

@@ -0,0 +1,11 @@
+import { type AssertionsReport, type MutationReport, type MutReportJson } from './types.js';
+import { type Thresholds } from './thresholds.js';
+export interface BuildMutInput {
+    readonly mutation: MutationReport;
+    readonly assertions: AssertionsReport;
+    readonly inputSig: string;
+    readonly out: string;
+    readonly thresholds?: Thresholds;
+    readonly now?: () => Date;
+}
+export declare function buildMutReport(input: BuildMutInput): Promise<MutReportJson>;

package/dist/src/services/mut/report-builder.js

@@ -0,0 +1,110 @@
+/**
+ * Combines MutationReport + AssertionsReport into MutReportJson, computes
+ * thresholds, derives followups, computes MUT.sig, writes file atomically.
+ *
+ * Hard constraints:
+ *   H8 (audit trail hashable): MUT.sig is sha256 of normalized content;
+ *       generatedAt + sha256 are excluded from the digest to make the
+ *       signature deterministic across runs.
+ *   H6 (CLI裁决): passed boolean + followups computed by CLI, not LLM.
+ *   KISS: keep composition narrow — input, thresholds, output file path.
+ */
+import { createHash } from 'node:crypto';
+import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { MutReportSchema, } from './types.js';
+import { DEFAULT_THRESHOLDS, evaluateThresholds, } from './thresholds.js';
+function deriveFollowups(m, a, t) {
+    const out = [];
+    if (m.killRate < t.mutationKillRateMin) {
+        for (const f of m.byFile) {
+            if (f.killRate < t.mutationKillRateMin) {
+                out.push({
+                    file: f.file,
+                    issue: 'low_kill_rate',
+                    severity: 'soft',
+                    suggestion: `Add tests for ${f.survived.length} survived mutants in ${f.file}`,
+                });
+            }
+        }
+    }
+    if (a.weakRate > t.weakAssertionRateMax) {
+        for (const p of a.weakPatterns) {
+            if (p.count > 0) {
+                const exampleFile = p.examples[0]?.file ?? '<unknown>';
+                out.push({
+                    file: exampleFile,
+                    issue: 'high_weak_assertions',
+                    severity: 'hard',
+                    suggestion: `Replace ${p.count} weak assertions of type "${p.pattern}" with concrete value checks`,
+                });
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Recursively sort object keys to produce a canonical JSON string.
+ * Arrays preserve order; only object keys are sorted.
+ */
+function canonicalize(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => canonicalize(v));
+    }
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+        sorted[key] = canonicalize(obj[key]);
+    }
+    return sorted;
+}
+function sha256OfCanonical(value) {
+    const canonical = JSON.stringify(canonicalize(value));
+    return createHash('sha256').update(canonical).digest('hex');
+}
+/**
+ * Compute MUT.sig: sha256 of the report content excluding generatedAt and
+ * sha256 itself. Both fields are removed before canonicalization so the
+ * digest is stable across runs that differ only in timestamp.
+ */
+function computeMutSig(report) {
+    const { generatedAt: _g, ...rest } = report;
+    void _g;
+    return sha256OfCanonical(rest);
+}
+export async function buildMutReport(input) {
+    const thresholds = input.thresholds ?? DEFAULT_THRESHOLDS;
+    const now = input.now ?? (() => new Date());
+    const evalResult = evaluateThresholds(thresholds, input.mutation.killRate, input.assertions.weakRate);
+    const followups = deriveFollowups(input.mutation, input.assertions, thresholds);
+    const partial = {
+        version: '1.0',
+        generatedAt: now().toISOString(),
+        inputSig: input.inputSig,
+        mutation: input.mutation,
+        assertions: input.assertions,
+        thresholds: {
+            mutationKillRateMin: thresholds.mutationKillRateMin,
+            weakAssertionRateMax: thresholds.weakAssertionRateMax,
+            passed: evalResult.passed,
+        },
+        followups,
+    };
+    const sha256 = computeMutSig(partial);
+    const final = { ...partial, sha256 };
+    MutReportSchema.parse(final);
+    await mkdir(dirname(input.out), { recursive: true });
+    const tmp = `${input.out}.tmp`;
+    try {
+        await writeFile(tmp, JSON.stringify(final, null, 2), 'utf8');
+        await rename(tmp, input.out);
+    }
+    catch (err) {
+        await unlink(tmp).catch(() => undefined);
+        throw err;
+    }
+    return final;
+}

package/dist/src/services/mut/report-loader.d.ts

@@ -0,0 +1,31 @@
+import { type MutReportJson } from './types.js';
+export declare const MUT_REPORT_RELATIVE_PATH = "mut/mut-report.json";
+/**
+ * Build the canonical absolute path of a session's mut-report.json.
+ * Exported so the CLI surface in qa-commands can reuse the same
+ * constant for diagnostic messages.
+ *
+ * Uses POSIX separators intentionally: the one-axis envelope is
+ * documented as `.peaks/_runtime/<sid>/mut/mut-report.json` (forward
+ * slashes) and that path is what the hotfix 81f00ce audit-trail
+ * contract guarantees. `node:path` would produce backslashes on
+ * Windows, breaking the cross-platform invariant. POSIX join is
+ * correct here because the result is a logical path stored in JSON
+ * artifacts and CLI diagnostics — it never gets passed to OS
+ * syscalls directly (readFile / writeFile accept both forms).
+ */
+export declare function mutReportPath(sessionId: string): string;
+/**
+ * Read and validate a session's mut-report.json.
+ *
+ * Returns `null` for any of these cases:
+ *   - file does not exist (ENOENT)
+ *   - file exists but JSON is malformed
+ *   - file exists and parses but does not satisfy `MutReportSchema`
+ *
+ * Never throws. Never logs to stdout (per "no console.log in src/").
+ * Schema-parse failures are reported via `process.stderr` so the
+ * qa-runner operator can see why their report is being treated as
+ * absent.
+ */
+export declare function loadMutReport(sessionId: string): Promise<MutReportJson | null>;

package/dist/src/services/mut/report-loader.js

@@ -0,0 +1,78 @@
+/**
+ * Plan 2 — Task 8: peaks-qa consumes MUT.sig from peaks-mut.
+ *
+ * `loadMutReport` is the read-side counterpart of `buildMutReport`
+ * (which is the write-side). Both share the canonical path:
+ * `.peaks/_runtime/<sessionId>/mut/mut-report.json` (per hotfix 81f00ce
+ * one-axis envelope — no `.peaks/_runtime/<sessionId>/` fallback).
+ *
+ * Design contract (per spec lines 1292-1341):
+ *   - Missing file      → `null` (gate is skipped, NOT failed)
+ *   - Schema-invalid    → `null` (log via stderr; do not throw — qa is a
+ *                         pre-step, not a precondition)
+ *   - Schema-valid      → the parsed `MutReportJson`
+ *
+ * Returning `null` instead of throwing is what lets peaks-qa treat
+ * "peaks mut was not run" as a no-op. If we threw, the qa gate would
+ * crash on every session that hasn't run peaks-mut yet.
+ */
+import { readFile } from 'node:fs/promises';
+import { posix as pathPosix } from 'node:path';
+import { MutReportSchema } from './types.js';
+export const MUT_REPORT_RELATIVE_PATH = 'mut/mut-report.json';
+/**
+ * Build the canonical absolute path of a session's mut-report.json.
+ * Exported so the CLI surface in qa-commands can reuse the same
+ * constant for diagnostic messages.
+ *
+ * Uses POSIX separators intentionally: the one-axis envelope is
+ * documented as `.peaks/_runtime/<sid>/mut/mut-report.json` (forward
+ * slashes) and that path is what the hotfix 81f00ce audit-trail
+ * contract guarantees. `node:path` would produce backslashes on
+ * Windows, breaking the cross-platform invariant. POSIX join is
+ * correct here because the result is a logical path stored in JSON
+ * artifacts and CLI diagnostics — it never gets passed to OS
+ * syscalls directly (readFile / writeFile accept both forms).
+ */
+export function mutReportPath(sessionId) {
+    return pathPosix.join('.peaks', '_runtime', sessionId, MUT_REPORT_RELATIVE_PATH);
+}
+/**
+ * Read and validate a session's mut-report.json.
+ *
+ * Returns `null` for any of these cases:
+ *   - file does not exist (ENOENT)
+ *   - file exists but JSON is malformed
+ *   - file exists and parses but does not satisfy `MutReportSchema`
+ *
+ * Never throws. Never logs to stdout (per "no console.log in src/").
+ * Schema-parse failures are reported via `process.stderr` so the
+ * qa-runner operator can see why their report is being treated as
+ * absent.
+ */
+export async function loadMutReport(sessionId) {
+    const path = mutReportPath(sessionId);
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        // ENOENT or permission denied — both treated as "not run".
+        return null;
+    }
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[peaks-qa] mut-report at ${path} is not valid JSON; treating as absent: ${message}\n`);
+        return null;
+    }
+    const parsed = MutReportSchema.safeParse(parsedJson);
+    if (!parsed.success) {
+        process.stderr.write(`[peaks-qa] mut-report at ${path} failed schema validation; treating as absent: ${parsed.error.message}\n`);
+        return null;
+    }
+    return parsed.data;
+}

package/dist/src/services/mut/thresholds.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Per spec §4.2 验收审计 — Default thresholds + evaluator.
+ *
+ * Override via `peaks-mut.config.json` at project root.
+ */
+export interface Thresholds {
+    readonly mutationKillRateMin: number;
+    readonly weakAssertionRateMax: number;
+}
+export declare const DEFAULT_THRESHOLDS: Thresholds;
+export type ThresholdViolationKind = 'mutationKillRateMin' | 'weakAssertionRateMax';
+export interface ThresholdViolation {
+    readonly kind: ThresholdViolationKind;
+    readonly actual: number;
+    readonly threshold: number;
+}
+export interface ThresholdEvaluation {
+    readonly passed: boolean;
+    readonly violations: ReadonlyArray<ThresholdViolation>;
+}
+export declare function evaluateThresholds(t: Thresholds, actualKillRate: number, actualWeakRate: number): ThresholdEvaluation;

package/dist/src/services/mut/thresholds.js

@@ -0,0 +1,22 @@
+export const DEFAULT_THRESHOLDS = Object.freeze({
+    mutationKillRateMin: 0.80,
+    weakAssertionRateMax: 0.05,
+});
+export function evaluateThresholds(t, actualKillRate, actualWeakRate) {
+    const violations = [];
+    if (actualKillRate < t.mutationKillRateMin) {
+        violations.push({
+            kind: 'mutationKillRateMin',
+            actual: actualKillRate,
+            threshold: t.mutationKillRateMin,
+        });
+    }
+    if (actualWeakRate > t.weakAssertionRateMax) {
+        violations.push({
+            kind: 'weakAssertionRateMax',
+            actual: actualWeakRate,
+            threshold: t.weakAssertionRateMax,
+        });
+    }
+    return { passed: violations.length === 0, violations };
+}

package/dist/src/services/mut/types.d.ts

@@ -0,0 +1,336 @@
+/**
+ * Per spec §4.2 验收审计 + §7 阶段二 — MutReportJson v1.0.
+ *
+ * Hard constraints:
+ *   H8 (audit trail hashable): sha256 + inputSig (chain to TACT.sig)
+ *   H6 (CLI裁决, not LLM): passed boolean is computed by CLI, not LLM
+ */
+import { z } from 'zod';
+export type MutVersion = '1.0';
+export type MutTool = 'stryker' | 'mutmut' | 'go-mutesting';
+export type WeakPattern = 'toBeDefined' | 'toBeTruthy' | 'toEqual-self' | 'expect-anything' | 'toBe-self';
+export interface SurvivedMutant {
+    readonly line: number;
+    readonly mutation: string;
+    readonly survivedBecause: string;
+}
+export interface FileMutationReport {
+    readonly file: string;
+    readonly killRate: number;
+    readonly survived: ReadonlyArray<SurvivedMutant>;
+}
+export interface MutationReport {
+    readonly tool: MutTool;
+    readonly mutantsTotal: number;
+    readonly mutantsKilled: number;
+    readonly mutantsSurvived: number;
+    readonly mutantsTimeout: number;
+    readonly killRate: number;
+    readonly byFile: ReadonlyArray<FileMutationReport>;
+}
+export interface WeakExample {
+    readonly file: string;
+    readonly line: number;
+    readonly code: string;
+}
+export interface WeakPatternCount {
+    readonly pattern: WeakPattern;
+    readonly count: number;
+    readonly examples: ReadonlyArray<WeakExample>;
+}
+export interface AssertionsReport {
+    readonly totalAssertions: number;
+    readonly weakAssertions: number;
+    readonly weakRate: number;
+    readonly weakPatterns: ReadonlyArray<WeakPatternCount>;
+}
+export interface ThresholdsConfig {
+    readonly mutationKillRateMin: number;
+    readonly weakAssertionRateMax: number;
+    readonly passed: boolean;
+}
+export type FollowupSeverity = 'soft' | 'hard';
+export type FollowupIssue = 'low_kill_rate' | 'high_weak_assertions';
+export interface Followup {
+    readonly file: string;
+    readonly issue: FollowupIssue;
+    readonly severity: FollowupSeverity;
+    readonly suggestion: string;
+}
+export interface MutReportJson {
+    readonly version: MutVersion;
+    readonly sha256: string;
+    readonly generatedAt: string;
+    readonly inputSig: string;
+    readonly mutation: MutationReport;
+    readonly assertions: AssertionsReport;
+    readonly thresholds: ThresholdsConfig;
+    readonly followups: ReadonlyArray<Followup>;
+}
+export declare const WeakPatternSchema: z.ZodEnum<["toBeDefined", "toBeTruthy", "toEqual-self", "expect-anything", "toBe-self"]>;
+export declare const MutReportSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1.0">;
+    sha256: z.ZodString;
+    generatedAt: z.ZodString;
+    inputSig: z.ZodString;
+    mutation: z.ZodObject<{
+        tool: z.ZodEnum<["stryker", "mutmut", "go-mutesting"]>;
+        mutantsTotal: z.ZodNumber;
+        mutantsKilled: z.ZodNumber;
+        mutantsSurvived: z.ZodNumber;
+        mutantsTimeout: z.ZodNumber;
+        killRate: z.ZodNumber;
+        byFile: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            killRate: z.ZodNumber;
+            survived: z.ZodArray<z.ZodObject<{
+                line: z.ZodNumber;
+                mutation: z.ZodString;
+                survivedBecause: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }, {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }, {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        tool: "stryker" | "mutmut" | "go-mutesting";
+        killRate: number;
+        mutantsTotal: number;
+        mutantsKilled: number;
+        mutantsSurvived: number;
+        mutantsTimeout: number;
+        byFile: {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }[];
+    }, {
+        tool: "stryker" | "mutmut" | "go-mutesting";
+        killRate: number;
+        mutantsTotal: number;
+        mutantsKilled: number;
+        mutantsSurvived: number;
+        mutantsTimeout: number;
+        byFile: {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }[];
+    }>;
+    assertions: z.ZodObject<{
+        totalAssertions: z.ZodNumber;
+        weakAssertions: z.ZodNumber;
+        weakRate: z.ZodNumber;
+        weakPatterns: z.ZodArray<z.ZodObject<{
+            pattern: z.ZodEnum<["toBeDefined", "toBeTruthy", "toEqual-self", "expect-anything", "toBe-self"]>;
+            count: z.ZodNumber;
+            examples: z.ZodArray<z.ZodObject<{
+                file: z.ZodString;
+                line: z.ZodNumber;
+                code: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                code: string;
+                file: string;
+                line: number;
+            }, {
+                code: string;
+                file: string;
+                line: number;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }, {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        weakRate: number;
+        totalAssertions: number;
+        weakAssertions: number;
+        weakPatterns: {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }[];
+    }, {
+        weakRate: number;
+        totalAssertions: number;
+        weakAssertions: number;
+        weakPatterns: {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }[];
+    }>;
+    thresholds: z.ZodObject<{
+        mutationKillRateMin: z.ZodNumber;
+        weakAssertionRateMax: z.ZodNumber;
+        passed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        passed: boolean;
+        mutationKillRateMin: number;
+        weakAssertionRateMax: number;
+    }, {
+        passed: boolean;
+        mutationKillRateMin: number;
+        weakAssertionRateMax: number;
+    }>;
+    followups: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        issue: z.ZodEnum<["low_kill_rate", "high_weak_assertions"]>;
+        severity: z.ZodEnum<["soft", "hard"]>;
+        suggestion: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        severity: "soft" | "hard";
+        issue: "low_kill_rate" | "high_weak_assertions";
+        suggestion: string;
+    }, {
+        file: string;
+        severity: "soft" | "hard";
+        issue: "low_kill_rate" | "high_weak_assertions";
+        suggestion: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: "1.0";
+    sha256: string;
+    generatedAt: string;
+    inputSig: string;
+    mutation: {
+        tool: "stryker" | "mutmut" | "go-mutesting";
+        killRate: number;
+        mutantsTotal: number;
+        mutantsKilled: number;
+        mutantsSurvived: number;
+        mutantsTimeout: number;
+        byFile: {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }[];
+    };
+    assertions: {
+        weakRate: number;
+        totalAssertions: number;
+        weakAssertions: number;
+        weakPatterns: {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }[];
+    };
+    thresholds: {
+        passed: boolean;
+        mutationKillRateMin: number;
+        weakAssertionRateMax: number;
+    };
+    followups: {
+        file: string;
+        severity: "soft" | "hard";
+        issue: "low_kill_rate" | "high_weak_assertions";
+        suggestion: string;
+    }[];
+}, {
+    version: "1.0";
+    sha256: string;
+    generatedAt: string;
+    inputSig: string;
+    mutation: {
+        tool: "stryker" | "mutmut" | "go-mutesting";
+        killRate: number;
+        mutantsTotal: number;
+        mutantsKilled: number;
+        mutantsSurvived: number;
+        mutantsTimeout: number;
+        byFile: {
+            file: string;
+            killRate: number;
+            survived: {
+                line: number;
+                mutation: string;
+                survivedBecause: string;
+            }[];
+        }[];
+    };
+    assertions: {
+        weakRate: number;
+        totalAssertions: number;
+        weakAssertions: number;
+        weakPatterns: {
+            count: number;
+            examples: {
+                code: string;
+                file: string;
+                line: number;
+            }[];
+            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
+        }[];
+    };
+    thresholds: {
+        passed: boolean;
+        mutationKillRateMin: number;
+        weakAssertionRateMax: number;
+    };
+    followups: {
+        file: string;
+        severity: "soft" | "hard";
+        issue: "low_kill_rate" | "high_weak_assertions";
+        suggestion: string;
+    }[];
+}>;