Expand toolkit to 135 agents, 120 plugins, 796 total files

- Add 60 new agents across all 10 categories (75 -> 135)
- Add 95 new plugins with command files (25 -> 120)
- Update all agents to use model: opus
- Update README with complete plugin/agent tables
- Update marketplace.json with all 120 plugins

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

@@ -0,0 +1,6 @@
+{
+  "name": "code-explainer",
+  "version": "1.0.0",
+  "description": "Explain complex code and annotate files with inline documentation",
+  "commands": ["commands/explain.md", "commands/annotate.md"]
+}

plugins/code-explainer/commands/annotate.md

@@ -0,0 +1,46 @@
+Add inline documentation (JSDoc, docstrings, comments) to under-documented code.
+
+## Steps
+
+1. Read the target file and assess current documentation level.
+2. Identify what needs documentation:
+   - Public functions and methods lacking doc comments.
+   - Complex logic blocks without explanatory comments.
+   - Non-obvious parameter types or return values.
+   - Module-level overview missing.
+3. Generate documentation in the appropriate format:
+   - TypeScript/JavaScript: JSDoc with `@param`, `@returns`, `@throws`, `@example`.
+   - Python: Google-style or NumPy-style docstrings.
+   - Go: Godoc comments above exported functions.
+   - Rust: `///` doc comments with examples.
+4. For each function, document:
+   - What it does (one-sentence summary).
+   - Parameters with types and descriptions.
+   - Return value description.
+   - Thrown exceptions or error conditions.
+   - Usage example for complex functions.
+5. Add a module-level doc comment explaining the file's purpose.
+6. Verify the documentation does not break the build or linter.
+
+## Format
+
+```typescript
+/**
+ * Creates a new user account with the given credentials.
+ *
+ * @param email - The user's email address (must be unique)
+ * @param password - Plain text password (will be hashed)
+ * @returns The created user object with generated ID
+ * @throws {ConflictError} If a user with this email already exists
+ * @example
+ * const user = await createUser("alice@example.com", "securePass123");
+ */
+```
+
+## Rules
+
+- Document intent and contracts, not implementation details.
+- Every public function must have at minimum a summary and parameter descriptions.
+- Do not add comments that merely restate the code.
+- Use the project's existing documentation style if one is established.
+- Include `@example` for functions with non-obvious usage patterns.

plugins/code-explainer/commands/explain.md

@@ -0,0 +1,49 @@
+Explain a code file, function, or concept in clear, structured language.
+
+## Steps
+
+1. Read the target code (file path, function name, or code block).
+2. Determine the audience level from context (junior, mid, senior, non-technical).
+3. Analyze the code structure:
+   - Purpose: What problem does this code solve?
+   - Inputs: What data does it receive and from where?
+   - Processing: What transformations or logic does it apply?
+   - Outputs: What does it produce or modify?
+   - Side effects: What external state does it change?
+4. Break down complex sections:
+   - Explain algorithms step by step.
+   - Clarify language-specific idioms or patterns.
+   - Describe the data flow through the code.
+5. Identify design patterns in use (Observer, Strategy, Factory, etc.).
+6. Note any non-obvious behavior, gotchas, or edge cases.
+7. Provide analogies for complex concepts when appropriate.
+
+## Format
+
+```
+## <File/Function Name>
+
+### Purpose
+<one-sentence summary>
+
+### How It Works
+1. <step-by-step explanation>
+
+### Key Concepts
+- <pattern/concept>: <explanation>
+
+### Gotchas
+- <non-obvious behavior to be aware of>
+
+### Dependencies
+- <what this code depends on>
+- <what depends on this code>
+```
+
+## Rules
+
+- Explain the "why" not just the "what"; anyone can read the code.
+- Use concrete examples with real values from the codebase.
+- Avoid jargon unless explaining it; match the audience level.
+- Keep explanations under 100 lines; link to deeper resources for complex topics.
+- Do not restate code as prose; explain the intent and reasoning behind it.