nodebench-mcp 2.28.0 → 2.31.0

package/dist/tools/toolRegistry.js

@@ -675,6 +675,131 @@ const REGISTRY_ENTRIES = [
         },
         phase: "research",
     },
+    // ═══ RESEARCH OPTIMIZER ═══
+    {
+        name: "merge_research_results",
+        category: "research_optimizer",
+        tags: ["merge", "aggregate", "parallel", "sub-agent", "research", "join", "dataset", "coordinator"],
+        quickRef: {
+            nextAction: "Results merged. Use multi_criteria_score to rank options, or compare_options for a side-by-side table.",
+            nextTools: ["multi_criteria_score", "compare_options"],
+            methodology: "agent_contract",
+            tip: "Pass a join_key that exists in all sub-agent records (e.g., 'hotel_name'). Use conflict_resolution to handle overlapping fields.",
+        },
+        phase: "utility",
+    },
+    {
+        name: "multi_criteria_score",
+        category: "research_optimizer",
+        tags: ["score", "optimize", "rank", "criteria", "weight", "MCDM", "decision", "compare", "valuation", "points"],
+        quickRef: {
+            nextAction: "Options scored and ranked. Use compare_options for a formatted report, or run_quality_gate to validate thresholds.",
+            nextTools: ["compare_options", "run_quality_gate", "save_session_note"],
+            methodology: "agent_contract",
+            tip: "Weights must sum to 1.0. Use direction 'minimize' for costs/distances, 'maximize' for value/scores. classify_field adds tier labels (e.g., cpp_value → poor/acceptable/good/excellent).",
+        },
+        phase: "utility",
+    },
+    {
+        name: "compare_options",
+        category: "research_optimizer",
+        tags: ["compare", "table", "report", "side-by-side", "recommendation", "present", "markdown", "format"],
+        quickRef: {
+            nextAction: "Comparison generated. Present to user or save with save_session_note for persistence.",
+            nextTools: ["save_session_note", "send_email", "record_learning"],
+            methodology: "agent_contract",
+            tip: "Pass score_id from multi_criteria_score to auto-load ranked results. Use highlight_fields to control column order.",
+        },
+        phase: "utility",
+    },
+    // ═══ WEB SCRAPING (Scrapling) ═══
+    {
+        name: "scrapling_fetch",
+        category: "web_scraping",
+        tags: ["scrape", "fetch", "stealth", "anti-bot", "cloudflare", "tls", "fingerprint", "crawl", "http"],
+        quickRef: {
+            nextAction: "Page fetched. Use scrapling_extract for structured data, or merge_research_results to combine with other sources.",
+            nextTools: ["scrapling_extract", "extract_structured_data", "merge_research_results"],
+            methodology: "agent_contract",
+            tip: "Use tier 'stealth' for Cloudflare-protected sites, 'dynamic' for JS-rendered pages. Default 'http' works for most public pages.",
+        },
+        phase: "research",
+    },
+    {
+        name: "scrapling_extract",
+        category: "web_scraping",
+        tags: ["extract", "css", "xpath", "selector", "structured", "parse", "scrape", "deterministic"],
+        quickRef: {
+            nextAction: "Data extracted. Use merge_research_results to combine sources, or multi_criteria_score to rank options.",
+            nextTools: ["merge_research_results", "multi_criteria_score", "save_session_note"],
+            methodology: "agent_contract",
+            tip: "Zero LLM tokens — deterministic CSS/XPath extraction. Use '::text' suffix for text content, '::attr(href)' for attributes.",
+        },
+        phase: "research",
+    },
+    {
+        name: "scrapling_batch_fetch",
+        category: "web_scraping",
+        tags: ["batch", "parallel", "multi-url", "concurrent", "bulk", "competitive", "comparison"],
+        quickRef: {
+            nextAction: "Batch complete. Use merge_research_results to join results by key, or scrapling_extract on individual pages.",
+            nextTools: ["merge_research_results", "scrapling_extract", "multi_criteria_score"],
+            methodology: "agent_contract",
+            tip: "Up to 20 URLs with 1-10 concurrency. All URLs share the same tier and extraction config.",
+        },
+        phase: "research",
+        complexity: "medium",
+    },
+    {
+        name: "scrapling_track_element",
+        category: "web_scraping",
+        tags: ["track", "monitor", "element", "change", "adaptive", "price", "watch", "dom"],
+        quickRef: {
+            nextAction: "Element tracked. Compare with previous snapshots or set up monitoring with save_session_note.",
+            nextTools: ["save_session_note", "scrapling_fetch", "multi_criteria_score"],
+            methodology: "agent_contract",
+            tip: "Scrapling's adaptive tracking survives CSS class renames and DOM restructuring. Great for price monitoring.",
+        },
+        phase: "research",
+        complexity: "medium",
+    },
+    {
+        name: "scrapling_crawl",
+        category: "web_scraping",
+        tags: ["crawl", "spider", "multi-page", "sitemap", "deep", "sec", "edgar", "news"],
+        quickRef: {
+            nextAction: "Crawl started. Poll with scrapling_crawl_status to check progress and get items.",
+            nextTools: ["scrapling_crawl_status", "scrapling_crawl_stop"],
+            methodology: "agent_contract",
+            tip: "Returns a session_id. Set domain_whitelist to prevent crawling external sites. Max 500 pages.",
+        },
+        phase: "research",
+        complexity: "high",
+    },
+    {
+        name: "scrapling_crawl_status",
+        category: "web_scraping",
+        tags: ["crawl", "status", "progress", "poll", "items", "results"],
+        quickRef: {
+            nextAction: "Check if crawl is complete. If so, use merge_research_results on the items.",
+            nextTools: ["merge_research_results", "scrapling_crawl_stop", "multi_criteria_score"],
+            methodology: "agent_contract",
+            tip: "Poll periodically until status is 'completed'. Items are available incrementally.",
+        },
+        phase: "research",
+    },
+    {
+        name: "scrapling_crawl_stop",
+        category: "web_scraping",
+        tags: ["crawl", "stop", "abort", "pause", "cancel"],
+        quickRef: {
+            nextAction: "Crawl stopped. Items collected so far are preserved. Process with merge_research_results.",
+            nextTools: ["merge_research_results", "scrapling_crawl_status"],
+            methodology: "agent_contract",
+            tip: "Use when you have enough data or need to abort. Collected items are not lost.",
+        },
+        phase: "research",
+    },
     // ═══ GITHUB ═══
     {
         name: "search_github",
@@ -2583,6 +2708,378 @@ const REGISTRY_ENTRIES = [
         phase: "utility",
         complexity: "low",
     },
+    // ═══════════════════════════════════════════
+    // DESIGN GOVERNANCE — Spec enforcement & compliance
+    // ═══════════════════════════════════════════
+    {
+        name: "get_design_spec",
+        category: "design_governance",
+        tags: ["design", "governance", "spec", "tokens", "colors", "typography", "spacing", "components", "rules", "system"],
+        quickRef: {
+            nextAction: "Review the spec. Use check_design_compliance on specific files, or get_design_violations for a full scan.",
+            nextTools: ["check_design_compliance", "get_design_violations"],
+            methodology: "ai_flywheel",
+            tip: "Returns the machine-readable design governance spec — approved colors, typography classes, component primitives, spacing scale, uppercase policy. Read before making UI changes.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "check_design_compliance",
+        category: "design_governance",
+        tags: ["design", "compliance", "lint", "check", "validate", "file", "violations", "governance", "tokens", "patterns"],
+        quickRef: {
+            nextAction: "Fix the reported violations. Re-run check_design_compliance to verify. Then run get_design_violations for remaining issues.",
+            nextTools: ["get_design_violations", "get_design_spec"],
+            methodology: "ai_flywheel",
+            tip: "Validates a single file against the design governance spec. Returns violations with line numbers, severity, and fix suggestions.",
+        },
+        phase: "verify",
+        complexity: "low",
+    },
+    {
+        name: "get_design_violations",
+        category: "design_governance",
+        tags: ["design", "violations", "scan", "audit", "governance", "bulk", "report", "compliance", "quality", "lint"],
+        quickRef: {
+            nextAction: "Focus on high-severity violations first. Use check_design_compliance on the worst files. Fix and re-scan.",
+            nextTools: ["check_design_compliance", "get_design_spec", "log_gap"],
+            methodology: "ai_flywheel",
+            tip: "Scans entire src/ for design governance violations. Filter by severity or category. Returns top files and fix suggestions.",
+        },
+        phase: "verify",
+        complexity: "medium",
+    },
+    {
+        name: "sync_figma_tokens",
+        category: "design_governance",
+        tags: ["figma", "tokens", "sync", "drift", "design", "variables", "css", "compare", "validation"],
+        quickRef: {
+            nextAction: "Review drift report. Update src/index.css or Figma variables to reconcile mismatches. Run check_design_compliance to verify.",
+            nextTools: ["check_design_compliance", "get_design_spec", "get_design_violations"],
+            methodology: "ai_flywheel",
+            tip: "Compares Figma design token variables against CSS custom properties. Requires FIGMA_ACCESS_TOKEN env var.",
+        },
+        phase: "verify",
+        complexity: "low",
+    },
+    {
+        name: "get_figma_design_context",
+        category: "design_governance",
+        tags: ["figma", "design", "context", "component", "patterns", "typography", "spacing", "tokens", "rules"],
+        quickRef: {
+            nextAction: "Use the returned design context to implement or review the component. Run check_design_compliance after changes.",
+            nextTools: ["check_design_compliance", "get_design_spec", "sync_figma_tokens"],
+            methodology: "ai_flywheel",
+            tip: "Returns design system rules for a specific component (button, card, page-shell, sidebar, empty-state, stat-badge).",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    // AGENT TRAVERSAL — Frontend view navigation for OpenClaw agents
+    // ═══════════════════════════════════════════
+    {
+        name: "list_available_views",
+        category: "agent_traverse",
+        tags: ["views", "manifest", "discover", "navigate", "frontend", "agent", "traversal", "sitemap"],
+        quickRef: {
+            nextAction: "Pick a view from the manifest and navigate to it with navigate_to_view.",
+            nextTools: ["navigate_to_view", "get_view_capabilities"],
+            methodology: "agent_traversal",
+            tip: "Use search parameter to filter by keyword. Returns 27 views with actions, data endpoints, and tags.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "get_view_capabilities",
+        category: "agent_traverse",
+        tags: ["view", "capabilities", "actions", "tools", "endpoints", "agent", "traversal", "inspect"],
+        quickRef: {
+            nextAction: "Now navigate to the view or invoke its per-view tools with invoke_view_tool.",
+            nextTools: ["navigate_to_view", "invoke_view_tool", "query_view_data"],
+            methodology: "agent_traversal",
+            tip: "Returns full view metadata including per-view WebMCP tools. Call before interacting with a view.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "navigate_to_view",
+        category: "agent_traverse",
+        tags: ["navigate", "view", "route", "go", "switch", "frontend", "agent", "session"],
+        quickRef: {
+            nextAction: "You're on the target view. Use invoke_view_tool for actions or query_view_data for reading.",
+            nextTools: ["invoke_view_tool", "query_view_data", "get_view_state"],
+            methodology: "agent_traversal",
+            tip: "Tracks navigation in session history for audit. Returns target view capabilities.",
+        },
+        phase: "implement",
+        complexity: "low",
+    },
+    {
+        name: "invoke_view_tool",
+        category: "agent_traverse",
+        tags: ["invoke", "tool", "view", "action", "interact", "agent", "per-view", "webmcp"],
+        quickRef: {
+            nextAction: "Check results. Navigate to another view or invoke more tools.",
+            nextTools: ["invoke_view_tool", "navigate_to_view", "get_view_state"],
+            methodology: "agent_traversal",
+            tip: "Auto-detects current view from session. Use get_view_capabilities to see available tools first.",
+        },
+        phase: "implement",
+        complexity: "medium",
+    },
+    {
+        name: "query_view_data",
+        category: "agent_traverse",
+        tags: ["query", "data", "endpoint", "read", "fetch", "view", "agent", "api"],
+        quickRef: {
+            nextAction: "Process the data. Navigate to another view or invoke view tools.",
+            nextTools: ["invoke_view_tool", "navigate_to_view", "traverse_feed"],
+            methodology: "agent_traversal",
+            tip: "Use get_view_capabilities to see available data endpoints for a view.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "traverse_feed",
+        category: "agent_traverse",
+        tags: ["feed", "traverse", "hot", "new", "top", "rising", "paginate", "moltbook", "discovery"],
+        quickRef: {
+            nextAction: "Process items. Use cursor for next page, or switch feed type.",
+            nextTools: ["traverse_feed", "navigate_to_view", "invoke_view_tool"],
+            methodology: "agent_traversal",
+            tip: "Supports hot/new/top/rising sort across 6 feed types. Cursor-based pagination.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "get_view_state",
+        category: "agent_traverse",
+        tags: ["state", "session", "history", "audit", "introspect", "agent", "traversal"],
+        quickRef: {
+            nextAction: "Review session state. Continue navigating or end session.",
+            nextTools: ["navigate_to_view", "list_available_views"],
+            methodology: "agent_traversal",
+            tip: "Returns navigation history, interaction log, and session duration for self-awareness.",
+        },
+        phase: "verify",
+        complexity: "low",
+    },
+    {
+        name: "get_traversal_plan",
+        category: "agent_traverse",
+        tags: ["plan", "goal", "multi-view", "journey", "strategy", "agent", "traversal", "optimize"],
+        quickRef: {
+            nextAction: "Follow the plan step by step: navigate_to_view for each step, then invoke_view_tool or query_view_data.",
+            nextTools: ["navigate_to_view", "invoke_view_tool", "query_view_data"],
+            methodology: "agent_traversal",
+            tip: "Describe your goal in natural language. Returns ranked views with suggested actions and tools.",
+        },
+        phase: "research",
+        complexity: "medium",
+    },
+    // ENGINE CONTEXT — Accumulated knowledge and content archive
+    // ═══════════════════════════════════════════
+    {
+        name: "get_engine_context_health",
+        category: "engine_context",
+        tags: ["context", "health", "learnings", "trend", "conformance", "knowledge", "accumulated", "engine"],
+        quickRef: {
+            nextAction: "Review context health. If learnings are low, run more workflows. If trend is regressing, investigate failing steps.",
+            nextTools: ["get_workflow_history", "search_content_archive", "search_all_knowledge"],
+            methodology: "ai_flywheel",
+            tip: "Call at session start to understand how much accumulated knowledge is available.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "get_workflow_history",
+        category: "engine_context",
+        tags: ["workflow", "history", "runs", "scores", "grades", "trend", "conformance", "engine"],
+        quickRef: {
+            nextAction: "Compare scores across runs. If regressing, check failed steps. If improving, document what changed.",
+            nextTools: ["get_engine_context_health", "search_all_knowledge", "record_learning"],
+            methodology: "ai_flywheel",
+            tip: "Track conformance scores over time to detect quality drift.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "archive_content",
+        category: "engine_context",
+        tags: ["archive", "content", "save", "digest", "post", "report", "dedup", "themes"],
+        quickRef: {
+            nextAction: "Content archived. Use search_content_archive before next generation to avoid repetition.",
+            nextTools: ["search_content_archive", "get_engine_context_health"],
+            methodology: "ai_flywheel",
+            tip: "Archive every generated digest/post to prevent theme repetition in future runs.",
+        },
+        phase: "ship",
+        complexity: "low",
+    },
+    {
+        name: "search_content_archive",
+        category: "engine_context",
+        tags: ["search", "content", "archive", "fts5", "themes", "dedup", "topics", "covered"],
+        quickRef: {
+            nextAction: "Review results. Adjust new content to cover gaps, not repeat existing themes.",
+            nextTools: ["archive_content", "get_engine_context_health", "search_all_knowledge"],
+            methodology: "ai_flywheel",
+            tip: "Call before generating content to check what's already been covered.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    // ═══ CONTEXT SANDBOX — Context window protection via FTS5 indexing ═══
+    {
+        name: "sandbox_ingest",
+        category: "context_sandbox",
+        tags: ["sandbox", "ingest", "index", "context", "fts5", "chunk", "store", "compress"],
+        quickRef: {
+            nextAction: "Content indexed. Use sandbox_search to query it without pulling raw data into context.",
+            nextTools: ["sandbox_search", "sandbox_stats"],
+            methodology: "context_management",
+            tip: "Use for large API responses, file contents, or any data you want searchable without flooding context.",
+        },
+        phase: "utility",
+        complexity: "low",
+    },
+    {
+        name: "sandbox_search",
+        category: "context_sandbox",
+        tags: ["sandbox", "search", "bm25", "fts5", "query", "context", "retrieve", "snippet"],
+        quickRef: {
+            nextAction: "Review search results. Follow up with more specific queries or use sandbox_ingest for new content.",
+            nextTools: ["sandbox_ingest", "sandbox_execute", "sandbox_stats"],
+            methodology: "context_management",
+            tip: "Pass multiple queries as an array to batch all questions in one call.",
+        },
+        phase: "utility",
+        complexity: "low",
+    },
+    {
+        name: "sandbox_execute",
+        category: "context_sandbox",
+        tags: ["sandbox", "execute", "shell", "command", "index", "output", "compress", "context"],
+        quickRef: {
+            nextAction: "Output indexed. Use sandbox_search to find specific details. Check exitCode for errors.",
+            nextTools: ["sandbox_search", "sandbox_batch", "sandbox_stats"],
+            methodology: "context_management",
+            tip: "Use instead of raw shell execution for commands producing >20 lines. Pass queries param for immediate search.",
+        },
+        phase: "utility",
+        complexity: "low",
+    },
+    {
+        name: "sandbox_batch",
+        category: "context_sandbox",
+        tags: ["sandbox", "batch", "execute", "search", "multi", "efficient", "context", "compress"],
+        quickRef: {
+            nextAction: "Batch complete. Review search results. Use sandbox_search for follow-up queries.",
+            nextTools: ["sandbox_search", "sandbox_stats"],
+            methodology: "context_management",
+            tip: "One sandbox_batch replaces N sandbox_execute + M sandbox_search calls. Use for research phases.",
+        },
+        phase: "utility",
+        complexity: "medium",
+    },
+    {
+        name: "sandbox_stats",
+        category: "context_sandbox",
+        tags: ["sandbox", "stats", "token", "savings", "context", "metrics", "session", "compression"],
+        quickRef: {
+            nextAction: "Review savings ratio. If low, route more heavy outputs through sandbox_execute or sandbox_ingest.",
+            nextTools: ["sandbox_ingest", "sandbox_execute", "sandbox_batch"],
+            methodology: "context_management",
+        },
+        phase: "meta",
+        complexity: "low",
+    },
+    // ── Thompson Protocol (6 tools) ─────────────────────────────────────────
+    {
+        name: "thompson_write",
+        category: "thompson_protocol",
+        tags: ["content", "writing", "plain-english", "analogy", "jargon", "translation", "accessibility", "thompson", "calculus-made-easy"],
+        quickRef: {
+            nextAction: "Content written. Send sections to thompson_feynman_edit for skeptical beginner review.",
+            nextTools: ["thompson_feynman_edit", "call_llm"],
+            methodology: "thompson_protocol",
+            tip: "Use call_llm with the system_prompt from this tool's output to generate the actual content. The tool provides constraints, the LLM does the creative work.",
+        },
+        phase: "implement",
+        complexity: "high",
+    },
+    {
+        name: "thompson_feynman_edit",
+        category: "thompson_protocol",
+        tags: ["editing", "review", "rejection", "readability", "feynman", "skeptical-beginner", "quality", "rewrite"],
+        quickRef: {
+            nextAction: "Review complete. If REWRITE sections exist, send back to thompson_write. If all PASS, proceed to thompson_visual_map.",
+            nextTools: ["thompson_write", "thompson_visual_map"],
+            methodology: "thompson_protocol",
+            tip: "Max 3 rewrite cycles. After 3 consecutive failures on same criterion, escalate to user.",
+        },
+        phase: "verify",
+        complexity: "medium",
+    },
+    {
+        name: "thompson_visual_map",
+        category: "thompson_protocol",
+        tags: ["visual", "metaphor", "image", "prompt", "analogy", "illustration", "accessibility", "alt-text"],
+        quickRef: {
+            nextAction: "Visual prompts generated. Send content + visuals to thompson_anti_elitism_lint for final scan.",
+            nextTools: ["thompson_anti_elitism_lint"],
+            methodology: "thompson_protocol",
+            tip: "Each visual maps 1:1 with a text analogy. No generic b-roll. Include alt-text for accessibility.",
+        },
+        phase: "implement",
+        complexity: "medium",
+    },
+    {
+        name: "thompson_anti_elitism_lint",
+        category: "thompson_protocol",
+        tags: ["lint", "elitism", "gatekeeping", "banned-phrases", "readability", "inclusivity", "passive-voice", "jargon"],
+        quickRef: {
+            nextAction: "Lint complete. If CLEAN, proceed to thompson_quality_gate. If FLAGGED, fix banned phrases and re-lint.",
+            nextTools: ["thompson_quality_gate", "thompson_write"],
+            methodology: "thompson_protocol",
+            tip: "Fully deterministic — no LLM needed. 22 banned phrase patterns + readability metrics.",
+        },
+        phase: "verify",
+        complexity: "low",
+    },
+    {
+        name: "thompson_quality_gate",
+        category: "thompson_protocol",
+        tags: ["quality", "gate", "checklist", "grade", "content", "verification", "thompson"],
+        quickRef: {
+            nextAction: "Quality gate scored. If passing/exemplary, content is ready for distribution. If needs_work/failing, review failing_checks and restart.",
+            nextTools: ["save_session_note", "record_learning", "send_email"],
+            methodology: "thompson_protocol",
+            tip: "10-point boolean checklist. Grade thresholds: exemplary (9-10), passing (7-8), needs_work (5-6), failing (0-4).",
+        },
+        phase: "verify",
+        complexity: "low",
+    },
+    {
+        name: "thompson_pipeline",
+        category: "thompson_protocol",
+        tags: ["pipeline", "orchestrator", "content", "end-to-end", "thompson", "workflow", "multi-agent"],
+        quickRef: {
+            nextAction: "Pipeline plan generated. Execute steps sequentially: thompson_write → thompson_feynman_edit (loop) → thompson_visual_map → thompson_anti_elitism_lint → thompson_quality_gate.",
+            nextTools: ["thompson_write", "call_llm"],
+            methodology: "thompson_protocol",
+            tip: "This is the orchestrator. Start here for end-to-end content transformation. Each step's output feeds the next.",
+        },
+        phase: "meta",
+        complexity: "low",
+    },
 ];
 // ── Exported lookup structures ───────────────────────────────────────────
 /** Map of tool name → registry entry for O(1) lookup */
@@ -2643,6 +3140,9 @@ const CATEGORY_COMPLEXITY = {
     qa_orchestration: "low",
     visual_qa: "medium",
     local_dashboard: "low",
+    design_governance: "low",
+    agent_traverse: "low",
+    engine_context: "low",
 };
 /** Per-tool complexity overrides (when category default is wrong) */
 const TOOL_COMPLEXITY_OVERRIDES = {
@@ -2689,6 +3189,18 @@ const TOOL_COMPLEXITY_OVERRIDES = {
     solve_storage_upgrade_cost_per_file_from_image: "high",
     // Web
     fetch_url: "low",
+    // Research Optimizer
+    merge_research_results: "low",
+    multi_criteria_score: "low",
+    compare_options: "low",
+    // Web Scraping
+    scrapling_fetch: "low",
+    scrapling_extract: "low",
+    scrapling_batch_fetch: "medium",
+    scrapling_track_element: "medium",
+    scrapling_crawl: "high",
+    scrapling_crawl_status: "low",
+    scrapling_crawl_stop: "low",
     // GitHub
     search_github: "low",
     // Boilerplate
@@ -3851,5 +4363,118 @@ export const WORKFLOW_CHAINS = {
             { tool: "record_learning", action: "Record QA trajectory and Gemini finding patterns for regression tracking" },
         ],
     },
+    content_pipeline: {
+        name: "Daily Content Pipeline",
+        description: "End-to-end content production: gather signals from RSS + web search, build research digest, generate a 3-post thread (Signal/Analysis/Agency) via LLM, quality-gate the output, and publish via email or save for manual posting. Engine-graded for conformance.",
+        steps: [
+            { tool: "fetch_rss_feeds", action: "Pull latest articles from all registered RSS/Atom sources — new items stored in SQLite" },
+            { tool: "web_search", action: "Search for breaking developments in target topics (AI, infrastructure, security) to supplement RSS" },
+            { tool: "build_research_digest", action: "Generate a categorized digest of new articles — groups by topic, highlights key signals" },
+            { tool: "call_llm", action: "Generate Post 1 (The Signal): narrative framing, numbered signals with hard numbers + URLs, competing explanations" },
+            { tool: "call_llm", action: "Generate Post 2 (The Analysis): fact-checks with badges (VERIFIED/PARTIAL/UNVERIFIED), evidence breakdown per explanation" },
+            { tool: "call_llm", action: "Generate Post 3 (The Agency): actionable steps, stress-test each explanation with score badge, engagement hook" },
+            { tool: "run_quality_gate", action: "Quality-gate all 3 posts: check source attribution, evidence scores, character limits, no hallucinated claims" },
+            { tool: "save_session_note", action: "Persist the final 3-post thread and digest to session notes — survives context compaction" },
+            { tool: "record_learning", action: "Record which signals resonated, content patterns, and quality gate pass/fail reasons for future runs" },
+        ],
+    },
+    content_publish: {
+        name: "Content Publish & Distribute",
+        description: "Take a content pipeline output and distribute across channels — email digest to subscribers, format for LinkedIn posting, archive to knowledge base",
+        steps: [
+            { tool: "search_all_knowledge", action: "Load the latest content pipeline output from session notes or knowledge base" },
+            { tool: "call_llm", action: "Format content for target platform (LinkedIn character limits, email HTML, markdown archive)" },
+            { tool: "run_quality_gate", action: "Final quality gate before publish — verify formatting, links, attribution, no sensitive data" },
+            { tool: "send_email", action: "Email the formatted content digest to distribution list" },
+            { tool: "save_session_note", action: "Archive the published content with timestamp and distribution metadata" },
+            { tool: "record_learning", action: "Record distribution outcomes and engagement signals for optimization" },
+        ],
+    },
+    agent_traversal: {
+        name: "Agent Frontend Traversal",
+        description: "Navigate the NodeBench AI frontend as an agent — discover views, interact with per-view tools, traverse content feeds, and plan multi-view journeys",
+        steps: [
+            { tool: "list_available_views", action: "Discover all 27 views with capabilities and available tools" },
+            { tool: "get_traversal_plan", action: "Generate a goal-based traversal plan ranking views by relevance" },
+            { tool: "navigate_to_view", action: "Navigate to the first target view (creates session)" },
+            { tool: "get_view_capabilities", action: "Inspect the view's actions, data endpoints, and per-view tools" },
+            { tool: "invoke_view_tool", action: "Call a per-view tool (e.g., nb_search_research, nb_list_deals)" },
+            { tool: "query_view_data", action: "Query data from view endpoints" },
+            { tool: "traverse_feed", action: "Browse content feeds with hot/new/top/rising sort" },
+            { tool: "get_view_state", action: "Audit session — navigation history, interactions, duration" },
+        ],
+    },
+    research_optimizer: {
+        name: "Research Optimization Pipeline",
+        description: "Single-agent deep web research → structured extraction → multi-criteria scoring → ranked recommendation. For travel booking, vendor selection, investment comparison, or any multi-attribute decision.",
+        steps: [
+            { tool: "web_search", action: "Search for options and pricing across multiple queries (hotels, flights, products)" },
+            { tool: "fetch_url", action: "Fetch detailed pages for top search results — extract pricing, reviews, specs" },
+            { tool: "extract_structured_data", action: "Convert fetched content into structured records with consistent fields" },
+            { tool: "save_session_note", action: "Persist extracted data so it survives context compaction" },
+            { tool: "multi_criteria_score", action: "Score all options against weighted criteria (cost, distance, value, risk)" },
+            { tool: "compare_options", action: "Generate formatted comparison table with rankings and decision explanation" },
+            { tool: "run_quality_gate", action: "Validate recommendation meets minimum thresholds before presenting" },
+        ],
+    },
+    parallel_research: {
+        name: "Parallel Multi-Agent Research",
+        description: "Coordinator spawns specialized sub-agents for parallel research, merges results, scores, and optimizes. For complex decisions requiring multiple information sources gathered simultaneously.",
+        steps: [
+            { tool: "bootstrap_parallel_agents", action: "Scaffold parallel agent infrastructure — define roles for each research domain" },
+            { tool: "claim_task", action: "Each sub-agent claims a research domain (pricing, reviews, logistics, availability)" },
+            { tool: "web_search", action: "Sub-agents search their domain in parallel — each focuses on specific queries" },
+            { tool: "fetch_url", action: "Sub-agents fetch and extract data from their search results" },
+            { tool: "extract_structured_data", action: "Each sub-agent extracts structured records with domain-specific fields" },
+            { tool: "save_session_note", action: "Sub-agents persist findings to shared knowledge base" },
+            { tool: "merge_research_results", action: "Coordinator merges all sub-agent results by join key into unified dataset" },
+            { tool: "multi_criteria_score", action: "Coordinator scores merged options against weighted optimization criteria" },
+            { tool: "compare_options", action: "Generate final ranked comparison with decision explanation" },
+            { tool: "run_quality_gate", action: "Final validation — check data completeness, scoring sanity, recommendation quality" },
+        ],
+    },
+    competitive_intel: {
+        name: "Competitive Intelligence Pipeline",
+        description: "Stealth-fetch competitor pages, extract structured data, merge multi-source results, score and rank. Uses Scrapling for anti-bot bypass and adaptive element tracking.",
+        steps: [
+            { tool: "web_search", action: "Identify competitor URLs and market landscape" },
+            { tool: "scrapling_batch_fetch", action: "Stealth-fetch 5-10 competitor pages in parallel with anti-bot bypass" },
+            { tool: "scrapling_extract", action: "Extract pricing, features, positioning data with CSS/XPath selectors" },
+            { tool: "merge_research_results", action: "Join competitor data by company name into unified comparison dataset" },
+            { tool: "call_llm", action: "Analyze competitive positioning, strengths/weaknesses, market gaps" },
+            { tool: "multi_criteria_score", action: "Score competitors against weighted criteria (price, features, market share)" },
+            { tool: "compare_options", action: "Generate ranked comparison table with strategic recommendations" },
+        ],
+    },
+    price_monitor: {
+        name: "Price Monitoring Pipeline",
+        description: "Crawl product pages, track price elements with adaptive relocation, aggregate data, and alert on changes. Uses Scrapling's element tracking to survive CSS changes.",
+        steps: [
+            { tool: "scrapling_crawl", action: "Start multi-page crawl of product catalog or competitor pricing pages" },
+            { tool: "scrapling_crawl_status", action: "Poll crawl progress and collect extracted items" },
+            { tool: "scrapling_extract", action: "Extract price, availability, and product details with CSS selectors" },
+            { tool: "scrapling_track_element", action: "Set up adaptive element tracking for key price elements" },
+            { tool: "merge_research_results", action: "Merge multi-source pricing data by product identifier" },
+            { tool: "multi_criteria_score", action: "Score products against price/value/availability criteria" },
+            { tool: "save_session_note", action: "Persist price snapshot for historical comparison" },
+            { tool: "send_email", action: "Alert on significant price changes or threshold breaches" },
+        ],
+    },
+    thompson_protocol: {
+        name: "Thompson Protocol Content Pipeline",
+        description: "Transform complex topics into accessible content using the 'Calculus Made Easy' approach — 4-agent pipeline: Thompson Writer (plain English + analogies) → Feynman Editor (skeptical beginner rejection loop, max 3 cycles) → Visual Metaphor Mapper (1:1 analogy→visual prompts) → Anti-Elitism Linter (banned phrase detection + readability scoring) → Quality Gate (10-point checklist).",
+        steps: [
+            { tool: "thompson_pipeline", action: "Initialize the full pipeline — generates execution plan with all agent prompts and handoff points" },
+            { tool: "thompson_write", action: "Transform the complex topic into plain-English sections with jargon translations, analogies, and difficulty acknowledgments" },
+            { tool: "call_llm", action: "Execute the Thompson Writer system prompt against the topic — LLM does the creative writing, tool provides constraints" },
+            { tool: "thompson_feynman_edit", action: "Run Skeptical Beginner review — 8 rejection criteria, deterministic readability checks, max 3 rewrite cycles" },
+            { tool: "thompson_write", action: "(Loop) Rewrite any REWRITE-flagged sections with specific fix instructions from Feynman Editor" },
+            { tool: "thompson_visual_map", action: "Generate visual prompts for each analogy — literal 1:1 mapping, consistent style, accessibility alt-text" },
+            { tool: "thompson_anti_elitism_lint", action: "Scan for banned phrases (22 patterns), passive voice, readability, jargon density — fully deterministic" },
+            { tool: "thompson_quality_gate", action: "10-point boolean checklist → grade (exemplary/passing/needs_work/failing). Gate before distribution." },
+            { tool: "save_session_note", action: "Persist the Thompson-processed content for distribution via content_publish workflow" },
+            { tool: "record_learning", action: "Record which analogies, styles, and audience levels produced the best engagement" },
+        ],
+    },
 };
 //# sourceMappingURL=toolRegistry.js.map