genexus-mcp 3.6.1 → 3.7.1

package/cli/lib/config.js

@@ -33,6 +33,7 @@ function generateNeutralConfig(gxPath, { workerPath, gatewayMode = 'stdio-isolat
         Server: {
             HttpPort: 0,
             McpStdio: true,
+            WorkerSharingMode: 'isolated',
             SessionIdleTimeoutMinutes: 10,
             WorkerIdleTimeoutMinutes: 5,
             EmitStructuredContent: false,
@@ -70,6 +71,10 @@ function getToolDefinitionsPath() {
         // 3. Fallback alongside the CLI itself (defensive — for unusual layouts).
         path.join(__dirname, '..', '..', 'publish', 'tool_definitions.json')
     ];
+    // An explicit gateway override is usually a fixed-path or checkout install.
+    // Do not hide a missing sibling artifact with this source tree's copy: the
+    // Gateway loads the file next to its own executable at runtime.
+    if (process.env.GENEXUS_MCP_GATEWAY_EXE) return candidates[0];
     for (const candidate of candidates) {
         if (fs.existsSync(candidate)) return candidate;
     }
@@ -107,14 +112,14 @@ function getGeneXusVersionCatalog() {
         legacyMajors: [
             { major: '10.3', displayName: 'GeneXus Evolution 3', defaultInstallPath: 'C:\\Program Files (x86)\\GeneXus\\GeneXusXEv3' },
             { major: '9', displayName: 'GeneXus 9.0', defaultInstallPath: 'C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 9.0' },
-            { major: '8', displayName: 'GeneXus 8.0', defaultInstallPath: 'C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 8.0' }
+            { major: '8', displayName: 'GeneXus 8.0', defaultInstallPath: 'C:\\Program Files (x86)\\ARTech\\GeneXus\\gxw80' }
         ],
         source: 'built-in-fallback'
     };
 }
 
 function hasGeneXusExecutable(gxPath) {
-    return Boolean(gxPath) && ['genexus.exe', 'gx.exe']
+    return Boolean(gxPath) && ['genexus.exe', 'gx.exe', 'gxw32.exe']
         .some((name) => fs.existsSync(path.join(gxPath, name)));
 }
 
@@ -165,6 +170,24 @@ function discoverGeneXusFromRegistry(preferredMajor = null) {
                     } catch {
                     }
                 }
+                // Classic ARTech installers store GX8/GX9 under Setup\\<version>
+                // and expose the actual IDE root in the Install value rather
+                // than the modern GeneXus <major>\\InstallationDirectory key.
+                for (const setupVersion of (entry.legacySetupVersions || [])) {
+                    const key = `${hive}\\\\${setupVersion}`;
+                    try {
+                        const out = execFileSync('reg.exe', ['query', key, '/v', 'Install'], {
+                            encoding: 'utf8',
+                            stdio: ['ignore', 'pipe', 'ignore'],
+                            windowsHide: true,
+                            timeout: 3000
+                        });
+                        const installLine = out.split(String.fromCharCode(10)).map((line) => line.trim()).find((line) => /^Install\s+REG_SZ\s+/i.test(line));
+                        const candidate = installLine ? installLine.replace(/^Install\s+REG_SZ\s+/i, '').trim() : null;
+                        if (candidate && hasGeneXusExecutable(candidate) && matchesPreferredGeneXusMajor(candidate, preferredMajor)) return candidate;
+                    } catch {
+                    }
+                }
                 for (const legacyVersion of (entry.legacyRegistryVersions || [])) {
                     const key = `${hive}\\GeneXus\\${legacyVersion}`;
                     try {
@@ -259,7 +282,7 @@ function discoverGeneXusFromPath(preferredMajor = null) {
     if (process.platform !== 'win32') return null;
     try {
         const { execFileSync } = require('child_process');
-        for (const executable of ['genexus.exe', 'gx.exe']) {
+        for (const executable of ['genexus.exe', 'gx.exe', 'gxw32.exe']) {
             let out;
             try {
                 out = execFileSync('where.exe', [executable], {
@@ -361,7 +384,9 @@ function discoverKnowledgeBases(cwd, { maxResults = 25, scanDepth = 2 } = {}) {
 function directoryLooksLikeKnowledgeBase(dir) {
     try {
         const files = fs.readdirSync(dir);
-        return files.some((f) => f.toLowerCase().endsWith('.gxw') || f.toLowerCase() === 'knowledgebase.connection');
+        if (files.some((f) => f.toLowerCase().endsWith('.gxw') || f.toLowerCase() === 'knowledgebase.connection')) return true;
+        const classicMarkers = new Set(['data001', 'gxspc001', 'kbdata', 'attribut.dat', 'att.xpw', 'objects.dat', 'objects.idx']);
+        return files.filter((f) => classicMarkers.has(f.toLowerCase())).length >= 2;
     } catch {
         return false;
     }
@@ -603,8 +628,11 @@ function migrateLegacyConfig(sourcePath, targetPath, { rejectNonMigratable = fal
 
 function resolveConfigPathNoMutate(cwd) {
     const cwdConfigPath = path.join(cwd, 'config.json');
-    if (process.env.GX_CONFIG_PATH && fs.existsSync(process.env.GX_CONFIG_PATH)) {
-        return process.env.GX_CONFIG_PATH;
+    // Match the Gateway: an explicit GX_CONFIG_PATH is authoritative even when
+    // the file is missing, so diagnostics do not silently inspect an unrelated
+    // cwd config while the runtime fails on the explicit path.
+    if (process.env.GX_CONFIG_PATH) {
+        return path.resolve(process.env.GX_CONFIG_PATH);
     }
     if (fs.existsSync(cwdConfigPath)) {
         return cwdConfigPath;
@@ -1927,6 +1955,9 @@ function readGeneXusInstallationIdentity(gxPath, options = {}) {
     if (!executableVersion) {
         executableVersion = readExecutableVersion(path.join(gxPath, 'gx.exe'));
     }
+    if (!executableVersion) {
+        executableVersion = readExecutableVersion(path.join(gxPath, 'gxw32.exe'));
+    }
     if (executableVersion) {
         return {
             version: executableVersion,
@@ -2013,6 +2044,7 @@ function readGeneXusKbIdentity(kbPath) {
 
     let gxwFiles;
     let gxiFiles = [];
+    let classicMarkerCount = 0;
     try {
         const allFiles = fs.readdirSync(kbPath);
         gxwFiles = allFiles
@@ -2021,6 +2053,8 @@ function readGeneXusKbIdentity(kbPath) {
         gxiFiles = allFiles
             .filter((fileName) => fileName.toLowerCase().endsWith('.gxi'))
             .map((fileName) => path.join(kbPath, fileName));
+        const classicMarkers = new Set(['data001', 'gxspc001', 'kbdata', 'attribut.dat', 'att.xpw', 'objects.dat', 'objects.idx']);
+        classicMarkerCount = allFiles.filter((fileName) => classicMarkers.has(fileName.toLowerCase())).length;
     } catch {
         return { version: null, major: null, source: 'unavailable', reason: 'unreadable-kb-path' };
     }
@@ -2028,6 +2062,9 @@ function readGeneXusKbIdentity(kbPath) {
         if (gxiFiles.length > 0) {
             return { version: '9.0', major: '9', source: 'gxi-classic', reason: null };
         }
+        if (classicMarkerCount >= 2) {
+            return { version: null, major: null, source: 'classic-dat', reason: 'classic-generation-requires-provider' };
+        }
         return { version: null, major: null, source: 'unavailable', reason: 'no-gxw' };
     }
     if (gxwFiles.length > 1) return { version: null, major: null, source: 'unavailable', reason: 'multiple-gxw' };
@@ -2049,34 +2086,65 @@ function readGeneXusKbIdentity(kbPath) {
     }
 }
 
-function compareGeneXusKbAndInstallation(kbPath, gxPath) {
+function compareGeneXusKbAndInstallation(kbPath, gxPath, options = {}) {
     const kb = readGeneXusKbIdentity(kbPath);
-    const gx = readGeneXusInstallationIdentity(gxPath);
+    const gx = readGeneXusInstallationIdentity(gxPath, options);
     let status = 'unresolved';
-    if (kb.major && gx.major) status = kb.major === gx.major ? 'match' : 'mismatch';
+    // A classic .gxi is shared by the GX8/GX9 family and does not carry a
+    // reliable generation marker. Do not turn the historical default of 9
+    // into a false GX8-vs-GX9 mismatch; the provider open is the authority.
+    if ((kb.source === 'gxi-classic' || kb.source === 'classic-dat') && (gx.major === '8' || gx.major === '9')) {
+        status = 'unresolved';
+    } else if (kb.major && gx.major) {
+        status = kb.major === gx.major ? 'match' : 'mismatch';
+    }
     return { status, kb, gx };
 }
 
 function normalizeKbCatalog(raw) {
+    const normalized = {};
+    const entries = {};
+    const add = (name, value) => {
+        if (typeof name !== 'string' || !name) return;
+        if (typeof value === 'string' && value) {
+            normalized[name] = value;
+            return;
+        }
+        if (!value || typeof value !== 'object') return;
+        const kbPath = typeof value.path === 'string' ? value.path : value.Path;
+        if (typeof kbPath !== 'string' || !kbPath) return;
+        normalized[name] = kbPath;
+        const metadata = { alias: name, path: kbPath };
+        let hasLegacyMetadata = false;
+        for (const [source, target] of [['driver', 'driver'], ['Driver', 'driver'], ['installationPath', 'installationPath'], ['InstallationPath', 'installationPath'], ['major', 'major'], ['Major', 'major']]) {
+            if (typeof value[source] === 'string' && value[source]) {
+                metadata[target] = value[source];
+                hasLegacyMetadata = true;
+            }
+        }
+        if (hasLegacyMetadata) entries[name] = metadata;
+    };
+
     if (Array.isArray(raw)) {
-        const normalized = {};
         for (const entry of raw) {
             if (!entry || typeof entry !== 'object') continue;
             const name = typeof entry.alias === 'string' ? entry.alias : entry.Alias;
-            const kbPath = typeof entry.path === 'string' ? entry.path : entry.Path;
-            if (typeof name === 'string' && name && typeof kbPath === 'string' && kbPath) {
-                normalized[name] = kbPath;
-            }
+            add(name, entry);
         }
+        Object.defineProperty(normalized, '__entries', { value: entries, enumerable: false, writable: true });
         return normalized;
     }
 
-    return raw && typeof raw === 'object' ? raw : {};
+    if (raw && typeof raw === 'object') {
+        for (const [name, value] of Object.entries(raw)) add(name, value);
+    }
+    Object.defineProperty(normalized, '__entries', { value: entries, enumerable: false, writable: true });
+    return normalized;
 }
 
-function readKbCatalog(configPath) {
-    if (!configPath) return { kbs: {}, activeKb: null, kbPath: null };
-    const cfg = readJsonFileSafe(configPath);
+function readKbCatalog(configPath, configOverride = undefined) {
+    if (!configPath && configOverride === undefined) return { kbs: {}, activeKb: null, kbPath: null };
+    const cfg = configOverride === undefined ? readJsonFileSafe(configPath) : configOverride;
     if (!cfg) return { kbs: {}, activeKb: null, kbPath: null };
     const env = cfg.Environment || {};
     const activeKb = typeof env.ActiveKb === 'string' && env.ActiveKb
@@ -2092,7 +2160,19 @@ function readKbCatalog(configPath) {
 function writeKbCatalog(configPath, { kbs, activeKb, kbPath }) {
     const cfg = readJsonFileSafe(configPath) || {};
     cfg.Environment = cfg.Environment || {};
-    cfg.Environment.KBs = kbs;
+    const serializedKbs = {};
+    for (const [name, kbPathValue] of Object.entries(kbs || {})) {
+        const metadata = kbs.__entries && kbs.__entries[name];
+        serializedKbs[name] = metadata
+            ? {
+                Path: kbPathValue,
+                ...(metadata.driver ? { Driver: metadata.driver } : {}),
+                ...(metadata.installationPath ? { InstallationPath: metadata.installationPath } : {}),
+                ...(metadata.major ? { Major: metadata.major } : {})
+            }
+            : kbPathValue;
+    }
+    cfg.Environment.KBs = serializedKbs;
     if (activeKb) {
         cfg.Environment.ActiveKb = activeKb;
         cfg.Environment.DefaultKb = activeKb;

package/cli/run.test.js

@@ -1,6 +1,6 @@
 const test = require('node:test');
 const assert = require('node:assert/strict');
-const { spawnSync } = require('node:child_process');
+const { spawn, spawnSync } = require('node:child_process');
 const { Readable, Writable } = require('node:stream');
 const path = require('node:path');
 const os = require('node:os');
@@ -22,8 +22,11 @@ const {
     getGeneXusCatalogEntries,
     discoverGeneXusInstallation,
     readGeneXusInstallationIdentity,
+    directoryLooksLikeKnowledgeBase,
     readGeneXusKbIdentity,
     compareGeneXusKbAndInstallation,
+    readKbCatalog,
+    switchActiveKb,
     patchClientConfig
 } = require('./lib/config');
 const { handleInit, resolveMcpSmokeTarget } = require('./commands/axi');
@@ -65,23 +68,29 @@ function removeTempPath(targetPath, options = {}, deps = {}) {
     }
 }
 
-// Issue #211 teardown safety net: a probe child that outlives its terminate
+// Issue #211/#248 teardown safety net: a probe child that outlives its terminate
 // signal keeps the stubbed GxMcp.Gateway.exe image mapped, which turns the
 // cleanup rmSync into EPERM. Terminate only processes started from this test's
 // own temp dir — never a machine-wide GxMcp.Gateway.exe sweep, which would hit
 // other checkouts and the operator's own gateways.
 function stopLingeringGatewayStubs(dirPath, deps = {}) {
     const platform = deps.platform || process.platform;
-    const run = deps.run || ((command, args) => spawnSync(command, args, { encoding: 'utf8', windowsHide: true }));
+    const run = deps.run || ((command, args) => spawnSync(command, args, {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 20000
+    }));
     if (platform !== 'win32') return false;
 
-    const escapedDir = String(dirPath).replace(/'/g, "''");
-    const script = [
-        "$ErrorActionPreference = 'SilentlyContinue'",
+    let canonicalDir = String(dirPath);
+    try { canonicalDir = fs.realpathSync.native(canonicalDir); } catch { }
+    const escapedDir = canonicalDir.replace(/'/g, "''");
+    const processPipeline = [
         `Get-CimInstance Win32_Process -Filter "Name = 'GxMcp.Gateway.exe'"`,
-        `Where-Object { $_.ExecutablePath -and ([System.IO.Path]::GetDirectoryName($_.ExecutablePath) -eq '${escapedDir}') }`,
-        'ForEach-Object { Stop-Process -Id $_.ProcessId -Force }'
+        'Where-Object { if (-not $_.ExecutablePath -or -not $targetDirectory) { return $false }; $processDirectory = (Get-Item -LiteralPath ([System.IO.Path]::GetDirectoryName($_.ExecutablePath)) -ErrorAction SilentlyContinue).FullName; $processDirectory -and [System.StringComparer]::OrdinalIgnoreCase.Equals($processDirectory, $targetDirectory) }',
+        'ForEach-Object { $processId = $_.ProcessId; Stop-Process -Id $processId -Force; try { Wait-Process -Id $processId -Timeout 5 -ErrorAction SilentlyContinue } catch { } }'
     ].join(' | ');
+    const script = `$ErrorActionPreference = 'SilentlyContinue'; $targetDirectory = (Get-Item -LiteralPath '${escapedDir}' -ErrorAction SilentlyContinue).FullName; ${processPipeline}`;
     try {
         run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script]);
     } catch { }
@@ -89,9 +98,16 @@ function stopLingeringGatewayStubs(dirPath, deps = {}) {
 }
 
 test.after(() => {
-    removeTempPath(testGxPath, { recursive: true, force: true });
     stopLingeringGatewayStubs(testGatewayDir);
-    removeTempPath(testGatewayDir, { recursive: true, force: true });
+    let firstError = null;
+    for (const directory of [testGxPath, testGatewayDir]) {
+        try {
+            removeTempPath(directory, { recursive: true, force: true });
+        } catch (error) {
+            if (!firstError) firstError = error;
+        }
+    }
+    if (firstError) throw firstError;
 });
 
 function runCli(args, opts = {}) {
@@ -173,11 +189,66 @@ test('lingering gateway stub cleanup stays scoped to the test temp dir', () => {
     assert.equal(windowsCalls[0][0], 'powershell.exe');
 
     const script = windowsCalls[0][1].join(' ');
+    assert.ok(script.includes("'SilentlyContinue'; $targetDirectory") && script.includes('; Get-CimInstance'), 'must set PowerShell error handling before starting the process pipeline');
     assert.ok(script.includes("GxMcp.Gateway.exe"), 'must target the stubbed gateway image');
     assert.ok(script.includes('C:\\Temp\\genexus-mcp-test-1'), 'must be scoped to the test temp dir');
+    assert.ok(script.includes('Wait-Process -Id $processId -Timeout 5'), 'must wait for targeted processes to exit before removing the temp directory');
     assert.ok(!script.includes('Stop-Process -Name'), 'must never terminate by process name machine-wide');
 });
 
+test('lingering gateway stub cleanup escapes PowerShell path literals', () => {
+    const calls = [];
+    stopLingeringGatewayStubs("C:\\Temp\\o'brien", {
+        platform: 'win32',
+        run: (_command, args) => calls.push(args.join(' '))
+    });
+    assert.equal(calls.length, 1);
+    assert.ok(calls[0].includes("C:\\Temp\\o''brien"), 'single quotes must be doubled inside the PowerShell literal');
+});
+
+function waitForChildExit(child, timeoutMs = 10000) {
+    return new Promise((resolve) => {
+        if (!child || child.exitCode !== null || child.signalCode !== null) {
+            resolve(true);
+            return;
+        }
+        const timer = setTimeout(() => resolve(false), timeoutMs);
+        child.once('exit', () => {
+            clearTimeout(timer);
+            resolve(true);
+        });
+    });
+}
+
+test('windows cleanup stops a real scoped gateway stub before removal', { skip: process.platform !== 'win32' }, async () => {
+    const probeDir = path.join(testGatewayDir, 'wait-probe');
+    const probePath = path.join(probeDir, 'GxMcp.Gateway.exe');
+    fs.mkdirSync(probeDir, { recursive: true });
+    fs.copyFileSync(testGatewayPath, probePath);
+    const child = spawn(probePath, ['/c', 'ping 127.0.0.1 -n 5 > nul'], {
+        stdio: 'ignore',
+        windowsHide: true
+    });
+    await new Promise((resolve, reject) => {
+        child.once('spawn', resolve);
+        child.once('error', reject);
+    });
+
+    stopLingeringGatewayStubs(probeDir);
+    let removeError = null;
+    try {
+        fs.rmSync(probeDir, { recursive: true, force: true });
+    } catch (error) {
+        removeError = error;
+    }
+    const exited = await waitForChildExit(child);
+    if (!exited) {
+        try { child.kill(); } catch { }
+    }
+    assert.equal(removeError, null, `the scoped cleanup must release the gateway image before removal: ${removeError?.message || removeError}`);
+    assert.equal(exited, true, 'the scoped cleanup must terminate the gateway stub before directory removal');
+});
+
 test('a failed stub cleanup does not mask the test result', () => {
     const ran = stopLingeringGatewayStubs('C:\\Temp\\genexus-mcp-test-1', {
         platform: 'win32',
@@ -571,6 +642,23 @@ test('classic GeneXus installation identity reads gx.exe metadata', () => {
     }
 });
 
+test('GeneXus 8 installation identity reads gxw32.exe metadata', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-gx8-version-'));
+    try {
+        fs.writeFileSync(path.join(tempRoot, 'gxw32.exe'), 'not-a-real-executable');
+        const identity = readGeneXusInstallationIdentity(tempRoot, {
+            readExecutableVersion: (exePath) => exePath.endsWith('gxw32.exe') ? '8.0.0.632' : null
+        });
+        assert.deepEqual(identity, {
+            version: '8.0.0.632',
+            major: '8',
+            source: 'executable-metadata'
+        });
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
 test('classic GeneXus installation discovery accepts GENEXUS_HOME with gx.exe', () => {
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-classic-home-'));
     const previousHome = process.env.GENEXUS_HOME;
@@ -692,6 +780,72 @@ test('KB identity reads GeneXus 9.0 classic major from gxi when gxw is absent',
     }
 });
 
+test('classic DAT KB identity recognizes GX8/9 model markers without inventing a major', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-kb-classic-dat-'));
+    try {
+        for (const marker of ['DATA001', 'GXSPC001', 'ATTRIBUT.DAT', 'ATT.XPW']) {
+            fs.writeFileSync(path.join(tempRoot, marker), 'classic');
+        }
+        const identity = readGeneXusKbIdentity(tempRoot);
+        assert.equal(identity.major, null);
+        assert.equal(identity.source, 'classic-dat');
+        assert.equal(identity.reason, 'classic-generation-requires-provider');
+        assert.equal(directoryLooksLikeKnowledgeBase(tempRoot), true);
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('KB catalog edits preserve per-KB legacy driver metadata', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-kb-catalog-'));
+    const configPath = path.join(tempRoot, 'config.json');
+    try {
+        fs.writeFileSync(configPath, JSON.stringify({
+            Environment: {
+                KBs: {
+                    sect80: {
+                        Path: 'D:\\\\GX80\\\\SECT',
+                        Driver: 'com-gxpublic',
+                        InstallationPath: 'C:\\\\gxw80',
+                        Major: '8'
+                    }
+                },
+                ActiveKb: 'sect80'
+            }
+        }));
+
+        const catalog = readKbCatalog(configPath);
+        assert.equal(catalog.kbs.sect80, 'D:\\\\GX80\\\\SECT');
+        assert.equal(Object.keys(catalog.kbs).length, 1);
+        const switched = switchActiveKb(configPath, { name: 'sect80' });
+        assert.equal(switched.ok, true);
+        const persisted = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        assert.equal(persisted.Environment.KBs.sect80.Driver, 'com-gxpublic');
+        assert.equal(persisted.Environment.KBs.sect80.InstallationPath, 'C:\\\\gxw80');
+        assert.equal(persisted.Environment.KBs.sect80.Major, '8');
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('classic gxi identity does not invent a GX8/GX9 mismatch before provider open', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-kb-gxi-compare-'));
+    const gx8Root = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-gx8-compare-'));
+    try {
+        fs.writeFileSync(path.join(tempRoot, 'Legacy.gxi'), 'classic-kb');
+        fs.writeFileSync(path.join(gx8Root, 'gxw32.exe'), 'not-a-real-executable');
+        const compatibility = compareGeneXusKbAndInstallation(tempRoot, gx8Root, {
+            readExecutableVersion: (exePath) => exePath.endsWith('gxw32.exe') ? '8.0.0.632' : null
+        });
+        assert.equal(compatibility.status, 'unresolved');
+        assert.equal(compatibility.kb.source, 'gxi-classic');
+        assert.equal(compatibility.gx.major, '8');
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+        removeTempPath(gx8Root, { recursive: true, force: true });
+    }
+});
+
 test('init rejects a known KB and SDK major mismatch before writing config', () => {
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-mismatch-'));
     const kbDir = path.join(tempRoot, 'kb17');
@@ -1088,6 +1242,146 @@ test('--fields validation returns usage error for invalid doctor field', () => {
     assert.equal(parsed.error.code, 'usage_error');
 });
 
+test('doctor client_config_sync describes the effective gateway and its source', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-doctor-gateway-source-'));
+    try {
+        const env = sandboxHomeEnv(tempRoot);
+        const configuredGateway = path.join(tempRoot, 'checkout', 'publish', 'GxMcp.Gateway.exe');
+        const mismatchedGateway = path.join(tempRoot, 'other', 'GxMcp.Gateway.exe');
+        const clientConfig = path.join(tempRoot, '.gemini', 'settings.json');
+        fs.mkdirSync(path.dirname(configuredGateway), { recursive: true });
+        fs.mkdirSync(path.dirname(clientConfig), { recursive: true });
+        fs.writeFileSync(configuredGateway, '');
+        fs.writeFileSync(clientConfig, JSON.stringify({
+            mcpServers: {
+                genexus18mcp: { command: configuredGateway, args: [] }
+            }
+        }));
+
+        const overrideEnv = { ...env, GENEXUS_MCP_GATEWAY_EXE: configuredGateway };
+        const matching = runCli(['doctor', '--format', 'json'], { env: overrideEnv });
+        assert.equal(matching.status, 0);
+        const matchingCheck = JSON.parse(matching.stdout).ok.checks.find((c) => c.id === 'client_config_sync');
+        assert.ok(matchingCheck);
+        assert.equal(matchingCheck.status, 'pass');
+        assert.ok(matchingCheck.detail.includes(`Configured Gateway: ${configuredGateway} (source: GENEXUS_MCP_GATEWAY_EXE)`));
+        assert.doesNotMatch(matchingCheck.detail, /npm-package gateway exe/);
+
+        fs.writeFileSync(clientConfig, JSON.stringify({
+            mcpServers: {
+                genexus18mcp: { command: mismatchedGateway, args: [] }
+            }
+        }));
+        const mismatching = runCli(['doctor', '--format', 'json'], { env: overrideEnv });
+        assert.equal(mismatching.status, 0);
+        const mismatchingCheck = JSON.parse(mismatching.stdout).ok.checks.find((c) => c.id === 'client_config_sync');
+        assert.ok(mismatchingCheck);
+        assert.equal(mismatchingCheck.status, 'warn');
+        assert.ok(mismatchingCheck.detail.includes(`Configured Gateway: ${configuredGateway} (source: GENEXUS_MCP_GATEWAY_EXE)`));
+        assert.doesNotMatch(mismatchingCheck.detail, /this npm package's bundled exe/);
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('doctor fails closed when GX_CONFIG_PATH points at a missing file', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-doctor-config-selection-'));
+    try {
+        const cwdConfig = path.join(tempRoot, 'config.json');
+        const missingConfig = path.join(tempRoot, 'missing.json');
+        fs.writeFileSync(cwdConfig, JSON.stringify({ Environment: { KBPath: 'C:\\wrong-context' } }));
+
+        const result = runCli(['doctor', '--mcp-smoke', '--format', 'json'], {
+            cwd: tempRoot,
+            env: {
+                ...sandboxHomeEnv(tempRoot),
+                GX_CONFIG_PATH: missingConfig,
+                GENEXUS_MCP_GATEWAY_EXE: process.execPath
+            }
+        });
+        assert.equal(result.status, 0);
+        const checks = JSON.parse(result.stdout).ok.checks;
+        const configCheck = checks.find((c) => c.id === 'config_file');
+        const probeCheck = checks.find((c) => c.id === 'gateway_spawn_probe');
+        const smokeCheck = checks.find((c) => c.id === 'mcp_smoke');
+        assert.ok(configCheck);
+        assert.equal(configCheck.status, 'fail');
+        assert.ok(configCheck.detail.includes(missingConfig));
+        assert.ok(probeCheck);
+        assert.equal(probeCheck.status, 'not_applicable');
+        assert.ok(smokeCheck);
+        assert.equal(smokeCheck.status, 'not_applicable');
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('doctor rejects malformed tool definitions instead of reporting only file presence', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-doctor-tool-defs-'));
+    try {
+        const configPath = path.join(tempRoot, 'config.json');
+        const toolDefinitionsPath = path.join(tempRoot, 'tool_definitions.json');
+        fs.writeFileSync(configPath, JSON.stringify({}));
+        fs.writeFileSync(toolDefinitionsPath, '{ invalid json');
+
+        const result = runCli(['doctor', '--format', 'json'], {
+            cwd: tempRoot,
+            env: {
+                ...sandboxHomeEnv(tempRoot),
+                GX_CONFIG_PATH: configPath,
+                GENEXUS_MCP_GATEWAY_EXE: path.join(tempRoot, 'missing', 'GxMcp.Gateway.exe'),
+                GENEXUS_MCP_TOOL_DEFINITIONS: toolDefinitionsPath
+            }
+        });
+        assert.equal(result.status, 0);
+        const check = JSON.parse(result.stdout).ok.checks.find((c) => c.id === 'tool_definitions');
+        assert.ok(check);
+        assert.equal(check.status, 'fail');
+        assert.ok(check.detail.includes(toolDefinitionsPath));
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('doctor reports strict KB catalog ambiguity instead of ignoring Environment.KBs', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-doctor-kb-catalog-'));
+    try {
+        const kbOne = path.join(tempRoot, 'kb-one');
+        const kbTwo = path.join(tempRoot, 'kb-two');
+        const configPath = path.join(tempRoot, 'config.json');
+        fs.mkdirSync(kbOne, { recursive: true });
+        fs.mkdirSync(kbTwo, { recursive: true });
+        fs.writeFileSync(path.join(kbOne, 'model.gxw'), '');
+        fs.writeFileSync(path.join(kbTwo, 'model.gxw'), '');
+        fs.writeFileSync(configPath, JSON.stringify({
+            GatewayMode: 'stdio-isolated',
+            Environment: {
+                ResolutionPolicy: 'strict',
+                KBs: {
+                    one: { Path: kbOne },
+                    two: { Path: kbTwo }
+                }
+            }
+        }));
+
+        const result = runCli(['doctor', '--format', 'json'], {
+            cwd: tempRoot,
+            env: {
+                ...sandboxHomeEnv(tempRoot),
+                GX_CONFIG_PATH: configPath,
+                GENEXUS_MCP_GATEWAY_EXE: path.join(tempRoot, 'missing', 'GxMcp.Gateway.exe')
+            }
+        });
+        assert.equal(result.status, 0);
+        const check = JSON.parse(result.stdout).ok.checks.find((c) => c.id === 'kb_catalog');
+        assert.ok(check);
+        assert.equal(check.status, 'warn');
+        assert.match(check.detail, /neither ActiveKb nor DefaultKb/);
+    } finally {
+        removeTempPath(tempRoot, { recursive: true, force: true });
+    }
+});
+
 test('doctor finds tool_definitions.json next to the gateway exe (not just dev-tree)', () => {
     // Regression for v2.6.6 bug: getToolDefinitionsPath() hard-coded the dev-tree
     // location, so every installed copy reported "tool_definitions.json is missing"

package/config/gx-versions.json

@@ -63,15 +63,17 @@
       "driver": "com-gxpublic",
       "defaultInstallPath": "C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 9.0",
       "registryNames": ["GeneXus 9.0"],
-      "legacyRegistryVersions": ["9.0"]
+      "legacyRegistryVersions": ["9.0"],
+      "legacySetupVersions": ["90"]
     },
     {
       "major": "8",
       "displayName": "GeneXus 8.0",
       "driver": "com-gxpublic",
-      "defaultInstallPath": "C:\\Program Files (x86)\\ARTech\\GeneXus\\GeneXus 8.0",
+      "defaultInstallPath": "C:\\Program Files (x86)\\ARTech\\GeneXus\\gxw80",
       "registryNames": ["GeneXus 8.0"],
-      "legacyRegistryVersions": ["8.0"]
+      "legacyRegistryVersions": ["8.0"],
+      "legacySetupVersions": ["80"]
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genexus-mcp",
-  "version": "3.6.1",
+  "version": "3.7.1",
   "mcpName": "io.github.lennix1337/genexus",
   "description": "GeneXus 16, GeneXus 17, GeneXus 18 MCP server with native SDK support; basic legacy compatibility for GeneXus Evolution 3, GeneXus Evolution 2, GeneXus Evolution 1, GeneXus 15, GeneXus 9.0, GeneXus 8.0 via com-gxpublic and dotnet-reflection drivers — read, edit, and analyze Knowledge Base objects directly from Claude, Cursor, and other AI agents over the Model Context Protocol.",
   "keywords": [

package/publish/GxMcp.Gateway.deps.json

@@ -7,7 +7,7 @@
   "targets": {
     ".NETCoreApp,Version=v10.0": {},
     ".NETCoreApp,Version=v10.0/win-x64": {
-      "GxMcp.Gateway/3.6.1": {
+      "GxMcp.Gateway/3.7.1": {
         "dependencies": {
           "Newtonsoft.Json": "13.0.3",
           "System.Management": "10.0.5",
@@ -66,7 +66,7 @@
     }
   },
   "libraries": {
-    "GxMcp.Gateway/3.6.1": {
+    "GxMcp.Gateway/3.7.1": {
       "type": "project",
       "serviceable": false,
       "sha512": ""