@veewo/gitnexus 1.4.11-rc.2 → 1.5.0-rc

package/dist/benchmark/u2-e2e/hydration-policy-repeatability-runner.d.ts

@@ -0,0 +1,55 @@
+type PolicyName = 'fast' | 'balanced' | 'strict';
+interface PolicyModeObservation {
+    requestedMode?: string;
+    effectiveMode?: string;
+    reason?: string;
+    needsParityRetry?: boolean;
+}
+export interface HydrationPolicyRepeatabilityReport {
+    generatedAt: string;
+    repoAlias: string;
+    repeatability: Record<PolicyName, {
+        consistent: boolean;
+        runCount: number;
+        mismatchCount: number;
+    }>;
+    policy_mode_matrix: Record<PolicyName, {
+        compact: PolicyModeObservation;
+        parity: PolicyModeObservation;
+    }>;
+    policy_mapping: {
+        fast: {
+            requested: string;
+            effective: string;
+            reason?: string;
+        };
+        balanced: {
+            compact_requested: string;
+            parity_requested: string;
+            escalation?: string;
+        };
+        strict: {
+            requested: string;
+            effective: string;
+            reason?: string;
+            downgradeOnFallback: 'verified_partial/verified_segment';
+        };
+    };
+    missing_evidence_contract: {
+        requiresArray: boolean;
+        populatedWhenIncomplete: boolean;
+    };
+    contractCompatibility: {
+        needsParityRetryRetained: boolean;
+    };
+    warmup_cache_state: {
+        parityWarmupEnabled: boolean;
+        note: string;
+    };
+}
+export declare function buildHydrationPolicyRepeatabilityReport(input: {
+    repoAlias: string;
+    runCount?: number;
+}): Promise<HydrationPolicyRepeatabilityReport>;
+export declare function writeHydrationPolicyRepeatabilityReport(outPath: string, report: HydrationPolicyRepeatabilityReport): Promise<void>;
+export {};

package/dist/benchmark/u2-e2e/hydration-policy-repeatability-runner.js

