@veewo/gitnexus 1.3.8 → 1.3.10

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

@@ -0,0 +1,58 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildFinalVerdictMarkdown } from './report.js';
+test('buildFinalVerdictMarkdown includes estimate comparison and symbol outcomes', () => {
+    const md = buildFinalVerdictMarkdown({
+        runId: 'test-run',
+        buildTimings: { buildMs: 1200, pipelineProfileMs: 2500, analyzeSec: 114.8 },
+        estimateComparison: { status: 'in-range', inRange: true, actualSec: 500, lower: 322.6, upper: 540.1, deltaSec: 0 },
+        retrievalSummary: {
+            symbols: [
+                { symbol: 'MainUIManager', pass: true, stepCount: 3 },
+                { symbol: 'CoinPowerUp', pass: true, stepCount: 3 },
+            ],
+            tokenSummary: { totalTokensEst: 3456, totalDurationMs: 876 },
+            failures: [],
+        },
+        failures: [],
+    });
+    assert.match(md, /Estimate Comparison/);
+    assert.match(md, /MainUIManager/);
+    assert.match(md, /CoinPowerUp/);
+});
+test('buildFinalVerdictMarkdown deduplicates repeated failures and renders serialized edge count', () => {
+    const md = buildFinalVerdictMarkdown({
+        runId: 'test-run',
+        retrievalSummary: {
+            symbols: [{ symbol: 'AssetRef', pass: true, stepCount: 4 }],
+            tokenSummary: { totalTokensEst: 100, totalDurationMs: 12.3 },
+            serializedTypeEdgeCount: 12,
+            failures: ['duration.min=1.1ms median=2.2ms max=3.3ms'],
+        },
+        failures: ['duration.min=1.1ms median=2.2ms max=3.3ms'],
+    });
+    const duplicateMatches = md.match(/duration\.min=1\.1ms median=2\.2ms max=3\.3ms/g) || [];
+    assert.equal(duplicateMatches.length, 1);
+    assert.match(md, /UNITY_SERIALIZED_TYPE_IN Edges: 12/);
+});
+test('buildFinalVerdictMarkdown renders CharacterList AssetRef sprite summary when provided', () => {
+    const md = buildFinalVerdictMarkdown({
+        runId: 'test-run',
+        retrievalSummary: {
+            symbols: [{ symbol: 'AssetRef', pass: true, stepCount: 4 }],
+            tokenSummary: { totalTokensEst: 100, totalDurationMs: 12.3 },
+            serializedTypeEdgeCount: 12,
+            characterListAssetRefSprite: {
+                extractedAssetRefInstances: 127,
+                nonEmptyAssetRefInstances: 123,
+                spriteAssetRefInstances: 63,
+                spriteRatioInNonEmpty: 0.5122,
+                uniqueSpriteAssets: 54,
+            },
+            failures: [],
+        },
+        failures: [],
+    });
+    assert.match(md, /CharacterList AssetRef Sprite Instances: 63/);
+    assert.match(md, /CharacterList AssetRef Sprite Ratio: 51.22%/);
+});

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

@@ -0,0 +1,21 @@
+import type { SymbolScenario } from './config.js';
+import { type StepMetric } from './metrics.js';
+export interface ToolRunner {
+    query: (params: Record<string, unknown>) => Promise<any>;
+    context: (params: Record<string, unknown>) => Promise<any>;
+    impact: (params: Record<string, unknown>) => Promise<any>;
+    cypher: (params: Record<string, unknown>) => Promise<any>;
+}
+export interface RetrievalStepResult extends StepMetric {
+    input: Record<string, unknown>;
+    output: any;
+}
+export interface SymbolScenarioResult {
+    symbol: string;
+    steps: RetrievalStepResult[];
+    assertions: {
+        pass: boolean;
+        failures: string[];
+    };
+}
+export declare function runSymbolScenario(runner: ToolRunner, scenario: SymbolScenario, repo?: string): Promise<SymbolScenarioResult>;

package/dist/benchmark/u2-e2e/retrieval-runner.js

