bmad-module-skill-forge 0.6.0 → 0.7.0

package/src/workflows/create-skill/steps-c/step-08-report.md

@@ -73,17 +73,17 @@ Where `{primary_confidence}` is the predominant confidence tier (T1 if Forge/Dee
 |------|-------|-------------|
 | T1 (AST) | {t1_count} | Structurally verified via ast-grep |
 | T1-low (Source) | {t1_low_count} | Inferred from source reading |
-| T2 (QMD) | {t2_count} | Enriched with temporal context |
+| T2 (QMD) | {t2_count} | QMD-enriched semantic context |
 | T3 (External) | {t3_count} | Sourced from external documentation URLs |
 
 **Output Files:**
-- `skills/{name}/SKILL.md` — Active skill with trigger-based usage
-- `skills/{name}/context-snippet.md` — Passive context for CLAUDE.md
-- `skills/{name}/metadata.json` — Machine-readable birth certificate
-- `skills/{name}/references/` — Progressive disclosure ({ref_count} files)
-- `forge-data/{name}/provenance-map.json` — Source map with AST bindings
-- `forge-data/{name}/evidence-report.md` — Build audit trail
-- `forge-data/{name}/extraction-rules.yaml` — Reproducible extraction schema"
+- `{skills_output_folder}/{name}/SKILL.md` — Active skill with trigger-based usage
+- `{skills_output_folder}/{name}/context-snippet.md` — Passive context for CLAUDE.md
+- `{skills_output_folder}/{name}/metadata.json` — Machine-readable birth certificate
+- `{skills_output_folder}/{name}/references/` — Progressive disclosure ({ref_count} files)
+- `{forge_data_folder}/{name}/provenance-map.json` — Source map with AST bindings
+- `{forge_data_folder}/{name}/evidence-report.md` — Build audit trail
+- `{forge_data_folder}/{name}/extraction-rules.yaml` — Reproducible extraction schema"
 
 ### 3. Display Warnings (If Any)
 
@@ -100,7 +100,7 @@ If no warnings, omit this section entirely.
 
 "**Recommended next steps:**
 - **[TS] Test Skill** — verify completeness and accuracy before export
-- **[ES] Export Skill** — publish to your skill library or agentskills.io
+- **[EX] Export Skill** — publish to your skill library or agentskills.io
 - **[US] Update Skill** — edit specific sections or add manual content
 
 To use this skill immediately, add the context snippet to your CLAUDE.md:
@@ -116,9 +116,23 @@ To use this skill immediately, add the context snippet to your CLAUDE.md:
 
 {If more remaining:} Proceeding to next brief: {next_skill_name}..."
 
-Update sidecar checkpoint with batch progress, then loop back to step-01 for the next brief.
+Update the batch checkpoint in `{sidecar_path}/batch-state.yaml` with:
 
-**If not batch mode or all batch briefs complete:**
+```yaml
+batch_active: true
+brief_list: [{full list of brief paths}]
+current_index: {index of next brief to process, 0-based}
+completed: [{list of completed skill names}]
+last_updated: {ISO timestamp}
+```
+
+Then loop back to step-01 for the next brief. Step-01 detects an active batch via `batch-state.yaml` and loads the brief at `current_index`.
+
+**If all batch briefs complete:**
+
+Set `batch_active: false` in `{sidecar_path}/batch-state.yaml` to prevent stale state. Display: "Batch complete. {completed_count} skills compiled."
+
+**If not batch mode:**
 
 End workflow. No further steps.
 

package/src/workflows/create-skill/workflow.md

@@ -9,13 +9,13 @@ installed_path: '{project-root}/_bmad/skf/workflows/skillforge/create-skill'
 
 **Goal:** Compile a verified agent skill from a skill-brief.yaml and source code, producing an agentskills.io-compliant SKILL.md with provenance map, evidence report, and progressive disclosure references.
 
-**Your Role:** You are a skill compilation engine performing structural extraction and assembly. This workflow is mostly autonomous with three interaction points — one after ecosystem check (if a match is found), one after source extraction (to confirm findings before compilation), and one after content quality review (when tessl produces suggestions). All other steps auto-proceed. Apply zero hallucination tolerance: every instruction in the output must trace to source code with a confidence tier citation.
+**Your Role:** You are operating in **Ferris Architect mode** — a skill compilation engine performing structural extraction and assembly. This workflow is mostly autonomous with three interaction points — one after ecosystem check (if a match is found), one after source extraction (to confirm findings before compilation), and one after content quality review (when tessl produces suggestions). All other steps auto-proceed. Apply zero hallucination tolerance: every instruction in the output must trace to source code with a confidence tier citation.
 
 ## WORKFLOW ARCHITECTURE
 
 ### Core Principles
 
-- **Micro-file Design**: Each step of the overall goal is a self contained instruction file that you will adhere too 1 file as directed at a time
+- **Micro-file Design**: Each step of the overall goal is a self contained instruction file that you will adhere to 1 file as directed at a time
 - **Just-In-Time Loading**: Only 1 current step file will be loaded, read, and executed to completion - never load future step files until told to do so
 - **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
 - **Tier-Aware Execution**: Steps adapt behavior based on forge tier (Quick/Forge/Forge+/Deep) loaded from sidecar at init

package/src/workflows/create-stack-skill/data/compose-mode-rules.md

@@ -0,0 +1,65 @@
+# Compose Mode Rules
+
+Rules for synthesizing a stack skill from pre-generated individual skills and an architecture document, without requiring a codebase.
+
+## Skill Loading
+
+1. Scan `{skills_output_folder}` for subdirectories containing both `SKILL.md` and `metadata.json`
+2. **Filter:** Skip any subdirectory named `{project_name}-stack` or any skill where `metadata.json` has `"skill_type": "stack"` — stack skills must not be loaded as source dependencies to avoid self-referencing loops
+3. Skip any subdirectory missing either `SKILL.md` or `metadata.json` — log a warning and skip
+4. Load each `metadata.json` and extract: `name`, `language`, `confidence_tier`, `source_repo`, `exports` (count), `version`
+5. Store the subdirectory name as `skill_dir` (distinct from `name` — the directory may differ from the metadata name)
+6. Store loaded skills as `raw_dependencies` with `source: "existing_skill"`
+
+## Architecture Integration Mapping
+
+**If `{architecture_doc_path}` is null or the file does not exist:** Skip this section and proceed to [Inferred Integrations (No Architecture Document)](#inferred-integrations-no-architecture-document) below.
+
+1. Load the architecture document from `{architecture_doc_path}`
+2. Parse section headers and prose paragraphs for references to loaded skill names
+3. A **co-mention** is detected when a paragraph or section references 2+ loaded skill names
+4. For each co-mention pair, load both skills' export lists and API signatures from their `SKILL.md`
+5. Compose an integration section describing how the two libraries connect based on:
+   - Shared types or interfaces between the two skills' API surfaces
+   - Architecture document prose describing their interaction
+   - Complementary domain roles (e.g., one produces data the other consumes)
+
+## Confidence Tier Inheritance
+
+- All compose-mode evidence inherits confidence tiers from the source individual skills
+- If both skills in a pair are T1, the integration is T1
+- If either skill is T1-low, the integration is T1-low
+- If either skill is T2, the structural confidence still inherits the lower of T1/T1-low from the pair — the T2 temporal annotations from that skill are carried as an additive enrichment marker, not a tier upgrade
+- T1 + T2 pair: inherits `T1 [composed, +T2 annotations]` — the T1 skill provides full structural confidence
+- T1-low + T2 pair: inherits `T1-low [composed, +T2 annotations]` — T1-low structural confidence with T2 temporal annotations noted
+- If both skills are T2 (no T1/T1-low base available): the integration confidence is `T1-low [composed, +T2 annotations from both]` — T2 temporal enrichment depends on structural extraction, so the most conservative structural tier is assumed
+- Compose-mode integrations add suffix: `[composed]` — e.g., `T1 [composed]`, `T1-low [composed, +T2 annotations]`
+
+## Integration Evidence Format
+
+Each integration entry must cite both source skills by name with function signatures:
+
+```
+{Skill A name} + {Skill B name}
+  Type: [pattern type from integration-patterns.md]
+  Evidence:
+    [from skill: {Skill A name}] {exported_function_signature}
+    [from skill: {Skill B name}] {exported_function_signature}
+  Architecture reference: "{quoted prose from architecture doc}"
+  Confidence: {inherited_tier} [composed]
+```
+
+## Feasibility Report Integration
+
+If a feasibility report (`feasibility-report-{project_name}.md`) exists in `{forge_data_folder}/`:
+- Load the VS overall verdict from the report's YAML frontmatter `overall_verdict` field (`FEASIBLE`, `CONDITIONALLY FEASIBLE`, or `NOT FEASIBLE`) and parse per-pair verdicts from the `## Integration Verdicts` markdown table (`Verified`, `Plausible`, `Risky`, or `Blocked`)
+- Include the verdict in the integration evidence: `VS overall: {FEASIBLE|CONDITIONALLY FEASIBLE|NOT FEASIBLE}`, `VS pair: {Verified|Plausible|Risky|Blocked}`
+- Flag any pairs where VS reported `Risky` or `Blocked` verdicts
+
+## Inferred Integrations (No Architecture Document)
+
+When no architecture document is available:
+- Infer potential integrations from skills sharing the same `language` field
+- Infer from skills sharing domain keywords in their `SKILL.md` descriptions
+- Mark all inferred integrations: `[inferred from shared domain]`
+- Inferred integrations default to lowest confidence of the pair with `[inferred from shared domain]` suffix (use this instead of `[composed]` for inferred integrations)

package/src/workflows/create-stack-skill/data/stack-skill-template.md

@@ -70,17 +70,39 @@ Indexed format targeting ~80-120 tokens per stack:
   "version": "1.0.0",
   "generation_date": "{ISO-8601}",
   "confidence_tier": "{Quick|Forge|Forge+|Deep}",
+  "spec_version": "1.3",
   "source_authority": "{official|community|internal}",
+  "generated_by": "create-stack-skill",
   "exports": [],
   "library_count": 0,
   "integration_count": 0,
   "libraries": ["lib1", "lib2"],
   "integration_pairs": [["lib1", "lib2"]],
+  "language": "{primary language or list of languages from constituent skills}",
+  "ast_node_count": "{number-or-omitted-if-no-ast}",
   "confidence_distribution": {
-    "T1": 0,
-    "T1-low": 0,
-    "T2": 0
-  }
+    "t1": 0,
+    "t1_low": 0,
+    "t2": 0,
+    "t3": 0
+  },
+  "tool_versions": {
+    "ast_grep": "{version-or-null}",
+    "qmd": "{version-or-null}",
+    "skf": "{skf_version}"
+  },
+  "stats": {
+    "exports_documented": 0,
+    "exports_public_api": 0,
+    "exports_internal": 0,
+    "exports_total": 0,
+    "public_api_coverage": 0.0,
+    "total_coverage": 0.0,
+    "scripts_count": 0,
+    "assets_count": 0
+  },
+  "dependencies": [],
+  "compatibility": "{semver-range}"
 }
 ```
 
@@ -90,7 +112,7 @@ Indexed format targeting ~80-120 tokens per stack:
 # {library_name} Reference
 
 **Version:** {version_from_manifest}
-**Import count:** {count} files
+**Import count:** {count} files *(compose-mode: replace with **Export count:** {count} exports)*
 **Confidence:** {T1/T1-low/T2}
 
 ## Key Exports
@@ -110,7 +132,7 @@ Indexed format targeting ~80-120 tokens per stack:
 
 **Type:** {pattern_type}
 **Co-import files:** {count}
-**Confidence:** {T1/T1-low}
+**Confidence:** {T1/T1-low/T2 [composed]}
 
 ## Integration Pattern
 [Detailed description of how these libraries connect]

package/src/workflows/create-stack-skill/steps-c/step-01-init.md

@@ -81,6 +81,7 @@ Extract:
 **Tier-dependent tools:**
 - **Quick:** gh_bridge (source reading) — graceful degradation to local file reading if unavailable
 - **Forge:** ast_bridge (ast-grep structural analysis) — required for Forge tier
+- **Forge+:** ast_bridge + ccc_bridge (ccc semantic co-import augmentation) — ccc available for step-05
 - **Deep:** qmd_bridge (QMD temporal enrichment) — required for Deep tier
 
 Report tool availability. If a tier-required tool is missing, downgrade tier and note:
@@ -99,6 +100,18 @@ Check if the user provided:
 - If provided, store as `scope_overrides` for use in step 03
 - Format: `library_name: include|exclude`
 
+**Compose mode detection:**
+
+Set `compose_mode: false` as the default.
+
+- 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 subdirectory in `{skills_output_folder}` contains both `SKILL.md` and `metadata.json` → suggest compose mode to the user and ask for optional architecture document path
+  - 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
+
+If compose_mode:
+- Display: "**Compose mode detected.** Synthesizing stack skill from existing skills + architecture document."
+
 If no optional inputs provided, auto-detection will be used.
 
 ### 4. Display Initialization Summary
@@ -106,16 +119,19 @@ If no optional inputs provided, auto-detection will be used.
 "**Stack Skill Forge initialized.**
 
 **Project:** {project_name}
-**Forge Tier:** {tier_description}
-- Quick: Source reading and import counting
-- Forge: + AST-backed structural analysis
-- Forge+: + CCC semantic co-import augmentation
-- Deep: + Temporal integration evolution
+**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}
+**Input Mode:** {auto-detect | explicit dependency list | compose mode}
 
-**Proceeding to manifest detection...**"
+**If compose mode:** Proceeding to skill loading...
+**If code mode:** Proceeding to manifest detection..."
 
 ### 5. Auto-Proceed to Next Step
 

package/src/workflows/create-stack-skill/steps-c/step-02-detect-manifests.md

@@ -38,7 +38,7 @@ Scan the project root for dependency manifest files, parse each to extract depen
 - 🎯 Load manifest-patterns.md for detection rules
 - 💾 Store manifests found and raw dependency list as workflow state
 - 📖 Auto-proceed to step 03 after successful detection
-- 🚫 HALT if no manifests found and no explicit list provided
+- 🚫 HALT if no manifests found and no explicit list provided — **unless `compose_mode` is true** (compose mode skips manifest detection)
 
 ## CONTEXT BOUNDARIES:
 
@@ -50,6 +50,39 @@ Scan the project root for dependency manifest files, parse each to extract depen
 
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
 
+### 0. Check Compose Mode
+
+**If `compose_mode` is true AND `explicit_deps` was provided in step 01:**
+
+Use the explicit dependency list directly. Store the explicit list as `raw_dependencies` with `source: "explicit"` and skip to [Auto-Proceed to Next Step](#5-auto-proceed-to-next-step).
+
+**If `compose_mode` is true AND `explicit_deps` was NOT provided:**
+
+Scan `{skills_output_folder}` for subdirectories containing SKILL.md and metadata.json.
+
+**Filter:** Skip any subdirectory named `{project_name}-stack` or any skill where `metadata.json` has `"skill_type": "stack"` — stack skills must not be loaded as source dependencies to avoid self-referencing loops.
+
+**If zero skills remain after filtering:** HALT with: "**Cannot proceed in compose-mode.** No individual skills found in `{skills_output_folder}` (after filtering stack skills). Run [CS] Create Skill or [QS] Quick Skill to generate individual skills first, then re-run [SS]."
+
+For each skill found:
+1. Read metadata.json
+2. Extract: name, language, confidence_tier, source_repo, exports count, version
+3. Store the subdirectory name as `skill_dir` (distinct from `name` — the directory may differ from the metadata name)
+4. Store as `raw_dependencies` with source: "existing_skill"
+
+Display:
+"**Loaded {N} existing skills as dependencies.**
+
+| Skill | Language | Tier | Exports | Source |
+|-------|----------|------|---------|--------|
+| {name} | {lang} | {tier} | {count} | {repo} |
+
+**Proceeding to scope confirmation...**"
+
+Skip to [Auto-Proceed to Next Step](#5-auto-proceed-to-next-step) — the skills table above serves as the detection summary.
+
+**If not compose_mode:** Continue with section 1 (existing flow).
+
 ### 1. Check for Explicit Dependency List
 
 **If `explicit_deps` was provided in step 01:**
@@ -58,7 +91,7 @@ Scan the project root for dependency manifest files, parse each to extract depen
 
 **Dependencies:** {explicit_deps_count} libraries provided"
 
-Store the explicit list as `raw_dependencies` and skip to section 4.
+Store the explicit list as `raw_dependencies` and skip to [Display Detection Summary](#4-display-detection-summary).
 
 **If no explicit list:** Continue to section 2.
 

package/src/workflows/create-stack-skill/steps-c/step-03-rank-and-confirm.md

@@ -52,6 +52,30 @@ Count import frequency for each dependency across the codebase, rank by usage, a
 
 ### 1. Count Import Frequency
 
+**If `compose_mode` is true:**
+
+Skip import counting entirely. All skills are included by default.
+
+Set `confirmed_dependencies` = all `raw_dependencies` (the list already stored as workflow state from Step 02).
+
+**Apply scope_overrides:** If `scope_overrides` were provided in step 01, apply them now — force-include or force-exclude skills as specified. Log any overrides applied.
+
+Present skills sorted by architectural layer (from architecture doc if available):
+- If `architecture_doc_path` is not null: parse architecture doc for section headers to determine layer grouping
+- If `architecture_doc_path` is null or layers not detectable: present alphabetically
+
+Display skills as a table:
+
+| # | Skill | Language | Tier | Architecture Layer |
+|---|-------|----------|------|--------------------|
+| 1 | {name} | {language} | {confidence_tier} | {layer or 'Unclassified'} |
+
+User confirms inclusion/exclusion at the gate (same [C] menu as code-mode).
+
+Skip to [Present MENU OPTIONS](#5-present-menu-options).
+
+**If not compose_mode:**
+
 For each dependency in `raw_dependencies`:
 
 **Launch a subprocess** that runs grep across all source files in the project to count import statements for each library. Return only the counts, not file contents.
@@ -136,8 +160,8 @@ Display: **Select:** [C] Continue to Extraction
 
 #### Menu Handling Logic:
 
-- IF C: Store confirmed_dependencies, then load, read entire file, then execute {nextStepFile}
-- IF Any other: Process as scope modification, redisplay updated list, then [Redisplay Menu Options](#5-present-menu-options)
+- IF C: Store current `confirmed_dependencies` (including any modifications made since initial presentation), then load, read entire file, then execute {nextStepFile}
+- IF Any other: Process as scope modification (add/remove skills from `confirmed_dependencies`), update the in-memory `confirmed_dependencies` list accordingly, redisplay the updated skills table, then [Redisplay Menu Options](#5-present-menu-options)
 
 ---
 

package/src/workflows/create-stack-skill/steps-c/step-04-parallel-extract.md

@@ -50,6 +50,30 @@ For each confirmed dependency, extract key exports, usage patterns, and API surf
 
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
 
+### 0. Check Compose Mode
+
+**If `compose_mode` is true:**
+
+"**Extraction data already available from individual skills. Skipping extraction phase.**"
+
+For each confirmed skill, load `{skills_output_folder}/{skill_dir}/SKILL.md` (where `skill_dir` is the subdirectory name stored in step-02, which may differ from the `name` field in metadata.json) into context. Build a `per_library_extractions[]` entry for each skill with the following fields:
+- `library`: skill name from metadata.json
+- `exports`: exports list extracted from the SKILL.md exports section
+- `usage_patterns`: usage patterns from the SKILL.md usage section
+- `confidence`: the skill's existing confidence tier (T1, T1-low, T2) — inherited directly
+
+Display an extraction summary:
+
+"**Loaded {N} skill extractions from existing skills.**
+
+| Skill | Exports | Confidence | Status |
+|-------|---------|------------|--------|
+| {name} | {count} | {tier} | Loaded |"
+
+Auto-proceed to next step.
+
+**If not compose_mode:** Continue with section 1 (existing flow).
+
 ### 1. Prepare Extraction Plan
 
 **AST Tool Availability Check (Forge/Deep only):**

package/src/workflows/create-stack-skill/steps-c/step-05-detect-integrations.md

@@ -4,6 +4,7 @@ description: 'Detect co-import patterns and integration points between confirmed
 
 nextStepFile: './step-06-compile-stack.md'
 integrationPatterns: '../data/integration-patterns.md'
+composeModeRules: '../data/compose-mode-rules.md'
 ---
 
 # Step 5: Detect Integrations
@@ -42,7 +43,7 @@ Analyze co-import patterns between confirmed libraries to identify integration p
 
 ## CONTEXT BOUNDARIES:
 
-- From step 03: confirmed_dependencies[] with file lists per library
+- From step 03: confirmed_dependencies[] — in code-mode, includes file lists per library; in compose-mode, file lists are not present (use per_library_extractions[] from step 04 for skill content)
 - From step 04: per_library_extractions[] with exports and patterns
 - This step produces: integration_graph {pairs[], types[], files[]}
 - This is the VALUE-ADD step — what makes stack skills different from individual skills
@@ -61,6 +62,33 @@ Report: "**Analyzing {pair_count} library pairs for integration patterns...**"
 
 ### 2. Detect Co-Import Files
 
+**If `compose_mode` is true:**
+
+Instead of co-import grep, detect integrations from architecture document:
+
+1. Load `{composeModeRules}` for integration evidence format rules
+2. **If `{architecture_doc_path}` is null or not available:** Skip directly to the "If no architecture document available" fallback below
+3. Load the architecture document from `{architecture_doc_path}`
+4. Use prose-based co-mention analysis: find paragraphs mentioning 2+ confirmed skill names
+5. For each detected integration pair:
+   - Load both skills' export lists and API signatures
+   - Compose an integration section following the format from `{composeModeRules}`
+   - Include VS feasibility verdict if a feasibility report (`feasibility-report-{project_name}.md`) exists in `{forge_data_folder}/`
+   - Cite evidence from both skills: `[from skill: {skill_name}]`
+
+All integration evidence inherits confidence tiers from the source skills. Load and apply the full **Confidence Tier Inheritance** matrix from `{composeModeRules}` to compute the correct tier for each pair (covers T1+T1, T1+T1-low, T1-low+T1-low, T1+T2, T1-low+T2, T2+T2 cases). Apply the `[composed]` suffix to all confidence labels — e.g., `T1 [composed]`, `T1-low [composed, +T2 annotations]`.
+
+**VS verdict parsing (if feasibility report exists):** Read the `overall_verdict` from the report's YAML frontmatter. Parse the `## Integration Verdicts` markdown table for per-pair verdicts. For each architecture-detected pair, include `VS overall: {verdict}` and `VS pair: {verdict}` in the integration evidence per the format in `{composeModeRules}`. VS verdicts do not apply to inferred integrations since the VS report operates on architecture-described interactions only. Additionally, flag any pairs where VS reported `Risky` or `Blocked` by appending a `[VS: Risky]` or `[VS: Blocked]` warning annotation to the integration entry.
+
+If no architecture document available:
+- Infer potential integrations from skills sharing the same `language` field or sharing domain keywords in their SKILL.md descriptions (use the `usage_patterns` and `exports` fields from `per_library_extractions[]` built in step-04, or reload `{skills_output_folder}/{skill_dir}/SKILL.md` if full prose text is needed for keyword extraction)
+- Mark inferred integrations: `[inferred from shared domain]` — use this suffix instead of `[composed]` for inferred integrations
+- Inferred integrations qualify automatically — no file-count threshold applies
+
+Skip to section 3 (Classify Integration Types) with the compose-mode pairs.
+
+**If not compose_mode:**
+
 For each library pair (A, B):
 
 **Launch a subprocess** that greps across all source files to find files importing BOTH library A and library B. Return only file paths and import line numbers.
