bmad-module-skill-forge 0.2.0

package/src/workflows/test-skill/steps-c/step-04-coherence-check.md

@@ -0,0 +1,249 @@
+---
+name: 'step-04-coherence-check'
+description: 'Validate internal consistency — references, types, and integration patterns'
+
+nextStepFile: './step-05-score.md'
+outputFile: '{output_folder}/test-report-{skill_name}.md'
+outputFormatsFile: '../data/output-section-formats.md'
+---
+
+# Step 4: Coherence Check
+
+## STEP GOAL:
+
+Validate internal consistency of the skill documentation. In contextual mode (stack skills): verify that all cross-references in SKILL.md point to real files, types match their declarations, and integration patterns are complete. In naive mode (individual skills): perform basic structural validation only.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER fabricate references or claim files exist without verifying — zero hallucination
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step, ensure entire file is read
+- ⚙️ TOOL/SUBPROCESS FALLBACK: If any instruction references a subprocess, subagent, or tool you do not have access to, you MUST still achieve the outcome in your main context thread
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are a skill auditor in Ferris's Audit mode — zero hallucination
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ Every broken reference must cite exactly what was referenced and where it was expected
+- ✅ Report structural facts — do not interpret or editorialize
+
+### Step-Specific Rules:
+
+- 🎯 Use subprocess optimization: Pattern 1 (grep for references across files), Pattern 2 (per-reference deep validation)
+- 💬 Subprocess returns structured findings only, not full file contents
+- 🚫 DO NOT BE LAZY — For EACH reference in contextual mode, launch a subprocess to validate the target
+- ⚙️ If subprocess unavailable, perform validation in main thread sequentially
+- 📋 Analysis depth is conditional on testMode (naive vs contextual)
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Check testMode from output frontmatter to determine analysis depth
+- 💾 Append Coherence Analysis section to {outputFile}
+- 📖 Update stepsCompleted in {outputFile}
+- 🚫 FORBIDDEN to skip coherence check entirely — even naive mode runs basic structural validation
+
+## CONTEXT BOUNDARIES:
+
+- Available: SKILL.md, source files, testMode, forge tier, coverage results from step 03
+- Focus: Internal consistency and reference validation only — coverage was step 03
+- Limits: Do NOT recalculate coverage scores — use results from step 03
+- Dependencies: step-03 must have completed coverage analysis
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+### 1. Check Test Mode
+
+Read `testMode` from `{outputFile}` frontmatter.
+
+**IF naive mode → Execute Naive Coherence (Section 2)**
+**IF contextual mode → Execute Contextual Coherence (Sections 3-5)**
+
+### 2. Naive Mode: Basic Structural Validation
+
+Perform lightweight structural checks:
+
+**Document structure:**
+- SKILL.md has required top-level sections (description, exports, usage)
+- Section headers are properly formatted
+- Code examples have language annotations
+- No broken markdown (unclosed code blocks, malformed tables)
+
+**Internal consistency:**
+- Exports referenced in usage examples match exports listed in exports section
+- Type names used in examples match documented types
+- No self-contradictions (e.g., function described as async but shown sync in example)
+
+Build a simple structural findings list:
+
+```json
+{
+  "structural_issues": [
+    {"type": "missing_section", "detail": "No 'Usage' section found"},
+    {"type": "broken_example", "detail": "Line 42: references undeclared function 'getConfig'"}
+  ],
+  "issues_found": 2
+}
+```
+
+**After naive coherence → Skip to Section 6 (Append Results)**
+
+### 3. Contextual Mode: Extract References
+
+Scan SKILL.md for all cross-references:
+
+**Reference types to extract:**
+- File path references (`./path/to/file.ts`, `../shared/types.ts`)
+- Skill references (`See SKILL.md for {other-skill}`, `Integrates with {package}`)
+- Type imports (`import { Type } from './module'`)
+- Integration pattern references (middleware chains, plugin hooks, shared state)
+
+Launch a subprocess that:
+1. Runs grep/regex across SKILL.md for reference patterns (file paths, import statements, skill names)
+2. Returns all found references with their line numbers
+
+```json
+{
+  "references_found": [
+    {"line": 15, "type": "file_path", "target": "./shared/types.ts"},
+    {"line": 42, "type": "skill_ref", "target": "auth-skill"},
+    {"line": 78, "type": "type_import", "target": "SharedConfig from ./config"}
+  ],
+  "total_references": 3
+}
+```
+
+If subprocess unavailable, scan SKILL.md in main thread.
+
+### 4. Contextual Mode: Validate Each Reference
+
+DO NOT BE LAZY — For EACH reference found, launch a subprocess that:
+
+1. Checks if the target exists (file exists, skill exists, type is declared)
+2. If target exists, validates the reference is accurate:
+   - File path references: file exists at specified path
+   - Type imports: type is actually exported from the referenced module
+   - Skill references: referenced skill exists in skills output folder
+   - Integration patterns: documented pattern matches actual implementation
+3. Returns structured validation:
+
+```json
+{
+  "reference": "./shared/types.ts",
+  "line": 15,
+  "target_exists": true,
+  "type_match": true,
+  "signature_match": true,
+  "issues": []
+}
+```
+
+Or for failures:
+
+```json
+{
+  "reference": "auth-skill",
+  "line": 42,
+  "target_exists": false,
+  "issues": ["Referenced skill 'auth-skill' not found in skills output folder"]
+}
+```
+
+If subprocess unavailable, validate each reference in main thread.
+
+### 5. Contextual Mode: Check Integration Pattern Completeness
+
+For stack skills, verify integration patterns are complete:
+
+- **All documented integration points have corresponding code examples**
+- **Shared types are consistently used across referenced components**
+- **Middleware/plugin chains show complete flow, not fragments**
+- **Event handlers reference valid event types**
+
+Build integration completeness findings:
+
+```json
+{
+  "patterns_documented": 5,
+  "patterns_complete": 4,
+  "incomplete_patterns": [
+    {
+      "pattern": "Auth middleware chain",
+      "issue": "Shows middleware registration but not the handler function signature",
+      "line": 95
+    }
+  ]
+}
+```
+
+### 6. Append Coherence Analysis to Output
+
+Load `{outputFormatsFile}` and use the appropriate Coherence Analysis section format (naive or contextual) to append findings to `{outputFile}`.
+
+### 7. Report Coherence Results
+
+**For Naive Mode:**
+"**Coherence check complete (naive mode).**
+
+Basic structural validation of **{skill_name}**:
+- {N} structural issues found
+- Coherence category not scored (weight redistributed to coverage)
+
+**Proceeding to scoring...**"
+
+**For Contextual Mode:**
+"**Coherence check complete (contextual mode).**
+
+Reference validation of **{skill_name}**:
+- References: {valid}/{total} valid ({percentage}%)
+- Integration patterns: {complete}/{total} complete ({percentage}%)
+- Combined coherence: {percentage}%
+
+**{N} issues found** — details in Coherence Analysis section.
+
+**Proceeding to scoring...**"
+
+### 8. Auto-Proceed
+
+Display: "**Proceeding to scoring...**"
+
+#### Menu Handling Logic:
+
+- After coherence analysis is complete, update {outputFile} frontmatter stepsCompleted, then immediately load, read entire file, then execute {nextStepFile}
+
+#### EXECUTION RULES:
+
+- This is an auto-proceed validation step with no user choices
+- Proceed directly to next step after coherence is analyzed
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN coherence analysis is complete (naive structural or contextual full validation), the Coherence Analysis section has been appended to {outputFile}, and coherence scores (if contextual) have been calculated, will you then load and read fully `{nextStepFile}` to execute scoring.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Correct mode path executed (naive structural OR contextual full)
+- All references validated in contextual mode (DO NOT BE LAZY)
+- Every broken reference cites exact location and expected target
+- Coherence Analysis section appended to output document
+- Coherence scores calculated (contextual) or weight redistribution noted (naive)
+- Zero fabricated findings — all traceable to artifacts
+
+### ❌ SYSTEM FAILURE:
+
+- Skipping coherence check entirely (even naive mode runs structural checks)
+- Fabricating reference validation results
+- Not checking every reference in contextual mode (DO NOT BE LAZY)
+- Running contextual checks on a naive-mode skill (unnecessary depth)
+- Running only naive checks on a contextual-mode skill (insufficient depth)
+- Hardcoding paths instead of using frontmatter variables
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE. Zero hallucination — every finding traces to artifacts.

