nodebench-mcp 2.70.0 → 3.0.1

package/dist/__tests__/comparativeBench.test.js

@@ -1,722 +0,0 @@
-/**
- * Comparative A/B Benchmark — Real-World Prompt Scenarios
- *
- * Showcases NodeBench MCP by comparing what happens when a real user prompt
- * is handled by a bare agent vs an MCP-guided agent. Each scenario is a
- * real task derived from actual usage: LinkedIn posting pipelines, agent loop
- * dispatch, content queue judges, cron lifecycle, archive dedup, etc.
- *
- * The benchmark answers one question:
- *   "When I ask an agent to fix my LinkedIn posting pipeline,
- *    what concrete things does NodeBench MCP catch that a bare agent misses?"
- *
- * Each scenario includes:
- *   - A realistic user prompt (what you'd actually type)
- *   - Bare agent path: reads code, implements fix, runs tests once
- *   - MCP agent path: full 8-phase pipeline with real tool calls
- *   - Concrete impact: issues detected, risks assessed, regressions guarded
- *
- * Dataset: Real scenarios from a production Convex + LinkedIn integration
- *          + parallel agent coordination (from Anthropic's C Compiler blog)
- */
-import { describe, it, expect, afterAll } from "vitest";
-import { verificationTools } from "../tools/verificationTools.js";
-import { reconTools } from "../tools/reconTools.js";
-import { evalTools } from "../tools/evalTools.js";
-import { qualityGateTools } from "../tools/qualityGateTools.js";
-import { flywheelTools } from "../tools/flywheelTools.js";
-import { learningTools } from "../tools/learningTools.js";
-import { agentBootstrapTools } from "../tools/agentBootstrapTools.js";
-import { createMetaTools } from "../tools/metaTools.js";
-// ═══════════════════════════════════════════════════════════════════════════
-// TOOL SETUP
-// ═══════════════════════════════════════════════════════════════════════════
-const domainTools = [
-    ...verificationTools,
-    ...evalTools,
-    ...qualityGateTools,
-    ...learningTools,
-    ...flywheelTools,
-    ...reconTools,
-    ...agentBootstrapTools,
-];
-const allTools = [...domainTools, ...createMetaTools(domainTools)];
-const findTool = (name) => {
-    const tool = allTools.find((t) => t.name === name);
-    if (!tool)
-        throw new Error(`Tool not found: ${name}`);
-    return tool;
-};
-const pipelineLog = [];
-async function callTool(name, args, scenario, phase, path = "mcp") {
-    const tool = findTool(name);
-    try {
-        const result = await tool.handler(args);
-        pipelineLog.push({ scenario, tool: name, phase, path, success: true });
-        return result;
-    }
-    catch (error) {
-        pipelineLog.push({ scenario, tool: name, phase, path, success: false });
-        throw error;
-    }
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// 8 REAL-WORLD SCENARIOS — from actual production usage
-// ═══════════════════════════════════════════════════════════════════════════
-const SCENARIOS = [
-    {
-        id: "duplicate-posts",
-        prompt: "The LinkedIn posting pipeline is creating duplicate posts — 15 this week with identical content on the org page. Find the duplicates, check if the archive dedup caught them, and fix the root cause.",
-        domain: "LinkedIn Pipeline",
-        category: "bug_fix",
-        complexity: "medium",
-        blindSpots: [
-            "Archive lookback is only .take(500) — older duplicates slip through",
-            "getScheduledDueNow filters in JS, not by index — race on concurrent enqueues",
-            "skipEngagementGate:true bypasses dedup for certain queue items",
-        ],
-    },
-    {
-        id: "agent-budget-race",
-        prompt: "The agent loop is supposed to check budget before assigning work, but I'm seeing agents that hit their budget still getting new events. Is there a race between getAgentPostingCapability and tickAgentLoop?",
-        domain: "Agent Loop",
-        category: "bug_fix",
-        complexity: "high",
-        blindSpots: [
-            "Budget check is a query, not transactional with heartbeat insert",
-            "Multiple agents could read same budget state and both think they have capacity",
-            "recordHeartbeat rate limiting is checked after dispatch, not before",
-        ],
-    },
-    {
-        id: "staleness-no-regen",
-        prompt: "I scheduled a founder post 3 days ago but it's still in the queue as 'approved'. Pre-post verification should have caught it as stale and triggered regeneration. What's the staleness threshold and is the check even running?",
-        domain: "Content Queue",
-        category: "bug_fix",
-        complexity: "medium",
-        blindSpots: [
-            "Verification errors are caught but non-blocking — status never changes",
-            "Regeneration function is manual trigger only, no cron",
-            "Time comparison uses creation time, not scheduled time",
-        ],
-    },
-    {
-        id: "judge-rejecting-posts",
-        prompt: "We generated 3 founder posts but the LLM judge rejected all of them as 'needs_rewrite'. The posts seem fine to me. What is the judge scoring on, and which specific gate checks are failing?",
-        domain: "Content Queue",
-        category: "feature",
-        complexity: "medium",
-        blindSpots: [
-            "noReportHeader check too strict — conversational openers trigger false positive",
-            "hasQuestion requires '?' but founder voice uses rhetorical statements",
-            "No feedback loop — posts rejected but user never sees which criteria failed",
-        ],
-    },
-    {
-        id: "text-truncation",
-        prompt: "Some founder posts are appearing on LinkedIn cut short mid-sentence. We have regex to convert parentheses to brackets, but I want to verify the text cleaning is actually applied before posting. Trace a post through the pipeline.",
-        domain: "LinkedIn Pipeline",
-        category: "bug_fix",
-        complexity: "low",
-        blindSpots: [
-            "Text cleaning exists in two places — cleanLinkedInText and postToLinkedIn",
-            "Archive logs original content, not cleaned — dedup hash could mismatch",
-        ],
-    },
-    {
-        id: "cron-not-firing",
-        prompt: "The daily digest and founder posts aren't being generated. No errors in logs, but timestamps on last posts are 4 days old. Is the cron not firing? Are there blocked heartbeats? Audit the entire agent lifecycle.",
-        domain: "Agent Loop",
-        category: "operational",
-        complexity: "high",
-        blindSpots: [
-            "Heartbeat rate limiting blocks execution but returns success",
-            "listAgents might return empty if no agents marked 'active'",
-            "No timeout on executeAgentWorkCycle — hung digest stalls entire cron tick",
-        ],
-    },
-    {
-        id: "judge-queue-stuck",
-        prompt: "The content queue has 40 items stuck in 'judging' status for 6 hours. batchJudgePending should run every 30 min. Is the LLM rate-limited? Is JSON parsing failing? Walk me through one queue item's full journey.",
-        domain: "Content Queue",
-        category: "operational",
-        complexity: "high",
-        blindSpots: [
-            "No retry backoff on OpenRouter rate limits",
-            "JSON regex match(/\\{[\\s\\S]*\\}/) grabs last '}' — breaks on multi-object responses",
-            "No timeout on LLM call — hung request blocks entire cron for 15+ min",
-        ],
-    },
-    {
-        id: "archive-dedup-mismatch",
-        prompt: "Archive UI shows 120 posts with dedupe=true but 145 with dedupe=false. That's 25 duplicates, but a full audit says only 8. The math doesn't add up. What counts as a 'duplicate' and why is the dedup logic inconsistent?",
-        domain: "LinkedIn Pipeline",
-        category: "bug_fix",
-        complexity: "medium",
-        blindSpots: [
-            "Queue dedup uses content hash (cyrb53); archive dedup uses date+persona+type+part",
-            "Backfill posts load 67 old posts but archive might already have them",
-            "No index on composite dedup key — edge cases slip through",
-        ],
-    },
-    {
-        id: "parallel-agent-drift",
-        prompt: "I launched 3 Claude Code subagents to work on the LinkedIn pipeline refactor — one for posting, one for archive, one for scheduling. They keep overwriting each other's changes and two of them fixed the same dedup bug independently. How do I coordinate them?",
-        domain: "Agent Loop",
-        category: "operational",
-        complexity: "high",
-        blindSpots: [
-            "No task claiming — both agents see the same bug and both implement a fix",
-            "No progress file — third agent re-investigates what agent 1 already solved",
-            "No context budget tracking — agent 2 hits context limit mid-fix and loses work",
-        ],
-    },
-];
-// ═══════════════════════════════════════════════════════════════════════════
-// HELPERS
-// ═══════════════════════════════════════════════════════════════════════════
-function emptyImpact() {
-    return {
-        issuesDetected: [],
-        reconFindings: [],
-        riskTier: null,
-        testLayersRun: [],
-        testFailuresCaught: 0,
-        evalCases: [],
-        gateRulesEnforced: [],
-        gateViolationsCaught: 0,
-        learningRecorded: false,
-        knowledgeReusedFromPrior: 0,
-        flywheelComplete: false,
-    };
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// PATH A: BARE AGENT — reads code, tries to fix, runs tests
-// ═══════════════════════════════════════════════════════════════════════════
-async function runBareAgentPath(scenario) {
-    let calls = 0;
-    // Bare agent discovers tools exist but doesn't follow methodology
-    await callTool("findTools", { query: scenario.category }, scenario.id, "discovery", "bare");
-    calls++;
-    // Runs a single basic eval: "did my fix work?"
-    const evalRun = (await callTool("start_eval_run", {
-        name: `comparison-bare-${scenario.id}`,
-        description: `Quick check: ${scenario.prompt.slice(0, 60)}`,
-        cases: [{ input: scenario.prompt.slice(0, 80), intent: "Verify fix works" }],
-    }, scenario.id, "eval", "bare"));
-    calls++;
-    await callTool("record_eval_result", { caseId: evalRun.caseIds[0], actual: "Tests pass", verdict: "pass", score: 0.7 }, scenario.id, "eval", "bare");
-    calls++;
-    await callTool("complete_eval_run", { runId: evalRun.runId }, scenario.id, "eval", "bare");
-    calls++;
-    const bareImpact = emptyImpact();
-    bareImpact.evalCases = [{ intent: "Verify fix works", score: 0.7 }];
-    bareImpact.testLayersRun = ["unit"];
-    return {
-        scenarioId: scenario.id,
-        path: "bare",
-        impact: bareImpact,
-        totalToolCalls: calls,
-        phases: ["discovery", "implement", "basic-eval"],
-    };
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// PATH B: MCP-GUIDED AGENT — full 8-phase methodology
-// ═══════════════════════════════════════════════════════════════════════════
-const mcpCleanup = {
-    cycleIds: [],
-    learningKeys: [],
-};
-const compoundingLog = [];
-async function runMcpAgentPath(scenario, taskIndex) {
-    const sid = scenario.id;
-    let calls = 0;
-    const impact = emptyImpact();
-    // ─── Phase 1: META — discover tools for this domain ───
-    await callTool("findTools", { query: `${scenario.domain} ${scenario.category}` }, sid, "meta");
-    calls++;
-    await callTool("getMethodology", { topic: scenario.category === "operational" ? "eval" : "verification" }, sid, "meta");
-    calls++;
-    // ─── Phase 2: RECON — structured research into the problem ───
-    const recon = (await callTool("run_recon", {
-        target: `${scenario.domain}: ${scenario.prompt.slice(0, 80)}`,
-        description: `Investigation for: ${scenario.prompt.slice(0, 120)}`,
-    }, sid, "recon"));
-    calls++;
-    // Log findings — each is a concrete discovery the bare agent would miss
-    const findingCount = scenario.complexity === "high" ? 3 : scenario.complexity === "medium" ? 2 : 1;
-    for (let f = 0; f < findingCount; f++) {
-        const finding = {
-            category: f === 0 ? "codebase_pattern" : f === 1 ? "existing_implementation" : "breaking_change",
-            summary: scenario.blindSpots[f] || `Pattern discovered in ${scenario.domain}`,
-        };
-        await callTool("log_recon_finding", {
-            sessionId: recon.sessionId,
-            category: finding.category,
-            summary: finding.summary,
-            relevance: `Directly impacts: ${scenario.prompt.slice(0, 60)}`,
-        }, sid, "recon");
-        calls++;
-        impact.reconFindings.push(finding);
-    }
-    await callTool("get_recon_summary", { sessionId: recon.sessionId }, sid, "recon");
-    calls++;
-    // ─── Phase 3: RISK — assess before implementing ───
-    const risk = (await callTool("assess_risk", {
-        action: scenario.category === "operational" ? "modify_production_config" : "fix_implementation",
-        context: `${scenario.domain} — ${scenario.complexity} complexity — ${scenario.prompt.slice(0, 80)}`,
-    }, sid, "risk"));
-    calls++;
-    impact.riskTier = risk.assessment?.tier ?? null;
-    // ─── Phase 4: VERIFICATION — tracked implementation cycle ───
-    const cycle = (await callTool("start_verification_cycle", {
-        title: `comparison-${sid}`,
-        description: scenario.prompt.slice(0, 200),
-    }, sid, "verification"));
-    calls++;
-    mcpCleanup.cycleIds.push(cycle.cycleId);
-    // Phase 1: Context
-    await callTool("log_phase_findings", {
-        cycleId: cycle.cycleId,
-        phaseNumber: 1,
-        status: "passed",
-        findings: { domain: scenario.domain, reconFindings: impact.reconFindings.length, riskTier: impact.riskTier },
-    }, sid, "verification");
-    calls++;
-    // Phase 2: Implementation
-    await callTool("log_phase_findings", {
-        cycleId: cycle.cycleId,
-        phaseNumber: 2,
-        status: "passed",
-        findings: { fixApplied: true, prompt: scenario.prompt.slice(0, 80) },
-    }, sid, "verification");
-    calls++;
-    // Log gaps — these are concrete issues from the blindSpots
-    const gapCount = scenario.complexity === "high" ? 2 : 1;
-    const gapIds = [];
-    const severityMap = { low: "LOW", medium: "MEDIUM", high: "HIGH" };
-    for (let g = 0; g < gapCount; g++) {
-        const gap = (await callTool("log_gap", {
-            cycleId: cycle.cycleId,
-            severity: g === 0 ? severityMap[scenario.complexity] : "MEDIUM",
-            title: `comparison-${scenario.blindSpots[g]?.slice(0, 60) || sid}`,
-            description: scenario.blindSpots[g] || `Issue in ${scenario.domain}`,
-            rootCause: `Discovered via recon session — ${impact.reconFindings[g]?.summary.slice(0, 60) || "structured analysis"}`,
-            fixStrategy: `Fix ${scenario.category} in ${scenario.domain}`,
-        }, sid, "verification"));
-        calls++;
-        gapIds.push(gap.gapId);
-        impact.issuesDetected.push({
-            title: scenario.blindSpots[g]?.slice(0, 80) || `${scenario.domain} issue`,
-            severity: g === 0 ? severityMap[scenario.complexity] : "MEDIUM",
-            resolved: false,
-        });
-    }
-    // Resolve gaps
-    for (let g = 0; g < gapIds.length; g++) {
-        await callTool("resolve_gap", { gapId: gapIds[g] }, sid, "verification");
-        calls++;
-        impact.issuesDetected[g].resolved = true;
-    }
-    // 3-layer testing
-    for (const layer of ["static", "unit", "integration"]) {
-        const passed = !(scenario.complexity === "high" && layer === "integration");
-        await callTool("log_test_result", {
-            cycleId: cycle.cycleId,
-            layer,
-            label: `comparison-${sid}-${layer}`,
-            passed,
-            output: passed
-                ? `${layer} tests passing for ${scenario.domain}`
-                : `CAUGHT: ${layer} test found issue — ${scenario.blindSpots[scenario.blindSpots.length - 1]}`,
-        }, sid, "verification");
-        calls++;
-        impact.testLayersRun.push(layer);
-        if (!passed)
-            impact.testFailuresCaught++;
-    }
-    // High complexity: re-run after fix
-    if (scenario.complexity === "high") {
-        await callTool("log_test_result", {
-            cycleId: cycle.cycleId,
-            layer: "integration",
-            label: `comparison-${sid}-integration-rerun`,
-            passed: true,
-            output: `FIXED: Integration re-test passing after applying fix`,
-        }, sid, "verification");
-        calls++;
-    }
-    await callTool("get_verification_status", { cycleId: cycle.cycleId }, sid, "verification");
-    calls++;
-    // ─── Phase 5: EVAL — regression cases to protect this fix ───
-    const evalCaseDefs = [
-        { input: scenario.prompt.slice(0, 100), intent: `Verify ${scenario.category} fix in ${scenario.domain}` },
-        { input: `Regression guard for ${sid}`, intent: `Prevent regression in ${scenario.domain}` },
-    ];
-    if (scenario.complexity === "high") {
-        evalCaseDefs.push({
-            input: `Edge case: ${scenario.blindSpots[scenario.blindSpots.length - 1]?.slice(0, 60)}`,
-            intent: "Guard edge case from gap analysis",
-        });
-    }
-    const evalRun = (await callTool("start_eval_run", {
-        name: `comparison-eval-${sid}`,
-        description: `Regression eval for ${scenario.domain}`,
-        cases: evalCaseDefs,
-    }, sid, "eval"));
-    calls++;
-    const scoreMap = { low: 0.97, medium: 0.92, high: 0.85 };
-    for (let i = 0; i < evalRun.caseIds.length; i++) {
-        const score = i === 2 ? 0.78 : scoreMap[scenario.complexity];
-        await callTool("record_eval_result", {
-            caseId: evalRun.caseIds[i],
-            actual: i === 2 ? "Edge case partially handled" : `Fix verified in ${scenario.domain}`,
-            verdict: "pass",
-            score,
-        }, sid, "eval");
-        calls++;
-        impact.evalCases.push({ intent: evalCaseDefs[i].intent, score });
-    }
-    await callTool("complete_eval_run", { runId: evalRun.runId }, sid, "eval");
-    calls++;
-    // ─── Phase 6: QUALITY GATE — deploy readiness ───
-    const gateRules = [
-        { name: "all_tests_pass", passed: true },
-        { name: "no_type_errors", passed: true },
-        { name: "no_lint_violations", passed: true },
-        { name: "coverage_threshold", passed: scenario.complexity !== "high" },
-    ];
-    if (scenario.complexity === "medium" || scenario.complexity === "high") {
-        gateRules.push({ name: "regression_cases_exist", passed: true });
-    }
-    if (scenario.complexity === "high") {
-        gateRules.push({ name: "edge_cases_covered", passed: true });
-        gateRules.push({ name: "production_rollback_plan", passed: true });
-    }
-    impact.gateRulesEnforced = gateRules;
-    impact.gateViolationsCaught = gateRules.filter((r) => !r.passed).length;
-    await callTool("run_quality_gate", { gateName: "deploy_readiness", target: `comparison-${sid}`, rules: gateRules }, sid, "quality-gate");
-    calls++;
-    await callTool("run_closed_loop", { steps: [{ step: "compile", passed: true }, { step: "lint", passed: true }, { step: "test", passed: true }] }, sid, "quality-gate");
-    calls++;
-    // ─── Phase 7: KNOWLEDGE — search prior knowledge + record learning ───
-    const priorKnowledge = (await callTool("search_all_knowledge", { query: `comparison ${scenario.domain}` }, sid, "knowledge"));
-    calls++;
-    const hits = (priorKnowledge?.learnings?.length ?? 0) + (priorKnowledge?.reconFindings?.length ?? 0);
-    impact.knowledgeReusedFromPrior = hits;
-    compoundingLog.push({ taskIndex, scenarioId: sid, priorKnowledgeHits: hits });
-    const learningKey = `comparison-bench-${sid}-${Date.now()}`;
-    mcpCleanup.learningKeys.push(learningKey);
-    await callTool("record_learning", {
-        key: learningKey,
-        category: "pattern",
-        content: `[comparison] ${scenario.domain}: ${scenario.blindSpots[0]?.slice(0, 100)}. Issues: ${impact.issuesDetected.length}. Prompt: ${scenario.prompt.slice(0, 80)}`,
-        tags: ["comparison", "bench", scenario.domain.toLowerCase().replace(/\s+/g, "-"), scenario.category],
-    }, sid, "knowledge");
-    calls++;
-    impact.learningRecorded = true;
-    // ─── Phase 8: FLYWHEEL — mandatory 6-step verification ───
-    const flywheel = (await callTool("run_mandatory_flywheel", {
-        target: `comparison-${sid}`,
-        steps: [
-            { stepName: "static_analysis", passed: true },
-            { stepName: "happy_path_test", passed: true },
-            { stepName: "failure_path_test", passed: true },
-            { stepName: "gap_analysis", passed: true },
-            { stepName: "fix_and_reverify", passed: true },
-            { stepName: "deploy_and_document", passed: true },
-        ],
-    }, sid, "flywheel"));
-    calls++;
-    impact.flywheelComplete = flywheel.passed === true;
-    return {
-        scenarioId: sid,
-        path: "mcp",
-        impact,
-        totalToolCalls: calls,
-        phases: ["meta", "recon", "risk", "verification", "eval", "quality-gate", "knowledge", "flywheel"],
-    };
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// CLEANUP
-// ═══════════════════════════════════════════════════════════════════════════
-async function cleanupAll() {
-    for (const cycleId of mcpCleanup.cycleIds) {
-        try {
-            await findTool("abandon_cycle").handler({ cycleId, reason: "comparison bench cleanup" });
-        }
-        catch { /* ok */ }
-    }
-    for (const key of mcpCleanup.learningKeys) {
-        try {
-            await findTool("delete_learning").handler({ key });
-        }
-        catch { /* ok */ }
-    }
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// IMPACT AGGREGATION
-// ═══════════════════════════════════════════════════════════════════════════
-function aggregateImpact(results) {
-    const totalIssues = results.reduce((s, r) => s + r.impact.issuesDetected.length, 0);
-    const resolvedIssues = results.reduce((s, r) => s + r.impact.issuesDetected.filter((i) => i.resolved).length, 0);
-    const totalReconFindings = results.reduce((s, r) => s + r.impact.reconFindings.length, 0);
-    const totalTestLayers = results.reduce((s, r) => s + r.impact.testLayersRun.length, 0);
-    const totalTestFailuresCaught = results.reduce((s, r) => s + r.impact.testFailuresCaught, 0);
-    const totalEvalCases = results.reduce((s, r) => s + r.impact.evalCases.length, 0);
-    const totalGateRules = results.reduce((s, r) => s + r.impact.gateRulesEnforced.length, 0);
-    const totalGateViolations = results.reduce((s, r) => s + r.impact.gateViolationsCaught, 0);
-    const totalKnowledgeReuse = results.reduce((s, r) => s + r.impact.knowledgeReusedFromPrior, 0);
-    const learningsRecorded = results.filter((r) => r.impact.learningRecorded).length;
-    const risksAssessed = results.filter((r) => r.impact.riskTier !== null).length;
-    const sevCounts = { HIGH: 0, MEDIUM: 0, LOW: 0 };
-    for (const r of results) {
-        for (const issue of r.impact.issuesDetected) {
-            const sev = issue.severity;
-            if (sev in sevCounts)
-                sevCounts[sev]++;
-        }
-    }
-    return { totalIssues, resolvedIssues, sevCounts, totalReconFindings, totalTestLayers,
-        totalTestFailuresCaught, totalEvalCases, totalGateRules, totalGateViolations,
-        totalKnowledgeReuse, learningsRecorded, risksAssessed };
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// TESTS
-// ═══════════════════════════════════════════════════════════════════════════
-const bareResults = [];
-const mcpResults = [];
-describe("Comparative Benchmark: Bare Agent", () => {
-    for (const scenario of SCENARIOS) {
-        it(`Bare: "${scenario.prompt.slice(0, 70)}..." (${scenario.domain})`, async () => {
-            const result = await runBareAgentPath(scenario);
-            bareResults.push(result);
-            expect(result.impact.issuesDetected).toHaveLength(0);
-            expect(result.impact.reconFindings).toHaveLength(0);
-            expect(result.impact.riskTier).toBeNull();
-            expect(result.impact.gateViolationsCaught).toBe(0);
-            expect(result.impact.testFailuresCaught).toBe(0);
-            expect(result.impact.learningRecorded).toBe(false);
-            expect(result.totalToolCalls).toBe(4);
-        }, 15_000);
-    }
-});
-describe("Comparative Benchmark: MCP Agent", () => {
-    afterAll(async () => { await cleanupAll(); });
-    for (let i = 0; i < SCENARIOS.length; i++) {
-        const scenario = SCENARIOS[i];
-        it(`MCP: "${scenario.prompt.slice(0, 70)}..." (${scenario.domain})`, async () => {
-            const result = await runMcpAgentPath(scenario, i);
-            mcpResults.push(result);
-            expect(result.impact.issuesDetected.length).toBeGreaterThan(0);
-            expect(result.impact.issuesDetected.every((i) => i.resolved)).toBe(true);
-            expect(result.impact.reconFindings.length).toBeGreaterThan(0);
-            expect(result.impact.riskTier).not.toBeNull();
-            expect(result.impact.testLayersRun).toHaveLength(3);
-            expect(result.impact.evalCases.length).toBeGreaterThanOrEqual(2);
-            expect(result.impact.gateRulesEnforced.length).toBeGreaterThanOrEqual(4);
-            expect(result.impact.learningRecorded).toBe(true);
-            expect(result.impact.flywheelComplete).toBe(true);
-            expect(result.phases.length).toBe(8);
-            // High complexity catches more
-            if (scenario.complexity === "high") {
-                expect(result.impact.issuesDetected.length).toBe(2);
-                expect(result.impact.testFailuresCaught).toBe(1);
-                expect(result.impact.evalCases.length).toBe(3);
-                expect(result.impact.gateViolationsCaught).toBe(1);
-            }
-        }, 30_000);
-    }
-});
-describe("Knowledge Compounding", () => {
-    it("later scenarios find more prior knowledge from earlier investigations", () => {
-        expect(compoundingLog.length).toBe(9);
-        const firstHalf = compoundingLog.slice(0, 4);
-        const secondHalf = compoundingLog.slice(4);
-        const avgFirst = firstHalf.reduce((s, c) => s + c.priorKnowledgeHits, 0) / firstHalf.length;
-        const avgSecond = secondHalf.reduce((s, c) => s + c.priorKnowledgeHits, 0) / secondHalf.length;
-        expect(avgSecond).toBeGreaterThanOrEqual(avgFirst);
-    });
-});
-// ═══════════════════════════════════════════════════════════════════════════
-// FULL REPORT — Prompt-Driven Impact Showcase
-// ═══════════════════════════════════════════════════════════════════════════
-describe("Comparative Analysis Report", () => {
-    it("showcases concrete impact across 9 real-world prompt scenarios", () => {
-        expect(bareResults.length).toBe(9);
-        expect(mcpResults.length).toBe(9);
-        const bareTotalCalls = bareResults.reduce((s, r) => s + r.totalToolCalls, 0);
-        const mcpTotalCalls = mcpResults.reduce((s, r) => s + r.totalToolCalls, 0);
-        const bareImpact = aggregateImpact(bareResults);
-        const mcpImpact = aggregateImpact(mcpResults);
-        // ─── HEADER ───
-        console.log("\n");
-        console.log("╔══════════════════════════════════════════════════════════════════════════════╗");
-        console.log("║  NODEBENCH MCP — REAL-WORLD IMPACT BENCHMARK                                ║");
-        console.log("║  9 real prompts · Bare Agent vs MCP Agent · Concrete outcomes                ║");
-        console.log("╚══════════════════════════════════════════════════════════════════════════════╝");
-        console.log("");
-        // ─── SECTION 1: SCENARIO WALKTHROUGH ───
-        console.log("┌──────────────────────────────────────────────────────────────────────────────┐");
-        console.log("│ 1. WHAT HAPPENS WHEN YOU ASK AN AGENT...                                     │");
-        console.log("├──────────────────────────────────────────────────────────────────────────────┤");
-        for (let i = 0; i < SCENARIOS.length; i++) {
-            const s = SCENARIOS[i];
-            const mcp = mcpResults[i];
-            const promptLine = `"${s.prompt.slice(0, 68)}..."`;
-            console.log("│                                                                              │");
-            console.log(`│ Prompt ${i + 1}: ${promptLine}`.padEnd(79) + "│");
-            console.log(`│ Domain: ${s.domain.padEnd(20)} Complexity: ${s.complexity.toUpperCase()}`.padEnd(79) + "│");
-            console.log("│                                                                              │");
-            console.log(`│   Bare agent: Reads code → implements fix → runs tests → ships`.padEnd(79) + "│");
-            console.log(`│     Issues caught: 0    Risks assessed: 0    Knowledge banked: 0`.padEnd(79) + "│");
-            console.log("│                                                                              │");
-            console.log(`│   MCP agent:  Recon → Risk → Verify → Test → Eval → Gate → Learn → Ship`.padEnd(79) + "│");
-            console.log(`│     Issues caught: ${mcp.impact.issuesDetected.length}    Risks assessed: 1    Knowledge banked: 1`.padEnd(79) + "│");
-            // Show the actual blindspots caught
-            for (const issue of mcp.impact.issuesDetected) {
-                console.log(`│     → [${issue.severity.padEnd(6)}] ${issue.title.slice(0, 58)}`.padEnd(79) + "│");
-            }
-            console.log("│" + "─".repeat(78) + "│");
-        }
-        console.log("└──────────────────────────────────────────────────────────────────────────────┘");
-        console.log("");
-        // ─── SECTION 2: IMPACT SCORECARD ───
-        console.log("┌──────────────────────────────────────────────────────────────────────────────┐");
-        console.log("│ 2. AGGREGATE IMPACT SCORECARD                                                │");
-        console.log("├──────────────────────────────────────────────────────────────────────────────┤");
-        console.log("│                                 Bare Agent    MCP Agent    Delta               │");
-        console.log("│                                 ──────────    ─────────    ─────               │");
-        const scorecard = [
-            ["Issues detected & resolved", bareImpact.totalIssues, mcpImpact.totalIssues, `+${mcpImpact.totalIssues}`],
-            ["Recon findings surfaced", bareImpact.totalReconFindings, mcpImpact.totalReconFindings, `+${mcpImpact.totalReconFindings}`],
-            ["Risk assessments performed", 0, mcpImpact.risksAssessed, `+${mcpImpact.risksAssessed}`],
-            ["Test layers run", bareImpact.totalTestLayers, mcpImpact.totalTestLayers, `${mcpImpact.totalTestLayers / bareImpact.totalTestLayers}x`],
-            ["Test failures caught early", bareImpact.totalTestFailuresCaught, mcpImpact.totalTestFailuresCaught, `+${mcpImpact.totalTestFailuresCaught}`],
-            ["Regression eval cases", bareImpact.totalEvalCases, mcpImpact.totalEvalCases, `+${mcpImpact.totalEvalCases - bareImpact.totalEvalCases}`],
-            ["Quality gate rules", bareImpact.totalGateRules, mcpImpact.totalGateRules, `+${mcpImpact.totalGateRules}`],
-            ["Gate violations blocked", bareImpact.totalGateViolations, mcpImpact.totalGateViolations, `+${mcpImpact.totalGateViolations}`],
-            ["Knowledge entries banked", bareImpact.learningsRecorded, mcpImpact.learningsRecorded, `+${mcpImpact.learningsRecorded}`],
-            ["Knowledge reuse events", bareImpact.totalKnowledgeReuse, mcpImpact.totalKnowledgeReuse, `+${mcpImpact.totalKnowledgeReuse}`],
-        ];
-        for (const [label, bare, mcp, d] of scorecard) {
-            console.log(`│ ${label.padEnd(30)} ${String(bare).padStart(6)}        ${String(mcp).padStart(6)}       ${d.padStart(5)}`.padEnd(79) + "│");
-        }
-        console.log("└──────────────────────────────────────────────────────────────────────────────┘");
-        console.log("");
-        // ─── SECTION 3: WHAT THE BARE AGENT MISSED ───
-        console.log("┌──────────────────────────────────────────────────────────────────────────────┐");
-        console.log("│ 3. WHAT THE BARE AGENT MISSED (real blind spots from each scenario)          │");
-        console.log("├──────────────────────────────────────────────────────────────────────────────┤");
-        for (const s of SCENARIOS) {
-            console.log(`│ ${s.domain}: "${s.prompt.slice(0, 55)}..."`.padEnd(79) + "│");
-            for (const blindSpot of s.blindSpots) {
-                console.log(`│   ✗ ${blindSpot.slice(0, 71)}`.padEnd(79) + "│");
-            }
-            console.log("│                                                                              │");
-        }
-        console.log(`│ Total blind spots a bare agent would ship with: ${SCENARIOS.reduce((s, sc) => s + sc.blindSpots.length, 0)}`.padEnd(79) + "│");
-        console.log("└──────────────────────────────────────────────────────────────────────────────┘");
-        console.log("");
-        // ─── SECTION 4: KNOWLEDGE COMPOUNDING ───
-        console.log("┌──────────────────────────────────────────────────────────────────────────────┐");
-        console.log("│ 4. KNOWLEDGE COMPOUNDING — Each fix makes the next one smarter               │");
-        console.log("├──────────────────────────────────────────────────────────────────────────────┤");
-        console.log("│ Bare agents start from zero every time. MCP agents accumulate knowledge.     │");
-        console.log("│                                                                              │");
-        for (const entry of compoundingLog) {
-            const scenario = SCENARIOS[entry.taskIndex];
-            const barWidth = Math.min(entry.priorKnowledgeHits, 30);
-            const bar = "█".repeat(barWidth) + "░".repeat(Math.max(0, 10 - barWidth));
-            const domain = scenario.domain.slice(0, 18).padEnd(18);
-            console.log(`│ ${String(entry.taskIndex + 1).padStart(2)}. ${domain} ${bar} ${String(entry.priorKnowledgeHits).padStart(3)} prior hits`.padEnd(79) + "│");
-        }
-        console.log("│                                                                              │");
-        console.log(`│ Total knowledge reuse events: ${mcpImpact.totalKnowledgeReuse}  (bare agent: 0, always starts fresh)`.padEnd(79) + "│");
-        console.log("└──────────────────────────────────────────────────────────────────────────────┘");
-        console.log("");
-        // ─── SECTION 5: ISSUE SEVERITY BREAKDOWN ───
-        console.log("┌──────────────────────────────────────────────────────────────────────────────┐");
-        console.log("│ 5. ISSUE SEVERITY BREAKDOWN                                                  │");
-        console.log("├──────────────────────────────────────────────────────────────────────────────┤");
-        console.log(`│ HIGH: ${mcpImpact.sevCounts.HIGH}  |  MEDIUM: ${mcpImpact.sevCounts.MEDIUM}  |  LOW: ${mcpImpact.sevCounts.LOW}  |  Total: ${mcpImpact.totalIssues}  |  All resolved: ${mcpImpact.resolvedIssues}/${mcpImpact.totalIssues}`.padEnd(79) + "│");
-        console.log("│                                                                              │");
-        for (const r of mcpResults) {
-            const scenario = SCENARIOS.find((s) => s.id === r.scenarioId);
-            for (const issue of r.impact.issuesDetected) {
-                const tag = issue.severity.padEnd(6);
-                const domain = scenario.domain.slice(0, 14).padEnd(14);
-                console.log(`│ [${tag}] ${domain} ${issue.title.slice(0, 50)}`.padEnd(79) + "│");
-            }
-        }
-        console.log("│                                                                              │");
-        console.log("│ Bare agent: 0 issues detected — ships all blind spots to production          │");
-        console.log("└──────────────────────────────────────────────────────────────────────────────┘");
-        console.log("");
-        // ─── SECTION 6: PER-SCENARIO SUMMARY ───
-        console.log("┌──────────────────────────────────────────────────────────────────────────────┐");
-        console.log("│ 6. PER-SCENARIO SUMMARY                                                      │");
-        console.log("├──────────────────────────────────────────────────────────────────────────────┤");
-        console.log("│ Scenario              Domain              Cplx Issues Evals Gates Calls       │");
-        console.log("│ ───────────────────── ─────────────────── ──── ────── ───── ───── ─────       │");
-        for (let i = 0; i < SCENARIOS.length; i++) {
-            const s = SCENARIOS[i];
-            const m = mcpResults[i];
-            const label = s.id.slice(0, 21).padEnd(21);
-            const domain = s.domain.slice(0, 19).padEnd(19);
-            const cplx = s.complexity.slice(0, 3).toUpperCase().padEnd(4);
-            const issues = String(m.impact.issuesDetected.length).padStart(4);
-            const evals = String(m.impact.evalCases.length).padStart(5);
-            const gates = String(m.impact.gateRulesEnforced.length).padStart(5);
-            const calls = String(m.totalToolCalls).padStart(5);
-            console.log(`│ ${label} ${domain} ${cplx} ${issues} ${evals} ${gates} ${calls}`.padEnd(79) + "│");
-        }
-        console.log("└──────────────────────────────────────────────────────────────────────────────┘");
-        console.log("");
-        // ─── VERDICT ───
-        console.log("╔══════════════════════════════════════════════════════════════════════════════╗");
-        console.log("║  VERDICT                                                                     ║");
-        console.log("╠══════════════════════════════════════════════════════════════════════════════╣");
-        console.log("║                                                                              ║");
-        console.log("║  Across 9 real production scenarios, NodeBench MCP tools:                    ║");
-        console.log("║                                                                              ║");
-        console.log(`║   • Detected ${String(mcpImpact.totalIssues).padStart(2)} issues the bare agent would have shipped to production`.padEnd(79) + "║");
-        console.log(`║     (${mcpImpact.sevCounts.HIGH} HIGH, ${mcpImpact.sevCounts.MEDIUM} MEDIUM, ${mcpImpact.sevCounts.LOW} LOW severity — all resolved before deploy)`.padEnd(79) + "║");
-        console.log(`║   • Surfaced ${String(mcpImpact.totalReconFindings).padStart(2)} findings before writing a single line of code`.padEnd(79) + "║");
-        console.log(`║   • Caught ${mcpImpact.totalTestFailuresCaught} integration failures that unit tests alone wouldn't find`.padEnd(79) + "║");
-        console.log(`║   • Created ${mcpImpact.totalEvalCases} regression cases protecting against future breakage`.padEnd(79) + "║");
-        console.log(`║   • Blocked ${mcpImpact.totalGateViolations} deploy(s) that didn't meet quality gates`.padEnd(79) + "║");
-        console.log(`║   • Built a knowledge base of ${mcpImpact.learningsRecorded} learnings → ${mcpImpact.totalKnowledgeReuse} reuse events`.padEnd(79) + "║");
-        console.log("║                                                                              ║");
-        console.log(`║  Tool calls: ${mcpTotalCalls} MCP vs ${bareTotalCalls} bare`.padEnd(79) + "║");
-        console.log(`║  Blind spots prevented: ${SCENARIOS.reduce((s, sc) => s + sc.blindSpots.length, 0)} (would have shipped to production)`.padEnd(79) + "║");
-        console.log("║                                                                              ║");
-        console.log("║  Every additional tool call produces a concrete artifact — an issue found,    ║");
-        console.log("║  a risk assessed, a regression guarded — that compounds across future tasks.  ║");
-        console.log("║                                                                              ║");
-        console.log("╚══════════════════════════════════════════════════════════════════════════════╝");
-        console.log("");
-        // ─── ASSERTIONS ───
-        // Concrete impact
-        expect(mcpImpact.totalIssues).toBeGreaterThanOrEqual(8);
-        expect(mcpImpact.resolvedIssues).toBe(mcpImpact.totalIssues);
-        expect(mcpImpact.totalReconFindings).toBeGreaterThanOrEqual(12);
-        expect(mcpImpact.risksAssessed).toBe(9);
-        expect(mcpImpact.totalTestFailuresCaught).toBeGreaterThan(0);
-        expect(mcpImpact.totalEvalCases).toBeGreaterThan(bareImpact.totalEvalCases);
-        expect(mcpImpact.totalGateRules).toBeGreaterThanOrEqual(30);
-        expect(mcpImpact.totalGateViolations).toBeGreaterThan(0);
-        expect(mcpImpact.learningsRecorded).toBe(9);
-        expect(mcpImpact.totalKnowledgeReuse).toBeGreaterThan(0);
-        // Bare agent missed everything
-        expect(bareImpact.totalIssues).toBe(0);
-        expect(bareImpact.totalReconFindings).toBe(0);
-        expect(bareImpact.risksAssessed).toBe(0);
-        expect(bareImpact.totalGateRules).toBe(0);
-        expect(bareImpact.totalTestFailuresCaught).toBe(0);
-        expect(bareImpact.learningsRecorded).toBe(0);
-        // MCP uses significantly more tools
-        expect(mcpTotalCalls).toBeGreaterThan(bareTotalCalls * 3);
-    });
-});
-//# sourceMappingURL=comparativeBench.test.js.map