// install-metadata.mjs — Curated resource metadata for the dispatch/registry system.
// Extracted from install.mjs to keep the installer focused on installation logic.
// Contains RESOURCE_METADATA (FTS5-optimized metadata per resource) and
// MARKETING_ON_REQUEST (Set of marketing/SEO resources in on_request mode).

// ─── Curated Resource Metadata ───────────────────────────────────────────────
// Replaces generic name-echo fallback with FTS5-optimized metadata per resource.
// Keys: intent_tags, domain_tags, capability_summary, trigger_patterns

export const RESOURCE_METADATA = {
  // ─── Skills ──────────────────────────────────────────────────────────────
  'skill:skill-creator': {
    intent_tags: 'skill,create,extend,meta,develop,author',
    domain_tags: 'claude,skill,markdown',
    capability_summary: 'Guide for creating and authoring new Claude Code skills with proper structure and metadata',
    trigger_patterns: 'when user wants to create a new skill or extend Claude capabilities with custom workflows',
    keywords: 'skill-builder,skill-authoring,skill-template,extend-claude',
    tech_stack: 'claude-code',
    use_cases: 'create skill;extend Claude',
  },
  'skill:frontend-design': {
    intent_tags: 'design,ui,ux,frontend,css,component,layout,styling,interface',
    domain_tags: 'css,react,html,tailwind,frontend',
    capability_summary: 'Create distinctive production-grade frontend interfaces with high design quality',
    trigger_patterns: 'when user needs to build or design UI components pages or web interfaces',
    invocation_name: 'frontend-design:frontend-design',
    keywords: 'ui-build,component-library,responsive-layout,design-system',
    tech_stack: 'sass,jsx,tailwindcss,javascript',
    use_cases: 'UI design;layout build;component build;user experience',
  },
  'skill:webapp-testing': {
    intent_tags: 'test,webapp,e2e,browser,qa,selenium,cypress,integration',
    domain_tags: 'browser,web,testing',
    capability_summary: 'Web application testing with browser automation and E2E test suites',
    trigger_patterns: 'when user needs to test web applications in a browser or write E2E tests',
    keywords: 'browser-automation,e2e-test,selenium-test,web-qa',
    tech_stack: 'chromium,playwright,http,rest,jest',
    use_cases: 'write unit tests;increase test coverage',
  },
  'skill:mcp-builder': {
    intent_tags: 'mcp,server,tool,integration,build,protocol,plugin',
    domain_tags: 'mcp,node,typescript',
    capability_summary: 'Build MCP servers and tool integrations for Claude Code',
    trigger_patterns: 'when user wants to build an MCP server or create tool integrations',
    keywords: 'mcp-server,tool-builder,protocol-server,claude-extension',
    tech_stack: 'mcp-sdk,json-rpc,nodejs,npm',
    use_cases: 'build MCP server;create tool',
  },
  'skill:pdf': {
    intent_tags: 'pdf,document,generate,export,report,print',
    domain_tags: 'pdf,document',
    capability_summary: 'Generate and export PDF documents from content',
    trigger_patterns: 'when user needs to create generate or export PDF documents',
    keywords: 'pdf-generation,document-export,report-builder,print-format',
    tech_stack: 'docx',
    use_cases: 'code generation;auto-generate',
  },
  'skill:doc-coauthoring': {
    intent_tags: 'documentation,writing,collaborate,docs,readme,technical-writing',
    domain_tags: 'markdown,docs,documentation',
    capability_summary: 'Collaborative documentation writing and technical content authoring',
    trigger_patterns: 'when user needs help writing documentation README or technical content',
    keywords: 'collaborative-docs,technical-writing,readme-authoring',
    use_cases: 'write documentation;update README',
  },
  'skill:superpowers-brainstorming': {
    intent_tags: 'brainstorm,design,planning,creative,ideas,explore,requirements',
    domain_tags: 'planning,design',
    capability_summary: 'Explore user intent requirements and design before implementation through structured brainstorming',
    trigger_patterns: 'when user needs to brainstorm ideas explore requirements or plan creative solutions before coding',
    invocation_name: 'superpowers:brainstorming',
    keywords: 'ideation,requirements,creative-thinking,design-session,explore-options',
    tech_stack: 'architecture',
    use_cases: 'explore ideas;gather requirements;UI design;layout build',
  },
  'skill:superpowers-tdd': {
    intent_tags: 'test,tdd,testing,unittest,spec,coverage,quality,red-green-refactor',
    domain_tags: 'testing,javascript,typescript,python',
    capability_summary: 'Test-driven development workflow with red-green-refactor cycle and quality checks',
    trigger_patterns: 'when user wants to write tests first or follow TDD methodology for feature development',
    invocation_name: 'superpowers:test-driven-development',
    keywords: 'red-green-refactor,test-first,test-driven,unit-tests,spec-writing',
    tech_stack: 'jest,vitest,pytest,es6,pip',
    use_cases: 'write unit tests;increase test coverage',
  },
  'skill:superpowers-debugging': {
    intent_tags: 'debug,troubleshoot,fix,error,systematic,diagnose,bug,crash,failure',
    domain_tags: 'debugging,error-handling',
    capability_summary: 'Systematic debugging approach for complex bugs using hypothesis-driven investigation',
    trigger_patterns: 'when user encounters bugs errors crashes or unexpected behavior that needs systematic debugging',
    invocation_name: 'superpowers:systematic-debugging',
    keywords: 'root-cause,hypothesis-driven,stack-trace,reproduce-bug,isolate-error',
    use_cases: 'debug errors;isolate issues;fix bugs',
  },
  'skill:superpowers-code-review': {
    intent_tags: 'review,code-review,quality,audit,feedback,inspect,pr-review',
    domain_tags: 'quality,review',
    capability_summary: 'Structured code review requesting with quality checklists and feedback gathering',
    trigger_patterns: 'when user wants to request or perform a thorough code review of their changes',
    invocation_name: 'superpowers:requesting-code-review',
    keywords: 'peer-review,code-quality,checklist,review-feedback,merge-review',
    tech_stack: 'linter,analyzer,diff,pr-review',
    use_cases: 'code review;identify issues',
  },
  'skill:superpowers-writing-plans': {
    intent_tags: 'plan,architecture,spec,implementation,blueprint,roadmap,strategy',
    domain_tags: 'planning,architecture',
    capability_summary: 'Write structured implementation plans from specs before touching code',
    trigger_patterns: 'when user has requirements or specs and needs a multi-step implementation plan before coding',
    invocation_name: 'superpowers:writing-plans',
    keywords: 'implementation-plan,task-breakdown,spec-to-plan,step-by-step',
    use_cases: 'architecture design;implementation planning',
  },
  'skill:superpowers-git-worktrees': {
    intent_tags: 'git,worktree,branch,isolation,parallel,workspace',
    domain_tags: 'git,workflow',
    capability_summary: 'Create isolated git worktrees for parallel feature development',
    trigger_patterns: 'when user needs to work on multiple branches simultaneously or isolate feature work',
    invocation_name: 'superpowers:using-git-worktrees',
    keywords: 'parallel-branches,isolated-workspace,worktree,concurrent-work',
    tech_stack: 'github',
    use_cases: 'git workflow;version control',
  },
  'skill:superpowers-verification': {
    intent_tags: 'verify,check,test,complete,quality,validation,evidence',
    domain_tags: 'quality,verification',
    capability_summary: 'Verify work is complete by running checks and gathering evidence before claiming done',
    trigger_patterns: 'when user is about to claim work is complete and needs verification before committing',
    invocation_name: 'superpowers:verification-before-completion',
    keywords: 'verify-before-commit,final-check,evidence-based,confirm-passing',
    tech_stack: 'linter,analyzer',
    use_cases: 'write unit tests;increase test coverage',
  },
  'skill:playwright-skill': {
    intent_tags: 'playwright,browser,automation,test,e2e,screenshot,scrape',
    domain_tags: 'playwright,browser,testing',
    capability_summary: 'Browser automation with Playwright for testing forms screenshots and web interactions',
    trigger_patterns: 'when user needs to automate browser interactions test web pages or take screenshots with Playwright',
    invocation_name: 'playwright-skill:playwright-skill',
    keywords: 'playwright-test,browser-script,page-interaction,screenshot',
    tech_stack: 'javascript,node,typescript,chromium,jest,vitest,pytest',
  },
  'skill:planning-with-files': {
    intent_tags: 'plan,files,organize,structure,project,scope',
    domain_tags: 'planning,project',
    capability_summary: 'Plan project structure and organize files before implementation',
    trigger_patterns: 'when user needs to plan file structure or organize project layout before building',
    keywords: 'file-structure,project-layout,directory-plan,scaffolding',
    tech_stack: 'architecture',
    use_cases: 'architecture design;implementation planning',
  },
  'skill:code-review-expert': {
    intent_tags: 'review,code-review,expert,quality,SOLID,security,architecture',
    domain_tags: 'quality,review,security',
    capability_summary: 'Expert code review detecting SOLID violations security risks and architectural issues',
    trigger_patterns: 'when user needs expert-level code review with SOLID analysis and security scanning',
    keywords: 'expert-analysis,deep-review,architectural-review,pattern-violations',
    tech_stack: 'linter,analyzer,diff,pr-review,owasp',
    use_cases: 'code review;identify issues',
  },
  'skill:ui-ux-pro-max': {
    intent_tags: 'ui,ux,design,frontend,pro,interface,visual,styling',
    domain_tags: 'ui,ux,frontend,css',
    capability_summary: 'Professional UI/UX design with polished visual styling and user experience focus',
    trigger_patterns: 'when user needs professional-grade UI/UX design with strong visual polish',
    keywords: 'polished-ui,professional-design,visual-quality,ux-patterns',
    tech_stack: 'html,javascript,sass',
    use_cases: 'UI design;component build;user experience;interaction design',
  },
  // ─── Agents ──────────────────────────────────────────────────────────────
  'agent:code-review-ai': {
    intent_tags: 'review,code-review,ai,quality,audit,automated',
    domain_tags: 'quality,review',
    capability_summary: 'AI-powered automated code review with quality analysis and improvement suggestions',
    trigger_patterns: 'when user wants AI-automated code review or quality analysis of their codebase',
    keywords: 'automated-review,ai-review,review-assistant,pr-feedback',
    tech_stack: 'linter,analyzer,diff,pr-review',
    use_cases: 'code review;identify issues',
  },
  'agent:tdd-workflows': {
    intent_tags: 'test,tdd,workflow,testing,quality,unittest,spec',
    domain_tags: 'testing,tdd',
    capability_summary: 'Automated TDD workflow agent for test-first development cycles',
    trigger_patterns: 'when user wants automated TDD workflow support with test generation and execution',
    keywords: 'tdd-cycle,test-first,red-green,failing-test,test-driven',
    tech_stack: 'jest,vitest,pytest',
    use_cases: 'write unit tests;increase test coverage',
  },
  'agent:debugging-toolkit': {
    intent_tags: 'debug,toolkit,error,troubleshoot,fix,diagnose,trace,crash',
    domain_tags: 'debugging,error-handling',
    capability_summary: 'Debugging toolkit agent with error analysis stack trace investigation and fix suggestions',
    trigger_patterns: 'when user has errors or crashes and needs automated debugging assistance and fix suggestions',
    keywords: 'stack,investigation,suggestions,errors',
    use_cases: 'debug errors;isolate issues;error handling;error tracking',
  },
  'agent:code-refactoring': {
    intent_tags: 'refactor,clean,simplify,restructure,organize,improve,technical-debt',
    domain_tags: 'refactoring,quality',
    capability_summary: 'Automated code refactoring for cleaner structure reduced complexity and technical debt',
    trigger_patterns: 'when user wants to refactor code simplify complex logic or reduce technical debt',
    keywords: 'restructure,extract-method,rename,simplify,solid-principles',
    tech_stack: 'linter,analyzer',
    use_cases: 'refactor code;reduce complexity;simplify code',
  },
  'agent:code-documentation': {
    intent_tags: 'documentation,docs,readme,jsdoc,comment,docstring,api-docs',
    domain_tags: 'documentation,docs',
    capability_summary: 'Automated code documentation generation including JSDoc README and API docs',
    trigger_patterns: 'when user needs to generate documentation add JSDoc comments or create README files',
    keywords: 'inline-docs,jsdoc,docstring,comment-generation',
    use_cases: 'write documentation;update README',
  },
  'agent:security-scanning': {
    intent_tags: 'security,scan,vulnerability,audit,owasp,secrets,xss,injection',
    domain_tags: 'security,audit',
    capability_summary: 'Security vulnerability scanning for OWASP issues secrets leaks and injection flaws',
    trigger_patterns: 'when user needs security scanning for vulnerabilities secrets or OWASP compliance',
    keywords: 'vuln-scan,dependency-audit,cve-check,sast,dast',
    tech_stack: 'owasp,cve',
    use_cases: 'security audit;vulnerability scan;vulnerability scanning;security patching',
  },
  'agent:application-performance': {
    intent_tags: 'performance,optimize,profile,benchmark,speed,latency,memory',
    domain_tags: 'performance,optimization',
    capability_summary: 'Application performance profiling optimization and benchmark analysis',
    trigger_patterns: 'when user needs to profile optimize or benchmark application performance',
    keywords: 'latency-analysis,response-time,throughput',
    tech_stack: 'profiler,apm,benchmark',
    use_cases: 'optimize performance;reduce latency;performance profiling;bottleneck detection',
  },
  'agent:api-scaffolding': {
    intent_tags: 'api,scaffold,rest,endpoint,backend,route,express,fastify',
    domain_tags: 'api,backend,rest',
    capability_summary: 'Scaffold REST API endpoints with routes controllers and validation boilerplate',
    trigger_patterns: 'when user needs to scaffold new API endpoints or build REST backend structure',
    keywords: 'api-generator,endpoint-scaffold,route-setup,openapi-spec',
    tech_stack: 'openapi',
    use_cases: 'API design;create endpoints;project scaffolding;boilerplate setup',
  },
  'agent:database-design': {
    intent_tags: 'database,schema,sql,design,model,erd,table,relation',
    domain_tags: 'database,sql,schema',
    capability_summary: 'Database schema design with table relationships indexes and normalization',
    trigger_patterns: 'when user needs to design database schema create tables or model data relationships',
    keywords: 'schema-design,entity-relationship,normalization,table-design',
    tech_stack: 'orm,postgresql,mysql,migration',
    use_cases: 'database design;schema migration;schema design;data modeling',
  },
  'agent:database-migrations': {
    intent_tags: 'database,migration,schema,alter,sql,upgrade,rollback',
    domain_tags: 'database,sql,migration',
    capability_summary: 'Database migration generation with schema alterations upgrade and rollback support',
    trigger_patterns: 'when user needs to create database migrations alter schemas or manage schema versions',
    keywords: 'migration-script,schema-change,alter-table,rollback-plan',
    tech_stack: 'orm,postgresql,mysql,alembic,flyway',
    use_cases: 'database design;schema migration;data migration;schema design',
  },
  'agent:cicd-automation': {
    intent_tags: 'ci,cd,automation,pipeline,deploy,github-actions,workflow',
    domain_tags: 'cicd,devops,deploy',
    capability_summary: 'CI/CD pipeline automation with GitHub Actions workflow configuration and deploy setup',
    trigger_patterns: 'when user needs to set up CI/CD pipelines configure GitHub Actions or automate deployments',
    keywords: 'ci-pipeline,github-actions,jenkins,build-automation,deploy-pipeline',
    tech_stack: 'ci,cd,pipeline',
    use_cases: 'continuous integration;build pipeline;continuous deployment;release pipeline',
  },
  'agent:git-pr-workflows': {
    intent_tags: 'git,pr,pull-request,merge,workflow,branch,commit',
    domain_tags: 'git,workflow',
    capability_summary: 'Git PR workflow automation with branch management commit strategy and merge handling',
    trigger_patterns: 'when user needs help with git PR workflows branch management or merge strategies',
    keywords: 'pull-request,pr-template,review-process,branch-strategy',
    tech_stack: 'github',
    use_cases: 'git workflow;version control',
  },
  'agent:unit-testing': {
    intent_tags: 'test,unit,jest,vitest,mocha,pytest,unittest,spec',
    domain_tags: 'testing,unittest',
    capability_summary: 'Unit test generation and execution with jest vitest mocha or pytest',
    trigger_patterns: 'when user needs to write or generate unit tests using jest vitest mocha or pytest',
    keywords: 'unit-test,isolated-tests,mock-setup,assertion,test-runner',
    tech_stack: 'jest,vitest,pytest',
    use_cases: 'write unit tests;increase test coverage',
  },
  'agent:dependency-management': {
    intent_tags: 'dependency,npm,package,update,manage,upgrade,audit,outdated',
    domain_tags: 'dependencies,npm,package',
    capability_summary: 'Dependency management with version updates audit and compatibility checking',
    trigger_patterns: 'when user needs to manage update audit or resolve dependency conflicts',
    keywords: 'version,updates,compatibility,checking,resolve,conflicts',
  },
  'agent:error-debugging': {
    intent_tags: 'error,debug,diagnose,stack-trace,fix,exception,crash,runtime',
    domain_tags: 'debugging,error-handling',
    capability_summary: 'Error diagnosis from stack traces with root cause analysis and fix suggestions',
    trigger_patterns: 'when user has runtime errors exceptions or stack traces that need diagnosis and fixing',
    keywords: 'diagnosis,stack,traces,root,cause',
    use_cases: 'error handling;error tracking;debug errors;isolate issues',
  },
  'agent:python-development': {
    intent_tags: 'python,pip,poetry,django,flask,fastapi,virtualenv',
    domain_tags: 'python,backend',
    capability_summary: 'Python development agent for Django Flask FastAPI and general Python projects',
    trigger_patterns: 'when user is working on Python projects with pip poetry Django Flask or FastAPI',
    tech_stack: 'pip',
  },
  'agent:javascript-typescript': {
    intent_tags: 'javascript,typescript,node,npm,web,react,express,fullstack',
    domain_tags: 'javascript,typescript,node,web',
    capability_summary: 'JavaScript and TypeScript development agent for Node.js React and web projects',
    trigger_patterns: 'when user is working on JavaScript TypeScript Node.js or web development projects',
    tech_stack: 'es6,nodejs,npm,http,rest',
  },
  'agent:cloud-infrastructure': {
    intent_tags: 'cloud,aws,gcp,azure,infrastructure,terraform,iac,devops',
    domain_tags: 'cloud,infrastructure,devops',
    capability_summary: 'Cloud infrastructure management with AWS GCP Azure and Terraform IaC',
    trigger_patterns: 'when user needs to manage cloud infrastructure with AWS GCP Azure or Terraform',
    tech_stack: 'ci,cd,pipeline',
  },
  'agent:ui-design': {
    intent_tags: 'ui,design,frontend,css,component,layout,responsive',
    domain_tags: 'ui,frontend,css',
    capability_summary: 'UI design agent for frontend component layout and responsive design implementation',
    trigger_patterns: 'when user needs to design and implement UI components layouts or responsive interfaces',
    tech_stack: 'html,javascript,sass',
    use_cases: 'UI design;component build;layout build;frontend development',
  },
  'agent:frontend-developer': {
    intent_tags: 'frontend,react,vue,web,component,spa,interface',
    domain_tags: 'frontend,react,vue,web',
    capability_summary: 'Frontend development agent for React Vue and modern web application building',
    trigger_patterns: 'when user needs to build frontend applications with React Vue or modern web frameworks',
    tech_stack: 'html,css,javascript,jsx,vuex',
    use_cases: 'frontend development;component build',
  },
  'agent:mcp-expert': {
    intent_tags: 'mcp,server,tool,integration,protocol,sdk,plugin',
    domain_tags: 'mcp,protocol,integration',
    capability_summary: 'MCP protocol expert for building servers tools and integrations with the MCP SDK',
    trigger_patterns: 'when user needs expert help with MCP protocol server development or tool integration',
    tech_stack: 'mcp-sdk,json-rpc',
    use_cases: 'build MCP server;create tool',
  },
  'agent:component-reviewer': {
    intent_tags: 'component,review,quality,frontend,react,vue,audit',
    domain_tags: 'frontend,review,component',
    capability_summary: 'Frontend component reviewer for quality accessibility and best-practice auditing',
    trigger_patterns: 'when user wants to review frontend components for quality accessibility and best practices',
  },  'skill:ab-test-setup': {
    intent_tags: 'ab-test,experiment,cro,conversion,split-test,variant,marketing',
    domain_tags: 'marketing,cro,analytics',
    capability_summary: 'Set up A/B tests with variant design hypothesis tracking and statistical analysis',
    trigger_patterns: 'when user needs to set up A/B tests or split tests for marketing experiments',
    keywords: 'hypothesis,tracking,statistical',
  },
  'skill:ad-creative': {
    intent_tags: 'ad,creative,advertising,copy,banner,campaign,visual,marketing',
    domain_tags: 'marketing,advertising,creative',
    capability_summary: 'Create compelling ad creative copy and visuals for advertising campaigns',
    trigger_patterns: 'when user needs to create ad creatives copy or advertising campaign assets',
    keywords: 'compelling,visuals,campaigns,creatives,assets',
  },
  'skill:ai-seo': {
    intent_tags: 'ai,seo,search,optimization,llm,generative,marketing',
    domain_tags: 'marketing,seo,ai',
    capability_summary: 'AI-powered SEO optimization for search visibility and content ranking',
    trigger_patterns: 'when user needs AI-driven SEO strategies or search optimization',
    keywords: 'ai-powered,visibility,ranking,ai-driven,strategies',
    use_cases: 'search optimization;meta tags',
  },
  'skill:analytics-tracking': {
    intent_tags: 'analytics,tracking,metrics,data,ga4,events,conversion,marketing',
    domain_tags: 'marketing,analytics,data',
    capability_summary: 'Set up analytics tracking events conversion goals and marketing metrics',
    trigger_patterns: 'when user needs to set up analytics tracking events or marketing metrics',
  },
  'skill:churn-prevention': {
    intent_tags: 'churn,retention,customer,saas,lifecycle,engagement,marketing',
    domain_tags: 'marketing,retention,saas',
    capability_summary: 'Design churn prevention strategies with retention campaigns and lifecycle engagement',
    trigger_patterns: 'when user needs to reduce churn or improve customer retention',
    keywords: 'prevention,strategies,campaigns,reduce,improve',
  },
  'skill:cold-email': {
    intent_tags: 'cold-email,outreach,sales,prospecting,email,b2b,marketing',
    domain_tags: 'marketing,email,sales',
    capability_summary: 'Write effective cold email sequences for outreach and sales prospecting',
    trigger_patterns: 'when user needs to write cold emails outreach sequences or sales prospecting messages',
    keywords: 'write,effective,cold,sequences,emails,messages',
  },
  'skill:competitor-alternatives': {
    intent_tags: 'competitor,alternatives,comparison,analysis,positioning,marketing',
    domain_tags: 'marketing,seo,competitive',
    capability_summary: 'Create competitor comparison and alternatives pages for SEO and positioning',
    trigger_patterns: 'when user needs competitor analysis alternative comparison pages or competitive positioning',
    keywords: 'pages,alternative',
  },
  'skill:content-strategy': {
    intent_tags: 'content,strategy,blog,editorial,calendar,publishing,marketing',
    domain_tags: 'marketing,content,editorial',
    capability_summary: 'Plan content strategy with editorial calendars topic clusters and publishing workflows',
    trigger_patterns: 'when user needs content strategy editorial planning or blog content organization',
    keywords: 'plan,calendars,topic,clusters',
  },
  'skill:copy-editing': {
    intent_tags: 'copy-editing,proofread,writing,grammar,clarity,tone,marketing',
    domain_tags: 'marketing,writing,editing',
    capability_summary: 'Professional copy editing for marketing content with clarity tone and grammar improvement',
    trigger_patterns: 'when user needs copy editing proofreading or marketing content polishing',
    keywords: 'professional,copy,improvement,proofreading,polishing',
  },
  'skill:copywriting': {
    intent_tags: 'copywriting,persuasion,landing-page,headline,cta,conversion,marketing',
    domain_tags: 'marketing,copywriting,conversion',
    capability_summary: 'Write persuasive marketing copy for landing pages headlines CTAs and conversion',
    trigger_patterns: 'when user needs persuasive copywriting for landing pages or marketing materials',
    keywords: 'write,persuasive,copy,landing,pages,headlines',
  },
  'skill:email-sequence': {
    intent_tags: 'email,sequence,drip,automation,nurture,onboarding,marketing',
    domain_tags: 'marketing,email,automation',
    capability_summary: 'Design email sequences with drip campaigns nurture flows and automated triggers',
    trigger_patterns: 'when user needs to create email sequences drip campaigns or automated email flows',
    keywords: 'sequences,campaigns,flows,triggers',
  },
  'skill:form-cro': {
    intent_tags: 'form,cro,conversion,optimization,signup,lead,marketing',
    domain_tags: 'marketing,cro,forms',
    capability_summary: 'Optimize web forms for higher conversion rates with field reduction and UX improvements',
    trigger_patterns: 'when user needs to optimize forms for better conversion rates',
    keywords: 'optimize,higher,rates,field,reduction,improvements',
  },
  'skill:free-tool-strategy': {
    intent_tags: 'free-tool,growth,acquisition,lead-gen,viral,product-led,marketing',
    domain_tags: 'marketing,growth,product',
    capability_summary: 'Plan free tool strategies for lead generation viral growth and user acquisition',
    trigger_patterns: 'when user wants to build free tools for marketing lead generation or growth',
    keywords: 'plan,free,strategies,lead',
  },
  'skill:launch-strategy': {
    intent_tags: 'launch,strategy,go-to-market,product-launch,gtm,marketing',
    domain_tags: 'marketing,launch,product',
    capability_summary: 'Plan product launch strategies with go-to-market timelines and channel selection',
    trigger_patterns: 'when user needs a product launch strategy or go-to-market plan',
    keywords: 'plan,strategies,timelines,channel,selection',
  },
  'skill:marketing-ideas': {
    intent_tags: 'marketing,ideas,brainstorm,growth,creative,campaign,marketing',
    domain_tags: 'marketing,creative,growth',
    capability_summary: 'Generate creative marketing ideas and growth campaign brainstorming',
    trigger_patterns: 'when user needs marketing ideas creative campaign concepts or growth brainstorming',
    keywords: 'generate,brainstorming,concepts',
    use_cases: 'explore ideas;gather requirements',
  },
  'skill:marketing-psychology': {
    intent_tags: 'psychology,persuasion,behavior,neuromarketing,bias,influence,marketing',
    domain_tags: 'marketing,psychology,persuasion',
    capability_summary: 'Apply marketing psychology principles like scarcity social proof and cognitive biases',
    trigger_patterns: 'when user wants to apply psychological principles to marketing or conversion optimization',
    keywords: 'apply,principles,scarcity,social,proof,cognitive',
  },
  'skill:onboarding-cro': {
    intent_tags: 'onboarding,cro,activation,ux,first-run,welcome,marketing',
    domain_tags: 'marketing,cro,onboarding',
    capability_summary: 'Optimize user onboarding flows for activation and first-run conversion',
    trigger_patterns: 'when user needs to improve onboarding flows user activation or first-run experience',
    keywords: 'optimize,flows,conversion,improve,experience',
  },
  'skill:page-cro': {
    intent_tags: 'page,cro,landing-page,conversion,layout,optimization,marketing',
    domain_tags: 'marketing,cro,landing-page',
    capability_summary: 'Optimize landing pages for conversion with layout copy and CTA improvements',
    trigger_patterns: 'when user needs to optimize landing pages or web pages for higher conversion',
    keywords: 'optimize,landing,pages,copy,improvements,higher',
  },
  'skill:paid-ads': {
    intent_tags: 'paid-ads,ppc,campaign,google-ads,meta-ads,budget,marketing',
    domain_tags: 'marketing,advertising,ppc',
    capability_summary: 'Plan and optimize paid advertising campaigns across Google Meta and ad platforms',
    trigger_patterns: 'when user needs to plan or optimize paid ad campaigns PPC or advertising budgets',
    keywords: 'plan,optimize,paid,campaigns,google,meta',
  },
  'skill:paywall-upgrade-cro': {
    intent_tags: 'paywall,upgrade,conversion,pricing,upsell,premium,marketing',
    domain_tags: 'marketing,cro,pricing',
    capability_summary: 'Optimize paywall and upgrade flows for premium conversion and upsell',
    trigger_patterns: 'when user needs to optimize paywall upgrade flows or premium conversion rates',
    keywords: 'optimize,flows,rates',
  },
  'skill:popup-cro': {
    intent_tags: 'popup,cro,conversion,lead-capture,exit-intent,modal,marketing',
    domain_tags: 'marketing,cro,popup',
    capability_summary: 'Design high-converting popups with exit-intent triggers and lead capture optimization',
    trigger_patterns: 'when user needs to create or optimize popups for lead capture or conversion',
    keywords: 'high-converting,popups,triggers,lead,capture',
  },
  'skill:pricing-strategy': {
    intent_tags: 'pricing,strategy,monetization,revenue,tiers,freemium,marketing',
    domain_tags: 'marketing,pricing,business',
    capability_summary: 'Design pricing strategies with tier structures freemium models and revenue optimization',
    trigger_patterns: 'when user needs pricing strategy tier design or monetization planning',
    keywords: 'strategies,tier,structures,optimization',
  },
  'skill:product-marketing-context': {
    intent_tags: 'product,positioning,messaging,value-prop,context,differentiation,marketing',
    domain_tags: 'marketing,product,positioning',
    capability_summary: 'Define product positioning messaging and value proposition for marketing context',
    trigger_patterns: 'when user needs product positioning value proposition or marketing messaging framework',
    keywords: 'define,value,proposition',
  },
  'skill:programmatic-seo': {
    intent_tags: 'programmatic-seo,automation,pages,templates,scale,marketing',
    domain_tags: 'marketing,seo,automation',
    capability_summary: 'Build programmatic SEO pages at scale with templates and automated content generation',
    trigger_patterns: 'when user needs programmatic SEO pages at scale or templated content generation',
    keywords: 'programmatic,templated',
  },
  'skill:referral-program': {
    intent_tags: 'referral,viral,growth,program,incentive,share,marketing',
    domain_tags: 'marketing,growth,referral',
    capability_summary: 'Design referral programs with incentive structures viral mechanics and tracking',
    trigger_patterns: 'when user needs to design referral programs or viral growth mechanics',
    keywords: 'programs,structures,mechanics,tracking',
  },
  'skill:schema-markup': {
    intent_tags: 'schema,structured-data,seo,markup,rich-snippets,json-ld,marketing',
    domain_tags: 'marketing,seo,schema',
    capability_summary: 'Implement schema markup and structured data for rich search snippets',
    trigger_patterns: 'when user needs schema markup structured data or JSON-LD for SEO',
    keywords: 'data,rich,search,snippets',
    tech_stack: 'orm,migration',
    use_cases: 'schema design;data modeling;search optimization;meta tags',
  },
  'skill:mktg-seo-audit': {
    intent_tags: 'seo,audit,technical,analysis,crawl,marketing',
    domain_tags: 'marketing,seo,audit',
    capability_summary: 'Marketing-focused SEO audit with technical and content analysis',
    trigger_patterns: 'when user needs a marketing-focused SEO audit or technical site analysis',
    keywords: 'marketing-focused,site',
    use_cases: 'search optimization;meta tags;code audit;quality assessment',
  },
  'skill:signup-flow-cro': {
    intent_tags: 'signup,flow,cro,conversion,registration,onboarding,marketing',
    domain_tags: 'marketing,cro,signup',
    capability_summary: 'Optimize signup and registration flows for higher conversion rates',
    trigger_patterns: 'when user needs to optimize signup flows registration pages or conversion funnels',
    keywords: 'optimize,flows,higher,rates,pages,funnels',
  },
  'skill:social-content': {
    intent_tags: 'social,content,twitter,linkedin,posts,engagement,marketing',
    domain_tags: 'marketing,social-media,content',
    capability_summary: 'Create engaging social media content for Twitter LinkedIn and social platforms',
    trigger_patterns: 'when user needs social media content posts or engagement strategies',
    keywords: 'engaging,media,platforms,strategies',
  },
  'skill:seo-audit': {
    intent_tags: 'seo,audit,technical,analysis,crawl,indexing',
    domain_tags: 'seo,audit,web',
    capability_summary: 'Comprehensive SEO audit with technical analysis crawl errors and performance checks',
    trigger_patterns: 'when user needs a comprehensive SEO audit or technical site analysis',
    keywords: 'errors,performance,checks,site',
    tech_stack: 'http,rest',
    use_cases: 'search optimization;meta tags;code audit;quality assessment',
  },
  'skill:seo-competitor-pages': {
    intent_tags: 'seo,competitor,pages,analysis,serp,ranking,gap',
    domain_tags: 'seo,competitive,analysis',
    capability_summary: 'Analyze competitor pages for SEO strategy gaps and ranking opportunities',
    trigger_patterns: 'when user needs SEO competitor page analysis or SERP gap identification',
    keywords: 'analyze,strategy,gaps,opportunities,page,identification',
    use_cases: 'search optimization;meta tags',
  },
  'skill:seo-content': {
    intent_tags: 'seo,content,optimization,keywords,writing,on-page,headings',
    domain_tags: 'seo,content,writing',
    capability_summary: 'Optimize content for SEO with keyword integration heading structure and readability',
    trigger_patterns: 'when user needs to optimize content for SEO keywords or on-page factors',
    keywords: 'optimize,keyword,integration,heading,structure,readability',
    use_cases: 'search optimization;meta tags',
  },
  'skill:seo-geo': {
    intent_tags: 'seo,geo,local,location,regional,gmb,maps',
    domain_tags: 'seo,local,geo',
    capability_summary: 'Implement geo-targeted and local SEO strategies for regional visibility',
    trigger_patterns: 'when user needs local SEO geo-targeting or regional search optimization',
    keywords: 'geo-targeted,strategies,visibility,geo-targeting,search,optimization',
    use_cases: 'search optimization;meta tags',
  },
  'skill:seo-hreflang': {
    intent_tags: 'seo,hreflang,international,multilingual,i18n,language,region',
    domain_tags: 'seo,international,i18n',
    capability_summary: 'Implement hreflang tags for international and multilingual SEO',
    trigger_patterns: 'when user needs hreflang implementation international SEO or multilingual site setup',
    keywords: 'tags,site,setup',
    use_cases: 'search optimization;meta tags',
  },
  'skill:seo-images': {
    intent_tags: 'seo,images,optimization,alt-text,compression,webp,lazy-load',
    domain_tags: 'seo,images,performance',
    capability_summary: 'Optimize images for SEO with alt text compression formats and lazy loading',
    trigger_patterns: 'when user needs image SEO optimization alt text or image compression strategies',
    keywords: 'optimize,formats,lazy,loading,image',
    tech_stack: 'profiler,apm',
    use_cases: 'search optimization;meta tags',
  },
  'skill:seo-page': {
    intent_tags: 'seo,page,on-page,meta,title,description,optimization',
    domain_tags: 'seo,on-page,meta',
    capability_summary: 'On-page SEO optimization with meta tags title optimization and page structure',
    trigger_patterns: 'when user needs on-page SEO meta tag optimization or page structure improvements',
    keywords: 'tags,structure,improvements',
    use_cases: 'search optimization;meta tags',
  },
  'skill:seo-plan': {
    intent_tags: 'seo,plan,strategy,roadmap,goals,timeline,priorities',
    domain_tags: 'seo,strategy,planning',
    capability_summary: 'Create SEO strategy plans with goals roadmap timelines and priority actions',
    trigger_patterns: 'when user needs an SEO strategy plan roadmap or prioritized action items',
    keywords: 'plans,timelines,priority,actions,prioritized,action',
    tech_stack: 'architecture',
    use_cases: 'search optimization;meta tags;architecture design;implementation planning',
  },
  'skill:seo-programmatic': {
    intent_tags: 'seo,programmatic,scale,templates,automation,dynamic,pages',
    domain_tags: 'seo,programmatic,automation',
    capability_summary: 'Build programmatic SEO with dynamic templates and automated page generation at scale',
    trigger_patterns: 'when user needs programmatic SEO dynamic page generation or automated content at scale',
    use_cases: 'search optimization;meta tags',
  },
  'skill:seo-schema': {
    intent_tags: 'seo,schema,structured-data,json-ld,rich-snippets,markup',
    domain_tags: 'seo,schema,structured-data',
    capability_summary: 'Implement SEO schema markup with JSON-LD for rich snippets and search features',
    trigger_patterns: 'when user needs SEO schema markup JSON-LD or structured data implementation',
    keywords: 'rich,snippets,search,features,data',
    tech_stack: 'orm,migration',
    use_cases: 'search optimization;meta tags;schema design;data modeling',
  },
  'skill:seo-sitemap': {
    intent_tags: 'seo,sitemap,xml,crawl,index,robots,submission',
    domain_tags: 'seo,sitemap,technical',
    capability_summary: 'Generate and optimize XML sitemaps for crawl efficiency and index coverage',
    trigger_patterns: 'when user needs XML sitemap generation optimization or crawl management',
    keywords: 'generate,optimize,sitemaps,efficiency,coverage',
    use_cases: 'search optimization;meta tags',
  },
  'skill:seo-technical': {
    intent_tags: 'seo,technical,core-web-vitals,crawl,indexing',
    domain_tags: 'seo,technical',
    capability_summary: 'Technical SEO audit covering core web vitals site speed crawlability and indexing',
    trigger_patterns: 'when user needs technical SEO improvements core web vitals or site speed optimization',
    keywords: 'audit,core,vitals,site,speed',
    use_cases: 'search optimization;meta tags',
  },
  'agent:seo-content-agent': {
    intent_tags: 'seo,content,agent,writing,optimization,automated',
    domain_tags: 'seo,content,agent',
    capability_summary: 'Automated SEO content agent for writing and optimizing search-friendly content',
    trigger_patterns: 'when user wants automated SEO content writing or optimization assistance',
    keywords: 'optimizing,search-friendly,assistance',
    use_cases: 'search optimization;meta tags',
  },
  'agent:seo-performance-agent': {
    intent_tags: 'seo,agent,core-web-vitals,pagespeed',
    domain_tags: 'seo,agent',
    capability_summary: 'SEO performance monitoring agent for core web vitals and page speed analysis',
    trigger_patterns: 'when user needs automated SEO performance monitoring or speed optimization',
    keywords: 'performance,core,vitals,page,speed',
    use_cases: 'search optimization;meta tags',
  },
  'agent:seo-schema-agent': {
    intent_tags: 'seo,schema,agent,structured-data,automation,json-ld',
    domain_tags: 'seo,schema,agent',
    capability_summary: 'Automated schema markup agent for generating and validating structured data',
    trigger_patterns: 'when user wants automated schema markup generation or structured data validation',
    keywords: 'markup,generating,validating,data,validation',
    tech_stack: 'orm,migration',
    use_cases: 'search optimization;meta tags;schema design;data modeling',
  },
  'agent:seo-sitemap-agent': {
    intent_tags: 'seo,sitemap,agent,xml,automation,crawl',
    domain_tags: 'seo,sitemap,agent',
    capability_summary: 'Automated sitemap management agent for XML generation and submission',
    trigger_patterns: 'when user wants automated sitemap generation management or submission',
    use_cases: 'search optimization;meta tags',
  },
  'agent:seo-technical-agent': {
    intent_tags: 'seo,technical,agent,audit,automation,crawl,indexing',
    domain_tags: 'seo,technical,agent',
    capability_summary: 'Automated technical SEO agent for crawl analysis indexing and site health monitoring',
    trigger_patterns: 'when user wants automated technical SEO audits or site health monitoring',
    keywords: 'site,health',
    use_cases: 'search optimization;meta tags',
  },
  'agent:seo-visual-agent': {
    intent_tags: 'seo,visual,agent,images,design,alt-text,optimization',
    domain_tags: 'seo,visual,agent',
    capability_summary: 'SEO visual optimization agent for image alt text and visual content analysis',
    trigger_patterns: 'when user wants automated image SEO optimization or visual content analysis',
    use_cases: 'search optimization;meta tags',
  },
  'skill:humanizer': {
    intent_tags: 'humanize,writing,ai-detection,tone,natural,rewrite,polish',
    domain_tags: 'writing,editing,content',
    capability_summary: 'Remove signs of AI-generated writing to make text sound natural and human',
    trigger_patterns: 'when user wants to humanize AI-generated text or remove AI writing patterns',
    keywords: 'remove,signs,ai-generated,sound,human',
  },
  'skill:claudeception': {
    intent_tags: 'skill-extraction,learning,continuous,autonomous,meta,knowledge',
    domain_tags: 'meta,learning,skills',
    capability_summary: 'Autonomous skill extraction and continuous learning from Claude Code work sessions',
    trigger_patterns: 'when user wants to extract reusable skills from work sessions or enable continuous learning',
    keywords: 'extraction,claude,sessions,extract,reusable',
  },
  'skill:mem-memory': {
    intent_tags: 'memory,save,store,remember,note,record,persist,auto-save',
    domain_tags: 'memory,ai,claude',
    capability_summary: 'Save content to memory — with explicit content, instructions, or auto-summarize current session',
    trigger_patterns: 'when user wants to save something to memory or auto-save session highlights',
    invocation_name: 'claude-mem-lite:memory',
    keywords: 'explicit,instructions,auto-summarize,current,session',
    tech_stack: 'claude-code',
  },
  'skill:mem-update': {
    intent_tags: 'maintenance,cleanup,deduplicate,decay,optimize,reindex,health',
    domain_tags: 'memory,registry,maintenance',
    capability_summary: 'Auto-maintain memory and resource registry — deduplicate, merge, decay, cleanup, reindex',
    trigger_patterns: 'when user wants to clean up memory database or maintain the tool registry',
    invocation_name: 'claude-mem-lite:update',
    keywords: 'auto-maintain,resource,merge,clean,database,maintain',
  },
  'skill:mem-tools': {
    intent_tags: 'import,tools,github,skills,agents,registry,add,discover',
    domain_tags: 'memory,registry,github,tools',
    capability_summary: 'Import skills and agents from GitHub repositories into the tool resource registry',
    trigger_patterns: 'when user wants to import or add new skills and agents from GitHub to the tool registry',
    invocation_name: 'claude-mem-lite:tools',
    keywords: 'repositories,resource',
  },
  'skill:anthropic-architect': {
    intent_tags: 'anthropic,architecture,system-design,claude,patterns,best-practices',
    domain_tags: 'anthropic,architecture,ai',
    capability_summary: 'Architect Anthropic Claude-based systems with best practice patterns and design',
    trigger_patterns: 'when user needs to architect systems using Anthropic Claude APIs or AI patterns',
    keywords: 'architect,claude-based,practice,apis',
  },
  'skill:anthropic-prompt-engineer': {
    intent_tags: 'anthropic,prompt,engineering,claude,optimization,techniques',
    domain_tags: 'anthropic,prompt,ai',
    capability_summary: 'Expert Anthropic prompt engineering with optimization techniques for Claude',
    trigger_patterns: 'when user needs prompt engineering for Anthropic Claude models',
  },
  'skill:apple-hig-designer': {
    intent_tags: 'apple,hig,design,ios,macos,ui,human-interface,guidelines',
    domain_tags: 'apple,design,ios,macos',
    capability_summary: 'Design Apple HIG-compliant interfaces for iOS macOS and Apple platforms',
    trigger_patterns: 'when user needs Apple Human Interface Guidelines compliant UI design',
    keywords: 'hig-compliant,platforms,human,interface,compliant',
    tech_stack: 'swift',
    use_cases: 'UI design;layout build',
  },
  'skill:book-illustrator': {
    intent_tags: 'illustration,book,art,visual,creative,drawing,children',
    domain_tags: 'illustration,art,creative',
    capability_summary: 'Create book illustrations with visual storytelling and artistic direction',
    trigger_patterns: 'when user needs book illustrations visual art or creative illustration direction',
    keywords: 'illustrations,storytelling,artistic,direction',
  },
  'skill:content-brief-generator': {
    intent_tags: 'content,brief,generator,writing,planning,outline,structure',
    domain_tags: 'content,writing,planning',
    capability_summary: 'Generate structured content briefs with outlines target audience and key messages',
    trigger_patterns: 'when user needs content briefs writing outlines or structured content plans',
    keywords: 'generate,briefs,outlines,target,audience,messages',
    tech_stack: 'architecture',
  },
  'skill:design-brief-generator': {
    intent_tags: 'design,brief,generator,creative,project,requirements,visual',
    domain_tags: 'design,creative,project',
    capability_summary: 'Generate design briefs with creative requirements visual direction and project scope',
    trigger_patterns: 'when user needs design briefs creative direction or project visual requirements',
    keywords: 'generate,briefs,direction,scope',
    use_cases: 'UI design;layout build',
  },
  'skill:engineer-expertise-extractor': {
    intent_tags: 'expertise,extraction,knowledge,engineering,skills,assessment',
    domain_tags: 'engineering,knowledge,assessment',
    capability_summary: 'Extract and document engineering expertise knowledge and skill assessments',
    trigger_patterns: 'when user needs to extract document or assess engineering expertise and knowledge',
    keywords: 'extract,document,assessments,assess',
  },
  'skill:engineer-skill-creator': {
    intent_tags: 'skill,creator,engineering,development,custom,workflow',
    domain_tags: 'engineering,skills,meta',
    capability_summary: 'Create engineering-focused custom skills and development workflows',
    trigger_patterns: 'when user wants to create engineering-focused custom skills or workflows',
    use_cases: 'create skill;extend Claude',
  },
  'skill:frontend-designer': {
    intent_tags: 'frontend,designer,ui,web,visual,layout,responsive',
    domain_tags: 'frontend,design,web',
    capability_summary: 'Frontend design with visual UI layout responsive design and web aesthetics',
    trigger_patterns: 'when user needs frontend visual design responsive layouts or web UI aesthetics',
    tech_stack: 'html,css,javascript,http,rest',
    use_cases: 'frontend development;component build;UI design',
  },
  'skill:git-worktrees': {
    intent_tags: 'git,worktree,branch,parallel,workflow,isolation',
    domain_tags: 'git,workflow,development',
    capability_summary: 'Git worktree workflows for parallel branch development and isolation',
    trigger_patterns: 'when user needs git worktree setup for parallel development or branch isolation',
    tech_stack: 'github',
    use_cases: 'git workflow;version control',
  },
  'skill:kids-book-writer': {
    intent_tags: 'children,book,writing,story,creative,kids,illustration',
    domain_tags: 'writing,children,creative',
    capability_summary: 'Write children books with age-appropriate stories and illustration guidance',
    trigger_patterns: 'when user wants to write children books or create kids story content',
    keywords: 'write,books,age-appropriate,stories,guidance',
  },
  'skill:leetcode-teacher': {
    intent_tags: 'leetcode,algorithms,teaching,interview,coding,data-structures',
    domain_tags: 'algorithms,education,interview',
    capability_summary: 'Teach LeetCode problems with algorithm explanations and interview preparation',
    trigger_patterns: 'when user needs help with LeetCode problems algorithm learning or coding interviews',
    keywords: 'teach,problems,algorithm,explanations,preparation,learning',
  },
  'skill:llm-router': {
    intent_tags: 'llm,router,model,selection,orchestration,multi-model,dispatch',
    domain_tags: 'ai,llm,orchestration',
    capability_summary: 'Route LLM requests to optimal models based on task complexity and requirements',
    trigger_patterns: 'when user needs LLM routing multi-model selection or request orchestration',
    keywords: 'route,requests,optimal,task,complexity',
    use_cases: 'data modeling;schema design',
  },
  'skill:math-teacher': {
    intent_tags: 'math,teaching,education,tutor,problems,algebra,calculus',
    domain_tags: 'math,education,tutoring',
    capability_summary: 'Teach mathematics with step-by-step explanations and practice problem guidance',
    trigger_patterns: 'when user needs math tutoring explanations or practice problem help',
    keywords: 'teach,mathematics,step-by-step,explanations,practice,problem',
  },
  'skill:openai-prompt-engineer': {
    intent_tags: 'openai,prompt,engineering,gpt,optimization,techniques',
    domain_tags: 'openai,prompt,ai',
    capability_summary: 'Expert OpenAI prompt engineering with GPT optimization techniques',
    trigger_patterns: 'when user needs prompt engineering for OpenAI GPT models',
  },
  'skill:prd-generator': {
    intent_tags: 'prd,product,requirements,document,spec,features,scope',
    domain_tags: 'product,requirements,planning',
    capability_summary: 'Generate product requirements documents with features scope and specifications',
    trigger_patterns: 'when user needs to create PRDs product requirements documents or feature specifications',
    keywords: 'generate,documents,specifications,prds,feature',
    tech_stack: 'architecture',
  },
  'skill:qa-test-planner': {
    intent_tags: 'qa,test,planner,quality,testing,strategy,coverage',
    domain_tags: 'qa,testing,planning',
    capability_summary: 'Plan QA test strategies with coverage mapping test cases and quality assurance',
    trigger_patterns: 'when user needs QA test planning test strategy or test coverage mapping',
    keywords: 'plan,strategies,mapping,cases,assurance',
    tech_stack: 'jest,vitest,pytest,architecture',
    use_cases: 'write unit tests;increase test coverage',
  },
  'skill:query-expert': {
    intent_tags: 'query,sql,database,optimization,expert,performance,tuning',
    domain_tags: 'sql,database,query',
    capability_summary: 'Expert SQL query writing optimization and database performance tuning',
    trigger_patterns: 'when user needs expert SQL query writing or database query optimization',
    tech_stack: 'postgresql,mysql,orm',
    use_cases: 'write SQL queries;schema design;database design;schema migration',
  },
  'skill:reading-teacher': {
    intent_tags: 'reading,teaching,education,literacy,comprehension,phonics',
    domain_tags: 'education,reading,literacy',
    capability_summary: 'Teach reading skills with comprehension strategies and literacy development',
    trigger_patterns: 'when user needs reading instruction literacy development or comprehension strategies',
    keywords: 'teach,skills,strategies,instruction',
  },
  'skill:releasing-macos-apps': {
    intent_tags: 'macos,release,app-store,distribution,apple,notarize,signing',
    domain_tags: 'macos,release,apple',
    capability_summary: 'Guide macOS app release with App Store submission notarization and distribution',
    trigger_patterns: 'when user needs to release a macOS app to the App Store or handle code signing',
    keywords: 'store,submission,notarization,handle',
    use_cases: 'deploy to production;release management',
  },
  'skill:swift-concurrency': {
    intent_tags: 'swift,concurrency,async,await,actor,structured,task',
    domain_tags: 'swift,ios,concurrency',
    capability_summary: 'Swift concurrency with async/await actors structured concurrency and task groups',
    trigger_patterns: 'when user needs Swift concurrency patterns async/await or actor-based design',
    keywords: 'asyncawait,actors,groups,patterns,actor-based',
    tech_stack: 'xcode',
  },
  'skill:swiftui-animation': {
    intent_tags: 'swiftui,animation,ios,motion,transition,effect,visual',
    domain_tags: 'swiftui,ios,animation',
    capability_summary: 'Create SwiftUI animations with transitions motion effects and visual polish',
    trigger_patterns: 'when user needs SwiftUI animations transitions or motion design for iOS apps',
    keywords: 'animations,transitions,effects,polish,apps',
    tech_stack: 'swift',
    use_cases: 'CSS animation;motion design',
  },
  'skill:technical-launch-planner': {
    intent_tags: 'launch,technical,planner,deployment,release,checklist,rollout',
    domain_tags: 'deployment,planning,release',
    capability_summary: 'Plan technical product launches with deployment checklists and rollout strategy',
    trigger_patterns: 'when user needs technical launch planning deployment checklists or release management',
    keywords: 'plan,product,launches,checklists,strategy',
    tech_stack: 'architecture',
  },
  'skill:trading-plan-generator': {
    intent_tags: 'trading,plan,finance,strategy,markets,risk,portfolio',
    domain_tags: 'finance,trading,markets',
    capability_summary: 'Generate trading plans with strategy risk management and portfolio analysis',
    trigger_patterns: 'when user needs trading plans investment strategies or portfolio analysis',
    keywords: 'generate,plans,investment,strategies',
    use_cases: 'architecture design;implementation planning',
  },
  'agent:accessibility-compliance': {
    intent_tags: 'accessibility,a11y,compliance,wcag,aria,screen-reader,inclusive',
    domain_tags: 'accessibility,web,compliance',
    capability_summary: 'Accessibility compliance agent for WCAG auditing ARIA implementation and a11y testing',
    trigger_patterns: 'when user needs accessibility auditing WCAG compliance or ARIA implementation',
    tech_stack: 'http,rest',
    use_cases: 'a11y;screen reader',
  },
  'agent:agent-orchestration': {
    intent_tags: 'agent,orchestration,multi-agent,workflow,coordination,pipeline',
    domain_tags: 'agents,orchestration,automation',
    capability_summary: 'Multi-agent orchestration with workflow coordination and pipeline management',
    trigger_patterns: 'when user needs multi-agent orchestration workflow coordination or agent pipelines',
  },
  'agent:agent-teams': {
    intent_tags: 'agent,teams,collaboration,multi-agent,roles,delegation',
    domain_tags: 'agents,teams,collaboration',
    capability_summary: 'Agent team management with role delegation and collaborative task execution',
    trigger_patterns: 'when user needs agent team collaboration role-based delegation or multi-agent teamwork',
    keywords: 'team,role,collaborative,task,role-based',
  },
  'agent:api-testing-observability': {
    intent_tags: 'api,testing,observability,monitoring,tracing,health-check',
    domain_tags: 'api,testing,observability',
    capability_summary: 'API testing and observability with health checks tracing and monitoring dashboards',
    trigger_patterns: 'when user needs API testing observability setup or endpoint monitoring',
    keywords: 'health,checks,dashboards,setup,endpoint',
    tech_stack: 'rest,openapi,jest,vitest,pytest',
    use_cases: 'API design;create endpoints;write unit tests;increase test coverage',
  },
  'agent:arm-cortex-microcontrollers': {
    intent_tags: 'arm,cortex,embedded,microcontroller,firmware,iot,rtos',
    domain_tags: 'embedded,arm,firmware',
    capability_summary: 'ARM Cortex microcontroller development with firmware RTOS and embedded programming',
    trigger_patterns: 'when user needs ARM Cortex microcontroller firmware or embedded systems development',
  },
  'agent:backend-api-security': {
    intent_tags: 'backend,api,security,auth,owasp,jwt,rate-limit',
    domain_tags: 'security,backend,api',
    capability_summary: 'Backend API security with authentication rate limiting and OWASP protection',
    trigger_patterns: 'when user needs API security authentication setup or backend security hardening',
    keywords: 'authentication,rate,limiting,protection,setup,hardening',
    tech_stack: 'owasp,cve,rest,openapi',
    use_cases: 'API design;create endpoints;security audit;vulnerability scan',
  },
  'agent:backend-development': {
    intent_tags: 'backend,development,server,api,node,express,architecture',
    domain_tags: 'backend,server,api',
    capability_summary: 'Backend development agent for server-side API architecture and implementation',
    trigger_patterns: 'when user needs backend server development API architecture or server-side coding',
    tech_stack: 'rest,openapi',
  },
  'agent:blockchain-web3': {
    intent_tags: 'blockchain,web3,smart-contract,solidity,ethereum,defi,nft',
    domain_tags: 'blockchain,web3,ethereum',
    capability_summary: 'Blockchain and Web3 development with smart contracts Solidity and DeFi patterns',
    trigger_patterns: 'when user needs blockchain development smart contracts Web3 or Solidity programming',
    keywords: 'smart,contracts,patterns',
  },
  'agent:business-analytics': {
    intent_tags: 'business,analytics,data,dashboard,kpi,reporting,metrics',
    domain_tags: 'business,analytics,data',
    capability_summary: 'Business analytics with KPI dashboards reporting and data-driven insights',
    trigger_patterns: 'when user needs business analytics KPI dashboards or data reporting setup',
    keywords: 'dashboards,data-driven,insights,setup',
  },
  'agent:c4-architecture': {
    intent_tags: 'c4,architecture,diagram,system-design,modeling,context,container',
    domain_tags: 'architecture,c4,design',
    capability_summary: 'C4 architecture modeling with context container component and code diagrams',
    trigger_patterns: 'when user needs C4 architecture diagrams system modeling or design documentation',
    keywords: 'component,diagrams,documentation',
  },
  'agent:codebase-cleanup': {
    intent_tags: 'cleanup,codebase,dead-code,lint,hygiene,unused,technical-debt',
    domain_tags: 'quality,cleanup,maintenance',
    capability_summary: 'Codebase cleanup agent for removing dead code fixing lint issues and reducing tech debt',
    trigger_patterns: 'when user needs codebase cleanup dead code removal or technical debt reduction',
    tech_stack: 'linter,analyzer',
  },
  'agent:comprehensive-review': {
    intent_tags: 'review,comprehensive,audit,quality,deep,thorough,analysis',
    domain_tags: 'quality,review,audit',
    capability_summary: 'Comprehensive code and project review with deep quality and architecture analysis',
    trigger_patterns: 'when user needs a thorough comprehensive code review or project quality audit',
    tech_stack: 'linter,analyzer,diff,pr-review',
    use_cases: 'code review;identify issues;code audit;quality assessment',
  },
  'agent:conductor': {
    intent_tags: 'conductor,orchestrator,workflow,pipeline,automation,dispatch',
    domain_tags: 'orchestration,workflow,automation',
    capability_summary: 'Conductor agent for orchestrating complex multi-step workflows and pipelines',
    trigger_patterns: 'when user needs workflow orchestration pipeline management or task conductor setup',
  },
  'agent:content-marketing': {
    intent_tags: 'content,marketing,strategy,blog,seo,editorial,publishing',
    domain_tags: 'marketing,content,strategy',
    capability_summary: 'Content marketing agent for blog strategy editorial planning and SEO content',
    trigger_patterns: 'when user needs content marketing strategy blog planning or SEO-driven content',
  },
  'agent:context-management': {
    intent_tags: 'context,management,memory,state,session,persistence,window',
    domain_tags: 'context,memory,management',
    capability_summary: 'Context and memory management for maintaining state across agent sessions',
    trigger_patterns: 'when user needs context management memory persistence or session state handling',
    keywords: 'maintaining,sessions',
  },
  'agent:customer-sales-automation': {
    intent_tags: 'customer,sales,automation,crm,pipeline,lead,outreach',
    domain_tags: 'sales,crm,automation',
    capability_summary: 'Customer sales automation with CRM pipeline management and lead nurturing',
    trigger_patterns: 'when user needs sales automation CRM pipeline setup or customer outreach workflows',
    keywords: 'nurturing,setup',
  },
  'agent:data-engineering': {
    intent_tags: 'data,engineering,pipeline,etl,warehouse,transform,ingest',
    domain_tags: 'data,engineering,pipeline',
    capability_summary: 'Data engineering with ETL pipelines data warehouse design and transformation',
    trigger_patterns: 'when user needs data engineering ETL pipelines or data warehouse architecture',
  },
  'agent:data-validation-suite': {
    intent_tags: 'data,validation,quality,schema,integrity,checks,rules',
    domain_tags: 'data,validation,quality',
    capability_summary: 'Data validation suite with schema checks integrity rules and quality assurance',
    trigger_patterns: 'when user needs data validation schema checks or data quality assurance',
    keywords: 'suite,assurance',
    tech_stack: 'linter,analyzer',
  },
  'agent:database-cloud-optimization': {
    intent_tags: 'database,cloud,optimization,scaling,cost,performance,tuning',
    domain_tags: 'database,cloud,optimization',
    capability_summary: 'Cloud database optimization with scaling strategies cost reduction and performance tuning',
    trigger_patterns: 'when user needs cloud database optimization scaling or cost reduction strategies',
    keywords: 'strategies,reduction',
    tech_stack: 'sql,orm,profiler,benchmark',
    use_cases: 'database design;schema migration',
  },
  'agent:deployment-strategies': {
    intent_tags: 'deployment,strategies,blue-green,canary,rollout,zero-downtime',
    domain_tags: 'deployment,devops,strategies',
    capability_summary: 'Deployment strategy planning with blue-green canary and zero-downtime rollout patterns',
    trigger_patterns: 'when user needs deployment strategies blue-green canary or zero-downtime rollout planning',
    keywords: 'strategy,patterns',
    tech_stack: 'ci,cd,pipeline',
  },
  'agent:deployment-validation': {
    intent_tags: 'deployment,validation,smoke-test,health,verify,post-deploy',
    domain_tags: 'deployment,validation,devops',
    capability_summary: 'Post-deployment validation with smoke tests health checks and verification',
    trigger_patterns: 'when user needs deployment validation smoke testing or post-deploy health checks',
    keywords: 'post-deployment,smoke,checks,verification',
    tech_stack: 'ci,cd,pipeline',
  },
  'agent:developer-essentials': {
    intent_tags: 'developer,essentials,tools,productivity,workflow,setup,config',
    domain_tags: 'development,tools,productivity',
    capability_summary: 'Developer essentials toolkit for productivity tools workflow setup and configuration',
    trigger_patterns: 'when user needs developer productivity tools workflow optimization or environment setup',
    keywords: 'toolkit,configuration,optimization,environment',
  },
  'agent:distributed-debugging': {
    intent_tags: 'distributed,debugging,microservices,tracing,logs,correlation',
    domain_tags: 'debugging,distributed,microservices',
    capability_summary: 'Distributed system debugging with trace correlation log analysis and microservice diagnosis',
    trigger_patterns: 'when user needs distributed debugging microservice tracing or cross-service log analysis',
    keywords: 'trace,microservice,diagnosis,cross-service',
    use_cases: 'debug errors;isolate issues',
  },
  'agent:documentation-generation': {
    intent_tags: 'documentation,generation,auto-doc,api-docs,readme,javadoc',
    domain_tags: 'documentation,generation,automation',
    capability_summary: 'Automated documentation generation for APIs READMEs and code documentation',
    trigger_patterns: 'when user needs automated documentation generation API docs or README creation',
    keywords: 'apis,readmes,docs,creation',
    use_cases: 'write documentation;update README',
  },
  'agent:dotnet-contribution': {
    intent_tags: 'dotnet,csharp,contribution,aspnet,nuget,entity-framework',
    domain_tags: 'dotnet,csharp,aspnet',
    capability_summary: '.NET and C# development agent for ASP.NET Entity Framework and NuGet workflows',
    trigger_patterns: 'when user is working on .NET C# ASP.NET or Entity Framework projects',
  },
  'agent:error-diagnostics': {
    intent_tags: 'error,diagnostics,analysis,root-cause,triage,classification',
    domain_tags: 'debugging,diagnostics,error',
    capability_summary: 'Error diagnostics agent for root cause analysis triage and error classification',
    trigger_patterns: 'when user needs error diagnostics root cause analysis or automated error triage',
    keywords: 'root,cause',
    use_cases: 'error handling;error tracking',
  },
  'agent:framework-migration': {
    intent_tags: 'framework,migration,upgrade,transition,compatibility,breaking-changes',
    domain_tags: 'migration,framework,upgrade',
    capability_summary: 'Framework migration agent for version upgrades breaking change resolution and transitions',
    trigger_patterns: 'when user needs to migrate frameworks upgrade versions or resolve breaking changes',
    keywords: 'version,upgrades,breaking,change,resolution',
    tech_stack: 'alembic,flyway',
    use_cases: 'schema migration;data migration',
  },
  'agent:frontend-mobile-development': {
    intent_tags: 'frontend,mobile,react-native,flutter,responsive,cross-platform',
    domain_tags: 'frontend,mobile,cross-platform',
    capability_summary: 'Frontend and mobile development with React Native Flutter and cross-platform patterns',
    trigger_patterns: 'when user needs mobile app development React Native Flutter or cross-platform frontend',
    keywords: 'react,native,patterns',
    tech_stack: 'html,css,javascript',
    use_cases: 'frontend development;component build',
  },
  'agent:frontend-mobile-security': {
    intent_tags: 'frontend,mobile,security,xss,csp,csrf,sanitization',
    domain_tags: 'security,frontend,mobile',
    capability_summary: 'Frontend and mobile security with XSS prevention CSP configuration and CSRF protection',
    trigger_patterns: 'when user needs frontend security XSS prevention or mobile app security hardening',
    keywords: 'prevention,configuration,protection,hardening',
    tech_stack: 'owasp,cve,html,css,javascript',
    use_cases: 'frontend development;component build;security audit;vulnerability scan',
  },
  'agent:full-stack-orchestration': {
    intent_tags: 'fullstack,orchestration,frontend,backend,integration,end-to-end',
    domain_tags: 'fullstack,orchestration,integration',
    capability_summary: 'Full-stack orchestration agent for coordinating frontend backend and integration layers',
    trigger_patterns: 'when user needs full-stack orchestration end-to-end integration or frontend-backend coordination',
    keywords: 'full-stack,coordinating,layers,frontend-backend,coordination',
    use_cases: 'frontend development;component build',
  },
  'agent:functional-programming': {
    intent_tags: 'functional,programming,fp,immutable,pure,monad,composition',
    domain_tags: 'functional,programming,patterns',
    capability_summary: 'Functional programming patterns with immutability composition and pure function design',
    trigger_patterns: 'when user needs functional programming patterns monads or immutable design help',
    keywords: 'immutability,function,monads',
  },
  'agent:game-development': {
    intent_tags: 'game,development,unity,godot,gamedev,engine,mechanics',
    domain_tags: 'game,development,engine',
    capability_summary: 'Game development agent for Unity Godot game mechanics and interactive systems',
    trigger_patterns: 'when user needs game development help with Unity Godot or game mechanics design',
  },
  'agent:hr-legal-compliance': {
    intent_tags: 'hr,legal,compliance,policy,gdpr,privacy,regulation',
    domain_tags: 'legal,compliance,hr',
    capability_summary: 'HR and legal compliance agent for policy generation GDPR and regulatory requirements',
    trigger_patterns: 'when user needs HR legal compliance policy generation or GDPR regulatory guidance',
    keywords: 'regulatory,requirements,guidance',
  },
  'agent:incident-response': {
    intent_tags: 'incident,response,sre,postmortem,alert,escalation,runbook',
    domain_tags: 'sre,incident,devops',
    capability_summary: 'Incident response agent with runbook execution escalation and postmortem analysis',
    trigger_patterns: 'when user needs incident response runbooks escalation workflows or postmortem analysis',
    tech_stack: 'ci,cd,pipeline',
  },
  'agent:julia-development': {
    intent_tags: 'julia,scientific,computing,numerical,data,performance,math',
    domain_tags: 'julia,scientific,computing',
    capability_summary: 'Julia development agent for scientific computing numerical analysis and data processing',
    trigger_patterns: 'when user is working on Julia projects scientific computing or numerical programming',
  },
  'agent:jvm-languages': {
    intent_tags: 'jvm,java,kotlin,scala,gradle,maven,spring',
    domain_tags: 'jvm,java,kotlin',
    capability_summary: 'JVM language development agent for Java Kotlin Scala with Spring and Gradle',
    trigger_patterns: 'when user is working on JVM projects Java Kotlin Scala or Spring applications',
    tech_stack: 'maven',
  },
  'agent:kubernetes-operations': {
    intent_tags: 'kubernetes,k8s,devops,container,helm,deploy,cluster',
    domain_tags: 'kubernetes,devops,container',
    capability_summary: 'Kubernetes operations agent for cluster management Helm deployments and container orchestration',
    trigger_patterns: 'when user needs Kubernetes cluster management Helm charts or container orchestration',
    keywords: 'operations,deployments,orchestration,charts',
    tech_stack: 'k8s,helm,ci,cd,pipeline',
    use_cases: 'K8s deployment;pod configuration',
  },
  'agent:llm-application-dev': {
    intent_tags: 'llm,application,ai,rag,agent,prompt,chain',
    domain_tags: 'ai,llm,application',
    capability_summary: 'LLM application development with RAG agent design and prompt engineering',
    trigger_patterns: 'when user needs to build LLM applications RAG systems or AI agent architectures',
    keywords: 'engineering,architectures',
  },
  'agent:machine-learning-ops': {
    intent_tags: 'mlops,ml,training,deployment,pipeline,model,inference',
    domain_tags: 'ml,mlops,data-science',
    capability_summary: 'MLOps agent for model training deployment pipelines and ML infrastructure',
    trigger_patterns: 'when user needs MLOps model training pipelines or ML deployment infrastructure',
  },
  'agent:multi-platform-apps': {
    intent_tags: 'multi-platform,cross-platform,desktop,mobile,web,electron,tauri',
    domain_tags: 'cross-platform,desktop,mobile',
    capability_summary: 'Multi-platform app development with Electron Tauri and cross-platform frameworks',
    trigger_patterns: 'when user needs multi-platform app development Electron Tauri or cross-platform solutions',
  },
  'agent:observability-monitoring': {
    intent_tags: 'observability,monitoring,logging,metrics,tracing,grafana,prometheus',
    domain_tags: 'observability,monitoring,devops',
    capability_summary: 'Observability stack setup with logging metrics tracing Grafana and Prometheus',
    trigger_patterns: 'when user needs observability monitoring setup Grafana dashboards or logging infrastructure',
    keywords: 'stack,setup,dashboards,infrastructure',
    tech_stack: 'prometheus,grafana,ci,cd,pipeline',
  },
  'agent:payment-processing': {
    intent_tags: 'payment,processing,stripe,billing,checkout,subscription,webhook',
    domain_tags: 'payment,billing,ecommerce',
    capability_summary: 'Payment processing integration with Stripe billing subscriptions and checkout flows',
    trigger_patterns: 'when user needs payment processing Stripe integration or billing system setup',
    keywords: 'integration,subscriptions,flows,setup',
  },
  'agent:performance-testing-review': {
    intent_tags: 'performance,testing,load,benchmark,stress,k6,artillery',
    domain_tags: 'performance,testing,benchmark',
    capability_summary: 'Performance testing with load benchmarking stress testing and bottleneck analysis',
    trigger_patterns: 'when user needs performance testing load testing or benchmark analysis',
    keywords: 'benchmarking,bottleneck',
    tech_stack: 'profiler,apm,jest,vitest,pytest',
    use_cases: 'optimize performance;reduce latency;write unit tests;increase test coverage',
  },
  'agent:quantitative-trading': {
    intent_tags: 'quant,trading,finance,algorithm,backtest,strategy,market',
    domain_tags: 'finance,trading,quantitative',
    capability_summary: 'Quantitative trading agent for algorithmic strategies backtesting and market analysis',
    trigger_patterns: 'when user needs quantitative trading algorithms backtesting or market analysis tools',
    keywords: 'algorithmic,strategies,backtesting,algorithms',
  },
  'agent:reverse-engineering': {
    intent_tags: 'reverse-engineering,binary,decompile,analysis,disassembly,forensics',
    domain_tags: 'security,reverse-engineering,analysis',
    capability_summary: 'Reverse engineering agent for binary analysis decompilation and forensic investigation',
    trigger_patterns: 'when user needs reverse engineering binary analysis or decompilation assistance',
    keywords: 'reverse,engineering,decompilation,forensic,investigation',
    tech_stack: 'owasp,cve',
  },
  'agent:security-compliance': {
    intent_tags: 'security,compliance,soc2,iso,policy,audit,governance',
    domain_tags: 'security,compliance,governance',
    capability_summary: 'Security compliance agent for SOC2 ISO auditing and governance policy creation',
    trigger_patterns: 'when user needs security compliance SOC2 ISO auditing or governance policies',
    keywords: 'compliance-check,soc2,gdpr,hipaa,policy-enforcement',
    tech_stack: 'owasp,cve',
    use_cases: 'security audit;vulnerability scan',
  },
  'agent:seo-analysis-monitoring': {
    intent_tags: 'seo,analysis,monitoring,ranking,tracking,serp,keywords',
    domain_tags: 'seo,analysis,monitoring',
    capability_summary: 'SEO analysis and monitoring agent for ranking tracking SERP analysis and keyword monitoring',
    trigger_patterns: 'when user needs SEO ranking monitoring SERP analysis or keyword tracking',
    tech_stack: 'prometheus,grafana',
    use_cases: 'search optimization;meta tags',
  },
  'agent:seo-content-creation': {
    intent_tags: 'seo,content,creation,writing,keywords,optimization,blog',
    domain_tags: 'seo,content,writing',
    capability_summary: 'SEO content creation agent for keyword-optimized articles and blog writing',
    trigger_patterns: 'when user needs SEO-optimized content creation keyword articles or blog writing',
    keywords: 'keyword-optimized,articles,seo-optimized,keyword',
    use_cases: 'search optimization;meta tags',
  },
  'agent:seo-technical-optimization': {
    intent_tags: 'seo,technical,optimization,crawl,indexing',
    domain_tags: 'seo,technical',
    capability_summary: 'Technical SEO optimization agent for site speed crawl efficiency and indexing',
    trigger_patterns: 'when user needs technical SEO optimization site speed or crawl improvements',
    keywords: 'site,speed,efficiency,improvements',
    use_cases: 'search optimization;meta tags',
  },
  'agent:shell-scripting': {
    intent_tags: 'shell,scripting,bash,zsh,automation,cli,devops',
    domain_tags: 'shell,scripting,automation',
    capability_summary: 'Shell scripting agent for bash/zsh automation CLI tools and system administration',
    trigger_patterns: 'when user needs shell scripts bash automation or CLI tool development',
    keywords: 'bashzsh,administration,scripts',
  },
  'agent:startup-business-analyst': {
    intent_tags: 'startup,business,analysis,strategy,market,competitive,research',
    domain_tags: 'business,startup,analysis',
    capability_summary: 'Startup business analysis with market research competitive strategy and growth planning',
    trigger_patterns: 'when user needs startup business analysis market research or competitive strategy',
  },
  'agent:systems-programming': {
    intent_tags: 'systems,programming,rust,c,low-level,memory,performance',
    domain_tags: 'systems,programming,rust,c',
    capability_summary: 'Systems programming agent for Rust C low-level memory management and performance',
    trigger_patterns: 'when user needs systems programming Rust C low-level coding or memory management',
    tech_stack: 'cargo',
  },
  'agent:team-collaboration': {
    intent_tags: 'team,collaboration,workflow,communication,project,standup,sprint',
    domain_tags: 'team,collaboration,project',
    capability_summary: 'Team collaboration agent for project workflows standups and communication optimization',
    trigger_patterns: 'when user needs team collaboration workflow optimization or project management setup',
    keywords: 'standups,optimization,setup',
  },
  'agent:web-scripting': {
    intent_tags: 'web,scripting,scraping,automation,crawl,extract,parse',
    domain_tags: 'web,scripting,automation',
    capability_summary: 'Web scripting agent for scraping data extraction and web automation tasks',
    trigger_patterns: 'when user needs web scraping data extraction or web automation scripting',
    keywords: 'data,extraction,tasks',
    tech_stack: 'http,rest',
  },
  'skill:audit-website': {
    intent_tags: 'audit,website,accessibility,performance,seo,security,quality',
    domain_tags: 'audit,web,quality',
    capability_summary: 'Comprehensive website audit covering accessibility performance SEO and security',
    trigger_patterns: 'when user needs a comprehensive website audit covering accessibility performance and SEO',
    tech_stack: 'http,rest,linter,analyzer',
    use_cases: 'code audit;quality assessment;a11y;screen reader',
  },
  'agent:academic-researcher': {
    intent_tags: 'academic,research,paper,literature,citation,review,scholar',
    domain_tags: 'research,academic,paper',
    capability_summary: 'Academic research agent for literature review paper analysis and citation management',
    trigger_patterns: 'when user needs academic research literature review or paper analysis assistance',
  },
  'agent:code-reviewer': {
    intent_tags: 'code,reviewer,quality,bugs,analysis,patterns,best-practices',
    domain_tags: 'quality,review,code',
    capability_summary: 'Code review agent for bug detection quality analysis and best practice enforcement',
    trigger_patterns: 'when user needs automated code review bug detection or quality analysis',
    keywords: 'detection,practice,enforcement',
    tech_stack: 'linter,analyzer,diff,pr-review',
  },
  'agent:content-creator': {
    intent_tags: 'content,creator,writing,generate,creative,article,blog',
    domain_tags: 'content,writing,creative',
    capability_summary: 'Content creation agent for articles blog posts and creative writing generation',
    trigger_patterns: 'when user needs content creation article writing or creative content generation',
    keywords: 'creation,articles,posts',
  },
  'agent:data-analyst': {
    intent_tags: 'data,analyst,analysis,visualization,statistics,charts,insights',
    domain_tags: 'data,analysis,visualization',
    capability_summary: 'Data analysis agent with statistical analysis visualization and insight generation',
    trigger_patterns: 'when user needs data analysis statistical processing or data visualization',
    keywords: 'statistical,insight,processing',
  },
  'agent:debugger': {
    intent_tags: 'debugger,bug,fix,error,diagnosis,trace,root-cause',
    domain_tags: 'debugging,error,fix',
    capability_summary: 'Debugging agent for automated bug diagnosis error tracing and fix suggestions',
    trigger_patterns: 'when user needs automated debugging bug diagnosis or error tracing',
    keywords: 'tracing,suggestions',
    use_cases: 'debug errors;fix bugs',
  },
  'agent:decision-helper': {
    intent_tags: 'decision,helper,analysis,pros-cons,evaluate,compare,trade-off',
    domain_tags: 'decision,analysis,evaluation',
    capability_summary: 'Decision analysis helper with pros/cons evaluation trade-off comparison and recommendations',
    trigger_patterns: 'when user needs help making decisions evaluating options or comparing trade-offs',
    keywords: 'proscons,comparison,recommendations,making,decisions,evaluating',
  },
  'agent:deep-research': {
    intent_tags: 'research,deep,investigation,analysis,comprehensive,web,synthesis',
    domain_tags: 'research,investigation,analysis',
    capability_summary: 'Deep research agent for comprehensive investigation web analysis and synthesis',
    trigger_patterns: 'when user needs deep research comprehensive investigation or thorough analysis',
  },
  'agent:editor': {
    intent_tags: 'editor,writing,proofread,grammar,style,clarity,tone',
    domain_tags: 'writing,editing,quality',
    capability_summary: 'Writing editor agent for proofreading grammar correction style and clarity improvement',
    trigger_patterns: 'when user needs writing editing proofreading or grammar correction',
    keywords: 'proofreading,correction,improvement',
    tech_stack: 'linter,analyzer',
  },
  'agent:email-drafter': {
    intent_tags: 'email,drafter,writing,professional,communication,template,reply',
    domain_tags: 'email,writing,communication',
    capability_summary: 'Email drafting agent for professional communication templates and reply composition',
    trigger_patterns: 'when user needs email drafting professional communication or email template creation',
    keywords: 'drafting,templates,composition,creation',
  },
  'agent:fact-checker': {
    intent_tags: 'fact-check,verify,accuracy,claims,source,evidence,truth',
    domain_tags: 'fact-check,verification,accuracy',
    capability_summary: 'Fact-checking agent for verifying claims checking sources and assessing accuracy',
    trigger_patterns: 'when user needs fact-checking claim verification or source accuracy assessment',
    keywords: 'fact-checking,verifying,checking,sources,assessing',
  },
  'agent:fullstack-developer': {
    intent_tags: 'fullstack,developer,frontend,backend,web,react,node',
    domain_tags: 'fullstack,web,development',
    capability_summary: 'Full-stack developer agent for frontend backend and complete web application building',
    trigger_patterns: 'when user needs full-stack web development frontend and backend integration',
    keywords: 'full-stack,complete,integration',
    tech_stack: 'http,rest',
    use_cases: 'frontend development;component build',
  },
  'agent:meeting-notes': {
    intent_tags: 'meeting,notes,summary,action-items,minutes,transcript,decisions',
    domain_tags: 'meeting,notes,productivity',
    capability_summary: 'Meeting notes agent for summarizing discussions extracting action items and decisions',
    trigger_patterns: 'when user needs meeting notes summaries action item extraction or minutes generation',
    keywords: 'summarizing,discussions,extracting,action,items',
  },
  'agent:project-planner': {
    intent_tags: 'project,planner,roadmap,timeline,milestones,tasks,breakdown',
    domain_tags: 'project,planning,management',
    capability_summary: 'Project planning agent for roadmaps timeline creation and milestone task breakdown',
    trigger_patterns: 'when user needs project planning roadmap creation or task breakdown with milestones',
    keywords: 'roadmaps,creation,milestone,task',
    tech_stack: 'architecture',
  },
  'agent:python-expert': {
    intent_tags: 'python,expert,advanced,optimization,patterns,best-practices',
    domain_tags: 'python,expert,development',
    capability_summary: 'Python expert agent for advanced patterns optimization and best practice guidance',
    trigger_patterns: 'when user needs expert Python advice advanced patterns or performance optimization',
    keywords: 'practice,guidance,advice,performance',
    tech_stack: 'pip',
  },
  'agent:sprint-planner': {
    intent_tags: 'sprint,planner,agile,scrum,backlog,estimation,velocity',
    domain_tags: 'agile,sprint,planning',
    capability_summary: 'Sprint planning agent for backlog grooming story estimation and velocity tracking',
    trigger_patterns: 'when user needs sprint planning backlog grooming or agile estimation',
    keywords: 'grooming,story,tracking',
    tech_stack: 'architecture',
  },
  'agent:strategy-advisor': {
    intent_tags: 'strategy,advisor,business,consulting,planning,analysis,recommendation',
    domain_tags: 'strategy,business,consulting',
    capability_summary: 'Strategy advisor agent for business consulting analysis and strategic recommendations',
    trigger_patterns: 'when user needs strategic business advice consulting analysis or planning guidance',
    keywords: 'strategic,recommendations,advice,guidance',
  },
  'agent:technical-writer': {
    intent_tags: 'technical,writer,documentation,api-docs,guides,tutorials,reference',
    domain_tags: 'documentation,technical-writing,guides',
    capability_summary: 'Technical writing agent for API docs user guides tutorials and reference documentation',
    trigger_patterns: 'when user needs technical writing API documentation user guides or tutorials',
    use_cases: 'write documentation;update README',
  },
  'agent:ux-designer': {
    intent_tags: 'ux,designer,user-experience,wireframe,usability,persona,journey',
    domain_tags: 'ux,design,user-experience',
    capability_summary: 'UX design agent for wireframing user research persona creation and usability analysis',
    trigger_patterns: 'when user needs UX design wireframing user research or usability analysis',
    keywords: 'wireframing,research,creation',
    use_cases: 'user experience;interaction design',
  },
  'agent:visualization-expert': {
    intent_tags: 'visualization,charts,graphs,data-viz,d3,dashboard,infographic',
    domain_tags: 'visualization,data,charts',
    capability_summary: 'Data visualization expert for charts dashboards infographics and interactive displays',
    trigger_patterns: 'when user needs data visualization charts dashboards or interactive graph creation',
    keywords: 'dashboards,infographics,interactive,displays,graph',
  },

  // ─── Plugin Skills (locally installed, no git repo) ────────────────────────
  'skill:superpowers-executing-plans': {
    intent_tags: 'execute,plan,implementation,session,review,checkpoint,step-by-step',
    domain_tags: 'planning,execution,workflow',
    capability_summary: 'Execute written implementation plans in separate sessions with review checkpoints',
    trigger_patterns: 'when user has a written implementation plan to execute with review checkpoints',
    invocation_name: 'superpowers:executing-plans',
    keywords: 'written,plans,separate,sessions,checkpoints',
    tech_stack: 'architecture',
    use_cases: 'architecture design;implementation planning',
  },
  'skill:superpowers-receiving-code-review': {
    intent_tags: 'code-review,feedback,receiving,review-response,technical-rigor,verification',
    domain_tags: 'quality,review,workflow',
    capability_summary: 'Handle received code review feedback with technical rigor and verification before implementing',
    trigger_patterns: 'when receiving code review feedback especially if unclear or technically questionable',
    invocation_name: 'superpowers:receiving-code-review',
    keywords: 'handle,received,technical,rigor,especially,unclear',
    tech_stack: 'linter,analyzer,diff,pr-review',
    use_cases: 'code review;identify issues',
  },
  'skill:superpowers-subagent-development': {
    intent_tags: 'subagent,parallel,development,independent,tasks,concurrent,delegation',
    domain_tags: 'workflow,parallel,automation',
    capability_summary: 'Execute implementation plans with independent tasks via parallel subagents',
    trigger_patterns: 'when executing plans with independent tasks that can be parallelized via subagents',
    invocation_name: 'superpowers:subagent-driven-development',
    keywords: 'execute,plans,subagents,executing,parallelized',
  },
  'skill:superpowers-finishing-branch': {
    intent_tags: 'finish,branch,merge,pr,cleanup,integrate,complete,development',
    domain_tags: 'git,workflow,integration',
    capability_summary: 'Guide completion of development branches with merge PR or cleanup options',
    trigger_patterns: 'when implementation is complete tests pass and need to decide how to integrate the work',
    invocation_name: 'superpowers:finishing-a-development-branch',
    keywords: 'completion,branches,options,pass,decide',
    tech_stack: 'github',
  },
  'skill:superpowers-writing-skills': {
    intent_tags: 'skill,write,create,edit,deploy,verify,author,markdown',
    domain_tags: 'skills,meta,authoring',
    capability_summary: 'Create edit and verify Claude Code skills before deployment',
    trigger_patterns: 'when creating new skills editing existing skills or verifying skills work before deployment',
    invocation_name: 'superpowers:writing-skills',
    keywords: 'claude,deployment,editing,existing,verifying',
    use_cases: 'create skill;extend Claude',
  },
  'skill:superpowers-parallel-agents': {
    intent_tags: 'parallel,agents,dispatch,concurrent,independent,tasks,multi-agent',
    domain_tags: 'workflow,parallel,agents',
    capability_summary: 'Dispatch parallel agents for 2+ independent tasks without shared state',
    trigger_patterns: 'when facing 2 or more independent tasks that can be worked on without shared state',
    invocation_name: 'superpowers:dispatching-parallel-agents',
    keywords: 'without,shared,state,facing,worked',
  },
  'skill:claude-api': {
    intent_tags: 'claude,api,anthropic,sdk,build,integration,tool-use,agent-sdk',
    domain_tags: 'anthropic,api,sdk,ai',
    capability_summary: 'Build apps with the Claude API or Anthropic SDK including Agent SDK',
    trigger_patterns: 'when code imports anthropic sdk or user asks to use Claude API Anthropic SDK or Agent SDK',
    invocation_name: 'claude-api',
    keywords: 'anthropic-api,claude-sdk,tool-use,messages-api',
    tech_stack: 'rest,openapi',
    use_cases: 'API design;create endpoints',
  },
  'skill:postgres-patterns': {
    intent_tags: 'postgresql,postgres,database,query,optimization,schema,indexing,security,supabase',
    domain_tags: 'postgresql,database,sql,supabase',
    capability_summary: 'PostgreSQL patterns for query optimization schema design indexing and security',
    trigger_patterns: 'when user needs PostgreSQL query optimization schema design indexing or security patterns',
    invocation_name: 'postgres-patterns',
    tech_stack: 'orm,mysql',
    use_cases: 'database design;schema migration',
  },
  'skill:multi-model-reviewer': {
    intent_tags: 'multi-model,review,openrouter,gpt,qwen,claude,code-review,architecture',
    domain_tags: 'ai,review,quality',
    capability_summary: 'Multi-model code review via OpenRouter calling Claude GPT Qwen for joint assessment',
    trigger_patterns: 'when user requests code review architecture review or multi-model multi-angle analysis',
    invocation_name: 'multi-model-reviewer',
    keywords: 'calling,joint,assessment,requests,multi-angle',
    tech_stack: 'diff,pr-review,linter,analyzer',
    use_cases: 'code review;identify issues',
  },
  'skill:build-error-resolver': {
    intent_tags: 'build,error,typescript,type-error,fix,compile,resolution,minimal',
    domain_tags: 'build,typescript,debugging',
    capability_summary: 'Fix build and TypeScript errors with minimal diffs focusing on getting build green',
    trigger_patterns: 'when build fails or type errors occur needing quick resolution with minimal changes',
    invocation_name: 'build-error-resolver',
    keywords: 'errors,diffs,focusing,getting,green,fails',
    use_cases: 'build config;bundler setup;error handling;error tracking',
  },
  'skill:perplexity-search': {
    intent_tags: 'search,web,perplexity,latest,best-practice,documentation,solution',
    domain_tags: 'search,web,ai',
    capability_summary: 'Web search via Perplexity AI for latest programming resources and solutions',
    trigger_patterns: 'when needing latest API docs best practices tool recommendations or searching solutions online',
    invocation_name: 'perplexity-search',
    keywords: 'resources,solutions,needing,docs,recommendations',
    tech_stack: 'http,rest',
  },
  'skill:claude-code-plugin-dev': {
    intent_tags: 'plugin,claude-code,marketplace,mcp,hooks,commands,develop,publish',
    domain_tags: 'claude,plugin,mcp,development',
    capability_summary: 'Create and publish Claude Code plugins with correct metadata format and marketplace support',
    trigger_patterns: 'when building Claude Code plugins getting plugin install errors or packaging MCP servers as plugins',
    invocation_name: 'claude-code-plugin-dev',
    keywords: 'plugin-dev,marketplace,plugin-json,hooks-json,mcp-config',
    tech_stack: 'claude-code,mcp-sdk,json-rpc',
  },
  'skill:npm-cross-platform-release': {
    intent_tags: 'npm,publish,release,cross-platform,binary,github-actions,npx',
    domain_tags: 'npm,release,cicd',
    capability_summary: 'Cross-platform binary build and npm publish via GitHub Actions with npx support',
    trigger_patterns: 'when user needs to publish npm packages set up cross-platform binary distribution or CI/CD release',
    invocation_name: 'npm-cross-platform-release',
    keywords: 'github,actions,packages,distribution',
    use_cases: 'deploy to production;release management',
  },
  'skill:fullstack-qa': {
    intent_tags: 'qa,fullstack,automation,test,browser,api,ui,e2e,visual,curl',
    domain_tags: 'testing,qa,browser,web',
    capability_summary: 'Fullstack automated testing: test suite curl API browser function UI visual review',
    trigger_patterns: 'when user needs fullstack testing QA automation browser testing API testing or UI visual review',
    invocation_name: 'fullstack-qa',
    keywords: 'suite,function,review',
    tech_stack: 'jest,vitest,pytest,chromium,playwright',
  },
  'skill:strategic-compact': {
    intent_tags: 'compact,context,memory,compression,preserve,manual,window',
    domain_tags: 'context,workflow,memory',
    capability_summary: 'Manual context compaction at logical intervals to preserve context through task phases',
    trigger_patterns: 'when context window is getting full and need strategic compaction to preserve important context',
    invocation_name: 'strategic-compact',
    keywords: 'compaction,logical,intervals,task,phases,getting',
  },
  'skill:keybindings-help': {
    intent_tags: 'keybindings,keyboard,shortcuts,rebind,customize,chord,keys',
    domain_tags: 'claude,config,keyboard',
    capability_summary: 'Customize Claude Code keyboard shortcuts rebind keys and add chord bindings',
    trigger_patterns: 'when user wants to customize keyboard shortcuts rebind keys or modify keybindings',
    invocation_name: 'keybindings-help',
    keywords: 'bindings,modify',
    tech_stack: 'claude-code',
  },
  'skill:simplify': {
    intent_tags: 'simplify,refactor,reuse,quality,efficiency,review,clean,code',
    domain_tags: 'quality,refactoring,code',
    capability_summary: 'Review changed code for reuse quality and efficiency then fix any issues found',
    trigger_patterns: 'when user wants to review and simplify recently changed code for quality and efficiency',
    invocation_name: 'simplify',
    keywords: 'changed,found,recently',
    tech_stack: 'linter,analyzer',
    use_cases: 'simplify code;reduce complexity;refactor code',
  },
  'skill:loop': {
    intent_tags: 'loop,recurring,interval,poll,schedule,repeat,monitor,cron',
    domain_tags: 'automation,workflow,scheduling',
    capability_summary: 'Run a prompt or slash command on a recurring interval for monitoring or polling',
    trigger_patterns: 'when user wants to set up a recurring task poll for status or run something repeatedly',
    invocation_name: 'loop',
    keywords: 'prompt,slash,command,polling,task',
  },
  'skill:feature-dev': {
    intent_tags: 'feature,development,guided,architecture,codebase,implementation,design',
    domain_tags: 'development,architecture,workflow',
    capability_summary: 'Guided feature development with codebase understanding and architecture focus',
    trigger_patterns: 'when user needs guided feature development with architecture analysis and codebase understanding',
    invocation_name: 'feature-dev:feature-dev',
    keywords: 'understanding,focus',
  },
  'skill:mem-search': {
    intent_tags: 'memory,search,manage,recall,observations,sessions,prompts,history',
    domain_tags: 'memory,ai,claude,search',
    capability_summary: 'Search and manage project memory including observations sessions and prompts',
    trigger_patterns: 'when user wants to search memory recall past work manage observations or browse session history',
    invocation_name: 'claude-mem-lite:mem',
    keywords: 'past,browse,session',
    tech_stack: 'claude-code',
  },

  // ─── Plugin Commands as Skills ─────────────────────────────────────────────
  'skill:commit-clean-gone': {
    intent_tags: 'git,clean,branch,gone,remote,prune,worktree,cleanup',
    domain_tags: 'git,cleanup,branch',
    capability_summary: 'Clean up git branches marked as gone with associated worktree removal',
    trigger_patterns: 'when user needs to clean up deleted remote branches or prune gone branches',
    invocation_name: 'commit-commands:clean_gone',
    keywords: 'branches,marked,associated,removal,deleted',
    tech_stack: 'github',
    use_cases: 'git workflow;version control;refactor code;reduce complexity',
  },
  'skill:commit': {
    intent_tags: 'git,commit,save,stage,message,changes',
    domain_tags: 'git,workflow',
    capability_summary: 'Create a git commit with staged changes',
    trigger_patterns: 'when user wants to create a git commit',
    invocation_name: 'commit-commands:commit',
    tech_stack: 'github',
    use_cases: 'git workflow;version control;create commits;open PRs',
  },
  'skill:commit-push-pr': {
    intent_tags: 'git,commit,push,pr,pull-request,merge,publish',
    domain_tags: 'git,workflow,github',
    capability_summary: 'Commit push and open a pull request in one workflow',
    trigger_patterns: 'when user wants to commit push and create a PR in one step',
    invocation_name: 'commit-commands:commit-push-pr',
    keywords: 'open,pull,request,step',
    use_cases: 'git workflow;version control;create commits;open PRs',
  },
  'skill:ralph-cancel': {
    intent_tags: 'ralph,cancel,stop,loop,session,abort',
    domain_tags: 'ralph,workflow,automation',
    capability_summary: 'Cancel an active Ralph Loop session',
    trigger_patterns: 'when user wants to cancel or stop an active Ralph Loop',
    invocation_name: 'ralph-loop:cancel-ralph',
  },
  'skill:ralph-help': {
    intent_tags: 'ralph,help,explain,commands,usage,documentation',
    domain_tags: 'ralph,workflow,help',
    capability_summary: 'Explain Ralph Loop plugin and list available commands',
    trigger_patterns: 'when user asks about Ralph Loop what it does or how to use it',
    invocation_name: 'ralph-loop:help',
    keywords: 'loop,plugin,list,available,asks,what',
  },
  'skill:ralph-loop-start': {
    intent_tags: 'ralph,loop,start,autonomous,session,continuous',
    domain_tags: 'ralph,workflow,automation',
    capability_summary: 'Start Ralph Loop for autonomous continuous session execution',
    trigger_patterns: 'when user wants to start Ralph Loop for continuous autonomous work',
    invocation_name: 'ralph-loop:ralph-loop',
  },
  'skill:gsd-resume': {
    intent_tags: 'gsd,resume,continue,restore,state,project,workspace',
    domain_tags: 'gsd,project,workflow',
    capability_summary: 'Resume project execution from saved state with workspace validation',
    trigger_patterns: 'when user wants to resume a paused GSD project from saved state',
    invocation_name: 'gsd:resume',
    keywords: 'saved,validation,paused',
  },
  'skill:gsd-start': {
    intent_tags: 'gsd,start,project,requirements,plan,discuss,execute',
    domain_tags: 'gsd,project,workflow',
    capability_summary: 'Interactive project start — discuss requirements research plan then auto-execute',
    trigger_patterns: 'when user wants to start a new GSD project with discussion planning and execution',
    invocation_name: 'gsd:start',
    keywords: 'interactive,research,auto-execute,discussion',
  },
  'skill:gsd-stop': {
    intent_tags: 'gsd,stop,pause,save,state,checkpoint',
    domain_tags: 'gsd,project,workflow',
    capability_summary: 'Save current GSD project state and pause execution',
    trigger_patterns: 'when user wants to pause or stop a GSD project and save progress',
    invocation_name: 'gsd:stop',
    keywords: 'current,progress',
  },
  'skill:gsd-prd': {
    intent_tags: 'gsd,prd,requirements,document,description,spec,start',
    domain_tags: 'gsd,project,requirements',
    capability_summary: 'Start GSD project from a requirements document or description text',
    trigger_patterns: 'when user has a PRD or requirements document and wants to start a GSD project from it',
    invocation_name: 'gsd:prd',
  },
  'skill:gsd-status': {
    intent_tags: 'gsd,status,progress,overview,dashboard,state',
    domain_tags: 'gsd,project,monitoring',
    capability_summary: 'Display GSD project progress overview from canonical state fields',
    trigger_patterns: 'when user wants to see GSD project status progress or current state',
    invocation_name: 'gsd:status',
    keywords: 'display,canonical,fields,current',
    tech_stack: 'prometheus,grafana',
  },

  // ─── Plugin Agent Types ────────────────────────────────────────────────────
  'agent:feature-dev-code-architect': {
    intent_tags: 'architecture,design,feature,blueprint,codebase,patterns,conventions,plan',
    domain_tags: 'architecture,development,design',
    capability_summary: 'Design feature architectures by analyzing codebase patterns with implementation blueprints',
    trigger_patterns: 'when user needs feature architecture design with codebase analysis and implementation blueprints',
    invocation_name: 'feature-dev:code-architect',
    keywords: 'architectures,analyzing,blueprints',
    use_cases: 'UI design;layout build',
  },
  'agent:feature-dev-code-reviewer': {
    intent_tags: 'review,bugs,logic,security,quality,conventions,confidence,priority',
    domain_tags: 'quality,review,security',
    capability_summary: 'Review code for bugs security vulnerabilities and quality with confidence-based filtering',
    trigger_patterns: 'when user needs focused code review for bugs security issues and high-priority quality problems',
    invocation_name: 'feature-dev:code-reviewer',
    keywords: 'vulnerabilities,confidence-based,filtering,focused,high-priority',
    tech_stack: 'linter,analyzer,diff,pr-review,owasp',
    use_cases: 'code review;identify issues',
  },
  'agent:feature-dev-code-explorer': {
    intent_tags: 'explore,analyze,trace,execution,architecture,dependencies,understand,codebase',
    domain_tags: 'architecture,analysis,exploration',
    capability_summary: 'Deep codebase analysis by tracing execution paths mapping architecture and understanding patterns',
    trigger_patterns: 'when user needs deep codebase analysis execution path tracing or architecture understanding',
    invocation_name: 'feature-dev:code-explorer',
    keywords: 'deep,tracing,paths,mapping,understanding,patterns',
    use_cases: 'explore options;investigate approaches',
  },
  'agent:code-simplifier-agent': {
    intent_tags: 'simplify,refine,clarity,consistency,maintainability,clean,refactor',
    domain_tags: 'quality,refactoring,code',
    capability_summary: 'Simplify and refine code for clarity consistency and maintainability preserving functionality',
    trigger_patterns: 'when user wants to simplify code improve clarity or refine for consistency and maintainability',
    invocation_name: 'code-simplifier:code-simplifier',
    keywords: 'preserving,functionality,improve',
    tech_stack: 'linter,analyzer',
    use_cases: 'simplify code;reduce complexity',
  },
  'agent:superpowers-code-reviewer-agent': {
    intent_tags: 'review,plan,standards,major-step,validate,milestone,code-review',
    domain_tags: 'quality,review,workflow',
    capability_summary: 'Review completed project steps against original plan and coding standards',
    trigger_patterns: 'when a major project step is completed and needs review against plan and coding standards',
    invocation_name: 'superpowers:code-reviewer',
    keywords: 'completed,steps,against,original,major',
    tech_stack: 'linter,analyzer,diff,pr-review',
    use_cases: 'code review;identify issues;architecture design;implementation planning',
  },
  'agent:gsd-debugger': {
    intent_tags: 'debug,systematic,root-cause,analysis,fix,diagnose,gsd',
    domain_tags: 'debugging,gsd,analysis',
    capability_summary: 'Systematic GSD debugging with root cause analysis and targeted fixes',
    trigger_patterns: 'when GSD project encounters bugs needing systematic debugging and root cause analysis',
    invocation_name: 'gsd:debugger',
    keywords: 'root,cause,targeted,fixes,encounters,bugs',
    use_cases: 'debug errors;isolate issues',
  },
  'agent:gsd-executor': {
    intent_tags: 'execute,task,tdd,self-review,structured,result,gsd',
    domain_tags: 'gsd,execution,tdd',
    capability_summary: 'Execute one GSD task with TDD self-review and return structured result',
    trigger_patterns: 'when GSD project needs to execute a single task with TDD and structured output',
    invocation_name: 'gsd:executor',
    keywords: 'return,single,output',
    use_cases: 'write unit tests;increase test coverage',
  },
  'agent:gsd-reviewer': {
    intent_tags: 'review,two-stage,quality,post-execution,gsd,verify',
    domain_tags: 'gsd,review,quality',
    capability_summary: 'Two-stage code review after GSD executor completes a task',
    trigger_patterns: 'when GSD executor completes a task and needs two-stage quality review',
    invocation_name: 'gsd:reviewer',
    keywords: 'executor,completes,task',
    tech_stack: 'diff,pr-review,linter,analyzer',
    use_cases: 'code review;identify issues',
  },
  'agent:gsd-researcher': {
    intent_tags: 'research,domain,ecosystem,planning,investigate,gsd,discovery',
    domain_tags: 'gsd,research,planning',
    capability_summary: 'Research domain ecosystem and gather information before GSD project planning',
    trigger_patterns: 'when GSD project needs domain research ecosystem investigation before planning',
    invocation_name: 'gsd:researcher',
    keywords: 'gather,information,investigation',
    tech_stack: 'architecture',
  },

  // ─── Missing Skills (from installed plugins) ────────────────────────────
  'skill:update-config': {
    intent_tags: 'config,settings,hooks,permissions,env,automation,harness',
    domain_tags: 'claude-code,configuration',
    capability_summary: 'Configure Claude Code harness via settings.json including hooks permissions and environment variables',
    trigger_patterns: 'when user wants to configure hooks permissions env vars or automation in Claude Code settings',
    invocation_name: 'update-config',
    keywords: 'settings-json,hook-config,permission-config,env-var,automation-trigger',
    tech_stack: 'claude-code,json',
    use_cases: 'add hook;configure permission;set env var;automate behavior',
  },
  'skill:gsd-doctor': {
    intent_tags: 'diagnostic,health,check,gsd,install,verify',
    domain_tags: 'gsd,diagnostic',
    capability_summary: 'Run diagnostic checks on GSD-Lite installation and project health',
    trigger_patterns: 'when user needs to verify GSD installation health or troubleshoot GSD issues',
    invocation_name: 'gsd:doctor',
    keywords: 'gsd-health,install-check,diagnostic',
    tech_stack: 'gsd',
  },
  'skill:superpowers-using-superpowers': {
    intent_tags: 'skill,discovery,meta,workflow,find,use,invoke',
    domain_tags: 'claude-code,skill,meta',
    capability_summary: 'Meta-skill for discovering and using available skills — establishes skill invocation workflow',
    trigger_patterns: 'when starting any conversation to establish skill awareness and discovery process',
    invocation_name: 'superpowers:using-superpowers',
    keywords: 'skill-discovery,find-skill,invoke-skill,meta-workflow',
    tech_stack: 'claude-code',
    recommendation_mode: 'on_request',
  },

  // ─── Code Graph MCP Skills ──────────────────────────────────────────────
  'skill:code-graph-rebuild': {
    intent_tags: 'index,rebuild,reindex,code-graph,ast,refresh',
    domain_tags: 'code-graph,ast,indexing',
    capability_summary: 'Force a full code-graph AST knowledge graph index rebuild',
    trigger_patterns: 'when code-graph index is stale outdated or needs full reindexing',
    invocation_name: 'code-graph-mcp:rebuild',
    keywords: 'ast-reindex,graph-rebuild,full-reindex',
    tech_stack: 'ast,code-graph',
  },
  'skill:code-graph-impact': {
    intent_tags: 'impact,analysis,change,scope,symbol,dependency,risk',
    domain_tags: 'code-graph,ast,refactor',
    capability_summary: 'Analyze the impact scope of changing a symbol before modifying it',
    trigger_patterns: 'when user needs to understand what will break if a function class or symbol is changed',
    invocation_name: 'code-graph-mcp:impact',
    keywords: 'impact-analysis,change-scope,ripple-effect,breaking-change',
    tech_stack: 'ast,code-graph',
  },
  'skill:code-graph-trace': {
    intent_tags: 'trace,http,request,route,handler,endpoint,flow',
    domain_tags: 'code-graph,http,api',
    capability_summary: 'Trace a full HTTP request flow from route definition to data layer',
    trigger_patterns: 'when user needs to follow an HTTP request through route middleware handler to database',
    invocation_name: 'code-graph-mcp:trace',
    keywords: 'request-trace,http-flow,route-to-db,endpoint-trace',
    tech_stack: 'http,rest,express,fastify',
  },
  'skill:code-graph-status': {
    intent_tags: 'status,index,progress,embedding,health,code-graph',
    domain_tags: 'code-graph,monitoring',
    capability_summary: 'Show code-graph index status and embedding progress',
    trigger_patterns: 'when user wants to check code-graph indexing status or embedding completion progress',
    invocation_name: 'code-graph-mcp:status',
    keywords: 'index-status,embedding-progress,graph-health',
    tech_stack: 'code-graph',
  },
  'skill:code-graph-understand': {
    intent_tags: 'understand,module,architecture,deep-dive,analyze,file',
    domain_tags: 'code-graph,ast,architecture',
    capability_summary: 'Deep dive into a module or file architecture and relationships via AST analysis',
    trigger_patterns: 'when user needs to deeply understand a module file or component architecture and dependencies',
    invocation_name: 'code-graph-mcp:understand',
    keywords: 'module-analysis,file-architecture,deep-understanding,relationship-map',
    tech_stack: 'ast,code-graph',
  },

  // ─── Missing Agents ─────────────────────────────────────────────────────
  'agent:code-graph-code-explorer': {
    intent_tags: 'explore,understand,code,ast,knowledge-graph,trace,architecture',
    domain_tags: 'code-graph,ast,analysis',
    capability_summary: 'Deep code understanding expert using AST knowledge graph for tracing relationships and architecture',
    trigger_patterns: 'when user needs deep code understanding tracing complex relationships or exploring module architecture',
    invocation_name: 'code-graph-mcp:code-explorer',
    keywords: 'ast-explore,code-trace,relationship-graph,module-architecture',
    tech_stack: 'ast,code-graph',
  },
  'agent:general-purpose': {
    intent_tags: 'general,research,search,multi-step,autonomous,complex',
    domain_tags: '',
    capability_summary: 'General-purpose agent for researching complex questions searching code and executing multi-step tasks',
    trigger_patterns: 'when task requires autonomous multi-step research code searching or complex investigation',
    invocation_name: 'general-purpose',
    keywords: 'autonomous-research,code-search,multi-step,investigation',
    recommendation_mode: 'on_request',
  },
  'agent:explore-agent': {
    intent_tags: 'explore,codebase,search,find,pattern,architecture,quick',
    domain_tags: '',
    capability_summary: 'Fast agent for exploring codebases — find files by patterns search code for keywords answer architecture questions',
    trigger_patterns: 'when user needs quick codebase exploration file pattern matching or architecture overview',
    invocation_name: 'Explore',
    keywords: 'codebase-explore,file-search,pattern-match,quick-search',
    recommendation_mode: 'on_request',
  },
  'agent:plan-agent': {
    intent_tags: 'plan,architecture,design,strategy,implementation,trade-off',
    domain_tags: '',
    capability_summary: 'Software architect agent for designing implementation plans with step-by-step strategies',
    trigger_patterns: 'when user needs to plan implementation strategy identify critical files or consider architectural trade-offs',
    invocation_name: 'Plan',
    keywords: 'implementation-plan,architecture-design,strategy,step-by-step',
    recommendation_mode: 'on_request',
  },
  'agent:claude-code-guide': {
    intent_tags: 'help,guide,claude-code,features,hooks,mcp,api,sdk,ide',
    domain_tags: 'claude-code,documentation',
    capability_summary: 'Expert guide for Claude Code CLI features hooks slash commands MCP servers and API usage',
    trigger_patterns: 'when user asks about Claude Code features API usage SDK integration or IDE setup',
    invocation_name: 'claude-code-guide',
    keywords: 'claude-code-help,feature-guide,api-docs,mcp-setup',
    tech_stack: 'claude-code,anthropic-sdk',
    recommendation_mode: 'on_request',
  },
  'agent:statusline-setup': {
    intent_tags: 'statusline,status,configure,display,ui',
    domain_tags: 'claude-code,configuration',
    capability_summary: 'Configure Claude Code status line display settings',
    trigger_patterns: 'when user wants to configure or customize the Claude Code status line',
    invocation_name: 'statusline-setup',
    keywords: 'status-line,display-config,ui-setting',
    tech_stack: 'claude-code',
    recommendation_mode: 'on_request',
  },

  // ─── MCP Server Resources ──────────────────────────────────────────────
  'skill:context7-docs': {
    intent_tags: 'docs,documentation,library,api,reference,latest,up-to-date',
    domain_tags: 'documentation,library',
    capability_summary: 'Query up-to-date library documentation and code examples via Context7 MCP server',
    trigger_patterns: 'when user needs current library docs API reference or code examples for any package',
    invocation_name: 'context7:query-docs',
    keywords: 'library-docs,api-reference,package-docs,latest-docs,context7',
    tech_stack: 'npm,pypi,crates',
  },
  'skill:context7-resolve': {
    intent_tags: 'resolve,library,lookup,identify,package',
    domain_tags: 'documentation,library',
    capability_summary: 'Resolve library ID for documentation lookup in Context7',
    trigger_patterns: 'when user needs to identify the correct library ID before querying documentation',
    invocation_name: 'context7:resolve-library-id',
    keywords: 'library-resolve,package-id,doc-lookup,context7',
    tech_stack: 'npm,pypi,crates',
    recommendation_mode: 'on_request',
  },
  'skill:sequential-thinking': {
    intent_tags: 'think,reason,step-by-step,sequential,analyze,complex,logic',
    domain_tags: '',
    capability_summary: 'Sequential step-by-step reasoning for complex problems requiring structured thought',
    trigger_patterns: 'when facing complex logical problems that benefit from structured sequential reasoning',
    invocation_name: 'sequential-thinking',
    keywords: 'step-by-step,structured-thought,chain-of-thought,complex-reasoning',
    recommendation_mode: 'on_request',
  },

};

