@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/server/ToolRouter.js

@@ -2,53 +2,57 @@ import { logger } from '../utils/logger.js';
 import { allTools, getToolDomain } from './ToolCatalog.js';
 import { getActiveToolNames } from './MCPServer.search.helpers.js';
 import { normalizeToolName } from './MCPServer.search.validation.js';
-const WORKFLOW_RULES = [
-    {
-        patterns: [
-            /(capture|intercept|monitor|hook).*(network|request|response|api|traffic)/i,
-            /(抓包|拦截|监控|hook).*(网络|请求|响应|api|流量)/i,
-        ],
-        domain: 'network',
-        priority: 100,
-        tools: ['web_api_capture_session', 'network_enable', 'page_navigate', 'network_get_requests'],
-        hint: 'Network capture workflow: bootstrap browser/page state -> enable capture -> navigate or act -> inspect captured requests',
-    },
-    {
-        patterns: [
-            /(browser|page|navigate|screenshot|click|type|scrape)/i,
-            /(浏览器|页面|导航|截图|点击|输入|爬取)/i,
-        ],
-        domain: 'browser',
-        priority: 90,
-        tools: ['page_navigate', 'page_screenshot', 'page_click', 'page_type', 'page_evaluate'],
-        hint: 'Browser automation workflow: bootstrap browser/page state -> navigate -> interact -> extract data',
-    },
-    {
-        patterns: [
-            /(deobfuscate|deobfusc|beautify|analyze).*(javascript|js|script|code)/i,
-            /(反混淆|美化|分析).*(javascript|js|脚本|代码)/i,
-        ],
-        domain: 'core',
-        priority: 85,
-        tools: ['deobfuscate', 'advanced_deobfuscate', 'extract_function_tree'],
-        hint: 'JavaScript analysis workflow: collect -> deobfuscate -> inspect function tree',
-    },
-    {
-        patterns: [
-            /(workflow|extension|run)/i,
-            /(工作流|扩展|运行)/i,
-        ],
-        domain: 'workflow',
-        priority: 95,
-        tools: ['run_extension_workflow', 'list_extension_workflows'],
-        hint: 'Extension workflow: list available workflows -> run the best matching workflow',
-    },
-];
+import {} from './ToolSearch.js';
+import { getAllManifests } from './registry/index.js';
+let _allToolsByName = null;
+function getAllToolsByName() {
+    if (!_allToolsByName)
+        _allToolsByName = new Map(allTools.map((t) => [t.name, t]));
+    return _allToolsByName;
+}
+let _cachedWorkflowRules = null;
+function getEffectiveWorkflowRules() {
+    if (_cachedWorkflowRules)
+        return _cachedWorkflowRules;
+    const rules = [];
+    for (const m of getAllManifests()) {
+        if (m.workflowRule) {
+            rules.push({
+                patterns: [...m.workflowRule.patterns],
+                domain: m.domain,
+                priority: m.workflowRule.priority,
+                tools: [...m.workflowRule.tools],
+                hint: m.workflowRule.hint,
+            });
+        }
+    }
+    _cachedWorkflowRules = rules.sort((a, b) => b.priority - a.priority);
+    return _cachedWorkflowRules;
+}
 const BROWSER_OR_NETWORK_TASK_PATTERN = /(browser|page|navigate|click|type|screenshot|scrape|network|request|response|api|traffic|hook|capture|intercept|monitor|浏览器|页面|导航|点击|输入|截图|爬取|网络|请求|响应|接口|流量|抓包|拦截|监控)/i;
 const MAINTENANCE_TASK_PATTERN = /(token budget|cache|artifact|extension|plugin|reload|doctor|cleanup|memory|profile|tool list|令牌预算|缓存|工件|扩展|插件|重载|环境诊断|清理|内存|配置)/i;
