@elizaos/skills 2.0.0-alpha.3

package/skills/testing-handbook-skills/skills/testing-handbook-generator/SKILL.md

@@ -0,0 +1,372 @@
+---
+name: testing-handbook-generator
+description: >
+  Meta-skill that analyzes the Trail of Bits Testing Handbook (appsec.guide)
+  and generates Claude Code skills for security testing tools and techniques.
+  Use when creating new skills based on handbook content.
+---
+
+# Testing Handbook Skill Generator
+
+Generate and maintain Claude Code skills from the Trail of Bits Testing Handbook.
+
+## When to Use
+
+**Invoke this skill when:**
+- Creating new security testing skills from handbook content
+- User mentions "testing handbook", "appsec.guide", or asks about generating skills
+- Bulk skill generation or refresh is needed
+
+**Do NOT use for:**
+- General security testing questions (use the generated skills)
+- Non-handbook skill creation
+
+## Handbook Location
+
+The skill needs the Testing Handbook repository. See [discovery.md](discovery.md) for full details.
+
+**Quick reference:** Check `./testing-handbook`, `../testing-handbook`, `~/testing-handbook` → ask user → clone as last resort.
+
+**Repository:** `https://github.com/trailofbits/testing-handbook`
+
+## Workflow Overview
+
+```
+Phase 0: Setup              Phase 1: Discovery
+┌─────────────────┐        ┌─────────────────┐
+│ Locate handbook │   →    │ Analyze handbook│
+│ - Find or clone │        │ - Scan sections │
+│ - Confirm path  │        │ - Classify types│
+└─────────────────┘        └─────────────────┘
+         ↓                          ↓
+Phase 3: Generation        Phase 2: Planning
+┌─────────────────┐        ┌─────────────────┐
+│ TWO-PASS GEN    │   ←    │ Generate plan   │
+│ Pass 1: Content │        │ - New skills    │
+│ Pass 2: X-refs  │        │ - Updates       │
+│ - Write to gen/ │        │ - Present user  │
+└─────────────────┘        └─────────────────┘
+         ↓
+Phase 4: Testing           Phase 5: Finalize
+┌─────────────────┐        ┌─────────────────┐
+│ Validate skills │   →    │ Post-generation │
+│ - Run validator │        │ - Update README │
+│ - Test activation│       │ - Update X-refs │
+│ - Fix issues    │        │ - Self-improve  │
+└─────────────────┘        └─────────────────┘
+```
+
+## Scope Restrictions
+
+**ONLY modify these locations:**
+- `plugins/testing-handbook-skills/skills/[skill-name]/*` - Generated skills (as siblings to testing-handbook-generator)
+- `plugins/testing-handbook-skills/skills/testing-handbook-generator/*` - Self-improvement
+- Repository root `README.md` - Add generated skills to table
+
+**NEVER modify or analyze:**
+- Other plugins (`plugins/property-based-testing/`, `plugins/static-analysis/`, etc.)
+- Other skills outside this plugin
+
+Do not scan or pull into context any skills outside of `testing-handbook-skills/`. Generate skills based solely on handbook content and resources referenced from it.
+
+## Quick Reference
+
+### Section → Skill Type Mapping
+
+| Handbook Section | Skill Type | Template |
+|------------------|------------|----------|
+| `/static-analysis/[tool]/` | Tool Skill | tool-skill.md |
+| `/fuzzing/[lang]/[fuzzer]/` | Fuzzer Skill | fuzzer-skill.md |
+| `/fuzzing/techniques/` | Technique Skill | technique-skill.md |
+| `/crypto/[tool]/` | Domain Skill | domain-skill.md |
+| `/web/[tool]/` | Tool Skill | tool-skill.md |
+
+### Skill Candidate Signals
+
+| Signal | Indicates |
+|--------|-----------|
+| `_index.md` with `bookCollapseSection: true` | Major tool/topic |
+| Numbered files (00-, 10-, 20-) | Structured content |
+| `techniques/` subsection | Methodology content |
+| `99-resources.md` or `91-resources.md` | Has external links |
+
+### Exclusion Signals
+
+| Signal | Action |
+|--------|--------|
+| `draft: true` in frontmatter | Skip section |
+| Empty directory | Skip section |
+| Template/placeholder file | Skip section |
+| GUI-only tool (e.g., `web/burp/`) | Skip section (Claude cannot operate GUI tools) |
+
+## Decision Tree
+
+**Starting skill generation?**
+
+```
+├─ Need to analyze handbook and build plan?
+│  └─ Read: discovery.md
+│     (Handbook analysis methodology, plan format)
+│
+├─ Spawning skill generation agents?
+│  └─ Read: agent-prompt.md
+│     (Full prompt template, variable reference, validation checklist)
+│
+├─ Generating a specific skill type?
+│  └─ Read appropriate template:
+│     ├─ Tool (Semgrep, CodeQL) → templates/tool-skill.md
+│     ├─ Fuzzer (libFuzzer, AFL++) → templates/fuzzer-skill.md
+│     ├─ Technique (harness, coverage) → templates/technique-skill.md
+│     └─ Domain (crypto, web) → templates/domain-skill.md
+│
+├─ Validating generated skills?
+│  └─ Run: scripts/validate-skills.py
+│     Then read: testing.md for activation testing
+│
+├─ Finalizing after generation?
+│  └─ See: Post-Generation Tasks below
+│     (Update main README, update Skills Cross-Reference, self-improvement)
+│
+└─ Quick generation from specific section?
+   └─ Use Quick Reference above, apply template directly
+```
+
+## Two-Pass Generation (Phase 3)
+
+Generation uses a **two-pass approach** to solve forward reference problems (skills referencing other skills that don't exist yet).
+
+### Pass 1: Content Generation (Parallel)
+
+Generate all skills in parallel **without** the Related Skills section:
+
+```
+Pass 1 - Generating 5 skills in parallel:
+├─ Agent 1: libfuzzer (fuzzer) → skills/libfuzzer/SKILL.md
+├─ Agent 2: aflpp (fuzzer) → skills/aflpp/SKILL.md
+├─ Agent 3: semgrep (tool) → skills/semgrep/SKILL.md
+├─ Agent 4: harness-writing (technique) → skills/harness-writing/SKILL.md
+└─ Agent 5: wycheproof (domain) → skills/wycheproof/SKILL.md
+
+Each agent uses: pass=1 (content only, Related Skills left empty)
+```
+
+**Pass 1 agents:**
+- Generate all sections EXCEPT Related Skills
+- Leave a placeholder: `## Related Skills\n\n<!-- PASS2: populate after all skills exist -->`
+- Output report includes `references: DEFERRED`
+
+### Pass 2: Cross-Reference Population (Sequential)
+
+After all Pass 1 agents complete, run Pass 2 to populate Related Skills:
+
+```
+Pass 2 - Populating cross-references:
+├─ Read all generated skill names from skills/*/SKILL.md
+├─ For each skill, determine related skills based on:
+│   ├─ related_sections from discovery (handbook structure)
+│   ├─ Skill type relationships (fuzzers → techniques)
+│   └─ Explicit mentions in content
+└─ Update each SKILL.md's Related Skills section
+```
+
+**Pass 2 process:**
+1. Collect all generated skill names: `ls -d skills/*/SKILL.md`
+2. For each skill, identify related skills using the mapping from discovery
+3. Edit each SKILL.md to replace the placeholder with actual links
+4. Validate cross-references exist (no broken links)
+
+### Agent Prompt Template
+
+See **[agent-prompt.md](agent-prompt.md)** for the full prompt template with:
+- Variable substitution reference (including `pass` variable)
+- Pre-write validation checklist
+- Hugo shortcode conversion rules
+- Line count splitting rules
+- Error handling guidance
+- Output report format
+
+### Collecting Results
+
+After Pass 1: Aggregate output reports, verify all skills generated.
+After Pass 2: Run validator to check cross-references.
+
+### Handling Agent Failures
+
+If an agent fails or produces invalid output:
+
+| Failure Type | Detection | Recovery Action |
+|--------------|-----------|-----------------|
+| Agent crashed | No output report | Re-run single agent with same inputs |
+| Validation failed | Output report shows errors | Check gaps/warnings, manually patch or re-run |
+| Wrong skill type | Content doesn't match template | Re-run with corrected `type` parameter |
+| Missing content | Output report lists gaps | Accept if minor, or provide additional `related_sections` |
+| Pass 2 broken ref | Validator shows missing skill | Check if skill was skipped, update reference |
+
+**Important:** Do NOT re-run the entire parallel batch for a single agent failure. Fix individual failures independently.
+
+### Single-Skill Regeneration
+
+To regenerate a single skill without re-running the entire batch:
+
+```
+# Regenerate single skill (Pass 1 - content only)
+"Use testing-handbook-generator to regenerate the {skill-name} skill from section {section_path}"
+
+# Example:
+"Use testing-handbook-generator to regenerate the libfuzzer skill from section fuzzing/c-cpp/10-libfuzzer"
+```
+
+**Regeneration workflow:**
+1. Re-read the handbook section for fresh content
+2. Apply the appropriate template
+3. Write to `skills/{skill-name}/SKILL.md` (overwrites existing)
+4. Re-run Pass 2 for that skill only to update cross-references
+5. Run validator on the single skill: `uv run scripts/validate-skills.py --skill {skill-name}`
+
+## Output Location
+
+Generated skills are written to:
+```
+skills/[skill-name]/SKILL.md
+```
+
+Each skill gets its own directory for potential supporting files (as siblings to testing-handbook-generator).
+
+## Quality Checklist
+
+Before delivering generated skills:
+
+- [ ] All handbook sections analyzed (Phase 1)
+- [ ] Plan presented to user before generation (Phase 2)
+- [ ] Parallel agents launched - one per skill (Phase 3)
+- [ ] Templates applied correctly per skill type
+- [ ] Validator passes: `uv run scripts/validate-skills.py`
+- [ ] Activation testing passed - see [testing.md](testing.md)
+- [ ] Main `README.md` updated with generated skills table
+- [ ] `README.md` Skills Cross-Reference graph updated
+- [ ] Self-improvement notes captured
+- [ ] User notified with summary
+
+## Post-Generation Tasks
+
+### 1. Update Main README
+
+After generating skills, update the repository's main `README.md` to list them.
+
+**Format:** Add generated skills to the same "Available Plugins" table, directly after `testing-handbook-skills`. Use plain text `testing-handbook-generator` as the author (no link).
+
+**Example:**
+
+```markdown
+| Plugin | Description | Author |
+|--------|-------------|--------|
+| ... other plugins ... |
+| [testing-handbook-skills](plugins/testing-handbook-skills/) | Meta-skill that generates skills from the Testing Handbook | Paweł Płatek |
+| [libfuzzer](plugins/testing-handbook-skills/skills/libfuzzer/) | Coverage-guided fuzzing with libFuzzer for C/C++ | testing-handbook-generator |
+| [aflpp](plugins/testing-handbook-skills/skills/aflpp/) | Multi-core fuzzing with AFL++ | testing-handbook-generator |
+| [semgrep](plugins/testing-handbook-skills/skills/semgrep/) | Fast static analysis for finding bugs | testing-handbook-generator |
+```
+
+### 2. Update Skills Cross-Reference
+
+After generating skills, update the `README.md`'s **Skills Cross-Reference** section with the mermaid graph showing skill relationships.
+
+**Process:**
+1. Read each generated skill's `SKILL.md` and extract its `## Related Skills` section
+2. Build the mermaid graph with nodes grouped by skill type (Fuzzers, Techniques, Tools, Domain)
+3. Add edges based on the Related Skills relationships:
+   - Solid arrows (`-->`) for primary technique dependencies
+   - Dashed arrows (`-.->`) for alternative tool suggestions
+4. Replace the existing mermaid code block in README.md
+
+**Edge classification:**
+| Relationship | Arrow Style | Example |
+|--------------|-------------|---------|
+| Fuzzer → Technique | `-->` | `libfuzzer --> harness-writing` |
+| Tool → Tool (alternative) | `-.->` | `semgrep -.-> codeql` |
+| Fuzzer → Fuzzer (alternative) | `-.->` | `libfuzzer -.-> aflpp` |
+| Technique → Technique | `-->` | `harness-writing --> coverage-analysis` |
+
+**Validation:** After updating, run `validate-skills.py` to verify all referenced skills exist.
+
+### 3. Self-Improvement
+
+After each generation run, reflect on what could improve future runs.
+
+**Capture improvements to:**
+- Templates (missing sections, better structure)
+- Discovery logic (missed patterns, false positives)
+- Content extraction (shortcodes not handled, formatting issues)
+
+**Update process:**
+1. Note issues encountered during generation
+2. Identify patterns that caused problems
+3. Update relevant files:
+   - `SKILL.md` - Workflow, decision tree, quick reference updates
+   - `templates/*.md` - Template improvements
+   - `discovery.md` - Detection logic updates
+   - `testing.md` - New validation checks
+4. Document the improvement in commit message
+
+**Example self-improvement:**
+```
+Issue: libFuzzer skill missing sanitizer flags table
+Fix: Updated templates/fuzzer-skill.md to include ## Compiler Flags section
+```
+
+## Example Usage
+
+### Full Discovery and Generation
+
+```
+User: "Generate skills from the testing handbook"
+
+1. Locate handbook (check common locations, ask user, or clone)
+2. Read discovery.md for methodology
+3. Scan handbook at {handbook_path}/content/docs/
+4. Build candidate list with types
+5. Present plan to user
+6. On approval, generate each skill using appropriate template
+7. Validate generated skills
+8. Update main README.md with generated skills table
+9. Update README.md Skills Cross-Reference graph from Related Skills sections
+10. Self-improve: note any template/discovery issues for future runs
+11. Report results
+```
+
+### Single Section Generation
+
+```
+User: "Create a skill for the libFuzzer section"
+
+1. Read /testing-handbook/content/docs/fuzzing/c-cpp/10-libfuzzer/
+2. Identify type: Fuzzer Skill
+3. Read templates/fuzzer-skill.md
+4. Extract content, apply template
+5. Write to skills/libfuzzer/SKILL.md
+6. Validate and report
+```
+
+## Tips
+
+**Do:**
+- Always present plan before generating
+- Use appropriate template for skill type
+- Preserve code blocks exactly
+- Validate after generation
+
+**Don't:**
+- Generate without user approval
+- Skip fetching non-video external resources (use WebFetch)
+- Fetch video URLs (YouTube, Vimeo - titles only)
+- Include handbook images directly
+- Skip validation step
+- Exceed 500 lines per SKILL.md
+
+---
+
+**For first-time use:** Start with [discovery.md](discovery.md) to understand the handbook analysis process.
+
+**For template reference:** See [templates/](templates/) directory for skill type templates.
+
+**For validation:** See [testing.md](testing.md) for quality assurance methodology.

package/skills/testing-handbook-skills/skills/testing-handbook-generator/agent-prompt.md

@@ -0,0 +1,280 @@
+# Agent Prompt Template
+
+Use this prompt when spawning each skill generation agent. Variables in `{braces}` are substituted from the per-skill package (see [discovery.md](discovery.md#phase-3-prepare-generation-context)).
+
+---
+
+# Skill Generation Task
+
+Generate: **{name}** (type: {type}, pass: {pass})
+
+## Context
+
+You are generating a Claude Code skill as a sibling to testing-handbook-generator:
+```
+plugins/testing-handbook-skills/skills/
+├── testing-handbook-generator/   # This generator (do not modify)
+├── {name}/                       # ← Your output directory
+│   └── SKILL.md                  # ← Write here
+├── libfuzzer/                    # Example sibling
+└── semgrep/                      # Example sibling
+```
+
+## Inputs
+
+| Variable | Value |
+|----------|-------|
+| Handbook section | `{handbook_path}/content/docs/{section_path}/` |
+| Template | `{template_path}` |
+| Related sections | `{related_sections}` |
+| Pass | `{pass}` (1=content generation, 2=cross-references only) |
+
+**Notes:**
+- `related_sections` is a comma-separated list of handbook paths (e.g., `fuzzing/techniques/asan, fuzzing/techniques/harness`), or empty string if none.
+- `pass` determines what to generate: Pass 1 generates all content except Related Skills; Pass 2 only populates Related Skills.
+
+## Process
+
+### Pass 1: Content Generation
+
+1. **Read template first** - defines all required sections
+2. **Read ALL `*.md` files** in the handbook section path
+3. **Read related sections** (if `related_sections` is not empty) for context
+4. **Fetch external resources** with these limits:
+   - Maximum **5 URLs** per skill (prioritize official docs over blogs)
+   - Skip video URLs (YouTube, Vimeo, etc.) - include title/URL only
+   - **30 second timeout** per fetch - skip and note in warnings if timeout
+5. **Check line count** - if content will exceed 450 lines, apply splitting rules (see below)
+6. **Validate before writing** (see checklist below)
+7. **Write SKILL.md** with Related Skills placeholder:
+   ```markdown
+   ## Related Skills
+
+   <!-- PASS2: populate after all skills exist -->
+   ```
+
+### Pass 2: Cross-Reference Population (run after all Pass 1 complete)
+
+1. **List generated skills**: Read all `skills/*/SKILL.md` files to get skill names
+2. **Determine related skills** for this skill based on:
+   - `related_sections` mapping (handbook structure → skill names)
+   - Skill type relationships (e.g., fuzzers typically relate to technique skills)
+   - Explicit mentions in the skill's content
+3. **Replace the placeholder** with actual Related Skills section
+4. **Validate** that all referenced skills exist
+
+## Pre-Write Validation Checklist
+
+### Pass 1 Checklist
+
+Before writing SKILL.md, verify ALL items:
+
+- [ ] **Line count**: Content will be under 500 lines (if >450, apply splitting rules)
+- [ ] **No shortcodes**: No `{{<` or `{{% ` patterns remain in output
+- [ ] **No escaped backticks**: No `\``` ` patterns remain (should be unescaped to ` ``` `)
+- [ ] **Required section**: Has `## When to Use` heading
+- [ ] **Trigger phrase**: Description contains "Use when" or "Use for"
+- [ ] **Code preserved**: All code blocks have language specifier and exact content
+- [ ] **Related Skills placeholder**: Has `## Related Skills` with `<!-- PASS2: ... -->` comment
+
+If any check fails, fix before writing. If unfixable (e.g., source has no code), note in warnings.
+
+### Pass 2 Checklist
+
+Before updating Related Skills section:
+
+- [ ] **All referenced skills exist**: Each skill name in Related Skills has a corresponding `skills/{name}/SKILL.md`
+- [ ] **No circular-only references**: Don't list only skills that reference this skill back
+- [ ] **Appropriate skill types**: Fuzzers link to techniques; techniques link to tools/fuzzers
+
+## Critical Rules
+
+**Template backtick escaping:**
+
+Templates use `\``` ` (backslash-escaped backticks) to show code block examples within markdown code blocks. When generating skills:
+- Convert `\``` ` → ` ``` ` (remove the backslash escape)
+- This applies to all code fence markers in the "Template Structure" sections
+- Example: `\```bash` in template becomes ` ```bash` in generated skill
+
+**Hugo shortcode conversion:**
+
+| From | To |
+|------|-----|
+| `{{< hint info >}}X{{< /hint >}}` | `> **Note:** X` |
+| `{{< hint warning >}}X{{< /hint >}}` | `> **Warning:** X` |
+| `{{< hint danger >}}X{{< /hint >}}` | `> **⚠️ Danger:** X` |
+| `{{< tabs >}}{{< tab "Y" >}}X{{< /tab >}}{{< /tabs >}}` | `### Y` followed by X |
+| `{{% relref "path" %}}` | `See: path` (plain text) |
+| `{{< customFigure "..." >}}` | `(See handbook diagram)` |
+| `{{< mermaid >}}X{{< /mermaid >}}` | Omit (describe diagram in text if critical) |
+| `{{< details "title" >}}X{{< /details >}}` | `<details><summary>title</summary>X</details>` |
+| `{{< expand "title" >}}X{{< /expand >}}` | `<details><summary>title</summary>X</details>` |
+| `{{< figure src="..." >}}` | `(See handbook image: filename)` |
+| `{{< youtube ID >}}` | `[Video: Title](https://youtube.com/watch?v=ID)` (title only) |
+| `{{< vimeo ID >}}` | `[Video: Title](https://vimeo.com/ID)` (title only) |
+| `{{< button href="URL" >}}X{{< /button >}}` | `[X](URL)` |
+| `{{< columns >}}X{{< /columns >}}` | Remove wrapper, keep content X |
+| `{{< katex >}}X{{< /katex >}}` | `$X$` (inline math) or omit if complex |
+
+**Preserve exactly:** Code blocks (language specifier, indentation, full content)
+
+**Omit:** Images (reference as: `See handbook diagram: filename.svg`), video content (title/URL only)
+
+**YAML frontmatter:**
+- `name`: lowercase, `[a-z0-9-]+`, max 64 chars
+- `type`: one of `tool`, `fuzzer`, `technique`, `domain` (determines required sections)
+- `description`: max 1024 chars, MUST include "Use when {trigger}" or "Use for {purpose}"
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Missing handbook content | Note gap in report, use template placeholder |
+| WebFetch timeout (>30s) | Include URL without summary, note in warnings |
+| WebFetch fails | Include URL without summary, note in warnings |
+| Over 450 lines in draft | Apply Line Count Splitting Rules (see below) |
+| Missing resources file | Omit Resources section, note in report |
+| No related sections (`related_sections` is empty) | Leave Related Skills placeholder for Pass 2 |
+
+## Line Count Splitting Rules
+
+**Hard limit:** 500 lines per file. **Soft limit:** 450 lines (triggers splitting).
+
+### When to Split
+
+After drafting content, count lines. If **line count > 450**:
+
+1. **Identify split candidates** (sections that can stand alone):
+
+   | Section | Split Priority | Typical Lines |
+   |---------|---------------|---------------|
+   | Installation | High | 50-100 |
+   | Advanced Usage | High | 80-150 |
+   | CI/CD Integration | High | 60-100 |
+   | Troubleshooting | Medium | 40-80 |
+   | Configuration | Medium | 50-100 |
+   | Tool-Specific Guidance | Medium | 100-200 |
+
+2. **Calculate what to extract:** Remove sections until SKILL.md is under 400 lines (leaving room for decision tree).
+
+### How to Split
+
+**Step 1:** Create file structure:
+```
+skills/{name}/
+├── SKILL.md           # Core content + decision tree (target: <400 lines)
+├── installation.md    # If extracted
+├── advanced.md        # If extracted
+├── ci-integration.md  # If extracted
+└── troubleshooting.md # If extracted
+```
+
+**Step 2:** Transform SKILL.md into a router. Add decision tree after Quick Reference:
+```markdown
+## Decision Tree
+
+**What do you need?**
+
+├─ First time setup?
+│  └─ Read: [Installation Guide](installation.md)
+│
+├─ Basic usage?
+│  └─ See: Quick Reference above
+│
+├─ Advanced features?
+│  └─ Read: [Advanced Usage](advanced.md)
+│
+├─ CI/CD integration?
+│  └─ Read: [CI Integration](ci-integration.md)
+│
+└─ Something not working?
+   └─ Read: [Troubleshooting](troubleshooting.md)
+```
+
+**Step 3:** Each extracted file gets minimal frontmatter:
+```yaml
+---
+parent: {name}
+title: Installation Guide
+---
+```
+
+### What to Keep in SKILL.md
+
+Always keep in SKILL.md (never extract):
+- YAML frontmatter (name, type, description)
+- When to Use section
+- Quick Reference section
+- Decision Tree (add if splitting)
+- Related Skills section (placeholder for Pass 2)
+
+### Splitting Decision Table
+
+| Total Lines | Action |
+|-------------|--------|
+| ≤400 | No split needed |
+| 401-450 | Review for optional trimming, no split required |
+| 451-550 | Extract 1-2 largest sections |
+| 551-700 | Extract 2-3 sections |
+| >700 | Extract all optional sections, review for content reduction |
+
+### Example Split
+
+**Before (520 lines):**
+```
+SKILL.md
+├── Frontmatter (10 lines)
+├── When to Use (30 lines)
+├── Quick Reference (40 lines)
+├── Installation (90 lines)      ← Extract
+├── Core Workflow (80 lines)
+├── Advanced Usage (120 lines)   ← Extract
+├── CI/CD Integration (70 lines) ← Extract
+├── Common Mistakes (30 lines)
+├── Related Skills (20 lines)
+└── Resources (30 lines)
+```
+
+**After split:**
+```
+SKILL.md (280 lines)
+├── Frontmatter (10 lines)
+├── When to Use (30 lines)
+├── Quick Reference (40 lines)
+├── Decision Tree (40 lines)     ← Added
+├── Core Workflow (80 lines)
+├── Common Mistakes (30 lines)
+├── Related Skills (20 lines)
+└── Resources (30 lines)
+
+installation.md (90 lines)
+advanced.md (120 lines)
+ci-integration.md (70 lines)
+```
+
+## Scope Restriction
+
+ONLY write to: `{output_dir}/{name}/`
+Do NOT read/modify other plugins, skills, or testing-handbook-generator itself.
+
+## Output Report
+
+After writing, output this report (used for orchestration and cross-reference tracking):
+
+### Pass 1 Report
+```
+## {name} (Pass 1)
+- **Lines:** {count}
+- **Split:** {Yes - files listed | No}
+- **Sections:** {populated sections, comma-separated}
+- **Gaps:** {missing template sections, or "None"}
+- **Warnings:** {issues encountered, or "None"}
+- **References:** DEFERRED (Pass 2)
+```
+
+### Pass 2 Report
+```
+## {name} (Pass 2)
+- **References:** {skill names in Related Skills section, comma-separated}
+- **Broken refs:** {skill names that don't exist, or "None"}
+```