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

package/dist/benchmark/u2-e2e/live-evidence-validator.d.ts

@@ -0,0 +1,19 @@
+export interface LiveEvidenceRow {
+    timestamp: string;
+    command: string;
+    flags: Record<string, unknown>;
+    request_excerpt: string;
+    response_excerpt: string;
+    segment: string;
+    hop_anchor: string;
+}
+export interface LiveEvidenceValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export declare function validateLiveEvidenceRows(rows: unknown[]): LiveEvidenceValidationResult;
+export declare function parseLiveEvidenceJsonl(raw: string): {
+    rows: unknown[];
+    errors: string[];
+};
+export declare function validateLiveEvidenceJsonlFile(inputPath: string): Promise<LiveEvidenceValidationResult>;

package/dist/benchmark/u2-e2e/live-evidence-validator.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function validateRow(row, index) {
+    const errors = [];
+    if (!isNonEmptyString(row?.timestamp))
+        errors.push(`row ${index + 1}: missing timestamp`);
+    if (!isNonEmptyString(row?.command))
+        errors.push(`row ${index + 1}: missing command`);
+    if (!row || typeof row !== 'object' || !row.flags || typeof row.flags !== 'object') {
+        errors.push(`row ${index + 1}: missing flags object`);
+    }
+    if (!isNonEmptyString(row?.request_excerpt))
+        errors.push(`row ${index + 1}: missing request_excerpt`);
+    if (!isNonEmptyString(row?.response_excerpt))
+        errors.push(`row ${index + 1}: missing response_excerpt`);
+    if (!isNonEmptyString(row?.segment))
+        errors.push(`row ${index + 1}: missing segment`);
+    if (!isNonEmptyString(row?.hop_anchor))
+        errors.push(`row ${index + 1}: missing hop_anchor`);
+    return errors;
+}
+export function validateLiveEvidenceRows(rows) {
+    const errors = [];
+    for (let i = 0; i < rows.length; i += 1) {
+        errors.push(...validateRow(rows[i], i));
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+export function parseLiveEvidenceJsonl(raw) {
+    const errors = [];
+    const rows = [];
+    const lines = String(raw || '')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    lines.forEach((line, index) => {
+        try {
+            rows.push(JSON.parse(line));
+        }
+        catch (error) {
+            errors.push(`line ${index + 1}: invalid JSON (${error instanceof Error ? error.message : String(error)})`);
+        }
+    });
+    return { rows, errors };
+}
+export async function validateLiveEvidenceJsonlFile(inputPath) {
+    const raw = await fs.readFile(inputPath, 'utf-8');
+    const parsed = parseLiveEvidenceJsonl(raw);
+    if (parsed.errors.length > 0) {
+        return { valid: false, errors: parsed.errors };
+    }
+    return validateLiveEvidenceRows(parsed.rows);
+}
+function parseCliInputArg(argv) {
+    const index = argv.indexOf('--input');
+    if (index < 0)
+        return '';
+    return String(argv[index + 1] || '').trim();
+}
+async function runCli() {
+    const input = parseCliInputArg(process.argv);
+    if (!input) {
+        throw new Error('Usage: node dist/benchmark/u2-e2e/live-evidence-validator.js --input <jsonl-path>');
+    }
+    const resolved = path.resolve(input);
+    const result = await validateLiveEvidenceJsonlFile(resolved);
+    if (!result.valid) {
+        throw new Error(`live evidence validation failed:\n${result.errors.map((row) => `- ${row}`).join('\n')}`);
+    }
+    process.stdout.write(`live evidence validation passed: ${resolved}\n`);
+}
+const entryPath = process.argv[1] ? path.resolve(process.argv[1]) : '';
+const thisPath = fileURLToPath(import.meta.url);
+if (entryPath && entryPath === thisPath) {
+    runCli().catch((error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${msg}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/benchmark/u2-e2e/live-evidence-validator.test.d.ts

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

package/dist/benchmark/u2-e2e/live-evidence-validator.test.js

@@ -0,0 +1,33 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { validateLiveEvidenceRows } from './live-evidence-validator.js';
+test('validateLiveEvidenceRows fails when required authenticity fields are missing', () => {
+    const result = validateLiveEvidenceRows([
+        {
+            timestamp: '2026-04-01T10:00:00.000Z',
+            command: 'node gitnexus/dist/cli/index.js query -r neonspark-core "Reload"',
+            flags: { confidenceFields: 'on' },
+            request_excerpt: 'Reload NEON.Game.Graph.Nodes.Reloads',
+            response_excerpt: 'processes: []',
+            segment: 'resource',
+            // hop_anchor intentionally missing
+        },
+    ]);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors.some((row) => /hop_anchor/i.test(row)));
+});
+test('validateLiveEvidenceRows passes when authenticity schema is complete', () => {
+    const result = validateLiveEvidenceRows([
+        {
+            timestamp: '2026-04-01T10:00:00.000Z',
+            command: 'node gitnexus/dist/cli/index.js query -r neonspark-core "Reload"',
+            flags: { confidenceFields: 'on', unity_resources: 'on', unity_hydration: 'parity' },
+            request_excerpt: 'Reload NEON.Game.Graph.Nodes.Reloads',
+            response_excerpt: 'confidence=low verification_hint.action=rerun_parity_hydration',
+            segment: 'runtime',
+            hop_anchor: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:CheckReload',
+        },
+    ]);
+    assert.equal(result.valid, true);
+    assert.equal(result.errors.length, 0);
+});

package/dist/benchmark/u2-e2e/neonspark-full-e2e.js

@@ -200,6 +200,17 @@ async function loadSerializedTypeEdgeCount(runner, repoAlias) {
     }
     return count;
 }
+async function loadResourceSummaryEdgeCount(runner, repoAlias) {
+    const result = await runner.cypher({
+        repo: repoAlias,
+        query: "MATCH ()-[r:CodeRelation]->() WHERE r.type='UNITY_RESOURCE_SUMMARY' RETURN COUNT(r) AS summaryEdgeCount",
+    });
+    const count = extractSingleCountFromCypherResult(result);
+    if (count === null) {
+        throw new Error('Unable to parse UNITY_RESOURCE_SUMMARY edge count from cypher result');
+    }
+    return count;
+}
 function selectClassUid(contextOutput, expectedSymbol) {
     const candidates = Array.isArray(contextOutput?.candidates) ? contextOutput.candidates : [];
     const expectedLower = expectedSymbol.toLowerCase();
@@ -325,8 +336,10 @@ export async function runNeonsparkU2E2E(options) {
                         results.push(await runSymbolScenario(runner, scenario, repoAlias));
                     }
                     const serializedTypeEdgeCount = await loadSerializedTypeEdgeCount(runner, repoAlias);
-                    if (serializedTypeEdgeCount <= 0) {
-                        throw new Error('U3 gate failed: UNITY_SERIALIZED_TYPE_IN edge count must be > 0');
+                    const resourceSummaryEdgeCount = await loadResourceSummaryEdgeCount(runner, repoAlias);
+                    const retrievalWarnings = [];
+                    if (serializedTypeEdgeCount <= 0 && resourceSummaryEdgeCount <= 0) {
+                        retrievalWarnings.push('UNITY edge persistence counts are 0; using query-time Unity resource evidence gates for this run');
                     }
                     const characterListContext = await loadCharacterListContext(runner, repoAlias);
                     const characterBindings = Array.isArray(characterListContext?.resourceBindings)
@@ -334,12 +347,14 @@ export async function runNeonsparkU2E2E(options) {
                         : [];
                     const characterListAssetRefSprite = summarizeCharacterListAssetRefSprite(characterBindings);
                     if (characterListAssetRefSprite.spriteAssetRefInstances <= 0) {
-                        throw new Error('U3 gate failed: CharacterList AssetRef sprite instances must be > 0');
+                        retrievalWarnings.push('CharacterList AssetRef sprite instances are 0; proceeding with runtime confidence calibration checks only');
                     }
+                    const baseRetrievalSummary = summarizeRetrieval(results);
                     state.retrievalResults = results;
                     state.retrievalSummary = {
-                        ...summarizeRetrieval(results),
+                        ...baseRetrievalSummary,
                         serializedTypeEdgeCount,
+                        resourceSummaryEdgeCount,
                         characterListAssetRefSprite: {
                             extractedAssetRefInstances: characterListAssetRefSprite.extractedAssetRefInstances,
                             nonEmptyAssetRefInstances: characterListAssetRefSprite.nonEmptyAssetRefInstances,
@@ -347,6 +362,10 @@ export async function runNeonsparkU2E2E(options) {
                             spriteRatioInNonEmpty: characterListAssetRefSprite.spriteRatioInNonEmpty,
                             uniqueSpriteAssets: characterListAssetRefSprite.uniqueSpriteAssets,
                         },
+                        failures: [
+                            ...(baseRetrievalSummary.failures || []),
+                            ...retrievalWarnings,
+                        ],
                     };
                     return state.retrievalSummary;
                 }

package/dist/benchmark/u2-e2e/reload-v1-acceptance-runner.d.ts

@@ -0,0 +1,38 @@
+import type { RuntimeChainResult } from '../../mcp/local/runtime-chain-verify.js';
+export interface AnchorValidationRow {
+    anchor: string;
+    valid: boolean;
+    reason?: string;
+}
+export interface ReloadAcceptanceArtifact {
+    generatedAt: string;
+    repoAlias: string;
+    repoPath: string;
+    status: {
+        indexedCommit: string;
+        currentCommit: string;
+        upToDate: boolean;
+        raw: string;
+    };
+    commands: Array<{
+        command: string;
+        output: unknown;
+    }>;
+    runtime_chain: RuntimeChainResult;
+    anchor_validation: AnchorValidationRow[];
+}
+export declare function containsPlaceholderText(value: unknown): boolean;
+export declare function validateAnchorAuthenticity(repoPath: string, hop: {
+    anchor?: string;
+    snippet?: string;
+}): Promise<AnchorValidationRow>;
+export declare function validateReloadAcceptanceArtifact(artifact: ReloadAcceptanceArtifact): Promise<{
+    ok: boolean;
+    failures: string[];
+    anchorValidation: AnchorValidationRow[];
+}>;
+export declare function buildReloadAcceptanceArtifact(input: {
+    repoAlias: string;
+    requireStatusMatch?: boolean;
+}): Promise<ReloadAcceptanceArtifact>;
+export declare function writeReloadAcceptanceArtifact(outPath: string, artifact: ReloadAcceptanceArtifact): Promise<void>;

package/dist/benchmark/u2-e2e/reload-v1-acceptance-runner.js

@@ -0,0 +1,206 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { listRegisteredRepos } from '../../storage/repo-manager.js';
+import { getCurrentCommit } from '../../storage/git.js';
+import { LocalBackend } from '../../mcp/local/local-backend.js';
+const PLACEHOLDER_RE = /TODO|TBD|placeholder|<symbol-or-query>/i;
+export function containsPlaceholderText(value) {
+    return PLACEHOLDER_RE.test(String(value || ''));
+}
+function parseAnchor(anchor) {
+    const match = String(anchor || '').match(/^(.*):(\d+)$/);
+    if (!match)
+        return null;
+    return { filePath: match[1], line: Number(match[2]) };
+}
+export async function validateAnchorAuthenticity(repoPath, hop) {
+    const anchor = String(hop.anchor || '').trim();
+    if (!anchor)
+        return { anchor, valid: false, reason: 'anchor missing' };
+    if (containsPlaceholderText(anchor))
+        return { anchor, valid: false, reason: 'anchor contains placeholder text' };
+    const parsed = parseAnchor(anchor);
+    if (!parsed)
+        return { anchor, valid: false, reason: 'anchor format invalid' };
+    const resolvedPath = path.isAbsolute(parsed.filePath)
+        ? parsed.filePath
+        : path.join(repoPath, parsed.filePath);
+    let raw;
+    try {
+        raw = await fs.readFile(resolvedPath, 'utf-8');
+    }
+    catch {
+        return { anchor, valid: false, reason: 'anchor file does not exist' };
+    }
+    const lines = raw.split(/\r?\n/);
+    if (parsed.line < 1 || parsed.line > lines.length) {
+        return { anchor, valid: false, reason: 'anchor line out of range' };
+    }
+    const expectedSnippet = String(hop.snippet || '').trim();
+    if (expectedSnippet && !lines[parsed.line - 1].includes(expectedSnippet)) {
+        return { anchor, valid: false, reason: 'anchor snippet mismatch' };
+    }
+    return { anchor, valid: true };
+}
+export async function validateReloadAcceptanceArtifact(artifact) {
+    const failures = [];
+    const chain = artifact.runtime_chain;
+    const hops = Array.isArray(chain?.hops) ? chain.hops : [];
+    if (containsPlaceholderText(JSON.stringify(chain))) {
+        failures.push('placeholder text leaked into runtime_chain');
+    }
+    const hopTypes = new Set(hops.map((hop) => hop.hop_type));
+    for (const required of ['resource', 'guid_map', 'code_loader', 'code_runtime']) {
+        if (!hopTypes.has(required)) {
+            failures.push(`missing required ${required} hop`);
+        }
+    }
+    if (chain?.status === 'verified_full' && hops.length === 0) {
+        failures.push('verified_full requires non-empty hops');
+    }
+    const loaderHops = hops.filter((hop) => hop.hop_type === 'code_loader');
+    if (loaderHops.length > 0) {
+        const hasCurGunGraphAssignmentAnchor = loaderHops.some((hop) => /\bCurGunGraph\b\s*=/i.test(String(hop.snippet || '')));
+        if (!hasCurGunGraphAssignmentAnchor) {
+            failures.push('loader semantic closure missing CurGunGraph assignment anchor');
+        }
+    }
+    const runtimeHops = hops.filter((hop) => hop.hop_type === 'code_runtime');
+    if (runtimeHops.length > 0) {
+        const hasRuntimeGraphAnchor = runtimeHops.some((hop) => /RegisterEvents|StartRoutineWithEvents/i.test(String(hop.snippet || '')));
+        const hasRuntimeReloadAnchor = runtimeHops.some((hop) => /GetValue|CheckReload|ReloadRoutine/i.test(String(hop.snippet || '')));
+        if (!hasRuntimeGraphAnchor || !hasRuntimeReloadAnchor) {
+            failures.push('runtime semantic closure missing RegisterEvents/StartRoutineWithEvents and GetValue|CheckReload|ReloadRoutine anchors');
+        }
+    }
+    const anchorValidation = await Promise.all(hops.map((hop) => validateAnchorAuthenticity(artifact.repoPath, hop)));
+    anchorValidation
+        .filter((row) => !row.valid)
+        .forEach((row) => failures.push(row.reason || 'invalid anchor'));
+    return {
+        ok: failures.length === 0,
+        failures,
+        anchorValidation,
+    };
+}
+function buildStatus(repoPath, indexedCommit) {
+    const currentCommit = String(getCurrentCommit(repoPath) || '').trim();
+    const upToDate = indexedCommit === currentCommit;
+    const raw = [
+        `Repository: ${repoPath}`,
+        `Indexed commit: ${indexedCommit}`,
+        `Current commit: ${currentCommit}`,
+        `Status: ${upToDate ? '✅ up-to-date' : '⚠️ stale (re-run gitnexus analyze)'}`,
+    ].join('\n');
+    return { indexedCommit, currentCommit, upToDate, raw };
+}
+async function runBackendCommand(backend, command, method, params) {
+    return {
+        command,
+        output: await backend.callTool(method, params),
+    };
+}
+export async function buildReloadAcceptanceArtifact(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 distCli = path.resolve('gitnexus/dist/cli/index.js');
+    const env = { ...process.env, GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS: 'on' };
+    const status = buildStatus(repo.path, repo.lastCommit);
+    if (input.requireStatusMatch && !status.upToDate) {
+        throw new Error(`status mismatch for ${input.repoAlias}`);
+    }
+    const backend = new LocalBackend();
+    const ready = await backend.init();
+    if (!ready) {
+        throw new Error('LocalBackend failed to initialize for acceptance runner');
+    }
+    const commands = await Promise.all([
+        runBackendCommand(backend, `GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on node ${distCli} query -r ${input.repoAlias} --unity-resources on --unity-hydration parity --runtime-chain-verify on-demand "Reload NEON.Game.Graph.Nodes.Reloads"`, 'query', {
+            repo: input.repoAlias,
+            query: 'Reload NEON.Game.Graph.Nodes.Reloads',
+            unity_resources: 'on',
+            unity_hydration_mode: 'parity',
+            runtime_chain_verify: 'on-demand',
+        }),
+        runBackendCommand(backend, `GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on node ${distCli} query -r ${input.repoAlias} --unity-resources on --unity-hydration parity --runtime-chain-verify on-demand "PickItUp EquipWithEvent WeaponPowerUp Equip CurGunGraph"`, 'query', {
+            repo: input.repoAlias,
+            query: 'PickItUp EquipWithEvent WeaponPowerUp Equip CurGunGraph',
+            unity_resources: 'on',
+            unity_hydration_mode: 'parity',
+            runtime_chain_verify: 'on-demand',
+        }),
+        runBackendCommand(backend, `GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on node ${distCli} context -r ${input.repoAlias} --file Assets/NEON/Code/Game/Graph/Nodes/Reloads/Reload.cs --unity-resources on --unity-hydration parity --runtime-chain-verify on-demand Reload`, 'context', {
+            repo: input.repoAlias,
+            name: 'Reload',
+            file_path: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/Reload.cs',
+            unity_resources: 'on',
+            unity_hydration_mode: 'parity',
+            runtime_chain_verify: 'on-demand',
+        }),
+    ]);
+    const runtime_chain = commands[0].output?.runtime_chain;
+    if (!runtime_chain) {
+        throw new Error('runtime_chain missing from reload query');
+    }
+    const artifact = {
+        generatedAt: new Date().toISOString(),
+        repoAlias: input.repoAlias,
+        repoPath: repo.path,
+        status,
+        commands: [
+            {
+                command: `node ${distCli} status`,
+                output: status.raw,
+            },
+            ...commands,
+        ],
+        runtime_chain,
+        anchor_validation: [],
+    };
+    const validation = await validateReloadAcceptanceArtifact(artifact);
+    artifact.anchor_validation = validation.anchorValidation;
+    if (!validation.ok) {
+        throw new Error(validation.failures.join('\n'));
+    }
+    return artifact;
+}
+export async function writeReloadAcceptanceArtifact(outPath, artifact) {
+    await fs.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.writeFile(outPath, JSON.stringify(artifact, null, 2));
+}
+async function main(argv) {
+    const verifyOnlyIndex = argv.indexOf('--verify-only');
+    if (verifyOnlyIndex >= 0) {
+        const inputPath = path.resolve(argv[verifyOnlyIndex + 1] || '');
+        const artifact = JSON.parse(await fs.readFile(inputPath, 'utf-8'));
+        const validation = await validateReloadAcceptanceArtifact(artifact);
+        if (!validation.ok) {
+            throw new Error(validation.failures.join('\n'));
+        }
+        process.stdout.write(`reload acceptance verification passed: ${inputPath}\n`);
+        return;
+    }
+    const repoIndex = argv.indexOf('--repo');
+    const outIndex = argv.indexOf('--out');
+    const requireStatusMatch = argv.includes('--require-status-match');
+    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/reload-v1-acceptance-runner.js --repo <alias> --out <path> [--require-status-match] | --verify-only <path>');
+    }
+    const artifact = await buildReloadAcceptanceArtifact({ repoAlias, requireStatusMatch });
+    await writeReloadAcceptanceArtifact(outPath, artifact);
+    process.stdout.write(`reload 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/reload-v1-acceptance-runner.test.d.ts

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

package/dist/benchmark/u2-e2e/reload-v1-acceptance-runner.test.js

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { containsPlaceholderText, validateAnchorAuthenticity, validateReloadAcceptanceArtifact, } from './reload-v1-acceptance-runner.js';
+const { test: rawTest } = process.env.VITEST
+    ? await import('vitest')
+    : await import('node:test');
+const test = rawTest;
+test('v1 reload acceptance rejects placeholders and missing required segments', async () => {
+    const artifact = {
+        repoPath: process.cwd(),
+        runtime_chain: {
+            status: 'verified_full',
+            hops: [
+                { hop_type: 'resource', anchor: 'placeholder:1', snippet: 'placeholder' },
+            ],
+        },
+    };
+    const validation = await validateReloadAcceptanceArtifact(artifact);
+    assert.equal(validation.ok, false);
+    assert.equal(validation.failures.some((failure) => /placeholder/i.test(failure)), true);
+    assert.equal(validation.failures.some((failure) => /missing required guid_map/i.test(failure)), true);
+    assert.equal(validation.failures.some((failure) => /missing required code_runtime/i.test(failure)), true);
+});
+test('v1 anchor authenticity validates file existence, line range, and snippet match', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'reload-v1-'));
+    const filePath = path.join(tempDir, 'Anchor.cs');
+    await fs.writeFile(filePath, 'line one\nneedle line\nline three\n');
+    const valid = await validateAnchorAuthenticity(tempDir, {
+        anchor: `${filePath}:2`,
+        snippet: 'needle line',
+    });
+    assert.deepEqual(valid, { anchor: `${filePath}:2`, valid: true });
+    const lineOut = await validateAnchorAuthenticity(tempDir, {
+        anchor: `${filePath}:9`,
+        snippet: 'needle line',
+    });
+    assert.equal(lineOut.valid, false);
+    assert.match(lineOut.reason || '', /line out of range/i);
+    const mismatch = await validateAnchorAuthenticity(tempDir, {
+        anchor: `${filePath}:2`,
+        snippet: 'missing snippet',
+    });
+    assert.equal(mismatch.valid, false);
+    assert.match(mismatch.reason || '', /snippet mismatch/i);
+});
+test('containsPlaceholderText detects placeholder leakage', () => {
+    assert.equal(containsPlaceholderText('TODO later'), true);
+    assert.equal(containsPlaceholderText('real anchor'), false);
+});
+test('v1 reload acceptance enforces loader/runtime semantic anchors', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'reload-v1-semantic-'));
+    const filePath = path.join(tempDir, 'Chain.cs');
+    await fs.writeFile(filePath, 'resource line\nguid line\nloader line\nruntime line\n');
+    const artifact = {
+        repoPath: tempDir,
+        runtime_chain: {
+            status: 'verified_full',
+            hops: [
+                { hop_type: 'resource', anchor: `${filePath}:1`, snippet: 'resource line', note: 'resource ok' },
+                { hop_type: 'guid_map', anchor: `${filePath}:2`, snippet: 'guid line', note: 'guid ok' },
+                { hop_type: 'code_loader', anchor: `${filePath}:3`, snippet: 'loader line', note: 'loader ok' },
+                { hop_type: 'code_runtime', anchor: `${filePath}:4`, snippet: 'runtime line', note: 'runtime ok' },
+            ],
+        },
+    };
+    const validation = await validateReloadAcceptanceArtifact(artifact);
+    assert.equal(validation.ok, false);
+    assert.equal(validation.failures.some((failure) => /loader.*curgungraph/i.test(failure)), true);
+    assert.equal(validation.failures.some((failure) => /runtime.*closure/i.test(failure)), true);
+});

package/dist/benchmark/u2-e2e/report.d.ts

@@ -28,6 +28,7 @@ export interface U2RetrievalSummary {
         totalDurationMs: number;
     };
     serializedTypeEdgeCount?: number;
+    resourceSummaryEdgeCount?: number;
     characterListAssetRefSprite?: U2CharacterListAssetRefSpriteSummary;
     failures?: string[];
 }

package/dist/benchmark/u2-e2e/report.js

@@ -44,6 +44,7 @@ export function buildRetrievalSummaryMarkdown(summary) {
         `- Total Tokens (est): ${summary.tokenSummary?.totalTokensEst ?? 0}`,
         `- Total Duration: ${formatMs(summary.tokenSummary?.totalDurationMs)}`,
         `- UNITY_SERIALIZED_TYPE_IN Edges: ${typeof summary.serializedTypeEdgeCount === 'number' ? summary.serializedTypeEdgeCount : 'n/a'}`,
+        `- UNITY_RESOURCE_SUMMARY Edges: ${typeof summary.resourceSummaryEdgeCount === 'number' ? summary.resourceSummaryEdgeCount : 'n/a'}`,
         `- CharacterList AssetRef Sprite Instances: ${summary.characterListAssetRefSprite?.spriteAssetRefInstances ?? 'n/a'}`,
         `- CharacterList AssetRef Sprite Ratio: ${typeof summary.characterListAssetRefSprite?.spriteRatioInNonEmpty === 'number'
             ? `${(summary.characterListAssetRefSprite.spriteRatioInNonEmpty * 100).toFixed(2)}%`
@@ -87,6 +88,7 @@ export function buildFinalVerdictMarkdown(input) {
         `- Total Tokens (est): ${summary?.tokenSummary?.totalTokensEst ?? 0}`,
         `- Total Duration: ${formatMs(summary?.tokenSummary?.totalDurationMs)}`,
         `- UNITY_SERIALIZED_TYPE_IN Edges: ${typeof summary?.serializedTypeEdgeCount === 'number' ? summary.serializedTypeEdgeCount : 'n/a'}`,
+        `- UNITY_RESOURCE_SUMMARY Edges: ${typeof summary?.resourceSummaryEdgeCount === 'number' ? summary.resourceSummaryEdgeCount : 'n/a'}`,
         `- CharacterList AssetRef Sprite Instances: ${summary?.characterListAssetRefSprite?.spriteAssetRefInstances ?? 'n/a'}`,
         `- CharacterList AssetRef Sprite Ratio: ${typeof summary?.characterListAssetRefSprite?.spriteRatioInNonEmpty === 'number'
             ? `${(summary.characterListAssetRefSprite.spriteRatioInNonEmpty * 100).toFixed(2)}%`

package/dist/benchmark/u2-e2e/retrieval-runner.d.ts

@@ -18,4 +18,38 @@ export interface SymbolScenarioResult {
         failures: string[];
     };
 }
+export interface Phase5ConfidenceCalibrationCounts {
+    totalEvaluated: number;
+    falseNegativeCount: number;
+    falseConfidenceCount: number;
+    lowConfidenceHintCovered: number;
+    lowConfidenceCount: number;
+    fallbackCovered: number;
+}
+export interface Phase5BaselineSnapshot extends Partial<Phase5ConfidenceCalibrationCounts> {
+    artifactPath: string;
+    gitCommit: string;
+    sha256: string;
+}
+export interface Phase5ConfidenceCalibrationSummary {
+    lowConfidenceHintCoverage: number;
+    falseConfidenceFailures: number;
+    falseNegativeFallbackCoverage: number;
+    falseNegativeRateBaselinePct: number;
+    falseNegativeRateCurrentPct: number;
+    falseNegativeRateDeltaPct: number;
+    falseConfidenceRateBaselinePct: number;
+    falseConfidenceRateCurrentPct: number;
+    falseConfidenceRateDeltaPct: number;
+    baseline: {
+        artifactPath: string;
+        gitCommit: string;
+        sha256: string;
+    };
+}
+export declare function containsPlaceholderLeak(value: unknown): boolean;
+export declare function summarizePhase5ConfidenceCalibration(input: {
+    current: Phase5ConfidenceCalibrationCounts;
+    baseline: Phase5BaselineSnapshot;
+}): Phase5ConfidenceCalibrationSummary;
 export declare function runSymbolScenario(runner: ToolRunner, scenario: SymbolScenario, repo?: string): Promise<SymbolScenarioResult>;