agentcert 0.1.0

package/dist/corpus-store.js

@@ -0,0 +1,241 @@
+import { mkdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { appendCorpusRecords, readCorpus } from "./corpus.js";
+const DEFAULT_TABLE_NAME = "agentcert_corpus_records";
+export async function openCorpusStore(options) {
+    const kind = options.kind ?? "jsonl";
+    if (kind === "jsonl") {
+        return createJsonlCorpusStore(options.jsonlPath ?? ".agentcert/corpus/corpus.jsonl");
+    }
+    if (kind === "sqlite") {
+        return createSqliteCorpusStore(options.sqlitePath ?? ".agentcert/corpus/agentcert.sqlite", options.tableName);
+    }
+    if (kind === "postgres") {
+        if (!options.databaseUrl) {
+            throw new Error("Postgres corpus store requires --database-url or AGENTCERT_DATABASE_URL.");
+        }
+        return createPostgresCorpusStore(options.databaseUrl, options.tableName);
+    }
+    throw new Error(`Unsupported corpus store: ${kind}`);
+}
+export function parseCorpusStoreKind(input) {
+    const value = input ?? "jsonl";
+    if (value === "jsonl" || value === "sqlite" || value === "postgres") {
+        return value;
+    }
+    throw new Error(`Unsupported corpus store "${value}". Use jsonl, sqlite, or postgres.`);
+}
+export function validateCorpusTableName(input) {
+    const tableName = input ?? DEFAULT_TABLE_NAME;
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(tableName)) {
+        throw new Error("Corpus table name must contain only letters, numbers, and underscores, and cannot start with a number.");
+    }
+    return tableName;
+}
+function createJsonlCorpusStore(path) {
+    return {
+        kind: "jsonl",
+        description: `JSONL corpus at ${resolve(path)}`,
+        append: (records, options) => appendCorpusRecords(path, records, options?.replace ?? false),
+        readAll: () => readCorpus(path),
+        close: async () => { },
+    };
+}
+async function createSqliteCorpusStore(path, tableNameInput) {
+    const tableName = validateCorpusTableName(tableNameInput);
+    const table = quoteIdentifier(tableName);
+    const outPath = resolve(path);
+    await mkdir(dirname(outPath), { recursive: true });
+    let sqlite;
+    try {
+        sqlite = await import("node:sqlite");
+    }
+    catch {
+        throw new Error("SQLite corpus store requires Node.js 22+ with node:sqlite available. Use --store jsonl on Node 20.");
+    }
+    const db = new sqlite.DatabaseSync(outPath);
+    db.exec(corpusTableSql(table));
+    db.exec(indexSqls(tableName, table).join(";\n"));
+    const insert = db.prepare(insertSql(table));
+    const select = db.prepare(`SELECT record_json FROM ${table} ORDER BY timestamp DESC, id ASC`);
+    return {
+        kind: "sqlite",
+        description: `SQLite corpus at ${outPath}`,
+        append: async (records, options) => {
+            if (options?.replace) {
+                db.exec(`DELETE FROM ${table}`);
+            }
+            db.exec("BEGIN");
+            try {
+                for (const record of records) {
+                    insert.run(...recordSqlValues(record, "sqlite"), JSON.stringify(record));
+                }
+                db.exec("COMMIT");
+            }
+            catch (error) {
+                db.exec("ROLLBACK");
+                throw error;
+            }
+        },
+        readAll: async () => select.all().map((row) => JSON.parse(row.record_json)),
+        close: async () => {
+            db.close();
+        },
+    };
+}
+async function createPostgresCorpusStore(databaseUrl, tableNameInput) {
+    const tableName = validateCorpusTableName(tableNameInput);
+    const table = quoteIdentifier(tableName);
+    const pg = await importOptionalPg();
+    const client = new pg.Client({ connectionString: databaseUrl });
+    await client.connect();
+    await client.query(corpusTableSql(table, "jsonb"));
+    for (const sql of indexSqls(tableName, table)) {
+        await client.query(sql);
+    }
+    return {
+        kind: "postgres",
+        description: `Postgres corpus table ${tableName}`,
+        append: async (records, options) => {
+            if (options?.replace) {
+                await client.query(`DELETE FROM ${table}`);
+            }
+            await client.query("BEGIN");
+            try {
+                for (const record of records) {
+                    await client.query(insertSql(table, "$"), [...recordSqlValues(record, "postgres"), JSON.stringify(record)]);
+                }
+                await client.query("COMMIT");
+            }
+            catch (error) {
+                await client.query("ROLLBACK");
+                throw error;
+            }
+        },
+        readAll: async () => {
+            const result = await client.query(`SELECT record_json FROM ${table} ORDER BY timestamp DESC, id ASC`);
+            return result.rows.map((row) => recordFromDatabaseJson(row.record_json));
+        },
+        close: async () => {
+            await client.end();
+        },
+    };
+}
+function corpusTableSql(table, jsonType = "TEXT") {
+    return `
+CREATE TABLE IF NOT EXISTS ${table} (
+  id TEXT PRIMARY KEY,
+  ingested_at TEXT NOT NULL,
+  subject TEXT NOT NULL,
+  product TEXT NOT NULL,
+  phase TEXT NOT NULL,
+  agent_name TEXT NOT NULL,
+  agent_version TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  timestamp TEXT NOT NULL,
+  passed BOOLEAN NOT NULL,
+  score REAL NOT NULL,
+  scenario_name TEXT,
+  fault_name TEXT,
+  evidence_count INTEGER NOT NULL,
+  high_or_critical_evidence_count INTEGER NOT NULL,
+  failure_types TEXT NOT NULL,
+  source_path TEXT NOT NULL,
+  record_json ${jsonType} NOT NULL
+)`;
+}
+function indexSqls(tableName, table) {
+    return [
+        `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${tableName}_product_idx`)} ON ${table} (product)`,
+        `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${tableName}_timestamp_idx`)} ON ${table} (timestamp)`,
+        `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${tableName}_fault_idx`)} ON ${table} (fault_name)`,
+        `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${tableName}_agent_idx`)} ON ${table} (agent_name)`,
+        `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${tableName}_version_idx`)} ON ${table} (agent_version)`,
+    ];
+}
+function insertSql(table, placeholderPrefix = "?") {
+    const values = placeholderPrefix === "?"
+        ? new Array(18).fill("?").join(", ")
+        : new Array(18)
+            .fill(undefined)
+            .map((_, index) => `$${index + 1}`)
+            .join(", ");
+    return `
+INSERT INTO ${table} (
+  id,
+  ingested_at,
+  subject,
+  product,
+  phase,
+  agent_name,
+  agent_version,
+  run_id,
+  timestamp,
+  passed,
+  score,
+  scenario_name,
+  fault_name,
+  evidence_count,
+  high_or_critical_evidence_count,
+  failure_types,
+  source_path,
+  record_json
+) VALUES (${values})
+ON CONFLICT(id) DO UPDATE SET
+  ingested_at = excluded.ingested_at,
+  subject = excluded.subject,
+  product = excluded.product,
+  phase = excluded.phase,
+  agent_name = excluded.agent_name,
+  agent_version = excluded.agent_version,
+  run_id = excluded.run_id,
+  timestamp = excluded.timestamp,
+  passed = excluded.passed,
+  score = excluded.score,
+  scenario_name = excluded.scenario_name,
+  fault_name = excluded.fault_name,
+  evidence_count = excluded.evidence_count,
+  high_or_critical_evidence_count = excluded.high_or_critical_evidence_count,
+  failure_types = excluded.failure_types,
+  source_path = excluded.source_path,
+  record_json = excluded.record_json`;
+}
+function recordSqlValues(record, dialect) {
+    return [
+        record.id,
+        record.ingestedAt,
+        record.subject,
+        record.product,
+        record.phase,
+        record.agentName,
+        record.agentVersion,
+        record.runId,
+        record.timestamp,
+        dialect === "sqlite" ? Number(record.passed) : record.passed,
+        record.score,
+        record.scenarioName ?? null,
+        record.faultName ?? null,
+        record.evidenceCount,
+        record.highOrCriticalEvidenceCount,
+        [...new Set(record.failurePatterns.map((pattern) => pattern.type))].join(","),
+        record.sourcePath,
+    ];
+}
+function quoteIdentifier(input) {
+    return `"${validateCorpusTableName(input)}"`;
+}
+function recordFromDatabaseJson(input) {
+    if (typeof input === "string") {
+        return JSON.parse(input);
+    }
+    return input;
+}
+async function importOptionalPg() {
+    try {
+        const dynamicImport = new Function("specifier", "return import(specifier)");
+        return (await dynamicImport("pg"));
+    }
+    catch {
+        throw new Error("Postgres corpus store requires the optional dependency 'pg'. Run npm install in packages/agentcert-cli.");
+    }
+}

package/dist/corpus.js

@@ -0,0 +1,435 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+export function recordsFromAgentCertResult(result, sourcePath, subject, rawInput, ingestedAt = new Date().toISOString()) {
+    if (result.product === "tripwire-ci") {
+        const tripwireRecords = recordsFromTripwireInput(result, sourcePath, subject, rawInput, ingestedAt);
+        if (tripwireRecords.length > 0) {
+            return tripwireRecords;
+        }
+    }
+    return [
+        {
+            schemaVersion: "1",
+            kind: "product_run",
+            id: stableRecordId([subject, result.product, result.runId, sourcePath]),
+            ingestedAt,
+            subject,
+            agentName: subject,
+            agentVersion: "unversioned",
+            product: result.product,
+            phase: result.phase,
+            runId: result.runId,
+            timestamp: result.timestamp,
+            score: result.score,
+            passed: result.passed,
+            evidenceCount: result.evidence.length,
+            highOrCriticalEvidenceCount: countHighOrCritical(result.evidence),
+            failurePatterns: result.passed ? [] : failurePatternsFromEvidence(result.evidence),
+            artifacts: result.artifacts,
+            sourcePath,
+            metadata: result.summary ? { summary: result.summary } : undefined,
+        },
+    ];
+}
+export function summarizeCorpus(records) {
+    const totalRecords = records.length;
+    const passedRecords = records.filter((record) => record.passed).length;
+    const failedRecords = totalRecords - passedRecords;
+    return {
+        totalRecords,
+        passedRecords,
+        failedRecords,
+        passRate: ratio(passedRecords, totalRecords),
+        byProduct: bucket(records, (record) => record.product),
+        byFault: bucket(records.filter((record) => record.faultName), (record) => record.faultName ?? "unknown"),
+        byAgent: bucket(records, (record) => record.agentName),
+        byVersion: bucket(records, (record) => record.agentVersion),
+        byFailureType: bucket(records.flatMap((record) => record.failurePatterns.map((pattern) => ({
+            ...record,
+            failureTypeForBucket: pattern.type,
+            passed: false,
+        }))), (record) => record.failureTypeForBucket ?? "unknown_failure"),
+        taxonomy: taxonomySummary(records),
+        topFailurePatterns: topFailurePatterns(records),
+    };
+}
+export function reviewedFailureDataset(records) {
+    return records.flatMap((record) => record.failurePatterns
+        .filter(isReviewedPattern)
+        .map((pattern) => ({
+        schemaVersion: "1",
+        kind: "agentcert.reviewed_failure",
+        id: stableRecordId([record.id, pattern.key, pattern.reviewId ?? pattern.reviewedAt ?? pattern.type]),
+        recordId: record.id,
+        subject: record.subject,
+        agentName: record.agentName,
+        agentVersion: record.agentVersion,
+        product: record.product,
+        phase: record.phase,
+        runId: record.runId,
+        timestamp: record.timestamp,
+        scenarioName: record.scenarioName,
+        faultName: record.faultName,
+        patternKey: pattern.key,
+        severity: pattern.severity,
+        message: pattern.message,
+        suggestedType: pattern.suggestedType ?? pattern.type,
+        reviewedType: pattern.type,
+        reviewStatus: pattern.reviewStatus,
+        reviewer: pattern.reviewer,
+        reviewedAt: pattern.reviewedAt,
+        reviewConfidence: pattern.reviewConfidence,
+        firstDivergenceSnippet: pattern.reviewEvidenceContext?.firstDivergenceSnippet,
+        screenshotPath: pattern.reviewEvidenceContext?.screenshotPath,
+        screenshotUrl: pattern.reviewEvidenceContext?.screenshotUrl,
+        tracePath: pattern.reviewEvidenceContext?.tracePath,
+        stepIndex: pattern.reviewEvidenceContext?.stepIndex,
+        taxonomyRationale: pattern.taxonomyRationale,
+        sourcePath: record.sourcePath,
+    })));
+}
+export function evaluateFailureClassifier(records) {
+    const rows = reviewedFailureDataset(records);
+    const correctRows = rows.filter((row) => row.suggestedType === row.reviewedType).length;
+    const byTypeBuckets = new Map();
+    const confusionBuckets = new Map();
+    for (const row of rows) {
+        const byType = byTypeBuckets.get(row.reviewedType) ?? { reviewedRows: 0, correctRows: 0 };
+        byType.reviewedRows += 1;
+        if (row.suggestedType === row.reviewedType)
+            byType.correctRows += 1;
+        byTypeBuckets.set(row.reviewedType, byType);
+        const confusionKey = `${row.suggestedType}->${row.reviewedType}`;
+        const confusion = confusionBuckets.get(confusionKey) ?? {
+            suggestedType: row.suggestedType,
+            reviewedType: row.reviewedType,
+            count: 0,
+        };
+        confusion.count += 1;
+        confusionBuckets.set(confusionKey, confusion);
+    }
+    const totalFailurePatterns = records.reduce((sum, record) => sum + record.failurePatterns.length, 0);
+    return {
+        schemaVersion: "1",
+        kind: "agentcert.failure_classifier_evaluation",
+        reviewedRows: rows.length,
+        correctRows,
+        incorrectRows: rows.length - correctRows,
+        precision: ratio(correctRows, rows.length),
+        coverage: ratio(rows.length, totalFailurePatterns),
+        byType: [...byTypeBuckets.entries()]
+            .map(([type, bucket]) => ({
+            type,
+            reviewedRows: bucket.reviewedRows,
+            correctRows: bucket.correctRows,
+            precision: ratio(bucket.correctRows, bucket.reviewedRows),
+        }))
+            .sort((left, right) => left.type.localeCompare(right.type)),
+        confusion: [...confusionBuckets.values()].sort((left, right) => right.count - left.count || left.suggestedType.localeCompare(right.suggestedType)),
+    };
+}
+export async function writeReviewedFailureDataset(path, records) {
+    const rows = reviewedFailureDataset(records);
+    const outPath = resolve(path);
+    await mkdir(dirname(outPath), { recursive: true });
+    const payload = rows.map((row) => JSON.stringify(row)).join("\n");
+    await writeFile(outPath, `${payload}${payload.length > 0 ? "\n" : ""}`);
+    return rows;
+}
+export async function appendCorpusRecords(path, records, replace = false) {
+    const outPath = resolve(path);
+    await mkdir(dirname(outPath), { recursive: true });
+    const payload = records.map((record) => JSON.stringify(record)).join("\n");
+    const prefix = replace ? "" : await existingCorpus(outPath);
+    const separator = prefix.length > 0 && payload.length > 0 ? "\n" : "";
+    await writeFile(outPath, `${prefix}${separator}${payload}${payload.length > 0 ? "\n" : ""}`);
+}
+export async function readCorpus(path) {
+    const raw = await readFile(resolve(path), "utf8");
+    return raw
+        .split(/\r?\n/)
+        .filter((line) => line.trim().length > 0)
+        .map((line) => JSON.parse(line));
+}
+export function renderCorpusSummary(summary) {
+    const lines = [
+        "# AgentCert Corpus Summary",
+        "",
+        `Total records: ${summary.totalRecords}`,
+        `Passed: ${summary.passedRecords}`,
+        `Failed: ${summary.failedRecords}`,
+        `Pass rate: ${(summary.passRate * 100).toFixed(1)}%`,
+        `Taxonomy review coverage: ${(summary.taxonomy.reviewCoverage * 100).toFixed(1)}%`,
+        `Reviewed-label precision: ${(summary.taxonomy.autoLabelPrecision * 100).toFixed(1)}%`,
+        `Correction rate: ${(summary.taxonomy.correctionRate * 100).toFixed(1)}%`,
+        "",
+        "## By Product",
+        ...renderBuckets(summary.byProduct),
+        "",
+        "## By Fault",
+        ...renderBuckets(summary.byFault),
+        "",
+        "## Top Failure Patterns",
+        ...summary.topFailurePatterns.map((pattern) => `- ${pattern.key}: ${pattern.count} (${pattern.severity}) - ${pattern.message}`),
+    ];
+    return `${lines.join("\n")}\n`;
+}
+function recordsFromTripwireInput(result, sourcePath, subject, rawInput, ingestedAt) {
+    const input = asRecord(rawInput);
+    const runs = Array.isArray(input.runs) ? input.runs : [];
+    return runs.map((run, index) => {
+        const record = asRecord(run);
+        const assertions = Array.isArray(record.assertions) ? record.assertions.map(asRecord) : [];
+        const failedAssertions = assertions.filter((assertion) => assertion.pass === false);
+        const scenarioName = stringValue(record.scenarioName);
+        const faultName = stringValue(record.faultName);
+        const runId = stringValue(record.runId) ?? `${result.runId}_${index + 1}`;
+        const passed = record.status === "passed";
+        const agent = asRecord(record.agent);
+        const agentEnv = asRecord(agent.env);
+        const agentName = agentNameFromTripwireRun(agent, subject);
+        const agentVersion = stringValue(agentEnv.AGENTCERT_AGENT_VERSION) ?? stringValue(agentEnv.AGENT_VERSION) ?? "unversioned";
+        const failurePatterns = failedAssertions.map((assertion) => {
+            const assertionType = stringValue(assertion.type) ?? "assertion";
+            const message = stringValue(assertion.message) ?? "Tripwire assertion failed.";
+            const failureType = classifyTripwireFailure({
+                faultName,
+                assertionType,
+                message,
+                run: record,
+            });
+            return {
+                key: `tripwire:${failureType}:${faultName ?? "unknown"}:${assertionType}`,
+                severity: "high",
+                message,
+                type: failureType,
+                suggestedType: failureType,
+                reviewStatus: "unreviewed",
+                scenarioName,
+                faultName,
+            };
+        });
+        if (!passed && failurePatterns.length === 0) {
+            const failureType = classifyTripwireFailure({
+                faultName,
+                assertionType: "run_status",
+                message: "Tripwire run failed without a failed assertion.",
+                run: record,
+            });
+            failurePatterns.push({
+                key: `tripwire:${failureType}:${faultName ?? "unknown"}:run_status`,
+                severity: "high",
+                message: "Tripwire run failed without a failed assertion.",
+                type: failureType,
+                suggestedType: failureType,
+                reviewStatus: "unreviewed",
+                scenarioName,
+                faultName,
+            });
+        }
+        return {
+            schemaVersion: "1",
+            kind: "scenario_run",
+            id: stableRecordId([subject, result.product, runId, sourcePath]),
+            ingestedAt,
+            subject,
+            agentName,
+            agentVersion,
+            product: result.product,
+            phase: result.phase,
+            runId,
+            timestamp: stringValue(record.startedAt) ?? result.timestamp,
+            score: passed ? 100 : 0,
+            passed,
+            scenarioName,
+            faultName,
+            durationMs: numberValue(record.durationMs),
+            stepCount: numberValue(record.stepCount),
+            evidenceCount: failedAssertions.length,
+            highOrCriticalEvidenceCount: failedAssertions.length,
+            failurePatterns,
+            artifacts: {
+                result: sourcePath,
+                trace: stringValue(record.tracePath) ?? "",
+                artifactDir: stringValue(record.artifactDir) ?? "",
+            },
+            sourcePath,
+            metadata: {
+                finalUrl: stringValue(record.finalUrl),
+                diagnostics: Array.isArray(record.diagnostics) ? record.diagnostics : [],
+                warnings: Array.isArray(record.warnings) ? record.warnings : [],
+                failureTypes: [...new Set(failurePatterns.map((pattern) => pattern.type))],
+            },
+        };
+    });
+}
+function failurePatternsFromEvidence(evidence) {
+    return evidence
+        .filter((item) => item.severity === "critical" || item.severity === "high" || item.severity === "medium")
+        .map((item) => {
+        const metadata = asRecord(item.metadata);
+        return {
+            key: `${item.source ?? "agentcert"}:${stringValue(metadata.faultName) ?? item.kind}`,
+            severity: item.severity,
+            message: item.message,
+            type: classifyEvidenceFailure(item),
+            suggestedType: classifyEvidenceFailure(item),
+            reviewStatus: "unreviewed",
+            scenarioName: stringValue(metadata.scenarioName),
+            faultName: stringValue(metadata.faultName),
+        };
+    });
+}
+function taxonomySummary(records) {
+    const patterns = records.flatMap((record) => record.failurePatterns);
+    const confirmedFailurePatterns = patterns.filter((pattern) => pattern.reviewStatus === "confirmed").length;
+    const correctedFailurePatterns = patterns.filter((pattern) => pattern.reviewStatus === "corrected").length;
+    const reviewedFailurePatterns = confirmedFailurePatterns + correctedFailurePatterns;
+    const reviewedPatterns = patterns.filter(isReviewedPattern);
+    const confidenceValues = reviewedPatterns
+        .map((pattern) => pattern.reviewConfidence)
+        .filter((value) => typeof value === "number" && Number.isFinite(value));
+    return {
+        totalFailurePatterns: patterns.length,
+        reviewedFailurePatterns,
+        unreviewedFailurePatterns: patterns.length - reviewedFailurePatterns,
+        confirmedFailurePatterns,
+        correctedFailurePatterns,
+        reviewCoverage: ratio(reviewedFailurePatterns, patterns.length),
+        autoLabelPrecision: ratio(confirmedFailurePatterns, reviewedFailurePatterns),
+        correctionRate: ratio(correctedFailurePatterns, reviewedFailurePatterns),
+        meanReviewerConfidence: confidenceValues.length === 0 ? undefined : confidenceValues.reduce((sum, value) => sum + value, 0) / confidenceValues.length,
+    };
+}
+function topFailurePatterns(records) {
+    const counts = new Map();
+    for (const pattern of records.flatMap((record) => record.failurePatterns)) {
+        const current = counts.get(pattern.key);
+        counts.set(pattern.key, {
+            count: (current?.count ?? 0) + 1,
+            message: current?.message ?? pattern.message,
+            severity: current?.severity ?? pattern.severity,
+            type: current?.type ?? pattern.type,
+        });
+    }
+    return [...counts.entries()]
+        .map(([key, value]) => ({ key, ...value }))
+        .sort((left, right) => right.count - left.count || left.key.localeCompare(right.key))
+        .slice(0, 10);
+}
+function bucket(records, keyFor) {
+    const buckets = new Map();
+    for (const record of records) {
+        const key = keyFor(record);
+        const current = buckets.get(key) ?? { total: 0, passed: 0 };
+        current.total += 1;
+        if (record.passed)
+            current.passed += 1;
+        buckets.set(key, current);
+    }
+    return [...buckets.entries()]
+        .map(([key, value]) => ({
+        key,
+        total: value.total,
+        passed: value.passed,
+        failed: value.total - value.passed,
+        passRate: ratio(value.passed, value.total),
+    }))
+        .sort((left, right) => right.total - left.total || left.key.localeCompare(right.key));
+}
+function classifyTripwireFailure(input) {
+    const fault = input.faultName ?? "";
+    const assertion = input.assertionType;
+    const message = input.message.toLowerCase();
+    const diagnostics = stringArray(input.run.diagnostics).join(" ").toLowerCase();
+    const warnings = stringArray(input.run.warnings).join(" ").toLowerCase();
+    const agentResult = asRecord(input.run.agentResult);
+    if (agentResult.timedOut === true || assertion === "max_steps" || message.includes("timed out"))
+        return "timeout";
+    if (fault.includes("prompt-injection") || assertion === "no_sensitive_text_in_output" || message.includes("ignore previous instructions")) {
+        return "prompt_injection";
+    }
+    if (fault.includes("misleading-button") || message.includes("wrong button") || message.includes("cancel"))
+        return "wrong_click";
+    if (fault.includes("button-text-drift") || fault.includes("layout-shift") || fault.includes("modal-overlay") || fault.includes("disabled-submit")) {
+        return "ui_drift";
+    }
+    if (fault.includes("slow-network") || fault.includes("http-failure") || message.includes("network") || message.includes("503")) {
+        return "network_failure";
+    }
+    if (assertion === "no_console_error" || message.includes("console"))
+        return "console_error";
+    if (diagnostics.includes("did not appear to connect") || warnings.includes("did not appear to connect"))
+        return "agent_connection";
+    if (agentResult.exitCode === 0 && (assertion === "url_contains" || assertion === "text_exists"))
+        return "silent_partial_success";
+    return "assertion_failure";
+}
+function isReviewedPattern(pattern) {
+    return pattern.reviewStatus === "confirmed" || pattern.reviewStatus === "corrected";
+}
+function classifyEvidenceFailure(evidence) {
+    const kind = evidence.kind.toLowerCase();
+    const message = evidence.message.toLowerCase();
+    if (kind.includes("verification") || message.includes("did not match expected"))
+        return "verification_gap";
+    if (kind.includes("approval") || kind.includes("policy") || message.includes("approval"))
+        return "policy_or_approval";
+    if (kind.includes("timeout") || message.includes("timeout"))
+        return "timeout";
+    if (kind.includes("prompt") || message.includes("prompt injection"))
+        return "prompt_injection";
+    return "unknown_failure";
+}
+function agentNameFromTripwireRun(agent, fallback) {
+    const args = Array.isArray(agent.args) ? agent.args.filter((item) => typeof item === "string") : [];
+    const command = stringValue(agent.command);
+    const candidate = [...args].reverse().find((arg) => /agent|browser-use|stagehand|playwright/i.test(arg));
+    if (candidate) {
+        return candidate
+            .split(/[\\/]/)
+            .pop()
+            ?.replace(/\.(mjs|js|py|ts)$/i, "")
+            .replace(/[_-]+/g, " ") ?? fallback;
+    }
+    return command ?? fallback;
+}
+function renderBuckets(buckets) {
+    if (buckets.length === 0) {
+        return ["- none"];
+    }
+    return buckets.map((bucket) => `- ${bucket.key}: ${bucket.passed}/${bucket.total} passed (${(bucket.passRate * 100).toFixed(1)}%), ${bucket.failed} failed`);
+}
+function stringArray(input) {
+    return Array.isArray(input) ? input.filter((item) => typeof item === "string") : [];
+}
+async function existingCorpus(path) {
+    try {
+        return (await readFile(path, "utf8")).trimEnd();
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function countHighOrCritical(evidence) {
+    return evidence.filter((item) => item.severity === "critical" || item.severity === "high").length;
+}
+function stableRecordId(parts) {
+    return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+}
+function ratio(numerator, denominator) {
+    return denominator === 0 ? 0 : numerator / denominator;
+}
+function asRecord(input) {
+    return input && typeof input === "object" && !Array.isArray(input) ? input : {};
+}
+function stringValue(input) {
+    return typeof input === "string" && input.length > 0 ? input : undefined;
+}
+function numberValue(input) {
+    return typeof input === "number" && Number.isFinite(input) ? input : undefined;
+}