@veewo/gitnexus 1.3.10 → 1.3.11

package/dist/cli/analyze-runtime-summary.test.js

@@ -0,0 +1,14 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { toPipelineRuntimeSummary } from './analyze-runtime-summary.js';
+test('toPipelineRuntimeSummary drops graph reference and preserves reporting fields', () => {
+    const out = toPipelineRuntimeSummary({
+        totalFileCount: 12,
+        communityResult: { stats: { totalCommunities: 3 } },
+        processResult: { stats: { totalProcesses: 2 } },
+        unityResult: { diagnostics: ['scanContext: scripts=1'] },
+    });
+    assert.equal('graph' in out, false);
+    assert.equal(out.totalFileCount, 12);
+    assert.equal(out.communityResult?.stats.totalCommunities, 3);
+});

package/dist/cli/analyze.js

@@ -20,6 +20,9 @@ import fs from 'fs/promises';
 import { registerClaudeHook } from './claude-hooks.js';
 import { resolveEffectiveAnalyzeOptions } from './analyze-options.js';
 import { formatFallbackSummary, formatUnityDiagnosticsSummary } from './analyze-summary.js';
+import { resolveChildProcessExit } from './exit-code.js';
+import { shouldCloseKuzuOnAnalyzeExit } from './analyze-close-policy.js';
+import { toPipelineRuntimeSummary } from './analyze-runtime-summary.js';
 const HEAP_MB = 8192;
 const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
 /** Re-exec the process with an 8GB heap if we're currently below that. */
@@ -37,7 +40,11 @@ function ensureHeap() {
         });
     }
     catch (e) {
-        process.exitCode = e.status ?? 1;
+        const resolved = resolveChildProcessExit(e, 1);
+        if (resolved.bySignal && resolved.signal) {
+            console.error(`  analyze subprocess terminated by signal ${resolved.signal}`);
+        }
+        process.exitCode = resolved.code;
     }
     return true;
 }
@@ -149,6 +156,10 @@ export const analyzeCommand = async (inputPath, options) => {
         aborted = true;
         bar.stop();
         console.log('\n  Interrupted — cleaning up...');
+        if (!shouldCloseKuzuOnAnalyzeExit()) {
+            process.exit(130);
+            return;
+        }
         closeKuzu().catch(() => { }).finally(() => process.exit(130));
     };
     process.on('SIGINT', sigintHandler);
@@ -246,6 +257,8 @@ export const analyzeCommand = async (inputPath, options) => {
         const progress = Math.min(84, 60 + Math.round((kuzuMsgCount / (kuzuMsgCount + 10)) * 24));
         updateBar(progress, msg);
     });
+    const pipelineRuntime = toPipelineRuntimeSummary(pipelineResult);
+    pipelineResult = undefined;
     const kuzuTime = ((Date.now() - t0Kuzu) / 1000).toFixed(1);
     const kuzuWarnings = kuzuResult.warnings;
     // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
@@ -312,38 +325,41 @@ export const analyzeCommand = async (inputPath, options) => {
             embeddings: embeddingsEnabled,
         },
         stats: {
-            files: pipelineResult.totalFileCount,
+            files: pipelineRuntime.totalFileCount,
             nodes: stats.nodes,
             edges: stats.edges,
-            communities: pipelineResult.communityResult?.stats.totalCommunities,
-            processes: pipelineResult.processResult?.stats.totalProcesses,
+            communities: pipelineRuntime.communityResult?.stats.totalCommunities,
+            processes: pipelineRuntime.processResult?.stats.totalProcesses,
         },
     };
     await saveMeta(storagePath, meta);
+    await persistUnityParitySeed(storagePath, pipelineRuntime.unityResult?.paritySeed);
     const registeredRepo = await registerRepo(repoPath, meta, { repoAlias });
     await addToGitignore(repoPath);
     const hookResult = await registerClaudeHook();
     const projectName = path.basename(repoPath);
     let aggregatedClusterCount = 0;
