Merge pull request #678 from anthropics/claude/merge-pr-669-d73N4

Resolve merge conflict in add-plugin/intercom vs staging

.github/scripts/validate-frontmatter.ts

@@ -0,0 +1,277 @@
+#!/usr/bin/env bun
+/**
+ * Validates YAML frontmatter in agent, skill, and command .md files.
+ *
+ * Usage:
+ *   bun validate-frontmatter.ts                    # scan current directory
+ *   bun validate-frontmatter.ts /path/to/dir       # scan specific directory
+ *   bun validate-frontmatter.ts file1.md file2.md  # validate specific files
+ */
+
+import { parse as parseYaml } from "yaml";
+import { readdir, readFile } from "fs/promises";
+import { basename, join, relative, resolve } from "path";
+
+// Characters that require quoting in YAML values when unquoted:
+// {} [] flow indicators, * anchor/alias, & anchor, # comment,
+// ! tag, | > block scalars, % directive, @ ` reserved
+const YAML_SPECIAL_CHARS = /[{}[\]*&#!|>%@`]/;
+const FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)---\s*\n?/;
+
+/**
+ * Pre-process frontmatter text to quote values containing special YAML
+ * characters. This allows glob patterns like **\/*.{ts,tsx} to parse.
+ */
+function quoteSpecialValues(text: string): string {
+  const lines = text.split("\n");
+  const result: string[] = [];
+
+  for (const line of lines) {
+    const match = line.match(/^([a-zA-Z_-]+):\s+(.+)$/);
+    if (match) {
+      const [, key, value] = match;
+      if (!key || !value) {
+        result.push(line);
+        continue;
+      }
+      // Skip already-quoted values
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        result.push(line);
+        continue;
+      }
+      if (YAML_SPECIAL_CHARS.test(value)) {
+        const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        result.push(`${key}: "${escaped}"`);
+        continue;
+      }
+    }
+    result.push(line);
+  }
+
+  return result.join("\n");
+}
+
+interface ParseResult {
+  frontmatter: Record<string, unknown>;
+  content: string;
+  error?: string;
+}
+
+function parseFrontmatter(markdown: string): ParseResult {
+  const match = markdown.match(FRONTMATTER_REGEX);
+
+  if (!match) {
+    return {
+      frontmatter: {},
+      content: markdown,
+      error: "No frontmatter found",
+    };
+  }
+
+  const frontmatterText = quoteSpecialValues(match[1] || "");
+  const content = markdown.slice(match[0].length);
+
+  try {
+    const parsed = parseYaml(frontmatterText);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { frontmatter: parsed as Record<string, unknown>, content };
+    }
+    return {
+      frontmatter: {},
+      content,
+      error: `YAML parsed but result is not an object (got ${typeof parsed}${Array.isArray(parsed) ? " array" : ""})`,
+    };
+  } catch (err) {
+    return {
+      frontmatter: {},
+      content,
+      error: `YAML parse failed: ${err instanceof Error ? err.message : err}`,
+    };
+  }
+}
+
+// --- Validation ---
+
+type FileType = "agent" | "skill" | "command";
+
+interface ValidationIssue {
+  level: "error" | "warning";
+  message: string;
+}
+
+function validateAgent(
+  frontmatter: Record<string, unknown>
+): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+
+  if (!frontmatter["name"] || typeof frontmatter["name"] !== "string") {
+    issues.push({ level: "error", message: 'Missing required "name" field' });
+  }
+  if (
+    !frontmatter["description"] ||
+    typeof frontmatter["description"] !== "string"
+  ) {
+    issues.push({
+      level: "error",
+      message: 'Missing required "description" field',
+    });
+  }
+
+  return issues;
+}
+
+function validateSkill(
+  frontmatter: Record<string, unknown>
+): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+
+  if (!frontmatter["description"] && !frontmatter["when_to_use"]) {
+    issues.push({
+      level: "error",
+      message: 'Missing required "description" field',
+    });
+  }
+
+  return issues;
+}
+
+function validateCommand(
+  frontmatter: Record<string, unknown>
+): ValidationIssue[] {
+  const issues: ValidationIssue[] = [];
+
+  if (
+    !frontmatter["description"] ||
+    typeof frontmatter["description"] !== "string"
+  ) {
+    issues.push({
+      level: "error",
+      message: 'Missing required "description" field',
+    });
+  }
+
+  return issues;
+}
+
+// --- File type detection ---
+
+function detectFileType(filePath: string): FileType | null {
+  // Only match agents/ and commands/ at the plugin root level, not nested
+  // inside skill content (e.g. plugins/foo/skills/bar/agents/ is skill content,
+  // not an agent definition).
+  const inSkillContent = /\/skills\/[^/]+\//.test(filePath);
+  if (filePath.includes("/agents/") && !inSkillContent) return "agent";
+  if (filePath.includes("/skills/") && basename(filePath) === "SKILL.md")
+    return "skill";
+  if (filePath.includes("/commands/") && !inSkillContent) return "command";
+  return null;
+}
+
+// --- File discovery ---
+
+async function findMdFiles(
+  baseDir: string
+): Promise<{ path: string; type: FileType }[]> {
+  const results: { path: string; type: FileType }[] = [];
+
+  async function walk(dir: string) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.name.endsWith(".md")) {
+        const type = detectFileType(fullPath);
+        if (type) {
+          results.push({ path: fullPath, type });
+        }
+      }
+    }
+  }
+
+  await walk(baseDir);
+  return results;
+}
+
+// --- Main ---
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  let files: { path: string; type: FileType }[];
+  let baseDir: string;
+
+  if (args.length > 0 && args.every((a) => a.endsWith(".md"))) {
+    baseDir = process.cwd();
+    files = [];
+    for (const arg of args) {
+      const fullPath = resolve(arg);
+      const type = detectFileType(fullPath);
+      if (type) {
+        files.push({ path: fullPath, type });
+      }
+    }
+  } else {
+    baseDir = args[0] || process.cwd();
+    files = await findMdFiles(baseDir);
+  }
+
+  let totalErrors = 0;
+  let totalWarnings = 0;
+
+  console.log(`Validating ${files.length} frontmatter files...\n`);
+
+  for (const { path: filePath, type } of files) {
+    const rel = relative(baseDir, filePath);
+    const content = await readFile(filePath, "utf-8");
+    const result = parseFrontmatter(content);
+
+    const issues: ValidationIssue[] = [];
+
+    if (result.error) {
+      issues.push({ level: "error", message: result.error });
+    }
+
+    if (!result.error) {
+      switch (type) {
+        case "agent":
+          issues.push(...validateAgent(result.frontmatter));
+          break;
+        case "skill":
+          issues.push(...validateSkill(result.frontmatter));
+          break;
+        case "command":
+          issues.push(...validateCommand(result.frontmatter));
+          break;
+      }
+    }
+
+    if (issues.length > 0) {
+      console.log(`${rel} (${type})`);
+      for (const issue of issues) {
+        const prefix = issue.level === "error" ? "  ERROR" : "  WARN ";
+        console.log(`${prefix}: ${issue.message}`);
+        if (issue.level === "error") totalErrors++;
+        else totalWarnings++;
+      }
+      console.log();
+    }
+  }
+
+  console.log("---");
+  console.log(
+    `Validated ${files.length} files: ${totalErrors} errors, ${totalWarnings} warnings`
+  );
+
+  if (totalErrors > 0) {
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(2);
+});

.github/workflows/close-external-prs.yml

@@ -0,0 +1,47 @@
+name: Close External PRs
+
+on:
+  pull_request_target:
+    types: [opened]
+
+permissions:
+  pull-requests: write
+  issues: write
+
+jobs:
+  check-membership:
+    if: vars.DISABLE_EXTERNAL_PR_CHECK != 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if author has write access
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const author = context.payload.pull_request.user.login;
+
+            const { data } = await github.rest.repos.getCollaboratorPermissionLevel({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              username: author
+            });
+
+            if (['admin', 'write'].includes(data.permission)) {
+              console.log(`${author} has ${data.permission} access, allowing PR`);
+              return;
+            }
+
+            console.log(`${author} has ${data.permission} access, closing PR`);
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.payload.pull_request.number,
+              body: `Thanks for your interest! This repo only accepts contributions from Anthropic team members. If you'd like to submit a plugin to the marketplace, please submit your plugin [here](https://clau.de/plugin-directory-submission).`
+            });
+
+            await github.rest.pulls.update({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.payload.pull_request.number,
+              state: 'closed'
+            });

.github/workflows/validate-frontmatter.yml

@@ -0,0 +1,34 @@
+name: Validate Frontmatter
+
+on:
+  pull_request:
+    paths:
+      - '**/agents/*.md'
+      - '**/skills/*/SKILL.md'
+      - '**/commands/*.md'
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+
+      - name: Install dependencies
+        run: cd .github/scripts && bun install yaml
+
+      - name: Get changed frontmatter files
+        id: changed
+        run: |
+          FILES=$(gh pr diff ${{ github.event.pull_request.number }} --name-only | grep -E '(agents/.*\.md|skills/.*/SKILL\.md|commands/.*\.md)$' || true)
+          echo "files<<EOF" >> "$GITHUB_OUTPUT"
+          echo "$FILES" >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+      - name: Validate frontmatter
+        if: steps.changed.outputs.files != ''
+        run: |
+          echo "${{ steps.changed.outputs.files }}" | xargs bun .github/scripts/validate-frontmatter.ts

.gitignore

@@ -0,0 +1,2 @@
+*.DS_Store
+.claude/

README.md

