quality-intelligence-engine 2.2.17 → 2.2.22

package/dist/bin/qi.js

@@ -13,10 +13,15 @@ async function main() {
     const args = process.argv.slice(2);
     const playwrightResultsDir = args.find(a => !a.startsWith("--")) ?? "playwright-results";
     const showIssues = args.includes("--issue") || args.includes("--issues");
-    // Resolve project root (works after npm install)
+    /**
+     * __dirname → dist/bin
+     * projectRoot → dist
+     */
     const projectRoot = path_1.default.resolve(__dirname, "..");
-    // IMPORTANT: call compiled JS, never TS
-    // dist/final-run.js EXISTS in published package
+    /**
+     * final-run.ts → dist/final-run.js
+     * (this file IS published)
+     */
     const finalRunPath = path_1.default.join(projectRoot, "final-run.js");
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const { runFinal } = require(finalRunPath);

package/dist/src/adapters/playwright-folder.adapter.js

@@ -0,0 +1,68 @@
+"use strict";
+// src/adapters/playwright-folder.adapter.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePlaywrightFailureFolders = parsePlaywrightFailureFolders;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Improved Playwright failure folder parser
+ * Focus: reduce UNKNOWN classifications
+ */
+function parsePlaywrightFailureFolders(resultsDir) {
+    const fullDir = path_1.default.resolve(resultsDir);
+    if (!fs_1.default.existsSync(fullDir)) {
+        throw new Error(`Playwright results directory not found: ${fullDir}`);
+    }
+    const entries = fs_1.default.readdirSync(fullDir, { withFileTypes: true });
+    const failures = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const name = entry.name;
+        if (!name.includes("FAIL"))
+            continue;
+        const lower = name.toLowerCase();
+        let classification = "UNKNOWN";
+        // 🔢 Numeric / data mismatches
+        if (lower.includes("numeric-mismatch") ||
+            lower.includes("count") ||
+            lower.includes("total") ||
+            lower.includes("sum") ||
+            lower.includes("price")) {
+            classification = "NUMERIC_MISMATCH";
+        }
+        // 🔐 Auth / permission issues
+        else if (lower.includes("unauthorized") ||
+            lower.includes("forbidden") ||
+            lower.includes("permission")) {
+            classification = "AUTH_BUG";
+        }
+        // ⏱ Timeouts / waits
+        else if (lower.includes("timeout") ||
+            lower.includes("timed-out") ||
+            lower.includes("wait")) {
+            classification = "TIMEOUT";
+        }
+        // 🧭 UI / locator issues
+        else if (lower.includes("locator") ||
+            lower.includes("not-visible") ||
+            lower.includes("hidden") ||
+            lower.includes("detached")) {
+            classification = "UI_STATE";
+        }
+        // 🔁 Retry / flaky signal
+        else if (lower.includes("retry")) {
+            classification = "FLAKY";
+        }
+        failures.push({
+            testName: name,
+            classification,
+            failureType: classification,
+            message: `Derived from Playwright folder name: ${name}`
+        });
+    }
+    return failures;
+}

package/dist/src/adapters/playwright-json.adapter.js

