bmad-module-skill-forge 0.9.0 → 0.10.1-alpha.0

package/src/{workflows/verify-stack → skf-verify-stack}/steps-c/step-04-requirements.md

@@ -1,9 +1,9 @@
 ---
-name: 'step-04-requirements'
-description: 'Pass 3 (OPTIONAL) — if PRD/vision document provided, verify the stack covers stated requirements'
-
 nextStepFile: './step-05-synthesize.md'
-outputFile: '{forge_data_folder}/feasibility-report-{project_name}.md'
+feasibilitySchemaRef: 'src/shared/references/feasibility-report-schema.md'
+atomicWriteScript: '{project-root}/src/shared/scripts/skf-atomic-write.py'
+outputFile: '{forge_data_folder}/feasibility-report-{project_slug}-{timestamp}.md'
+outputFileLatest: '{forge_data_folder}/feasibility-report-{project_slug}-latest.md'
 ---
 
 # Step 4: Requirements Coverage
@@ -12,41 +12,11 @@ outputFile: '{forge_data_folder}/feasibility-report-{project_name}.md'
 
 If a PRD or vision document was provided in Step 01, verify that the combined capabilities of the generated skills address each stated requirement. If no PRD was provided, skip this pass and auto-proceed. Produce a requirements coverage table with Fulfilled, Partially Fulfilled, or Not Addressed verdicts.
 
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', 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 stack verification analyst assessing requirements coverage
-- ✅ Every verdict must reason from actual skill capabilities, not assumptions
-- ✅ "Not Addressed" is a valid and important finding — do not force-fit skills to requirements
-
-### Step-Specific Rules:
-
-- 🎯 Focus ONLY on requirements-to-skills coverage assessment
-- 🚫 FORBIDDEN to re-analyze integrations — that was Step 03
-- 🚫 FORBIDDEN to synthesize or produce overall verdicts — that is Step 05
-- 💬 If no PRD was provided, skip immediately with a clear message
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Extract requirements from PRD/vision document and assess skill coverage
-- 💾 Append Requirements Coverage section to {outputFile}
-- 📖 Auto-proceed to next step after completion or skip
-- 🚫 Only requirements coverage — no synthesis, no overall verdict
+## Rules
 
-## CONTEXT BOUNDARIES:
-
-- Available: PRD/vision document (if provided), skill SKILL.md files, metadata.json files
-- Focus: Mapping requirements to skill capabilities
-- Limits: Do not evaluate skill quality — only whether capabilities match requirements
-- Dependencies: Step 01 (PRD availability flag, skill inventory)
+- Focus only on requirements-to-skills coverage assessment
+- Do not re-analyze integrations (Step 03) or synthesize verdicts (Step 05)
+- If no PRD was provided, skip immediately with a clear message
 
 ## MANDATORY SEQUENCE
 
@@ -54,7 +24,7 @@ If a PRD or vision document was provided in Step 01, verify that the combined ca
 
 ### 1. Check PRD Availability
 
-**Check `prd_available` from workflow state (set in Step 01). If `prd_available` is false (no PRD/vision document was provided):**
+**Read `prdAvailable` from `{outputFile}` frontmatter (set in Step 01). If `prdAvailable` is false (no PRD/vision document was provided):**
 
 "**Pass 3: Requirements Coverage — Skipped**
 
@@ -64,7 +34,7 @@ To include this pass, re-run **[VS]** with a PRD or vision document path.
 
 **Proceeding to synthesis...**"
 
-Update {outputFile} frontmatter: append `'step-04-requirements'` to `stepsCompleted`, set `requirements_pass: "skipped"`.
+Update `{outputFile}` frontmatter: append `'step-04-requirements'` to `stepsCompleted`; set `requirementsPass: "skipped"`. Pipe the updated content through `python3 {atomicWriteScript} write --target {outputFile}` and again with `--target {outputFileLatest}`.
 
 Load, read the full file and then execute `{nextStepFile}`. **STOP HERE — do not execute sections 2-6.**
 
@@ -129,12 +99,13 @@ For each requirement, evaluate whether the combined capabilities of the generate
 
 ### 5. Append to Report
 