@@ -0,0 +1,190 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { LocalBackend } from '../../mcp/local/local-backend.js';
+import { resolveUnityConfig } from '../../core/config/unity-config.js';
+function observeHydrationMeta(out) {
+    if (out?.hydrationMeta) {
+        return {
+            requestedMode: out.hydrationMeta.requestedMode,
+            effectiveMode: out.hydrationMeta.effectiveMode,
+            reason: out.hydrationMeta.reason,
+            needsParityRetry: out.hydrationMeta.needsParityRetry,
+        };
+    }
+    return {
+        reason: out?.error
+            ? `missing_hydration_meta:${String(out.error)}`
+            : 'missing_hydration_meta:no_hydration_payload',
+    };
+}
+function snapshotFromResponse(out) {
+    return {
+        status: String(out?.runtime_claim?.status || 'unknown'),
+        evidence_level: String(out?.runtime_claim?.evidence_level || 'none'),
+        reason: out?.runtime_claim?.reason ? String(out.runtime_claim.reason) : undefined,
+        fallbackToCompact: Boolean(out?.hydrationMeta?.fallbackToCompact),
+    };
+}
+async function callPolicyProbe(input) {
+    const queryOut = await input.backend.callTool('query', {
+        repo: input.repoAlias,
+        query: 'Reload',
+        unity_resources: 'on',
+        hydration_policy: input.policy,
+        unity_hydration_mode: input.mode,
+        runtime_chain_verify: 'on-demand',
+    });
+    if (queryOut?.hydrationMeta) {
+        return queryOut;
+    }
+    return input.backend.callTool('context', {
+        repo: input.repoAlias,
+        name: 'ReloadBase',
+        file_path: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
+        unity_resources: 'on',
+        hydration_policy: input.policy,
+        unity_hydration_mode: input.mode,
+        runtime_chain_verify: 'on-demand',
+    });
+}
+function classifyConsistency(rows) {
+    if (rows.length <= 1)
+        return { consistent: true, mismatchCount: 0 };
+    const first = JSON.stringify(rows[0]);
+    let mismatchCount = 0;
+    for (let i = 1; i < rows.length; i += 1) {
+        if (JSON.stringify(rows[i]) !== first)
+            mismatchCount += 1;
+    }
+    return { consistent: mismatchCount === 0, mismatchCount };
+}
+export async function buildHydrationPolicyRepeatabilityReport(input) {
+    const backend = new LocalBackend();
+    const ready = await backend.init();
+    if (!ready) {
+        throw new Error('LocalBackend failed to initialize for hydration policy repeatability runner');
+    }
+    const runCount = Math.max(1, Number(input.runCount || 3));
+    const policies = ['fast', 'balanced', 'strict'];
+    const snapshotsByPolicy = new Map();
+    let requiresArray = true;
+    let populatedWhenIncomplete = true;
+    let needsParityRetryRetained = true;
+    for (const policy of policies) {
+        const snapshots = [];
+        for (let i = 0; i < runCount; i += 1) {
+            const out = await callPolicyProbe({
+                backend,
+                repoAlias: input.repoAlias,
+                policy,
+                mode: 'compact',
+            });
+            snapshots.push(snapshotFromResponse(out));
+            const missingEvidence = out?.missing_evidence;
+            if (missingEvidence !== undefined && !Array.isArray(missingEvidence)) {
+                requiresArray = false;
+            }
+            if (out?.hydrationMeta?.isComplete === false && (!Array.isArray(missingEvidence) || missingEvidence.length === 0)) {
+                populatedWhenIncomplete = false;
+            }
+            if (out?.hydrationMeta?.effectiveMode === 'compact' && out?.hydrationMeta?.isComplete === false) {
+                if (typeof out?.hydrationMeta?.needsParityRetry !== 'boolean') {
+                    needsParityRetryRetained = false;
+                }
+            }
+        }
+        snapshotsByPolicy.set(policy, snapshots);
+    }
+    const fastConsistency = classifyConsistency(snapshotsByPolicy.get('fast') || []);
+    const balancedConsistency = classifyConsistency(snapshotsByPolicy.get('balanced') || []);
+    const strictConsistency = classifyConsistency(snapshotsByPolicy.get('strict') || []);
+    const strictRows = snapshotsByPolicy.get('strict') || [];
+    const strictFallbackDowngraded = strictRows.every((row) => {
+        if (!row.fallbackToCompact)
+            return true;
+        return row.status === 'verified_partial' && row.evidence_level === 'verified_segment';
+    });
+    const policy_mode_matrix = {};
+    for (const policy of policies) {
+        const compactOut = await callPolicyProbe({
+            backend,
+            repoAlias: input.repoAlias,
+            policy,
+            mode: 'compact',
+        });
+        const parityOut = await callPolicyProbe({
+            backend,
+            repoAlias: input.repoAlias,
+            policy,
+            mode: 'parity',
+        });
+        policy_mode_matrix[policy] = {
+            compact: observeHydrationMeta(compactOut),
+            parity: observeHydrationMeta(parityOut),
+        };
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        repoAlias: input.repoAlias,
+        repeatability: {
+            fast: { consistent: fastConsistency.consistent, runCount, mismatchCount: fastConsistency.mismatchCount },
+            balanced: { consistent: balancedConsistency.consistent, runCount, mismatchCount: balancedConsistency.mismatchCount },
+            strict: { consistent: strictConsistency.consistent && strictFallbackDowngraded, runCount, mismatchCount: strictConsistency.mismatchCount },
+        },
+        policy_mode_matrix,
+        policy_mapping: {
+            fast: {
+                requested: policy_mode_matrix.fast.compact.requestedMode || 'compact',
+                effective: policy_mode_matrix.fast.compact.effectiveMode || 'compact',
+                reason: policy_mode_matrix.fast.compact.reason,
+            },
+            balanced: {
+                compact_requested: policy_mode_matrix.balanced.compact.requestedMode || 'compact',
+                parity_requested: policy_mode_matrix.balanced.parity.requestedMode || 'compact',
+                escalation: 'parity_on_missing_evidence',
+            },
+            strict: {
+                requested: policy_mode_matrix.strict.compact.requestedMode || 'parity',
+                effective: policy_mode_matrix.strict.compact.effectiveMode || 'parity',
+                reason: policy_mode_matrix.strict.compact.reason,
+                downgradeOnFallback: 'verified_partial/verified_segment',
+            },
+        },
+        missing_evidence_contract: {
+            requiresArray,
+            populatedWhenIncomplete,
+        },
+        contractCompatibility: {
+            needsParityRetryRetained,
+        },
+        warmup_cache_state: {
+            parityWarmupEnabled: resolveUnityConfig().config.parityWarmup,
+            note: 'repeatability sampled under current runtime/cache state',
+        },
+    };
+}
+export async function writeHydrationPolicyRepeatabilityReport(outPath, report) {
+    await fs.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.writeFile(outPath, JSON.stringify(report, null, 2));
+}
+async function main(argv) {
+    const repoIndex = argv.indexOf('--repo');
+    const outIndex = argv.indexOf('--out');
+    const repoAlias = String(argv[repoIndex + 1] || '').trim();
+    const outPath = path.resolve(String(argv[outIndex + 1] || '').trim());
+    if (!repoAlias || !outPath) {
+        throw new Error('Usage: node dist/benchmark/u2-e2e/hydration-policy-repeatability-runner.js --repo <alias> --out <path>');
+    }
+    const report = await buildHydrationPolicyRepeatabilityReport({ repoAlias, runCount: 3 });
+    await writeHydrationPolicyRepeatabilityReport(outPath, report);
+    process.stdout.write(`phase4 hydration policy repeatability artifact written: ${outPath}\n`);
+}
+const entryPath = process.argv[1] ? path.resolve(process.argv[1]) : '';
+const thisPath = fileURLToPath(import.meta.url);
+if (entryPath === thisPath) {
+    main(process.argv.slice(2)).catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/benchmark/u2-e2e/hydration-policy-repeatability-runner.test.js

@@ -0,0 +1,13 @@
+import assert from 'node:assert/strict';
+import { buildHydrationPolicyRepeatabilityReport } from './hydration-policy-repeatability-runner.js';
+const { test: rawTest } = process.env.VITEST
+    ? await import('vitest')
+    : await import('node:test');
+const test = rawTest;
+test('phase4 hydration policy repeatability report tracks consistency and compatibility', async () => {
+    const report = await buildHydrationPolicyRepeatabilityReport({ repoAlias: 'GitNexus' });
+    assert.equal(report.repeatability.fast.consistent, true);
+    assert.equal(report.repeatability.balanced.consistent, true);
+    assert.equal(report.repeatability.strict.consistent, true);
+    assert.equal(report.contractCompatibility.needsParityRetryRetained, true);
+});

package/dist/benchmark/u2-e2e/phase1-process-ref-acceptance-runner.d.ts

@@ -0,0 +1,22 @@
+export interface Phase1ProcessRefAcceptanceReport {
+    generatedAt: string;
+    repoAlias: string;
+    metrics: {
+        process_ref: {
+            total: number;
+            readable_count: number;
+            readable_rate: number;
+            unreadable_count: number;
+        };
+        derived_id_stability_rate: number;
+    };
+    checks: {
+        query: string;
+        unity_resources: 'on';
+        unity_hydration_mode: 'compact';
+    };
+}
+export declare function buildPhase1ProcessRefAcceptanceReport(input: {
+    repoAlias: string;
+}): Promise<Phase1ProcessRefAcceptanceReport>;
+export declare function writePhase1ProcessRefAcceptanceReport(outPath: string, report: Phase1ProcessRefAcceptanceReport): Promise<void>;

package/dist/benchmark/u2-e2e/phase1-process-ref-acceptance-runner.js

@@ -0,0 +1,100 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { listRegisteredRepos } from '../../storage/repo-manager.js';
+import { LocalBackend } from '../../mcp/local/local-backend.js';
+import { readResource } from '../../mcp/resources.js';
+function toRate(numerator, denominator) {
+    if (denominator <= 0)
+        return 1;
+    return Math.round((numerator / denominator) * 10000) / 10000;
+}
+function extractDerivedIds(result) {
+    const processes = Array.isArray(result?.processes) ? result.processes : [];
+    return processes
+        .map((entry) => String(entry?.id || ''))
+        .filter((id) => id.startsWith('derived:'))
+        .sort();
+}
+export async function buildPhase1ProcessRefAcceptanceReport(input) {
+    const repos = await listRegisteredRepos({ validate: false });
+    const repo = repos.find((entry) => entry.name === input.repoAlias);
+    if (!repo) {
+        throw new Error(`Repo alias not found: ${input.repoAlias}`);
+    }
+    const backend = new LocalBackend();
+    const ready = await backend.init();
+    if (!ready) {
+        throw new Error('LocalBackend failed to initialize for phase1 acceptance runner');
+    }
+    const params = {
+        repo: input.repoAlias,
+        query: 'Reload',
+        unity_resources: 'on',
+        unity_hydration_mode: 'compact',
+    };
+    const first = await backend.callTool('query', params);
+    const second = await backend.callTool('query', params);
+    const processes = Array.isArray(first?.processes) ? first.processes : [];
+    const persistentReaderUris = processes
+        .map((entry) => entry?.process_ref)
+        .filter((processRef) => processRef?.kind === 'persistent' && typeof processRef.reader_uri === 'string')
+        .map((processRef) => processRef.reader_uri);
+    let readableCount = 0;
+    for (const uri of persistentReaderUris) {
+        try {
+            await readResource(uri, backend);
+            readableCount += 1;
+        }
+        catch {
+            // Count as unreadable in behavior-level metric.
+        }
+    }
+    const unreadableCount = Math.max(0, persistentReaderUris.length - readableCount);
+    const firstDerived = extractDerivedIds(first);
+    const secondDerived = extractDerivedIds(second);
+    const derivedStable = firstDerived.length === secondDerived.length
+        && firstDerived.every((id, idx) => id === secondDerived[idx]);
+    return {
+        generatedAt: new Date().toISOString(),
+        repoAlias: input.repoAlias,
+        metrics: {
+            process_ref: {
+                total: persistentReaderUris.length,
+                readable_count: readableCount,
+                readable_rate: toRate(readableCount, persistentReaderUris.length),
+                unreadable_count: unreadableCount,
+            },
+            derived_id_stability_rate: derivedStable ? 1 : 0,
+        },
+        checks: {
+            query: 'Reload',
+            unity_resources: 'on',
+            unity_hydration_mode: 'compact',
+        },
+    };
+}
+export async function writePhase1ProcessRefAcceptanceReport(outPath, report) {
+    await fs.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.writeFile(outPath, JSON.stringify(report, null, 2));
+}
+async function main(argv) {
+    const repoIndex = argv.indexOf('--repo');
+    const outIndex = argv.indexOf('--out');
+    const repoAlias = String(argv[repoIndex + 1] || '').trim();
+    const outPath = path.resolve(String(argv[outIndex + 1] || '').trim());
+    if (!repoAlias || !outPath) {
+        throw new Error('Usage: node dist/benchmark/u2-e2e/phase1-process-ref-acceptance-runner.js --repo <alias> --out <path>');
+    }
+    const report = await buildPhase1ProcessRefAcceptanceReport({ repoAlias });
+    await writePhase1ProcessRefAcceptanceReport(outPath, report);
+    process.stdout.write(`phase1 process_ref acceptance artifact written: ${outPath}\n`);
+}
+const entryPath = process.argv[1] ? path.resolve(process.argv[1]) : '';
+const thisPath = fileURLToPath(import.meta.url);
+if (entryPath === thisPath) {
+    main(process.argv.slice(2)).catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/benchmark/u2-e2e/phase1-process-ref-acceptance-runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/benchmark/u2-e2e/phase1-process-ref-acceptance-runner.test.js

@@ -0,0 +1,13 @@
+import assert from 'node:assert/strict';
+import { buildPhase1ProcessRefAcceptanceReport } from './phase1-process-ref-acceptance-runner.js';
+const { test: rawTest } = process.env.VITEST
+    ? await import('vitest')
+    : await import('node:test');
+const test = rawTest;
+test('phase1 process_ref acceptance report emits readable + stable metrics', async () => {
+    const report = await buildPhase1ProcessRefAcceptanceReport({
+        repoAlias: 'GitNexus',
+    });
+    assert.equal(report.metrics.process_ref.readable_rate, 1);
+    assert.equal(report.metrics.derived_id_stability_rate, 1);
+});

package/dist/benchmark/u2-e2e/phase2-runtime-claim-acceptance-runner.d.ts

@@ -0,0 +1,27 @@
+export interface Phase2RuntimeClaimAcceptanceReport {
+    generatedAt: string;
+    repoAlias: string;
+    claim_fields_presence: {
+        rule_id: boolean;
+        rule_version: boolean;
+        scope: boolean;
+        guarantees: boolean;
+        non_guarantees: boolean;
+    };
+    failure_classification_coverage: string[];
+    failure_classification_missing: string[];
+    coverage_pass: boolean;
+    samples: {
+        matched_status?: string;
+        matched_reason?: string;
+        evidence_missing_reason?: string;
+        verification_failed_reason?: string;
+        unmatched_reason?: string;
+        gate_disabled_reason?: string;
+    };
+    reproduction_commands: Record<string, string>;
+}
+export declare function buildPhase2RuntimeClaimAcceptanceReport(input: {
+    repoAlias: string;
+}): Promise<Phase2RuntimeClaimAcceptanceReport>;
+export declare function writePhase2RuntimeClaimAcceptanceReport(outPath: string, report: Phase2RuntimeClaimAcceptanceReport): Promise<void>;

package/dist/benchmark/u2-e2e/phase2-runtime-claim-acceptance-runner.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { LocalBackend } from '../../mcp/local/local-backend.js';
+export async function buildPhase2RuntimeClaimAcceptanceReport(input) {
+    const backend = new LocalBackend();
+    const ready = await backend.init();
+    if (!ready) {
+        throw new Error('LocalBackend failed to initialize for phase2 acceptance runner');
+    }
+    const matched = await backend.callTool('query', {
+        repo: input.repoAlias,
+        query: 'Reload',
+        unity_resources: 'on',
+        runtime_chain_verify: 'on-demand',
+    });
+    const evidenceMissing = await backend.callTool('query', {
+        repo: input.repoAlias,
+        query: 'Reload',
+        unity_resources: 'on',
+        runtime_chain_verify: 'on-demand',
+        unity_evidence_mode: 'summary',
+        max_bindings: 1,
+        max_reference_fields: 1,
+    });
+    const unmatched = await backend.callTool('query', {
+        repo: input.repoAlias,
+        query: 'UnrelatedUnityChain',
+        unity_resources: 'on',
+        runtime_chain_verify: 'on-demand',
+    });
+    // gate_disabled reason is no longer produced (env var gate removed in config migration)
+    let gateDisabled;
+    try {
+        gateDisabled = await backend.callTool('query', {
+            repo: input.repoAlias,
+            query: 'Reload',
+            unity_resources: 'on',
+            runtime_chain_verify: 'off',
+        });
+    }
+    finally {
+    }
+    const claim = matched.runtime_claim || {};
+    const requiredReasons = [
+        'rule_not_matched',
+        'rule_matched_but_evidence_missing',
+        'rule_matched_but_verification_failed',
+        'gate_disabled',
+    ];
+    const reasons = [
+        claim.reason,
+        evidenceMissing.runtime_claim?.reason,
+        unmatched.runtime_claim?.reason,
+        gateDisabled.runtime_claim?.reason,
+    ]
+        .filter(Boolean)
+        .map((reason) => String(reason));
+    const failure_classification_coverage = [...new Set(reasons)];
+    const failure_classification_missing = requiredReasons.filter((reason) => !failure_classification_coverage.includes(reason));
+    const coverage_pass = failure_classification_missing.length === 0;
+    const report = {
+        generatedAt: new Date().toISOString(),
+        repoAlias: input.repoAlias,
+        claim_fields_presence: {
+            rule_id: Boolean(claim.rule_id),
+            rule_version: Boolean(claim.rule_version),
+            scope: Boolean(claim.scope),
+            guarantees: Array.isArray(claim.guarantees),
+            non_guarantees: Array.isArray(claim.non_guarantees),
+        },
+        failure_classification_coverage,
+        failure_classification_missing,
+        coverage_pass,
+        samples: {
+            matched_status: claim.status,
+            matched_reason: claim.reason,
+            evidence_missing_reason: evidenceMissing.runtime_claim?.reason,
+            verification_failed_reason: claim.reason,
+            unmatched_reason: unmatched.runtime_claim?.reason,
+            gate_disabled_reason: gateDisabled.runtime_claim?.reason,
+        },
+        reproduction_commands: {
+            rule_matched_but_verification_failed: `gitnexus query --repo ${input.repoAlias} --runtime-chain-verify on-demand --unity-resources on "Reload"`,
+            rule_matched_but_evidence_missing: `gitnexus query --repo ${input.repoAlias} --runtime-chain-verify on-demand --unity-resources on --unity-evidence-mode summary --max-bindings 1 --max-reference-fields 1 "Reload"`,
+            rule_not_matched: `gitnexus query --repo ${input.repoAlias} --runtime-chain-verify on-demand --unity-resources on "UnrelatedUnityChain"`,
+            gate_disabled: `gitnexus query --repo ${input.repoAlias} --runtime-chain-verify off --unity-resources on "Reload"`,
+        },
+    };
+    if (!coverage_pass) {
+        throw new Error(`phase2 failure classification coverage is incomplete (${failure_classification_coverage.length}/4). Missing: ${failure_classification_missing.join(', ')}`);
+    }
+    return report;
+}
+export async function writePhase2RuntimeClaimAcceptanceReport(outPath, report) {
+    await fs.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.writeFile(outPath, JSON.stringify(report, null, 2));
+}
+async function main(argv) {
+    const repoIndex = argv.indexOf('--repo');
+    const outIndex = argv.indexOf('--out');
+    const repoAlias = String(argv[repoIndex + 1] || '').trim();
+    const outPath = path.resolve(String(argv[outIndex + 1] || '').trim());
+    if (!repoAlias || !outPath) {
+        throw new Error('Usage: node dist/benchmark/u2-e2e/phase2-runtime-claim-acceptance-runner.js --repo <alias> --out <path>');
+    }
+    const report = await buildPhase2RuntimeClaimAcceptanceReport({ repoAlias });
+    await writePhase2RuntimeClaimAcceptanceReport(outPath, report);
+    process.stdout.write(`phase2 runtime_claim acceptance artifact written: ${outPath}\n`);
+}
+const entryPath = process.argv[1] ? path.resolve(process.argv[1]) : '';
+const thisPath = fileURLToPath(import.meta.url);
+if (entryPath === thisPath) {
+    main(process.argv.slice(2)).catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/benchmark/u2-e2e/phase2-runtime-claim-acceptance-runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/benchmark/u2-e2e/phase2-runtime-claim-acceptance-runner.test.js

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict';
+import { buildPhase2RuntimeClaimAcceptanceReport } from './phase2-runtime-claim-acceptance-runner.js';
+const { test: rawTest } = process.env.VITEST
+    ? await import('vitest')
+    : await import('node:test');
+const test = rawTest;
+test('phase2 runtime_claim acceptance report tracks contract + failure classification coverage', async () => {
+    const report = await buildPhase2RuntimeClaimAcceptanceReport({ repoAlias: 'GitNexus' });
+    assert.equal(report.claim_fields_presence.rule_id, true);
+    assert.equal(report.claim_fields_presence.rule_version, true);
+    assert.equal(report.coverage_pass, true);
+    assert.equal(report.failure_classification_coverage.includes('rule_not_matched'), true);
+    assert.equal(report.failure_classification_coverage.includes('rule_matched_but_evidence_missing'), true);
+    assert.equal(report.failure_classification_coverage.includes('rule_matched_but_verification_failed'), true);
+    assert.equal(report.failure_classification_coverage.includes('gate_disabled'), true);
+});

package/dist/benchmark/u2-e2e/phase5-rule-lab-acceptance-runner.d.ts

@@ -0,0 +1,60 @@
+export interface Phase5StageCoverageRow {
+    stage: 'discover' | 'analyze' | 'review-pack' | 'curate' | 'promote' | 'regress';
+    command: string;
+    status: 'passed' | 'failed';
+    retry_hint?: string;
+    error?: string;
+}
+export interface Phase5FailureClassification {
+    code: string;
+    retry_hint: string;
+    repro_command: string;
+}
+export interface Phase5RuleLabAcceptanceReport {
+    generated_at: string;
+    repo_alias: string;
+    repo_path: string;
+    run_id: string;
+    stage_coverage: Phase5StageCoverageRow[];
+    metrics: {
+        precision: number;
+        coverage: number;
+        probe_pass_rate: number;
+        token_budget: number;
+    };
+    authenticity_checks: {
+        static_no_hardcoded_reload: {
+            pass: boolean;
+            blocked_symbols: string[];
+        };
+        dsl_lint_pass: boolean;
+    };
+    failure_classifications: Phase5FailureClassification[];
+    artifact_paths: {
+        manifest: string;
+        candidates: string;
+        review_cards: string;
+        curation_input: string;
+        curated: string;
+        catalog: string;
+        promoted_files: string[];
+        regress_report?: string;
+    };
+}
+export interface BuildPhase5RuleLabAcceptanceInput {
+    repoAlias: string;
+    repoPath?: string;
+    seed?: string;
+}
+export declare function buildPhase5RuleLabAcceptanceReport(input: BuildPhase5RuleLabAcceptanceInput): Promise<Phase5RuleLabAcceptanceReport>;
+export declare function runPhase5RuleLabGate(input: {
+    reportPath: string;
+}): Promise<{
+    pass: boolean;
+    reason?: string;
+}>;
+export declare function writePhase5RuleLabAcceptanceArtifacts(input: {
+    report: Phase5RuleLabAcceptanceReport;
+    jsonPath: string;
+    mdPath: string;
+}): Promise<void>;