@@ -0,0 +1,46 @@
+"use strict";
+// src/adapters/playwright-json.adapter.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePlaywrightJsonReport = parsePlaywrightJsonReport;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Converts Playwright JSON report → FailureAnalysisResult[]
+ */
+function parsePlaywrightJsonReport(reportPath) {
+    const fullPath = path_1.default.resolve(reportPath);
+    const raw = fs_1.default.readFileSync(fullPath, "utf-8");
+    const report = JSON.parse(raw);
+    const failures = [];
+    for (const suite of report.suites ?? []) {
+        for (const spec of suite.specs ?? []) {
+            for (const test of spec.tests ?? []) {
+                for (const result of test.results ?? []) {
+                    if (result.status === "failed") {
+                        const error = result.error?.message ?? "";
+                        let classification = "UNKNOWN";
+                        if (error.includes("toHaveCount")) {
+                            classification = "NUMERIC_MISMATCH";
+                        }
+                        else if (error.includes("timeout")) {
+                            classification = "TIMEOUT";
+                        }
+                        else if (error.includes("locator")) {
+                            classification = "LOCATOR_CHANGED";
+                        }
+                        failures.push({
+                            testName: test.title,
+                            classification,
+                            failureType: classification,
+                            message: error
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return failures;
+}

package/dist/src/adapters/playwright.adapter.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPlaywrightFailures = readPlaywrightFailures;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function readPlaywrightFailures(reportDir) {
+    const reportFile = path_1.default.join(reportDir, 'report.json');
+    if (!fs_1.default.existsSync(reportFile)) {
+        throw new Error(`Playwright JSON report not found.\nExpected at: ${reportFile}`);
+    }
+    const raw = JSON.parse(fs_1.default.readFileSync(reportFile, 'utf-8'));
+    const failures = [];
+    for (const suite of raw.suites ?? []) {
+        for (const spec of suite.specs ?? []) {
+            for (const test of spec.tests ?? []) {
+                const failedResults = test.results?.filter((r) => r.status === 'failed');
+                if (!failedResults || failedResults.length === 0)
+                    continue;
+                const firstFailure = failedResults[0];
+                const error = firstFailure.error;
+                failures.push({
+                    testName: spec.title,
+                    errorMessage: error?.message ?? 'Unknown error',
+                    stack: error?.stack,
+                    filePath: error?.location?.file ?? spec.file,
+                    lineNumber: error?.location?.line ?? spec.line ?? 0,
+                    retryCount: failedResults.length - 1
+                });
+            }
+        }
+    }
+    return failures;
+}

package/dist/src/cli/qi-test.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runQiTest = runQiTest;
+const child_process_1 = require("child_process");
+function runQiTest(args) {
+    const playwrightArgs = [
+        'playwright',
+        'test',
+        '--config',
+        'playwright.config.ts',
+        ...args
+    ];
+    const child = (0, child_process_1.spawn)('npx', playwrightArgs, {
+        stdio: 'inherit',
+        shell: true
+    });
+    child.on('exit', code => {
+        process.exit(code ?? 0);
+    });
+}

package/dist/src/cli/qi.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+"use strict";
+// src/cli/qi.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runQiCli = runQiCli;
+const runner_1 = require("../runner");
+/**
+ * Core CLI runner (reusable)
+ */
+async function runQiCli(input) {
+    const results = await (0, runner_1.runQualityIntelligence)(input);
+    if (!Array.isArray(results) || results.length === 0) {
+        console.log("No failures detected.");
+        return;
+    }
+    for (const f of results) {
+        const testName = f.testName ?? "UNKNOWN_TEST";
+        const isExpected = testName.includes("EXPECTED");
+        console.log("=================================");
+        console.log(`Test Name     : ${testName}${isExpected ? " (EXPECTED)" : ""}`);
+        console.log(`Failure Type  : ${f.failureType ?? f.classification}`);
+        console.log(`Confidence    : ${f.confidence ?? "N/A"}\n`);
+        if (f.rootCause?.length) {
+            console.log("Root Cause:");
+            for (const line of f.rootCause) {
+                console.log(` - ${line}`);
+            }
+            console.log();
+        }
+        if (f.evidence?.length) {
+            console.log("Evidence:");
+            for (const line of f.evidence) {
+                console.log(` - ${line}`);
+            }
+            console.log();
+        }
+        if (f.diagnosis?.length) {
+            console.log("Diagnosis:");
+            for (const line of f.diagnosis) {
+                console.log(` - ${line}`);
+            }
+            console.log();
+        }
+    }
+}
+/**
+ * CLI ENTRY POINT
+ * Allows: npx qi <path>
+ */
+async function main() {
+    const input = process.argv[2] ?? "playwright-results";
+    await runQiCli(input);
+}
+if (process.argv[1]?.includes("qi")) {
+    main().catch(err => {
+        console.error("QI CLI failed:", err);
+        process.exit(1);
+    });
+}

package/dist/src/cli/ui/divider.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.divider = divider;
+function divider(title, width = 60) {
+    const line = '━'.repeat(width);
+    if (!title) {
+        return `\n${line}\n`;
+    }
+    return `\n${line}\n${title}\n${line}\n`;
+}

package/dist/src/cli/ui/failureLogger.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logFailure = logFailure;
+function logFailure(input) {
+    const confidencePercent = Math.round(input.confidence * 100);
+    console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+❌ Automation Test Failure
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Test Name     : ${input.testName}
+Failure Type  : ${input.failureType}
+Severity      : ${input.severity}
+Priority      : ${input.priority}
+Confidence    : ${confidencePercent}%
+
+Failure Location:
+- Test File   : ${input.file}
+- Line Number : ${input.line}
+
+Root Cause:
+- ${input.rootCause}
+`);
+}

package/dist/src/configLoader.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const file_utils_1 = require("./utils/file-utils");
+/**
+ * Validate configuration object structure
+ */
+function validateConfig(config) {
+    if (typeof config !== 'object' || config === null) {
+        return false;
+    }
+    const cfg = config;
+    // Validate engine section
+    if (typeof cfg.engine !== 'object' ||
+        cfg.engine === null) {
+        return false;
+    }
+    const engine = cfg.engine;
+    if (typeof engine.mode !== 'string' ||
+        typeof engine.confidenceThresholds !== 'object') {
+        return false;
+    }
+    return true;
+}
+/**
+ * Load and validate configuration
+ */
+function loadConfig() {
+    try {
+        const configPath = (0, file_utils_1.resolvePath)('config', 'agent.config.json');
+        const config = (0, file_utils_1.readJsonFile)(configPath);
+        if (!validateConfig(config)) {
+            throw new Error('Invalid configuration structure');
+        }
+        return config;
+    }
+    catch (error) {
+        console.error('❌ Failed to load configuration:', error);
+        console.error('\n💡 Using default configuration');
+        // Return safe defaults
+        return {
+            engine: {
+                mode: 'standard',
+                confidenceThresholds: {
+                    fail: 0.85,
+                    passRisk: 0.6
+                }
+            },
+            output: {
+                writeMarkdown: true,
+                maxHistoryRuns: 10
+            },
+            passAnalysis: {
+                enable: true,
+                reportFlakyPass: true,
+                reportApiWarnings: true
+            }
+        };
+    }
+}

package/dist/src/console/issue-view.js

@@ -0,0 +1,81 @@
+"use strict";
+// src/console/issue-view.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractIssues = extractIssues;
+exports.filterIssues = filterIssues;
+exports.printIssues = printIssues;
+/* ===================================================== */
+/* 🔹 EXISTING LOGIC (RESTORED – NO BEHAVIOR CHANGE)     */
+/* ===================================================== */
+function extractIssues(groupedCounts, confidence) {
+    return Object.entries(groupedCounts).map(([type, count]) => ({
+        type,
+        count,
+        confidence,
+        autoHealAllowed: type === "FLAKY",
+        owner: {
+            team: type === "FLAKY"
+                ? "QA"
+                : type === "NUMERIC_MISMATCH"
+                    ? "Backend"
+                    : "Frontend"
+        },
+        summary: type === "FLAKY"
+            ? "Test behavior is unstable across executions"
+            : type === "NUMERIC_MISMATCH"
+                ? "Numeric values returned by backend do not match expected results"
+                : "Test failures detected but root cause is unclear",
+        reasoning: type === "FLAKY"
+            ? ["Failures disappear on retry", "Timing or synchronization issues detected"]
+            : type === "NUMERIC_MISMATCH"
+                ? ["API response data differs from expected calculation"]
+                : ["Failure artifacts exist", "Signals insufficient for confident classification"],
+        recommendations: type === "FLAKY"
+            ? ["Improve waits or synchronization", "Stabilize test setup and assertions"]
+            : type === "NUMERIC_MISMATCH"
+                ? ["Verify backend calculation logic", "Validate API response against expected schema"]
+                : ["Review screenshot and trace manually"]
+    }));
+}
+function filterIssues(issues, filter) {
+    if (!filter.enabled)
+        return [];
+    let result = issues;
+    if (filter.keyword) {
+        result = result.filter(i => i.type.toLowerCase().includes(filter.keyword.toLowerCase()));
+    }
+    if (filter.topN) {
+        result = result.slice(0, filter.topN);
+    }
+    return result;
+}
+/* ===================================================== */
+/* 🔹 UPDATED PRINTER (NEW DESIGN)                       */
+/* ===================================================== */
+function printIssues(issues, failureFolder) {
+    if (!issues.length) {
+        console.log("No matching issues found.");
+        return;
+    }
+    issues.forEach((issue, index) => {
+        console.log(`\nISSUE #${index + 1}`);
+        console.log(`Type        : ${issue.type}`);
+        console.log(`Occurrences : ${issue.count}`);
+        console.log(`Confidence  : ${issue.confidence}`);
+        console.log(`Domain      : ${issue.owner?.team ?? "UNKNOWN"}`);
+        console.log("\nWHAT IS THE ISSUE:");
+        console.log(`  ${issue.summary}`);
+        console.log("\nWHY IT IS HAPPENING:");
+        issue.reasoning.forEach((r) => console.log(`  • ${r}`));
+        console.log("\nWHAT TO DO NEXT:");
+        issue.recommendations.forEach((r) => console.log(`  • ${r}`));
+        if (issue.autoHealAllowed) {
+            console.log("\nSelf-Healing:");
+            console.log("  Allowed : YES (retry-based stabilization is safe)");
+        }
+        console.log("\nEvidence:");
+        console.log(`  Screenshot : ${failureFolder}/test-failed-1.png`);
+        console.log(`  Trace      : npx playwright show-trace ${failureFolder}/trace.zip`);
+        console.log("-".repeat(70));
+    });
+}

package/dist/src/failure-analysis/failure-analyzer.js

@@ -0,0 +1,38 @@
+"use strict";
+// src/failure-analysis/failure-analyzer.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailureAnalyzer = void 0;
+/**
+ * FailureAnalyzer
+ * ----------------
+ * Phase 1 core analyzer.
+ * This class is intentionally simple and stable.
+ * Do NOT add history, trends, or intelligence here.
+ */
+class FailureAnalyzer {
+    analyze(input) {
+        if (!input || !Array.isArray(input)) {
+            return [];
+        }
+        return input.map((item) => {
+            // Minimal safe classification logic
+            if (item?.type === "NUMERIC_MISMATCH") {
+                return {
+                    classification: "NUMERIC_MISMATCH",
+                    message: item.message
+                };
+            }
+            if (item?.type === "API_BUG") {
+                return {
+                    classification: "API_BUG",
+                    message: item.message
+                };
+            }
+            return {
+                classification: "UNKNOWN",
+                message: item?.message
+            };
+        });
+    }
+}
+exports.FailureAnalyzer = FailureAnalyzer;

package/dist/src/final-run.js

@@ -0,0 +1,131 @@
+"use strict";
+// src/final-run.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFinal = runFinal;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const runner_1 = require("./runner");
+const v2_intelligence_pipeline_1 = require("./v2/pipeline/v2-intelligence.pipeline");
+/* ===================================================== */
+/* 🔹 STRONG METADATA DERIVATION (NO GUESSING)           */
+/* ===================================================== */
+function deriveTestMetadata(failureFolder) {
+    // 1️⃣ Try spec file (best)
+    try {
+        const files = fs_1.default.readdirSync(failureFolder, { recursive: true });
+        const spec = files.find(f => f.endsWith(".spec.ts") || f.endsWith(".spec.js"));
+        if (spec) {
+            return {
+                testName: path_1.default.basename(spec).replace(/\.(spec\.ts|spec\.js)$/, ""),
+                testLocation: `${spec}:?`
+            };
+        }
+    }
+    catch { }
+    // 2️⃣ Fallback: derive from folder name (deterministic)
+    const folderName = path_1.default.basename(failureFolder);
+    const cleaned = folderName
+        .replace(/--chromium|--firefox|--webkit/g, "")
+        .replace(/-FAIL.*/i, "")
+        .replace(/[-_]/g, " ")
+        .trim();
+    return {
+        testName: cleaned || "Unknown test",
+        testLocation: "Derived from Playwright results"
+    };
+}
+/* ===================================================== */
+/* 🔹 FAILURE FALLBACK CLASSIFIER (SAFE)                 */
+/* ===================================================== */
+function normalizeFailure(dominant, failureFolder) {
+    if (dominant !== "UNCLASSIFIED_FAILURE") {
+        return {
+            primary: dominant,
+            domain: dominant === "NUMERIC_MISMATCH"
+                ? "API"
+                : dominant === "FLAKY"
+                    ? "TEST"
+                    : dominant === "ASSERTION_FAILURE"
+                        ? "UI"
+                        : "UNKNOWN"
+        };
+    }
+    const keywords = ["invalid", "required", "rejected", "format", "error", "fail"];
+    const name = failureFolder.toLowerCase();
+    if (keywords.some(k => name.includes(k))) {
+        return {
+            primary: "UI_VALIDATION_FAILURE",
+            domain: "UI"
+        };
+    }
+    return {
+        primary: "UNKNOWN",
+        domain: "UNKNOWN"
+    };
+}
+function line(char = "=", count = 70) {
+    console.log(char.repeat(count));
+}
+/* ===================================================== */
+/* ✅ MAIN EXECUTION – NO LOGIC REGRESSION                */
+/* ===================================================== */
+async function runFinal() {
+    const playwrightResultsDir = "playwright-results";
+    const folders = fs_1.default.readdirSync(playwrightResultsDir).filter(f => fs_1.default.statSync(path_1.default.join(playwrightResultsDir, f)).isDirectory());
+    if (!folders.length) {
+        console.error("No Playwright failure folders found.");
+        return;
+    }
+    const failureFolder = path_1.default.join(playwrightResultsDir, folders[0]);
+    const meta = deriveTestMetadata(failureFolder);
+    const v1 = await (0, runner_1.runQualityIntelligence)(playwrightResultsDir);
+    const normalized = normalizeFailure(v1.dominantCategory, failureFolder);
+    line();
+    console.log("QUALITY INTELLIGENCE – FINAL PROJECT OUTPUT");
+    line();
+    console.log(`Test Case        : ${meta.testName}`);
+    console.log(`Test Location    : ${meta.testLocation}`);
+    console.log(`Primary Failure  : ${normalized.primary}`);
+    console.log(`Failure Domain   : ${normalized.domain}`);
+    console.log(`Confidence Score : ${v1.confidence}`);
+    console.log(`Trend Signal     : ${v1.trend?.signal ?? "STABLE"}`);
+    line("-");
+    console.log("WHAT FAILED:");
+    console.log(normalized.primary === "UI_VALIDATION_FAILURE"
+        ? "  UI validation error occurred during user input"
+        : normalized.primary === "NUMERIC_MISMATCH"
+            ? "  Numeric values returned by backend do not match expected results"
+            : "  Test failure detected");
+    line("-");
+    console.log("WHY IT FAILED:");
+    v1.intelligence.confidence.explanation.forEach(e => console.log(`  • ${e}`));
+    line("-");
+    console.log("WHAT TO DO NEXT:");
+    if (normalized.domain === "UI") {
+        console.log("  • Review UI validation rules and test assertions");
+    }
+    else if (normalized.domain === "API") {
+        console.log("  • Verify backend calculations and API responses");
+    }
+    else {
+        console.log("  • Review screenshot and trace manually");
+    }
+    const v2 = await (0, v2_intelligence_pipeline_1.runV2Intelligence)(failureFolder, normalized.primary, "Derived from Playwright failure artifacts");
+    line("-");
+    console.log("TRACE & SELF-HEALING INTELLIGENCE");
+    console.log("Evidence:");
+    v2.trace.screenshots.forEach(s => console.log(`  Screenshot: ${s}`));
+    line("-");
+    console.log("Self-Healing Decision:");
+    console.log("  Allowed     : NO (requires human decision)");
+    line();
+}
+/* ===================================================== */
+/* CLI SUPPORT                                           */
+/* ===================================================== */
+if (require.main === module) {
+    runFinal();
+}

package/dist/src/final-runner.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFinalOutput = runFinalOutput;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+async function runFinalOutput(options) {
+    const args = [];
+    if (options.showIssues) {
+        args.push("--issue");
+    }
+    // run existing final-run.ts via ts-node / node
+    const scriptPath = path_1.default.join(__dirname, "final-run.ts");
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)("node", ["--loader", "ts-node/esm", scriptPath, ...args], {
+            stdio: "inherit"
+        });
+        proc.on("close", code => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`final-run exited with ${code}`));
+        });
+    });
+}