-    if (pipelineResult.communityResult?.communities) {
+    if (pipelineRuntime.communityResult?.communities) {
         const groups = new Map();
-        for (const c of pipelineResult.communityResult.communities) {
+        for (const c of pipelineRuntime.communityResult.communities) {
             const label = c.heuristicLabel || c.label || 'Unknown';
             groups.set(label, (groups.get(label) || 0) + c.symbolCount);
         }
         aggregatedClusterCount = Array.from(groups.values()).filter(count => count >= 5).length;
     }
     const aiContext = await generateAIContextFiles(repoPath, storagePath, projectName, {
-        files: pipelineResult.totalFileCount,
+        files: pipelineRuntime.totalFileCount,
         nodes: stats.nodes,
         edges: stats.edges,
-        communities: pipelineResult.communityResult?.stats.totalCommunities,
+        communities: pipelineRuntime.communityResult?.stats.totalCommunities,
         clusters: aggregatedClusterCount,
-        processes: pipelineResult.processResult?.stats.totalProcesses,
+        processes: pipelineRuntime.processResult?.stats.totalProcesses,
     }, {
         skillScope: ((await loadCLIConfig()).setupScope === 'global') ? 'global' : 'project',
     });
-    await closeKuzu();
+    if (shouldCloseKuzuOnAnalyzeExit()) {
+        await closeKuzu();
+    }
     // Note: we intentionally do NOT call disposeEmbedder() here.
     // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs.
     // Since the process exits immediately after, Node.js reclaims everything.
@@ -361,9 +377,9 @@ export const analyzeCommand = async (inputPath, options) => {
     console.log(`  Repo Name: ${registeredRepo.name}`);
     console.log(`  Repo Alias: ${registeredRepo.alias || 'none'}`);
     console.log(`  Scope Rules: ${scopeRules.length}`);
-    console.log(`  Scoped Files: ${pipelineResult.totalFileCount}`);
-    if (scopeRules.length > 0 && pipelineResult.scopeDiagnostics) {
-        const diagnostics = pipelineResult.scopeDiagnostics;
+    console.log(`  Scoped Files: ${pipelineRuntime.totalFileCount}`);
+    if (scopeRules.length > 0 && pipelineRuntime.scopeDiagnostics) {
+        const diagnostics = pipelineRuntime.scopeDiagnostics;
         console.log(`  Scope Overlap Files: ${diagnostics.overlapFiles} (${diagnostics.dedupedMatchCount} duplicate matches removed)`);
         if (diagnostics.normalizedCollisions.length === 0) {
             console.log('  Scope Collisions: none');
@@ -378,11 +394,11 @@ export const analyzeCommand = async (inputPath, options) => {
             }
         }
     }
-    const unitySummaryLines = formatUnityDiagnosticsSummary(pipelineResult.unityResult?.diagnostics);
+    const unitySummaryLines = formatUnityDiagnosticsSummary(pipelineRuntime.unityResult?.diagnostics);
     for (const line of unitySummaryLines) {
         console.log(`  ${line}`);
     }
-    console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineResult.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineResult.processResult?.stats.totalProcesses || 0} flows`);
+    console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineRuntime.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineRuntime.processResult?.stats.totalProcesses || 0} flows`);
     console.log(`  KuzuDB ${kuzuTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
     if (includeExtensions.length > 0) {
         console.log(`  File filter: ${includeExtensions.join(', ')}`);
@@ -416,3 +432,14 @@ export const analyzeCommand = async (inputPath, options) => {
         process.exit(0);
     }
 };
+async function persistUnityParitySeed(storagePath, seed) {
+    const seedPath = path.join(storagePath, 'unity-parity-seed.json');
+    if (!seed) {
+        try {
+            await fs.rm(seedPath, { force: true });
+        }
+        catch { }
+        return;
+    }
+    await fs.writeFile(seedPath, JSON.stringify(seed), 'utf-8');
+}

package/dist/cli/eval-server.js

@@ -253,6 +253,9 @@ function getNextStepHint(toolName) {
 }
 // ─── Server ───────────────────────────────────────────────────────────
 export async function evalServerCommand(options) {
+    if (!process.env.GITNEXUS_UNITY_PARITY_WARMUP) {
+        process.env.GITNEXUS_UNITY_PARITY_WARMUP = '1';
+    }
     const port = parseInt(options?.port || '4848');
     const idleTimeoutSec = parseInt(options?.idleTimeout || '0');
     const backend = new LocalBackend();

package/dist/cli/exit-code.d.ts

@@ -0,0 +1,13 @@
+export interface ChildExitResolution {
+    code: number;
+    signal?: string;
+    bySignal: boolean;
+}
+/**
+ * Convert a signal name to a conventional shell exit code (128 + signal number).
+ */
+export declare function getSignalExitCode(signal?: string | null): number | null;
+/**
+ * Normalize child-process termination details into a stable numeric exit code.
+ */
+export declare function resolveChildProcessExit(error: any, fallbackCode?: number): ChildExitResolution;

package/dist/cli/exit-code.js

@@ -0,0 +1,25 @@
+import { constants as osConstants } from 'node:os';
+/**
+ * Convert a signal name to a conventional shell exit code (128 + signal number).
+ */
+export function getSignalExitCode(signal) {
+    if (!signal)
+        return null;
+    const signalNumber = osConstants.signals[signal];
+    if (typeof signalNumber !== 'number')
+        return null;
+    return 128 + signalNumber;
+}
+/**
+ * Normalize child-process termination details into a stable numeric exit code.
+ */
+export function resolveChildProcessExit(error, fallbackCode = 1) {
+    if (typeof error?.status === 'number') {
+        return { code: error.status, bySignal: false };
+    }
+    if (typeof error?.signal === 'string') {
+        const code = getSignalExitCode(error.signal) ?? fallbackCode;
+        return { code, signal: error.signal, bySignal: true };
+    }
+    return { code: fallbackCode, bySignal: false };
+}

package/dist/cli/exit-code.test.d.ts

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

package/dist/cli/exit-code.test.js

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { constants as osConstants } from 'node:os';
+import { getSignalExitCode, resolveChildProcessExit } from './exit-code.js';
+test('getSignalExitCode maps signal number using 128+N convention', () => {
+    const signalNumber = osConstants.signals.SIGSEGV;
+    const expected = typeof signalNumber === 'number' ? 128 + signalNumber : null;
+    assert.equal(getSignalExitCode('SIGSEGV'), expected);
+});
+test('resolveChildProcessExit prefers explicit status when present', () => {
+    const resolved = resolveChildProcessExit({ status: 42, signal: 'SIGSEGV' }, 1);
+    assert.equal(resolved.code, 42);
+    assert.equal(resolved.bySignal, false);
+    assert.equal(resolved.signal, undefined);
+});
+test('resolveChildProcessExit maps signal-based termination', () => {
+    const signalNumber = osConstants.signals.SIGSEGV;
+    const expected = typeof signalNumber === 'number' ? 128 + signalNumber : 1;
+    const resolved = resolveChildProcessExit({ signal: 'SIGSEGV' }, 1);
+    assert.equal(resolved.code, expected);
+    assert.equal(resolved.bySignal, true);
+    assert.equal(resolved.signal, 'SIGSEGV');
+});
+test('resolveChildProcessExit falls back to default code for unknown errors', () => {
+    const resolved = resolveChildProcessExit({ message: 'boom' }, 7);
+    assert.equal(resolved.code, 7);
+    assert.equal(resolved.bySignal, false);
+});

package/dist/cli/index.js

@@ -14,8 +14,11 @@ if (!process.env.NODE_OPTIONS?.includes('--max-old-space-size')) {
             process.exit(0);
         }
         catch (e) {
-            // If the child exited with an error code, propagate it
-            process.exit(e.status ?? 1);
+            const resolved = resolveChildProcessExit(e, 1);
+            if (resolved.bySignal && resolved.signal) {
+                process.stderr.write(`gitnexus: child process terminated by signal ${resolved.signal}\n`);
+            }
+            process.exit(resolved.code);
         }
     }
 }
@@ -38,6 +41,7 @@ import { benchmarkUnityCommand } from './benchmark-unity.js';
 import { benchmarkAgentContextCommand } from './benchmark-agent-context.js';
 import { unityBindingsCommand } from './unity-bindings.js';
 import { benchmarkU2E2ECommand } from './benchmark-u2-e2e.js';
+import { resolveChildProcessExit } from './exit-code.js';
 function resolveCliVersion() {
     try {
         const currentFile = fileURLToPath(import.meta.url);
@@ -125,6 +129,7 @@ program
     .option('-l, --limit <n>', 'Max processes to return (default: 5)')
     .option('--content', 'Include full symbol source code')
     .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')
     .action(queryCommand);
 program
     .command('context [name]')
@@ -134,6 +139,7 @@ program
     .option('-f, --file <path>', 'File path to disambiguate common names')
     .option('--content', 'Include full symbol source code')
     .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')
     .action(contextCommand);
 program
     .command('unity-bindings <symbol>')

package/dist/cli/mcp.js

@@ -8,6 +8,9 @@
 import { startMCPServer } from '../mcp/server.js';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 export const mcpCommand = async () => {
+    if (!process.env.GITNEXUS_UNITY_PARITY_WARMUP) {
+        process.env.GITNEXUS_UNITY_PARITY_WARMUP = '1';
+    }
     // Prevent unhandled errors from crashing the MCP server process.
     // KuzuDB lock conflicts and transient errors should degrade gracefully.
     process.on('uncaughtException', (err) => {

package/dist/cli/setup.js

@@ -164,9 +164,10 @@ function buildCodexMcpTable() {
 function mergeCodexConfig(existingRaw) {
     const table = buildCodexMcpTable();
     const normalized = existingRaw.replace(/\r\n/g, '\n');
-    const tablePattern = /\[mcp_servers\.gitnexus\][\s\S]*?(?=\n\[[^\]]+\]|\s*$)/m;
+    const tablePattern = /^\[mcp_servers\.gitnexus\][\s\S]*?(?=^\[[^\]]+\]|(?![\s\S]))/m;
     if (tablePattern.test(normalized)) {
-        return normalized.replace(tablePattern, table).trimEnd() + '\n';
+        // Keep exactly one table by replacing the whole previous section block.
+        return normalized.replace(tablePattern, `${table}\n\n`).trimEnd() + '\n';
     }
     const trimmed = normalized.trimEnd();
     if (trimmed.length === 0)

package/dist/cli/setup.test.js

@@ -12,6 +12,7 @@ const packageRoot = path.resolve(here, '..', '..');
 const cliPath = path.join(packageRoot, 'dist', 'cli', 'index.js');
 const packageName = JSON.parse(await fs.readFile(path.join(packageRoot, 'package.json'), 'utf-8'));
 const expectedMcpPackage = `${packageName.name || 'gitnexus'}@latest`;
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 async function runSetup(args, env, cwd = packageRoot) {
     return execFileAsync(process.execPath, [cliPath, 'setup', ...args], { cwd, env });
 }
@@ -235,6 +236,72 @@ test('setup --scope project --agent codex writes only .codex/config.toml', async
         await fs.rm(fakeRepo, { recursive: true, force: true });
     }
 });
+test('setup --scope project --agent codex replaces existing gitnexus table without duplicate keys', async () => {
+    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
+    const fakeRepo = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-repo-'));
+    try {
+        await execFileAsync('git', ['init'], { cwd: fakeRepo });
+        const codexConfigPath = path.join(fakeRepo, '.codex', 'config.toml');
+        await fs.mkdir(path.dirname(codexConfigPath), { recursive: true });
+        await fs.writeFile(codexConfigPath, [
+            '[mcp_servers.gitnexus]',
+            'command = "npx"',
+            'args = ["-y", "oldpkg@latest", "mcp"]',
+            '',
+            '[profiles.default]',
+            'model = "gpt-5"',
+            '',
+        ].join('\n'), 'utf-8');
+        await runSetup(['--scope', 'project', '--agent', 'codex'], {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
+        }, fakeRepo);
+        const codexConfigRaw = await fs.readFile(codexConfigPath, 'utf-8');
+        const tableMatches = codexConfigRaw.match(/^\[mcp_servers\.gitnexus\]$/gm) || [];
+        assert.equal(tableMatches.length, 1);
+        const gitnexusTableMatch = codexConfigRaw.match(/^\[mcp_servers\.gitnexus\][\s\S]*?(?=^\[[^\]]+\]|(?![\s\S]))/m);
+        assert.ok(gitnexusTableMatch, 'expected [mcp_servers.gitnexus] table');
+        const gitnexusTable = gitnexusTableMatch[0];
+        assert.equal((gitnexusTable.match(/^command\s*=/gm) || []).length, 1);
+        assert.equal((gitnexusTable.match(/^args\s*=/gm) || []).length, 1);
+        assert.match(gitnexusTable, new RegExp(escapeRegExp(expectedMcpPackage)));
+        assert.doesNotMatch(gitnexusTable, /oldpkg@latest/);
+        assert.match(codexConfigRaw, /^\[profiles\.default\]$/m);
+    }
+    finally {
+        await fs.rm(fakeHome, { recursive: true, force: true });
+        await fs.rm(fakeRepo, { recursive: true, force: true });
+    }
+});
+test('setup --scope project --agent codex is idempotent across repeated runs', async () => {
+    const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
+    const fakeRepo = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-repo-'));
+    try {
+        await execFileAsync('git', ['init'], { cwd: fakeRepo });
+        const env = {
+            ...process.env,
+            HOME: fakeHome,
+            USERPROFILE: fakeHome,
+        };
+        await runSetup(['--scope', 'project', '--agent', 'codex'], env, fakeRepo);
+        await runSetup(['--scope', 'project', '--agent', 'codex'], env, fakeRepo);
+        const codexConfigPath = path.join(fakeRepo, '.codex', 'config.toml');
+        const codexConfigRaw = await fs.readFile(codexConfigPath, 'utf-8');
+        const tableMatches = codexConfigRaw.match(/^\[mcp_servers\.gitnexus\]$/gm) || [];
+        assert.equal(tableMatches.length, 1);
+        const gitnexusTableMatch = codexConfigRaw.match(/^\[mcp_servers\.gitnexus\][\s\S]*?(?=^\[[^\]]+\]|(?![\s\S]))/m);
+        assert.ok(gitnexusTableMatch, 'expected [mcp_servers.gitnexus] table');
+        const gitnexusTable = gitnexusTableMatch[0];
+        assert.equal((gitnexusTable.match(/^command\s*=/gm) || []).length, 1);
+        assert.equal((gitnexusTable.match(/^args\s*=/gm) || []).length, 1);
+        assert.match(gitnexusTable, new RegExp(escapeRegExp(expectedMcpPackage)));
+    }
+    finally {
+        await fs.rm(fakeHome, { recursive: true, force: true });
+        await fs.rm(fakeRepo, { recursive: true, force: true });
+    }
+});
 test('setup --scope project --agent opencode writes only opencode.json', async () => {
     const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-home-'));
     const fakeRepo = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-setup-repo-'));

package/dist/cli/tool.d.ts

@@ -13,7 +13,7 @@
  * Note: Output goes to stderr because KuzuDB's native module captures stdout
  * at the OS level during init. This is consistent with augment.ts.
  */
-import type { UnityResourcesMode } from '../core/unity/options.js';
+import type { UnityHydrationMode, UnityResourcesMode } from '../core/unity/options.js';
 export declare function queryCommand(queryText: string, options?: {
     repo?: string;
     context?: string;
@@ -21,6 +21,7 @@ export declare function queryCommand(queryText: string, options?: {
     limit?: string;
     content?: boolean;
     unityResources?: UnityResourcesMode;
+    unityHydration?: UnityHydrationMode;
 }): Promise<void>;
 export declare function contextCommand(name: string, options?: {
     repo?: string;
@@ -28,6 +29,7 @@ export declare function contextCommand(name: string, options?: {
     uid?: string;
     content?: boolean;
     unityResources?: UnityResourcesMode;
+    unityHydration?: UnityHydrationMode;
 }): Promise<void>;
 export declare function impactCommand(target: string, options?: {
     direction?: string;

package/dist/cli/tool.js

@@ -44,6 +44,7 @@ export async function queryCommand(queryText, options) {
         limit: options?.limit ? parseInt(options.limit) : undefined,
         include_content: options?.content ?? false,
         unity_resources: options?.unityResources,
+        unity_hydration_mode: options?.unityHydration,
         repo: options?.repo,
     });
     output(result);
@@ -60,6 +61,7 @@ export async function contextCommand(name, options) {
         file_path: options?.file,
         include_content: options?.content ?? false,
         unity_resources: options?.unityResources,
+        unity_hydration_mode: options?.unityHydration,
         repo: options?.repo,
     });
     output(result);

package/dist/core/graph/types.d.ts

@@ -20,7 +20,7 @@ export type NodeProperties = {
     entryPointScore?: number;
     entryPointReason?: string;
 };
-export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'MEMBER_OF' | 'STEP_IN_PROCESS' | 'UNITY_COMPONENT_IN' | 'UNITY_COMPONENT_INSTANCE' | 'UNITY_SERIALIZED_TYPE_IN';
+export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'OVERRIDES' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'MEMBER_OF' | 'STEP_IN_PROCESS' | 'UNITY_COMPONENT_IN' | 'UNITY_COMPONENT_INSTANCE' | 'UNITY_RESOURCE_SUMMARY' | 'UNITY_SERIALIZED_TYPE_IN';
 export interface GraphNode {
     id: string;
     label: NodeLabel;

package/dist/core/ingestion/filesystem-walker.d.ts

@@ -16,6 +16,12 @@ export interface FilePath {
  * Memory: ~10MB for 100K files vs ~1GB+ with content.
  */
 export declare const walkRepositoryPaths: (repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void) => Promise<ScannedFile[]>;
+/**
+ * Scan Unity resource files used by binding enrichment.
+ * This path scan intentionally does not apply the 512KB source-size cap,
+ * because bindings often live in large serialized assets.
+ */
+export declare const walkUnityResourcePaths: (repoPath: string) => Promise<string[]>;
 /**
  * Phase 2: Read file contents for a specific set of relative paths.
  * Returns a Map for O(1) lookup. Silently skips files that fail to read.

package/dist/core/ingestion/filesystem-walker.js

@@ -5,6 +5,7 @@ import { shouldIgnorePath } from '../../config/ignore-service.js';
 const READ_CONCURRENCY = 32;
 /** Skip files larger than 512KB — they're usually generated/vendored and crash tree-sitter */
 const MAX_FILE_SIZE = 512 * 1024;
+const UNITY_RESOURCE_GLOBS = ['**/*.prefab', '**/*.unity', '**/*.asset'];
 /**
  * Phase 1: Scan repository — stat files to get paths + sizes, no content loaded.
  * Memory: ~10MB for 100K files vs ~1GB+ with content.
@@ -46,6 +47,22 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
     }
     return entries;
 };
+/**
+ * Scan Unity resource files used by binding enrichment.
+ * This path scan intentionally does not apply the 512KB source-size cap,
+ * because bindings often live in large serialized assets.
+ */
+export const walkUnityResourcePaths = async (repoPath) => {
+    const files = await glob(UNITY_RESOURCE_GLOBS, {
+        cwd: repoPath,
+        nodir: true,
+        dot: false,
+    });
+    return files
+        .filter(file => !shouldIgnorePath(file))
+        .map(file => file.replace(/\\/g, '/'))
+        .sort((left, right) => left.localeCompare(right));
+};
 /**
  * Phase 2: Read file contents for a specific set of relative paths.
  * Returns a Map for O(1) lookup. Silently skips files that fail to read.

package/dist/core/ingestion/filesystem-walker.test.d.ts

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

package/dist/core/ingestion/filesystem-walker.test.js

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { walkRepositoryPaths, walkUnityResourcePaths } from './filesystem-walker.js';
+test('walkUnityResourcePaths includes large Unity resources while walkRepositoryPaths skips them', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-fswalker-'));
+    const assetsDir = path.join(repoRoot, 'Assets/Scene');
+    await fs.mkdir(assetsDir, { recursive: true });
+    const largePrefab = 'Assets/Scene/Large.prefab';
+    const smallPrefab = 'Assets/Scene/Small.prefab';
+    const scriptFile = 'Assets/Scene/Test.cs';
+    try {
+        await fs.writeFile(path.join(repoRoot, largePrefab), 'x'.repeat(600 * 1024), 'utf-8');
+        await fs.writeFile(path.join(repoRoot, smallPrefab), 'small', 'utf-8');
+        await fs.writeFile(path.join(repoRoot, scriptFile), 'public class Test {}', 'utf-8');
+        const scanned = await walkRepositoryPaths(repoRoot);
+        const scannedPaths = new Set(scanned.map((entry) => entry.path));
+        assert.equal(scannedPaths.has(largePrefab), false);
+        assert.equal(scannedPaths.has(smallPrefab), true);
+        assert.equal(scannedPaths.has(scriptFile), true);
+        const unityPaths = await walkUnityResourcePaths(repoRoot);
+        assert.equal(unityPaths.includes(largePrefab), true);
+        assert.equal(unityPaths.includes(smallPrefab), true);
+    }
+    finally {
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+});
+test('walkUnityResourcePaths only returns prefab/unity/asset files and still honors ignore rules', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-fswalker-'));
+    await fs.mkdir(path.join(repoRoot, 'Assets/Scene'), { recursive: true });
+    await fs.mkdir(path.join(repoRoot, 'node_modules/pkg'), { recursive: true });
+    try {
+        await fs.writeFile(path.join(repoRoot, 'Assets/Scene/Keep.prefab'), 'prefab', 'utf-8');
+        await fs.writeFile(path.join(repoRoot, 'Assets/Scene/Keep.unity'), 'scene', 'utf-8');
+        await fs.writeFile(path.join(repoRoot, 'Assets/Scene/Keep.asset'), 'asset', 'utf-8');
+        await fs.writeFile(path.join(repoRoot, 'Assets/Scene/Ignore.cs'), 'public class Ignore {}', 'utf-8');
+        await fs.writeFile(path.join(repoRoot, 'node_modules/pkg/Hidden.prefab'), 'hidden', 'utf-8');
+        const unityPaths = await walkUnityResourcePaths(repoRoot);
+        assert.deepEqual(unityPaths, [
+            'Assets/Scene/Keep.asset',
+            'Assets/Scene/Keep.prefab',
+            'Assets/Scene/Keep.unity',
+        ]);
+    }
+    finally {
+        await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+});

package/dist/core/ingestion/pipeline.js

@@ -9,7 +9,7 @@ import { processProcesses } from './process-processor.js';
 import { processUnityResources } from './unity-resource-processor.js';
 import { createSymbolTable } from './symbol-table.js';
 import { createASTCache } from './ast-cache.js';
-import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
+import { walkRepositoryPaths, readFileContents, walkUnityResourcePaths } from './filesystem-walker.js';
 import { getLanguageFromFilename } from './utils.js';
 import { createWorkerPool } from './workers/worker-pool.js';
 import { selectEntriesByScopeRules } from './scope-filter.js';
@@ -75,9 +75,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             stats: { filesProcessed: 0, totalFiles, nodesCreated: graph.nodeCount },
         });
         const allPaths = extensionFiltered.map(f => f.path);
+        const unityCandidates = await walkUnityResourcePaths(repoPath);
         const unityScopedPaths = (options?.scopeRules && options.scopeRules.length > 0)
-            ? scopedFiles.map(f => f.path)
-            : allPaths;
+            ? selectEntriesByScopeRules(unityCandidates.map(path => ({ path })), options.scopeRules).selected.map(entry => entry.path)
+            : unityCandidates;
         processStructure(graph, allPaths);
         onProgress({
             phase: 'structure',

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

@@ -0,0 +1,9 @@
+import type { 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>;
+}
+export declare function buildUnityParitySeed(scanContext: UnityScanContext): UnityParitySeed;

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

@@ -0,0 +1,69 @@
+export function buildUnityParitySeed(scanContext) {
+    const canonicalMap = scanContext.symbolToCanonicalScriptPath instanceof Map
+        ? scanContext.symbolToCanonicalScriptPath
+        : new Map();
+    const fallbackMap = scanContext.symbolToScriptPath instanceof Map
+        ? scanContext.symbolToScriptPath
+        : new Map();
+    const canonical = canonicalMap.size > 0 ? canonicalMap : fallbackMap;
+    const symbolToScriptPath = {};
+    for (const [symbol, scriptPath] of canonical.entries()) {
+        const key = String(symbol || '').trim();
+        const value = normalizePath(scriptPath);
+        if (!key || !value)
+            continue;
+        symbolToScriptPath[key] = value;
+    }
+    const scriptPathToGuid = {};
+    const scriptPathToGuidMap = scanContext.scriptPathToGuid instanceof Map
+        ? scanContext.scriptPathToGuid
+        : new Map();
+    for (const [scriptPath, guid] of scriptPathToGuidMap.entries()) {
+        const key = normalizePath(scriptPath);
+        const value = String(guid || '').trim();
+        if (!key || !value)
+            continue;
+        scriptPathToGuid[key] = value;
+    }
+    const guidToResourcePaths = {};
+    const guidToResourceHitsMap = scanContext.guidToResourceHits instanceof Map
+        ? scanContext.guidToResourceHits
+        : new Map();
+    for (const [guid, hits] of guidToResourceHitsMap.entries()) {
+        const key = String(guid || '').trim();
+        if (!key)
+            continue;
+        const uniquePaths = new Set();
+        for (const hit of hits || []) {
+            const resourcePath = normalizePath(hit?.resourcePath || '');
+            if (resourcePath)
+                uniquePaths.add(resourcePath);
+        }
+        if (uniquePaths.size > 0) {
+            guidToResourcePaths[key] = [...uniquePaths].sort((left, right) => left.localeCompare(right));
+        }
+    }
+    const assetGuidToPath = {};
+    if (scanContext.assetGuidToPath instanceof Map) {
+        for (const [guid, assetPath] of scanContext.assetGuidToPath.entries()) {
+            const key = String(guid || '').trim();
+            const value = normalizePath(assetPath);
+            if (!key || !value)
+                continue;
+            assetGuidToPath[key] = value;
+        }
+    }
+    return {
+        version: 1,
+        symbolToScriptPath: sortRecord(symbolToScriptPath),
+        scriptPathToGuid: sortRecord(scriptPathToGuid),
+        guidToResourcePaths: sortRecord(guidToResourcePaths),
+        assetGuidToPath: Object.keys(assetGuidToPath).length > 0 ? sortRecord(assetGuidToPath) : undefined,
+    };
+}
+function normalizePath(input) {
+    return String(input || '').replace(/\\/g, '/').trim();
+}
+function sortRecord(input) {
+    return Object.fromEntries(Object.entries(input).sort(([left], [right]) => left.localeCompare(right)));
+}

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

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