ecc

Plugin ecc in GimoXagros/ai-work-skills. Commands read from the repo's manifest — 8 days ago.

Skills (200)

• 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.

• 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.

• 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.

• 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 credibili

• 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.

• benchmark-methodology

  Use after competitive-platform-analysis has produced a tiered competitor set. Scores each competitor across nine weighted dimensions (positioning, voice, visual craft, offer packaging, evidence, enterprise-readiness, thought leadership, pricing, client's strategic tension) with explicit 1–5 rubrics

• brand-discovery

  Use when a brand needs to discover or articulate its identity through structured multi-session interviews. Covers purpose, positioning, audience, personality, voice, narrative, and founder-brand tension across 8 modules using laddering, 5 Whys, and projective techniques. Produces a resumable session

• 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.

• bun-runtime

  Bun as runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes, and Vercel support.

• 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.

• competitive-platform-analysis

  Use when scoping a competitive landscape — identifying, categorising, and score-filtering a competitor set before any benchmarking begins. Decides who counts as a competitor, which tier they belong to, and which sources to mine. First step in the three-skill competitive pipeline; precedes benchmark-

• competitive-report-structure

  Use after benchmark-methodology has produced scored competitor profile cards. Assembles findings into a decision-grade report: landscape map, competitor profiles, benchmarking matrix, white-space analysis, strategic recommendations, and team alignment trigger questions. Final step in the three-skill

• 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.

• 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.

• 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.

• 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.

• 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).

• 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-conventions

  Development conventions and patterns for ECC. JavaScript project with conventional commits.

• 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.

• 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.

• 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.

• 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.

• 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 abstra

• 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 fu

• 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.

• 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.

• 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.

• 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.

• nextjs-turbopack

  Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• verification-loop

  A comprehensive verification system for Claude Code sessions. Use when verifying a Claude Code session's work before claiming it is complete.

• 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

• 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.

• agentic-engineering

  Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when AI agents perform most implementation work and humans enforce quality and risk controls. origin: ECC

• autonomous-loops

  Patterns and architectures for autonomous Claude Code loops — from simple sequential pipelines to RFC-driven multi-agent DAG systems.

• content-hash-cache-pattern

  Cache expensive file processing results using SHA-256 content hashes — path-independent, auto-invalidating, with service layer separation.

• 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.

• cpp-testing

  Use only when writing/updating/fixing C++ tests, configuring GoogleTest/CTest, diagnosing failing or flaky tests, or adding coverage/sanitizers.

• database-migrations

  Database migration best practices for schema changes, data migrations, rollbacks, and zero-downtime deployments across PostgreSQL, MySQL, and common ORMs (Prisma, Drizzle, Django, TypeORM, golang-migrate). Use when planning or implementing database schema changes. origin: ECC

• 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 deployment infrastructure or planning releases. origin: ECC

• django-patterns

  Django architecture patterns, REST API design with DRF, ORM best practices, caching, signals, middleware, and production-grade Django apps.

• django-security

  Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations.

• docker-patterns

  Docker and Docker Compose patterns for local development, container security, networking, volume strategies, and multi-service orchestration. Use when setting up containerized development environments or reviewing Docker configurations. origin: ECC

• fastapi-patterns

  FastAPI patterns for async APIs, dependency injection, Pydantic request and response models, OpenAPI docs, tests, security, and production readiness.

• golang-patterns

  Go-specific design patterns and best practices including functional options, small interfaces, dependency injection, concurrency patterns, error handling, and package organization. Use when working with Go code to apply idiomatic Go patterns. origin: ECC globs: ["**/*.go", "**/go.mod", "**/go.sum"]

• golang-testing

  Go testing best practices including table-driven tests, test helpers, benchmarking, race detection, coverage analysis, and integration testing patterns. Use when writing or improving Go tests. origin: ECC globs: ["**/*.go", "**/go.mod", "**/go.sum"]

• 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.

• jpa-patterns

  JPA/Hibernate patterns for entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and pooling in Spring Boot.

• kotlin-patterns

  Idiomatic Kotlin patterns, best practices, and conventions for building robust, efficient, and maintainable Kotlin applications with coroutines, null safety, and DSL builders.

• kotlin-testing

  Kotlin testing patterns with Kotest, MockK, coroutine testing, property-based testing, and Kover coverage. Follows TDD methodology with idiomatic Kotlin practices.

• nestjs-patterns

  NestJS architecture patterns for modules, controllers, providers, DTO validation, guards, interceptors, config, and production-grade TypeScript backends.

