bmad-module-skill-forge 2.0.0 → 2.0.1

package/src/skf-create-stack-skill/references/init.md

@@ -27,74 +27,12 @@ Before anything else, load `{project-root}/_bmad/skf/config.yaml`. If the file i
 
 **Halting workflow.**"
 
-STOP — do not proceed.
+Then emit the result envelope on stderr per the Result Contract in SKILL.md (`project_name` is unresolved here, so `skill_name` is `null`), and STOP — do not proceed:
 
-### 0b. Resume Check
-
-Before any further init work, check for an interrupted prior run.
-
-**Probe path.** Resolve `{resume_skill_name}` as `{project_name}-stack` (the same skill name used at step 7) and probe `{forge_data_folder}/{resume_skill_name}/in-progress.json`. (The file lives at the version-agnostic skill root so it can be found before `{version}` resolution.)
-
-**If no in-progress.json exists:** Continue to §1.
-
-**If in-progress.json exists:** Load and parse it. Read `last_completed_step` and `started_at` (ISO-8601 timestamp). Surface a soft gate:
-
-"**Resume previous run?**
-
-Found a previous in-progress run at `{forge_data_folder}/{resume_skill_name}/in-progress.json` from {started_at}, last completed at step {last_completed_step}.
-
-- **[C] Continue** (recommended) — resume from the next step after {last_completed_step}, restoring saved workflow state.
-- **[F] Fresh** — archive the existing in-progress.json (rename to `in-progress.{timestamp}.json`) and start over from step 1.
-- **[X] Cancel and exit** — leave the in-progress.json untouched and halt.
-
-Select [C/F/X]:"
-
-**Headless default:** `[C]` Continue.
-
-**On [C] Continue:**
-1. Restore workflow context from in-progress.json fields: `last_completed_step`, `workflow_state` (mode, tier, scope), and any accumulator fields (partial extractions, ranked libraries, integration pairs, compile-stack output) that the writing step persisted.
-2. Determine the resume target: the step file that runs immediately after `last_completed_step`.
-3. Jump directly to that step file by loading and executing it (skip the remaining §0b–§5 init substeps for this run).
-
-**On [F] Fresh:**
-1. Compute `{archive_timestamp}` as the current UTC time in `YYYYMMDDTHHMMSSZ` form.
-2. Rename `{forge_data_folder}/{resume_skill_name}/in-progress.json` → `{forge_data_folder}/{resume_skill_name}/in-progress.{archive_timestamp}.json`.
-3. Continue with §1 of this file as if no prior run existed.
-
-**On [X] Cancel and exit:** HARD HALT with exit code 6 (user-cancelled). Do NOT modify the in-progress.json. Emit the result envelope on stderr per the Result Contract in SKILL.md:
-
-```
-SKF_STACK_RESULT_JSON: {"status":"error","skill_package":null,"skill_name":"{resume_skill_name}","stack_libraries":[],"mode":null,"exit_code":6,"halt_reason":"user-cancelled"}
 ```
-
-**in-progress.json schema (read side).** This PR wires only the READ side of the resume protocol. The WRITE side — each stage step persisting an updated in-progress.json after it completes — is deferred to a follow-up PR. When write-side wiring lands, each step writes the file via `skf-atomic-write.py write` at the end of its mandatory sequence with this shape:
-
-```json
-{
-  "schema_version": "1.0",
-  "skill_name": "{project_name}-stack",
-  "started_at": "{ISO-8601 of step 1 start}",
-  "updated_at": "{ISO-8601 of most recent step completion}",
-  "last_completed_step": "step-NN",
-  "workflow_state": {
-    "mode": "code|compose",
-    "forge_tier": "Quick|Forge|Forge+|Deep",
-    "headless_mode": false,
-    "scope": {"explicit_deps": [], "scope_overrides": {}, "architecture_doc_path": null}
-  },
-  "accumulators": {
-    "manifests": [],
-    "ranked_libraries": [],
-    "extractions": {},
-    "integration_pairs": [],
-    "compiled_stack": null,
-    "workflow_warnings": []
-  }
-}
+SKF_STACK_RESULT_JSON: {"status":"error","skill_package":null,"skill_name":null,"stack_libraries":[],"mode":null,"exit_code":2,"halt_reason":"config-missing"}
 ```
 
-Until the write side is wired, in-progress.json will not naturally appear and §0b will fall through to §1 on every run. The resume gate is a no-op until that follow-up lands.
-
 ### 1. Load Forge Tier Configuration
 
 Load `{forgeTierFile}` from the Ferris sidecar.
