nodebench-mcp 2.70.0 → 3.0.1

package/dist/index.js

@@ -33,6 +33,8 @@ import { initObservability, startWatchdog, stopWatchdog } from "./tools/observab
 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";
 // TOON format — ~40% token savings on tool responses
 import { encode as toonEncode } from "@toon-format/toon";
 // Embedding provider — neural semantic search
@@ -40,7 +42,6 @@ import { initEmbeddingIndex } from "./tools/embeddingProvider.js";
 // ── CLI argument parsing ──────────────────────────────────────────────
 const cliArgs = process.argv.slice(2);
 const useToon = !cliArgs.includes("--no-toon");
-const useEmbedding = !cliArgs.includes("--no-embedding");
 const useSmartPreset = cliArgs.includes("--smart-preset");
 const showStats = cliArgs.includes("--stats");
 const exportStats = cliArgs.includes("--export-stats");
@@ -51,25 +52,34 @@ const statusFlag = cliArgs.includes("--status");
 const diagnoseFlag = cliArgs.includes("--diagnose");
 const autoPresetFlag = cliArgs.includes("--auto-preset");
 const syncConfigsFlag = cliArgs.includes("--sync-configs");
-const useEngine = cliArgs.includes("--engine");
+const requestedPreset = getRequestedPreset(cliArgs);
+const runtimeFlags = resolveRuntimeFlags(cliArgs, requestedPreset);
+const useEmbedding = runtimeFlags.enableEmbedding;
+const useEngine = runtimeFlags.enableEngine;
+const useProfile = runtimeFlags.enableProfiling;
 const engineSecret = (() => {
     const idx = cliArgs.indexOf("--engine-secret");
     return idx >= 0 && idx + 1 < cliArgs.length ? cliArgs[idx + 1] : process.env.ENGINE_SECRET;
 })();
 export { TOOLSET_MAP };
-// Starter: ~19 tools. Just decision intelligence + discovery/meta overhead.
-// Users call discover_tools → load_toolset to expand. Under Google's 50-tool IDE limit.
-const STARTER_TOOLSETS = ["deep_sim"];
+// Starter/default: v3 core workflow facade only. Discovery/meta/dynamic tools are added separately.
+const STARTER_TOOLSETS = ["core_workflow"];
 // Core: the original default. ~81 tools across 15 domains.
