nodebench-mcp 3.0.1 → 3.1.0

package/NODEBENCH_AGENTS.md

@@ -21,24 +21,24 @@ Add to `~/.claude/settings.json`:
 }
 ```
 
-Restart Claude Code. 175 tools available immediately.
+Restart Claude Code. The default lane exposes 9 tools immediately.
 
-### Preset Selection
-
-By default all toolsets are enabled. Use `--preset` to start with a scoped subset:
+### Preset Selection
+
+By default NodeBench starts in the workflow-first lane. Use `--preset` when you want a deeper or more specialized surface:
 
 ```json
 {
   "mcpServers": {
     "nodebench": {
       "command": "npx",
-      "args": ["-y", "nodebench-mcp", "--preset", "meta"]
-    }
-  }
-}
-```
-
-The **meta** preset is the recommended front door for new agents: start with just 5 discovery tools, use `discover_tools` to find what you need, then self-escalate to a larger preset. See [Toolset Gating & Presets](#toolset-gating--presets) for the full breakdown.
+      "args": ["-y", "nodebench-mcp", "--preset", "power"]
+    }
+  }
+}
+```
+
+The **default** preset is the recommended front door for new agents: start with the 9-tool workflow lane, use `discover_tools` only when the task needs more, then expand with `load_toolset` or a larger preset. See [Toolset Gating & Presets](#toolset-gating--presets) for the full breakdown.
 
 **→ Quick Refs:** After setup, run `getMethodology("overview")` | First task? See [Verification Cycle](#verification-cycle-workflow) | New to codebase? See [Environment Setup](#environment-setup) | Preset options: See [Toolset Gating & Presets](#toolset-gating--presets)
 
@@ -287,71 +287,78 @@ Use `getMethodology("overview")` to see all available workflows.
 | **Session Memory** | `save_session_note`, `load_session_notes`, `refresh_task_context` | Compaction-resilient notes, attention refresh |
 | **Discovery** | `discover_tools`, `get_tool_quick_ref`, `get_workflow_chain` | Hybrid search, quick refs, workflow chains |
 
-Meta + Discovery tools (5 total) are **always included** regardless of preset. See [Toolset Gating & Presets](#toolset-gating--presets).
-
-**→ Quick Refs:** Find tools by keyword: `findTools({ query: "verification" })` | Hybrid search: `discover_tools({ query: "security" })` | Get workflow guide: `getMethodology({ topic: "..." })` | See [Methodology Topics](#methodology-topics) for all topics
+The current front door is the workflow-first default lane. Agents start small, prove value quickly, and only expand into heavier toolsets when the task demands it.
+
+**→ Quick Refs:** Start small: `investigate({ topic: "..." })` | Expand only when needed: `discover_tools({ query: "security" })` | Load a deeper lane: `load_toolset({ toolset: "recon" })` | See [Methodology Topics](#methodology-topics) for verification and eval guidance
 
 ---
 
 ## Toolset Gating & Presets
 
-NodeBench MCP supports 4 presets that control which domain toolsets are loaded at startup. Meta + Discovery tools (5 total) are **always included** on top of any preset.
+NodeBench MCP now uses a workflow-first default and keeps the larger surfaces behind explicit presets.
 
 ### Preset Table
 
-| Preset | Domain Toolsets | Domain Tools | Total (with meta+discovery) | Use Case |
-|--------|----------------|-------------|----------------------------|----------|
-| **meta** | 0 | 0 | 5 | Discovery-only front door. Agents start here and self-escalate. |
-| **lite** | 8 | 38 | 43 | Lightweight verification-focused workflows. CI bots, quick checks. |
-| **core** | 23 | 105 | 110 | Full development workflow. Most agent sessions. |
-| **full** | 31 | 170 | 175 | Everything enabled. Benchmarking, exploration, advanced use. |
+| Preset | Surface | Use Case |
+|--------|---------|----------|
+| **default** | 9 visible tools | Workflow-first lane: investigate, compare, track, summarize, search, report, ask_context, discover_tools, load_toolset |
+| **power** | Expanded workflow surface | Founder, recon, packets, and web-heavy research without admin runtime |
+| **admin** | Operator surface | Profiling, observability, dashboards, eval, and debug workflows |
+| **core** | Full methodology lane | Verification, eval, learning, recon, execution trace, mission harness |
+| **founder** | Compatibility preset | Existing founder-oriented setups |
+| **full** | All loaded domains | Maximum coverage when you explicitly want everything |
 
 ### Usage
 
-```bash
-npx nodebench-mcp --preset meta       # Discovery-only (5 tools)
-npx nodebench-mcp --preset lite       # Verification + eval + recon + security
-npx nodebench-mcp --preset core       # Full dev workflow without vision/parallel
-npx nodebench-mcp --preset full       # All toolsets (default)
-npx nodebench-mcp --toolsets verification,eval,recon   # Custom selection
-npx nodebench-mcp --exclude vision,ui_capture          # Exclude specific toolsets
-```
-
-### The Meta Preset — Discovery-Only Front Door
-
-The **meta** preset loads zero domain tools. Agents start with only 5 tools:
-
-| Tool | Purpose |
-|------|---------|
-| `findTools` | Keyword search across all registered tools |
-| `getMethodology` | Get workflow guides by topic |
-| `discover_tools` | Hybrid search with relevance scoring (richer than findTools) |
-| `get_tool_quick_ref` | Quick reference card for any specific tool |
-| `get_workflow_chain` | Recommended tool sequence for common workflows |
-
-This is the recommended starting point for autonomous agents. The self-escalation pattern:
-
-```
-1. Start with --preset meta (5 tools)
-2. discover_tools({ query: "what I need to do" })    // Find relevant tools
-3. get_workflow_chain({ workflow: "verification" })    // Get the tool sequence
-4. If needed tools are not loaded:
-   → Restart with --preset core or --preset full
-   → Or use --toolsets to add specific domains
-5. Proceed with full workflow
-```
-
-### Preset Domain Breakdown
-
-**meta** (0 domains): No domain tools. Meta + Discovery only.
-
-**lite** (8 domains): `verification`, `eval`, `quality_gate`, `learning`, `flywheel`, `recon`, `security`, `boilerplate`
-
-**core** (22 domains): Everything in lite plus `bootstrap`, `self_eval`, `llm`, `platform`, `research_writing`, `flicker_detection`, `figma_flow`, `benchmark`, `session_memory`, `toon`, `pattern`, `git_workflow`, `seo`, `voice_bridge`
-
-**full** (30 domains): All toolsets in TOOLSET_MAP including `ui_capture`, `vision`, `local_file`, `web`, `github`, `docs`, `parallel`, `gaia_solvers`, and everything in core.
-
-**→ Quick Refs:** Check current toolset: `findTools({ query: "*" })` | Self-escalate: restart with `--preset core` | See [MCP Tool Categories](#mcp-tool-categories) | CLI help: `npx nodebench-mcp --help`
+```bash
+npx nodebench-mcp                       # Default workflow lane
+npx nodebench-mcp --preset power       # Expanded founder / recon / packet workflows
+npx nodebench-mcp --preset admin       # Profiling, dashboards, and operator tooling
+npx nodebench-mcp --preset core        # Full dev workflow without all optional domains
+npx nodebench-mcp --preset full        # All toolsets
+npx nodebench-mcp --toolsets verification,eval,recon   # Custom selection
+npx nodebench-mcp --exclude vision,ui_capture          # Exclude specific toolsets
+```
+
+### The Default Lane
+
+The **default** preset is intentionally small:
+
+| Tool | Purpose |
+|------|---------|
+| `investigate` | Produce a sourced report on a topic, company, person, link, or messy note |
+| `compare` | Side-by-side compare 2 to 4 entities |
+| `track` | Add, inspect, or list tracked entities |
+| `summarize` | Compress raw context into a compact brief |
+| `search` | Search live web and saved knowledge in one step |
+| `report` | Turn findings into a readable report artifact |
+| `ask_context` | Query saved NodeBench context |
+| `discover_tools` | Find the next deeper lane when the default surface is not enough |
+| `load_toolset` | Expand the session with a specific toolset only when needed |
+
+Recommended escalation pattern:
+
+```
+1. Start with the default workflow lane
+2. Try investigate / compare / search / report first
+3. If the task needs deeper capability, call discover_tools(...)
+4. Load exactly one relevant toolset with load_toolset(...)
+5. Continue the workflow with the newly loaded tools
+```
+
+### Preset Domain Breakdown
+
+**default**: `core_workflow`
+
+**power**: `core_workflow`, `deep_sim`, `founder`, `recon`, `web`, `shared_context`, `sync_bridge`, `session_memory`, `entity_lookup`, `delta`, `site_map`
+
+**admin**: `core_workflow`, `observability`, `profiler`, `local_dashboard`, `benchmark`, `longitudinal_benchmark`, `dogfood_judge`, `execution_trace`, `qa_orchestration`, `mission_harness`, `quality_gate`, `eval`, `verification`
+
+**core**: verification, eval, quality_gate, learning, flywheel, autonomous_delivery, sync_bridge, shared_context, recon, security, boilerplate, skill_update, context_sandbox, observability, execution_trace, mission_harness, deep_sim, founder, scenario_compiler, packet_compiler, entity_temporal
+
+**full**: every registered domain in the package
+
+**→ Quick Refs:** Check current lane with `discover_tools({ query: "..." })` | Self-escalate with `load_toolset({ toolset: "recon" })` or restart with `--preset core` | See [MCP Tool Categories](#mcp-tool-categories) | CLI help: `npx nodebench-mcp --help`
 
 ---
 
@@ -706,12 +713,12 @@ Available via `getMethodology({ topic: "..." })`:
 | `autonomous_maintenance` | Risk-tiered execution | [Autonomous Maintenance](#autonomous-self-maintenance-system) |
 | `parallel_agent_teams` | Multi-agent coordination, task locking, oracle testing | [Parallel Agent Teams](#parallel-agent-teams) |
 | `self_reinforced_learning` | Trajectory analysis, self-eval, improvement recs | [Self-Reinforced Learning](#self-reinforced-learning-loop) |
-| `toolset_gating` | 4 presets (meta, lite, core, full) and self-escalation | [Toolset Gating & Presets](#toolset-gating--presets) |
+| `toolset_gating` | Default, power, admin, core, founder, and full preset strategy | [Toolset Gating & Presets](#toolset-gating--presets) |
 | `toon_format` | TOON encoding — ~40% token savings vs JSON | TOON is on by default since v2.14.1 |
 | `seo_audit` | Full SEO audit workflow (technical + performance + content) | `seo_audit_url`, `check_page_performance`, `analyze_seo_content` |
 | `voice_bridge` | Voice pipeline design, config analysis, scaffolding | `design_voice_pipeline`, `analyze_voice_config` |
 
-**→ Quick Refs:** Find tools: `findTools({ query: "..." })` | Get any methodology: `getMethodology({ topic: "..." })` | See [MCP Tool Categories](#mcp-tool-categories)
+**→ Quick Refs:** Find deeper lanes: `discover_tools({ query: "..." })` | Get any methodology: `getMethodology({ topic: "..." })` | See [MCP Tool Categories](#mcp-tool-categories)
 
 ---
 

package/README.md

@@ -5,22 +5,22 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![GitHub stars](https://img.shields.io/github/stars/HomenShum/nodebench-ai.svg)](https://github.com/HomenShum/nodebench-ai)
 [![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-green.svg)](https://modelcontextprotocol.io)
-[![Default](https://img.shields.io/badge/Default-19%20visible-brightgreen.svg)](https://www.npmjs.com/package/nodebench-mcp)
+[![Default](https://img.shields.io/badge/Default-9%20visible-brightgreen.svg)](https://www.npmjs.com/package/nodebench-mcp)
 
-**Investigate a topic and return a sourced report fast.** NodeBench MCP now defaults to a small workflow facade, with heavier research and admin surfaces moved behind explicit presets.
+**Investigate a topic and return a sourced report fast.** The NodeBench MCP architecture is now split into three install lanes that share one runtime.
 
-Default install: `19` visible tools total, including `7` core workflow tools:
+Default install: `9` visible tools total, including `7` core workflow tools:
 `investigate`, `compare`, `track`, `summarize`, `search`, `report`, and `ask_context`.
 
 ```bash
-# Default v3 core workflow surface
+# Core workflow lane
 claude mcp add nodebench -- npx -y nodebench-mcp
 
-# Extended workflow surface
-claude mcp add nodebench -- npx -y nodebench-mcp --preset power
+# Power lane
+claude mcp add nodebench-power -- npx -y nodebench-mcp-power
 
-# Admin/runtime surface
-claude mcp add nodebench -- npx -y nodebench-mcp --preset admin --admin
+# Admin lane
+claude mcp add nodebench-admin -- npx -y nodebench-mcp-admin
 ```
 
 ### What's New
@@ -40,8 +40,8 @@ This section records a repo-grounded reexamination of NodeBench MCP as of April
 
 ### Repo-grounded findings
 
-- **Surface area and messaging are out of sync**
-  - This README currently markets `350+ tools`, `founder` under `50` tools, and `full` as `338`.
+- **Surface area and messaging were out of sync**
+  - At the time of this audit, the README marketed `350+ tools`, `founder` under `50` tools, and `full` as `338`.
   - The audit that drove this section measured roughly `28` tools in the starter `tools/list` payload, roughly `186` in `founder`, and roughly `546` in `full`, before counting the extra dynamic-loading helpers separately.
 - **The core executable is overloaded**
   - `packages/mcp-local/src/index.ts` currently combines MCP serving, analytics tracking, embedding bootstrapping, profiling hooks, A/B instrumentation, dynamic tool loading, dashboard startup, and engine hosting in one runtime path.
@@ -103,13 +103,14 @@ NodeBench is now a workflow-first MCP. The default install proves one concrete j
 
 ### Presets
 
-| Preset | Visible tools | What it is for |
+| Preset | Surface | What it is for |
 |---|---|---|
-| `default` | `19` | v3 core workflow facade: investigate, compare, track, summarize, search, report, ask_context, plus discovery/meta helpers |
-| `power` | `203` | Extended research and founder workflow pack without auto-starting admin runtime surfaces |
-| `admin` | `106` | Profiling, observability, dashboards, eval, and debug-oriented operator lanes |
-| `founder` | `191` | Legacy founder preset kept for compatibility |
-| `full` | all domains | Maximum coverage when you explicitly want the warehouse |
+| `default` | `9` visible tools | Workflow-first lane: `investigate`, `compare`, `track`, `summarize`, `search`, `report`, `ask_context`, `discover_tools`, `load_toolset` |
+| `power` | expanded workflow surface | Founder, recon, packets, and web-heavy workflows without admin runtime |
+| `admin` | operator surface | Profiling, observability, dashboards, eval, and debug-oriented lanes |
+| `core` | full methodology lane | Verification, eval, learning, recon, execution trace, and mission harness |
+| `founder` | compatibility preset | Legacy founder-facing pack kept for existing setups |
+| `full` | all loaded domains | Maximum coverage when you explicitly want the warehouse |
 
 ### Default workflow
 
@@ -173,7 +174,7 @@ Add to `.windsurf/mcp.json` (or Settings > MCP > View raw config):
   "mcpServers": {
     "nodebench": {
       "command": "npx",
-      "args": ["-y", "nodebench-mcp", "--preset", "founder"]
+      "args": ["-y", "nodebench-mcp", "--preset", "power"]
     }
   }
 }
@@ -186,23 +187,23 @@ Any MCP-compatible client works. Point `command` to `npx`, `args` to `["-y", "no
 ### First Prompts to Try
 
 ```
-# Find tools for your task
-> Use discover_tools("evaluate this acquisition target") to find relevant tools
+# Research a topic
+> Use investigate with topic="Anthropic" to produce a sourced report
 
-# Load a toolset
-> Use load_toolset("deep_sim") to activate decision simulation tools
+# Compare two entities
+> Use compare with entities=["Anthropic","OpenAI"] to get a side-by-side brief
 
-# Run a decision simulation
-> Use run_deep_sim_scenario to simulate a business decision with multiple variables
+# Turn rough notes into a report
+> Use report with topic="AI agent infrastructure" and context="..." to produce a decision memo
 
-# Generate a decision memo
-> Use generate_decision_memo to produce a shareable memo from your analysis
+# Search live web + saved knowledge
+> Use search with query="MCP server best practices 2026"
 
-# Weekly founder reset
-> Use founder_weekly_reset to review the week's decisions and outcomes
+# Track an entity
+> Use track with action="add" and entity="Anthropic"
 
-# Pre-delegation briefing
-> Use pre_delegation_briefing to prepare context before handing off a task
+# Expand only when you need more
+> Use discover_tools("visual QA for a Vite app"), then load_toolset("ui_ux_dive")
 ```
 
 ### Optional: API Keys
@@ -231,17 +232,17 @@ Set these as environment variables, or add them to the `env` block in your MCP c
 
 ---
 
-## Progressive Discovery — How 338 Tools Fit in Any Context Window
+## Progressive Discovery — How Optional Toolsets Stay Off the Hot Path
 
-The starter preset loads 15 tools. The other 323 are discoverable and loadable on demand.
+The default preset exposes `9` tools. Everything else stays off the hot path until you deliberately load a specific toolset.
 
 ### How it works
 
 ```
-1. discover_tools("your task description")    → ranked results from all 338 tools
-2. load_toolset("deep_sim")                   → tools activate in your session
-3. Use the tools directly                     → no proxy, native binding
-4. unload_toolset("deep_sim")                 → free context budget when done
+1. discover_tools("your task description")    → ranked results from the full registry
+2. load_toolset("ui_ux_dive")                 → a specific toolset activates in your session
+3. Use the newly loaded tools directly        → no proxy, native binding
+4. Keep the default surface small             → only load what the workflow needs
 ```
 
 ### Multi-modal search engine
@@ -263,10 +264,11 @@ Plus cursor pagination (`offset`/`limit`), result expansion (`expand: N`), and m
 
 ### Client compatibility
 
-| Client | Dynamic Loading |
+| Client | Recommended path |
 |---|---|
-| Claude Code, GitHub Copilot | Native — re-fetches tools after `list_changed` |
-| Windsurf, Cursor, Claude Desktop, Gemini CLI | Via `call_loaded_tool` fallback (always available) |
+| Claude Code, GitHub Copilot | Default preset + `discover_tools` / `load_toolset` |
+| Cursor | `--preset cursor` to stay within its tool cap |
+| Windsurf, Claude Desktop, Gemini CLI | Use `--preset power` or a targeted preset if your client does not refresh tools reliably |
 
 ---
 
@@ -358,7 +360,7 @@ NodeBench MCP runs locally on your machine.
 
 - All persistent data stored in `~/.nodebench/` (SQLite). No data sent to external servers unless you provide API keys and use tools that call external APIs.
 - Analytics data never leaves your machine.
-- The `local_file` toolset can read files anywhere your Node.js process has permission. Use the `starter` preset to restrict file system access.
+- The `local_file` toolset can read files anywhere your Node.js process has permission. Use the `default` preset to keep local-file tools off the hot path.
 - All API keys read from environment variables — never hardcoded or logged.
 - All database queries use parameterized statements.
 
@@ -401,7 +403,7 @@ Then use absolute path:
 
 **Cursor tools not loading** — Ensure `.cursor/mcp.json` exists in project root. Use `--preset cursor` to stay within the tool cap. Restart Cursor after config changes.
 
-**Dynamic loading not working** — Claude Code and GitHub Copilot support native dynamic loading. For Windsurf/Cursor, use `call_loaded_tool` as a fallback.
+**Dynamic loading not working** — Claude Code and GitHub Copilot support native dynamic loading. For Windsurf/Cursor, prefer `--preset cursor` or `--preset power` if your client does not refresh tools reliably after `load_toolset`.
 
 ---
 

package/dist/dashboard/operatingDashboardHtml.js

@@ -1511,7 +1511,7 @@ export function getOperatingDashboardHtml() {
     <!-- 10. Footer -->
     <footer class="footer fade-in fade-in-9">
       <div class="footer-text">
-        <span>NodeBench</span> MCP v${NODEBENCH_VERSION} &middot; 325 tools &middot; 30 tables &middot; auto-refresh: 10s
+        <span>NodeBench</span> MCP v${NODEBENCH_VERSION} &middot; workflow lanes + operator data &middot; auto-refresh: 10s
       </div>
     </footer>
   </div>

package/dist/index.js

@@ -34,7 +34,7 @@ import { createMetaTools } from "./tools/metaTools.js";
 import { createProgressiveDiscoveryTools } from "./tools/progressiveDiscoveryTools.js";
 import { getQuickRef, ALL_REGISTRY_ENTRIES, TOOL_REGISTRY, getToolComplexity, getToolAnnotations, toolNameToTitle, _setDbAccessor, hybridSearch, WORKFLOW_CHAINS } from "./tools/toolRegistry.js";
 import { getRequestedPreset, resolveRuntimeFlags } from "./runtimeConfig.js";
-import { NODEBENCH_PACKAGE_NAME, NODEBENCH_VERSION, comparePackageVersions } from "./packageInfo.js";
+import { NODEBENCH_CLI_COMMAND, NODEBENCH_DISPLAY_NAME, NODEBENCH_NPX_PACKAGE, NODEBENCH_PACKAGE_NAME, NODEBENCH_SERVER_KEY, NODEBENCH_VERSION, comparePackageVersions, } from "./packageInfo.js";
 // TOON format — ~40% token savings on tool responses
 import { encode as toonEncode } from "@toon-format/toon";
 // Embedding provider — neural semantic search
@@ -57,6 +57,11 @@ const runtimeFlags = resolveRuntimeFlags(cliArgs, requestedPreset);
 const useEmbedding = runtimeFlags.enableEmbedding;
 const useEngine = runtimeFlags.enableEngine;
 const useProfile = runtimeFlags.enableProfiling;
+const DISPLAY_NAME = NODEBENCH_DISPLAY_NAME;
+const CLI_COMMAND = NODEBENCH_CLI_COMMAND;
+const NPX_COMMAND = `npx ${NODEBENCH_NPX_PACKAGE}`;
+const NPX_Y_COMMAND = `npx -y ${NODEBENCH_NPX_PACKAGE}`;
+const SERVER_KEY = NODEBENCH_SERVER_KEY;
 const engineSecret = (() => {
     const idx = cliArgs.indexOf("--engine-secret");
     return idx >= 0 && idx + 1 < cliArgs.length ? cliArgs[idx + 1] : process.env.ENGINE_SECRET;
@@ -128,6 +133,9 @@ const PRESET_DESCRIPTIONS = {
     delta: "Delta (~65 tools) — full operating-intelligence preset. Entity intel, decision memos, watchlists, agent handoff, execution traces.",
     full: "Everything — all domains for maximum coverage",
 };
+function isWorkflowFacadePreset(presetName) {
+    return presetName === "default" || presetName === "starter" || presetName === "v3";
+}
 async function parseToolsets() {
     if (cliArgs.includes("--help")) {
         const lines = [
@@ -528,7 +536,8 @@ if (healthFlag) {
         await loadToolsets(presetToolsets);
     }
     const presetToolCount = presetToolsets
-        ? presetToolsets.reduce((s, k) => s + (TOOLSET_MAP[k]?.length ?? 0), 0) + 12
+        ? presetToolsets.reduce((s, k) => s + (TOOLSET_MAP[k]?.length ?? 0), 0)
+            + (isWorkflowFacadePreset(activePreset) ? 2 : 12)
         : 12;
     lines.push(`${C}Tools${X}       ${presetToolCount} visible (preset: ${activePreset}) | ${ALL_DOMAIN_KEYS.length} domains available`);
     // 2. TOON + Embedding
@@ -630,7 +639,7 @@ if (healthFlag) {
     try {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), 3000);
-        const res = await fetch("https://registry.npmjs.org/nodebench-mcp/latest", {
+        const res = await fetch(`https://registry.npmjs.org/${NODEBENCH_PACKAGE_NAME}/latest`, {
             signal: controller.signal,
             headers: { Accept: "application/json" },
         });
@@ -905,11 +914,26 @@ if (syncConfigsFlag) {
         if (process.env[key])
             envObj[key] = process.env[key];
     }
-    // Build the MCP server config entry
+    // Build the MCP server config entry. Wrapper packages can override this so
+    // sync-configs writes the public lane command instead of an internal entry path.
     const nodePath = process.execPath; // path to node binary
+    const configCommandOverride = process.env.NODEBENCH_CONFIG_COMMAND_OVERRIDE?.trim();
+    let configArgsOverride;
+    const rawConfigArgsOverride = process.env.NODEBENCH_CONFIG_ARGS_OVERRIDE;
+    if (rawConfigArgsOverride) {
+        try {
+            const parsed = JSON.parse(rawConfigArgsOverride);
+            if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+                configArgsOverride = parsed;
+            }
+        }
+        catch {
+            // Ignore invalid override payloads and fall back to the local entry path.
+        }
+    }
     const serverEntry = {
-        command: nodePath,
-        args: [entryPath, ...forwardArgs],
+        command: configCommandOverride || nodePath,
+        args: configArgsOverride ?? [entryPath, ...forwardArgs],
         ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
     };
     // Helper: merge into existing config file (preserves other servers)
@@ -948,7 +972,7 @@ if (syncConfigsFlag) {
     // 1. Claude Code: ~/.claude/claude_desktop_config.json
     try {
         const claudeConfigPath = path.join(os.homedir(), ".claude", "claude_desktop_config.json");
-        const r = mergeConfig(claudeConfigPath, "nodebench-mcp");
+        const r = mergeConfig(claudeConfigPath, SERVER_KEY);
         results.push({ name: "Claude Code", ...r });
     }
     catch (e) {
@@ -957,7 +981,7 @@ if (syncConfigsFlag) {
     // 2. Cursor: <project>/.cursor/mcp.json
     try {
         const cursorConfigPath = path.join(process.cwd(), ".cursor", "mcp.json");
-        const r = mergeConfig(cursorConfigPath, "nodebench-mcp");
+        const r = mergeConfig(cursorConfigPath, SERVER_KEY);
         results.push({ name: "Cursor", ...r });
     }
     catch (e) {
@@ -966,7 +990,7 @@ if (syncConfigsFlag) {
     // 3. Windsurf: <project>/.windsurf/mcp.json
     try {
         const windsurfConfigPath = path.join(process.cwd(), ".windsurf", "mcp.json");
-        const r = mergeConfig(windsurfConfigPath, "nodebench-mcp");
+        const r = mergeConfig(windsurfConfigPath, SERVER_KEY);
         results.push({ name: "Windsurf", ...r });
     }
     catch (e) {
@@ -985,8 +1009,8 @@ if (syncConfigsFlag) {
     // Print config summary
     lines.push("");
     lines.push(`${C}Config entry:${X}`);
-    lines.push(`  command: ${nodePath}`);
-    lines.push(`  args:    [${[entryPath, ...forwardArgs].map(a => `"${a}"`).join(", ")}]`);
+    lines.push(`  command: ${String(serverEntry.command)}`);
+    lines.push(`  args:    [${(serverEntry.args ?? []).map(a => `"${a}"`).join(", ")}]`);
     if (Object.keys(envObj).length > 0) {
         lines.push(`  env:     ${Object.keys(envObj).join(", ")}`);
     }
@@ -1933,7 +1957,7 @@ const dynamicLoadingTools = [
     },
 ];
 // v3 preset gate: expose only facade tools + discover_tools + load_toolset
-const isV3Surface = currentPreset === "default" || currentPreset === "starter" || currentPreset === "v3";
+const isV3Surface = isWorkflowFacadePreset(currentPreset);
 // Combine all tools (mutable for dynamic loading)
 let allTools;
 if (isV3Surface) {
@@ -3378,7 +3402,7 @@ const engineInfo = enginePort ? ` engine at http://127.0.0.1:${enginePort}` : ""
 const runtimeInfo = runtimeFlags.enableDashboards || runtimeFlags.enableWatchdog
     ? " admin-runtime"
     : " core-runtime";
-console.error(`nodebench-mcp ready (${allTools.length} tools, ${PROMPTS.length} prompts${toolsetInfo}, SQLite at ~/.nodebench/${dashInfo}${uiDiveInfo}${engineInfo}${runtimeInfo})`);
+console.error(`${CLI_COMMAND} ready (${allTools.length} tools, ${PROMPTS.length} prompts${toolsetInfo}, SQLite at ~/.nodebench/${dashInfo}${uiDiveInfo}${engineInfo}${runtimeInfo})`);
 // ── Auto-brief on first start (delta/hackathon presets) ──────────────
 // When using delta or hackathon preset, auto-run delta_brief on first session
 // to give users immediate value before they even ask.