// ─── Marketing / SEO resources → on_request mode ────────────────────────────
// These resources are rarely useful during programming sessions.
// They only surface when the user explicitly asks for marketing/SEO help.
export const MARKETING_ON_REQUEST = new Set([
  // Skills — marketing domain
  'skill:ab-test-setup',
  'skill:ad-creative',
  'skill:ai-seo',
  'skill:analytics-tracking',
  'skill:churn-prevention',
  'skill:cold-email',
  'skill:competitor-alternatives',
  'skill:content-strategy',
  'skill:copy-editing',
  'skill:copywriting',
  'skill:email-sequence',
  'skill:form-cro',
  'skill:free-tool-strategy',
  'skill:launch-strategy',
  'skill:marketing-ideas',
  'skill:marketing-psychology',
  'skill:onboarding-cro',
  'skill:page-cro',
  'skill:paid-ads',
  'skill:paywall-upgrade-cro',
  'skill:popup-cro',
  'skill:pricing-strategy',
  'skill:product-marketing-context',
  'skill:programmatic-seo',
  'skill:referral-program',
  'skill:schema-markup',
  'skill:mktg-seo-audit',
  'skill:signup-flow-cro',
  'skill:social-content',
  // Skills — SEO domain
  'skill:seo-audit',
  'skill:seo-competitor-pages',
  'skill:seo-content',
  'skill:seo-geo',
  'skill:seo-hreflang',
  'skill:seo-images',
  'skill:seo-page',
  'skill:seo-plan',
  'skill:seo-programmatic',
  'skill:seo-schema',
  'skill:seo-sitemap',
  'skill:seo-technical',
  // Agents — SEO
  'agent:seo-content-agent',
  'agent:seo-performance-agent',
  'agent:seo-schema-agent',
  'agent:seo-sitemap-agent',
  'agent:seo-technical-agent',
  'agent:seo-visual-agent',
  'agent:seo-analysis-monitoring',
  'agent:seo-content-creation',
  'agent:seo-technical-optimization',
  // Agents — marketing / sales
  'agent:content-marketing',
  'agent:customer-sales-automation',
]);

// Stamp recommendation_mode into metadata so both insert and update paths read it
for (const key of MARKETING_ON_REQUEST) {
  if (RESOURCE_METADATA[key]) {
    RESOURCE_METADATA[key].recommendation_mode = 'on_request';
  }
}