package/dist/src/fixtures/networkCollector.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = void 0;
+const test_1 = require("@playwright/test");
+exports.test = test_1.test.extend({
+    networkResponses: async ({ page }, use) => {
+        const responses = [];
+        page.on('response', async (response) => {
+            responses.push({
+                url: response.url(),
+                method: response.request().method(),
+                status: response.status(),
+                ok: response.ok()
+            });
+        });
+        await use(responses);
+    }
+});

package/dist/src/history/failure-history.store.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveFailureHistory = saveFailureHistory;
+exports.loadFailureHistory = loadFailureHistory;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const HISTORY_DIR = path_1.default.join(process.cwd(), "artifacts/failure-history");
+function saveFailureHistory(entry) {
+    if (!fs_1.default.existsSync(HISTORY_DIR)) {
+        fs_1.default.mkdirSync(HISTORY_DIR, { recursive: true });
+    }
+    const filePath = path_1.default.join(HISTORY_DIR, `${entry.runId}.json`);
+    fs_1.default.writeFileSync(filePath, JSON.stringify(entry, null, 2));
+}
+function loadFailureHistory() {
+    if (!fs_1.default.existsSync(HISTORY_DIR))
+        return [];
+    return fs_1.default.readdirSync(HISTORY_DIR).map(file => {
+        const fullPath = path_1.default.join(HISTORY_DIR, file);
+        return JSON.parse(fs_1.default.readFileSync(fullPath, "utf-8"));
+    });
+}