package/src/workflows/test-skill/steps-c/step-05-score.md

@@ -0,0 +1,222 @@
+---
+name: 'step-05-score'
+description: 'Calculate completeness score from coverage and coherence findings'
+
+nextStepFile: './step-06-report.md'
+outputFile: '{output_folder}/test-report-{skill_name}.md'
+scoringRulesFile: '../data/scoring-rules.md'
+---
+
+# Step 5: Score
+
+## STEP GOAL:
+
+Calculate the overall completeness score by aggregating coverage and coherence category scores with the appropriate weight distribution (naive or contextual), apply the pass/fail threshold, and determine the test result.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER invent scores — all values must derive from step 03 and step 04 findings
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step, ensure entire file is read
+- ⚙️ TOOL/SUBPROCESS FALLBACK: If any instruction references a subprocess, subagent, or tool you do not have access to, you MUST still achieve the outcome in your main context thread
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are a skill auditor in Ferris's Audit mode — zero hallucination
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ Scoring is mechanical — apply the formula, report the math
+- ✅ Do not editorialize on the score — facts and numbers only
+
+### Step-Specific Rules:
+
+- 🎯 Focus only on score calculation — do NOT generate remediation suggestions (that's step 06)
+- 🚫 FORBIDDEN to adjust scores subjectively — the formula determines the result
+- 💬 Show the math: category scores, weights, weighted contributions, total
+- 📋 Score must be reproducible — same inputs always produce same output
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load scoring rules and read findings from {outputFile}
+- 💾 Append Completeness Score section to {outputFile}
+- 📖 Update {outputFile} frontmatter with testResult, score, and stepsCompleted
+- 🚫 FORBIDDEN to proceed without setting testResult to pass or fail
+
+## CONTEXT BOUNDARIES:
+
+- Available: Coverage Analysis (step 03) and Coherence Analysis (step 04) in {outputFile}
+- Focus: Score calculation and pass/fail determination only
+- Limits: Do NOT generate gap remediation — that's step 06
+- Dependencies: steps 03 and 04 must have appended their analysis sections
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+### 1. Load Scoring Rules
+
+Load `{scoringRulesFile}` to get:
+- Category weights (naive vs contextual distribution)
+- Default threshold (80%)
+- Tier-dependent scoring adjustments
+- Any custom threshold override from workflow input
+
+### 2. Read Category Scores from Output
+
+Read `{outputFile}` and extract the category scores calculated in previous steps:
+
+**From Coverage Analysis (step 03):**
+- Export Coverage: {percentage}%
+- Signature Accuracy: {percentage}% or N/A (Quick tier)
+- Type Coverage: {percentage}% or N/A (Quick tier)
+
+**From Coherence Analysis (step 04):**
+- Combined Coherence: {percentage}% (contextual mode only)
+- Or: not scored (naive mode — weight redistributed)
+
+### 3. Apply Weight Distribution
+
+**Read testMode from {outputFile} frontmatter.**
+
+**IF naive mode — use redistributed weights:**
+
+| Category | Score | Weight | Weighted |
+|----------|-------|--------|----------|
+| Export Coverage | {N}% | 50% | {N * 0.50}% |
+| Signature Accuracy | {N}% | 30% | {N * 0.30}% |
+| Type Coverage | {N}% | 20% | {N * 0.20}% |
+| **Total** | | **100%** | **{sum}%** |
+
+**IF contextual mode — use full weights:**
+
+| Category | Score | Weight | Weighted |
+|----------|-------|--------|----------|
+| Export Coverage | {N}% | 40% | {N * 0.40}% |
+| Signature Accuracy | {N}% | 25% | {N * 0.25}% |
+| Type Coverage | {N}% | 15% | {N * 0.15}% |
+| Coherence | {N}% | 20% | {N * 0.20}% |
+| **Total** | | **100%** | **{sum}%** |
+
+**Quick tier adjustment:**
+If Signature Accuracy and Type Coverage are N/A (Quick tier, no AST):
+- Naive: Export Coverage gets 100% weight
+- Contextual: Export Coverage 60%, Coherence 40%
+
+### 4. Determine Pass/Fail
+
+```
+threshold = custom_threshold OR default_threshold (80%)
+score = sum of weighted category scores
+
+IF score >= threshold → PASS
+IF score < threshold → FAIL
+```
+
+### 5. Determine Next Workflow Recommendation
+
+Based on test result:
+
+**IF PASS:**
+- `nextWorkflow: 'export-skill'` — skill is ready for export
+
+**IF FAIL:**
+- `nextWorkflow: 'update-skill'` — skill needs remediation before export
+
+### 6. Append Completeness Score to Output
+
+Append the **Completeness Score** section to `{outputFile}`:
+
+```markdown
+## Completeness Score
+
+### Score Breakdown
+
+| Category | Score | Weight | Weighted |
+|----------|-------|--------|----------|
+| Export Coverage | {N}% | {W}% | {WS}% |
+| Signature Accuracy | {N}% | {W}% | {WS}% |
+| Type Coverage | {N}% | {W}% | {WS}% |
+| Coherence | {N}% | {W}% | {WS}% |
+| **Total** | | **100%** | **{total}%** |
+
+### Result
+
+**Score:** {total}%
+**Threshold:** {threshold}%
+**Result:** **{PASS|FAIL}**
+
+**Weight Distribution:** {naive (redistributed) | contextual (full)}
+**Tier Adjustment:** {none | Quick tier — signature and type coverage not scored}
+```
+
+### 7. Update Output Frontmatter
+
+Update `{outputFile}` frontmatter:
+- `testResult: '{pass|fail}'`
+- `score: '{total}%'`
+- `threshold: '{threshold}%'`
+- `nextWorkflow: '{export-skill|update-skill}'`
+- Append `'step-05-score'` to `stepsCompleted`
+
+### 8. Report Score
+
+"**Completeness score calculated.**
+
+**{skill_name}:** **{total}%** — **{PASS|FAIL}**
+
+| Category | Score | Weighted |
+|----------|-------|----------|
+| Export Coverage | {N}% | {WS}% |
+| Signature Accuracy | {N}% | {WS}% |
+| Type Coverage | {N}% | {WS}% |
+| Coherence | {N}% | {WS}% |
+
+**Threshold:** {threshold}%
+**Recommendation:** {export-skill if pass | update-skill if fail}
+
+**Proceeding to gap report...**"
+
+### 9. Auto-Proceed
+
+Display: "**Proceeding to gap report...**"
+
+#### Menu Handling Logic:
+
+- After score is calculated and frontmatter updated, immediately load, read entire file, then execute {nextStepFile}
+
+#### EXECUTION RULES:
+
+- This is an auto-proceed scoring step with no user choices
+- Proceed directly to next step after score is determined
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN the score is calculated, pass/fail is determined, the Completeness Score section is appended to {outputFile}, and frontmatter is updated with testResult and score, will you then load and read fully `{nextStepFile}` to execute gap report generation.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- All category scores read from previous steps (not invented)
+- Correct weight distribution applied (naive vs contextual)
+- Tier adjustment applied if Quick tier
+- Score calculated with visible math (show the formula)
+- Pass/fail determined against threshold
+- Completeness Score section appended to output
+- Frontmatter updated with testResult, score, threshold, nextWorkflow
+- Auto-proceeded to step 06
+
+### ❌ SYSTEM FAILURE:
+
+- Inventing category scores not calculated in steps 03/04
+- Using wrong weight distribution for the detected mode
+- Not showing the math (score must be reproducible)
+- Subjectively adjusting the score
+- Not setting testResult in frontmatter
+- Generating remediation suggestions (that's step 06)
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE. Scoring is mechanical — apply the formula, report the math.

package/src/workflows/test-skill/steps-c/step-06-report.md

@@ -0,0 +1,175 @@
+---
+name: 'step-06-report'
+description: 'Generate gap report with remediation suggestions and finalize test report'
+
+outputFile: '{output_folder}/test-report-{skill_name}.md'
+scoringRulesFile: '../data/scoring-rules.md'
+outputFormatsFile: '../data/output-section-formats.md'
+---
+
+# Step 6: Gap Report
+
+## STEP GOAL:
+
+Generate a detailed gap report listing every issue found during coverage and coherence analysis, assign severity to each gap, provide specific actionable remediation suggestions, and finalize the test report document. This is the final step — no next step file.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER fabricate gaps — every item must trace to findings from steps 03 and 04
+- 📖 CRITICAL: Read the complete step file before taking any action
+- ⚙️ TOOL/SUBPROCESS FALLBACK: If any instruction references a subprocess, subagent, or tool you do not have access to, you MUST still achieve the outcome in your main context thread
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are a skill auditor in Ferris's Audit mode — zero hallucination
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ Remediation suggestions must be specific and actionable — not vague advice
+- ✅ Each gap tells the user exactly what to fix, where, and how
+
+### Step-Specific Rules:
+
+- 🎯 Focus on gap enumeration, severity classification, and remediation
+- 🚫 FORBIDDEN to recalculate scores — use the score from step 05
+- 💬 Remediation suggestions reference specific files, exports, and line numbers
+- 📋 Gaps are ordered by severity (Critical → High → Medium → Low → Info)
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Read all findings from {outputFile} coverage and coherence sections
+- 💾 Append Gap Report section to {outputFile}
+- 📖 Update {outputFile} frontmatter: mark stepsCompleted with all steps, finalize document
+- 🚫 This is the final step — no next step to load
+
+## CONTEXT BOUNDARIES:
+
+- Available: Complete {outputFile} with Test Summary, Coverage Analysis, Coherence Analysis, Completeness Score
+- Focus: Gap enumeration and remediation only
+- Limits: Do NOT re-analyze source code — work from existing findings
+- Dependencies: steps 03, 04, and 05 must have completed their sections
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+### 1. Collect All Issues
+
+Read `{outputFile}` and extract every issue found across all analysis sections:
+
+**From Coverage Analysis (step 03):**
+- Missing documentation (exports in source but not in SKILL.md)
+- Signature mismatches (documented signature differs from source)
+- Stale documentation (documented but no longer in source)
+- Type coverage gaps (undocumented types/interfaces)
+
+**From Coherence Analysis (step 04):**
+- Broken references (file paths, skill references, type imports that don't resolve)
+- Incomplete integration patterns (contextual mode)
+- Structural issues (naive mode — missing sections, broken examples)
+
+### 2. Load Severity Rules
+
+Load `{scoringRulesFile}` for gap severity classification:
+
+| Severity | Criteria |
+|----------|----------|
+| **Critical** | Missing exported function/class documentation |
+| **High** | Signature mismatch between source and SKILL.md |
+| **Medium** | Missing type or interface documentation |
+| **Low** | Missing optional metadata or examples |
+| **Info** | Style suggestions, non-blocking observations |
+
+### 3. Classify and Order Gaps
+
+Load `{outputFormatsFile}` for gap entry format and remediation quality rules.
+
+For each issue, assign severity from `{scoringRulesFile}` and generate a specific remediation following the quality rules in `{outputFormatsFile}`. Order gaps by severity: Critical → High → Medium → Low → Info.
+
+### 4. Generate Remediation Summary and Append Gap Report
+
+Load the Gap Report section format from `{outputFormatsFile}`. Count gaps by severity, estimate effort per the guidelines in `{outputFormatsFile}`, and append the complete **Gap Report** section to `{outputFile}`.
+
+If no gaps found, append a clean pass message recommending **export-skill** workflow.
+
+### 5. Finalize Output Document
+
+Update `{outputFile}` frontmatter:
+- Set `stepsCompleted` to `['step-01-init', 'step-02-detect-mode', 'step-03-coverage-check', 'step-04-coherence-check', 'step-05-score', 'step-06-report']`
+
+### 6. Present Final Report
+
+"**Test complete for {skill_name}.**
+
+---
+
+**Result:** **{PASS|FAIL}** — **{score}%** (threshold: {threshold}%)
+
+**Gaps Found:** {total_gaps}
+- Critical: {N}
+- High: {N}
+- Medium: {N}
+- Low: {N}
+- Info: {N}
+
+**Report saved to:** `{outputFile}`
+
+---
+
+**Recommended next step:**
+
+{IF PASS:}
+**export-skill** — This skill is ready for export. Run the export-skill workflow to package it for distribution.
+
+{IF FAIL:}
+**update-skill** — This skill needs remediation. Review the gap report above and run the update-skill workflow to address the {N} blocking issues (Critical + High).
+
+---
+
+**Test report finalized.**"
+
+### 7. Present MENU OPTIONS
+
+Display: "**Test complete.** [C] Finish"
+
+#### Menu Handling Logic:
+
+- IF C: Workflow is complete. No further steps to load.
+- IF Any other: help user respond, then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- This is the final step — C ends the workflow
+- User may ask questions about the report before finishing
+
+## CRITICAL STEP COMPLETION NOTE
+
+This is the final step of the test-skill workflow. When the user selects C, the workflow is complete. The test report document at `{outputFile}` contains the full analysis: Test Summary, Coverage Analysis, Coherence Analysis, Completeness Score, and Gap Report.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Every gap traces to a finding from steps 03 or 04 (zero fabrication)
+- Gaps classified by severity using scoring rules
+- Gaps ordered by severity (Critical first)
+- Every gap has a specific, actionable remediation suggestion
+- Remediation summary with counts and effort estimates
+- Output document finalized with all stepsCompleted
+- Correct next workflow recommended (export-skill or update-skill)
+- Report presented clearly to user
+
+### ❌ SYSTEM FAILURE:
+
+- Fabricating gaps not found in analysis steps
+- Vague remediation suggestions ("fix the issue", "add documentation")
+- Not classifying severity
+- Recalculating or modifying the score from step 05
+- Not finalizing the output document frontmatter
+- Missing the next workflow recommendation
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE. Every gap is specific, every remediation is actionable.

package/src/workflows/test-skill/templates/test-report-template.md

@@ -0,0 +1,24 @@
+---
+workflowType: 'test-skill'
+skillName: ''
+testMode: ''
+forgeTier: ''
+testResult: ''
+score: ''
+threshold: ''
+testDate: ''
+stepsCompleted: []
+nextWorkflow: ''
+---
+
+# Test Report: {{skillName}}
+
+## Test Summary
+
+## Coverage Analysis
+
+## Coherence Analysis
+
+## Completeness Score
+
+## Gap Report