-const CORE_TOOLSETS = ["verification", "eval", "quality_gate", "learning", "flywheel", "recon", "security", "boilerplate", "skill_update", "context_sandbox", "observability", "execution_trace", "mission_harness", "deep_sim", "founder"];
+const CORE_TOOLSETS = ["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"];
+// Power: extended research + founder intelligence without admin/debug-only runtime surfaces.
+const POWER_TOOLSETS = ["core_workflow", "deep_sim", "founder", "recon", "web", "shared_context", "sync_bridge", "session_memory", "entity_lookup", "delta", "site_map"];
+// Admin: profiling, debugging, observability, dashboards, and eval harness domains.
+const ADMIN_TOOLSETS = ["core_workflow", "observability", "profiler", "local_dashboard", "benchmark", "longitudinal_benchmark", "dogfood_judge", "execution_trace", "qa_orchestration", "mission_harness", "quality_gate", "eval", "verification"];
 const PRESETS = {
-    // DEFAULT: starter (~19 tools). Progressive discovery is the gateway to 338.
+    // DEFAULT: v3 core workflow facade. Progressive discovery expands into power/admin domains only when needed.
     default: STARTER_TOOLSETS,
     starter: STARTER_TOOLSETS,
+    power: POWER_TOOLSETS,
+    admin: ADMIN_TOOLSETS,
     // Core AI Flywheel — everything from the old default
     core: CORE_TOOLSETS,
-    // Themed presets — bridge between starter (19 tools) and full (338 tools)
-    web_dev: [...CORE_TOOLSETS, "ui_capture", "vision", "web", "seo", "git_workflow", "architect", "ui_ux_dive", "ui_ux_dive_v2", "mcp_bridge", "qa_orchestration", "visual_qa", "design_governance", "web_scraping"],
+    // Themed presets — bridge between the core workflow surface and full-domain coverage
+    web_dev: [...CORE_TOOLSETS, "ui_capture", "vision", "web", "seo", "git_workflow", "architect", "ui_ux_dive", "ui_ux_dive_v2", "mcp_bridge", "qa_orchestration", "visual_qa", "design_governance", "web_scraping", "site_map", "savings"],
     research: [...CORE_TOOLSETS, "web", "llm", "rss", "email", "docs", "research_optimizer", "web_scraping", "temporal_intelligence", "deep_sim"],
     data: [...CORE_TOOLSETS, "local_file", "llm", "web", "research_optimizer", "web_scraping", "temporal_intelligence"],
     devops: [...CORE_TOOLSETS, "git_workflow", "session_memory", "benchmark", "pattern"],
@@ -77,22 +87,29 @@ const PRESETS = {
     academic: [...CORE_TOOLSETS, "research_writing", "llm", "web", "local_file"],
     multi_agent: [...CORE_TOOLSETS, "parallel", "self_eval", "session_memory", "pattern", "toon", "qa_orchestration", "agent_traverse", "engine_context", "research_optimizer", "web_scraping", "deep_sim"],
     content: [...CORE_TOOLSETS, "llm", "critter", "email", "rss", "platform", "architect", "local_dashboard", "engine_context", "thompson_protocol"],
-    // ── Persona presets (all under 50 tools for IDE compatibility) ──
-    // Founder: decision intelligence + company tracking + session memory + local dashboard (~40 tools)
-    founder: ["deep_sim", "founder", "learning", "local_dashboard"],
+    // ── Persona presets (kept for compatibility, but no longer the default entry point) ──
+    // Founder: decision intelligence + company tracking + session memory + local dashboard
+    founder: ["deep_sim", "founder", "learning", "local_dashboard", "autonomous_delivery", "sync_bridge", "shared_context", "site_map", "savings", "profiler", "sweep", "monte_carlo"],
     // Banker/analyst: decision intelligence + company profiling + web research + recon (~39 tools)
-    banker: ["deep_sim", "founder", "web", "recon"],
-    // Operator: decision intelligence + company tracking + causal memory + action tracing (~40 tools)
-    operator: ["deep_sim", "founder", "causal_memory"],
+    banker: ["deep_sim", "founder", "web", "recon", "autonomous_delivery", "sync_bridge", "shared_context", "profiler"],
+    // Operator: decision intelligence + company tracking + causal memory + action tracing
+    operator: ["deep_sim", "founder", "causal_memory", "autonomous_delivery", "sync_bridge", "shared_context", "profiler"],
     // Researcher: decision intelligence + web + recon + session memory (~32 tools)
-    researcher: ["deep_sim", "web", "recon", "learning"],
+    researcher: ["deep_sim", "web", "recon", "learning", "autonomous_delivery", "sync_bridge", "shared_context", "profiler"],
     // Cursor IDE has a hard 40-tool limit across ALL MCP servers.
     cursor: ["deep_sim", "quality_gate", "learning", "session_memory", "web", "toon"],
+    // Hackathon: founder + web intelligence + entity enrichment + shared context
+    // Pairs with retention.sh for QA. Install: claude mcp add nodebench -- npx -y nodebench-mcp --preset=hackathon
+    hackathon: ["deep_sim", "founder", "learning", "web", "entity_enrichment", "autonomous_delivery", "sync_bridge", "shared_context", "recon", "local_dashboard", "delta", "profiler", "sweep", "monte_carlo"],
+    // Delta: full operating-intelligence preset — all delta.* packet tools + watchlist + entity intel
+    delta: ["deep_sim", "founder", "learning", "web", "entity_enrichment", "autonomous_delivery", "sync_bridge", "shared_context", "recon", "local_dashboard", "quality_gate", "execution_trace", "delta"],
     full: ALL_DOMAIN_KEYS,
 };
 const PRESET_DESCRIPTIONS = {
-    default: "Starter (~19 tools) — decision intelligence + progressive discovery. Use discover_tools → load_toolset to expand.",
-    starter: "Starter (~19 tools) — decision intelligence + progressive discovery. Use discover_tools → load_toolset to expand.",
+    default: "Default v3 surface — 7 workflow tools plus discovery/meta helpers. Fast boot, one artifact-shaped workflow.",
+    starter: "Default v3 surface — 7 workflow tools plus discovery/meta helpers. Fast boot, one artifact-shaped workflow.",
+    power: "Extended workflow preset — founder + recon + web + packets without admin-only runtime surfaces.",
+    admin: "Admin/runtime preset — profiling, observability, dashboards, eval, and debug lanes.",
     core: "Core AI Flywheel (~81 tools) — verification, eval, quality gates, learning, recon, mission harness",
     web_dev: "Web projects — adds visual QA, SEO audit, git workflow, code architecture",
     research: "Research workflows — adds web search, LLM calls, RSS feeds, email, docs",
@@ -102,24 +119,26 @@ const PRESET_DESCRIPTIONS = {
     academic: "Academic papers — adds polish, review, translate, logic check, data analysis",
     multi_agent: "Multi-agent teams — adds task locking, messaging, roles, oracle testing, frontend traversal",
     content: "Content & publishing — adds LLM, accountability, email, RSS, platform queue",
-    founder: "Founder (~40 tools) — decision intelligence, company tracking, session memory, local dashboard",
+    founder: "Founder decision preset — company tracking, decision intelligence, shared context, local dashboard",
     banker: "Banker/Analyst (~39 tools) — decision intelligence, company profiling, web research, recon",
-    operator: "Operator (~40 tools) — decision intelligence, company tracking, causal memory, action tracing",
+    operator: "Operator — decision intelligence, company tracking, causal memory, action tracing",
     researcher: "Researcher (~32 tools) — decision intelligence, web search, recon, session memory",
     cursor: "Cursor IDE (28 tools) — decision intelligence, quality gates, session memory, web, TOON encoding. Leaves 12 slots for other MCP servers.",
-    full: "Everything — all 338 tools for maximum coverage",
+    hackathon: "Hackathon — decision intelligence + entity intel + web research + team coordination. Pairs with retention.sh for QA.",
+    delta: "Delta (~65 tools) — full operating-intelligence preset. Entity intel, decision memos, watchlists, agent handoff, execution traces.",
+    full: "Everything — all domains for maximum coverage",
 };
 async function parseToolsets() {
     if (cliArgs.includes("--help")) {
         const lines = [
-            "nodebench-mcp v2.30.0 — Development Methodology MCP Server",
+            `nodebench-mcp v${NODEBENCH_VERSION} — Development Methodology MCP Server`,
             "",
             "Usage: nodebench-mcp [options]",
             "",
             "Options:",
             "  --toolsets <list>   Comma-separated toolsets to enable (default: default)",
             "  --exclude <list>    Comma-separated toolsets to exclude",
-            "  --preset <name>     Use a preset: default or full",
+            "  --preset <name>     Use a preset: default, power, admin, or full",
             "  --smart-preset      Generate smart preset recommendation based on project type and usage history",
             "  --auto-preset       Detect project type from package.json/pyproject.toml and recommend a preset",
             "  --stats             Show usage statistics for current project",
@@ -127,8 +146,13 @@ async function parseToolsets() {
             "  --reset-stats       Clear all usage analytics data",
             "  --list-presets      List all available presets with descriptions",
             "  --dynamic           Enable dynamic toolset loading (Search+Load pattern from arxiv 2509.20386)",
+            "  --embedding         Enable semantic embedding index on the default preset",
             "  --no-toon           Disable TOON encoding (TOON is on by default for ~40% token savings)",
-            "  --no-embedding      Disable neural embedding search (uses local HuggingFace model or API keys)",
+            "  --no-embedding      Disable neural embedding search",
+            "  --profile           Enable profiling proxy — logs every tool call with cost/latency",
+            "  --admin            Enable admin runtime surfaces (dashboards + watchdog)",
+            "  --dashboards       Start local dashboards explicitly",
+            "  --watchdog         Start observability watchdog explicitly",
             "  --engine            Start headless API engine server on port 6276",
             "  --engine-secret <s> Require Bearer token for engine API (or set ENGINE_SECRET env var)",
             "  --explain <tool>    Show plain-English explanation of a tool and exit",
@@ -147,12 +171,14 @@ async function parseToolsets() {
             }),
             "",
             "Examples:",
-            "  npx nodebench-mcp                    # Default (81 tools) - core AI Flywheel",
+            "  npx nodebench-mcp                    # Default v3 core workflow surface",
+            "  npx nodebench-mcp --preset power     # Extended founder/research surface",
+            "  npx nodebench-mcp --preset admin     # Profiling, observability, dashboards",
             "  npx nodebench-mcp --preset web_dev   # Web development (+ vision, SEO, git)",
             "  npx nodebench-mcp --preset research  # Research workflows (+ web, LLM, RSS, email)",
             "  npx nodebench-mcp --preset data      # Data analysis (+ local file parsing, LLM)",
             "  npx nodebench-mcp --preset academic  # Academic writing (+ paper tools, LLM)",
-            "  npx nodebench-mcp --preset full      # All 295 tools",
+            "  npx nodebench-mcp --preset full      # All available domains",
             "  npx nodebench-mcp --smart-preset     # Get AI-powered preset recommendation",
             "  npx nodebench-mcp --stats            # Show usage statistics",
             "  npx nodebench-mcp --toolsets verification,eval,recon",
@@ -195,7 +221,7 @@ async function parseToolsets() {
         const domainsToLoad = ALL_DOMAIN_KEYS.filter((k) => !excluded.has(k));
         return loadToolsets(domainsToLoad);
     }
-    // Default to starter preset (~19 tools — decision intelligence + discovery)
+    // Default to the v3 core workflow facade
     return loadToolsets(PRESETS.default);
 }
 // ── Analytics CLI flag handling ─────────────────────────────────────────
@@ -454,9 +480,11 @@ if (autoPresetFlag) {
         signals.push("academic: LaTeX files found");
         recommended = "academic";
     }
-    // Output — load all toolsets to get accurate counts
-    await loadToolsets(ALL_DOMAIN_KEYS);
+    // Output — only load the recommended preset to keep auto-preset fast
     const presetToolsets = PRESETS[recommended];
+    if (presetToolsets) {
+        await loadToolsets(presetToolsets);
+    }
     const toolCount = presetToolsets
         ? presetToolsets.reduce((s, k) => s + (TOOLSET_MAP[k]?.length ?? 0), 0) + 12
         : 0;
@@ -491,22 +519,24 @@ if (healthFlag) {
     const warn = `${Y}WARN${X}`;
     const fail = `${R}FAIL${X}`;
     const lines = [];
-    lines.push(`${B}NodeBench MCP v2.30.0 — Health Check${X}`);
+    lines.push(`${B}NodeBench MCP v${NODEBENCH_VERSION} — Health Check${X}`);
     lines.push("");
-    // 1. Tool count + preset — load all toolsets to get accurate counts
-    await loadToolsets(ALL_DOMAIN_KEYS);
-    const presetIdx2 = cliArgs.indexOf("--preset");
-    const activePreset = presetIdx2 !== -1 && cliArgs[presetIdx2 + 1] ? cliArgs[presetIdx2 + 1] : "default";
-    const domainCount = Object.keys(TOOLSET_MAP).length;
-    const totalTools = Object.values(TOOLSET_MAP).reduce((s, v) => s + v.length, 0);
+    // 1. Tool count + preset — load only the active preset for a fast health path
+    const activePreset = requestedPreset;
     const presetToolsets = PRESETS[activePreset];
+    if (presetToolsets) {
+        await loadToolsets(presetToolsets);
+    }
     const presetToolCount = presetToolsets
         ? presetToolsets.reduce((s, k) => s + (TOOLSET_MAP[k]?.length ?? 0), 0) + 12
-        : totalTools;
-    lines.push(`${C}Tools${X}       ${presetToolCount} loaded (preset: ${activePreset}) | ${totalTools} total across ${domainCount} domains`);
+        : 12;
+    lines.push(`${C}Tools${X}       ${presetToolCount} visible (preset: ${activePreset}) | ${ALL_DOMAIN_KEYS.length} domains available`);
     // 2. TOON + Embedding
     lines.push(`${C}TOON${X}        ${useToon ? ok : `${warn} disabled (--no-toon)`}`);
-    lines.push(`${C}Embedding${X}   ${useEmbedding ? ok : `${warn} disabled (--no-embedding)`}`);
+    lines.push(`${C}Embedding${X}   ${useEmbedding ? ok : `${warn} disabled on default hot path`}`);
+    lines.push(`${C}Runtime${X}     ${runtimeFlags.enableDashboards || runtimeFlags.enableWatchdog
+        ? `${ok} admin surfaces enabled`
+        : `${warn} core-only (pass --admin, --dashboards, or --watchdog to enable admin runtime)`}`);
     // 3. Database
     const os = await import("node:os");
     const path = await import("node:path");
@@ -592,6 +622,39 @@ if (healthFlag) {
         catch { /* not running */ }
         lines.push(`  ${reachable ? ok : `${Y}--${X}`}  ${name.padEnd(22)} :${port}${reachable ? "" : " (not running)"}`);
     }
+    // 9. Version check (npm registry)
+    lines.push("");
+    lines.push(`${B}Version${X}`);
+    const currentVersion = NODEBENCH_VERSION;
+    let latestVersion = "";
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch("https://registry.npmjs.org/nodebench-mcp/latest", {
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
+        });
+        clearTimeout(timeout);
+        if (res.ok) {
+            const data = await res.json();
+            latestVersion = data.version || "";
+        }
+    }
+    catch { /* offline or timeout */ }
+    const versionDelta = latestVersion ? comparePackageVersions(latestVersion, currentVersion) : 0;
+    if (latestVersion && versionDelta > 0) {
+        lines.push(`  ${Y}UPDATE${X}  ${currentVersion} → ${G}${latestVersion}${X}`);
+        lines.push(`          Run: ${C}npm install -g ${NODEBENCH_PACKAGE_NAME}@latest${X}`);
+    }
+    else if (latestVersion && versionDelta === 0) {
+        lines.push(`  ${ok}  v${currentVersion} (up to date)`);
+    }
+    else if (latestVersion) {
+        lines.push(`  ${ok}  v${currentVersion} (ahead of npm latest v${latestVersion})`);
+    }
+    else {
+        lines.push(`  ${ok}  v${currentVersion} (registry check skipped — offline?)`);
+    }
     // Summary
     lines.push("");
     const allEnvSet = envChecks.filter(([k]) => !!process.env[k]).length;
@@ -930,9 +993,52 @@ if (syncConfigsFlag) {
     else {
         lines.push(`  env:     ${Y}(none set)${X}`);
     }
+    // ── Copy rules to ~/.claude/rules/ ──────────────────────────────────
+    lines.push("");
+    lines.push(`${B}Rules${X}`);
+    const claudeRulesDir = path.join(os.homedir(), ".claude", "rules");
+    if (!fs.existsSync(claudeRulesDir)) {
+        fs.mkdirSync(claudeRulesDir, { recursive: true });
+    }
+    // Find rules directory relative to this file
+    const thisDir = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1"));
+    const rulesSearchPaths = [
+        path.resolve(thisDir, "..", "rules"), // dist/../rules (installed package)
+        path.resolve(thisDir, "..", "..", "rules"), // src/../../rules (dev mode)
+    ];
+    let rulesDir = "";
+    for (const p of rulesSearchPaths) {
+        if (fs.existsSync(p)) {
+            rulesDir = p;
+            break;
+        }
+    }
+    let rulesInstalled = 0;
+    if (rulesDir) {
+        const ruleFiles = fs.readdirSync(rulesDir).filter((f) => f.startsWith("nodebench-") && f.endsWith(".md"));
+        for (const file of ruleFiles) {
+            const src = path.join(rulesDir, file);
+            const dest = path.join(claudeRulesDir, file);
+            // Don't overwrite if user's version is newer
+            if (fs.existsSync(dest)) {
+                const srcStat = fs.statSync(src);
+                const destStat = fs.statSync(dest);
+                if (destStat.mtimeMs > srcStat.mtimeMs) {
+                    lines.push(`  ${Y}SKIP${X} ${file} (user version is newer)`);
+                    continue;
+                }
+            }
+            fs.copyFileSync(src, dest);
+            rulesInstalled++;
+        }
+        lines.push(`  ${G}OK${X}   Installed ${rulesInstalled} rules to ${claudeRulesDir}`);
+    }
+    else {
+        lines.push(`  ${Y}WARN${X} Rules directory not found — rules not copied`);
+    }
     lines.push("");
     const successCount = results.filter(r => r.action !== "failed").length;
-    lines.push(`${B}Written to ${successCount}/${results.length} locations${X}`);
+    lines.push(`${B}Written to ${successCount}/${results.length} IDE configs | ${rulesInstalled} rules installed${X}`);
     console.log(lines.join("\n"));
     process.exit(0);
 }
@@ -981,6 +1087,109 @@ if (cliArgs.length === 0 || (subCmd === undefined && !cliArgs.includes("--stdio"
     console.log(welcome.join("\n"));
     process.exit(0);
 }
+// ── Delta subcommands (run-and-exit, banking-convention verbs) ────────
+const DELTA_VERBS = ["brief", "diligence", "handoff", "watch", "memo", "scan", "compare", "review", "retain", "packets", "dogfood"];
+if (subCmd && DELTA_VERBS.includes(subCmd)) {
+    const { createDeltaTools } = await import("./tools/deltaTools.js");
+    const deltaTools = createDeltaTools();
+    const toolName = subCmd === "packets" ? "delta_packets"
+        : subCmd === "watch" ? "delta_watch"
+            : subCmd === "dogfood" ? "delta_self_dogfood"
+                : `delta_${subCmd}`;
+    const tool = deltaTools.find((t) => t.name === toolName);
+    if (!tool) {
+        console.error(`Unknown delta command: ${subCmd}`);
+        process.exit(1);
+    }
+    // Parse remaining args as JSON or key=value pairs
+    const rawToolArgs = cliArgs.filter((a) => a !== subCmd && !a.startsWith("--"));
+    const argStr = rawToolArgs.join(" ");
+    const parseCliScalar = (value) => {
+        if (value === "true")
+            return true;
+        if (value === "false")
+            return false;
+        if (/^-?\d+(\.\d+)?$/.test(value))
+            return Number(value);
+        if ((value.startsWith("{") && value.endsWith("}")) || (value.startsWith("[") && value.endsWith("]"))) {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        }
+        return value;
+    };
+    let toolArgs = {};
+    if (argStr) {
+        try {
+            toolArgs = JSON.parse(argStr);
+        }
+        catch {
+            if (rawToolArgs.length === 1) {
+                try {
+                    toolArgs = JSON.parse(rawToolArgs[0]);
+                }
+                catch {
+                    toolArgs = {};
+                }
+            }
+            // Check for key=value pairs first, collect remaining as positional
+            const kvParts = [];
+            const positionalParts = [];
+            for (const part of rawToolArgs) {
+                const eqIdx = part.indexOf("=");
+                if (eqIdx > 0) {
+                    toolArgs[part.slice(0, eqIdx)] = parseCliScalar(part.slice(eqIdx + 1));
+                    kvParts.push(part);
+                }
+                else {
+                    positionalParts.push(part);
+                }
+            }
+            // Join ALL positional words as the primary arg (handles multi-word strings)
+            if (positionalParts.length > 0) {
+                const fullPositional = positionalParts.join(" ");
+                if (subCmd === "diligence" || subCmd === "compare")
+                    toolArgs.entity = toolArgs.entity || fullPositional;
+                else if (subCmd === "watch")
+                    toolArgs.entity = toolArgs.entity || fullPositional;
+                else if (subCmd === "memo")
+                    toolArgs.decision = toolArgs.decision || fullPositional;
+                else if (subCmd === "handoff")
+                    toolArgs.task = toolArgs.task || fullPositional;
+                else if (subCmd === "retain")
+                    toolArgs.content = toolArgs.content || fullPositional;
+                else if (subCmd === "review")
+                    toolArgs.forecast = toolArgs.forecast || fullPositional;
+            }
+            // Default action for watch
+            if (subCmd === "watch" && !toolArgs.action)
+                toolArgs.action = toolArgs.entity ? "add" : "list";
+        }
+    }
+    else if (subCmd === "watch") {
+        toolArgs.action = "list";
+    }
+    try {
+        const result = await tool.handler(toolArgs);
+        const structuredResult = result;
+        const text = structuredResult.content?.[0]?.text || JSON.stringify(result);
+        try {
+            const parsed = JSON.parse(text);
+            console.log(JSON.stringify(parsed, null, 2));
+        }
+        catch {
+            console.log(text);
+        }
+    }
+    catch (err) {
+        console.error(`Error running delta_${subCmd}:`, err);
+        process.exit(1);
+    }
+    process.exit(0);
+}
 // ── Demo subcommand (run-and-exit) ───────────────────────────────────
 if (subCmd === "demo") {
     const USE_COLOR = process.stdout.isTTY;
@@ -1231,7 +1440,7 @@ if (subCmd === "setup") {
     lines.push(`  ${C}Dashboard:${X}  https://www.nodebenchai.com/founder`);
     lines.push(`  ${C}Agent setup:${X}  https://www.nodebenchai.com/agent-setup.txt`);
     lines.push("");
-    lines.push(`  ${Y}Presets:${X}  --preset default (99 tools) | --preset full (313 tools)`);
+    lines.push(`  ${Y}Presets:${X}  --preset default (core workflow) | --preset power | --preset admin`);
     lines.push(`  ${Y}Founder tools:${X}  founder_deep_context_gather, founder_packet_validate, founder_packet_diff`);
     lines.push("");
     console.log(lines.join("\n"));
@@ -1243,13 +1452,9 @@ getDb();
 _setDbAccessor(getDb);
 // Assemble tools (filtered by --toolsets / --exclude / --preset if provided)
 let domainTools = await parseToolsets();
-// Determine current preset name for analytics
-let currentPreset = 'default';
-const presetIdx = cliArgs.indexOf("--preset");
-if (presetIdx !== -1 && cliArgs[presetIdx + 1]) {
-    currentPreset = cliArgs[presetIdx + 1];
-}
-else if (cliArgs.includes("--toolsets") || cliArgs.includes("--exclude")) {
+// Determine current preset name for analytics/runtime gating
+let currentPreset = requestedPreset;
+if (cliArgs.includes("--toolsets") || cliArgs.includes("--exclude")) {
     currentPreset = 'custom';
 }
 // Dynamic loading: --dynamic flag enables Search+Load architecture
@@ -1727,8 +1932,44 @@ const dynamicLoadingTools = [
         },
     },
 ];
+// v3 preset gate: expose only facade tools + discover_tools + load_toolset
+const isV3Surface = currentPreset === "default" || currentPreset === "starter" || currentPreset === "v3";
 // Combine all tools (mutable for dynamic loading)
-let allTools = [...allToolsWithoutDiscovery, ...discoveryTools, ...dynamicLoadingTools];
+let allTools;
+if (isV3Surface) {
+    allTools = [
+        ...domainTools,
+        ...discoveryTools.filter(t => t.name === "discover_tools"),
+        ...dynamicLoadingTools.filter(t => t.name === "load_toolset"),
+    ];
+}
+else {
+    allTools = [...allToolsWithoutDiscovery, ...discoveryTools, ...dynamicLoadingTools];
+}
+// Always initialize profiler tables (lightweight, non-blocking)
+try {
+    const { initEventCollectorTables } = require("./profiler/eventCollector.js");
+    const { initWorkflowTemplateTables } = require("./profiler/workflowTemplates.js");
+    const { initProofEngineTables } = require("./profiler/proofEngine.js");
+    const { initModelRoutingTables } = require("./profiler/modelRouter.js");
+    initEventCollectorTables();
+    initWorkflowTemplateTables();
+    initProofEngineTables();
+    initModelRoutingTables();
+}
+catch { /* profiler tables optional */ }
+// Wrap all tools with profiling proxy when --profile is set
+// This adds ~1ms per tool call but logs everything to SQLite
+if (useProfile) {
+    try {
+        const { wrapToolsWithProxy } = require("./profiler/mcpProxy.js");
+        allTools = wrapToolsWithProxy(allTools, { sessionId: `mcp_${Date.now().toString(36)}` });
+        console.error("[profiler] All tools wrapped with profiling proxy (--profile)");
+    }
+    catch (e) {
+        console.error("[profiler] Failed to enable profiling:", e?.message);
+    }
+}
 // Background: initialize embedding index for semantic search (non-blocking)
 // Uses Agent-as-a-Graph bipartite corpus: tool nodes + domain nodes for graph-aware retrieval
 if (useEmbedding) {
@@ -1777,7 +2018,16 @@ for (const tool of allTools) {
 }
 // Rebuild function for dynamic loading — reconstructs allTools + toolMap
 function rebuildAllTools() {
-    allTools = [...allToolsWithoutDiscovery, ...discoveryTools, ...dynamicLoadingTools];
+    if (isV3Surface) {
+        allTools = [
+            ...domainTools,
+            ...discoveryTools.filter(t => t.name === "discover_tools"),
+            ...dynamicLoadingTools.filter(t => t.name === "load_toolset"),
+        ];
+    }
+    else {
+        allTools = [...allToolsWithoutDiscovery, ...discoveryTools, ...dynamicLoadingTools];
+    }
     toolMap = new Map();
     for (const tool of allTools) {
         toolMap.set(tool.name, tool);
@@ -2508,7 +2758,7 @@ You are connected to NodeBench MCP. Follow these rules EXACTLY.
 
 ### SELF-SETUP — If a capability is missing
 When discover_tools returns nothing useful, or a tool says "not configured":
-1. Escalate toolset: If started with --preset lite, switch to --preset core or targeted --toolsets
+1. Escalate toolset: If started on the default lane, switch to --preset power, --preset core, or targeted --toolsets
 2. Resolve providers: Configure missing API keys (GEMINI_API_KEY, OPENAI_API_KEY, etc.)
 3. Bootstrap infra: Run scaffold_nodebench_project or bootstrap_parallel_agents if repo lacks infra
 4. Smoke-test: Re-run the first workflow chain step to confirm the capability is available
@@ -2870,7 +3120,7 @@ Use NodeBench tools when you need to:
 - Audit SEO, analyze Figma flows, detect Android flicker
 - Call LLMs (GPT, Claude, Gemini) for analysis and extraction
 Start with discover_tools("<your task>") to find the right tool.`;
-const server = new Server({ name: "nodebench-mcp-methodology", version: "2.32.0" }, {
+const server = new Server({ name: "nodebench-mcp-methodology", version: NODEBENCH_VERSION }, {
     capabilities: { tools: { listChanged: true }, prompts: {} },
     instructions: SERVER_INSTRUCTIONS,
 });
@@ -3076,19 +3326,22 @@ process.on('exit', () => {
 // Connect via stdio
 const transport = new StdioServerTransport();
 await server.connect(transport);
-// Start local dashboard servers (non-blocking, best-effort)
-// Operating Dashboard is PRIMARY — shows business intelligence + system data
+// Start local dashboard servers only when explicitly requested.
 let operatingDashboardPort = 0;
-try {
-    operatingDashboardPort = await startOperatingDashboardServer(getDb(), 6274);
+if (runtimeFlags.enableDashboards) {
+    try {
+        operatingDashboardPort = await startOperatingDashboardServer(getDb(), 6274);
+    }
+    catch { /* operating dashboard is optional — don't block MCP */ }
 }
-catch { /* operating dashboard is optional — don't block MCP */ }
-// UI Dive dashboard is secondary — shows UI review sessions
+// UI Dive dashboard is secondary — also admin-only
 let dashboardPort = 0;
-try {
-    dashboardPort = await startDashboardServer(getDb(), 6278);
+if (runtimeFlags.enableDashboards) {
+    try {
+        dashboardPort = await startDashboardServer(getDb(), 6278);
+    }
+    catch { /* dashboard is optional — don't block MCP */ }
 }
-catch { /* dashboard is optional — don't block MCP */ }
 // Start engine API server (non-blocking, best-effort)
 let enginePort = 0;
 if (useEngine) {
@@ -3105,12 +3358,14 @@ if (useEngine) {
     }
     catch { /* engine is optional — don't block MCP */ }
 }
-// Start observability watchdog (non-blocking, best-effort)
-try {
-    initObservability(getDb);
-    startWatchdog(getDb());
+// Start observability watchdog only when explicitly requested.
+if (runtimeFlags.enableWatchdog) {
+    try {
+        initObservability(getDb);
+        startWatchdog(getDb());
+    }
+    catch { /* observability is optional — don't block MCP */ }
 }
-catch { /* observability is optional — don't block MCP */ }
 // Graceful shutdown
 process.on("SIGINT", () => { stopWatchdog(); process.exit(0); });
 process.on("SIGTERM", () => { stopWatchdog(); process.exit(0); });
@@ -3120,5 +3375,32 @@ const toolsetInfo = cliArgs.includes("--toolsets") || cliArgs.includes("--exclud
 const dashInfo = operatingDashboardPort ? ` dashboard at http://127.0.0.1:${operatingDashboardPort}` : "";
 const uiDiveInfo = dashboardPort ? ` ui-dive at http://127.0.0.1:${dashboardPort}` : "";
 const engineInfo = enginePort ? ` engine at http://127.0.0.1:${enginePort}` : "";
-console.error(`nodebench-mcp ready (${allTools.length} tools, ${PROMPTS.length} prompts${toolsetInfo}, SQLite at ~/.nodebench/${dashInfo}${uiDiveInfo}${engineInfo})`);
+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})`);
+// ── 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.
+const presetIdx2 = cliArgs.indexOf("--preset");
+const activePreset = presetIdx2 >= 0 ? cliArgs[presetIdx2 + 1] : "";
+if (activePreset === "hackathon" || activePreset === "delta" || cliArgs.includes("--auto-brief")) {
+    (async () => {
+        try {
+            const { createDeltaTools } = await import("./tools/deltaTools.js");
+            const dTools = createDeltaTools();
+            const briefTool = dTools.find((t) => t.name === "delta_brief");
+            if (briefTool) {
+                const result = await briefTool.handler({ persona: "founder" });
+                const text = result.content?.[0]?.text;
+                if (text) {
+                    const parsed = JSON.parse(text);
+                    const comp = parsed.compounding;
+                    console.error(`[delta] Auto-brief: ${comp?.totalPackets ?? 0} packets, ${comp?.watchedCount ?? 0} watched, ${comp?.daysSinceFirst ?? 0} days active`);
+                }
+            }
+        }
+        catch { /* auto-brief is best-effort */ }
+    })();
+}
 //# sourceMappingURL=index.js.map