nodebench-mcp 2.14.2 → 2.17.0

package/dist/tools/toolRegistry.js

@@ -9,6 +9,7 @@
  * 2. Append quickRefs to every tool response (so agents always know what to do next)
  * 3. Build tool chains (recommended sequences for common workflows)
  */
+import { isEmbeddingReady, embeddingSearch } from "./embeddingProvider.js";
 // ── Registry: every tool mapped with metadata ────────────────────────────
 const REGISTRY_ENTRIES = [
     // ═══ VERIFICATION ═══
@@ -1494,6 +1495,17 @@ const REGISTRY_ENTRIES = [
         },
         phase: "meta",
     },
+    {
+        name: "check_mcp_setup",
+        category: "meta",
+        tags: ["setup", "wizard", "diagnostic", "config", "env", "api-key", "onboarding", "health-check", "status", "readiness"],
+        quickRef: {
+            nextAction: "Review the readiness report. Configure missing domains by following setupInstructions. Re-run to verify.",
+            nextTools: ["check_email_setup", "discover_tools", "getMethodology"],
+            tip: "Run this FIRST when starting with NodeBench MCP. Checks all env vars, API keys, npm packages, and servers across every domain.",
+        },
+        phase: "meta",
+    },
     // ── Image solver tools (GAIA media lane) ──────────────────────────────
     {
         name: "solve_red_green_deviation_average_from_image",
@@ -1824,6 +1836,154 @@ const REGISTRY_ENTRIES = [
         },
         phase: "research",
     },