+let _cachedPrerequisites = null;
+function getEffectivePrerequisites() {
+    if (_cachedPrerequisites)
+        return _cachedPrerequisites;
+    const merged = {};
+    for (const m of getAllManifests()) {
+        if (m.prerequisites) {
+            for (const [toolName, entries] of Object.entries(m.prerequisites)) {
+                merged[toolName] = entries.map((e) => ({
+                    condition: e.condition,
+                    check: () => false,
+                    fix: e.fix,
+                }));
+            }
+        }
+    }
+    _cachedPrerequisites = merged;
+    return _cachedPrerequisites;
+}
 function detectWorkflowIntent(query) {
     const matches = [];
-    for (const rule of WORKFLOW_RULES) {
+    for (const rule of getEffectiveWorkflowRules()) {
         for (const pattern of rule.patterns) {
             if (pattern.test(query)) {
                 matches.push(rule);
@@ -63,7 +67,7 @@ function detectWorkflowIntent(query) {
 }
 function getToolInputSchema(toolName, ctx) {
     const canonicalName = normalizeToolName(toolName);
-    const builtInTool = allTools.find((tool) => tool.name === canonicalName);
+    const builtInTool = getAllToolsByName().get(canonicalName);
     if (builtInTool) {
         return builtInTool.inputSchema;
     }
@@ -71,11 +75,15 @@ function getToolInputSchema(toolName, ctx) {
     if (extTool) {
         return extTool.tool.inputSchema;
     }
+    const metaTool = ctx.metaToolsByName.get(canonicalName);
+    if (metaTool) {
+        return metaTool.inputSchema;
+    }
     return undefined;
 }
 function getToolDescription(toolName, ctx) {
     const canonicalName = normalizeToolName(toolName);
-    const builtInTool = allTools.find((tool) => tool.name === canonicalName);
+    const builtInTool = getAllToolsByName().get(canonicalName);
     if (builtInTool?.description) {
         return builtInTool.description.split('\n')[0] || 'No description available';
     }
@@ -83,6 +91,10 @@ function getToolDescription(toolName, ctx) {
     if (extTool?.tool?.description) {
         return extTool.tool.description.split('\n')[0] || 'No description available';
     }
+    const metaTool = ctx.metaToolsByName.get(canonicalName);
+    if (metaTool?.description) {
+        return metaTool.description.split('\n')[0] || 'No description available';
+    }
     return 'No description available';
 }
 function isActive(toolName, ctx) {
@@ -94,61 +106,54 @@ function isActive(toolName, ctx) {
     return activeTools.has(canonicalName);
 }
 function getAvailableToolNames(ctx) {
-    return new Set([
-        ...allTools.map((tool) => tool.name),
-        ...ctx.extensionToolsByName.keys(),
-    ]);
+    return new Set([...allTools.map((tool) => tool.name), ...ctx.extensionToolsByName.keys()]);
 }
-async function getRoutingState(ctx) {
-    let hasActivePage = false;
-    if (ctx.pageController && typeof ctx.pageController.getPage === 'function') {
-        try {
-            hasActivePage = Boolean(await ctx.pageController.getPage());
-        }
-        catch {
-            hasActivePage = false;
-        }
+async function probeActivePage(ctx) {
+    if (!ctx.pageController || typeof ctx.pageController.getPage !== 'function')
+        return false;
+    try {
+        return Boolean(await ctx.pageController.getPage());
     }
-    let networkEnabled = false;
-    let capturedRequestCount = 0;
-    if (ctx.consoleMonitor) {
-        try {
-            if (typeof ctx.consoleMonitor.getNetworkStatus === 'function') {
-                networkEnabled = Boolean(ctx.consoleMonitor.getNetworkStatus().enabled);
-            }
-            else if (typeof ctx.consoleMonitor.isNetworkEnabled === 'function') {
-                networkEnabled = Boolean(ctx.consoleMonitor.isNetworkEnabled());
-            }
+    catch {
+        return false;
+    }
+}
+function probeNetworkEnabled(ctx) {
+    if (!ctx.consoleMonitor)
+        return false;
+    try {
+        if (typeof ctx.consoleMonitor.getNetworkStatus === 'function') {
+            return Boolean(ctx.consoleMonitor.getNetworkStatus().enabled);
         }
-        catch {
-            networkEnabled = false;
+        if (typeof ctx.consoleMonitor.isNetworkEnabled === 'function') {
+            return Boolean(ctx.consoleMonitor.isNetworkEnabled());
         }
+    }
+    catch { }
+    return false;
+}
+function probeCapturedRequests(ctx) {
+    if (!ctx.consoleMonitor || typeof ctx.consoleMonitor.getNetworkRequests !== 'function')
+        return 0;
+    try {
+        const requests = ctx.consoleMonitor.getNetworkRequests({ limit: 1 });
+        return Array.isArray(requests) ? requests.length : 0;
+    }
+    catch {
         try {
-            if (typeof ctx.consoleMonitor.getNetworkRequests === 'function') {
-                const requests = ctx.consoleMonitor.getNetworkRequests({ limit: 1 });
-                if (Array.isArray(requests)) {
-                    capturedRequestCount = requests.length;
-                }
-            }
+            const requests = ctx.consoleMonitor.getNetworkRequests();
+            return Array.isArray(requests) ? requests.length : 0;
         }
         catch {
-            try {
-                if (typeof ctx.consoleMonitor.getNetworkRequests === 'function') {
-                    const requests = ctx.consoleMonitor.getNetworkRequests();
-                    if (Array.isArray(requests)) {
-                        capturedRequestCount = requests.length;
-                    }
-                }
-            }
-            catch {
-                capturedRequestCount = 0;
-            }
+            return 0;
         }
     }
+}
+async function getRoutingState(ctx) {
     return {
-        hasActivePage,
-        networkEnabled,
-        capturedRequestCount,
+        hasActivePage: await probeActivePage(ctx),
+        networkEnabled: probeNetworkEnabled(ctx),
+        capturedRequestCount: probeCapturedRequests(ctx),
     };
 }
 function buildWorkflowToolSequence(workflow, state, availableToolNames) {
@@ -179,9 +184,9 @@ function buildWorkflowToolSequence(workflow, state, availableToolNames) {
     return sequence;
 }
 function isBrowserOrNetworkTask(task, workflow) {
-    return workflow?.domain === 'browser' ||
+    return (workflow?.domain === 'browser' ||
         workflow?.domain === 'network' ||
-        BROWSER_OR_NETWORK_TASK_PATTERN.test(task);
+        BROWSER_OR_NETWORK_TASK_PATTERN.test(task));
 }
 function isMaintenanceTask(task) {
     return MAINTENANCE_TASK_PATTERN.test(task);
@@ -204,7 +209,10 @@ function rerankResultsForContext(results, task, workflow, state) {
             if (state.hasActivePage && !state.networkEnabled && result.name === 'network_enable') {
                 score *= 1.35;
             }
-            if (state.hasActivePage && state.networkEnabled && state.capturedRequestCount > 0 && result.name === 'network_get_requests') {
+            if (state.hasActivePage &&
+                state.networkEnabled &&
+                state.capturedRequestCount > 0 &&
+                result.name === 'network_get_requests') {
                 score *= 1.5;
             }
         }
@@ -224,7 +232,7 @@ export async function routeToolRequest(request, ctx, searchEngine) {
     const activeNames = getActiveToolNames(ctx);
     const routingState = await getRoutingState(ctx);
     const availableToolNames = getAvailableToolNames(ctx);
-    const searchResults = searchEngine.search(task, maxRecommendations * 2, activeNames);
+    const searchResults = await searchEngine.search(task, maxRecommendations * 2, activeNames);
     let finalResults = [];
     if (workflow) {
         const workflowSequence = buildWorkflowToolSequence(workflow, routingState, availableToolNames);
@@ -232,7 +240,7 @@ export async function routeToolRequest(request, ctx, searchEngine) {
             name,
             domain: getToolDomain(name) ?? ctx.extensionToolsByName.get(name)?.domain ?? null,
             shortDescription: getToolDescription(name, ctx),
-            score: workflow.priority - (index * 0.01),
+            score: workflow.priority - index * 0.01,
             isActive: isActive(name, ctx),
         }));
         const workflowNames = new Set(workflowSequence);
@@ -276,6 +284,14 @@ export async function routeToolRequest(request, ctx, searchEngine) {
         if (!toolIsActive) {
             recommendation.activationCommand = `activate_tools with names: ["${result.name}"]`;
         }
+        const prereqs = getEffectivePrerequisites()[result.name];
+        if (prereqs && prereqs.length > 0) {
+            recommendation.prerequisites = prereqs.map((p) => ({
+                condition: p.condition,
+                satisfied: p.check(routingState),
+                fix: p.fix,
+            }));
+        }
         return recommendation;
     });
     const nextActions = [];
@@ -326,7 +342,7 @@ export function buildCallToolCommand(toolName, schema) {
     return `call_tool({ name: "${toolName}", args: ${JSON.stringify(generateExampleArgs(schema))} })`;
 }
 export function generateExampleArgs(schema) {
-    if (!schema || schema.type !== 'object' || !schema.properties) {
+    if (schema?.type !== 'object' || !schema.properties) {
         return {};
     }
     const example = {};

package/dist/src/server/activation/ActivationController.d.ts

@@ -0,0 +1,35 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { EventBus, ServerEventMap } from '../EventBus.js';
+import type { MCPServerContext } from '../MCPServer.context.js';
+import type { ActivationControllerOptions, EventRecord } from './types.js';
+import { PredictiveBooster } from './PredictiveBooster.js';
+import { AutoPruner } from './AutoPruner.js';
+export declare function getPlatformFilteredTools(tools: Tool[]): Tool[];
+export declare class ActivationController {
+    private readonly eventBus;
+    private readonly ctx;
+    private readonly cooldownMs;
+    private readonly boostRules;
+    private readonly unsubscribers;
+    private readonly lastBoostTime;
+    private readonly lastActivity;
+    private readonly eventHistory;
+    private readonly maxEventHistory;
+    private toolCallCount;
+    private readonly compoundEngine;
+    private readonly predictiveBooster;
+    private readonly autoPruner;
+    private disposed;
+    constructor(eventBus: EventBus<ServerEventMap>, ctx: MCPServerContext, options?: ActivationControllerOptions);
+    private subscribe;
+    private recordEvent;
+    private evaluateBoostRules;
+    private attemptBoost;
+    private evaluateCompoundConditions;
+    getLastActivity(domain: string): number | undefined;
+    getEventHistory(): readonly EventRecord[];
+    getLastBoostTime(domain: string): number | undefined;
+    getPredictiveBooster(): PredictiveBooster;
+    getAutoPruner(): AutoPruner;
+    dispose(): void;
+}

package/dist/src/server/activation/ActivationController.js

@@ -0,0 +1,188 @@
+import { CompoundConditionEngine } from './CompoundConditionEngine.js';
+import { PredictiveBooster } from './PredictiveBooster.js';
+import { AutoPruner } from './AutoPruner.js';
+import { getToolDomain, getProfileDomains } from '../ToolCatalog.js';
+import { logger } from '../../utils/logger.js';
+const DEFAULT_BOOST_RULES = [
+    {
+        eventPattern: 'debugger:breakpoint_hit',
+        targetDomains: ['debugger'],
+        threshold: 1,
+        windowMs: 60_000,
+        priority: 10,
+    },
+    {
+        eventPattern: 'browser:navigated',
+        targetDomains: ['browser'],
+        threshold: 1,
+        windowMs: 60_000,
+        priority: 10,
+    },
+    {
+        eventPattern: 'memory:scan_completed',
+        targetDomains: ['memory'],
+        threshold: 1,
+        windowMs: 60_000,
+        priority: 10,
+    },
+];
+const WIN32_ONLY_TOOL_PREFIXES = [
+    'pe_',
+    'anticheat_',
+    'speedhack_',
+    'hw_breakpoint_',
+    'inject_',
+];
+export function getPlatformFilteredTools(tools) {
+    const platform = process.platform;
+    if (platform === 'win32') {
+        return tools;
+    }
+    return tools.filter((tool) => {
+        return !WIN32_ONLY_TOOL_PREFIXES.some((prefix) => tool.name.startsWith(prefix));
+    });
+}
+export class ActivationController {
+    eventBus;
+    ctx;
+    cooldownMs;
+    boostRules;
+    unsubscribers = [];
+    lastBoostTime = new Map();
+    lastActivity = new Map();
+    eventHistory = [];
+    maxEventHistory = 200;
+    toolCallCount = 0;
+    compoundEngine;
+    predictiveBooster;
+    autoPruner;
+    disposed = false;
+    constructor(eventBus, ctx, options = {}) {
+        this.eventBus = eventBus;
+        this.ctx = ctx;
+        this.cooldownMs = options.cooldownMs ?? 30_000;
+        const customRules = options.boostRules ?? [];
+        this.boostRules = [...DEFAULT_BOOST_RULES, ...customRules].sort((a, b) => b.priority - a.priority);
+        this.compoundEngine = new CompoundConditionEngine();
+        this.predictiveBooster = new PredictiveBooster();
+        const baseDomains = new Set(getProfileDomains(ctx.baseTier));
+        this.autoPruner = new AutoPruner(eventBus, baseDomains, (domain) => {
+            logger.info(`[ActivationController] Auto-pruning domain "${domain}"`);
+        });
+        this.subscribe();
+        logger.info(`[ActivationController] Initialized with ${this.boostRules.length} boost rules, ` +
+            `cooldown=${this.cooldownMs}ms, platform=${process.platform}, ` +
+            `${this.compoundEngine.conditionCount} compound conditions`);
+    }
+    subscribe() {
+        this.unsubscribers.push(this.eventBus.on('tool:called', (payload) => {
+            this.recordEvent('tool:called', payload);
+            if (payload.domain) {
+                this.lastActivity.set(payload.domain, Date.now());
+                this.autoPruner.recordActivity(payload.domain);
+            }
+            this.predictiveBooster.recordCall(payload.toolName);
+            const predictedDomains = this.predictiveBooster.predictNextDomains(payload.toolName, (name) => getToolDomain(name) ?? null);
+            for (const domain of predictedDomains) {
+                this.attemptBoost(domain, `predictive: ${payload.toolName} → ${domain}`);
+            }
+            this.toolCallCount++;
+            if (this.toolCallCount % 5 === 0) {
+                this.evaluateCompoundConditions();
+            }
+        }));
+        this.unsubscribers.push(this.eventBus.on('debugger:breakpoint_hit', (payload) => {
+            this.recordEvent('debugger:breakpoint_hit', payload);
+            this.evaluateBoostRules('debugger:breakpoint_hit');
+        }));
+        this.unsubscribers.push(this.eventBus.on('browser:navigated', (payload) => {
+            this.recordEvent('browser:navigated', payload);
+            this.evaluateBoostRules('browser:navigated');
+        }));
+        this.unsubscribers.push(this.eventBus.on('memory:scan_completed', (payload) => {
+            this.recordEvent('memory:scan_completed', payload);
+            this.evaluateBoostRules('memory:scan_completed');
+        }));
+    }
+    recordEvent(event, payload) {
+        this.eventHistory.push({ event, timestamp: Date.now(), payload });
+        if (this.eventHistory.length > this.maxEventHistory) {
+            this.eventHistory.splice(0, this.eventHistory.length - this.maxEventHistory);
+        }
+    }
+    evaluateBoostRules(eventName) {
+        const now = Date.now();
+        for (const rule of this.boostRules) {
+            if (!eventName.startsWith(rule.eventPattern))
+                continue;
+            const windowStart = now - rule.windowMs;
+            const matchCount = this.eventHistory.filter((e) => e.event.startsWith(rule.eventPattern) && e.timestamp >= windowStart).length;
+            if (matchCount >= rule.threshold) {
+                for (const domain of rule.targetDomains) {
+                    this.attemptBoost(domain, `rule:${rule.eventPattern} (${matchCount} events)`);
+                }
+            }
+        }
+    }
+    attemptBoost(domain, reason) {
+        if (this.disposed)
+            return;
+        const now = Date.now();
+        const lastBoost = this.lastBoostTime.get(domain) ?? 0;
+        if (now - lastBoost < this.cooldownMs) {
+            return;
+        }
+        if (this.ctx.enabledDomains.has(domain)) {
+            return;
+        }
+        this.lastBoostTime.set(domain, now);
+        logger.info(`[ActivationController] Boosting domain "${domain}" — reason: ${reason}`);
+        void this.eventBus.emit('activation:domain_boosted', {
+            domain,
+            reason,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    evaluateCompoundConditions() {
+        const state = {
+            platform: process.platform,
+            activeDomains: this.ctx.enabledDomains,
+            eventHistory: this.eventHistory,
+            recentToolCalls: this.eventHistory
+                .filter((e) => e.event === 'tool:called')
+                .map((e) => e.payload?.toolName ?? ''),
+        };
+        const domainsToBoost = this.compoundEngine.evaluate(state);
+        for (const domain of domainsToBoost) {
+            this.attemptBoost(domain, `compound condition`);
+        }
+    }
+    getLastActivity(domain) {
+        return this.lastActivity.get(domain);
+    }
+    getEventHistory() {
+        return this.eventHistory;
+    }
+    getLastBoostTime(domain) {
+        return this.lastBoostTime.get(domain);
+    }
+    getPredictiveBooster() {
+        return this.predictiveBooster;
+    }
+    getAutoPruner() {
+        return this.autoPruner;
+    }
+    dispose() {
+        this.disposed = true;
+        for (const unsub of this.unsubscribers) {
+            unsub();
+        }
+        this.unsubscribers.length = 0;
+        this.lastBoostTime.clear();
+        this.lastActivity.clear();
+        this.eventHistory.length = 0;
+        this.autoPruner.dispose();
+        this.predictiveBooster.reset();
+        logger.info('[ActivationController] Disposed');
+    }
+}

package/dist/src/server/activation/AutoPruner.d.ts

@@ -0,0 +1,25 @@
+import type { EventBus, ServerEventMap } from '../EventBus.js';
+export interface AutoPruneConfig {
+    autoActivatedInactivityMs?: number;
+    manualActivatedInactivityMs?: number;
+    checkIntervalMs?: number;
+}
+export declare class AutoPruner {
+    private readonly lastActivity;
+    private readonly baseDomains;
+    private readonly autoActivatedDomains;
+    private readonly autoInactivityMs;
+    private readonly manualInactivityMs;
+    private readonly checkIntervalMs;
+    private checkTimer;
+    private readonly eventBus;
+    private readonly onPrune;
+    constructor(eventBus: EventBus<ServerEventMap>, baseDomains: Set<string>, onPrune: (domain: string) => void, config?: AutoPruneConfig);
+    recordActivity(domain: string): void;
+    markAutoActivated(domain: string): void;
+    private startCheckTimer;
+    private checkAndPrune;
+    getLastActivity(domain: string): number | undefined;
+    isAutoActivated(domain: string): boolean;
+    dispose(): void;
+}

package/dist/src/server/activation/AutoPruner.js

@@ -0,0 +1,73 @@
+import { logger } from '../../utils/logger.js';
+export class AutoPruner {
+    lastActivity = new Map();
+    baseDomains;
+    autoActivatedDomains = new Set();
+    autoInactivityMs;
+    manualInactivityMs;
+    checkIntervalMs;
+    checkTimer = null;
+    eventBus;
+    onPrune;
+    constructor(eventBus, baseDomains, onPrune, config = {}) {
+        this.eventBus = eventBus;
+        this.baseDomains = baseDomains;
+        this.onPrune = onPrune;
+        this.autoInactivityMs = config.autoActivatedInactivityMs ?? 5 * 60_000;
+        this.manualInactivityMs = config.manualActivatedInactivityMs ?? 15 * 60_000;
+        this.checkIntervalMs = config.checkIntervalMs ?? 60_000;
+        this.startCheckTimer();
+    }
+    recordActivity(domain) {
+        this.lastActivity.set(domain, Date.now());
+    }
+    markAutoActivated(domain) {
+        this.autoActivatedDomains.add(domain);
+        this.lastActivity.set(domain, Date.now());
+    }
+    startCheckTimer() {
+        this.checkTimer = setInterval(() => {
+            this.checkAndPrune();
+        }, this.checkIntervalMs);
+        if (this.checkTimer.unref) {
+            this.checkTimer.unref();
+        }
+    }
+    checkAndPrune() {
+        const now = Date.now();
+        for (const [domain, lastTime] of this.lastActivity.entries()) {
+            if (this.baseDomains.has(domain))
+                continue;
+            const inactivityMs = now - lastTime;
+            const threshold = this.autoActivatedDomains.has(domain)
+                ? this.autoInactivityMs
+                : this.manualInactivityMs;
+            if (inactivityMs >= threshold) {
+                logger.info(`[AutoPruner] Pruning domain "${domain}" — inactive for ${Math.round(inactivityMs / 1000)}s ` +
+                    `(threshold: ${Math.round(threshold / 1000)}s)`);
+                this.onPrune(domain);
+                this.lastActivity.delete(domain);
+                this.autoActivatedDomains.delete(domain);
+                void this.eventBus.emit('activation:domain_pruned', {
+                    domain,
+                    reason: `inactivity (${Math.round(inactivityMs / 1000)}s)`,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+        }
+    }
+    getLastActivity(domain) {
+        return this.lastActivity.get(domain);
+    }
+    isAutoActivated(domain) {
+        return this.autoActivatedDomains.has(domain);
+    }
+    dispose() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = null;
+        }
+        this.lastActivity.clear();
+        this.autoActivatedDomains.clear();
+    }
+}

package/dist/src/server/activation/CompoundConditionEngine.d.ts

@@ -0,0 +1,38 @@
+import type { EventRecord } from './types.js';
+export type ConditionPredicate = {
+    type: 'platform';
+    value: NodeJS.Platform;
+} | {
+    type: 'domain_active';
+    domain: string;
+} | {
+    type: 'event_count';
+    event: string;
+    minCount: number;
+    windowMs: number;
+} | {
+    type: 'tool_called_recently';
+    toolName: string;
+    withinMs: number;
+};
+export interface CompoundCondition {
+    id: string;
+    name: string;
+    conditions: ConditionPredicate[];
+    boostDomains: string[];
+    priority: number;
+}
+export interface ConditionState {
+    platform: NodeJS.Platform;
+    activeDomains: Set<string>;
+    eventHistory: readonly EventRecord[];
+    recentToolCalls: readonly string[];
+}
+export declare class CompoundConditionEngine {
+    private readonly conditions;
+    constructor(customConditions?: CompoundCondition[]);
+    evaluate(state: ConditionState): string[];
+    private allConditionsMet;
+    private evaluatePredicate;
+    get conditionCount(): number;
+}