genexus-mcp 3.6.1 → 3.7.0

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

@@ -22,8 +22,11 @@ const {
     getGeneXusCatalogEntries,
     discoverGeneXusInstallation,
     readGeneXusInstallationIdentity,
+    directoryLooksLikeKnowledgeBase,
     readGeneXusKbIdentity,
     compareGeneXusKbAndInstallation,
+    readKbCatalog,
+    switchActiveKb,
     patchClientConfig
 } = require('./lib/config');
 const { handleInit, resolveMcpSmokeTarget } = require('./commands/axi');
@@ -571,6 +574,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 +712,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 +1174,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.0",
   "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.0": {
         "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.0": {
       "type": "project",
       "serviceable": false,
       "sha512": ""

package/publish/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/publish/config.json

@@ -1,19 +1,19 @@
 {
-  "Environment": {
-    "ResolutionPolicy": "strict"
+  "GatewayMode": "stdio-isolated",
+  "ConfigSchemaVersion": 2,
+  "GeneXus": {
+    "WorkerExecutable": "worker\\\\GxMcp.Worker.exe",
+    "InstallationPath": "C:\\Program Files (x86)\\GeneXus\\GeneXus18"
   },
   "Server": {
-    "McpStdio": true,
-    "TerseResponses": true,
-    "HttpPort": 0,
     "WorkerIdleTimeoutMinutes": 5,
+    "HttpPort": 0,
+    "TerseResponses": true,
     "SessionIdleTimeoutMinutes": 10,
-    "EmitStructuredContent": false
-  },
-  "ConfigSchemaVersion": 2,
-  "GeneXus": {
-    "InstallationPath": "C:\\Program Files (x86)\\GeneXus\\GeneXus18",
-    "WorkerExecutable": "worker\\\\GxMcp.Worker.exe"
+    "EmitStructuredContent": false,
+    "McpStdio": true
   },
-  "GatewayMode": "stdio-isolated"
+  "Environment": {
+    "ResolutionPolicy": "strict"
+  }
 }

package/publish/gxmcp-manifest.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": "gxmcp-release-manifest/1",
-  "version": "3.6.1",
-  "sourceCommit": "994b57d6eea67e439edda731572152bf13a41508",
+  "version": "3.7.0",
+  "sourceCommit": "1c6d0fb48c98ce2e88b5914a8b6f11510a0c9691",
   "sourceCommitPolicy": "exact-tag",
-  "generatedAtUtc": "2026-09-18T14:27:29.5142024Z",
+  "generatedAtUtc": "2026-09-19T05:58:25.2316950Z",
   "runtime": {
     "gateway": "net10.0-windows",
     "worker": "net48-x86",
@@ -15,28 +15,28 @@
     "2026-07-28"
   ],
   "schema": "tool_definitions.json",
-  "schemaSha256": "c9bfe92403a70dd3760b7685bc357491ec35c46c9b5a362dd9717017a3784532",
+  "schemaSha256": "de5ac0b8955a64065f4d9468b6b4e66610f476e43c9732c1c233b49feee5ddbb",
   "provenance": "gxmcp-sbom.json",
   "artifacts": [
     {
       "path": "gxmcp-sbom.json",
       "size": 590,
-      "sha256": "3a437e76cc53aa499706dfd5da80e9ff8bc9d4b0176e47dc5bb1bb29112bdbdd"
+      "sha256": "7d32db9bbf7bab298561c8e5fe9f2e2518e4ac716daa371aa4dbd752ce61b300"
     },
     {
       "path": "GxMcp.Gateway.exe",
       "size": 162304,
-      "sha256": "15765fd9430a58eb0ecb8f95ed3a3638be76fdb5c224103aefa0a44398945c61"
+      "sha256": "3507a7154b251a53deaadbb524298b1958ef017f4d59fc3ac369f04652ec9ac2"
     },
     {
       "path": "tool_definitions.json",
-      "size": 125411,
-      "sha256": "c9bfe92403a70dd3760b7685bc357491ec35c46c9b5a362dd9717017a3784532"
+      "size": 126023,
+      "sha256": "de5ac0b8955a64065f4d9468b6b4e66610f476e43c9732c1c233b49feee5ddbb"
     },
     {
       "path": "worker/GxMcp.Worker.exe",
-      "size": 3342336,
-      "sha256": "f837b7ce71044eaba8b84d9f7ccc258a15e9a75ba9be46b17c6c08670dffdfd6"
+      "size": 3414016,
+      "sha256": "9c1bb1f040661936e367706f353e5da14d0cc2e3ac0217b3b0ae1b5919fc5ce6"
     }
   ]
 }