@@ -0,0 +1,166 @@
+import { performance } from 'node:perf_hooks';
+import path from 'node:path';
+import { estimateTokens } from './metrics.js';
+function stringify(value) {
+    try {
+        return JSON.stringify(value ?? null);
+    }
+    catch {
+        return String(value);
+    }
+}
+function buildMetric(stepId, tool, durationMs, input, output) {
+    const inputText = stringify(input);
+    const outputText = stringify(output);
+    const inputChars = inputText.length;
+    const outputChars = outputText.length;
+    const inputTokensEst = estimateTokens(inputText);
+    const outputTokensEst = estimateTokens(outputText);
+    return {
+        stepId,
+        tool,
+        durationMs: Number(durationMs.toFixed(1)),
+        inputChars,
+        outputChars,
+        inputTokensEst,
+        outputTokensEst,
+        totalTokensEst: inputTokensEst + outputTokensEst,
+        input,
+        output,
+    };
+}
+function countRefs(value) {
+    if (!value)
+        return 0;
+    let total = 0;
+    for (const rows of Object.values(value)) {
+        if (Array.isArray(rows)) {
+            total += rows.length;
+        }
+    }
+    return total;
+}
+function hasDeepDiveEvidence(output) {
+    const processSymbols = Array.isArray(output?.process_symbols) ? output.process_symbols.length : 0;
+    const definitions = Array.isArray(output?.definitions) ? output.definitions.length : 0;
+    const candidates = Array.isArray(output?.candidates) ? output.candidates.length : 0;
+    const rows = Array.isArray(output?.rows) ? output.rows.length : 0;
+    const byDepth = output?.byDepth && typeof output.byDepth === 'object'
+        ? Object.values(output.byDepth).reduce((sum, value) => sum + (Array.isArray(value) ? value.length : 0), 0)
+        : 0;
+    const impacted = Number(output?.impactedCount || 0);
+    const incomingRefs = countRefs(output?.incoming);
+    const outgoingRefs = countRefs(output?.outgoing);
+    return processSymbols + definitions + candidates + rows + byDepth + impacted + incomingRefs + outgoingRefs > 0;
+}
+function assertScenario(scenario, contextOnOutput, deepDiveOutputs) {
+    const failures = [];
+    const bindings = Array.isArray(contextOnOutput?.resourceBindings) ? contextOnOutput.resourceBindings : [];
+    const hasBindings = bindings.length > 0;
+    const hasResolvedReferences = bindings.some((binding) => Array.isArray(binding?.resolvedReferences) && binding.resolvedReferences.length > 0);
+    const hasAssetTypeBinding = bindings.some((binding) => typeof binding?.resourceType === 'string' && binding.resourceType.length > 0);
+    if (scenario.symbol === 'MainUIManager' || scenario.symbol === 'PlayerActor') {
+        if (!hasBindings) {
+            failures.push(`${scenario.symbol}: context(on) must include resourceBindings`);
+        }
+    }
+    if (scenario.symbol === 'CoinPowerUp' || scenario.symbol === 'GlobalDataAssets') {
+        if (!hasAssetTypeBinding && !hasResolvedReferences) {
+            failures.push(`${scenario.symbol}: require asset-type binding or resolved references evidence`);
+        }
+    }
+    if (scenario.symbol === 'AssetRef') {
+        if (!hasBindings) {
+            failures.push('AssetRef: context(on) must include resourceBindings');
+        }
+        const deepDiveEvidence = deepDiveOutputs.some((output) => hasDeepDiveEvidence(output));
+        if (!deepDiveEvidence) {
+            failures.push('AssetRef: deep-dive must provide usage/dependency evidence');
+        }
+    }
+    return {
+        pass: failures.length === 0,
+        failures,
+    };
+}
+async function invokeTool(runner, tool, input) {
+    if (tool === 'query') {
+        return runner.query(input);
+    }
+    if (tool === 'context') {
+        return runner.context(input);
+    }
+    if (tool === 'impact') {
+        return runner.impact(input);
+    }
+    return runner.cypher(input);
+}
+function selectDisambiguationUid(symbol, output) {
+    const expectedFile = `${symbol}.cs`.toLowerCase();
+    const candidates = Array.isArray(output?.candidates) ? output.candidates : [];
+    for (const candidate of candidates) {
+        const kind = String(candidate?.kind || '').toLowerCase();
+        if (kind !== 'class')
+            continue;
+        const filePath = String(candidate?.filePath || candidate?.file_path || '').trim();
+        if (!filePath)
+            continue;
+        if (path.basename(filePath).toLowerCase() !== expectedFile)
+            continue;
+        const uid = String(candidate?.uid || '').trim();
+        if (uid) {
+            return uid;
+        }
+    }
+    return undefined;
+}
+async function runContextWithDisambiguation(runner, scenario, input) {
+    const first = await runner.context(input);
+    if (first?.status !== 'ambiguous') {
+        return first;
+    }
+    const hint = typeof scenario.contextFileHint === 'string' ? scenario.contextFileHint.trim() : '';
+    if (hint) {
+        const hinted = await runner.context({ ...input, file_path: hint });
+        if (hinted?.status !== 'ambiguous') {
+            return hinted;
+        }
+    }
+    const uid = selectDisambiguationUid(scenario.symbol, first);
+    if (uid) {
+        return runner.context({ ...input, uid });
+    }
+    return first;
+}
+export async function runSymbolScenario(runner, scenario, repo) {
+    const steps = [];
+    const baseContextInput = { name: scenario.symbol };
+    if (repo) {
+        baseContextInput.repo = repo;
+    }
+    const contextOffInput = { ...baseContextInput, unity_resources: 'off' };
+    const t0 = performance.now();
+    const contextOff = await runContextWithDisambiguation(runner, scenario, contextOffInput);
+    steps.push(buildMetric('context-off', 'context', performance.now() - t0, contextOffInput, contextOff));
+    const contextOnInput = { ...baseContextInput, unity_resources: 'on' };
+    const t1 = performance.now();
+    const contextOn = await runContextWithDisambiguation(runner, scenario, contextOnInput);
+    steps.push(buildMetric('context-on', 'context', performance.now() - t1, contextOnInput, contextOn));
+    const deepDiveOutputs = [];
+    for (let i = 0; i < scenario.deepDivePlan.length; i += 1) {
+        const step = scenario.deepDivePlan[i];
+        const input = { ...(step.input || {}) };
+        if (repo) {
+            input.repo = repo;
+        }
+        const ts = performance.now();
+        const output = await invokeTool(runner, step.tool, input);
+        deepDiveOutputs.push(output);
+        steps.push(buildMetric(`deep-dive-${i + 1}`, step.tool, performance.now() - ts, input, output));
+    }
+    return {
+        symbol: scenario.symbol,
+        steps,
+        assertions: assertScenario(scenario, contextOn, deepDiveOutputs),
+    };
+}

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

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