• postgres-patterns

  PostgreSQL database patterns for query optimization, schema design, indexing, and security. Quick reference for common patterns, index types, data types, and anti-pattern detection. Based on Supabase best practices. origin: ECC credit: Supabase team (MIT License)

• python-patterns

  Python-specific design patterns and best practices including protocols, dataclasses, context managers, decorators, async/await, type hints, and package organization. Use when working with Python code to apply Pythonic patterns. origin: ECC globs: ["**/*.py", "**/*.pyi"]

• python-testing

  Python testing best practices using pytest including fixtures, parametrization, mocking, coverage analysis, async testing, and test organization. Use when writing or improving Python tests. origin: ECC globs: ["**/*.py", "**/*.pyi"]

• pytorch-patterns

  PyTorch deep learning patterns and best practices for building robust, efficient, and reproducible training pipelines, model architectures, and data loading.

• react-patterns
• react-testing
• rust-patterns
• rust-testing
• search-first
• springboot-patterns
• springboot-security
• swift-actor-persistence
• swift-protocol-di-testing
• continuous-learning-v2
• continuous-learning
• laravel-patterns
• laravel-security
• laravel-tdd
• laravel-verification
• quarkus-patterns
• quarkus-security
• quarkus-tdd
• quarkus-verification
• springboot-tdd
• springboot-verification
• accessibility
• agent-architecture-audit
• agent-eval
• agent-harness-construction
• agent-payment-x402
• agentic-os
• ai-first-engineering
• ai-regression-testing
• android-clean-architecture
• angular-developer
• api-connector-builder
• architecture-decision-records
• automation-audit-ops
• autonomous-agent-harness
• benchmark
• blueprint
• browser-qa
• canary-watch
• carrier-relationship-management
• cisco-ios-patterns
• ck
• claude-devfleet
• click-path-audit
• clickhouse-io
• code-tour
• codebase-onboarding
• compose-multiplatform-patterns
• configure-ecc
• connections-optimizer
• context-budget
• continuous-agent-loop
• cost-aware-llm-pipeline
• cost-tracking
• council
• csharp-testing
• customer-billing-ops
• customs-trade-compliance
• dart-flutter-patterns
• dashboard-builder
• data-scraper-agent
• defi-amm-security
• design-system
• django-celery
• django-tdd
• django-verification
• dotnet-patterns
• ecc-guide
• ecc-tools-cost-audit
• email-ops
• energy-procurement
• enterprise-agent-ops
• error-handling
• evm-token-decimals
• finance-billing-ops
• flox-environments
• flutter-dart-code-review
• foundation-models-on-device
• frontend-design-direction
• fsharp-testing
• gan-style-harness
• gateguard
• git-workflow
• github-ops
• google-workspace-ops
• healthcare-cdss-patterns
• healthcare-emr-patterns
• healthcare-eval-harness
• healthcare-phi-compliance
• hermes-imports
• hexagonal-architecture
• hipaa-compliance
• homelab-network-readiness
• homelab-network-setup
• homelab-pihole-dns
• homelab-vlan-segmentation
• homelab-wireguard-vpn
• hookify-rules
• inventory-demand-planning
• ios-icon-gen
• iterative-retrieval
• jira-integration
• knowledge-ops
• kotlin-coroutines-flows
• kotlin-exposed-patterns
• kotlin-ktor-patterns
• laravel-plugin-discovery
• lead-intelligence
• liquid-glass-design
• llm-trading-agent-security
• logistics-exception-management
• make-interfaces-feel-better
• manim-video
• messages-ops
• motion-advanced
• motion-foundations
• motion-patterns
• mysql-patterns
• nanoclaw-repl
• netmiko-ssh-automation
• network-bgp-diagnostics
• network-config-validation
• network-interface-health
• nodejs-keccak256
• nutrient-document-processing
• nuxt4-patterns
• openclaw-persona-forge
• opensource-pipeline
• perl-patterns
• perl-security
• perl-testing
• plan-orchestrate
• plankton-code-quality
• product-lens
• production-audit
• production-scheduling
• project-flow-ops
• project-guidelines-example
• prompt-optimizer

Slash commands (94)

