@veewo/gitnexus 1.3.9 → 1.3.11-rc.1

package/dist/cli/analyze-options.js

@@ -54,3 +54,38 @@ export async function resolveAnalyzeScopeRules(options) {
     }
     return normalizedRules;
 }
+function parseScopePrefixCount(scopePrefix) {
+    if (Array.isArray(scopePrefix))
+        return scopePrefix.length;
+    if (typeof scopePrefix === 'string')
+        return scopePrefix.trim() ? 1 : 0;
+    return 0;
+}
+export async function resolveEffectiveAnalyzeOptions(options, stored) {
+    const includeExtensionsFromCli = parseExtensionList(options?.extensions);
+    const scopeRulesFromCli = await resolveAnalyzeScopeRules({
+        scopeManifest: options?.scopeManifest,
+        scopePrefix: options?.scopePrefix,
+    });
+    const repoAliasFromCli = normalizeRepoAlias(options?.repoAlias);
+    const hasCliExtensions = options?.extensions !== undefined;
+    const hasCliScope = Boolean(options?.scopeManifest) || parseScopePrefixCount(options?.scopePrefix) > 0;
+    const hasCliRepoAlias = options?.repoAlias !== undefined;
+    const canReuse = options?.reuseOptions !== false;
+    const includeExtensions = hasCliExtensions
+        ? includeExtensionsFromCli
+        : (canReuse ? (stored?.includeExtensions || []) : []);
+    const scopeRules = hasCliScope
+        ? scopeRulesFromCli
+        : (canReuse ? (stored?.scopeRules || []) : []);
+    const repoAlias = hasCliRepoAlias
+        ? repoAliasFromCli
+        : (canReuse ? normalizeRepoAlias(stored?.repoAlias) : undefined);
+    const embeddings = options?.embeddings ?? (canReuse ? Boolean(stored?.embeddings) : false);
+    return {
+        includeExtensions: [...includeExtensions],
+        scopeRules: [...scopeRules],
+        repoAlias,
+        embeddings,
+    };
+}

package/dist/cli/analyze-options.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { normalizeRepoAlias, parseExtensionList, resolveAnalyzeScopeRules } from './analyze-options.js';
+import { normalizeRepoAlias, parseExtensionList, resolveAnalyzeScopeRules, resolveEffectiveAnalyzeOptions, } from './analyze-options.js';
 test('parseExtensionList normalizes dot prefixes', () => {
     const exts = parseExtensionList('cs,.ts, go ');
     assert.deepEqual(exts, ['.cs', '.ts', '.go']);
@@ -34,3 +34,44 @@ test('resolveAnalyzeScopeRules fails when manifest has no usable rule', async ()
     await fs.writeFile(manifestPath, '# only comments\n\n', 'utf-8');
     await assert.rejects(resolveAnalyzeScopeRules({ scopeManifest: manifestPath }), /no valid scope rules/i);
 });
+test('resolveEffectiveAnalyzeOptions reuses stored settings when CLI omits them', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({}, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/NEON/Code'],
+        repoAlias: 'neonspark-v1-subset',
+        embeddings: true,
+    });
+    assert.deepEqual(resolved.includeExtensions, ['.cs']);
+    assert.deepEqual(resolved.scopeRules, ['Assets/NEON/Code']);
+    assert.equal(resolved.repoAlias, 'neonspark-v1-subset');
+    assert.equal(resolved.embeddings, true);
+});
+test('resolveEffectiveAnalyzeOptions disables reuse via reuseOptions=false', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({ reuseOptions: false }, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/NEON/Code'],
+        repoAlias: 'neonspark-v1-subset',
+        embeddings: true,
+    });
+    assert.deepEqual(resolved.includeExtensions, []);
+    assert.deepEqual(resolved.scopeRules, []);
+    assert.equal(resolved.repoAlias, undefined);
+    assert.equal(resolved.embeddings, false);
+});
+test('resolveEffectiveAnalyzeOptions prefers explicit CLI values over stored settings', async () => {
+    const resolved = await resolveEffectiveAnalyzeOptions({
+        extensions: '.ts',
+        scopePrefix: ['src'],
+        repoAlias: 'new-alias',
+        embeddings: false,
+    }, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/NEON/Code'],
+        repoAlias: 'old-alias',
+        embeddings: true,
+    });
+    assert.deepEqual(resolved.includeExtensions, ['.ts']);
+    assert.deepEqual(resolved.scopeRules, ['src']);
+    assert.equal(resolved.repoAlias, 'new-alias');
+    assert.equal(resolved.embeddings, false);
+});