@@ -85,7 +113,7 @@ CCC failures: skip augmentation silently, proceed with grep-only results.
 
 Load `{integrationPatterns}` for classification rules.
 
-For each qualifying pair (2+ co-import files), analyze the co-import files to classify the integration type:
+For each qualifying pair, analyze to classify the integration type (**in compose-mode**: all architecture-document-detected pairs qualify automatically — the 2+ co-import file threshold applies only in code-mode; **in code-mode**: pair must have 2+ co-import files):
 
 - **Type 1: Middleware Chain** — Sequential function calls piping output between libraries
 - **Type 2: Shared Types** — Type definitions exchanged between libraries

package/src/workflows/create-stack-skill/steps-c/step-06-compile-stack.md

@@ -80,6 +80,8 @@ description: >
 
 **This is the core value of the stack skill.** Compile in order:
 
+**Zero-integration guard:** If the integration graph from step 05 has zero edges (no detected integration pairs), skip the integration layer compilation and note: "No integration patterns detected — stack skill will contain library summaries without an integration layer." Proceed directly to section 4 (Per-Library Sections).
+
 **Cross-cutting patterns** (if any):
 - Patterns spanning 3+ libraries
 - Middleware chains, shared configuration, common architectural patterns
@@ -98,7 +100,7 @@ description: >
 
 ### 4. Compile Per-Library Sections
 
