nodebench-mcp 1.0.0

package/dist/tools/metaTools.js

@@ -0,0 +1,837 @@
+/**
+ * Meta tools — tool discovery and methodology guidance.
+ * findTools helps agents discover what's available.
+ * getMethodology teaches agents the development process.
+ */
+const METHODOLOGY_CONTENT = {
+    verification: {
+        title: "6-Phase Iterative Deep-Dive Verification Process",
+        description: "Standard verification workflow for any non-trivial implementation. Run this before declaring any integration, migration, or protocol-level change done.",
+        steps: [
+            {
+                phase: 1,
+                name: "Context Gathering",
+                description: "Launch parallel research into SDK/protocol specs, current codebase patterns, dispatcher/backend audits, and external API status. Use recon tools to structure this research.",
+                tools: [
+                    "search_learnings",
+                    "run_recon",
+                    "check_framework_updates",
+                    "log_recon_finding",
+                ],
+                action: "Start with search_learnings for past issues. Call run_recon to structure your research (include projectContext for holistic view). Use check_framework_updates for known ecosystems. Log findings with log_recon_finding. Then call log_phase_findings with your context notes.",
+            },
+            {
+                phase: 2,
+                name: "Gap Analysis",
+                description: "Compare findings against current implementation. Categorize each gap as CRITICAL/HIGH/MEDIUM/LOW.",
+                tools: ["log_gap"],
+                action: "Record each gap with severity, root cause, and fix strategy. Call log_phase_findings when complete.",
+            },
+            {
+                phase: 3,
+                name: "Implementation",
+                description: "Fix CRITICAL and HIGH gaps first. Each fix is discrete and testable. Follow existing patterns.",
+                tools: ["resolve_gap"],
+                action: "Implement fixes, call resolve_gap for each. Call log_phase_findings when done.",
+            },
+            {
+                phase: 4,
+                name: "Testing & Validation",
+                description: "Run tests at 5 layers: static (tsc), unit, integration, manual, live_e2e. ALL must pass.",
+                tools: ["log_test_result", "run_closed_loop"],
+                action: "Record each test with log_test_result. Use run_closed_loop for compile/lint/test cycle. Call log_phase_findings when all layers pass.",
+            },
+            {
+                phase: 5,
+                name: "Self-Closed-Loop Verification",
+                description: "Parallel checks: spec compliance, functional correctness, argument compatibility. Any FAIL loops back to Phase 3.",
+                tools: ["run_quality_gate"],
+                action: "Run verification checks. If any fail, loop back to Phase 3. Call log_phase_findings with results.",
+            },
+            {
+                phase: 6,
+                name: "Document Learnings",
+                description: "Record edge cases, gotchas, patterns discovered. This prevents future regressions.",
+                tools: ["record_learning"],
+                action: "Call record_learning for each discovery. Call log_phase_findings to complete the cycle.",
+            },
+        ],
+        composesWith: "After completing, use promote_to_eval to feed test cases into the Eval loop.",
+    },
+    eval: {
+        title: "Eval-Driven Development Loop",
+        description: "Continuous improvement cycle. Changes only ship if evals improve — never on gut feel alone. The eval batch is the gatekeeper, not human intuition.",
+        steps: [
+            {
+                step: 1,
+                name: "Run Eval Batch",
+                description: "Define test cases with input (prompt/scenario), intent (ground truth goal), and expected behavior.",
+                tools: ["start_eval_run"],
+                action: "Create an eval run with your test cases.",
+            },
+            {
+                step: 2,
+                name: "Execute & Record",
+                description: "Run each test case. Record actual results, verdict (pass/fail/partial), telemetry, and judge notes.",
+                tools: ["record_eval_result"],
+                action: "For each case: execute it, then record what happened with record_eval_result.",
+            },
+            {
+                step: 3,
+                name: "Aggregate & Analyze",
+                description: "Finalize the run. Compute pass rate, average score, failure patterns, and improvement suggestions.",
+                tools: ["complete_eval_run"],
+                action: "Call complete_eval_run to get aggregate scores.",
+            },
+            {
+                step: 4,
+                name: "Compare & Decide",
+                description: "Compare against baseline. DEPLOY if improved, REVERT if regressed, INVESTIGATE if flat.",
+                tools: ["compare_eval_runs"],
+                action: "Call compare_eval_runs with baseline and candidate run IDs. Follow the recommendation.",
+            },
+            {
+                step: 5,
+                name: "Track Over Time",
+                description: "Monitor eval history for drift. Regressions trigger verification investigations.",
+                tools: ["list_eval_runs", "trigger_investigation"],
+                action: "Use list_eval_runs to spot trends. If regression detected, call trigger_investigation.",
+            },
+        ],
+        composesWith: "Regressions trigger 6-Phase Verification via trigger_investigation.",
+    },
+    flywheel: {
+        title: "The AI Flywheel (Verification × Eval)",
+        description: "The 6-Phase Verification (inner loop) and Eval-Driven Development (outer loop) are not separate processes — they are nested loops that reinforce each other. Every verification produces eval artifacts. Every eval regression triggers verification.",
+        steps: [
+            {
+                name: "Inner → Outer (Verification feeds Evals)",
+                items: [
+                    "Phase 4 test cases become eval batch test cases with known-good expected outputs",
+                    "Phase 5 PASS/FAIL checklists become eval scoring rubrics",
+                    "Phase 6 edge cases become adversarial eval cases targeting discovered failure modes",
+                ],
+                tools: ["promote_to_eval"],
+            },
+            {
+                name: "Outer → Inner (Evals trigger Verification)",
+                items: [
+                    "Tool calling inefficiency → Phase 2 gap analysis on that tool",
+                    "Eval scores regress after deploy → Full Phase 1-6 cycle (treat as production incident)",
+                    "New tool/prompt change suggested → Phase 3 implementation + Phase 4-5 validation",
+                    "Recurring failure pattern → Phase 1 deep dive into root cause",
+                ],
+                tools: ["trigger_investigation"],
+            },
+            {
+                name: "When to use which",
+                items: [
+                    "Building/changing a feature → Run 6-Phase Verification (Is this correct?)",
+                    "Measuring system quality over time → Run Eval loop (Is this better?)",
+                    "Both, always → They compound. Every 6-Phase run produces eval artifacts. Every eval regression triggers 6-Phase.",
+                ],
+                tools: ["get_flywheel_status"],
+            },
+            {
+                name: "Mandatory Minimum Verification",
+                items: [
+                    "Every non-trivial change MUST pass the 6-step mandatory flywheel before being declared done.",
+                    "This is the floor, not the ceiling. The full 6-Phase cycle is the gold standard.",
+                    "Only skip for trivial changes (typos, comments, config) with explicit justification.",
+                    'Call getMethodology("mandatory_flywheel") for the full 6-step checklist and the variety-check dead-code example.',
+                ],
+                tools: ["run_mandatory_flywheel"],
+            },
+        ],
+    },
+    ui_ux_qa: {
+        title: "UI/UX QA Verification (Frontend Changes)",
+        description: "After any implementation that touches frontend UI — new components, layout changes, interaction updates — run this QA process before declaring work done. Uses existing testing infrastructure: Vitest, Playwright, Storybook, Lighthouse.",
+        steps: [
+            {
+                step: 1,
+                name: "Component Verification",
+                description: "Run component tests for changed files. Check for React render errors, missing props, broken imports.",
+                tools: ["run_closed_loop"],
+                action: "Run `npm run test:run` to execute Vitest component tests. Run compile + lint + test closed loop. FAIL if any component test fails.",
+            },
+            {
+                step: 2,
+                name: "Visual & Layout QA",
+                description: "Capture screenshots at 3 breakpoints (375px mobile, 768px tablet, 1280px desktop) using capture_responsive_suite. Verify visual consistency with adjacent components. Run Storybook to check component in isolation.",
+                tools: ["capture_responsive_suite", "capture_ui_screenshot", "get_gate_preset"],
+                action: 'Call capture_responsive_suite(url, label) to screenshot at mobile/tablet/desktop. Visually inspect each capture. Run `npm run storybook` for isolated view. Call get_gate_preset("ui_ux_qa") for the full rule checklist.',
+            },
+            {
+                step: 3,
+                name: "Accessibility Audit",
+                description: "Verify keyboard navigation (Tab order, Enter/Space activation). Check aria-labels on interactive elements. Run Storybook a11y addon panel for automated axe checks. Run Lighthouse accessibility audit.",
+                tools: ["run_quality_gate"],
+                action: "Tab through the changed UI. Check Storybook's Accessibility panel for axe violations. Run `npm run perf:lighthouse` for accessibility score. Record results.",
+            },
+            {
+                step: 4,
+                name: "Interaction & State QA",
+                description: "Test loading states, error states, empty states. Verify form validation and error messages. Check hover/focus/active states on interactive elements.",
+                tools: ["log_test_result"],
+                action: 'Manually test each interaction state. Log results with log_test_result(layer: "manual"). FAIL if any async operation lacks loading/error/empty states.',
+            },
+            {
+                step: 5,
+                name: "E2E Smoke Test",
+                description: "Run relevant Playwright tests. If no existing test covers the change, write one. Capture screenshot for visual reference using capture_ui_screenshot.",
+                tools: ["log_test_result", "capture_ui_screenshot"],
+                action: 'Run `npm run test:e2e` for Playwright tests. Call capture_ui_screenshot for visual reference of the final state. Log results with log_test_result(layer: "live_e2e"). If no test exists, create one in tests/e2e/.',
+            },
+            {
+                step: 6,
+                name: "Record & Gate",
+                description: "Run the ui_ux_qa quality gate with boolean results for all 8 rules. Record learnings for any UI gotchas discovered.",
+                tools: ["run_quality_gate", "record_learning"],
+                action: 'Evaluate all 8 rules from the ui_ux_qa preset. Call run_quality_gate(gateName: "ui_ux_qa", rules: [...]) with your results. Call record_learning for any UI patterns or gotchas discovered.',
+            },
+        ],
+        composesWith: "Use after Phase 3 (Implementation) of a verification cycle when the change involves frontend code. The ui_ux_qa gate result feeds into Phase 5 (Self-Verification).",
+        commands: {
+            component_tests: "npm run test:run",
+            e2e_tests: "npm run test:e2e",
+            storybook: "npm run storybook",
+            lighthouse: "npm run perf:lighthouse",
+            bundle_analysis: "npm run perf:bundle",
+        },
+    },
+    agentic_vision: {
+        title: "Agentic Vision (AI-Powered Visual Verification)",
+        description: "Use AI vision models to analyze UI screenshots programmatically. The Discover-Capture-Analyze-Manipulate-Iterate-Gate loop provides automated visual QA that goes beyond what rule-based checks can catch. Gemini with code execution provides the richest analysis (zoom, crop, compute within the model). Falls back to GPT-4o, Claude, or OpenRouter vision.",
+        steps: [
+            {
+                step: 1,
+                name: "Discover",
+                description: "Check what vision capabilities are available in the current environment. API keys and SDKs determine which providers can be used for visual analysis.",
+                tools: ["discover_vision_env"],
+                action: "Call discover_vision_env to see available providers. If none are available, set an API key (GEMINI_API_KEY recommended for agentic vision with code execution).",
+            },
+            {
+                step: 2,
+                name: "Capture",
+                description: "Take screenshots of the UI at relevant viewports. Use capture_responsive_suite for comprehensive coverage or capture_ui_screenshot for a specific viewport.",
+                tools: ["capture_ui_screenshot", "capture_responsive_suite"],
+                action: "Call capture_responsive_suite(url, label) for 3-breakpoint coverage, or capture_ui_screenshot(url) for a single viewport. Both return base64 images inline + console errors.",
+            },
+            {
+                step: 3,
+                name: "Analyze",
+                description: "Send the captured screenshot to a vision model for AI-powered analysis. The model evaluates layout, spacing, typography, color, accessibility, and component states. Gemini with code execution can zoom into regions, measure distances, and annotate issues autonomously.",
+                tools: ["analyze_screenshot"],
+                action: 'Call analyze_screenshot(imageBase64) with the base64 data from step 2. Optionally provide a custom prompt for focused analysis (e.g., "Check if the navigation menu is accessible on mobile"). Gemini will use code execution to zoom, crop, and compute.',
+            },
+            {
+                step: 4,
+                name: "Manipulate (Optional)",
+                description: "If the analysis identifies specific regions of concern, crop or annotate the screenshot for deeper inspection or documentation. Crop to isolate a component, annotate to mark issues.",
+                tools: ["manipulate_screenshot"],
+                action: "Call manipulate_screenshot with operation='crop' to extract a region, or operation='annotate' to mark issues with bounding boxes and labels. Feed cropped images back to analyze_screenshot for focused analysis.",
+            },
+            {
+                step: 5,
+                name: "Iterate",
+                description: "If issues were found, fix the code, re-capture, and re-analyze. Repeat until the analysis shows no CRITICAL or HIGH issues. This is the closed loop.",
+                tools: ["capture_ui_screenshot", "analyze_screenshot"],
+                action: "Fix identified issues in code. Re-capture the same URL. Re-analyze. Compare before/after. Continue until the vision model reports clean results.",
+            },
+            {
+                step: 6,
+                name: "Gate",
+                description: "Run the ui_ux_qa quality gate using the vision analysis results to inform your boolean evaluation of each gate rule.",
+                tools: ["run_quality_gate", "get_gate_preset", "record_learning"],
+                action: 'Call get_gate_preset("ui_ux_qa") for the 8 rules. Use vision analysis results to evaluate each rule with evidence. Call run_quality_gate with boolean results. Record any visual patterns or gotchas as learnings.',
+            },
+        ],
+        composesWith: "Use after capture_ui_screenshot or capture_responsive_suite to add AI-powered analysis. Combines with ui_ux_qa methodology (getMethodology('ui_ux_qa')) for comprehensive frontend verification.",
+        providerPriority: {
+            gemini: "Best choice. Code execution enables agentic vision — model can zoom, crop, measure, annotate within its reasoning loop. Set GEMINI_API_KEY.",
+            openai: "GPT-4o provides strong vision analysis without code execution. Set OPENAI_API_KEY.",
+            anthropic: "Claude provides detailed text analysis of visual elements. Set ANTHROPIC_API_KEY.",
+            openrouter: "Routes to various vision models via OpenAI-compatible API. Fallback option. Set OPENROUTER_API_KEY.",
+        },
+    },
+    quality_gates: {
+        title: "Quality Gates (Boolean Check Pattern)",
+        description: "Deterministic pre-action validation using boolean checks. Define rules, evaluate each one, aggregate into pass/fail. Built-in presets: engagement (content quality), code_review (implementation quality), deploy_readiness (pre-deploy checklist), ui_ux_qa (frontend UI/UX verification).",
+        steps: [
+            {
+                step: 1,
+                name: "Get Rules",
+                description: "Use a built-in preset or define custom rules. Each rule has a name, description, and evaluation hint.",
+                tools: ["get_gate_preset"],
+                action: 'Call get_gate_preset with "engagement", "code_review", or "deploy_readiness" to get rule definitions.',
+            },
+            {
+                step: 2,
+                name: "Evaluate",
+                description: "Check each rule against your target (content, code, PR). Record boolean pass/fail for each.",
+                tools: [],
+                action: "Evaluate each rule yourself. Note which pass and which fail.",
+            },
+            {
+                step: 3,
+                name: "Record Results",
+                description: "Submit rule results. The tool aggregates score and persists the run.",
+                tools: ["run_quality_gate"],
+                action: "Call run_quality_gate with your boolean results. Review failures.",
+            },
+            {
+                step: 4,
+                name: "Track Trends",
+                description: "Monitor pass/fail trends over time for each gate.",
+                tools: ["get_gate_history"],
+                action: "Call get_gate_history to see if quality is improving.",
+            },
+        ],
+    },
+    closed_loop: {
+        title: "Closed Loop Verification",
+        description: "Local green loop: compile → lint → test → self-debug. Never present changes to anyone without a full green loop. If any step fails: read logs, hypothesize, fix, restart from the failed step.",
+        steps: [
+            {
+                step: 1,
+                name: "Compile",
+                description: "Build clean. No errors.",
+                action: "Run your build command (tsc, go build, cargo build, etc.)",
+            },
+            {
+                step: 2,
+                name: "Lint",
+                description: "Style clean. No warnings.",
+                action: "Run your linter (eslint, golint, clippy, etc.)",
+            },
+            {
+                step: 3,
+                name: "Test",
+                description: "Run automated test suites. All must pass.",
+                action: "Run your test suite (jest, pytest, go test, etc.)",
+            },
+            {
+                step: 4,
+                name: "Self-Debug",
+                description: "If steps 1-3 fail: read logs, hypothesize root cause, fix, restart loop.",
+                action: "Analyze failures, implement fix, go back to step 1. Repeat until green.",
+            },
+        ],
+        composesWith: "Record the loop result with run_closed_loop. Use as part of Phase 4 in a verification cycle.",
+    },
+    learnings: {
+        title: "Learnings (Persistent Knowledge Base)",
+        description: "Store edge cases, gotchas, patterns, and regressions discovered during development. Search before starting new work to avoid repeating mistakes. Always record learnings after completing a verification cycle.",
+        steps: [
+            {
+                step: 1,
+                name: "Search Before You Start",
+                description: "Before implementing anything, search for relevant learnings from past work. Use search_all_knowledge for a unified view across learnings, recon findings, and resolved gaps.",
+                tools: ["search_learnings", "search_all_knowledge"],
+                action: 'Call search_all_knowledge with what you\'re about to work on (e.g. "convex http routing"). This searches learnings, recon findings, AND resolved gaps in one call.',
+            },
+            {
+                step: 2,
+                name: "Record As You Go",
+                description: "When you discover an edge case, gotcha, or pattern, record it immediately.",
+                tools: ["record_learning"],
+                action: "Call record_learning with key, content, category, and tags.",
+            },
+            {
+                step: 3,
+                name: "Browse & Review",
+                description: "Periodically review the knowledge base to refresh your understanding.",
+                tools: ["list_learnings"],
+                action: "Call list_learnings with a category filter to browse specific types of learnings.",
+            },
+        ],
+        composesWith: "Learnings are recorded in Phase 6 of verification cycles. They feed into future Phase 1 context gathering.",
+    },
+    mandatory_flywheel: {
+        title: "Mandatory AI Flywheel Testing (Minimum 6 Steps)",
+        description: "After any non-trivial code change, feature addition, or bug fix, this verification process MUST be run before declaring work done. This is not optional. It catches production bugs that smoke tests miss.",
+        steps: [
+            {
+                step: 1,
+                name: "Static Analysis",
+                description: "Type checking must pass with zero errors. tsc --noEmit, convex dev --once --typecheck=enable, or your stack's equivalent.",
+                action: "Run all static analysis tools. Must be completely green.",
+            },
+            {
+                step: 2,
+                name: "Happy-Path Test",
+                description: "Run the changed functionality with valid inputs and confirm expected output.",
+                action: "Execute the main use case with known-good inputs. Verify output matches expectations exactly.",
+            },
+            {
+                step: 3,
+                name: "Failure-Path Test",
+                description: "Test each failure mode the code is supposed to handle: invalid inputs, edge cases, error states.",
+                action: "Send bad inputs, trigger error paths, test boundary conditions. Ensure errors are handled, not swallowed silently.",
+            },
+            {
+                step: 4,
+                name: "Gap Analysis",
+                description: "Review code for dead code, unused variables, missing integrations, or logic that doesn't match stated intent.",
+                action: "Read the implementation line-by-line. Look for: data fetched but never used, conditionals always true/false, missing error handling, incomplete features.",
+            },
+            {
+                step: 5,
+                name: "Fix and Re-Verify",
+                description: "If any gap is found, fix it and re-run steps 1-3 FROM SCRATCH. Don't just re-run the failed step.",
+                action: "Fix the gap, then restart from step 1. The full re-run catches cascading issues the fix might introduce.",
+            },
+            {
+                step: 6,
+                name: "Deploy and Document",
+                description: "Deploy the verified fix. Document any gaps found and how they were resolved.",
+                tools: ["record_learning"],
+                action: "Deploy to production. Call record_learning for each gap discovered during this process.",
+            },
+        ],
+        whenToSkip: "Only skip for trivial changes where blast radius is near zero: typo fixes, comment updates, config tweaks with no code execution impact. All other changes require all 6 steps.",
+        realWorldExample: {
+            title: "The Variety Check Dead-Code Bug",
+            description: "The first deployment of the pre-post verification pipeline had a bug where the variety check fetched scheduled queue items but never actually compared entities against them (dead code). This was only caught because the flywheel process was run after the initial 'it works' smoke tests. Without it, the bug would have gone to production silently.",
+            lesson: "Smoke tests show 'it runs' but not 'it works correctly'. Step 4 (Gap Analysis) catches logic bugs that type systems and basic tests miss. Step 5 (Fix and Re-Verify from scratch) catches cascading issues.",
+        },
+        tools: ["run_mandatory_flywheel"],
+    },
+    reconnaissance: {
+        title: "Reconnaissance & Research (Structured Phase 1 Context Gathering)",
+        description: "Before implementing or fixing anything, gather comprehensive context about BOTH external sources (latest SDK versions, API changes, known issues) AND internal context (existing codebase patterns, project architecture, team conventions). Structure this research as a trackable recon session.",
+        steps: [
+            {
+                step: 1,
+                name: "Start Recon Session",
+                description: "Define what you're researching and why. Provide project context (tech stack, versions, architecture) for holistic analysis.",
+                tools: ["run_recon"],
+                action: "Call run_recon with target, description, and projectContext. If project context is unknown, the tool will suggest questions to ask.",
+            },
+            {
+                step: 2,
+                name: "Check Framework Sources",
+                description: "Use pre-built source checklists for known ecosystems: anthropic, langchain, openai, google, mcp.",
+                tools: ["check_framework_updates"],
+                action: "Call check_framework_updates for each relevant ecosystem. Visit each source URL systematically.",
+            },
+            {
+                step: 3,
+                name: "Visit Sources & Record Findings",
+                description: "Check each source systematically. Record EVERY relevant finding — both from external sources and from the existing codebase.",
+                tools: ["log_recon_finding"],
+                action: "For each discovery: call log_recon_finding. Categories: breaking_change, new_feature, deprecation, best_practice, dataset, benchmark, codebase_pattern, existing_implementation.",
+            },
+            {
+                step: 4,
+                name: "Aggregate & Prioritize",
+                description: "Review all findings grouped by category. Prioritize: breaking changes > deprecations > existing implementations > new features.",
+                tools: ["get_recon_summary", "search_all_knowledge"],
+                action: "Call get_recon_summary with completeSession=true. Use search_all_knowledge to cross-reference with past learnings and resolved gaps. Use prioritized action items to inform gap analysis.",
+            },
+        ],
+        composesWith: "Use at the start of Phase 1 (Context Gathering) in a verification cycle. Findings inform Phase 2 (Gap Analysis). Also call search_learnings to check past findings.",
+        categories: {
+            breaking_change: "Requires immediate action before deploying",
+            deprecation: "Plan migration path, may break in future",
+            new_feature: "Potential improvements or capabilities to leverage",
+            best_practice: "Recommended patterns or approaches",
+            dataset: "Useful datasets or benchmarks for evaluation",
+            benchmark: "Performance or quality baselines to evaluate against",
+            codebase_pattern: "Existing patterns in the project codebase",
+            existing_implementation: "Code that already handles part of what you're building",
+        },
+    },
+    project_ideation: {
+        title: "Project Ideation & Validation Process",
+        description: "Structured approach for validating project concepts before development. Captures requirements, constraints, success metrics, and competitive analysis. Use this before starting any new project or major feature.",
+        steps: [
+            {
+                phase: 1,
+                name: "Define Concept",
+                description: "Define the problem, target users, and core value proposition. Search existing knowledge for similar past projects.",
+                tools: ["record_learning", "search_all_knowledge"],
+                action: "Document the problem statement and why it matters. Call search_all_knowledge to check for similar past projects or relevant learnings.",
+            },
+            {
+                phase: 2,
+                name: "Research Market",
+                description: "Validate demand, find prior art, and understand the competitive landscape.",
+                tools: ["web_search", "search_github", "research_job_market"],
+                action: "Use web_search for market research. Call search_github to find similar projects. Use research_job_market to understand skill demand.",
+            },
+            {
+                phase: 3,
+                name: "Analyze Competition",
+                description: "Study competitor implementations, understand patterns, and identify differentiation opportunities.",
+                tools: ["fetch_url", "analyze_repo"],
+                action: "Use fetch_url to read competitor docs. Call analyze_repo to understand their tech stack and patterns. Note what to adopt vs. differentiate.",
+            },
+            {
+                phase: 4,
+                name: "Define Requirements",
+                description: "List functional and non-functional requirements with priority and rationale.",
+                tools: ["log_recon_finding", "update_agents_md"],
+                action: "Record each requirement with log_recon_finding. Update AGENTS.md with project requirements using update_agents_md.",
+            },
+            {
+                phase: 5,
+                name: "Plan Metrics",
+                description: "Define measurable success criteria and create baseline eval test cases.",
+                tools: ["start_eval_run"],
+                action: "Create eval test cases that represent success. Call start_eval_run with initial baseline cases.",
+            },
+            {
+                phase: 6,
+                name: "Gate Approval",
+                description: "Document findings, run quality gate, and mark project as ready or needs rework.",
+                tools: ["run_quality_gate", "record_learning"],
+                action: "Call run_quality_gate with ideation rules. Record key decisions with record_learning. Mark project as approved or needs iteration.",
+            },
+        ],
+        composesWith: "Phase 1 (Concept) informs verification cycle planning. Success metrics feed directly into eval batches. Requirements inform AGENTS.md documentation.",
+    },
+    tech_stack_2026: {
+        title: "Tech Stack & Dependency Management (2026)",
+        description: "Systematic approach to evaluating, documenting, and maintaining technology choices. Ensures alignment with project goals and minimizes tech debt. Run periodically or when considering new dependencies.",
+        steps: [
+            {
+                step: 1,
+                name: "Inventory Current Stack",
+                description: "Document all frameworks, libraries, and tools in use with versions and purposes.",
+                tools: ["record_learning", "search_all_knowledge", "setup_local_env"],
+                action: "Call setup_local_env to detect current environment. List every dependency with version, purpose, and maintenance status. Use search_all_knowledge to find past tech decisions.",
+            },
+            {
+                step: 2,
+                name: "Evaluate Against Goals",
+                description: "Compare each component against current project requirements. Check for updates and breaking changes.",
+                tools: ["check_framework_updates", "web_search"],
+                action: "For each major dependency, call check_framework_updates for known ecosystems. Use web_search for latest release notes and migration guides.",
+            },
+            {
+                step: 3,
+                name: "Research Alternatives",
+                description: "Research newer or better-suited alternatives. Compare features, community, performance.",
+                tools: ["search_github", "analyze_repo", "fetch_url"],
+                action: "Use search_github to find promising alternatives. Call analyze_repo to understand their architecture. Use fetch_url to read their documentation.",
+            },
+            {
+                step: 4,
+                name: "Plan Migrations",
+                description: "For each desired change, outline migration steps and risk assessment.",
+                tools: ["log_gap"],
+                action: "Log each migration as a gap with complexity and risk level. Prioritize: breaking changes > critical perf gains > nice-to-haves.",
+            },
+            {
+                step: 5,
+                name: "Document Rationale",
+                description: "Record why each tech choice was made and when to reconsider.",
+                tools: ["record_learning", "update_agents_md"],
+                action: "Call record_learning with decision rationale, trade-offs, and review frequency. Update AGENTS.md Tech Stack section with update_agents_md.",
+            },
+        ],
+        composesWith: "Migrations discovered become verification cycles. Findings inform agentic vision setup (provider choices). Updates feed into AGENTS.md maintenance.",
+    },
+    telemetry_setup: {
+        title: "Telemetry & Instrumentation Setup",
+        description: "Establish observability for system behavior, performance, and quality metrics. Build dashboards and alerting for early problem detection.",
+        steps: [
+            {
+                step: 1,
+                name: "Define Metrics & Signals",
+                description: "Identify what to measure: latency, errors, quality scores, user actions.",
+                tools: ["record_learning"],
+                action: "Document each metric's purpose, collection method, and alerting thresholds. Call record_learning to persist the instrumentation plan.",
+            },
+            {
+                step: 2,
+                name: "Instrument Code",
+                description: "Add logging, tracing, and metric collection to key functions.",
+                tools: ["log_test_result"],
+                action: "Add telemetry calls at phase boundaries. Use log_test_result to capture execution metrics during development.",
+            },
+            {
+                step: 3,
+                name: "Aggregate & Visualize",
+                description: "Set up dashboards and queries to view metric trends.",
+                action: "Build dashboards in your observability tool (DataDog, Prometheus, CloudWatch). Include: pass rates, cycle times, tool latencies.",
+            },
+            {
+                step: 4,
+                name: "Define Alerts & SLOs",
+                description: "Create alert rules and service-level objectives.",
+                action: "Set alert thresholds for critical metrics. Define SLOs: eval pass rate >95%, verification cycle time <4 hours.",
+            },
+            {
+                step: 5,
+                name: "Review & Adjust",
+                description: "Periodically review telemetry to catch patterns and adjust thresholds.",
+                tools: ["search_learnings", "get_gate_history", "list_eval_runs"],
+                action: "Weekly review of metric trends. Use get_gate_history and list_eval_runs as data sources. Adjust thresholds as system matures.",
+            },
+        ],
+        composesWith: "Telemetry data enriches verification and eval outputs. Use get_gate_history and list_eval_runs as dashboard data sources.",
+    },
+    agents_md_maintenance: {
+        title: "AGENTS.md Documentation Maintenance",
+        description: "Keep AGENTS.md synchronized with actual agent implementations, tool updates, and deployment procedures. Single source of truth for agent setup and troubleshooting.",
+        steps: [
+            {
+                step: 1,
+                name: "Audit Current Documentation",
+                description: "Review AGENTS.md against actual implementations. Flag mismatches.",
+                tools: ["update_agents_md", "search_all_knowledge"],
+                action: 'Call update_agents_md({ operation: "read" }) to see current sections. Compare against actual code. Use search_all_knowledge to find recent learnings.',
+            },
+            {
+                step: 2,
+                name: "Identify Changes",
+                description: "List all recent code changes that impact agent setup or deployment.",
+                tools: ["search_github", "setup_local_env"],
+                action: "Call setup_local_env to check current environment. Use search_github to find recent changes in relevant repos. Note new tools, changed schemas, breaking changes.",
+            },
+            {
+                step: 3,
+                name: "Update Sections",
+                description: "Sync AGENTS.md sections: tool catalog, setup steps, environment variables.",
+                tools: ["update_agents_md", "record_learning"],
+                action: 'Call update_agents_md({ operation: "update_section", section: "...", content: "..." }) for each outdated section. Record gotchas with record_learning.',
+            },
+            {
+                step: 4,
+                name: "Verify with Real Setup",
+                description: "Test setup steps on a clean machine or CI environment.",
+                tools: ["run_closed_loop"],
+                action: "Follow AGENTS.md steps exactly. Run run_closed_loop to verify build/test pass. If failures, update docs or fix the process.",
+            },
+            {
+                step: 5,
+                name: "Version & Schedule",
+                description: "Document when AGENTS.md was last updated. Schedule periodic reviews.",
+                tools: ["record_learning"],
+                action: 'Add timestamp header to AGENTS.md. Call record_learning with category "documentation" to schedule monthly review.',
+            },
+        ],
+        composesWith: "AGENTS.md is the source of truth for Phase 1 context gathering. Keep in sync with actual implementations and tool changes.",
+    },
+    overview: {
+        title: "NodeBench Development Methodology — Overview",
+        description: "A dual-loop system for rigorous development. The inner loop (6-Phase Verification) ensures correctness. The outer loop (Eval-Driven Development) ensures improvement. Together they form the AI Flywheel.",
+        steps: [
+            {
+                name: "Start here",
+                description: "Call getMethodology with a specific topic to get detailed guidance.",
+                topics: {
+                    verification: "6-Phase Verification — systematic correctness checking",
+                    eval: "Eval-Driven Development — measure improvement objectively",
+                    flywheel: "AI Flywheel — how the two loops compose and reinforce each other",
+                    mandatory_flywheel: "Mandatory Flywheel — 6-step minimum verification before declaring work done",
+                    reconnaissance: "Reconnaissance — structured research and context gathering for Phase 1",
+                    quality_gates: "Quality Gates — boolean check validation pattern",
+                    ui_ux_qa: "UI/UX QA — frontend verification after UI implementations",
+                    agentic_vision: "Agentic Vision — AI-powered visual verification using vision models (Gemini code execution, GPT-4o, Claude)",
+                    closed_loop: "Closed Loop — compile/lint/test/debug before presenting work",
+                    learnings: "Learnings — persistent knowledge base to prevent repeating mistakes",
+                    project_ideation: "Project Ideation — validate concepts before development with market research and competitive analysis",
+                    tech_stack_2026: "Tech Stack Management — evaluate and maintain technology choices for 2026",
+                    telemetry_setup: "Telemetry Setup — observability, instrumentation, and early problem detection",
+                    agents_md_maintenance: "AGENTS.md Maintenance — keep documentation synchronized with implementations",
+                },
+            },
+            {
+                name: "Quick start for first-time setup",
+                sequence: [
+                    "1. bootstrap_project — Register your project (tech stack, architecture, conventions)",
+                    '2. getMethodology("overview") — See all available methodologies',
+                    "3. search_all_knowledge — Check if the knowledge base has relevant past findings",
+                ],
+            },
+            {
+                name: "Quick start for a new feature",
+                sequence: [
+                    "1. search_all_knowledge — Check learnings, recon findings, and resolved gaps",
+                    "2. start_verification_cycle — Begin 6-phase process",
+                    "3. Follow phases 1-6 (guided by tool responses)",
+                    "4. record_learning — Capture what you discovered",
+                    "5. promote_to_eval — Turn findings into eval cases",
+                    "6. start_eval_run + compare_eval_runs — Verify improvement",
+                ],
+            },
+            {
+                name: "Quick start for checking quality",
+                sequence: [
+                    "1. get_gate_preset — Get rules for your context",
+                    "2. Evaluate each rule",
+                    "3. run_quality_gate — Record results",
+                    "4. run_closed_loop — Ensure compile/lint/test pass",
+                ],
+            },
+        ],
+    },
+};
+export function createMetaTools(allTools) {
+    return [
+        {
+            name: "findTools",
+            description: "Search available methodology tools by keyword or capability description. Returns matching tool names and descriptions. Use this to discover which tools are available for a task.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: 'What you want to do (e.g. "verify implementation", "track quality", "record edge case")',
+                    },
+                    category: {
+                        type: "string",
+                        enum: [
+                            "verification",
+                            "eval",
+                            "quality_gate",
+                            "learning",
+                            "flywheel",
+                            "reconnaissance",
+                            "ui_capture",
+                            "vision",
+                            "web",
+                            "github",
+                            "documentation",
+                            "meta",
+                        ],
+                        description: "Filter by tool category (optional)",
+                    },
+                },
+                required: ["query"],
+            },
+            handler: async (args) => {
+                const query = (args.query ?? "").toLowerCase();
+                const category = args.category;
+                // Category mapping
+                const categoryMap = {
+                    verification: [
+                        "start_verification_cycle",
+                        "log_phase_findings",
+                        "log_gap",
+                        "resolve_gap",
+                        "log_test_result",
+                        "get_verification_status",
+                        "list_verification_cycles",
+                    ],
+                    eval: [
+                        "start_eval_run",
+                        "record_eval_result",
+                        "complete_eval_run",
+                        "compare_eval_runs",
+                        "list_eval_runs",
+                    ],
+                    quality_gate: [
+                        "run_quality_gate",
+                        "get_gate_preset",
+                        "get_gate_history",
+                        "run_closed_loop",
+                    ],
+                    learning: [
+                        "record_learning",
+                        "search_learnings",
+                        "list_learnings",
+                        "delete_learning",
+                    ],
+                    flywheel: [
+                        "get_flywheel_status",
+                        "promote_to_eval",
+                        "trigger_investigation",
+                        "run_mandatory_flywheel",
+                    ],
+                    reconnaissance: [
+                        "run_recon",
+                        "log_recon_finding",
+                        "get_recon_summary",
+                        "check_framework_updates",
+                        "search_all_knowledge",
+                        "bootstrap_project",
+                        "get_project_context",
+                    ],
+                    ui_capture: [
+                        "capture_ui_screenshot",
+                        "capture_responsive_suite",
+                    ],
+                    vision: [
+                        "discover_vision_env",
+                        "analyze_screenshot",
+                        "manipulate_screenshot",
+                    ],
+                    web: [
+                        "web_search",
+                        "fetch_url",
+                    ],
+                    github: [
+                        "search_github",
+                        "analyze_repo",
+                    ],
+                    documentation: [
+                        "update_agents_md",
+                        "research_job_market",
+                        "setup_local_env",
+                    ],
+                    meta: ["findTools", "getMethodology"],
+                };
+                let candidates = allTools;
+                if (category && categoryMap[category]) {
+                    const names = new Set(categoryMap[category]);
+                    candidates = allTools.filter((t) => names.has(t.name));
+                }
+                const matches = candidates.filter((t) => {
+                    const text = `${t.name} ${t.description}`.toLowerCase();
+                    return query.split(/\s+/).some((word) => text.includes(word));
+                });
+                return {
+                    query,
+                    count: matches.length,
+                    tools: matches.map((t) => ({
+                        name: t.name,
+                        description: t.description,
+                    })),
+                };
+            },
+        },
+        {
+            name: "getMethodology",
+            description: 'Get step-by-step guidance for a development methodology. Topics: verification, eval, flywheel, mandatory_flywheel, reconnaissance, quality_gates, ui_ux_qa, agentic_vision, closed_loop, learnings, project_ideation, tech_stack_2026, telemetry_setup, agents_md_maintenance, overview. Call with topic "overview" to see all available methodologies.',
+            inputSchema: {
+                type: "object",
+                properties: {
+                    topic: {
+                        type: "string",
+                        enum: [
+                            "verification",
+                            "eval",
+                            "flywheel",
+                            "mandatory_flywheel",
+                            "reconnaissance",
+                            "quality_gates",
+                            "ui_ux_qa",
+                            "agentic_vision",
+                            "closed_loop",
+                            "learnings",
+                            "project_ideation",
+                            "tech_stack_2026",
+                            "telemetry_setup",
+                            "agents_md_maintenance",
+                            "overview",
+                        ],
+                        description: "Which methodology to explain",
+                    },
+                },
+                required: ["topic"],
+            },
+            handler: async (args) => {
+                const content = METHODOLOGY_CONTENT[args.topic];
+                if (!content)
+                    throw new Error(`Unknown topic: ${args.topic}. Available: ${Object.keys(METHODOLOGY_CONTENT).join(", ")}`);
+                return content;
+            },
+        },
+    ];
+}
+//# sourceMappingURL=metaTools.js.map