claude-flow 3.32.35 → 3.32.37

package/v3/@claude-flow/cli/dist/src/commands/hooks.js

@@ -1218,8 +1218,20 @@ const metricsCommand = {
             const totalPatterns = safeNum(rawMetrics.patterns?.total ?? rawMetrics.summary?.patternsLearned);
             const successfulPatterns = safeNum(rawMetrics.patterns?.successful ?? Math.round(safeNum(rawMetrics.summary?.successRate) * totalPatterns));
             const failedPatterns = Math.max(0, safeNum(rawMetrics.patterns?.failed ?? totalPatterns - successfulPatterns));
+            const unknownPatterns = Math.max(0, safeNum(rawMetrics.patterns?.unknown));
+            const describedPatterns = Math.max(0, safeNum(rawMetrics.patterns?.described));
+            const descriptionCoverage = safeNum(rawMetrics.patterns?.descriptionCoverage ??
+                (totalPatterns > 0 ? describedPatterns / totalPatterns : 0));
             const avgConfidence = safeNum(rawMetrics.patterns?.avgConfidence ?? rawMetrics.summary?.avgQuality);
-            const routingAccuracy = safeNum(rawMetrics.agents?.routingAccuracy ?? rawMetrics.routing?.avgConfidence);
+            const routingAccuracy = rawMetrics.agents?.routingAccuracy == null
+                ? null
+                : safeNum(rawMetrics.agents.routingAccuracy);
+            const averageRoutingConfidence = safeNum(rawMetrics.agents?.averageConfidence ??
+                rawMetrics.routing?.avgConfidence ??
+                rawMetrics.patterns?.avgConfidence);
+            const routingOutcomeSuccessRate = rawMetrics.agents?.outcomeSuccessRate == null
+                ? null
+                : safeNum(rawMetrics.agents.outcomeSuccessRate);
             const totalRoutes = safeNum(rawMetrics.agents?.totalRoutes ?? rawMetrics.routing?.totalRoutes);
             const topAgent = rawMetrics.agents?.topAgent ?? rawMetrics.routing?.topAgents?.[0]?.agent ?? 'n/a';
             const totalCommands = safeNum(rawMetrics.commands?.totalExecuted ?? rawMetrics.commands?.totalCommands);
@@ -1227,8 +1239,22 @@ const metricsCommand = {
             const avgRiskScore = safeNum(rawMetrics.commands?.avgRiskScore ?? rawMetrics.commands?.avgExecutionTime);
             const result = {
                 ...rawMetrics,
-                patterns: { total: totalPatterns, successful: successfulPatterns, failed: failedPatterns, avgConfidence },
-                agents: { routingAccuracy, totalRoutes, topAgent },
+                patterns: {
+                    total: totalPatterns,
+                    successful: successfulPatterns,
+                    failed: failedPatterns,
+                    unknown: unknownPatterns,
+                    described: describedPatterns,
+                    descriptionCoverage,
+                    avgConfidence,
+                },
+                agents: {
+                    routingAccuracy,
+                    averageConfidence: averageRoutingConfidence,
+                    outcomeSuccessRate: routingOutcomeSuccessRate,
+                    totalRoutes,
+                    topAgent,
+                },
                 commands: { totalExecuted: totalCommands, successRate: commandSuccessRate, avgRiskScore },
             };
             if (ctx.flags.format === 'json') {
@@ -1246,6 +1272,8 @@ const metricsCommand = {
                     { metric: 'Total Patterns', value: totalPatterns },
                     { metric: 'Successful', value: output.success(String(successfulPatterns)) },
                     { metric: 'Failed', value: output.error(String(failedPatterns)) },
+                    ...(unknownPatterns > 0 ? [{ metric: 'Unclassified', value: String(unknownPatterns) }] : []),
+                    { metric: 'With Task Context', value: `${(descriptionCoverage * 100).toFixed(1)}%` },
                     { metric: 'Avg Confidence', value: `${(avgConfidence * 100).toFixed(1)}%` }
                 ]
             });
@@ -1258,7 +1286,14 @@ const metricsCommand = {
                     { key: 'value', header: 'Value', width: 20, align: 'right' }
                 ],
                 data: [
-                    { metric: 'Routing Accuracy', value: `${(routingAccuracy * 100).toFixed(1)}%` },
+                    {
+                        metric: routingAccuracy === null ? 'Avg Confidence' : 'Routing Accuracy',
+                        value: `${((routingAccuracy ?? averageRoutingConfidence) * 100).toFixed(1)}%`,
+                    },
+                    ...(routingOutcomeSuccessRate === null ? [] : [{
+                            metric: 'Outcome Success Rate',
+                            value: `${(routingOutcomeSuccessRate * 100).toFixed(1)}%`,
+                        }]),
                     { metric: 'Total Routes', value: totalRoutes },
                     { metric: 'Top Agent', value: output.highlight(topAgent) }
                 ]

package/v3/@claude-flow/cli/dist/src/commands/init.js

@@ -492,7 +492,7 @@ function isInitialized(cwd) {
     };
 }
 // Init subcommand (default)