-For each confirmed library (ordered by integration connectivity, then import count):
+For each confirmed library (ordered by integration connectivity, then import count — **in compose-mode**, order by integration connectivity, then skill confidence tier since import counts are not available):
 
 - Role in stack (one-line description)
 - Key exports used in this project
@@ -122,6 +124,8 @@ Create the reference index table:
 |---------|---------|-------------|------------|-----------|
 | ... | ... | ... | ... | ... |
 
+(**in compose-mode**: replace the Imports column with Export Count from source skill metadata, since import counts are not available)
+
 ### 7. Present Compiled SKILL.md Preview
 
 "**Stack skill compilation complete. Please review:**

package/src/workflows/create-stack-skill/steps-c/step-07-generate-output.md

@@ -77,10 +77,10 @@ Write `{skills_output_folder}/{project_name}-stack/SKILL.md` with the approved s
 For each confirmed library, write `{skills_output_folder}/{project_name}-stack/references/{library_name}.md`:
 
 Load structure from `{stackSkillTemplate}` references section:
-- Library name, version from manifest
-- Import count and file count
+- Library name, version from manifest (**in compose-mode**: version from source skill `metadata.json`)
+- Import count and file count (**in compose-mode**: export count from source skill metadata)
 - Key exports with signatures
-- Usage patterns with file:line citations
+- Usage patterns with file:line citations (**in compose-mode**: usage patterns from source skill SKILL.md)
 - Confidence tier label
 
 ### 4. Write Integration Pair Reference Files