package/dist/benchmark/u2-e2e/retrieval-runner.test.js

@@ -0,0 +1,145 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { runSymbolScenario } from './retrieval-runner.js';
+import { loadE2EConfig } from './config.js';
+test('runSymbolScenario executes context off/on + deepDive and records metrics', async () => {
+    const mockToolRunner = {
+        context: async (input) => {
+            if (input.unity_resources === 'on') {
+                return {
+                    status: 'found',
+                    resourceBindings: [
+                        {
+                            resourcePath: 'Assets/Prefabs/UI.prefab',
+                            resourceType: 'prefab',
+                            resolvedReferences: [{ uid: 'Class:Foo' }],
+                        },
+                    ],
+                };
+            }
+            return { status: 'found' };
+        },
+        query: async () => ({ process_symbols: [{ id: 'Class:MainUIManager' }] }),
+        impact: async () => ({ impactedCount: 1 }),
+        cypher: async () => ({ rows: [] }),
+    };
+    const out = await runSymbolScenario(mockToolRunner, {
+        symbol: 'MainUIManager',
+        kind: 'component',
+        objectives: ['verify context'],
+        deepDivePlan: [{ tool: 'query', input: { query: 'MainUIManager' } }],
+    });
+    assert.equal(out.steps.length, 3);
+    assert.ok(out.steps.every((s) => s.durationMs >= 0));
+    assert.ok(out.steps.every((s) => s.totalTokensEst >= 0));
+    assert.equal(out.assertions.pass, true);
+});
+test('AssetRef requires context(on) resourceBindings after serializable-class coverage', async () => {
+    const noEvidenceRunner = {
+        context: async () => ({ status: 'found', resourceBindings: [] }),
+        query: async () => ({ process_symbols: [] }),
+        impact: async () => ({ impactedCount: 0 }),
+        cypher: async () => ({ rows: [] }),
+    };
+    const out = await runSymbolScenario(noEvidenceRunner, {
+        symbol: 'AssetRef',
+        kind: 'serializable-class',
+        objectives: ['verify usage evidence'],
+        deepDivePlan: [{ tool: 'query', input: { query: 'AssetRef usage' } }],
+    });
+    assert.equal(out.assertions.pass, false);
+    assert.ok(out.assertions.failures.some((f) => f.includes('context(on) must include resourceBindings')));
+});
+test('AssetRef requires deep-dive evidence even when context(on) has resourceBindings', async () => {
+    const noDeepDiveEvidenceRunner = {
+        context: async () => ({
+            status: 'found',
+            resourceBindings: [{ resourcePath: 'Assets/Data/Unlock.asset', resourceType: 'asset' }],
+        }),
+        query: async () => ({ process_symbols: [] }),
+        impact: async () => ({ impactedCount: 0 }),
+        cypher: async () => ({ rows: [] }),
+    };
+    const out = await runSymbolScenario(noDeepDiveEvidenceRunner, {
+        symbol: 'AssetRef',
+        kind: 'serializable-class',
+        objectives: ['verify usage evidence'],
+        deepDivePlan: [{ tool: 'query', input: { query: 'AssetRef usage' } }],
+    });
+    assert.equal(out.assertions.pass, false);
+    assert.ok(out.assertions.failures.some((f) => f.includes('deep-dive must provide usage/dependency evidence')));
+});
+test('AssetRef passes when context(on) bindings and deep-dive evidence are both present', async () => {
+    const satisfiedRunner = {
+        context: async () => ({
+            status: 'found',
+            resourceBindings: [{ resourcePath: 'Assets/Data/Unlock.asset', resourceType: 'asset' }],
+        }),
+        query: async () => ({ process_symbols: [{ id: 'Class:Assets/Scripts/UnlockContent.cs:UnlockContent' }] }),
+        impact: async () => ({ impactedCount: 0 }),
+        cypher: async () => ({ rows: [] }),
+    };
+    const out = await runSymbolScenario(satisfiedRunner, {
+        symbol: 'AssetRef',
+        kind: 'serializable-class',
+        objectives: ['verify usage evidence'],
+        deepDivePlan: [{ tool: 'query', input: { query: 'AssetRef usage' } }],
+    });
+    assert.equal(out.assertions.pass, true);
+    assert.equal(out.assertions.failures.length, 0);
+});
+test('PlayerActor scenario uses context file hint and valid context deep-dive input', async () => {
+    const config = await loadE2EConfig('benchmarks/u2-e2e/neonspark-full-u2-e2e.config.json');
+    const player = config.symbolScenarios.find((s) => s.symbol === 'PlayerActor');
+    assert.equal(player?.contextFileHint, 'Assets/NEON/Code/Game/Actors/PlayerActor/PlayerActor.cs');
+    assert.equal(player?.deepDivePlan[0]?.tool, 'context');
+    assert.equal(player?.deepDivePlan[0]?.input?.name, 'PlayerActor');
+});
+test('runSymbolScenario retries context with file hint when response is ambiguous', async () => {
+    const hint = 'Assets/NEON/Code/Game/Actors/PlayerActor/PlayerActor.cs';
+    const contextCalls = [];
+    const runner = {
+        context: async (input) => {
+            contextCalls.push(input);
+            if (input.unity_resources === 'off') {
+                return { status: 'found' };
+            }
+            if (input.file_path === hint) {
+                return {
+                    status: 'found',
+                    resourceBindings: [
+                        {
+                            resourcePath: 'Assets/Prefabs/Player.prefab',
+                            resourceType: 'prefab',
+                            resolvedReferences: [{ uid: 'Class:PlayerActor' }],
+                        },
+                    ],
+                };
+            }
+            return {
+                status: 'ambiguous',
+                candidates: [
+                    {
+                        uid: 'Class:Assets/NEON/Code/Game/Actors/PlayerActor/PlayerActor.Visual.cs:PlayerActor',
+                        kind: 'Class',
+                        filePath: 'Assets/NEON/Code/Game/Actors/PlayerActor/PlayerActor.Visual.cs',
+                    },
+                ],
+            };
+        },
+        query: async () => ({ process_symbols: [] }),
+        impact: async () => ({ impactedCount: 0 }),
+        cypher: async () => ({ rows: [] }),
+    };
+    const out = await runSymbolScenario(runner, {
+        symbol: 'PlayerActor',
+        kind: 'partial-component',
+        contextFileHint: hint,
+        objectives: ['verify fallback'],
+        deepDivePlan: [{ tool: 'query', input: { query: 'PlayerActor resource binding' } }],
+    });
+    assert.equal(contextCalls.length, 3);
+    assert.equal(contextCalls[2]?.file_path, hint);
+    assert.equal(out.steps[1]?.output?.status, 'found');
+    assert.equal(out.assertions.pass, true);
+});