package/dist/cli/analyze-runtime-summary.d.ts

@@ -0,0 +1,2 @@
+import type { PipelineResult, PipelineRuntimeSummary } from '../types/pipeline.js';
+export declare function toPipelineRuntimeSummary(input: PipelineResult): PipelineRuntimeSummary;

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

@@ -0,0 +1,9 @@
+export function toPipelineRuntimeSummary(input) {
+    return {
+        totalFileCount: input.totalFileCount,
+        communityResult: input.communityResult,
+        processResult: input.processResult,
+        unityResult: input.unityResult,
+        scopeDiagnostics: input.scopeDiagnostics,
+    };
+}

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.d.ts

@@ -10,5 +10,6 @@ export interface AnalyzeOptions {
     repoAlias?: string;
     scopeManifest?: string;
     scopePrefix?: string[];
+    reuseOptions?: boolean;
 }
 export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;

package/dist/cli/analyze.js

@@ -18,8 +18,11 @@ import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
 import { generateAIContextFiles } from './ai-context.js';
 import fs from 'fs/promises';
 import { registerClaudeHook } from './claude-hooks.js';
-import { normalizeRepoAlias, parseExtensionList, resolveAnalyzeScopeRules } from './analyze-options.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;
 }
@@ -62,22 +69,6 @@ export const analyzeCommand = async (inputPath, options) => {
     if (ensureHeap())
         return;
     console.log('\n  GitNexus Analyzer\n');
-    let includeExtensions = [];
-    let scopeRules = [];
-    let repoAlias;
-    try {
-        includeExtensions = parseExtensionList(options?.extensions);
-        scopeRules = await resolveAnalyzeScopeRules({
-            scopeManifest: options?.scopeManifest,
-            scopePrefix: options?.scopePrefix,
-        });
-        repoAlias = normalizeRepoAlias(options?.repoAlias);
-    }
-    catch (error) {
-        console.log(`  ${error?.message || String(error)}\n`);
-        process.exitCode = 1;
-        return;
-    }
     let repoPath;
     if (inputPath) {
         repoPath = path.resolve(inputPath);
@@ -99,15 +90,52 @@ export const analyzeCommand = async (inputPath, options) => {
     const { storagePath, kuzuPath } = getStoragePaths(repoPath);
     const currentCommit = getCurrentCommit(repoPath);
     const existingMeta = await loadMeta(storagePath);
-    if (existingMeta &&
-        !options?.force &&
-        existingMeta.lastCommit === currentCommit &&
-        includeExtensions.length === 0 &&
-        scopeRules.length === 0 &&
-        !repoAlias) {
-        console.log('  Already up to date\n');
+    let includeExtensions = [];
+    let scopeRules = [];
+    let repoAlias;
+    let embeddingsEnabled = false;
+    try {
+        const effectiveOptions = await resolveEffectiveAnalyzeOptions({
+            extensions: options?.extensions,
+            scopeManifest: options?.scopeManifest,
+            scopePrefix: options?.scopePrefix,
+            repoAlias: options?.repoAlias,
+            embeddings: options?.embeddings,
+            reuseOptions: options?.reuseOptions,
+        }, existingMeta?.analyzeOptions);
+        includeExtensions = effectiveOptions.includeExtensions;
+        scopeRules = effectiveOptions.scopeRules;
+        repoAlias = effectiveOptions.repoAlias;
+        embeddingsEnabled = effectiveOptions.embeddings;
+    }
+    catch (error) {
+        console.log(`  ${error?.message || String(error)}\n`);
+        process.exitCode = 1;
         return;
     }
+    if (existingMeta && !options?.force && existingMeta.lastCommit === currentCommit) {
+        const hasScopePrefixInput = Array.isArray(options?.scopePrefix)
+            ? options.scopePrefix.length > 0
+            : Boolean(options?.scopePrefix);
+        const hasCliOverrides = options?.extensions !== undefined ||
+            Boolean(options?.scopeManifest) ||
+            hasScopePrefixInput ||
+            options?.repoAlias !== undefined ||
+            options?.embeddings !== undefined ||
+            options?.reuseOptions === false;
+        if (!hasCliOverrides) {
+            console.log('  Already up to date\n');
+            return;
+        }
+        if (options?.reuseOptions !== false &&
+            includeExtensions.length === 0 &&
+            scopeRules.length === 0 &&
+            !repoAlias &&
+            !embeddingsEnabled) {
+            console.log('  Already up to date\n');
+            return;
+        }
+    }
     // Single progress bar for entire pipeline
     const bar = new cliProgress.SingleBar({
         format: '  {bar} {percentage}% | {phase}',
@@ -128,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);
@@ -171,7 +203,7 @@ export const analyzeCommand = async (inputPath, options) => {
     // ── Cache embeddings from existing index before rebuild ────────────
     let cachedEmbeddingNodeIds = new Set();
     let cachedEmbeddings = [];
-    if (options?.embeddings && existingMeta && !options?.force) {
+    if (embeddingsEnabled && existingMeta && !options?.force) {
         try {
             updateBar(0, 'Caching embeddings...');
             await initKuzu(kuzuPath);
@@ -225,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%) ─────────────────────────────────────────
@@ -259,7 +293,7 @@ export const analyzeCommand = async (inputPath, options) => {
     let embeddingTime = '0.0';
     let embeddingSkipped = true;
     let embeddingSkipReason = 'off (use --embeddings to enable)';
-    if (options?.embeddings) {
+    if (embeddingsEnabled) {
         if (stats.nodes > EMBEDDING_NODE_LIMIT) {
             embeddingSkipReason = `skipped (${stats.nodes.toLocaleString()} nodes > ${EMBEDDING_NODE_LIMIT.toLocaleString()} limit)`;
         }
@@ -284,39 +318,48 @@ export const analyzeCommand = async (inputPath, options) => {
         repoPath,
         lastCommit: currentCommit,
         indexedAt: new Date().toISOString(),
+        analyzeOptions: {
+            includeExtensions,
+            scopeRules,
+            repoAlias,
+            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.
@@ -334,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');
@@ -351,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(', ')}`);
@@ -389,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.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);
@@ -69,6 +73,7 @@ program
     .command('analyze [path]')
     .description('Index a repository (full analysis)')
     .option('-f, --force', 'Force full re-index even if up to date')
+    .option('--no-reuse-options', 'Do not reuse stored analyze options from previous index')
     .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
     .option('--extensions <list>', 'Comma-separated file extensions to include (e.g. .cs,.ts)')
     .option('--repo-alias <name>', 'Override indexed repository name with a stable alias')
@@ -124,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]')
@@ -133,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/repo-manager-alias.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { readRegistry, registerRepo } from '../storage/repo-manager.js';
+import { loadMeta, readRegistry, registerRepo, saveMeta } from '../storage/repo-manager.js';
 function makeMeta(repoPath, lastCommit) {
     return {
         repoPath,
@@ -38,3 +38,26 @@ test('registerRepo stores alias and rejects collisions on different paths', asyn
         }
     }
 });
+test('saveMeta/loadMeta persists analyzeOptions for future re-index reuse', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-meta-'));
+    const storagePath = path.join(tmpDir, '.gitnexus');
+    await saveMeta(storagePath, {
+        repoPath: tmpDir,
+        lastCommit: 'abc1234',
+        indexedAt: '2026-03-12T00:00:00.000Z',
+        analyzeOptions: {
+            includeExtensions: ['.cs'],
+            scopeRules: ['Assets/NEON/Code'],
+            repoAlias: 'neonspark-v1-subset',
+            embeddings: true,
+        },
+        stats: { files: 1, nodes: 2, edges: 3 },
+    });
+    const meta = await loadMeta(storagePath);
+    assert.deepEqual(meta?.analyzeOptions, {
+        includeExtensions: ['.cs'],
+        scopeRules: ['Assets/NEON/Code'],
+        repoAlias: 'neonspark-v1-subset',
+        embeddings: true,
+    });
+});

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-'));