-const initAction = async (ctx) => {
+const initClaudeAction = async (ctx) => {
     const force = ctx.flags.force;
     const minimal = ctx.flags.minimal;
     const full = ctx.flags.full;
@@ -507,13 +507,7 @@ const initAction = async (ctx) => {
     const noGlobal = ctx.flags['no-global'] === true || ctx.flags['global'] === false;
     const allAgents = ctx.flags['all-agents'];
     const cloudMcp = ctx.flags['cloud-mcp'];
-    const codexMode = ctx.flags.codex;
-    const dualMode = ctx.flags.dual;
     const cwd = ctx.cwd;
-    // If codex mode, use the Codex initializer
-    if (codexMode || dualMode) {
-        return initCodexAction(ctx, { codexMode, dualMode, force, minimal, full });
-    }
     // Check if already initialized
     const initialized = isInitialized(cwd);
     const hasExisting = initialized.claude || initialized.claudeFlow;
@@ -786,6 +780,56 @@ const initAction = async (ctx) => {
         return { success: false, exitCode: 1 };
     }
 };
+/**
+ * Route platform initialization. Dual mode deliberately runs both native
+ * initializers: Claude Code first, then Codex without its compatibility
+ * CLAUDE.md stub so the full native Claude scaffold remains authoritative.
+ */
+const initAction = async (ctx) => {
+    const force = ctx.flags.force;
+    const minimal = ctx.flags.minimal;
+    const full = ctx.flags.full;
+    const codexMode = ctx.flags.codex;
+    const dualMode = ctx.flags.dual;
+    if (codexMode && !dualMode) {
+        return initCodexAction(ctx, { codexMode, dualMode: false, force, minimal, full });
+    }
+    if (!dualMode) {
+        return initClaudeAction(ctx);
+    }
+    const claudeContext = {
+        ...ctx,
+        flags: {
+            ...ctx.flags,
+            codex: false,
+            dual: false,
+            // The explicit Codex pass below owns Codex setup.
+            'no-codex-detect': true,
+        },
+    };
+    const claudeResult = await initClaudeAction(claudeContext);
+    if (!claudeResult.success)
+        return claudeResult;
+    const codexResult = await initCodexAction(ctx, {
+        codexMode: true,
+        // Preserve the full CLAUDE.md and .claude/ scaffold just generated.
+        dualMode: false,
+        force,
+        minimal,
+        full,
+    });
+    if (!codexResult.success) {
+        return {
+            ...codexResult,
+            message: 'Claude Code initialized, but Codex initialization failed',
+            data: { claude: claudeResult.data, codex: codexResult.data },
+        };
+    }
+    return {
+        success: true,
+        data: { claude: claudeResult.data, codex: codexResult.data },
+    };
+};
 // Wizard subcommand for interactive setup
 const wizardCommand = {
     name: 'wizard',
@@ -1453,7 +1497,7 @@ export const initCommand = {
         { command: 'claude-flow init upgrade --settings', description: 'Update helpers and merge new settings (Agent Teams)' },
         { command: 'claude-flow init upgrade --verbose', description: 'Show detailed upgrade info' },
         { command: 'claude-flow init --codex', description: 'Initialize for OpenAI Codex (AGENTS.md)' },
-        { command: 'claude-flow init --codex --full', description: 'Codex init with all 137+ skills' },
+        { command: 'claude-flow init --codex --full', description: 'Codex init with all canonical packaged skills' },
         { command: 'claude-flow init --dual', description: 'Initialize for both Claude Code and Codex' },
         { command: 'claude-flow init --no-codex-detect', description: 'Skip auto-configuring OpenAI Codex even if it is installed' },
         { command: 'claude-flow init --no-skills-sh', description: 'Skip the post-init skills.sh registration' },

package/v3/@claude-flow/cli/dist/src/commands/mcp.js

@@ -63,7 +63,7 @@ const startCommand = {
         },
         {
             name: 'tools',
-            description: 'Tools to enable (comma-separated or "all")',
+            description: 'Tools to advertise (comma-separated categories, prefixes, exact names, or "all")',
             type: 'string',
             default: 'all'
         },

package/v3/@claude-flow/cli/dist/src/commands/memory-distill.js

@@ -182,6 +182,7 @@ const runCommand = {
             data: [
                 { metric: 'Processed', value: String(report.processed) },
                 { metric: 'Episodes', value: String(report.episodes) },
+                { metric: 'Episode Embeddings', value: String(report.episodeEmbeddings) },
                 { metric: 'Patterns', value: String(report.patterns) },
                 { metric: 'Pattern Embeddings', value: String(report.patternEmbeddings) },
                 { metric: 'Causal Edges', value: String(report.causalEdges) },

package/v3/@claude-flow/cli/dist/src/commands/swarm.js

@@ -50,6 +50,34 @@ function getSwarmStatus(swarmId) {
             // Ignore
         }
     }
+    // The canonical agent registry is the same source used by `agent list`.
+    // Prefer it over the swarm-level coordination boolean so idle agents are
+    // not reported as active (#2808). Hive agents are merged additively.
+    if (totalAgents === 0) {
+        try {
+            const canonicalPath = path.join(process.cwd(), '.claude-flow', 'agents', 'store.json');
+            const hivePath = path.join(process.cwd(), '.claude-flow', 'agents.json');
+            const merged = {};
+            for (const storePath of [hivePath, canonicalPath]) {
+                if (!fs.existsSync(storePath))
+                    continue;
+                const parsed = JSON.parse(fs.readFileSync(storePath, 'utf-8'));
+                if (parsed?.agents && typeof parsed.agents === 'object') {
+                    Object.assign(merged, parsed.agents);
+                }
+            }
+            const agents = Object.values(merged).filter(agent => agent.status !== 'terminated');
+            if (agents.length > 0) {
+                totalAgents = agents.length;
+                activeAgents = agents.filter(agent => agent.status === 'active' ||
+                    agent.status === 'running' ||
+                    agent.status === 'busy').length;
+            }
+        }
+        catch {
+            // Ignore — the count-only activity file remains the final fallback.
+        }
+    }
     // #2799 — `agent spawn` never writes `.swarm/agents/*.json`; it records
     // the count in `.claude-flow/metrics/swarm-activity.json` (via
     // updateSwarmActivityMetrics in commands/agent.ts). So when the agents

package/v3/@claude-flow/cli/dist/src/init/executor.js

@@ -370,18 +370,19 @@ function mergeSettingsForUpgrade(existing) {
     // js/redos): a crafted settings.json command string with dozens of
     // dash-token repetitions can hang this check for minutes.
     const BROKEN_STATUSLINE_RE = /(?:npx\s+(?:--?\S+\s+){0,10})?@?claude-flow(?:\/cli)?(?:@\S+)?\s+hooks\s+statusline/;
+    const BROKEN_NPX_LATEST_RE = /npx\s+(?:--?\S+\s+){0,10}@?claude-flow\/cli@latest\s+\S+/;
     const existingStatusLine = existing.statusLine;
     if (existingStatusLine) {
         const existingCmd = typeof existingStatusLine.command === 'string' ? existingStatusLine.command : '';
-        const isBroken = BROKEN_STATUSLINE_RE.test(existingCmd);
+        const isBroken = BROKEN_STATUSLINE_RE.test(existingCmd) || BROKEN_NPX_LATEST_RE.test(existingCmd);
         merged.statusLine = {
             type: 'command',
             command: isBroken || !existingCmd ? NEW_STATUSLINE_CMD : existingCmd,
             // Remove invalid fields: refreshMs, enabled (not supported by Claude Code)
         };
     }
-    // #2448 — Detect and REGENERATE per-action hook commands that still use
-    // the runaway `npx @claude-flow/cli@latest hooks <sub>` form. These fire
+    // #2448 / #2677 — Detect and REGENERATE per-action hook commands that still
+    // use the runaway `npx @claude-flow/cli@latest hooks <sub>` form. These fire
     // on every PreToolUse/PostToolUse/UserPromptSubmit, each spawning ~130 MB
     // of cold Node + npm registry resolution; the storm is what kernel-paniced
     // the reporter's machine in #2448.
@@ -409,15 +410,20 @@ function mergeSettingsForUpgrade(existing) {
             for (const group of groups) {
                 if (!Array.isArray(group.hooks))
                     continue;
-                for (const h of group.hooks) {
+                group.hooks = group.hooks.filter((h) => {
                     if (typeof h?.command !== 'string')
-                        continue;
+                        return true;
                     const m = BROKEN_HOOK_RE.exec(h.command);
-                    if (!m)
-                        continue;
-                    // Subcommand captured (e.g. "pre-bash", "post-edit", "route") — keep it.
-                    h.command = localHookCmd(m[1]);
-                }
+                    if (m) {
+                        // Subcommand captured (e.g. "pre-bash", "post-edit", "route") — keep it.
+                        h.command = localHookCmd(m[1]);
+                        return true;
+                    }
+                    // Sibling CLI invocations (memory/daemon/swarm/...) have no
+                    // hook-handler equivalent. Drop the stale extra; the merge above
+                    // has already installed current local-helper hooks for this event.
+                    return !BROKEN_NPX_LATEST_RE.test(h.command);
+                });
             }
         }
     }
@@ -1373,6 +1379,7 @@ async function writeStatusline(targetDir, options, result) {
  * Write runtime configuration (.claude-flow/)
  */
 async function writeRuntimeConfig(targetDir, options, result) {
+    updateRootGitignore(targetDir, result);
     const configPath = path.join(targetDir, '.claude-flow', 'config.yaml');
     if (fs.existsSync(configPath) && !options.force) {
         result.skipped.push('.claude-flow/config.yaml');
@@ -1441,6 +1448,34 @@ neural/
     // Write CAPABILITIES.md with full system overview
     await writeCapabilitiesDoc(targetDir, options, result);
 }
+/**
+ * Protect project-local secrets and runtime state for Claude-only installs.
+ * Append missing entries without replacing the project's existing rules.
+ */
+function updateRootGitignore(targetDir, result) {
+    const gitignorePath = path.join(targetDir, '.gitignore');
+    const entries = [
+        '# Ruflo local secrets and runtime data',
+        '.env',
+        '.env.local',
+        '.env.*.local',
+        '.claude-flow/data/',
+        '.claude-flow/logs/',
+        '.claude-flow/sessions/',
+    ];
+    const existing = fs.existsSync(gitignorePath)
+        ? fs.readFileSync(gitignorePath, 'utf8')
+        : '';
+    const existingLines = new Set(existing.split(/\r?\n/));
+    const missing = entries.filter((entry) => !existingLines.has(entry));
+    if (missing.length === 0)
+        return;
+    const separator = existing.length === 0
+        ? ''
+        : existing.endsWith('\n') ? '\n' : '\n\n';
+    fs.writeFileSync(gitignorePath, `${existing}${separator}${missing.join('\n')}\n`, 'utf8');
+    result.created.files.push('.gitignore (updated)');
+}
 /**
  * Write initial metrics files for statusline
  * Creates baseline data so statusline shows meaningful state instead of all zeros

package/v3/@claude-flow/cli/dist/src/init/helpers-generator.js

@@ -775,11 +775,22 @@ export function generateIntelligenceStub() {
         "const path = require('path');",
         "const os = require('os');",
         '',
-        "const DATA_DIR = path.join(process.cwd(), '.claude-flow', 'data');",
+        'function resolveProjectRoot(startDir) {',
+        '  if (process.env.CLAUDE_PROJECT_DIR) return path.resolve(process.env.CLAUDE_PROJECT_DIR);',
+        '  var dir = path.resolve(startDir || process.cwd());',
+        '  while (true) {',
+        '    if (fs.existsSync(path.join(dir, ".git")) || fs.existsSync(path.join(dir, ".claude-flow"))) return dir;',
+        '    var parent = path.dirname(dir);',
+        '    if (parent === dir) return path.resolve(startDir || process.cwd());',
+        '    dir = parent;',
+        '  }',
+        '}',
+        "const PROJECT_ROOT = resolveProjectRoot(process.cwd());",
+        "const DATA_DIR = path.join(PROJECT_ROOT, '.claude-flow', 'data');",
         "const STORE_PATH = path.join(DATA_DIR, 'auto-memory-store.json');",
         "const RANKED_PATH = path.join(DATA_DIR, 'ranked-context.json');",
         "const PENDING_PATH = path.join(DATA_DIR, 'pending-insights.jsonl');",
-        "const SESSION_DIR = path.join(process.cwd(), '.claude-flow', 'sessions');",
+        "const SESSION_DIR = path.join(PROJECT_ROOT, '.claude-flow', 'sessions');",
         "const SESSION_FILE = path.join(SESSION_DIR, 'current.json');",
         '',
         'function ensureDir(dir) {',
@@ -823,8 +834,8 @@ export function generateIntelligenceStub() {
         '  var entries = [];',
         '  var candidates = [',
         '    path.join(os.homedir(), ".claude", "projects"),',
-        '    path.join(process.cwd(), ".claude-flow", "memory"),',
-        '    path.join(process.cwd(), ".claude", "memory"),',
+        '    path.join(PROJECT_ROOT, ".claude-flow", "memory"),',
+        '    path.join(PROJECT_ROOT, ".claude", "memory"),',
         '  ];',
         '  for (var i = 0; i < candidates.length; i++) {',
         '    try {',

package/v3/@claude-flow/cli/dist/src/init/statusline-generator.js

@@ -53,6 +53,16 @@ function getInstalledCliVersionLocal() {
         return '0.0.0';
     }
 }
+function compareVersionsLocal(a, b) {
+    const pa = a.split(/[.-]/).map(part => Number.parseInt(part, 10) || 0);
+    const pb = b.split(/[.-]/).map(part => Number.parseInt(part, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const delta = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (delta !== 0)
+            return delta;
+    }
+    return 0;
+}
 /**
  * Generate optimized statusline script
  * Output format:
@@ -91,10 +101,12 @@ export function generateStatuslineScript(options) {
     // getInstalledCliVersionLocal() above — reuse the pattern for the
     // same reason it exists there.
     let helperContent = null;
+    let helperPackageRoot = '';
     try {
         const esmRequire = createRequire(import.meta.url);
         const pkgJsonPath = esmRequire.resolve('@claude-flow/cli/package.json');
-        const helperPath = path.join(path.dirname(pkgJsonPath), '.claude', 'helpers', 'statusline.cjs');
+        helperPackageRoot = path.dirname(pkgJsonPath);
+        const helperPath = path.join(helperPackageRoot, '.claude', 'helpers', 'statusline.cjs');
         helperContent = fs.readFileSync(helperPath, 'utf-8');
     }
     catch {
@@ -105,6 +117,7 @@ export function generateStatuslineScript(options) {
                 if (pkg && pkg.name === '@claude-flow/cli') {
                     const candidate = path.join(dir, '.claude', 'helpers', 'statusline.cjs');
                     if (fs.existsSync(candidate)) {
+                        helperPackageRoot = dir;
                         helperContent = fs.readFileSync(candidate, 'utf-8');
                         break;
                     }
@@ -128,15 +141,15 @@ export function generateStatuslineScript(options) {
     // whatever the helper hard-codes) ships. Add a paired test in
     // statusline-cost-display.test.ts before changing either token.
     helperContent = helperContent.replace(/maxAgents: \d+,/, `maxAgents: ${maxAgents},`);
+    helperContent = helperContent.replace(/const BAKED_INSTALL_ROOT = "[^"]*";/, `const BAKED_INSTALL_ROOT = ${JSON.stringify(helperPackageRoot)};`);
     // Only overwrite the helper's baked version if OURS resolves higher.
     // Otherwise the substitution could DOWNGRADE (test environments where
     // esmRequire.resolve happens to hit an older node_modules install would
-    // clobber a fresh committed helper). Naive lexicographic compare — works
-    // for canonical semver strings with same-width digit parts, which is
-    // reliable at this stage of the version space.
+    // clobber a fresh committed helper). Compare numeric components:
+    // lexicographic comparison freezes 3.32.24 below 3.32.8 (#2811).
     const helperVerMatch = helperContent.match(/let ver = "([^"]+)";/);
     const helperVer = helperVerMatch ? helperVerMatch[1] : '';
-    if (!helperVer || bakedVersion > helperVer) {
+    if (!helperVer || compareVersionsLocal(bakedVersion, helperVer) > 0) {
         helperContent = helperContent.replace(/let ver = "[^"]+";/, `let ver = ${JSON.stringify(bakedVersion)};`);
     }
     return helperContent;

package/v3/@claude-flow/cli/dist/src/mcp-server.d.ts

@@ -48,6 +48,31 @@ export interface MCPServerStatus {
         metrics?: Record<string, number>;
     };
 }
+export declare function parseMcpToolSelection(value: string | undefined): string[] | 'all';
+/**
+ * Apply the existing `--tools` contract to advertised schemas. A selector can
+ * be an exact tool name, a category, or a namespace prefix (`memory` matches
+ * `memory_store`). Execution remains registered internally; only the fixed
+ * per-request schema catalogue is reduced.
+ */
+export declare function filterAdvertisedMcpTools<T extends {
+    name: string;
+    category?: string;
+}>(tools: T[], selection: string[] | 'all'): T[];
+export interface McpSchemaOverhead {
+    toolCount: number;
+    bytes: number;
+    estimatedTokens: number;
+    contextWindowTokens?: number;
+    ratio?: number;
+    risk: 'normal' | 'high';
+}
+/** Conservative JSON-size estimate for the fixed tools/list catalogue. */
+export declare function assessMcpSchemaOverhead(tools: Array<{
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+}>, contextWindowTokens?: number): McpSchemaOverhead;
 /**
  * MCP Server Manager
  *

package/v3/@claude-flow/cli/dist/src/mcp-server.js

@@ -42,6 +42,54 @@ const DEFAULT_OPTIONS = {
     daemonize: false,
     timeout: 30000,
 };
+export function parseMcpToolSelection(value) {
+    if (!value || value.trim().toLowerCase() === 'all')
+        return 'all';
+    const selectors = value.split(',').map((item) => item.trim()).filter(Boolean);
+    return selectors.length > 0 ? selectors : 'all';
+}
+/**
+ * Apply the existing `--tools` contract to advertised schemas. A selector can
+ * be an exact tool name, a category, or a namespace prefix (`memory` matches
+ * `memory_store`). Execution remains registered internally; only the fixed
+ * per-request schema catalogue is reduced.
+ */
+export function filterAdvertisedMcpTools(tools, selection) {
+    if (selection === 'all')
+        return tools;
+    const selectors = new Set(selection.map((item) => item.toLowerCase()));
+    return tools.filter((tool) => {
+        const name = tool.name.toLowerCase();
+        const category = tool.category?.toLowerCase();
+        return selectors.has(name)
+            || (category !== undefined && selectors.has(category))
+            || Array.from(selectors).some((selector) => name.startsWith(`${selector}_`));
+    });
+}
+/** Conservative JSON-size estimate for the fixed tools/list catalogue. */
+export function assessMcpSchemaOverhead(tools, contextWindowTokens) {
+    const catalogue = tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+    }));
+    const bytes = Buffer.byteLength(JSON.stringify(catalogue), 'utf8');
+    const estimatedTokens = Math.ceil(bytes / 4);
+    const validWindow = Number.isFinite(contextWindowTokens) && Number(contextWindowTokens) > 0
+        ? Number(contextWindowTokens)
+        : undefined;
+    const ratio = validWindow ? estimatedTokens / validWindow : undefined;
+    return {
+        toolCount: tools.length,
+        bytes,
+        estimatedTokens,
+        ...(validWindow === undefined ? {} : { contextWindowTokens: validWindow }),
+        ...(ratio === undefined ? {} : { ratio }),
+        risk: (ratio !== undefined ? ratio >= 0.2 : estimatedTokens >= 8_000)
+            ? 'high'
+            : 'normal',
+    };
+}
 /**
  * MCP Server Manager
  *
@@ -55,7 +103,14 @@ export class MCPServerManager extends EventEmitter {
     healthCheckInterval;
     constructor(options = {}) {
         super();
-        this.options = { ...DEFAULT_OPTIONS, ...options };
+        // `options.tools`, populated by the `mcp start --tools` CLI flag, is
+        // spread last below and therefore takes precedence over this env fallback.
+        const environmentTools = parseMcpToolSelection(process.env.CLAUDE_FLOW_MCP_TOOLS);
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...(environmentTools === 'all' ? {} : { tools: environmentTools }),
+            ...options,
+        };
     }
     /**
      * Start the MCP server
@@ -420,7 +475,7 @@ export class MCPServerManager extends EventEmitter {
                         },
                     };
                 case 'tools/list':
-                    const tools = listMCPTools();
+                    const tools = filterAdvertisedMcpTools(listMCPTools(), this.options.tools);
                     return {
                         jsonrpc: '2.0',
                         id: message.id,