genexus-mcp 3.2.0 → 3.2.2

package/cli/run.test.js

@@ -15,7 +15,8 @@ const {
     getGeneXusCatalogEntries,
     readGeneXusInstallationIdentity,
     readGeneXusKbIdentity,
-    compareGeneXusKbAndInstallation
+    compareGeneXusKbAndInstallation,
+    patchClientConfig
 } = require('./lib/config');
 const { handleInit } = require('./commands/axi');
 
@@ -177,6 +178,129 @@ test('non-interactive init supports idempotent no-op', () => {
     fs.rmSync(tempRoot, { recursive: true, force: true });
 });
 
+test('config create creates explicit neutral runtime without KB or client registration', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-neutral-'));
+    const output = path.join(tempRoot, 'nested', 'runtime.json');
+    const result = runCli([
+        'config', 'create', '--config-scope', 'neutral', '--output', output,
+        '--gx', 'C:\\GeneXus18', '--worker', 'C:\\worker.exe',
+        '--gateway-mode', 'stdio-isolated', '--resolution-policy', 'strict', '--format', 'json'
+    ]);
+    assert.equal(result.status, 0);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.meta.command, 'config.create');
+    assert.equal(parsed.ok.configPath, path.resolve(output));
+    assert.equal(parsed.ok.clientsPatchedCount, 0);
+    assert.equal(parsed.ok.config.Environment.KBPath, undefined);
+    assert.equal(parsed.ok.config.Environment.KBs, undefined);
+    assert.equal(parsed.meta.clientRegistration, 'not_attempted');
+    assert.equal(parsed.meta.kbCatalog, 'not_created');
+    assert.deepEqual(JSON.parse(fs.readFileSync(output, 'utf8')), parsed.ok.config);
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('config create rejects missing new-format flags', () => {
+    const result = runCli(['config', 'create', '--config-scope', 'neutral', '--format', 'json']);
+    assert.equal(result.status, 2);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.error.code, 'usage_error');
+    assert.match(parsed.error.message, /--output/);
+    assert.match(parsed.error.message, /--worker/);
+    assert.match(parsed.error.message, /--gateway-mode/);
+    assert.match(parsed.error.message, /--resolution-policy/);
+});
+
+test('config create rejects KB in neutral runtime', () => {
+    const result = runCli([
+        'config', 'create', '--config-scope', 'neutral', '--output', path.join(os.tmpdir(), 'should-not-write.json'),
+        '--gx', 'C:\\GeneXus18', '--worker', 'C:\\worker.exe', '--gateway-mode', 'stdio-isolated',
+        '--resolution-policy', 'strict', '--kb', 'C:\\KBs\\forbidden', '--format', 'json'
+    ]);
+    assert.equal(result.status, 2);
+    const parsed = JSON.parse(result.stdout);
+    assert.equal(parsed.error.code, 'usage_error');
+    assert.match(parsed.error.message, /--kb is not allowed/);
+});
+
+test('config create does not modify client registration', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-neutral-reg-'));
+    const output = path.join(tempRoot, 'runtime.json');
+    const marker = path.join(tempRoot, 'client-config.json');
+    fs.writeFileSync(marker, JSON.stringify({ mcpServers: { existing: { command: 'keep' } } }, null, 2));
+    const before = fs.readFileSync(marker, 'utf8');
+    const result = runCli([
+        'config', 'create', '--config-scope', 'neutral', '--output', output,
+        '--gx', 'C:\\GeneXus18', '--worker', 'C:\\worker.exe', '--gateway-mode', 'stdio-isolated',
+        '--resolution-policy', 'strict', '--format', 'json'
+    ]);
+    assert.equal(result.status, 0);
+    assert.equal(fs.readFileSync(marker, 'utf8'), before);
+    assert.deepEqual(JSON.parse(result.stdout).ok.config, JSON.parse(fs.readFileSync(output, 'utf8')));
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+test('config migrate creates a neutral config with an atomic backup and read-back receipt', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-migrate-'));
+    try {
+        const source = path.join(tempRoot, 'legacy.json');
+        const target = path.join(tempRoot, 'neutral.json');
+        const legacy = {
+            GeneXus: { InstallationPath: 'C:\\GeneXus18', WorkerExecutable: 'C:\\worker.exe' },
+            Server: { HttpPort: 5000, McpStdio: true },
+            Environment: { KBPath: 'C:\\KBs\\main', DefaultKb: 'main', KBs: [{ Alias: 'main', Path: 'C:\\KBs\\main' }] }
+        };
+        fs.writeFileSync(source, JSON.stringify(legacy, null, 2));
+        const result = runCli(['config', 'migrate', '--from', source, '--output', target, '--format', 'json']);
+        assert.equal(result.status, 0);
+        const parsed = JSON.parse(result.stdout);
+        assert.equal(parsed.meta.command, 'config.migrate');
+        assert.equal(parsed.ok.readBack, true);
+        assert.ok(fs.existsSync(parsed.ok.backupPath));
+        assert.deepEqual(JSON.parse(fs.readFileSync(parsed.ok.backupPath, 'utf8')), legacy);
+        assert.equal(JSON.parse(fs.readFileSync(target, 'utf8')).ConfigSchemaVersion, 2);
+        assert.deepEqual(parsed.ok.notMigrated, ['Environment.KBPath', 'Environment.KBs', 'Environment.DefaultKb']);
+    } finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('config migrate rolls back an existing destination when read-back fails', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-migrate-rollback-'));
+    try {
+        const source = path.join(tempRoot, 'legacy.json');
+        const target = path.join(tempRoot, 'neutral.json');
+        fs.writeFileSync(source, JSON.stringify({ GeneXus: { InstallationPath: 'C:\\GeneXus18' } }));
+        const original = JSON.stringify({ keep: 'old' }, null, 2);
+        fs.writeFileSync(target, original);
+        const result = runCli(['config', 'migrate', '--from', source, '--output', target, '--format', 'json'], {
+            env: { GENEXUS_MCP_MIGRATE_FAIL_READBACK: '1' }
+        });
+        assert.equal(result.status, 1);
+        const parsed = JSON.parse(result.stdout);
+        assert.equal(parsed.error.code, 'operation_error');
+        assert.equal(parsed.ok, undefined);
+        assert.equal(fs.readFileSync(target, 'utf8'), original);
+        assert.equal(parsed.error.rollback.rolledBack, true);
+    } finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('config migrate rejects non-migratable fields when explicitly requested', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-migrate-reject-'));
+    try {
+        const source = path.join(tempRoot, 'legacy.json');
+        const target = path.join(tempRoot, 'neutral.json');
+        fs.writeFileSync(source, JSON.stringify({ Environment: { KBPath: 'C:\\KBs\\main' } }));
+        const result = runCli(['config', 'migrate', '--from', source, '--output', target, '--reject-non-migratable', '--format', 'json']);
+        assert.equal(result.status, 2);
+        const parsed = JSON.parse(result.stdout);
+        assert.match(parsed.error.message, /non-migratable/i);
+        assert.equal(fs.existsSync(target), false);
+    } finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+});
+
 test('whoami without config returns disconnected state', () => {
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-test-'));
     const res = runCli(['whoami', '--format', 'json'], { cwd: tempRoot });
@@ -1084,7 +1208,7 @@ test('clients add patches OpenCode Desktop into shared opencode config', () => {
         assert.ok(fs.existsSync(opencodeCfg), 'shared opencode config should be created');
         const written = JSON.parse(fs.readFileSync(opencodeCfg, 'utf8'));
         assert.ok(written.mcp.genexus18mcp, 'shared config should contain genexus18mcp entry');
-        assert.equal(written.mcp.genexus18mcp.environment.GX_CONFIG_PATH, cfgPath);
+        assert.equal(written.mcp.genexus18mcp.environment?.GX_CONFIG_PATH, undefined);
 
         const listRes = runCli(['clients', '--format', 'json'], { env });
         const row = JSON.parse(listRes.stdout).ok.clients.find((client) => client.id === 'opencode-desktop');
@@ -1302,7 +1426,7 @@ test('clients add preserves OpenCode 1.x direct mcp shape', () => {
     assert.equal(written.mcp.genexus18mcp.disabled, undefined);
     assert.ok(written.mcp.other, 'unrelated direct MCP server should be preserved');
     assert.equal(written.mcp.servers, undefined);
-    assert.deepEqual(written.mcp.genexus18mcp.environment, { GX_CONFIG_PATH: cfgPath });
+    assert.equal(written.mcp.genexus18mcp.environment?.GX_CONFIG_PATH, undefined);
 
     const listed = runCli(['clients', '--format', 'json'], { env });
     assert.equal(listed.status, 0);
@@ -1333,7 +1457,7 @@ test('clients add preserves OpenCode v2 nested mcp.servers shape', () => {
     assert.equal(written.mcp.servers.genexus18mcp.enabled, undefined);
     assert.ok(written.mcp.servers.other, 'unrelated nested MCP server should be preserved');
     assert.equal(written.mcp.genexus18mcp, undefined);
-    assert.deepEqual(written.mcp.servers.genexus18mcp.environment, { GX_CONFIG_PATH: cfgPath });
+    assert.equal(written.mcp.servers.genexus18mcp.environment?.GX_CONFIG_PATH, undefined);
 
     const listed = runCli(['clients', '--format', 'json'], { env });
     assert.equal(listed.status, 0);
@@ -1370,7 +1494,7 @@ test('init auto-registers detected OpenCode in either config layout', () => {
             const written = JSON.parse(fs.readFileSync(openCodeCfg, 'utf8'));
             const entry = label === 'nested' ? written.mcp.servers.genexus18mcp : written.mcp.genexus18mcp;
             assert.ok(entry, `${label} OpenCode entry should be present after init`);
-            assert.deepEqual(entry.environment, { GX_CONFIG_PATH: path.join(kbDir, 'config.json') });
+            assert.equal(entry.environment?.GX_CONFIG_PATH, undefined);
             assert.ok(label === 'nested' ? written.mcp.servers.other : written.mcp.other);
         } finally {
             fs.rmSync(tempRoot, { recursive: true, force: true });
@@ -1378,6 +1502,52 @@ test('init auto-registers detected OpenCode in either config layout', () => {
     }
 });
 
+test('init with --global-config persists GX_CONFIG_PATH into client entry', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-opencode-init-global-'));
+    try {
+        const env = sandboxHomeEnv(tempRoot);
+        const kbDir = path.join(tempRoot, 'kb');
+        const openCodeCfg = path.join(env.XDG_CONFIG_HOME, 'opencode', 'opencode.json');
+        fs.mkdirSync(kbDir, { recursive: true });
+        fs.mkdirSync(path.dirname(openCodeCfg), { recursive: true });
+        fs.writeFileSync(openCodeCfg, JSON.stringify({ mcp: {} }, null, 2));
+
+        const result = runCli(
+            ['init', '--kb', kbDir, '--gx', testGxPath, '--global-config', '--no-smoke', '--format', 'json'],
+            { cwd: kbDir, env: { ...env, ...testGatewayEnv } }
+        );
+        assert.equal(result.status, 0, `init should succeed: ${result.stderr}`);
+
+        const written = JSON.parse(fs.readFileSync(openCodeCfg, 'utf8'));
+        assert.ok(written.mcp.genexus18mcp);
+        assert.equal(written.mcp.genexus18mcp.environment.GX_CONFIG_PATH, path.join(kbDir, 'config.json'));
+    } finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+});
+
+test('clients add with --global-config persists GX_CONFIG_PATH into client entry', () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-opencode-add-global-'));
+    try {
+        const env = sandboxHomeEnv(tempRoot);
+        const cfgPath = path.join(tempRoot, 'config.json');
+        const openCodeCfg = path.join(env.XDG_CONFIG_HOME, 'opencode', 'opencode.json');
+        fs.mkdirSync(path.dirname(openCodeCfg), { recursive: true });
+        fs.writeFileSync(cfgPath, JSON.stringify({ Environment: { KBPath: tempRoot } }));
+        fs.writeFileSync(openCodeCfg, JSON.stringify({ mcp: {} }, null, 2));
+
+        const res = runCli(['clients', 'add', '--clients', 'opencode', '--global-config', '--format', 'json'], {
+            env: { ...env, GX_CONFIG_PATH: cfgPath }
+        });
+        assert.equal(res.status, 0);
+        const written = JSON.parse(fs.readFileSync(openCodeCfg, 'utf8'));
+        assert.ok(written.mcp.genexus18mcp);
+        assert.equal(written.mcp.genexus18mcp.environment.GX_CONFIG_PATH, cfgPath);
+    } finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+});
+
 test('init auto-registers detected OpenCode Desktop when its marker is present', () => {
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genexus-mcp-opencode-desktop-init-'));
     try {
@@ -1835,3 +2005,93 @@ test('clients add rejects invalid --server-name characters with usage error', ()
     assert.equal(parsed.error.code, 'usage_error');
     assert.match(parsed.error.message, /alphanumeric/);
 });
+
+function fsFailureProxy(realFs, failure) {
+    let calls = 0;
+    return new Proxy(realFs, {
+        get(target, property) {
+            if (property === failure.method) {
+                return (...args) => {
+                    calls += 1;
+                    if (!failure.match || failure.match(args, calls)) throw new Error(failure.message);
+                    return target[property](...args);
+                };
+            }
+            const value = target[property];
+            return typeof value === 'function' ? value.bind(target) : value;
+        }
+    });
+}
+
+function patchFailureFixture(prefix) {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    const env = sandboxHomeEnv(tempRoot);
+    process.env.XDG_CONFIG_HOME = env.XDG_CONFIG_HOME;
+    process.env.APPDATA = env.APPDATA;
+    const cfgPath = path.join(tempRoot, 'config.json');
+    fs.writeFileSync(cfgPath, JSON.stringify({ Environment: { KBPath: tempRoot } }));
+    const openCodeCfg = path.join(env.XDG_CONFIG_HOME, 'opencode', 'opencode.json');
+    const vscodeCfg = path.join(env.APPDATA, 'Code', 'User', 'mcp.json');
+    fs.mkdirSync(path.dirname(openCodeCfg), { recursive: true });
+    fs.mkdirSync(path.dirname(vscodeCfg), { recursive: true });
+    fs.writeFileSync(openCodeCfg, JSON.stringify({ mcp: { other: { type: 'local' } } }));
+    fs.writeFileSync(vscodeCfg, JSON.stringify({ servers: { other: { type: 'stdio' } } }));
+    return { tempRoot, env, cfgPath, openCodeCfg, vscodeCfg };
+}
+
+test('patchClientConfig reports backup failure without claiming that client patched', () => {
+    const fixture = patchFailureFixture('genexus-mcp-partial-backup-');
+    try {
+        const result = patchClientConfig(fixture.cfgPath, {
+            ids: ['opencode', 'vscode'], onlyExisting: false,
+            fs: fsFailureProxy(fs, { method: 'copyFileSync', message: 'backup denied', match: ([source]) => source === fixture.openCodeCfg })
+        });
+        assert.deepEqual(result.patched, ['VS Code']);
+        assert.deepEqual(result.failed, [{ client: 'OpenCode (CLI)', reason: 'backup denied' }]);
+        assert.equal(JSON.parse(fs.readFileSync(fixture.openCodeCfg, 'utf8')).mcp.genexus18mcp, undefined);
+        assert.ok(JSON.parse(fs.readFileSync(fixture.vscodeCfg, 'utf8')).servers.genexus18mcp);
+    } finally { fs.rmSync(fixture.tempRoot, { recursive: true, force: true }); }
+});
+
+test('patchClientConfig preserves earlier success when a later client write fails', () => {
+    const fixture = patchFailureFixture('genexus-mcp-partial-write-');
+    try {
+        const result = patchClientConfig(fixture.cfgPath, {
+            ids: ['opencode', 'vscode'], onlyExisting: false,
+            fs: fsFailureProxy(fs, { method: 'writeFileSync', message: 'write denied', match: ([filePath]) => filePath === `${fixture.vscodeCfg}.tmp-${process.pid}` })
+        });
+        assert.deepEqual(result.patched, ['OpenCode (CLI)']);
+        assert.deepEqual(result.failed, [{ client: 'VS Code', reason: 'write denied' }]);
+        assert.ok(JSON.parse(fs.readFileSync(fixture.openCodeCfg, 'utf8')).mcp.genexus18mcp);
+        assert.equal(JSON.parse(fs.readFileSync(fixture.vscodeCfg, 'utf8')).servers.genexus18mcp, undefined);
+    } finally { fs.rmSync(fixture.tempRoot, { recursive: true, force: true }); }
+});
+
+test('patchClientConfig reports post-write read-back failure as partial state', () => {
+    const fixture = patchFailureFixture('genexus-mcp-partial-readback-');
+    try {
+        const result = patchClientConfig(fixture.cfgPath, {
+            ids: ['opencode', 'vscode'], onlyExisting: false,
+            fs: fsFailureProxy(fs, { method: 'readFileSync', message: 'read-back denied', match: ([filePath], calls) => filePath === fixture.openCodeCfg && calls === 2 })
+        });
+        assert.deepEqual(result.patched, ['VS Code']);
+        assert.deepEqual(result.failed, [{ client: 'OpenCode (CLI)', reason: 'post-write verification failed (genexus18mcp entry not found after write)' }]);
+        assert.ok(JSON.parse(fs.readFileSync(fixture.openCodeCfg, 'utf8')).mcp.genexus18mcp);
+        assert.ok(JSON.parse(fs.readFileSync(fixture.vscodeCfg, 'utf8')).servers.genexus18mcp);
+    } finally { fs.rmSync(fixture.tempRoot, { recursive: true, force: true }); }
+});
+
+test('patchClientConfig keeps a stale same-second backup and writes a distinct backup', () => {
+    const fixture = patchFailureFixture('genexus-mcp-stale-backup-');
+    try {
+        const stamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+        const stale = `${fixture.openCodeCfg}.${stamp}.bak`;
+        fs.writeFileSync(stale, 'stale backup');
+        const result = patchClientConfig(fixture.cfgPath, { ids: ['opencode'], onlyExisting: false });
+        assert.deepEqual(result.failed, []);
+        assert.equal(fs.readFileSync(stale, 'utf8'), 'stale backup');
+        const backups = fs.readdirSync(path.dirname(fixture.openCodeCfg)).filter((name) => name.startsWith(path.basename(fixture.openCodeCfg)) && name.endsWith('.bak'));
+        assert.equal(backups.length, 2);
+        assert.ok(backups.some((name) => name !== path.basename(stale)));
+    } finally { fs.rmSync(fixture.tempRoot, { recursive: true, force: true }); }
+});

package/docs/llm_cli_mcp_playbook.md

@@ -38,6 +38,15 @@ Entry points:
 - `genexus-mcp tools list`
 - `genexus-mcp config show`
 
+Neutral installer/runtime setup:
+- `genexus-mcp config create --config-scope neutral --output <path> --gx <path> --worker <path> --gateway-mode stdio-isolated --resolution-policy strict`
+- `genexus-mcp clients add --all-clients` (or `--clients opencode,codex-cli,vscode,antigravity,gemini-cli`)
+- `genexus-mcp config migrate --from <legacy.json> --output <neutral.json>` is the only configuration migration path. It copies runtime fields into the neutral schema (`ConfigSchemaVersion: 2`, `GatewayMode`, `GeneXus`, `Server`, and `Environment.ResolutionPolicy`), writes an atomic source backup, verifies the destination by read-back, and rolls back an existing destination if verification fails. The JSON receipt reports `backupPath`, `readBack`, `rolledBack`, `migrated`, and `notMigrated`.
+- Legacy KB fields (`Environment.KBPath`, `KBs`, `DefaultKb`, `ActiveKb`) are deliberately not migrated because neutral configs are KB-free. Use `--reject-non-migratable` to fail before writing when any are present.
+- `init` and `clients add` never migrate or rewrite an existing config automatically. `kb add`, `kb remove`, and `kb switch` remain the legacy catalog flow: they mutate the `Environment` catalog in the config selected by `GX_CONFIG_PATH` or the current directory. Neutral runtimes use explicit per-session MCP KB selection instead.
+
+The neutral runtime contains no `KBPath`, `KBs`, `DefaultKb`, or `ActiveKb`; KB selection remains an explicit MCP session action. Adapters preserve unrelated servers and the existing OpenCode `mcp.<name>` versus `mcp.servers.<name>` layout. They add `GX_CONFIG_PATH` only when `--global-config` is explicitly requested.
+
 Rules:
 - Parse `stdout` only.
 - Expect envelope fields: `ok`, `error`, `help`, `meta`.
@@ -71,6 +80,36 @@ this file.
 
 For `tools/call`, parse `result.content[0].text` as JSON.
 
+### KB context, leases, and compatibility
+
+Use the neutral `stdio-isolated` + `ResolutionPolicy: "strict"` configuration
+for local work. Strict resolution is explicit `kb` → session `select` → strict
+rules: persisted defaults do not silently select a session, and declared KBs
+are never auto-opened. Set `ResolutionPolicy: "legacy"` only when preserving a
+legacy client contract is intentional; it retains `config-default` →
+`single-open` → `declared-first` fallback and legacy persistent `set_default`.
+
+`genexus_kb action=open` opens/registers a worker and returns an owner-scoped
+lease. `select`/`set_session_default` select only the current session and do
+not persist config or grant a lease. `close` releases only the caller's lease.
+In strict mode, a stateful KB-bound call without that lease returns
+`KB_NOT_OWNED`, even if `kb` names the target; `kb` identifies a target but does
+not transfer ownership. `KB_LEASE_INVALID` means an invalid or mismatched
+token/context, and `KB_LEASE_EXPIRED` means the lease TTL elapsed. A duplicate
+worker lock is reported as `KB_LOCKED`; do not blindly retry or expect proxy
+fallback. Sessionless HTTP cannot use `select` and returns
+`KB_SESSION_UNAVAILABLE`.
+
+The default local-friendly posture accepts an explicit valid local KB path.
+Hardened deployments add OS/root/network controls and must expose that posture
+in diagnostics; `HttpPort=0` is not proof of isolation.
+
+For HTTP, `GXMCP_HTTP_TOKEN` is an environment secret. Once set, send it on
+every `/mcp` request as `Authorization: Bearer <token>` or `X-GXMCP-Token`.
+Without a token, loopback remains available; non-loopback requests are refused.
+Never place the token in client registration, config examples, MCP payloads, or
+logs. Restart after rotating it.
+
 Gateway AXI-like enrichments are additive (under `_meta` — underscore-prefixed per MCP convention):
 - `_meta.schemaVersion = mcp-axi/2` (v2.0.0+)
 - `_meta.tool = <tool-name>`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genexus-mcp",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "mcpName": "io.github.lennix1337/genexus",
   "description": "GeneXus 17, GeneXus 18 MCP server — read, edit, and analyze Knowledge Base objects directly from Claude, Cursor, and other AI agents over the Model Context Protocol.",
   "keywords": [
@@ -32,7 +32,7 @@
     "automation"
   ],
   "scripts": {
-    "test": "node --test cli/run.test.js cli/lib/client-adapters.test.js",
+    "test": "node --test cli/run.test.js cli/lib/client-adapters.test.js cli/docs.test.js",
     "lint": "eslint cli scripts eslint.config.js --max-warnings=0",
     "test:one": "node scripts/test-one.js",
     "prepack": "node scripts/clean-package.js",

package/publish/GxMcp.Gateway.deps.json

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

package/publish/config.json

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

package/publish/gxmcp-manifest.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": "gxmcp-release-manifest/1",
-  "version": "3.2.0",
-  "sourceCommit": "d0ed6ff43d48cc5d62ba7e09f36f28477d161710",
+  "version": "3.2.2",
+  "sourceCommit": "3b9e16fe449c6ae0d3555112cd433c3ecb358934",
   "sourceCommitPolicy": "exact-tag",
-  "generatedAtUtc": "2026-09-09T16:51:27.9077164Z",
+  "generatedAtUtc": "2026-09-10T17:38:42.0225221Z",
   "runtime": {
     "gateway": "net10.0-windows",
     "worker": "net48-x86",
@@ -15,33 +15,33 @@
     "2026-07-28"
   ],
   "schema": "tool_definitions.json",
-  "schemaSha256": "e4a3043ade9e565599dabed109ade92db73360c02bc5ee0d28f21eec25d89d68",
+  "schemaSha256": "a548b6b8a4a8a88270b320e669e60755c61169e5d771591e92b21edaa5c6afad",
   "provenance": "gxmcp-sbom.json",
   "artifacts": [
     {
       "path": "gxmcp-sbom.json",
       "size": 590,
-      "sha256": "02cdc88c7dff83608a1f157be94f45b914a6b7d319bd701d4ce54a4d621a6e71"
+      "sha256": "f815950ad437f1949fc23ba06dfa45df814172070f0f94e4f621635d5e31026d"
     },
     {
       "path": "GxMcp.Gateway.exe",
       "size": 162304,
-      "sha256": "f15a4622bc1b0b552a480964e32b1defee7fa240d1ded2bb27852dd44a645977"
+      "sha256": "bc99684803a349f2ca3343ccf330d637bc8fe72263217e7596139a5361488048"
     },
     {
       "path": "nexus-ide.vsix",
-      "size": 1318667,
-      "sha256": "e665685cd085a7d5af4c23e7704371167a02ba0ae6a2ed74a5d6681be016e44e"
+      "size": 1318670,
+      "sha256": "b8adec54e5735f7df64146afae3c86c4bd001e7b2bab39ea17797ec1c36335a1"
     },
     {
       "path": "tool_definitions.json",
-      "size": 106423,
-      "sha256": "e4a3043ade9e565599dabed109ade92db73360c02bc5ee0d28f21eec25d89d68"
+      "size": 109656,
+      "sha256": "a548b6b8a4a8a88270b320e669e60755c61169e5d771591e92b21edaa5c6afad"
     },
     {
       "path": "worker/GxMcp.Worker.exe",
-      "size": 2926080,
-      "sha256": "903e41245f740f88a6d3e6f8ada00bd82a18b6ea07259ebb7dd9dbe90b1a550e"
+      "size": 2989568,
+      "sha256": "9f3e594e79c09672f084d6d3a7ac7b07ca63e5e20de7fa5f2d65e00ed0c3b3dd"
     }
   ]
 }

package/publish/gxmcp-sbom.json

@@ -1,20 +1,20 @@
 {
   "schemaVersion": "gxmcp-provenance/1",
-  "version": "3.2.0",
-  "sourceCommit": "d0ed6ff43d48cc5d62ba7e09f36f28477d161710",
+  "version": "3.2.2",
+  "sourceCommit": "3b9e16fe449c6ae0d3555112cd433c3ecb358934",
   "sourceCommitPolicy": "exact-tag",
   "components": [
     {
       "name": "genexus-mcp",
       "lockfile": "package-lock.json",
       "size": 39914,
-      "sha256": "4ddd59d46b934fafe177482aa8d769b0cd041a7f0205cd6cc52d6fe3a825de88"
+      "sha256": "28352a3b59b5d25e58f7150e54ed003f813cfa0b68b7123a6e452ca21dd6a4a8"
     },
     {
       "name": "nexus-ide",
       "lockfile": "src/nexus-ide/package-lock.json",
       "size": 274983,
-      "sha256": "000a3e5e18fe604470bb99fe853acecfbf92712b98d74c7e6f379e0593ded562"
+      "sha256": "21f8d8457e5ae77c2ab3e3670dda9b89f792d741c31a05367bdbbb8e8b6d1d1b"
     }
   ]
 }