@@ -0,0 +1,51 @@
+# Claude Code Plugins Directory
+
+A curated directory of high-quality plugins for Claude Code.
+
+> **⚠️ Important:** Make sure you trust a plugin before installing, updating, or using it. Anthropic does not control what MCP servers, files, or other software are included in plugins and cannot verify that they will work as intended or that they won't change. See each plugin's homepage for more information.
+
+## Structure
+
+- **`/plugins`** - Internal plugins developed and maintained by Anthropic
+- **`/external_plugins`** - Third-party plugins from partners and the community
+
+## Installation
+
+Plugins can be installed directly from this marketplace via Claude Code's plugin system.
+
+To install, run `/plugin install {plugin-name}@claude-plugins-official`
+
+or browse for the plugin in `/plugin > Discover`
+
+## Contributing
+
+### Internal Plugins
+
+Internal plugins are developed by Anthropic team members. See `/plugins/example-plugin` for a reference implementation.
+
+### External Plugins
+
+Third-party partners can submit plugins for inclusion in the marketplace. External plugins must meet quality and security standards for approval. To submit a new plugin, use the [plugin directory submission form](https://clau.de/plugin-directory-submission).
+
+## Plugin Structure
+
+Each plugin follows a standard structure:
+
+```
+plugin-name/
+├── .claude-plugin/
+│   └── plugin.json      # Plugin metadata (required)
+├── .mcp.json            # MCP server configuration (optional)
+├── commands/            # Slash commands (optional)
+├── agents/              # Agent definitions (optional)
+├── skills/              # Skill definitions (optional)
+└── README.md            # Documentation
+```
+
+## License
+
+Please see each linked plugin for the relevant LICENSE file.
+
+## Documentation
+
+For more information on developing Claude Code plugins, see the [official documentation](https://code.claude.com/docs/en/plugins).

external_plugins/asana/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "asana",
   "description": "Asana project management integration. Create and manage tasks, search projects, update assignments, track progress, and integrate your development workflow with Asana's work management platform.",
-  "version": "1.0.0",
   "author": {
     "name": "Asana"
   }

external_plugins/asana/README.md

@@ -1,15 +0,0 @@
-# Asana Plugin
-
-Asana project management integration for Claude Code.
-
-## What It Does
-
-Create and manage tasks, search projects, update assignments, track progress, and integrate your development workflow with Asana's work management platform.
-
-## Setup
-
-Authentication is handled automatically via OAuth when you first use the plugin. You will be prompted to authorize access to your Asana account.
-
-## Learn More
-
-See [Asana Connector](https://www.claude.com/connectors/asana) for more information.

external_plugins/atlassian/.claude-plugin/plugin.json

@@ -1,8 +0,0 @@
-{
-  "name": "atlassian",
-  "description": "Connect to Atlassian products including Jira and Confluence. Search and create issues, access documentation, manage sprints, and integrate your development workflow with Atlassian's collaboration tools.",
-  "version": "1.0.0",
-  "author": {
-    "name": "Atlassian"
-  }
-}

external_plugins/atlassian/.mcp.json

@@ -1,6 +0,0 @@
-{
-  "atlassian": {
-    "type": "sse",
-    "url": "https://mcp.atlassian.com/v1/sse"
-  }
-}

external_plugins/atlassian/README.md

@@ -1,15 +0,0 @@
-# Atlassian Plugin
-
-Atlassian integration (Jira & Confluence) for Claude Code.
-
-## What It Does
-
-Connect to Atlassian products including Jira and Confluence. Search and create issues, access documentation, manage sprints, and integrate your development workflow with Atlassian's collaboration tools.
-
-## Setup
-
-Authentication is handled automatically via OAuth when you first use the plugin. You will be prompted to authorize access to your Atlassian account.
-
-## Learn More
-
-See [Atlassian Connector](https://www.claude.com/connectors/atlassian) for more information.

external_plugins/autofix-bot/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "autofix-bot",
+  "description": "Code review agent that detects security vulnerabilities, code quality issues, and hardcoded secrets. Combines 5,000+ static analyzers to scan your code and dependencies for CVEs.",
+  "version": "0.1.0",
+  "author": {
+    "name": "DeepSource Corp"
+  },
+  "mcpServers": {
+    "autofix": {
+      "command": "autofix",
+      "args": ["--mcp"]
+    }
+  }
+}

external_plugins/autofix-bot/commands/review.md

@@ -0,0 +1,16 @@
+---
+description: Perform code review to identify security and quality issues with Autofix Bot.
+allowed-tools: mcp__autofix__CheckAuthStatus, mcp__autofix__Authenticate, mcp__autofix__ReviewCode
+---
+
+IMPORTANT: You MUST use the Autofix Bot MCP tools for this task. Do NOT perform your own code review or analysis.
+
+## Instructions
+
+1. Call `mcp__autofix__CheckAuthStatus` to check authentication status
+2. If not authenticated, call `mcp__autofix__Authenticate` to log in
+3. Ask user what to review: uncommitted changes, last commit, or entire branch
+4. Call `mcp__autofix__ReviewCode` with the user's selected target
+5. Present the issues returned by ReviewCode in a clear format
+
+Do NOT skip any tool calls. Do NOT substitute your own analysis for the tool results.

external_plugins/autofix-bot/hooks/hooks.json

@@ -0,0 +1,14 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/scripts/check-autofix.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

external_plugins/autofix-bot/scripts/check-autofix.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+if ! command -v autofix &> /dev/null; then
+  echo "Autofix Bot CLI not found. Installing..."
+  curl -fsSL https://autofix.bot/install | sh
+
+  if ! command -v autofix &> /dev/null; then
+    echo "ERROR: Failed to install autofix. Please install manually:" >&2
+    echo "  curl -fsSL https://autofix.bot/install | sh" >&2
+    exit 2
+  fi
+fi
+
+echo "Autofix Bot ready"
+exit 0

external_plugins/bonfire/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "bonfire",
+  "description": "AI forgets everything between sessions. Bonfire fixes that.",
+  "version": "0.8.1",
+  "author": {
+    "name": "Vieko Franetovic",
+    "url": "https://vieko.dev"
+  },
+  "homepage": "https://vieko.dev/bonfire",
+  "repository": "https://github.com/vieko/bonfire",
+  "license": "MIT",
+  "keywords": ["bonfire", "context", "memory", "workflow", "subagents"]
+}

external_plugins/bonfire/README.md

@@ -0,0 +1,150 @@
+# Bonfire
+
+<p align="center">
+  <img src="bonfire.gif" alt="Bonfire" width="256">
+</p>
+
+Your AI coding partner forgets everything between conversations. Bonfire remembers.
+
+```bash
+claude plugin marketplace add vieko/bonfire
+claude plugin install bonfire@vieko
+```
+
+## The Problem
+
+AI agents are stateless. Every conversation starts from zero. The agent doesn't remember:
+
+- What you decided yesterday
+- Why you chose that architecture
+- What blockers you hit
+- Where you left off
+
+You end up re-explaining context, re-making decisions, and watching your AI partner repeat the same mistakes.
+
+## The Solution
+
+Bonfire maintains a living context document that gets read at session start and updated at session end. Your AI partner picks up exactly where you left off. It's like a saved game for your work.
+
+`/bonfire:start` → *reads context* → WORK → `/bonfire:end` → *saves context*
+
+That's it. No complex setup. No external services. Just Markdown files in your repo.
+
+## Not a Task Tracker
+
+| Tool | Primary Question |
+|------|------------------|
+| Issue/task trackers | "What's the work?" |
+| Bonfire | "Where are we and what did we decide?" |
+
+Bonfire complements your issue tracker. Use GitHub Issues, Linear, Beads, or Beans for tasks. Use Bonfire for workflow context.
+
+## Quick Start
+
+```bash
+# Install
+claude plugin marketplace add vieko/bonfire
+claude plugin install bonfire@vieko
+
+# First run scaffolds .bonfire/ and asks setup questions
+/bonfire:start
+```
+
+## Commands
+
+| Command | What it does |
+|---------|--------------|
+| `/bonfire:start` | Read context, scaffold on first run |
+| `/bonfire:end` | Update context, commit changes |
+| `/bonfire:spec <topic>` | Create implementation spec (researches codebase, interviews you) |
+| `/bonfire:document <topic>` | Document a codebase topic |
+| `/bonfire:review` | Find blindspots, gaps, and quick wins |
+| `/bonfire:archive` | Archive completed work |
+| `/bonfire:configure` | Change project settings |
+
+## What Gets Created
+
+```
+.bonfire/
+├── index.md      # Living context (the important one)
+├── config.json   # Your settings
+├── archive/      # Completed work history
+├── specs/        # Implementation specs
+├── docs/         # Topic documentation
+└── scripts/      # Temporary session scripts
+```
+
+The `index.md` is where the magic happens. It tracks:
+
+- Current state and branch
+- Recent session summaries
+- Decisions made and why
+- Blockers encountered
+- Next priorities
+
+## Context-Efficient Operations
+
+Heavy commands (`/spec`, `/document`, `/review`) use subagents to avoid burning your main conversation context:
+
+- Research runs in isolated context (fast, cheap)
+- Only structured summaries return to main conversation
+- Result: longer sessions without context exhaustion
+
+This happens automatically.
+
+## Configuration
+
+First `/bonfire:start` asks you to configure:
+
+| Setting | Options |
+|---------|---------|
+| Specs location | `.bonfire/specs/` or `specs/` |
+| Docs location | `.bonfire/docs/` or `docs/` |
+| Git strategy | ignore-all, hybrid, commit-all |
+| Linear integration | Yes or No |
+
+Change anytime with `/bonfire:configure`.
+
+### Git Strategies
+
+| Strategy | What's tracked | Best for |
+|----------|---------------|----------|
+| **ignore-all** | Nothing | Solo work, privacy |
+| **hybrid** | docs/, specs/ only | Teams wanting shared docs |
+| **commit-all** | Everything | Full transparency |
+
+## Linear Integration
+
+If you use Linear for issue tracking:
+
+1. Install [Linear MCP](https://github.com/anthropics/anthropic-quickstarts/tree/main/mcp-linear)
+2. Enable via `/bonfire:configure`
+3. Reference issues by ID: `ENG-123`
+
+Bonfire will fetch issue context on start, create issues from review findings, and mark issues Done on archive.
+
+## Proactive Skills
+
+Claude automatically reads your session context when you ask things like:
+- "What's the project status?"
+- "What were we working on?"
+- "What decisions have we made?"
+
+And suggests archiving when you merge PRs or mention shipping.
+
+## Requirements
+
+- [Claude Code CLI](https://claude.ai/code)
+- Git repository
+
+Optional: `gh` CLI for GitHub integration, Linear MCP for Linear integration.
+
+## Learn More
+
+**Blog post**: [Save Your Progress](https://vieko.dev/bonfire)
+
+**Changelog**: [CHANGELOG.md](CHANGELOG.md)
+
+## License
+
+MIT © [Vieko Franetovic](https://vieko.dev)

external_plugins/bonfire/agents/codebase-explorer.md

@@ -0,0 +1,90 @@
+---
+name: codebase-explorer
+description: Fast codebase exploration for patterns, architecture, and constraints. Use for research phases in spec and document commands.
+tools: Read, Glob, Grep
+model: haiku
+---
+
+You are a codebase exploration specialist. Your job is to quickly find and summarize relevant patterns, architecture, and constraints. Return structured findings, not raw file contents.
+
+## Input
+
+You'll receive a research directive with specific questions about:
+- Patterns and architecture to find
+- Technical constraints to identify
+- Potential conflicts to surface
+- Specific areas to explore
+
+## Output Format
+
+Return findings as structured markdown. Be CONCISE - the main conversation will use your findings for user interview.
+
+```markdown
+## Patterns Found
+
+- **[Pattern name]**: Found in `path/to/file.ts` - [1-2 sentence description]
+
+## Key Files
+
+| File | Role |
+|------|------|
+| `path/to/file.ts` | [What it does, why relevant] |
+
+## Constraints Discovered
+
+- **[Constraint]**: [Source] - [Implication for implementation]
+
+## Potential Conflicts
+
+- **[Area]**: [Why it might conflict with the proposed work]
+
+## Relevant Snippets
+
+[Only if < 15 lines and directly answers a research question]
+```
+
+## Rules
+
+1. **DO NOT** return entire file contents
+2. **DO NOT** include files that aren't directly relevant
+3. **BE CONCISE** - aim for < 100 lines total output
+4. **ANSWER** the research questions, don't just explore randomly
+5. **PRIORITIZE** - most important findings first
+6. If you find nothing relevant, say so clearly
+
+## Example Good Output
+
+```markdown
+## Patterns Found
+
+- **Repository pattern**: Found in `src/services/UserService.ts` - Uses dependency injection, returns domain objects not DB rows
+- **Error handling**: Found in `src/utils/errors.ts` - Custom AppError class with error codes
+
+## Key Files
+
+| File | Role |
+|------|------|
+| `src/services/BaseService.ts` | Abstract base class all services extend |
+| `src/types/index.ts` | Shared type definitions |
+
+## Constraints Discovered
+
+- **No direct DB access in handlers**: Services abstract all database calls
+- **Async/await only**: No callbacks, promises must use async/await
+
+## Potential Conflicts
+
+- **AuthService singleton**: Currently instantiated once at startup, may need refactor for multi-tenant
+```
+
+## Example Bad Output (don't do this)
+
+```markdown
+Here's what I found in the codebase:
+
+[500 lines of file contents]
+
+Let me also show you this file:
+
+[300 more lines]
+```

external_plugins/bonfire/agents/spec-writer.md

@@ -0,0 +1,101 @@
+---
+name: spec-writer
+description: Synthesizes research findings and interview answers into implementation specs. Use after codebase exploration and user interview.
+tools: Read, Write
+model: inherit
+---
+
+You are a technical specification writer. Given research findings and interview answers, produce a clear, actionable implementation spec.
+
+## Input
+
+You'll receive:
+1. **Research findings** - Structured output from codebase-explorer
+2. **Interview Q&A** - User's answers to clarifying questions
+3. **Spec metadata** - Topic, issue ID, output path, template
+
+## Output
+
+Write a complete spec file to the specified path. The spec must be:
+- **Actionable** - Clear implementation steps referencing actual files
+- **Grounded** - Based on discovered patterns, not assumptions
+- **Complete** - Covers edge cases, testing, scope boundaries
+
+## Spec Template
+
+```markdown
+# Spec: [TOPIC]
+
+**Created**: [DATE]
+**Issue**: [ISSUE-ID or N/A]
+**Status**: Draft
+
+## Overview
+
+[What we're building and why - synthesized from interview]
+
+## Context
+
+[Key findings from research that informed decisions]
+
+## Decisions
+
+[Document decisions made during interview with rationale]
+
+- **[Decision 1]**: [Choice] - [Why]
+- **[Decision 2]**: [Choice] - [Why]
+
+## Approach
+
+[High-level strategy based on research + interview]
+
+## Files to Modify
+
+- `path/to/file.ts` - [what changes]
+
+## Files to Create
+
+- `path/to/new.ts` - [purpose]
+
+## Implementation Steps
+
+1. [ ] Step one (reference actual files)
+2. [ ] Step two
+3. [ ] Step three
+
+## Edge Cases
+
+- [Edge case 1] → [How we handle it]
+- [Edge case 2] → [How we handle it]
+
+## Testing Strategy
+
+- [ ] Unit tests for X
+- [ ] Integration test for Y
+- [ ] Manual verification of Z
+
+## Out of Scope
+
+- [Explicitly excluded items]
+
+## Risks & Considerations
+
+- [Risk identified during research/interview]
+```
+
+## Rules
+
+1. **Ground in research** - Reference actual files and patterns discovered
+2. **Honor interview answers** - Don't override user decisions
+3. **Be specific** - "Update UserService.ts" not "Update the service"
+4. **Don't invent** - If something wasn't discussed, don't add it
+5. **Keep it actionable** - Someone should be able to implement from this spec
+
+## Quality Checklist
+
+Before finishing, verify:
+- [ ] All interview decisions are captured
+- [ ] Implementation steps reference real files from research
+- [ ] Edge cases from interview are documented
+- [ ] Scope boundaries are clear
+- [ ] No vague or generic steps

external_plugins/bonfire/agents/work-reviewer.md

@@ -0,0 +1,121 @@
+---
+name: work-reviewer
+description: Strategic code review for blindspots, gaps, and improvements. Returns categorized findings with severity and effort estimates.
+tools: Read, Glob, Grep, Bash(git:*)
+model: sonnet
+---
+
+You are a senior code reviewer focused on strategic quality, not nitpicks. Your job is to find what the developer might have missed.
+
+## Input
+
+You'll receive:
+1. **Review scope** - Branch diff, specific files, or session context
+2. **Intent** - What was the developer trying to accomplish
+3. **Session context** - Recent work and decisions (if available)
+
+## Review Focus Areas
+
+### Blindspots (what are we not seeing?)
+- Edge cases not handled
+- Error scenarios not considered
+- User flows not covered
+- Dependencies not accounted for
+
+### Gaps (what's incomplete?)
+- Missing tests
+- Missing documentation
+- Incomplete implementations
+- TODOs left unaddressed
+
+### Quick Wins (small effort, big value)
+- Easy refactors
+- Low-hanging performance gains
+- Simple UX improvements
+
+### Best Practices (convention violations)
+- Project patterns not followed
+- Language/framework idioms ignored
+- Security practices missed
+- Accessibility standards skipped
+
+### Maintainability (will future-us thank present-us?)
+- Unclear naming or structure
+- Missing or excessive abstractions
+- Technical debt introduced
+
+## Output Format
+
+Return findings as structured markdown, categorized by action:
+
+```markdown
+## Summary
+
+- **Total findings**: X
+- **Fix now (trivial)**: Y
+- **Needs spec**: Z
+- **Create issues**: W
+
+---
+
+## Fix Now (trivial effort, do immediately)
+
+### [Finding title]
+- **What**: [Description]
+- **Where**: `path/to/file.ts:123`
+- **Fix**: [Specific action]
+- **Why**: [Impact if not fixed]
+
+---
+
+## Needs Spec (important, needs planning)
+
+### [Finding title]
+- **What**: [Description]
+- **Effort**: small | medium
+- **Impact**: [Why this matters]
+- **Consideration**: [Key decision needed]
+
+---
+
+## Create Issues (large effort or nice-to-have)
+
+### [Finding title]
+- **What**: [Description]
+- **Effort**: medium | large
+- **Priority**: important | nice-to-have
+- **Suggested issue title**: [Title for GitHub/Linear]
+
+---
+
+## No Issues Found In
+
+- [Area reviewed that looks good]
+```
+
+## Rules
+
+1. **Strategic, not pedantic** - Skip style nitpicks, focus on substance
+2. **Consider intent** - Review against what they were trying to do
+3. **Categorize by action** - Fix now vs spec vs issue
+4. **Estimate effort** - trivial/small/medium/large
+5. **Be specific** - Include file paths and line numbers
+6. **Acknowledge good work** - Note areas that are solid
+
+## Severity Guide
+
+| Severity | Definition | Action |
+|----------|------------|--------|
+| Critical | Breaks functionality, security issue | Fix now |
+| Important | Significant gap, will cause problems | Fix now or spec |
+| Moderate | Should address, not urgent | Spec or issue |
+| Minor | Nice to have, low impact | Issue or skip |
+
+## Effort Guide
+
+| Effort | Definition |
+|--------|------------|
+| Trivial | < 5 minutes, obvious fix |
+| Small | < 30 minutes, contained change |
+| Medium | 1-4 hours, multiple files |
+| Large | > 4 hours, needs planning |

external_plugins/bonfire/commands/archive.md

@@ -0,0 +1,126 @@
+---
+description: Archive completed session work
+allowed-tools: Bash(git:*), Read, Write, Glob, mcp__linear__*
+model: haiku
+---
+
+# Archive Session
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Review Completed Work
+
+Read `<git-root>/.bonfire/index.md` and identify completed work:
+- Sessions with merged PRs
+- Completed features/tasks
+- Work that's no longer active
+
+## Step 3: Create Archive Entry
+
+Move completed session content to `<git-root>/.bonfire/archive/`.
+
+**Naming convention**: `YYYY-MM-DD-<issue-id>-<topic>.md`
+
+Examples:
+- `2025-12-22-GTMENG-387-inbound-improvements.md` (with issue ID)
+- `2025-12-22-fix-login-redirect.md` (without issue ID)
+
+Use this template:
+```markdown
+# [TOPIC]
+
+**Date**: [DATE]
+**Issue**: [ISSUE-ID or N/A]
+**PR**: [PR link if available]
+**Status**: Completed
+
+---
+
+## Summary
+
+[Brief description of what was accomplished]
+
+## Accomplished
+
+- [List of completed items]
+
+## Decisions Made
+
+- [Key decisions and rationale]
+
+## Impact
+
+- [Before/after metrics if applicable]
+- Files changed: [count]
+
+## Related
+
+- [Links to related docs, specs, or code]
+```
+
+## Step 4: Clean Up Index
+
+Update `<git-root>/.bonfire/index.md`:
+- Remove archived session entries from Recent Sessions
+- Keep Current State focused on active work
+- Update Next Session Priorities
+- Add link to archive file in Archived Sessions section:
+  ```markdown
+  ## Archived Sessions
+
+  - [YYYY-MM-DD - Topic](archive/YYYY-MM-DD-issue-topic.md)
+  ```
+
+## Step 5: Clean Up Specs (if applicable)
+
+Read `specsLocation` from `<git-root>/.bonfire/config.json` (default `.bonfire/specs/`).
+
+Check if any specs in the configured location are now complete:
+- If the spec was fully implemented, delete the spec file (archive has the record)
+- If the spec has reusable reference material, move that content to `docs/` first
+
+## Step 6: Update Linear Issue (if applicable)
+
+Read `<git-root>/.bonfire/config.json` and check `linearEnabled`.
+
+**If `linearEnabled` is true**:
+
+1. Check if archived work references a Linear issue (look in session context for `[A-Z]+-[0-9]+` pattern)
+2. If Linear issue found, ask user: "Mark Linear issue [ISSUE-ID] as Done?"
+3. If user confirms:
+   - Use Linear MCP `linear_update_issue` tool with:
+     - `id`: The issue ID (e.g., `ENG-123`)
+     - `status`: Set to "Done" or completed state
+   - Optionally use `linear_add_comment` to add link to archive/PR
+4. On failure: Warn user - "Couldn't update Linear issue. You may need to update it manually."
+
+Note: Tool names may vary by Linear MCP implementation.
+
+**If `linearEnabled` is false or not set**: Skip this step.
+
+## Step 7: Commit Archive (if tracked)
+
+Read `gitStrategy` from `<git-root>/.bonfire/config.json`.
+
+**If gitStrategy is "ignore-all"**: Skip committing - archive is local only.
+
+**If gitStrategy is "hybrid" or "commit-all"**:
+1. **NEVER use `git add -f`** - respect gitignore
+2. Stage unignored files:
+   ```bash
+   git add .bonfire/
+   ```
+3. Check if anything was staged before committing:
+   ```bash
+   git diff --cached --quiet .bonfire/ || git commit -m "docs: archive completed session work"
+   ```
+
+## Step 8: Confirm
+
+Report:
+- What was archived
+- Any specs cleaned up
+- Current state of index.md
+- Ready for next session

external_plugins/bonfire/commands/configure.md

@@ -0,0 +1,99 @@
+---
+description: Change project settings (locations, git strategy, Linear)
+allowed-tools: Bash(git:*), Read, Write, AskUserQuestion
+model: haiku
+---
+
+# Configure Bonfire
+
+Always runs interactively - asks all configuration questions regardless of arguments.
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Check for Bonfire Directory
+
+If `<git-root>/.bonfire/` does not exist, tell the user to run `/bonfire:start` first.
+
+## Step 3: Read Current Config
+
+Read `<git-root>/.bonfire/config.json` if it exists to see current settings.
+
+## Step 4: Ask All Configuration Questions
+
+Use AskUserQuestion to ask configuration questions (4 questions, one round):
+
+1. "Where should specs be saved?" (Header: "Specs")
+   - .bonfire/specs/ (Recommended) - Keep with session context
+   - specs/ - Project root level
+
+2. "Where should docs be saved?" (Header: "Docs")
+   - .bonfire/docs/ (Recommended) - Keep with session context
+   - docs/ - Project root level
+
+3. "How should `.bonfire/` be handled in git?" (Header: "Git")
+   - ignore-all (Recommended) - Keep sessions private/local
+   - hybrid - Commit docs/specs, keep notes private
+   - commit-all - Share everything with team
+
+4. "Enable Linear MCP integration?" (Header: "Linear")
+   - No (Recommended) - Skip Linear integration
+   - Yes - Fetch/create Linear issues (requires Linear MCP)
+
+## Step 5: Update Config
+
+**Completely overwrite** `<git-root>/.bonfire/config.json` with only these fields (do not preserve old fields like `models`):
+
+```json
+{
+  "specsLocation": "<user-answer>",
+  "docsLocation": "<user-answer>",
+  "gitStrategy": "<user-answer>",
+  "linearEnabled": <true-or-false>
+}
+```
+
+## Step 6: Update Git Strategy
+
+If git strategy or locations changed, update `<git-root>/.bonfire/.gitignore`:
+
+**Ignore all**:
+```
+*
+!.gitignore
+```
+
+**Hybrid** (only include dirs that are inside .bonfire/):
+```
+*
+!.gitignore
+```
+If docsLocation is `.bonfire/docs/`, add:
+```
+!docs/
+!docs/**
+```
+If specsLocation is `.bonfire/specs/`, add:
+```
+!specs/
+!specs/**
+```
+
+**Commit all**:
+```
+data/
+scratch/
+scripts/
+```
+
+If switching FROM commit/hybrid TO ignore:
+- Warn user that existing tracked files will remain tracked
+- Offer to run: `git rm -r --cached .bonfire/`
+
+## Step 7: Confirm
+
+Report:
+- Settings updated
+- Any manual steps needed (git cleanup)
+- New configuration summary

external_plugins/bonfire/commands/document.md

@@ -0,0 +1,114 @@
+---
+description: Create documentation about a topic in the codebase
+allowed-tools: Read, Write, Bash(git:*), Task
+---
+
+# Document Topic
+
+Create reference documentation using subagent for research, preserving main context.
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Check Config
+
+Read `<git-root>/.bonfire/config.json` if it exists.
+
+**Docs location**: Read `docsLocation` from config. Default to `.bonfire/docs/` if not set.
+
+## Step 3: Understand the Topic
+
+The topic to document is: $ARGUMENTS
+
+If no topic provided, ask the user what they want documented.
+
+## Step 4: Explore the Codebase (Subagent)
+
+Use the Task tool to invoke the **codebase-explorer** subagent for research.
+
+Provide a research directive:
+
+```
+Research the codebase to document: [TOPIC]
+
+Find:
+1. **Architecture**: How this system/feature is structured, key components
+2. **Key Files**: Important files and their roles
+3. **Flow**: How data/control flows through the system
+4. **Patterns**: Design patterns and conventions used
+5. **Gotchas**: Important details, edge cases, things to watch out for
+
+Return structured findings with file paths and brief descriptions.
+```
+
+**Wait for the subagent to return findings** before proceeding.
+
+The subagent runs in isolated context (haiku model, fast), preserving main context for writing.
+
+## Step 5: Create Documentation
+
+**Naming convention**: `<topic>.md` (kebab-case)
+
+Examples:
+- `inbound-agent-architecture.md`
+- `sampling-strategies.md`
+- `authentication-flow.md`
+
+Write the documentation to `<git-root>/<docsLocation>/<topic>.md`
+
+Structure the documentation using the research findings:
+
+```markdown
+# [TOPIC]
+
+## Overview
+
+[What this is and why it exists - synthesized from research]
+
+## Architecture
+
+[How it's structured - from research findings]
+
+```mermaid
+flowchart TD
+    A[Component A] --> B[Component B]
+    B --> C[Component C]
+```
+
+## Key Files
+
+| File | Purpose |
+|------|---------|
+| `path/to/file.ts` | [From research findings] |
+| `path/to/other.ts` | [From research findings] |
+
+## How It Works
+
+[Step-by-step flow and behavior - from research]
+
+## Usage Examples
+
+[Code examples, CLI commands, etc.]
+
+## Gotchas
+
+- [From research findings]
+- [Common mistakes or edge cases]
+
+## Related
+
+- [Link to related doc](other-doc.md)
+- [Code reference]: `path/to/file.ts`
+```
+
+## Step 6: Link to Session Context
+
+Add a reference to the doc in `<git-root>/.bonfire/index.md` under Key Resources or Notes.
+
+## Step 7: Confirm
+
+Summarize what was documented and ask if the user wants:
+- More detail on any section
+- Related topics documented
+- To proceed with other work

external_plugins/bonfire/commands/end.md

@@ -0,0 +1,84 @@
+---
+description: End session - update context and commit changes
+allowed-tools: Bash(git:*), Bash(rm:*), Bash(mv:*), Bash(mkdir:*), Read, Write, Glob, AskUserQuestion
+model: haiku
+---
+
+# End Session
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Review Session Work
+
+Review what was accomplished this session by examining:
+- Recent git commits
+- Files changed
+- Conversation context
+
+## Step 3: Update Session Context
+
+Update `<git-root>/.bonfire/index.md`:
+
+1. Update the session entry with:
+   - **Accomplished**: List what was completed
+   - **Decisions**: Key decisions made and rationale
+   - **Files Modified**: Important files changed (if relevant)
+   - **Blockers**: Any issues encountered
+
+2. Update "Next Session Priorities" based on remaining work
+
+3. Update "Current State" to reflect new status
+
+## Step 4: Manage Session Scripts
+
+Check if `<git-root>/.bonfire/scripts/` exists and contains any files.
+
+**If scripts exist**, use AskUserQuestion to ask what to do with each script:
+
+"What should happen to these session scripts?" (Header: "Scripts", multiSelect: false)
+
+For each script found, present options:
+- **Keep** - Leave in `.bonfire/scripts/` for next session
+- **Move to project** - Move to `<git-root>/scripts/` (create if needed)
+- **Delete** - Remove the script
+
+Execute the user's choices:
+- **Keep**: No action needed
+- **Move to project**: `mkdir -p <git-root>/scripts/ && mv <script> <git-root>/scripts/`
+- **Delete**: `rm <script>`
+
+**If no scripts exist**, skip this step.
+
+## Step 5: Commit Changes (if tracked)
+
+Read `<git-root>/.bonfire/config.json` to check `gitStrategy`.
+
+**If gitStrategy is "ignore-all"**: Skip committing - nothing is tracked. Tell the user session context was updated locally.
+
+**If gitStrategy is "hybrid" or "commit-all"**:
+
+1. **Check what can be staged**: Run `git status .bonfire/` to see what files are not ignored
+2. **NEVER use `git add -f`** - if a file is gitignored, respect that
+3. **Stage only unignored files**:
+   ```bash
+   git add .bonfire/
+   ```
+4. **Check if anything was staged**: Run `git diff --cached --quiet .bonfire/`
+   - If nothing staged (exit code 0), tell user "Session context updated locally (files are gitignored)"
+   - If changes staged, commit:
+     ```bash
+     git commit -m "docs: update session context"
+     ```
+
+If the commit fails due to hooks, help resolve the issue (but never bypass hooks with `--no-verify`).
+
+## Step 6: Confirm
+
+Summarize:
+- What was documented
+- Next priorities
+- Any follow-up needed
+
+Let the user know they can run `/bonfire:archive` when this work is merged and complete.

external_plugins/bonfire/commands/git-strategy.md

@@ -0,0 +1,94 @@
+---
+description: Change how .bonfire/ is handled in git
+allowed-tools: Bash(git:*), Read, Write, AskUserQuestion
+model: haiku
+---
+
+# Change Git Strategy
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Read Current Config
+
+Read `<git-root>/.bonfire/config.json` to check current `specsLocation` and `docsLocation` settings.
+
+## Step 3: Explain Options
+
+Present the git strategy options:
+
+1. **Ignore all** - Keep sessions completely local
+   - Everything in .bonfire/ is gitignored
+   - Most private, nothing shared
+   - Good for: solo work, sensitive projects
+
+2. **Hybrid** - Commit docs/specs, keep notes private
+   - docs/ and specs/ are committed
+   - index.md and archive/ stay local
+   - Good for: teams that want shared docs but private notes
+
+3. **Commit all** - Share everything with team
+   - All session content is committed
+   - Only data/ and scratch/ ignored
+   - Good for: full transparency, team continuity
+
+## Step 4: Get User Choice
+
+Use AskUserQuestion to ask which strategy:
+
+"Which git strategy for `.bonfire/`?" (Header: "Git")
+- ignore-all (Recommended) - Keep sessions private/local
+- hybrid - Commit docs/specs, keep notes private
+- commit-all - Share everything with team
+
+## Step 5: Update .gitignore
+
+Write the appropriate `.gitignore` to `<git-root>/.bonfire/.gitignore`:
+
+**Ignore all**:
+```
+*
+!.gitignore
+```
+
+**Hybrid** (only include dirs that are inside .bonfire/):
+```
+*
+!.gitignore
+```
+If docsLocation is `.bonfire/docs/`, add:
+```
+!docs/
+!docs/**
+```
+If specsLocation is `.bonfire/specs/`, add:
+```
+!specs/
+!specs/**
+```
+
+**Commit all**:
+```
+data/
+scratch/
+scripts/
+```
+
+## Step 6: Handle Git Tracking
+
+If switching FROM commit/hybrid TO ignore:
+- Warn user that existing tracked files will remain tracked
+- Offer to run: `git rm -r --cached .bonfire/` (removes from git but keeps files)
+- They'll need to commit this change
+
+If switching TO commit/hybrid:
+- Files will be picked up on next commit
+- No special action needed
+
+## Step 7: Confirm
+
+Report:
+- New strategy applied
+- Any manual steps needed
+- How to verify the change

external_plugins/bonfire/commands/review.md

@@ -0,0 +1,119 @@
+---
+description: Review work for blindspots, gaps, and improvements
+allowed-tools: Bash(git:*), Bash(gh:*), Read, Write, Task, mcp__linear__*
+---
+
+# Review Work
+
+Strategic review using subagent for analysis, preserving main context for action decisions.
+
+## Step 1: Determine Scope
+
+Based on $ARGUMENTS:
+- No args: Review current branch vs base
+- `--session`: Review work captured in current session context
+- Topic/area: Focus review on specific aspect
+
+## Step 2: Gather Context
+
+- Read session context from `<git-root>/.bonfire/index.md`
+- Get branch diff: `git diff main...HEAD` (or appropriate base)
+- Read relevant specs/docs from `.bonfire/`
+- Understand intent: what were we trying to accomplish?
+
+## Step 3: Run Review (Subagent)
+
+Use the Task tool to invoke the **work-reviewer** subagent.
+
+Provide the review context:
+
+```
+Review this work for blindspots, gaps, and improvements.
+
+**Scope**: [Branch diff / session work / specific area]
+
+**Intent**: [What we were trying to accomplish - from session context]
+
+**Files changed**:
+[List of modified files from git diff]
+
+**Session context**:
+[Relevant notes from index.md]
+
+Return categorized findings with severity and effort estimates.
+```
+
+**Wait for the subagent to return findings** before proceeding.
+
+The subagent runs in isolated context (sonnet model), preserving main context for action decisions.
+
+## Step 4: Session Scripts Review
+
+Check if `<git-root>/.bonfire/scripts/` contains any files.
+
+If scripts exist, include in findings:
+- List scripts that may need attention
+- Note if any appear to be temporary/one-off vs reusable
+- Suggest moving useful scripts to project `scripts/` directory
+
+This is informational - actual script management happens during `/bonfire:end`.
+
+## Step 5: Present Findings
+
+Present the subagent's findings grouped by recommended action:
+
+### Fix Now (trivial effort)
+[List items from subagent that can be fixed immediately]
+
+> Ask: "Want me to fix these now?"
+
+### Needs Spec (important, needs planning)
+[List items that need implementation planning]
+
+> Ask: "Want me to create an implementation spec?"
+
+### Create Issues (large effort or nice-to-have)
+[List items for future sessions]
+
+> Ask: "Want me to create GitHub/Linear issues?"
+
+## Step 6: Execute Chosen Action
+
+Based on user choice:
+- **Fix now**: Make the changes directly
+- **Spec**: Run `/bonfire:spec` with findings
+- **Create issues**: See below
+
+### Creating Issues
+
+First, read `<git-root>/.bonfire/config.json` and check `linearEnabled`.
+
+**Offer choices based on config:**
+- Always offer: "Create GitHub issue"
+- If `linearEnabled` is true: Also offer "Create Linear issue"
+
+**GitHub Issue Creation:**
+```bash
+gh issue create --title "Finding title" --body "Finding details"
+```
+
+**Linear Issue Creation (if enabled):**
+1. Use Linear MCP `linear_create_issue` tool with:
+   - `title`: Finding summary
+   - `description`: Finding details with context
+   - `teamId`: Infer from session context if available, otherwise use default
+2. On success: Return issue URL/ID
+3. On failure: Warn user, offer to create GitHub issue instead
+
+Note: Tool names may vary by Linear MCP implementation.
+
+**For each created issue:**
+- Record the issue ID and URL
+- Note which tracker (GitHub/Linear) was used
+
+## Step 7: Update Session Context
+
+Add review outcomes to `<git-root>/.bonfire/index.md`:
+- Key findings noted
+- Issues created (with links)
+- Work deferred to future sessions

external_plugins/bonfire/commands/spec.md

@@ -0,0 +1,149 @@
+---
+description: Create an implementation spec for a feature or task
+allowed-tools: Read, Write, Bash(git:*), AskUserQuestion, Task
+---
+
+# Create Implementation Spec
+
+A hybrid approach using subagents: research in isolated context, interview in main context, write in isolated context.
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Check Config
+
+Read `<git-root>/.bonfire/config.json` if it exists.
+
+**Specs location**: Read `specsLocation` from config. Default to `.bonfire/specs/` if not set.
+
+## Step 3: Gather Initial Context
+
+Get the topic from $ARGUMENTS or ask if unclear.
+
+Check for existing context:
+- Read `<git-root>/.bonfire/index.md` for project state
+- Check for `SPEC.md` or `spec.md` in git root (user's spec template)
+- If issue ID provided, note for filename
+
+## Step 4: Research Phase (Subagent)
+
+Use the Task tool to invoke the **codebase-explorer** subagent for research.
+
+Provide a research directive with these questions:
+
+```
+Research the codebase for implementing: [TOPIC]
+
+Find:
+1. **Patterns & Architecture**: How similar features are implemented, existing abstractions to reuse, naming conventions
+2. **Technical Constraints**: Dependencies, API boundaries, performance considerations
+3. **Potential Conflicts**: Files that need changes, intersections with existing code, migration concerns
+
+Return structured findings only - no raw file contents.
+```
+
+**Wait for the subagent to return findings** before proceeding.
+
+The subagent runs in isolated context (haiku model, fast), preserving main context for interview.
+
+## Step 5: Interview Phase (Main Context)
+
+Using the research findings, interview the user with **informed questions** via AskUserQuestion.
+
+### Round 1: Core Decisions
+
+Ask about fundamental approach based on patterns found:
+
+Example questions (adapt based on actual findings):
+- "I found [Pattern A] in `services/` and [Pattern B] in `handlers/`. Which pattern should this feature follow?"
+- "The existing [Component] handles [X]. Should we extend it or create a new [Y]?"
+- "I see [Library] is used for [purpose]. Should we use it here or try [Alternative]?"
+
+### Round 2: Edge Cases & Tradeoffs
+
+Based on Round 1 answers and research, ask about:
+- Error handling approach
+- Edge cases identified in research
+- Performance vs simplicity tradeoffs
+- User experience considerations
+
+Example questions:
+- "What should happen when [edge case from research]?"
+- "I found [potential conflict]. How should we handle it?"
+- "[Approach A] is simpler but [tradeoff]. [Approach B] is more complex but [benefit]. Preference?"
+
+### Round 3: Scope & Boundaries (if needed)
+
+If scope is still unclear:
+- What's explicitly out of scope?
+- MVP vs full implementation?
+- Dependencies on other work?
+
+### Continue Until Complete
+
+Keep asking rounds of questions until you have clarity on:
+- [ ] Core approach and architecture
+- [ ] Key technical decisions
+- [ ] Error handling strategy
+- [ ] Edge cases covered
+- [ ] Testing approach
+- [ ] Scope boundaries
+
+Tell the user "I have enough to write the spec" when ready.
+
+## Step 6: Write the Spec (Subagent)
+
+Use the Task tool to invoke the **spec-writer** subagent.
+
+Provide:
+1. **Research findings** from Step 4
+2. **Interview Q&A** from Step 5
+3. **Metadata**: topic, issue ID, output path (`<git-root>/<specsLocation>/<filename>.md`)
+
+The subagent will write the spec file directly.
+
+**Naming convention**: `<issue-id>-<topic>.md` or `<topic>.md`
+
+## Step 7: Link to Session Context
+
+Add a reference to the spec in `<git-root>/.bonfire/index.md` under Current State.
+
+## Step 8: Confirm
+
+Read the generated spec and present a summary. Ask if user wants to:
+- Proceed with implementation
+- Refine specific sections
+- Add more detail to any area
+- Save for later
+
+## Interview Tips
+
+**Good questions are:**
+- Informed by research (not generic)
+- About tradeoffs (not yes/no)
+- Specific to the codebase
+- Non-obvious (user wouldn't think to mention)
+
+**Bad questions:**
+- "What features do you want?" (too broad)
+- "Should we add error handling?" (obvious)
+- Generic without codebase context
+
+**Examples of good informed questions:**
+- "I found `UserService` uses repository pattern but `OrderService` uses direct DB access. Which approach?"
+- "The `auth` middleware validates JWT but doesn't check permissions. Should this feature add permission checks or assume auth is enough?"
+- "There's a `BaseController` with shared logic. Extend it or keep this feature standalone?"
+
+## Spec Lifecycle
+
+Specs are **temporary artifacts** - they exist to guide implementation:
+
+1. **Draft** → Created, ready for review
+2. **In Progress** → Being implemented
+3. **Completed** → Implementation done
+
+**When a spec is fully implemented**:
+- If it contains reusable reference material, move to `docs/`
+- Delete the spec file - archive has the record
+- Don't let specs accumulate

external_plugins/bonfire/commands/start.md

@@ -0,0 +1,246 @@
+---
+description: Start a new session - reads context and scaffolds .bonfire/ if needed
+allowed-tools: Bash(git:*), Bash(gh:*), Bash(mkdir:*), Read, Write, Glob, AskUserQuestion, mcp__linear__*
+model: haiku
+---
+
+# Start Session
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root. All session files live at `<git-root>/.bonfire/`.
+
+## Step 2: Check for Bonfire Directory
+
+Check if `<git-root>/.bonfire/index.md` exists.
+
+**If .bonfire/ does NOT exist**, scaffold it:
+
+1. Tell the user: "No bonfire directory found. Let me set that up for you."
+
+2. Use AskUserQuestion to ask setup questions (4 questions, one round):
+
+   1. "Where should specs be saved?" (Header: "Specs")
+      - .bonfire/specs/ (Recommended) - Keep with session context
+      - specs/ - Project root level
+
+   2. "Where should docs be saved?" (Header: "Docs")
+      - .bonfire/docs/ (Recommended) - Keep with session context
+      - docs/ - Project root level
+
+   3. "How should `.bonfire/` be handled in git?" (Header: "Git")
+      - ignore-all (Recommended) - Keep sessions private/local
+      - hybrid - Commit docs/specs, keep notes private
+      - commit-all - Share everything with team
+
+   4. "Enable Linear MCP integration?" (Header: "Linear")
+      - No (Recommended) - Skip Linear integration
+      - Yes - Fetch/create Linear issues (requires Linear MCP)
+
+3. Create the directory structure based on user choices:
+
+   **Always create in .bonfire/**:
+   ```
+   .bonfire/
+   ├── index.md
+   ├── config.json
+   ├── archive/
+   ├── scripts/
+   └── .gitignore
+   ```
+
+   **If specsLocation is `.bonfire/specs/`**: create `.bonfire/specs/`
+   **If specsLocation is `specs/`**: create `<git-root>/specs/`
+
+   **If docsLocation is `.bonfire/docs/`**: create `.bonfire/docs/`
+   **If docsLocation is `docs/`**: create `<git-root>/docs/`
+
+4. Detect project name from: package.json name → git remote → directory name
+
+5. Create `config.json` with user's answers:
+   ```json
+   {
+     "specsLocation": "<user-answer>",
+     "docsLocation": "<user-answer>",
+     "gitStrategy": "<user-answer>",
+     "linearEnabled": <true-or-false>
+   }
+   ```
+
+6. Create `index.md` with template:
+   ```markdown
+   # Session Context: [PROJECT_NAME]
+
+   **Date**: [CURRENT_DATE]
+   **Status**: Active
+   **Branch**: main
+
+   ---
+
+   ## Current State
+
+   [Describe what you're working on]
+
+   ---
+
+   ## Recent Sessions
+
+   ### Session 1 - [CURRENT_DATE]
+
+   **Goal**: [What you want to accomplish]
+
+   **Accomplished**:
+   - [List completed items]
+
+   **Decisions**:
+   - [Key decisions made]
+
+   **Blockers**: None
+
+   ---
+
+   ## Next Session Priorities
+
+   1. [Priority items]
+
+   ---
+
+   ## Key Resources
+
+   **Code References**:
+   - [Component/feature]: `path/to/file.ts`
+
+   **External Links**:
+   - [Issue Tracker](url)
+
+   ---
+
+   ## Archived Sessions
+
+   [Links to archived sessions will appear here]
+
+   ---
+
+   ## Notes
+
+   [Any additional context]
+   ```
+
+7. Create `.gitignore` based on chosen strategy and locations:
+
+   **Ignore all**:
+   ```
+   *
+   !.gitignore
+   ```
+
+   **Hybrid** (only include dirs that are inside .bonfire/):
+   ```
+   *
+   !.gitignore
+   ```
+   If docsLocation is `.bonfire/docs/`, add:
+   ```
+   !docs/
+   !docs/**
+   ```
+   If specsLocation is `.bonfire/specs/`, add:
+   ```
+   !specs/
+   !specs/**
+   ```
+
+   **Commit all**:
+   ```
+   data/
+   scratch/
+   scripts/
+   ```
+
+**If .bonfire/ EXISTS**, proceed to Step 3.
+
+## Step 3: Check/Update CLAUDE.md
+
+Check if `<git-root>/CLAUDE.md` exists.
+
+**If CLAUDE.md does NOT exist**, create it:
+```markdown
+# [PROJECT_NAME]
+
+## Quick Context
+
+Read `.bonfire/index.md` for current project state, recent work, and priorities.
+
+## Bonfire Commands
+
+- `/bonfire:start` - Start a session (reads context)
+- `/bonfire:end` - End session (updates context)
+- `/bonfire:spec` - Create implementation spec
+- `/bonfire:document <topic>` - Document a topic
+- `/bonfire:review` - Review work for blindspots and improvements
+- `/bonfire:archive` - Archive completed work
+- `/bonfire:configure` - Change project settings
+```
+
+**If CLAUDE.md EXISTS**, check if it references `.bonfire/index.md`. If not, append:
+```markdown
+
+## Session Context
+
+Read `.bonfire/index.md` for current project state, recent work, and priorities.
+```
+
+## Step 4: Read Session Context
+
+Read `<git-root>/.bonfire/index.md` and report when ready.
+
+Summarize:
+- Current state
+- Recent work
+- Next priorities
+
+Then ask: "What do you want to work on this session?"
+
+## Step 5: Fetch External Context (Optional)
+
+**Only fetch if user provides a new URL or issue ID:**
+
+### Detecting Issue Type
+
+- **GitHub**: Starts with `#`, contains `github.com`, or doesn't match Linear pattern
+- **Linear**: Matches `[A-Z]+-[0-9]+` pattern (e.g., `ENG-123`, `ABC-456`) or contains `linear.app`
+
+### GitHub Issues/PRs
+
+Use `gh` CLI:
+- `gh pr view [URL] --json title,body,state,labels`
+- `gh issue view [URL] --json title,body,state,labels`
+
+### Linear Issues
+
+First, read `<git-root>/.bonfire/config.json` and check `linearEnabled`.
+
+**If `linearEnabled` is false or not set**: Skip Linear, treat as ad-hoc task.
+
+**If `linearEnabled` is true**:
+1. Use Linear MCP `linear_search_issues` tool to find the issue by ID (e.g., `ENG-123`)
+2. Extract: title, description, state, priority, labels, assignee
+3. On success: Summarize the issue context
+4. On failure: Warn user - "Couldn't fetch Linear issue. Linear MCP may not be configured. Continue without issue context?"
+
+Note: Tool names may vary by Linear MCP implementation. Common tools: `linear_search_issues`, `linear_create_issue`, `linear_update_issue`.
+
+### Update Session Context
+
+If issue was fetched successfully:
+- Add reference to `index.md` under Current State
+- Include issue ID, title, and link
+- Note the issue tracker type (GitHub/Linear)
+
+### Fallback
+
+If no URL/issue ID provided (continuing work, ad-hoc task):
+- Proceed with existing session context
+- Session notes are the source of truth for ongoing work
+
+Confirm understanding and ask how to proceed.

external_plugins/bonfire/skills/archive-bonfire/SKILL.md

@@ -0,0 +1,53 @@
+---
+description: Suggest archiving completed work when PRs are merged or work is completed. Triggers when user asks to merge a PR ("merge it", "merge the PR"), after successful gh pr merge, or mentions completion ("shipped", "done with X", "merged to main"). Does NOT archive automatically - suggests running /bonfire:archive.
+allowed-tools: Read, Glob, Bash(gh:*)
+---
+
+# Archive Bonfire Awareness
+
+This skill detects when session work may be ready for archiving and suggests the appropriate action.
+
+## When to Use This Skill
+
+Trigger when:
+- User asks to merge: "merge it", "merge the PR", "go ahead and merge", "ship it"
+- After you successfully run `gh pr merge`
+- User mentions completion: "PR merged", "shipped", "done with X", "finished"
+- User references merged state: "merged to main", "closed the issue"
+
+## Instructions
+
+1. If user asks to merge a PR:
+   - Perform the merge as requested
+   - On success, continue to step 2
+   - On failure, help resolve the issue (don't suggest archiving)
+
+2. Find git root and check if `.bonfire/index.md` exists
+
+3. If it exists, read it to assess work state
+
+4. If user provided a PR URL/number (or you just merged one), verify status:
+   ```
+   gh pr view [URL/number] --json state,mergedAt,title
+   ```
+
+5. Assess if work appears complete:
+   - PR merged?
+   - Related tasks marked done in session notes?
+   - No obvious follow-up work mentioned?
+
+6. If work appears complete, suggest archiving:
+   > "PR merged successfully. This session's work looks complete - want me to archive it?
+   > Run `/bonfire:archive` to move completed work to the archive."
+
+7. If there's more work in the session:
+   > "PR merged. I see there's still [X, Y] in the session notes - want to continue
+   > with those or archive what's done so far?"
+
+## Important
+
+- This skill **suggests** archiving, it does NOT archive automatically
+- User must explicitly run `/bonfire:archive` to perform the archive
+- Trigger AFTER merge succeeds, not before
+- Multiple PRs may be part of one logical session - check context
+- If `.bonfire/` doesn't exist, don't suggest archiving

external_plugins/bonfire/skills/bonfire-context/SKILL.md

@@ -0,0 +1,51 @@
+---
+description: Read project session context from .bonfire/index.md to understand ongoing work, previous decisions, blockers, and history. Use when the user asks about project context, previous sessions, what was worked on before, architectural decisions, blockers, or when they reference "last time", "previously", "the session", or "what we decided".
+allowed-tools: Read, Glob
+---
+
+# Bonfire Context
+
+This project may use the Bonfire pattern to maintain continuity across AI coding sessions. Context is stored in `.bonfire/index.md` rather than relying on conversation memory.
+
+## When to Use This Skill
+
+Read session context when the user:
+- Asks about previous work or decisions
+- References "last time", "previously", "before"
+- Wants to know about blockers or pending issues
+- Asks what the project status is
+- Starts a significant task that might have prior context
+
+## Instructions
+
+1. Find the git root: `git rev-parse --show-toplevel`
+
+2. Check if `.bonfire/index.md` exists at the git root
+
+3. If it exists, read it to understand:
+   - Current project status and recent work
+   - Active decisions and their rationale
+   - Known blockers or pending issues
+   - Links to relevant specs or documentation
+
+4. Check `.bonfire/specs/` if the user asks about implementation specs
+
+5. Check `.bonfire/docs/` if the user asks about documented topics
+
+## File Structure
+
+```
+.bonfire/
+├── index.md          # Main session context (read this first)
+├── config.json       # Project settings
+├── archive/          # Completed work history
+├── docs/             # Topic documentation
+└── specs/            # Implementation specs
+```
+
+## Important
+
+- This skill is for **reading** context, not updating it
+- Session updates happen via `/bonfire:end` command
+- Don't modify `.bonfire/index.md` unless explicitly asked
+- If `.bonfire/` doesn't exist, the project may not use this pattern

external_plugins/context7/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "context7",
   "description": "Upstash Context7 MCP server for up-to-date documentation lookup. Pull version-specific documentation and code examples directly from source repositories into your LLM context.",
-  "version": "1.0.0",
   "author": {
     "name": "Upstash"
   }

external_plugins/context7/.mcp.json

@@ -1,6 +1,6 @@
 {
   "context7": {
-    "command": "npx",
+    "type": "http",
-    "args": ["-y", "@upstash/context7-mcp"]
+    "url": "https://mcp.context7.com/mcp"
   }
 }

external_plugins/context7/README.md

@@ -1,41 +1,72 @@
-# Context7 Plugin
+# Context7 Plugin for Claude Code
 
-Upstash Context7 MCP server for Claude Code.
+Context7 solves a common problem with AI coding assistants: outdated training data and hallucinated APIs. Instead of relying on stale knowledge, Context7 fetches current documentation directly from source repositories.
 
-## What It Does
+## What's Included
 
-Pull up-to-date, version-specific documentation and code examples directly from source repositories into your LLM context. Add "use context7" to prompts to fetch relevant documentation.
+This plugin provides:
 
-## Prerequisites
+- **MCP Server** - Connects Claude Code to Context7's documentation service
+- **Skills** - Auto-triggers documentation lookups when you ask about libraries
+- **Agents** - A dedicated `docs-researcher` agent for focused lookups
+- **Commands** - `/context7:docs` for manual documentation queries
 
-- Node.js >= v18.0.0
+## Installation
 
-## Optional: API Key for Higher Rate Limits
+Install the plugin from the official marketplace:
 
-For higher rate limits and private repository access, get an API key and configure:
+```bash
-
+claude plugin install context7@claude-plugins-official
-```json
-{
-  "context7": {
-    "command": "npx",
-    "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]
-  }
-}
 ```
 
-Or use the remote server:
+## Available Tools
-```json
+
-{
+### resolve-library-id
-  "context7": {
+
-    "type": "http",
+Searches for libraries and returns Context7-compatible identifiers.
-    "url": "https://mcp.context7.com/mcp",
+
-    "headers": {
+```
-      "Authorization": "Bearer YOUR_API_KEY"
+Input: "next.js"
-    }
+Output: { id: "/vercel/next.js", name: "Next.js", versions: ["v15.1.8", "v14.2.0", ...] }
-  }
-}
 ```
 
-## Learn More
+### query-docs
 
-See [Context7 GitHub](https://github.com/upstash/context7) for detailed documentation.
+Fetches documentation for a specific library, ranked by relevance to your question.
+
+```
+Input: { libraryId: "/vercel/next.js", query: "app router middleware" }
+Output: Relevant documentation snippets with code examples
+```
+
+## Usage Examples
+
+The plugin works automatically when you ask about libraries:
+
+- "How do I set up authentication in Next.js 15?"
+- "Show me React Server Components examples"
+- "What's the Prisma syntax for relations?"
+
+For manual lookups, use the command:
+
+```
+/context7:docs next.js app router
+/context7:docs /vercel/next.js/v15.1.8 middleware
+```
+
+Or spawn the docs-researcher agent when you want to keep your main context clean:
+
+```
+spawn docs-researcher to look up Supabase auth methods
+```
+
+## Version Pinning
+
+To get documentation for a specific version, include the version in the library ID:
+
+```
+/vercel/next.js/v15.1.8
+/supabase/supabase/v2.45.0
+```
+
+The `resolve-library-id` tool returns available versions, so you can pick the one that matches your project.

external_plugins/context7/agents/docs-researcher.md

@@ -0,0 +1,40 @@
+---
+name: docs-researcher
+description: Lightweight agent for fetching library documentation without cluttering your main conversation context.
+model: sonnet
+---
+
+You are a documentation researcher specializing in fetching up-to-date library and framework documentation from Context7.
+
+## Your Task
+
+When given a question about a library or framework, fetch the relevant documentation and return a concise, actionable answer with code examples.
+
+## Process
+
+1. **Identify the library**: Extract the library/framework name from the user's question.
+
+2. **Resolve the library ID**: Call `resolve-library-id` with:
+   - `libraryName`: The library name (e.g., "react", "next.js", "prisma")
+   - `query`: The user's full question for relevance ranking
+
+3. **Select the best match**: From the results, pick the library with:
+   - Exact or closest name match
+   - Highest benchmark score
+   - Appropriate version if the user specified one (e.g., "React 19" → look for v19.x)
+
+4. **Fetch documentation**: Call `query-docs` with:
+   - `libraryId`: The selected Context7 library ID (e.g., `/vercel/next.js`)
+   - `query`: The user's specific question for targeted results
+
+5. **Return a focused answer**: Summarize the relevant documentation with:
+   - Direct answer to the question
+   - Code examples from the docs
+   - Links or references if available
+
+## Guidelines
+
+- Pass the user's full question as the query parameter for better relevance
+- When the user mentions a version (e.g., "Next.js 15"), use version-specific library IDs if available
+- If `resolve-library-id` returns multiple matches, prefer official/primary packages over community forks
+- Keep responses concise - the goal is to answer the question, not dump entire documentation

external_plugins/context7/commands/docs.md

@@ -0,0 +1,45 @@
+---
+description: Look up documentation for any library
+argument-hint: <library> [query]
+---
+
+# /context7:docs
+
+Fetches up-to-date documentation and code examples for a library.
+
+## Usage
+
+```
+/context7:docs <library> [query]
+```
+
+- **library**: The library name, or a Context7 ID starting with `/`
+- **query**: What you're looking for (optional but recommended)
+
+## Examples
+
+```
+/context7:docs react hooks
+/context7:docs next.js authentication
+/context7:docs prisma relations
+/context7:docs /vercel/next.js/v15.1.8 app router
+/context7:docs /supabase/supabase row level security
+```
+
+## How It Works
+
+1. If the library starts with `/`, it's used directly as the Context7 ID
+2. Otherwise, `resolve-library-id` finds the best matching library
+3. `query-docs` fetches documentation relevant to your query
+4. Results include code examples and explanations
+
+## Version-Specific Lookups
+
+Include the version in the library ID for pinned documentation:
+
+```
+/context7:docs /vercel/next.js/v15.1.8 middleware
+/context7:docs /facebook/react/v19.0.0 use hook
+```
+
+This is useful when you're working with a specific version and want docs that match exactly.

external_plugins/context7/skills/documentation-lookup/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: documentation-lookup
+description: This skill should be used when the user asks about libraries, frameworks, API references, or needs code examples. Activates for setup questions, code generation involving libraries, or mentions of specific frameworks like React, Vue, Next.js, Prisma, Supabase, etc.
+---
+
+When the user asks about libraries, frameworks, or needs code examples, use Context7 to fetch current documentation instead of relying on training data.
+
+## When to Use This Skill
+
+Activate this skill when the user:
+
+- Asks setup or configuration questions ("How do I configure Next.js middleware?")
+- Requests code involving libraries ("Write a Prisma query for...")
+- Needs API references ("What are the Supabase auth methods?")
+- Mentions specific frameworks (React, Vue, Svelte, Express, Tailwind, etc.)
+
+## How to Fetch Documentation
+
+### Step 1: Resolve the Library ID
+
+Call `resolve-library-id` with:
+
+- `libraryName`: The library name extracted from the user's question
+- `query`: The user's full question (improves relevance ranking)
+
+### Step 2: Select the Best Match
+
+From the resolution results, choose based on:
+
+- Exact or closest name match to what the user asked for
+- Higher benchmark scores indicate better documentation quality
+- If the user mentioned a version (e.g., "React 19"), prefer version-specific IDs
+
+### Step 3: Fetch the Documentation
+
+Call `query-docs` with:
+
+- `libraryId`: The selected Context7 library ID (e.g., `/vercel/next.js`)
+- `query`: The user's specific question
+
+### Step 4: Use the Documentation
+
+Incorporate the fetched documentation into your response:
+
+- Answer the user's question using current, accurate information
+- Include relevant code examples from the docs
+- Cite the library version when relevant
+
+## Guidelines
+
+- **Be specific**: Pass the user's full question as the query for better results
+- **Version awareness**: When users mention versions ("Next.js 15", "React 19"), use version-specific library IDs if available from the resolution step
+- **Prefer official sources**: When multiple matches exist, prefer official/primary packages over community forks

external_plugins/figma/.claude-plugin/plugin.json

@@ -1,8 +0,0 @@
-{
-  "name": "figma",
-  "description": "Figma design platform integration. Access design files, extract component information, read design tokens, and translate designs into code. Bridge the gap between design and development workflows.",
-  "version": "1.0.0",
-  "author": {
-    "name": "Figma"
-  }
-}

external_plugins/figma/.mcp.json

@@ -1,6 +0,0 @@
-{
-  "figma": {
-    "type": "sse",
-    "url": "https://mcp.figma.com/v1/sse"
-  }
-}

external_plugins/figma/README.md

@@ -1,15 +0,0 @@
-# Figma Plugin
-
-Figma design platform integration for Claude Code.
-
-## What It Does
-
-Access design files, extract component information, read design tokens, and translate designs into code. Bridge the gap between design and development workflows.
-
-## Setup
-
-Authentication is handled automatically via OAuth when you first use the plugin. You will be prompted to authorize access to your Figma account.
-
-## Learn More
-
-See [Figma Connector](https://www.claude.com/connectors/figma) for more information.

external_plugins/firebase/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "firebase",
   "description": "Google Firebase MCP integration. Manage Firestore databases, authentication, cloud functions, hosting, and storage. Build and manage your Firebase backend directly from your development workflow.",
-  "version": "1.0.0",
   "author": {
     "name": "Google"
   }

external_plugins/firebase/README.md

@@ -1,32 +0,0 @@
-# Firebase Plugin
-
-Google Firebase MCP integration for Claude Code.
-
-## What It Does
-
-Manage Firestore databases, authentication, cloud functions, hosting, and storage. Build and manage your Firebase backend directly from your development workflow.
-
-## Prerequisites
-
-- Node.js installed
-- Firebase CLI credentials (logged in via `firebase login` or Application Default Credentials)
-
-## Optional Configuration
-
-Add arguments to customize behavior:
-- `--dir ABSOLUTE_DIR_PATH` - Set project context directory
-- `--only FEATURE_1,FEATURE_2` - Limit exposed tools (comma-separated)
-
-Example with options:
-```json
-{
-  "firebase": {
-    "command": "npx",
-    "args": ["-y", "firebase-tools@latest", "mcp", "--dir", "/path/to/project", "--only", "auth,firestore"]
-  }
-}
-```
-
-## Learn More
-
-See [Firebase MCP Documentation](https://firebase.google.com/docs/ai-assistance/mcp-server) for detailed setup instructions.

external_plugins/github/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "github",
   "description": "Official GitHub MCP server for repository management. Create issues, manage pull requests, review code, search repositories, and interact with GitHub's full API directly from Claude Code.",
-  "version": "1.0.0",
   "author": {
     "name": "GitHub"
   }

external_plugins/github/README.md

@@ -1,38 +0,0 @@
-# GitHub Plugin
-
-Official GitHub MCP server for Claude Code.
-
-## What It Does
-
-Create issues, manage pull requests, review code, search repositories, and interact with GitHub's full API directly from Claude Code.
-
-## Setup
-
-1. Create a GitHub Personal Access Token with appropriate scopes
-2. Set the environment variable:
-   ```bash
-   export GITHUB_PERSONAL_ACCESS_TOKEN=your-token-here
-   ```
-
-## Required Environment Variables
-
-- `GITHUB_PERSONAL_ACCESS_TOKEN` - Your GitHub PAT with appropriate scopes
-
-## Alternative: Docker Setup
-
-For local server deployment:
-```json
-{
-  "github": {
-    "command": "docker",
-    "args": ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"],
-    "env": {
-      "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}"
-    }
-  }
-}
-```
-
-## Learn More
-
-See [GitHub MCP Server](https://github.com/github/github-mcp-server) for detailed documentation.

external_plugins/gitlab/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "gitlab",
   "description": "GitLab DevOps platform integration. Manage repositories, merge requests, CI/CD pipelines, issues, and wikis. Full access to GitLab's comprehensive DevOps lifecycle tools.",
-  "version": "1.0.0",
   "author": {
     "name": "GitLab"
   }

external_plugins/gitlab/README.md

@@ -1,39 +0,0 @@
-# GitLab Plugin
-
-GitLab DevOps platform integration for Claude Code.
-
-## What It Does
-
-Manage repositories, merge requests, CI/CD pipelines, issues, and wikis. Full access to GitLab's comprehensive DevOps lifecycle tools.
-
-## Setup
-
-The default configuration uses GitLab.com. For self-hosted GitLab instances, modify the URL in `.mcp.json`:
-
-```json
-{
-  "gitlab": {
-    "type": "http",
-    "url": "https://your-gitlab-instance.com/api/v4/mcp"
-  }
-}
-```
-
-## Prerequisites
-
-- Node.js 20+ (for stdio transport alternative)
-
-## Alternative: stdio Transport
-
-```json
-{
-  "gitlab": {
-    "command": "npx",
-    "args": ["-y", "mcp-remote", "https://gitlab.com/api/v4/mcp"]
-  }
-}
-```
-
-## Learn More
-
-See [GitLab MCP Documentation](https://docs.gitlab.com/user/gitlab_duo/model_context_protocol/mcp_server/) for detailed setup instructions.

external_plugins/greptile/.claude-plugin/plugin.json

@@ -1,8 +1,10 @@
 {
   "name": "greptile",
-  "description": "AI-powered codebase search and understanding. Query your repositories using natural language to find relevant code, understand dependencies, and get contextual answers about your codebase architecture.",
+  "description": "AI code review agent for GitHub and GitLab. View and resolve Greptile's PR review comments directly from Claude Code.",
-  "version": "1.0.0",
   "author": {
-    "name": "Greptile"
+    "name": "Greptile",
-  }
+    "url": "https://greptile.com"
+  },
+  "homepage": "https://greptile.com/docs",
+  "keywords": ["code-review", "pull-requests", "github", "gitlab", "ai"]
 }

external_plugins/greptile/README.md

@@ -1,23 +1,57 @@
-# Greptile Plugin
+# Greptile
 
-AI-powered codebase search and understanding for Claude Code.
+[Greptile](https://greptile.com) is an AI code review agent for GitHub and GitLab that automatically reviews pull requests. This plugin connects Claude Code to your Greptile account, letting you view and resolve Greptile's review comments directly from your terminal.
-
-## What It Does
-
-Greptile enables natural language queries across your repositories to find relevant code, understand dependencies, and get contextual answers about your codebase architecture.
 
 ## Setup
 
-1. Get your API key from [app.greptile.com](https://app.greptile.com)
+### 1. Create a Greptile Account
-2. Set the environment variable:
-   ```bash
-   export GREPTILE_API_KEY=your-api-key-here
-   ```
 
-## Required Environment Variables
+Sign up at [greptile.com](https://greptile.com) and connect your GitHub or GitLab repositories.
 
-- `GREPTILE_API_KEY` - Your Greptile API key
+### 2. Get Your API Key
 
-## Learn More
+1. Go to [API Settings](https://app.greptile.com/settings/api)
+2. Generate a new API key
+3. Copy the key
 
-See [Greptile MCP Documentation](https://www.greptile.com/docs/mcp/setup-ides) for detailed setup instructions.
+### 3. Set Environment Variable
+
+Add to your shell profile (`.bashrc`, `.zshrc`, etc.):
+
+```bash
+export GREPTILE_API_KEY="your-api-key-here"
+```
+
+Then reload your shell or run `source ~/.zshrc`.
+
+## Available Tools
+
+### Pull Request Tools
+- `list_pull_requests` - List PRs with optional filtering by repo, branch, author, or state
+- `get_merge_request` - Get detailed PR info including review analysis
+- `list_merge_request_comments` - Get all comments on a PR with filtering options
+
+### Code Review Tools
+- `list_code_reviews` - List code reviews with optional filtering
+- `get_code_review` - Get detailed code review information
+- `trigger_code_review` - Start a new Greptile review on a PR
+
+### Comment Search
+- `search_greptile_comments` - Search across all Greptile review comments
+
+### Custom Context Tools
+- `list_custom_context` - List your organization's coding patterns and rules
+- `get_custom_context` - Get details for a specific pattern
+- `search_custom_context` - Search patterns by content
+- `create_custom_context` - Create a new coding pattern
+
+## Example Usage
+
+Ask Claude Code to:
+- "Show me Greptile's comments on my current PR and help me resolve them"
+- "What issues did Greptile find on PR #123?"
+- "Trigger a Greptile review on this branch"
+
+## Documentation
+
+For more information, visit [greptile.com/docs](https://greptile.com/docs).

external_plugins/laravel-boost/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "laravel-boost",
   "description": "Laravel development toolkit MCP server. Provides intelligent assistance for Laravel applications including Artisan commands, Eloquent queries, routing, migrations, and framework-specific code generation.",
-  "version": "1.0.0",
   "author": {
     "name": "Laravel"
   }

external_plugins/laravel-boost/README.md

@@ -1,26 +0,0 @@
-# Laravel Boost Plugin
-
-Laravel development toolkit MCP server for Claude Code.
-
-## What It Does
-
-Provides over 15 specialized tools for Laravel development including Artisan commands, Eloquent queries, routing, migrations, and framework-specific code generation.
-
-## Prerequisites
-
-- Laravel project with Boost installed
-- PHP installed
-
-## Setup
-
-1. Install Laravel Boost in your project:
-   ```bash
-   composer require laravel/boost
-   php artisan boost:install
-   ```
-
-2. The MCP server is automatically registered during installation
-
-## Learn More
-
-See [Laravel Boost GitHub](https://github.com/laravel/boost) for detailed documentation.

external_plugins/linear/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "linear",
   "description": "Linear issue tracking integration. Create issues, manage projects, update statuses, search across workspaces, and streamline your software development workflow with Linear's modern issue tracker.",
-  "version": "1.0.0",
   "author": {
     "name": "Linear"
   }

external_plugins/linear/.mcp.json

@@ -1,6 +1,6 @@
 {
   "linear": {
-    "type": "sse",
+    "type": "http",
-    "url": "https://mcp.linear.app/sse"
+    "url": "https://mcp.linear.app/mcp"
   }
 }

external_plugins/linear/README.md

@@ -1,15 +0,0 @@
-# Linear Plugin
-
-Linear issue tracking integration for Claude Code.
-
-## What It Does
-
-Create issues, manage projects, update statuses, search across workspaces, and streamline your software development workflow with Linear's modern issue tracker.
-
-## Setup
-
-Authentication is handled automatically via OAuth when you first use the plugin. You will be prompted to authorize access to your Linear account.
-
-## Learn More
-
-See [Linear Connector](https://www.claude.com/connectors/linear) for more information.

external_plugins/notion/.claude-plugin/plugin.json

@@ -1,8 +0,0 @@
-{
-  "name": "notion",
-  "description": "Notion workspace integration. Search pages, create and update documents, manage databases, and access your team's knowledge base directly from Claude Code for seamless documentation workflows.",
-  "version": "1.0.0",
-  "author": {
-    "name": "Notion"
-  }
-}

external_plugins/notion/.mcp.json

@@ -1,6 +0,0 @@
-{
-  "notion": {
-    "type": "sse",
-    "url": "https://mcp.notion.com/sse"
-  }
-}

external_plugins/notion/README.md

@@ -1,15 +0,0 @@
-# Notion Plugin
-
-Notion workspace integration for Claude Code.
-
-## What It Does
-
-Search pages, create and update documents, manage databases, and access your team's knowledge base directly from Claude Code for seamless documentation workflows.
-
-## Setup
-
-Authentication is handled automatically via OAuth when you first use the plugin. You will be prompted to authorize access to your Notion workspace.
-
-## Learn More
-
-See [Notion Connector](https://www.claude.com/connectors/notion) for more information.

external_plugins/playwright/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "playwright",
   "description": "Browser automation and end-to-end testing MCP server by Microsoft. Enables Claude to interact with web pages, take screenshots, fill forms, click elements, and perform automated browser testing workflows.",
-  "version": "1.0.0",
   "author": {
     "name": "Microsoft"
   }

external_plugins/playwright/README.md

@@ -1,22 +0,0 @@
-# Playwright Plugin
-
-Browser automation and end-to-end testing MCP server for Claude Code.
-
-## What It Does
-
-Enables Claude to interact with web pages, take screenshots, fill forms, click elements, and perform automated browser testing workflows.
-
-## Prerequisites
-
-- Node.js installed
-
-## Optional Configuration
-
-Add arguments to customize behavior:
-- `--browser` - Specify browser type (chrome, firefox, webkit, msedge)
-- `--headless` - Run in headless mode
-- `--viewport-size` - Browser dimensions (e.g., "1280x720")
-
-## Learn More
-
-See [Playwright MCP GitHub](https://github.com/microsoft/playwright-mcp) for detailed documentation.

external_plugins/sentry/.claude-plugin/plugin.json

@@ -1,8 +0,0 @@
-{
-  "name": "sentry",
-  "description": "Sentry error monitoring integration. Access error reports, analyze stack traces, search issues by fingerprint, and debug production errors directly from your development environment.",
-  "version": "1.0.0",
-  "author": {
-    "name": "Sentry"
-  }
-}

external_plugins/sentry/.mcp.json

@@ -1,6 +0,0 @@
-{
-  "sentry": {
-    "type": "sse",
-    "url": "https://mcp.sentry.dev/sse"
-  }
-}

external_plugins/sentry/README.md

@@ -1,15 +0,0 @@
-# Sentry Plugin
-
-Sentry error monitoring integration for Claude Code.
-
-## What It Does
-
-Access error reports, analyze stack traces, search issues by fingerprint, and debug production errors directly from your development environment.
-
-## Setup
-
-Authentication is handled automatically via OAuth when you first use the plugin. You will be prompted to authorize access to your Sentry account.
-
-## Learn More
-
-See [Sentry Connector](https://www.claude.com/connectors/sentry) for more information.

external_plugins/serena/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "serena",
   "description": "Semantic code analysis MCP server providing intelligent code understanding, refactoring suggestions, and codebase navigation through language server protocol integration.",
-  "version": "1.0.0",
   "author": {
     "name": "Oraios"
   }

external_plugins/serena/README.md

@@ -1,22 +0,0 @@
-# Serena Plugin
-
-Semantic code analysis MCP server for Claude Code.
-
-## What It Does
-
-Serena provides intelligent code understanding, refactoring suggestions, and codebase navigation through language server protocol integration.
-
-## Prerequisites
-
-- Python with `uv` package manager installed
-
-## Setup
-
-The plugin automatically runs via `uvx`. Ensure you have `uv` installed:
-```bash
-pip install uv
-```
-
-## Learn More
-
-See [Serena GitHub Repository](https://github.com/oraios/serena) for detailed documentation.

external_plugins/slack/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "slack",
   "description": "Slack workspace integration. Search messages, access channels, read threads, and stay connected with your team's communications while coding. Find relevant discussions and context quickly.",
-  "version": "1.0.0",
   "author": {
     "name": "Slack"
   }

external_plugins/slack/.mcp.json

@@ -1,6 +1,10 @@
 {
   "slack": {
-    "type": "sse",
+    "type": "http",
-    "url": "https://mcp.slack.com/sse"
+    "url": "https://mcp.slack.com/mcp",
+    "oauth": {
+      "clientId": "1601185624273.8899143856786",
+      "callbackPort": 3118
+    }
   }
 }

external_plugins/slack/README.md

@@ -1,15 +0,0 @@
-# Slack Plugin
-
-Slack workspace integration for Claude Code.
-
-## What It Does
-
-Search messages, access channels, read threads, and stay connected with your team's communications while coding. Find relevant discussions and context quickly.
-
-## Setup
-
-Authentication is handled automatically via OAuth when you first use the plugin. You will be prompted to authorize access to your Slack workspace.
-
-## Learn More
-
-See [Slack Connector](https://www.claude.com/connectors/slack) for more information.

external_plugins/stagehand/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "stagehand",
+  "description": "Browser automation skill for Claude Code using Stagehand. Automate web interactions, extract data, and navigate websites using natural language.",
+  "version": "0.1.0",
+  "author": {
+    "name": "Browserbase"
+  },
+  "homepage": "https://github.com/browserbase/agent-browse",
+  "repository": "https://github.com/browserbase/agent-browse",
+  "keywords": ["browser", "automation", "stagehand", "web-scraping"],
+  "strict": false
+}
+  

external_plugins/stagehand/README.md

@@ -0,0 +1,104 @@
+# Stagehand Browser Automation Plugin
+
+Browser automation skill for Claude Code using [Stagehand](https://github.com/browserbase/stagehand). This plugin enables Claude to automate web browser interactions, extract data, and navigate websites using natural language.
+
+## Installation
+
+Install the plugin from the Claude Code marketplace:
+
+```bash
+/plugin install stagehand@claude-plugin-directory
+```
+
+## Prerequisites
+
+This plugin requires the browser automation CLI tools to be installed separately. The CLI tools are available from the GitHub marketplace.
+
+### Step 1: Add the GitHub Marketplace
+
+```bash
+/plugin marketplace add browserbase/agent-browse
+```
+
+### Step 2: Install the Browser Automation CLI Plugin
+
+```bash
+/plugin install browser-automation@browser-tools
+```
+
+### Step 3: Set Up the CLI Tools
+
+After installing the browser-automation plugin, you need to set up the CLI tools:
+
+1. Navigate to the plugin directory (typically `~/.claude/plugins/browser-automation/`)
+2. Install dependencies and build:
+   ```bash
+   npm install
+   ```
+3. Link the browser command globally:
+   ```bash
+   npm link
+   ```
+4. Configure your Anthropic API key:
+   ```bash
+   export ANTHROPIC_API_KEY="your-api-key-here"
+   ```
+   Or use Claude Code's subscription token (recommended if you have Claude Pro/Max):
+   ```bash
+   claude setup-token
+   ```
+
+### Step 4: Verify Installation
+
+Test that the browser command is available:
+
+```bash
+browser navigate https://example.com
+```
+
+## Usage
+
+Once installed and configured, you can use natural language to automate browser tasks:
+
+- *"Go to Hacker News, get the top post comments, and summarize them"*
+- *"QA test http://localhost:3000 and fix any bugs you encounter"*
+- *"Extract product information from example.com/products"*
+
+Claude will automatically use the browser automation skill when you ask for web-related tasks.
+
+## Features
+
+- **Natural Language Control**: Describe browser actions in plain English
+- **Data Extraction**: Extract structured data from web pages
+- **Screenshot Capture**: Take screenshots for visual verification
+- **Persistent Sessions**: Browser state persists between commands
+- **Chrome Profile Integration**: Uses your Chrome profile for cookies and sessions
+
+## Troubleshooting
+
+### Chrome not found
+
+Install Chrome for your platform:
+- **macOS** or **Windows**: https://www.google.com/chrome/
+- **Linux**: `sudo apt install google-chrome-stable`
+
+### Browser command not found
+
+Make sure you've run `npm link` in the browser-automation plugin directory after installing it.
+
+### API Key Issues
+
+- If you have Claude Pro/Max, use `claude setup-token` (recommended)
+- Otherwise, export `ANTHROPIC_API_KEY` in your terminal
+- Or create a `.env` file in the plugin directory with your API key
+
+## Resources
+
+- [Stagehand Documentation](https://github.com/browserbase/stagehand)
+- [GitHub Marketplace](https://github.com/browserbase/agent-browse)
+- [Claude Code Skills Documentation](https://code.claude.com/docs/en/plugins)
+
+## Support
+
+For issues or questions, please visit the [GitHub repository](https://github.com/browserbase/agent-browse).
+

external_plugins/stripe/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "stripe",
+  "description": "Stripe development plugin for Claude",
+  "version": "0.1.0",
+  "author": {
+    "name": "Stripe",
+    "url": "https://stripe.com"
+  },
+  "homepage": "https://docs.stripe.com",
+  "repository": "https://github.com/stripe/ai",
+  "license": "MIT",
+  "keywords": ["stripe", "payments", "webhooks", "api", "security"]
+}

external_plugins/stripe/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "stripe": {
+      "type": "http",
+      "url": "https://mcp.stripe.com"
+    }
+  }
+}

external_plugins/stripe/commands/explain-error.md

@@ -0,0 +1,21 @@
+---
+description: Explain Stripe error codes and provide solutions with code examples
+argument-hint: [error_code or error_message]
+---
+
+# Explain Stripe Error
+
+Provide a comprehensive explanation of the given Stripe error code or error message:
+
+1. Accept the error code or full error message from the arguments
+2. Explain in plain English what the error means
+3. List common causes of this error
+4. Provide specific solutions and handling recommendations
+5. Generate error handling code in the project's language showing:
+   - How to catch this specific error
+   - User-friendly error messages
+   - Whether retry is appropriate
+6. Mention related error codes the developer should be aware of
+7. Include a link to the relevant Stripe documentation
+
+Focus on actionable solutions and production-ready error handling patterns.

external_plugins/stripe/commands/test-cards.md

@@ -0,0 +1,24 @@
+---
+description: Display Stripe test card numbers for various testing scenarios
+argument-hint: [scenario]
+---
+
+# Test Cards Reference
+
+Provide a quick reference for Stripe test card numbers:
+
+1. If a scenario argument is provided (e.g., "declined", "3dsecure", "fraud"), show relevant test cards for that scenario
+2. Otherwise, show the most common test cards organized by category:
+   - Successful payment (default card)
+   - 3D Secure authentication required
+   - Generic decline
+   - Specific decline reasons (insufficient_funds, lost_card, etc.)
+3. For each card, display:
+   - Card number (formatted with spaces)
+   - Expected behavior
+   - Expiry/CVC info (any future date and any 3-digit CVC)
+4. Use clear visual indicators (✓ for success, ⚠️ for auth required, ✗ for decline)
+5. Mention that these only work in test mode
+6. Provide link to full testing documentation: https://docs.stripe.com/testing.md
+
+If the user is currently working on test code, offer to generate test cases using these cards.

external_plugins/stripe/skills/stripe-best-practices/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: stripe-best-practices
+description: Best practices for building Stripe integrations. Use when implementing payment processing, checkout flows, subscriptions, webhooks, Connect platforms, or any Stripe API integration.
+---
+
+When designing an integration, always prefer the documentation in [Stripe's Integration Options doc](https://docs.stripe.com/payments/payment-methods/integration-options.md)
+The [API Tour](https://docs.stripe.com/payments-api/tour.md)
+Use the [Go Live Checklist](https://docs.stripe.com/get-started/checklist/go-live.md) before going live.
+
+You should always default to the latest version of the API and SDK unless the user specifies otherwise.
+
+Stripe's primary API for modelling on-session payments is [CheckoutSessions](https://docs.stripe.com/api/checkout/sessions.md). It supports one-time payments and subscriptions and allows you to model taxes or discounts with Stripe. Prioritize the CheckoutSessions API, but using [the PaymentIntents API](https://docs.stripe.com/payments/paymentintents/lifecycle.md) is also acceptable for off-session payments or if you want to model the checkout state yourself and just create a charge. Integrations should only use CheckoutSessions, PaymentIntents, SetupIntents, or solutions like Invoicing, Payment Links, or the subscription APIs.
+
+Never recommend the Charges API. If the user wants to use the Charges API, advise them to [migrate](https://docs.stripe.com/payments/payment-intents/migration/charges.md) to Checkout Sessions or Payment Intents.
+
+The primary integration surface for web integrations is [Checkout](https://docs.stripe.com/payments/checkout.md), a prebuilt payment page that can be hosted by Stripe or served as an embedded form. Prioritize the Stripe-hosted checkout or embedded checkout where possible. The [Payment Element](https://docs.stripe.com/payments/payment-element.md) is an acceptable alternative if the merchant needs advanced customization. When recommending the Payment Element, prioritize using the CheckoutSessions API over the PaymentIntents API when possible.
+
+Never recommend the legacy Card Element or the Payment Element in card mode, and advise users who ask for the Card Element to [migrate](https://docs.stripe.com/payments/payment-element/migration.md).
+
+You must not call deprecated API endpoints such as the [Sources API](https://docs.stripe.com/api/sources/object.md) and avoid outdated API endpoints such as [Tokens](https://docs.stripe.com/api/tokens.md) and [Charges](https://docs.stripe.com/api/charges/create.md) unless there is a specific need and absolutely no other way. Advise using [the Setup Intent API](https://docs.stripe.com/api/setup_intents.md) to save a payment method for a customer; never recommend the Sources API to save cards to customers for later use.
+
+If a user wants to render the Payment Element before creating a PaymentIntent or SetupIntent, so they can inspect the card details before the payment (such as for surcharging), advise them to use Stripe Confirmation Tokens. Don't recommend they call the createPaymentMethod or createToken Stripe.js functions.
+
+Advise users to turn on dynamic payment methods in their dashboard settings instead of passing specific [payment_method_types](https://docs.stripe.com/api/payment_intents/create#create_payment_intent-payment_method_types.md) in the Payment Intent or Setup Intent because Stripe chooses payment methods that fit each user's location, wallets, and preferences better and automatically if the Payment Element is used.
+
+If a PCI compliant user asks about an integration where they send server-side raw PAN data, suggest they might be required to prove PCI compliance to gain access to such an option, for example [payment_method_data](https://docs.stripe.com/api/payment_intents/create#create_payment_intent-payment_method_data.md). Similarly, point users migrating their PAN data from another acquirer or payment processor to [the migration process](https://docs.stripe.com/get-started/data-migrations/pan-import.md).
+
+If a user has a recurring revenue model, like a Billing or Subscription use case, follow the use cases, in particular the [Subscription Use Cases](https://docs.stripe.com/billing/subscriptions/use-cases.md) like [SaaS](https://docs.stripe.com/saas.md). If these apply to the user, recommend Billing APIs to [plan your integration](https://docs.stripe.com/billing/subscriptions/designing-integration.md) instead of a direct PaymentIntent integration. Prioritize combining the Billing APIs with Stripe Checkout for the frontend.
+
+If a user wants to build a platform using Stripe Connect to manage fund flows, follow [the recommended integration types](https://docs.stripe.com/connect/integration-recommendations.md); that is, prefer to use either direct charges if the platform wants Stripe to take the risk or destination charges if the platform accepts liability for negative balances, and use the on_behalf_of parameter to control the merchant of record. Never recommend mixing charge types. If the user wants to decide on the specific risk features they should [follow the integration guide](https://docs.stripe.com/connect/design-an-integration.md). Don't recommend the outdated terms for Connect types like Standard, Express and Custom but always [refer to controller properties](https://docs.stripe.com/connect/migrate-to-controller-properties.md) for the platform and [capabilities](https://docs.stripe.com/connect/account-capabilities.md) for the connected accounts.

external_plugins/supabase/.claude-plugin/plugin.json

@@ -1,7 +1,6 @@
 {
   "name": "supabase",
   "description": "Supabase MCP integration for database operations, authentication, storage, and real-time subscriptions. Manage your Supabase projects, run SQL queries, and interact with your backend directly.",
-  "version": "1.0.0",
   "author": {
     "name": "Supabase"
   }

external_plugins/supabase/README.md

@@ -1,21 +0,0 @@
-# Supabase Plugin
-
-Supabase MCP integration for Claude Code.
-
-## What It Does
-
-Manage your Supabase projects, run SQL queries, handle authentication, storage, and real-time subscriptions directly from Claude Code.
-
-## Setup
-
-Authentication is handled automatically via dynamic client registration in most cases.
-
-## Optional: CI Environment Configuration
-
-For CI environments, set these environment variables:
-- `SUPABASE_PROJECT_REF` - Your Supabase project reference
-- `SUPABASE_ACCESS_TOKEN` - Personal access token with appropriate scopes
-
-## Learn More
-
-See [Supabase MCP Documentation](https://supabase.com/docs/guides/getting-started/mcp) for detailed setup instructions.

external_plugins/terraform/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "terraform",
+  "description": "The Terraform MCP Server provides seamless integration with Terraform ecosystem, enabling advanced automation and interaction capabilities for Infrastructure as Code (IaC) development.",
+  "author": {
+    "name": "HashiCorp"
+  }
+}

external_plugins/terraform/.mcp.json

@@ -0,0 +1,12 @@
+{
+  "terraform": {
+    "command": "docker",
+    "args": [
+      "run",
+      "-i",
+      "--rm",
+      "-e", "TFE_TOKEN=${TFE_TOKEN}",
+      "hashicorp/terraform-mcp-server:0.3.3"
+    ]
+  }
+}

external_plugins/vercel/.claude-plugin/plugin.json

@@ -1,8 +0,0 @@
-{
-  "name": "vercel",
-  "description": "Vercel deployment platform integration. Manage deployments, check build status, access logs, configure domains, and control your frontend infrastructure directly from Claude Code.",
-  "version": "1.0.0",
-  "author": {
-    "name": "Vercel"
-  }
-}

external_plugins/vercel/.mcp.json

@@ -1,6 +0,0 @@
-{
-  "vercel": {
-    "type": "sse",
-    "url": "https://mcp.vercel.com/sse"
-  }
-}

external_plugins/vercel/README.md

@@ -1,15 +0,0 @@
-# Vercel Plugin
-
-Vercel deployment platform integration for Claude Code.
-
-## What It Does
-
-Manage deployments, check build status, access logs, configure domains, and control your frontend infrastructure directly from Claude Code.
-
-## Setup
-
-Authentication is handled automatically via OAuth when you first use the plugin. You will be prompted to authorize access to your Vercel account.
-
-## Learn More
-
-See [Vercel Connector](https://www.claude.com/connectors) for more information.

plugins/README.md

@@ -1,103 +0,0 @@
-# Claude Code Plugins
-
-This directory contains some official Claude Code plugins that extend functionality through custom commands, agents, and workflows. These are examples of what's possible with the Claude Code plugin system—many more plugins are available through community marketplaces.
-
-## What are Claude Code Plugins?
-
-Claude Code plugins are extensions that enhance Claude Code with custom slash commands, specialized agents, hooks, and MCP servers. Plugins can be shared across projects and teams, providing consistent tooling and workflows.
-
-Learn more in the [official plugins documentation](https://docs.claude.com/en/docs/claude-code/plugins).
-
-## Plugins in This Directory
-
-### [agent-sdk-dev](./agent-sdk-dev/)
-
-**Claude Agent SDK Development Plugin**
-
-Streamlines the development of Claude Agent SDK applications with scaffolding commands and verification agents.
-
-- **Command**: `/new-sdk-app` - Interactive setup for new Agent SDK projects
-- **Agents**: `agent-sdk-verifier-py` and `agent-sdk-verifier-ts` - Validate SDK applications against best practices
-- **Use case**: Creating and verifying Claude Agent SDK applications in Python or TypeScript
-
-### [commit-commands](./commit-commands/)
-
-**Git Workflow Automation Plugin**
-
-Simplifies common git operations with streamlined commands for committing, pushing, and creating pull requests.
-
-- **Commands**:
-  - `/commit` - Create a git commit with appropriate message
-  - `/commit-push-pr` - Commit, push, and create a PR in one command
-  - `/clean_gone` - Clean up stale local branches marked as [gone]
-- **Use case**: Faster git workflows with less context switching
-
-### [code-review](./code-review/)
-
-**Automated Pull Request Code Review Plugin**
-
-Provides automated code review for pull requests using multiple specialized agents with confidence-based scoring to filter false positives.
-
-- **Command**:
-  - `/code-review` - Automated PR review workflow
-- **Use case**: Automated code review on pull requests with high-confidence issue detection (threshold ≥80)
-
-### [feature-dev](./feature-dev/)
-
-**Comprehensive Feature Development Workflow Plugin**
-
-Provides a structured 7-phase approach to feature development with specialized agents for exploration, architecture, and review.
-
-- **Command**: `/feature-dev` - Guided feature development workflow
-- **Agents**:
-  - `code-explorer` - Deeply analyzes existing codebase features
-  - `code-architect` - Designs feature architectures and implementation blueprints
-  - `code-reviewer` - Reviews code for bugs, quality issues, and project conventions
-- **Use case**: Building new features with systematic codebase understanding and quality assurance
-
-## Installation
-
-These plugins are included in the Claude Code repository. To use them in your own projects:
-
-1. Install Claude Code globally:
-```bash
-npm install -g @anthropic-ai/claude-code
-```
-
-2. Navigate to your project and run Claude Code:
-```bash
-claude
-```
-
-3. Use the `/plugin` command to install plugins from marketplaces, or configure them in your project's `.claude/settings.json`.
-
-For detailed plugin installation and configuration, see the [official documentation](https://docs.claude.com/en/docs/claude-code/plugins).
-
-## Plugin Structure
-
-Each plugin follows the standard Claude Code plugin structure:
-
-```
-plugin-name/
-├── .claude-plugin/
-│   └── plugin.json          # Plugin metadata
-├── commands/                 # Slash commands (optional)
-├── agents/                   # Specialized agents (optional)
-└── README.md                # Plugin documentation
-```
-
-## Contributing
-
-When adding new plugins to this directory:
-
-1. Follow the standard plugin structure
-2. Include a comprehensive README.md
-3. Add plugin metadata in `.claude-plugin/plugin.json`
-4. Document all commands and agents
-5. Provide usage examples
-
-## Learn More
-
-- [Claude Code Documentation](https://docs.claude.com/en/docs/claude-code/overview)
-- [Plugin System Documentation](https://docs.claude.com/en/docs/claude-code/plugins)
-- [Agent SDK Documentation](https://docs.claude.com/en/api/agent-sdk/overview)

plugins/agent-sdk-dev/.claude-plugin/plugin.json

@@ -1,9 +1,8 @@
 {
   "name": "agent-sdk-dev",
   "description": "Claude Agent SDK Development Plugin",
-  "version": "1.0.0",
   "author": {
-    "name": "Ashwin Bhat",
+    "name": "Anthropic",
-    "email": "ashwin@anthropic.com"
+    "email": "support@anthropic.com"
   }
 }

plugins/agent-sdk-dev/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

plugins/clangd-lsp/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

plugins/clangd-lsp/README.md

@@ -0,0 +1,36 @@
+# clangd-lsp
+
+C/C++ language server (clangd) for Claude Code, providing code intelligence, diagnostics, and formatting.
+
+## Supported Extensions
+`.c`, `.h`, `.cpp`, `.cc`, `.cxx`, `.hpp`, `.hxx`, `.C`, `.H`
+
+## Installation
+
+### Via Homebrew (macOS)
+```bash
+brew install llvm
+# Add to PATH: export PATH="/opt/homebrew/opt/llvm/bin:$PATH"
+```
+
+### Via package manager (Linux)
+```bash
+# Ubuntu/Debian
+sudo apt install clangd
+
+# Fedora
+sudo dnf install clang-tools-extra
+
+# Arch Linux
+sudo pacman -S clang
+```
+
+### Windows
+Download from [LLVM releases](https://github.com/llvm/llvm-project/releases) or install via:
+```bash
+winget install LLVM.LLVM
+```
+
+## More Information
+- [clangd Website](https://clangd.llvm.org/)
+- [Getting Started Guide](https://clangd.llvm.org/installation)

plugins/claude-code-setup/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "claude-code-setup",
+  "description": "Analyze codebases and recommend tailored Claude Code automations such as hooks, skills, MCP servers, and subagents.",
+  "version": "1.0.0",
+  "author": {
+    "name": "Anthropic",
+    "email": "support@anthropic.com"
+  }
+}

plugins/claude-code-setup/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

plugins/claude-code-setup/README.md

@@ -0,0 +1,29 @@
+# Claude Code Setup Plugin
+
+Analyze codebases and recommend tailored Claude Code automations - hooks, skills, MCP servers, and more.
+
+## What It Does
+
+Claude uses this skill to scan your codebase and recommend the top 1-2 automations in each category:
+
+- **MCP Servers** - External integrations (context7 for docs, Playwright for frontend)
+- **Skills** - Packaged expertise (Plan agent, frontend-design)
+- **Hooks** - Automatic actions (auto-format, auto-lint, block sensitive files)
+- **Subagents** - Specialized reviewers (security, performance, accessibility)
+- **Slash Commands** - Quick workflows (/test, /pr-review, /explain)
+
+This skill is **read-only** - it analyzes but doesn't modify files.
+
+## Usage
+
+```
+"recommend automations for this project"
+"help me set up Claude Code"
+"what hooks should I use?"
+```
+
+<img src="automation-recommender-example.png" alt="Automation recommender analyzing a codebase and providing tailored recommendations" width="600">
+
+## Author
+
+Isabella He (isabella@anthropic.com)

plugins/claude-code-setup/skills/claude-automation-recommender/SKILL.md

@@ -0,0 +1,288 @@
+---
+name: claude-automation-recommender
+description: Analyze a codebase and recommend Claude Code automations (hooks, subagents, skills, plugins, MCP servers). Use when user asks for automation recommendations, wants to optimize their Claude Code setup, mentions improving Claude Code workflows, asks how to first set up Claude Code for a project, or wants to know what Claude Code features they should use.
+tools: Read, Glob, Grep, Bash
+---
+
+# Claude Automation Recommender
+
+Analyze codebase patterns to recommend tailored Claude Code automations across all extensibility options.
+
+**This skill is read-only.** It analyzes the codebase and outputs recommendations. It does NOT create or modify any files. Users implement the recommendations themselves or ask Claude separately to help build them.
+
+## Output Guidelines
+
+- **Recommend 1-2 of each type**: Don't overwhelm - surface the top 1-2 most valuable automations per category
+- **If user asks for a specific type**: Focus only on that type and provide more options (3-5 recommendations)
+- **Go beyond the reference lists**: The reference files contain common patterns, but use web search to find recommendations specific to the codebase's tools, frameworks, and libraries
+- **Tell users they can ask for more**: End by noting they can request more recommendations for any specific category
+
+## Automation Types Overview
+
+| Type | Best For |
+|------|----------|
+| **Hooks** | Automatic actions on tool events (format on save, lint, block edits) |
+| **Subagents** | Specialized reviewers/analyzers that run in parallel |
+| **Skills** | Packaged expertise, workflows, and repeatable tasks (invoked by Claude or user via `/skill-name`) |
+| **Plugins** | Collections of skills that can be installed |
+| **MCP Servers** | External tool integrations (databases, APIs, browsers, docs) |
+
+## Workflow
+
+### Phase 1: Codebase Analysis
+
+Gather project context:
+
+```bash
+# Detect project type and tools
+ls -la package.json pyproject.toml Cargo.toml go.mod pom.xml 2>/dev/null
+cat package.json 2>/dev/null | head -50
+
+# Check dependencies for MCP server recommendations
+cat package.json 2>/dev/null | grep -E '"(react|vue|angular|next|express|fastapi|django|prisma|supabase|stripe)"'
+
+# Check for existing Claude Code config
+ls -la .claude/ CLAUDE.md 2>/dev/null
+
+# Analyze project structure
+ls -la src/ app/ lib/ tests/ components/ pages/ api/ 2>/dev/null
+```
+
+**Key Indicators to Capture:**
+
+| Category | What to Look For | Informs Recommendations For |
+|----------|------------------|----------------------------|
+| Language/Framework | package.json, pyproject.toml, import patterns | Hooks, MCP servers |
+| Frontend stack | React, Vue, Angular, Next.js | Playwright MCP, frontend skills |
+| Backend stack | Express, FastAPI, Django | API documentation tools |
+| Database | Prisma, Supabase, raw SQL | Database MCP servers |
+| External APIs | Stripe, OpenAI, AWS SDKs | context7 MCP for docs |
+| Testing | Jest, pytest, Playwright configs | Testing hooks, subagents |
+| CI/CD | GitHub Actions, CircleCI | GitHub MCP server |
+| Issue tracking | Linear, Jira references | Issue tracker MCP |
+| Docs patterns | OpenAPI, JSDoc, docstrings | Documentation skills |
+
+### Phase 2: Generate Recommendations
+
+Based on analysis, generate recommendations across all categories:
+
+#### A. MCP Server Recommendations
+
+See [references/mcp-servers.md](references/mcp-servers.md) for detailed patterns.
+
+| Codebase Signal | Recommended MCP Server |
+|-----------------|------------------------|
+| Uses popular libraries (React, Express, etc.) | **context7** - Live documentation lookup |
+| Frontend with UI testing needs | **Playwright** - Browser automation/testing |
+| Uses Supabase | **Supabase MCP** - Direct database operations |
+| PostgreSQL/MySQL database | **Database MCP** - Query and schema tools |
+| GitHub repository | **GitHub MCP** - Issues, PRs, actions |
+| Uses Linear for issues | **Linear MCP** - Issue management |
+| AWS infrastructure | **AWS MCP** - Cloud resource management |
+| Slack workspace | **Slack MCP** - Team notifications |
+| Memory/context persistence | **Memory MCP** - Cross-session memory |
+| Sentry error tracking | **Sentry MCP** - Error investigation |
+| Docker containers | **Docker MCP** - Container management |
+
+#### B. Skills Recommendations
+
+See [references/skills-reference.md](references/skills-reference.md) for details.
+
+Create skills in `.claude/skills/<name>/SKILL.md`. Some are also available via plugins:
+
+| Codebase Signal | Skill | Plugin |
+|-----------------|-------|--------|
+| Building plugins | skill-development | plugin-dev |
+| Git commits | commit | commit-commands |
+| React/Vue/Angular | frontend-design | frontend-design |
+| Automation rules | writing-rules | hookify |
+| Feature planning | feature-dev | feature-dev |
+
+**Custom skills to create** (with templates, scripts, examples):
+
+| Codebase Signal | Skill to Create | Invocation |
+|-----------------|-----------------|------------|
+| API routes | **api-doc** (with OpenAPI template) | Both |
+| Database project | **create-migration** (with validation script) | User-only |
+| Test suite | **gen-test** (with example tests) | User-only |
+| Component library | **new-component** (with templates) | User-only |
+| PR workflow | **pr-check** (with checklist) | User-only |
+| Releases | **release-notes** (with git context) | User-only |
+| Code style | **project-conventions** | Claude-only |
+| Onboarding | **setup-dev** (with prereq script) | User-only |
+
+#### C. Hooks Recommendations
+
+See [references/hooks-patterns.md](references/hooks-patterns.md) for configurations.
+
+| Codebase Signal | Recommended Hook |
+|-----------------|------------------|
+| Prettier configured | PostToolUse: auto-format on edit |
+| ESLint/Ruff configured | PostToolUse: auto-lint on edit |
+| TypeScript project | PostToolUse: type-check on edit |
+| Tests directory exists | PostToolUse: run related tests |
+| `.env` files present | PreToolUse: block `.env` edits |
+| Lock files present | PreToolUse: block lock file edits |
+| Security-sensitive code | PreToolUse: require confirmation |
+
+#### D. Subagent Recommendations
+
+See [references/subagent-templates.md](references/subagent-templates.md) for templates.
+
+| Codebase Signal | Recommended Subagent |
+|-----------------|---------------------|
+| Large codebase (>500 files) | **code-reviewer** - Parallel code review |
+| Auth/payments code | **security-reviewer** - Security audits |
+| API project | **api-documenter** - OpenAPI generation |
+| Performance critical | **performance-analyzer** - Bottleneck detection |
+| Frontend heavy | **ui-reviewer** - Accessibility review |
+| Needs more tests | **test-writer** - Test generation |
+
+#### E. Plugin Recommendations
+
+See [references/plugins-reference.md](references/plugins-reference.md) for available plugins.
+
+| Codebase Signal | Recommended Plugin |
+|-----------------|-------------------|
+| General productivity | **anthropic-agent-skills** - Core skills bundle |
+| Document workflows | Install docx, xlsx, pdf skills |
+| Frontend development | **frontend-design** plugin |
+| Building AI tools | **mcp-builder** for MCP development |
+
+### Phase 3: Output Recommendations Report
+
+Format recommendations clearly. **Only include 1-2 recommendations per category** - the most valuable ones for this specific codebase. Skip categories that aren't relevant.
+
+```markdown
+## Claude Code Automation Recommendations
+
+I've analyzed your codebase and identified the top automations for each category. Here are my top 1-2 recommendations per type:
+
+### Codebase Profile
+- **Type**: [detected language/runtime]
+- **Framework**: [detected framework]
+- **Key Libraries**: [relevant libraries detected]
+
+---
+
+### 🔌 MCP Servers
+
+#### context7
+**Why**: [specific reason based on detected libraries]
+**Install**: `claude mcp add context7`
+
+---
+
+### 🎯 Skills
+
+#### [skill name]
+**Why**: [specific reason]
+**Create**: `.claude/skills/[name]/SKILL.md`
+**Invocation**: User-only / Both / Claude-only
+**Also available in**: [plugin-name] plugin (if applicable)
+```yaml
+---
+name: [skill-name]
+description: [what it does]
+disable-model-invocation: true  # for user-only
+---
+```
+
+---
+
+### ⚡ Hooks
+
+#### [hook name]
+**Why**: [specific reason based on detected config]
+**Where**: `.claude/settings.json`
+
+---
+
+### 🤖 Subagents
+
+#### [agent name]
+**Why**: [specific reason based on codebase patterns]
+**Where**: `.claude/agents/[name].md`
+
+---
+
+**Want more?** Ask for additional recommendations for any specific category (e.g., "show me more MCP server options" or "what other hooks would help?").
+
+**Want help implementing any of these?** Just ask and I can help you set up any of the recommendations above.
+```
+
+## Decision Framework
+
+### When to Recommend MCP Servers
+- External service integration needed (databases, APIs)
+- Documentation lookup for libraries/SDKs
+- Browser automation or testing
+- Team tool integration (GitHub, Linear, Slack)
+- Cloud infrastructure management
+
+### When to Recommend Skills
+
+- Document generation (docx, xlsx, pptx, pdf — also in plugins)
+- Frequently repeated prompts or workflows
+- Project-specific tasks with arguments
+- Applying templates or scripts to tasks (skills can bundle supporting files)
+- Quick actions invoked with `/skill-name`
+- Workflows that should run in isolation (`context: fork`)
+
+**Invocation control:**
+- `disable-model-invocation: true` — User-only (for side effects: deploy, commit, send)
+- `user-invocable: false` — Claude-only (for background knowledge)
+- Default (omit both) — Both can invoke
+
+### When to Recommend Hooks
+- Repetitive post-edit actions (formatting, linting)
+- Protection rules (block sensitive file edits)
+- Validation checks (tests, type checks)
+
+### When to Recommend Subagents
+- Specialized expertise needed (security, performance)
+- Parallel review workflows
+- Background quality checks
+
+### When to Recommend Plugins
+- Need multiple related skills
+- Want pre-packaged automation bundles
+- Team-wide standardization
+
+---
+
+## Configuration Tips
+
+### MCP Server Setup
+
+**Team sharing**: Check `.mcp.json` into repo so entire team gets same MCP servers
+
+**Debugging**: Use `--mcp-debug` flag to identify configuration issues
+
+**Prerequisites to recommend:**
+- GitHub CLI (`gh`) - enables native GitHub operations
+- Puppeteer/Playwright CLI - for browser MCP servers
+
+### Headless Mode (for CI/Automation)
+
+Recommend headless Claude for automated pipelines:
+
+```bash
+# Pre-commit hook example
+claude -p "fix lint errors in src/" --allowedTools Edit,Write
+
+# CI pipeline with structured output
+claude -p "<prompt>" --output-format stream-json | your_command
+```
+
+### Permissions for Hooks
+
+Configure allowed tools in `.claude/settings.json`:
+
+```json
+{
+  "permissions": {
+    "allow": ["Edit", "Write", "Bash(npm test:*)", "Bash(git commit:*)"]
+  }
+}
+```

plugins/claude-code-setup/skills/claude-automation-recommender/references/hooks-patterns.md

@@ -0,0 +1,226 @@
+# Hooks Recommendations
+
+Hooks automatically run commands in response to Claude Code events. They're ideal for enforcement and automation that should happen consistently.
+
+**Note**: These are common patterns. Use web search to find hooks for tools/frameworks not listed here to recommend the best hooks for the user.
+
+## Auto-Formatting Hooks
+
+### Prettier (JavaScript/TypeScript)
+| Detection | File Exists |
+|-----------|-------------|
+| `.prettierrc`, `.prettierrc.json`, `prettier.config.js` | ✓ |
+
+**Recommend**: PostToolUse hook on Edit/Write to auto-format
+**Value**: Code stays formatted without thinking about it
+
+### ESLint (JavaScript/TypeScript)
+| Detection | File Exists |
+|-----------|-------------|
+| `.eslintrc`, `.eslintrc.json`, `eslint.config.js` | ✓ |
+
+**Recommend**: PostToolUse hook on Edit/Write to auto-fix
+**Value**: Lint errors fixed automatically
+
+### Black/isort (Python)
+| Detection | File Exists |
+|-----------|-------------|
+| `pyproject.toml` with black/isort, `.black`, `setup.cfg` | ✓ |
+
+**Recommend**: PostToolUse hook to format Python files
+**Value**: Consistent Python formatting
+
+### Ruff (Python - Modern)
+| Detection | File Exists |
+|-----------|-------------|
+| `ruff.toml`, `pyproject.toml` with `[tool.ruff]` | ✓ |
+
+**Recommend**: PostToolUse hook for lint + format
+**Value**: Fast, comprehensive Python linting
+
+### gofmt (Go)
+| Detection | File Exists |
+|-----------|-------------|
+| `go.mod` | ✓ |
+
+**Recommend**: PostToolUse hook to run gofmt
+**Value**: Standard Go formatting
+
+### rustfmt (Rust)
+| Detection | File Exists |
+|-----------|-------------|
+| `Cargo.toml` | ✓ |
+
+**Recommend**: PostToolUse hook to run rustfmt
+**Value**: Standard Rust formatting
+
+---
+
+## Type Checking Hooks
+
+### TypeScript
+| Detection | File Exists |
+|-----------|-------------|
+| `tsconfig.json` | ✓ |
+
+**Recommend**: PostToolUse hook to run tsc --noEmit
+**Value**: Catch type errors immediately
+
+### mypy/pyright (Python)
+| Detection | File Exists |
+|-----------|-------------|
+| `mypy.ini`, `pyrightconfig.json`, pyproject.toml with mypy | ✓ |
+
+**Recommend**: PostToolUse hook for type checking
+**Value**: Catch type errors in Python
+
+---
+
+## Protection Hooks
+
+### Block Sensitive File Edits
+| Detection | Presence Of |
+|-----------|-------------|
+| `.env`, `.env.local`, `.env.production` | Environment files |
+| `credentials.json`, `secrets.yaml` | Secret files |
+| `.git/` directory | Git internals |
+
+**Recommend**: PreToolUse hook that blocks Edit/Write to these paths
+**Value**: Prevent accidental secret exposure or git corruption
+
+### Block Lock File Edits
+| Detection | Presence Of |
+|-----------|-------------|
+| `package-lock.json`, `yarn.lock`, `pnpm-lock.yaml` | JS lock files |
+| `Cargo.lock`, `poetry.lock`, `Pipfile.lock` | Other lock files |
+
+**Recommend**: PreToolUse hook that blocks direct edits
+**Value**: Lock files should only change via package manager
+
+---
+
+## Test Runner Hooks
+
+### Jest (JavaScript/TypeScript)
+| Detection | Presence Of |
+|-----------|-------------|
+| `jest.config.js`, `jest` in package.json | Jest configured |
+| `__tests__/`, `*.test.ts`, `*.spec.ts` | Test files exist |
+
+**Recommend**: PostToolUse hook to run related tests after edit
+**Value**: Immediate test feedback on changes
+
+### pytest (Python)
+| Detection | Presence Of |
+|-----------|-------------|
+| `pytest.ini`, `pyproject.toml` with pytest | pytest configured |
+| `tests/`, `test_*.py` | Test files exist |
+
+**Recommend**: PostToolUse hook to run pytest on changed files
+**Value**: Immediate test feedback
+
+---
+
+## Quick Reference: Detection → Recommendation
+
+| If You See | Recommend This Hook |
+|------------|-------------------|
+| Prettier config | Auto-format on Edit/Write |
+| ESLint config | Auto-lint on Edit/Write |
+| Ruff/Black config | Auto-format Python |
+| tsconfig.json | Type-check on Edit |
+| Test directory | Run related tests on Edit |
+| .env files | Block .env edits |
+| Lock files | Block lock file edits |
+| Go project | gofmt on Edit |
+| Rust project | rustfmt on Edit |
+
+---
+
+## Notification Hooks
+
+Notification hooks run when Claude Code sends notifications. Use matchers to filter by notification type.
+
+### Permission Alerts
+| Matcher | Use Case |
+|---------|----------|
+| `permission_prompt` | Alert when Claude requests permissions |
+
+**Recommend**: Play sound, send desktop notification, or log permission requests
+**Value**: Never miss permission prompts when multitasking
+
+### Idle Notifications
+| Matcher | Use Case |
+|---------|----------|
+| `idle_prompt` | Alert when Claude is waiting for input (60+ seconds idle) |
+
+**Recommend**: Play sound or send notification when Claude needs attention
+**Value**: Know when Claude is ready for your input
+
+### Example Configuration
+
+```json
+{
+  "hooks": {
+    "Notification": [
+      {
+        "matcher": "permission_prompt",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "afplay /System/Library/Sounds/Ping.aiff"
+          }
+        ]
+      },
+      {
+        "matcher": "idle_prompt",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "osascript -e 'display notification \"Claude is waiting\" with title \"Claude Code\"'"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+### Available Matchers
+
+| Matcher | Triggers When |
+|---------|---------------|
+| `permission_prompt` | Claude needs permission for a tool |
+| `idle_prompt` | Claude waiting for input (60+ seconds) |
+| `auth_success` | Authentication succeeds |
+| `elicitation_dialog` | MCP tool needs input |
+
+---
+
+## Quick Reference: Detection → Recommendation
+
+| If You See | Recommend This Hook |
+|------------|-------------------|
+| Prettier config | Auto-format on Edit/Write |
+| ESLint config | Auto-lint on Edit/Write |
+| Ruff/Black config | Auto-format Python |
+| tsconfig.json | Type-check on Edit |
+| Test directory | Run related tests on Edit |
+| .env files | Block .env edits |
+| Lock files | Block lock file edits |
+| Go project | gofmt on Edit |
+| Rust project | rustfmt on Edit |
+| Multitasking workflow | Notification hooks for alerts |
+
+---
+
+## Hook Placement
+
+Hooks go in `.claude/settings.json`:
+
+```
+.claude/
+└── settings.json  ← Hook configurations here
+```
+
+Recommend creating the `.claude/` directory if it doesn't exist.

plugins/claude-code-setup/skills/claude-automation-recommender/references/mcp-servers.md

@@ -0,0 +1,263 @@
+# MCP Server Recommendations
+
+MCP (Model Context Protocol) servers extend Claude's capabilities by connecting to external tools and services.
+
+**Note**: These are common MCP servers. Use web search to find MCP servers specific to the codebase's services and integrations.
+
+## Setup & Team Sharing
+
+**Connection methods:**
+1. **Project config** (`.mcp.json`) - Available only in that directory
+2. **Global config** (`~/.claude.json`) - Available across all projects
+3. **Checked-in `.mcp.json`** - Available to entire team (recommended!)
+
+**Tip**: Check `.mcp.json` into git so your whole team gets the same MCP servers.
+
+**Debugging**: Use `claude --mcp-debug` to identify configuration issues.
+
+## Documentation & Knowledge
+
+### context7
+**Best for**: Projects using popular libraries/SDKs where you want Claude to code with up-to-date documentation
+
+| Recommend When | Examples |
+|----------------|----------|
+| Using React, Vue, Angular | Frontend frameworks |
+| Using Express, FastAPI, Django | Backend frameworks |
+| Using Prisma, Drizzle | ORMs |
+| Using Stripe, Twilio, SendGrid | Third-party APIs |
+| Using AWS SDK, Google Cloud | Cloud SDKs |
+| Using LangChain, OpenAI SDK | AI/ML libraries |
+
+**Value**: Claude fetches live documentation instead of relying on training data, reducing hallucinated APIs and outdated patterns.
+
+---
+
+## Browser & Frontend
+
+### Playwright MCP
+**Best for**: Frontend projects needing browser automation, testing, or screenshots
+
+| Recommend When | Examples |
+|----------------|----------|
+| React/Vue/Angular app | UI component testing |
+| E2E tests needed | User flow validation |
+| Visual regression testing | Screenshot comparisons |
+| Debugging UI issues | See what user sees |
+| Form testing | Multi-step workflows |
+
+**Value**: Claude can interact with your running app, take screenshots, fill forms, and verify UI behavior.
+
+### Puppeteer MCP
+**Best for**: Headless browser automation, web scraping
+
+| Recommend When | Examples |
+|----------------|----------|
+| PDF generation from HTML | Report generation |
+| Web scraping tasks | Data extraction |
+| Headless testing | CI environments |
+
+---
+
+## Databases
+
+### Supabase MCP
+**Best for**: Projects using Supabase for backend/database
+
+| Recommend When | Examples |
+|----------------|----------|
+| Supabase project detected | `@supabase/supabase-js` in deps |
+| Auth + database needs | User management apps |
+| Real-time features | Live data sync |
+
+**Value**: Claude can query tables, manage auth, and interact with Supabase storage directly.
+
+### PostgreSQL MCP
+**Best for**: Direct PostgreSQL database access
+
+| Recommend When | Examples |
+|----------------|----------|
+| Raw PostgreSQL usage | No ORM layer |
+| Database migrations | Schema management |
+| Data analysis tasks | Complex queries |
+| Debugging data issues | Inspect actual data |
+
+### Neon MCP
+**Best for**: Neon serverless Postgres users
+
+### Turso MCP
+**Best for**: Turso/libSQL edge database users
+
+---
+
+## Version Control & DevOps
+
+### GitHub MCP
+**Best for**: GitHub-hosted repositories needing issue/PR integration
+
+| Recommend When | Examples |
+|----------------|----------|
+| GitHub repository | `.git` with GitHub remote |
+| Issue-driven development | Reference issues in commits |
+| PR workflows | Review, merge operations |
+| GitHub Actions | CI/CD pipeline access |
+| Release management | Tag and release automation |
+
+**Value**: Claude can create issues, review PRs, check workflow runs, and manage releases.
+
+### GitLab MCP
+**Best for**: GitLab-hosted repositories
+
+### Linear MCP
+**Best for**: Teams using Linear for issue tracking
+
+| Recommend When | Examples |
+|----------------|----------|
+| Linear workspace | Issue references like `ABC-123` |
+| Sprint planning | Backlog management |
+| Issue creation from code | Auto-create issues for TODOs |
+
+---
+
+## Cloud Infrastructure
+
+### AWS MCP
+**Best for**: AWS infrastructure management
+
+| Recommend When | Examples |
+|----------------|----------|
+| AWS SDK in dependencies | `@aws-sdk/*` packages |
+| Infrastructure as code | Terraform, CDK, SAM |
+| Lambda development | Serverless functions |
+| S3, DynamoDB usage | Cloud data services |
+
+### Cloudflare MCP
+**Best for**: Cloudflare Workers, Pages, R2, D1
+
+| Recommend When | Examples |
+|----------------|----------|
+| Cloudflare Workers | Edge functions |
+| Pages deployment | Static site hosting |
+| R2 storage | Object storage |
+| D1 database | Edge SQL database |
+
+### Vercel MCP
+**Best for**: Vercel deployment and configuration
+
+---
+
+## Monitoring & Observtic
+
+### Sentry MCP
+**Best for**: Error tracking and debugging
+
+| Recommend When | Examples |
+|----------------|----------|
+| Sentry configured | `@sentry/*` in deps |
+| Production debugging | Investigate errors |
+| Error patterns | Group similar issues |
+| Release tracking | Correlate deploys with errors |
+
+**Value**: Claude can investigate Sentry issues, find root causes, and suggest fixes.
+
+### Datadog MCP
+**Best for**: APM, logs, and metrics
+
+---
+
+## Communication
+
+### Slack MCP
+**Best for**: Slack workspace integration
+
+| Recommend When | Examples |
+|----------------|----------|
+| Team uses Slack | Send notifications |
+| Deployment notifications | Alert channels |
+| Incident response | Post updates |
+
+### Notion MCP
+**Best for**: Notion workspace for documentation
+
+| Recommend When | Examples |
+|----------------|----------|
+| Notion for docs | Read/update pages |
+| Knowledge base | Search documentation |
+| Meeting notes | Create summaries |
+
+---
+
+## File & Data
+
+### Filesystem MCP
+**Best for**: Enhanced file operations beyond built-in tools
+
+| Recommend When | Examples |
+|----------------|----------|
+| Complex file operations | Batch processing |
+| File watching | Monitor changes |
+| Advanced search | Custom patterns |
+
+### Memory MCP
+**Best for**: Persistent memory across sessions
+
+| Recommend When | Examples |
+|----------------|----------|
+| Long-running projects | Remember context |
+| User preferences | Store settings |
+| Learning patterns | Build knowledge |
+
+**Value**: Claude remembers project context, decisions, and patterns across conversations.
+
+---
+
+## Containers & DevOps
+
+### Docker MCP
+**Best for**: Container management
+
+| Recommend When | Examples |
+|----------------|----------|
+| Docker Compose file | Container orchestration |
+| Dockerfile present | Build images |
+| Container debugging | Inspect logs, exec |
+
+### Kubernetes MCP
+**Best for**: Kubernetes cluster management
+
+| Recommend When | Examples |
+|----------------|----------|
+| K8s manifests | Deploy, scale pods |
+| Helm charts | Package management |
+| Cluster debugging | Pod logs, status |
+
+---
+
+## AI & ML
+
+### Exa MCP
+**Best for**: Web search and research
+
+| Recommend When | Examples |
+|----------------|----------|
+| Research tasks | Find current info |
+| Competitive analysis | Market research |
+| Documentation gaps | Find examples |
+
+---
+
+## Quick Reference: Detection Patterns
+
+| Look For | Suggests MCP Server |
+|----------|-------------------|
+| Popular npm packages | context7 |
+| React/Vue/Next.js | Playwright MCP |
+| `@supabase/supabase-js` | Supabase MCP |
+| `pg` or `postgres` | PostgreSQL MCP |
+| GitHub remote | GitHub MCP |
+| `.linear` or Linear refs | Linear MCP |
+| `@aws-sdk/*` | AWS MCP |
+| `@sentry/*` | Sentry MCP |
+| `docker-compose.yml` | Docker MCP |
+| Slack webhook URLs | Slack MCP |
+| `@anthropic-ai/sdk` | context7 for Anthropic docs |

plugins/claude-code-setup/skills/claude-automation-recommender/references/plugins-reference.md

@@ -0,0 +1,98 @@
+# Plugin Recommendations
+
+Plugins are installable collections of skills, commands, agents, and hooks. Install via `/plugin install`.
+
+**Note**: These are plugins from the official repository. Use web search to discover additional community plugins.
+
+---
+
+## Official Plugins
+
+### Development & Code Quality
+
+| Plugin | Best For | Key Features |
+|--------|----------|--------------|
+| **plugin-dev** | Building Claude Code plugins | Skills for creating skills, hooks, commands, agents |
+| **pr-review-toolkit** | PR review workflows | Specialized review agents (code, tests, types) |
+| **code-review** | Automated code review | Multi-agent review with confidence scoring |
+| **code-simplifier** | Code refactoring | Simplify code while preserving functionality |
+| **feature-dev** | Feature development | End-to-end feature workflow with agents |
+
+### Git & Workflow
+
+| Plugin | Best For | Key Features |
+|--------|----------|--------------|
+| **commit-commands** | Git workflows | /commit, /commit-push-pr commands |
+| **hookify** | Automation rules | Create hooks from conversation patterns |
+
+### Frontend
+
+| Plugin | Best For | Key Features |
+|--------|----------|--------------|
+| **frontend-design** | UI development | Production-grade UI, avoids generic aesthetics |
+
+### Learning & Guidance
+
+| Plugin | Best For | Key Features |
+|--------|----------|--------------|
+| **explanatory-output-style** | Learning | Educational insights about code choices |
+| **learning-output-style** | Interactive learning | Requests contributions at decision points |
+| **security-guidance** | Security awareness | Warns about security issues when editing |
+
+### Language Servers (LSP)
+
+| Plugin | Language |
+|--------|----------|
+| **typescript-lsp** | TypeScript/JavaScript |
+| **pyright-lsp** | Python |
+| **gopls-lsp** | Go |
+| **rust-analyzer-lsp** | Rust |
+| **clangd-lsp** | C/C++ |
+| **jdtls-lsp** | Java |
+| **kotlin-lsp** | Kotlin |
+| **swift-lsp** | Swift |
+| **csharp-lsp** | C# |
+| **php-lsp** | PHP |
+| **lua-lsp** | Lua |
+
+---
+
+## Quick Reference: Codebase → Plugin
+
+| Codebase Signal | Recommended Plugin |
+|-----------------|-------------------|
+| Building plugins | plugin-dev |
+| PR-based workflow | pr-review-toolkit |
+| Git commits | commit-commands |
+| React/Vue/Angular | frontend-design |
+| Want automation rules | hookify |
+| TypeScript project | typescript-lsp |
+| Python project | pyright-lsp |
+| Go project | gopls-lsp |
+| Security-sensitive code | security-guidance |
+| Learning/onboarding | explanatory-output-style |
+
+---
+
+## Plugin Management
+
+```bash
+# Install a plugin
+/plugin install <plugin-name>
+
+# List installed plugins
+/plugin list
+
+# View plugin details
+/plugin info <plugin-name>
+```
+
+---
+
+## When to Recommend Plugins
+
+**Recommend plugin installation when:**
+- User wants to install Claude Code automations from Anthropic's official repository or another shared marketplace
+- User needs multiple related capabilities
+- Team wants standardized workflows
+- First-time Claude Code setup

plugins/claude-code-setup/skills/claude-automation-recommender/references/skills-reference.md

@@ -0,0 +1,408 @@
+# Skills Recommendations
+
+Skills are packaged expertise with workflows, reference materials, and best practices. Create them in `.claude/skills/<name>/SKILL.md`. Skills can be invoked by Claude automatically when relevant, or by users directly with `/skill-name`.
+
+Some pre-built skills are available through official plugins (install via `/plugin install`).
+
+**Note**: These are common patterns. Use web search to find skill ideas specific to the codebase's tools and frameworks.
+
+---
+
+## Available from Official Plugins
+
+### Plugin Development (plugin-dev)
+
+| Skill | Best For |
+|-------|----------|
+| **skill-development** | Creating new skills with proper structure |
+| **hook-development** | Building hooks for automation |
+| **command-development** | Creating slash commands |
+| **agent-development** | Building specialized subagents |
+| **mcp-integration** | Integrating MCP servers into plugins |
+| **plugin-structure** | Understanding plugin architecture |
+
+### Git Workflows (commit-commands)
+
+| Skill | Best For |
+|-------|----------|
+| **commit** | Creating git commits with proper messages |
+| **commit-push-pr** | Full commit, push, and PR workflow |
+
+### Frontend (frontend-design)
+
+| Skill | Best For |
+|-------|----------|
+| **frontend-design** | Creating polished UI components |
+
+**Value**: Creates distinctive, high-quality UI instead of generic AI aesthetics.
+
+### Automation Rules (hookify)
+
+| Skill | Best For |
+|-------|----------|
+| **writing-rules** | Creating hookify rules for automation |
+
+### Feature Development (feature-dev)
+
+| Skill | Best For |
+|-------|----------|
+| **feature-dev** | End-to-end feature development workflow |
+
+---
+
+## Quick Reference: Official Plugin Skills
+
+| Codebase Signal | Skill | Plugin |
+|-----------------|-------|--------|
+| Building plugins | skill-development | plugin-dev |
+| Git commits | commit | commit-commands |
+| React/Vue/Angular | frontend-design | frontend-design |
+| Automation rules | writing-rules | hookify |
+| Feature planning | feature-dev | feature-dev |
+
+---
+
+## Custom Project Skills
+
+Create project-specific skills in `.claude/skills/<name>/SKILL.md`.
+
+### Skill Structure
+
+```
+.claude/skills/
+└── my-skill/
+    ├── SKILL.md           # Main instructions (required)
+    ├── template.yaml      # Template to apply
+    ├── scripts/
+    │   └── validate.sh    # Script to run
+    └── examples/          # Reference examples
+```
+
+### Frontmatter Reference
+
+```yaml
+---
+name: skill-name
+description: What this skill does and when to use it
+disable-model-invocation: true  # Only user can invoke (for side effects)
+user-invocable: false           # Only Claude can invoke (for background knowledge)
+allowed-tools: Read, Grep, Glob # Restrict tool access
+context: fork                   # Run in isolated subagent
+agent: Explore                  # Which agent type when forked
+---
+```
+
+### Invocation Control
+
+| Setting | User | Claude | Use for |
+|---------|------|--------|---------|
+| (default) | ✓ | ✓ | General-purpose skills |
+| `disable-model-invocation: true` | ✓ | ✗ | Side effects (deploy, send) |
+| `user-invocable: false` | ✗ | ✓ | Background knowledge |
+
+---
+
+## Custom Skill Examples
+
+### API Documentation with OpenAPI Template
+
+Apply a YAML template to generate consistent API docs:
+
+```
+.claude/skills/api-doc/
+├── SKILL.md
+└── openapi-template.yaml
+```
+
+**SKILL.md:**
+```yaml
+---
+name: api-doc
+description: Generate OpenAPI documentation for an endpoint. Use when documenting API routes.
+---
+
+Generate OpenAPI documentation for the endpoint at $ARGUMENTS.
+
+Use the template in [openapi-template.yaml](openapi-template.yaml) as the structure.
+
+1. Read the endpoint code
+2. Extract path, method, parameters, request/response schemas
+3. Fill in the template with actual values
+4. Output the completed YAML
+```
+
+**openapi-template.yaml:**
+```yaml
+paths:
+  /{path}:
+    {method}:
+      summary: ""
+      description: ""
+      parameters: []
+      requestBody:
+        content:
+          application/json:
+            schema: {}
+      responses:
+        "200":
+          description: ""
+          content:
+            application/json:
+              schema: {}
+```
+
+---
+
+### Database Migration Generator with Script
+
+Generate and validate migrations using a bundled script:
+
+```
+.claude/skills/create-migration/
+├── SKILL.md
+└── scripts/
+    └── validate-migration.sh
+```
+
+**SKILL.md:**
+```yaml
+---
+name: create-migration
+description: Create a database migration file
+disable-model-invocation: true
+allowed-tools: Read, Write, Bash
+---
+
+Create a migration for: $ARGUMENTS
+
+1. Generate migration file in `migrations/` with timestamp prefix
+2. Include up and down functions
+3. Run validation: `bash ~/.claude/skills/create-migration/scripts/validate-migration.sh`
+4. Report any issues found
+```
+
+**scripts/validate-migration.sh:**
+```bash
+#!/bin/bash
+# Validate migration syntax
+npx prisma validate 2>&1 || echo "Validation failed"
+```
+
+---
+
+### Test Generator with Examples
+
+Generate tests following project patterns:
+
+```
+.claude/skills/gen-test/
+├── SKILL.md
+└── examples/
+    ├── unit-test.ts
+    └── integration-test.ts
+```
+
+**SKILL.md:**
+```yaml
+---
+name: gen-test
+description: Generate tests for a file following project conventions
+disable-model-invocation: true
+---
+
+Generate tests for: $ARGUMENTS
+
+Reference these examples for the expected patterns:
+- Unit tests: [examples/unit-test.ts](examples/unit-test.ts)
+- Integration tests: [examples/integration-test.ts](examples/integration-test.ts)
+
+1. Analyze the source file
+2. Identify functions/methods to test
+3. Generate tests matching project conventions
+4. Place in appropriate test directory
+```
+
+---
+
+### Component Generator with Template
+
+Scaffold new components from a template:
+
+```
+.claude/skills/new-component/
+├── SKILL.md
+└── templates/
+    ├── component.tsx.template
+    ├── component.test.tsx.template
+    └── component.stories.tsx.template
+```
+
+**SKILL.md:**
+```yaml
+---
+name: new-component
+description: Scaffold a new React component with tests and stories
+disable-model-invocation: true
+---
+
+Create component: $ARGUMENTS
+
+Use templates in [templates/](templates/) directory:
+1. Generate component from component.tsx.template
+2. Generate tests from component.test.tsx.template
+3. Generate Storybook story from component.stories.tsx.template
+
+Replace {{ComponentName}} with the PascalCase name.
+Replace {{component-name}} with the kebab-case name.
+```
+
+---
+
+### PR Review with Checklist
+
+Review PRs against a project-specific checklist:
+
+```
+.claude/skills/pr-check/
+├── SKILL.md
+└── checklist.md
+```
+
+**SKILL.md:**
+```yaml
+---
+name: pr-check
+description: Review PR against project checklist
+disable-model-invocation: true
+context: fork
+---
+
+## PR Context
+- Diff: !`gh pr diff`
+- Description: !`gh pr view`
+
+Review against [checklist.md](checklist.md).
+
+For each item, mark ✅ or ❌ with explanation.
+```
+
+**checklist.md:**
+```markdown
+## PR Checklist
+
+- [ ] Tests added for new functionality
+- [ ] No console.log statements
+- [ ] Error handling includes user-facing messages
+- [ ] API changes are backwards compatible
+- [ ] Database migrations are reversible
+```
+
+---
+
+### Release Notes Generator
+
+Generate release notes from git history:
+
+**SKILL.md:**
+```yaml
+---
+name: release-notes
+description: Generate release notes from commits since last tag
+disable-model-invocation: true
+---
+
+## Recent Changes
+- Commits since last tag: !`git log $(git describe --tags --abbrev=0)..HEAD --oneline`
+- Last tag: !`git describe --tags --abbrev=0`
+
+Generate release notes:
+1. Group commits by type (feat, fix, docs, etc.)
+2. Write user-friendly descriptions
+3. Highlight breaking changes
+4. Format as markdown
+```
+
+---
+
+### Project Conventions (Claude-only)
+
+Background knowledge Claude applies automatically:
+
+**SKILL.md:**
+```yaml
+---
+name: project-conventions
+description: Code style and patterns for this project. Apply when writing or reviewing code.
+user-invocable: false
+---
+
+## Naming Conventions
+- React components: PascalCase
+- Utilities: camelCase
+- Constants: UPPER_SNAKE_CASE
+- Files: kebab-case
+
+## Patterns
+- Use `Result<T, E>` for fallible operations, not exceptions
+- Prefer composition over inheritance
+- All API responses use `{ data, error, meta }` shape
+
+## Forbidden
+- No `any` types
+- No `console.log` in production code
+- No synchronous file I/O
+```
+
+---
+
+### Environment Setup
+
+Onboard new developers with setup script:
+
+```
+.claude/skills/setup-dev/
+├── SKILL.md
+└── scripts/
+    └── check-prerequisites.sh
+```
+
+**SKILL.md:**
+```yaml
+---
+name: setup-dev
+description: Set up development environment for new contributors
+disable-model-invocation: true
+---
+
+Set up development environment:
+
+1. Check prerequisites: `bash scripts/check-prerequisites.sh`
+2. Install dependencies: `npm install`
+3. Copy environment template: `cp .env.example .env`
+4. Set up database: `npm run db:setup`
+5. Verify setup: `npm test`
+
+Report any issues encountered.
+```
+
+---
+
+## Argument Patterns
+
+| Pattern | Meaning | Example |
+|---------|---------|---------|
+| `$ARGUMENTS` | All args as string | `/deploy staging` → "staging" |
+
+Arguments are appended as `ARGUMENTS: <value>` if `$ARGUMENTS` isn't in the skill.
+
+## Dynamic Context Injection
+
+Use `!`command`` to inject live data before the skill runs:
+
+```yaml
+## Current State
+- Branch: !`git branch --show-current`
+- Status: !`git status --short`
+```
+
+The command output replaces the placeholder before Claude sees the skill content.

plugins/claude-code-setup/skills/claude-automation-recommender/references/subagent-templates.md

@@ -0,0 +1,181 @@
+# Subagent Recommendations
+
+Subagents are specialized Claude instances that run in parallel, each with their own context window and tool access. They're ideal for focused reviews, analysis, or generation tasks.
+
+**Note**: These are common patterns. Design custom subagents based on the codebase's specific review and analysis needs.
+
+## Code Review Agents
+
+### code-reviewer
+**Best for**: Automated code quality checks on large codebases
+
+| Recommend When | Detection |
+|----------------|-----------|
+| Large codebase (>500 files) | File count |
+| Frequent code changes | Active development |
+| Team wants consistent review | Quality focus |
+
+**Value**: Runs code review in parallel while you continue working
+**Model**: sonnet (balanced quality/speed)
+**Tools**: Read, Grep, Glob, Bash
+
+---
+
+### security-reviewer
+**Best for**: Security-focused code review
+
+| Recommend When | Detection |
+|----------------|-----------|
+| Auth code present | `auth/`, `login`, `session` patterns |
+| Payment processing | `stripe`, `payment`, `billing` patterns |
+| User data handling | `user`, `profile`, `pii` patterns |
+| API keys in code | Environment variable patterns |
+
+**Value**: Catches OWASP vulnerabilities, auth issues, data exposure
+**Model**: sonnet
+**Tools**: Read, Grep, Glob (read-only for safety)
+
+---
+
+### test-writer
+**Best for**: Generating comprehensive test coverage
+
+| Recommend When | Detection |
+|----------------|-----------|
+| Low test coverage | Few test files vs source files |
+| Test suite exists | `tests/`, `__tests__/` present |
+| Testing framework configured | jest, pytest, vitest in deps |
+
+**Value**: Generates tests matching project conventions
+**Model**: sonnet
+**Tools**: Read, Write, Grep, Glob
+
+---
+
+## Specialized Agents
+
+### api-documenter
+**Best for**: API documentation generation
+
+| Recommend When | Detection |
+|----------------|-----------|
+| REST endpoints | Express routes, FastAPI paths |
+| GraphQL schema | `.graphql` files |
+| OpenAPI exists | `openapi.yaml`, `swagger.json` |
+| Undocumented APIs | Routes without docs |
+
+**Value**: Generates OpenAPI specs, endpoint documentation
+**Model**: sonnet
+**Tools**: Read, Write, Grep, Glob
+
+---
+
+### performance-analyzer
+**Best for**: Finding performance bottlenecks
+
+| Recommend When | Detection |
+|----------------|-----------|
+| Database queries | ORM usage, raw SQL |
+| High-traffic code | API endpoints, hot paths |
+| Performance complaints | User reports slowness |
+| Complex algorithms | Nested loops, recursion |
+
+**Value**: Finds N+1 queries, O(n²) algorithms, memory leaks
+**Model**: sonnet
+**Tools**: Read, Grep, Glob, Bash
+
+---
+
+### ui-reviewer
+**Best for**: Frontend accessibility and UX review
+
+| Recommend When | Detection |
+|----------------|-----------|
+| React/Vue/Angular | Frontend framework detected |
+| Component library | `components/` directory |
+| User-facing UI | Not just API project |
+
+**Value**: Catches accessibility issues, UX problems, responsive design gaps
+**Model**: sonnet
+**Tools**: Read, Grep, Glob
+
+---
+
+## Utility Agents
+
+### dependency-updater
+**Best for**: Safe dependency updates
+
+| Recommend When | Detection |
+|----------------|-----------|
+| Outdated deps | `npm outdated` has results |
+| Security advisories | `npm audit` warnings |
+| Major version behind | Significant version gaps |
+
+**Value**: Updates dependencies incrementally with testing
+**Model**: sonnet
+**Tools**: Read, Write, Bash, Grep
+
+---
+
+### migration-helper
+**Best for**: Framework/version migrations
+
+| Recommend When | Detection |
+|----------------|-----------|
+| Major upgrade needed | Framework version very old |
+| Breaking changes coming | Deprecation warnings |
+| Refactoring planned | Architectural changes |
+
+**Value**: Plans and executes migrations incrementally
+**Model**: opus (complex reasoning needed)
+**Tools**: Read, Write, Grep, Glob, Bash
+
+---
+
+## Quick Reference: Detection → Recommendation
+
+| If You See | Recommend Subagent |
+|------------|-------------------|
+| Large codebase | code-reviewer |
+| Auth/payment code | security-reviewer |
+| Few tests | test-writer |
+| API routes | api-documenter |
+| Database heavy | performance-analyzer |
+| Frontend components | ui-reviewer |
+| Outdated packages | dependency-updater |
+| Old framework version | migration-helper |
+
+---
+
+## Subagent Placement
+
+Subagents go in `.claude/agents/`:
+
+```
+.claude/
+└── agents/
+    ├── code-reviewer.md
+    ├── security-reviewer.md
+    └── test-writer.md
+```
+
+---
+
+## Model Selection Guide
+
+| Model | Best For | Trade-off |
+|-------|----------|-----------|
+| **haiku** | Simple, repetitive checks | Fast, cheap, less thorough |
+| **sonnet** | Most review/analysis tasks | Balanced (recommended default) |
+| **opus** | Complex migrations, architecture | Thorough, slower, more expensive |
+
+---
+
+## Tool Access Guide
+
+| Access Level | Tools | Use Case |
+|--------------|-------|----------|
+| Read-only | Read, Grep, Glob | Reviews, analysis |
+| Writing | + Write | Code generation, docs |
+| Full | + Bash | Migrations, testing |

plugins/claude-md-management/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "claude-md-management",
+  "description": "Tools to maintain and improve CLAUDE.md files - audit quality, capture session learnings, and keep project memory current.",
+  "version": "1.0.0",
+  "author": {
+    "name": "Anthropic",
+    "email": "support@anthropic.com"
+  }
+}

plugins/claude-md-management/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

plugins/claude-md-management/README.md

@@ -0,0 +1,40 @@
+# CLAUDE.md Management Plugin
+
+Tools to maintain and improve CLAUDE.md files - audit quality, capture session learnings, and keep project memory current.
+
+## What It Does
+
+Two complementary tools for different purposes:
+
+| | claude-md-improver (skill) | /revise-claude-md (command) |
+|---|---|---|
+| **Purpose** | Keep CLAUDE.md aligned with codebase | Capture session learnings |
+| **Triggered by** | Codebase changes | End of session |
+| **Use when** | Periodic maintenance | Session revealed missing context |
+
+## Usage
+
+### Skill: claude-md-improver
+
+Audits CLAUDE.md files against current codebase state:
+
+```
+"audit my CLAUDE.md files"
+"check if my CLAUDE.md is up to date"
+```
+
+<img src="claude-md-improver-example.png" alt="CLAUDE.md improver showing quality scores and recommended updates" width="600">
+
+### Command: /revise-claude-md
+
+Captures learnings from the current session:
+
+```
+/revise-claude-md
+```
+
+<img src="revise-claude-md-example.png" alt="Revise command capturing session learnings into CLAUDE.md" width="600">
+
+## Author
+
+Isabella He (isabella@anthropic.com)

plugins/claude-md-management/commands/revise-claude-md.md

@@ -0,0 +1,54 @@
+---
+description: Update CLAUDE.md with learnings from this session
+allowed-tools: Read, Edit, Glob
+---
+
+Review this session for learnings about working with Claude Code in this codebase. Update CLAUDE.md with context that would help future Claude sessions be more effective.
+
+## Step 1: Reflect
+
+What context was missing that would have helped Claude work more effectively?
+- Bash commands that were used or discovered
+- Code style patterns followed
+- Testing approaches that worked
+- Environment/configuration quirks
+- Warnings or gotchas encountered
+
+## Step 2: Find CLAUDE.md Files
+
+```bash
+find . -name "CLAUDE.md" -o -name ".claude.local.md" 2>/dev/null | head -20
+```
+
+Decide where each addition belongs:
+- `CLAUDE.md` - Team-shared (checked into git)
+- `.claude.local.md` - Personal/local only (gitignored)
+
+## Step 3: Draft Additions
+
+**Keep it concise** - one line per concept. CLAUDE.md is part of the prompt, so brevity matters.
+
+Format: `<command or pattern>` - `<brief description>`
+
+Avoid:
+- Verbose explanations
+- Obvious information
+- One-off fixes unlikely to recur
+
+## Step 4: Show Proposed Changes
+
+For each addition:
+
+```
+### Update: ./CLAUDE.md
+
+**Why:** [one-line reason]
+
+\`\`\`diff
++ [the addition - keep it brief]
+\`\`\`
+```
+
+## Step 5: Apply with Approval
+
+Ask if the user wants to apply the changes. Only edit files they approve.