-Write the **Requirements Coverage** section to `{outputFile}`:
+Write the Requirements Coverage content under the `## Recommendations` section (or as a clearly-titled subsection preceding Recommendations — the shared schema's fixed top-level headings are Executive Summary, Coverage Analysis, Integration Verdicts, Recommendations, Evidence Sources; requirements detail lives under Recommendations):
 - Include the full requirements coverage table
 - Include recommendations for Not Addressed and Partially Fulfilled items
 - Update frontmatter: append `'step-04-requirements'` to `stepsCompleted`
-- Set `requirements_pass: "completed"`
-- Set `requirements_fulfilled`, `requirements_partial`, `requirements_not_addressed` counts
+- Set `requirementsPass: "completed"`
+- Set `requirementsFulfilled`, `requirementsPartial`, `requirementsNotAddressed` counts
+- Pipe the updated full content through `python3 {atomicWriteScript} write --target {outputFile}` and again with `--target {outputFileLatest}`
 
 ### 6. Auto-Proceed to Next Step
 
@@ -142,27 +113,3 @@ Write the **Requirements Coverage** section to `{outputFile}`:
 
 Load, read the full file and then execute `{nextStepFile}`.
 
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- PRD availability checked first — skipped cleanly if not provided
-- All requirements extracted from PRD with source section citations
-- Each requirement assessed against actual skill capabilities (exports, descriptions)
-- Verdicts include contributing skill names and specific capabilities
-- Not Addressed items have actionable recommendations
-- Requirements Coverage section appended to {outputFile}
-- Auto-proceeded to step 05
-
-### ❌ SYSTEM FAILURE:
-
-- Fabricating requirements not stated in the PRD document
-- Force-fitting skills to requirements they do not address
-- Verdicts without evidence from actual skill content
-- Not executing the skip path when no PRD was provided
-- Producing synthesis or overall verdicts (that is Step 05)
-- Hardcoded paths instead of frontmatter variables
-
-**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

package/src/skf-verify-stack/steps-c/step-05-synthesize.md

@@ -0,0 +1,147 @@
+---
+nextStepFile: './step-06-report.md'
+feasibilitySchemaRef: 'src/shared/references/feasibility-report-schema.md'
+atomicWriteScript: '{project-root}/src/shared/scripts/skf-atomic-write.py'
+outputFile: '{forge_data_folder}/feasibility-report-{project_slug}-{timestamp}.md'
+outputFileLatest: '{forge_data_folder}/feasibility-report-{project_slug}-latest.md'
+---
+
+# Step 5: Synthesize Verdict
+
+## STEP GOAL:
+
+Calculate the overall feasibility verdict based on all three analysis passes, generate prescriptive recommendations for every non-verified finding, check for a previous feasibility report to produce a delta, and compile the synthesis section of the report.
+
+## Rules
+
+- Focus only on synthesizing findings from Steps 02-04 into a verdict — do not discover new findings
+- Recommendations must name specific tools, libraries, or actions
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+### 1. Calculate Overall Verdict
+
+**Zero-coverage short-circuit (evaluate before anything else):** Read `coveragePercentage` from `{outputFile}` frontmatter. If `coveragePercentage == 0`, force `overallVerdict: NOT_FEASIBLE` with rationale "no coverage — analysis vacuous: zero generated skills match the architecture's referenced technologies, so integration and requirements verdicts cannot produce meaningful evidence." Skip the remainder of the verdict ladder; proceed directly to section 2 to generate recommendations for the Missing skills surfaced by Step 02.
+
+Apply the following decision logic using findings from all completed passes:
+
+**Evaluate in order — the first matching condition wins. Do not continue once a verdict is determined.**
+
+**NOT_FEASIBLE (evaluate first):**
+- Any integration is **Blocked** → overall verdict is `NOT_FEASIBLE`
+- Rationale: a blocked integration represents a fundamental architectural incompatibility. Also note in the rationale any co-occurring Missing skills or Risky integrations so the user understands the full set of problems
+
+**CONDITIONALLY_FEASIBLE (evaluate second):**
+If ANY of the following apply, the verdict is `CONDITIONALLY_FEASIBLE`. Include ALL matching conditions in the rationale:
+- Any technology is **Missing** from coverage (no skill exists)
+- Any integration is **Risky** (but none Blocked)
+- Requirements have any **Not Addressed** items
+- Requirements have any **Partially Fulfilled** items
+- Rationale: the stack can work but has gaps, risks, or unverified assumptions that must be addressed
+
+**FEASIBLE (evaluate last):**
+- Coverage is 100% (no Missing skills) AND all integrations are `Verified` AND requirements are all Fulfilled (or requirements pass was skipped) AND no Blocked or Risky integrations AND zero pairs were capped at `Plausible` due to missing Check 4 evidence → overall verdict is `FEASIBLE`
+- If any pair sits at `Plausible` (including Check-4-missing caps), downgrade to `CONDITIONALLY_FEASIBLE`
+- Rationale: {IF requirements pass completed:} the stack can support the architecture as described — all requirements fully fulfilled, every integration pair has a literal cross-reference. {IF requirements pass was skipped:} the stack can support the architecture as described — requirements were not evaluated (no PRD provided)
+
+**Post-verdict: Zero integration pairs guard (apply after ANY verdict):**
+If zero integration pairs were extracted (all four integration counts are 0), fire the guard whenever the user continued past the step-02 `[C] Continue anyway` prompt (i.e., any `[C]` continuation from 0% coverage or any other zero-state) — regardless of how many technologies the architecture document references:
+- If the verdict was `FEASIBLE`, override to `CONDITIONALLY_FEASIBLE`
+- Regardless of verdict, append this note to the rationale: "No integration claims were found in the architecture document prose. Manual review recommended to confirm that technology relationships are not documented exclusively in diagrams or implied without explicit co-mention."
+
+Store the verdict for use in the report.
+
+### 2. Generate Prescriptive Recommendations
+
+For each non-verified finding across all passes, generate an actionable next step:
+
+**Missing skill (from Step 02):**
+- "Run **[CS] Create Skill** or **[QS] Quick Skill** for `{library_name}`, then re-run **[VS]** to verify coverage."
+
+**Risky integration (from Step 03):**
+- If protocol mismatch → "Consider adding a bridge layer between `{lib_a}` and `{lib_b}` (e.g., HTTP adapter, message queue). Document the bridge in the architecture."
+- If type incompatibility → "Add a serialization/conversion layer between `{lib_a}` and `{lib_b}` to resolve the type mismatch identified in their API surfaces."
+- If weak evidence (Check 4 missing literal cross-reference) → "Run **[SS] Create Stack Skill** to compose `{lib_a}` and `{lib_b}` and surface integration evidence via the stack manifest, then re-run **[VS]** — the stack manifest's `integration_patterns` block will provide the literal cross-references that promote this pair from `Plausible` to `Verified`."
+
+**Blocked integration (from Step 03):**
+- If language barrier → "Replace `{lib_a}` with a `{lib_b_language}`-compatible alternative, or introduce an IPC/FFI bridge. Redesign the integration path in the architecture document."
+- If fundamental incompatibility → "Replace `{blocked_lib}` with an alternative that is compatible with `{other_lib}` in the same domain, or redesign the integration path in the architecture document."
+- **Named-candidate requirement:** For every Blocked integration where the recommendation proposes replacement, propose AT LEAST ONE named alternative library with a one-line justification (e.g., "Consider `{candidate_name}` — same domain as `{blocked_lib}`, native {target_language} support, compatible with `{other_lib}` via {mechanism}."). If you cannot name at least one concrete candidate, state explicitly: "No named candidate identified — manual research required" and still include one sentence on the selection criteria the user should apply. A Blocked recommendation without either a named candidate or the explicit no-candidate notice is a schema violation.
+
+**Not Addressed requirement (from Step 04):**
+- "No library in the stack covers `{requirement}`. Evaluate `{category}` libraries that provide this capability, generate a skill, then re-run **[VS]**."
+
+**Partially Fulfilled requirement (from Step 04):**
+- "Gap in `{requirement}`: {what_is_missing}. Consider extending `{contributing_skill}` or adding a dedicated library."
+
+**Zero integration pairs (from Step 03):**
+- If zero integration pairs were found AND the architecture references 2+ technologies: "No integration claims were found in the architecture document prose. Add explicit prose descriptions of how your technologies interact (not only in diagrams), then re-run **[VS]** to verify integrations."
+
+### 3. Check for Previous Report
+
+Read `previousReport` from `{outputFile}` frontmatter (set in Step 01). Since the current workflow run overwrites the report starting in Step 01, the delta feature requires the user to have saved a copy before re-running [VS].
+
+**Note:** The delta feature is only available when the user has manually backed up a prior report and provided the path. To enable delta comparisons, instruct the user to copy their feasibility report (e.g., `feasibility-report-{projectSlug}-v1.md`) before re-running [VS], then provide the backup path when prompted in Step 01.
+
+**If a previous report is found:**
+- Load its verdict, coverage percentage, integration verdicts, and per-skill `confidence_tier` values (if captured in the previous report's inventory block)
+- Generate a delta comparison:
+  - **Improved items:** findings that were Risky/Blocked/Missing and are now Verified/Covered
+  - **Regressed items:** findings that were Verified/Covered and are now Risky/Blocked/Missing
+  - **Tier downgrades (regression):** for each skill present in both runs, compare current `confidence_tier` against previous. A downgrade (e.g., Tier 1 → Tier 2, or T1 → T1-low) is a regression — flag explicitly in the delta section with rationale "skill `{skill_name}` regressed from `{prev_tier}` to `{curr_tier}` — re-extract with [CS] at the prior tier level".
+  - **New items:** findings not present in the previous report
+  - **Unchanged items:** count of findings with the same verdict
+
+**If no previous report found:**
+- Note: "First verification run — no delta available."
+
+### 4. Compile Synthesis Section
+
+Assemble the following for the report:
+
+**Overall verdict** with rationale citing the decision logic.
+
+**Recommendation list** ordered by priority (count total recommendations as `recommendationCount` — persist this count to `{outputFile}` frontmatter for use in step-06):
+1. Blocked integrations (if any)
+2. Missing skills
+3. Risky integrations
+4. Not Addressed requirements
+5. Partially Fulfilled requirements
+
+**Delta from previous run** (if applicable):
+- Improved, regressed, new, unchanged counts
+- Specific items that changed
+
+**Suggested next workflow** (match on case-sensitive `overallVerdict` token):
+- `FEASIBLE` → "Proceed to **[RA] Refine Architecture** to produce an implementation-ready architecture, then **[SS]** to compose your stack skill, then **[TS]** to test and **[EX]** to export."
+- `CONDITIONALLY_FEASIBLE` → "Address the {recommendationCount} recommendations above, then re-run **[VS]**. Once all clear, proceed to **[RA]**."
+- `NOT_FEASIBLE` → "Critical blockers must be resolved before proceeding. Apply the recommendations above and re-run **[VS]**."
+
+### 5. Append to Report
+
+Write the **Recommendations** and **Evidence Sources** sections to `{outputFile}` (per the fixed heading order in `{feasibilitySchemaRef}`):
+- Include overall verdict with rationale in the `## Executive Summary` section (replace the placeholder text from the template)
+- Include prioritized recommendation list under `## Recommendations`
+- Include delta from previous run (if applicable) under `## Recommendations` as a subsection
+- Include suggested next workflow at the end of `## Recommendations`
+- Populate `## Evidence Sources` with per-skill citations (SKILL.md path, `metadata_schema_version`, `confidence_tier`, stack manifest if any) and architecture/PRD doc paths
+- Update frontmatter (shared-schema keys):
+  - Append `'step-05-synthesize'` to `stepsCompleted`
+  - Set `overallVerdict` to one of `FEASIBLE`, `CONDITIONALLY_FEASIBLE`, `NOT_FEASIBLE` (case-sensitive, underscores — NOT spaces)
+  - Set `recommendationCount` to the total number of recommendations
+  - If delta was computed (section 3), set `deltaImproved`, `deltaRegressed`, `deltaNew`, `deltaUnchanged`
+  - Verify that `pairsVerified`, `pairsPlausible`, `pairsRisky`, `pairsBlocked` match the counts from Step 03 (these were set in Step 03). If a discrepancy is found, overwrite the frontmatter counts with the values from Step 03 — the report file is the system of record
+- **Overall verdict enforcement (schema producer obligation):**
+  - If any pair has Check 4 missing/weak AND was capped at `Plausible`, that alone does NOT force `NOT_FEASIBLE`, but `FEASIBLE` requires zero such pairs
+  - `FEASIBLE` requires 100% coverage AND zero Blocked pairs AND zero Check-4-missing pairs — otherwise downgrade to `CONDITIONALLY_FEASIBLE`
+  - `coveragePercentage == 0` forces `NOT_FEASIBLE` (per section 1 short-circuit)
+- Pipe the updated full content through `python3 {atomicWriteScript} write --target {outputFile}` and again with `--target {outputFileLatest}`
+
+### 6. Auto-Proceed to Next Step
+
+"**Proceeding to final report presentation...**"
+
+Load, read the full file and then execute `{nextStepFile}`.
+

package/src/skf-verify-stack/steps-c/step-06-report.md

@@ -0,0 +1,156 @@
+---
+outputFile: '{forge_data_folder}/feasibility-report-{project_slug}-{timestamp}.md'
+outputFileLatest: '{forge_data_folder}/feasibility-report-{project_slug}-latest.md'
+feasibilitySchemaRef: 'src/shared/references/feasibility-report-schema.md'
+atomicWriteScript: '{project-root}/src/shared/scripts/skf-atomic-write.py'
+nextStepFile: './step-07-health-check.md'
+---
+
+# Step 6: Present Report
+
+## STEP GOAL:
+
+Present the complete feasibility report to the user. Display the overall verdict prominently, walk through key findings from each analysis pass, present actionable next steps based on the verdict, and offer the user options to review the full report or exit.
+
+## Rules
+
+- Focus only on presenting the completed report — no new analysis or changes to verdicts
+- Chains to the local health-check step via `{nextStepFile}` after completion — the user-facing report is NOT the terminal step
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+### 1. Load Complete Report
+
+Read the entire `{outputFile}` to have all data available for presentation.
+
+Verify all expected sections are present in order per `{feasibilitySchemaRef}`: `## Executive Summary`, `## Coverage Analysis`, `## Integration Verdicts`, `## Recommendations`, `## Evidence Sources`. If any section is missing or out of order, HALT and report the schema violation — do not display partial results.
+
+**Extract metrics from `{outputFile}` frontmatter** (per shared schema in `{feasibilitySchemaRef}`): `skillsAnalyzed`, `coveragePercentage`, `pairsVerified` (as `verified_count`), `pairsPlausible` (as `plausible_count`), `pairsRisky` (as `risky_count`), `pairsBlocked` (as `blocked_count`), `requirementsFulfilled` (as `fulfilled_count`), `requirementsPartial` (as `partial_count`), `requirementsNotAddressed` (as `not_addressed_count`), `requirementsPass`, `overallVerdict`, and `recommendationCount`. Use these mapped display names in the summary table and next steps below.
+
+**Schema guard:** Verify `schemaVersion == "1.0"` in the frontmatter. If mismatched, HALT with "Report frontmatter schemaVersion `{value}` does not match producer schema `1.0` — report was corrupted between steps. Re-run [VS]." (Producer never proceeds past a schema mismatch.)
+
+### 2. Present Summary
+
+"**Verify Stack — Feasibility Report**
+
+---
+
+**Overall Verdict: {FEASIBLE / CONDITIONALLY_FEASIBLE / NOT_FEASIBLE}** (tokens are case-sensitive and use underscores per `{feasibilitySchemaRef}`; for user-facing prose you may render them as "Feasible", "Conditionally feasible", or "Not feasible")
+
+| Metric | Value |
+|--------|-------|
+| **Skills Analyzed** | {skillsAnalyzed} |
+| **Coverage** | {coveragePercentage}% |
+| **Integrations Verified** | {verified_count} |
+| **Integrations Plausible** | {plausible_count} |
+| **Integrations Risky** | {risky_count} |
+| **Integrations Blocked** | {blocked_count} |
+| **Requirements Fulfilled** | {fulfilled_count or 'N/A — no PRD'} |
+| **Requirements Partially Fulfilled** | {partial_count or 'N/A — no PRD'} |
+| **Requirements Not Addressed** | {not_addressed_count or 'N/A — no PRD'} |
+
+{IF deltaImproved is not null (delta from previous run exists):}
+**Delta from Previous Run:**
+- Improved: {deltaImproved} items
+- Regressed: {deltaRegressed} items
+- New: {deltaNew} items
+- Unchanged: {deltaUnchanged} items
+
+---"
+
+### 3. Present Detailed Findings
+
+Walk through each section briefly, focusing on items that need attention:
+
+"**Coverage Highlights:**
+{IF 100% coverage:}
+- All referenced technologies have a matching skill
+
+{IF any missing:}
+- **Missing:** {list of missing technology names}
+
+**Integration Verdicts:**
+{IF all Verified/Plausible:}
+- All integration pairs verified or plausible — no blockers
+
+{IF any Risky:}
+- **Risky:** {list of risky pairs with brief concern}
+
+{IF any Blocked:}
+- **Blocked:** {list of blocked pairs with brief incompatibility}
+
+{IF requirements pass completed:}
+**Requirements Gaps:**
+{IF all Fulfilled:}
+- All stated requirements addressed by the stack
+
+{IF any Partially Fulfilled:}
+- **Partially Fulfilled:** {list of partially covered requirements with gap description}
+
+{IF any Not Addressed:}
+- **Not Addressed:** {list of unaddressed requirements}"
+
+### 4. Present Next Steps
+
+Based on the overall verdict, present the appropriate recommendation:
+
+**IF `overallVerdict == "FEASIBLE"`:**
+"**Your stack is verified.** All technologies are covered, integrations are compatible, and requirements are all fulfilled (or requirements pass was skipped).
+
+**Recommended next steps:**
+1. **[RA] Refine Architecture** — Produce an implementation-ready architecture document enriched with skill-backed API details
+2. **[SS] Create Stack Skill** — compose your individual skills into a unified stack skill, providing the refined architecture doc when prompted
+3. **[TS] Test Skill** → **[EX] Export Skill** — Verify completeness and package for distribution"
+
+**IF `overallVerdict == "CONDITIONALLY_FEASIBLE"`:**
+"**Your stack is conditionally feasible.** There are {recommendationCount} items to address before proceeding.
+
+**Required actions:**
+{List the specific recommendations from Step 05 synthesis}
+
+**After addressing these items:** Re-run **[VS] Verify Stack** to confirm resolution, then proceed to **[RA]**."
+
+**IF `overallVerdict == "NOT_FEASIBLE"`:**
+"**Critical blockers must be resolved.** The stack cannot support the architecture as described.
+
+**Critical actions:**
+{List the blocked integration recommendations and missing skill actions from Step 05}
+
+**After resolving blockers:** Re-run **[VS] Verify Stack**. Repeat until verdict improves to FEASIBLE or CONDITIONALLY FEASIBLE."
+
+### 4b. Result Contract
+
+Write the result contract per `shared/references/output-contract-schema.md`: the per-run record at `{forge_data_folder}/verify-stack-result-{YYYYMMDD-HHmmss}.json` (UTC timestamp, resolution to seconds) and a copy at `{forge_data_folder}/verify-stack-result-latest.json` (stable path for pipeline consumers — copy, not symlink). Include the feasibility report path (both `{outputFile}` and `{outputFileLatest}`) in `outputs`; include `overallVerdict` (`FEASIBLE` / `CONDITIONALLY_FEASIBLE` / `NOT_FEASIBLE`), `coveragePercentage`, and `recommendationCount` in `summary` — use the case-sensitive schema tokens.
+
+Write both JSON files through `python3 {atomicWriteScript} write --target ...` to avoid partial-write corruption.
+
+**Result-contract ordering:** The result contract is written exactly once on the first entry to step-06 (the `[X] Exit verification` path). Re-walks of the report via the `[R] Review full report` menu option do NOT regenerate it — the contract captures the run, not the presentation loop. If the user selects `[R]` repeatedly before exiting, the single on-disk contract written on first entry remains authoritative.
+
+### 5. Present Menu
+
+Display: "**[R] Review full report** | **[X] Exit verification**"
+
+#### Menu Handling Logic:
+
+- **IF R:** Walk through the report section by section, presenting each section's content from {outputFile} in a readable format. After completing the walkthrough, redisplay the menu. (Note: the R walkthrough loop terminates only when the user selects X.)
+- **IF X:** "**Feasibility report saved to:** `{outputFile}`
+
+Re-run **[VS] Verify Stack** anytime after making changes to your skills or architecture document.
+
+**Verification workflow complete.**"
+
+  Then load, read the full file, and execute `{nextStepFile}` — the health-check step is the true terminal step of this workflow.
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting the menu
+- **GATE [default: X]** — If `{headless_mode}`: auto-proceed with [X] Exit verification, log: "headless: auto-exit past report menu"
+- R may be selected multiple times — always walk through the full report
+- X triggers the health check, which is the true workflow exit
+
+## CRITICAL STEP COMPLETION NOTE
+
+When the user selects X, this step chains to the local health-check step (`{nextStepFile}`), which in turn delegates to `shared/health-check.md`. After the health check completes, the verify-stack workflow is fully done. The feasibility report at `{outputFile}` (and its stable `-latest.md` copy) contains the full analysis under the fixed headings: Executive Summary, Coverage Analysis, Integration Verdicts, Recommendations, Evidence Sources.
+

package/src/skf-verify-stack/steps-c/step-07-health-check.md

@@ -0,0 +1,25 @@
+---
+# `shared/health-check.md` resolves relative to the SKF module root
+# (`_bmad/skf/` when installed, `src/` during development), NOT relative
+# to this step file.
+nextStepFile: 'shared/health-check.md'
+---
+
+# Step 7: Workflow Health Check
+
+## STEP GOAL:
+
+Chain to the shared workflow self-improvement health check at `{nextStepFile}`. This is the terminal step of verify-stack — after the shared health check completes, the workflow is fully done.
+
+## Rules
+
+- No user-facing reports, file writes, or result contracts in this step — those belong in step-06
+- Delegate directly to `{nextStepFile}` with no additional commentary
+- Do not attempt any other action between loading this step and executing `{nextStepFile}`
+
+## MANDATORY SEQUENCE
+
+Attempt to load `{nextStepFile}`.
+
+- **If `{nextStepFile}` loads successfully:** Read it fully, then execute it.
+- **If `{nextStepFile}` cannot be resolved or loaded** (e.g., running against a partial installation, module root not resolvable, or the file has been removed): log exactly `health-check unavailable at {path}` (substitute the attempted resolved path) to the user-visible output and exit the workflow cleanly. Do NOT HALT with an error — the health check is an optional self-improvement hook, and the feasibility report (written in step-06) is the authoritative workflow output. Exit cleanly so CI and headless runs do not fail on a missing optional hook.

package/tools/cli/commands/install.js

@@ -4,7 +4,7 @@ const { UI } = require('../lib/ui');
 
 module.exports = {
   command: 'install',
-  description: 'Install SKF agents and workflows into your project',
+  description: 'Install SKF skills into your project',
   options: [],
   action: async () => {
     try {

package/tools/cli/commands/status.js

@@ -8,20 +8,18 @@ const path = require('node:path');
 const fs = require('fs-extra');
 const yaml = require('js-yaml');
 const { readManifest } = require('../lib/manifest');
+const { getAvailablePlatforms } = require('../lib/ide-skills');
 
 const SKF_FOLDER = '_bmad/skf';
 const SIDECAR_FOLDER = '_bmad/_memory/forger-sidecar';
 
-const IDE_NAMES = {
-  'claude-code': 'Claude Code',
-  cline: 'Cline',
-  codex: 'Codex',
-  cursor: 'Cursor',
-  'github-copilot': 'GitHub Copilot',
-  roo: 'Roo Code',
-  windsurf: 'Windsurf',
-  other: 'Other',
-};
+function getIdeNames() {
+  const names = { other: 'Other' };
+  for (const p of getAvailablePlatforms()) {
+    names[p.value] = p.label;
+  }
+  return names;
+}
 
 async function readYaml(filePath) {
   try {
@@ -50,18 +48,17 @@ async function getStatus(projectDir) {
   // Read preferences
   const preferences = await readYaml(path.join(sidecarDir, 'preferences.yaml'));
 
-  // Check agent file
-  const agentFile = path.join(skfDir, 'agents', 'forger.md');
-  const agentCompiled = await fs.pathExists(agentFile);
+  // Check agent skill in module dir (always present when installed)
+  const agentInstalled = await fs.pathExists(path.join(skfDir, 'skf-forger', 'SKILL.md'));
 
-  // Count workflows
-  const workflowsDir = path.join(skfDir, 'workflows', 'skillforge');
+  // Count workflow skills (skf-* directories with SKILL.md, excluding the forger agent)
   let workflowCount = 0;
-  if (await fs.pathExists(workflowsDir)) {
-    const entries = await fs.readdir(workflowsDir);
+  if (await fs.pathExists(skfDir)) {
+    const entries = await fs.readdir(skfDir);
     for (const entry of entries) {
-      const wfPath = path.join(workflowsDir, entry, 'workflow.md');
-      if (await fs.pathExists(wfPath)) {
+      if (!entry.startsWith('skf-') || entry === 'skf-forger') continue;
+      const skillPath = path.join(skfDir, entry, 'SKILL.md');
+      if (await fs.pathExists(skillPath)) {
         workflowCount++;
       }
     }
@@ -85,7 +82,7 @@ async function getStatus(projectDir) {
     config,
     forgeTier,
     preferences,
-    agentCompiled,
+    agentInstalled,
     workflowCount,
     skillsFolder,
     skillsFolderExists,
@@ -117,8 +114,8 @@ function displayStatus(status, version) {
   console.log(chalk.white.bold('  Installation'));
   console.log(`    Project:      ${chalk.hex('#FBBF24')(config.project_name || '(unknown)')}`);
   console.log(`    SKF folder:   ${chalk.dim(SKF_FOLDER + '/')}`);
-  console.log(`    Agent:        ${status.agentCompiled ? chalk.green('compiled') : chalk.yellow('not compiled')}`);
-  console.log(`    Workflows:    ${chalk.white(status.workflowCount)}`);
+  console.log(`    Agent:        ${status.agentInstalled ? chalk.green('installed') : chalk.yellow('not installed')}`);
+  console.log(`    Skills:       ${chalk.white(status.workflowCount)}`);
   if (manifest) {
     console.log(
       `    Installed:    ${chalk.dim(manifest.installed_at ? new Date(manifest.installed_at).toLocaleDateString() : '(unknown)')}`,
@@ -131,10 +128,11 @@ function displayStatus(status, version) {
 
   // IDEs
   const ides = config.ides || [];
+  const ideNames = getIdeNames();
   console.log(chalk.white.bold('  IDEs'));
   if (ides.length > 0) {
     for (const ide of ides) {
-      console.log(`    ${chalk.green('●')} ${IDE_NAMES[ide] || ide}`);
+      console.log(`    ${chalk.green('●')} ${ideNames[ide] || ide}`);
     }
   } else {
     console.log(chalk.dim('    None configured'));

package/tools/cli/commands/uninstall.js

@@ -1,6 +1,6 @@
 /**
  * SKF Uninstall Command
- * Clean removal of SKF files, IDE commands, sidecar, and output folders.
+ * Clean removal of SKF files, IDE skill directories, sidecar, and output folders.
  * Uses the manifest to know exactly what to remove.
  */
 
@@ -9,6 +9,7 @@ const path = require('node:path');
 const fs = require('fs-extra');
 const { confirm, isCancel, spinner, log, outro } = require('@clack/prompts');
 const { readManifest, MANIFEST_DIR, MANIFEST_FILE } = require('../lib/manifest');
+const { removeAllSkfSkills } = require('../lib/ide-skills');
 
 /**
  * Count files that still exist on disk from manifest lists.
@@ -17,7 +18,7 @@ async function countExistingFiles(projectDir, manifest) {
   const allFiles = [
     ...(manifest.files.skf || []),
     ...(manifest.files.sidecar || []),
-    ...(manifest.files.ide_commands || []),
+    ...(manifest.files.ide_skills || []),
     ...(manifest.files.learning || []),
     ...(manifest.files.output || []),
   ];
@@ -38,7 +39,7 @@ async function displayRemovalPlan(projectDir, manifest) {
   const categories = [
     { key: 'skf', label: 'SKF module files', dir: manifest.skf_folder },
     { key: 'sidecar', label: 'Agent sidecar state', dir: '_bmad/_memory/forger-sidecar' },
-    { key: 'ide_commands', label: 'IDE command files' },
+    { key: 'ide_skills', label: 'IDE skill directories' },
     { key: 'learning', label: 'Learning material', dir: '_skf-learn' },
     { key: 'output', label: 'Output folder scaffolding' },
   ];
@@ -146,22 +147,13 @@ module.exports = {
 
       const s = spinner();
 
-      // Remove IDE commands first (scattered across project)
-      const ideFiles = manifest.files.ide_commands || [];
-      if (ideFiles.length > 0) {
-        s.start('Removing IDE commands...');
-        const ideRemoved = await removeFiles(projectDir, ideFiles);
-        // Clean empty IDE directories
-        const cleanedDirs = new Set();
-        for (const f of ideFiles) {
-          const dir = path.dirname(f);
-          if (!cleanedDirs.has(dir)) {
-            cleanedDirs.add(dir);
-            await removeEmptyDir(path.join(projectDir, dir));
-            await removeEmptyDir(path.join(projectDir, path.dirname(dir)));
-          }
-        }
-        s.stop(`Removed ${ideRemoved} IDE command files`);
+      // Remove IDE skill directories from all known platforms (skills + legacy command files)
+      s.start('Removing IDE skill directories...');
+      const removedIdeDirs = await removeAllSkfSkills(projectDir);
+      if (removedIdeDirs.length > 0) {
+        s.stop(`Cleaned skills from ${removedIdeDirs.length} IDE target(s)`);
+      } else {
+        s.stop('No IDE skill directories found');
       }
 
       // Remove learning material directory

package/tools/cli/commands/update.js

@@ -1,6 +1,6 @@
 /**
  * SKF Quick Update Command
- * Replaces SKF files and recompiles agents without re-prompting.
+ * Replaces SKF files and reinstalls agent skill without re-prompting.
  * Preserves config.yaml and sidecar state.
  */
 
@@ -15,7 +15,7 @@ const SKF_FOLDER = '_bmad/skf';
 
 module.exports = {
   command: 'update',
-  description: 'Update SKF files and recompile agents (preserves config and sidecar)',
+  description: 'Update SKF files and reinstall agent skill (preserves config and sidecar)',
   options: [],
   action: async () => {
     try {