+    // ═══ CRITTER (pre-action intentionality check) ═══
+    {
+        name: "critter_check",
+        category: "critter",
+        tags: ["intentionality", "why", "who", "purpose", "audience", "reflection", "scope", "pre-action", "metacognition"],
+        quickRef: {
+            nextAction: "Answered critter check. If verdict is 'proceed', continue with your task. If 'reconsider', sharpen answers and re-run.",
+            nextTools: ["save_session_note", "start_verification_cycle", "run_recon"],
+            methodology: "agent_contract",
+            tip: "Call at the start of any non-trivial task. Prevents scope creep and aimless exploration.",
+        },
+        phase: "research",
+    },
+    // ═══ EMAIL (SMTP send, IMAP read, draft replies) ═══
+    {
+        name: "send_email",
+        category: "email",
+        tags: ["email", "smtp", "send", "gmail", "notification", "alert", "digest", "report"],
+        quickRef: {
+            nextAction: "Email sent. Log the action with save_session_note and continue with your workflow.",
+            nextTools: ["save_session_note", "record_learning", "build_research_digest"],
+            methodology: "agent_contract",
+            tip: "Requires EMAIL_USER and EMAIL_PASS env vars. For Gmail, use an App Password. Supports html parameter for rich emails.",
+        },
+        phase: "implement",
+    },
+    {
+        name: "read_emails",
+        category: "email",
+        tags: ["email", "imap", "read", "inbox", "gmail", "fetch", "messages", "unread"],
+        quickRef: {
+            nextAction: "Emails retrieved. Review subjects/content, then draft_email_reply for actionable items or save_session_note to persist context.",
+            nextTools: ["draft_email_reply", "save_session_note", "extract_structured_data"],
+            methodology: "agent_contract",
+            tip: "Requires EMAIL_USER and EMAIL_PASS env vars. Use folder param for specific mailboxes (INBOX default). Limit controls count.",
+        },
+        phase: "research",
+    },
+    {
+        name: "draft_email_reply",
+        category: "email",
+        tags: ["email", "reply", "draft", "compose", "response", "assistant"],
+        quickRef: {
+            nextAction: "Draft generated. Review the draft, then send_email to deliver or edit and re-draft.",
+            nextTools: ["send_email", "save_session_note"],
+            methodology: "agent_contract",
+            tip: "Generates a professional reply draft from original email context. Always review before sending.",
+        },
+        phase: "implement",
+    },
+    // ═══ RSS (subscribe, fetch, digest feeds) ═══
+    {
+        name: "add_rss_source",
+        category: "rss",
+        tags: ["rss", "atom", "feed", "subscribe", "source", "monitor", "research", "news"],
+        quickRef: {
+            nextAction: "RSS source registered. Call fetch_rss_feeds to pull articles, then build_research_digest for a summary.",
+            nextTools: ["fetch_rss_feeds", "build_research_digest", "save_session_note"],
+            methodology: "research_digest",
+            tip: "Validates the feed URL on add. Use category param to group sources for filtered digests.",
+        },
+        phase: "research",
+    },
+    {
+        name: "fetch_rss_feeds",
+        category: "rss",
+        tags: ["rss", "atom", "feed", "fetch", "articles", "news", "update", "pull"],
+        quickRef: {
+            nextAction: "Feeds fetched. New articles stored in SQLite. Call build_research_digest to generate a summary of new items.",
+            nextTools: ["build_research_digest", "save_session_note", "record_learning"],
+            methodology: "research_digest",
+            tip: "Deduplicates automatically — same article won't be stored twice. Fetches all registered sources if no URLs specified.",
+        },
+        phase: "research",
+    },
+    {
+        name: "build_research_digest",
+        category: "rss",
+        tags: ["rss", "digest", "summary", "research", "newsletter", "report", "markdown", "html"],
+        quickRef: {
+            nextAction: "Digest generated. Use send_email with html format to distribute, or save_session_note to persist the digest.",
+            nextTools: ["send_email", "save_session_note", "record_learning"],
+            methodology: "research_digest",
+            tip: "Marks articles as seen after digest — next call only shows truly new content. Use format='html' for email-ready output.",
+        },
+        phase: "implement",
+    },
+    // ═══ SETUP WIZARDS ═══
+    {
+        name: "check_email_setup",
+        category: "email",
+        tags: ["email", "setup", "wizard", "diagnostic", "config", "smtp", "imap", "onboarding", "gmail", "outlook"],
+        quickRef: {
+            nextAction: "Setup check complete. If ready, try send_email or read_emails. If not, follow the setup instructions.",
+            nextTools: ["send_email", "read_emails", "get_workflow_chain"],
+            methodology: "agent_contract",
+            tip: "Run this FIRST before using any email tools. Tests SMTP/IMAP connections and generates MCP config snippets.",
+        },
+        phase: "research",
+    },
+    {
+        name: "scaffold_research_pipeline",
+        category: "rss",
+        tags: ["rss", "scaffold", "pipeline", "project", "cron", "automation", "digest", "email", "standalone", "setup", "wizard"],
+        quickRef: {
+            nextAction: "Pipeline scaffolded. Save the generated files, configure .env, add feeds, and run.",
+            nextTools: ["save_session_note", "check_email_setup"],
+            methodology: "research_digest",
+            tip: "Generates a ZERO-dependency standalone Node.js project. Copy files, add feeds, run. No nodebench-mcp needed at runtime.",
+        },
+        phase: "implement",
+    },
+    // ═══════════════════════════════════════════
+    // ARCHITECT — Structural code analysis
+    // ═══════════════════════════════════════════
+    {
+        name: "scan_capabilities",
+        category: "architect",
+        tags: ["structural-analysis", "capability-scan", "code-patterns", "regex-scan", "react", "backend", "state-management", "layout", "interaction", "rendering"],
+        quickRef: {
+            nextAction: "Review the capability report. Use verify_concept_support to check if a specific concept is implemented.",
+            nextTools: ["verify_concept_support", "generate_implementation_plan", "save_session_note"],
+            tip: "Pure regex analysis — no LLM needed, instant results. Scans React hooks, layout patterns, interaction handlers, rendering, and backend patterns.",
+        },
+        phase: "research",
+    },
+    {
+        name: "verify_concept_support",
+        category: "architect",
+        tags: ["concept-verification", "gap-analysis", "structural-analysis", "regex-scan", "implementation-check", "progress-tracking"],
+        quickRef: {
+            nextAction: "If gaps found, use generate_implementation_plan to build a plan. If fully implemented, move on.",
+            nextTools: ["generate_implementation_plan", "scan_capabilities", "record_learning"],
+            tip: "Define required signatures from web research, then verify against code. Results persisted to SQLite for tracking progress.",
+        },
+        phase: "research",
+    },
+    {
+        name: "generate_implementation_plan",
+        category: "architect",
+        tags: ["implementation-plan", "gap-analysis", "code-generation", "structural-analysis", "concept-verification", "strategy"],
+        quickRef: {
+            nextAction: "Follow the step-by-step plan. After each step, re-run verify_concept_support to track progress.",
+            nextTools: ["verify_concept_support", "scan_capabilities", "start_verification_cycle"],
+            tip: "Pass current_context from scan_capabilities to get conflict-aware injection strategies.",
+        },
+        phase: "implement",
+    },
 ];
 // ── Exported lookup structures ───────────────────────────────────────────
 /** Map of tool name → registry entry for O(1) lookup */
