@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

package/dist/benchmark/runtime-poc/runner.d.ts

@@ -0,0 +1,31 @@
+type RuntimeStatus = 'verified_full' | 'verified_partial' | 'failed';
+type RuntimeEvidenceLevel = 'verified_chain' | 'verified_segment' | 'clue' | 'none';
+export interface RuntimePocCase {
+    case_id: string;
+    query_text: string;
+    symbol_name?: string;
+    resource_seed_path?: string;
+    mapped_seed_targets?: string[];
+    baseline: {
+        status: RuntimeStatus;
+        evidence_level: RuntimeEvidenceLevel;
+        reason?: string;
+    };
+    graph_only: {
+        status: RuntimeStatus;
+        evidence_level: RuntimeEvidenceLevel;
+        reason?: string;
+    };
+}
+export interface RuntimePocBenchmarkResult {
+    comparisonPath: string;
+    summaryPath: string;
+    provenanceArtifactPath: string;
+    provenanceIndexPath: string;
+}
+export declare function runRuntimePocBenchmark(input: {
+    repo: string;
+    reportDir: string;
+    casesPath?: string;
+}): Promise<RuntimePocBenchmarkResult>;
+export {};

package/dist/benchmark/runtime-poc/runner.js

@@ -0,0 +1,163 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { writeRuntimeProvenanceArtifact, } from './provenance-artifact.js';
+function toIsoStamp(date = new Date()) {
+    return date.toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+function normalizeStatus(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (normalized === 'verified_full')
+        return 'verified_full';
+    if (normalized === 'verified_partial')
+        return 'verified_partial';
+    return 'failed';
+}
+function normalizeEvidence(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (normalized === 'verified_chain')
+        return 'verified_chain';
+    if (normalized === 'verified_segment')
+        return 'verified_segment';
+    if (normalized === 'clue')
+        return 'clue';
+    return 'none';
+}
+function classifyFailureBucket(input) {
+    if (normalizeStatus(input.graph_only.status) !== 'failed')
+        return 'none';
+    const reason = String(input.graph_only.reason || '').trim().toLowerCase();
+    if (reason.includes('anchor'))
+        return 'anchor_gap';
+    if (reason.includes('bind') || reason.includes('guid'))
+        return 'bind_gap';
+    if (reason.includes('bridge') || reason.includes('loader'))
+        return 'bridge_gap';
+    if (reason.includes('runtime'))
+        return 'runtime_gap';
+    if (reason.includes('policy') || reason.includes('precision'))
+        return 'precision_penalty';
+    return 'unknown_gap';
+}
+function buildComparisonRows(cases) {
+    return cases.map((item) => {
+        const baselineStatus = normalizeStatus(item.baseline.status);
+        const graphStatus = normalizeStatus(item.graph_only.status);
+        const failureBucket = classifyFailureBucket(item);
+        return {
+            case_id: String(item.case_id || '').trim(),
+            baseline_status: baselineStatus,
+            graph_only_status: graphStatus,
+            baseline_evidence_level: normalizeEvidence(item.baseline.evidence_level),
+            graph_only_evidence_level: normalizeEvidence(item.graph_only.evidence_level),
+            verified_full_false_positive: baselineStatus !== 'verified_full' && graphStatus === 'verified_full',
+            regression: baselineStatus === 'verified_full' && graphStatus !== 'verified_full',
+            failure_bucket: graphStatus === 'failed' ? failureBucket : 'none',
+        };
+    });
+}
+function rate(count, total) {
+    if (total <= 0)
+        return 0;
+    return Number((count / total).toFixed(6));
+}
+function toMarkdown(report) {
+    return [
+        '# Runtime PoC Comparison',
+        '',
+        `- Generated At: ${report.generated_at}`,
+        `- Repo: ${report.repo}`,
+        `- Total Cases: ${report.summary.total_cases}`,
+        `- verified_full_false_positive_rate: ${report.summary.verified_full_false_positive_rate}`,
+        `- regression_count: ${report.summary.regression_count}`,
+        `- graph_failed_count: ${report.summary.graph_failed_count}`,
+        '',
+        '## Rows',
+        '',
+        '| case_id | baseline_status | graph_only_status | false_positive | regression | failure_bucket |',
+        '| --- | --- | --- | --- | --- | --- |',
+        ...report.comparison_rows.map((row) => (`| ${row.case_id} | ${row.baseline_status} | ${row.graph_only_status} | ${row.verified_full_false_positive} | ${row.regression} | ${row.failure_bucket} |`)),
+        '',
+    ].join('\n');
+}
+async function loadCases(casesPath) {
+    if (!casesPath) {
+        return [
+            {
+                case_id: 'default-case-1',
+                query_text: 'Reload GunGraph',
+                symbol_name: 'GunGraph',
+                resource_seed_path: 'Assets/NEON/DataAssets/weapon.asset',
+                mapped_seed_targets: ['Assets/NEON/Graphs/weapon_graph.asset'],
+                baseline: { status: 'verified_full', evidence_level: 'verified_chain' },
+                graph_only: { status: 'verified_full', evidence_level: 'verified_chain' },
+            },
+            {
+                case_id: 'default-case-2',
+                query_text: 'Reload WeaponPowerUp',
+                symbol_name: 'WeaponPowerUp',
+                resource_seed_path: 'Assets/NEON/DataAssets/orb.asset',
+                mapped_seed_targets: ['Assets/NEON/Graphs/global.asset'],
+                baseline: { status: 'failed', evidence_level: 'none', reason: 'rule_not_matched' },
+                graph_only: { status: 'failed', evidence_level: 'none', reason: 'anchor_gap' },
+            },
+        ];
+    }
+    const raw = await fs.readFile(path.resolve(casesPath), 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+        throw new Error('runtime-poc cases file must be a JSON array');
+    }
+    return parsed;
+}
+function toProvenanceRecords(cases) {
+    return cases.map((item) => ({
+        scenario_id: String(item.case_id || '').trim(),
+        query_text: String(item.query_text || '').trim(),
+        ...(String(item.symbol_name || '').trim() ? { symbol_name: String(item.symbol_name).trim() } : {}),
+        ...(String(item.resource_seed_path || '').trim()
+            ? { resource_seed_path: String(item.resource_seed_path).trim() }
+            : {}),
+        mapped_seed_targets: Array.isArray(item.mapped_seed_targets) ? item.mapped_seed_targets : [],
+        runtime_claim: {
+            status: normalizeStatus(item.graph_only.status),
+            evidence_level: normalizeEvidence(item.graph_only.evidence_level),
+            ...(String(item.graph_only.reason || '').trim() ? { reason: String(item.graph_only.reason).trim() } : {}),
+        },
+    }));
+}
+export async function runRuntimePocBenchmark(input) {
+    const reportDir = path.resolve(input.reportDir);
+    await fs.mkdir(reportDir, { recursive: true });
+    const cases = await loadCases(input.casesPath);
+    const rows = buildComparisonRows(cases);
+    const falsePositiveCount = rows.filter((row) => row.verified_full_false_positive).length;
+    const regressionCount = rows.filter((row) => row.regression).length;
+    const graphFailedCount = rows.filter((row) => row.graph_only_status === 'failed').length;
+    const report = {
+        generated_at: toIsoStamp(),
+        repo: String(input.repo || '').trim(),
+        comparison_rows: rows,
+        summary: {
+            total_cases: rows.length,
+            verified_full_false_positive_count: falsePositiveCount,
+            verified_full_false_positive_rate: rate(falsePositiveCount, rows.length),
+            regression_count: regressionCount,
+            graph_failed_count: graphFailedCount,
+        },
+    };
+    const comparisonPath = path.join(reportDir, 'runtime-poc-comparison.json');
+    await fs.writeFile(comparisonPath, `${JSON.stringify(report, null, 2)}\n`, 'utf-8');
+    const summaryPath = path.join(reportDir, 'runtime-poc-summary.md');
+    await fs.writeFile(summaryPath, `${toMarkdown(report)}\n`, 'utf-8');
+    const provenance = await writeRuntimeProvenanceArtifact({
+        reportDir,
+        repo: report.repo,
+        records: toProvenanceRecords(cases),
+    });
+    return {
+        comparisonPath,
+        summaryPath,
+        provenanceArtifactPath: provenance.artifactPath,
+        provenanceIndexPath: provenance.indexPath,
+    };
+}

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

@@ -39,6 +39,14 @@ export interface HydrationPolicyRepeatabilityReport {
         requiresArray: boolean;
         populatedWhenIncomplete: boolean;
     };
+    semantic_contract: {
+        coreAdjustedDelta: {
+            strictFallbackRuns: number;
+            strictFallbackAdjustedRuns: number;
+            nonStrictAdjustedRuns: number;
+        };
+        downgradeOnlyWhenStrictFallback: boolean;
+    };
     contractCompatibility: {
         needsParityRetryRetained: boolean;
     };

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

@@ -22,6 +22,12 @@ function snapshotFromResponse(out) {
     return {
         status: String(out?.runtime_claim?.status || 'unknown'),
         evidence_level: String(out?.runtime_claim?.evidence_level || 'none'),
+        verification_core_status: String(out?.runtime_claim?.verification_core_status || 'unknown'),
+        verification_core_evidence_level: String(out?.runtime_claim?.verification_core_evidence_level || 'none'),
+        policy_adjusted: Boolean(out?.runtime_claim?.policy_adjusted),
+        policy_adjust_reason: out?.runtime_claim?.policy_adjust_reason
+            ? String(out.runtime_claim.policy_adjust_reason)
+            : undefined,
         reason: out?.runtime_claim?.reason ? String(out.runtime_claim.reason) : undefined,
         fallbackToCompact: Boolean(out?.hydrationMeta?.fallbackToCompact),
     };
@@ -100,11 +106,18 @@ export async function buildHydrationPolicyRepeatabilityReport(input) {
     const balancedConsistency = classifyConsistency(snapshotsByPolicy.get('balanced') || []);
     const strictConsistency = classifyConsistency(snapshotsByPolicy.get('strict') || []);
     const strictRows = snapshotsByPolicy.get('strict') || [];
+    const fastRows = snapshotsByPolicy.get('fast') || [];
+    const balancedRows = snapshotsByPolicy.get('balanced') || [];
     const strictFallbackDowngraded = strictRows.every((row) => {
         if (!row.fallbackToCompact)
             return true;
         return row.status === 'verified_partial' && row.evidence_level === 'verified_segment';
     });
+    const strictFallbackRuns = strictRows.filter((row) => row.fallbackToCompact).length;
+    const strictFallbackAdjustedRuns = strictRows.filter((row) => row.fallbackToCompact && row.policy_adjusted).length;
+    const nonStrictAdjustedRuns = [...fastRows, ...balancedRows].filter((row) => row.policy_adjusted).length;
+    const downgradeOnlyWhenStrictFallback = nonStrictAdjustedRuns === 0
+        && strictFallbackAdjustedRuns <= strictFallbackRuns;
     const policy_mode_matrix = {};
     for (const policy of policies) {
         const compactOut = await callPolicyProbe({
@@ -155,6 +168,14 @@ export async function buildHydrationPolicyRepeatabilityReport(input) {
             requiresArray,
             populatedWhenIncomplete,
         },
+        semantic_contract: {
+            coreAdjustedDelta: {
+                strictFallbackRuns,
+                strictFallbackAdjustedRuns,
+                nonStrictAdjustedRuns,
+            },
+            downgradeOnlyWhenStrictFallback,
+        },
         contractCompatibility: {
             needsParityRetryRetained,
         },

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

@@ -17,7 +17,6 @@ export interface Phase2RuntimeClaimAcceptanceReport {
         evidence_missing_reason?: string;
         verification_failed_reason?: string;
         unmatched_reason?: string;
-        gate_disabled_reason?: string;
     };
     reproduction_commands: Record<string, string>;
 }

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

@@ -1,58 +1,62 @@
 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 { verifyRuntimeClaimOnDemand } from '../../mcp/local/runtime-chain-verify.js';
+function makeSymbolOnlyExecutor(symbolName, filePath) {
+    return async (query, params) => {
+        if (!String(query || '').includes('WHERE n.name IN $symbolNames')) {
+            return [];
+        }
+        const names = Array.isArray(params?.symbolNames) ? params?.symbolNames : [];
+        if (!names.includes(symbolName))
+            return [];
+        return [{
+                id: `Class:${filePath}:${symbolName}`,
+                name: symbolName,
+                type: 'Class',
+                filePath,
+                startLine: 1,
+            }];
+    };
+}
 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 repoPath = path.resolve('.');
+    const verificationFailedClaim = await verifyRuntimeClaimOnDemand({
+        repoPath,
+        queryText: 'Reload',
+        symbolName: 'ReloadBase',
+        symbolFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
+        resourceSeedPath: 'Assets/Rules/reload.asset',
+        resourceBindings: [{ resourcePath: 'Assets/Rules/reload.asset' }],
+        executeParameterized: makeSymbolOnlyExecutor('ReloadBase', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs'),
     });
-    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 evidenceMissingClaim = await verifyRuntimeClaimOnDemand({
+        repoPath,
+        queryText: 'Reload',
+        symbolName: 'ReloadBase',
+        symbolFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
+        resourceSeedPath: 'Assets/Rules/reload.asset',
+        resourceBindings: [{ resourcePath: 'Assets/Rules/reload.asset' }],
+        minimumEvidenceSatisfied: false,
+        executeParameterized: makeSymbolOnlyExecutor('ReloadBase', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs'),
     });
-    const unmatched = await backend.callTool('query', {
-        repo: input.repoAlias,
-        query: 'UnrelatedUnityChain',
-        unity_resources: 'on',
-        runtime_chain_verify: 'on-demand',
+    const unmatchedClaim = await verifyRuntimeClaimOnDemand({
+        repoPath,
+        queryText: 'UnrelatedUnityChain',
+        resourceBindings: [],
+        executeParameterized: async () => [],
     });
-    // 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 verificationFailedReason = String(verificationFailedClaim.reason || 'rule_matched_but_verification_failed');
+    const claim = verificationFailedClaim;
     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,
+        verificationFailedReason,
+        evidenceMissingClaim.reason,
+        unmatchedClaim.reason,
     ]
         .filter(Boolean)
         .map((reason) => String(reason));
@@ -75,20 +79,18 @@ export async function buildPhase2RuntimeClaimAcceptanceReport(input) {
         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,
+            evidence_missing_reason: evidenceMissingClaim.reason,
+            verification_failed_reason: verificationFailedReason,
+            unmatched_reason: unmatchedClaim.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"`,
+            rule_matched_but_verification_failed: 'gitnexus query --runtime-chain-verify on-demand --unity-resources on "Reload"',
+            rule_matched_but_evidence_missing: 'gitnexus query --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 --runtime-chain-verify on-demand --unity-resources on "UnrelatedUnityChain"',
         },
     };
     if (!coverage_pass) {
-        throw new Error(`phase2 failure classification coverage is incomplete (${failure_classification_coverage.length}/4). Missing: ${failure_classification_missing.join(', ')}`);
+        throw new Error(`phase2 failure classification coverage is incomplete (${failure_classification_coverage.length}/3). Missing: ${failure_classification_missing.join(', ')}`);
     }
     return report;
 }

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

@@ -12,5 +12,4 @@ test('phase2 runtime_claim acceptance report tracks contract + failure classific
     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

@@ -1,5 +1,5 @@
 export interface Phase5StageCoverageRow {
-    stage: 'discover' | 'analyze' | 'review-pack' | 'curate' | 'promote' | 'regress';
+    stage: 'analyze' | 'review-pack' | 'curate' | 'promote' | 'regress';
     command: string;
     status: 'passed' | 'failed';
     retry_hint?: string;

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

@@ -1,6 +1,5 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { discoverRuleLabRun } from '../../rule-lab/discover.js';
 import { analyzeRuleLabSlice } from '../../rule-lab/analyze.js';
 import { buildReviewPack } from '../../rule-lab/review-pack.js';
 import { curateRuleLabSlice } from '../../rule-lab/curate.js';
@@ -8,8 +7,6 @@ import { promoteCuratedRules } from '../../rule-lab/promote.js';
 import { runRuleLabRegress } from '../../rule-lab/regress.js';
 function commandFor(stage, input) {
     switch (stage) {
-        case 'discover':
-            return 'gitnexus rule-lab discover --scope full';
         case 'analyze':
             return `gitnexus rule-lab analyze --run-id ${input.runId} --slice-id ${input.sliceId}`;
         case 'review-pack':
@@ -27,11 +24,69 @@ function commandFor(stage, input) {
 async function mustExist(filePath) {
     await fs.access(filePath);
 }
+async function bootstrapReducedRuleLabRun(input) {
+    const normalizedSeed = String(input.seed || Date.now())
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .toLowerCase();
+    const runId = `phase5-${normalizedSeed}-${Date.now()}`;
+    const sliceId = 'slice-startup-exact-pair';
+    const runRoot = path.join(input.repoPath, '.gitnexus', 'rules', 'lab', 'runs', runId);
+    const sliceRoot = path.join(runRoot, 'slices', sliceId);
+    const manifestPath = path.join(runRoot, 'manifest.json');
+    const slicePath = path.join(sliceRoot, 'slice.json');
+    await fs.mkdir(sliceRoot, { recursive: true });
+    await fs.writeFile(manifestPath, `${JSON.stringify({
+        run_id: runId,
+        repo_path: input.repoPath,
+        scope: 'full',
+        generated_at: new Date().toISOString(),
+        slices: [
+            {
+                id: sliceId,
+                trigger_family: 'startup',
+                resource_types: ['asset'],
+                host_base_type: ['StartupNode'],
+                required_hops: ['resource', 'code_runtime'],
+            },
+        ],
+        stages: ['analyze'],
+        next_actions: [`gitnexus rule-lab analyze --run-id ${runId} --slice-id ${sliceId}`],
+    }, null, 2)}\n`, 'utf-8');
+    await fs.writeFile(slicePath, `${JSON.stringify({
+        id: sliceId,
+        trigger_family: 'startup',
+        resource_types: ['asset'],
+        host_base_type: ['StartupNode'],
+        required_hops: ['resource', 'code_runtime'],
+        exact_pairs: [
+            {
+                id: 'pair-startup-1',
+                binding_kind: 'method_triggers_method',
+                draft_rule_id: 'demo.startup.v1',
+                source_anchor: {
+                    file: 'Assets/Rules/startup.asset',
+                    line: 1,
+                    symbol: 'StartupNode.Initialize',
+                },
+                target_anchor: {
+                    file: 'Assets/Rules/startup.asset',
+                    line: 1,
+                    symbol: 'StartupNode.Bootstrap',
+                },
+            },
+        ],
+    }, null, 2)}\n`, 'utf-8');
+    return {
+        runId,
+        sliceId,
+        manifestPath,
+    };
+}
 function buildFailureTaxonomy(runId) {
     return [
         {
             code: 'rule_not_matched',
-            retry_hint: 'confirm trigger_family tokens and rerun discover/analyze/promote',
+            retry_hint: 'confirm trigger_family tokens and rerun analyze/promote',
             repro_command: `gitnexus rule-lab analyze --run-id ${runId} --slice-id <slice_id>`,
         },
         {
@@ -70,7 +125,20 @@ function hasDslPlaceholders(text) {
     return /(^|\s)(unknown|todo|tbd)(\s|$)|<[^>]+>/i.test(text);
 }
 async function buildAuthenticityChecks(input) {
-    const verifierPath = path.join(input.repoPath, 'gitnexus', 'src', 'mcp', 'local', 'runtime-chain-verify.ts');
+    const verifierPathCandidates = [
+        path.join(input.repoPath, 'gitnexus', 'src', 'mcp', 'local', 'runtime-chain-verify.ts'),
+        path.join(input.repoPath, 'src', 'mcp', 'local', 'runtime-chain-verify.ts'),
+    ];
+    let verifierPath = verifierPathCandidates[0];
+    for (const candidate of verifierPathCandidates) {
+        try {
+            await fs.access(candidate);
+            verifierPath = candidate;
+            break;
+        }
+        catch {
+        }
+    }
     const verifierRaw = await fs.readFile(verifierPath, 'utf-8');
     const blockedSymbols = [
         'RESOURCE_ASSET_PATH',
@@ -98,17 +166,12 @@ async function buildAuthenticityChecks(input) {
 export async function buildPhase5RuleLabAcceptanceReport(input) {
     const repoPath = path.resolve(input.repoPath || process.cwd());
     const stageCoverage = [];
-    const discover = await discoverRuleLabRun({ repoPath, scope: 'full', seed: input.seed || 'phase5-acceptance' });
-    stageCoverage.push({
-        stage: 'discover',
-        command: commandFor('discover', {}),
-        status: 'passed',
+    const bootstrapped = await bootstrapReducedRuleLabRun({
+        repoPath,
+        seed: input.seed || 'phase5-acceptance',
     });
-    if (discover.manifest.slices.length === 0) {
-        throw new Error('discover produced no slices');
-    }
-    const sliceId = discover.manifest.slices[0].id;
-    const runId = discover.runId;
+    const sliceId = bootstrapped.sliceId;
+    const runId = bootstrapped.runId;
     const analyze = await analyzeRuleLabSlice({ repoPath, runId, sliceId });
     stageCoverage.push({
         stage: 'analyze',
@@ -122,6 +185,7 @@ export async function buildPhase5RuleLabAcceptanceReport(input) {
         status: 'passed',
     });
     const firstCandidate = analyze.candidates[0];
+    const promotedRuleId = `demo.startup.${runId}.v1`;
     const curationInputPath = path.join(repoPath, '.gitnexus', 'rules', 'lab', 'runs', runId, 'slices', sliceId, 'curation-input.json');
     await fs.writeFile(curationInputPath, `${JSON.stringify({
         run_id: runId,
@@ -129,7 +193,7 @@ export async function buildPhase5RuleLabAcceptanceReport(input) {
         curated: [
             {
                 id: firstCandidate.id,
-                rule_id: 'demo.startup.v1',
+                rule_id: promotedRuleId,
                 title: 'startup startup graph',
                 match: {
                     trigger_tokens: ['startup'],
@@ -195,7 +259,7 @@ export async function buildPhase5RuleLabAcceptanceReport(input) {
         retry_hint: regress.pass ? undefined : regress.failures.join(','),
     });
     const artifactPaths = {
-        manifest: discover.paths.manifestPath,
+        manifest: bootstrapped.manifestPath,
         candidates: analyze.paths.candidatesPath,
         review_cards: reviewPack.paths.reviewCardsPath,
         curation_input: curationInputPath,
@@ -240,7 +304,7 @@ export async function runPhase5RuleLabGate(input) {
     try {
         const raw = await fs.readFile(reportPath, 'utf-8');
         const report = JSON.parse(raw);
-        if (!Array.isArray(report.stage_coverage) || report.stage_coverage.length !== 6) {
+        if (!Array.isArray(report.stage_coverage) || report.stage_coverage.length !== 5) {
             return { pass: false, reason: 'stage_coverage_incomplete' };
         }
         if (typeof report.metrics?.precision !== 'number' || typeof report.metrics?.coverage !== 'number') {

package/dist/benchmark/u2-e2e/phase5-rule-lab-acceptance-runner.test.js

@@ -9,7 +9,7 @@ const { test: rawTest } = process.env.VITEST
 const test = rawTest;
 test('phase5 rule-lab acceptance runner emits complete stage coverage', async () => {
     const report = await buildPhase5RuleLabAcceptanceReport({ repoAlias: 'GitNexus' });
-    assert.equal(report.stage_coverage.length, 6);
+    assert.equal(report.stage_coverage.length, 5);
     assert.equal(typeof report.metrics.precision, 'number');
 });
 test('phase5 gate fails when required artifacts are missing', async () => {
@@ -22,7 +22,6 @@ test('phase5 gate fails when anti-hardcode scan or dsl lint fails', async () =>
     const reportPath = path.join(tmpDir, 'report.json');
     await fs.writeFile(reportPath, JSON.stringify({
         stage_coverage: [
-            { stage: 'discover', status: 'passed' },
             { stage: 'analyze', status: 'passed' },
             { stage: 'review-pack', status: 'passed' },
             { stage: 'curate', status: 'passed' },

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

@@ -191,16 +191,17 @@ function assertScenario(scenario, contextOnOutput, deepDiveExecutions, contextUn
     };
 }
 async function invokeTool(runner, tool, input) {
+    const params = withLegacyFullProfile(tool, input);
     if (tool === 'query') {
-        return runner.query(input);
+        return runner.query(params);
     }
     if (tool === 'context') {
-        return runner.context(input);
+        return runner.context(params);
     }
     if (tool === 'impact') {
-        return runner.impact(input);
+        return runner.impact(params);
     }
-    return runner.cypher(input);
+    return runner.cypher(params);
 }
 function selectDisambiguationUid(symbol, output) {
     const expectedFile = `${symbol}.cs`.toLowerCase();
@@ -222,20 +223,21 @@ function selectDisambiguationUid(symbol, output) {
     return undefined;
 }
 async function runContextWithDisambiguation(runner, scenario, input) {
-    const first = await runner.context(input);
+    const normalizedInput = withLegacyFullProfile('context', input);
+    const first = await runner.context(normalizedInput);
     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 });
+        const hinted = await runner.context(withLegacyFullProfile('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 runner.context(withLegacyFullProfile('context', { ...input, uid }));
     }
     return first;
 }
@@ -276,3 +278,9 @@ export async function runSymbolScenario(runner, scenario, repo) {
         assertions: assertScenario(scenario, contextOn, deepDiveExecutions, contextUnityHydration),
     };
 }
+function withLegacyFullProfile(tool, input) {
+    if ((tool === 'query' || tool === 'context') && !('response_profile' in input)) {
+        return { ...input, response_profile: 'full' };
+    }
+    return input;
+}