@@ -102,7 +102,7 @@ Write `{skills_output_folder}/{project_name}-stack/context-snippet.md`:
 
 Use the Vercel-aligned indexed format targeting ~80-120 tokens:
 ```
-[{project_name}-stack v{version}]|root: skills/{project_name}-stack/
+[{project_name}-stack v{version — in code-mode: primary_library_version or 1.0.0; in compose-mode: highest version across constituent skill metadata.json files, or 1.0.0 if none}]|root: skills/{project_name}-stack/
 |IMPORTANT: {project_name}-stack — read SKILL.md before writing integration code. Do NOT rely on training data.
 |stack: {dep-1}@{v1}, {dep-2}@{v2}, {dep-3}@{v3}
 |integrations: {pattern-1}, {pattern-2}
@@ -113,6 +113,8 @@ Use the Vercel-aligned indexed format targeting ~80-120 tokens:
 
 Write `{skills_output_folder}/{project_name}-stack/metadata.json`:
 
+Populate all fields from the metadata.json schema defined in `{stackSkillTemplate}`:
+
 ```json
 {
   "skill_type": "stack",
@@ -120,11 +122,34 @@ Write `{skills_output_folder}/{project_name}-stack/metadata.json`:
   "version": "{primary_library_version or 1.0.0}",
   "generation_date": "{current_date}",
   "confidence_tier": "{tier}",
+  "spec_version": "1.3",
+  "source_authority": "{official|community|internal — use the lowest authority among constituent skills}",
+  "generated_by": "create-stack-skill",
+  "exports": [],
   "library_count": N,
   "integration_count": N,
   "libraries": ["lib1", "lib2"],
   "integration_pairs": [["lib1", "lib2"]],
-  "confidence_distribution": {"T1": N, "T1-low": N, "T2": N}
+  "language": "{primary language or list of languages from constituent skills}",
+  "ast_node_count": "{number or omit if no AST extraction performed}",
+  "confidence_distribution": {"t1": N, "t1_low": N, "t2": N, "t3": N},
+  "tool_versions": {
+    "ast_grep": "{version or null}",
+    "qmd": "{version or null}",
+    "skf": "{skf_version}"
+  },
+  "stats": {
+    "exports_documented": N,
+    "exports_public_api": N,
+    "exports_internal": N,
+    "exports_total": N,
+    "public_api_coverage": 0.0,
+    "total_coverage": 0.0,
+    "scripts_count": N,
+    "assets_count": N
+  },
+  "dependencies": [],
+  "compatibility": "{semver-range}"
 }
 ```
 
@@ -133,6 +158,8 @@ Write `{skills_output_folder}/{project_name}-stack/metadata.json`:
 Write workspace artifacts to `{forge_data_folder}/{project_name}-stack/`:
 
 **provenance-map.json:**
+
+**In code-mode:**
 ```json
 {
   "libraries": {
@@ -154,6 +181,27 @@ Write workspace artifacts to `{forge_data_folder}/{project_name}-stack/`:
 }
 ```
 
+**In compose-mode:**
+```json
+{
+  "libraries": {
+    "lib_name": {
+      "source_skill_path": "skills/{skill_dir}/",
+      "compose_source": "architecture_co_mention|inferred_from_shared_domain",
+      "confidence": "T1|T1-low|T2",
+      "source_skill_tier": "{original skill confidence tier}",
+      "exports_found": N
+    }
+  },
+  "integrations": {
+    "libA+libB": {
+      "detection_method": "architecture_co_mention|inferred_from_shared_domain",
+      "type": "pattern_type"
+    }
+  }
+}
+```
+
 **evidence-report.md:**
 - Extraction summary per library
 - Integration detection results per pair

package/src/workflows/create-stack-skill/steps-c/step-08-validate.md

@@ -112,16 +112,16 @@ Parse metadata.json and verify required fields:
 - [ ] `skill_type` equals "stack"
 - [ ] `name` matches `{project_name}-stack`
 - [ ] `version` and `generation_date` present
-- [ ] `confidence_tier` matches tier from step 01
+- [ ] `confidence_tier` matches forge tier from step 01 (Quick/Forge/Forge+/Deep) — in both code-mode and compose-mode, this is the forge tier; per-library inherited confidence is tracked separately in `confidence_distribution`
 - [ ] `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 keys
+- [ ] `confidence_distribution` object present with `t1`, `t1_low`, `t2`, `t3` keys (lowercase, matching template definition)
 
 Record mismatches as **WARNING** findings.
 
 ### 6. Validate Reference File Completeness
 
-For each confirmed library, verify `references/{library}.md` contains: library name header, version from manifest, Key Exports section, Usage Patterns section.
+For each confirmed library, verify `references/{library}.md` contains: library name header, version from manifest (**in compose-mode**: version from source skill metadata), Key Exports section, Usage Patterns section.
 
 For each integration pair, verify `references/integrations/{libraryA}-{libraryB}.md` contains: integration pair header, type classification, Integration Pattern section, Key Files section.
 

package/src/workflows/create-stack-skill/steps-c/step-09-report.md

@@ -64,7 +64,11 @@ Forge tier: **{tier}**"
 |------|-------|-------------|
 | T1 | {count} | AST-verified structural extraction |
 | T1-low | {count} | Source reading inference |
-| T2 | {count} | QMD-enriched temporal context |"
+| 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
 
@@ -107,7 +111,9 @@ Forge tier: **{tier}**"
 
 "**Next steps:**
 - **[TS] test-skill** — Validate the stack skill against its own assertions
-- **[ES] export-skill** — Package for distribution or agent loading
+- **[EX] export-skill** — Package for distribution or agent loading
+
+- **[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}
 
 **Workflow complete.**"
 

package/src/workflows/create-stack-skill/workflow.md

@@ -7,7 +7,7 @@ installed_path: '{project-root}/_bmad/skf/workflows/skillforge/create-stack-skil
 
 # Create Stack Skill
 
-**Goal:** Analyze a project's dependency manifests, detect significant libraries, discover co-import integration points, and produce a consolidated stack skill documenting how libraries connect in THIS specific codebase.
+**Goal:** Produce a consolidated stack skill documenting how libraries connect. **Code-mode:** analyzes dependency manifests and co-import patterns from actual source code. **Compose-mode:** synthesizes from pre-generated individual skills and architecture documents when no codebase exists yet.
 
 **Your Role:** In addition to your name, communication_style, and persona, you are also a dependency analyst and integration architect operating in Ferris Architect mode. You bring expertise in dependency analysis, cross-library integration patterns, and compositional architecture, while the user brings their project knowledge and scope preferences. Execute with prescriptive precision — every finding must trace to actual code with file:line citations.
 
@@ -23,7 +23,7 @@ This uses **step-file architecture** for disciplined execution:
 - **Just-In-Time Loading**: Only the current step file is in memory — never load future step files until told to do so
 - **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
 - **Append-Only Building**: Build outputs by accumulating state across steps
-- **Zero Hallucination**: All extracted content must trace to actual source code — no inferred or assumed patterns
+- **Zero Hallucination**: All extracted content must trace to actual source code — no inferred or assumed patterns. In compose-mode, inferred integrations are permitted but must be labeled `[inferred from shared domain]` per compose-mode-rules.md
 
 ### Step Processing Rules