feat: consolidate all Anthropic plugins into ECC v2.0.0

Ports functionality from 10+ separate plugins into ECC so users only
need one plugin installed. Consolidates: pr-review-toolkit, feature-dev,
commit-commands, hookify, code-simplifier, security-guidance,
frontend-design, explanatory-output-style, and personal skills.

New agents (8): code-architect, code-explorer, code-simplifier,
comment-analyzer, conversation-analyzer, pr-test-analyzer,
silent-failure-hunter, type-design-analyzer

New commands (9): commit, commit-push-pr, clean-gone, review-pr,
feature-dev, hookify, hookify-list, hookify-configure, hookify-help

New skills (8): frontend-design, hookify-rules, github-ops,
knowledge-ops, lead-intelligence, oura-health, pmx-guidelines, remotion

Enhanced skills (8): article-writing, content-engine, market-research,
investor-materials, investor-outreach, x-api, security-scan,
autonomous-loops — merged with personal skill content

New hook: security-reminder.py (pattern-based OWASP vulnerability
warnings on file edits)

Totals: 36 agents, 69 commands, 128 skills, 29 hook scripts

commands/clean-gone.md

@@ -0,0 +1,30 @@
+---
+description: Cleans up all git branches marked as [gone] (branches deleted on remote but still exist locally), including removing associated worktrees
+---
+
+Clean up stale local branches that have been deleted on the remote.
+
+## Steps
+
+1. Fetch and prune remote tracking refs:
+   ```bash
+   git fetch --prune
+   ```
+
+2. Find branches marked as [gone]:
+   ```bash
+   git branch -vv | grep ': gone]' | awk '{print $1}'
+   ```
+
+3. For each gone branch, remove associated worktrees if any:
+   ```bash
+   git worktree list
+   git worktree remove <path> --force
+   ```
+
+4. Delete the gone branches:
+   ```bash
+   git branch -D <branch-name>
+   ```
+
+5. Report what was cleaned up

commands/commit-push-pr.md

@@ -0,0 +1,30 @@
+---
+description: Commit, push, and open a PR
+---
+
+Commit all changes, push to remote, and create a pull request in one workflow.
+
+## Steps
+
+1. Run in parallel: `git status`, `git diff`, `git log --oneline -5`, check current branch tracking
+2. Stage and commit changes following conventional commit format
+3. Create a new branch if on main/master: `git checkout -b <descriptive-branch-name>`
+4. Push to remote with `-u` flag: `git push -u origin <branch>`
+5. Create PR using gh CLI:
+   ```bash
+   gh pr create --title "short title" --body "$(cat <<'EOF'
+   ## Summary
+   <1-3 bullet points>
+
+   ## Test plan
+   - [ ] Testing checklist items
+   EOF
+   )"
+   ```
+6. Return the PR URL
+
+**Rules:**
+- Keep PR title under 70 characters
+- Analyze ALL commits in the branch (not just the latest)
+- Never force push
+- Never skip hooks

commands/commit.md

@@ -0,0 +1,28 @@
+---
+description: Create a git commit
+---
+
+Create a single git commit from staged and unstaged changes with an appropriate message.
+
+## Steps
+
+1. Run `git status` (never use `-uall` flag) and `git diff` in parallel to see all changes
+2. Run `git log --oneline -5` to match commit message style
+3. Analyze changes and draft a concise commit message following conventional commits format: `<type>: <description>`
+   - Types: feat, fix, refactor, docs, test, chore, perf, ci
+   - Focus on "why" not "what"
+4. Stage relevant files (prefer specific files over `git add -A`)
+5. Create the commit using a HEREDOC for the message:
+   ```bash
+   git commit -m "$(cat <<'EOF'
+   type: description
+   EOF
+   )"
+   ```
+6. Run `git status` to verify success
+
+**Rules:**
+- Never skip hooks (--no-verify) or bypass signing
+- Never amend existing commits unless explicitly asked
+- Do not commit files that likely contain secrets (.env, credentials.json)
+- If pre-commit hook fails, fix the issue and create a NEW commit

commands/feature-dev.md

@@ -0,0 +1,45 @@
+---
+description: Guided feature development with codebase understanding and architecture focus
+---
+
+A structured 7-phase feature development workflow that emphasizes understanding existing code before writing new code.
+
+## Phases
+
+### Phase 1: Discovery
+- Read the user's feature request carefully
+- Identify key requirements, constraints, and acceptance criteria
+- Ask clarifying questions if the request is ambiguous
+
+### Phase 2: Codebase Exploration
+- Use the **code-explorer** agent to deeply analyze relevant existing code
+- Trace execution paths and map architecture layers
+- Understand existing patterns, abstractions, and conventions
+- Document dependencies and integration points
+
+### Phase 3: Clarifying Questions
+- Present findings from exploration to the user
+- Ask targeted questions about design decisions, edge cases, and preferences
+- **Wait for user response before proceeding**
+
+### Phase 4: Architecture Design
+- Use the **code-architect** agent to design the feature architecture
+- Provide implementation blueprint: files to create/modify, component designs, data flows
+- Present the plan to the user for approval
+- **Wait for user approval before implementing**
+
+### Phase 5: Implementation
+- Implement the feature following the approved architecture
+- Use TDD approach: write tests first, then implementation
+- Follow existing codebase patterns and conventions
+- Make small, focused commits
+
+### Phase 6: Quality Review
+- Use the **code-reviewer** agent to review the implementation
+- Address Critical and Important issues
+- Verify test coverage meets requirements
+
+### Phase 7: Summary
+- Summarize what was built and how it integrates
+- List any follow-up items or known limitations
+- Provide testing instructions