@@ -107,7 +45,11 @@ Load `{forgeTierFile}` from the Ferris sidecar.
 
 **Halting workflow.**"
 
-STOP — do not proceed.
+Then emit the result envelope on stderr per the Result Contract in SKILL.md (config loaded, so `skill_name` is known; `mode` is not yet resolved), and STOP — do not proceed:
+
+```
+SKF_STACK_RESULT_JSON: {"status":"error","skill_package":null,"skill_name":"{project_name}-stack","stack_libraries":[],"mode":null,"exit_code":3,"halt_reason":"forge-tier-missing"}
+```
 
 **If forge-tier.yaml exists:**
 
@@ -156,6 +98,7 @@ Skills use version-nested directories — see `knowledge/version-paths.md` for t
 - If user provides an architecture document path for composition or explicitly requests compose mode → set `compose_mode: true` and store `architecture_doc_path`
 - If no manifest files exist in project root AND at least one skill is discoverable in `{skills_output_folder}` → suggest compose mode to the user and ask for optional architecture document path
   - **Skill discovery (version-aware):** First, read `{skills_output_folder}/.export-manifest.json` — each entry in `exports` names a skill with an `active_version`, which resolves to `{skills_output_folder}/{skill-name}/{active_version}/{skill-name}/` containing `SKILL.md` and `metadata.json`. If the export manifest does not exist or is empty, fall back to scanning for `active` symlinks: check `{skills_output_folder}/*/active/*/SKILL.md` — each match indicates a skill whose package lives at `{skills_output_folder}/{skill-name}/active/{skill-name}/` (the `{active_skill}` template).
+  - **Headless default (B8):** If `{headless_mode}` is true, do NOT prompt — auto-accept the suggestion: set `compose_mode: true` and `architecture_doc_path: null` (unless an architecture doc path was supplied via the optional inputs above). This is the constructive default: with no manifests present, code-mode would only halt at step 2 (`no-manifests`), so compose is the sole path that produces output. Log the auto-decision by appending to `workflow_warnings[]`: `{step: "step-01", severity: "info", code: "headless-compose-autodetect", message: "no manifests + {N} discoverable skills — auto-selected compose mode", context: {discoverable_skills: {N}}}`.
   - If user accepts → set `compose_mode: true` and store `architecture_doc_path` (may be `null` if user chose not to provide one)
   - If user declines → `compose_mode` remains `false`, continue with code-mode
 
@@ -166,22 +109,7 @@ If no optional inputs provided, auto-detection will be used.
 
 ### 4. Display Initialization Summary
 
-"**Stack Skill Forge initialized.**
-
-**Project:** {project_name}
-**Forge Tier:** {forge_tier} — {tier_description}
-
-Where tier_description follows positive capability framing:
-- Quick: "Source reading and import counting"
-- Forge: "AST-backed structural analysis"
-- Forge+: "AST structural + CCC semantic co-import augmentation"
-- Deep: "Full intelligence — structural + contextual + temporal"
-
-**Available Tools:** {tool_list}
-**Input Mode:** {auto-detect | explicit dependency list | compose mode}
-
-**If compose mode:** Proceeding to skill loading...
-**If code mode:** Proceeding to manifest detection..."
+Report that the Stack Skill Forge is initialized, naming: the project (`{project_name}`); the forge tier (`{forge_tier}`) with its positive-capability framing (Quick = source reading and import counting; Forge = AST-backed structural analysis; Forge+ = AST structural + CCC semantic co-import augmentation; Deep = full intelligence — structural + contextual + temporal); the available tools (`{tool_list}`); and the resolved input mode (auto-detect, explicit dependency list, or compose mode).
 
 ### 5. Auto-Proceed to Next Step
 

package/src/skf-create-stack-skill/references/manifest-patterns.md

@@ -15,41 +15,11 @@
 | PHP                   | composer.json                                       | require, require-dev                     | `use ...`, `require_once`                 |
 | .NET                  | *.csproj                                            | PackageReference                         | `using ...`                               |
 
