claude-mem-lite 2.3.3 → 2.5.2

package/install.mjs

@@ -34,6 +34,9 @@ const RESOURCE_METADATA = {
     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',
@@ -41,30 +44,44 @@ const RESOURCE_METADATA = {
     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',
@@ -72,6 +89,9 @@ const RESOURCE_METADATA = {
     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',
@@ -79,6 +99,9 @@ const RESOURCE_METADATA = {
     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',
@@ -86,6 +109,8 @@ const RESOURCE_METADATA = {
     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',
@@ -93,6 +118,9 @@ const RESOURCE_METADATA = {
     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',
@@ -100,6 +128,8 @@ const RESOURCE_METADATA = {
     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',
@@ -107,6 +137,9 @@ const RESOURCE_METADATA = {
     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',
@@ -114,30 +147,44 @@ const RESOURCE_METADATA = {
     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',
+    keywords: 'playwright-test,browser-script,page-interaction,screenshot',
+    tech_stack: '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': {
@@ -145,126 +192,175 @@ const RESOURCE_METADATA = {
     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',
@@ -276,18 +372,22 @@ const RESOURCE_METADATA = {
     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',
@@ -300,270 +400,339 @@ const RESOURCE_METADATA = {
     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',
@@ -571,6 +740,8 @@ const RESOURCE_METADATA = {
     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',
@@ -578,6 +749,7 @@ const RESOURCE_METADATA = {
     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',
@@ -585,12 +757,14 @@ const RESOURCE_METADATA = {
     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',
@@ -603,72 +777,91 @@ const RESOURCE_METADATA = {
     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',
@@ -681,60 +874,81 @@ const RESOURCE_METADATA = {
     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',
@@ -747,12 +961,16 @@ const RESOURCE_METADATA = {
     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',
@@ -765,42 +983,52 @@ const RESOURCE_METADATA = {
     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',
@@ -819,12 +1047,14 @@ const RESOURCE_METADATA = {
     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',
@@ -837,42 +1067,56 @@ const RESOURCE_METADATA = {
     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',
@@ -885,36 +1129,50 @@ const RESOURCE_METADATA = {
     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',
@@ -927,12 +1185,14 @@ const RESOURCE_METADATA = {
     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',
@@ -945,18 +1205,23 @@ const RESOURCE_METADATA = {
     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',
@@ -975,60 +1240,79 @@ const RESOURCE_METADATA = {
     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',
@@ -1041,24 +1325,30 @@ const RESOURCE_METADATA = {
     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',
@@ -1071,30 +1361,37 @@ const RESOURCE_METADATA = {
     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',
@@ -1107,72 +1404,91 @@ const RESOURCE_METADATA = {
     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) ────────────────────────
@@ -1182,6 +1498,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1189,6 +1508,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1196,6 +1518,7 @@ const RESOURCE_METADATA = {
     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',
@@ -1203,6 +1526,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1210,6 +1535,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1217,6 +1544,7 @@ const RESOURCE_METADATA = {
     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',
@@ -1224,6 +1552,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1231,6 +1562,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1238,6 +1571,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1245,6 +1581,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1252,6 +1590,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1259,6 +1599,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1266,6 +1608,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1273,6 +1617,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1280,6 +1626,7 @@ const RESOURCE_METADATA = {
     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',
@@ -1287,6 +1634,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1294,6 +1643,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1301,6 +1653,7 @@ const RESOURCE_METADATA = {
     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',
@@ -1308,6 +1661,7 @@ const RESOURCE_METADATA = {
     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',
@@ -1315,6 +1669,8 @@ const RESOURCE_METADATA = {
     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 ─────────────────────────────────────────────
@@ -1324,6 +1680,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1331,6 +1690,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1338,6 +1699,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1352,6 +1715,7 @@ const RESOURCE_METADATA = {
     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',
@@ -1366,6 +1730,7 @@ const RESOURCE_METADATA = {
     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',
@@ -1373,6 +1738,7 @@ const RESOURCE_METADATA = {
     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',
@@ -1380,6 +1746,7 @@ const RESOURCE_METADATA = {
     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',
@@ -1394,6 +1761,8 @@ const RESOURCE_METADATA = {
     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 ────────────────────────────────────────────────────
@@ -1403,6 +1772,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1410,6 +1781,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1417,6 +1791,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1424,6 +1800,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1431,6 +1810,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1438,6 +1820,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1445,6 +1829,8 @@ const RESOURCE_METADATA = {
     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',
@@ -1452,6 +1838,9 @@ const RESOURCE_METADATA = {
     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',
@@ -1459,6 +1848,8 @@ const RESOURCE_METADATA = {
     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',
   },
 
 };
@@ -1506,8 +1897,20 @@ function registerVirtualResources(rdb) {
   const insert = rdb.prepare(`
     INSERT OR IGNORE INTO resources (name, type, status, source, local_path, invocation_name,
       intent_tags, domain_tags, capability_summary, trigger_patterns,
+      keywords, tech_stack, use_cases,
       created_at, updated_at)
-    VALUES (?, ?, 'active', 'preinstalled', '', ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+    VALUES (?, ?, 'active', 'preinstalled', '', ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+  `);
+
+  // Backfill FTS5 fields for existing resources that have empty keywords/tech_stack/use_cases
+  const updateFts = rdb.prepare(`
+    UPDATE resources SET
+      keywords = CASE WHEN (keywords IS NULL OR keywords = '') AND ?1 != '' THEN ?1 ELSE keywords END,
+      tech_stack = CASE WHEN (tech_stack IS NULL OR tech_stack = '') AND ?2 != '' THEN ?2 ELSE tech_stack END,
+      use_cases = CASE WHEN (use_cases IS NULL OR use_cases = '') AND ?3 != '' THEN ?3 ELSE use_cases END,
+      updated_at = datetime('now')
+    WHERE type = ?4 AND name = ?5
+      AND ((keywords IS NULL OR keywords = '') OR (tech_stack IS NULL OR tech_stack = '') OR (use_cases IS NULL OR use_cases = ''))
   `);
 
   let count = 0;
@@ -1524,9 +1927,35 @@ function registerVirtualResources(rdb) {
         meta.domain_tags || '',
         meta.capability_summary || `${type}: ${name.replace(/-/g, ' ')}`,
         meta.trigger_patterns || `when user needs ${name.replace(/-/g, ' ')}`,
+        meta.keywords || '',
+        meta.tech_stack || '',
+        meta.use_cases || '',
       );
       count += changes;
+
+      // Backfill FTS5 fields for existing resources
+      if (changes === 0) {
+        updateFts.run(meta.keywords || '', meta.tech_stack || '', meta.use_cases || '', type, name);
+      }
     }
+
+    // Backfill keywords from preinstalled tags for resources still missing keywords
+    try {
+      const backfill = rdb.prepare(`
+        UPDATE resources SET keywords = (
+          SELECT GROUP_CONCAT(json_each.value, ',')
+          FROM preinstalled p, json_each(p.tags)
+          WHERE p.type = resources.type AND p.name = resources.name
+        )
+        WHERE (keywords IS NULL OR keywords = '')
+          AND EXISTS (
+            SELECT 1 FROM preinstalled p
+            WHERE p.type = resources.type AND p.name = resources.name
+              AND p.tags != '[]' AND p.tags IS NOT NULL
+          )
+      `);
+      backfill.run();
+    } catch {}
   })();
   return count;
 }