@@ -1877,6 +2037,10 @@ const CATEGORY_COMPLEXITY = {
     git_workflow: "medium",
     seo: "medium",
     voice_bridge: "medium",
+    critter: "low",
+    email: "medium",
+    rss: "low",
+    architect: "low",
 };
 /** Per-tool complexity overrides (when category default is wrong) */
 const TOOL_COMPLEXITY_OVERRIDES = {
@@ -1946,7 +2110,7 @@ export function getToolComplexity(toolName) {
 }
 // ── Synonym / semantic expansion map ──────────────────────────────────────
 const SYNONYM_MAP = {
-    verify: ["validate", "check", "confirm", "test", "assert", "ensure"],
+    verify: ["validate", "check", "confirm", "test", "assert", "ensure", "correct"],
     test: ["verify", "validate", "check", "assert", "spec", "expect"],
     search: ["find", "discover", "lookup", "query", "locate", "browse"],
     find: ["search", "discover", "lookup", "locate"],
@@ -1958,7 +2122,7 @@ const SYNONYM_MAP = {
     monitor: ["watch", "observe", "track", "follow"],
     security: ["vulnerability", "audit", "cve", "secret", "credential", "leak", "exposure"],
     benchmark: ["measure", "evaluate", "score", "grade", "performance", "capability"],
-    parallel: ["multi-agent", "coordinate", "team", "concurrent", "distributed"],
+    parallel: ["multi-agent", "coordinate", "team", "concurrent", "distributed", "multiple"],
     document: ["doc", "documentation", "readme", "agents-md", "report"],
     research: ["recon", "investigate", "discover", "explore", "gather"],
     quality: ["gate", "check", "validate", "standard", "rule"],
@@ -1970,10 +2134,19 @@ const SYNONYM_MAP = {
     review: ["inspect", "audit", "pr", "pull-request", "feedback", "critique"],
     performance: ["speed", "latency", "optimize", "fast", "slow", "bottleneck"],
     data: ["csv", "xlsx", "json", "pdf", "file", "parse", "extract", "spreadsheet"],
-    paper: ["academic", "research", "write", "publish", "neurips", "icml", "arxiv"],
+    paper: ["academic", "research", "write", "publish", "neurips", "icml", "arxiv", "section"],
     start: ["begin", "init", "kick-off", "launch", "bootstrap", "new"],
     report: ["generate", "summary", "output", "export", "document"],
     clean: ["cleanup", "prune", "remove", "delete", "stale", "orphan"],
+    remember: ["save", "record", "persist", "store", "note", "session"],
+    save: ["remember", "record", "persist", "store", "note", "keep"],
+    wrong: ["investigate", "debug", "diagnose", "error", "issue", "problem", "fail"],
+    correct: ["verify", "validate", "check", "ensure", "confirm"],
+    write: ["paper", "section", "draft", "compose", "author", "document"],
+    task: ["claim", "assign", "work", "agent", "parallel", "concurrent"],
+    why: ["purpose", "reason", "intentionality", "motivation", "goal", "critter"],
+    purpose: ["why", "reason", "intentionality", "motivation", "goal", "critter"],
+    reflect: ["think", "pause", "reconsider", "intentionality", "metacognition", "critter"],
 };
 // ── TF-IDF: compute inverse document frequency for tags ───────────────────
 let _idfCache = null;
@@ -2042,7 +2215,7 @@ function ngramSimilarity(a, b, n = 3) {
 }
 // ── Dense search: TF-IDF cosine similarity on full text ──────────────────
 /** Tokenize text into lowercase words (alpha + underscore only) */
-function tokenize(text) {
+export function tokenize(text) {
     return text.toLowerCase().match(/[a-z_]+/g) ?? [];
 }
 /** Build a TF vector: word → frequency */
@@ -2059,7 +2232,7 @@ function termFreq(tokens) {
 /** Pre-computed document TF-IDF vectors for dense search (lazy init) */
 let _denseVectorsCache = null;
 let _denseIDFCache = null;
-function buildDenseIndex() {
+export function buildDenseIndex() {
     if (_denseVectorsCache && _denseIDFCache)
         return { vectors: _denseVectorsCache, idf: _denseIDFCache };
     // Build corpus: each tool's full text (name + tags + description + category)
@@ -2120,6 +2293,137 @@ const DOMAIN_CLUSTERS = {
     writing: ["research_writing", "documentation"],
     measurement: ["eval", "benchmark", "self_eval"],
 };
+// ── Execution trace edges — co-occurrence mining from tool_call_log ────────
+// Based on Agent-as-a-Graph (arxiv:2511.18194): execution trace edges
+// mine sequential co-occurrence patterns to discover implicit tool relationships.
+let _cooccurrenceCache = null;
+let _cooccurrenceCacheTime = 0;
+const COOCCURRENCE_TTL_MS = 60_000; // refresh every 60s
+/** Agent-as-a-Graph wRRF constants (arxiv:2511.18194).
+ *
+ *  Paper optimal: α_A=1.5, α_T=1.0, K=60. Ablation confirmed this beats 5 alternatives
+ *  even for single-server tool retrieval (Recall@5=0.625 vs 0.583 for α_D=0.6/K=20).
+ *
+ *  Key finding: K and α_D are coupled. K=60 dampens scores enough that α_D=1.5 lifts
+ *  category siblings gently. K=20 with α_D=1.5 overshoots (domain boost drowns lexical).
+ *  The paper's full parameter set is internally consistent — don't cherry-pick.
+ *
+ *  Max embedding contribution at rank 1: α_T * 1000/(60+1) ≈ 16 pts (tool),
+ *  α_D * 1000/(60+1) ≈ 25 pts (domain). These slot into the additive scoring system
+ *  alongside keyword (3-50), fuzzy (4-12), dense (0-40) as a moderate signal.
+ *
+ *  Validated via 6-config ablation grid: see tools.test.ts "wRRF α ratio ablation". */
+let WRRF_ALPHA_T = 1.0; // tool weight — direct embedding match
+let WRRF_ALPHA_D = 1.5; // domain weight — upward traversal boost (paper optimal)
+let WRRF_K = 60; // RRF smoothing constant (paper optimal)
+/** Bonus score for tools that frequently co-occur with top-ranked results.
+ *  Calibrated to lift borderline tools ~1-2 positions without overriding strong lexical matches.
+ *  At +4, a tool needs ≥8 points of lexical evidence to appear in results at all (score > 0),
+ *  then trace edges nudge it up. Compare: keyword:desc = +3, semantic:tag = +6, domain_boost = +5. */
+const TRACE_EDGE_BOOST = 4;
+// DB accessor injected at init time to avoid circular import (toolRegistry is pure ESM)
+let _dbAccessor = null;
+/** Inject the DB accessor — called once from index.ts at startup. */
+export function _setDbAccessor(accessor) {
+    _dbAccessor = accessor;
+}
+/**
+ * Mine co-occurrence patterns from tool_call_log.
+ * Returns a map of toolName → [most co-occurring tools] based on session adjacency.
+ *
+ * Approach: for each session, pull the ordered tool sequence, then count
+ * pairs within a sliding window of 5 calls. O(n) per session, no self-join.
+ */
+function getCooccurrenceEdges() {
+    const now = Date.now();
+    if (_cooccurrenceCache && now - _cooccurrenceCacheTime < COOCCURRENCE_TTL_MS) {
+        return _cooccurrenceCache;
+    }
+    const edges = new Map();
+    if (!_dbAccessor) {
+        _cooccurrenceCache = edges;
+        _cooccurrenceCacheTime = now;
+        return edges;
+    }
+    try {
+        const db = _dbAccessor();
+        // Pull recent sessions' tool sequences, ordered by creation time
+        const rows = db.prepare(`
+      SELECT session_id, tool_name
+      FROM tool_call_log
+      WHERE created_at > datetime('now', '-7 days')
+      ORDER BY session_id, created_at ASC
+    `).all();
+        // Group by session
+        const sessions = new Map();
+        for (const row of rows) {
+            const list = sessions.get(row.session_id) ?? [];
+            list.push(row.tool_name);
+            sessions.set(row.session_id, list);
+        }
+        // Count co-occurrences within sliding window of 5
+        const pairCounts = new Map();
+        for (const [, sequence] of sessions) {
+            for (let i = 0; i < sequence.length; i++) {
+                const toolA = sequence[i];
+                for (let j = i + 1; j < Math.min(i + 6, sequence.length); j++) {
+                    const toolB = sequence[j];
+                    if (toolA === toolB)
+                        continue;
+                    const key = `${toolA}\0${toolB}`;
+                    pairCounts.set(key, (pairCounts.get(key) ?? 0) + 1);
+                    // Bidirectional
+                    const keyR = `${toolB}\0${toolA}`;
+                    pairCounts.set(keyR, (pairCounts.get(keyR) ?? 0) + 1);
+                }
+            }
+        }
+        // Filter to pairs with 2+ co-occurrences, sort by count
+        const sorted = [...pairCounts.entries()]
+            .filter(([, cnt]) => cnt >= 2)
+            .sort((a, b) => b[1] - a[1]);
+        for (const [key] of sorted) {
+            const [toolA, toolB] = key.split("\0");
+            const list = edges.get(toolA) ?? [];
+            if (list.length < 10) {
+                list.push(toolB);
+                edges.set(toolA, list);
+            }
+        }
+    }
+    catch {
+        // No DB or table not yet created — return empty (graceful degradation)
+    }
+    _cooccurrenceCache = edges;
+    _cooccurrenceCacheTime = now;
+    return edges;
+}
+/** Reset co-occurrence cache — for testing only. */
+export function _resetCooccurrenceCache() {
+    _cooccurrenceCache = null;
+    _cooccurrenceCacheTime = 0;
+}
+/** Inject co-occurrence edges directly — for testing only. */
+export function _setCooccurrenceForTesting(edges) {
+    _cooccurrenceCache = edges;
+    _cooccurrenceCacheTime = Date.now() + 999_999_999; // never expire
+}
+/** Override wRRF weights — for ablation testing only.
+ *  Allows comparing paper's α_A=1.5,α_T=1.0,K=60 vs our α_T=1.0,α_D=0.6,K=20. */
+export function _setWrrfParamsForTesting(params) {
+    if (params.alphaT !== undefined)
+        WRRF_ALPHA_T = params.alphaT;
+    if (params.alphaD !== undefined)
+        WRRF_ALPHA_D = params.alphaD;
+    if (params.k !== undefined)
+        WRRF_K = params.k;
+}
+/** Restore default wRRF weights — for ablation testing only. */
+export function _resetWrrfParamsForTesting() {
+    WRRF_ALPHA_T = 1.0;
+    WRRF_ALPHA_D = 1.5;
+    WRRF_K = 60;
+}
 function getDomainBoost(category, topCategories) {
     for (const [, cluster] of Object.entries(DOMAIN_CLUSTERS)) {
         if (cluster.includes(category) && cluster.some((c) => topCategories.has(c) && c !== category)) {
@@ -2129,7 +2433,7 @@ function getDomainBoost(category, topCategories) {
     return 0;
 }
 /**
- * Multi-modal hybrid search engine.
+ * Multi-modal hybrid search engine with Agent-as-a-Graph bipartite retrieval.
  *
  * Search modes (all run in parallel, scores merged):
  * - **keyword**: Exact and partial word matching on name, tags, description, category
@@ -2141,6 +2445,11 @@ function getDomainBoost(category, topCategories) {
  * - **regex**: Pass a regex pattern to match against tool names/descriptions
  * - **bigram**: Two-word phrase matching (e.g., "quality gate" matched as phrase)
  * - **domain boost**: Related categories get boosted when top results cluster
+ * - **embedding**: Neural embedding with type-specific wRRF (tool α_T + domain α_D nodes)
+ * - **graph traversal**: Upward traversal from tools → domains → sibling tools
+ * - **trace edges**: Execution co-occurrence mining from tool_call_log (dynamic graph edges)
+ *
+ * Graph architecture based on arxiv:2511.18194 (Agent-as-a-Graph).
  */
 export function hybridSearch(query, tools, options) {
     const queryLower = query.toLowerCase().trim();
@@ -2171,6 +2480,41 @@ export function hybridSearch(query, tools, options) {
                 syns.forEach((s) => expandedWords.add(s));
         }
     }
+    // ── Pre-compute query-invariant data ONCE before the per-tool loop ──
+    // Dense: TF-IDF query vector (query-invariant — don't recompute per tool)
+    let denseQueryVec = null;
+    let denseDocVectors = null;
+    if (mode === "dense" || mode === "hybrid") {
+        const { vectors, idf: denseIdf } = buildDenseIndex();
+        const queryTokens = tokenize(queryLower);
+        if (queryTokens.length > 0) {
+            const queryTf = termFreq(queryTokens);
+            denseQueryVec = new Map();
+            for (const [term, tfVal] of queryTf) {
+                denseQueryVec.set(term, tfVal * (denseIdf.get(term) ?? 1));
+            }
+            denseDocVectors = vectors;
+        }
+    }
+    // Embedding: pre-split ranks by node type (query-invariant — don't recompute per tool)
+    let embToolRanks = null;
+    let embDomainRanks = null;
+    if ((mode === "embedding" || mode === "hybrid") && isEmbeddingReady() && options?.embeddingQueryVec) {
+        const vecResults = embeddingSearch(options.embeddingQueryVec, 50);
+        embToolRanks = new Map();
+        embDomainRanks = new Map();
+        let toolIdx = 0, domainIdx = 0;
+        for (const r of vecResults) {
+            if (r.nodeType === "domain") {
+                domainIdx++;
+                embDomainRanks.set(r.name.replace("domain:", ""), domainIdx);
+            }
+            else {
+                toolIdx++;
+                embToolRanks.set(r.name, toolIdx);
+            }
+        }
+    }
     const toolScores = new Map();
     for (const tool of tools) {
         const entry = TOOL_REGISTRY.get(tool.name);
@@ -2347,27 +2691,35 @@ export function hybridSearch(query, tools, options) {
                 }
             }
         }
-        // ── DENSE: TF-IDF cosine similarity on full text ──
-        if (mode === "dense" || mode === "hybrid") {
-            const { vectors, idf: denseIdf } = buildDenseIndex();
-            const queryTokens = tokenize(queryLower);
-            if (queryTokens.length > 0) {
-                const queryTf = termFreq(queryTokens);
-                const queryVec = new Map();
-                for (const [term, tfVal] of queryTf) {
-                    queryVec.set(term, tfVal * (denseIdf.get(term) ?? 1));
-                }
-                const docVec = vectors.get(tool.name);
-                if (docVec) {
-                    const sim = cosineSimilarity(queryVec, docVec);
-                    if (sim > 0.05) {
-                        const denseScore = Math.round(sim * 40);
-                        score += denseScore;
-                        reasons.push(`dense:cosine(sim=${sim.toFixed(3)},+${denseScore})`);
-                    }
+        // ── DENSE: TF-IDF cosine similarity (query vec pre-computed above) ──
+        if (denseQueryVec && denseDocVectors) {
+            const docVec = denseDocVectors.get(tool.name);
+            if (docVec) {
+                const sim = cosineSimilarity(denseQueryVec, docVec);
+                if (sim > 0.05) {
+                    const denseScore = Math.round(sim * 40);
+                    score += denseScore;
+                    reasons.push(`dense:cosine(sim=${sim.toFixed(3)},+${denseScore})`);
                 }
             }
         }
+        // ── EMBEDDING: Agent-as-a-Graph bipartite RRF (ranks pre-computed above) ──
+        if (embToolRanks && embDomainRanks) {
+            const toolRank = embToolRanks.get(tool.name);
+            if (toolRank) {
+                const rrfScore = Math.round(WRRF_ALPHA_T * 1000 / (WRRF_K + toolRank));
+                score += rrfScore;
+                reasons.push(`embedding:tool_rrf(rank=${toolRank},+${rrfScore})`);
+            }
+            // Upward traversal: if this tool's domain matched, boost it (sibling expansion)
+            const toolCategory = entry.category;
+            const domainRank = embDomainRanks.get(toolCategory);
+            if (domainRank) {
+                const domainRrf = Math.round(WRRF_ALPHA_D * 1000 / (WRRF_K + domainRank));
+                score += domainRrf;
+                reasons.push(`embedding:domain_rrf(${toolCategory},rank=${domainRank},+${domainRrf})`);
+            }
+        }
         if (score > 0) {
             toolScores.set(tool.name, { score, reasons });
         }
@@ -2380,6 +2732,17 @@ export function hybridSearch(query, tools, options) {
         if (entry)
             topCategories.add(entry.category);
     }
+    // ── Execution trace edges (2nd pass) — co-occurrence boost ──
+    // Agent-as-a-Graph: mine tool_call_log for sequential co-occurrence.
+    // If a top-ranked tool frequently co-occurs with another tool, boost the sibling.
+    const cooccurrence = getCooccurrenceEdges();
+    const topToolNames = sortedPrelim.slice(0, 5).map(([name]) => name);
+    const traceBoostTargets = new Set();
+    for (const topTool of topToolNames) {
+        const neighbors = cooccurrence.get(topTool);
+        if (neighbors)
+            neighbors.forEach((n) => traceBoostTargets.add(n));
+    }
     const results = [];
     for (const tool of tools) {
         const entry = TOOL_REGISTRY.get(tool.name);
@@ -2391,6 +2754,11 @@ export function hybridSearch(query, tools, options) {
             scored.score += domainBoost;
             scored.reasons.push(`domain_boost:+${domainBoost}`);
         }
+        // Execution trace edge: boost tools that frequently co-occur with top results
+        if (traceBoostTargets.has(tool.name) && !topToolNames.includes(tool.name)) {
+            scored.score += TRACE_EDGE_BOOST;
+            scored.reasons.push(`trace_edge:+${TRACE_EDGE_BOOST}`);
+        }
         results.push({
             name: tool.name,
             description: tool.description,
@@ -2406,7 +2774,7 @@ export function hybridSearch(query, tools, options) {
     return results.slice(0, limit);
 }
 /** Available search modes for discover_tools */
-export const SEARCH_MODES = ["hybrid", "fuzzy", "regex", "prefix", "semantic", "exact", "dense"];
+export const SEARCH_MODES = ["hybrid", "fuzzy", "regex", "prefix", "semantic", "exact", "dense", "embedding"];
 /** Pre-built workflow chains for common tasks */
 export const WORKFLOW_CHAINS = {
     new_feature: {
@@ -2736,5 +3104,36 @@ export const WORKFLOW_CHAINS = {
             { tool: "record_learning", action: "Record voice pipeline implementation patterns" },
         ],
     },
+    intentionality_check: {
+        name: "Intentionality Check (Critter)",
+        description: "Pause before action — articulate why and who, then proceed with clarity",
+        steps: [
+            { tool: "critter_check", action: "Answer: Why are you doing this? Who is it for? Score your intentionality" },
+            { tool: "save_session_note", action: "Persist the critter check so it survives context compaction" },
+            { tool: "run_recon", action: "Gather context now that purpose is clear" },
+        ],
+    },
+    research_digest: {
+        name: "Automated Research Digest",
+        description: "Subscribe to RSS/Atom feeds, fetch new articles, build a digest, and optionally email it",
+        steps: [
+            { tool: "add_rss_source", action: "Register RSS/Atom feed URLs for topics of interest (arXiv, blogs, news)" },
+            { tool: "fetch_rss_feeds", action: "Pull latest articles from all registered sources — new items stored in SQLite" },
+            { tool: "build_research_digest", action: "Generate a categorized digest of new (unseen) articles in markdown, json, or html" },
+            { tool: "send_email", action: "Email the html digest to yourself or your team for daily/weekly review" },
+            { tool: "save_session_note", action: "Persist key findings so they survive context compaction" },
+            { tool: "record_learning", action: "Record insights from noteworthy articles for the knowledge base" },
+        ],
+    },
+    email_assistant: {
+        name: "Email Draft Assistant",
+        description: "Read inbox, draft professional replies, review, and send — all from the agent",
+        steps: [
+            { tool: "read_emails", action: "Fetch recent/unread emails from IMAP inbox to understand what needs attention" },
+            { tool: "draft_email_reply", action: "Generate a professional reply draft from original email context and your instructions" },
+            { tool: "send_email", action: "Send the reviewed and approved draft reply" },
+            { tool: "save_session_note", action: "Log sent emails so you have an audit trail that survives compaction" },
+        ],
+    },
 };
 //# sourceMappingURL=toolRegistry.js.map