@hopla/claude-setup 1.14.1 → 1.16.0

package/skills/execution-report/report-structure.md

@@ -0,0 +1,88 @@
+# Execution Report Structure
+
+Fill every section. Write "Not applicable" rather than leaving a section blank — empty sections make it unclear whether the check was performed.
+
+## Meta Information
+
+- **Plan file:** [path to the plan that guided this implementation]
+- **Files added:** [list with paths]
+- **Files modified:** [list with paths]
+- **Lines changed:** +X −Y
+
+## Validation Results
+
+- Syntax & Linting: ✓/✗ [details if failed]
+- Type Checking: ✓/✗ [details if failed]
+- Unit Tests: ✓/✗ [X passed, Y failed]
+- Integration Tests: ✓/✗ [X passed, Y failed]
+
+## Code Review Findings
+
+- **Code review file:** [path to `.agents/code-reviews/[name].md`, or "Not run"]
+- **Issues found:** [count by severity: X critical, Y high, Z medium, W low]
+- **Issues fixed before this report:** [count]
+- **Key findings:** [1-2 sentence summary of the most significant issues found]
+
+## What Went Well
+
+List specific things that worked smoothly:
+
+- [concrete examples]
+
+## Challenges Encountered
+
+List specific difficulties:
+
+- [what was difficult and why]
+
+## Bugs Encountered
+
+Categorize each bug found during implementation:
+
+| Bug | Category | Found By | Severity |
+|-----|----------|----------|----------|
+| [description] | stale closure / validation / race condition / styling / scope mismatch / type error / route ordering / other | lint / types / tests / code review / manual testing | critical / high / medium / low |
+
+If no bugs were encountered, write "No bugs encountered during implementation."
+
+## Divergences from Plan
+
+For each divergence:
+
+**[Divergence Title]**
+
+- **Planned:** [what the plan specified]
+- **Actual:** [what was implemented instead]
+- **Reason:** [why this divergence occurred]
+- **Type:** Better approach found | Plan assumption wrong | Security concern | Performance issue | Other
+
+## Scope Assessment
+
+- **Planned tasks:** [number in the original plan]
+- **Executed tasks:** [number actually completed]
+- **Unplanned additions:** [count and brief description of work not in the original plan]
+- **Scope accuracy:** On target | Under-scoped (took more work than planned) | Over-scoped (simpler than expected)
+
+## Skipped Items
+
+List anything from the plan that was not implemented:
+
+- [what was skipped] — Reason: [why]
+
+## Technical Patterns Discovered
+
+New gotchas, patterns, or conventions learned during this implementation that should be documented:
+
+- **Pattern/Gotcha:** [description]
+- **Where it applies:** [what type of feature or context triggers this]
+- **Ready-to-paste CLAUDE.md entry:** [Write the EXACT text that should be added to the project's CLAUDE.md to prevent this gotcha in future features. Format it as a bullet point under the appropriate section. If it belongs in a guide instead, write the exact text for the guide. Do not write vague suggestions like "document this" — write the actual content so the system reviewer can apply it directly.]
+
+If nothing new was discovered, write "No new patterns discovered."
+
+## Recommendations
+
+Based on this implementation, what should change for next time?
+
+- Plan command improvements: [suggestions]
+- Execute command improvements: [suggestions]
+- CLAUDE.md additions: [suggestions]

package/skills/verify/SKILL.md

@@ -47,13 +47,7 @@ Instead, run the verification and report actual results.
 
 ## Integration with Validation Pyramid
 
-When completing a feature (not just a single file edit), run the full validation pyramid:
-
-1. **Level 1**: Lint & format
-2. **Level 2**: Type check
-3. **Level 3**: Unit tests
-4. **Level 4**: Integration tests (if applicable)
-5. **Level 5**: Human review suggestion
+When completing a feature (not just a single file edit), run levels **1–4 + 7** from `commands/guides/validation-pyramid.md` (Lint, Types, Unit, Integration, Human review).
 
 Reference `/hopla:validate` for project-specific validation commands.
 
@@ -72,3 +66,14 @@ When verifying completion of a plan execution (not just a standalone task):
 3. **All acceptance criteria met?** — Read the plan's acceptance criteria and verify each one has fresh evidence.
 
 These checks prevent the common pattern where implementation is "done" but divergences are silently omitted from the report.
+
+## Authoritative post-implementation sequence
+
+When verification passes, follow this order to avoid redundant work and skill overlap:
+
+1. **`verify`** (this skill) — confirm fresh evidence for every completion claim.
+2. **`code-review`** — run technical review on changed files. Fix `critical`/`high` issues before proceeding.
+3. **`execution-report`** — document what was built, bugs found, divergences, patterns discovered.
+4. **`git`** — commit (and PR when ready).
+
+Each step cites the next, so at any point you should be routing to exactly one subsequent skill. If multiple skills are triggering simultaneously on a completion claim, this is the canonical ordering.