-## Detection Priority
-
-1. Search project root for manifest files (depth 0-1)
-2. Parse each found manifest to extract dependency names
-3. Normalize names across ecosystems (e.g., `@scope/package` → `package`)
-4. Deduplicate across multiple manifests
-
-## Scan Exclusion Patterns
-
-When scanning for manifest files, ALWAYS exclude these directories from glob results:
-
-**Dependency/Vendor Directories:**
-- `node_modules/`
-- `.venv/` / `venv/` / `.env/`
-- `vendor/` (PHP Composer, Go modules)
-- `Pods/` (iOS CocoaPods)
-
-**Build Output Directories:**
-- `dist/` / `build/` / `out/`
-- `target/` (Rust, Java/Maven)
-- `__pycache__/`
-- `.next/` / `.nuxt/` / `.output/`
-
-**Hidden and VCS Directories:**
-- `.git/`
-- Any directory starting with `.` (except project root hidden config files like `.csproj`)
-
-**Monorepo Note:** For monorepo structures (e.g., `packages/*/package.json`), the depth 0-1 scan rule already limits scope. If monorepo manifest detection is needed at deeper levels, these exclusions become critical to prevent scanning dependency trees within each package.
-
-## Filtering Rules
-
-- Exclude dev-only dependencies unless they appear in production imports
-- Exclude build tools (webpack, babel, eslint, etc.) unless significantly imported
-- Include all runtime dependencies by default
-- Flag transitive dependencies that appear in direct imports
+<!-- Manifest scanning, name normalization, dedup, exclusion-dir filtering, and
+dev/build-tool filtering are performed by `skf-scan-manifests.py` (invoked in
+detect-manifests.md §2), which implements exactly the ecosystem table above.
+This file is loaded only for that reference table and the import-counting
+exclusions below — see the script's `--help` for the operative scan contract. -->
 
 ## Import Counting
 

package/src/skf-create-stack-skill/references/parallel-extract.md

