@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

package/dist/cli/analyze.test.js

@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { buildPipelineRunOptionsForAnalyze } from './analyze.js';
+import { resolveScopeManifestForAnalyze } from './sync-manifest.js';
+test('analyze auto-loads .gitnexus/sync-manifest.txt when CLI scope options are omitted', async () => {
+    const repoPath = path.join('/tmp', 'demo-repo');
+    const expectedManifest = path.join(repoPath, '.gitnexus', 'sync-manifest.txt');
+    const resolved = await resolveScopeManifestForAnalyze(repoPath, {}, async (candidate) => candidate === expectedManifest);
+    assert.equal(resolved, expectedManifest);
+});
+test('explicit --scope-manifest still wins over auto-detected default file', async () => {
+    const repoPath = path.join('/tmp', 'demo-repo');
+    const explicitManifest = path.join(repoPath, 'custom-manifest.txt');
+    const resolved = await resolveScopeManifestForAnalyze(repoPath, { scopeManifest: explicitManifest }, async () => true);
+    assert.equal(resolved, explicitManifest);
+});
+test('buildPipelineRunOptionsForAnalyze passes csharp define csproj option through to pipeline', () => {
+    const out = buildPipelineRunOptionsForAnalyze({ includeExtensions: ['.cs'], scopeRules: ['Assets/**'] }, { csharpDefineCsproj: '/tmp/Assembly-CSharp.csproj' });
+    assert.deepEqual(out, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/**'],
+        csharpDefineCsproj: '/tmp/Assembly-CSharp.csproj',
+    });
+});

package/dist/cli/benchmark-agent-context.js

@@ -27,7 +27,7 @@ export async function benchmarkAgentContextCommand(dataset, options, deps) {
         }
         const analyzePath = path.resolve(options.targetPath);
         const analyzeOptions = {
-            extensions: options.extensions || '.cs',
+            extensions: options.extensions,
             repoAlias: options.repoAlias,
             scopeManifest: options.scopeManifest,
             scopePrefix: options.scopePrefix,

package/dist/cli/benchmark-agent-safe-query-context.d.ts

@@ -0,0 +1,20 @@
+import { runAnalyze } from '../benchmark/analyze-runner.js';
+import { runAgentSafeQueryContextBenchmark, writeAgentSafeQueryContextReports, type AgentSafeQueryContextBenchmarkReport } from '../benchmark/agent-safe-query-context/report.js';
+import type { AgentSafeBenchmarkSuite } from '../benchmark/agent-safe-query-context/types.js';
+export declare function benchmarkAgentSafeQueryContextCommand(dataset: string, options: {
+    repo?: string;
+    repoAlias?: string;
+    targetPath?: string;
+    reportDir?: string;
+    subagentRunsDir?: string;
+    extensions?: string;
+    scopeManifest?: string;
+    scopePrefix?: string[];
+    skipAnalyze?: boolean;
+}, deps?: {
+    loadSuite?: (root: string) => Promise<AgentSafeBenchmarkSuite>;
+    runBenchmark?: typeof runAgentSafeQueryContextBenchmark;
+    writeReports?: typeof writeAgentSafeQueryContextReports;
+    writeLine?: (line: string) => void;
+    analyze?: typeof runAnalyze;
+}): Promise<AgentSafeQueryContextBenchmarkReport>;

package/dist/cli/benchmark-agent-safe-query-context.js

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import { runAnalyze } from '../benchmark/analyze-runner.js';
+import { loadAgentSafeQueryContextSuite } from '../benchmark/agent-safe-query-context/io.js';
+import { runAgentSafeQueryContextBenchmark, writeAgentSafeQueryContextReports, } from '../benchmark/agent-safe-query-context/report.js';
+export async function benchmarkAgentSafeQueryContextCommand(dataset, options, deps) {
+    const loadSuite = deps?.loadSuite || loadAgentSafeQueryContextSuite;
+    const runBenchmark = deps?.runBenchmark || runAgentSafeQueryContextBenchmark;
+    const writeReports = deps?.writeReports || writeAgentSafeQueryContextReports;
+    const writeLine = deps?.writeLine || ((line) => process.stderr.write(`${line}\n`));
+    const analyze = deps?.analyze || runAnalyze;
+    const reportDir = path.resolve(options.reportDir || '.gitnexus/benchmark-agent-safe-query-context');
+    if (!(options.skipAnalyze ?? false)) {
+        if (!options.targetPath) {
+            throw new Error('targetPath is required unless skipAnalyze is true');
+        }
+        await analyze(path.resolve(options.targetPath), {
+            extensions: options.extensions,
+            repoAlias: options.repoAlias,
+            scopeManifest: options.scopeManifest,
+            scopePrefix: options.scopePrefix,
+        });
+    }
+    const suite = await loadSuite(path.resolve(dataset));
+    const report = await runBenchmark(suite, {
+        repo: options.repo || options.repoAlias || (options.targetPath ? path.basename(path.resolve(options.targetPath)) : undefined),
+        subagentRunsDir: options.subagentRunsDir ? path.resolve(options.subagentRunsDir) : undefined,
+    });
+    await writeReports(reportDir, report);
+    writeLine(`${report.pass ? 'PASS' : 'FAIL'}`);
+    for (const key of ['weapon_powerup', 'reload']) {
+        const row = report.workflow_replay_slim[key];
+        writeLine(`${key}: guid_invariance_pass=${row.guid_invariance_pass}, live_tool_evidence_pass=${row.live_tool_evidence_pass}, freeze_ready=${row.freeze_ready}, confirmed_chain_steps=${row.confirmed_chain.steps.length}, placeholder_leak_detected=${row.placeholder_leak_detected}, heuristic_top_summary_detected=${row.heuristic_top_summary_detected}`);
+    }
+    writeLine(`Report: ${reportDir}`);
+    if (!report.pass) {
+        process.exitCode = 1;
+    }
+    return report;
+}

package/dist/cli/benchmark-agent-safe-query-context.test.d.ts

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

package/dist/cli/benchmark-agent-safe-query-context.test.js

@@ -0,0 +1,271 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { benchmarkAgentSafeQueryContextCommand } from './benchmark-agent-safe-query-context.js';
+test('benchmark-agent-safe-query-context runs suite loader, benchmark, and report writer', async () => {
+    const output = [];
+    const calls = [];
+    const report = await benchmarkAgentSafeQueryContextCommand('../benchmarks/agent-safe-query-context/neonspark-v1', {
+        repo: 'neonspark-core',
+        reportDir: '.gitnexus/benchmark-agent-safe-query-context-test',
+        subagentRunsDir: '.gitnexus/subagent-runs',
+        skipAnalyze: true,
+    }, {
+        loadSuite: async () => ({
+            thresholds: {
+                workflowReplay: { maxSteps: 5 },
+                tokenReduction: { weapon_powerup: 0.5, reload: 0.4 },
+            },
+            cases: {
+                weapon_powerup: {
+                    label: 'weapon_powerup',
+                    start_query: 'weapon powerup equip chain',
+                    retry_query: 'retry',
+                    proof_contexts: ['WeaponPowerUp'],
+                    proof_cypher: 'MATCH () RETURN 1',
+                    tool_plan: [],
+                    live_task: {
+                        objective: 'Investigate WeaponPowerUp from the provided asset seed.',
+                        symbol_seed: 'WeaponPowerUp',
+                        resource_seed: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+                    },
+                    semantic_tuple: {
+                        resource_anchor: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+                        symbol_anchor: 'WeaponPowerUp',
+                        proof_edges: ['HoldPickup -> WeaponPowerUp.PickItUp'],
+                        closure_status: 'not_verified_full',
+                    },
+                },
+                reload: {
+                    label: 'reload',
+                    start_query: 'reload getvalue checkreload',
+                    retry_query: 'retry',
+                    proof_contexts: ['ReloadBase'],
+                    proof_cypher: 'MATCH () RETURN 1',
+                    tool_plan: [],
+                    live_task: {
+                        objective: 'Investigate ReloadBase from the provided graph seed.',
+                        symbol_seed: 'ReloadBase',
+                        resource_seed: 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+                    },
+                    semantic_tuple: {
+                        resource_anchor: 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+                        symbol_anchor: 'ReloadBase',
+                        proof_edge: 'ReloadBase.GetValue -> ReloadBase.CheckReload',
+                        closure_status: 'not_verified_full',
+                    },
+                },
+            },
+        }),
+        runBenchmark: async (_suite, options) => {
+            calls.push({ repo: options.repo });
+            const workflowReplayCases = {
+                weapon_powerup: {
+                    steps: [],
+                    semantic_tuple: {
+                        resource_anchor: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+                        symbol_anchor: 'WeaponPowerUp',
+                        proof_edges: ['HoldPickup -> WeaponPowerUp.PickItUp'],
+                        closure_status: 'not_verified_full',
+                    },
+                    normalized_tuple_pass: true,
+                    evidence_validation_pass: true,
+                    failure_class: undefined,
+                    semantic_tuple_pass: true,
+                    anchor_top1_pass: true,
+                    recommended_follow_up_hit: true,
+                    post_narrowing_anchor_pass: true,
+                    post_narrowing_follow_up_hit: true,
+                    guid_invariance_pass: true,
+                    base: {
+                        primary_candidate: 'WeaponPowerUp',
+                        recommended_follow_up: 'resource_path_prefix=Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+                    },
+                    guid_variant: {
+                        primary_candidate: 'WeaponPowerUp',
+                        recommended_follow_up: 'resource_path_prefix=Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+                    },
+                    confirmed_chain: { steps: ['HoldPickup -> PickItUp'] },
+                    live_tool_evidence_pass: true,
+                    freeze_ready: true,
+                    tier_envelope: {
+                        facts_present: true,
+                        closure_present: true,
+                        clues_present: true,
+                        semantic_order_pass: true,
+                        summary_source: 'facts',
+                    },
+                    ambiguity_detour_count: 0,
+                    placeholder_leak_detected: false,
+                    heuristic_top_summary_detected: false,
+                    tool_calls_to_completion: 1,
+                    tokens_to_completion: 1,
+                    retry_breakdown: { query_retry_count: 0, context_retry_count: 0, cypher_retry_count: 0 },
+                    stop_reason: 'semantic_tuple_satisfied',
+                },
+                reload: {
+                    steps: [],
+                    semantic_tuple: {
+                        resource_anchor: 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+                        symbol_anchor: 'ReloadBase',
+                        proof_edge: 'ReloadBase.GetValue -> ReloadBase.CheckReload',
+                        closure_status: 'not_verified_full',
+                    },
+                    normalized_tuple_pass: true,
+                    evidence_validation_pass: true,
+                    failure_class: undefined,
+                    semantic_tuple_pass: true,
+                    anchor_top1_pass: true,
+                    recommended_follow_up_hit: true,
+                    post_narrowing_anchor_pass: true,
+                    post_narrowing_follow_up_hit: true,
+                    guid_invariance_pass: true,
+                    base: {
+                        primary_candidate: 'ReloadBase',
+                        recommended_follow_up: 'resource_path_prefix=Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+                    },
+                    guid_variant: {
+                        primary_candidate: 'ReloadBase',
+                        recommended_follow_up: 'resource_path_prefix=Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+                    },
+                    confirmed_chain: { steps: ['GetValue -> CheckReload'] },
+                    live_tool_evidence_pass: true,
+                    freeze_ready: true,
+                    tier_envelope: {
+                        facts_present: true,
+                        closure_present: true,
+                        clues_present: true,
+                        semantic_order_pass: true,
+                        summary_source: 'facts',
+                    },
+                    ambiguity_detour_count: 0,
+                    placeholder_leak_detected: false,
+                    heuristic_top_summary_detected: false,
+                    tool_calls_to_completion: 1,
+                    tokens_to_completion: 1,
+                    retry_breakdown: { query_retry_count: 0, context_retry_count: 0, cypher_retry_count: 0 },
+                    stop_reason: 'semantic_tuple_satisfied',
+                },
+            };
+            const sameScriptCases = {
+                weapon_powerup: {
+                    tool_plan: [],
+                    steps: [],
+                    semantic_tuple: {
+                        resource_anchor: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+                        symbol_anchor: 'WeaponPowerUp',
+                        proof_edges: ['HoldPickup -> WeaponPowerUp.PickItUp'],
+                        closure_status: 'not_verified_full',
+                    },
+                    semantic_tuple_pass: true,
+                    tool_calls_to_completion: 1,
+                    tokens_to_completion: 1,
+                },
+                reload: {
+                    tool_plan: [],
+                    steps: [],
+                    semantic_tuple: {
+                        resource_anchor: 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+                        symbol_anchor: 'ReloadBase',
+                        proof_edge: 'ReloadBase.GetValue -> ReloadBase.CheckReload',
+                        closure_status: 'not_verified_full',
+                    },
+                    semantic_tuple_pass: true,
+                    tool_calls_to_completion: 1,
+                    tokens_to_completion: 1,
+                },
+            };
+            const subagentLive = {
+                weapon_powerup: {
+                    steps: [],
+                    semantic_tuple: {
+                        resource_anchor: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+                        symbol_anchor: 'WeaponPowerUp',
+                        proof_edges: ['HoldPickup -> WeaponPowerUp.PickItUp'],
+                        closure_status: 'not_verified_full',
+                    },
+                    normalized_tuple_pass: true,
+                    evidence_validation_pass: true,
+                    failure_class: undefined,
+                    semantic_tuple_pass: true,
+                    tool_calls_to_completion: 1,
+                    tokens_to_completion: 1,
+                    stop_reason: 'semantic_tuple_satisfied',
+                    prompt: 'Use only telemetry-tool.js\nFinal JSON schema:',
+                    prompt_path: '/tmp/prompt.txt',
+                    result_path: '/tmp/result.json',
+                    telemetry_path: '/tmp/telemetry.jsonl',
+                    final_result: {},
+                },
+                reload: {
+                    steps: [],
+                    semantic_tuple: {
+                        resource_anchor: 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+                        symbol_anchor: 'ReloadBase',
+                        proof_edge: 'ReloadBase.GetValue -> ReloadBase.CheckReload',
+                        closure_status: 'not_verified_full',
+                    },
+                    normalized_tuple_pass: true,
+                    evidence_validation_pass: true,
+                    failure_class: undefined,
+                    semantic_tuple_pass: true,
+                    tool_calls_to_completion: 1,
+                    tokens_to_completion: 1,
+                    stop_reason: 'semantic_tuple_satisfied',
+                    prompt: 'Use only telemetry-tool.js\nFinal JSON schema:',
+                    prompt_path: '/tmp/prompt.txt',
+                    result_path: '/tmp/result.json',
+                    telemetry_path: '/tmp/telemetry.jsonl',
+                    final_result: {},
+                },
+            };
+            return {
+                generatedAt: '2026-04-08T00:00:00.000Z',
+                workflow_replay_full: workflowReplayCases,
+                workflow_replay_slim: workflowReplayCases,
+                same_script_full: sameScriptCases,
+                same_script_slim: sameScriptCases,
+                cases: subagentLive,
+                same_script: {
+                    tool_plan: { weapon_powerup: [], reload: [] },
+                    cases: sameScriptCases,
+                },
+                subagent_live: subagentLive,
+                acceptance: { pass: true, cases: { weapon_powerup: true, reload: true } },
+                pass: true,
+                semantic_equivalence: { pass: false, cases: { weapon_powerup: false, reload: false } },
+                token_summary: {
+                    weapon_powerup: { before: 1, after: 1, saved: 0, reduction: 0 },
+                    reload: { before: 1, after: 1, saved: 0, reduction: 0 },
+                },
+                call_summary: {
+                    weapon_powerup: { before: 1, after: 1, saved: 0 },
+                    reload: { before: 1, after: 1, saved: 0 },
+                },
+            };
+        },
+        writeReports: async () => { },
+        writeLine: (line) => output.push(line),
+        analyze: async () => ({ stdout: '', stderr: '' }),
+    });
+    assert.equal(calls[0].repo, 'neonspark-core');
+    assert.ok(output.some((line) => line.includes('PASS')));
+    assert.ok(output.some((line) => line.includes('weapon_powerup: guid_invariance_pass=true, live_tool_evidence_pass=true, freeze_ready')));
+    assert.ok(output.some((line) => line.includes('Report:')));
+    assert.equal(report.workflow_replay_slim.weapon_powerup.placeholder_leak_detected, false);
+    assert.equal(report.workflow_replay_slim.weapon_powerup.heuristic_top_summary_detected, false);
+});
+test('runtime retrieval contract docs remove heuristic mode and pin full as debug-only', async () => {
+    const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
+    const docPaths = [
+        'gitnexus/src/mcp/tools.ts',
+    ].map((relativePath) => path.join(repoRoot, relativePath));
+    const text = (await Promise.all(docPaths.map((filePath) => fs.readFile(filePath, 'utf-8')))).join('\n');
+    assert.ok(text.includes('discovery -> seed narrowing -> closure verification'));
+    assert.ok(!text.includes('resource_heuristic'));
+    assert.ok(text.includes('response_profile=slim is the default and sufficient'));
+    assert.ok(text.includes('response_profile=full is for debugging'));
+    assert.ok(text.includes('strong graph hops can coexist with failed closure'));
+});

package/dist/cli/benchmark-unity.js

@@ -18,7 +18,7 @@ export async function benchmarkUnityCommand(dataset, options) {
         targetPath: options.targetPath,
         profile: profileConfig,
         reportDir: options.reportDir,
-        extensions: options.extensions || '.cs',
+        extensions: options.extensions,
         scopeManifest: options.scopeManifest,
         scopePrefix: options.scopePrefix,
         skipAnalyze: options.skipAnalyze ?? false,

package/dist/cli/benchmark-unity.test.js

@@ -1,14 +1,18 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { resolveProfileConfig } from './benchmark-unity.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+const packagePath = path.resolve(here, '..', '..', 'package.json');
 test('quick profile uses reduced sample limits', () => {
     const c = resolveProfileConfig('quick');
     assert.equal(c.maxSymbols, 10);
     assert.equal(c.maxTasks, 5);
 });
 test('package scripts include neonspark benchmark commands', async () => {
-    const raw = await fs.readFile('package.json', 'utf-8');
+    const raw = await fs.readFile(packagePath, 'utf-8');
     const pkg = JSON.parse(raw);
     const scripts = pkg.scripts || {};
     assert.ok(scripts['benchmark:neonspark:full']);

package/dist/cli/benchmark.d.ts

@@ -0,0 +1,29 @@
+export interface BenchmarkCommandOptions {
+    repo?: string;
+    reportDir?: string;
+    recordsPath?: string;
+    casesPath?: string;
+}
+export declare function benchmarkCommand(suite: string, options?: BenchmarkCommandOptions): Promise<{
+    artifactPath?: string;
+    indexPath?: string;
+    sha256?: string;
+    comparisonPath?: string;
+    summaryPath?: string;
+    provenanceArtifactPath?: string;
+    provenanceIndexPath?: string;
+}>;
+export declare function benchmarkSuiteCommand(suite: string, options: {
+    repo?: string;
+    reportDir?: string;
+    recordsPath?: string;
+    casesPath?: string;
+}): Promise<{
+    artifactPath?: string;
+    indexPath?: string;
+    sha256?: string;
+    comparisonPath?: string;
+    summaryPath?: string;
+    provenanceArtifactPath?: string;
+    provenanceIndexPath?: string;
+}>;

package/dist/cli/benchmark.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { writeRuntimeProvenanceArtifact, } from '../benchmark/runtime-poc/provenance-artifact.js';
+import { runRuntimePocBenchmark } from '../benchmark/runtime-poc/runner.js';
+async function loadRuntimePocRecords(recordsPath) {
+    if (!recordsPath)
+        return [];
+    const raw = await fs.readFile(path.resolve(recordsPath), 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+        throw new Error('runtime-poc records file must be a JSON array');
+    }
+    return parsed;
+}
+export async function benchmarkCommand(suite, options = {}) {
+    const normalizedSuite = String(suite || '').trim().toLowerCase();
+    if (normalizedSuite !== 'runtime-poc') {
+        throw new Error(`unsupported benchmark suite: ${suite}`);
+    }
+    const repo = String(options.repo || 'unknown-repo').trim();
+    const reportDir = path.resolve(options.reportDir || 'docs/reports/runtime-poc');
+    if (options.recordsPath) {
+        const records = await loadRuntimePocRecords(options.recordsPath);
+        const out = await writeRuntimeProvenanceArtifact({
+            reportDir,
+            repo,
+            records,
+        });
+        process.stdout.write(`runtime-poc provenance artifact written: ${out.artifactPath}\n`);
+        process.stdout.write(`runtime-poc provenance index updated: ${out.indexPath}\n`);
+        return {
+            artifactPath: out.artifactPath,
+            indexPath: out.indexPath,
+            sha256: out.sha256,
+        };
+    }
+    const run = await runRuntimePocBenchmark({
+        repo,
+        reportDir,
+        casesPath: options.casesPath,
+    });
+    process.stdout.write(`runtime-poc comparison report written: ${run.comparisonPath}\n`);
+    process.stdout.write(`runtime-poc markdown summary written: ${run.summaryPath}\n`);
+    process.stdout.write(`runtime-poc provenance artifact written: ${run.provenanceArtifactPath}\n`);
+    process.stdout.write(`runtime-poc provenance index updated: ${run.provenanceIndexPath}\n`);
+    return {
+        comparisonPath: run.comparisonPath,
+        summaryPath: run.summaryPath,
+        provenanceArtifactPath: run.provenanceArtifactPath,
+        provenanceIndexPath: run.provenanceIndexPath,
+    };
+}
+export async function benchmarkSuiteCommand(suite, options) {
+    return await benchmarkCommand(suite, options);
+}

package/dist/cli/index.js

@@ -29,6 +29,8 @@ program
     .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
     .option('--extensions <list>', 'Comma-separated file extensions to include (e.g. .cs,.ts)')
     .option('--repo-alias <name>', 'Override indexed repository name with a stable alias')
+    .option('--csharp-define-csproj <path>', 'Load C# DefineConstants from the specified .csproj and normalize conditional-compilation blocks before parsing')
+    .option('--sync-manifest-policy <policy>', 'When CLI options differ from sync manifest directives: ask|update|keep|error (default: ask)')
     .option('--skills', 'Generate repo-specific skill files from detected communities')
     .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
     .option('--scope-manifest <path>', 'Manifest file with scope rules (supports comments and * wildcard; recommended: .gitnexus/sync-manifest.txt)')
@@ -84,6 +86,7 @@ program
     .option('-g, --goal <text>', 'What you want to find')
     .option('-l, --limit <n>', 'Max processes to return (default: 5)')
     .option('--content', 'Include full symbol source code')
+    .option('--response-profile <profile>', 'Response payload profile: slim|full', 'slim')
     .option('--scope-preset <preset>', 'Scope preset for retrieval: unity-gameplay|unity-all')
     .option('--unity-resources <mode>', 'Unity resource retrieval mode: off|on|auto', 'off')
     .option('--unity-hydration <mode>', 'Unity hydration mode when resources are enabled: parity|compact', 'compact')
@@ -99,6 +102,7 @@ program
     .option('-u, --uid <uid>', 'Direct symbol UID (zero-ambiguity lookup)')
     .option('-f, --file <path>', 'File path to disambiguate common names')
     .option('--content', 'Include full symbol source code')
+    .option('--response-profile <profile>', 'Response payload profile: slim|full', 'slim')
     .option('--unity-resources <mode>', 'Unity resource retrieval mode: off|on|auto', 'off')
     .option('--unity-hydration <mode>', 'Unity hydration mode when resources are enabled: parity|compact', 'compact')
     .option('--unity-evidence <mode>', 'Unity evidence payload mode: summary|focused|full', 'summary')
@@ -150,7 +154,7 @@ program
     .option('--repo-alias <name>', 'Analyze-time repo alias and default evaluation repo when --repo is omitted')
     .option('--target-path <path>', 'Path to analyze before evaluation (required unless --skip-analyze)')
     .option('--report-dir <path>', 'Output directory for benchmark-report.json and benchmark-summary.md', '.gitnexus/benchmark')
-    .option('--extensions <list>', 'Analyze extension filter (default: .cs)', '.cs')
+    .option('--extensions <list>', 'Analyze extension filter (comma-separated, optional)')
     .option('--scope-manifest <path>', 'Analyze scope manifest file')
     .option('--scope-prefix <pathPrefix>', 'Analyze scope path prefix (repeatable)', collectValues, [])
     .option('--skip-analyze', 'Skip analyze stage and evaluate current index only')
@@ -163,15 +167,36 @@ program
     .option('--repo-alias <name>', 'Analyze-time repo alias and default evaluation repo when --repo is omitted')
     .option('--target-path <path>', 'Path to analyze before evaluation (required unless --skip-analyze)')
     .option('--report-dir <path>', 'Output directory for benchmark-report.json and benchmark-summary.md', '.gitnexus/benchmark-agent-context')
-    .option('--extensions <list>', 'Analyze extension filter (default: .cs)', '.cs')
+    .option('--extensions <list>', 'Analyze extension filter (comma-separated, optional)')
     .option('--scope-manifest <path>', 'Analyze scope manifest file')
     .option('--scope-prefix <pathPrefix>', 'Analyze scope path prefix (repeatable)', collectValues, [])
     .option('--skip-analyze', 'Skip analyze stage and evaluate current index only')
     .action(createLazyAction(() => import('./benchmark-agent-context.js'), 'benchmarkAgentContextCommand'));
+program
+    .command('benchmark-agent-safe-query-context <dataset>')
+    .description('Run the agent-safe Unity query/context benchmark')
+    .option('-r, --repo <name>', 'Target indexed repo')
+    .option('--repo-alias <name>', 'Analyze-time repo alias and default evaluation repo when --repo is omitted')
+    .option('--target-path <path>', 'Path to analyze before evaluation (required unless --skip-analyze)')
+    .option('--subagent-runs-dir <path>', 'Directory containing session-generated subagent run artifacts')
+    .option('--report-dir <path>', 'Output directory for benchmark-report.json and benchmark-summary.md', '.gitnexus/benchmark-agent-safe-query-context')
+    .option('--extensions <list>', 'Analyze extension filter (comma-separated, optional)')
+    .option('--scope-manifest <path>', 'Analyze scope manifest file')
+    .option('--scope-prefix <pathPrefix>', 'Analyze scope path prefix (repeatable)', collectValues, [])
+    .option('--skip-analyze', 'Skip analyze stage and evaluate current index only')
+    .action(createLazyAction(() => import('./benchmark-agent-safe-query-context.js'), 'benchmarkAgentSafeQueryContextCommand'));
 program
     .command('benchmark-u2-e2e')
     .description('Run fail-fast full neonspark U2 E2E benchmark and emit evidence reports')
     .option('--config <path>', 'Path to E2E config JSON')
     .option('--report-dir <path>', 'Output directory for reports')
     .action(createLazyAction(() => import('./benchmark-u2-e2e.js'), 'benchmarkU2E2ECommand'));
+program
+    .command('benchmark <suite>')
+    .description('Run benchmark suite (currently supports: runtime-poc)')
+    .option('-r, --repo <name>', 'Target indexed repo')
+    .option('--report-dir <path>', 'Output directory for runtime-poc reports', 'docs/reports/runtime-poc')
+    .option('--cases-path <path>', 'Optional JSON cases file for runtime-poc comparison run')
+    .option('--records-path <path>', 'Optional JSON records file to emit provenance artifact only')
+    .action(createLazyAction(() => import('./benchmark.js'), 'benchmarkSuiteCommand'));
 program.parse(process.argv);

package/dist/cli/rule-lab.d.ts

@@ -1,14 +1,9 @@
 import type { Command } from 'commander';
-declare const RULE_LAB_COMMANDS: readonly ["discover", "analyze", "review-pack", "curate", "promote", "regress"];
-type RuleLabHandlerName = 'ruleLabDiscoverCommand' | 'ruleLabAnalyzeCommand' | 'ruleLabReviewPackCommand' | 'ruleLabCurateCommand' | 'ruleLabPromoteCommand' | 'ruleLabRegressCommand';
+declare const RULE_LAB_COMMANDS: readonly ["analyze", "review-pack", "curate", "promote", "regress"];
+type RuleLabHandlerName = 'ruleLabAnalyzeCommand' | 'ruleLabReviewPackCommand' | 'ruleLabCurateCommand' | 'ruleLabPromoteCommand' | 'ruleLabRegressCommand';
 type LazyFactory = (handlerName: RuleLabHandlerName) => (...args: any[]) => void | Promise<void>;
 export declare function getRuleLabCommandNames(program: Command): string[];
 export declare function attachRuleLabCommands(program: Command, lazyFactory?: LazyFactory): void;
-export declare function ruleLabDiscoverCommand(options: {
-    repoPath?: string;
-    scope?: 'full' | 'diff';
-    seed?: string;
-}): Promise<void>;
 export declare function ruleLabAnalyzeCommand(options: {
     repoPath?: string;
     runId: string;
@@ -30,6 +25,7 @@ export declare function ruleLabPromoteCommand(options: {
     repoPath?: string;
     runId: string;
     sliceId: string;
+    ruleVersion?: string;
     version?: string;
 }): Promise<void>;
 export declare function ruleLabRegressCommand(options: {