@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

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/scope-manifest-config.d.ts

@@ -0,0 +1,9 @@
+export interface ScopeManifestConfig {
+    scopeRules: string[];
+    directives: {
+        extensions?: string;
+        repoAlias?: string;
+        embeddings?: string;
+    };
+}
+export declare function parseScopeManifestConfig(raw: string): ScopeManifestConfig;

package/dist/cli/scope-manifest-config.js

@@ -0,0 +1,37 @@
+import { normalizeScopeRules, normalizeScopedPath } from '../core/ingestion/scope-filter.js';
+const SUPPORTED_DIRECTIVES = new Set(['extensions', 'repoalias', 'embeddings']);
+export function parseScopeManifestConfig(raw) {
+    const scopeRules = [];
+    const directives = {};
+    const lines = raw.split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        if (trimmed.startsWith('@')) {
+            const separatorIndex = trimmed.indexOf('=');
+            if (separatorIndex <= 1) {
+                throw new Error(`Invalid manifest directive at line ${index + 1}: ${trimmed}`);
+            }
+            const key = trimmed.slice(1, separatorIndex).trim().toLowerCase();
+            const value = trimmed.slice(separatorIndex + 1).trim();
+            if (!SUPPORTED_DIRECTIVES.has(key)) {
+                throw new Error(`Unknown manifest directive: @${key}`);
+            }
+            if (key === 'extensions')
+                directives.extensions = value;
+            else if (key === 'repoalias')
+                directives.repoAlias = value;
+            else if (key === 'embeddings')
+                directives.embeddings = value;
+            continue;
+        }
+        const normalized = normalizeScopedPath(trimmed);
+        if (normalized)
+            scopeRules.push(normalized);
+    }
+    return {
+        scopeRules: normalizeScopeRules(scopeRules),
+        directives,
+    };
+}

package/dist/cli/setup.js

@@ -14,7 +14,7 @@ import { fileURLToPath } from 'url';
 import { getGlobalDir, loadCLIConfig, saveCLIConfig } from '../storage/repo-manager.js';
 import { getGitRoot } from '../storage/git.js';
 import { glob } from 'glob';
-import { buildNpxCommand, resolveCliSpec } from '../config/cli-spec.js';
+import { resolveCliSpec } from '../config/cli-spec.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const execFileAsync = promisify(execFile);
@@ -47,25 +47,24 @@ async function installLegacyCursorSkills(result) {
         result.errors.push(`Cursor skills: ${err.message}`);
     }
 }
-const DEFAULT_MCP_PACKAGE_SPEC = resolveCliSpec().packageSpec;
 /**
  * The MCP server entry for all editors.
- * On Windows, npx must be invoked via cmd /c since it's a .cmd script.
+ * Uses the locally installed gitnexus binary.
  */