package/dist/benchmark/u2-performance-sampler.d.ts

@@ -0,0 +1,33 @@
+export interface NumericStats {
+    mean: number;
+    median: number;
+    min: number;
+    max: number;
+    spread: number;
+}
+export interface MetricThreshold {
+    medianMax: number;
+    maxMax: number;
+}
+export interface U2PerformanceThresholds {
+    metaIndexMs?: MetricThreshold;
+    referenceResolveMs?: MetricThreshold;
+    graphReferenceWriteMs?: MetricThreshold;
+}
+export interface U2ThresholdVerdict {
+    pass: boolean;
+    metrics: Record<string, {
+        pass: boolean;
+        actual: {
+            median: number;
+            max: number;
+        };
+        expected: MetricThreshold;
+    }>;
+}
+export declare function computeNumericStats(values: number[]): NumericStats;
+export declare function evaluateMetricsThresholds(metrics: {
+    metaIndexMs: number[];
+    referenceResolveMs: number[];
+    graphReferenceWriteMs: number[];
+}, thresholds: U2PerformanceThresholds): U2ThresholdVerdict;

package/dist/benchmark/u2-performance-sampler.js

@@ -0,0 +1,178 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
+import { resolveAnalyzeScopeRules } from '../cli/analyze-options.js';
+export function computeNumericStats(values) {
+    if (values.length === 0) {
+        return { mean: 0, median: 0, min: 0, max: 0, spread: 0 };
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const mean = sorted.reduce((sum, value) => sum + value, 0) / sorted.length;
+    const mid = Math.floor(sorted.length / 2);
+    const median = sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+    const min = sorted[0];
+    const max = sorted[sorted.length - 1];
+    return {
+        mean: round1(mean),
+        median: round1(median),
+        min: round1(min),
+        max: round1(max),
+        spread: round1(max - min),
+    };
+}
+export function evaluateMetricsThresholds(metrics, thresholds) {
+    const verdict = { pass: true, metrics: {} };
+    const entries = [
+        ['metaIndexMs', thresholds.metaIndexMs],
+        ['referenceResolveMs', thresholds.referenceResolveMs],
+        ['graphReferenceWriteMs', thresholds.graphReferenceWriteMs],
+    ];
+    for (const [name, threshold] of entries) {
+        if (!threshold)
+            continue;
+        const stats = computeNumericStats(metrics[name]);
+        const metricPass = stats.median <= threshold.medianMax && stats.max <= threshold.maxMax;
+        verdict.metrics[name] = {
+            pass: metricPass,
+            actual: { median: stats.median, max: stats.max },
+            expected: threshold,
+        };
+        if (!metricPass) {
+            verdict.pass = false;
+        }
+    }
+    return verdict;
+}
+async function samplePipeline(targetPath, run, scopeRules) {
+    const phases = [];
+    let currentPhase = null;
+    let phaseStart = performance.now();
+    const onProgress = (progress) => {
+        const now = performance.now();
+        if (!currentPhase) {
+            currentPhase = progress.phase;
+            phaseStart = now;
+            return;
+        }
+        if (progress.phase !== currentPhase) {
+            phases.push({ phase: currentPhase, durationMs: round1(now - phaseStart) });
+            currentPhase = progress.phase;
+            phaseStart = now;
+        }
+    };
+    const t0 = performance.now();
+    const result = await runPipelineFromRepo(targetPath, onProgress, {
+        scopeRules,
+    });
+    const t1 = performance.now();
+    if (currentPhase) {
+        phases.push({ phase: currentPhase, durationMs: round1(t1 - phaseStart) });
+    }
+    return {
+        run,
+        totalMs: round1(t1 - t0),
+        phases,
+        unity: {
+            processedSymbols: result.unityResult.processedSymbols,
+            bindingCount: result.unityResult.bindingCount,
+            diagnosticsTotal: result.unityResult.diagnostics.length,
+            timingsMs: {
+                scanContext: result.unityResult.timingsMs.scanContext,
+                resolve: result.unityResult.timingsMs.resolve,
+                graphWrite: result.unityResult.timingsMs.graphWrite,
+                total: result.unityResult.timingsMs.total,
+            },
+        },
+    };
+}
+function parseArgs(argv) {
+    const get = (name) => {
+        const index = argv.indexOf(name);
+        if (index === -1 || index + 1 >= argv.length)
+            return undefined;
+        return argv[index + 1];
+    };
+    const targetPath = get('--target-path');
+    const reportPath = get('--report');
+    const thresholdsPath = get('--thresholds');
+    const scopeManifest = get('--scope-manifest');
+    const runs = Number(get('--runs') || '3');
+    const scopePrefix = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        if (argv[i] === '--scope-prefix' && i + 1 < argv.length) {
+            scopePrefix.push(argv[i + 1]);
+            i += 1;
+        }
+    }
+    if (!targetPath)
+        throw new Error('Missing required arg: --target-path <path>');
+    if (!reportPath)
+        throw new Error('Missing required arg: --report <path>');
+    if (!Number.isFinite(runs) || runs <= 0)
+        throw new Error('Invalid --runs, must be positive integer');
+    return { targetPath: path.resolve(targetPath), runs: Math.floor(runs), reportPath: path.resolve(reportPath), thresholdsPath: thresholdsPath ? path.resolve(thresholdsPath) : undefined, scopeManifest, scopePrefix };
+}
+function round1(value) {
+    return Number(value.toFixed(1));
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const scopeRules = await resolveAnalyzeScopeRules({
+        scopeManifest: args.scopeManifest,
+        scopePrefix: args.scopePrefix,
+    });
+    const runs = [];
+    for (let run = 1; run <= args.runs; run += 1) {
+        console.log(`[u2-sampler] run ${run}/${args.runs} ...`);
+        runs.push(await samplePipeline(args.targetPath, run, scopeRules));
+    }
+    const metaIndexMsSeries = runs.map((entry) => entry.unity.timingsMs.scanContext);
+    const referenceResolveMsSeries = runs.map((entry) => entry.unity.timingsMs.resolve);
+    const graphReferenceWriteMsSeries = runs.map((entry) => entry.unity.timingsMs.graphWrite);
+    let thresholdVerdict = null;
+    if (args.thresholdsPath) {
+        const raw = await fs.readFile(args.thresholdsPath, 'utf-8');
+        const thresholds = JSON.parse(raw);
+        thresholdVerdict = evaluateMetricsThresholds({
+            metaIndexMs: metaIndexMsSeries,
+            referenceResolveMs: referenceResolveMsSeries,
+            graphReferenceWriteMs: graphReferenceWriteMsSeries,
+        }, thresholds);
+    }
+    const report = {
+        capturedAt: new Date().toISOString(),
+        targetPath: args.targetPath,
+        runs: args.runs,
+        scope: {
+            scopeManifest: args.scopeManifest || null,
+            scopePrefix: args.scopePrefix,
+            scopeRuleCount: scopeRules.length,
+        },
+        samples: runs,
+        metrics: {
+            metaIndexMs: computeNumericStats(metaIndexMsSeries),
+            referenceResolveMs: computeNumericStats(referenceResolveMsSeries),
+            graphReferenceWriteMs: computeNumericStats(graphReferenceWriteMsSeries),
+            unityTotalMs: computeNumericStats(runs.map((entry) => entry.unity.timingsMs.total)),
+            pipelineTotalMs: computeNumericStats(runs.map((entry) => entry.totalMs)),
+        },
+        notes: {
+            metaIndexMsDefinition: 'Current implementation uses unity.timingsMs.scanContext as metaIndexMs proxy (scanContext includes meta index + resource scan + asset meta index).',
+        },
+        thresholdVerdict,
+    };
+    await fs.mkdir(path.dirname(args.reportPath), { recursive: true });
+    await fs.writeFile(args.reportPath, JSON.stringify(report, null, 2));
+    console.log(`[u2-sampler] report written: ${args.reportPath}`);
+    if (thresholdVerdict && !thresholdVerdict.pass) {
+        process.exitCode = 1;
+    }
+}
+const modulePath = process.argv[1] ? path.resolve(process.argv[1]) : '';
+if (import.meta.url === `file://${modulePath}`) {
+    main().catch((error) => {
+        console.error(`[u2-sampler] failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    });
+}

package/dist/benchmark/u2-performance-sampler.test.d.ts

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

package/dist/benchmark/u2-performance-sampler.test.js

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { computeNumericStats, evaluateMetricsThresholds } from './u2-performance-sampler.js';
+test('computeNumericStats returns stable summary fields', () => {
+    const stats = computeNumericStats([120, 80, 100]);
+    assert.equal(stats.mean, 100);
+    assert.equal(stats.median, 100);
+    assert.equal(stats.min, 80);
+    assert.equal(stats.max, 120);
+    assert.equal(stats.spread, 40);
+});
+test('evaluateMetricsThresholds marks pass/fail per metric', () => {
+    const metrics = {
+        metaIndexMs: [4100, 4000, 4200],
+        referenceResolveMs: [3000, 2900, 3100],
+        graphReferenceWriteMs: [250, 240, 260],
+    };
+    const thresholds = {
+        metaIndexMs: { medianMax: 4500, maxMax: 5000 },
+        referenceResolveMs: { medianMax: 3200, maxMax: 3600 },
+        graphReferenceWriteMs: { medianMax: 260, maxMax: 300 },
+    };
+    const verdict = evaluateMetricsThresholds(metrics, thresholds);
+    assert.equal(verdict.pass, true);
+    assert.equal(verdict.metrics.metaIndexMs?.pass, true);
+    assert.equal(verdict.metrics.referenceResolveMs?.pass, true);
+    assert.equal(verdict.metrics.graphReferenceWriteMs?.pass, true);
+    const failing = evaluateMetricsThresholds(metrics, {
+        ...thresholds,
+        referenceResolveMs: { medianMax: 2500, maxMax: 2800 },
+    });
+    assert.equal(failing.pass, false);
+    assert.equal(failing.metrics.referenceResolveMs?.pass, false);
+});

package/dist/cli/ai-context.js

@@ -38,7 +38,7 @@ This project is indexed by GitNexus as **${projectName}** (${stats.nodes || 0} s
 2. **Match your task to a skill below** and **read that skill file**
 3. **Follow the skill's workflow and checklist**
 
-> If step 1 warns the index is stale, run \`npx gitnexus analyze\` in the terminal first.
+> If step 1 warns the index is stale, ask user whether to rebuild index via \`npx -y gitnexus analyze\` first (it reuses previous analyze scope/options by default; add \`--no-reuse-options\` to reset). If user declines, explicitly warn that retrieval may not reflect current codebase. For build/analyze/test commands, use a 10-30 minute timeout; on failure/timeout, report exact tool output and do not auto-retry or silently fall back to glob/grep.
 
 ## Skills
 

package/dist/cli/analyze-multi-scope-regression.test.js

@@ -20,3 +20,13 @@ test('runPipelineFromRepo deduplicates overlapping scope matches and reports dia
     assert.equal(result.scopeDiagnostics?.dedupedMatchCount, 3);
     assert.equal(result.scopeDiagnostics?.normalizedCollisions.length, 0);
 });
+test('pipeline forwards extension-filtered scoped paths to unity enrich', { timeout: 60_000 }, async () => {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const fixtureRepo = path.resolve(here, '../../src/core/unity/__fixtures__/mini-unity');
+    const result = await runPipelineFromRepo(fixtureRepo, () => { }, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets'],
+    });
+    assert.ok((result.unityResult?.bindingCount || 0) > 0);
+    assert.ok(result.unityResult?.diagnostics.some((message) => message.includes('scanContext:')));
+});