@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/MCPServer.search.test.js

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DEFAULT_SEARCH_CONFIG } from '../../src/config/search-defaults.js';
 import { createToolHandlerMap } from '../../src/server/ToolHandlerMap.js';
 function tool(name, description = `desc_${name}`) {
     return {
@@ -16,23 +17,36 @@ vi.mock('@server/ToolCatalog', () => {
     const builtinTools = [
         tool('browser_launch', 'Launch a browser'),
         tool('page_navigate', 'Navigate a page'),
+        tool('network_enable', 'Enable network monitoring'),
         tool('network_get_requests', 'Inspect network requests'),
+        tool('get_token_budget_stats', 'Inspect token budget state'),
     ];
     return {
         allTools: builtinTools,
         getToolDomain: (name) => {
-            if (name === 'network_get_requests')
+            if (name === 'get_token_budget_stats')
+                return 'maintenance';
+            if (name === 'network_enable' || name === 'network_get_requests')
                 return 'network';
             if (name === 'browser_launch' || name === 'page_navigate')
                 return 'browser';
             return undefined;
         },
-        getToolsByDomains: (domains) => builtinTools.filter((candidate) => domains.includes(candidate.name.startsWith('network_') ? 'network' : 'browser')),
+        getToolsByDomains: (domains) => builtinTools.filter((candidate) => {
+            const domain = candidate.name === 'get_token_budget_stats'
+                ? 'maintenance'
+                : candidate.name.startsWith('network_')
+                    ? 'network'
+                    : 'browser';
+            return domains.includes(domain);
+        }),
         getToolMinimalTier: (name) => {
             if (name === 'browser_launch' || name === 'page_navigate')
                 return 'workflow';
-            if (name === 'network_get_requests')
+            if (name === 'network_enable' || name === 'network_get_requests')
                 return 'workflow';
+            if (name === 'get_token_budget_stats')
+                return 'search';
             return null;
         },
         getTierIndex: (tier) => {
@@ -47,9 +61,6 @@ vi.mock('@server/ToolCatalog', () => {
         TIER_ORDER: ['search', 'workflow', 'full'],
     };
 });
-vi.mock('@server/MCPServer.boost', () => ({
-    boostProfile: vi.fn().mockResolvedValue({ success: true }),
-}));
 vi.mock('@server/ToolHandlerMap', () => ({
     createToolHandlerMap: vi.fn(() => ({})),
 }));
@@ -58,6 +69,7 @@ vi.mock('@server/registry/index', () => ({
     ALL_REGISTRATIONS: [
         { domain: 'browser', tool: tool('browser_launch') },
         { domain: 'browser', tool: tool('page_navigate') },
+        { domain: 'network', tool: tool('network_enable') },
         { domain: 'network', tool: tool('network_get_requests') },
     ],
 }));
@@ -97,28 +109,23 @@ vi.mock('@src/utils/logger', () => ({
     },
 }));
 vi.mock('@src/constants', () => ({
-    DYNAMIC_BOOST_ENABLED: true,
-    DYNAMIC_BOOST_RERESEARCH_AFTER_BOOST: false,
-    DYNAMIC_BOOST_STRATEGY: 'max',
-    DYNAMIC_BOOST_SKIP_SEARCH_TO_FULL: false,
-    DYNAMIC_BOOST_MAX_JUMP: 2,
-    SEARCH_WORKFLOW_BOOST_TIERS: new Set(['workflow', 'full']),
+    SEARCH_AUTO_ACTIVATE_DOMAINS: true,
+    ACTIVATION_TTL_MINUTES: 30,
     SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER: 1.5,
 }));
 let registerSearchMetaTools;
 function createCtx(overrides = {}) {
     const registered = new Map();
     const ctx = {
-        currentTier: 'search',
+        baseTier: 'search',
         selectedTools: [tool('browser_launch')],
-        boostedToolNames: new Set(),
         activatedToolNames: new Set(),
-        boostedExtensionToolNames: new Set(),
         extensionToolsByName: new Map(),
         extensionWorkflowRuntimeById: new Map(),
-        enabledDomains: new Set(),
+        enabledDomains: new Set(['browser']),
         activatedRegisteredTools: new Map(),
-        boostedRegisteredTools: new Map(),
+        domainTtlEntries: new Map(),
+        config: { search: structuredClone(DEFAULT_SEARCH_CONFIG) },
         router: { addHandlers: vi.fn(), removeHandler: vi.fn() },
         handlerDeps: {},
         server: {
@@ -147,9 +154,8 @@ describe('MCPServer.search', () => {
         vi.resetModules();
         ({ registerSearchMetaTools } = await import('../../src/server/MCPServer.search.js'));
     });
-    it('builds a workflow-biased description that includes loaded extension counts', () => {
+    it('builds a description that includes loaded extension counts', () => {
         const ctx = createCtx({
-            currentTier: 'workflow',
             extensionToolsByName: new Map([
                 [
                     'custom_tool',
@@ -164,9 +170,9 @@ describe('MCPServer.search', () => {
         });
         registerSearchMetaTools(ctx);
         const searchToolsRegistration = ctx.__registered.get('search_tools');
-        expect(searchToolsRegistration.options.description).toContain('1 currently loaded');
-        expect(searchToolsRegistration.options.description).not.toContain('DYNAMIC_BOOST_ENABLED');
-        expect(searchToolsRegistration.options.description).toContain('workflow-tier sessions boost ranking for workflow-domain results');
+        expect(searchToolsRegistration.options.description).toContain('Search 5 tools');
+        expect(searchToolsRegistration.options.description).toContain('workflow (1)');
+        expect(searchToolsRegistration.options.description).toContain('activate_tools for exact matches');
     });
     it('reuses the cached search engine when the signature is unchanged', async () => {
         const ctx = createCtx();
@@ -196,35 +202,41 @@ describe('MCPServer.search', () => {
         const searchHandler = ctx.__registered.get('search_tools').handler;
         const response = parseResponse(await searchHandler({ query: 'page' }));
         expect(response.hint).toContain('For guided tool discovery with workflow detection, use route_tool instead');
-        expect(response.hint).not.toContain('DYNAMIC_BOOST_ENABLED');
         expect(response.hint).toContain('activate_tools to enable specific tools');
     });
-    it('calls boostProfile when dynamic boost is triggered', async () => {
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        const ctx = createCtx({ currentTier: 'search' });
+    it('returns direct-call nextActions with exampleArgs instead of forcing describe_tool', async () => {
+        const ctx = createCtx();
         registerSearchMetaTools(ctx);
         const searchHandler = ctx.__registered.get('search_tools').handler;
         state.searchImpl = () => [
             {
                 name: 'page_navigate',
-                description: 'Navigate to a page',
-                shortDescription: 'Navigate to a page',
+                description: 'Navigate a page',
+                shortDescription: 'Navigate a page',
                 score: 1,
                 domain: 'browser',
                 isActive: false,
             },
         ];
-        await searchHandler({ query: 'page', top_k: 5 });
-        expect(boostProfile).toHaveBeenCalled();
+        const response = parseResponse(await searchHandler({ query: 'navigate' }));
+        expect(response.nextActions).toEqual([
+            {
+                step: 1,
+                action: 'activate_tools',
+                command: 'activate_tools with names: ["page_navigate"]',
+                description: 'Activate top 1 result(s)',
+            },
+            {
+                step: 2,
+                action: 'call',
+                command: 'page_navigate',
+                exampleArgs: {},
+                description: 'Call page_navigate. Use describe_tool("page_navigate") only if you need the full schema.',
+            },
+        ]);
     });
-    it.skip('does not call boostProfile when DYNAMIC_BOOST_ENABLED is false', async () => {
-        vi.doMock('@src/constants', () => ({
-            DYNAMIC_BOOST_ENABLED: false,
-            SEARCH_WORKFLOW_BOOST_TIERS: new Set(['workflow', 'full']),
-            SEARCH_WORKFLOW_DOMAIN_BOOST_MULTIPLIER: 1.5,
-        }));
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        const ctx = createCtx({ currentTier: 'search' });
+    it('auto-activates domains when search finds inactive tools in non-enabled domains', async () => {
+        const ctx = createCtx({ enabledDomains: new Set() });
         registerSearchMetaTools(ctx);
         const searchHandler = ctx.__registered.get('search_tools').handler;
         state.searchImpl = () => [
@@ -237,15 +249,13 @@ describe('MCPServer.search', () => {
                 isActive: false,
             },
         ];
-        await searchHandler({ query: 'page', top_k: 5 });
-        expect(boostProfile).not.toHaveBeenCalled();
+        const response = parseResponse(await searchHandler({ query: 'page', top_k: 5 }));
+        expect(response.autoActivatedDomains).toBeDefined();
     });
-    it('transparently boosts when upgrade succeeds', async () => {
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        boostProfile.mockResolvedValueOnce({ success: true });
-        const ctx = createCtx({ currentTier: 'search' });
-        registerSearchMetaTools(ctx);
-        const searchHandler = ctx.__registered.get('search_tools').handler;
+    it('does not auto-activate when all search results are already active', async () => {
+        const ctx = createCtx();
+        ctx.activatedToolNames.add('page_navigate');
+        ctx.enabledDomains.add('browser');
         state.searchImpl = () => [
             {
                 name: 'page_navigate',
@@ -253,24 +263,17 @@ describe('MCPServer.search', () => {
                 shortDescription: 'Navigate to a page',
                 score: 1,
                 domain: 'browser',
-                isActive: false,
+                isActive: true,
             },
         ];
-        const response = parseResponse(await searchHandler({ query: 'page', top_k: 5 }));
-        expect(boostProfile).toHaveBeenCalled();
-        expect(response.boostAttempted).toBeUndefined();
-        expect(response.boostedToTier).toBeUndefined();
-        expect(response.boostError).toBeUndefined();
-    });
-    it('transparently handles boost failures without exposing errors', async () => {
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        boostProfile.mockResolvedValueOnce({
-            success: false,
-            error: 'Tier upgrade failed',
-        });
-        const ctx = createCtx({ currentTier: 'search' });
         registerSearchMetaTools(ctx);
         const searchHandler = ctx.__registered.get('search_tools').handler;
+        const response = parseResponse(await searchHandler({ query: 'page', top_k: 5 }));
+        expect(response.autoActivatedDomains).toBeUndefined();
+    });
+    it('does not auto-activate domains that are already enabled', async () => {
+        const ctx = createCtx();
+        ctx.enabledDomains.add('browser');
         state.searchImpl = () => [
             {
                 name: 'page_navigate',
@@ -281,187 +284,241 @@ describe('MCPServer.search', () => {
                 isActive: false,
             },
         ];
+        registerSearchMetaTools(ctx);
+        const searchHandler = ctx.__registered.get('search_tools').handler;
         const response = parseResponse(await searchHandler({ query: 'page', top_k: 5 }));
-        expect(boostProfile).toHaveBeenCalled();
-        expect(response.boostAttempted).toBeUndefined();
-        expect(response.boostedToTier).toBeUndefined();
-        expect(response.boostError).toBeUndefined();
+        expect(response.autoActivatedDomains).toBeUndefined();
     });
-    it('considers all inactive tools within score threshold for tier calculation', async () => {
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        const ctx = createCtx({ currentTier: 'search' });
-        state.searchImpl = (_query, _topK) => {
-            return [
-                {
-                    name: 'browser_launch',
-                    description: 'Launch browser',
-                    shortDescription: 'Launch browser',
-                    score: 1,
-                    domain: 'browser',
-                    isActive: false,
-                },
-                {
-                    name: 'page_navigate',
-                    description: 'Navigate page',
-                    shortDescription: 'Navigate page',
-                    score: 0.9,
-                    domain: 'browser',
-                    isActive: false,
-                },
-                {
-                    name: 'network_get_requests',
-                    description: 'Get network requests',
-                    shortDescription: 'Get network requests',
-                    score: 0.8,
-                    domain: 'network',
-                    isActive: false,
-                },
-                {
-                    name: 'browser_launch',
-                    description: 'Launch browser duplicate',
-                    shortDescription: 'Launch browser',
-                    score: 0.7,
-                    domain: 'browser',
-                    isActive: false,
-                },
-                {
-                    name: 'page_navigate',
-                    description: 'Navigate page duplicate',
-                    shortDescription: 'Navigate page',
-                    score: 0.6,
-                    domain: 'browser',
-                    isActive: false,
-                },
-            ];
-        };
+    it('invalidates the cached search engine when extension signature changes', async () => {
+        const ctx = createCtx();
         registerSearchMetaTools(ctx);
         const searchHandler = ctx.__registered.get('search_tools').handler;
-        await searchHandler({ query: 'test', top_k: 10 });
-        expect(boostProfile).toHaveBeenCalledWith(expect.anything(), 'workflow');
-    });
-    it('handles extension tools with boostTier', async () => {
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        const ctx = createCtx({ currentTier: 'search' });
+        parseResponse(await searchHandler({ query: 'page', top_k: 5 }));
         ctx.extensionToolsByName.set('custom_tool', {
             name: 'custom_tool',
-            domain: 'custom',
-            tool: tool('custom_tool', 'Custom tool'),
-            boostTier: 'full',
+            domain: 'workflow',
+            tool: tool('custom_tool', 'Custom workflow tool'),
         });
-        state.searchImpl = () => [
-            {
-                name: 'custom_tool',
-                description: 'Custom tool',
-                shortDescription: 'Custom tool',
-                score: 1,
-                domain: 'custom',
-                isActive: false,
-            },
-        ];
+        const second = parseResponse(await searchHandler({ query: 'page', top_k: 5 }));
+        expect(state.constructors).toHaveLength(2);
+        expect(second.results[0].name).toBe('engine_2');
+    });
+    it('invalidates the cached search engine when workflow runtime count changes', async () => {
+        const ctx = createCtx();
         registerSearchMetaTools(ctx);
         const searchHandler = ctx.__registered.get('search_tools').handler;
-        await searchHandler({ query: 'custom', top_k: 5 });
-        expect(boostProfile).toHaveBeenCalledWith(expect.anything(), 'full');
+        parseResponse(await searchHandler({ query: 'network', top_k: 5 }));
+        ctx.extensionWorkflowRuntimeById.set('wf-1', {});
+        parseResponse(await searchHandler({ query: 'network', top_k: 5 }));
+        expect(state.constructors).toHaveLength(2);
+    });
+    it('normalizes namespaced tool names for describe_tool and activate/deactivate_tools', async () => {
+        const extensionHandler = vi.fn();
+        const registeredTool = { remove: vi.fn() };
+        const ctx = createCtx({
+            extensionToolsByName: new Map([
+                [
+                    'custom_tool',
+                    {
+                        name: 'custom_tool',
+                        domain: 'workflow',
+                        tool: tool('custom_tool', 'Custom workflow tool'),
+                        handler: extensionHandler,
+                    },
+                ],
+            ]),
+            registerSingleTool: vi.fn(() => registeredTool),
+        });
+        registerSearchMetaTools(ctx);
+        const describeHandler = ctx.__registered.get('describe_tool').handler;
+        const activateHandler = ctx.__registered.get('activate_tools').handler;
+        const deactivateHandler = ctx.__registered.get('deactivate_tools').handler;
+        expect(parseResponse(await describeHandler({ name: 'mcp__jshook__page_navigate' }))).toEqual({
+            success: true,
+            tool: {
+                name: 'page_navigate',
+                description: 'Navigate a page',
+                inputSchema: { type: 'object', properties: {} },
+            },
+        });
+        expect(parseResponse(await activateHandler({
+            names: ['mcp__jshook__network_get_requests', 'mcp__jshook__custom_tool'],
+        }))).toEqual({
+            success: true,
+            activated: ['network_get_requests', 'custom_tool'],
+            alreadyActive: [],
+            notFound: [],
+            totalActive: 3,
+            hint: 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.',
+        });
+        expect(ctx.activatedToolNames.has('network_get_requests')).toBe(true);
+        expect(ctx.activatedToolNames.has('custom_tool')).toBe(true);
+        expect(parseResponse(await deactivateHandler({
+            names: ['mcp__jshook__custom_tool'],
+        }))).toEqual({
+            success: true,
+            deactivated: ['custom_tool'],
+            notActivated: [],
+            hint: 'Deactivated tools are no longer available. Search again to find alternatives.',
+        });
     });
-    it('transparently handles boostProfile throwing an exception', async () => {
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        boostProfile.mockRejectedValueOnce(new Error('Network error'));
-        const ctx = createCtx({ currentTier: 'search' });
+    it('auto-activates route_tool recommendations and returns canonical activated names', async () => {
+        const ctx = createCtx({
+            selectedTools: [],
+            registerSingleTool: vi.fn(() => ({ remove: vi.fn() })),
+        });
         registerSearchMetaTools(ctx);
-        const searchHandler = ctx.__registered.get('search_tools').handler;
+        const routeHandler = ctx.__registered.get('route_tool').handler;
         state.searchImpl = () => [
             {
                 name: 'page_navigate',
-                description: 'Navigate to a page',
-                shortDescription: 'Navigate to a page',
+                description: 'Navigate a page',
+                shortDescription: 'Navigate a page',
                 score: 1,
                 domain: 'browser',
                 isActive: false,
             },
         ];
-        const response = parseResponse(await searchHandler({ query: 'page', top_k: 5 }));
-        expect(boostProfile).toHaveBeenCalled();
-        expect(response.boostAttempted).toBeUndefined();
-        expect(response.boostedToTier).toBeUndefined();
-        expect(response.boostError).toBeUndefined();
-        expect(response.resultCount).toBe(1);
+        const response = parseResponse(await routeHandler({ task: 'inspect page state' }));
+        expect(response.autoActivated).toBe(true);
+        expect(response.activatedNames).toEqual(['browser_launch', 'page_navigate']);
+        expect(response.recommendations[0]).toMatchObject({
+            name: 'browser_launch',
+            isActive: true,
+        });
+        expect(response.recommendations[1]).toMatchObject({
+            name: 'page_navigate',
+            isActive: true,
+        });
+        expect(response.nextActions[0]).toEqual({
+            step: 1,
+            action: 'call',
+            toolName: 'browser_launch',
+            command: 'browser_launch',
+            exampleArgs: {},
+            description: 'Call browser_launch. Use describe_tool("browser_launch") only if you need the full schema.',
+        });
     });
-    it('does not boost when all search results are already active', async () => {
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        const ctx = createCtx({ currentTier: 'search' });
-        ctx.activatedToolNames.add('page_navigate');
+    it('route_tool prioritizes browser bootstrap and downranks maintenance noise when no active page exists', async () => {
+        const ctx = createCtx({
+            selectedTools: [],
+            pageController: {
+                getPage: vi.fn(async () => {
+                    throw new Error('no page');
+                }),
+            },
+            consoleMonitor: {
+                getNetworkStatus: vi.fn(() => ({ enabled: false })),
+                getNetworkRequests: vi.fn(() => []),
+            },
+        });
+        registerSearchMetaTools(ctx);
+        const routeHandler = ctx.__registered.get('route_tool').handler;
         state.searchImpl = () => [
             {
-                name: 'page_navigate',
-                description: 'Navigate to a page',
-                shortDescription: 'Navigate to a page',
-                score: 1,
-                domain: 'browser',
-                isActive: true,
+                name: 'get_token_budget_stats',
+                description: 'Inspect token budget state',
+                shortDescription: 'Inspect token budget state',
+                score: 50,
+                domain: 'maintenance',
+                isActive: false,
+            },
+            {
+                name: 'network_get_requests',
+                description: 'Inspect network requests',
+                shortDescription: 'Inspect network requests',
+                score: 20,
+                domain: 'network',
+                isActive: false,
             },
         ];
-        registerSearchMetaTools(ctx);
-        const searchHandler = ctx.__registered.get('search_tools').handler;
-        await searchHandler({ query: 'page', top_k: 5 });
-        expect(boostProfile).not.toHaveBeenCalled();
+        const response = parseResponse(await routeHandler({
+            task: 'capture network traffic for this page',
+            context: { autoActivate: false },
+        }));
+        expect(response.recommendations[0].name).toBe('browser_launch');
+        expect(response.recommendations.slice(0, 2).map((item) => item.name)).not.toContain('get_token_budget_stats');
+        expect(response.nextActions[0]).toEqual({
+            step: 1,
+            action: 'activate',
+            toolName: undefined,
+            command: 'activate_tools with names: ["browser_launch", "network_enable", "page_navigate", "network_get_requests"]',
+            description: 'Activate 4 recommended tools',
+        });
     });
-    it('does not boost when tools have no tier information', async () => {
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        const ctx = createCtx({ currentTier: 'search' });
+    it('route_tool prioritizes network_enable when a page exists but monitoring is still off', async () => {
+        const ctx = createCtx({
+            selectedTools: [],
+            pageController: {
+                getPage: vi.fn(async () => ({})),
+            },
+            consoleMonitor: {
+                getNetworkStatus: vi.fn(() => ({ enabled: false })),
+                getNetworkRequests: vi.fn(() => []),
+            },
+        });
+        registerSearchMetaTools(ctx);
+        const routeHandler = ctx.__registered.get('route_tool').handler;
         state.searchImpl = () => [
             {
-                name: 'unknown_tool_1',
-                description: 'Unknown tool',
-                shortDescription: 'Unknown tool',
-                score: 1,
-                domain: 'unknown',
+                name: 'network_get_requests',
+                description: 'Inspect network requests',
+                shortDescription: 'Inspect network requests',
+                score: 10,
+                domain: 'network',
+                isActive: false,
+            },
+            {
+                name: 'get_token_budget_stats',
+                description: 'Inspect token budget state',
+                shortDescription: 'Inspect token budget state',
+                score: 9,
+                domain: 'maintenance',
                 isActive: false,
             },
         ];
-        registerSearchMetaTools(ctx);
-        const searchHandler = ctx.__registered.get('search_tools').handler;
-        await searchHandler({ query: 'unknown', top_k: 5 });
-        expect(boostProfile).not.toHaveBeenCalled();
-    });
-    it('does not boost when already at higher tier', async () => {
-        const { boostProfile } = await import('../../src/server/MCPServer.boost.js');
-        const ctx = createCtx({ currentTier: 'full' });
-        registerSearchMetaTools(ctx);
-        const searchHandler = ctx.__registered.get('search_tools').handler;
-        await searchHandler({ query: 'page', top_k: 5 });
-        expect(boostProfile).not.toHaveBeenCalled();
+        const response = parseResponse(await routeHandler({
+            task: 'capture network traffic for this page',
+            context: { autoActivate: false },
+        }));
+        expect(response.recommendations[0].name).toBe('network_enable');
     });
-    it('invalidates the cached search engine when extension signature changes', async () => {
-        const ctx = createCtx();
-        registerSearchMetaTools(ctx);
-        const searchHandler = ctx.__registered.get('search_tools').handler;
-        parseResponse(await searchHandler({ query: 'page', top_k: 5 }));
-        ctx.extensionToolsByName.set('custom_tool', {
-            name: 'custom_tool',
-            domain: 'workflow',
-            tool: tool('custom_tool', 'Custom workflow tool'),
+    it('route_tool prioritizes network_get_requests when requests are already available', async () => {
+        const ctx = createCtx({
+            selectedTools: [],
+            pageController: {
+                getPage: vi.fn(async () => ({})),
+            },
+            consoleMonitor: {
+                getNetworkStatus: vi.fn(() => ({ enabled: true })),
+                getNetworkRequests: vi.fn(() => [{ id: '1' }]),
+            },
         });
-        const second = parseResponse(await searchHandler({ query: 'page', top_k: 5 }));
-        expect(state.constructors).toHaveLength(2);
-        expect(second.results[0].name).toBe('engine_2');
-    });
-    it('invalidates the cached search engine when the current tier changes', async () => {
-        const ctx = createCtx();
         registerSearchMetaTools(ctx);
-        const searchHandler = ctx.__registered.get('search_tools').handler;
-        parseResponse(await searchHandler({ query: 'network', top_k: 5 }));
-        ctx.currentTier = 'workflow';
-        parseResponse(await searchHandler({ query: 'network', top_k: 5 }));
-        expect(state.constructors).toHaveLength(2);
-    });
-    it('invalidates the cached search engine when workflow runtime count changes', async () => {
-        const ctx = createCtx();
-        registerSearchMetaTools(ctx);
-        const searchHandler = ctx.__registered.get('search_tools').handler;
-        parseResponse(await searchHandler({ query: 'network', top_k: 5 }));
-        ctx.extensionWorkflowRuntimeById.set('wf-1', {});
-        parseResponse(await searchHandler({ query: 'network', top_k: 5 }));
-        expect(state.constructors).toHaveLength(2);
+        const routeHandler = ctx.__registered.get('route_tool').handler;
+        state.searchImpl = () => [
+            {
+                name: 'get_token_budget_stats',
+                description: 'Inspect token budget state',
+                shortDescription: 'Inspect token budget state',
+                score: 20,
+                domain: 'maintenance',
+                isActive: false,
+            },
+            {
+                name: 'page_navigate',
+                description: 'Navigate a page',
+                shortDescription: 'Navigate a page',
+                score: 10,
+                domain: 'browser',
+                isActive: false,
+            },
+        ];
+        const response = parseResponse(await routeHandler({
+            task: 'capture network traffic for this page',
+            context: { autoActivate: false },
+        }));
+        expect(response.recommendations[0].name).toBe('network_get_requests');
     });
     it('rejects invalid activate_tools and deactivate_tools payloads', async () => {
         const ctx = createCtx();
@@ -507,8 +564,9 @@ describe('MCPServer.search', () => {
             alreadyActive: ['page_navigate'],
             notFound: ['missing_tool'],
             totalActive: 4,
+            hint: 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.',
         });
-        expect(ctx.enabledDomains).toEqual(new Set(['network', 'workflow']));
+        expect(ctx.enabledDomains).toEqual(new Set(['browser', 'network', 'workflow']));
         expect(vi.mocked(createToolHandlerMap)).toHaveBeenCalledWith(ctx.handlerDeps, new Set(['network_get_requests']));
         expect(ctx.router.addHandlers).toHaveBeenCalledWith({});
         expect(ctx.router.addHandlers).toHaveBeenCalledWith({ custom_tool: extensionHandler });
@@ -590,6 +648,8 @@ describe('MCPServer.search', () => {
             activated: 2,
             activatedTools: ['page_navigate', 'custom_tool'],
             totalDomainTools: 3,
+            ttlMinutes: 30,
+            hint: 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.',
         });
         expect(second).toEqual({
             success: true,
@@ -597,6 +657,7 @@ describe('MCPServer.search', () => {
             activated: 0,
             activatedTools: [],
             totalDomainTools: 3,
+            ttlMinutes: 30,
         });
         expect(ctx.enabledDomains.has('browser')).toBe(true);
         expect(vi.mocked(createToolHandlerMap)).toHaveBeenCalledWith(ctx.handlerDeps, new Set(['page_navigate']));
@@ -630,20 +691,27 @@ describe('MCPServer.search', () => {
             activated: 1,
             activatedTools: ['custom_tool'],
             totalDomainTools: 1,
+            ttlMinutes: 30,
+            hint: 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.',
         });
         expect(vi.mocked(createToolHandlerMap)).not.toHaveBeenCalled();
         expect(ctx.router.addHandlers).toHaveBeenCalledWith({ custom_tool: extensionHandler });
     });
-    it('proxies extension listing and reload results', async () => {
+    it('activate_domain with ttlMinutes=0 passes no-expiry', async () => {
         const ctx = createCtx({
-            listExtensions: vi.fn(() => ({ success: true, plugins: ['a'] })),
-            reloadExtensions: vi.fn(async () => ({ success: true, reloaded: 2 })),
+            registerSingleTool: vi.fn(() => ({ remove: vi.fn() })),
         });
         registerSearchMetaTools(ctx);
-        const listHandler = ctx.__registered.get('extensions_list').handler;
-        const reloadHandler = ctx.__registered.get('extensions_reload').handler;
-        expect(parseResponse(await listHandler({}))).toEqual({ success: true, plugins: ['a'] });
-        expect(parseResponse(await reloadHandler({}))).toEqual({ success: true, reloaded: 2 });
+        const activateDomainHandler = ctx.__registered.get('activate_domain').handler;
+        const response = parseResponse(await activateDomainHandler({ domain: 'browser', ttlMinutes: 0 }));
+        expect(response.ttlMinutes).toBe('no expiry');
+        expect(response.activated).toBeGreaterThan(0);
+    });
+    it('does not register extensions_list or extensions_reload as search meta-tools', async () => {
+        const ctx = createCtx();
+        registerSearchMetaTools(ctx);
+        expect(ctx.__registered.has('extensions_list')).toBe(false);
+        expect(ctx.__registered.has('extensions_reload')).toBe(false);
     });
     it('wraps search_tools failures as error responses', async () => {
         const ctx = createCtx();
@@ -696,28 +764,4 @@ describe('MCPServer.search', () => {
         expect(response.isError).toBe(true);
         expect(response.content[0].text).toBe('Error: domain exploded');
     });
-    it('wraps extensions_list failures as error responses', async () => {
-        const ctx = createCtx({
-            listExtensions: vi.fn(() => {
-                throw new Error('list exploded');
-            }),
-        });
-        registerSearchMetaTools(ctx);
-        const listHandler = ctx.__registered.get('extensions_list').handler;
-        const response = await listHandler({});
-        expect(response.isError).toBe(true);
-        expect(response.content[0].text).toBe('Error: list exploded');
-    });
-    it('wraps extensions_reload failures as error responses', async () => {
-        const ctx = createCtx({
-            reloadExtensions: vi.fn(async () => {
-                throw new Error('reload exploded');
-            }),
-        });
-        registerSearchMetaTools(ctx);
-        const reloadHandler = ctx.__registered.get('extensions_reload').handler;
-        const response = await reloadHandler({});
-        expect(response.isError).toBe(true);
-        expect(response.content[0].text).toBe('Error: reload exploded');
-    });
 });