-function getMcpEntry(mcpPackageSpec) {
+function getMcpEntry() {
     if (process.platform === 'win32') {
         return {
             command: 'cmd',
-            args: ['/c', 'npx', '-y', mcpPackageSpec, 'mcp'],
+            args: ['/c', 'gitnexus', 'mcp'],
         };
     }
     return {
-        command: 'npx',
-        args: ['-y', mcpPackageSpec, 'mcp'],
+        command: 'gitnexus',
+        args: ['mcp'],
     };
 }
-function getOpenCodeMcpEntry(mcpPackageSpec) {
-    const entry = getMcpEntry(mcpPackageSpec);
+function getOpenCodeMcpEntry() {
+    const entry = getMcpEntry();
     return {
         type: 'local',
         command: [entry.command, ...entry.args],
@@ -75,28 +74,28 @@ function getOpenCodeMcpEntry(mcpPackageSpec) {
  * Merge gitnexus entry into an existing MCP config JSON object.
  * Returns the updated config.
  */
-function mergeMcpConfig(existing, mcpPackageSpec) {
+function mergeMcpConfig(existing) {
     if (!existing || typeof existing !== 'object') {
         existing = {};
     }
     if (!existing.mcpServers || typeof existing.mcpServers !== 'object') {
         existing.mcpServers = {};
     }
-    existing.mcpServers.gitnexus = getMcpEntry(mcpPackageSpec);
+    existing.mcpServers.gitnexus = getMcpEntry();
     return existing;
 }
 /**
  * Merge gitnexus entry into an OpenCode config JSON object.
  * Returns the updated config.
  */
-function mergeOpenCodeConfig(existing, mcpPackageSpec) {
+function mergeOpenCodeConfig(existing) {
     if (!existing || typeof existing !== 'object') {
         existing = {};
     }
     if (!existing.mcp || typeof existing.mcp !== 'object') {
         existing.mcp = {};
     }
-    existing.mcp.gitnexus = getOpenCodeMcpEntry(mcpPackageSpec);
+    existing.mcp.gitnexus = getOpenCodeMcpEntry();
     return existing;
 }
 /**
@@ -148,16 +147,16 @@ async function fileExists(filePath) {
 function toTomlString(value) {
     return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
 }
-function buildCodexMcpTable(mcpPackageSpec) {
-    const entry = getMcpEntry(mcpPackageSpec);
+function buildCodexMcpTable() {
+    const entry = getMcpEntry();
     return [
         '[mcp_servers.gitnexus]',
         `command = ${toTomlString(entry.command)}`,
         `args = [${entry.args.map(toTomlString).join(', ')}]`,
     ].join('\n');
 }
-function mergeCodexConfig(existingRaw, mcpPackageSpec) {
-    const table = buildCodexMcpTable(mcpPackageSpec);
+function mergeCodexConfig(existingRaw) {
+    const table = buildCodexMcpTable();
     const normalized = existingRaw.replace(/\r\n/g, '\n');
     const tablePattern = /^\[mcp_servers\.gitnexus\][\s\S]*?(?=^\[[^\]]+\]|(?![\s\S]))/m;
     if (tablePattern.test(normalized)) {
@@ -179,7 +178,7 @@ async function resolveOpenCodeConfigPath(opencodeDir) {
     return preferredPath;
 }
 // ─── Editor-specific setup ─────────────────────────────────────────
-async function setupCursor(result, mcpPackageSpec) {
+async function setupCursor(result) {
     const cursorDir = path.join(os.homedir(), '.cursor');
     if (!(await dirExists(cursorDir))) {
         result.skipped.push('Cursor (not installed)');
@@ -188,7 +187,7 @@ async function setupCursor(result, mcpPackageSpec) {
     const mcpPath = path.join(cursorDir, 'mcp.json');
     try {
         const existing = await readJsonFile(mcpPath);
-        const updated = mergeMcpConfig(existing, mcpPackageSpec);
+        const updated = mergeMcpConfig(existing);
         await writeJsonFile(mcpPath, updated);
         result.configured.push('Cursor');
     }
@@ -196,7 +195,7 @@ async function setupCursor(result, mcpPackageSpec) {
         result.errors.push(`Cursor: ${err.message}`);
     }
 }
-async function setupClaudeCode(result, mcpPackageSpec) {
+async function setupClaudeCode(result) {
     const claudeDir = path.join(os.homedir(), '.claude');
     const hasClaude = await dirExists(claudeDir);
     if (!hasClaude) {
@@ -207,7 +206,7 @@ async function setupClaudeCode(result, mcpPackageSpec) {
     console.log('');
     console.log('  Claude Code detected. Run this command to add GitNexus MCP:');
     console.log('');
-    console.log(`    claude mcp add gitnexus -- ${buildNpxCommand(mcpPackageSpec, 'mcp')}`);
+    console.log(`    claude mcp add gitnexus -- gitnexus mcp`);
     console.log('');
     result.configured.push('Claude Code (MCP manual step printed)');
 }
@@ -243,7 +242,7 @@ async function installProjectAgentSkills(repoRoot, result) {
  * Install GitNexus hooks to ~/.claude/settings.json for Claude Code.
  * Merges hook config without overwriting existing hooks.
  */
-async function installClaudeCodeHooks(result, mcpPackageSpec) {
+async function installClaudeCodeHooks(result) {
     const claudeDir = path.join(os.homedir(), '.claude');
     if (!(await dirExists(claudeDir)))
         return;
@@ -295,7 +294,7 @@ async function installClaudeCodeHooks(result, mcpPackageSpec) {
         result.errors.push(`Claude Code hooks: ${err.message}`);
     }
 }
-async function setupOpenCode(result, mcpPackageSpec) {
+async function setupOpenCode(result) {
     const opencodeDir = path.join(os.homedir(), '.config', 'opencode');
     if (!(await dirExists(opencodeDir))) {
         result.skipped.push('OpenCode (not installed)');
@@ -304,7 +303,7 @@ async function setupOpenCode(result, mcpPackageSpec) {
     const configPath = await resolveOpenCodeConfigPath(opencodeDir);
     try {
         const existing = await readJsonFile(configPath);
-        const config = mergeOpenCodeConfig(existing, mcpPackageSpec);
+        const config = mergeOpenCodeConfig(existing);
         await writeJsonFile(configPath, config);
         result.configured.push(`OpenCode (${path.basename(configPath)})`);
     }
@@ -312,8 +311,8 @@ async function setupOpenCode(result, mcpPackageSpec) {
         result.errors.push(`OpenCode: ${err.message}`);
     }
 }
-async function setupCodex(result, mcpPackageSpec) {
-    const entry = getMcpEntry(mcpPackageSpec);
+async function setupCodex(result) {
+    const entry = getMcpEntry();
     try {
         await execFileAsync('codex', ['mcp', 'add', 'gitnexus', '--', entry.command, ...entry.args], { timeout: 15000 });
         result.configured.push('Codex');
@@ -326,11 +325,11 @@ async function setupCodex(result, mcpPackageSpec) {
         result.errors.push(`Codex: ${err.message}`);
     }
 }
-async function setupProjectMcp(repoRoot, result, mcpPackageSpec) {
+async function setupProjectMcp(repoRoot, result) {
     const mcpPath = path.join(repoRoot, '.mcp.json');
     try {
         const existing = await readJsonFile(mcpPath);
-        const updated = mergeMcpConfig(existing, mcpPackageSpec);
+        const updated = mergeMcpConfig(existing);
         await writeJsonFile(mcpPath, updated);
         result.configured.push(`Project MCP (${path.relative(repoRoot, mcpPath)})`);
     }
@@ -338,7 +337,7 @@ async function setupProjectMcp(repoRoot, result, mcpPackageSpec) {
         result.errors.push(`Project MCP: ${err.message}`);
     }
 }
-async function setupProjectCodex(repoRoot, result, mcpPackageSpec) {
+async function setupProjectCodex(repoRoot, result) {
     const codexConfigPath = path.join(repoRoot, '.codex', 'config.toml');
     try {
         let existingRaw = '';
@@ -349,7 +348,7 @@ async function setupProjectCodex(repoRoot, result, mcpPackageSpec) {
             if (err?.code !== 'ENOENT')
                 throw err;
         }
-        const merged = mergeCodexConfig(existingRaw, mcpPackageSpec);
+        const merged = mergeCodexConfig(existingRaw);
         await fs.mkdir(path.dirname(codexConfigPath), { recursive: true });
         await fs.writeFile(codexConfigPath, merged, 'utf-8');
         result.configured.push(`Project Codex MCP (${path.relative(repoRoot, codexConfigPath)})`);
@@ -358,11 +357,11 @@ async function setupProjectCodex(repoRoot, result, mcpPackageSpec) {
         result.errors.push(`Project Codex MCP: ${err.message}`);
     }
 }
-async function setupProjectOpenCode(repoRoot, result, mcpPackageSpec) {
+async function setupProjectOpenCode(repoRoot, result) {
     const opencodePath = path.join(repoRoot, 'opencode.json');
     try {
         const existing = await readJsonFile(opencodePath);
-        const merged = mergeOpenCodeConfig(existing, mcpPackageSpec);
+        const merged = mergeOpenCodeConfig(existing);
         await writeJsonFile(opencodePath, merged);
         result.configured.push(`Project OpenCode MCP (${path.relative(repoRoot, opencodePath)})`);
     }
@@ -510,7 +509,7 @@ export const setupCommand = async (options = {}) => {
         explicitVersion: options.cliVersion,
         config: existingConfig,
     });
-    const mcpPackageSpec = resolvedCliSpec.packageSpec || DEFAULT_MCP_PACKAGE_SPEC;
+    const mcpPackageSpec = resolvedCliSpec.packageSpec;
     const result = {
         configured: [],
         skipped: [],
@@ -518,7 +517,7 @@ export const setupCommand = async (options = {}) => {
     };
     if (scope === 'global') {
         if (legacyCursorMode) {
-            await setupCursor(result, mcpPackageSpec);
+            await setupCursor(result);
             await installLegacyCursorSkills(result);
             await saveSetupConfig(scope, mcpPackageSpec, result);
             agent = LEGACY_CURSOR_AGENT;
@@ -526,15 +525,15 @@ export const setupCommand = async (options = {}) => {
         else {
             // Configure only the selected agent MCP
             if (agent === 'claude') {
-                await setupClaudeCode(result, mcpPackageSpec);
+                await setupClaudeCode(result);
                 // Claude-only hooks should only be installed when Claude is selected.
-                await installClaudeCodeHooks(result, mcpPackageSpec);
+                await installClaudeCodeHooks(result);
             }
             else if (agent === 'opencode') {
-                await setupOpenCode(result, mcpPackageSpec);
+                await setupOpenCode(result);
             }
             else if (agent === 'codex') {
-                await setupCodex(result, mcpPackageSpec);
+                await setupCodex(result);
             }
             // Install shared global skills once
             await installGlobalAgentSkills(result);
@@ -549,13 +548,13 @@ export const setupCommand = async (options = {}) => {
             return;
         }
         if (agent === 'claude') {
-            await setupProjectMcp(repoRoot, result, mcpPackageSpec);
+            await setupProjectMcp(repoRoot, result);
         }
         else if (agent === 'codex') {
-            await setupProjectCodex(repoRoot, result, mcpPackageSpec);
+            await setupProjectCodex(repoRoot, result);
         }
         else if (agent === 'opencode') {
-            await setupProjectOpenCode(repoRoot, result, mcpPackageSpec);
+            await setupProjectOpenCode(repoRoot, result);
         }
         await installProjectAgentSkills(repoRoot, result);
         await saveSetupConfig(scope, mcpPackageSpec, result);

package/dist/cli/setup.test.js

@@ -10,9 +10,6 @@ const execFileAsync = promisify(execFile);
 const here = path.dirname(fileURLToPath(import.meta.url));
 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 });
 }
@@ -30,8 +27,8 @@ test('setup without --agent uses legacy Cursor install path', async () => {
         const configPath = path.join(fakeHome, '.gitnexus', 'config.json');
         const cursorMcpRaw = await fs.readFile(cursorMcpPath, 'utf-8');
         const cursorMcp = JSON.parse(cursorMcpRaw);
-        assert.equal(cursorMcp.mcpServers?.gitnexus?.command, 'npx');
-        assert.deepEqual(cursorMcp.mcpServers?.gitnexus?.args, ['-y', expectedMcpPackage, 'mcp']);
+        assert.equal(cursorMcp.mcpServers?.gitnexus?.command, 'gitnexus');
+        assert.deepEqual(cursorMcp.mcpServers?.gitnexus?.args, ['mcp']);
         await fs.access(cursorSkillPath);
         const configRaw = await fs.readFile(configPath, 'utf-8');
         const config = JSON.parse(configRaw);
@@ -142,7 +139,7 @@ process.exit(0);
         const raw = await fs.readFile(outputPath, 'utf-8');
         const parsed = JSON.parse(raw);
         assert.deepEqual(parsed.args.slice(0, 4), ['mcp', 'add', 'gitnexus', '--']);
-        assert.ok(parsed.args.includes(expectedMcpPackage));
+        assert.ok(parsed.args.includes('gitnexus'));
         assert.ok(parsed.args.includes('mcp'));
     }
     finally {
@@ -164,7 +161,7 @@ test('setup configures OpenCode MCP in ~/.config/opencode/opencode.json', async
         const opencodeRaw = await fs.readFile(opencodeConfigPath, 'utf-8');
         const opencodeConfig = JSON.parse(opencodeRaw);
         assert.equal(opencodeConfig.mcp?.gitnexus?.type, 'local');
-        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', expectedMcpPackage, 'mcp']);
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['gitnexus', 'mcp']);
     }
     finally {
         await fs.rm(fakeHome, { recursive: true, force: true });
@@ -186,7 +183,8 @@ test('setup --cli-version pins MCP package spec and persists it in config', asyn
         const configPath = path.join(fakeHome, '.gitnexus', 'config.json');
         const savedConfigRaw = await fs.readFile(configPath, 'utf-8');
         const savedConfig = JSON.parse(savedConfigRaw);
-        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', '@veewo/gitnexus@1.4.7-rc', 'mcp']);
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['gitnexus', 'mcp']);
+        // Version is persisted to config, not MCP entry:
         assert.equal(savedConfig.cliPackageSpec, '@veewo/gitnexus@1.4.7-rc');
         assert.equal(savedConfig.cliVersion, '1.4.7-rc');
     }
@@ -211,7 +209,7 @@ test('setup keeps using legacy ~/.config/opencode/config.json when it already ex
         const legacyConfig = JSON.parse(legacyRaw);
         assert.equal(legacyConfig.existing, true);
         assert.equal(legacyConfig.mcp?.gitnexus?.type, 'local');
-        assert.deepEqual(legacyConfig.mcp?.gitnexus?.command, ['npx', '-y', expectedMcpPackage, 'mcp']);
+        assert.deepEqual(legacyConfig.mcp?.gitnexus?.command, ['gitnexus', 'mcp']);
         await assert.rejects(fs.access(preferredConfigPath));
     }
     finally {
@@ -254,7 +252,8 @@ test('setup --scope project --agent claude writes only .mcp.json', async () => {
         const opencodeConfigPath = path.join(fakeRepo, 'opencode.json');
         const projectMcpRaw = await fs.readFile(projectMcpPath, 'utf-8');
         const projectMcp = JSON.parse(projectMcpRaw);
-        assert.equal(projectMcp.mcpServers?.gitnexus?.command, 'npx');
+        assert.equal(projectMcp.mcpServers?.gitnexus?.command, 'gitnexus');
+        assert.deepEqual(projectMcp.mcpServers?.gitnexus?.args, ['mcp']);
         await assert.rejects(fs.access(codexConfigPath));
         await assert.rejects(fs.access(opencodeConfigPath));
     }
@@ -278,7 +277,8 @@ test('setup --scope project --agent codex writes only .codex/config.toml', async
         const opencodeConfigPath = path.join(fakeRepo, 'opencode.json');
         const codexConfigRaw = await fs.readFile(codexConfigPath, 'utf-8');
         assert.match(codexConfigRaw, /\[mcp_servers\.gitnexus\]/);
-        assert.match(codexConfigRaw, /command = "npx"/);
+        assert.match(codexConfigRaw, /command = "gitnexus"/);
+        assert.match(codexConfigRaw, /args = \["mcp"\]/);
         await assert.rejects(fs.access(projectMcpPath));
         await assert.rejects(fs.access(opencodeConfigPath));
     }
@@ -316,7 +316,7 @@ test('setup --scope project --agent codex replaces existing gitnexus table witho
         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.match(gitnexusTable, /command = "gitnexus"/);
         assert.doesNotMatch(gitnexusTable, /oldpkg@latest/);
         assert.match(codexConfigRaw, /^\[profiles\.default\]$/m);
     }
@@ -346,7 +346,7 @@ test('setup --scope project --agent codex is idempotent across repeated runs', a
         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.match(gitnexusTable, /command = "gitnexus"/);
     }
     finally {
         await fs.rm(fakeHome, { recursive: true, force: true });
@@ -374,7 +374,7 @@ test('setup --scope project --agent opencode writes only opencode.json', async (
         const configRaw = await fs.readFile(configPath, 'utf-8');
         const config = JSON.parse(configRaw);
         assert.equal(opencodeConfig.mcp?.gitnexus?.type, 'local');
-        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['npx', '-y', expectedMcpPackage, 'mcp']);
+        assert.deepEqual(opencodeConfig.mcp?.gitnexus?.command, ['gitnexus', 'mcp']);
         await assert.rejects(fs.access(projectMcpPath));
         await assert.rejects(fs.access(codexConfigPath));
         await fs.access(localSkillPath);

package/dist/cli/sync-manifest.d.ts

@@ -0,0 +1,27 @@
+export interface SyncManifestScopeOptions {
+    scopeManifest?: string;
+    scopePrefix?: string[] | string;
+}
+export type SyncManifestPolicy = 'ask' | 'update' | 'keep' | 'error';
+export interface SyncManifestDiffEntry {
+    directive: 'extensions' | 'repoAlias' | 'embeddings';
+    manifestValue?: string;
+    cliValue: string;
+}
+export interface EnforceSyncManifestConsistencyInput {
+    manifestPath?: string;
+    extensions?: string;
+    repoAlias?: string;
+    embeddings?: boolean;
+    policy?: SyncManifestPolicy;
+    stdinIsTTY?: boolean;
+    prompt?: (message: string) => Promise<'update' | 'keep'>;
+}
+export interface EnforceSyncManifestConsistencyResult {
+    decision: 'none' | 'update' | 'keep';
+    diff: SyncManifestDiffEntry[];
+}
+export declare function resolveDefaultSyncManifestPath(repoPath: string): string;
+export declare function shouldAutoUseSyncManifest(options?: SyncManifestScopeOptions): boolean;
+export declare function resolveScopeManifestForAnalyze(repoPath: string, options?: SyncManifestScopeOptions, pathExists?: (candidatePath: string) => Promise<boolean>): Promise<string | undefined>;
+export declare function enforceSyncManifestConsistency(input: EnforceSyncManifestConsistencyInput): Promise<EnforceSyncManifestConsistencyResult>;