• /ecc:aside
• /ecc:auto-update
• /ecc:build-fix
• /ecc:checkpoint
• /ecc:code-review
• /ecc:cost-report
• /ecc:cpp-build
• /ecc:cpp-review
• /ecc:cpp-test
• /ecc:ecc-guide
• /ecc:epic-claim
• /ecc:epic-decompose
• /ecc:epic-publish
• /ecc:epic-review
• /ecc:epic-sync
• /ecc:epic-unblock
• /ecc:epic-validate
• /ecc:evolve
• /ecc:fastapi-review
• /ecc:feature-dev
• /ecc:flutter-build
• /ecc:flutter-review
• /ecc:flutter-test
• /ecc:gan-build
• /ecc:gan-design
• /ecc:go-build
• /ecc:go-review
• /ecc:go-test
• /ecc:gradle-build
• /ecc:harness-audit
• /ecc:hookify-configure
• /ecc:hookify-help
• /ecc:hookify-list
• /ecc:hookify
• /ecc:instinct-export
• /ecc:instinct-import
• /ecc:instinct-status
• /ecc:jira
• /ecc:kotlin-build
• /ecc:kotlin-review
• /ecc:kotlin-test
• /ecc:learn-eval
• /ecc:learn
• /ecc:loop-start
• /ecc:loop-status
• /ecc:marketing-campaign
• /ecc:model-route
• /ecc:multi-backend
• /ecc:multi-execute
• /ecc:multi-frontend
• /ecc:multi-plan
• /ecc:multi-workflow
• /ecc:orch-add-feature
• /ecc:orch-build-mvp
• /ecc:orch-change-feature
• /ecc:orch-fix-defect
• /ecc:orch-refine-code
• /ecc:orch-review
• /ecc:plan-canvas
• /ecc:plan-prd
• /ecc:plan
• /ecc:pm2
• /ecc:pr
• /ecc:project-init
• /ecc:projects
• /ecc:promote
• /ecc:prp-commit
• /ecc:prp-implement
• /ecc:prp-plan
• /ecc:prp-pr
• /ecc:prp-prd
• /ecc:prune
• /ecc:python-review
• /ecc:quality-gate
• /ecc:react-build
• /ecc:react-review
• /ecc:react-test
• /ecc:refactor-clean
• /ecc:resume-session
• /ecc:review-pr
• /ecc:rust-build
• /ecc:rust-review
• /ecc:rust-test
• /ecc:santa-loop
• /ecc:save-session
• /ecc:security-scan
• /ecc:sessions
• /ecc:setup-pm
• /ecc:skill-create
• /ecc:skill-health
• /ecc:test-coverage
• /ecc:update-codemaps
• /ecc:update-docs
• /ecc:vue-review

Subagents (68)

• a11y-architect
• agent-evaluator
• architect
• build-error-resolver
• chief-of-staff
• code-architect
• code-explorer
• code-reviewer
• code-simplifier
• comment-analyzer
• conversation-analyzer
• cpp-build-resolver
• cpp-reviewer
• csharp-reviewer
• dart-build-resolver
• database-reviewer
• django-build-resolver
• django-reviewer
• doc-updater
• docs-lookup
• e2e-runner
• fastapi-reviewer
• flutter-reviewer
• fsharp-reviewer
• gan-evaluator
• gan-generator
• gan-planner
• go-build-resolver
• go-reviewer
• harmonyos-app-resolver
• harness-optimizer
• healthcare-reviewer
• homelab-architect
• java-build-resolver
• java-reviewer
• kotlin-build-resolver
• kotlin-reviewer
• loop-operator
• marketing-agent
• mle-reviewer
• network-architect
• network-config-reviewer
• network-troubleshooter
• opensource-forker
• opensource-packager
• opensource-sanitizer
• performance-optimizer
• php-reviewer
• planner
• pr-test-analyzer
• python-reviewer
• pytorch-build-resolver
• rag-pipeline-reviewer
• react-build-resolver
• react-reviewer
• refactor-cleaner
• rust-build-resolver
• rust-reviewer
• security-reviewer
• seo-specialist
• silent-failure-hunter
• spec-miner
• swift-build-resolver
• swift-reviewer
• tdd-guide
• type-design-analyzer
• typescript-reviewer
• vue-reviewer

MCP servers (1)

• chrome-devtools

  runs: npx -y [email protected]

Hooks (24)

• PreToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PreToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PreToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PreToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PreToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PreToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PreToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PreToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PreToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PreCompact

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• SessionStart

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• SessionStart

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PostToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PostToolUse

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PostToolUseFailure

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• PostToolUseFailure

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• Stop

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• Stop

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• Stop

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• Stop

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• Stop

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• Stop

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• Stop

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

• SessionEnd

  node -e "const p=require('path');const r=(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),

Similar plugins