@@ -60,7 +60,11 @@ The script emits JSON of the form:
 }
 ```
 
-Cache this result as `stack_skill_inventory` in workflow state — the per-skill subagent fan-out at §1+ MUST read from this cache rather than re-reading each skill's `SKILL.md` / `metadata.json` / `references/` to determine exports. Append every entry in `warnings[]` to workflow state for the evidence report (the script already labels them per-skill, e.g. `"<skill-name>: no exports found via any resolution path"`). For every entry in `cycles[]`, halt with a structured-error contract on stderr — a composes-cycle makes the stack unbuildable.
+Cache this result as `stack_skill_inventory` in workflow state — the per-skill subagent fan-out at §1+ MUST read from this cache rather than re-reading each skill's `SKILL.md` / `metadata.json` / `references/` to determine exports. Append every entry in `warnings[]` to workflow state for the evidence report (the script already labels them per-skill, e.g. `"<skill-name>: no exports found via any resolution path"`). If `cycles[]` is non-empty, a composes-cycle makes the stack unbuildable — emit the result envelope on stderr per the Result Contract in SKILL.md and exit `3`:
+
+```
+SKF_STACK_RESULT_JSON: {"status":"error","skill_package":null,"skill_name":"{project_name}-stack","stack_libraries":[],"mode":"compose","exit_code":3,"halt_reason":"resolution-failure"}
+```
 
 Build a `per_library_extractions[]` entry for each skill by reading from the cached inventory:
 - `library`: `inventory.skills[i].name`
@@ -70,15 +74,7 @@ Build a `per_library_extractions[]` entry for each skill by reading from the cac
 - `metadata_hash`: `inventory.skills[i].metadata_hash` — record for step 7 provenance (null when exports came from references/ or SKILL.md prose).
 - `usage_patterns`: populated by the §1+ per-skill subagent fan-out, NOT by this script. The script provides the inventory + exports; the subagent does the per-skill usage analysis. They're complementary.
 
-Display an extraction summary:
-
-"**Loaded {N} skill extractions from existing skills.**
-
-| Skill | Exports | Confidence | Status |
-|-------|---------|------------|--------|
-| {name} | {count} | {tier} | Loaded |"
-
-Auto-proceed to next step.
+Report the loaded extractions — for each skill: export count, confidence tier, and load status. Then auto-proceed to the next step.
 
 **If not compose_mode:** Continue with section 1 (existing flow).
 
@@ -177,26 +173,15 @@ For each library extraction:
 **If ALL extractions fail:** HALT — cannot produce meaningful stack skill. Before halting (B7):
 
 1. Purge any in-flight staging artifacts under the forge workspace: remove `{forge_data_folder}/{project_name}-stack/{version}/*-tmp` and any `{forge_data_folder}/{project_name}-stack/{version}/*.skf-tmp` directories so partial state does not linger.
-2. Emit a structured error contract on stderr: `{"status":"error","skill":"skf-create-stack-skill","stage":"step 4","reason":"all extractions failed","libraries":[...]}`.
-3. Exit with a non-zero status so headless pipelines detect the failure.
-
-### 4. Display Extraction Summary
+2. Emit the result envelope on stderr per the Result Contract in SKILL.md (`stack_libraries` carries the confirmed library names that failed extraction), and exit `2`:
 
-"**Library extraction complete.**
+   ```
+   SKF_STACK_RESULT_JSON: {"status":"error","skill_package":null,"skill_name":"{project_name}-stack","stack_libraries":["<confirmed-lib>", "..."],"mode":"{code|compose}","exit_code":2,"halt_reason":"all-extractions-failed"}
+   ```
 
-| Library | Exports | Patterns | Confidence | Status |
-|---------|---------|----------|------------|--------|
-| {name} | {count} | {count} | {tier} | ✓ |
-| {name} | {count} | {count} | {tier} | ✓ |
-| {name} | — | — | — | ⚠ partial |
-
-**Results:** {success_count}/{total_count} libraries extracted
-**Confidence distribution:** T1: {count}, T1-low: {count}, T2: {count}
-{If Deep tier:} **T2 enrichment:** {enriched_count}/{total_count} libraries had temporal collections available
-{If libraries without temporal > 0:} **Tip:** Run [CS] Create Skill at Deep tier for individual libraries to generate temporal collections, then re-run [SS] for full T2 enrichment.
-{If warnings:} **Warnings:** {warning_count} issues noted
+### 4. Display Extraction Summary
 
-**Proceeding to integration detection...**"
+Report the extraction results: per library the export count, pattern count, confidence tier, and success/partial status; the overall `{success_count}/{total_count}` extracted; and the T1 / T1-low / T2 confidence distribution. At Deep tier, add the T2-enrichment count (`{enriched_count}/{total_count}` libraries with temporal collections available); and if any library lacked a temporal collection, add the tip: run **[CS] Create Skill** at Deep tier for those libraries to generate temporal collections, then re-run **[SS]** for full T2 enrichment. Note any warning count.
 
 ### 5. Auto-Proceed to Next Step
 

package/src/skf-create-stack-skill/references/rank-and-confirm.md

@@ -56,7 +56,7 @@ Use ecosystem-appropriate import patterns:
 - Python: `import library`, `from library import`
 - Rust: `use library::`, `extern crate library`
 - Go: `"library"` in import blocks
-- (Match patterns from manifest-patterns.md)
+- (Match patterns from `{manifestPatternsPath}`)
 
 **Subprocess returns:** `{library_name: import_count, files: [file_paths]}` for each dependency.
 
@@ -112,13 +112,13 @@ Apply additions/exclusions, display updated list, and ask for final confirmation
 **If custom list provided:**
 Use the custom list as `confirmed_dependencies`.
 
-Display final confirmation:
+Display the resolved scope:
 
 "**Scope confirmed:** {count} libraries selected for stack skill extraction.
 
-{List confirmed libraries}
+{List confirmed libraries}"
 
-**Proceeding to parallel extraction...**"
+The extraction itself begins only once the user clears the gate below.
 
 ### 5. Present MENU OPTIONS
 
@@ -126,9 +126,9 @@ Display: **Select:** [C] Continue to Extraction | [X] Cancel and exit
 
 #### EXECUTION RULES:
 
-- ALWAYS halt and wait for user input after presenting scope
+- This is a confirmation gate — advancing without the user's `C` would extract and ship a stack scope they never approved. Halt and wait for input after presenting scope.
 - **GATE [default: C]** — If `{headless_mode}`: auto-proceed with [C] Continue (accept all ranked libraries), log: "headless: auto-confirm library scope"
-- ONLY proceed to next step when user confirms scope and selects 'C'
+- Proceed to the next step only once the user confirms scope by selecting `C`.
 
 #### Menu Handling Logic:
 

package/src/skf-create-stack-skill/references/report.md

@@ -25,68 +25,17 @@ Display the final summary of the forged stack skill with confidence distribution
 
 ## MANDATORY SEQUENCE
 
-### 1. Display Stack Forged Banner
+### 1. Report the Forge Result
 
-"**Stack forged: {project_name}-stack — {lib_count} libraries, {integration_count} integration patterns**
+Surface the forge result to the console, leading with the win:
 
-Forge tier: **{tier}**"
+- **Headline:** stack `{project_name}-stack` — `{lib_count}` libraries, `{integration_count}` integration patterns, forge tier `{tier}`.
+- **Confidence distribution:** the T1 / T1-low / T2 counts (T1 = AST-verified structural extraction, T1-low = source-reading inference, T2 = QMD-enriched temporal context). **In compose-mode**, note the tiers are inherited from the source skills — they reflect the extraction method used when those skills were originally generated, not the current compose run.
+- **Output files:** the `{skill_package}` deliverables (SKILL.md, context-snippet.md with `{token_estimate}` tokens, metadata.json, `references/` per-library files, and `references/integrations/` pair files when integrations exist), the `{forge_version}` workspace (provenance-map.json, evidence-report.md), and the `{skill_group}/active -> {version}` symlink.
+- **Validation:** all checks passed, or `{warning_count}` finding(s) each with its description.
+- **Warnings — only if `workflow_warnings[]` is non-empty:** the accumulated entries rendered as `[{step}/{severity}] {code}: {message}`. `workflow_warnings[]` (defined in SKILL.md's *Workflow state contract*) is the single sink surfacing every warning pushed during the run; if it is empty, omit this section.
 
-### 2. Display Confidence Distribution
-
-"**Confidence distribution:**
-
-| Tier | Count | Description |
-|------|-------|-------------|
-| T1 | {count} | AST-verified structural extraction |
-| T1-low | {count} | Source reading inference |
-| T2 | {count} | QMD-enriched temporal context |
-
-{IF compose_mode:}
-*Note: Confidence tiers above are inherited from source skills — they reflect the extraction method used when those skills were originally generated, not the current compose run.*
-{END IF}"
-
-### 3. Display Output File Summary
-
-"**Output files:**
-
-**Deliverables** (`{skill_package}`):
-- SKILL.md — Integration patterns, library summaries, conventions
-- context-snippet.md — Compressed stack index ({token_estimate} tokens)
-- metadata.json — Skill metadata and library registry
-- references/ — {lib_count} per-library reference files
-{If integrations:} - references/integrations/ — {pair_count} integration pair files
-
-**Workspace** (`{forge_version}`):
-- provenance-map.json — Extraction source tracking
-- evidence-report.md — Evidence and confidence breakdown
-
-**Symlink:** `{skill_group}/active` -> `{version}`"
-
-### 4. Display Validation Summary
-
-**If validation passed with no findings:**
-
-"**Validation:** All checks passed"
-
-**If validation had findings:**
-
-"**Validation:** {warning_count} warning(s) found
-{For each finding:}
-- ⚠ {description}"
-
-### 5. Display Warnings (Conditional)
-
-Read from the `workflow_warnings[]` accumulator defined in the Workflow Rules of `SKILL.md` (M4). Every step that emitted a warning during this run pushed a structured entry there — this section is the single sink that surfaces them.
-
-**Only display if `workflow_warnings[]` is non-empty:**
-
-"**Warnings:**
-{For each entry in workflow_warnings[]:}
-- [{step}/{severity}] {code}: {message}"
-
-**If `workflow_warnings[]` is empty:** Skip this section entirely.
-
-### 6. Recommend Next Workflows
+### 2. Recommend Next Workflows
 
 "**Next steps:**
 - **[TS] test-skill** — Validate the stack skill against its own assertions
@@ -94,7 +43,7 @@ Read from the `workflow_warnings[]` accumulator defined in the Workflow Rules of
 
 - **[VS] verify-stack** — Validate the stack's integration feasibility against your architecture document{IF compose_mode:} (re-run to confirm feasibility after any architecture changes from **[RA] refine-architecture**){END IF}"
 
-### 6b. Result Contract
+### 2b. Result Contract
 
 Write the result contract per `shared/references/output-contract-schema.md` using the shared atomic writer. Two artifacts — both written via `skf-atomic-write.py write`:
 
@@ -122,7 +71,23 @@ Include `SKILL.md`, `context-snippet.md`, and `metadata.json` paths in `outputs`
 
 If either atomic write fails, log the error, leave any prior `-latest.json` untouched, and continue — the report is advisory and should not block the health-check chain.
 
-### 7. Chain to Health Check
+**Headless success envelope.** When `{headless_mode}` is true, emit the single-line result envelope on **stdout** (the success counterpart to the error envelopes every HARD HALT emits on stderr) before chaining to step 10. `skill_package` is the absolute path to the committed package; `stack_libraries` is the included library names:
+
+```
+SKF_STACK_RESULT_JSON: {"status":"success","skill_package":"{skill_package}","skill_name":"{project_name}-stack","stack_libraries":["<lib>", "..."],"mode":"{code|compose}","exit_code":0,"halt_reason":null}
+```
+
+### 2c. Post-Completion Hook (optional)
+
+If `{onCompleteCommand}` (resolved at SKILL.md On Activation §3 from `workflow.on_complete`) is non-empty, invoke it now — after the result contract (§2b) is written, before chaining to health-check:
+
+```bash
+{onCompleteCommand}
+```
+
+Run it with a bounded timeout (default 60s). On success, continue. On non-zero exit, timeout, or any failure, append the reason to `workflow_warnings[]` (e.g. `on_complete — failed (exit {N}): {stderr_first_line}`) and continue. **The hook must never fail the workflow** — it is integration glue (catalog registration, downstream pipeline notify) orthogonal to the forged stack. When `{onCompleteCommand}` is empty (bundled default), skip this section entirely.
+
+### 3. Chain to Health Check
 
-ONLY WHEN the forge banner, confidence distribution, output file summary, validation summary, warnings (if any), next-workflow recommendations, and result contract have all been handled will you then load, read the full file, and execute `{nextStepFile}`. The health-check step is the true terminal step — do not stop here even though the report reads as final.
+After the report sections above are handled, load, read the full file, and execute `{nextStepFile}`. The health-check step is the true terminal step — do not stop here even though the report reads as final.
 

package/src/skf-create-stack-skill/references/validate.md

@@ -1,6 +1,8 @@
 ---
 nextStepFile: 'report.md'
-stackSkillTemplate: 'assets/stack-skill-template.md'
+outputValidatorProbeOrder:
+  - '{project-root}/_bmad/skf/shared/scripts/skf-validate-output.py'
+  - '{project-root}/src/shared/scripts/skf-validate-output.py'
 ---
 
 <!-- Config: communicate in {communication_language}. Artifact text in {document_output_language}. -->
@@ -20,12 +22,25 @@ Validate all written output files against their expected structure and verify co
 
 ### 1. Verify File Existence
 
-Check that all expected files exist from written_files[]:
+Run the shared deterministic output validator once against the committed package — it checks the three core deliverable files' existence, SKILL.md frontmatter, and context-snippet format/token in a single call, so this step consumes its JSON rather than re-deriving those by hand. Resolve `{outputValidator}` from `{outputValidatorProbeOrder}` (first existing path wins). If neither candidate exists, log a WARNING (`"output validator unavailable — skf-validate-output.py missing"`) and fall back to the manual file/frontmatter/snippet checks below.
+
+```bash
+python3 {outputValidator} {skill_package} --generated-by create-stack-skill --skill-type stack
+```
+
+Consume from its JSON:
+
+- `files_found` — existence of `SKILL.md` / `context-snippet.md` / `metadata.json` (the three core deliverable rows below).
+- `validation.skill_md.frontmatter` — feeds the frontmatter check in §3 (manual-fallback path).
+- `validation.context_snippet.issues` — feeds §8.
+- `validation.stack_counts` — the stack count-equalities, derived deterministically from disk + metadata by the `--skill-type stack` pass: `issues[]` (each `{severity, field, message}`, one per mismatch of `library_count` / `integration_count` / `confidence_distribution`; empty when all agree) and `observed` (`library_count_meta`, `ref_file_count`, `integration_count_meta`, `pair_file_count`, `confidence_sum`). Feeds the count rows in §5 and the confidence-sum row in §7 — do not re-count files or re-sum the distribution by hand.
+
+**Under `--skill-type stack`, `validation.skill_md.body` and `validation.metadata` are emitted as `{"skipped": ...}` markers** — the *individual-skill* schema (which looks for `## Overview` / `Description` / `Key Exports` / `Usage` sections and a `source_repo` field) does not apply to a stack package, so the validator skips those passes and runs `validation.stack_counts` instead. Stack-shaped body structure and the remaining (non-count) metadata fields are checked in §4 / §5.
+
+Then confirm the remaining files the validator does not cover:
 
 **Deliverables** (`{skill_package}`):
-- [ ] SKILL.md
-- [ ] context-snippet.md
-- [ ] metadata.json
+- [ ] SKILL.md · context-snippet.md · metadata.json — from `files_found` above
 - [ ] references/ directory with per-library files
 - [ ] references/integrations/ directory with pair files (if integrations detected)
 
@@ -36,7 +51,7 @@ Check that all expected files exist from written_files[]:
 **Symlink:**
 - [ ] `{skill_group}/active` exists and resolves to `{version}`
 
-Record any missing files as **ERROR** findings.
+Record any missing files (from `files_found` or the manual rows) as **ERROR** findings.
 
 ### 2. Check Tool Availability
 
@@ -57,21 +72,15 @@ timeout 10s npx --no-install skill-check -h
 
 This validates frontmatter, description, body limits, links, formatting — and auto-fixes deterministic issues. Parse JSON for `scores[].score` (match the entry by `relativePath`/`skillId`; falls back to a top-level `qualityScore` on older skill-check builds), `diagnostics[]`, `fixed[]`.
 
-**Post-fix provenance drift guard (S15):** If `fixed[]` is non-empty, `skill-check --fix` has modified `SKILL.md` after step 7 wrote it. The safe default for v1.0 is to emit a **WARNING** finding listing each auto-fix (`"skill-check --fix modified SKILL.md: {fix_description} — metadata.json hashes/provenance may be out of date"`). Do NOT silently accept the fixes without surfacing the drift. If the caller wants authoritative metadata, they should re-run the workflow.
+**Post-fix provenance drift guard (S15):** If `fixed[]` is non-empty, `skill-check --fix` has modified `SKILL.md` after step 7 wrote it — so the `metadata.json` hashes/provenance recorded against the pre-fix body may now be stale. Emit a **WARNING** finding listing each auto-fix (`"skill-check --fix modified SKILL.md: {fix_description} — metadata.json hashes/provenance may be out of date"`) rather than silently accepting the fixes, so the drift is surfaced. If the caller wants authoritative metadata, they should re-run the workflow.
 
-**If `body.max_lines` reported**, prefer selective split: extract only the largest Tier 2 section(s) to `references/`, keeping Tier 1 content inline (inline passive context achieves 100% task accuracy vs 79% for on-demand retrieval). For a stack capstone the canonical split is the catalog (`Library Reference Index` + `Per-Library Summaries`) → `references/stack-catalog.md`, leaving an inline pointer (see `{stackSkillTemplate}` "Sizing Guidance"). This is the **intended** large-stack layout, not a violation: §4 below accepts the pointer form, so clearing the skill-check body ERROR this way does not also trip the structure check. Fall back to `npx skill-check split-body <skill-dir> --write` if not feasible. Verify any in-SKILL.md anchor links (e.g. to the catalog/pointer or other moved sections) still resolve after the split. Then re-validate.
+**If `body.max_lines` reported**, prefer selective split: extract only the largest Tier 2 section(s) to `references/`, keeping Tier 1 content inline (inline passive context achieves 100% task accuracy vs 79% for on-demand retrieval). For a stack capstone the canonical split is the catalog (`Library Reference Index` + `Per-Library Summaries`) → `references/stack-catalog.md`, leaving an inline pointer (see `{stackSkillTemplatePath}` "Sizing Guidance"). This is the **intended** large-stack layout, not a violation: §4 below accepts the pointer form, so clearing the skill-check body ERROR this way does not also trip the structure check. Fall back to `npx skill-check split-body <skill-dir> --write` if not feasible. Verify any in-SKILL.md anchor links (e.g. to the catalog/pointer or other moved sections) still resolve after the split. Then re-validate.
 
-**If unavailable**, perform manual frontmatter check:
-- [ ] Frontmatter present with `---` delimiters
-- [ ] `name` — present, non-empty, lowercase alphanumeric + hyphens, 1-64 chars, matches `{project_name}-stack`
-- [ ] `description` — present, non-empty, 1-1024 characters
-- [ ] No unknown fields — only `name`, `description`, `license`, `compatibility`, `metadata`, `allowed-tools` permitted
-
-Record frontmatter violations as **WARNING** findings. Invalid frontmatter will fail `npx skills add` and `npx skill-check check`.
+**If unavailable**, do not hand-walk the frontmatter — use `validation.skill_md.frontmatter` from the §1 output-validator run, which checks delimiters, `name` format + directory match (`{project_name}-stack`), `description` presence/length, and unknown fields against the agentskills.io allow-set. Record each reported issue at its severity as a **WARNING** finding. (If the output validator was *also* unavailable in §1, fall back to the manual checklist: `---` delimiters; `name` lowercase-alphanumeric-plus-hyphens 1-64 chars matching `{project_name}-stack`; `description` present and 1-1024 chars; only `name`/`description`/`license`/`compatibility`/`metadata`/`allowed-tools` permitted.) Invalid frontmatter will fail `npx skills add` and `npx skill-check check`.
 
 ### 4. Validate SKILL.md Body Structure
 
-Load `{stackSkillTemplate}` and verify SKILL.md contains expected sections:
+Load `{stackSkillTemplatePath}` and verify SKILL.md contains expected sections:
 
 - [ ] Header with project name, library count, integration count, forge tier
 - [ ] Integration Patterns section (before per-library summaries)
@@ -93,11 +102,12 @@ Parse metadata.json and verify required fields:
 - [ ] `version` and `generation_date` present
 - [ ] `forge_tier` is present and matches the forge tier from step 01 (`Quick|Forge|Forge+|Deep`)
 - [ ] `confidence_tier` is present and is exactly one of `T1|T1-low|T2|T3` — the dominant T-code computed from `confidence_distribution` (pick the tier with the highest count; ties resolve to the weaker tier: T1-low > T1, T2 > T1-low, T3 > T2 for tie-break so the reported tier never overstates confidence)
-- [ ] `library_count` matches actual reference files; `integration_count` matches pair files
 - [ ] `libraries` array present and non-empty
 - [ ] `confidence_distribution` object present with `t1`, `t1_low`, `t2`, `t3` keys (lowercase, matching template definition)
 
-Record mismatches as **WARNING** findings.
+**Count equalities (library / integration)** — do NOT re-count files here; take them from `validation.stack_counts` in the §1 output-validator run (invoked with `--skill-type stack`), which derived them deterministically from disk. The `library_count` vs per-library reference files and `integration_count` vs integration pair files checks surface as `field: "library_count"` / `field: "integration_count"` entries in `validation.stack_counts.issues[]` (absent when they agree); echo the exact numbers from `validation.stack_counts.observed` (`library_count_meta` / `ref_file_count`, `integration_count_meta` / `pair_file_count`). The `confidence_distribution`-sum equality is covered in §7.
+
+Record each `validation.stack_counts.issues[]` count entry (`library_count` / `integration_count`) and any other mismatch above as **WARNING** findings.
 
 ### 6. Validate Reference File Completeness
 
@@ -113,17 +123,17 @@ Scan all output files for confidence tier coverage:
 
 - [ ] SKILL.md: each per-library summary and integration pair entry has a confidence label
 - [ ] Reference files: each has a confidence label in its header
-- [ ] metadata.json: confidence_distribution sums match library_count
+- [ ] metadata.json: `confidence_distribution` sums to `library_count` — take this from the §1 output-validator run (`--skill-type stack`): the `field: "confidence_distribution"` entry in `validation.stack_counts.issues[]` is present only on mismatch, with `validation.stack_counts.observed.confidence_sum` vs `library_count_meta` for the exact numbers. Do not re-sum the distribution by hand.
 
-Record missing tier labels as **WARNING** findings.
+Record missing tier labels and any `validation.stack_counts` `confidence_distribution` issue as **WARNING** findings.
 
 ### 8. Validate context-snippet.md
 
-Verify context-snippet.md follows Vercel-aligned indexed format:
-- [ ] First line matches: `[{project}-stack v{version}]|root: {prefix}{project}-stack/` where prefix is `skills/` (draft form) or any IDE skill root (`.{dir}/skills/`)
-- [ ] Second line starts with `|IMPORTANT:`
+Take the first-line format, `|IMPORTANT:` second-line, and token-estimate checks from `validation.context_snippet.issues` returned by the §1 output-validator run — it performs the line-1 `[name vVersion]|root:` pattern match, the line-2 check, and the `len(content)//4` token estimate deterministically, so this step does not recompute them. Record each reported issue as a **WARNING** finding.
+
+Then verify the two stack-specific rows the generic validator does not cover:
 - [ ] Stack and integrations lines present
-- [ ] Approximate token count is ~80-120 tokens (use the `ceil(char_count / 4)` heuristic from step 7 §5; tolerate up to ~150 if the overflow strategy was applied and a workflow_warning was emitted)
+- [ ] Token estimate lands near the ~80-120 design target from step 7 §5 (the validator flags only its wider <40 / >200 bounds; an ~80-150 snippet with an overflow-strategy `workflow_warning` is expected, not a defect)
 
 Record format violations as **WARNING** findings.
 
@@ -137,13 +147,7 @@ Record security findings as advisory **WARNING** findings — they do not block
 
 ### 10. Display Validation Results
 
-**If all checks pass:**
-
-"**Validation complete — all checks passed.** Files: {count}/{count} present. SKILL.md structure valid. metadata.json fields verified. {lib_count} library + {pair_count} integration files verified. Confidence tiers: complete coverage. **Proceeding to summary report...**"
-
-**If warnings found:**
-
-"**Validation complete with {warning_count} finding(s).** Findings: {list each: severity, description, file_path}. Files: {present}/{expected} present. Warnings: {count}. Errors: {count}. {If errors: Note missing files may indicate a write failure in step 07.} **Proceeding to summary report...**"
+Report the validation outcome. If all checks passed, state so and name what was verified: file presence (`{count}/{count}`), SKILL.md structure, metadata.json fields, the `{lib_count}` library + `{pair_count}` integration reference files, and complete confidence-tier coverage. If there were findings, report the `{warning_count}` finding(s) — each with severity, description, and file path — plus files present/expected and warning/error counts; when errors include missing files, note this may indicate a write failure in step 07.
 
 ### 11. Auto-Proceed to Next Step