@thoughtflow/core 0.1.2

package/dist/libs/tool-capabilities.data.js

@@ -0,0 +1,1462 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_TOOL_CAPABILITIES = void 0;
+exports.ALL_TOOL_CAPABILITIES = [
+    {
+        toolName: "codebase_index",
+        domain: "codebase",
+        intents: ["index codebase", "build search index", "analyze repository from scratch", "rebuild embeddings"],
+        capabilities: ["file discovery", "AST chunking", "embedding generation", "vector storage"],
+        requires: ["file system access", "embedding model", "vector DB"],
+        inputExample: "Index the current project",
+        outputExample: '{ totalFiles: 342, totalChunks: 1847, timeMs: 115200 }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["index", "analyze from scratch", "first time", "rebuild index", "reindex", "scan project", "ingest"],
+        workflow: "Discover all source files, chunk code at function and class boundaries, generate embeddings for each chunk, and store them in the vector database for semantic search.",
+    },
+    {
+        toolName: "codebase_search",
+        domain: "codebase",
+        intents: ["search codebase semantically", "find relevant code", "query code knowledge base", "locate implementation"],
+        capabilities: ["semantic search", "vector similarity", "relevance ranking", "cross-file retrieval"],
+        requires: ["codebase index", "vector DB"],
+        inputExample: "Find where authentication logic is implemented",
+        outputExample: '{ results: [{ file: "src/auth/login.ts", line: 42, score: 0.94, snippet: "async function authenticate..." }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["search", "find", "where is", "locate", "look up", "semantic search", "discover", "retrieve"],
+        workflow: "Accept a natural language query, convert to embedding vector, perform nearest-neighbor search against the codebase index, and return ranked results with file paths and snippets.",
+    },
+    {
+        toolName: "codebase_status",
+        domain: "codebase",
+        intents: ["check index status", "view codebase health", "inspect indexing progress", "diagnose indexing issues"],
+        capabilities: ["index metrics", "health reporting", "progress tracking", "error diagnostics"],
+        requires: ["codebase index"],
+        inputExample: "Show codebase index status",
+        outputExample: '{ indexed: true, totalFiles: 342, staleFiles: 3, lastIndexed: "2026-05-01T10:00:00Z" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["status", "health", "progress", "index state", "is indexed", "check indexing", "diagnose index"],
+        workflow: "Query the index database for current metrics, check for stale files that have been modified since last indexing, and report overall health.",
+    },
+    {
+        toolName: "codebase_graph_query",
+        domain: "codebase",
+        intents: ["query dependency graph", "traverse code relationships", "find dependents", "explore imports"],
+        capabilities: ["graph traversal", "Cypher-style queries", "relationship mapping", "path finding"],
+        requires: ["knowledge graph", "codebase index"],
+        inputExample: "Find all files that import from src/utils/helpers.ts",
+        outputExample: '{ nodes: [{ file: "src/components/Header.tsx" }, { file: "src/pages/Home.tsx" }], edges: [{ from: "...", to: "...", type: "imports" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["graph query", "dependencies", "imports of", "dependents", "callers of", "relationship", "traverse"],
+        workflow: "Parse the user's graph query, traverse the knowledge graph along edges representing imports, calls, and type references, and return matching subgraph.",
+    },
+    {
+        toolName: "codebase_graph_visualize",
+        domain: "codebase",
+        intents: ["visualize dependency graph", "render architecture diagram", "show module relationships", "display file dependencies"],
+        capabilities: ["graph rendering", "layout algorithms", "interactive zoom", "export formats"],
+        requires: ["knowledge graph"],
+        inputExample: "Show the dependency graph for the auth module",
+        outputExample: '{ mermaidCode: "graph TD\\n  A[login.ts] --> B[token.ts]\\n  A --> C[validator.ts]", svgUrl: "..." }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["visualize", "diagram", "graph view", "show dependencies", "render graph", "architecture map", "module map"],
+        workflow: "Extract relevant subgraph from the knowledge graph, apply a directed layout algorithm, and generate a Mermaid or Graphviz representation for rendering.",
+    },
+    {
+        toolName: "codebase_graph_circular",
+        domain: "codebase",
+        intents: ["detect circular dependencies", "find import cycles", "identify dependency loops", "check acyclic property"],
+        capabilities: ["cycle detection", "Tarjan's algorithm", "severity classification", "fix suggestions"],
+        requires: ["knowledge graph"],
+        inputExample: "Check for circular dependencies in the project",
+        outputExample: '{ cycles: [{ files: ["A.ts", "B.ts", "C.ts", "A.ts"], length: 3, severity: "warning" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["circular", "cycles", "dependency loop", "import cycle", "cyclic", "deadlock potential", "circular deps"],
+        workflow: "Run cycle detection algorithms on the dependency graph, identify all strongly connected components, and report each cycle with severity and suggested fixes.",
+    },
+    {
+        toolName: "codebase_graph_stats",
+        domain: "codebase",
+        intents: ["view graph statistics", "analyze codebase structure", "measure coupling", "inspect topology"],
+        capabilities: ["graph metrics", "centrality analysis", "degree distribution", "module cohesion"],
+        requires: ["knowledge graph"],
+        inputExample: "Show codebase graph statistics",
+        outputExample: '{ totalNodes: 342, totalEdges: 2103, avgDegree: 6.15, mostCoupled: "src/core/engine.ts", maxDepth: 12 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["stats", "statistics", "metrics", "coupling", "topology", "graph analysis", "structure analysis"],
+        workflow: "Compute degree centrality, betweenness, and clustering coefficients across the dependency graph to surface highly coupled or architecturally significant modules.",
+    },
+    {
+        toolName: "codebase_impact",
+        domain: "codebase",
+        intents: ["analyze change impact", "predict refactor blast radius", "assess modification risk", "trace change propagation"],
+        capabilities: ["impact analysis", "transitive dependency tracing", "risk scoring", "affected test detection"],
+        requires: ["knowledge graph", "codebase index"],
+        inputExample: "What is the impact of changing the User type definition?",
+        outputExample: '{ affectedFiles: 23, affectedTests: 8, riskLevel: "high", propagationPaths: [[...], [...]] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["impact", "what if I change", "blast radius", "affected by", "consequences of", "change risk", "ripple effect"],
+        workflow: "Starting from the target file or symbol, traverse forward along all dependency edges to compute the full transitive closure of affected modules and tests.",
+    },
+    {
+        toolName: "codebase_flow",
+        domain: "codebase",
+        intents: ["trace data flow", "follow execution path", "analyze control flow", "map call chains"],
+        capabilities: ["data flow analysis", "call chain reconstruction", "control flow graphing", "variable taint tracking"],
+        requires: ["knowledge graph", "AST parser"],
+        inputExample: "Trace the flow from user input in the login handler to the database call",
+        outputExample: '{ path: ["handler.ts:login()", "service.ts:authenticate()", "db.ts:findUser()"], latencyBreakdown: {...} }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["flow", "trace", "data path", "execution path", "call chain", "how does data move", "propagation"],
+        workflow: "Perform interprocedural data flow analysis starting from a source symbol, following variable assignments and function calls until reaching a sink.",
+    },
+    {
+        toolName: "codebase_knowledge",
+        domain: "codebase",
+        intents: ["query codebase knowledge", "ask architectural questions", "understand design decisions", "learn codebase patterns"],
+        capabilities: ["RAG over codebase", "architectural Q&A", "pattern recognition", "design rationale extraction"],
+        requires: ["codebase index", "LLM access"],
+        inputExample: "Why does the auth module use JWT instead of session tokens?",
+        outputExample: '{ answer: "Based on code comments and ADRs, JWT was chosen for stateless scaling across microservices.", sources: ["docs/adr/003-auth.md", "src/auth/jwt.ts:15"] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["why", "how does", "explain architecture", "design rationale", "what pattern", "understanding", "codebase knowledge"],
+        workflow: "Retrieve relevant code and documentation chunks via semantic search, feed them as context to an LLM, and return a synthesized answer with source citations.",
+    },
+    {
+        toolName: "codebase_crossref",
+        domain: "codebase",
+        intents: ["find cross-references", "locate all usages", "trace symbol references", "find implementations of interface"],
+        capabilities: ["symbol indexing", "cross-reference resolution", "interface implementation mapping", "call-site enumeration"],
+        requires: ["codebase index", "AST parser"],
+        inputExample: "Find all usages of the validateEmail function",
+        outputExample: '{ references: [{ file: "src/forms/signup.ts", line: 88, context: "if (validateEmail(input))" }, ...], totalCount: 12 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["references", "usages", "where used", "cross reference", "call sites", "implementations of", "who calls"],
+        workflow: "Query the symbol index for all references to a given identifier across the codebase, resolving overloaded names and returning contextual snippets at each call site.",
+    },
+    {
+        toolName: "codebase_analyze",
+        domain: "codebase",
+        intents: ["analyze codebase deeply", "comprehensive code audit", "generate architecture report", "assess codebase maturity"],
+        capabilities: ["multi-faceted analysis", "trend detection", "report generation", "comparative benchmarking"],
+        requires: ["codebase index", "knowledge graph", "LLM access"],
+        inputExample: "Generate a comprehensive analysis of the entire codebase",
+        outputExample: '{ architecture: { layers: [...], violations: 3 }, quality: { score: 78 }, health: { techDebt: "moderate" }, recommendations: [...] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "high",
+        triggers: ["analyze", "comprehensive", "audit", "codebase report", "assessment", "full analysis", "deep dive"],
+        workflow: "Orchestrate multiple analysis tools (complexity, coverage, coupling, graph stats) and synthesize results into a comprehensive report with prioritized recommendations.",
+    },
+    {
+        toolName: "neural_explain",
+        domain: "neural",
+        intents: ["explain code", "understand complex logic", "get plain-English description", "demystify algorithm"],
+        capabilities: ["LLM reasoning", "code summarization", "concept mapping", "difficulty-adaptive explanation"],
+        requires: ["LLM access", "file access"],
+        inputExample: "Explain what the debounce function in utils/timing.ts does",
+        outputExample: '{ summary: "This function limits how often a callback can fire by waiting until calls pause for a given delay.", complexity: "intermediate", keyConcepts: ["closure", "timer", "leading/trailing edge"] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["explain", "what does this do", "how does this work", "describe", "clarify", "understand this", "walk me through"],
+        workflow: "Read the target code, parse its structure, and use an LLM to generate a plain-English explanation with identified concepts and complexity level.",
+    },
+    {
+        toolName: "neural_suggest",
+        domain: "neural",
+        intents: ["suggest improvements", "propose optimizations", "recommend refactors", "offer alternative approaches"],
+        capabilities: ["LLM suggestion generation", "pattern matching", "best-practice knowledge", "context-aware proposals"],
+        requires: ["LLM access", "file access"],
+        inputExample: "Suggest improvements for the payment processing pipeline",
+        outputExample: '{ suggestions: [{ title: "Batch inserts", impact: "high", effort: "low", description: "Use bulk INSERT instead of N individual queries" }], totalCount: 5 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["suggest", "improve", "recommend", "better way", "optimize", "proposal", "alternatives", "ideas for"],
+        workflow: "Analyze the target code for common anti-patterns and performance bottlenecks, then use LLM reasoning to generate ranked improvement suggestions with effort/impact estimates.",
+    },
+    {
+        toolName: "neural_review",
+        domain: "neural",
+        intents: ["review code", "find bugs", "check quality", "code audit"],
+        capabilities: ["LLM reasoning", "pattern matching", "severity classification", "fix suggestion"],
+        requires: ["LLM access", "file access"],
+        inputExample: "Review src/auth/login.ts for security and bugs",
+        outputExample: '{ issues: [{ severity: "critical", category: "security", line: 42, message: "Hardcoded secret", suggestion: "Use env var" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "high",
+        triggers: ["review", "audit", "check code", "find bugs", "code quality", "security scan", "inspect", "examine"],
+        workflow: "Read target files, apply static analysis patterns, then perform LLM deep analysis to surface bugs, security issues, and quality concerns with severity-ranked fix suggestions.",
+    },
+    {
+        toolName: "neural_debug",
+        domain: "neural",
+        intents: ["debug errors", "diagnose failures", "trace bugs", "analyze stack traces"],
+        capabilities: ["error analysis", "stack trace interpretation", "root cause reasoning", "fix generation"],
+        requires: ["LLM access", "codebase index"],
+        inputExample: "Debug the TypeError in src/api/users.ts line 142",
+        outputExample: '{ rootCause: "usersService.findById returns null when user not found, but caller does not guard", suggestedFix: "Add null check before accessing .email", confidence: 0.92 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["debug", "fix error", "what's wrong", "bug", "crash", "stack trace", "failing", "broken", "exception"],
+        workflow: "Parse the error and stack trace, retrieve relevant source code, trace the logical flow that leads to the failure, and produce a root cause analysis with a concrete fix.",
+    },
+    {
+        toolName: "neural_security",
+        domain: "neural",
+        intents: ["scan for vulnerabilities", "security audit", "detect insecure patterns", "check OWASP compliance"],
+        capabilities: ["vulnerability detection", "OWASP top-10 mapping", "taint analysis", "CVE correlation"],
+        requires: ["LLM access", "codebase index", "CVE database"],
+        inputExample: "Run a security scan on the entire project",
+        outputExample: '{ findings: [{ severity: "critical", cwe: "CWE-89", location: "src/db/queries.ts:78", description: "SQL injection via unsanitized user input" }], riskScore: 65 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "high",
+        triggers: ["security", "vulnerability", "injection", "XSS", "CSRF", "OWASP", "CVE", "exploit", "secure code"],
+        workflow: "Scan codebase for OWASP top-10 vulnerability patterns, perform taint analysis on user-controlled data flows, and correlate findings with known CVE entries.",
+    },
+    {
+        toolName: "neural_smells",
+        domain: "neural",
+        intents: ["detect code smells", "identify anti-patterns", "find technical debt", "spot design issues"],
+        capabilities: ["smell catalog matching", "LLM pattern recognition", "debt quantification", "refactor targeting"],
+        requires: ["LLM access", "codebase index"],
+        inputExample: "Find code smells in the order processing module",
+        outputExample: '{ smells: [{ type: "God Class", location: "src/orders/OrderManager.ts", lines: 1847, suggestedAction: "Split into OrderValidator, OrderProcessor, OrderNotifier" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["code smell", "anti-pattern", "technical debt", "bad practice", "design issue", "refactor candidate", "smelly code"],
+        workflow: "Apply a catalog of known code smells (God Class, Long Method, Feature Envy, etc.) against the codebase, using LLM to validate matches and suggest specific refactors.",
+    },
+    {
+        toolName: "neural_deadcode",
+        domain: "neural",
+        intents: ["find dead code", "detect unused exports", "identify unreachable code", "clean up codebase"],
+        capabilities: ["dead code detection", "export usage analysis", "unreachable path detection", "safe removal suggestions"],
+        requires: ["codebase index", "knowledge graph", "LLM access"],
+        inputExample: "Find all dead code in the project",
+        outputExample: '{ deadFiles: ["src/legacy/oldParser.ts"], deadFunctions: [{ name: "deprecatedInit", file: "src/init.ts", line: 200 }], deadExports: 15, estimatedBytesSaved: 43000 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["dead code", "unused", "unreachable", "zombie code", "remove unused", "clean up", "stale code", "orphaned"],
+        workflow: "Cross-reference all exports against all imports in the knowledge graph, detect functions with no callers, and flag unreachable code paths with safe deletion confidence.",
+    },
+    {
+        toolName: "neural_similar",
+        domain: "neural",
+        intents: ["find duplicate code", "detect copy-paste", "identify similar implementations", "discover near-miss clones"],
+        capabilities: ["semantic similarity", "AST fingerprinting", "clone detection", "abstraction suggestion"],
+        requires: ["codebase index", "LLM access"],
+        inputExample: "Find similar code blocks that might be duplicated",
+        outputExample: '{ duplicates: [{ files: ["src/payment/stripe.ts:42-78", "src/payment/paypal.ts:35-71"], similarity: 0.94, suggestedAbstraction: "Extract shared payment validation logic" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["similar", "duplicate", "copy paste", "clone", "DRY", "repeated code", "near identical", "redundant"],
+        workflow: "Compute AST fingerprints and semantic embeddings for all code blocks, cluster by similarity, and report near-duplicate pairs with suggested abstractions.",
+    },
+    {
+        toolName: "neural_pattern",
+        domain: "neural",
+        intents: ["detect design patterns", "identify architectural patterns", "recognize applied patterns", "suggest missing patterns"],
+        capabilities: ["GoF pattern recognition", "architectural pattern matching", "pattern conformance checking", "pattern recommendation"],
+        requires: ["LLM access", "codebase index"],
+        inputExample: "What design patterns are used in the notification system?",
+        outputExample: '{ detected: [{ pattern: "Observer", confidence: 0.87, location: "src/notifications/bus.ts" }, { pattern: "Strategy", confidence: 0.92, location: "src/notifications/channels/" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["design pattern", "GoF", "architecture pattern", "factory", "singleton", "observer", "pattern used", "what pattern"],
+        workflow: "Analyze code structure against the Gang of Four and enterprise integration pattern catalogs, identifying both applied patterns and opportunities where patterns could improve the design.",
+    },
+    {
+        toolName: "neural_optimize",
+        domain: "neural",
+        intents: ["optimize code", "improve performance", "reduce complexity", "speed up execution"],
+        capabilities: ["performance bottleneck detection", "algorithmic optimization", "complexity reduction", "benchmark-aware suggestions"],
+        requires: ["LLM access", "codebase index", "profiling data"],
+        inputExample: "Optimize the search indexing pipeline for speed",
+        outputExample: '{ bottlenecks: [{ location: "src/index/builder.ts:234", issue: "O(n²) nested loop", suggestion: "Use hash map for lookup", estimatedSpeedup: "12x" }], totalEstimatedGain: "45% faster" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "high",
+        triggers: ["optimize", "faster", "performance", "speed up", "bottleneck", "slow", "accelerate", "improve latency"],
+        workflow: "Identify algorithmic inefficiencies and hotspots via static analysis and profiling data, then use LLM reasoning to propose optimizations with estimated performance gains.",
+    },
+    {
+        toolName: "quality_complexity",
+        domain: "quality",
+        intents: ["measure code complexity", "assess cognitive load", "find complex functions", "enforce complexity thresholds"],
+        capabilities: ["cyclomatic complexity", "cognitive complexity", "Halstead metrics", "threshold enforcement"],
+        requires: ["AST parser", "codebase index"],
+        inputExample: "Find the most complex functions in the project",
+        outputExample: '{ topComplexFunctions: [{ name: "processTransaction", file: "src/billing/engine.ts", cyclomatic: 47, cognitive: 62, status: "critical" }], avgComplexity: 8.3 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["complexity", "cognitive load", "cyclomatic", "complicated", "hard to understand", "nesting", "branching"],
+        workflow: "Parse AST to compute cyclomatic and cognitive complexity for every function, rank results, and flag those exceeding configured thresholds.",
+    },
+    {
+        toolName: "quality_coupling",
+        domain: "quality",
+        intents: ["measure module coupling", "assess cohesion", "find tightly coupled modules", "analyze dependency health"],
+        capabilities: ["afferent/efferent coupling", "instability metrics", "abstractness ratio", "distance from main sequence"],
+        requires: ["knowledge graph"],
+        inputExample: "Measure coupling across all modules",
+        outputExample: '{ modules: [{ name: "src/auth", afferent: 23, efferent: 5, instability: 0.18, status: "zone of pain" }], warnings: 3 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["coupling", "cohesion", "tightly coupled", "dependency health", "instability", "modularity", "loose coupling"],
+        workflow: "Compute Robert Martin's coupling metrics (afferent/efferent coupling, instability, abstractness) for each module and plot on the main sequence distance chart.",
+    },
+    {
+        toolName: "quality_coverage",
+        domain: "quality",
+        intents: ["check test coverage", "measure code covered by tests", "find untested code", "generate coverage report"],
+        capabilities: ["line/branch/function coverage", "coverage gap analysis", "threshold enforcement", "historical trending"],
+        requires: ["test runner", "coverage instrumentation"],
+        inputExample: "Show test coverage for the src/core module",
+        outputExample: '{ lineCoverage: 0.72, branchCoverage: 0.58, functionCoverage: 0.81, uncoveredFiles: ["src/core/edge-cases.ts"], gapSeverity: "moderate" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["coverage", "tested", "untested", "code coverage", "how much is tested", "coverage gap"],
+        workflow: "Run the test suite with coverage instrumentation, aggregate line, branch, and function coverage by module, and highlight the most critical untested code paths.",
+    },
+    {
+        toolName: "quality_deps",
+        domain: "quality",
+        intents: ["audit external dependencies", "check dependency freshness", "find vulnerable packages", "review dependency graph"],
+        capabilities: ["dependency version checking", "vulnerability scanning", "license compliance", "transitive dependency audit"],
+        requires: ["package manager", "vulnerability database"],
+        inputExample: "Audit all npm dependencies for vulnerabilities and outdated packages",
+        outputExample: '{ outdated: 12, vulnerable: 3, licenses: { compliant: 47, warning: 2, prohibited: 0 }, recommendations: ["Update lodash to 4.17.21+"] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["dependencies", "packages", "npm audit", "outdated", "vulnerable", "license check", "dependency audit"],
+        workflow: "Enumerate all direct and transitive dependencies, check against vulnerability databases and latest version registries, and flag license compliance issues.",
+    },
+    {
+        toolName: "quality_size",
+        domain: "quality",
+        intents: ["measure code size", "find oversized files", "track codebase growth", "enforce size limits"],
+        capabilities: ["LOC counting", "file size distribution", "growth trending", "size gate enforcement"],
+        requires: ["file system access"],
+        inputExample: "Find all files exceeding 500 lines",
+        outputExample: '{ oversizedFiles: [{ path: "src/engine/pipeline.ts", lines: 1247, recommendation: "Split into separate pipeline stages" }], sizeDistribution: { small: 230, medium: 98, large: 14 } }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["file size", "too large", "lines of code", "oversized", "growth", "size gate", "LOC", "max lines"],
+        workflow: "Count logical lines of code per file, compute distribution statistics, and flag files exceeding size thresholds with refactoring suggestions.",
+    },
+    {
+        toolName: "quality_types",
+        domain: "quality",
+        intents: ["check type safety", "audit type coverage", "find any types", "enforce strict typing"],
+        capabilities: ["strict type enforcement", "any-type detection", "type coverage ratio", "type widening analysis"],
+        requires: ["TypeScript compiler"],
+        inputExample: "Check type safety across the project",
+        outputExample: '{ strictTypeCoverage: 0.86, anyCount: 143, implicitAnyCount: 23, filesWithLowCoverage: ["src/utils/legacy.ts"], overall: "good" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["types", "type safety", "any type", "strict typing", "type coverage", "implicit any", "TypeScript strict"],
+        workflow: "Analyze TypeScript compilation output to find uses of any, implicit any, and type assertions, computing a strict type coverage ratio per file and overall.",
+    },
+    {
+        toolName: "quality_duplication",
+        domain: "quality",
+        intents: ["find duplicated code", "measure DRY compliance", "detect copy-paste", "identify repeated logic"],
+        capabilities: ["token-based clone detection", "duplication ratio", "clone visualization", "extraction suggestion"],
+        requires: ["codebase index"],
+        inputExample: "Find duplicated code blocks across the project",
+        outputExample: '{ duplicationRatio: 0.08, cloneGroups: [{ blockCount: 3, totalLines: 134, files: ["src/a.ts", "src/b.ts", "src/c.ts"], suggestion: "Extract to shared helper" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["duplication", "copy paste", "DRY", "repeated", "deduplicate", "identical code", "clone detection"],
+        workflow: "Run token-based clone detection on the codebase to find identical or near-identical code blocks, group them, compute duplication ratios, and suggest extractions.",
+    },
+    {
+        toolName: "test_gen_unit",
+        domain: "testing",
+        intents: ["generate unit tests", "create test cases", "write Jest tests", "add missing test coverage"],
+        capabilities: ["test scaffold generation", "edge case inference", "mock setup", "assertion generation"],
+        requires: ["LLM access", "codebase index"],
+        inputExample: "Generate unit tests for the calculateDiscount function in src/pricing.ts",
+        outputExample: 'Generated file: src/pricing.test.ts with 8 test cases covering happy path, edge cases (zero, negative, max), and error conditions.',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "high",
+        triggers: ["generate tests", "create unit test", "write test", "add test", "test coverage", "missing tests", "unit test"],
+        workflow: "Analyze the target function's signature, branches, and dependencies, then generate a complete test file with mocks, edge cases, and assertions following the project's test conventions.",
+    },
+    {
+        toolName: "test_gen_integration",
+        domain: "testing",
+        intents: ["generate integration tests", "create API tests", "write end-to-end test", "test service interactions"],
+        capabilities: ["integration test scaffolding", "fixture generation", "service mock setup", "HTTP assertion generation"],
+        requires: ["LLM access", "codebase index", "API schema"],
+        inputExample: "Generate integration tests for the user registration endpoint",
+        outputExample: 'Generated: src/__tests__/integration/register.test.ts with tests for valid registration, duplicate email, missing fields, and rate limiting.',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "high",
+        triggers: ["integration test", "e2e test", "API test", "endpoint test", "service test", "HTTP test", "request test"],
+        workflow: "Parse the API endpoint schema and handler logic, generate integration test scaffolding with realistic fixtures, and create assertions covering success and failure scenarios.",
+    },
+    {
+        toolName: "test_fix",
+        domain: "testing",
+        intents: ["fix broken tests", "update outdated tests", "repair test assertions", "align tests with code changes"],
+        capabilities: ["test failure analysis", "assertion repair", "mock strategy updates", "regression detection"],
+        requires: ["LLM access", "test runner output", "codebase index"],
+        inputExample: "Fix the failing tests in src/services/payment.test.ts",
+        outputExample: '{ fixedTests: 3, changes: [{ test: "should validate amount", issue: "Expected negative to throw", fix: "Added expect().rejects" }], remainingFailures: 0 }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["fix tests", "broken test", "failing test", "update test", "test broke", "repair test", "test failure"],
+        workflow: "Parse test failure output, compare test expectations against current implementation behavior, and update assertions or mocks to correctly reflect the intended behavior.",
+    },
+    {
+        toolName: "test_gap",
+        domain: "testing",
+        intents: ["find test gaps", "discover uncovered paths", "identify missing test scenarios", "analyze test completeness"],
+        capabilities: ["branch coverage gap analysis", "edge case detection", "risk-based gap scoring", "prioritized test queue"],
+        requires: ["codebase index", "coverage data"],
+        inputExample: "Find gaps in test coverage for the checkout flow",
+        outputExample: '{ gaps: [{ file: "src/checkout/processor.ts", function: "applyCoupon", missedBranches: 4, scenarios: ["expired coupon", "minimum order not met"] }], totalGaps: 7 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["test gaps", "missing tests", "uncovered", "test completeness", "coverage gap", "what's not tested", "untested paths"],
+        workflow: "Correlate code branches against existing test coverage to identify execution paths that lack test coverage, scoring gaps by risk and prioritizing them for test creation.",
+    },
+    {
+        toolName: "test_fuzz",
+        domain: "testing",
+        intents: ["generate fuzz tests", "find edge cases via randomization", "test input boundaries", "discover crashes via fuzzing"],
+        capabilities: ["fuzz input generation", "property-based testing", "invariant definition", "crash reproduction"],
+        requires: ["LLM access", "codebase index"],
+        inputExample: "Generate fuzz tests for the parseUserInput function",
+        outputExample: '{ strategy: "property-based", invariants: ["never throws on string input", "output is always valid User object or null"], testFile: "src/utils/__fuzz__/parseUserInput.fuzz.ts" }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["fuzz", "fuzzing", "property-based", "random test", "edge case generation", "input boundaries", "crash test"],
+        workflow: "Analyze function signature and constraints, define invariants that must hold, and generate property-based fuzz tests that validate behavior across randomized input ranges.",
+    },
+    {
+        toolName: "test_snapshot",
+        domain: "testing",
+        intents: ["generate snapshot tests", "create visual regression tests", "capture output snapshots", "detect unintended changes"],
+        capabilities: ["snapshot capture", "diff detection", "snapshot update workflows", "serialization helpers"],
+        requires: ["LLM access", "codebase index"],
+        inputExample: "Add snapshot tests for the UserProfile React component",
+        outputExample: '{ generatedSnapshots: ["UserProfile default state", "UserProfile with avatar", "UserProfile loading"], testFile: "src/components/UserProfile.snapshot.test.tsx" }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["snapshot", "visual test", "output capture", "regression test", "snapshot test", "render test", "UI test"],
+        workflow: "Analyze the component's props and states, render each meaningful state variant, and generate snapshot assertions that will catch unintended visual or structural changes.",
+    },
+    {
+        toolName: "refactor_extract",
+        domain: "refactor",
+        intents: ["extract code to function", "extract component", "extract module", "break up large blocks"],
+        capabilities: ["extract method", "extract component", "extract variable", "scope analysis"],
+        requires: ["AST parser", "LLM access"],
+        inputExample: "Extract the validation logic from src/forms/signup.ts into a separate function",
+        outputExample: 'Extracted function validateSignupInput() to src/forms/validation.ts. Updated 3 call sites in signup.ts. All existing tests pass.',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["extract", "pull out", "separate", "break out", "extract function", "extract component", "extract module"],
+        workflow: "Identify the selected code block, analyze its dependencies and scope, extract it into a new function/module, and update all references while preserving behavior.",
+    },
+    {
+        toolName: "refactor_rename",
+        domain: "refactor",
+        intents: ["rename symbol", "rename file", "rename variable", "rename across codebase"],
+        capabilities: ["cross-file rename", "symbol resolution", "string/non-code reference update", "safe rename validation"],
+        requires: ["codebase index", "knowledge graph"],
+        inputExample: "Rename the getCwd function to getCurrentWorkingDirectory across the entire project",
+        outputExample: '{ renamed: 34, filesModified: 12, conflicts: 0, testStatus: "all passing", warnings: ["String reference in docs/guide.md may need manual update"] }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "low",
+        triggers: ["rename", "change name", "rename symbol", "rename variable", "rename function", "rename file", "rename class"],
+        workflow: "Resolve the symbol across the entire codebase using the knowledge graph, perform the rename in all source files, and flag any string references in docs or comments.",
+    },
+    {
+        toolName: "refactor_move",
+        domain: "refactor",
+        intents: ["move file", "move module", "reorganize directory", "relocate code"],
+        capabilities: ["move with import update", "barrel file regeneration", "path remapping", "test relocation"],
+        requires: ["codebase index", "knowledge graph"],
+        inputExample: "Move src/utils/helpers.ts to src/common/helpers.ts and update all imports",
+        outputExample: '{ movedFiles: 2, updatedImports: 18, updatedFiles: 15, barrelFilesRegenerated: 2, testPassed: true }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "low",
+        triggers: ["move", "relocate", "reorganize", "move file", "move module", "move to", "change directory"],
+        workflow: "Move the target file, traverse the knowledge graph to find all import statements referencing it, update each import path, and regenerate affected barrel files.",
+    },
+    {
+        toolName: "refactor_types",
+        domain: "refactor",
+        intents: ["improve type definitions", "extract shared types", "narrow types", "add type guards"],
+        capabilities: ["type extraction", "interface consolidation", "type narrowing", "discriminated union generation"],
+        requires: ["TypeScript compiler", "LLM access"],
+        inputExample: "Improve the type definitions in src/models/order.ts",
+        outputExample: '{ changes: [{ description: "Replaced 4 duplicate status string unions with OrderStatus enum" }, { description: "Added discriminated union for Order type" }], typeCoverageImproved: 0.08 }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["improve types", "type refactor", "better types", "type definitions", "shared types", "type guard", "discriminated union"],
+        workflow: "Analyze type usage across the module, identify opportunities for extraction, narrowing, and discriminated unions, then refactor types while ensuring full type compatibility.",
+    },
+    {
+        toolName: "refactor_barrel",
+        domain: "refactor",
+        intents: ["generate barrel files", "manage index.ts exports", "organize module exports", "clean up export structure"],
+        capabilities: ["barrel generation", "export deduplication", "wildcard expansion", "barrel audit"],
+        requires: ["file system access", "AST parser"],
+        inputExample: "Generate barrel files for all directories in src/components",
+        outputExample: '{ generatedBarrels: 14, totalExports: 230, warnings: [{ file: "src/components/icons/index.ts", issue: "2 name conflicts resolved" }] }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["barrel", "index.ts", "re-export", "export *", "barrel file", "organize exports", "module exports"],
+        workflow: "Walk the directory tree, discover all exported symbols in each directory, generate or update index.ts barrel files with explicit re-exports, and resolve naming conflicts.",
+    },
+    {
+        toolName: "refactor_imports",
+        domain: "refactor",
+        intents: ["organize imports", "sort imports", "merge duplicate imports", "remove unused imports"],
+        capabilities: ["import sorting", "import merging", "unused import removal", "import path normalization"],
+        requires: ["AST parser", "TypeScript compiler"],
+        inputExample: "Organize and clean up all imports in src/pages",
+        outputExample: '{ filesModified: 24, unusedRemoved: 47, importsMerged: 18, importsSorted: 24, errors: 0 }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["organize imports", "sort imports", "clean imports", "unused imports", "import order", "fix imports"],
+        workflow: "Parse each file's imports, remove unused ones, merge duplicate specifiers from the same module, sort by convention (external, internal, relative), and normalize paths.",
+    },
+    {
+        toolName: "refactor_async",
+        domain: "refactor",
+        intents: ["convert to async/await", "modernize promise handling", "remove callback patterns", "fix promise chains"],
+        capabilities: ["callback-to-promise conversion", ".then() to async/await", "Promise.all optimization", "error handling improvement"],
+        requires: ["AST parser", "LLM access"],
+        inputExample: "Convert all callback-based code in src/data to async/await",
+        outputExample: '{ functionsConverted: 8, thenChainsRefactored: 5, errorHandlingAdded: 3, warnings: [{ file: "src/data/stream.ts", note: "EventEmitter retained for streaming" }] }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["async", "await", "promisify", "callback hell", "then chain", "promise refactor", "modern async"],
+        workflow: "Detect callback patterns and then() chains, convert them to async/await with proper try/catch error handling, and identify opportunities for Promise.all parallelization.",
+    },
+    {
+        toolName: "refactor_split",
+        domain: "refactor",
+        intents: ["split large file", "break up monolith", "separate concerns", "divide module by responsibility"],
+        capabilities: ["responsibility analysis", "cohesion scoring", "split strategy generation", "safe file division"],
+        requires: ["AST parser", "LLM access"],
+        inputExample: "Split src/services/OrderService.ts into focused modules by responsibility",
+        outputExample: '{ newFiles: ["OrderValidator.ts", "OrderProcessor.ts", "OrderNotifier.ts"], originalLines: 1847, averageNewSize: 615, testStatus: "18 tests pass after split" }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "high",
+        triggers: ["split", "break up", "divide", "separate concerns", "too big", "monolith", "split file", "decompose"],
+        workflow: "Analyze the file's contents to identify distinct responsibilities, propose a split strategy with cohesion scoring, and safely divide into focused modules with updated imports.",
+    },
+    {
+        toolName: "doc_gen_readme",
+        domain: "docs",
+        intents: ["generate README", "create project documentation", "write getting started guide", "build setup instructions"],
+        capabilities: ["README scaffolding", "project introspection", "badge generation", "API overview extraction"],
+        requires: ["LLM access", "codebase index"],
+        inputExample: "Generate a README for the payment-service package",
+        outputExample: 'Generated README.md with sections: Overview, Installation, Quick Start, API Reference, Configuration, Contributing.',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["readme", "README", "project docs", "getting started", "setup guide", "document project", "overview doc"],
+        workflow: "Introspect the package structure, dependencies, and entry points, then generate a comprehensive README with badges, installation steps, usage examples, and API overview.",
+    },
+    {
+        toolName: "doc_gen_api",
+        domain: "docs",
+        intents: ["generate API documentation", "create endpoint reference", "document REST API", "build SDK docs"],
+        capabilities: ["JSDoc/TSDoc extraction", "OpenAPI generation", "endpoint documentation", "parameter/response typing"],
+        requires: ["AST parser", "LLM access", "API schema"],
+        inputExample: "Generate API documentation for the /api/v2/users endpoints",
+        outputExample: '{ documentedEndpoints: 8, generatedFiles: ["docs/api/users.md", "openapi/users.yaml"], coverage: 1.0 }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["API docs", "document API", "endpoint docs", "OpenAPI", "Swagger", "route docs", "REST docs"],
+        workflow: "Parse route handlers and type definitions to extract endpoint signatures, parameters, request/response schemas, and generate formatted API documentation or OpenAPI specs.",
+    },
+    {
+        toolName: "doc_gen_adr",
+        domain: "docs",
+        intents: ["generate ADR", "write architecture decision record", "document design decision", "create decision log"],
+        capabilities: ["ADR template generation", "context gathering", "trade-off analysis", "decision traceability"],
+        requires: ["LLM access", "codebase index"],
+        inputExample: "Generate an ADR for the decision to use PostgreSQL over MongoDB",
+        outputExample: '{ adrFile: "docs/adr/012-postgresql-choice.md", sections: ["Status: accepted", "Context", "Decision", "Consequences", "Alternatives considered"] }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["ADR", "architecture decision", "design decision", "decision record", "why did we", "tech choice doc", "decision log"],
+        workflow: "Gather context about the decision from code and existing docs, apply the ADR template, and generate a structured record with context, decision rationale, trade-offs, and consequences.",
+    },
+    {
+        toolName: "doc_gen_diagrams",
+        domain: "docs",
+        intents: ["generate architecture diagrams", "create sequence diagrams", "draw component diagrams", "visualize system design"],
+        capabilities: ["Mermaid generation", "PlantUML generation", "architecture diagram extraction", "sequence diagram from code flow"],
+        requires: ["LLM access", "knowledge graph"],
+        inputExample: "Generate an architecture diagram for the microservices setup",
+        outputExample: '{ diagrams: [{ type: "C4 Container", mermaidCode: "graph TD\\n  Gateway --> Auth\\n  Gateway --> Orders", outputFile: "docs/diagrams/architecture.md" }] }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["diagram", "architecture diagram", "sequence diagram", "C4", "Mermaid", "UML", "visualize architecture"],
+        workflow: "Analyze the system's architecture from code structure and configs, generate appropriate diagram types (C4, sequence, class), and output as Mermaid or PlantUML markdown.",
+    },
+    {
+        toolName: "doc_check_links",
+        domain: "docs",
+        intents: ["check documentation links", "find broken links", "validate internal references", "verify external URLs"],
+        capabilities: ["link extraction", "dead link detection", "relative path resolution", "external URL validation"],
+        requires: ["file system access", "HTTP client"],
+        inputExample: "Check all documentation for broken links",
+        outputExample: '{ totalLinks: 234, broken: 7, redirected: 3, results: [{ file: "docs/guide.md:42", link: "./old-setup.md", issue: "File not found" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["broken links", "check links", "dead links", "validate links", "link check", "documentation links", "verify URLs"],
+        workflow: "Parse all markdown files for hyperlinks, resolve relative paths to check existence, HEAD-request external URLs, and report all broken or redirected links.",
+    },
+    {
+        toolName: "doc_check_coverage",
+        domain: "docs",
+        intents: ["check documentation coverage", "find undocumented code", "assess doc completeness", "audit JSDoc presence"],
+        capabilities: ["JSDoc coverage analysis", "undocumented export detection", "coverage scoring", "prioritized doc queue"],
+        requires: ["AST parser", "codebase index"],
+        inputExample: "Check which exported functions are missing documentation",
+        outputExample: '{ overallCoverage: 0.64, undocumentedExports: 143, priorityList: [{ symbol: "processPayment", file: "src/billing/processor.ts:42", impact: "critical" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["doc coverage", "undocumented", "JSDoc coverage", "missing docs", "documentation gap", "docs needed"],
+        workflow: "Enumerate all exported symbols, check for JSDoc/TSDoc presence, compute coverage ratios per module, and prioritize undocumented public APIs by usage frequency.",
+    },
+    {
+        toolName: "api_client",
+        domain: "docs",
+        intents: ["generate API client", "create SDK", "build typed HTTP client", "generate fetch wrappers"],
+        capabilities: ["client code generation", "type-safe request/response", "error handling boilerplate", "multi-language output"],
+        requires: ["API schema", "LLM access"],
+        inputExample: "Generate a TypeScript API client for the REST API",
+        outputExample: '{ generatedFiles: ["src/api-client/index.ts", "src/api-client/users.ts", "src/api-client/orders.ts"], languages: ["typescript"], totalEndpoints: 24 }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["API client", "generate client", "SDK", "typed client", "HTTP client", "fetch wrapper", "API wrapper"],
+        workflow: "Parse the API schema (OpenAPI or route definitions), generate type-safe request functions with proper error handling, and output as a consumable client library.",
+    },
+    {
+        toolName: "db_diagram",
+        domain: "database",
+        intents: ["generate database diagram", "visualize schema", "create ERD", "show table relationships"],
+        capabilities: ["ERD generation", "schema introspection", "relationship mapping", "Mermaid/PlantUML output"],
+        requires: ["database connection", "schema access"],
+        inputExample: "Generate an ERD diagram from the current database schema",
+        outputExample: '{ mermaidCode: "erDiagram\\n  USER ||--o{ ORDER : places\\n  ORDER ||--|{ ORDER_ITEM : contains", tables: 12, relationships: 18 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["ERD", "database diagram", "schema diagram", "table relationships", "DB diagram", "visualize schema", "entity relationship"],
+        workflow: "Introspect the database schema to discover tables, columns, and foreign keys, then generate an entity-relationship diagram in Mermaid or PlantUML format.",
+    },
+    {
+        toolName: "db_migration",
+        domain: "database",
+        intents: ["generate database migration", "create schema change script", "write migration file", "produce up/down migration"],
+        capabilities: ["migration generation", "schema diffing", "up/down script generation", "rollback support"],
+        requires: ["database connection", "LLM access"],
+        inputExample: "Generate a migration to add an email_verified column to the users table",
+        outputExample: '{ migrationFile: "migrations/20260501_add_email_verified.ts", up: "ALTER TABLE users ADD COLUMN email_verified BOOLEAN DEFAULT FALSE", down: "ALTER TABLE users DROP COLUMN email_verified" }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "low",
+        triggers: ["migration", "schema change", "alter table", "add column", "DB migration", "up/down", "database change"],
+        workflow: "Compare the desired schema against the current state, generate a reversible migration script with up and down logic, and validate against common migration pitfalls.",
+    },
+    {
+        toolName: "db_index_suggest",
+        domain: "database",
+        intents: ["suggest database indexes", "recommend index improvements", "analyze query performance", "find missing indexes"],
+        capabilities: ["query analysis", "index recommendation", "covering index detection", "performance impact estimation"],
+        requires: ["database connection", "query logs"],
+        inputExample: "Analyze slow queries and suggest missing indexes",
+        outputExample: '{ suggestions: [{ table: "orders", columns: ["user_id", "created_at"], type: "btree", estimatedImprovement: "12x faster", slowQuery: "SELECT * FROM orders WHERE user_id = ? ORDER BY created_at" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["index", "slow query", "query performance", "missing index", "DB optimization", "index suggestion", "database tuning"],
+        workflow: "Analyze slow query logs, identify table scans and missing indexes, and generate index creation suggestions with estimated performance improvements.",
+    },
+    {
+        toolName: "ci_workflow",
+        domain: "devops",
+        intents: ["generate CI workflow", "create GitHub Actions", "setup CI pipeline", "configure automated builds"],
+        capabilities: ["CI template generation", "platform-adaptive workflows", "matrix build generation", "caching strategies"],
+        requires: ["project configuration"],
+        inputExample: "Set up a CI workflow for this TypeScript monorepo",
+        outputExample: '{ generatedFiles: [".github/workflows/ci.yml"], jobs: ["lint", "typecheck", "test", "build"], platforms: ["ubuntu-latest"] }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "low",
+        triggers: ["CI", "GitHub Actions", "pipeline", "workflow", "automated build", "CI/CD setup", "GitLab CI"],
+        workflow: "Detect project type, test framework, and deployment targets, then generate a tailored CI workflow with appropriate jobs, caching strategies, and matrix builds.",
+    },
+    {
+        toolName: "ci_diagnose",
+        domain: "devops",
+        intents: ["diagnose CI failures", "debug pipeline errors", "analyze build failures", "troubleshoot CI issues"],
+        capabilities: ["CI log analysis", "failure pattern recognition", "root cause identification", "fix recommendation"],
+        requires: ["CI log access", "LLM access"],
+        inputExample: "Diagnose why the test job is failing in CI",
+        outputExample: '{ rootCause: "Node version mismatch: CI uses 18.x but project needs 20.x for String.replaceAll polyfill", fix: "Update .nvmrc and CI matrix to use node 20.x" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["CI failure", "pipeline broken", "build fail", "CI error", "workflow failed", "GitHub Actions error", "deploy failed"],
+        workflow: "Parse CI logs to extract error messages and stack traces, correlate with known failure patterns, and produce a root cause diagnosis with a concrete fix recommendation.",
+    },
+    {
+        toolName: "docker_optimize",
+        domain: "devops",
+        intents: ["optimize Dockerfile", "reduce image size", "improve build caching", "harden container"],
+        capabilities: ["layer optimization", "multi-stage build suggestion", "cache analysis", "security hardening"],
+        requires: ["LLM access"],
+        inputExample: "Optimize the Dockerfile for the API service to reduce image size",
+        outputExample: '{ changes: [{ file: "Dockerfile", suggestion: "Use multi-stage build to exclude devDependencies", estimatedSizeReduction: "340MB -> 95MB" }], totalReduction: "72%" }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["Docker", "container", "Dockerfile", "image size", "optimize container", "docker build", "layer caching"],
+        workflow: "Analyze the Dockerfile for optimization opportunities, reorder layers for better caching, suggest multi-stage builds, and identify unnecessary dependencies to trim image size.",
+    },
+    {
+        toolName: "env_generate",
+        domain: "devops",
+        intents: ["generate .env file", "create environment template", "build env.example", "document required variables"],
+        capabilities: ["env variable discovery", "template generation", "default value suggestion", "secret detection"],
+        requires: ["codebase index"],
+        inputExample: "Generate an .env.example file from the codebase",
+        outputExample: '{ generatedFile: ".env.example", variables: [{ key: "DATABASE_URL", defaultValue: "postgresql://localhost:5432/db", source: "src/config/database.ts:12" }], hasSecrets: true }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["env", "environment", ".env", "config template", "environment variables", "env.example", "secrets template"],
+        workflow: "Scan the codebase for process.env references and config files, extract all required environment variables with their source locations, and generate a documented .env.example template.",
+    },
+    {
+        toolName: "env_check",
+        domain: "devops",
+        intents: ["validate environment config", "check env variables", "verify required settings", "audit environment setup"],
+        capabilities: ["env diff checking", "missing variable detection", "type validation", "config drift detection"],
+        requires: ["file system access"],
+        inputExample: "Check if all required environment variables are set",
+        outputExample: '{ status: "incomplete", missing: ["SMTP_PASSWORD", "REDIS_URL"], invalid: [{ key: "PORT", value: "not-a-number", expected: "number" }], ok: 14 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["env check", "validate config", "check environment", "verify .env", "missing env", "config audit"],
+        workflow: "Compare the current .env file against the .env.example template, detect missing or differently typed variables, and report configuration drift or incompleteness.",
+    },
+    {
+        toolName: "deploy_check",
+        domain: "devops",
+        intents: ["run deployment readiness check", "pre-deploy validation", "verify deploy safety", "check production readiness"],
+        capabilities: ["pre-deploy checklist", "infrastructure validation", "rollback plan verification", "health check simulation"],
+        requires: ["CI/CD integration", "infrastructure access"],
+        inputExample: "Run deployment readiness checks before releasing to production",
+        outputExample: '{ ready: false, checks: [{ name: "Tests passing", status: "pass" }, { name: "Database backups recent", status: "fail", detail: "Last backup 48h ago" }], blockingIssues: 1 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["deploy check", "ready to deploy", "pre-deploy", "deployment readiness", "before release", "can I deploy", "go/no-go"],
+        workflow: "Execute a series of pre-deployment checks (tests passing, DB backups, migration safety, monitoring configured) and return a go/no-go decision with blocking issues highlighted.",
+    },
+    {
+        toolName: "k8s_manifests",
+        domain: "devops",
+        intents: ["generate Kubernetes manifests", "create K8s YAML", "write deployment config", "generate Helm charts"],
+        capabilities: ["K8s manifest generation", "Helm chart scaffolding", "resource sizing", "health probe configuration"],
+        requires: ["LLM access", "project configuration"],
+        inputExample: "Generate Kubernetes deployment manifests for the API service",
+        outputExample: '{ generatedFiles: ["k8s/deployment.yaml", "k8s/service.yaml", "k8s/configmap.yaml"], resources: { cpu: "500m", memory: "512Mi", replicas: 3 } }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["Kubernetes", "K8s", "deployment yaml", "Helm chart", "container orchestration", "kubectl", "pod config"],
+        workflow: "Generate production-ready Kubernetes manifests including Deployment, Service, ConfigMap, and health probes, with resource sizing based on the application's profile.",
+    },
+    {
+        toolName: "memory_save",
+        domain: "memory",
+        intents: ["save information to memory", "store context for later", "persist knowledge", "record important fact"],
+        capabilities: ["key-value persistence", "semantic indexing", "TTL management", "namespace isolation"],
+        requires: ["vector DB", "persistent storage"],
+        inputExample: "Remember that the project uses PostgreSQL with Prisma ORM",
+        outputExample: '{ saved: true, memoryId: "mem_abc123", namespace: "project-facts", ttl: null }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "low",
+        triggers: ["remember", "save", "store", "keep", "note this", "don't forget", "memorize", "retain"],
+        workflow: "Accept a fact or piece of context, generate an embedding, and persist it to the memory store with optional namespace and TTL for scoped retrieval.",
+    },
+    {
+        toolName: "memory_recall",
+        domain: "memory",
+        intents: ["recall saved information", "retrieve memory", "search past context", "remember stored facts"],
+        capabilities: ["semantic memory retrieval", "namespace-scoped search", "relevance ranking", "temporal filtering"],
+        requires: ["vector DB", "persistent storage"],
+        inputExample: "What do we know about the authentication system?",
+        outputExample: '{ memories: [{ content: "Auth uses JWT with RS256, stored in httpOnly cookies", savedAt: "2026-04-15T08:00:00Z", relevance: 0.93 }], totalMatches: 5 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["recall", "remember", "retrieve", "what do we know", "past context", "saved info", "look up memory", "recollect"],
+        workflow: "Convert the query to an embedding, search the memory store for semantically similar entries within the relevant namespace, and return ranked results.",
+    },
+    {
+        toolName: "memory_lessons",
+        domain: "memory",
+        intents: ["save lessons learned", "record project insights", "document gotchas", "capture troubleshooting knowledge"],
+        capabilities: ["lesson extraction", "issue-to-lesson mapping", "seasonal relevance tagging", "resolution tracking"],
+        requires: ["vector DB", "LLM access"],
+        inputExample: "Document the lesson learned from the production outage on May 1st",
+        outputExample: '{ lessonId: "les_def456", extractedInsights: ["Connection pool exhaustion under load spike"], relatedSystems: ["database", "connection pooling"], severity: "critical" }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "medium",
+        triggers: ["lesson learned", "gotcha", "troubleshooting knowledge", "post-mortem", "what we learned", "incident insight", "tribal knowledge"],
+        workflow: "Accept a description of a lesson learned, use LLM to extract structured insights and affected systems, and store for future recall during similar troubleshooting.",
+    },
+    {
+        toolName: "memory_patterns",
+        domain: "memory",
+        intents: ["detect recurring patterns in memory", "find repeated issues", "identify common solutions", "analyze memory trends"],
+        capabilities: ["temporal pattern detection", "issue clustering", "solution frequency analysis", "trend visualization"],
+        requires: ["vector DB", "LLM access"],
+        inputExample: "Are there recurring patterns in the bugs we've encountered?",
+        outputExample: '{ patterns: [{ description: "Null reference errors in form handlers", frequency: 14, trend: "increasing", suggestedFix: "Add zod validation at form boundaries" }] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["patterns", "recurring", "trend", "common issues", "repeated problems", "memory analysis", "frequent bugs"],
+        workflow: "Cluster saved memories by semantic similarity, detect temporal trends in issue frequency, and surface recurring patterns with suggested systemic fixes.",
+    },
+    {
+        toolName: "memory_context",
+        domain: "memory",
+        intents: ["load context from memory", "build situational awareness", "assemble working context", "prep conversation context"],
+        capabilities: ["context assembly", "relevance scoring", "pruning strategies", "token budget management"],
+        requires: ["vector DB", "LLM access"],
+        inputExample: "Load all relevant context about the billing module before working on it",
+        outputExample: '{ contextDocuments: [{ type: "lesson", content: "Billing rounding errors fixed in March by using decimal.js" }, { type: "fact", content: "Stripe webhooks need idempotency keys" }], tokenCount: 1200 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["context", "what's relevant", "what should I know", "background", "summarize history", "working context", "situational"],
+        workflow: "Query memory across all relevant namespaces for the current task, assemble a context packet within token budget, and present situational awareness for the next operation.",
+    },
+    {
+        toolName: "pm_breakdown",
+        domain: "planning",
+        intents: ["break down task", "decompose feature", "create subtasks", "split work into steps"],
+        capabilities: ["task decomposition", "dependency ordering", "effort estimation", "deliverable definition"],
+        requires: ["LLM access"],
+        inputExample: "Break down the user authentication feature into implementable tasks",
+        outputExample: '{ tasks: [{ id: "1", title: "Design DB schema for users", effort: "S", dependsOn: [] }, { id: "2", title: "Implement password hashing", effort: "S", dependsOn: ["1"] }], totalEffort: "M" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["break down", "decompose", "split into tasks", "subtasks", "task breakdown", "steps for", "plan this"],
+        workflow: "Accept a high-level feature description, decompose it into ordered, dependency-aware subtasks with effort estimates, and output a structured task hierarchy.",
+    },
+    {
+        toolName: "pm_estimate",
+        domain: "planning",
+        intents: ["estimate task effort", "size work items", "forecast delivery", "calculate story points"],
+        capabilities: ["effort estimation", "complexity scoring", "uncertainty quantification", "historical calibration"],
+        requires: ["LLM access", "historical data"],
+        inputExample: "Estimate the effort for implementing the search indexing pipeline",
+        outputExample: '{ estimate: { bestCase: "5 days", worstCase: "12 days", expected: "8 days", confidence: 0.7, assumptions: ["AST parser library stable"] } }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["estimate", "how long", "effort", "story points", "sizing", "how many days", "forecast", "timeline"],
+        workflow: "Analyze the task description against historical completion data, apply estimation heuristics, and produce a three-point estimate with confidence level and explicit assumptions.",
+    },
+    {
+        toolName: "pm_risks",
+        domain: "planning",
+        intents: ["identify project risks", "assess risk exposure", "create risk register", "plan mitigations"],
+        capabilities: ["risk identification", "probability/impact scoring", "mitigation planning", "risk heatmap generation"],
+        requires: ["LLM access"],
+        inputExample: "Identify risks for the payment integration project",
+        outputExample: '{ risks: [{ id: "R1", description: "Third-party API rate limits may block peak traffic", probability: "medium", impact: "high", mitigation: "Implement local queue with retry" }], riskScore: 42 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["risks", "risk assessment", "what could go wrong", "risk register", "mitigation", "project risk", "risk analysis"],
+        workflow: "Analyze the project scope and constraints, identify potential risks across technical, schedule, and resource dimensions, score probability and impact, and propose mitigations.",
+    },
+    {
+        toolName: "pm_deps",
+        domain: "planning",
+        intents: ["map task dependencies", "create dependency graph", "find blockers", "analyze task ordering"],
+        capabilities: ["dependency mapping", "critical path analysis", "blocker detection", "schedule optimization"],
+        requires: ["LLM access"],
+        inputExample: "Map the dependencies between all tasks in the onboarding project",
+        outputExample: '{ criticalPath: ["T1", "T4", "T7", "T9"], totalDuration: "14 days", blockers: [{ task: "T7", blockedBy: "External API docs not yet published" }], parallelizable: ["T2", "T3"] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["dependencies", "depends on", "blockers", "critical path", "task order", "what blocks what", "dependency graph"],
+        workflow: "Build a directed graph of tasks and their dependencies, compute the critical path and float, and identify external blockers that may delay delivery.",
+    },
+    {
+        toolName: "pm_progress",
+        domain: "planning",
+        intents: ["track project progress", "generate status report", "measure completion", "update stakeholders"],
+        capabilities: ["progress tracking", "burndown chart generation", "status report assembly", "variance analysis"],
+        requires: ["task board integration"],
+        inputExample: "Generate a progress report for the current sprint",
+        outputExample: '{ sprintProgress: 0.72, completed: 18, remaining: 7, atRisk: [{ task: "Payment integration", reason: "Behind schedule by 3 days" }], burndown: "on-track" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["progress", "status", "how far along", "sprint report", "completion", "update", "where are we"],
+        workflow: "Query the task management system for current completion status, compute velocity and burndown metrics, and generate a structured progress report with at-risk items.",
+    },
+    {
+        toolName: "analyze_project",
+        domain: "workspace",
+        intents: ["analyze project structure", "understand repository layout", "inspect codebase organization", "map project topology"],
+        capabilities: ["file tree analysis", "dependency mapping", "framework detection", "project type identification"],
+        requires: ["file system access"],
+        inputExample: "Analyze the current project structure and identify the tech stack",
+        outputExample: '{ type: "TypeScript monorepo", framework: "NestJS + React", packageManager: "pnpm", monorepoTool: "Nx", totalPackages: 15, services: 3, frontends: 2 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["analyze project", "project structure", "what is this", "repo overview", "tech stack", "layout", "monorepo analysis"],
+        workflow: "Scan the repository root and key config files to detect the project type, frameworks, package manager, and organizational structure, returning a concise topology summary.",
+    },
+    {
+        toolName: "batch_write_files",
+        domain: "workspace",
+        intents: ["write multiple files at once", "batch create files", "scaffold project structure", "create many files simultaneously"],
+        capabilities: ["atomic file writes", "parallel file creation", "directory auto-creation", "validation before write"],
+        requires: ["file system access"],
+        inputExample: "Create the following files: src/index.ts, src/types.ts, src/utils.ts",
+        outputExample: '{ created: 3, failed: 0, files: ["src/index.ts", "src/types.ts", "src/utils.ts"] }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["create multiple files", "batch write", "scaffold", "write all", "create files", "generate files", "batch create"],
+        workflow: "Accept an array of file paths with contents, validate each before writing, create necessary directories, and write all files in a single operation with rollback on failure.",
+    },
+    {
+        toolName: "browser",
+        domain: "workspace",
+        intents: ["browse web", "open URL", "navigate to page", "web automation"],
+        capabilities: ["page navigation", "DOM interaction", "screenshot capture", "JavaScript evaluation"],
+        requires: ["headless browser", "playwright/puppeteer"],
+        inputExample: "Open https://example.com and take a screenshot",
+        outputExample: '{ url: "https://example.com", title: "Example Domain", screenshotPath: "/tmp/screenshot-20260501.png", statusCode: 200 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["browse", "open URL", "go to", "navigate", "web page", "screenshot", "visit"],
+        workflow: "Launch a headless browser instance, navigate to the URL, optionally interact with the page, and return the rendered content or screenshot.",
+    },
+    {
+        toolName: "codebase_research",
+        domain: "workspace",
+        intents: ["research codebase question", "investigate code patterns", "explore implementation details", "deep-dive into code"],
+        capabilities: ["multi-step code exploration", "hypothesis-driven search", "evidence collection", "structured findings report"],
+        requires: ["codebase index", "LLM access"],
+        inputExample: "Research how error handling is implemented across all API routes",
+        outputExample: '{ findings: { approaches: ["global exception filter (73% of routes)", "try-catch per route (22%)", "none (5%)"], inconsistency: "moderate", recommendation: "Standardize on exception filter" } }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "high",
+        triggers: ["research", "investigate", "deep dive", "explore codebase", "how is X done", "codebase research", "study"],
+        workflow: "Formulate a research plan from the question, execute multi-step searches across the codebase, collect evidence, and synthesize findings into a structured report.",
+    },
+    {
+        toolName: "docker",
+        domain: "workspace",
+        intents: ["run docker commands", "manage containers", "build images", "orchestrate compose services"],
+        capabilities: ["container lifecycle", "image building", "compose orchestration", "log streaming"],
+        requires: ["Docker daemon"],
+        inputExample: "Build and start the development containers",
+        outputExample: '{ command: "docker compose up -d", status: "success", containers: [{ name: "api-dev", status: "running", port: 3000 }] }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["docker", "container", "compose", "docker build", "docker run", "containerize"],
+        workflow: "Execute the specified Docker or Docker Compose command, monitor container startup, and return status with port mappings and log tails.",
+    },
+    {
+        toolName: "edit_file",
+        domain: "workspace",
+        intents: ["edit source file", "modify code", "update file content", "apply code change"],
+        capabilities: ["safe file editing", "diff-based modifications", "syntax validation", "undo support"],
+        requires: ["file system access"],
+        inputExample: "Edit src/auth/login.ts to add rate limiting",
+        outputExample: '{ filePath: "src/auth/login.ts", changed: true, diff: "+  if (attempts > 5) throw new RateLimitError()", backupCreated: true }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["edit", "modify", "change", "update file", "patch", "fix code", "implement"],
+        workflow: "Apply the specified edit to the target file using diff-based patching, validate syntax post-edit, create a backup, and return the applied changes.",
+    },
+    {
+        toolName: "find_files",
+        domain: "workspace",
+        intents: ["find files by pattern", "search for filename", "glob search", "locate file by name"],
+        capabilities: ["glob pattern matching", "recursive directory search", "ignore pattern support", "filtered results"],
+        requires: ["file system access"],
+        inputExample: "Find all TypeScript files containing 'service' in the name",
+        outputExample: '{ matches: ["src/services/AuthService.ts", "src/services/UserService.ts", "src/services/PaymentService.ts"], totalCount: 3 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["find files", "locate file", "search filename", "glob", "where is file", "file pattern", "which file"],
+        workflow: "Execute a glob pattern match across the project directory tree, respecting .gitignore patterns, and return matching file paths sorted by modification time.",
+    },
+    {
+        toolName: "get_task",
+        domain: "workspace",
+        intents: ["get task details", "view task information", "fetch work item", "load task by ID"],
+        capabilities: ["task retrieval", "full detail expansion", "subtask enumeration", "status history"],
+        requires: ["task management system"],
+        inputExample: "Show details for task TASK-42",
+        outputExample: '{ id: "TASK-42", title: "Implement JWT refresh", status: "in-progress", assignee: "dev-1", subtasks: [...], linkedPRs: ["#231"] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["get task", "task details", "show task", "view task", "fetch task", "load task"],
+        workflow: "Query the task management system by task ID, retrieve full details including subtasks, linked code changes, and status history, and return a structured representation.",
+    },
+    {
+        toolName: "git",
+        domain: "workspace",
+        intents: ["run git commands", "manage version control", "commit changes", "view git history"],
+        capabilities: ["branch management", "commit creation", "diff viewing", "merge/conflict handling"],
+        requires: ["git CLI"],
+        inputExample: "Show the git diff for the current branch",
+        outputExample: '{ command: "git diff", output: "diff --git a/src/index.ts b/src/index.ts\\n+console.log(\'...\')", branch: "feat/rate-limit" }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["git", "commit", "branch", "merge", "diff", "pull", "push", "stash", "log"],
+        workflow: "Execute the specified git command, capture output, handle authentication, and return structured results including branch state and any conflicts detected.",
+    },
+    {
+        toolName: "grep",
+        domain: "workspace",
+        intents: ["search file contents", "find text patterns", "regex search code", "locate string in files"],
+        capabilities: ["regex pattern matching", "multi-file search", "context line output", "file type filtering"],
+        requires: ["file system access"],
+        inputExample: "Search for all uses of 'useState' in .tsx files",
+        outputExample: '{ pattern: "useState", matches: [{ file: "src/components/App.tsx", line: 12, content: "const [count, setCount] = useState(0)" }], totalMatches: 47 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["grep", "search for", "find in files", "regex", "text search", "pattern match", "search content"],
+        workflow: "Execute a regex search across the specified file set, return matching lines with surrounding context, file paths, and line numbers.",
+    },
+    {
+        toolName: "http_request",
+        domain: "workspace",
+        intents: ["make HTTP request", "call API endpoint", "test REST endpoint", "fetch URL"],
+        capabilities: ["full HTTP method support", "header customization", "body serialization", "response parsing"],
+        requires: ["outbound network access"],
+        inputExample: "POST to https://api.example.com/users with JSON body",
+        outputExample: '{ status: 201, headers: { "content-type": "application/json" }, body: { id: "user_123", created: true } }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["HTTP", "fetch", "API call", "curl", "request", "POST", "GET endpoint", "call API"],
+        workflow: "Execute the specified HTTP request with configurable method, headers, and body, capture and parse the response, and return status, headers, and body.",
+    },
+    {
+        toolName: "knowledge",
+        domain: "workspace",
+        intents: ["query knowledge base", "search documentation", "retrieve reference info", "look up concept"],
+        capabilities: ["RAG retrieval", "document chunk search", "source attribution", "concept linking"],
+        requires: ["vector DB", "documentation index"],
+        inputExample: "How do I configure the rate limiter in this project?",
+        outputExample: '{ answer: "Set RATE_LIMIT_MAX and RATE_LIMIT_WINDOW_MS env vars. See src/config/rate-limiter.ts.", sources: ["docs/configuration.md", "src/config/rate-limiter.ts:12"] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["knowledge", "documentation", "how to", "reference", "look up", "wiki", "docs search"],
+        workflow: "Perform RAG retrieval against the project's knowledge base, return the most relevant document chunks with source attribution and a synthesized answer.",
+    },
+    {
+        toolName: "list_dir",
+        domain: "workspace",
+        intents: ["list directory contents", "view folder structure", "browse file system", "inspect directory"],
+        capabilities: ["directory enumeration", "file metadata display", "recursive listing", "filtering and sorting"],
+        requires: ["file system access"],
+        inputExample: "List the contents of the src/components directory",
+        outputExample: '{ path: "src/components", entries: [{ name: "Header.tsx", type: "file", size: 2048 }, { name: "icons/", type: "directory" }], totalCount: 14 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["list", "ls", "directory", "folder contents", "show dir", "browse", "what's in"],
+        workflow: "Enumerate the contents of the specified directory, returning each entry's name, type, size, and modification time, with optional recursive depth.",
+    },
+    {
+        toolName: "list_tasks",
+        domain: "workspace",
+        intents: ["list project tasks", "view task board", "show work items", "enumerate open tasks"],
+        capabilities: ["task board querying", "filtering by status/assignee", "priority sorting", "pagination"],
+        requires: ["task management system"],
+        inputExample: "List all open tasks assigned to me in the current sprint",
+        outputExample: '{ tasks: [{ id: "TASK-42", title: "Implement JWT refresh", priority: "high" }, { id: "TASK-43", title: "Update API docs", priority: "low" }], totalCount: 2 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["list tasks", "show tasks", "my tasks", "task board", "open tasks", "sprint tasks", "what's assigned"],
+        workflow: "Query the task management system with optional filters (status, assignee, sprint), sort by priority or due date, and return a paginated list of matching work items.",
+    },
+    {
+        toolName: "multi_file_patch",
+        domain: "workspace",
+        intents: ["apply patch across multiple files", "batch code modifications", "multi-file edit", "bulk apply changes"],
+        capabilities: ["unified diff parsing", "multi-file patch application", "conflict detection", "atomic rollback"],
+        requires: ["file system access"],
+        inputExample: "Apply this patch that updates types across 5 files",
+        outputExample: '{ applied: 5, failed: 0, filesModified: ["src/types/user.ts", "src/services/user.ts", "src/controllers/user.ts"], snapshotCreated: true }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["multi-file patch", "batch edit", "apply patch", "bulk change", "patch multiple", "across files"],
+        workflow: "Parse a unified diff containing changes to multiple files, validate each hunk against current file state, apply changes atomically, and roll back on any conflict.",
+    },
+    {
+        toolName: "patch_file",
+        domain: "workspace",
+        intents: ["apply patch to file", "patch single file", "apply diff hunk", "surgically edit file"],
+        capabilities: ["unified diff application", "hunk matching", "offset adjustment", "rejection reporting"],
+        requires: ["file system access"],
+        inputExample: "Apply this diff to src/utils/helpers.ts",
+        outputExample: '{ filePath: "src/utils/helpers.ts", hunksApplied: 2, hunksFailed: 0, changes: "+12 lines, -3 lines" }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["patch", "apply diff", "apply hunk", "patch file", "surgical edit"],
+        workflow: "Parse a unified diff, locate matching hunks in the target file with fuzzy offset adjustment, apply the changes, and report which hunks were applied or rejected.",
+    },
+    {
+        toolName: "pipeline_run",
+        domain: "workspace",
+        intents: ["run CI pipeline", "trigger workflow", "execute build pipeline", "start automated job"],
+        capabilities: ["pipeline triggering", "parameter pass-through", "status polling", "log streaming"],
+        requires: ["CI/CD integration"],
+        inputExample: "Run the deploy pipeline for staging environment",
+        outputExample: '{ pipelineId: "run-4829", status: "started", url: "https://ci.example.com/runs/4829", estimatedDuration: "8m" }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["run pipeline", "trigger CI", "execute workflow", "start build", "run deploy", "trigger job"],
+        workflow: "Trigger the specified CI/CD pipeline with optional parameters, return a run identifier and tracking URL, and optionally poll for completion status.",
+    },
+    {
+        toolName: "plan",
+        domain: "workspace",
+        intents: ["create execution plan", "devise strategy", "plan approach", "outline solution steps"],
+        capabilities: ["task sequencing", "risk-aware planning", "resource estimation", "milestone definition"],
+        requires: ["LLM access"],
+        inputExample: "Create a plan for migrating the database from MySQL to PostgreSQL",
+        outputExample: '{ phases: [{ name: "Schema migration", steps: 4, duration: "2 days" }, { name: "Data transfer", steps: 3, duration: "1 day" }], totalDuration: "5 days", risks: 3 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["plan", "strategy", "approach", "how should I", "steps to", "roadmap", "execution plan"],
+        workflow: "Analyze the objective, decompose it into sequential phases with clear milestones, identify risks and dependencies, and output a structured execution plan.",
+    },
+    {
+        toolName: "process_manager",
+        domain: "workspace",
+        intents: ["manage running processes", "spawn background tasks", "monitor subprocesses", "kill/restart processes"],
+        capabilities: ["process spawning", "stdout/stderr streaming", "signal handling", "process lifecycle management"],
+        requires: ["OS process management"],
+        inputExample: "Start the development server in the background and stream logs",
+        outputExample: '{ pid: 28491, command: "npm run dev", status: "running", port: 3000, logStreamId: "stream_abc" }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["spawn", "background process", "run in background", "start server", "process manager", "daemon"],
+        workflow: "Spawn a subprocess with the specified command, capture stdout and stderr streams, and provide lifecycle management (status check, signal, terminate).",
+    },
+    {
+        toolName: "project_context",
+        domain: "workspace",
+        intents: ["load project context", "get situational awareness", "gather project metadata", "assemble working context"],
+        capabilities: ["context aggregation", "conversation history parsing", "relevant file detection", "token budget management"],
+        requires: ["codebase index", "conversation history"],
+        inputExample: "Load full project context before starting work",
+        outputExample: '{ projectType: "NestJS monorepo", recentFiles: ["src/auth/login.ts"], activeBranch: "feat/rate-limit", relevantDocs: ["ARCHITECTURE.md"] }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "medium",
+        triggers: ["context", "project context", "what's going on", "current state", "situational awareness", "catch me up"],
+        workflow: "Aggregate project metadata, recent file changes, active conversation context, and relevant documentation into a focused context packet for the next operation.",
+    },
+    {
+        toolName: "project_scanner",
+        domain: "workspace",
+        intents: ["scan project", "inspect repository", "audit project files", "crawl codebase structure"],
+        capabilities: ["recursive file scanning", "tech stack detection", "config file parsing", "anomaly detection"],
+        requires: ["file system access"],
+        inputExample: "Scan the project and report its structure and configuration",
+        outputExample: '{ packageJson: true, tsconfig: true, eslintConfig: "eslint.config.mjs", framework: "NestJS", linterConfigured: true, formatter: "prettier" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["scan project", "inspect repo", "project scan", "audit files", "what's configured", "detect stack"],
+        workflow: "Recursively walk the project tree, parse key configuration files, detect frameworks and tools, and return a comprehensive project configuration summary.",
+    },
+    {
+        toolName: "read_file",
+        domain: "workspace",
+        intents: ["read file contents", "view source code", "open file", "inspect file"],
+        capabilities: ["file reading", "encoding detection", "offset/limit reading", "large file handling"],
+        requires: ["file system access"],
+        inputExample: "Read the contents of src/auth/login.ts",
+        outputExample: '{ filePath: "src/auth/login.ts", lines: 142, content: "import { ... }\\n\\nexport async function login(...", encoding: "utf-8" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["read", "open", "view", "show file", "cat", "inspect", "look at"],
+        workflow: "Read the specified file with potential offset and line limit, detect encoding, and return the file contents with metadata.",
+    },
+    {
+        toolName: "run_tsc",
+        domain: "workspace",
+        intents: ["run TypeScript compiler", "check types", "type-check project", "validate TypeScript code"],
+        capabilities: ["type checking", "error reporting", "project reference resolution", "incremental compilation"],
+        requires: ["TypeScript compiler", "tsconfig.json"],
+        inputExample: "Run type checking on the entire project",
+        outputExample: '{ success: false, errors: [{ file: "src/utils.ts:42", message: "Type \'string\' is not assignable to type \'number\'" }], totalErrors: 3, durationMs: 4200 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["typecheck", "tsc", "TypeScript check", "run tsc", "type errors", "check types", "compile check"],
+        workflow: "Execute the TypeScript compiler in noEmit mode, capture type errors, and return a structured error report with file locations and messages.",
+    },
+    {
+        toolName: "safe_edit_policy",
+        domain: "workspace",
+        intents: ["enforce safe editing rules", "validate edit constraints", "check edit preconditions", "apply editing guardrails"],
+        capabilities: ["edit policy enforcement", "pre-edit validation", "post-edit verification", "destructive operation guarding"],
+        requires: ["workspace configuration"],
+        inputExample: "Check if this edit is allowed by the project's safety policy",
+        outputExample: '{ allowed: true, warnings: ["Editing a file with 23 dependents, changes may cascade"], requiresConfirmation: false }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["safe edit", "edit policy", "is this safe", "guardrails", "edit validation", "safety check"],
+        workflow: "Evaluate the proposed edit against configured safety policies (destructive operations, critical files, dependent count), and return allow/deny with warnings.",
+    },
+    {
+        toolName: "search_codebase",
+        domain: "workspace",
+        intents: ["search codebase contents", "find code by keyword", "locate implementation", "text search in source"],
+        capabilities: ["full-text search", "regex matching", "file type filtering", "result ranking"],
+        requires: ["codebase index", "file system access"],
+        inputExample: "Search for all error handling patterns in the codebase",
+        outputExample: '{ query: "catch \\(.*error\\)", matches: [{ file: "src/api/handler.ts:234", snippet: "catch (error) { logger.error(error)" }], totalMatches: 156 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["search codebase", "find in project", "look for", "search all files", "where in code", "find implementation"],
+        workflow: "Execute a full-text or regex search across the indexed codebase, rank results by relevance, and return matching snippets with file paths and line numbers.",
+    },
+    {
+        toolName: "store",
+        domain: "workspace",
+        intents: ["persist data", "save to storage", "store key-value pair", "cache data"],
+        capabilities: ["key-value storage", "TTL support", "serialization", "namespace partitioning"],
+        requires: ["persistent storage backend"],
+        inputExample: "Store the API response cache for the users endpoint",
+        outputExample: '{ stored: true, key: "cache:api:users:list", namespace: "http-cache", ttl: 300 }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["store", "save", "cache", "persist", "put", "set key", "write cache"],
+        workflow: "Serialize and persist a value under the given key in the specified namespace, with optional TTL for automatic expiration.",
+    },
+    {
+        toolName: "terminal_run",
+        domain: "workspace",
+        intents: ["execute terminal command", "run shell script", "invoke CLI tool", "execute system command"],
+        capabilities: ["command execution", "stdout/stderr capture", "timeout enforcement", "shell interpretation"],
+        requires: ["shell access"],
+        inputExample: "Run npm install in the project root",
+        outputExample: '{ exitCode: 0, stdout: "added 247 packages in 12s", stderr: "", durationMs: 12500 }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["run", "execute", "terminal", "shell", "command", "bash", "cli", "npm", "yarn", "pnpm"],
+        workflow: "Execute the specified command in a shell, capture stdout and stderr, enforce a timeout, and return exit code with output streams.",
+    },
+    {
+        toolName: "vision_browser",
+        domain: "workspace",
+        intents: ["browse with visual analysis", "take and analyze screenshots", "visually inspect page", "OCR from screenshots"],
+        capabilities: ["page rendering", "screenshot capture", "vision model analysis", "element detection from image"],
+        requires: ["headless browser", "vision LLM"],
+        inputExample: "Visit the login page and describe what you see visually",
+        outputExample: '{ url: "https://app.example.com/login", visualDescription: "Page has a centered card with email and password fields, a blue \'Sign In\' button, and a \'Forgot password?\' link", elementsDetected: 8 }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "high",
+        triggers: ["vision", "screenshot analyze", "visual inspect", "see page", "look at UI", "OCR", "image analysis"],
+        workflow: "Navigate to the URL with a headless browser, capture a screenshot, analyze it with a vision-capable LLM, and return a natural language description of the visual content.",
+    },
+    {
+        toolName: "write_file",
+        domain: "workspace",
+        intents: ["write new file", "create file", "save content to file", "generate new source file"],
+        capabilities: ["file creation", "directory auto-creation", "encoding specification", "overwrite protection"],
+        requires: ["file system access"],
+        inputExample: "Create src/services/NotificationService.ts with the provided content",
+        outputExample: '{ filePath: "src/services/NotificationService.ts", written: true, size: 2048, backupCreated: false }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "none",
+        triggers: ["write", "create", "new file", "generate file", "save as", "scaffold file"],
+        workflow: "Create a new file at the specified path (with auto-created directories), write the content with proper encoding, and return confirmation with file metadata.",
+    },
+    {
+        toolName: "subagent_conversation",
+        domain: "subagent",
+        intents: ["delegate conversation to subagent", "offload complex discussion", "run parallel agent conversation", "spawn conversational assistant"],
+        capabilities: ["subagent spawning", "context isolation", "parallel execution", "result aggregation"],
+        requires: ["LLM access", "agent runtime", "tool registry"],
+        inputExample: "Have a subagent discuss the database schema changes with me",
+        outputExample: '{ subagentId: "sub_abc123", status: "running", contextSummary: "Discussing migration strategy for users table" }',
+        isDestructive: false,
+        isReadOnly: false,
+        llmCostEstimate: "high",
+        triggers: ["subagent", "delegate", "offload", "parallel agent", "spawn agent", "conversation agent", "assistant agent"],
+        workflow: "Spawn a subagent with an isolated context window, provide the task description, and manage its conversation loop until completion or handoff.",
+    },
+    {
+        toolName: "subagent_job",
+        domain: "subagent",
+        intents: ["delegate background job to subagent", "offload long-running task", "run async agent task", "spawn job worker"],
+        capabilities: ["background job execution", "progress reporting", "result persistence", "timeout management"],
+        requires: ["LLM access", "agent runtime", "job queue"],
+        inputExample: "Have a subagent run the database migration in the background",
+        outputExample: '{ jobId: "job_def456", status: "queued", estimatedCompletion: "2026-05-01T14:30:00Z", pollingUrl: "/jobs/def456/status" }',
+        isDestructive: true,
+        isReadOnly: false,
+        llmCostEstimate: "high",
+        triggers: ["background job", "async task", "subagent job", "offload task", "run in background", "job worker", "delegate task"],
+        workflow: "Enqueue a background job for a subagent, provide the task specification and tool access, and return a job ID for polling status and retrieving results.",
+    },
+    {
+        toolName: "tool_name",
+        domain: "infra",
+        intents: ["resolve tool by name", "get tool metadata", "discover tool attributes", "introspect tool capabilities"],
+        capabilities: ["tool registration lookup", "schema retrieval", "capability matching", "tool discovery"],
+        requires: ["tool registry"],
+        inputExample: "Get metadata for the codebase_search tool",
+        outputExample: '{ toolName: "codebase_search", domain: "codebase", intents: ["search codebase semantically", ...], isReadOnly: true }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "none",
+        triggers: ["tool info", "tool metadata", "what does tool do", "tool schema", "tool capability", "describe tool"],
+        workflow: "Look up the tool in the registry by name, return its full capability metadata including domain, intents, requirements, and input/output schemas.",
+    },
+    {
+        toolName: "conversation_history",
+        domain: "infra",
+        intents: ["retrieve conversation history", "summarize past messages", "recall previous context", "search message log"],
+        capabilities: ["message retrieval", "semantic search over history", "summarization", "temporal filtering"],
+        requires: ["conversation store"],
+        inputExample: "Summarize the last 50 messages about the authentication feature",
+        outputExample: '{ summary: "Discussed JWT implementation, decided on RS256, created migration, resolved cookie domain issue", messageCount: 50, timespan: "last 2 hours" }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["history", "conversation history", "past messages", "what did we discuss", "recap", "previous context", "message log"],
+        workflow: "Query the conversation store for matching messages, optionally summarize using an LLM, and return the filtered or summarized conversation segment.",
+    },
+    {
+        toolName: "pii_guard",
+        domain: "infra",
+        intents: ["detect PII in content", "redact sensitive data", "scan for secrets", "prevent data leakage"],
+        capabilities: ["PII pattern recognition", "secret detection", "automatic redaction", "compliance policy enforcement"],
+        requires: ["PII detection rules", "secret scanning patterns"],
+        inputExample: "Scan this conversation output for PII before sending to the client",
+        outputExample: '{ piiDetected: true, findings: [{ type: "email", location: "output.text:42", action: "redacted" }, { type: "credit_card", location: "output.text:78", action: "blocked" }], safe: false }',
+        isDestructive: false,
+        isReadOnly: true,
+        llmCostEstimate: "low",
+        triggers: ["PII", "personal data", "secrets", "redact", "sensitive", "GDPR", "data leakage", "sanitize"],
+        workflow: "Scan the content against PII and secret detection patterns, redact or flag findings based on configured policies, and return a safety assessment.",
+    },
+];
+//# sourceMappingURL=tool-capabilities.data.js.map