commands/hookify-configure.md

@@ -0,0 +1,14 @@
+---
+description: Enable or disable hookify rules interactively
+---
+
+Interactively enable or disable existing hookify rules.
+
+## Steps
+
+1. Find all `.claude/hookify.*.local.md` files
+2. Read current state of each rule
+3. Present list with current enabled/disabled status
+4. Ask user which rules to toggle
+5. Update the `enabled:` field in selected rule files
+6. Confirm changes

commands/hookify-help.md

@@ -0,0 +1,42 @@
+---
+description: Get help with the hookify system
+---
+
+Display comprehensive hookify documentation.
+
+## Hook System Overview
+
+Hookify creates rule files that integrate with Claude Code's hook system to prevent unwanted behaviors.
+
+### Event Types
+- **bash**: Triggers on Bash tool use — match command patterns
+- **file**: Triggers on Write/Edit tool use — match file paths
+- **stop**: Triggers when session ends — final checks
+- **prompt**: Triggers on user message submission — match input patterns
+- **all**: Triggers on all events
+
+### Rule File Format
+Files are stored as `.claude/hookify.{name}.local.md`:
+
+```yaml
+---
+name: descriptive-name
+enabled: true
+event: bash|file|stop|prompt|all
+action: block|warn
+pattern: "regex pattern to match"
+---
+Message to display when rule triggers.
+Supports multiple lines.
+```
+
+### Commands
+- `/hookify [description]` — Create new rules (auto-analyzes conversation if no args)
+- `/hookify-list` — View all rules
+- `/hookify-configure` — Toggle rules on/off
+
+### Pattern Tips
+- Use regex syntax (pipes for OR, brackets for groups)
+- For bash: match against the full command string
+- For file: match against the file path
+- Test patterns before deploying

commands/hookify-list.md

@@ -0,0 +1,16 @@
+---
+description: List all configured hookify rules
+---
+
+Find and display all hookify rules in a formatted table.
+
+## Steps
+
+1. Find all `.claude/hookify.*.local.md` files using Glob
+2. Read each file's frontmatter (name, enabled, event, action, pattern)
+3. Display as table:
+
+| Rule | Enabled | Event | Pattern | File |
+|------|---------|-------|---------|------|
+
+4. Show count and helpful footer about `/hookify-configure` for modifications

commands/hookify.md

@@ -0,0 +1,45 @@
+---
+description: Create hooks to prevent unwanted behaviors from conversation analysis or explicit instructions
+---
+
+Create hook rules to prevent unwanted Claude Code behaviors by analyzing conversation patterns or explicit user instructions.
+
+## Usage
+
+`/hookify [description of behavior to prevent]`
+
+If no arguments provided, analyze the current conversation to find behaviors worth preventing.
+
+## Workflow
+
+### Step 1: Gather Behavior Info
+- **With arguments**: Parse the user's description of the unwanted behavior
+- **Without arguments**: Use the conversation-analyzer agent to find:
+  - Explicit corrections ("no, don't do that", "stop doing X")
+  - Frustrated reactions to repeated mistakes
+  - Reverted changes
+  - Repeated similar issues
+
+### Step 2: Present Findings
+Show the user what behaviors were identified and proposed hook rules:
+- Behavior description
+- Proposed event type (bash/file/stop/prompt/all)
+- Proposed pattern/matcher
+- Proposed action (block/warn)
+
+### Step 3: Generate Rule Files
+For each approved rule, create a file at `.claude/hookify.{name}.local.md`:
+
+```yaml
+---
+name: rule-name
+enabled: true
+event: bash|file|stop|prompt|all
+action: block|warn
+pattern: "regex pattern"
+---
+Message shown when rule triggers.
+```
+
+### Step 4: Confirm
+Report created rules and how to manage them (`/hookify-list`, `/hookify-configure`).

commands/review-pr.md

@@ -0,0 +1,36 @@
+---
+description: Comprehensive PR review using specialized agents
+---
+
+Run a comprehensive, multi-perspective review of a pull request.
+
+## Usage
+
+`/review-pr [PR-number-or-URL] [--focus=comments|tests|errors|types|code|simplify]`
+
+If no PR specified, review the current branch's PR. If no focus specified, run all reviews.
+
+## Steps
+
+1. **Identify the PR**: Use `gh pr view` to get PR details, changed files, and diff
+2. **Find project guidelines**: Look for CLAUDE.md, .eslintrc, tsconfig.json, etc.
+3. **Launch specialized review agents** (in parallel where possible):
+
+   | Agent | Focus |
+   |-------|-------|
+   | code-reviewer | Code quality, bugs, security, style guide adherence |
+   | comment-analyzer | Comment accuracy, completeness, maintainability |
+   | pr-test-analyzer | Test coverage quality and completeness |
+   | silent-failure-hunter | Silent failures, inadequate error handling |
+   | type-design-analyzer | Type design, invariants, encapsulation |
+   | code-simplifier | Code clarity, consistency, maintainability |
+
+4. **Aggregate results**: Collect findings, deduplicate, rank by severity
+5. **Report**: Present organized findings grouped by severity (Critical > Important > Advisory)
+
+## Confidence Scoring
+
+Only report issues with confidence ≥ 80:
+- **Critical (90-100)**: Bugs, security vulnerabilities, data loss risks
+- **Important (80-89)**: Style violations, missing tests, code quality
+- **Advisory (<80)**: Suggestions, nice-to-haves (only if explicitly requested)