@veewo/gitnexus 1.5.0 → 1.5.2

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

@@ -86,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')
@@ -101,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')
@@ -170,10 +172,31 @@ program
     .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: {

package/dist/cli/rule-lab.js

@@ -1,14 +1,13 @@
 import { writeSync } from 'node:fs';
 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';
 import { promoteCuratedRules } from '../rule-lab/promote.js';
 import { runRuleLabRegress } from '../rule-lab/regress.js';
 import { compileRules } from '../rule-lab/compile.js';
-const RULE_LAB_COMMANDS = ['discover', 'analyze', 'review-pack', 'curate', 'promote', 'regress'];
+const RULE_LAB_COMMANDS = ['analyze', 'review-pack', 'curate', 'promote', 'regress'];
 function output(data) {
     const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
     writeSync(1, `${text}\n`);
@@ -16,6 +15,11 @@ function output(data) {
 function resolveRepoPath(repoPath) {
     return path.resolve(repoPath || process.cwd());
 }
+function assertConcreteRunSliceIds(runId, sliceId) {
+    if (/[<>]/.test(runId) || /[<>]/.test(sliceId)) {
+        throw new Error('Invalid run/slice id: placeholder values are not allowed');
+    }
+}
 export function getRuleLabCommandNames(program) {
     const root = program.commands.find((command) => command.name() === 'rule-lab');
     if (!root)
@@ -27,8 +31,6 @@ export function attachRuleLabCommands(program, lazyFactory) {
         if (lazyFactory)
             return lazyFactory(handlerName);
         switch (handlerName) {
-            case 'ruleLabDiscoverCommand':
-                return (options) => ruleLabDiscoverCommand(options);
             case 'ruleLabAnalyzeCommand':
                 return (options) => ruleLabAnalyzeCommand(options);
             case 'ruleLabReviewPackCommand':
@@ -47,13 +49,7 @@ export function attachRuleLabCommands(program, lazyFactory) {
     };
     const root = program
         .command('rule-lab')
-        .description('Offline rule-lab workflow for discover/analyze/review-pack/curate/promote/regress');
-    root
-        .command('discover')
-        .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--scope <scope>', 'Discovery scope: full|diff', 'full')
-        .option('--seed <seed>', 'Optional deterministic seed')
-        .action(action('ruleLabDiscoverCommand'));
+        .description('Offline rule-lab workflow for analyze/review-pack/curate/promote/regress');
     root
         .command('analyze')
         .requiredOption('--run-id <id>', 'Rule-lab run id')
@@ -79,7 +75,7 @@ export function attachRuleLabCommands(program, lazyFactory) {
         .requiredOption('--run-id <id>', 'Rule-lab run id')
         .requiredOption('--slice-id <id>', 'Slice id')
         .option('--repo-path <path>', 'Repository path (default: cwd)')
-        .option('--version <version>', 'Promoted rule version', '1.0.0')
+        .option('--rule-version <version>', 'Promoted rule version', '1.0.0')
         .action(action('ruleLabPromoteCommand'));
     root
         .command('regress')
@@ -96,17 +92,11 @@ export function attachRuleLabCommands(program, lazyFactory) {
         .option('--family <family>', 'Rule family to compile', 'analyze_rules')
         .action((options) => compileRules({ repoPath: options.repoPath, family: options.family }));
 }
-export async function ruleLabDiscoverCommand(options) {
-    const result = await discoverRuleLabRun({
-        repoPath: resolveRepoPath(options?.repoPath),
-        scope: options?.scope || 'full',
-        seed: options?.seed,
-    });
-    output(result);
-}
 export async function ruleLabAnalyzeCommand(options) {
+    assertConcreteRunSliceIds(options.runId, options.sliceId);
+    const repoPath = resolveRepoPath(options?.repoPath);
     const result = await analyzeRuleLabSlice({
-        repoPath: resolveRepoPath(options?.repoPath),
+        repoPath,
         runId: options.runId,
         sliceId: options.sliceId,
     });
@@ -131,11 +121,12 @@ export async function ruleLabCurateCommand(options) {
     output(result);
 }
 export async function ruleLabPromoteCommand(options) {
+    const version = options.ruleVersion ?? options.version;
     const result = await promoteCuratedRules({
         repoPath: resolveRepoPath(options?.repoPath),
         runId: options.runId,
         sliceId: options.sliceId,
-        version: options.version,
+        version,
     });
     output(result);
 }

package/dist/cli/rule-lab.test.js

@@ -1,11 +1,31 @@
 import { describe, expect, it } from 'vitest';
 import { Command } from 'commander';
-import { attachRuleLabCommands, getRuleLabCommandNames } from './rule-lab.js';
+import { attachRuleLabCommands, getRuleLabCommandNames, ruleLabAnalyzeCommand } from './rule-lab.js';
 describe('rule-lab cli', () => {
-    it('registers all six rule-lab subcommands', async () => {
+    it('registers all rule-lab subcommands', async () => {
         const program = new Command();
+        program.version('test-version');
         attachRuleLabCommands(program);
         const cmds = getRuleLabCommandNames(program);
-        expect(cmds).toEqual(['discover', 'analyze', 'review-pack', 'curate', 'promote', 'regress']);
+        expect(cmds).toEqual(['analyze', 'review-pack', 'curate', 'promote', 'regress', 'compile']);
+    });
+    it('uses --rule-version for promote to avoid root --version collision', () => {
+        const program = new Command();
+        program.version('test-version');
+        attachRuleLabCommands(program);
+        const ruleLab = program.commands.find((command) => command.name() === 'rule-lab');
+        expect(ruleLab).toBeTruthy();
+        const promote = ruleLab?.commands.find((command) => command.name() === 'promote');
+        expect(promote).toBeTruthy();
+        const optionNames = (promote?.options || []).map((option) => option.long);
+        expect(optionNames).toContain('--rule-version');
+        expect(optionNames).not.toContain('--version');
+    });
+    it('rejects placeholder run/slice ids at analyze command boundary', async () => {
+        await expect(ruleLabAnalyzeCommand({
+            repoPath: process.cwd(),
+            runId: '<run_id>',
+            sliceId: '<slice_id>',
+        })).rejects.toThrow(/placeholder/i);
     });
 });

package/dist/cli/tool.d.ts

@@ -21,6 +21,7 @@ export declare function queryCommand(queryText: string, options?: {
     goal?: string;
     limit?: string;
     content?: boolean;
+    responseProfile?: 'slim' | 'full';
     scopePreset?: 'unity-gameplay' | 'unity-all';
     unityResources?: UnityResourcesMode;
     unityHydration?: UnityHydrationMode;
@@ -34,6 +35,7 @@ export declare function contextCommand(name: string, options?: {
     file?: string;
     uid?: string;
     content?: boolean;
+    responseProfile?: 'slim' | 'full';
     unityResources?: UnityResourcesMode;
     unityHydration?: UnityHydrationMode;
     unityEvidence?: UnityEvidenceMode;

package/dist/cli/tool.js

@@ -91,6 +91,7 @@ export async function queryCommand(queryText, options) {
         goal: options?.goal,
         limit: options?.limit ? parseInt(options.limit) : undefined,
         include_content: options?.content ?? false,
+        response_profile: options?.responseProfile,
         scope_preset: options?.scopePreset,
         unity_resources: options?.unityResources,
         unity_hydration_mode: options?.unityHydration,
@@ -114,6 +115,7 @@ export async function contextCommand(name, options) {
         uid: options?.uid,
         file_path: options?.file,
         include_content: options?.content ?? false,
+        response_profile: options?.responseProfile,
         unity_resources: options?.unityResources,
         unity_hydration_mode: options?.unityHydration,
         unity_evidence_mode: options?.unityEvidence,

package/dist/core/config/unity-config.d.ts

@@ -6,7 +6,6 @@ export interface UnityConfig {
     lazyBatchSize: number;
     lazyMaxMs: number;
     payloadMode: 'compact' | 'full';
-    persistLifecycleProcessMetadata: boolean;
     parityWarmup: boolean;
     parityWarmupMaxParallel: number;
     paritySeedCacheIdleMs: number;

package/dist/core/config/unity-config.js

@@ -8,7 +8,6 @@ const DEFAULTS = {
     lazyBatchSize: 30,
     lazyMaxMs: 5000,
     payloadMode: 'compact',
-    persistLifecycleProcessMetadata: false,
     parityWarmup: false,
     parityWarmupMaxParallel: 4,
     paritySeedCacheIdleMs: 60000,

package/dist/core/ingestion/pipeline.js

@@ -341,6 +341,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         let communityResult;
         let processResult;
         let unityResult;
+        let unityRuleBindingResult;
         if (!options?.skipGraphPhases) {
             // ── Phase 4.5: Method Resolution Order ──────────────────────────────
             onProgress({
@@ -406,7 +407,9 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             // ── Phase 5.6: Unity lifecycle synthetic calls (auto-detect) ────────
             const isUnityProject = allPaths.some(p => p.startsWith('Assets/') && p.endsWith('.cs'));
             const unityConfig = resolveUnityConfig();
-            const persistLifecycleProcessMetadata = unityConfig.config.persistLifecycleProcessMetadata ?? false;
+            // Persistence is coupled to the Unity resource-binding indexing flow:
+            // if Unity project auto-detection is active, persist lifecycle metadata.
+            const persistLifecycleProcessMetadata = isUnityProject;
             const unityLifecycleSyntheticResult = isUnityProject
                 ? applyUnityLifecycleSyntheticCalls(graph, {
                     maxSyntheticEdgesPerClass: unityConfig.config.maxSyntheticEdgesPerClass,
@@ -422,16 +425,41 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             // Phase 5.7: rule-driven binding injection (Phase 3)
             try {
                 const analyzeRules = await loadAnalyzeRules(repoPath);
-                if (analyzeRules.length > 0) {
-                    const bindingResult = applyUnityRuntimeBindingRules(graph, analyzeRules, unityConfig.config);
-                    if (isDev && bindingResult.edgesInjected > 0) {
-                        console.log(`[UnityRuleBinding] injected ${bindingResult.edgesInjected} edges from ${analyzeRules.length} rule(s)`);
-                    }
+                const bindingResult = applyUnityRuntimeBindingRules(graph, analyzeRules, unityConfig.config);
+                unityRuleBindingResult = bindingResult;
+                if (isDev && bindingResult.edgesInjected > 0) {
+                    console.log(`[UnityRuleBinding] injected ${bindingResult.edgesInjected} edges from ${analyzeRules.length} rule(s)`);
                 }
             }
             catch (err) {
                 // rule catalog missing or invalid — skip silently
                 console.warn(`[UnityRuleBinding] failed to load or apply analyze rules: ${err instanceof Error ? err.message : String(err)}`);
+                const reason = err instanceof Error ? err.message : String(err);
+                unityRuleBindingResult = {
+                    edgesInjected: 0,
+                    ruleResults: [],
+                    diagnostics: {
+                        rulesEvaluated: 0,
+                        bindingsEvaluated: 0,
+                        bindingsByKind: {},
+                        methodLookupCalls: 0,
+                        methodLookupCacheHits: 0,
+                        sceneRuntimeTraversalCalls: 0,
+                        sceneRuntimeTraversalCacheHits: 0,
+                        sceneRuntimeResourcesVisited: 0,
+                        anomalies: [`failed to load/apply analyze rules: ${reason}`],
+                        shouldAgentReport: true,
+                        agentReportReason: 'failed to load/apply analyze rules',
+                        summary: [
+                            'rule_binding.summary: rules=0, bindings=0, edges=0',
+                            'rule_binding.bindings_by_kind: none',
+                            'rule_binding.lookup: method_calls=0, cache_hits=0',
+                            'rule_binding.scene_closure: traversals=0, cache_hits=0, visited_resources=0',
+                            'rule_binding.agent_report: should_report=true reason="failed to load/apply analyze rules"',
+                            `rule_binding.anomaly: failed to load/apply analyze rules: ${reason}`,
+                        ],
+                    },
+                };
             }
             // ── Phase 6: Processes ─────────────────────────────────────────────
             onProgress({
@@ -517,6 +545,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             communityResult,
             processResult,
             unityResult,
+            unityRuleBindingResult,
             scopeDiagnostics: scopeSelection.diagnostics,
             csharpPreprocDiagnostics,
         };

package/dist/core/ingestion/unity-lifecycle-synthetic-calls.test.js

@@ -245,7 +245,7 @@ test('detects Unity hosts through transitive inheritance chains', () => {
     assert.equal(gunGraphHost.baseType, 'ScriptableObject');
     assert.ok(gunGraphHost.methods.length > 0);
 });
-test('prioritizes gameplay lifecycle hosts when synthetic edge budget is tight', () => {
+test('respects global lifecycle edge budget without emitting loader bridges', () => {
     const graph = createKnowledgeGraph();
     for (let i = 0; i < 6; i += 1) {
         addClass(graph, {
@@ -275,12 +275,13 @@ test('prioritizes gameplay lifecycle hosts when synthetic edge budget is tight',
         maxSyntheticEdgesPerClass: 4,
         maxSyntheticEdgesTotal: 8,
     });
-    const runtimeEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' &&
-        (edge.reason === 'unity-lifecycle-synthetic' || edge.reason === 'unity-runtime-loader-synthetic'));
-    const targets = new Set(runtimeEdges.map((edge) => edge.targetId));
+    const lifecycleEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-lifecycle-synthetic');
+    const loaderEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic');
     assert.equal(result.syntheticEdgeCount, 8);
-    assert.equal([...targets].some((id) => id.includes('Assets/NEON/Code/Game/Core/GunGraphMB.cs')), true);
-    assert.equal([...targets].some((id) => id.includes('Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadConfig.cs')), true);
+    assert.equal(result.lifecycleEdgeCount, 8);
+    assert.equal(result.loaderEdgeCount, 0);
+    assert.equal(lifecycleEdges.length, 8);
+    assert.equal(loaderEdges.length, 0);
 });
 test('resolves named class inheritance targets when direct target node lookup is ambiguous', () => {
     const graph = createKnowledgeGraph();
@@ -336,7 +337,7 @@ test('resolves named class inheritance targets when direct target node lookup is
     assert.ok(gunGraphHost);
     assert.equal(gunGraphHost.baseType, 'ScriptableObject');
 });
-test('emits deterministic runtime loader bridge chain after pre-bridge budget is exhausted', () => {
+test('lifecycle phase does not emit runtime-loader bridge edges', () => {
     const graph = createKnowledgeGraph();
     addClass(graph, {
         className: 'GunGraphMB',
@@ -429,16 +430,15 @@ test('emits deterministic runtime loader bridge chain after pre-bridge budget is
         maxSyntheticEdgesPerClass: 12,
         maxSyntheticEdgesTotal: 10,
     });
-    const syntheticEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic');
-    const syntheticPairs = new Set(syntheticEdges.map((edge) => `${edge.sourceId}->${edge.targetId}`));
-    assert.equal(result.syntheticEdgeCount, 10);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Core/GunGraphMB.cs:GunGraphMB.RegisterGraphEvents')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.RegisterEvents')}`), true);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.RegisterEvents')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.StartRoutineWithEvents')}`), true);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.StartRoutineWithEvents')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:ReloadBase.GetValue')}`), true);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:ReloadBase.GetValue')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:ReloadBase.CheckReload')}`), true);
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:ReloadBase.CheckReload')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/Reload.cs:Reload.ReloadRoutine')}`), true);
+    const syntheticLoaderEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic');
+    const lifecycleEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-lifecycle-synthetic');
+    assert.equal(result.syntheticEdgeCount, 3);
+    assert.equal(result.lifecycleEdgeCount, 3);
+    assert.equal(result.loaderEdgeCount, 0);
+    assert.equal(lifecycleEdges.length, 3);
+    assert.equal(syntheticLoaderEdges.length, 0);
 });
-test('preserves bridge budget when accepted host count exceeds synthetic edge cap', () => {
+test('lifecycle edge cap does not rely on runtime-loader bridge injection', () => {
     const graph = createKnowledgeGraph();
     for (let i = 0; i < 20; i += 1) {
         addClass(graph, {
@@ -534,8 +534,6 @@ test('preserves bridge budget when accepted host count exceeds synthetic edge ca
         maxSyntheticEdgesPerClass: 12,
         maxSyntheticEdgesTotal: 12,
     });
-    const syntheticPairs = new Set([...graph.iterRelationships()]
-        .filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic')
-        .map((edge) => `${edge.sourceId}->${edge.targetId}`));
-    assert.equal(syntheticPairs.has(`${generateId('Method', 'Assets/NEON/Code/Game/Core/GunGraphMB.cs:GunGraphMB.RegisterGraphEvents')}->${generateId('Method', 'Assets/NEON/Code/Game/Graph/Graphs/GunGraph.cs:GunGraph.RegisterEvents')}`), true);
+    const loaderEdges = [...graph.iterRelationships()].filter((edge) => edge.type === 'CALLS' && edge.reason === 'unity-runtime-loader-synthetic');
+    assert.equal(loaderEdges.length, 0);
 });

package/dist/core/ingestion/unity-parity-seed.d.ts

@@ -1,9 +1,10 @@
-import type { UnityScanContext } from '../unity/scan-context.js';
+import type { UnityPrefabSourceRef, UnityScanContext } from '../unity/scan-context.js';
 export interface UnityParitySeed {
     version: 1;
     symbolToScriptPath: Record<string, string>;
     scriptPathToGuid: Record<string, string>;
     guidToResourcePaths: Record<string, string[]>;
     assetGuidToPath?: Record<string, string>;
+    prefabSourceRefs?: UnityPrefabSourceRef[];
 }
 export declare function buildUnityParitySeed(scanContext: UnityScanContext): UnityParitySeed;

package/dist/core/ingestion/unity-parity-seed.js

@@ -59,6 +59,14 @@ export function buildUnityParitySeed(scanContext) {
         scriptPathToGuid: sortRecord(scriptPathToGuid),
         guidToResourcePaths: sortRecord(guidToResourcePaths),
         assetGuidToPath: Object.keys(assetGuidToPath).length > 0 ? sortRecord(assetGuidToPath) : undefined,
+        prefabSourceRefs: scanContext.prefabSourceRefs?.map((row) => ({
+            sourceResourcePath: normalizePath(row.sourceResourcePath),
+            targetGuid: String(row.targetGuid || '').trim().toLowerCase(),
+            targetResourcePath: normalizePath(row.targetResourcePath || '') || undefined,
+            fileId: String(row.fileId || '').trim() || undefined,
+            fieldName: 'm_SourcePrefab',
+            sourceLayer: row.sourceLayer === 'scene' ? 'scene' : 'prefab',
+        })),
     };
 }
 function normalizePath(input) {

package/dist/core/ingestion/unity-resource-processor.d.ts

@@ -7,6 +7,7 @@ export interface UnityResourceProcessingResult {
     bindingCount: number;
     componentCount: number;
     diagnostics: string[];
+    prefabSourceStats: PrefabSourcePassStats;
     paritySeed?: UnityParitySeed;
     timingsMs: {
         scanContext: number;
@@ -25,4 +26,14 @@ export interface UnityResourceProcessingDeps {
     buildScanContext?: typeof buildUnityScanContext;
     resolveBindings?: typeof resolveUnityBindings;
 }
+interface PrefabSourcePassStats {
+    rowsParsed: number;
+    rowsFilteredZeroGuid: number;
+    rowsFilteredPlaceholder: number;
+    rowsFilteredUnresolved: number;
+    rowsDeduped: number;
+    rowsEmitted: number;
+    fileErrors: number;
+}
 export declare function processUnityResources(graph: KnowledgeGraph, options: UnityResourceProcessingOptions, deps?: UnityResourceProcessingDeps): Promise<UnityResourceProcessingResult>;
+export {};

package/dist/core/ingestion/unity-resource-processor.js

@@ -5,6 +5,7 @@ import { resolveUnityBindings } from '../unity/resolver.js';
 import { buildUnityParitySeed } from './unity-parity-seed.js';
 import { resolveUnityConfig } from '../config/unity-config.js';
 const UNITY_DIAGNOSTIC_SAMPLE_LIMIT = 3;
+const PREFAB_SOURCE_PASS_DISABLE_ENV = 'GITNEXUS_DISABLE_PREFAB_SOURCE_PASS';
 export async function processUnityResources(graph, options, deps) {
     const tStart = performance.now();
     const buildScanContextFn = deps?.buildScanContext || buildUnityScanContext;
@@ -36,6 +37,7 @@ export async function processUnityResources(graph, options, deps) {
     let scanContextMs = 0;
     let resolveMs = 0;
     let graphWriteMs = 0;
+    let prefabSourceStats = initPrefabSourcePassStats();
     try {
         const tScanContextStart = performance.now();
         scanContext = await buildScanContextFn({
@@ -51,6 +53,22 @@ export async function processUnityResources(graph, options, deps) {
             }
         }
         diagnostics.push(`scanContext: scripts=${scanContext.symbolToScriptPath.size}, guids=${scanContext.scriptPathToGuid.size}, resources=${uniqueResourcePaths.size}`);
+        if (isPrefabSourcePassDisabledByEnv()) {
+            diagnostics.push(`prefab-source: skipped (env ${PREFAB_SOURCE_PASS_DISABLE_ENV}=1)`);
+        }
+        else {
+            const tPrefabSourceStart = performance.now();
+            prefabSourceStats = await emitPrefabSourceGuidRefsFromScanContext(graph, scanContext);
+            graphWriteMs += performance.now() - tPrefabSourceStart;
+            diagnostics.push(`prefab-source: emitted=${prefabSourceStats.rowsEmitted}`);
+            diagnostics.push(`prefab_source.rows_parsed=${prefabSourceStats.rowsParsed}`);
+            diagnostics.push(`prefab_source.rows_filtered_zero_guid=${prefabSourceStats.rowsFilteredZeroGuid}`);
+            diagnostics.push(`prefab_source.rows_filtered_placeholder=${prefabSourceStats.rowsFilteredPlaceholder}`);
+            diagnostics.push(`prefab_source.rows_filtered_unresolved=${prefabSourceStats.rowsFilteredUnresolved}`);
+            diagnostics.push(`prefab_source.rows_deduped=${prefabSourceStats.rowsDeduped}`);
+            diagnostics.push(`prefab_source.rows_emitted=${prefabSourceStats.rowsEmitted}`);
+            diagnostics.push(`prefab_source.file_errors=${prefabSourceStats.fileErrors}`);
+        }
         symbolsWithResourceHits = collectSymbolsWithResourceHits(scanContext);
     }
     catch (error) {
@@ -228,6 +246,7 @@ export async function processUnityResources(graph, options, deps) {
         bindingCount,
         componentCount,
         diagnostics,
+        prefabSourceStats,
         paritySeed: scanContext ? buildUnityParitySeed(scanContext) : undefined,
         timingsMs: {
             scanContext: roundMs(scanContextMs),
@@ -460,3 +479,86 @@ function classifyUnityDiagnostic(message) {
     }
     return 'other';
 }
+async function emitPrefabSourceGuidRefsFromScanContext(graph, scanContext) {
+    const stats = initPrefabSourcePassStats();
+    const dedupeBySource = new Map();
+    const iterable = typeof scanContext.streamPrefabSourceRefs === 'function'
+        ? scanContext.streamPrefabSourceRefs({
+            hooks: {
+                onFileError: () => {
+                    stats.fileErrors += 1;
+                },
+            },
+        })
+        : (async function* () {
+            for (const row of scanContext.prefabSourceRefs || []) {
+                yield row;
+            }
+        })();
+    for await (const row of iterable) {
+        stats.rowsParsed += 1;
+        const source = normalizePath(String(row.sourceResourcePath || '').trim());
+        const guid = String(row.targetGuid || '').trim().toLowerCase();
+        if (!guid || guid === '00000000000000000000000000000000') {
+            stats.rowsFilteredZeroGuid += 1;
+            continue;
+        }
+        const hintedTarget = normalizePath(String(row.targetResourcePath || '').trim());
+        if (hintedTarget === '__PLACEHOLDER__') {
+            stats.rowsFilteredPlaceholder += 1;
+            continue;
+        }
+        const resolvedTarget = hintedTarget
+            || normalizePath(scanContext.assetGuidToPath?.get(guid) || scanContext.assetGuidToPath?.get(guid.toLowerCase()) || '');
+        if (!resolvedTarget || !resolvedTarget.endsWith('.prefab')) {
+            stats.rowsFilteredUnresolved += 1;
+            continue;
+        }
+        if (!source) {
+            stats.rowsFilteredUnresolved += 1;
+            continue;
+        }
+        const perSourceDedupe = dedupeBySource.get(source) || new Set();
+        const dedupeKey = `${resolvedTarget}|m_SourcePrefab|${guid}|${String(row.fileId || '').trim()}|${row.sourceLayer === 'scene' ? 'scene' : 'prefab'}`;
+        if (perSourceDedupe.has(dedupeKey)) {
+            stats.rowsDeduped += 1;
+            continue;
+        }
+        perSourceDedupe.add(dedupeKey);
+        dedupeBySource.set(source, perSourceDedupe);
+        const sourceFileId = ensureResourceFileNode(graph, source);
+        const targetFileId = ensureResourceFileNode(graph, resolvedTarget);
+        graph.addRelationship({
+            id: generateId('UNITY_ASSET_GUID_REF', `${sourceFileId}->${targetFileId}:m_SourcePrefab:${guid}:${String(row.fileId || '')}`),
+            type: 'UNITY_ASSET_GUID_REF',
+            sourceId: sourceFileId,
+            targetId: targetFileId,
+            confidence: 1.0,
+            reason: JSON.stringify({
+                resourcePath: source,
+                targetResourcePath: resolvedTarget,
+                guid,
+                fileId: String(row.fileId || ''),
+                fieldName: 'm_SourcePrefab',
+                sourceLayer: row.sourceLayer === 'scene' ? 'scene' : 'prefab',
+            }),
+        });
+        stats.rowsEmitted += 1;
+    }
+    return stats;
+}
+function initPrefabSourcePassStats() {
+    return {
+        rowsParsed: 0,
+        rowsFilteredZeroGuid: 0,
+        rowsFilteredPlaceholder: 0,
+        rowsFilteredUnresolved: 0,
+        rowsDeduped: 0,
+        rowsEmitted: 0,
+        fileErrors: 0,
+    };
+}
+function isPrefabSourcePassDisabledByEnv() {
+    const value = String(process.env[PREFAB_SOURCE_PASS_DISABLE_ENV] || '').trim().toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes' || value === 'on';
+}