ctxora 6.2.2 → 6.3.0

package/src/harness_context/skills/ecc_catalog.json

@@ -0,0 +1,2233 @@
+{
+  "commit": "e04ea0b9cc8248686edf5ac751cadff550e162b8",
+  "modules": {
+    "agentic-patterns": {
+      "description": "Agentic engineering, autonomous loops, agent harness construction, and LLM pipeline optimization skills.",
+      "skills": [
+        "agent-architecture-audit",
+        "agent-harness-construction",
+        "agent-payment-x402",
+        "agentic-engineering",
+        "agentic-os",
+        "ai-first-engineering",
+        "autonomous-agent-harness",
+        "autonomous-loops",
+        "blueprint",
+        "claude-devfleet",
+        "content-hash-cache-pattern",
+        "continuous-agent-loop",
+        "cost-aware-llm-pipeline",
+        "data-scraper-agent",
+        "dynamic-workflow-mode",
+        "enterprise-agent-ops",
+        "gan-style-harness",
+        "hermes-imports",
+        "nanoclaw-repl",
+        "openclaw-persona-forge",
+        "opensource-pipeline",
+        "orch-add-feature",
+        "orch-build-mvp",
+        "orch-change-feature",
+        "orch-fix-defect",
+        "orch-pipeline",
+        "orch-refine-code",
+        "plan-orchestrate",
+        "prompt-optimizer",
+        "ralphinho-rfc-pipeline",
+        "regex-vs-llm-structured-text",
+        "search-first",
+        "team-agent-orchestration",
+        "team-builder",
+        "token-budget-advisor"
+      ]
+    },
+    "business-content": {
+      "description": "Business, writing, market, and investor communication skills.",
+      "skills": [
+        "article-writing",
+        "brand-discovery",
+        "brand-voice",
+        "competitive-platform-analysis",
+        "competitive-report-structure",
+        "content-engine",
+        "investor-materials",
+        "investor-outreach",
+        "lead-intelligence",
+        "market-research",
+        "marketing-campaign",
+        "product-capability",
+        "seo",
+        "social-graph-ranker"
+      ]
+    },
+    "database": {
+      "description": "Database and persistence-focused skills.",
+      "skills": [
+        "clickhouse-io",
+        "database-migrations",
+        "jpa-patterns",
+        "mysql-patterns",
+        "postgres-patterns",
+        "prisma-patterns",
+        "redis-patterns"
+      ]
+    },
+    "devops-infra": {
+      "description": "Deployment workflows, Docker patterns, and infrastructure skills.",
+      "skills": [
+        "canary-watch",
+        "cisco-ios-patterns",
+        "deployment-patterns",
+        "docker-patterns",
+        "flox-environments",
+        "homelab-network-readiness",
+        "homelab-network-setup",
+        "homelab-pihole-dns",
+        "homelab-vlan-segmentation",
+        "homelab-wireguard-vpn",
+        "kubernetes-patterns",
+        "netmiko-ssh-automation",
+        "network-bgp-diagnostics",
+        "network-config-validation",
+        "network-interface-health",
+        "terminal-opener",
+        "uncloud"
+      ]
+    },
+    "document-processing": {
+      "description": "Document processing, conversion, and translation skills.",
+      "skills": [
+        "nutrient-document-processing",
+        "visa-doc-translate"
+      ]
+    },
+    "framework-language": {
+      "description": "Core framework, language, and application-engineering skills.",
+      "skills": [
+        "accessibility",
+        "android-clean-architecture",
+        "angular-developer",
+        "api-design",
+        "backend-patterns",
+        "bun-runtime",
+        "coding-standards",
+        "compose-multiplatform-patterns",
+        "contract-first",
+        "cpp-coding-standards",
+        "cpp-testing",
+        "csharp-testing",
+        "dart-flutter-patterns",
+        "design-system",
+        "django-celery",
+        "django-patterns",
+        "django-tdd",
+        "django-verification",
+        "dotnet-patterns",
+        "fastapi-patterns",
+        "flutter-dart-code-review",
+        "frontend-a11y",
+        "frontend-design-direction",
+        "frontend-patterns",
+        "frontend-slides",
+        "fsharp-testing",
+        "generating-python-installer",
+        "golang-patterns",
+        "golang-testing",
+        "hexagonal-architecture",
+        "java-coding-standards",
+        "kotlin-coroutines-flows",
+        "kotlin-exposed-patterns",
+        "kotlin-ktor-patterns",
+        "kotlin-patterns",
+        "kotlin-testing",
+        "laravel-patterns",
+        "laravel-plugin-discovery",
+        "laravel-tdd",
+        "laravel-verification",
+        "make-interfaces-feel-better",
+        "mcp-server-patterns",
+        "motion-advanced",
+        "motion-foundations",
+        "motion-patterns",
+        "motion-ui",
+        "nestjs-patterns",
+        "nextjs-turbopack",
+        "nuxt4-patterns",
+        "perl-patterns",
+        "perl-testing",
+        "python-patterns",
+        "python-testing",
+        "quarkus-patterns",
+        "quarkus-tdd",
+        "quarkus-verification",
+        "react-native-patterns",
+        "react-patterns",
+        "react-performance",
+        "react-testing",
+        "rust-patterns",
+        "rust-testing",
+        "springboot-patterns",
+        "springboot-tdd",
+        "springboot-verification",
+        "tinystruct-patterns",
+        "ui-to-vue",
+        "vite-patterns",
+        "vue-patterns"
+      ]
+    },
+    "ito-compute": {
+      "description": "Authenticated Itô GPU inventory, RFQ, status, device revocation, and explicitly gated node-qualification workflows through the separately installed canonical CLI.",
+      "skills": [
+        "ito-compute",
+        "ito-inference",
+        "ito-training"
+      ]
+    },
+    "machine-learning": {
+      "description": "Production machine-learning engineering workflows for data contracts, reproducible training, evaluation, deployment, monitoring, and rollback.",
+      "skills": [
+        "ml-adoption-playbook",
+        "mle-workflow",
+        "pytorch-patterns",
+        "recsys-pipeline-architect"
+      ]
+    },
+    "media-generation": {
+      "description": "Media generation, technical explainers, and AI-assisted editing skills.",
+      "skills": [
+        "blender-motion-state-inspection",
+        "fal-ai-media",
+        "manim-video",
+        "remotion-video-creation",
+        "taste",
+        "tasteforge-video",
+        "ui-demo",
+        "video-editing",
+        "videodb"
+      ]
+    },
+    "nasiko-control-plane": {
+      "description": "Experimental Nasiko CLI lifecycle bridge guidance for pinned installation, read-only status, qualified uninstall, and opt-in telemetry boundaries.",
+      "skills": [
+        "nasiko-control-plane"
+      ]
+    },
+    "operator-workflows": {
+      "description": "Connected-app operator workflows for setup audits, billing operations, program tracking, Google Workspace, and network optimization.",
+      "skills": [
+        "api-connector-builder",
+        "automation-audit-ops",
+        "connections-optimizer",
+        "cost-tracking",
+        "customer-billing-ops",
+        "dashboard-builder",
+        "ecc-tools-cost-audit",
+        "email-ops",
+        "finance-billing-ops",
+        "github-ops",
+        "google-workspace-ops",
+        "jira-integration",
+        "knowledge-ops",
+        "mailtrap-email-integration",
+        "messages-ops",
+        "project-flow-ops",
+        "terminal-ops",
+        "unified-notifications-ops",
+        "workspace-surface-audit"
+      ]
+    },
+    "optimization-workflows": {
+      "description": "Parallel execution, benchmarking, data-throughput, latency, and recursive decision-ledger skills for faster evidence-backed work.",
+      "skills": [
+        "agent-eval",
+        "benchmark",
+        "benchmark-methodology",
+        "benchmark-optimization-loop",
+        "data-throughput-accelerator",
+        "latency-critical-systems",
+        "parallel-execution-optimizer",
+        "recursive-decision-ledger"
+      ]
+    },
+    "orchestration": {
+      "description": "Worktree/tmux orchestration runtime and workflow docs.",
+      "skills": [
+        "dmux-workflows"
+      ]
+    },
+    "prediction-market-skills": {
+      "description": "Public, non-advisory prediction-market workflows and the consolidated read-only Ito baskets data skill with gated Ito API access.",
+      "skills": [
+        "ito-baskets",
+        "prediction-market-oracle-research",
+        "prediction-market-risk-review"
+      ]
+    },
+    "research-apis": {
+      "description": "Research and API integration skills for deep investigations and model integrations.",
+      "skills": [
+        "deep-research",
+        "documentation-lookup",
+        "exa-search",
+        "research-ops",
+        "scientific-db-pubmed-database",
+        "scientific-db-uspto-database",
+        "scientific-pkg-gget",
+        "scientific-thinking-literature-review",
+        "scientific-thinking-scholar-evaluation"
+      ]
+    },
+    "security": {
+      "description": "Security review and security-focused framework guidance.",
+      "skills": [
+        "defi-amm-security",
+        "django-security",
+        "evm-token-decimals",
+        "gateguard",
+        "healthcare-cdss-patterns",
+        "healthcare-emr-patterns",
+        "healthcare-eval-harness",
+        "healthcare-phi-compliance",
+        "hipaa-compliance",
+        "laravel-security",
+        "llm-trading-agent-security",
+        "nodejs-keccak256",
+        "perl-security",
+        "quarkus-security",
+        "safety-guard",
+        "security-bounty-hunter",
+        "security-review",
+        "security-scan",
+        "springboot-security"
+      ]
+    },
+    "skill-unified-memory": {
+      "description": "Single-skill unified-memory guidance; requires the separately installed ecc-universal CLI runtime.",
+      "skills": [
+        "unified-memory"
+      ]
+    },
+    "social-distribution": {
+      "description": "Social publishing and distribution skills.",
+      "skills": [
+        "crosspost",
+        "social-publisher",
+        "x-api"
+      ]
+    },
+    "supply-chain-domain": {
+      "description": "Supply chain, logistics, procurement, and manufacturing domain skills.",
+      "skills": [
+        "carrier-relationship-management",
+        "customs-trade-compliance",
+        "energy-procurement",
+        "inventory-demand-planning",
+        "logistics-exception-management",
+        "production-scheduling",
+        "quality-nonconformance",
+        "returns-reverse-logistics"
+      ]
+    },
+    "swift-apple": {
+      "description": "Swift, SwiftUI, and Apple platform skills including concurrency, persistence, and design patterns.",
+      "skills": [
+        "foundation-models-on-device",
+        "ios-icon-gen",
+        "liquid-glass-design",
+        "swift-actor-persistence",
+        "swift-concurrency-6-2",
+        "swift-protocol-di-testing",
+        "swiftui-patterns"
+      ]
+    },
+    "workflow-quality": {
+      "description": "Evaluation, TDD, verification, compaction, learning, and cross-harness memory skills, including the legacy continuous-learning v1 path. The unified-memory workflow requires the separately installed ecc-universal CLI runtime.",
+      "skills": [
+        "agent-introspection-debugging",
+        "agent-self-evaluation",
+        "agent-sort",
+        "ai-regression-testing",
+        "architecture-decision-records",
+        "browser-qa",
+        "ck",
+        "click-path-audit",
+        "code-tour",
+        "codebase-onboarding",
+        "codehealth-mcp",
+        "config-gc",
+        "configure-ecc",
+        "context-budget",
+        "continuous-learning",
+        "continuous-learning-v2",
+        "council",
+        "council-multi-model",
+        "delivery-gate",
+        "dev-team",
+        "e2e-testing",
+        "ecc-guide",
+        "ecc-recipes",
+        "error-handling",
+        "eval-harness",
+        "git-workflow",
+        "growth-log",
+        "hookify-rules",
+        "inherit-legacy-style",
+        "intent-driven-development",
+        "iterative-retrieval",
+        "living-docs-governance",
+        "loop-design-check",
+        "plan-canvas",
+        "plankton-code-quality",
+        "product-lens",
+        "production-audit",
+        "repo-scan",
+        "rules-distill",
+        "santa-method",
+        "skill-comply",
+        "skill-scout",
+        "skill-stocktake",
+        "strategic-compact",
+        "tdd-workflow",
+        "verification-loop",
+        "windows-desktop-e2e"
+      ]
+    }
+  },
+  "profiles": {
+    "core": {
+      "description": "Minimal harness baseline with commands, hooks, platform configs, and quality workflow support. Skills only; no hooks, agents, commands, or runtime setup.",
+      "excluded_modules": [
+        "rules-core",
+        "agents-core",
+        "commands-core",
+        "hooks-runtime",
+        "platform-configs"
+      ],
+      "modules": [
+        "workflow-quality"
+      ]
+    },
+    "developer": {
+      "description": "Default engineering profile for most ECC users working across app codebases. Skills only; no hooks, agents, commands, or runtime setup.",
+      "excluded_modules": [
+        "rules-core",
+        "agents-core",
+        "commands-core",
+        "hooks-runtime",
+        "platform-configs"
+      ],
+      "modules": [
+        "workflow-quality",
+        "framework-language",
+        "database",
+        "orchestration"
+      ]
+    },
+    "full": {
+      "description": "Complete ECC install with all currently classified modules. Skills only; no hooks, agents, commands, or runtime setup.",
+      "excluded_modules": [
+        "rules-core",
+        "agents-core",
+        "commands-core",
+        "hooks-runtime",
+        "platform-configs"
+      ],
+      "modules": [
+        "framework-language",
+        "database",
+        "workflow-quality",
+        "skill-unified-memory",
+        "security",
+        "research-apis",
+        "business-content",
+        "operator-workflows",
+        "optimization-workflows",
+        "prediction-market-skills",
+        "ito-compute",
+        "nasiko-control-plane",
+        "social-distribution",
+        "media-generation",
+        "orchestration",
+        "swift-apple",
+        "agentic-patterns",
+        "devops-infra",
+        "machine-learning",
+        "supply-chain-domain",
+        "document-processing"
+      ]
+    },
+    "minimal": {
+      "description": "Low-context Claude Code setup with rules, agents, commands, platform configs, and quality workflow support, but no hook runtime. Skills only; no hooks, agents, commands, or runtime setup.",
+      "excluded_modules": [
+        "rules-core",
+        "agents-core",
+        "commands-core",
+        "platform-configs"
+      ],
+      "modules": [
+        "workflow-quality"
+      ]
+    },
+    "opencode": {
+      "description": "Default OpenCode setup with commands, platform configs, and quality workflow support. It intentionally excludes hooks-runtime; opt in with --modules hooks-runtime. Skills only; no hooks, agents, commands, or runtime setup.",
+      "excluded_modules": [
+        "commands-core",
+        "platform-configs"
+      ],
+      "modules": [
+        "workflow-quality"
+      ]
+    },
+    "research": {
+      "description": "Research and content-oriented setup for investigation, synthesis, and publishing workflows. Skills only; no hooks, agents, commands, or runtime setup.",
+      "excluded_modules": [
+        "rules-core",
+        "agents-core",
+        "commands-core",
+        "hooks-runtime",
+        "platform-configs"
+      ],
+      "modules": [
+        "workflow-quality",
+        "research-apis",
+        "business-content",
+        "social-distribution"
+      ]
+    },
+    "security": {
+      "description": "Security-heavy setup with baseline runtime support and security-specific guidance. Skills only; no hooks, agents, commands, or runtime setup.",
+      "excluded_modules": [
+        "rules-core",
+        "agents-core",
+        "commands-core",
+        "hooks-runtime",
+        "platform-configs"
+      ],
+      "modules": [
+        "workflow-quality",
+        "security"
+      ]
+    }
+  },
+  "skills": {
+    "accessibility": {
+      "description": "Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.",
+      "name": "accessibility",
+      "path": "ecc/accessibility",
+      "routing_text": "accessibility accessibility Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support. - Defining UI component specifications for Web, iOS, or Android.\n- Auditing existing code for accessibility barriers or compliance gaps.\n- Implementing new WCAG 2.2 standards like Target Size (Minimum) and Focus Appearance.\n- Mapping high-level design requirements to technical attributes (ARIA roles, traits, hints).\n\n"
+    },
+    "agent-architecture-audit": {
+      "description": "Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.",
+      "name": "agent-architecture-audit",
+      "path": "ecc/agent-architecture-audit",
+      "routing_text": "agent architecture audit agent architecture audit Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack. **MANDATORY for:**\n- Releasing any agent or LLM-powered application to production\n- Shipping features with tool calling, memory, or multi-step workflows\n- Agent behavior degrades after adding wrapper layers\n- User reports \"the agent is getting worse\" or \"tools are flaky\"\n- Same model works in playground but breaks inside your wrapper\n- Debugging agent behavior for more than 15 minutes without finding root cause\n\n**Especially critical when:**\n- You've added new prompt layers, tool definitions, or memory systems\n- Different agents in your system behave inconsistently\n- The model was fine yesterday but is hallucinating today\n- You suspect hidden repair/retry loops silently mutating responses\n\n**Do not use for:**\n- General code debugging — use `agent-introspection-debugging`\n- Code review — use language-specific reviewer agents\n- Security scanning — use `security-review` or `security-review/scan`\n- Agent performance benchmarking — use `agent-eval`\n- Writing new features — use the appropriate workflow skill\n\n"
+    },
+    "agent-eval": {
+      "description": "Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.",
+      "name": "agent-eval",
+      "path": "ecc/agent-eval",
+      "routing_text": "agent eval agent eval Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression. - Comparing coding agents (Claude Code, Aider, Codex, etc.) on your own codebase\n- Measuring agent performance before adopting a new tool or model\n- Running regression checks when an agent updates its model or tooling\n- Producing data-backed agent selection decisions for a team\n\n"
+    },
+    "agent-harness-construction": {
+      "description": "Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent's tool set, action space, or observation format.",
+      "name": "agent-harness-construction",
+      "path": "ecc/agent-harness-construction",
+      "routing_text": "agent harness construction agent harness construction Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent's tool set, action space, or observation format."
+    },
+    "agent-introspection-debugging": {
+      "description": "Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.",
+      "name": "agent-introspection-debugging",
+      "path": "ecc/agent-introspection-debugging",
+      "routing_text": "agent introspection debugging agent introspection debugging Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry. - Maximum tool call / loop-limit failures\n- Repeated retries with no forward progress\n- Context growth or prompt drift that starts degrading output quality\n- File-system or environment state mismatch between expectation and reality\n- Tool failures that are likely recoverable with diagnosis and a smaller corrective action\n\n"
+    },
+    "agent-payment-x402": {
+      "description": "Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.",
+      "name": "agent-payment-x402",
+      "path": "ecc/agent-payment-x402",
+      "routing_text": "agent payment x402 agent payment x402 Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet. Use when: your agent needs to pay for an API call, purchase a service, settle with another agent, enforce per-task spending limits, or manage a non-custodial wallet. Pairs naturally with cost-aware-llm-pipeline and security-review skills.\n\n"
+    },
+    "agent-self-evaluation": {
+      "description": "Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.",
+      "name": "agent-self-evaluation",
+      "path": "ecc/agent-self-evaluation",
+      "routing_text": "agent self evaluation agent self evaluation Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions. - After writing code that spans 3+ files or 50+ lines\n- After completing a multi-step workflow (implement → test → review)\n- After a debugging session that involved 3+ attempts\n- After producing a design document, architecture decision, or written analysis\n- When the user asks \"how good was that?\" or \"rate yourself\"\n- At the end of any session Stop hook (if configured — see `references/hook-integration.md`)\n\n"
+    },
+    "agent-sort": {
+      "description": "Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle.",
+      "name": "agent-sort",
+      "path": "ecc/agent-sort",
+      "routing_text": "agent sort agent sort Build an evidence-backed ECC install plan for a specific repo by sorting skills, commands, rules, hooks, and extras into DAILY vs LIBRARY buckets using parallel repo-aware review passes. Use when ECC should be trimmed to what a project actually needs instead of loading the full bundle. - A project only needs a subset of ECC and full installs are too noisy\n- The repo stack is clear, but nobody wants to hand-curate skills one by one\n- A team wants a repeatable install decision backed by grep evidence instead of opinion\n- You need to separate always-loaded daily workflow surfaces from searchable library/reference surfaces\n- A repo has drifted into the wrong language, rule, or hook set and needs cleanup\n\n"
+    },
+    "agentic-engineering": {
+      "description": "Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.",
+      "name": "agentic-engineering",
+      "path": "ecc/agentic-engineering",
+      "routing_text": "agentic engineering agentic engineering Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end."
+    },
+    "agentic-os": {
+      "description": "Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.",
+      "name": "agentic-os",
+      "path": "ecc/agentic-os",
+      "routing_text": "agentic os agentic os Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling. - Building a multi-agent workflow inside Claude Code\n- Setting up persistent Claude Code automation that survives session restarts\n- Creating a \"personal OS\" or \"agentic OS\" for recurring tasks\n- User says \"agentic OS\", \"personal OS\", \"multi-agent\", \"agent coordinator\", \"persistent agent\"\n- Structuring long-running projects where context must survive across sessions\n\n"
+    },
+    "ai-first-engineering": {
+      "description": "Engineering operating model for teams where AI agents generate a large share of implementation output. Use when setting team process, review gates, or ownership rules for a codebase largely written by agents.",
+      "name": "ai-first-engineering",
+      "path": "ecc/ai-first-engineering",
+      "routing_text": "ai first engineering ai first engineering Engineering operating model for teams where AI agents generate a large share of implementation output. Use when setting team process, review gates, or ownership rules for a codebase largely written by agents."
+    },
+    "ai-regression-testing": {
+      "description": "Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code. Use when adding regression coverage to AI-assisted code, or when the same model both wrote and reviewed a change.",
+      "name": "ai-regression-testing",
+      "path": "ecc/ai-regression-testing",
+      "routing_text": "ai regression testing ai regression testing Regression testing strategies for AI-assisted development. Sandbox-mode API testing without database dependencies, automated bug-check workflows, and patterns to catch AI blind spots where the same model writes and reviews code. Use when adding regression coverage to AI-assisted code, or when the same model both wrote and reviewed a change. - AI agent (Claude Code, Cursor, Codex) has modified API routes or backend logic\n- A bug was found and fixed — need to prevent re-introduction\n- Project has a sandbox/mock mode that can be leveraged for DB-free testing\n- Running `/bug-check` or similar review commands after code changes\n- Multiple code paths exist (sandbox vs production, feature flags, etc.)\n\n"
+    },
+    "android-clean-architecture": {
+      "description": "Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns. Use when structuring modules, layers, or data flow in an Android or KMP project.",
+      "name": "android-clean-architecture",
+      "path": "ecc/android-clean-architecture",
+      "routing_text": "android clean architecture android clean architecture Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns. Use when structuring modules, layers, or data flow in an Android or KMP project. - Structuring Android or KMP project modules\n- Implementing UseCases, Repositories, or DataSources\n- Designing data flow between layers (domain, data, presentation)\n- Setting up dependency injection with Koin or Hilt\n- Working with Room, SQLDelight, or Ktor in a layered architecture\n\n"
+    },
+    "angular-developer": {
+      "description": "Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.",
+      "name": "angular-developer",
+      "path": "ecc/angular-developer",
+      "routing_text": "angular developer angular developer Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling. - Working in any Angular project or codebase\n- Creating or scaffolding a new Angular project, application, or library\n- Generating components, services, directives, pipes, guards, or resolvers\n- Implementing reactivity with Angular Signals, `linkedSignal`, or `resource`\n- Working with Angular forms (signal forms, reactive forms, or template-driven)\n- Setting up dependency injection, routing, lazy loading, or route guards\n- Adding accessibility (ARIA), animations, or component styling\n- Writing or debugging Angular-specific tests (unit, component harness, E2E)\n- Configuring Angular CLI tooling or the Angular MCP server\n\n1. Always analyze the project's Angular version before providing guidance, as best practices and available features can vary significantly between versions. If creating a new project with Angular CLI, do not specify a version unless prompted by the user.\n\n2. When generating code, follow Angular's style guide and best practices for maintainability and performance. Use the Angular CLI for scaffolding components, services, directives, pipes, and routes to ensure consistency.\n\n3. Once you finish generating code, run `ng build` to ensure there are no build errors. If there are errors, analyze the error messages and fix them before proceeding. Do not skip this step, as it is critical for ensuring the generated code is correct and functional.\n\n"
+    },
+    "api-connector-builder": {
+      "description": "Build a new API connector or provider by matching the target repo's existing integration pattern exactly. Use when adding one more integration without inventing a second architecture.",
+      "name": "api-connector-builder",
+      "path": "ecc/api-connector-builder",
+      "routing_text": "api connector builder api connector builder Build a new API connector or provider by matching the target repo's existing integration pattern exactly. Use when adding one more integration without inventing a second architecture. - \"Build a Jira connector for this project\"\n- \"Add a Slack provider following the existing pattern\"\n- \"Create a new integration for this API\"\n- \"Build a plugin that matches the repo's connector style\"\n\n"
+    },
+    "api-design": {
+      "description": "REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs. Use when designing or reviewing REST endpoints, resource names, status codes, pagination, or versioning.",
+      "name": "api-design",
+      "path": "ecc/api-design",
+      "routing_text": "api design api design REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs. Use when designing or reviewing REST endpoints, resource names, status codes, pagination, or versioning. - Designing new API endpoints\n- Reviewing existing API contracts\n- Adding pagination, filtering, or sorting\n- Implementing error handling for APIs\n- Planning API versioning strategy\n- Building public or partner-facing APIs\n\n"
+    },
+    "architecture-decision-records": {
+      "description": "Capture architectural decisions made during Claude Code sessions as structured ADRs. Auto-detects decision moments, records context, alternatives considered, and rationale. Maintains an ADR log so future developers understand why the codebase is shaped the way it is.",
+      "name": "architecture-decision-records",
+      "path": "ecc/architecture-decision-records",
+      "routing_text": "architecture decision records architecture decision records Capture architectural decisions made during Claude Code sessions as structured ADRs. Auto-detects decision moments, records context, alternatives considered, and rationale. Maintains an ADR log so future developers understand why the codebase is shaped the way it is. - User explicitly says \"let's record this decision\" or \"ADR this\"\n- User chooses between significant alternatives (framework, library, pattern, database, API design)\n- User says \"we decided to...\" or \"the reason we're doing X instead of Y is...\"\n- User asks \"why did we choose X?\" (read existing ADRs)\n- During planning phases when architectural trade-offs are discussed\n\n"
+    },
+    "article-writing": {
+      "description": "Write articles, guides, blog posts, tutorials, newsletter issues, and other long-form content in a distinctive voice derived from supplied examples or brand guidance. Use when the user wants polished written content longer than a paragraph, especially when voice consistency, structure, and credibility matter.",
+      "name": "article-writing",
+      "path": "ecc/article-writing",
+      "routing_text": "article writing article writing Write articles, guides, blog posts, tutorials, newsletter issues, and other long-form content in a distinctive voice derived from supplied examples or brand guidance. Use when the user wants polished written content longer than a paragraph, especially when voice consistency, structure, and credibility matter. - drafting blog posts, essays, launch posts, guides, tutorials, or newsletter issues\n- turning notes, transcripts, or research into polished articles\n- matching an existing founder, operator, or brand voice from examples\n- tightening structure, pacing, and evidence in already-written long-form copy\n\n"
+    },
+    "automation-audit-ops": {
+      "description": "Evidence-first automation inventory and overlap audit workflow for ECC. Use when the user wants to know which jobs, hooks, connectors, MCP servers, or wrappers are live, broken, redundant, or missing before fixing anything.",
+      "name": "automation-audit-ops",
+      "path": "ecc/automation-audit-ops",
+      "routing_text": "automation audit ops automation audit ops Evidence-first automation inventory and overlap audit workflow for ECC. Use when the user wants to know which jobs, hooks, connectors, MCP servers, or wrappers are live, broken, redundant, or missing before fixing anything. - user asks \"what automations do I have\", \"what is live\", \"what is broken\", or \"what overlaps\"\n- the task spans cron jobs, GitHub Actions, local hooks, MCP servers, connectors, wrappers, or app integrations\n- the user wants to know what was ported from another agent system and what still needs to be rebuilt inside ECC\n- the workspace has accumulated multiple ways to do the same thing and the user wants one canonical lane\n\n"
+    },
+    "autonomous-agent-harness": {
+      "description": "Transform Claude Code into a fully autonomous agent system with persistent memory, scheduled operations, computer use, and task queuing. Replaces standalone agent frameworks (Hermes, AutoGPT) by leveraging Claude Code's native crons, dispatch, MCP tools, and memory. Use when the user wants continuous autonomous operation, scheduled tasks, or a self-directing agent loop.",
+      "name": "autonomous-agent-harness",
+      "path": "ecc/autonomous-agent-harness",
+      "routing_text": "autonomous agent harness autonomous agent harness Transform Claude Code into a fully autonomous agent system with persistent memory, scheduled operations, computer use, and task queuing. Replaces standalone agent frameworks (Hermes, AutoGPT) by leveraging Claude Code's native crons, dispatch, MCP tools, and memory. Use when the user wants continuous autonomous operation, scheduled tasks, or a self-directing agent loop. - User wants an agent that runs continuously or on a schedule\n- Setting up automated workflows that trigger periodically\n- Building a personal AI assistant that remembers context across sessions\n- User says \"run this every day\", \"check on this regularly\", \"keep monitoring\"\n- Wants to replicate functionality from Hermes, AutoGPT, or similar autonomous agent frameworks\n- Needs computer use combined with scheduled execution\n\n"
+    },
+    "autonomous-loops": {
+      "description": "Patterns and architectures for autonomous Claude Code loops — from simple sequential pipelines to RFC-driven multi-agent DAG systems. Retained for compatibility only: when new autonomous loop guidance is needed, use continuous-agent-loop instead.",
+      "name": "autonomous-loops",
+      "path": "ecc/autonomous-loops",
+      "routing_text": "autonomous loops autonomous loops Patterns and architectures for autonomous Claude Code loops — from simple sequential pipelines to RFC-driven multi-agent DAG systems. Retained for compatibility only: when new autonomous loop guidance is needed, use continuous-agent-loop instead. - Setting up autonomous development workflows that run without human intervention\n- Choosing the right loop architecture for your problem (simple vs complex)\n- Building CI/CD-style continuous development pipelines\n- Running parallel agents with merge coordination\n- Implementing context persistence across loop iterations\n- Adding quality gates and cleanup passes to autonomous workflows\n\n"
+    },
+    "backend-patterns": {
+      "description": "Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes. Use when building or reviewing Node.js, Express, or Next.js API routes and their data access.",
+      "name": "backend-patterns",
+      "path": "ecc/backend-patterns",
+      "routing_text": "backend patterns backend patterns Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes. Use when building or reviewing Node.js, Express, or Next.js API routes and their data access. - Designing REST or GraphQL API endpoints\n- Implementing repository, service, or controller layers\n- Optimizing database queries (N+1, indexing, connection pooling)\n- Adding caching (Redis, in-memory, HTTP cache headers)\n- Setting up background jobs or async processing\n- Structuring error handling and validation for APIs\n- Building middleware (auth, logging, rate limiting)\n\n"
+    },
+    "benchmark": {
+      "description": "Use this skill to measure performance baselines, detect regressions before/after PRs, and compare stack alternatives.",
+      "name": "benchmark",
+      "path": "ecc/benchmark",
+      "routing_text": "benchmark benchmark Use this skill to measure performance baselines, detect regressions before/after PRs, and compare stack alternatives. - Before and after a PR to measure performance impact\n- Setting up performance baselines for a project\n- When users report \"it feels slow\"\n- Before a launch — ensure you meet performance targets\n- Comparing your stack against alternatives\n\n"
+    },
+    "benchmark-methodology": {
+      "description": ">-",
+      "name": "benchmark-methodology",
+      "path": "ecc/benchmark-methodology",
+      "routing_text": "benchmark methodology benchmark methodology >- - A scoped, tiered competitor set from competitive-platform-analysis is ready to score.\n- Need comparable, evidence-anchored scores across competitors — not gut-feel rankings.\n- Client's strategic tension (the paired axes defining their target white-space) has been established.\n- Preparing to produce profile cards for assembly in competitive-report-structure.\n\n"
+    },
+    "benchmark-optimization-loop": {
+      "description": "Use when the user asks to make something faster, try many variants, run recursive optimization, benchmark latency/throughput/cost, or choose the best implementation by repeated measured tests.",
+      "name": "benchmark-optimization-loop",
+      "path": "ecc/benchmark-optimization-loop",
+      "routing_text": "benchmark optimization loop benchmark optimization loop Use when the user asks to make something faster, try many variants, run recursive optimization, benchmark latency/throughput/cost, or choose the best implementation by repeated measured tests."
+    },
+    "blender-motion-state-inspection": {
+      "description": "Use this skill when inspecting Blender characters, rigs, poses, animation retargeting, ground contact, facing direction, or model-vs-motion alignment where screenshots alone are not enough.",
+      "name": "blender-motion-state-inspection",
+      "path": "ecc/blender-motion-state-inspection",
+      "routing_text": "blender motion state inspection blender motion state inspection Use this skill when inspecting Blender characters, rigs, poses, animation retargeting, ground contact, facing direction, or model-vs-motion alignment where screenshots alone are not enough. - A Blender character looks twisted, mirrored, flattened, offset, or foot-sliding in an animation.\n- A user asks whether an imported avatar, armature, or retargeted motion matches an expected pose.\n- You need to compare rendered evidence with structured facts such as bones, bounding boxes, contacts, and facing vectors.\n- A workflow depends on deciding whether a model is a character, prop, proxy mesh, control rig, or broken import.\n\n"
+    },
+    "blueprint": {
+      "description": ">-",
+      "name": "blueprint",
+      "path": "ecc/blueprint",
+      "routing_text": "blueprint blueprint >- - Breaking a large feature into multiple PRs with clear dependency order\n- Planning a refactor or migration that spans multiple sessions\n- Coordinating parallel workstreams across sub-agents\n- Any task where context loss between sessions would cause rework\n\n**Do not use** for tasks completable in a single PR, fewer than 3 tool calls, or when the user says \"just do it.\"\n\n"
+    },
+    "brand-discovery": {
+      "description": ">-",
+      "name": "brand-discovery",
+      "path": "ecc/brand-discovery",
+      "routing_text": "brand discovery brand discovery >- - A brand is being created, repositioned, or needs a written identity reference to brief collaborators.\n- Multiple sessions are expected — the conversation will span days or weeks.\n- Multiple founders or stakeholders need individual interviews before a reconciliation pass.\n- The user wants a structured, repeatable method rather than an ad-hoc chat.\n- Existing brand documentation is scattered, implicit, or founder-dependent and needs to be made explicit.\n\n"
+    },
+    "brand-voice": {
+      "description": "Build a source-derived writing style profile from real posts, essays, launch notes, docs, or site copy, then reuse that profile across content, outreach, and social workflows. Use when the user wants voice consistency without generic AI writing tropes.",
+      "name": "brand-voice",
+      "path": "ecc/brand-voice",
+      "routing_text": "brand voice brand voice Build a source-derived writing style profile from real posts, essays, launch notes, docs, or site copy, then reuse that profile across content, outreach, and social workflows. Use when the user wants voice consistency without generic AI writing tropes. - the user wants content or outreach in a specific voice\n- writing for X, LinkedIn, email, launch posts, threads, or product updates\n- adapting a known author's tone across channels\n- the existing content lane needs a reusable style system instead of one-off mimicry\n\n"
+    },
+    "browser-qa": {
+      "description": "Use this skill to automate visual testing and UI interaction verification using browser automation after deploying features.",
+      "name": "browser-qa",
+      "path": "ecc/browser-qa",
+      "routing_text": "browser qa browser qa Use this skill to automate visual testing and UI interaction verification using browser automation after deploying features. - After deploying a feature to staging/preview\n- When you need to verify UI behavior across pages\n- Before shipping — confirm layouts, forms, interactions actually work\n- When reviewing PRs that touch frontend code\n- Accessibility audits and responsive testing\n\n"
+    },
+    "bun-runtime": {
+      "description": "Bun as runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes, and Vercel support.",
+      "name": "bun-runtime",
+      "path": "ecc/bun-runtime",
+      "routing_text": "bun runtime bun runtime Bun as runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes, and Vercel support. - **Prefer Bun** for: new JS/TS projects, scripts where install/run speed matters, Vercel deployments with Bun runtime, and when you want a single toolchain (run + install + test + build).\n- **Prefer Node** for: maximum ecosystem compatibility, legacy tooling that assumes Node, or when a dependency has known Bun issues.\n\nUse when: adopting Bun, migrating from Node, writing or debugging Bun scripts/tests, or configuring Bun on Vercel or other platforms.\n\n"
+    },
+    "canary-watch": {
+      "description": "Use this skill to monitor and verify a deployed URL after releases — checks HTTP endpoints, SSE streams, static assets, console errors, and performance regressions after deploys, merges, or dependency upgrades. Smoke / canary / post-deploy verification.",
+      "name": "canary-watch",
+      "path": "ecc/canary-watch",
+      "routing_text": "canary watch canary watch Use this skill to monitor and verify a deployed URL after releases — checks HTTP endpoints, SSE streams, static assets, console errors, and performance regressions after deploys, merges, or dependency upgrades. Smoke / canary / post-deploy verification. - After deploying to production or staging\n- After merging a risky PR\n- When you want to verify a fix actually fixed it\n- Continuous monitoring during a launch window\n- After dependency upgrades\n\n"
+    },
+    "carrier-relationship-management": {
+      "description": ">",
+      "name": "carrier-relationship-management",
+      "path": "ecc/carrier-relationship-management",
+      "routing_text": "carrier relationship management carrier relationship management > - Onboarding a new carrier and vetting safety, insurance, and authority\n- Running an annual or lane-specific RFP for rate benchmarking\n- Building or updating carrier scorecards and performance reviews\n- Reallocating freight during tight capacity or carrier underperformance\n- Negotiating rate increases, fuel surcharges, or accessorial schedules\n\n"
+    },
+    "cisco-ios-patterns": {
+      "description": "Cisco IOS and IOS-XE review patterns for show commands, config hierarchy, wildcard masks, ACL placement, interface hygiene, and safe change-window verification. Use when reading, writing, or reviewing Cisco IOS / IOS-XE configuration or planning a change window.",
+      "name": "cisco-ios-patterns",
+      "path": "ecc/cisco-ios-patterns",
+      "routing_text": "cisco ios patterns cisco ios patterns Cisco IOS and IOS-XE review patterns for show commands, config hierarchy, wildcard masks, ACL placement, interface hygiene, and safe change-window verification. Use when reading, writing, or reviewing Cisco IOS / IOS-XE configuration or planning a change window. - Reviewing IOS or IOS-XE configuration before a planned change.\n- Choosing read-only `show` commands for troubleshooting.\n- Checking ACL wildcard masks and interface direction.\n- Explaining global, interface, routing process, and line configuration modes.\n- Verifying that a change landed in running config and was saved intentionally.\n\n"
+    },
+    "ck": {
+      "description": "Persistent per-project memory for Claude Code. Auto-loads project context on session start, tracks sessions with git activity, and writes to native memory. Commands run deterministic Node.js scripts — behavior is consistent across model versions. Use when a project needs context to survive across Claude Code sessions instead of being re-explained each time.",
+      "name": "ck",
+      "path": "ecc/ck",
+      "routing_text": "ck ck Persistent per-project memory for Claude Code. Auto-loads project context on session start, tracks sessions with git activity, and writes to native memory. Commands run deterministic Node.js scripts — behavior is consistent across model versions. Use when a project needs context to survive across Claude Code sessions instead of being re-explained each time."
+    },
+    "claude-devfleet": {
+      "description": "Orchestrate multi-agent coding tasks via Claude DevFleet — plan projects, dispatch parallel agents in isolated worktrees, monitor progress, and read structured reports. Use when dispatching parallel coding agents across isolated worktrees and tracking their reports.",
+      "name": "claude-devfleet",
+      "path": "ecc/claude-devfleet",
+      "routing_text": "claude devfleet claude devfleet Orchestrate multi-agent coding tasks via Claude DevFleet — plan projects, dispatch parallel agents in isolated worktrees, monitor progress, and read structured reports. Use when dispatching parallel coding agents across isolated worktrees and tracking their reports. Use this skill when you need to dispatch multiple Claude Code agents to work on coding tasks in parallel. Each agent runs in an isolated git worktree with full tooling.\n\n"
+    },
+    "click-path-audit": {
+      "description": "Trace every user-facing button/touchpoint through its full state change sequence to find bugs where functions individually work but cancel each other out, produce wrong final state, or leave the UI in an inconsistent state. Use when: systematic debugging found no bugs but users report broken buttons, or after any major refactor touching shared state stores.",
+      "name": "click-path-audit",
+      "path": "ecc/click-path-audit",
+      "routing_text": "click path audit click path audit Trace every user-facing button/touchpoint through its full state change sequence to find bugs where functions individually work but cancel each other out, produce wrong final state, or leave the UI in an inconsistent state. Use when: systematic debugging found no bugs but users report broken buttons, or after any major refactor touching shared state stores. - After systematic debugging finds \"no bugs\" but users report broken UI\n- After modifying any Zustand store action (check all callers)\n- After any refactor that touches shared state\n- Before release, on critical user flows\n- When a button \"does nothing\" — this is THE tool for that\n\n"
+    },
+    "clickhouse-io": {
+      "description": "ClickHouse database patterns, query optimization, analytics, and data engineering best practices for high-performance analytical workloads. Use when writing ClickHouse schemas or queries, or when an analytical query is too slow.",
+      "name": "clickhouse-io",
+      "path": "ecc/clickhouse-io",
+      "routing_text": "clickhouse io clickhouse io ClickHouse database patterns, query optimization, analytics, and data engineering best practices for high-performance analytical workloads. Use when writing ClickHouse schemas or queries, or when an analytical query is too slow. - Designing ClickHouse table schemas (MergeTree engine selection)\n- Writing analytical queries (aggregations, window functions, joins)\n- Optimizing query performance (partition pruning, projections, materialized views)\n- Ingesting large volumes of data (batch inserts, Kafka integration)\n- Migrating from PostgreSQL/MySQL to ClickHouse for analytics\n- Implementing real-time dashboards or time-series analytics\n\n"
+    },
+    "code-tour": {
+      "description": "Create CodeTour `.tour` files — persona-targeted, step-by-step walkthroughs with real file and line anchors. Use for onboarding tours, architecture walkthroughs, PR tours, RCA tours, and structured \"explain how this works\" requests. Use when the user asks for a code tour, onboarding walkthrough, PR tour, or an explanation of how a subsystem works.",
+      "name": "code-tour",
+      "path": "ecc/code-tour",
+      "routing_text": "code tour code tour Create CodeTour `.tour` files — persona-targeted, step-by-step walkthroughs with real file and line anchors. Use for onboarding tours, architecture walkthroughs, PR tours, RCA tours, and structured \"explain how this works\" requests. Use when the user asks for a code tour, onboarding walkthrough, PR tour, or an explanation of how a subsystem works. Use this skill when:\n- the user asks for a code tour, onboarding tour, architecture walkthrough, or PR tour\n- the user says \"explain how X works\" and wants a reusable guided artifact\n- the user wants a ramp-up path for a new engineer or reviewer\n- the task is better served by a guided sequence than a flat summary\n\nExamples:\n- onboarding a new maintainer\n- architecture tour for one service or package\n- PR-review walk-through anchored to changed files\n- RCA tour showing the failure path\n- security review tour of trust boundaries and key checks\n\n"
+    },
+    "codebase-onboarding": {
+      "description": "Analyze an unfamiliar codebase and generate a structured onboarding guide with architecture map, key entry points, conventions, and a starter CLAUDE.md. Use when joining a new project or setting up Claude Code for the first time in a repo.",
+      "name": "codebase-onboarding",
+      "path": "ecc/codebase-onboarding",
+      "routing_text": "codebase onboarding codebase onboarding Analyze an unfamiliar codebase and generate a structured onboarding guide with architecture map, key entry points, conventions, and a starter CLAUDE.md. Use when joining a new project or setting up Claude Code for the first time in a repo. - First time opening a project with Claude Code\n- Joining a new team or repository\n- User asks \"help me understand this codebase\"\n- User asks to generate a CLAUDE.md for a project\n- User says \"onboard me\" or \"walk me through this repo\"\n\n"
+    },
+    "codehealth-mcp": {
+      "description": "Real-time structural Code Health via CodeScene MCP — review before edits, verify score deltas after changes, gate commits and PRs. Use when reviewing code quality, refactoring, checking if AI changes degraded a file, or before commit/PR.",
+      "name": "codehealth-mcp",
+      "path": "ecc/codehealth-mcp",
+      "routing_text": "codehealth mcp codehealth mcp Real-time structural Code Health via CodeScene MCP — review before edits, verify score deltas after changes, gate commits and PRs. Use when reviewing code quality, refactoring, checking if AI changes degraded a file, or before commit/PR. - User asks to **review code quality**, **refactor** a file, or check if **AI changes degraded** maintainability\n- Before editing a **hotspot**, legacy module, or unfamiliar file\n- Before **commit** or **pull request** when you need a maintainability safeguard\n- After a large agent-written diff — verify Code Health did not regress\n- Pair with `verification-loop`, `tdd-workflow`, or `/quality-gate` as a structural check (not a replacement for tests/lint)\n\n"
+    },
+    "coding-standards": {
+      "description": "Baseline cross-project coding conventions for naming, readability, immutability, and code-quality review. Use detailed frontend or backend skills for framework-specific patterns. Use when reviewing code quality or naming with no framework-specific skill that applies.",
+      "name": "coding-standards",
+      "path": "ecc/coding-standards",
+      "routing_text": "coding standards coding standards Baseline cross-project coding conventions for naming, readability, immutability, and code-quality review. Use detailed frontend or backend skills for framework-specific patterns. Use when reviewing code quality or naming with no framework-specific skill that applies. - Starting a new project or module\n- Reviewing code for quality and maintainability\n- Refactoring existing code to follow conventions\n- Enforcing naming, formatting, or structural consistency\n- Setting up linting, formatting, or type-checking rules\n- Onboarding new contributors to coding conventions\n\n"
+    },
+    "competitive-platform-analysis": {
+      "description": ">-",
+      "name": "competitive-platform-analysis",
+      "path": "ecc/competitive-platform-analysis",
+      "routing_text": "competitive platform analysis competitive platform analysis >- - About to start a competitive benchmarking project and need to define the competitor set first.\n- Unsure which companies belong in Direct / Adjacent / Aspirational tiers.\n- Need a defensible, pruned scope for a market landscape report.\n- Has a positioning brief and wants to identify who contests that position.\n- First step before running benchmark-methodology.\n\n"
+    },
+    "competitive-report-structure": {
+      "description": ">-",
+      "name": "competitive-report-structure",
+      "path": "ecc/competitive-report-structure",
+      "routing_text": "competitive report structure competitive report structure >- - All competitor profile cards from benchmark-methodology are complete and ready to assemble.\n- Need to present competitive findings to a founder, leadership team, or board.\n- The report must drive decisions (who to compete with, how, where the moat is) — not just document the landscape.\n- Preparing a client deliverable that must be auditable and defensible.\n\n"
+    },
+    "compose-multiplatform-patterns": {
+      "description": "Compose Multiplatform and Jetpack Compose patterns for KMP projects — state management, navigation, theming, performance, and platform-specific UI. Use when building Compose or Jetpack Compose UI, state, navigation, or theming in a KMP project.",
+      "name": "compose-multiplatform-patterns",
+      "path": "ecc/compose-multiplatform-patterns",
+      "routing_text": "compose multiplatform patterns compose multiplatform patterns Compose Multiplatform and Jetpack Compose patterns for KMP projects — state management, navigation, theming, performance, and platform-specific UI. Use when building Compose or Jetpack Compose UI, state, navigation, or theming in a KMP project. - Building Compose UI (Jetpack Compose or Compose Multiplatform)\n- Managing UI state with ViewModels and Compose state\n- Implementing navigation in KMP or Android projects\n- Designing reusable composables and design systems\n- Optimizing recomposition and rendering performance\n\n"
+    },
+    "config-gc": {
+      "description": "Garbage collection for your Claude Code configuration. Periodically scans ~/.claude (skills, memory, hooks, permissions, MCP servers, caches) for redundant, stale, orphaned, or low-value items, then walks the user through a confirm-each-deletion cleanup. Use when the user says \"clean up my config\", \"config GC\", \"too many skills\", \"audit my setup\", \"my .claude is bloated\", or asks for a periodic config review.",
+      "name": "config-gc",
+      "path": "ecc/config-gc",
+      "routing_text": "config gc config gc Garbage collection for your Claude Code configuration. Periodically scans ~/.claude (skills, memory, hooks, permissions, MCP servers, caches) for redundant, stale, orphaned, or low-value items, then walks the user through a confirm-each-deletion cleanup. Use when the user says \"clean up my config\", \"config GC\", \"too many skills\", \"audit my setup\", \"my .claude is bloated\", or asks for a periodic config review. - The user asks to clean up, audit, or slim down their Claude Code configuration\n- The user complains about too many skills, noisy hooks, or slow session startup\n- A monthly/periodic config review is due\n- After installing a large skill pack (e.g. this repo), to reconcile overlaps with existing setup\n\nDo NOT activate for: cleaning project source code (that's refactoring), clearing chat history, or uninstalling Claude Code itself.\n\n"
+    },
+    "configure-ecc": {
+      "description": "Guide ECC installation, update, or reconfiguration from inside Claude Code, Codex, or Kimi while respecting each harness's real plugin, scope, and hook capabilities.",
+      "name": "configure-ecc",
+      "path": "ecc/configure-ecc",
+      "routing_text": "configure ecc configure ecc Guide ECC installation, update, or reconfiguration from inside Claude Code, Codex, or Kimi while respecting each harness's real plugin, scope, and hook capabilities."
+    },
+    "connections-optimizer": {
+      "description": "Reorganize the user's X and LinkedIn network with review-first pruning, add/follow recommendations, and channel-specific warm outreach drafted in the user's real voice. Use when the user wants to clean up following lists, grow toward current priorities, or rebalance a social graph around higher-signal relationships.",
+      "name": "connections-optimizer",
+      "path": "ecc/connections-optimizer",
+      "routing_text": "connections optimizer connections optimizer Reorganize the user's X and LinkedIn network with review-first pruning, add/follow recommendations, and channel-specific warm outreach drafted in the user's real voice. Use when the user wants to clean up following lists, grow toward current priorities, or rebalance a social graph around higher-signal relationships. - the user wants to prune their X following\n- the user wants to rebalance who they follow or stay connected to\n- the user says \"clean up my network\", \"who should I unfollow\", \"who should I follow\", \"who should I reconnect with\"\n- outreach quality depends on network structure, not just cold list generation\n\n"
+    },
+    "content-engine": {
+      "description": "Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms.",
+      "name": "content-engine",
+      "path": "ecc/content-engine",
+      "routing_text": "content engine content engine Create platform-native content systems for X, LinkedIn, TikTok, YouTube, newsletters, and repurposed multi-platform campaigns. Use when the user wants social posts, threads, scripts, content calendars, or one source asset adapted cleanly across platforms. - writing X posts or threads\n- drafting LinkedIn posts or launch updates\n- scripting short-form video or YouTube explainers\n- repurposing articles, podcasts, demos, docs, or internal notes into public content\n- building a launch sequence or ongoing content system around a product, insight, or narrative\n\n"
+    },
+    "content-hash-cache-pattern": {
+      "description": "Cache expensive file processing results using SHA-256 content hashes — path-independent, auto-invalidating, with service layer separation. Use when repeated file processing is slow and results should be cached and invalidated by content rather than path.",
+      "name": "content-hash-cache-pattern",
+      "path": "ecc/content-hash-cache-pattern",
+      "routing_text": "content hash cache pattern content hash cache pattern Cache expensive file processing results using SHA-256 content hashes — path-independent, auto-invalidating, with service layer separation. Use when repeated file processing is slow and results should be cached and invalidated by content rather than path. - Building file processing pipelines (PDF, images, text extraction)\n- Processing cost is high and same files are processed repeatedly\n- Need a `--cache/--no-cache` CLI option\n- Want to add caching to existing pure functions without modifying them\n\n"
+    },
+    "context-budget": {
+      "description": "Audits Claude Code context window consumption across agents, skills, MCP servers, and rules. Identifies bloat, redundant components, and produces prioritized token-savings recommendations. Use when the context window is filling up too fast and the agents, skills, MCP servers, or rules consuming it need to be identified.",
+      "name": "context-budget",
+      "path": "ecc/context-budget",
+      "routing_text": "context budget context budget Audits Claude Code context window consumption across agents, skills, MCP servers, and rules. Identifies bloat, redundant components, and produces prioritized token-savings recommendations. Use when the context window is filling up too fast and the agents, skills, MCP servers, or rules consuming it need to be identified. - Session performance feels sluggish or output quality is degrading\n- You've recently added many skills, agents, or MCP servers\n- You want to know how much context headroom you actually have\n- Planning to add more components and need to know if there's room\n- Running `/context-budget` command (this skill backs it)\n\n"
+    },
+    "continuous-agent-loop": {
+      "description": "Patterns for continuous autonomous agent loops with quality gates, evals, and recovery controls. Use when running an agent loop that must self-check, gate on evals, and recover from failures.",
+      "name": "continuous-agent-loop",
+      "path": "ecc/continuous-agent-loop",
+      "routing_text": "continuous agent loop continuous agent loop Patterns for continuous autonomous agent loops with quality gates, evals, and recovery controls. Use when running an agent loop that must self-check, gate on evals, and recover from failures."
+    },
+    "continuous-learning": {
+      "description": "[DEPRECATED - use continuous-learning-v2] Legacy v1 stop-hook skill extractor. v2 is a strict superset with instinct-based, project-scoped, hook-reliable learning. Do not invoke v1: when continuous learning, session learning, or pattern extraction is requested, route to continuous-learning-v2 instead.",
+      "name": "continuous-learning",
+      "path": "ecc/continuous-learning",
+      "routing_text": "continuous learning continuous learning [DEPRECATED - use continuous-learning-v2] Legacy v1 stop-hook skill extractor. v2 is a strict superset with instinct-based, project-scoped, hook-reliable learning. Do not invoke v1: when continuous learning, session learning, or pattern extraction is requested, route to continuous-learning-v2 instead. - Setting up automatic pattern extraction from Claude Code sessions\n- Configuring the Stop hook for session evaluation\n- Reviewing or curating learned skills in `~/.claude/skills/learned/`\n- Adjusting extraction thresholds or pattern categories\n- Comparing v1 (this) vs v2 (instinct-based) approaches\n\n"
+    },
+    "continuous-learning-v2": {
+      "description": "Instinct-based learning system that observes sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills/commands/agents. v2.1 adds project-scoped instincts to prevent cross-project contamination. Use when capturing lessons from a session, managing instincts, or promoting them into skills, commands, or agents.",
+      "name": "continuous-learning-v2",
+      "path": "ecc/continuous-learning-v2",
+      "routing_text": "continuous learning v2 continuous learning v2 Instinct-based learning system that observes sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills/commands/agents. v2.1 adds project-scoped instincts to prevent cross-project contamination. Use when capturing lessons from a session, managing instincts, or promoting them into skills, commands, or agents. - Setting up automatic learning from Claude Code sessions\n- Configuring instinct-based behavior extraction via hooks\n- Tuning confidence thresholds for learned behaviors\n- Reviewing, exporting, or importing instinct libraries\n- Evolving instincts into full skills, commands, or agents\n- Managing project-scoped vs global instincts\n- Promoting instincts from project to global scope\n\n"
+    },
+    "contract-first": {
+      "description": "Use when multiple consumers and providers must evolve an API or event schema without field drift, integration surprises, or one side silently redefining the interface.",
+      "name": "contract-first",
+      "path": "ecc/contract-first",
+      "routing_text": "contract first contract first Use when multiple consumers and providers must evolve an API or event schema without field drift, integration surprises, or one side silently redefining the interface. - Frontend and backend work will proceed in parallel.\n- Two or more services exchange API payloads, events, or commands.\n- Field names, nullability, enums, or error shapes regularly drift.\n- One consumer needs several calls because the provider exposed storage models\n  instead of a task-oriented response.\n- A provider change can break consumers maintained by another person or agent.\n- Mock responses and production responses no longer have the same shape.\n\nDo not add contract machinery to a single-module boundary that changes in one\natomic commit and has no independent consumer. A shared type may be enough.\n\n"
+    },
+    "cost-aware-llm-pipeline": {
+      "description": "Cost optimization patterns for LLM API usage — model routing by task complexity, budget tracking, retry logic, and prompt caching. Use when LLM spend needs to come down, or when routing tasks across model tiers and budgets.",
+      "name": "cost-aware-llm-pipeline",
+      "path": "ecc/cost-aware-llm-pipeline",
+      "routing_text": "cost aware llm pipeline cost aware llm pipeline Cost optimization patterns for LLM API usage — model routing by task complexity, budget tracking, retry logic, and prompt caching. Use when LLM spend needs to come down, or when routing tasks across model tiers and budgets. - Building applications that call LLM APIs (Claude, GPT, etc.)\n- Processing batches of items with varying complexity\n- Need to stay within a budget for API spend\n- Optimizing cost without sacrificing quality on complex tasks\n\n"
+    },
+    "cost-tracking": {
+      "description": "Track and report Claude Code token usage, spending, and budgets from the local ECC cost-tracker metrics log. Use when the user asks about costs, spending, usage, tokens, budgets, or cost breakdowns by model, session, or date.",
+      "name": "cost-tracking",
+      "path": "ecc/cost-tracking",
+      "routing_text": "cost tracking cost tracking Track and report Claude Code token usage, spending, and budgets from the local ECC cost-tracker metrics log. Use when the user asks about costs, spending, usage, tokens, budgets, or cost breakdowns by model, session, or date. - The user asks \"how much have I spent?\", \"what did this session cost?\", or\n  \"what is my token usage?\"\n- The user mentions budgets, spending limits, overruns, or cost controls.\n- The user wants a cost breakdown by model, session, or date, or a CSV export.\n\n"
+    },
+    "council": {
+      "description": "Convene a four-voice council for ambiguous decisions, tradeoffs, and go/no-go calls. Use when multiple valid paths exist and you need structured disagreement before choosing.",
+      "name": "council",
+      "path": "ecc/council",
+      "routing_text": "council council Convene a four-voice council for ambiguous decisions, tradeoffs, and go/no-go calls. Use when multiple valid paths exist and you need structured disagreement before choosing. Use council when:\n- a decision has multiple credible paths and no obvious winner\n- you need explicit tradeoff surfacing\n- the user asks for second opinions, dissent, or multiple perspectives\n- conversational anchoring is a real risk\n- a go / no-go call would benefit from adversarial challenge\n\nExamples:\n- monorepo vs polyrepo\n- ship now vs hold for polish\n- feature flag vs full rollout\n- simplify scope vs keep strategic breadth\n\n"
+    },
+    "council-multi-model": {
+      "description": "Add one optional external Codex critique after the existing council has produced a decision draft. Use when an ambiguous, high-consequence decision would benefit from a separate model invocation's attempt to break the synthesis. Requires explicit consent before sending the compact draft and disagreement to OpenAI, labels same-provider reviews honestly, and marks the review absent when the adapter is unavailable.",
+      "name": "council-multi-model",
+      "path": "ecc/council-multi-model",
+      "routing_text": "council multi model council multi model Add one optional external Codex critique after the existing council has produced a decision draft. Use when an ambiguous, high-consequence decision would benefit from a separate model invocation's attempt to break the synthesis. Requires explicit consent before sending the compact draft and disagreement to OpenAI, labels same-provider reviews honestly, and marks the review absent when the adapter is unavailable. Use this extension when all of these are true:\n\n- `council` is appropriate and has already produced raw disagreement plus a\n  synthesis draft;\n- the decision is consequential enough to justify sending a compact review\n  packet to another model invocation;\n- the user explicitly agrees to send that packet to OpenAI.\n\nDo not use it for ordinary factual questions, implementation planning, or code\nreview. Do not send proprietary, regulated, credential-bearing, or personal\nmaterial unless the user has explicitly approved that exact transfer.\n\n"
+    },
+    "cpp-coding-standards": {
+      "description": "C++ coding standards based on the C++ Core Guidelines (isocpp.github.io). Use when writing, reviewing, or refactoring C++ code to enforce modern, safe, and idiomatic practices.",
+      "name": "cpp-coding-standards",
+      "path": "ecc/cpp-coding-standards",
+      "routing_text": "cpp coding standards cpp coding standards C++ coding standards based on the C++ Core Guidelines (isocpp.github.io). Use when writing, reviewing, or refactoring C++ code to enforce modern, safe, and idiomatic practices. - Writing new C++ code (classes, functions, templates)\n- Reviewing or refactoring existing C++ code\n- Making architectural decisions in C++ projects\n- Enforcing consistent style across a C++ codebase\n- Choosing between language features (e.g., `enum` vs `enum class`, raw pointer vs smart pointer)\n\n### When NOT to Use\n\n- Non-C++ projects\n- Legacy C codebases that cannot adopt modern C++ features\n- Embedded/bare-metal contexts where specific guidelines conflict with hardware constraints (adapt selectively)\n\n"
+    },
+    "cpp-testing": {
+      "description": "Use only when writing/updating/fixing C++ tests, configuring GoogleTest/CTest, diagnosing failing or flaky tests, or adding coverage/sanitizers.",
+      "name": "cpp-testing",
+      "path": "ecc/cpp-testing",
+      "routing_text": "cpp testing cpp testing Use only when writing/updating/fixing C++ tests, configuring GoogleTest/CTest, diagnosing failing or flaky tests, or adding coverage/sanitizers. - Writing new C++ tests or fixing existing tests\n- Designing unit/integration test coverage for C++ components\n- Adding test coverage, CI gating, or regression protection\n- Configuring CMake/CTest workflows for consistent execution\n- Investigating test failures or flaky behavior\n- Enabling sanitizers for memory/race diagnostics\n\n### When NOT to Use\n\n- Implementing new product features without test changes\n- Large-scale refactors unrelated to test coverage or failures\n- Performance tuning without test regressions to validate\n- Non-C++ projects or non-test tasks\n\n"
+    },
+    "crosspost": {
+      "description": "Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms.",
+      "name": "crosspost",
+      "path": "ecc/crosspost",
+      "routing_text": "crosspost crosspost Multi-platform content distribution across X, LinkedIn, Threads, and Bluesky. Adapts content per platform using content-engine patterns. Never posts identical content cross-platform. Use when the user wants to distribute content across social platforms. - the user wants to publish the same underlying idea across multiple platforms\n- a launch, update, release, or essay needs platform-specific versions\n- the user says \"crosspost\", \"post this everywhere\", or \"adapt this for X and LinkedIn\"\n\n"
+    },
+    "csharp-testing": {
+      "description": "C# and .NET testing patterns with xUnit, FluentAssertions, mocking, integration tests, and test organization best practices. Use when writing or reviewing xUnit tests, mocks, or integration tests in a C# / .NET project.",
+      "name": "csharp-testing",
+      "path": "ecc/csharp-testing",
+      "routing_text": "csharp testing csharp testing C# and .NET testing patterns with xUnit, FluentAssertions, mocking, integration tests, and test organization best practices. Use when writing or reviewing xUnit tests, mocks, or integration tests in a C# / .NET project. - Writing new tests for C# code\n- Reviewing test quality and coverage\n- Setting up test infrastructure for .NET projects\n- Debugging flaky or slow tests\n\n"
+    },
+    "customer-billing-ops": {
+      "description": "Operate customer billing workflows such as subscriptions, refunds, churn triage, billing-portal recovery, and plan analysis using connected billing tools like Stripe. Use when the user needs to help a customer, inspect subscription state, or manage revenue-impacting billing operations.",
+      "name": "customer-billing-ops",
+      "path": "ecc/customer-billing-ops",
+      "routing_text": "customer billing ops customer billing ops Operate customer billing workflows such as subscriptions, refunds, churn triage, billing-portal recovery, and plan analysis using connected billing tools like Stripe. Use when the user needs to help a customer, inspect subscription state, or manage revenue-impacting billing operations. - Customer says billing is broken, they want a refund, or they cannot cancel\n- Investigating duplicate subscriptions, accidental charges, failed renewals, or churn risk\n- Reviewing plan mix, active subscriptions, yearly vs monthly conversion, or team-seat confusion\n- Creating or validating a billing portal flow\n- Auditing support complaints that touch subscriptions, invoices, refunds, or payment methods\n\n"
+    },
+    "customs-trade-compliance": {
+      "description": ">",
+      "name": "customs-trade-compliance",
+      "path": "ecc/customs-trade-compliance",
+      "routing_text": "customs trade compliance customs trade compliance > - Classifying goods under HS/HTS tariff codes for import or export\n- Preparing customs documentation (commercial invoices, certificates of origin, ISF filings)\n- Screening parties against denied/restricted entity lists (SDN, Entity List, EU sanctions)\n- Evaluating FTA qualification and duty savings opportunities\n- Responding to customs audits, CF-28/CF-29 requests, or penalty notices\n\n"
+    },
+    "dart-flutter-patterns": {
+      "description": "Production-ready Dart and Flutter patterns covering null safety, immutable state, async composition, widget architecture, popular state management frameworks (BLoC, Riverpod, Provider), GoRouter navigation, Dio networking, Freezed code generation, and clean architecture. Use when writing or reviewing Dart and Flutter code — state, widgets, navigation, networking, or architecture.",
+      "name": "dart-flutter-patterns",
+      "path": "ecc/dart-flutter-patterns",
+      "routing_text": "dart flutter patterns dart flutter patterns Production-ready Dart and Flutter patterns covering null safety, immutable state, async composition, widget architecture, popular state management frameworks (BLoC, Riverpod, Provider), GoRouter navigation, Dio networking, Freezed code generation, and clean architecture. Use when writing or reviewing Dart and Flutter code — state, widgets, navigation, networking, or architecture. Use this skill when:\n- Starting a new Flutter feature and need idiomatic patterns for state management, navigation, or data access\n- Reviewing or writing Dart code and need guidance on null safety, sealed types, or async composition\n- Setting up a new Flutter project and choosing between BLoC, Riverpod, or Provider\n- Implementing secure HTTP clients, WebView integration, or local storage\n- Writing tests for Flutter widgets, Cubits, or Riverpod providers\n- Wiring up GoRouter with authentication guards\n\n"
+    },
+    "dashboard-builder": {
+      "description": "Build monitoring dashboards that answer real operator questions for Grafana, SigNoz, and similar platforms. Use when turning metrics into a working dashboard instead of a vanity board.",
+      "name": "dashboard-builder",
+      "path": "ecc/dashboard-builder",
+      "routing_text": "dashboard builder dashboard builder Build monitoring dashboards that answer real operator questions for Grafana, SigNoz, and similar platforms. Use when turning metrics into a working dashboard instead of a vanity board. - \"Build a Kafka monitoring dashboard\"\n- \"Create a Grafana dashboard for Elasticsearch\"\n- \"Make a SigNoz dashboard for this service\"\n- \"Turn this metrics list into a real operational dashboard\"\n\n"
+    },
+    "data-scraper-agent": {
+      "description": "Build a fully automated AI-powered data collection agent for any public source — job boards, prices, news, GitHub, sports, anything. Runs on a schedule, enriches data with a free LLM (Gemini Flash), stores results in Notion/Sheets/Supabase, and learns from user feedback. Runs 100% free on GitHub Actions. Use when the user wants to monitor, collect, or track any public data automatically.",
+      "name": "data-scraper-agent",
+      "path": "ecc/data-scraper-agent",
+      "routing_text": "data scraper agent data scraper agent Build a fully automated AI-powered data collection agent for any public source — job boards, prices, news, GitHub, sports, anything. Runs on a schedule, enriches data with a free LLM (Gemini Flash), stores results in Notion/Sheets/Supabase, and learns from user feedback. Runs 100% free on GitHub Actions. Use when the user wants to monitor, collect, or track any public data automatically. - User wants to gather or monitor any public website or API\n- User says \"build a bot that checks...\", \"monitor X for me\", \"collect data from...\"\n- User wants to track jobs, prices, news, repos, sports scores, events, listings\n- User asks how to automate data collection without paying for hosting\n- User wants an agent that gets smarter over time based on their decisions\n\n"
+    },
+    "data-throughput-accelerator": {
+      "description": "Use when large data ingestion, backfill, export, ETL, warehouse loading, manifest catch-up, or table synchronization needs to become much faster while preserving data correctness.",
+      "name": "data-throughput-accelerator",
+      "path": "ecc/data-throughput-accelerator",
+      "routing_text": "data throughput accelerator data throughput accelerator Use when large data ingestion, backfill, export, ETL, warehouse loading, manifest catch-up, or table synchronization needs to become much faster while preserving data correctness."
+    },
+    "database-migrations": {
+      "description": "Database migration best practices for schema changes, data migrations, rollbacks, and zero-downtime deployments across PostgreSQL, MySQL, and common ORMs (Prisma, Drizzle, Kysely, Django, TypeORM, golang-migrate). Use when writing a schema or data migration, planning a rollback, or aiming for zero-downtime deployment.",
+      "name": "database-migrations",
+      "path": "ecc/database-migrations",
+      "routing_text": "database migrations database migrations Database migration best practices for schema changes, data migrations, rollbacks, and zero-downtime deployments across PostgreSQL, MySQL, and common ORMs (Prisma, Drizzle, Kysely, Django, TypeORM, golang-migrate). Use when writing a schema or data migration, planning a rollback, or aiming for zero-downtime deployment. - Creating or altering database tables\n- Adding/removing columns or indexes\n- Running data migrations (backfill, transform)\n- Planning zero-downtime schema changes\n- Setting up migration tooling for a new project\n\n"
+    },
+    "deep-research": {
+      "description": "Multi-source deep research using firecrawl and exa MCPs. Searches the web, synthesizes findings, and delivers cited reports with source attribution. Use when the user wants thorough research on any topic with evidence and citations.",
+      "name": "deep-research",
+      "path": "ecc/deep-research",
+      "routing_text": "deep research deep research Multi-source deep research using firecrawl and exa MCPs. Searches the web, synthesizes findings, and delivers cited reports with source attribution. Use when the user wants thorough research on any topic with evidence and citations. - User asks to research any topic in depth\n- Competitive analysis, technology evaluation, or market sizing\n- Due diligence on companies, investors, or technologies\n- Any question requiring synthesis from multiple sources\n- User says \"research\", \"deep dive\", \"investigate\", or \"what's the current state of\"\n\n"
+    },
+    "defi-amm-security": {
+      "description": "Security checklist for Solidity AMM contracts, liquidity pools, and swap flows. Covers reentrancy, CEI ordering, donation or inflation attacks, oracle manipulation, slippage, admin controls, and integer math. Use when auditing or writing Solidity AMM, liquidity pool, or swap code.",
+      "name": "defi-amm-security",
+      "path": "ecc/defi-amm-security",
+      "routing_text": "defi amm security defi amm security Security checklist for Solidity AMM contracts, liquidity pools, and swap flows. Covers reentrancy, CEI ordering, donation or inflation attacks, oracle manipulation, slippage, admin controls, and integer math. Use when auditing or writing Solidity AMM, liquidity pool, or swap code. - Writing or auditing a Solidity AMM or liquidity-pool contract\n- Implementing swap, deposit, withdraw, mint, or burn flows that hold token balances\n- Reviewing any contract that uses `token.balanceOf(address(this))` in share or reserve math\n- Adding fee setters, pausers, oracle updates, or other admin functions to a DeFi protocol\n\n"
+    },
+    "delivery-gate": {
+      "description": "Stop hook that blocks Claude from finishing until quality checks pass. Detects rationalization patterns (surface text heuristics), stale learning logs (filesystem mtime), and low disk space. Complements self-audit by mechanically enforcing learning capture habits. Use when Claude should be mechanically blocked from declaring work finished before quality checks and learning capture actually pass.",
+      "name": "delivery-gate",
+      "path": "ecc/delivery-gate",
+      "routing_text": "delivery gate delivery gate Stop hook that blocks Claude from finishing until quality checks pass. Detects rationalization patterns (surface text heuristics), stale learning logs (filesystem mtime), and low disk space. Complements self-audit by mechanically enforcing learning capture habits. Use when Claude should be mechanically blocked from declaring work finished before quality checks and learning capture actually pass."
+    },
+    "deployment-patterns": {
+      "description": "Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists for web applications. Use when setting up CI/CD, containerizing an app, or checking production readiness before a release.",
+      "name": "deployment-patterns",
+      "path": "ecc/deployment-patterns",
+      "routing_text": "deployment patterns deployment patterns Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists for web applications. Use when setting up CI/CD, containerizing an app, or checking production readiness before a release. - Setting up CI/CD pipelines\n- Dockerizing an application\n- Planning deployment strategy (blue-green, canary, rolling)\n- Implementing health checks and readiness probes\n- Preparing for a production release\n- Configuring environment-specific settings\n\n"
+    },
+    "design-system": {
+      "description": "Use this skill to generate or audit design systems, check visual consistency, and review PRs that touch styling. Use when generating or auditing a design system, checking visual consistency, or reviewing a PR that touches styling.",
+      "name": "design-system",
+      "path": "ecc/design-system",
+      "routing_text": "design system design system Use this skill to generate or audit design systems, check visual consistency, and review PRs that touch styling. Use when generating or auditing a design system, checking visual consistency, or reviewing a PR that touches styling. - Starting a new project that needs a design system\n- Auditing an existing codebase for visual consistency\n- Before a redesign — understand what you have\n- When the UI looks \"off\" but you can't pinpoint why\n- Reviewing PRs that touch styling\n\n"
+    },
+    "dev-team": {
+      "description": "Simulate a collaborative dev team session where multiple role-based personas (PM, Architect, Developer, QA) respond to the same problem together in one session. Use when designing a feature, reviewing a proposal, or onboarding a new initiative and you want multi-role perspective without switching agents manually.",
+      "name": "dev-team",
+      "path": "ecc/dev-team",
+      "routing_text": "dev team dev team Simulate a collaborative dev team session where multiple role-based personas (PM, Architect, Developer, QA) respond to the same problem together in one session. Use when designing a feature, reviewing a proposal, or onboarding a new initiative and you want multi-role perspective without switching agents manually. The user provides a **topic** — a feature description, proposal, story, or question. The skill runs all four personas in parallel as independent subagents, then presents their responses together.\n\nUse when:\n\n- Designing a new feature and wanting PM, Architect, Dev, and QA concerns surfaced at once\n- Reviewing a proposal before committing to implementation\n- Onboarding an initiative and wanting each role to define their first concerns\n- User says \"what would the team think about this\", \"give me all perspectives\", or \"run this by the team\"\n- Starting a story and wanting role-specific input before writing a single line of code\n\n### When NOT to Use\n\n| Condition | Use Instead |\n| --- | --- |\n| Ambiguous go/no-go decision with real tradeoffs | `council` |\n| You want to hand-pick which agents participate | `team-builder` |\n| Single-role deep-dive (e.g. architecture only) | the `architect` agent |\n| Code review | the `code-reviewer` agent or `/code-review` |\n| Structured adversarial challenge | `santa-method` |\n\n"
+    },
+    "django-celery": {
+      "description": "Django + Celery async task patterns — configuration, task design, beat scheduling, retries, canvas workflows, monitoring, and testing. Use when adding background jobs, scheduled tasks, or async processing to a Django app.",
+      "name": "django-celery",
+      "path": "ecc/django-celery",
+      "routing_text": "django celery django celery Django + Celery async task patterns — configuration, task design, beat scheduling, retries, canvas workflows, monitoring, and testing. Use when adding background jobs, scheduled tasks, or async processing to a Django app. - Adding background jobs or async processing to a Django app\n- Implementing periodic/scheduled tasks\n- Offloading slow operations (email, PDF generation, API calls) from request cycle\n- Setting up Celery Beat for cron-like scheduling\n- Debugging task failures, retries, or queue backlogs\n- Writing tests for Celery tasks\n\n"
+    },
+    "django-patterns": {
+      "description": "Django architecture patterns, REST API design with DRF, ORM best practices, caching, signals, middleware, and production-grade Django apps. Use when building or reviewing Django apps, DRF APIs, ORM queries, or caching.",
+      "name": "django-patterns",
+      "path": "ecc/django-patterns",
+      "routing_text": "django patterns django patterns Django architecture patterns, REST API design with DRF, ORM best practices, caching, signals, middleware, and production-grade Django apps. Use when building or reviewing Django apps, DRF APIs, ORM queries, or caching. - Building Django web applications\n- Designing Django REST Framework APIs\n- Working with Django ORM and models\n- Setting up Django project structure\n- Implementing caching, signals, middleware\n\n"
+    },
+    "django-security": {
+      "description": "Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations. Use when reviewing Django authentication, authorization, input handling, or deployment settings.",
+      "name": "django-security",
+      "path": "ecc/django-security",
+      "routing_text": "django security django security Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations. Use when reviewing Django authentication, authorization, input handling, or deployment settings. - Setting up Django authentication and authorization\n- Implementing user permissions and roles\n- Configuring production security settings\n- Reviewing Django application for security issues\n- Deploying Django applications to production\n\n"
+    },
+    "django-tdd": {
+      "description": "Django testing strategies with pytest-django, TDD methodology, factory_boy, mocking, coverage, and testing Django REST Framework APIs. Use when writing Django or DRF tests with pytest-django, or driving a Django feature test-first.",
+      "name": "django-tdd",
+      "path": "ecc/django-tdd",
+      "routing_text": "django tdd django tdd Django testing strategies with pytest-django, TDD methodology, factory_boy, mocking, coverage, and testing Django REST Framework APIs. Use when writing Django or DRF tests with pytest-django, or driving a Django feature test-first. - Writing new Django applications\n- Implementing Django REST Framework APIs\n- Testing Django models, views, and serializers\n- Setting up testing infrastructure for Django projects\n\n"
+    },
+    "django-verification": {
+      "description": "Verification loop for Django projects: migrations, linting, tests with coverage, security scans, and deployment readiness checks before release or PR.",
+      "name": "django-verification",
+      "path": "ecc/django-verification",
+      "routing_text": "django verification django verification Verification loop for Django projects: migrations, linting, tests with coverage, security scans, and deployment readiness checks before release or PR. - Before opening a pull request for a Django project\n- After major model changes, migration updates, or dependency upgrades\n- Pre-deployment verification for staging or production\n- Running full environment → lint → test → security → deploy readiness pipeline\n- Validating migration safety and test coverage\n\n"
+    },
+    "dmux-workflows": {
+      "description": "Multi-agent orchestration using dmux (tmux pane manager for AI agents). Patterns for parallel agent workflows across Claude Code, Codex, OpenCode, and other harnesses. Use when running multiple agent sessions in parallel or coordinating multi-agent development workflows.",
+      "name": "dmux-workflows",
+      "path": "ecc/dmux-workflows",
+      "routing_text": "dmux workflows dmux workflows Multi-agent orchestration using dmux (tmux pane manager for AI agents). Patterns for parallel agent workflows across Claude Code, Codex, OpenCode, and other harnesses. Use when running multiple agent sessions in parallel or coordinating multi-agent development workflows. - Running multiple agent sessions in parallel\n- Coordinating work across Claude Code, Codex, and other harnesses\n- Complex tasks that benefit from divide-and-conquer parallelism\n- User says \"run in parallel\", \"split this work\", \"use dmux\", or \"multi-agent\"\n\n"
+    },
+    "docker-patterns": {
+      "description": "Docker and Docker Compose patterns for local development, hardened CLI installer harnesses, container security, networking, volumes, and multi-service orchestration. Use when creating or reviewing Dockerfiles and Compose services, testing installers across Linux distributions, or planning accurate native macOS and Windows validation.",
+      "name": "docker-patterns",
+      "path": "ecc/docker-patterns",
+      "routing_text": "docker patterns docker patterns Docker and Docker Compose patterns for local development, hardened CLI installer harnesses, container security, networking, volumes, and multi-service orchestration. Use when creating or reviewing Dockerfiles and Compose services, testing installers across Linux distributions, or planning accurate native macOS and Windows validation."
+    },
+    "documentation-lookup": {
+      "description": "Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, code examples, or when the user names a framework (e.g. React, Next.js, Prisma).",
+      "name": "documentation-lookup",
+      "path": "ecc/documentation-lookup",
+      "routing_text": "documentation lookup documentation lookup Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, code examples, or when the user names a framework (e.g. React, Next.js, Prisma). Activate when the user:\n\n- Asks setup or configuration questions (e.g. \"How do I configure Next.js middleware?\")\n- Requests code that depends on a library (\"Write a Prisma query for...\")\n- Needs API or reference information (\"What are the Supabase auth methods?\")\n- Mentions specific frameworks or libraries (React, Vue, Svelte, Express, Tailwind, Prisma, Supabase, etc.)\n\nUse this skill whenever the request depends on accurate, up-to-date behavior of a library, framework, or API. Applies across harnesses that have the Context7 MCP configured (e.g. Claude Code, Cursor, Codex).\n\n"
+    },
+    "dotnet-patterns": {
+      "description": "Idiomatic C# and .NET patterns, conventions, dependency injection, async/await, and best practices for building robust, maintainable .NET applications. Use when writing or reviewing C# / .NET code — DI, async, or general conventions.",
+      "name": "dotnet-patterns",
+      "path": "ecc/dotnet-patterns",
+      "routing_text": "dotnet patterns dotnet patterns Idiomatic C# and .NET patterns, conventions, dependency injection, async/await, and best practices for building robust, maintainable .NET applications. Use when writing or reviewing C# / .NET code — DI, async, or general conventions. - Writing new C# code\n- Reviewing C# code\n- Refactoring existing .NET applications\n- Designing service architectures with ASP.NET Core\n\n"
+    },
+    "dynamic-workflow-mode": {
+      "description": "Design task-local harnesses, eval gates, and reusable skill extraction for Claude dynamic workflow mode and other adaptive agent harnesses. Use when building a task-local harness, adding eval gates, or extracting a reusable skill from ad-hoc work.",
+      "name": "dynamic-workflow-mode",
+      "path": "ecc/dynamic-workflow-mode",
+      "routing_text": "dynamic workflow mode dynamic workflow mode Design task-local harnesses, eval gates, and reusable skill extraction for Claude dynamic workflow mode and other adaptive agent harnesses. Use when building a task-local harness, adding eval gates, or extracting a reusable skill from ad-hoc work. - The user mentions dynamic workflows, custom harnesses, harness-per-task, adaptive workflows, or Claude Code dynamic workflow mode.\n- A task needs a custom loop, evaluator, crawler, fixture generator, watcher, or local dashboard.\n- Multiple agents need the same repeatable process but the process is not yet captured as a shared skill.\n- A workflow needs durable handoff artifacts, eval evidence, or operator approval before merge.\n\n"
+    },
+    "e2e-testing": {
+      "description": "Playwright E2E testing patterns, Page Object Model, configuration, CI/CD integration, artifact management, and flaky test strategies. Use when writing Playwright tests, structuring page objects, or fixing flaky E2E runs in CI.",
+      "name": "e2e-testing",
+      "path": "ecc/e2e-testing",
+      "routing_text": "e2e testing e2e testing Playwright E2E testing patterns, Page Object Model, configuration, CI/CD integration, artifact management, and flaky test strategies. Use when writing Playwright tests, structuring page objects, or fixing flaky E2E runs in CI."
+    },
+    "ecc-guide": {
+      "description": "Guide users through ECC's current agents, skills, commands, hooks, rules, install profiles, and project onboarding by reading the live repository surface before answering.",
+      "name": "ecc-guide",
+      "path": "ecc/ecc-guide",
+      "routing_text": "ecc guide ecc guide Guide users through ECC's current agents, skills, commands, hooks, rules, install profiles, and project onboarding by reading the live repository surface before answering. Use this skill when the user:\n\n- asks what ECC includes\n- wants help finding a skill, command, agent, hook, rule, or install profile\n- is new to the repository and needs a guided path\n- asks \"how do I do X with ECC?\"\n- asks which ECC components fit a project\n- needs a lightweight explanation of how commands, skills, agents, hooks, and rules relate\n- is confused by install paths, duplicate installs, reset/uninstall, or selective install options\n\n"
+    },
+    "ecc-recipes": {
+      "description": "Map a described workflow to the right ECC command-GROUP with run-order and stop condition, and browse all command-group recipe families. Adds a family-grouping + run-order + when-to-stop layer on top of the flat command catalog. Advisory only. TRIGGER when the user says which commands for X, what command group runs X, show ECC recipes, list ECC pipelines, or how do I run a workflow with ECC. DO NOT TRIGGER when the user wants the task executed directly, wants a single-command deep doc (use ecc-guide), or wants a draft prompt rewritten (use prompt-optimizer).",
+      "name": "ecc-recipes",
+      "path": "ecc/ecc-recipes",
+      "routing_text": "ecc recipes ecc recipes Map a described workflow to the right ECC command-GROUP with run-order and stop condition, and browse all command-group recipe families. Adds a family-grouping + run-order + when-to-stop layer on top of the flat command catalog. Advisory only. TRIGGER when the user says which commands for X, what command group runs X, show ECC recipes, list ECC pipelines, or how do I run a workflow with ECC. DO NOT TRIGGER when the user wants the task executed directly, wants a single-command deep doc (use ecc-guide), or wants a draft prompt rewritten (use prompt-optimizer). - \"Which command group do I run for <workflow>?\"\n- \"What's the command sequence to build an MVP / fix a defect / refactor?\"\n- \"Show me all ECC command-group recipes\" (catalog mode)\n- \"How many workflow pipelines does ECC have?\"\n- User invokes `/ecc-recipes` with or without a description.\n\n### Do Not Use When\n\n- User wants the task done now — route to the actual command, don't describe it.\n- User wants deep docs for ONE command — use `ecc-guide`.\n- User wants a draft prompt rewritten — use `prompt-optimizer`.\n\n"
+    },
+    "ecc-tools-cost-audit": {
+      "description": "Evidence-first ECC Tools burn and billing audit workflow. Use when investigating runaway PR creation, quota bypass, premium-model leakage, duplicate jobs, or GitHub App cost spikes in the ECC Tools repo.",
+      "name": "ecc-tools-cost-audit",
+      "path": "ecc/ecc-tools-cost-audit",
+      "routing_text": "ecc tools cost audit ecc tools cost audit Evidence-first ECC Tools burn and billing audit workflow. Use when investigating runaway PR creation, quota bypass, premium-model leakage, duplicate jobs, or GitHub App cost spikes in the ECC Tools repo. - user says ECC Tools burn rate, PR recursion, over-created PRs, usage-limit bypass, or premium-model leakage\n- the task is in the sibling `ECC-Tools` repo and depends on webhook handlers, queue workers, usage reservation, PR creation logic, or paid-gate enforcement\n- a customer report says the app created too many PRs, billed incorrectly, or analyzed code without producing a usable result\n\n"
+    },
+    "email-ops": {
+      "description": "Evidence-first mailbox triage, drafting, send verification, and sent-mail-safe follow-up workflow for ECC. Use when the user wants to organize email, draft or send through the real mail surface, or prove what landed in Sent.",
+      "name": "email-ops",
+      "path": "ecc/email-ops",
+      "routing_text": "email ops email ops Evidence-first mailbox triage, drafting, send verification, and sent-mail-safe follow-up workflow for ECC. Use when the user wants to organize email, draft or send through the real mail surface, or prove what landed in Sent. - user asks to triage inbox or archive low-signal mail\n- user wants a draft, reply, or new outbound email\n- user wants to know whether a mail was already sent\n- the user wants proof of which account, thread, or Sent entry was used\n\n"
+    },
+    "energy-procurement": {
+      "description": ">",
+      "name": "energy-procurement",
+      "path": "ecc/energy-procurement",
+      "routing_text": "energy procurement energy procurement > - Running an RFP for electricity or natural gas supply across multiple facilities\n- Analyzing tariff structures and rate schedule optimization opportunities\n- Evaluating demand charge mitigation strategies (load shifting, battery storage, power factor correction)\n- Assessing PPA (Power Purchase Agreement) offers for on-site or virtual renewable energy\n- Building annual energy budgets and hedge position strategies\n- Responding to market volatility events (polar vortex, heat wave, regulatory changes)\n\n"
+    },
+    "enterprise-agent-ops": {
+      "description": "Operate long-lived agent workloads with observability, security boundaries, and lifecycle management. Use when running long-lived agent workloads that need observability, security boundaries, or lifecycle control.",
+      "name": "enterprise-agent-ops",
+      "path": "ecc/enterprise-agent-ops",
+      "routing_text": "enterprise agent ops enterprise agent ops Operate long-lived agent workloads with observability, security boundaries, and lifecycle management. Use when running long-lived agent workloads that need observability, security boundaries, or lifecycle control."
+    },
+    "error-handling": {
+      "description": "Patterns for robust error handling across TypeScript, Python, and Go. Covers typed errors, error boundaries, retries, circuit breakers, and user-facing error messages. Use when designing error types, retries, circuit breakers, or user-facing failure messages in TypeScript, Python, or Go.",
+      "name": "error-handling",
+      "path": "ecc/error-handling",
+      "routing_text": "error handling error handling Patterns for robust error handling across TypeScript, Python, and Go. Covers typed errors, error boundaries, retries, circuit breakers, and user-facing error messages. Use when designing error types, retries, circuit breakers, or user-facing failure messages in TypeScript, Python, or Go. - Designing error types or exception hierarchies for a new module or service\n- Adding retry logic or circuit breakers for unreliable external dependencies\n- Reviewing API endpoints for missing error handling\n- Implementing user-facing error messages and feedback\n- Debugging cascading failures or silent error swallowing\n\n"
+    },
+    "eval-harness": {
+      "description": "Formal evaluation framework for Claude Code sessions implementing eval-driven development (EDD) principles. Use when a Claude Code workflow needs a formal eval before it is trusted or changed.",
+      "name": "eval-harness",
+      "path": "ecc/eval-harness",
+      "routing_text": "eval harness eval harness Formal evaluation framework for Claude Code sessions implementing eval-driven development (EDD) principles. Use when a Claude Code workflow needs a formal eval before it is trusted or changed. - Setting up eval-driven development (EDD) for AI-assisted workflows\n- Defining pass/fail criteria for Claude Code task completion\n- Measuring agent reliability with pass@k metrics\n- Creating regression test suites for prompt or agent changes\n- Benchmarking agent performance across model versions\n\n"
+    },
+    "evm-token-decimals": {
+      "description": "Prevent silent decimal mismatch bugs across EVM chains. Covers runtime decimal lookup, chain-aware caching, bridged-token precision drift, and safe normalization for bots, dashboards, and DeFi tools. Use when handling token amounts across EVM chains, or when a balance, price, or transfer amount is off by orders of magnitude.",
+      "name": "evm-token-decimals",
+      "path": "ecc/evm-token-decimals",
+      "routing_text": "evm token decimals evm token decimals Prevent silent decimal mismatch bugs across EVM chains. Covers runtime decimal lookup, chain-aware caching, bridged-token precision drift, and safe normalization for bots, dashboards, and DeFi tools. Use when handling token amounts across EVM chains, or when a balance, price, or transfer amount is off by orders of magnitude. - Reading ERC-20 balances in Python, TypeScript, or Solidity\n- Calculating fiat values from on-chain balances\n- Comparing token amounts across multiple EVM chains\n- Handling bridged assets\n- Building portfolio trackers, bots, or aggregators\n\n"
+    },
+    "exa-search": {
+      "description": "Neural search via Exa MCP for web, code, and company research. Use when the user needs web search, code examples, company intel, people lookup, or AI-powered deep research with Exa's neural search engine.",
+      "name": "exa-search",
+      "path": "ecc/exa-search",
+      "routing_text": "exa search exa search Neural search via Exa MCP for web, code, and company research. Use when the user needs web search, code examples, company intel, people lookup, or AI-powered deep research with Exa's neural search engine. - User needs current web information or news\n- Searching for code examples, API docs, or technical references\n- Researching companies, competitors, or market players\n- Finding professional profiles or people in a domain\n- Running background research for any development task\n- User says \"search for\", \"look up\", \"find\", or \"what's the latest on\"\n\n"
+    },
+    "fal-ai-media": {
+      "description": "Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI.",
+      "name": "fal-ai-media",
+      "path": "ecc/fal-ai-media",
+      "routing_text": "fal ai media fal ai media Unified media generation via fal.ai MCP — image, video, and audio. Covers text-to-image (Nano Banana), text/image-to-video (Seedance, Kling, Veo 3), text-to-speech (CSM-1B), and video-to-audio (ThinkSound). Use when the user wants to generate images, videos, or audio with AI. - User wants to generate images from text prompts\n- Creating videos from text or images\n- Generating speech, music, or sound effects\n- Any media generation task\n- User says \"generate image\", \"create video\", \"text to speech\", \"make a thumbnail\", or similar\n\n"
+    },
+    "fastapi-patterns": {
+      "description": "FastAPI best practices covering project structure, Pydantic v2 schemas, dependency injection, async handlers, authentication, authorization, transactional service layers, and testing with httpx and pytest. Use when building or reviewing FastAPI apps — Pydantic schemas, dependencies, async handlers, auth, or tests.",
+      "name": "fastapi-patterns",
+      "path": "ecc/fastapi-patterns",
+      "routing_text": "fastapi patterns fastapi patterns FastAPI best practices covering project structure, Pydantic v2 schemas, dependency injection, async handlers, authentication, authorization, transactional service layers, and testing with httpx and pytest. Use when building or reviewing FastAPI apps — Pydantic schemas, dependencies, async handlers, auth, or tests."
+    },
+    "finance-billing-ops": {
+      "description": "Evidence-first revenue, pricing, refunds, team-billing, and billing-model truth workflow for ECC. Use when the user wants a sales snapshot, pricing comparison, duplicate-charge diagnosis, or code-backed billing reality instead of generic payments advice.",
+      "name": "finance-billing-ops",
+      "path": "ecc/finance-billing-ops",
+      "routing_text": "finance billing ops finance billing ops Evidence-first revenue, pricing, refunds, team-billing, and billing-model truth workflow for ECC. Use when the user wants a sales snapshot, pricing comparison, duplicate-charge diagnosis, or code-backed billing reality instead of generic payments advice. - user asks for Stripe sales, refunds, MRR, or recent customer activity\n- user asks whether team billing, per-seat billing, or quota stacking is real in code\n- user wants competitor pricing comparisons or pricing-model benchmarks\n- the question mixes revenue facts with product implementation truth\n\n"
+    },
+    "flox-environments": {
+      "description": "Create reproducible, cross-platform (macOS/Linux) development environments with Flox, a declarative Nix-based environment manager. Use when setting up project toolchains for any language, installing system-level dependencies (compilers, databases, native libs like openssl/BLAS), pinning exact package versions for a team, running local services (PostgreSQL, Redis, Kafka), onboarding developers with one command, or solving 'works on my machine' problems — including agent/vibe-coding setups that need project-scoped tools without sudo. Also use when the user mentions .flox/, manifest.toml, flox activate, or FloxHub.",
+      "name": "flox-environments",
+      "path": "ecc/flox-environments",
+      "routing_text": "flox environments flox environments Create reproducible, cross-platform (macOS/Linux) development environments with Flox, a declarative Nix-based environment manager. Use when setting up project toolchains for any language, installing system-level dependencies (compilers, databases, native libs like openssl/BLAS), pinning exact package versions for a team, running local services (PostgreSQL, Redis, Kafka), onboarding developers with one command, or solving 'works on my machine' problems — including agent/vibe-coding setups that need project-scoped tools without sudo. Also use when the user mentions .flox/, manifest.toml, flox activate, or FloxHub. Use this skill when the user has an environment management problem — even if they haven't mentioned Flox. Flox is the right tool when:\n\n- The project needs **system-level packages** (compilers, databases, CLI tools) alongside language-specific dependencies\n- **Reproducibility matters** — the setup should work identically on a teammate's machine, in CI, or on a fresh laptop\n- The user needs **multiple tools to coexist** — e.g., Python 3.11 + PostgreSQL 16 + Redis + Node.js in one environment\n- **Cross-platform support** is needed (macOS and Linux from the same config)\n- **AI agents need to install tools** — Flox lets agents add packages to a project-scoped environment without sudo, system pollution, or sandbox restrictions\n\nIf the user just needs a single language runtime with no system dependencies, standard tooling (nvm, pyenv, rustup alone) may suffice. If they need full OS-level isolation, containers might be more appropriate. Flox sits in the sweet spot: declarative, reproducible environments without container overhead.\n\n**Prerequisite:** Flox must be installed first — see [flox.dev/docs](https://flox.dev/docs/install-flox/install/) for macOS, Linux, and Docker.\n\n"
+    },
+    "flutter-dart-code-review": {
+      "description": "Library-agnostic Flutter/Dart code review checklist covering widget best practices, state management patterns (BLoC, Riverpod, Provider, GetX, MobX, Signals), Dart idioms, performance, accessibility, security, and clean architecture. Use when reviewing Flutter or Dart code, whatever state management library the project uses.",
+      "name": "flutter-dart-code-review",
+      "path": "ecc/flutter-dart-code-review",
+      "routing_text": "flutter dart code review flutter dart code review Library-agnostic Flutter/Dart code review checklist covering widget best practices, state management patterns (BLoC, Riverpod, Provider, GetX, MobX, Signals), Dart idioms, performance, accessibility, security, and clean architecture. Use when reviewing Flutter or Dart code, whatever state management library the project uses."
+    },
+    "foundation-models-on-device": {
+      "description": "Apple FoundationModels framework for on-device LLM — text generation, guided generation with @Generable, tool calling, and snapshot streaming in iOS 26+. Use when adding on-device LLM features with Apple FoundationModels on iOS 26+.",
+      "name": "foundation-models-on-device",
+      "path": "ecc/foundation-models-on-device",
+      "routing_text": "foundation models on device foundation models on device Apple FoundationModels framework for on-device LLM — text generation, guided generation with @Generable, tool calling, and snapshot streaming in iOS 26+. Use when adding on-device LLM features with Apple FoundationModels on iOS 26+. - Building AI-powered features using Apple Intelligence on-device\n- Generating or summarizing text without cloud dependency\n- Extracting structured data from natural language input\n- Implementing custom tool calling for domain-specific AI actions\n- Streaming structured responses for real-time UI updates\n- Need privacy-preserving AI (no data leaves the device)\n\n"
+    },
+    "frontend-a11y": {
+      "description": ">",
+      "name": "frontend-a11y",
+      "path": "ecc/frontend-a11y",
+      "routing_text": "frontend a11y frontend a11y > - Building or reviewing form components (`<input>`, `<select>`, `<textarea>`)\n- Creating interactive elements (modals, dropdowns, tooltips, tabs)\n- Using `<div>` or `<span>` with `onClick`\n- Adding `aria-*` attributes to any element\n- Implementing keyboard navigation or focus management\n- Receiving accessibility feedback from code review tools (CodeRabbit, ESLint a11y)\n- Building components that must support screen readers\n\n"
+    },
+    "frontend-design-direction": {
+      "description": "Set an ECC-specific frontend design direction for production UI work. Use when building or improving websites, dashboards, applications, components, landing pages, visual tools, or any web UI that needs stronger product-specific design judgment.",
+      "name": "frontend-design-direction",
+      "path": "ecc/frontend-design-direction",
+      "routing_text": "frontend design direction frontend design direction Set an ECC-specific frontend design direction for production UI work. Use when building or improving websites, dashboards, applications, components, landing pages, visual tools, or any web UI that needs stronger product-specific design judgment. - The user asks to build a web page, app, dashboard, artifact, component, or UI.\n- The user asks to make an interface more polished, distinctive, beautiful, or\n  less generic.\n- The implementation needs visual hierarchy, typography, color, motion, layout,\n  and interaction choices.\n- The current UI works but reads as flat, generic, templated, or mismatched to\n  the audience.\n\n"
+    },
+    "frontend-patterns": {
+      "description": "Frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices. Use when building or reviewing React or Next.js components, state, or render performance.",
+      "name": "frontend-patterns",
+      "path": "ecc/frontend-patterns",
+      "routing_text": "frontend patterns frontend patterns Frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices. Use when building or reviewing React or Next.js components, state, or render performance. - Building React components (composition, props, rendering)\n- Managing state (useState, useReducer, Zustand, Context)\n- Implementing data fetching (SWR, React Query, server components)\n- Optimizing performance (memoization, virtualization, code splitting)\n- Working with forms (validation, controlled inputs, Zod schemas)\n- Handling client-side routing and navigation\n- Building accessible, responsive UI patterns\n\n"
+    },
+    "frontend-slides": {
+      "description": "Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.",
+      "name": "frontend-slides",
+      "path": "ecc/frontend-slides",
+      "routing_text": "frontend slides frontend slides Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices. - Creating a talk deck, pitch deck, workshop deck, or internal presentation\n- Converting `.ppt` or `.pptx` slides into an HTML presentation\n- Improving an existing HTML presentation's layout, motion, or typography\n- Exploring presentation styles with a user who does not know their design preference yet\n\n"
+    },
+    "fsharp-testing": {
+      "description": "F# testing patterns with xUnit, FsUnit, Unquote, FsCheck property-based testing, integration tests, and test organization best practices. Use when writing F# tests with xUnit, FsUnit, Unquote, or FsCheck.",
+      "name": "fsharp-testing",
+      "path": "ecc/fsharp-testing",
+      "routing_text": "fsharp testing fsharp testing F# testing patterns with xUnit, FsUnit, Unquote, FsCheck property-based testing, integration tests, and test organization best practices. Use when writing F# tests with xUnit, FsUnit, Unquote, or FsCheck. - Writing new tests for F# code\n- Reviewing test quality and coverage\n- Setting up test infrastructure for F# projects\n- Debugging flaky or slow tests\n\n"
+    },
+    "gan-style-harness": {
+      "description": "GAN-inspired Generator-Evaluator agent harness for building high-quality applications autonomously. Based on Anthropic's March 2026 harness design paper. Use when a feature should be built autonomously through generator and evaluator iteration until it clears a quality bar.",
+      "name": "gan-style-harness",
+      "path": "ecc/gan-style-harness",
+      "routing_text": "gan style harness gan style harness GAN-inspired Generator-Evaluator agent harness for building high-quality applications autonomously. Based on Anthropic's March 2026 harness design paper. Use when a feature should be built autonomously through generator and evaluator iteration until it clears a quality bar. - Building complete applications from a one-line prompt\n- Frontend design tasks requiring high visual quality\n- Full-stack projects that need working features, not just code\n- Any task where \"AI slop\" aesthetics are unacceptable\n- Projects where you want to invest $50-200 for production-quality output\n\n"
+    },
+    "gateguard": {
+      "description": "Fact-forcing gate that blocks Edit/Write/Bash (including MultiEdit) and demands concrete investigation (importers, data schemas, user instruction) before allowing the action. Measurably improves output quality by +2.25 points vs ungated agents.",
+      "name": "gateguard",
+      "path": "ecc/gateguard",
+      "routing_text": "gateguard gateguard Fact-forcing gate that blocks Edit/Write/Bash (including MultiEdit) and demands concrete investigation (importers, data schemas, user instruction) before allowing the action. Measurably improves output quality by +2.25 points vs ungated agents. - Working on any codebase where file edits affect multiple modules\n- Projects with data files that have specific schemas or date formats\n- Teams where AI-generated code must match existing patterns\n- Any workflow where Claude tends to guess instead of investigating\n\n"
+    },
+    "generating-python-installer": {
+      "description": "Commercial-grade Python installer expert for Windows: Nuitka extreme compilation, dist slimming, DLL footprint analysis, and Inno Setup packaging to ship the smallest, fastest installers. Use when a Python app must ship as a minimal, fast-starting Windows installer; not for basic script-to-exe conversion. 中文触发：Nuitka 极限优化、Python 商业打包、极限编译 Python、dist 瘦身、DLL 分析、最小安装包、最快启动、商业级打包风格",
+      "name": "generating-python-installer",
+      "path": "ecc/generating-python-installer",
+      "routing_text": "generating python installer generating python installer Commercial-grade Python installer expert for Windows: Nuitka extreme compilation, dist slimming, DLL footprint analysis, and Inno Setup packaging to ship the smallest, fastest installers. Use when a Python app must ship as a minimal, fast-starting Windows installer; not for basic script-to-exe conversion. 中文触发：Nuitka 极限优化、Python 商业打包、极限编译 Python、dist 瘦身、DLL 分析、最小安装包、最快启动、商业级打包风格 Activate when the user explicitly asks for **advanced** Python packaging or size/startup optimization on Windows:\n\n- Nuitka extreme / commercial-grade compilation, smallest-size or fastest-startup builds\n- `dist` folder slimming, DLL footprint analysis, 32-bit vs 64-bit size tradeoffs\n- Inno Setup packaging with full metadata and a clean, residue-free uninstall\n\nThis skill targets advanced size/startup optimization — not basic one-file \"script to exe\" conversion.\n\n"
+    },
+    "git-workflow": {
+      "description": "Git workflow patterns including branching strategies, commit conventions, merge vs rebase, conflict resolution, and collaborative development best practices for teams of all sizes. Use when choosing a branching strategy, writing commit conventions, deciding merge versus rebase, or resolving conflicts.",
+      "name": "git-workflow",
+      "path": "ecc/git-workflow",
+      "routing_text": "git workflow git workflow Git workflow patterns including branching strategies, commit conventions, merge vs rebase, conflict resolution, and collaborative development best practices for teams of all sizes. Use when choosing a branching strategy, writing commit conventions, deciding merge versus rebase, or resolving conflicts. - Setting up Git workflow for a new project\n- Deciding on branching strategy (GitFlow, trunk-based, GitHub flow)\n- Writing commit messages and PR descriptions\n- Resolving merge conflicts\n- Managing releases and version tags\n- Onboarding new team members to Git practices\n\n"
+    },
+    "github-ops": {
+      "description": "GitHub repository operations, automation, and management. Issue triage, PR management, CI/CD operations, release management, and security monitoring using the gh CLI. Use when the user wants to manage GitHub issues, PRs, CI status, releases, contributors, stale items, or any GitHub operational task beyond simple git commands.",
+      "name": "github-ops",
+      "path": "ecc/github-ops",
+      "routing_text": "github ops github ops GitHub repository operations, automation, and management. Issue triage, PR management, CI/CD operations, release management, and security monitoring using the gh CLI. Use when the user wants to manage GitHub issues, PRs, CI status, releases, contributors, stale items, or any GitHub operational task beyond simple git commands. - Triaging issues (classifying, labeling, responding, deduplicating)\n- Managing PRs (review status, CI checks, stale PRs, merge readiness)\n- Debugging CI/CD failures\n- Preparing releases and changelogs\n- Monitoring Dependabot and security alerts\n- Managing contributor experience on open-source projects\n- User says \"check GitHub\", \"triage issues\", \"review PRs\", \"merge\", \"release\", \"CI is broken\"\n\n"
+    },
+    "golang-patterns": {
+      "description": "Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications. Use when writing or reviewing Go code and idiomatic structure or conventions are in question.",
+      "name": "golang-patterns",
+      "path": "ecc/golang-patterns",
+      "routing_text": "golang patterns golang patterns Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications. Use when writing or reviewing Go code and idiomatic structure or conventions are in question. - Writing new Go code\n- Reviewing Go code\n- Refactoring existing Go code\n- Designing Go packages/modules\n\n"
+    },
+    "golang-testing": {
+      "description": "Go testing patterns including table-driven tests, subtests, benchmarks, fuzzing, and test coverage. Follows TDD methodology with idiomatic Go practices. Use when writing Go tests — table-driven cases, subtests, benchmarks, fuzzing, or coverage.",
+      "name": "golang-testing",
+      "path": "ecc/golang-testing",
+      "routing_text": "golang testing golang testing Go testing patterns including table-driven tests, subtests, benchmarks, fuzzing, and test coverage. Follows TDD methodology with idiomatic Go practices. Use when writing Go tests — table-driven cases, subtests, benchmarks, fuzzing, or coverage. - Writing new Go functions or methods\n- Adding test coverage to existing code\n- Creating benchmarks for performance-critical code\n- Implementing fuzz tests for input validation\n- Following TDD workflow in Go projects\n\n"
+    },
+    "google-workspace-ops": {
+      "description": "Operate across Google Drive, Docs, Sheets, and Slides as one workflow surface for plans, trackers, decks, and shared documents. Use when the user needs to find, summarize, edit, migrate, or clean up Google Workspace assets without dropping to raw tool calls.",
+      "name": "google-workspace-ops",
+      "path": "ecc/google-workspace-ops",
+      "routing_text": "google workspace ops google workspace ops Operate across Google Drive, Docs, Sheets, and Slides as one workflow surface for plans, trackers, decks, and shared documents. Use when the user needs to find, summarize, edit, migrate, or clean up Google Workspace assets without dropping to raw tool calls. - User needs to find a doc, sheet, or deck and update it in place\n- Consolidating plans, trackers, notes, or customer lists stored in Google Drive\n- Cleaning or restructuring a shared spreadsheet\n- Importing, repairing, or reformatting a Google Slides deck\n- Producing summaries from Docs, Sheets, or Slides for decision-making\n\n"
+    },
+    "growth-log": {
+      "description": "Use after a complex task, failure, or when reviewing what was learned. Teaches how to write growth logs that extract reusable patterns — not diary entries.",
+      "name": "growth-log",
+      "path": "ecc/growth-log",
+      "routing_text": "growth log growth log Use after a complex task, failure, or when reviewing what was learned. Teaches how to write growth logs that extract reusable patterns — not diary entries. - After completing a complex task (multi-file, new feature, architecture change)\n- After a failure, mistake, or \"that was harder than expected\" moment\n- When you want to review what you've learned over a period\n\n**When NOT to activate:** Trivial changes (typo fixes, single-line tweaks, config value changes with no debugging). The threshold: *did this task involve debugging, redoing, rollback, or a non-obvious decision?* If yes → write an entry. If no → skip.\n\n"
+    },
+    "healthcare-cdss-patterns": {
+      "description": "Clinical Decision Support System (CDSS) development patterns. Drug interaction checking, dose validation, clinical scoring (NEWS2, qSOFA), alert severity classification, and integration into EMR workflows. Use when building clinical decision support — drug interaction checks, dose validation, clinical scoring, or alert severity.",
+      "name": "healthcare-cdss-patterns",
+      "path": "ecc/healthcare-cdss-patterns",
+      "routing_text": "healthcare cdss patterns healthcare cdss patterns Clinical Decision Support System (CDSS) development patterns. Drug interaction checking, dose validation, clinical scoring (NEWS2, qSOFA), alert severity classification, and integration into EMR workflows. Use when building clinical decision support — drug interaction checks, dose validation, clinical scoring, or alert severity. - Implementing drug interaction checking\n- Building dose validation engines\n- Implementing clinical scoring systems (NEWS2, qSOFA, APACHE, GCS)\n- Designing alert systems for abnormal clinical values\n- Building medication order entry with safety checks\n- Integrating lab result interpretation with clinical context\n\n"
+    },
+    "healthcare-emr-patterns": {
+      "description": "EMR/EHR development patterns for healthcare applications. Clinical safety, encounter workflows, prescription generation, clinical decision support integration, and accessibility-first UI for medical data entry. Use when building EMR or EHR features such as encounter workflows, prescription generation, or clinical data entry UI.",
+      "name": "healthcare-emr-patterns",
+      "path": "ecc/healthcare-emr-patterns",
+      "routing_text": "healthcare emr patterns healthcare emr patterns EMR/EHR development patterns for healthcare applications. Clinical safety, encounter workflows, prescription generation, clinical decision support integration, and accessibility-first UI for medical data entry. Use when building EMR or EHR features such as encounter workflows, prescription generation, or clinical data entry UI. - Building patient encounter workflows (complaint, exam, diagnosis, prescription)\n- Implementing clinical note-taking (structured + free text + voice-to-text)\n- Designing prescription/medication modules with drug interaction checking\n- Integrating Clinical Decision Support Systems (CDSS)\n- Building lab result displays with reference range highlighting\n- Implementing audit trails for clinical data\n- Designing healthcare-accessible UIs for clinical data entry\n\n"
+    },
+    "healthcare-eval-harness": {
+      "description": "Patient safety evaluation harness for healthcare application deployments. Automated test suites for CDSS accuracy, PHI exposure, clinical workflow integrity, and integration compliance. Blocks deployments on safety failures. Use when a healthcare deployment must be gated on patient-safety tests for CDSS accuracy, PHI exposure, and workflow integrity.",
+      "name": "healthcare-eval-harness",
+      "path": "ecc/healthcare-eval-harness",
+      "routing_text": "healthcare eval harness healthcare eval harness Patient safety evaluation harness for healthcare application deployments. Automated test suites for CDSS accuracy, PHI exposure, clinical workflow integrity, and integration compliance. Blocks deployments on safety failures. Use when a healthcare deployment must be gated on patient-safety tests for CDSS accuracy, PHI exposure, and workflow integrity. - Before any deployment of EMR/EHR applications\n- After modifying CDSS logic (drug interactions, dose validation, scoring)\n- After changing database schemas that touch patient data\n- After modifying authentication or access control\n- During CI/CD pipeline configuration for healthcare apps\n- After resolving merge conflicts in clinical modules\n\n"
+    },
+    "healthcare-phi-compliance": {
+      "description": "Protected Health Information (PHI) and Personally Identifiable Information (PII) compliance patterns for healthcare applications. Covers data classification, access control, audit trails, encryption, and common leak vectors. Use when code touches PHI or PII in a healthcare system, or when auditing access control, audit trails, or leak vectors.",
+      "name": "healthcare-phi-compliance",
+      "path": "ecc/healthcare-phi-compliance",
+      "routing_text": "healthcare phi compliance healthcare phi compliance Protected Health Information (PHI) and Personally Identifiable Information (PII) compliance patterns for healthcare applications. Covers data classification, access control, audit trails, encryption, and common leak vectors. Use when code touches PHI or PII in a healthcare system, or when auditing access control, audit trails, or leak vectors. - Building any feature that touches patient records\n- Implementing access control or authentication for clinical systems\n- Designing database schemas for healthcare data\n- Building APIs that return patient or clinician data\n- Implementing audit trails or logging\n- Reviewing code for data exposure vulnerabilities\n- Setting up Row-Level Security (RLS) for multi-tenant healthcare systems\n\n"
+    },
+    "hermes-imports": {
+      "description": "Convert local Hermes operator workflows into sanitized ECC skills and release-pack artifacts. Use when preparing a Hermes workflow for public ECC reuse without leaking private workspace state, credentials, or local-only paths.",
+      "name": "hermes-imports",
+      "path": "ecc/hermes-imports",
+      "routing_text": "hermes imports hermes imports Convert local Hermes operator workflows into sanitized ECC skills and release-pack artifacts. Use when preparing a Hermes workflow for public ECC reuse without leaking private workspace state, credentials, or local-only paths. - A Hermes workflow has repeated enough times to become reusable.\n- A local operator prompt should become a public ECC skill.\n- A launch, content, research, or engineering workflow needs sanitized handoff docs.\n- A workflow mentions local paths, credentials, personal datasets, or private account names that must be removed before publication.\n\n"
+    },
+    "hexagonal-architecture": {
+      "description": "Design, implement, and refactor Ports & Adapters systems with clear domain boundaries, dependency inversion, and testable use-case orchestration across TypeScript, Java, Kotlin, and Go services. Use when introducing or refactoring toward Ports and Adapters, or when domain logic has become entangled with I/O.",
+      "name": "hexagonal-architecture",
+      "path": "ecc/hexagonal-architecture",
+      "routing_text": "hexagonal architecture hexagonal architecture Design, implement, and refactor Ports & Adapters systems with clear domain boundaries, dependency inversion, and testable use-case orchestration across TypeScript, Java, Kotlin, and Go services. Use when introducing or refactoring toward Ports and Adapters, or when domain logic has become entangled with I/O. - Building new features where long-term maintainability and testability matter.\n- Refactoring layered or framework-heavy code where domain logic is mixed with I/O concerns.\n- Supporting multiple interfaces for the same use case (HTTP, CLI, queue workers, cron jobs).\n- Replacing infrastructure (database, external APIs, message bus) without rewriting business rules.\n\nUse this skill when the request involves boundaries, domain-centric design, refactoring tightly coupled services, or decoupling application logic from specific libraries.\n\n"
+    },
+    "hipaa-compliance": {
+      "description": "HIPAA-specific entrypoint for healthcare privacy and security work. Use when a task is explicitly framed around HIPAA, PHI handling, covered entities, BAAs, breach posture, or US healthcare compliance requirements.",
+      "name": "hipaa-compliance",
+      "path": "ecc/hipaa-compliance",
+      "routing_text": "hipaa compliance hipaa compliance HIPAA-specific entrypoint for healthcare privacy and security work. Use when a task is explicitly framed around HIPAA, PHI handling, covered entities, BAAs, breach posture, or US healthcare compliance requirements. - The request explicitly mentions HIPAA, PHI, covered entities, business associates, or BAAs\n- Building or reviewing US healthcare software that stores, processes, exports, or transmits PHI\n- Assessing whether logging, analytics, LLM prompts, storage, or support workflows create HIPAA exposure\n- Designing patient-facing or clinician-facing systems where minimum necessary access and auditability matter\n\n"
+    },
+    "homelab-network-readiness": {
+      "description": "Readiness checklist for homelab VLAN segmentation, local DNS filtering, and WireGuard-style remote access before changing router, firewall, DHCP, or VPN configuration.",
+      "name": "homelab-network-readiness",
+      "path": "ecc/homelab-network-readiness",
+      "routing_text": "homelab network readiness homelab network readiness Readiness checklist for homelab VLAN segmentation, local DNS filtering, and WireGuard-style remote access before changing router, firewall, DHCP, or VPN configuration. - Preparing to split a flat network into trusted, IoT, guest, server, or\n  management VLANs.\n- Moving DHCP clients to Pi-hole, AdGuard Home, Unbound, or another local DNS\n  resolver.\n- Adding WireGuard, Tailscale, ZeroTier, OpenVPN, or router-native VPN access.\n- Reviewing whether a homelab change can lock the operator out of the gateway,\n  switch, access point, DNS server, or VPN server.\n- Turning an informal home-network idea into a staged migration plan with\n  validation evidence.\n\n"
+    },
+    "homelab-network-setup": {
+      "description": "Practical home and homelab network planning for gateways, switches, access points, IP ranges, DHCP reservations, DNS, cabling, and common beginner mistakes. Use when planning or fixing a home or homelab network — gateway, switch, AP, IP ranges, DHCP, DNS, or cabling.",
+      "name": "homelab-network-setup",
+      "path": "ecc/homelab-network-setup",
+      "routing_text": "homelab network setup homelab network setup Practical home and homelab network planning for gateways, switches, access points, IP ranges, DHCP reservations, DNS, cabling, and common beginner mistakes. Use when planning or fixing a home or homelab network — gateway, switch, AP, IP ranges, DHCP, DNS, or cabling. - Planning a new home network or redesigning an ISP-router-only setup.\n- Choosing gateway, switch, and access point roles.\n- Designing IP ranges, DHCP scopes, static reservations, and DNS.\n- Preparing for future VLANs, Pi-hole, NAS, lab servers, or VPN access.\n- Troubleshooting a new network that has double NAT, unstable Wi-Fi, or changing\n  server addresses.\n\n"
+    },
+    "homelab-pihole-dns": {
+      "description": "Pi-hole installation, blocklist management, DNS-over-HTTPS setup, DHCP integration, local DNS records, and troubleshooting broken DNS resolution on a home network. Use when the task explicitly involves Pi-hole — installing it, managing blocklists, configuring DoH or DHCP, adding local DNS records, or diagnosing DNS resolution with Pi-hole in the path.",
+      "name": "homelab-pihole-dns",
+      "path": "ecc/homelab-pihole-dns",
+      "routing_text": "homelab pihole dns homelab pihole dns Pi-hole installation, blocklist management, DNS-over-HTTPS setup, DHCP integration, local DNS records, and troubleshooting broken DNS resolution on a home network. Use when the task explicitly involves Pi-hole — installing it, managing blocklists, configuring DoH or DHCP, adding local DNS records, or diagnosing DNS resolution with Pi-hole in the path. - Installing Pi-hole on a Raspberry Pi or Linux host\n- Configuring Pi-hole as the DNS server for a home network\n- Adding or managing blocklists\n- Setting up DNS-over-HTTPS (DoH) upstream resolvers\n- Creating local DNS records (e.g. `nas.home.lan`, `pi.home.lan`)\n- Troubleshooting devices that lose internet access after Pi-hole is installed\n- Running Pi-hole alongside or instead of DHCP\n\n"
+    },
+    "homelab-vlan-segmentation": {
+      "description": "Segmenting home networks into VLANs for IoT, guest, trusted, and server traffic using UniFi, pfSense/OPNsense, and MikroTik — including switch trunk config, firewall rules, and wireless SSID mapping. Use when splitting a home network into IoT, guest, trusted, and server VLANs on UniFi, pfSense/OPNsense, or MikroTik.",
+      "name": "homelab-vlan-segmentation",
+      "path": "ecc/homelab-vlan-segmentation",
+      "routing_text": "homelab vlan segmentation homelab vlan segmentation Segmenting home networks into VLANs for IoT, guest, trusted, and server traffic using UniFi, pfSense/OPNsense, and MikroTik — including switch trunk config, firewall rules, and wireless SSID mapping. Use when splitting a home network into IoT, guest, trusted, and server VLANs on UniFi, pfSense/OPNsense, or MikroTik. - Setting up VLANs on a home network for the first time\n- Isolating IoT devices (smart bulbs, cameras, TVs) from trusted devices\n- Creating a guest Wi-Fi network that cannot reach home devices\n- Explaining how VLANs work to someone unfamiliar with the concept\n- Configuring trunk ports, access ports, and SSID-to-VLAN mapping\n- Troubleshooting inter-VLAN routing or firewall rule issues on pfSense/OPNsense/UniFi\n\n"
+    },
+    "homelab-wireguard-vpn": {
+      "description": "WireGuard VPN server setup, peer configuration, key generation, split tunneling vs full tunnel routing, and remote access to a home network from mobile and laptop clients. Use when setting up WireGuard for remote access to a home network, or deciding between split and full tunnel routing.",
+      "name": "homelab-wireguard-vpn",
+      "path": "ecc/homelab-wireguard-vpn",
+      "routing_text": "homelab wireguard vpn homelab wireguard vpn WireGuard VPN server setup, peer configuration, key generation, split tunneling vs full tunnel routing, and remote access to a home network from mobile and laptop clients. Use when setting up WireGuard for remote access to a home network, or deciding between split and full tunnel routing. - Setting up WireGuard server on a Raspberry Pi, Linux host, pfSense, or router\n- Generating WireGuard keypairs and writing peer config files\n- Configuring remote access from a phone or laptop to a home network\n- Explaining split tunneling (route only home traffic) vs full tunnel (route all traffic)\n- Troubleshooting WireGuard connections that will not come up\n- Automating peer configuration generation for multiple clients\n\n"
+    },
+    "hookify-rules": {
+      "description": "This skill should be used when the user asks to create a hookify rule, write a hook rule, configure hookify, add a hookify rule, or needs guidance on hookify rule syntax and patterns.",
+      "name": "hookify-rules",
+      "path": "ecc/hookify-rules",
+      "routing_text": "hookify rules hookify rules This skill should be used when the user asks to create a hookify rule, write a hook rule, configure hookify, add a hookify rule, or needs guidance on hookify rule syntax and patterns."
+    },
+    "inherit-legacy-style": {
+      "description": "Legacy-project style inheritance skill. Use when the user types /inherit-legacy-style, or when onboarding an AI coding agent onto a hand-written legacy project and you need to prevent \"style drift\" (the model imposing its pretrained mainstream idioms onto the project). Language- and framework-agnostic — it aligns meta-architecture only, not syntax. Once run, it becomes a behavioral constraint on all subsequent coding tasks. Do NOT use for pure research or one-off questions unrelated to code-style alignment.",
+      "name": "inherit-legacy-style",
+      "path": "ecc/inherit-legacy-style",
+      "routing_text": "inherit legacy style inherit legacy style Legacy-project style inheritance skill. Use when the user types /inherit-legacy-style, or when onboarding an AI coding agent onto a hand-written legacy project and you need to prevent \"style drift\" (the model imposing its pretrained mainstream idioms onto the project). Language- and framework-agnostic — it aligns meta-architecture only, not syntax. Once run, it becomes a behavioral constraint on all subsequent coding tasks. Do NOT use for pure research or one-off questions unrelated to code-style alignment. - User types `/inherit-legacy-style`\n- User mentions onboarding AI onto a hand-written legacy project\n- User is worried about AI-generated code \"drifting\" from existing project conventions\n- User wants to extract and codify their project's implicit coding rules\n\n"
+    },
+    "intent-driven-development": {
+      "description": "Turn ambiguous or high-impact product and engineering changes into scoped, verifiable acceptance criteria before or alongside implementation. Use when a user asks to clarify a feature, define acceptance criteria, de-risk a security/data/migration/integration change, prepare implementation requirements for another agent, or make a complex request testable. Do not trigger for trivial edits, straightforward fixes, active debugging, code review, or implementation requests whose acceptance conditions are already clear unless the user explicitly invokes this skill.",
+      "name": "intent-driven-development",
+      "path": "ecc/intent-driven-development",
+      "routing_text": "intent driven development intent driven development Turn ambiguous or high-impact product and engineering changes into scoped, verifiable acceptance criteria before or alongside implementation. Use when a user asks to clarify a feature, define acceptance criteria, de-risk a security/data/migration/integration change, prepare implementation requirements for another agent, or make a complex request testable. Do not trigger for trivial edits, straightforward fixes, active debugging, code review, or implementation requests whose acceptance conditions are already clear unless the user explicitly invokes this skill. - User asks to clarify a feature, define acceptance criteria, or de-risk a change before implementation\n- Request touches security, authentication, persistent data, migrations, external APIs, or compliance\n- User wants to prepare a handoff artifact for another agent or team\n- Request is ambiguous enough that the expected outcome is not yet observable or testable\n- User explicitly invokes this skill with `/intent-driven-development`\n\nDo not activate for trivial edits, straightforward one-line fixes, active debugging sessions,\ncode review requests, or implementation requests whose acceptance conditions are already clear.\n\n"
+    },
+    "inventory-demand-planning": {
+      "description": ">",
+      "name": "inventory-demand-planning",
+      "path": "ecc/inventory-demand-planning",
+      "routing_text": "inventory demand planning inventory demand planning > - Generating or reviewing demand forecasts for existing or new SKUs\n- Setting safety stock levels based on demand variability and service level targets\n- Planning replenishment for seasonal transitions, promotions, or new product launches\n- Evaluating forecast accuracy and adjusting models or overrides\n- Making buy decisions under supplier MOQ constraints or lead time changes\n\n"
+    },
+    "investor-materials": {
+      "description": "Create and update pitch decks, one-pagers, investor memos, accelerator applications, financial models, and fundraising materials. Use when the user needs investor-facing documents, projections, use-of-funds tables, milestone plans, or materials that must stay internally consistent across multiple fundraising assets.",
+      "name": "investor-materials",
+      "path": "ecc/investor-materials",
+      "routing_text": "investor materials investor materials Create and update pitch decks, one-pagers, investor memos, accelerator applications, financial models, and fundraising materials. Use when the user needs investor-facing documents, projections, use-of-funds tables, milestone plans, or materials that must stay internally consistent across multiple fundraising assets. - creating or revising a pitch deck\n- writing an investor memo or one-pager\n- building a financial model, milestone plan, or use-of-funds table\n- answering accelerator or incubator application questions\n- aligning multiple fundraising docs around one source of truth\n\n"
+    },
+    "investor-outreach": {
+      "description": "Draft cold emails, warm intro blurbs, follow-ups, update emails, and investor communications for fundraising. Use when the user wants outreach to angels, VCs, strategic investors, or accelerators and needs concise, personalized, investor-facing messaging.",
+      "name": "investor-outreach",
+      "path": "ecc/investor-outreach",
+      "routing_text": "investor outreach investor outreach Draft cold emails, warm intro blurbs, follow-ups, update emails, and investor communications for fundraising. Use when the user wants outreach to angels, VCs, strategic investors, or accelerators and needs concise, personalized, investor-facing messaging. - writing a cold email to an investor\n- drafting a warm intro request\n- sending follow-ups after a meeting or no response\n- writing investor updates during a process\n- tailoring outreach based on fund thesis or partner fit\n\n"
+    },
+    "ios-icon-gen": {
+      "description": "Generate iOS app icons as PNG imagesets for Xcode asset catalogs from SF Symbols (5000+ Apple-native) or Iconify API (275k+ open source icons from 200+ collections). Use when generating icons, creating icon assets, adding icons to asset catalog, or searching for icons for iOS projects.",
+      "name": "ios-icon-gen",
+      "path": "ecc/ios-icon-gen",
+      "routing_text": "ios icon gen ios icon gen Generate iOS app icons as PNG imagesets for Xcode asset catalogs from SF Symbols (5000+ Apple-native) or Iconify API (275k+ open source icons from 200+ collections). Use when generating icons, creating icon assets, adding icons to asset catalog, or searching for icons for iOS projects. - Generating icon assets for an iOS/macOS Xcode project\n- Searching for icons across open source collections\n- Creating PNG imagesets (1x, 2x, 3x) for asset catalogs\n- Replacing placeholder icons with production-quality assets\n- Matching existing icon styles in an Xcode project\n\n"
+    },
+    "iterative-retrieval": {
+      "description": "Pattern for progressively refining context retrieval to solve the subagent context problem. Use when a subagent lacks the context it needs and retrieval must be refined across passes.",
+      "name": "iterative-retrieval",
+      "path": "ecc/iterative-retrieval",
+      "routing_text": "iterative retrieval iterative retrieval Pattern for progressively refining context retrieval to solve the subagent context problem. Use when a subagent lacks the context it needs and retrieval must be refined across passes. - Spawning subagents that need codebase context they cannot predict upfront\n- Building multi-agent workflows where context is progressively refined\n- Encountering \"context too large\" or \"missing context\" failures in agent tasks\n- Designing RAG-like retrieval pipelines for code exploration\n- Optimizing token usage in agent orchestration\n\n"
+    },
+    "ito-baskets": {
+      "description": "Read-only Itô basket and prediction-market data skill. Index the live basket catalog, compare a basket against user-supplied research or a watchlist, build a source-grounded market brief, or draft a non-executable planning worksheet. Use when a user asks to browse or index Itô baskets, compare a basket against notes or a thesis, research prediction-market events/venues/liquidity, or plan a basket or market idea without trading. Never advises, orders, trades, reserves, or executes.",
+      "name": "ito-baskets",
+      "path": "ecc/ito-baskets",
+      "routing_text": "ito baskets ito baskets Read-only Itô basket and prediction-market data skill. Index the live basket catalog, compare a basket against user-supplied research or a watchlist, build a source-grounded market brief, or draft a non-executable planning worksheet. Use when a user asks to browse or index Itô baskets, compare a basket against notes or a thesis, research prediction-market events/venues/liquidity, or plan a basket or market idea without trading. Never advises, orders, trades, reserves, or executes."
+    },
+    "ito-compute": {
+      "description": "Query live GPU inventory, submit an authenticated Itô fixed-rate RFQ, inspect RFQ or procurement status, revoke device credentials, and run explicitly gated node qualification through the separately installed canonical CLI. Use when a user asks to find H100/H200 capacity, request a fixed compute rate, check Itô compute status, validate GPU nodes, revoke Itô access, or rent or purchase GPU compute and needs the supported boundary explained.",
+      "name": "ito-compute",
+      "path": "ecc/ito-compute",
+      "routing_text": "ito compute ito compute Query live GPU inventory, submit an authenticated Itô fixed-rate RFQ, inspect RFQ or procurement status, revoke device credentials, and run explicitly gated node qualification through the separately installed canonical CLI. Use when a user asks to find H100/H200 capacity, request a fixed compute rate, check Itô compute status, validate GPU nodes, revoke Itô access, or rent or purchase GPU compute and needs the supported boundary explained."
+    },
+    "ito-inference": {
+      "description": "Inspect the availability of model serving on a completed Itô compute booking and, when the canonical backend becomes available, hand off an explicitly confirmed serving manifest. Use after ito-compute has booked GPU nodes and the user asks for an OpenAI-compatible endpoint, ito-serve, hosted Kimi, or self-hosted open-weights inference. ECC implements no serving stack of its own.",
+      "name": "ito-inference",
+      "path": "ecc/ito-inference",
+      "routing_text": "ito inference ito inference Inspect the availability of model serving on a completed Itô compute booking and, when the canonical backend becomes available, hand off an explicitly confirmed serving manifest. Use after ito-compute has booked GPU nodes and the user asks for an OpenAI-compatible endpoint, ito-serve, hosted Kimi, or self-hosted open-weights inference. ECC implements no serving stack of its own."
+    },
+    "ito-training": {
+      "description": "Inspect the availability of ML training on a completed Itô compute booking and, when the canonical backend becomes available, hand off an explicitly confirmed training manifest. Use after ito-compute has booked GPU nodes and the user wants pre-training, fine-tuning, or RL on that metal. ECC implements no training stack of its own.",
+      "name": "ito-training",
+      "path": "ecc/ito-training",
+      "routing_text": "ito training ito training Inspect the availability of ML training on a completed Itô compute booking and, when the canonical backend becomes available, hand off an explicitly confirmed training manifest. Use after ito-compute has booked GPU nodes and the user wants pre-training, fine-tuning, or RL on that metal. ECC implements no training stack of its own."
+    },
+    "java-coding-standards": {
+      "description": "Java coding standards for Spring Boot and Quarkus services: naming, immutability, Optional usage, streams, exceptions, generics, CDI, reactive patterns, and project layout. Automatically applies framework-specific conventions. Use when writing or reviewing Java in a Spring Boot or Quarkus service.",
+      "name": "java-coding-standards",
+      "path": "ecc/java-coding-standards",
+      "routing_text": "java coding standards java coding standards Java coding standards for Spring Boot and Quarkus services: naming, immutability, Optional usage, streams, exceptions, generics, CDI, reactive patterns, and project layout. Automatically applies framework-specific conventions. Use when writing or reviewing Java in a Spring Boot or Quarkus service. - Writing or reviewing Java code in Spring Boot or Quarkus projects\n- Enforcing naming, immutability, or exception handling conventions\n- Working with records, sealed classes, or pattern matching (Java 17+)\n- Reviewing use of Optional, streams, or generics\n- Structuring packages and project layout\n- **[QUARKUS]**: Working with CDI scopes, Panache entities, or reactive pipelines\n\n"
+    },
+    "jira-integration": {
+      "description": "Use this skill when retrieving Jira tickets, analyzing requirements, updating ticket status, adding comments, or transitioning issues. Provides Jira API patterns via MCP or direct REST calls.",
+      "name": "jira-integration",
+      "path": "ecc/jira-integration",
+      "routing_text": "jira integration jira integration Use this skill when retrieving Jira tickets, analyzing requirements, updating ticket status, adding comments, or transitioning issues. Provides Jira API patterns via MCP or direct REST calls. - Fetching a Jira ticket to understand requirements\n- Extracting testable acceptance criteria from a ticket\n- Adding progress comments to a Jira issue\n- Transitioning a ticket status (To Do → In Progress → Done)\n- Linking merge requests or branches to a Jira issue\n- Searching for issues by JQL query\n\n"
+    },
+    "jpa-patterns": {
+      "description": "JPA/Hibernate patterns for entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and pooling in Spring Boot. Use when designing JPA entities or relationships, or when a Hibernate query, transaction, or N+1 problem needs fixing.",
+      "name": "jpa-patterns",
+      "path": "ecc/jpa-patterns",
+      "routing_text": "jpa patterns jpa patterns JPA/Hibernate patterns for entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and pooling in Spring Boot. Use when designing JPA entities or relationships, or when a Hibernate query, transaction, or N+1 problem needs fixing. - Designing JPA entities and table mappings\n- Defining relationships (@OneToMany, @ManyToOne, @ManyToMany)\n- Optimizing queries (N+1 prevention, fetch strategies, projections)\n- Configuring transactions, auditing, or soft deletes\n- Setting up pagination, sorting, or custom repository methods\n- Tuning connection pooling (HikariCP) or second-level caching\n\n"
+    },
+    "knowledge-ops": {
+      "description": "Knowledge base management, ingestion, sync, and retrieval across multiple storage layers (local files, MCP memory, vector stores, Git repos). Use when the user wants to save, organize, sync, deduplicate, or search across their knowledge systems.",
+      "name": "knowledge-ops",
+      "path": "ecc/knowledge-ops",
+      "routing_text": "knowledge ops knowledge ops Knowledge base management, ingestion, sync, and retrieval across multiple storage layers (local files, MCP memory, vector stores, Git repos). Use when the user wants to save, organize, sync, deduplicate, or search across their knowledge systems. - User wants to save information to their knowledge base\n- Ingesting documents, conversations, or data into structured storage\n- Syncing knowledge across systems (local files, MCP memory, Supabase, Git repos)\n- Deduplicating or organizing existing knowledge\n- User says \"save this to KB\", \"sync knowledge\", \"what do I know about X\", \"ingest this\", \"update the knowledge base\"\n- Any knowledge management task beyond simple memory recall\n\n"
+    },
+    "kotlin-coroutines-flows": {
+      "description": "Kotlin Coroutines and Flow patterns for Android and KMP — structured concurrency, Flow operators, StateFlow, error handling, and testing. Use when writing coroutines or Flow code on Android or KMP, or debugging cancellation and concurrency.",
+      "name": "kotlin-coroutines-flows",
+      "path": "ecc/kotlin-coroutines-flows",
+      "routing_text": "kotlin coroutines flows kotlin coroutines flows Kotlin Coroutines and Flow patterns for Android and KMP — structured concurrency, Flow operators, StateFlow, error handling, and testing. Use when writing coroutines or Flow code on Android or KMP, or debugging cancellation and concurrency. - Writing async code with Kotlin coroutines\n- Using Flow, StateFlow, or SharedFlow for reactive data\n- Handling concurrent operations (parallel loading, debounce, retry)\n- Testing coroutines and Flows\n- Managing coroutine scopes and cancellation\n\n"
+    },
+    "kotlin-exposed-patterns": {
+      "description": "JetBrains Exposed ORM patterns including DSL queries, DAO pattern, transactions, HikariCP connection pooling, Flyway migrations, and repository pattern. Use when working with the Exposed ORM — DSL or DAO queries, transactions, pooling, or migrations.",
+      "name": "kotlin-exposed-patterns",
+      "path": "ecc/kotlin-exposed-patterns",
+      "routing_text": "kotlin exposed patterns kotlin exposed patterns JetBrains Exposed ORM patterns including DSL queries, DAO pattern, transactions, HikariCP connection pooling, Flyway migrations, and repository pattern. Use when working with the Exposed ORM — DSL or DAO queries, transactions, pooling, or migrations. - Setting up database access with Exposed\n- Writing SQL queries using Exposed DSL or DAO\n- Configuring connection pooling with HikariCP\n- Creating database migrations with Flyway\n- Implementing the repository pattern with Exposed\n- Handling JSON columns and complex queries\n\n"
+    },
+    "kotlin-ktor-patterns": {
+      "description": "Ktor server patterns including routing DSL, plugins, authentication, Koin DI, kotlinx.serialization, WebSockets, and testApplication testing. Use when building a Ktor server — routing, plugins, auth, DI, serialization, or tests.",
+      "name": "kotlin-ktor-patterns",
+      "path": "ecc/kotlin-ktor-patterns",
+      "routing_text": "kotlin ktor patterns kotlin ktor patterns Ktor server patterns including routing DSL, plugins, authentication, Koin DI, kotlinx.serialization, WebSockets, and testApplication testing. Use when building a Ktor server — routing, plugins, auth, DI, serialization, or tests. - Building Ktor HTTP servers\n- Configuring Ktor plugins (Auth, CORS, ContentNegotiation, StatusPages)\n- Implementing REST APIs with Ktor\n- Setting up dependency injection with Koin\n- Writing Ktor integration tests with testApplication\n- Working with WebSockets in Ktor\n\n"
+    },
+    "kotlin-patterns": {
+      "description": "Idiomatic Kotlin patterns, best practices, and conventions for building robust, efficient, and maintainable Kotlin applications with coroutines, null safety, and DSL builders. Use when writing or reviewing Kotlin code and idiomatic structure or null safety is in question.",
+      "name": "kotlin-patterns",
+      "path": "ecc/kotlin-patterns",
+      "routing_text": "kotlin patterns kotlin patterns Idiomatic Kotlin patterns, best practices, and conventions for building robust, efficient, and maintainable Kotlin applications with coroutines, null safety, and DSL builders. Use when writing or reviewing Kotlin code and idiomatic structure or null safety is in question. - Writing new Kotlin code\n- Reviewing Kotlin code\n- Refactoring existing Kotlin code\n- Designing Kotlin modules or libraries\n- Configuring Gradle Kotlin DSL builds\n\n"
+    },
+    "kotlin-testing": {
+      "description": "Kotlin testing patterns with Kotest, MockK, coroutine testing, property-based testing, and Kover coverage. Follows TDD methodology with idiomatic Kotlin practices. Use when writing Kotlin tests with Kotest or MockK, or testing coroutines and checking coverage.",
+      "name": "kotlin-testing",
+      "path": "ecc/kotlin-testing",
+      "routing_text": "kotlin testing kotlin testing Kotlin testing patterns with Kotest, MockK, coroutine testing, property-based testing, and Kover coverage. Follows TDD methodology with idiomatic Kotlin practices. Use when writing Kotlin tests with Kotest or MockK, or testing coroutines and checking coverage. - Writing new Kotlin functions or classes\n- Adding test coverage to existing Kotlin code\n- Implementing property-based tests\n- Following TDD workflow in Kotlin projects\n- Configuring Kover for code coverage\n\n"
+    },
+    "kubernetes-patterns": {
+      "description": "Kubernetes workload patterns, resource management, RBAC, probes, autoscaling, ConfigMap/Secret handling, and kubectl debugging for production-grade deployments. Use when writing or reviewing Kubernetes manifests, or debugging probes, RBAC, autoscaling, or resource limits.",
+      "name": "kubernetes-patterns",
+      "path": "ecc/kubernetes-patterns",
+      "routing_text": "kubernetes patterns kubernetes patterns Kubernetes workload patterns, resource management, RBAC, probes, autoscaling, ConfigMap/Secret handling, and kubectl debugging for production-grade deployments. Use when writing or reviewing Kubernetes manifests, or debugging probes, RBAC, autoscaling, or resource limits. - Writing Kubernetes manifests (Deployments, Services, Ingress, Jobs)\n- Configuring resource requests/limits, liveness/readiness probes\n- Setting up RBAC, namespaces, or ServiceAccounts\n- Managing configuration and secrets in K8s\n- Debugging CrashLoopBackOff, OOMKilled, pending pods, or image pull errors\n- Configuring HPA (Horizontal Pod Autoscaler) or PodDisruptionBudgets\n- Reviewing K8s YAML for security or correctness\n\n"
+    },
+    "laravel-patterns": {
+      "description": "Laravel architecture patterns, routing/controllers, Eloquent ORM, service layers, queues, events, caching, and API resources for production apps. Use when building or reviewing Laravel apps — controllers, Eloquent, service layers, queues, or API resources.",
+      "name": "laravel-patterns",
+      "path": "ecc/laravel-patterns",
+      "routing_text": "laravel patterns laravel patterns Laravel architecture patterns, routing/controllers, Eloquent ORM, service layers, queues, events, caching, and API resources for production apps. Use when building or reviewing Laravel apps — controllers, Eloquent, service layers, queues, or API resources. - Building Laravel web applications or APIs\n- Structuring controllers, services, and domain logic\n- Working with Eloquent models and relationships\n- Designing APIs with resources and pagination\n- Adding queues, events, caching, and background jobs\n\n"
+    },
+    "laravel-plugin-discovery": {
+      "description": "Discover and evaluate Laravel packages via LaraPlugins.io MCP. Use when the user wants to find plugins, check package health, or assess Laravel/PHP compatibility.",
+      "name": "laravel-plugin-discovery",
+      "path": "ecc/laravel-plugin-discovery",
+      "routing_text": "laravel plugin discovery laravel plugin discovery Discover and evaluate Laravel packages via LaraPlugins.io MCP. Use when the user wants to find plugins, check package health, or assess Laravel/PHP compatibility. - User wants to find Laravel packages for a specific feature (e.g. \"auth\", \"permissions\", \"admin panel\")\n- User asks \"what package should I use for...\" or \"is there a Laravel package for...\"\n- User wants to check if a package is actively maintained\n- User needs to verify Laravel version compatibility\n- User wants to assess package health before adding to a project\n\n"
+    },
+    "laravel-security": {
+      "description": "Laravel security best practices — authentication, authorization, Eloquent safety, CSRF, XSS prevention, API security, and secure deployment configurations. Use when reviewing Laravel auth, Eloquent safety, CSRF, XSS, API security, or deployment configuration.",
+      "name": "laravel-security",
+      "path": "ecc/laravel-security",
+      "routing_text": "laravel security laravel security Laravel security best practices — authentication, authorization, Eloquent safety, CSRF, XSS prevention, API security, and secure deployment configurations. Use when reviewing Laravel auth, Eloquent safety, CSRF, XSS, API security, or deployment configuration. - Setting up Laravel authentication and authorization (Sanctum, Passport, Jetstream, Breeze)\n- Implementing user roles, permissions, and policies\n- Configuring production security settings and environment variables\n- Reviewing Laravel applications for security vulnerabilities\n- Deploying Laravel applications to production\n- Writing secure Eloquent queries and migrations\n\n"
+    },
+    "laravel-tdd": {
+      "description": "Laravel testing strategies with PHPUnit, Pest, model factories, HTTP tests, Sanctum authentication testing, mocking, and coverage. Use when writing Laravel tests with PHPUnit or Pest, or driving a Laravel feature test-first.",
+      "name": "laravel-tdd",
+      "path": "ecc/laravel-tdd",
+      "routing_text": "laravel tdd laravel tdd Laravel testing strategies with PHPUnit, Pest, model factories, HTTP tests, Sanctum authentication testing, mocking, and coverage. Use when writing Laravel tests with PHPUnit or Pest, or driving a Laravel feature test-first. - Writing new Laravel applications or features\n- Implementing API endpoints with Sanctum or Passport authentication\n- Testing Eloquent models, relationships, scopes, and accessors\n- Setting up testing infrastructure for Laravel projects\n- Writing feature tests for HTTP controllers and form requests\n- Mocking external services (queues, mail, notifications, HTTP)\n\n"
+    },
+    "laravel-verification": {
+      "description": "Verification loop for Laravel projects: env checks, linting, static analysis, tests with coverage, security scans, and deployment readiness. Use when verifying a Laravel project before merge or deploy — lint, static analysis, tests, coverage, security.",
+      "name": "laravel-verification",
+      "path": "ecc/laravel-verification",
+      "routing_text": "laravel verification laravel verification Verification loop for Laravel projects: env checks, linting, static analysis, tests with coverage, security scans, and deployment readiness. Use when verifying a Laravel project before merge or deploy — lint, static analysis, tests, coverage, security. - Before opening a pull request for a Laravel project\n- After major refactors or dependency upgrades\n- Pre-deployment verification for staging or production\n- Running full lint -> test -> security -> deploy readiness pipeline\n\n"
+    },
+    "latency-critical-systems": {
+      "description": "Use for latency-sensitive systems such as realtime dashboards, market data, streaming agents, execution gateways, queues, caches, or HFT-like infrastructure where freshness and p95 latency matter. Use when p95 latency or data freshness matters — realtime dashboards, market data, streaming agents, queues, or caches.",
+      "name": "latency-critical-systems",
+      "path": "ecc/latency-critical-systems",
+      "routing_text": "latency critical systems latency critical systems Use for latency-sensitive systems such as realtime dashboards, market data, streaming agents, execution gateways, queues, caches, or HFT-like infrastructure where freshness and p95 latency matter. Use when p95 latency or data freshness matters — realtime dashboards, market data, streaming agents, queues, or caches."
+    },
+    "lead-intelligence": {
+      "description": "AI-native lead intelligence and outreach pipeline. Replaces Apollo, Clay, and ZoomInfo with agent-powered signal scoring, mutual ranking, warm path discovery, source-derived voice modeling, and channel-specific outreach across email, LinkedIn, and X. Use when the user wants to find, qualify, and reach high-value contacts.",
+      "name": "lead-intelligence",
+      "path": "ecc/lead-intelligence",
+      "routing_text": "lead intelligence lead intelligence AI-native lead intelligence and outreach pipeline. Replaces Apollo, Clay, and ZoomInfo with agent-powered signal scoring, mutual ranking, warm path discovery, source-derived voice modeling, and channel-specific outreach across email, LinkedIn, and X. Use when the user wants to find, qualify, and reach high-value contacts. - User wants to find leads or prospects in a specific industry\n- Building an outreach list for partnerships, sales, or fundraising\n- Researching who to reach out to and the best path to reach them\n- User says \"find leads\", \"outreach list\", \"who should I reach out to\", \"warm intros\"\n- Needs to score or rank a list of contacts by relevance\n- Wants to map mutual connections to find warm introduction paths\n\n"
+    },
+    "liquid-glass-design": {
+      "description": "iOS 26 Liquid Glass design system — dynamic glass material with blur, reflection, and interactive morphing for SwiftUI, UIKit, and WidgetKit. Use when building iOS 26 Liquid Glass UI in SwiftUI, UIKit, or WidgetKit.",
+      "name": "liquid-glass-design",
+      "path": "ecc/liquid-glass-design",
+      "routing_text": "liquid glass design liquid glass design iOS 26 Liquid Glass design system — dynamic glass material with blur, reflection, and interactive morphing for SwiftUI, UIKit, and WidgetKit. Use when building iOS 26 Liquid Glass UI in SwiftUI, UIKit, or WidgetKit. - Building or updating apps for iOS 26+ with the new design language\n- Implementing glass-style buttons, cards, toolbars, or containers\n- Creating morphing transitions between glass elements\n- Applying Liquid Glass effects to widgets\n- Migrating existing blur/material effects to the new Liquid Glass API\n\n"
+    },
+    "living-docs-governance": {
+      "description": "Keep a long-lived project's documentation from rotting by assigning existing project docs clear constitution, map, status, and history roles, then wiring the active agent harness to those canonical sources. Use in the maintain phase when docs drift from code, agents lose context between sessions, or intentional removals keep being recreated. Prefer adopting the repository's current docs structure over creating new root files. 中文触发：文档治理、活文档、项目状态追踪、防文档漂移、项目地图、健康仪表盘、删除区、长期项目治理",
+      "name": "living-docs-governance",
+      "path": "ecc/living-docs-governance",
+      "routing_text": "living docs governance living docs governance Keep a long-lived project's documentation from rotting by assigning existing project docs clear constitution, map, status, and history roles, then wiring the active agent harness to those canonical sources. Use in the maintain phase when docs drift from code, agents lose context between sessions, or intentional removals keep being recreated. Prefer adopting the repository's current docs structure over creating new root files. 中文触发：文档治理、活文档、项目状态追踪、防文档漂移、项目地图、健康仪表盘、删除区、长期项目治理 Activate when any of these are true:\n\n- The repository has grown past a few modules and its docs are drifting from the code.\n- Agents or teammates repeatedly rediscover the same structure and decisions.\n- Nobody can quickly answer what is healthy, blocked, intentionally removed, or currently authoritative.\n- Deleted files or abandoned approaches are recreated because their disposition was not preserved.\n- The project needs a durable governance layer without adopting a large documentation platform.\n\nDo **not** use this for a throwaway script or create a parallel documentation system when the repository already has one.\n\n"
+    },
+    "llm-trading-agent-security": {
+      "description": "Security patterns for autonomous trading agents with wallet or transaction authority. Covers prompt injection, spend limits, pre-send simulation, circuit breakers, MEV protection, and key handling. Use when an autonomous agent holds wallet or transaction authority and its limits, simulation, or key handling need review.",
+      "name": "llm-trading-agent-security",
+      "path": "ecc/llm-trading-agent-security",
+      "routing_text": "llm trading agent security llm trading agent security Security patterns for autonomous trading agents with wallet or transaction authority. Covers prompt injection, spend limits, pre-send simulation, circuit breakers, MEV protection, and key handling. Use when an autonomous agent holds wallet or transaction authority and its limits, simulation, or key handling need review. - Building an AI agent that signs and sends transactions\n- Auditing a trading bot or on-chain execution assistant\n- Designing wallet key management for an agent\n- Giving an LLM access to order placement, swaps, or treasury operations\n\n"
+    },
+    "logistics-exception-management": {
+      "description": ">",
+      "name": "logistics-exception-management",
+      "path": "ecc/logistics-exception-management",
+      "routing_text": "logistics exception management logistics exception management > - Shipment is delayed, damaged, lost, or refused at delivery\n- Carrier dispute over liability, accessorial charges, or detention claims\n- Customer escalation due to missed delivery window or incorrect order\n- Filing or managing freight claims with carriers or insurers\n- Building exception handling SOPs or escalation protocols\n\n"
+    },
+    "loop-design-check": {
+      "description": "Design a goal-oriented agent loop, and review it for the ways loops go wrong — spinning and burning tokens, Goodhart-gaming the verifier, or running a wrong answer to completion. Two actions: (1) WRITE a loop — gate whether to build it, define a machine-decidable goal, pick the loop type, pick a skeleton; (2) REVIEW a loop — run it past five failure modes plus decidability, boundaries, fallback, judge independence, and keep-judgment-with-the-human red lines. Use when designing an autonomous agent loop, or when you already have one and worry it will spin, cheat, or run a wrong answer to the end. Complements the mechanism-layer loop skills (autonomous-loops, continuous-agent-loop) by covering the judgment layer they don't. 中文触发：写 loop、设计 loop、做一个 loop、检查 loop 对不对、loop 体检、loop 会不会跑飞、可判定目标、五个崩法、plan build judge。English triggers: design an agent loop, write a loop, check a loop, loop review, prevent a runaway loop, goal-oriented loop, decidable goal, plan/build/judge.",
+      "name": "loop-design-check",
+      "path": "ecc/loop-design-check",
+      "routing_text": "loop design check loop design check Design a goal-oriented agent loop, and review it for the ways loops go wrong — spinning and burning tokens, Goodhart-gaming the verifier, or running a wrong answer to completion. Two actions: (1) WRITE a loop — gate whether to build it, define a machine-decidable goal, pick the loop type, pick a skeleton; (2) REVIEW a loop — run it past five failure modes plus decidability, boundaries, fallback, judge independence, and keep-judgment-with-the-human red lines. Use when designing an autonomous agent loop, or when you already have one and worry it will spin, cheat, or run a wrong answer to the end. Complements the mechanism-layer loop skills (autonomous-loops, continuous-agent-loop) by covering the judgment layer they don't. 中文触发：写 loop、设计 loop、做一个 loop、检查 loop 对不对、loop 体检、loop 会不会跑飞、可判定目标、五个崩法、plan build judge。English triggers: design an agent loop, write a loop, check a loop, loop review, prevent a runaway loop, goal-oriented loop, decidable goal, plan/build/judge."
+    },
+    "mailtrap-email-integration": {
+      "description": "Guides agents through integrating transactional email sending via Mailtrap's Email API, including sandbox testing, domain verification, and API authentication. Use when implementing email-sending features, debugging delivery issues, or setting up safe dev/staging email testing.",
+      "name": "mailtrap-email-integration",
+      "path": "ecc/mailtrap-email-integration",
+      "routing_text": "mailtrap email integration mailtrap email integration Guides agents through integrating transactional email sending via Mailtrap's Email API, including sandbox testing, domain verification, and API authentication. Use when implementing email-sending features, debugging delivery issues, or setting up safe dev/staging email testing. - Implementing a \"send email\" feature (signup confirmation, password reset, notifications, receipts)\n- Debugging why emails aren't arriving in dev/staging\n- Setting up a project's first email-sending integration\n- Reviewing code that calls an email API directly without sandbox separation\n\n"
+    },
+    "make-interfaces-feel-better": {
+      "description": "Apply concrete design-engineering details that make interfaces feel polished. Use when reviewing or improving UI spacing, typography, borders, shadows, motion, hit areas, icons, text wrapping, and interaction states.",
+      "name": "make-interfaces-feel-better",
+      "path": "ecc/make-interfaces-feel-better",
+      "routing_text": "make interfaces feel better make interfaces feel better Apply concrete design-engineering details that make interfaces feel polished. Use when reviewing or improving UI spacing, typography, borders, shadows, motion, hit areas, icons, text wrapping, and interaction states. - The user says the UI feels off, flat, generic, cramped, jumpy, or unfinished.\n- You are building controls, cards, lists, dashboards, navigation, forms, or\n  toolbars.\n- A component needs hover, active, focus, enter, exit, loading, or empty states.\n- A frontend review needs specific before/after recommendations.\n\n"
+    },
+    "manim-video": {
+      "description": "Build reusable Manim explainers for technical concepts, graphs, system diagrams, and product walkthroughs, then hand off to the wider ECC video stack if needed. Use when the user wants a clean animated explainer rather than a generic talking-head script.",
+      "name": "manim-video",
+      "path": "ecc/manim-video",
+      "routing_text": "manim video manim video Build reusable Manim explainers for technical concepts, graphs, system diagrams, and product walkthroughs, then hand off to the wider ECC video stack if needed. Use when the user wants a clean animated explainer rather than a generic talking-head script. - the user wants a technical explainer animation\n- the concept is a graph, workflow, architecture, metric progression, or system diagram\n- the user wants a short product or launch explainer for X or a landing page\n- the visual should feel precise instead of generically cinematic\n\n"
+    },
+    "market-research": {
+      "description": "Conduct market research, competitive analysis, investor due diligence, and industry intelligence with source attribution and decision-oriented summaries. Use when the user wants market sizing, competitor comparisons, fund research, technology scans, or research that informs business decisions.",
+      "name": "market-research",
+      "path": "ecc/market-research",
+      "routing_text": "market research market research Conduct market research, competitive analysis, investor due diligence, and industry intelligence with source attribution and decision-oriented summaries. Use when the user wants market sizing, competitor comparisons, fund research, technology scans, or research that informs business decisions. - researching a market, category, company, investor, or technology trend\n- building TAM/SAM/SOM estimates\n- comparing competitors or adjacent products\n- preparing investor dossiers before outreach\n- pressure-testing a thesis before building, funding, or entering a market\n\n"
+    },
+    "marketing-campaign": {
+      "description": "End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.",
+      "name": "marketing-campaign",
+      "path": "ecc/marketing-campaign",
+      "routing_text": "marketing campaign marketing campaign End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy. - planning a product or feature launch\n- building a full content suite from a single product brief\n- defining positioning and campaign angle before writing any copy\n- orchestrating multiple content types across channels\n- reviewing copy for conversion quality and brand consistency\n\n"
+    },
+    "mcp-server-patterns": {
+      "description": "Build MCP servers with Node/TypeScript SDK — tools, resources, prompts, Zod validation, stdio vs Streamable HTTP. Use Context7 or official MCP docs for latest API. Use when building or debugging an MCP server — tools, resources, prompts, validation, or transport choice.",
+      "name": "mcp-server-patterns",
+      "path": "ecc/mcp-server-patterns",
+      "routing_text": "mcp server patterns mcp server patterns Build MCP servers with Node/TypeScript SDK — tools, resources, prompts, Zod validation, stdio vs Streamable HTTP. Use Context7 or official MCP docs for latest API. Use when building or debugging an MCP server — tools, resources, prompts, validation, or transport choice. Use when: implementing a new MCP server, adding tools or resources, choosing stdio vs HTTP, upgrading the SDK, or debugging MCP registration and transport issues.\n\n"
+    },
+    "messages-ops": {
+      "description": "Evidence-first live messaging workflow for ECC. Use when the user wants to read texts or DMs, recover a recent one-time code, inspect a thread before replying, or prove which message source was actually checked.",
+      "name": "messages-ops",
+      "path": "ecc/messages-ops",
+      "routing_text": "messages ops messages ops Evidence-first live messaging workflow for ECC. Use when the user wants to read texts or DMs, recover a recent one-time code, inspect a thread before replying, or prove which message source was actually checked. - user says \"read my messages\", \"check texts\", \"look in DMs\", or \"find the code\"\n- the task depends on a live thread or a recent code delivered to a local messaging surface\n- the user wants proof of which source or thread was inspected\n\n"
+    },
+    "ml-adoption-playbook": {
+      "description": "End-to-end methodology for AI agents and software engineers to add machine learning algorithms to existing non-ML codebases. Covers problem framing, data readiness, architectural decoupling, and baseline model integration. Use when adding a machine learning capability to a codebase that has none, from problem framing through a baseline model.",
+      "name": "ml-adoption-playbook",
+      "path": "ecc/ml-adoption-playbook",
+      "routing_text": "ml adoption playbook ml adoption playbook End-to-end methodology for AI agents and software engineers to add machine learning algorithms to existing non-ML codebases. Covers problem framing, data readiness, architectural decoupling, and baseline model integration. Use when adding a machine learning capability to a codebase that has none, from problem framing through a baseline model. - A user asks to \"add ML\" or \"add an algorithm\" to their existing codebase.\n- Planning the integration of a new model (e.g., recommendation, classification, forecasting) into a non-ML application.\n- Structuring a workflow for an agent to build, train, and deploy an ML component adaptively.\n\n"
+    },
+    "mle-workflow": {
+      "description": "Production machine-learning engineering workflow for data contracts, reproducible training, model evaluation, deployment, monitoring, and rollback. Use when building, reviewing, or hardening ML systems beyond one-off notebooks.",
+      "name": "mle-workflow",
+      "path": "ecc/mle-workflow",
+      "routing_text": "mle workflow mle workflow Production machine-learning engineering workflow for data contracts, reproducible training, model evaluation, deployment, monitoring, and rollback. Use when building, reviewing, or hardening ML systems beyond one-off notebooks. - Planning or reviewing a production ML feature, model refresh, ranking system, recommender, classifier, embedding workflow, or forecasting pipeline\n- Converting notebook code into a reusable training, evaluation, batch inference, or online inference pipeline\n- Designing model promotion criteria, offline/online evals, experiment tracking, or rollback paths\n- Debugging failures caused by data drift, label leakage, stale features, artifact mismatch, or inconsistent training and serving logic\n- Adding model monitoring, canary rollout, shadow traffic, or post-deploy quality checks\n\n"
+    },
+    "motion-advanced": {
+      "description": "Advanced motion patterns for React / Next.js — drag & drop, gestures, text animations, SVG path drawing, custom hooks, imperative sequences (useAnimate), loaders, and the full API decision tree. Requires motion-foundations. Use when building drag and drop, gestures, text or SVG animation, or imperative animation sequences in React or Next.js.",
+      "name": "motion-advanced",
+      "path": "ecc/motion-advanced",
+      "routing_text": "motion advanced motion advanced Advanced motion patterns for React / Next.js — drag & drop, gestures, text animations, SVG path drawing, custom hooks, imperative sequences (useAnimate), loaders, and the full API decision tree. Requires motion-foundations. Use when building drag and drop, gestures, text or SVG animation, or imperative animation sequences in React or Next.js. - Building drag-to-dismiss sheets, swipe gestures, or reorderable lists\n- Animating text word-by-word, character-by-character, or as a live counter\n- Drawing SVG paths, morphing icons, or animating circular progress\n- Writing a custom animation hook (`useScrollReveal`, magnetic button, cursor follower)\n- Sequencing multi-step animations imperatively with `useAnimate`\n- Building spinners, shimmer skeletons, pulse indicators, or loading button states\n\n"
+    },
+    "motion-foundations": {
+      "description": "Motion tokens, spring presets, performance rules, device adaptation, accessibility enforcement, and SSR safety for React / Next.js using motion/react. Foundation layer — all other motion skills depend on this. Use when setting up motion tokens, spring presets, reduced-motion handling, or SSR-safe animation in React or Next.js.",
+      "name": "motion-foundations",
+      "path": "ecc/motion-foundations",
+      "routing_text": "motion foundations motion foundations Motion tokens, spring presets, performance rules, device adaptation, accessibility enforcement, and SSR safety for React / Next.js using motion/react. Foundation layer — all other motion skills depend on this. Use when setting up motion tokens, spring presets, reduced-motion handling, or SSR-safe animation in React or Next.js. - Starting any animated component from scratch\n- Setting up tokens, spring presets, or easing values\n- Implementing `prefers-reduced-motion` support\n- Debugging hydration mismatches from animation initial states\n- Evaluating whether an animation should exist at all\n\n"
+    },
+    "motion-patterns": {
+      "description": "Production-ready animation patterns for React / Next.js — button, modal, toast, stagger, page transitions, exit animations, scroll, and layout — built on motion-foundations tokens and springs. Use when animating a specific UI element in React or Next.js — button, modal, toast, stagger, page transition, or scroll.",
+      "name": "motion-patterns",
+      "path": "ecc/motion-patterns",
+      "routing_text": "motion patterns motion patterns Production-ready animation patterns for React / Next.js — button, modal, toast, stagger, page transitions, exit animations, scroll, and layout — built on motion-foundations tokens and springs. Use when animating a specific UI element in React or Next.js — button, modal, toast, stagger, page transition, or scroll. - Animating a button, card, modal, or toast notification\n- Building list entrances with stagger\n- Setting up page transitions in Next.js App Router\n- Adding entrance or exit animations to conditional content\n- Implementing scroll-reveal, scroll-linked progress, or sticky story sections\n- Building expanding cards, accordions, or shared-element transitions\n\n"
+    },
+    "motion-ui": {
+      "description": "Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.",
+      "name": "motion-ui",
+      "path": "ecc/motion-ui",
+      "routing_text": "motion ui motion ui Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns. Use this motion system when motion:\n\n* Guides attention (e.g., onboarding, key actions)\n* Communicates state (loading, success, error, transitions)\n* Preserves spatial continuity (layout changes, navigation)\n\n### Appropriate Scenarios\n\n* Interactive components (buttons, modals, menus)\n* State transitions (loading → loaded, open → closed)\n* Navigation and layout continuity (shared elements, crossfade)\n\n### Considerations\n\n* **Accessibility**: Always support reduced motion\n* **Device adaptation**: Adjust for low-end devices\n* **Performance trade-offs**: Prefer responsiveness over visual smoothness\n\n### Avoid Using Motion When\n\n* It is purely decorative\n* It reduces usability or clarity\n* It impacts performance negatively\n\n---\n\n"
+    },
+    "mysql-patterns": {
+      "description": "MySQL and MariaDB schema, query, indexing, transaction, replication, and connection-pool patterns for production backends. Use when designing MySQL or MariaDB schemas and indexes, or when a query, transaction, or replica lags.",
+      "name": "mysql-patterns",
+      "path": "ecc/mysql-patterns",
+      "routing_text": "mysql patterns mysql patterns MySQL and MariaDB schema, query, indexing, transaction, replication, and connection-pool patterns for production backends. Use when designing MySQL or MariaDB schemas and indexes, or when a query, transaction, or replica lags."
+    },
+    "nanoclaw-repl": {
+      "description": "Operate and extend NanoClaw v2, ECC's zero-dependency session-aware REPL built on claude -p. Use when operating or extending the NanoClaw REPL.",
+      "name": "nanoclaw-repl",
+      "path": "ecc/nanoclaw-repl",
+      "routing_text": "nanoclaw repl nanoclaw repl Operate and extend NanoClaw v2, ECC's zero-dependency session-aware REPL built on claude -p. Use when operating or extending the NanoClaw REPL."
+    },
+    "nasiko-control-plane": {
+      "description": "Use the experimental Nasiko CLI lifecycle bridge for pinned installation, read-only status, and qualified uninstall with explicit consent and telemetry and secrets boundaries.",
+      "name": "nasiko-control-plane",
+      "path": "ecc/nasiko-control-plane",
+      "routing_text": "nasiko control plane nasiko control plane Use the experimental Nasiko CLI lifecycle bridge for pinned installation, read-only status, and qualified uninstall with explicit consent and telemetry and secrets boundaries."
+    },
+    "nestjs-patterns": {
+      "description": "NestJS architecture patterns for modules, controllers, providers, DTO validation, guards, interceptors, config, and production-grade TypeScript backends. Use when building or reviewing a NestJS backend — modules, providers, DTO validation, guards, or interceptors.",
+      "name": "nestjs-patterns",
+      "path": "ecc/nestjs-patterns",
+      "routing_text": "nestjs patterns nestjs patterns NestJS architecture patterns for modules, controllers, providers, DTO validation, guards, interceptors, config, and production-grade TypeScript backends. Use when building or reviewing a NestJS backend — modules, providers, DTO validation, guards, or interceptors. - Building NestJS APIs or services\n- Structuring modules, controllers, and providers\n- Adding DTO validation, guards, interceptors, or exception filters\n- Configuring environment-aware settings and database integrations\n- Testing NestJS units or HTTP endpoints\n\n"
+    },
+    "netmiko-ssh-automation": {
+      "description": "Safe Python Netmiko patterns for read-only collection, bounded batch SSH, TextFSM parsing, guarded config changes, timeouts, and network automation error handling. Use when automating network device access with Python Netmiko, whether collecting state or pushing guarded config changes.",
+      "name": "netmiko-ssh-automation",
+      "path": "ecc/netmiko-ssh-automation",
+      "routing_text": "netmiko ssh automation netmiko ssh automation Safe Python Netmiko patterns for read-only collection, bounded batch SSH, TextFSM parsing, guarded config changes, timeouts, and network automation error handling. Use when automating network device access with Python Netmiko, whether collecting state or pushing guarded config changes. - Collecting `show` command output across routers, switches, or firewalls.\n- Building a small audit script for interface, routing, or config evidence.\n- Adding timeouts and exception handling to network SSH scripts.\n- Parsing command output with TextFSM when a template exists.\n- Reviewing automation before it touches production devices.\n\n"
+    },
+    "network-bgp-diagnostics": {
+      "description": "Diagnostics-only BGP troubleshooting patterns for neighbor state, route exchange, prefix policy, AS path inspection, and safe evidence collection. Use when a BGP neighbor is down, routes are missing, or prefix policy and AS path need inspection.",
+      "name": "network-bgp-diagnostics",
+      "path": "ecc/network-bgp-diagnostics",
+      "routing_text": "network bgp diagnostics network bgp diagnostics Diagnostics-only BGP troubleshooting patterns for neighbor state, route exchange, prefix policy, AS path inspection, and safe evidence collection. Use when a BGP neighbor is down, routes are missing, or prefix policy and AS path need inspection. - BGP neighbors are stuck in Idle, Connect, Active, OpenSent, or OpenConfirm.\n- A session is Established but expected prefixes are missing.\n- A route-map, prefix-list, max-prefix limit, or AS path policy may be filtering\n  routes.\n- You need before/after evidence for a BGP change.\n- You are reviewing automation that parses BGP summary output.\n\n"
+    },
+    "network-config-validation": {
+      "description": "Pre-deployment checks for router and switch configuration, including dangerous commands, duplicate addresses, subnet overlaps, stale references, management-plane risk, and IOS-style security hygiene. Use when reviewing a router or switch configuration before deployment.",
+      "name": "network-config-validation",
+      "path": "ecc/network-config-validation",
+      "routing_text": "network config validation network config validation Pre-deployment checks for router and switch configuration, including dangerous commands, duplicate addresses, subnet overlaps, stale references, management-plane risk, and IOS-style security hygiene. Use when reviewing a router or switch configuration before deployment. - Reviewing Cisco IOS or IOS-XE style snippets before deployment.\n- Auditing generated config from scripts or templates.\n- Looking for dangerous commands, duplicate IP addresses, or subnet overlaps.\n- Checking whether ACLs, route-maps, prefix-lists, or line policies are referenced\n  but not defined.\n- Building lightweight pre-flight scripts for network automation.\n\n"
+    },
+    "network-interface-health": {
+      "description": "Diagnose interface errors, drops, CRCs, duplex mismatches, flapping, speed negotiation issues, and counter trends on routers, switches, and Linux hosts. Use when an interface shows errors, drops, CRCs, flapping, or a duplex or speed mismatch.",
+      "name": "network-interface-health",
+      "path": "ecc/network-interface-health",
+      "routing_text": "network interface health network interface health Diagnose interface errors, drops, CRCs, duplex mismatches, flapping, speed negotiation issues, and counter trends on routers, switches, and Linux hosts. Use when an interface shows errors, drops, CRCs, flapping, or a duplex or speed mismatch. - A host or VLAN has packet loss, latency spikes, or intermittent reachability.\n- A switch or router interface shows CRCs, runts, giants, drops, resets, or flaps.\n- You need to compare both ends of a link before replacing hardware.\n- A change window needs before/after interface counter evidence.\n- Monitoring reports rising `ifInErrors`, `ifOutErrors`, or `ifOutDiscards`.\n\n"
+    },
+    "nextjs-turbopack": {
+      "description": "Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack.",
+      "name": "nextjs-turbopack",
+      "path": "ecc/nextjs-turbopack",
+      "routing_text": "nextjs turbopack nextjs turbopack Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack. - **Turbopack (default dev)**: Use for day-to-day development. Faster cold start and HMR, especially in large apps.\n- **Webpack (legacy dev)**: Use only if you hit a Turbopack bug or rely on a webpack-only plugin in dev. Disable with `--webpack` (or `--no-turbopack` depending on your Next.js version; check the docs for your release).\n- **Production**: Production build behavior (`next build`) may use Turbopack or webpack depending on Next.js version; check the official Next.js docs for your version.\n\nUse when: developing or debugging Next.js 16+ apps, diagnosing slow dev startup or HMR, or optimizing production bundles.\n\n"
+    },
+    "nodejs-keccak256": {
+      "description": "Prevent Ethereum hashing bugs in JavaScript and TypeScript. Node's sha3-256 is NIST SHA3, not Ethereum Keccak-256, and silently breaks selectors, signatures, storage slots, and address derivation. Use when hashing for Ethereum in JavaScript or TypeScript, or when a selector, signature, storage slot, or derived address is wrong.",
+      "name": "nodejs-keccak256",
+      "path": "ecc/nodejs-keccak256",
+      "routing_text": "nodejs keccak256 nodejs keccak256 Prevent Ethereum hashing bugs in JavaScript and TypeScript. Node's sha3-256 is NIST SHA3, not Ethereum Keccak-256, and silently breaks selectors, signatures, storage slots, and address derivation. Use when hashing for Ethereum in JavaScript or TypeScript, or when a selector, signature, storage slot, or derived address is wrong. - Computing Ethereum function selectors or event topics\n- Building EIP-712, signature, Merkle, or storage-slot helpers in JS/TS\n- Reviewing any code that hashes Ethereum data with Node crypto directly\n\n"
+    },
+    "nutrient-document-processing": {
+      "description": "Process, convert, OCR, extract, redact, sign, and fill documents using the Nutrient DWS API. Works with PDFs, DOCX, XLSX, PPTX, HTML, and images. Use when converting, OCRing, extracting from, redacting, signing, or filling documents via the Nutrient DWS API.",
+      "name": "nutrient-document-processing",
+      "path": "ecc/nutrient-document-processing",
+      "routing_text": "nutrient document processing nutrient document processing Process, convert, OCR, extract, redact, sign, and fill documents using the Nutrient DWS API. Works with PDFs, DOCX, XLSX, PPTX, HTML, and images. Use when converting, OCRing, extracting from, redacting, signing, or filling documents via the Nutrient DWS API. - Converting documents between formats (PDF, DOCX, XLSX, PPTX, HTML, images)\n- Extracting text, tables, or key-value pairs from PDFs\n- OCR on scanned documents or images\n- Redacting PII before sharing documents\n- Adding watermarks to drafts or confidential documents\n- Digitally signing contracts or agreements\n- Filling PDF forms programmatically\n\n"
+    },
+    "nuxt4-patterns": {
+      "description": "Nuxt 4 app patterns for hydration safety, performance, route rules, lazy loading, and SSR-safe data fetching with useFetch and useAsyncData. Use when building or reviewing a Nuxt 4 app, or debugging hydration mismatches and SSR-safe data fetching.",
+      "name": "nuxt4-patterns",
+      "path": "ecc/nuxt4-patterns",
+      "routing_text": "nuxt4 patterns nuxt4 patterns Nuxt 4 app patterns for hydration safety, performance, route rules, lazy loading, and SSR-safe data fetching with useFetch and useAsyncData. Use when building or reviewing a Nuxt 4 app, or debugging hydration mismatches and SSR-safe data fetching. - Hydration mismatches between server HTML and client state\n- Route-level rendering decisions such as prerender, SWR, ISR, or client-only sections\n- Performance work around lazy loading, lazy hydration, or payload size\n- Page or component data fetching with `useFetch`, `useAsyncData`, or `$fetch`\n- Nuxt routing issues tied to route params, middleware, or SSR/client differences\n\n"
+    },
+    "openclaw-persona-forge": {
+      "description": "为 OpenClaw AI Agent 锻造完整的龙虾灵魂方案。根据用户偏好或随机抽卡， 输出身份定位、灵魂描述(SOUL.md)、角色化底线规则、名字和头像生图提示词。 如当前环境提供已审核的生图 skill，可自动生成统一风格头像图片。 当用户需要创建、设计或定制 OpenClaw 龙虾灵魂时使用。 不适用于：微调已有 SOUL.md、非 OpenClaw 平台的角色设计、纯工具型无性格 Agent。 触发词：龙虾灵魂、虾魂、OpenClaw 灵魂、养虾灵魂、龙虾角色、龙虾定位、 龙虾剧本杀角色、龙虾游戏角色、龙虾 NPC、龙虾性格、龙虾背景故事、 lobster soul、lobster character、抽卡、随机龙虾、龙虾 SOUL、gacha。 Use when creating, designing, or customizing an OpenClaw lobster persona — identity, SOUL.md, name, or avatar prompt.",
+      "name": "openclaw-persona-forge",
+      "path": "ecc/openclaw-persona-forge",
+      "routing_text": "openclaw persona forge openclaw persona forge 为 OpenClaw AI Agent 锻造完整的龙虾灵魂方案。根据用户偏好或随机抽卡， 输出身份定位、灵魂描述(SOUL.md)、角色化底线规则、名字和头像生图提示词。 如当前环境提供已审核的生图 skill，可自动生成统一风格头像图片。 当用户需要创建、设计或定制 OpenClaw 龙虾灵魂时使用。 不适用于：微调已有 SOUL.md、非 OpenClaw 平台的角色设计、纯工具型无性格 Agent。 触发词：龙虾灵魂、虾魂、OpenClaw 灵魂、养虾灵魂、龙虾角色、龙虾定位、 龙虾剧本杀角色、龙虾游戏角色、龙虾 NPC、龙虾性格、龙虾背景故事、 lobster soul、lobster character、抽卡、随机龙虾、龙虾 SOUL、gacha。 Use when creating, designing, or customizing an OpenClaw lobster persona — identity, SOUL.md, name, or avatar prompt. - 当用户需要从零创建 OpenClaw 龙虾灵魂、角色设定、SOUL.md 或 IDENTITY.md\n- 当用户想通过引导式问答或抽卡模式快速得到完整 persona 方案\n- 当用户已经有一个粗糙设定，但还缺名字、边界规则、头像提示词或成套输出文件\n\n### Avoid when\n\n- 用户只需微调已有 SOUL.md\n- 目标平台不是 OpenClaw，需要的是其他 Agent 框架专用格式\n- 用户需要纯工具型 Agent，不需要角色化灵魂\n\n"
+    },
+    "opensource-pipeline": {
+      "description": "Open-source pipeline: fork, sanitize, and package private projects for safe public release. Chains 3 agents (forker, sanitizer, packager). Triggers: '/opensource', 'open source this', 'make this public', 'prepare for open source'. Use when a private project must be forked, stripped of secrets, and packaged for public release.",
+      "name": "opensource-pipeline",
+      "path": "ecc/opensource-pipeline",
+      "routing_text": "opensource pipeline opensource pipeline Open-source pipeline: fork, sanitize, and package private projects for safe public release. Chains 3 agents (forker, sanitizer, packager). Triggers: '/opensource', 'open source this', 'make this public', 'prepare for open source'. Use when a private project must be forked, stripped of secrets, and packaged for public release. - User says \"open source this project\" or \"make this public\"\n- User wants to prepare a private repo for public release\n- User needs to strip secrets before pushing to GitHub\n- User invokes `/opensource fork`, `/opensource verify`, or `/opensource package`\n\n"
+    },
+    "orch-add-feature": {
+      "description": "Orchestrate building a brand-new feature end to end — research, plan, TDD implementation, review, and gated commit — by delegating each phase to the matching ECC agent. Use when adding a capability that does not exist yet.",
+      "name": "orch-add-feature",
+      "path": "ecc/orch-add-feature",
+      "routing_text": "orch add feature orch add feature Orchestrate building a brand-new feature end to end — research, plan, TDD implementation, review, and gated commit — by delegating each phase to the matching ECC agent. Use when adding a capability that does not exist yet. - The user wants a capability that does **not exist yet** (\"add\", \"build\",\n  \"implement\", \"support …\").\n- It is net-new behavior — not a correction (`orch-fix-defect`) and not an\n  alteration of existing behavior (`orch-change-feature`).\n\n"
+    },
+    "orch-build-mvp": {
+      "description": "Orchestrate bootstrapping a working MVP from a design or spec document — ingest the doc, plan thin vertical slices, scaffold the first end-to-end slice, then TDD-implement, review, and gated commit. Use to turn an SDD/PRD into a running starting point. Use when a design or spec document must become a running MVP through planned vertical slices.",
+      "name": "orch-build-mvp",
+      "path": "ecc/orch-build-mvp",
+      "routing_text": "orch build mvp orch build mvp Orchestrate bootstrapping a working MVP from a design or spec document — ingest the doc, plan thin vertical slices, scaffold the first end-to-end slice, then TDD-implement, review, and gated commit. Use to turn an SDD/PRD into a running starting point. Use when a design or spec document must become a running MVP through planned vertical slices. - The user has a **design / spec document** (SDD, PRD, system_design) and wants a\n  working vertical slice bootstrapped from it.\n- Takes a doc path as its argument, e.g. `civicpulse/docs/SDD-v0.6.md`.\n\n"
+    },
+    "orch-change-feature": {
+      "description": "Orchestrate altering an existing, working feature to new desired behavior — update its tests to the new spec, change the implementation to match, review, and gated commit. Use when behavior is not broken but should be different.",
+      "name": "orch-change-feature",
+      "path": "ecc/orch-change-feature",
+      "routing_text": "orch change feature orch change feature Orchestrate altering an existing, working feature to new desired behavior — update its tests to the new spec, change the implementation to match, review, and gated commit. Use when behavior is not broken but should be different. - An existing feature **works**, but the desired behavior is different (\"change\",\n  \"adjust\", \"make it also …\", \"instead of X do Y\").\n- Distinguish from siblings:\n  - **not** broken → not `orch-fix-defect` (no bug to reproduce).\n  - **not** new → not `orch-add-feature` (the capability already exists).\n\n"
+    },
+    "orch-fix-defect": {
+      "description": "Orchestrate fixing a bug — reproduce it as a failing regression test, fix to green, review, and gated commit — by delegating each phase to the matching ECC agent. Use when existing behavior is broken or wrong.",
+      "name": "orch-fix-defect",
+      "path": "ecc/orch-fix-defect",
+      "routing_text": "orch fix defect orch fix defect Orchestrate fixing a bug — reproduce it as a failing regression test, fix to green, review, and gated commit — by delegating each phase to the matching ECC agent. Use when existing behavior is broken or wrong. - Something is **broken**: wrong output, an error, a crash, a regression.\n- Distinguish from siblings:\n  - behavior is correct but you want it different → `orch-change-feature`.\n  - the capability does not exist yet → `orch-add-feature`.\n\n"
+    },
+    "orch-pipeline": {
+      "description": "Shared orchestration engine for the orch-* skill family. Defines the gated Research-Plan-TDD-Review-Commit pipeline, the size classifier, the agent map, and the two human gates that the orch-* operation skills delegate to. Not usually invoked directly. Not usually invoked directly; it applies when an orch-* skill delegates its gated Research-Plan-TDD-Review-Commit pipeline.",
+      "name": "orch-pipeline",
+      "path": "ecc/orch-pipeline",
+      "routing_text": "orch pipeline orch pipeline Shared orchestration engine for the orch-* skill family. Defines the gated Research-Plan-TDD-Review-Commit pipeline, the size classifier, the agent map, and the two human gates that the orch-* operation skills delegate to. Not usually invoked directly. Not usually invoked directly; it applies when an orch-* skill delegates its gated Research-Plan-TDD-Review-Commit pipeline. - Loaded indirectly whenever an `orch-*` operation skill runs.\n- Read directly only when adding a new operation to the family or tuning the\n  shared phases, gates, or agent map.\n\n"
+    },
+    "orch-refine-code": {
+      "description": "Orchestrate a behavior-preserving refactor — confirm tests are green, restructure without changing behavior, keep tests green, review, and gated commit. Use when the structure should improve but behavior must not change.",
+      "name": "orch-refine-code",
+      "path": "ecc/orch-refine-code",
+      "routing_text": "orch refine code orch refine code Orchestrate a behavior-preserving refactor — confirm tests are green, restructure without changing behavior, keep tests green, review, and gated commit. Use when the structure should improve but behavior must not change. - Same behavior, **better structure**: extract modules, remove duplication, kill\n  dead code, reduce nesting, rename for clarity.\n- Distinguish from siblings: if behavior is meant to change at all, this is the\n  wrong skill (`orch-change-feature` / `orch-fix-defect`).\n\n"
+    },
+    "parallel-execution-optimizer": {
+      "description": "Use when the user wants a task done much faster through parallel work, concurrent agents, batched tool calls, isolated worktrees, or many independent verification lanes without losing correctness.",
+      "name": "parallel-execution-optimizer",
+      "path": "ecc/parallel-execution-optimizer",
+      "routing_text": "parallel execution optimizer parallel execution optimizer Use when the user wants a task done much faster through parallel work, concurrent agents, batched tool calls, isolated worktrees, or many independent verification lanes without losing correctness."
+    },
+    "perl-patterns": {
+      "description": "Modern Perl 5.36+ idioms, best practices, and conventions for building robust, maintainable Perl applications. Use when writing or reviewing modern Perl 5.36+ code.",
+      "name": "perl-patterns",
+      "path": "ecc/perl-patterns",
+      "routing_text": "perl patterns perl patterns Modern Perl 5.36+ idioms, best practices, and conventions for building robust, maintainable Perl applications. Use when writing or reviewing modern Perl 5.36+ code. - Writing new Perl code or modules\n- Reviewing Perl code for idiom compliance\n- Refactoring legacy Perl to modern standards\n- Designing Perl module architecture\n- Migrating pre-5.36 code to modern Perl\n\n"
+    },
+    "perl-security": {
+      "description": "Comprehensive Perl security covering taint mode, input validation, safe process execution, DBI parameterized queries, web security (XSS/SQLi/CSRF), and perlcritic security policies. Use when reviewing Perl input handling, process execution, DBI queries, or web-facing code.",
+      "name": "perl-security",
+      "path": "ecc/perl-security",
+      "routing_text": "perl security perl security Comprehensive Perl security covering taint mode, input validation, safe process execution, DBI parameterized queries, web security (XSS/SQLi/CSRF), and perlcritic security policies. Use when reviewing Perl input handling, process execution, DBI queries, or web-facing code. - Handling user input in Perl applications\n- Building Perl web applications (CGI, Mojolicious, Dancer2, Catalyst)\n- Reviewing Perl code for security vulnerabilities\n- Performing file operations with user-supplied paths\n- Executing system commands from Perl\n- Writing DBI database queries\n\n"
+    },
+    "perl-testing": {
+      "description": "Perl testing patterns using Test2::V0, Test::More, prove runner, mocking, coverage with Devel::Cover, and TDD methodology. Use when writing Perl tests with Test2::V0 or Test::More, or measuring coverage.",
+      "name": "perl-testing",
+      "path": "ecc/perl-testing",
+      "routing_text": "perl testing perl testing Perl testing patterns using Test2::V0, Test::More, prove runner, mocking, coverage with Devel::Cover, and TDD methodology. Use when writing Perl tests with Test2::V0 or Test::More, or measuring coverage. - Writing new Perl code (follow TDD: red, green, refactor)\n- Designing test suites for Perl modules or applications\n- Reviewing Perl test coverage\n- Setting up Perl testing infrastructure\n- Migrating tests from Test::More to Test2::V0\n- Debugging failing Perl tests\n\n"
+    },
+    "plan-canvas": {
+      "description": "Open plans and HTML artifacts in a local browser canvas where the human annotates elements, chats, and approves or requests changes without leaving the page. Use when presenting a plan for review, or when feedback like \"move this, change that\" is easier pointed at than typed.",
+      "name": "plan-canvas",
+      "path": "ecc/plan-canvas",
+      "routing_text": "plan canvas plan canvas Open plans and HTML artifacts in a local browser canvas where the human annotates elements, chats, and approves or requests changes without leaving the page. Use when presenting a plan for review, or when feedback like \"move this, change that\" is easier pointed at than typed. - You just wrote a plan artifact (`.claude/plans/*.plan.md` from `/plan`) and\n  need the CONFIRM/approve decision — the canvas verdict replaces a typed\n  \"yes/proceed\".\n- The user should *point at* what to change: reviewing designs, comparisons,\n  reports, or any local `.md` / `.html` artifact.\n- The user asks for `/plan-canvas`, a visual review, or \"open it in the browser\".\n\nDo NOT use for: code review of diffs (`/code-review`), running web apps, or\nremote URLs. The canvas serves local artifact files only.\n\n"
+    },
+    "plan-orchestrate": {
+      "description": "Read a plan document, decompose it into steps, design a per-step agent chain from the ECC catalogue, and emit ready-to-paste /orchestrate custom prompts. Generative only — never invokes /orchestrate itself. Use when the user has a multi-step plan and wants to drive it through orchestrate without composing chains by hand.",
+      "name": "plan-orchestrate",
+      "path": "ecc/plan-orchestrate",
+      "routing_text": "plan orchestrate plan orchestrate Read a plan document, decompose it into steps, design a per-step agent chain from the ECC catalogue, and emit ready-to-paste /orchestrate custom prompts. Generative only — never invokes /orchestrate itself. Use when the user has a multi-step plan and wants to drive it through orchestrate without composing chains by hand. - User has a multi-step plan document (PRD, RFC, implementation plan) and wants to drive it through `/orchestrate`.\n- User says \"orchestrate this plan\", \"give me orchestrate prompts for each step\", \"compose chains for this plan\".\n- A step-by-step plan exists but the user does not want to manually pick agents per step.\n\nSkip when:\n- The work is one ad-hoc step → call `/orchestrate custom` directly.\n- The plan is unreadable or empty. Lack of explicit numbering alone is not a skip condition — see the \"No clear steps\" edge case below.\n\n"
+    },
+    "plankton-code-quality": {
+      "description": "Write-time code quality enforcement using Plankton — auto-formatting, linting, and Claude-powered fixes on every file edit via hooks. Use when setting up write-time formatting, linting, or auto-fix hooks on file edits.",
+      "name": "plankton-code-quality",
+      "path": "ecc/plankton-code-quality",
+      "routing_text": "plankton code quality plankton code quality Write-time code quality enforcement using Plankton — auto-formatting, linting, and Claude-powered fixes on every file edit via hooks. Use when setting up write-time formatting, linting, or auto-fix hooks on file edits. - You want automatic formatting and linting on every file edit (not just at commit time)\n- You need defense against agents modifying linter configs to pass instead of fixing code\n- You want tiered model routing for fixes (Haiku for simple style, Sonnet for logic, Opus for types)\n- You work with multiple languages (Python, TypeScript, Shell, YAML, JSON, TOML, Markdown, Dockerfile)\n\n"
+    },
+    "postgres-patterns": {
+      "description": "PostgreSQL database patterns for query optimization, schema design, indexing, and security. Based on Supabase best practices. Use when designing PostgreSQL schemas, indexes, or RLS policies, or when a query is too slow.",
+      "name": "postgres-patterns",
+      "path": "ecc/postgres-patterns",
+      "routing_text": "postgres patterns postgres patterns PostgreSQL database patterns for query optimization, schema design, indexing, and security. Based on Supabase best practices. Use when designing PostgreSQL schemas, indexes, or RLS policies, or when a query is too slow. - Writing SQL queries or migrations\n- Designing database schemas\n- Troubleshooting slow queries\n- Implementing Row Level Security\n- Setting up connection pooling\n\n"
+    },
+    "prediction-market-oracle-research": {
+      "description": "Research prediction markets as data sources or oracle signals for products, agents, dashboards, and corporate decision intelligence. Use for source-grounded analysis of market-implied probabilities, caveats, and integration patterns without investment advice. Use when evaluating prediction markets as a data source or oracle signal for a product, agent, or dashboard.",
+      "name": "prediction-market-oracle-research",
+      "path": "ecc/prediction-market-oracle-research",
+      "routing_text": "prediction market oracle research prediction market oracle research Research prediction markets as data sources or oracle signals for products, agents, dashboards, and corporate decision intelligence. Use for source-grounded analysis of market-implied probabilities, caveats, and integration patterns without investment advice. Use when evaluating prediction markets as a data source or oracle signal for a product, agent, or dashboard."
+    },
+    "prediction-market-risk-review": {
+      "description": "Review prediction-market, basket, oracle, and trading-agent workflows for compliance, safety, data-quality, privacy, and execution risk. Use before any workflow handles venue auth, user portfolio data, API keys, or trade planning.",
+      "name": "prediction-market-risk-review",
+      "path": "ecc/prediction-market-risk-review",
+      "routing_text": "prediction market risk review prediction market risk review Review prediction-market, basket, oracle, and trading-agent workflows for compliance, safety, data-quality, privacy, and execution risk. Use before any workflow handles venue auth, user portfolio data, API keys, or trade planning."
+    },
+    "prisma-patterns": {
+      "description": "Prisma ORM patterns for TypeScript backends — schema design, query optimization, transactions, pagination, and critical traps like updateMany returning count not records, $transaction timeouts, migrate dev resetting the DB, @updatedAt skipped on bulk writes, and serverless connection exhaustion. Use when writing a Prisma schema or query, or debugging transactions, migrations, or serverless connection limits.",
+      "name": "prisma-patterns",
+      "path": "ecc/prisma-patterns",
+      "routing_text": "prisma patterns prisma patterns Prisma ORM patterns for TypeScript backends — schema design, query optimization, transactions, pagination, and critical traps like updateMany returning count not records, $transaction timeouts, migrate dev resetting the DB, @updatedAt skipped on bulk writes, and serverless connection exhaustion. Use when writing a Prisma schema or query, or debugging transactions, migrations, or serverless connection limits. - Designing or modifying Prisma schema models and relations\n- Writing queries, transactions, or pagination logic\n- Using `updateMany`, `deleteMany`, or any bulk operation\n- Running or planning database migrations\n- Deploying to serverless environments (Vercel, Lambda, Cloudflare Workers)\n- Implementing soft delete or multi-tenant row filtering\n\n"
+    },
+    "product-capability": {
+      "description": "Translate PRD intent, roadmap asks, or product discussions into an implementation-ready capability plan that exposes constraints, invariants, interfaces, and unresolved decisions before multi-service work starts. Use when the user needs an ECC-native PRD-to-SRS lane instead of vague planning prose.",
+      "name": "product-capability",
+      "path": "ecc/product-capability",
+      "routing_text": "product capability product capability Translate PRD intent, roadmap asks, or product discussions into an implementation-ready capability plan that exposes constraints, invariants, interfaces, and unresolved decisions before multi-service work starts. Use when the user needs an ECC-native PRD-to-SRS lane instead of vague planning prose. - A PRD, roadmap item, discussion, or founder note exists, but the implementation constraints are still implicit\n- A feature crosses multiple services, repos, or teams and needs a capability contract before coding\n- Product intent is clear, but architecture, data, lifecycle, or policy implications are still fuzzy\n- Senior engineers keep restating the same hidden assumptions during review\n- You need a reusable artifact that can survive across harnesses and sessions\n\n"
+    },
+    "product-lens": {
+      "description": "Use this skill to validate the \"why\" before building, run product diagnostics, and pressure-test product direction before the request becomes an implementation contract.",
+      "name": "product-lens",
+      "path": "ecc/product-lens",
+      "routing_text": "product lens product lens Use this skill to validate the \"why\" before building, run product diagnostics, and pressure-test product direction before the request becomes an implementation contract. - Before starting any feature — validate the \"why\"\n- Weekly product review — are we building the right thing?\n- When stuck choosing between features\n- Before a launch — sanity check the user journey\n- When converting a vague idea into a product brief before engineering planning starts\n\n"
+    },
+    "production-audit": {
+      "description": "Local-evidence production readiness audit for shipped apps, pre-launch reviews, post-merge checks, and \"what breaks in prod?\" questions without sending repo data to an external audit service. Use when auditing production readiness before launch, after a merge, or when asked what breaks in prod.",
+      "name": "production-audit",
+      "path": "ecc/production-audit",
+      "routing_text": "production audit production audit Local-evidence production readiness audit for shipped apps, pre-launch reviews, post-merge checks, and \"what breaks in prod?\" questions without sending repo data to an external audit service. Use when auditing production readiness before launch, after a merge, or when asked what breaks in prod. - The user asks \"is this production-ready\", \"what would break in prod\", \"what\n  did we miss\", \"audit this repo\", or \"ready to ship?\"\n- A feature was merged and needs a pre-deploy or post-merge risk pass.\n- A public launch, demo, customer rollout, or investor walkthrough is close.\n- CI is green but the user wants production risk, not only test status.\n- A deployed URL, release branch, PR, or current checkout is available for\n  evidence gathering.\n\n"
+    },
+    "production-scheduling": {
+      "description": ">",
+      "name": "production-scheduling",
+      "path": "ecc/production-scheduling",
+      "routing_text": "production scheduling production scheduling > - Production orders compete for constrained work centers\n- Disruptions (breakdown, shortage, absenteeism) require rapid re-sequencing\n- Changeover and campaign trade-offs need explicit economic decisions\n- New work orders need to be slotted into an existing schedule without destabilizing committed jobs\n- Shift-level bottleneck changes require drum reassignment\n\n"
+    },
+    "project-flow-ops": {
+      "description": "Operate execution flow across GitHub and Linear by triaging issues and pull requests, linking active work, and keeping GitHub public-facing while Linear remains the internal execution layer. Use when the user wants backlog control, PR triage, or GitHub-to-Linear coordination.",
+      "name": "project-flow-ops",
+      "path": "ecc/project-flow-ops",
+      "routing_text": "project flow ops project flow ops Operate execution flow across GitHub and Linear by triaging issues and pull requests, linking active work, and keeping GitHub public-facing while Linear remains the internal execution layer. Use when the user wants backlog control, PR triage, or GitHub-to-Linear coordination. - Triage open PR or issue backlogs\n- Decide what belongs in Linear vs what should remain GitHub-only\n- Link active GitHub work to internal execution lanes\n- Classify PRs into merge, port/rebuild, close, or park\n- Audit whether review comments, CI failures, or stale issues are blocking execution\n\n"
+    },
+    "prompt-optimizer": {
+      "description": ">-",
+      "name": "prompt-optimizer",
+      "path": "ecc/prompt-optimizer",
+      "routing_text": "prompt optimizer prompt optimizer >- - User says \"optimize this prompt\", \"improve my prompt\", \"rewrite this prompt\"\n- User says \"help me write a better prompt for...\"\n- User says \"what's the best way to ask Claude Code to...\"\n- User says \"优化prompt\", \"改进prompt\", \"怎么写prompt\", \"帮我优化这个指令\"\n- User pastes a draft prompt and asks for feedback or enhancement\n- User says \"I don't know how to prompt for this\"\n- User says \"how should I use ECC for...\"\n- User explicitly invokes `/prompt-optimize`\n\n### Do Not Use When\n\n- User wants the task done directly (just execute it)\n- User says \"优化代码\", \"优化性能\", \"optimize this code\", \"optimize performance\" — these are refactoring tasks, not prompt optimization\n- User is asking about ECC configuration (use `configure-ecc` instead)\n- User wants a skill inventory (use `skill-stocktake` instead)\n- User says \"just do it\" or \"直接做\"\n\n"
+    },
+    "python-patterns": {
+      "description": "Pythonic idioms, PEP 8 standards, type hints, and best practices for building robust, efficient, and maintainable Python applications. Use when writing or reviewing Python code and idiomatic structure, typing, or PEP 8 is in question.",
+      "name": "python-patterns",
+      "path": "ecc/python-patterns",
+      "routing_text": "python patterns python patterns Pythonic idioms, PEP 8 standards, type hints, and best practices for building robust, efficient, and maintainable Python applications. Use when writing or reviewing Python code and idiomatic structure, typing, or PEP 8 is in question. - Writing new Python code\n- Reviewing Python code\n- Refactoring existing Python code\n- Designing Python packages/modules\n\n"
+    },
+    "python-testing": {
+      "description": "Python testing strategies using pytest, TDD methodology, fixtures, mocking, parametrization, and coverage requirements. Use when writing pytest tests — fixtures, mocks, parametrization, or coverage.",
+      "name": "python-testing",
+      "path": "ecc/python-testing",
+      "routing_text": "python testing python testing Python testing strategies using pytest, TDD methodology, fixtures, mocking, parametrization, and coverage requirements. Use when writing pytest tests — fixtures, mocks, parametrization, or coverage. - Writing new Python code (follow TDD: red, green, refactor)\n- Designing test suites for Python projects\n- Reviewing Python test coverage\n- Setting up testing infrastructure\n\n"
+    },
+    "pytorch-patterns": {
+      "description": "PyTorch deep learning patterns and best practices for building robust, efficient, and reproducible training pipelines, model architectures, and data loading. Use when writing or reviewing PyTorch training loops, model architectures, or data loading, or when a run will not reproduce.",
+      "name": "pytorch-patterns",
+      "path": "ecc/pytorch-patterns",
+      "routing_text": "pytorch patterns pytorch patterns PyTorch deep learning patterns and best practices for building robust, efficient, and reproducible training pipelines, model architectures, and data loading. Use when writing or reviewing PyTorch training loops, model architectures, or data loading, or when a run will not reproduce. - Writing new PyTorch models or training scripts\n- Reviewing deep learning code\n- Debugging training loops or data pipelines\n- Optimizing GPU memory usage or training speed\n- Setting up reproducible experiments\n\n"
+    },
+    "quality-nonconformance": {
+      "description": ">",
+      "name": "quality-nonconformance",
+      "path": "ecc/quality-nonconformance",
+      "routing_text": "quality nonconformance quality nonconformance > - Investigating a non-conformance (NCR) from incoming inspection, in-process, or final test\n- Performing root cause analysis using 5-Why, Ishikawa, or fault tree methods\n- Determining disposition for non-conforming material (use-as-is, rework, scrap, return to vendor)\n- Creating or reviewing a CAPA (Corrective and Preventive Action) plan\n- Interpreting SPC data and control chart signals for process stability assessment\n- Preparing for or responding to a regulatory audit finding\n\n"
+    },
+    "quarkus-patterns": {
+      "description": "Quarkus 3.x LTS architecture patterns with Camel for messaging, RESTful API design, CDI services, data access with Panache, and async processing. Use for Java Quarkus backend work with event-driven architectures. Use when building or reviewing a Quarkus service, especially with Camel messaging or Panache data access.",
+      "name": "quarkus-patterns",
+      "path": "ecc/quarkus-patterns",
+      "routing_text": "quarkus patterns quarkus patterns Quarkus 3.x LTS architecture patterns with Camel for messaging, RESTful API design, CDI services, data access with Panache, and async processing. Use for Java Quarkus backend work with event-driven architectures. Use when building or reviewing a Quarkus service, especially with Camel messaging or Panache data access. - Building REST APIs with JAX-RS or RESTEasy Reactive\n- Structuring resource → service → repository layers\n- Implementing event-driven patterns with Apache Camel and RabbitMQ\n- Configuring Hibernate Panache, caching, or reactive streams\n- Adding validation, exception mapping, or pagination\n- Setting up profiles for dev/staging/production environments (YAML config)\n- Custom logging with LogContext and Logback/Logstash encoder\n- Working with CompletableFuture for async operations\n- Implementing conditional flow processing\n- Working with GraalVM native compilation\n\n"
+    },
+    "quarkus-security": {
+      "description": "Quarkus Security best practices for authentication, authorization, JWT/OIDC, RBAC, input validation, CSRF, secrets management, and dependency security. Use when reviewing Quarkus authn/authz, JWT or OIDC, RBAC, validation, or secrets.",
+      "name": "quarkus-security",
+      "path": "ecc/quarkus-security",
+      "routing_text": "quarkus security quarkus security Quarkus Security best practices for authentication, authorization, JWT/OIDC, RBAC, input validation, CSRF, secrets management, and dependency security. Use when reviewing Quarkus authn/authz, JWT or OIDC, RBAC, validation, or secrets. - Adding authentication (JWT, OIDC, Basic Auth)\n- Implementing authorization with @RolesAllowed or SecurityIdentity\n- Validating user input (Bean Validation, custom validators)\n- Configuring CORS or security headers\n- Managing secrets (Vault, environment variables, config sources)\n- Adding rate limiting or brute-force protection\n- Scanning dependencies for CVEs\n- Working with MicroProfile JWT or SmallRye JWT\n\n"
+    },
+    "quarkus-tdd": {
+      "description": "Test-driven development for Quarkus 3.x LTS using JUnit 5, Mockito, REST Assured, Camel testing, and JaCoCo. Use when adding features, fixing bugs, or refactoring event-driven services.",
+      "name": "quarkus-tdd",
+      "path": "ecc/quarkus-tdd",
+      "routing_text": "quarkus tdd quarkus tdd Test-driven development for Quarkus 3.x LTS using JUnit 5, Mockito, REST Assured, Camel testing, and JaCoCo. Use when adding features, fixing bugs, or refactoring event-driven services. - New features or REST endpoints\n- Bug fixes or refactors\n- Adding data access logic, security rules, or reactive streams\n- Testing Apache Camel routes and event handlers\n- Testing event-driven services with RabbitMQ\n- Testing conditional flow logic\n- Validating CompletableFuture async operations\n- Testing LogContext propagation\n\n"
+    },
+    "quarkus-verification": {
+      "description": "Verification loop for Quarkus projects: build, static analysis, tests with coverage, security scans, native compilation, and diff review before release or PR.",
+      "name": "quarkus-verification",
+      "path": "ecc/quarkus-verification",
+      "routing_text": "quarkus verification quarkus verification Verification loop for Quarkus projects: build, static analysis, tests with coverage, security scans, native compilation, and diff review before release or PR. - Before opening a pull request for a Quarkus service\n- After major refactoring or dependency upgrades\n- Pre-deployment verification for staging or production\n- Running full build → lint → test → security scan → native compilation pipeline\n- Validating test coverage meets thresholds (80%+)\n- Testing native image compatibility\n\n"
+    },
+    "ralphinho-rfc-pipeline": {
+      "description": "RFC-driven multi-agent DAG execution pattern with quality gates, merge queues, and work unit orchestration. Use when running RFC-driven multi-agent execution with quality gates and a merge queue.",
+      "name": "ralphinho-rfc-pipeline",
+      "path": "ecc/ralphinho-rfc-pipeline",
+      "routing_text": "ralphinho rfc pipeline ralphinho rfc pipeline RFC-driven multi-agent DAG execution pattern with quality gates, merge queues, and work unit orchestration. Use when running RFC-driven multi-agent execution with quality gates and a merge queue."
+    },
+    "react-native-patterns": {
+      "description": "React Native and Expo app patterns — Expo Router navigation, state separation (server/client/route/form), TanStack Query data fetching with Zod, performant lists, NativeWind/StyleSheet styling, native APIs, and secure storage. Use when building or editing React Native / Expo screens, components, navigation, or data layers.",
+      "name": "react-native-patterns",
+      "path": "ecc/react-native-patterns",
+      "routing_text": "react native patterns react native patterns React Native and Expo app patterns — Expo Router navigation, state separation (server/client/route/form), TanStack Query data fetching with Zod, performant lists, NativeWind/StyleSheet styling, native APIs, and secure storage. Use when building or editing React Native / Expo screens, components, navigation, or data layers. Use this skill when:\n\n- Building or editing React Native / Expo screens, components, or navigation\n- Setting up routing with Expo Router (file-based `app/` directory)\n- Deciding where state belongs (server cache vs client store vs route params vs form)\n- Wiring data fetching with TanStack Query and validating responses with Zod\n- Rendering long or heavy lists\n- Choosing or applying a styling approach (NativeWind or StyleSheet)\n- Accessing native device APIs (camera, location, notifications) or secure storage\n- Reviewing RN code for mobile-specific issues\n\nDo NOT use the web/React-DOM patterns here — URL-as-state, `<div>`, and SWR-for-browser do not apply to React Native.\n\n"
+    },
+    "react-patterns": {
+      "description": "React 18/19 patterns including hooks discipline, server/client component boundaries, Suspense + error boundaries, form actions, data fetching, state management decision trees, and accessibility-first composition. Use when writing or reviewing React components.",
+      "name": "react-patterns",
+      "path": "ecc/react-patterns",
+      "routing_text": "react patterns react patterns React 18/19 patterns including hooks discipline, server/client component boundaries, Suspense + error boundaries, form actions, data fetching, state management decision trees, and accessibility-first composition. Use when writing or reviewing React components. - Writing or modifying React function components, custom hooks, or component trees\n- Reviewing JSX/TSX files\n- Designing state shape or component composition\n- Migrating class components or older `forwardRef`/`useEffect`-heavy code\n- Choosing between local state, lifted state, context, and external stores\n- Working with Server Components / Client Components (Next.js App Router, RSC)\n- Implementing forms with React 19 actions or controlled inputs\n- Wiring data fetching with TanStack Query / SWR / RSC\n\n"
+    },
+    "react-performance": {
+      "description": "React and Next.js performance optimization patterns adapted from Vercel Engineering's React Best Practices (https://github.com/vercel-labs/agent-skills). Organizes 70+ rules across 8 priority categories — waterfalls, bundle size, server-side, client fetching, re-render, rendering, JS micro-perf, advanced. Use when writing, reviewing, or refactoring React/Next.js code for performance.",
+      "name": "react-performance",
+      "path": "ecc/react-performance",
+      "routing_text": "react performance react performance React and Next.js performance optimization patterns adapted from Vercel Engineering's React Best Practices (https://github.com/vercel-labs/agent-skills). Organizes 70+ rules across 8 priority categories — waterfalls, bundle size, server-side, client fetching, re-render, rendering, JS micro-perf, advanced. Use when writing, reviewing, or refactoring React/Next.js code for performance. - Writing or reviewing React/Next.js code for performance\n- Diagnosing slow page loads, slow interactions, or high CPU on the client\n- Auditing bundle size or Lighthouse Core Web Vitals regressions\n- Removing waterfalls in Server Components / API routes\n- Reducing client-side re-renders\n- Optimizing long lists, animations, or hydration\n- Auditing optimization choices in PRs touching `app/`, `pages/`, `components/`, or data layers\n\n"
+    },
+    "react-testing": {
+      "description": "React component testing with React Testing Library, Vitest/Jest, MSW for network mocking, accessibility assertions with axe, and the decision boundary between component tests and Playwright/Cypress end-to-end runs. Use when writing or fixing tests for React components, hooks, or pages.",
+      "name": "react-testing",
+      "path": "ecc/react-testing",
+      "routing_text": "react testing react testing React component testing with React Testing Library, Vitest/Jest, MSW for network mocking, accessibility assertions with axe, and the decision boundary between component tests and Playwright/Cypress end-to-end runs. Use when writing or fixing tests for React components, hooks, or pages. - Writing tests for React components, custom hooks, or pages\n- Adding test coverage to legacy untested components\n- Migrating from Enzyme or class-component-era patterns to React Testing Library\n- Setting up Vitest or Jest for a new React project\n- Mocking HTTP requests in tests\n- Asserting accessibility violations\n- Deciding which tests belong in RTL vs Playwright Component Testing vs full E2E\n\n"
+    },
+    "recsys-pipeline-architect": {
+      "description": "Design composable recommendation, ranking, and feed pipelines using the six-stage Source→Hydrator→Filter→Scorer→Selector→SideEffect framework popularized by xAI's open-sourced For You algorithm. Use this skill whenever the user is building any system that picks \"the top K items for a (user, context)\" — social feeds, content CMSs, RAG rerankers, task prioritizers, notification triage, search reranking, ad ranking.",
+      "name": "recsys-pipeline-architect",
+      "path": "ecc/recsys-pipeline-architect",
+      "routing_text": "recsys pipeline architect recsys pipeline architect Design composable recommendation, ranking, and feed pipelines using the six-stage Source→Hydrator→Filter→Scorer→Selector→SideEffect framework popularized by xAI's open-sourced For You algorithm. Use this skill whenever the user is building any system that picks \"the top K items for a (user, context)\" — social feeds, content CMSs, RAG rerankers, task prioritizers, notification triage, search reranking, ad ranking. - User wants to build any system that picks \"the top K items for a user/context\"\n- User asks \"how should I rank X\" or describes a feed/personalization problem\n- User has a scoring function and needs the pipeline plumbing around it\n- User wants to migrate from a single relevance score to multi-action prediction with tunable weights\n- User is wrapping an LLM/ML scorer and needs filters, hydrators, side-effects, and a runnable scaffold in their stack (TypeScript / Go / Python)\n- Triggers: \"recommendation system\", \"feed algorithm\", \"ranking pipeline\", \"for you feed\", \"candidate pipeline\", \"content recommender\", \"pipeline architecture for recsys\", \"RAG retrieval reranker\"\n\n"
+    },
+    "recursive-decision-ledger": {
+      "description": "Use when the user asks for repeated rollouts, marked decision processes, high-dimensional search, stochastic optimization, local-optima exploration, ensemble comparison, or recursive reasoning with a visible evidence trail.",
+      "name": "recursive-decision-ledger",
+      "path": "ecc/recursive-decision-ledger",
+      "routing_text": "recursive decision ledger recursive decision ledger Use when the user asks for repeated rollouts, marked decision processes, high-dimensional search, stochastic optimization, local-optima exploration, ensemble comparison, or recursive reasoning with a visible evidence trail."
+    },
+    "redis-patterns": {
+      "description": "Redis data structure patterns, caching strategies, distributed locks, rate limiting, pub/sub, and connection management for production applications. Use when adding caching, a distributed lock, rate limiting, or pub/sub with Redis, or when key design needs review.",
+      "name": "redis-patterns",
+      "path": "ecc/redis-patterns",
+      "routing_text": "redis patterns redis patterns Redis data structure patterns, caching strategies, distributed locks, rate limiting, pub/sub, and connection management for production applications. Use when adding caching, a distributed lock, rate limiting, or pub/sub with Redis, or when key design needs review. - Adding caching to an application\n- Implementing rate limiting or throttling\n- Building distributed locks or coordination\n- Setting up session or token storage\n- Using Pub/Sub or Redis Streams for messaging\n- Configuring Redis in production (pooling, eviction, clustering)\n\n"
+    },
+    "regex-vs-llm-structured-text": {
+      "description": "Decision framework for choosing between regex and LLM when parsing structured text — start with regex, add LLM only for low-confidence edge cases.",
+      "name": "regex-vs-llm-structured-text",
+      "path": "ecc/regex-vs-llm-structured-text",
+      "routing_text": "regex vs llm structured text regex vs llm structured text Decision framework for choosing between regex and LLM when parsing structured text — start with regex, add LLM only for low-confidence edge cases. - Parsing structured text with repeating patterns (questions, forms, tables)\n- Deciding between regex and LLM for text extraction\n- Building hybrid pipelines that combine both approaches\n- Optimizing cost/accuracy tradeoffs in text processing\n\n"
+    },
+    "remotion-video-creation": {
+      "description": "Best practices for Remotion - Video creation in React. 29 domain-specific rules covering 3D, animations, audio, captions, charts, transitions, and more. Use when building video in React with Remotion — animations, audio, captions, charts, or transitions.",
+      "name": "remotion-video-creation",
+      "path": "ecc/remotion-video-creation",
+      "routing_text": "remotion video creation remotion video creation Best practices for Remotion - Video creation in React. 29 domain-specific rules covering 3D, animations, audio, captions, charts, transitions, and more. Use when building video in React with Remotion — animations, audio, captions, charts, or transitions. Use this skills whenever you are dealing with Remotion code to obtain the domain-specific knowledge.\n\n"
+    },
+    "repo-scan": {
+      "description": "Bootstrap pointer that installs the external repo-scan skill from a pinned, reviewable commit. Use when repo-scan must be installed before running its cross-stack source-code asset audit; this ECC pointer does not perform the audit itself.",
+      "name": "repo-scan",
+      "path": "ecc/repo-scan",
+      "routing_text": "repo scan repo scan Bootstrap pointer that installs the external repo-scan skill from a pinned, reviewable commit. Use when repo-scan must be installed before running its cross-stack source-code asset audit; this ECC pointer does not perform the audit itself. - Taking over a large legacy codebase and need a structural overview\n- Before major refactoring — identify what's core, what's duplicate, what's dead\n- Auditing third-party dependencies embedded directly in source (not declared in package managers)\n- Preparing architecture decision records for monorepo reorganization\n\n"
+    },
+    "research-ops": {
+      "description": "Evidence-first current-state research workflow for ECC. Use when the user wants fresh facts, comparisons, enrichment, or a recommendation built from current public evidence and any supplied local context.",
+      "name": "research-ops",
+      "path": "ecc/research-ops",
+      "routing_text": "research ops research ops Evidence-first current-state research workflow for ECC. Use when the user wants fresh facts, comparisons, enrichment, or a recommendation built from current public evidence and any supplied local context. - user says \"research\", \"look up\", \"compare\", \"who should I talk to\", or \"what's the latest\"\n- the answer depends on current public information\n- the user already supplied evidence and wants it factored into a fresh recommendation\n- the task may be recurring enough that it should become a monitor instead of a one-off lookup\n\n"
+    },
+    "returns-reverse-logistics": {
+      "description": ">",
+      "name": "returns-reverse-logistics",
+      "path": "ecc/returns-reverse-logistics",
+      "routing_text": "returns reverse logistics returns reverse logistics > - Processing return requests and determining RMA eligibility\n- Inspecting returned goods and assigning condition grades for disposition\n- Routing disposition decisions (restock, refurbish, liquidate, scrap, RTV)\n- Investigating return fraud patterns or abuse of return policies\n- Managing warranty claims and vendor recovery chargebacks\n\n"
+    },
+    "rules-distill": {
+      "description": "Scan skills to extract cross-cutting principles and distill them into rules — append, revise, or create new rule files. Use when the same principle keeps recurring across skills and belongs in a rule file instead.",
+      "name": "rules-distill",
+      "path": "ecc/rules-distill",
+      "routing_text": "rules distill rules distill Scan skills to extract cross-cutting principles and distill them into rules — append, revise, or create new rule files. Use when the same principle keeps recurring across skills and belongs in a rule file instead. - Periodic rules maintenance (monthly or after installing new skills)\n- After a skill-stocktake reveals patterns that should be rules\n- When rules feel incomplete relative to the skills being used\n\n"
+    },
+    "rust-patterns": {
+      "description": "Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for building safe, performant applications. Use when writing or reviewing Rust code and ownership, error handling, traits, or concurrency is in question.",
+      "name": "rust-patterns",
+      "path": "ecc/rust-patterns",
+      "routing_text": "rust patterns rust patterns Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for building safe, performant applications. Use when writing or reviewing Rust code and ownership, error handling, traits, or concurrency is in question. - Writing new Rust code\n- Reviewing Rust code\n- Refactoring existing Rust code\n- Designing crate structure and module layout\n\n"
+    },
+    "rust-testing": {
+      "description": "Rust testing patterns including unit tests, integration tests, async testing, property-based testing, mocking, and coverage. Follows TDD methodology. Use when writing Rust tests — unit, integration, async, property-based, or coverage.",
+      "name": "rust-testing",
+      "path": "ecc/rust-testing",
+      "routing_text": "rust testing rust testing Rust testing patterns including unit tests, integration tests, async testing, property-based testing, mocking, and coverage. Follows TDD methodology. Use when writing Rust tests — unit, integration, async, property-based, or coverage. - Writing new Rust functions, methods, or traits\n- Adding test coverage to existing code\n- Creating benchmarks for performance-critical code\n- Implementing property-based tests for input validation\n- Following TDD workflow in Rust projects\n\n"
+    },
+    "safety-guard": {
+      "description": "Use this skill to prevent destructive operations when working on production systems or running agents autonomously.",
+      "name": "safety-guard",
+      "path": "ecc/safety-guard",
+      "routing_text": "safety guard safety guard Use this skill to prevent destructive operations when working on production systems or running agents autonomously. - When working on production systems\n- When agents are running autonomously (full-auto mode)\n- When you want to restrict edits to a specific directory\n- During sensitive operations (migrations, deploys, data changes)\n\n"
+    },
+    "santa-method": {
+      "description": "Multi-agent adversarial verification with convergence loop. Two independent review agents must both pass before output ships. Use when output must clear two independent adversarial reviewers before it ships.",
+      "name": "santa-method",
+      "path": "ecc/santa-method",
+      "routing_text": "santa method santa method Multi-agent adversarial verification with convergence loop. Two independent review agents must both pass before output ships. Use when output must clear two independent adversarial reviewers before it ships. Invoke this skill when:\n- Output will be published, deployed, or consumed by end users\n- Compliance, regulatory, or brand constraints must be enforced\n- Code ships to production without human review\n- Content accuracy matters (technical docs, educational material, customer-facing copy)\n- Batch generation at scale where spot-checking misses systemic patterns\n- Hallucination risk is elevated (claims, statistics, API references, legal language)\n\nDo NOT use for internal drafts, exploratory research, or tasks with deterministic verification (use build/test/lint pipelines for those).\n\n"
+    },
+    "scientific-db-pubmed-database": {
+      "description": "Direct PubMed and NCBI E-utilities search workflows for biomedical literature, MeSH queries, PMID lookup, citation retrieval, and API-backed literature monitoring. Use when a task needs biomedical literature from PubMed rather than general web search.",
+      "name": "pubmed-database",
+      "path": "ecc/scientific-db-pubmed-database",
+      "routing_text": "scientific db pubmed database pubmed database Direct PubMed and NCBI E-utilities search workflows for biomedical literature, MeSH queries, PMID lookup, citation retrieval, and API-backed literature monitoring. Use when a task needs biomedical literature from PubMed rather than general web search. - Searching MEDLINE or life-sciences literature.\n- Building PubMed queries with MeSH terms, field tags, dates, or article types.\n- Looking up PMIDs, abstracts, publication metadata, or related citations.\n- Running systematic-review search passes that need repeatable search strings.\n- Using NCBI E-utilities directly from Python, shell, or another HTTP client.\n\n"
+    },
+    "scientific-db-uspto-database": {
+      "description": "USPTO patent and trademark data workflow for official record lookup, PatentSearch queries, TSDR checks, assignment data, and reproducible IP research logs. Use when a task needs official United States patent or trademark records from USPTO systems.",
+      "name": "uspto-database",
+      "path": "ecc/scientific-db-uspto-database",
+      "routing_text": "scientific db uspto database uspto database USPTO patent and trademark data workflow for official record lookup, PatentSearch queries, TSDR checks, assignment data, and reproducible IP research logs. Use when a task needs official United States patent or trademark records from USPTO systems. - Searching granted patents or pre-grant publications.\n- Checking patent application status, file-wrapper data, assignments, or\n  public prosecution history.\n- Looking up trademark status, documents, or assignment history.\n- Building reproducible prior-art, portfolio, or IP landscape research logs.\n- Comparing USPTO records with secondary tools such as Google Patents,\n  Lens.org, Semantic Scholar, or company patent pages.\n\nDo not use this skill to give legal advice. Treat it as a data-gathering and\nrecord-verification workflow.\n\n"
+    },
+    "scientific-pkg-gget": {
+      "description": "gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs. Use when a task needs quick bioinformatics lookup across genomic reference databases with the gget CLI or Python package.",
+      "name": "gget",
+      "path": "ecc/scientific-pkg-gget",
+      "routing_text": "scientific pkg gget gget gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs. Use when a task needs quick bioinformatics lookup across genomic reference databases with the gget CLI or Python package. - Finding Ensembl IDs, gene metadata, transcript details, or sequences.\n- Running quick BLAST or BLAT lookups without building a full local pipeline.\n- Fetching reference genome links and annotations from Ensembl.\n- Querying protein structure, pathway, cancer, expression, or disease-association\n  modules through a single interface.\n- Creating a reproducible first-pass evidence log before moving to heavier\n  tools such as Biopython, Snakemake, Nextflow, BLAST+, or database-specific\n  clients.\n\nUse a dedicated workflow instead of `gget` when the task requires regulated\nclinical interpretation, high-throughput production pipelines, or fine-grained\ncontrol over database versions and local indexes.\n\n"
+    },
+    "scientific-thinking-literature-review": {
+      "description": "Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging. Use when the task is to find, screen, synthesize, and cite a body of academic or technical literature.",
+      "name": "literature-review",
+      "path": "ecc/scientific-thinking-literature-review",
+      "routing_text": "scientific thinking literature review literature review Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging. Use when the task is to find, screen, synthesize, and cite a body of academic or technical literature. - Building a systematic, scoping, or narrative literature review.\n- Synthesizing the state of the art for a research question.\n- Finding gaps, contradictions, or future-work directions.\n- Preparing citation-backed background sections for papers or reports.\n- Comparing evidence across peer-reviewed papers, preprints, patents, and\n  technical reports.\n\n"
+    },
+    "scientific-thinking-scholar-evaluation": {
+      "description": "Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback. Use when evaluating academic or scientific work — papers, proposals, methods sections, or evidence quality — against a repeatable rubric.",
+      "name": "scholar-evaluation",
+      "path": "ecc/scientific-thinking-scholar-evaluation",
+      "routing_text": "scientific thinking scholar evaluation scholar evaluation Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback. Use when evaluating academic or scientific work — papers, proposals, methods sections, or evidence quality — against a repeatable rubric. - Reviewing a research paper, proposal, thesis chapter, or literature review.\n- Checking whether claims are supported by cited evidence.\n- Evaluating methodology, study design, analysis, or limitations.\n- Comparing two or more papers for quality or relevance.\n- Producing structured feedback for revision.\n\n"
+    },
+    "search-first": {
+      "description": "Research-before-coding workflow. Search for existing tools, libraries, and patterns before writing custom code. Invokes the researcher agent.",
+      "name": "search-first",
+      "path": "ecc/search-first",
+      "routing_text": "search first search first Research-before-coding workflow. Search for existing tools, libraries, and patterns before writing custom code. Invokes the researcher agent. Use this skill when:\n- Starting a new feature that likely has existing solutions\n- Adding a dependency or integration\n- The user asks \"add X functionality\" and you're about to write code\n- Before creating a new utility, helper, or abstraction\n\n"
+    },
+    "security-bounty-hunter": {
+      "description": "Hunt for exploitable, bounty-worthy security issues in repositories. Focuses on remotely reachable vulnerabilities that qualify for real reports instead of noisy local-only findings. Use when hunting reportable, remotely reachable vulnerabilities in a repository.",
+      "name": "security-bounty-hunter",
+      "path": "ecc/security-bounty-hunter",
+      "routing_text": "security bounty hunter security bounty hunter Hunt for exploitable, bounty-worthy security issues in repositories. Focuses on remotely reachable vulnerabilities that qualify for real reports instead of noisy local-only findings. Use when hunting reportable, remotely reachable vulnerabilities in a repository. - Scanning a repository for exploitable vulnerabilities\n- Preparing a Huntr, HackerOne, or similar bounty submission\n- Triage where the question is \"does this actually pay?\" rather than \"is this theoretically unsafe?\"\n\n"
+    },
+    "security-review": {
+      "description": "Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.",
+      "name": "security-review",
+      "path": "ecc/security-review",
+      "routing_text": "security review security review Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns. - Implementing authentication or authorization\n- Handling user input or file uploads\n- Creating new API endpoints\n- Working with secrets or credentials\n- Implementing payment features\n- Storing or transmitting sensitive data\n- Integrating third-party APIs\n\n"
+    },
+    "security-scan": {
+      "description": "Scan your Claude Code configuration (.claude/ directory) for security vulnerabilities, misconfigurations, and injection risks using AgentShield. Checks CLAUDE.md, settings.json, MCP servers, hooks, and agent definitions. Use when auditing a .claude/ directory — CLAUDE.md, settings.json, MCP servers, hooks, or agent definitions.",
+      "name": "security-scan",
+      "path": "ecc/security-scan",
+      "routing_text": "security scan security scan Scan your Claude Code configuration (.claude/ directory) for security vulnerabilities, misconfigurations, and injection risks using AgentShield. Checks CLAUDE.md, settings.json, MCP servers, hooks, and agent definitions. Use when auditing a .claude/ directory — CLAUDE.md, settings.json, MCP servers, hooks, or agent definitions. - Setting up a new Claude Code project\n- After modifying `.claude/settings.json`, `CLAUDE.md`, or MCP configs\n- Before committing configuration changes\n- When onboarding to a new repository with existing Claude Code configs\n- Periodic security hygiene checks\n\n"
+    },
+    "seo": {
+      "description": "Audit, plan, and implement SEO improvements across technical SEO, on-page optimization, structured data, Core Web Vitals, and content strategy. Use when the user wants better search visibility, SEO remediation, schema markup, sitemap/robots work, or keyword mapping.",
+      "name": "seo",
+      "path": "ecc/seo",
+      "routing_text": "seo seo Audit, plan, and implement SEO improvements across technical SEO, on-page optimization, structured data, Core Web Vitals, and content strategy. Use when the user wants better search visibility, SEO remediation, schema markup, sitemap/robots work, or keyword mapping. Use this skill when:\n- auditing crawlability, indexability, canonicals, or redirects\n- improving title tags, meta descriptions, and heading structure\n- adding or validating structured data\n- improving Core Web Vitals\n- doing keyword research and mapping keywords to URLs\n- planning internal linking or sitemap / robots changes\n\n"
+    },
+    "skill-comply": {
+      "description": "Visualize whether skills, rules, and agent definitions are actually followed — auto-generates scenarios at 3 prompt strictness levels, runs agents, classifies behavioral sequences, and reports compliance rates with full tool call timelines. Use when checking whether agents actually follow the skills, rules, and definitions they were given, rather than assuming they do.",
+      "name": "skill-comply",
+      "path": "ecc/skill-comply",
+      "routing_text": "skill comply skill comply Visualize whether skills, rules, and agent definitions are actually followed — auto-generates scenarios at 3 prompt strictness levels, runs agents, classifies behavioral sequences, and reports compliance rates with full tool call timelines. Use when checking whether agents actually follow the skills, rules, and definitions they were given, rather than assuming they do. - User runs `/skill-comply <path>`\n- User asks \"is this rule actually being followed?\"\n- After adding new rules/skills, to verify agent compliance\n- Periodically as part of quality maintenance\n\n"
+    },
+    "skill-scout": {
+      "description": "Search existing local, marketplace, GitHub, and web skill sources before creating a new skill. Use when the user wants to create, build, fork, or find a skill for a workflow.",
+      "name": "skill-scout",
+      "path": "ecc/skill-scout",
+      "routing_text": "skill scout skill scout Search existing local, marketplace, GitHub, and web skill sources before creating a new skill. Use when the user wants to create, build, fork, or find a skill for a workflow. - The user says \"create a skill\", \"build a skill\", \"make a skill\", or \"new\n  skill\".\n- The user asks \"is there a skill for X?\" or \"does a skill exist that does Y?\"\n- The user describes a workflow and you are about to suggest creating a new\n  skill.\n- The user wants to fork or extend an existing skill.\n\nIf the user explicitly says to skip search or create from scratch, acknowledge\nthat and proceed with the requested creation workflow.\n\n"
+    },
+    "skill-stocktake": {
+      "description": "Use when auditing Claude skills and commands for quality. Supports Quick Scan (changed skills only) and Full Stocktake modes with sequential subagent batch evaluation.",
+      "name": "skill-stocktake",
+      "path": "ecc/skill-stocktake",
+      "routing_text": "skill stocktake skill stocktake Use when auditing Claude skills and commands for quality. Supports Quick Scan (changed skills only) and Full Stocktake modes with sequential subagent batch evaluation."
+    },
+    "social-graph-ranker": {
+      "description": "Weighted social-graph ranking for warm intro discovery, bridge scoring, and network gap analysis across X and LinkedIn. Use when the user wants the reusable graph-ranking engine itself, not the broader outreach or network-maintenance workflow layered on top of it.",
+      "name": "social-graph-ranker",
+      "path": "ecc/social-graph-ranker",
+      "routing_text": "social graph ranker social graph ranker Weighted social-graph ranking for warm intro discovery, bridge scoring, and network gap analysis across X and LinkedIn. Use when the user wants the reusable graph-ranking engine itself, not the broader outreach or network-maintenance workflow layered on top of it."
+    },
+    "social-publisher": {
+      "description": "Agent-driven scheduling and publishing of social media posts across 13 platforms via SocialClaw. Use when the user wants to publish to X, LinkedIn, Instagram, Facebook Pages, TikTok, Discord, Telegram, YouTube, Reddit, WordPress, or Pinterest — or when managing campaigns, uploading media, or monitoring post delivery status.",
+      "name": "social-publisher",
+      "path": "ecc/social-publisher",
+      "routing_text": "social publisher social publisher Agent-driven scheduling and publishing of social media posts across 13 platforms via SocialClaw. Use when the user wants to publish to X, LinkedIn, Instagram, Facebook Pages, TikTok, Discord, Telegram, YouTube, Reddit, WordPress, or Pinterest — or when managing campaigns, uploading media, or monitoring post delivery status. - publish content to X, LinkedIn, Instagram, TikTok, or other platforms\n- schedule a post campaign across multiple platforms at once\n- upload media for use in social posts\n- validate a post schedule before going live\n- monitor publishing run status and delivery analytics\n\n"
+    },
+    "springboot-patterns": {
+      "description": "Spring Boot architecture patterns, REST API design, layered services, data access, caching, async processing, and logging. Use for Java Spring Boot backend work. Use when building or reviewing a Spring Boot backend — REST layer, services, data access, caching, or async work.",
+      "name": "springboot-patterns",
+      "path": "ecc/springboot-patterns",
+      "routing_text": "springboot patterns springboot patterns Spring Boot architecture patterns, REST API design, layered services, data access, caching, async processing, and logging. Use for Java Spring Boot backend work. Use when building or reviewing a Spring Boot backend — REST layer, services, data access, caching, or async work. - Building REST APIs with Spring MVC or WebFlux\n- Structuring controller → service → repository layers\n- Configuring Spring Data JPA, caching, or async processing\n- Adding validation, exception handling, or pagination\n- Setting up profiles for dev/staging/production environments\n- Implementing event-driven patterns with Spring Events or Kafka\n\n"
+    },
+    "springboot-security": {
+      "description": "Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services. Use when reviewing Spring Security authn/authz, validation, CSRF, secrets, headers, or rate limiting.",
+      "name": "springboot-security",
+      "path": "ecc/springboot-security",
+      "routing_text": "springboot security springboot security Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services. Use when reviewing Spring Security authn/authz, validation, CSRF, secrets, headers, or rate limiting. - Adding authentication (JWT, OAuth2, session-based)\n- Implementing authorization (@PreAuthorize, role-based access)\n- Validating user input (Bean Validation, custom validators)\n- Configuring CORS, CSRF, or security headers\n- Managing secrets (Vault, environment variables)\n- Adding rate limiting or brute-force protection\n- Scanning dependencies for CVEs\n\n"
+    },
+    "springboot-tdd": {
+      "description": "Test-driven development for Spring Boot using JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo. Use when adding features, fixing bugs, or refactoring.",
+      "name": "springboot-tdd",
+      "path": "ecc/springboot-tdd",
+      "routing_text": "springboot tdd springboot tdd Test-driven development for Spring Boot using JUnit 5, Mockito, MockMvc, Testcontainers, and JaCoCo. Use when adding features, fixing bugs, or refactoring. - New features or endpoints\n- Bug fixes or refactors\n- Adding data access logic or security rules\n\n"
+    },
+    "springboot-verification": {
+      "description": "Verification loop for Spring Boot projects: build, static analysis, tests with coverage, security scans, and diff review before release or PR.",
+      "name": "springboot-verification",
+      "path": "ecc/springboot-verification",
+      "routing_text": "springboot verification springboot verification Verification loop for Spring Boot projects: build, static analysis, tests with coverage, security scans, and diff review before release or PR. - Before opening a pull request for a Spring Boot service\n- After major refactoring or dependency upgrades\n- Pre-deployment verification for staging or production\n- Running full build → lint → test → security scan pipeline\n- Validating test coverage meets thresholds\n\n"
+    },
+    "strategic-compact": {
+      "description": "Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction. Use when a session is approaching a context limit and a task phase is a natural place to compact.",
+      "name": "strategic-compact",
+      "path": "ecc/strategic-compact",
+      "routing_text": "strategic compact strategic compact Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction. Use when a session is approaching a context limit and a task phase is a natural place to compact. - Running long sessions that approach context limits (200K+ tokens)\n- Working on multi-phase tasks (research → plan → implement → test)\n- Switching between unrelated tasks within the same session\n- After completing a major milestone and starting new work\n- When responses slow down or become less coherent (context pressure)\n\n"
+    },
+    "swift-actor-persistence": {
+      "description": "Thread-safe data persistence in Swift using actors — in-memory cache with file-backed storage, eliminating data races by design. Use when persisting data in Swift and a data race or thread-safety problem needs designing out.",
+      "name": "swift-actor-persistence",
+      "path": "ecc/swift-actor-persistence",
+      "routing_text": "swift actor persistence swift actor persistence Thread-safe data persistence in Swift using actors — in-memory cache with file-backed storage, eliminating data races by design. Use when persisting data in Swift and a data race or thread-safety problem needs designing out. - Building a data persistence layer in Swift 5.5+\n- Need thread-safe access to shared mutable state\n- Want to eliminate manual synchronization (locks, DispatchQueues)\n- Building offline-first apps with local storage\n\n"
+    },
+    "swift-concurrency-6-2": {
+      "description": "Swift 6.2 Approachable Concurrency — single-threaded by default, @concurrent for explicit background offloading, isolated conformances for main actor types. Use when adopting Swift 6.2 concurrency — offloading with @concurrent or resolving main-actor isolation.",
+      "name": "swift-concurrency-6-2",
+      "path": "ecc/swift-concurrency-6-2",
+      "routing_text": "swift concurrency 6 2 swift concurrency 6 2 Swift 6.2 Approachable Concurrency — single-threaded by default, @concurrent for explicit background offloading, isolated conformances for main actor types. Use when adopting Swift 6.2 concurrency — offloading with @concurrent or resolving main-actor isolation. - Migrating Swift 5.x or 6.0/6.1 projects to Swift 6.2\n- Resolving data-race safety compiler errors\n- Designing MainActor-based app architecture\n- Offloading CPU-intensive work to background threads\n- Implementing protocol conformances on MainActor-isolated types\n- Enabling Approachable Concurrency build settings in Xcode 26\n\n"
+    },
+    "swift-protocol-di-testing": {
+      "description": "Protocol-based dependency injection for testable Swift code — mock file system, network, and external APIs using focused protocols and Swift Testing. Use when Swift code needs testing and file system, network, or external APIs must be mocked.",
+      "name": "swift-protocol-di-testing",
+      "path": "ecc/swift-protocol-di-testing",
+      "routing_text": "swift protocol di testing swift protocol di testing Protocol-based dependency injection for testable Swift code — mock file system, network, and external APIs using focused protocols and Swift Testing. Use when Swift code needs testing and file system, network, or external APIs must be mocked. - Writing Swift code that accesses file system, network, or external APIs\n- Need to test error handling paths without triggering real failures\n- Building modules that work across environments (app, test, SwiftUI preview)\n- Designing testable architecture with Swift concurrency (actors, Sendable)\n\n"
+    },
+    "swiftui-patterns": {
+      "description": "SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices. Use when building or reviewing SwiftUI views, @Observable state, navigation, or render performance.",
+      "name": "swiftui-patterns",
+      "path": "ecc/swiftui-patterns",
+      "routing_text": "swiftui patterns swiftui patterns SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices. Use when building or reviewing SwiftUI views, @Observable state, navigation, or render performance. - Building SwiftUI views and managing state (`@State`, `@Observable`, `@Binding`)\n- Designing navigation flows with `NavigationStack`\n- Structuring view models and data flow\n- Optimizing rendering performance for lists and complex layouts\n- Working with environment values and dependency injection in SwiftUI\n\n"
+    },
+    "taste": {
+      "description": "A creative-direction (taste) layer for music videos and short-form edits in the angelcore / cloud-trance / hyperpop visual family. Distills a named-genre aesthetic vocabulary, a mood + color + light system, and a beat-synced editing grammar, then chains ECC's video skills (video-editing, fal-ai-media, remotion-video-creation, motion-*, content-engine) into one production pipeline. Use when the work is not just making a video function but making it feel intentional, when building a music video, a fancam/edit, a moodboard-driven reel, or when choosing a coherent visual direction for AI-generated b-roll.",
+      "name": "taste",
+      "path": "ecc/taste",
+      "routing_text": "taste taste A creative-direction (taste) layer for music videos and short-form edits in the angelcore / cloud-trance / hyperpop visual family. Distills a named-genre aesthetic vocabulary, a mood + color + light system, and a beat-synced editing grammar, then chains ECC's video skills (video-editing, fal-ai-media, remotion-video-creation, motion-*, content-engine) into one production pipeline. Use when the work is not just making a video function but making it feel intentional, when building a music video, a fancam/edit, a moodboard-driven reel, or when choosing a coherent visual direction for AI-generated b-roll. - Building a **music video**, lyric video, fancam, or visualizer.\n- Making a short-form **edit / reel** where the *feel* matters more than the information.\n- Driving **AI b-roll generation** (fal.ai, Veo, Kling, etc.) and the prompts need a\n  coherent direction instead of one-off vibes.\n- Assembling a **moodboard** or choosing a visual genre before any rendering.\n- The user says \"taste\", \"make it feel like X\", \"give it a direction\", \"angelcore\",\n  \"cloud trance\", \"hyperpop edit\", \"Bladee\", \"dreamcore\", or names a saved reference.\n- The current edit works but reads as flat, generic, AI-slop, or stylistically incoherent.\n\nThis skill sits **on top of** `video-editing` (the mechanics) and `remotion-video-creation`\n(the renderer). Use those for *how*. Use this for *what and why*.\n\n"
+    },
+    "tasteforge-video": {
+      "description": "Use for file-driven multimodal image, video, and 3D-asset discovery; taste interviews; distill or apply workflows; style-pack validation; editable EDL/FCPXML export; provenance audits; and offline planning that must fail closed before provider generation.",
+      "name": "tasteforge-video",
+      "path": "ecc/tasteforge-video",
+      "routing_text": "tasteforge video tasteforge video Use for file-driven multimodal image, video, and 3D-asset discovery; taste interviews; distill or apply workflows; style-pack validation; editable EDL/FCPXML export; provenance audits; and offline planning that must fail closed before provider generation. - The user asks to **interview for video taste** before any footage is made\n  (\"ask me about the look\", \"interview me about aesthetic direction\").\n- The user wants to **distill an aesthetic into structured constraints** — a\n  reusable style pack rather than vibes (\"turn these references into a pack\").\n- The user wants to **validate a style pack** (is the metadata complete,\n  schema-valid, cadence measured, spec distilled?).\n- The user wants to **apply a style pack to local footage** — plan a cut from\n  the pack's measured cadence over local clips, deterministically.\n- The user wants to **export EDL/FCPXML** — an editable, frame-exact handoff\n  to DaVinci Resolve / Premiere / Final Cut.\n- The user asks for a **generated-media provenance audit** — where did this\n  pack, spec, or cut come from; what was measured locally versus generated by\n  a provider; what was dry-run.\n- The user asks to **discover or plan file-driven multimodal image, video, or\n  3D-asset outputs** from local reference files, including separate manifests,\n  subject-anchored CV effects, or Resolve effect recipes.\n- The user mentions TasteForge, style packs, flashethereal, taste distillation,\n  cadence/rhythm planning, multimodal discovery, distill/apply workflows, or a\n  taste interview for video.\n\n"
+    },
+    "tdd-workflow": {
+      "description": "Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests.",
+      "name": "tdd-workflow",
+      "path": "ecc/tdd-workflow",
+      "routing_text": "tdd workflow tdd workflow Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests. - Writing new features or functionality\n- Fixing bugs or issues\n- Refactoring existing code\n- Adding API endpoints\n- Creating new components\n- Continuing from a `/plan` output or another `*.plan.md` implementation plan\n\n"
+    },
+    "team-agent-orchestration": {
+      "description": "Run team-based orchestration for agent squads using work items, ownership, agent Kanban, merge gates, and control pane handoffs. Use when coordinating an agent squad with work items, ownership, Kanban, and merge gates.",
+      "name": "team-agent-orchestration",
+      "path": "ecc/team-agent-orchestration",
+      "routing_text": "team agent orchestration team agent orchestration Run team-based orchestration for agent squads using work items, ownership, agent Kanban, merge gates, and control pane handoffs. Use when coordinating an agent squad with work items, ownership, Kanban, and merge gates. - The task spans multiple agents, tools, harnesses, branches, or worktrees.\n- The user mentions team orchestration, agent Kanban, squad, conductor, control pane, manager, desktop app, Zellij, tmux, Hermes, Devin, Codex, Claude Code, or multi-agent work.\n- A project needs shared workflow state across people and agents.\n- Existing agent fan-out is producing output but not mergeable product.\n\n"
+    },
+    "team-builder": {
+      "description": "Interactive agent picker for composing and dispatching parallel teams. Use when composing and dispatching a parallel team of agents for a task.",
+      "name": "team-builder",
+      "path": "ecc/team-builder",
+      "routing_text": "team builder team builder Interactive agent picker for composing and dispatching parallel teams. Use when composing and dispatching a parallel team of agents for a task. - You have multiple agent personas (markdown files) and want to pick which ones to use for a task\n- You want to compose an ad-hoc team from different domains (e.g., Security + SEO + Architecture)\n- You want to browse what agents are available before deciding\n\n"
+    },
+    "terminal-opener": {
+      "description": "Open an executable and its argument array in a visible terminal window through a reusable, shell-free launch plan with dry-run, JSON, capability detection, detached fallback, and standalone recovery modes. Use when Codex needs to open an interactive CLI, SSH session, local development process, sandbox, or other argv-based command in a new host terminal; diagnose whether a supported terminal is available; or provide an actionable plan when the requested terminal is unsupported.",
+      "name": "terminal-opener",
+      "path": "ecc/terminal-opener",
+      "routing_text": "terminal opener terminal opener Open an executable and its argument array in a visible terminal window through a reusable, shell-free launch plan with dry-run, JSON, capability detection, detached fallback, and standalone recovery modes. Use when Codex needs to open an interactive CLI, SSH session, local development process, sandbox, or other argv-based command in a new host terminal; diagnose whether a supported terminal is available; or provide an actionable plan when the requested terminal is unsupported."
+    },
+    "terminal-ops": {
+      "description": "Evidence-first repo execution workflow for ECC. Use when the user wants a command run, a repo checked, a CI failure debugged, or a narrow fix pushed with exact proof of what was executed and verified.",
+      "name": "terminal-ops",
+      "path": "ecc/terminal-ops",
+      "routing_text": "terminal ops terminal ops Evidence-first repo execution workflow for ECC. Use when the user wants a command run, a repo checked, a CI failure debugged, or a narrow fix pushed with exact proof of what was executed and verified. - user says \"fix\", \"debug\", \"run this\", \"check the repo\", or \"push it\"\n- the task depends on command output, git state, test results, or a verified local fix\n- the answer must distinguish changed locally, verified locally, committed, and pushed\n\n"
+    },
+    "tinystruct-patterns": {
+      "description": "Expert guidance for developing with the tinystruct Java framework. Use when working on the tinystruct codebase or any project built on tinystruct — including creating Application classes, @Action-mapped routes, unit tests, ActionRegistry, HTTP/CLI dual-mode handling, the built-in HTTP server, the event system, JSON with Builder/Builders, database persistence with AbstractData, POJO generation, Server-Sent Events (SSE), file uploads, and outbound HTTP networking.",
+      "name": "tinystruct-patterns",
+      "path": "ecc/tinystruct-patterns",
+      "routing_text": "tinystruct patterns tinystruct patterns Expert guidance for developing with the tinystruct Java framework. Use when working on the tinystruct codebase or any project built on tinystruct — including creating Application classes, @Action-mapped routes, unit tests, ActionRegistry, HTTP/CLI dual-mode handling, the built-in HTTP server, the event system, JSON with Builder/Builders, database persistence with AbstractData, POJO generation, Server-Sent Events (SSE), file uploads, and outbound HTTP networking. ### When to Use\n\n- Creating new `Application` modules by extending `AbstractApplication`.\n- Defining routes and command-line actions using `@Action`.\n- Handling per-request state via `Context`.\n- Performing JSON serialization using the native `Builder` and `Builders` components.\n- Working with database persistence via `AbstractData` POJOs.\n- Generating POJOs from database tables using the `generate` command.\n- Implementing Server-Sent Events (SSE) for real-time push.\n- Handling file uploads via multipart data.\n- Making outbound HTTP requests with `URLRequest` and `HTTPHandler`.\n- Configuring database connections or system settings in `application.properties`.\n- Debugging routing conflicts (Actions) or CLI argument parsing.\n\n"
+    },
+    "token-budget-advisor": {
+      "description": ">-",
+      "name": "token-budget-advisor",
+      "path": "ecc/token-budget-advisor",
+      "routing_text": "token budget advisor token budget advisor >- - User wants to control how long or detailed a response is\n- User mentions tokens, budget, depth, or response length\n- User says \"short version\", \"tldr\", \"brief\", \"al 25%\", \"exhaustive\", etc.\n- Any time the user wants to choose depth/detail level upfront\n\n**Do not trigger** when: user already set a level this session (maintain it silently), or the answer is trivially one line.\n\n"
+    },
+    "ui-demo": {
+      "description": "Record polished UI demo videos using Playwright. Use when the user asks to create a demo, walkthrough, screen recording, or tutorial video of a web application. Produces WebM videos with visible cursor, natural pacing, and professional feel.",
+      "name": "ui-demo",
+      "path": "ecc/ui-demo",
+      "routing_text": "ui demo ui demo Record polished UI demo videos using Playwright. Use when the user asks to create a demo, walkthrough, screen recording, or tutorial video of a web application. Produces WebM videos with visible cursor, natural pacing, and professional feel. - User asks for a \"demo video\", \"screen recording\", \"walkthrough\", or \"tutorial\"\n- User wants to showcase a feature or workflow visually\n- User needs a video for documentation, onboarding, or stakeholder presentation\n\n"
+    },
+    "ui-to-vue": {
+      "description": "Use when the user has UI screenshots or design exports that need batch conversion into Vue 3 components, especially with Vant, Element Plus, or Ant Design Vue.",
+      "name": "ui-to-vue",
+      "path": "ecc/ui-to-vue",
+      "routing_text": "ui to vue ui to vue Use when the user has UI screenshots or design exports that need batch conversion into Vue 3 components, especially with Vant, Element Plus, or Ant Design Vue. - The user provides a directory of design screenshots or design-export images.\n- The target application is Vue 3.\n- The user wants a first pass of page components, shared components, and router wiring.\n- The user specifies Vant, Element Plus, or Ant Design Vue as the component library.\n\n"
+    },
+    "uncloud": {
+      "description": "Use when managing an Uncloud cluster — deploying services, configuring Caddy ingress, adding static proxy routes for non-cluster devices, publishing ports, scaling, inspecting logs, or managing machines and volumes with the `uc` CLI.",
+      "name": "uncloud",
+      "path": "ecc/uncloud",
+      "routing_text": "uncloud uncloud Use when managing an Uncloud cluster — deploying services, configuring Caddy ingress, adding static proxy routes for non-cluster devices, publishing ports, scaling, inspecting logs, or managing machines and volumes with the `uc` CLI. Use this skill when working with Uncloud clusters, especially when:\n- Bootstrapping or joining machines with `uc machine`\n- Deploying services from Compose files with `uc deploy`\n- Publishing HTTP, HTTPS, TCP, or UDP ports through Uncloud\n- Configuring Caddy ingress with `x-caddy`, `x-ports`, or `--caddyfile`\n- Routing external LAN devices through the cluster proxy\n- Inspecting logs, service state, volumes, DNS, or machine placement\n\n"
+    },
+    "unified-memory": {
+      "description": "Share durable, inspectable context and handoffs between Claude, Codex, Hermes, Cursor, OpenCode, and other agents through the local ECC Memory Vault. Use when an agent must save work state, transfer context, resume another agent's task, or search shared project knowledge.",
+      "name": "unified-memory",
+      "path": "ecc/unified-memory",
+      "routing_text": "unified memory unified memory Share durable, inspectable context and handoffs between Claude, Codex, Hermes, Cursor, OpenCode, and other agents through the local ECC Memory Vault. Use when an agent must save work state, transfer context, resume another agent's task, or search shared project knowledge. - Save durable context that another agent or later session will need.\n- Hand work from Claude to Codex, Hermes to Claude, or any other harness pair.\n- Resume a task and search for prior decisions, facts, lessons, or handoffs.\n- Diagnose malformed memories, broken links, duplicate IDs, or skipped\n  symbolic links.\n\nDo not use the vault as a task tracker, secret store, policy engine, or\nsubstitute for governed project documentation.\n\n"
+    },
+    "unified-notifications-ops": {
+      "description": "Operate notifications as one ECC-native workflow across GitHub, Linear, desktop alerts, hooks, and connected communication surfaces. Use when the real problem is alert routing, deduplication, escalation, or inbox collapse.",
+      "name": "unified-notifications-ops",
+      "path": "ecc/unified-notifications-ops",
+      "routing_text": "unified notifications ops unified notifications ops Operate notifications as one ECC-native workflow across GitHub, Linear, desktop alerts, hooks, and connected communication surfaces. Use when the real problem is alert routing, deduplication, escalation, or inbox collapse. - the user wants a unified notification lane across GitHub, Linear, local hooks, desktop alerts, chat, or email\n- CI failures, review requests, issue updates, and operator events are arriving in disconnected places\n- the current setup creates noise instead of action\n- the user wants to consolidate overlapping notification branches or backlog proposals into one ECC-native lane\n- the workspace already has hooks, MCPs, or connected tools, but no coherent notification policy\n\n"
+    },
+    "verification-loop": {
+      "description": "A comprehensive verification system for Claude Code sessions. Use when verifying a Claude Code session's work before claiming it is complete.",
+      "name": "verification-loop",
+      "path": "ecc/verification-loop",
+      "routing_text": "verification loop verification loop A comprehensive verification system for Claude Code sessions. Use when verifying a Claude Code session's work before claiming it is complete. Invoke this skill:\n- After completing a feature or significant code change\n- Before creating a PR\n- When you want to ensure quality gates pass\n- After refactoring\n\n"
+    },
+    "video-editing": {
+      "description": "AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.",
+      "name": "video-editing",
+      "path": "ecc/video-editing",
+      "routing_text": "video editing video editing AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content. - User wants to edit, cut, or structure video footage\n- Turning long recordings into short-form content\n- Building vlogs, tutorials, or demo videos from raw capture\n- Adding overlays, subtitles, music, or voiceover to existing video\n- Reframing video for different platforms (YouTube, TikTok, Instagram)\n- User says \"edit video\", \"cut this footage\", \"make a vlog\", or \"video workflow\"\n\n"
+    },
+    "videodb": {
+      "description": "See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture. Use when ingesting, indexing, searching, editing, transcoding, or alerting on video or audio content.",
+      "name": "videodb",
+      "path": "ecc/videodb",
+      "routing_text": "videodb videodb See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture. Use when ingesting, indexing, searching, editing, transcoding, or alerting on video or audio content. ### Desktop Perception\n- Start/stop a **desktop session** capturing **screen, mic, and system audio**\n- Stream **live context** and store **episodic session memory**\n- Run **real-time alerts/triggers** on what's spoken and what's happening on screen\n- Produce **session summaries**, a searchable timeline, and **playable evidence links**\n\n### Video ingest + stream\n- Ingest a **file or URL** and return a **playable web stream link**\n- Transcode/normalize: **codec, bitrate, fps, resolution, aspect ratio**\n\n### Index + search (timestamps + evidence)\n- Build **visual**, **spoken**, and **keyword** indexes\n- Search and return exact moments with **timestamps** and **playable evidence**\n- Auto-create **clips** from search results\n\n### Timeline editing + generation\n- Subtitles: **generate**, **translate**, **burn-in**\n- Overlays: **text/image/branding**, motion captions\n- Audio: **background music**, **voiceover**, **dubbing**\n- Programmatic composition and exports via **timeline operations**\n\n### Live streams (RTSP) + monitoring\n- Connect **RTSP/live feeds**\n- Run **real-time visual and spoken understanding** and emit **events/alerts** for monitoring workflows\n\n"
+    },
+    "visa-doc-translate": {
+      "description": "Translate visa application documents (images) to English and create a bilingual PDF with original and translation. Use when visa application document images must be translated to English as a bilingual PDF.",
+      "name": "visa-doc-translate",
+      "path": "ecc/visa-doc-translate",
+      "routing_text": "visa doc translate visa doc translate Translate visa application documents (images) to English and create a bilingual PDF with original and translation. Use when visa application document images must be translated to English as a bilingual PDF."
+    },
+    "vite-patterns": {
+      "description": "Vite build tool patterns including config, plugins, HMR, env variables, proxy setup, SSR, library mode, dependency pre-bundling, and build optimization. Activate when working with vite.config.ts, Vite plugins, or Vite-based projects.",
+      "name": "vite-patterns",
+      "path": "ecc/vite-patterns",
+      "routing_text": "vite patterns vite patterns Vite build tool patterns including config, plugins, HMR, env variables, proxy setup, SSR, library mode, dependency pre-bundling, and build optimization. Activate when working with vite.config.ts, Vite plugins, or Vite-based projects. - Configuring `vite.config.ts` or `vite.config.js`\n- Setting up environment variables or `.env` files\n- Configuring dev server proxy for API backends\n- Optimizing build output (chunks, minification, assets)\n- Publishing libraries with `build.lib`\n- Troubleshooting dependency pre-bundling or CJS/ESM interop\n- Debugging HMR, dev server, or build errors\n- Choosing or ordering Vite plugins\n\n"
+    },
+    "vue-patterns": {
+      "description": "Vue.js 3 Composition API patterns, component architecture, reactivity best practices, Pinia state management, Vue Router navigation, and Nuxt SSR patterns. Activates for Vue, Nuxt, Vite, or Pinia projects. Use when building or reviewing Vue 3, Nuxt, or Pinia code — Composition API, reactivity, or router navigation.",
+      "name": "vue-patterns",
+      "path": "ecc/vue-patterns",
+      "routing_text": "vue patterns vue patterns Vue.js 3 Composition API patterns, component architecture, reactivity best practices, Pinia state management, Vue Router navigation, and Nuxt SSR patterns. Activates for Vue, Nuxt, Vite, or Pinia projects. Use when building or reviewing Vue 3, Nuxt, or Pinia code — Composition API, reactivity, or router navigation. Activate this skill when:\n- The project uses Vue.js (any version), Nuxt, Vite + Vue, or Pinia.\n- The user asks about Vue component architecture, composables, reactivity, or state management.\n- Reviewing Vue Single-File Components (`.vue` files).\n- Setting up Vue Router, Pinia stores, or Vite/Vitest configuration.\n- Discussing Vue-specific performance, security, or SSR patterns.\n\n---\n\n"
+    },
+    "windows-desktop-e2e": {
+      "description": "E2E testing for Windows native desktop apps (WPF, WinForms, Win32/MFC, Qt) using pywinauto and Windows UI Automation. Use when writing E2E tests for a Windows native desktop app with pywinauto or UI Automation.",
+      "name": "windows-desktop-e2e",
+      "path": "ecc/windows-desktop-e2e",
+      "routing_text": "windows desktop e2e windows desktop e2e E2E testing for Windows native desktop apps (WPF, WinForms, Win32/MFC, Qt) using pywinauto and Windows UI Automation. Use when writing E2E tests for a Windows native desktop app with pywinauto or UI Automation. - Writing or running E2E tests for a Windows native desktop application\n- Setting up a desktop GUI test suite from scratch\n- Diagnosing flaky or failing desktop automation tests\n- Adding testability (AutomationId, accessible names) to an existing app\n- Integrating desktop E2E into a CI/CD pipeline (GitHub Actions `windows-latest`)\n\n### When NOT to Use\n\n- Web applications → use `e2e-testing` skill (Playwright)\n- Electron / CEF / WebView2 apps → the HTML layer needs browser automation, not UIA\n- Mobile apps → use platform-specific tools (UIAutomator, XCUITest)\n- Pure unit or integration tests that don't need a running GUI\n\n"
+    },
+    "workspace-surface-audit": {
+      "description": "Audit the active repo, MCP servers, plugins, connectors, env surfaces, and harness setup, then recommend the highest-value ECC-native skills, hooks, agents, and operator workflows. Use when the user wants help setting up Claude Code or understanding what capabilities are actually available in their environment.",
+      "name": "workspace-surface-audit",
+      "path": "ecc/workspace-surface-audit",
+      "routing_text": "workspace surface audit workspace surface audit Audit the active repo, MCP servers, plugins, connectors, env surfaces, and harness setup, then recommend the highest-value ECC-native skills, hooks, agents, and operator workflows. Use when the user wants help setting up Claude Code or understanding what capabilities are actually available in their environment. - User says \"set up Claude Code\", \"recommend automations\", \"what plugins or MCPs should I use?\", or \"what am I missing?\"\n- Auditing a machine or repo before installing more skills, hooks, or connectors\n- Comparing official marketplace plugins against ECC-native coverage\n- Reviewing `.env`, `.mcp.json`, plugin settings, or connected-app surfaces to find missing workflow layers\n- Deciding whether a capability should be a skill, hook, agent, MCP, or external connector\n\n"
+    },
+    "x-api": {
+      "description": "X/Twitter API integration for posting tweets, threads, reading timelines, search, and analytics. Covers OAuth auth patterns, rate limits, and platform-native content posting. Use when the user wants to interact with X programmatically.",
+      "name": "x-api",
+      "path": "ecc/x-api",
+      "routing_text": "x api x api X/Twitter API integration for posting tweets, threads, reading timelines, search, and analytics. Covers OAuth auth patterns, rate limits, and platform-native content posting. Use when the user wants to interact with X programmatically. - User wants to post tweets or threads programmatically\n- Reading timeline, mentions, or user data from X\n- Searching X for content, trends, or conversations\n- Building X integrations or bots\n- Analytics and engagement tracking\n- User says \"post to X\", \"tweet\", \"X API\", or \"Twitter API\"\n\n"
+    }
+  },
+  "source": "https://github.com/affaan-m/ECC",
+  "synced_at": "2026-09-08",
+  "version": 1
+}