bmad-module-skill-forge 0.6.0 → 0.7.1

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

@@ -9,7 +9,7 @@ forgeTierConfig: '{sidecar_path}/forge-tier.yaml'
 
 ## STEP GOAL:
 
-To write all compiled content to disk — 4 deliverable files to `skills/{name}/` and 3 workspace artifacts to `forge-data/{name}/`, creating directories as needed.
+To write all compiled content to disk — 4 deliverable files to `{skills_output_folder}/{name}/` and 3 workspace artifacts to `{forge_data_folder}/{name}/`, creating directories as needed.
 
 ## MANDATORY EXECUTION RULES (READ FIRST):
 
@@ -30,7 +30,7 @@ To write all compiled content to disk — 4 deliverable files to `skills/{name}/
 
 - 🎯 Focus ONLY on writing files from the compiled content in context
 - 🚫 FORBIDDEN to modify content during writing — write exactly what was compiled
-- 🚫 FORBIDDEN to skip any artifact — all 7 files must be written
+- 🚫 FORBIDDEN to skip any artifact — all base artifact types must be written (4 deliverables + 3 workspace files + N reference files)
 - 💬 Report each file written with its path
 - 📁 Create directories before writing files
 
@@ -54,65 +54,66 @@ To write all compiled content to disk — 4 deliverable files to `skills/{name}/
 
 ### 1. Create Directory Structure
 
-Create the following directories at `{project-root}/`:
+Create the following directories:
 
 ```
-skills/{name}/
-skills/{name}/references/
-forge-data/{name}/
+{skills_output_folder}/{name}/
+{skills_output_folder}/{name}/references/
+{forge_data_folder}/{name}/
 ```
 
-If `scripts_inventory` is non-empty, also create: `skills/{name}/scripts/`
-If `assets_inventory` is non-empty, also create: `skills/{name}/assets/`
+If `scripts_inventory` is non-empty, also create: `{skills_output_folder}/{name}/scripts/`
+If `assets_inventory` is non-empty, also create: `{skills_output_folder}/{name}/assets/`
 
 Where `{name}` is the skill name from the brief (kebab-case).
 
 If directories already exist, do not error — proceed with file writing (overwrites existing files).
 
-### 2. Write Deliverables to skills/{name}/
+### 2. Write Deliverables to {skills_output_folder}/{name}/
 
 Write these 4 files from the compiled content:
 
-**File 1:** `skills/{name}/SKILL.md`
+**File 1:** `{skills_output_folder}/{name}/SKILL.md`
 - The complete compiled skill document
 - agentskills.io-compliant format with all sections
 - [MANUAL] markers seeded
 
-**File 2:** `skills/{name}/context-snippet.md`
+**File 2:** `{skills_output_folder}/{name}/context-snippet.md`
 - Compressed 2-line format for CLAUDE.md integration
 
-**File 3:** `skills/{name}/metadata.json`
+**File 3:** `{skills_output_folder}/{name}/metadata.json`
 - Machine-readable birth certificate with stats and provenance
 
-**File 4:** `skills/{name}/references/*.md`
+**File 4:** `{skills_output_folder}/{name}/references/*.md`
 - One file per function group or type
 - Progressive disclosure detail files
 
-**Files 4b (conditional):** `skills/{name}/scripts/*`
+**Files 4b (conditional):** `{skills_output_folder}/{name}/scripts/*`
 - One file per detected script, copied from source with content preserved
 - Only created when `scripts_inventory` is non-empty
 
-**Files 4c (conditional):** `skills/{name}/assets/*`
+**Files 4c (conditional):** `{skills_output_folder}/{name}/assets/*`
 - One file per detected asset, copied from source with content preserved
 - Only created when `assets_inventory` is non-empty
 
-### 3. Write Workspace Artifacts to forge-data/{name}/
+### 3. Write Workspace Artifacts to {forge_data_folder}/{name}/
 
 Write these 3 files from the compiled content:
 
-**File 5:** `forge-data/{name}/provenance-map.json`
+**File 5:** `{forge_data_folder}/{name}/provenance-map.json`
 - Per-claim source map with AST bindings and confidence tiers
 
-**File 6:** `forge-data/{name}/evidence-report.md`
+**File 6:** `{forge_data_folder}/{name}/evidence-report.md`
 - Build artifact with extraction summary, validation results, warnings
 
-**File 7:** `forge-data/{name}/extraction-rules.yaml`
+**File 7:** `{forge_data_folder}/{name}/extraction-rules.yaml`
 - Language and ast-grep schema used for this extraction (for reproducibility)
 
 ### 4. Verify Write Completion
 
 After all files are written, verify:
-- All 7 base files exist at their expected paths, plus scripts/ and assets/ files when inventories are non-empty
+- All 4 deliverable artifact types exist (SKILL.md, context-snippet.md, metadata.json, at least one file in references/), all 3 workspace artifacts exist (provenance-map.json, evidence-report.md, extraction-rules.yaml), plus scripts/ and assets/ files when inventories are non-empty
+- Store `ref_count` = count of files written to `references/` for use in step-08 report
 - List each file with its path and size
 
 **If any write failed:**
@@ -123,7 +124,7 @@ Display brief confirmation:
 
 "**Artifacts generated.**
 
-**Deliverables (skills/{name}/):**
+**Deliverables ({skills_output_folder}/{name}/):**
 - SKILL.md
 - context-snippet.md
 - metadata.json
@@ -131,7 +132,7 @@ Display brief confirmation:
 {if assets: - assets/ ({assets_count} files)}
 - references/ ({reference_count} files)
 
-**Workspace (forge-data/{name}/):**
+**Workspace ({forge_data_folder}/{name}/):**
 - provenance-map.json
 - evidence-report.md
 - extraction-rules.yaml
@@ -144,23 +145,13 @@ Proceeding to compilation report..."
 
 Index the generated skill artifacts into a QMD collection so that audit-skill and update-skill can perform high-signal searches against curated extraction data instead of raw source files.
 
-**Collection creation:**
-
-Create a QMD collection from both artifact directories:
-```bash
-qmd collection add {project-root}/skills/{name} --name {name}-extraction --mask "**/*"
-qmd embed
-```
-
-If collection already exists (re-run): remove and recreate for atomic replace:
+**Collection creation:** Create (or replace) a QMD collection from the skill artifacts:
 ```bash
-qmd collection remove {name}-extraction
-qmd collection add {project-root}/skills/{name} --name {name}-extraction --mask "**/*"
-qmd embed
+qmd collection remove {name}-extraction 2>/dev/null  # no-op if new
+qmd collection add {skills_output_folder}/{name} --name {name}-extraction --mask "**/*"
+qmd embed  # generates vector embeddings for vector_search/deep_search
 ```
 
-**Note:** `qmd embed` generates vector embeddings required for `vector_search` and `deep_search`. Without it, only BM25 keyword `search` works.
-
 **Registry update:**
 
 Read `{forgeTierConfig}` and update the `qmd_collections` array.
@@ -197,7 +188,7 @@ Dispatch to ccc CLI (`ccc index {source_root}`) or ccc MCP tool — `ccc_bridge.
 
 Read `{forgeTierConfig}` and update the `ccc_index_registry` array.
 
-Deduplicate by `source_repo` (the canonical upstream URL from brief_data) combined with `skill_name` — NOT by local `path`, which may be an ephemeral clone path that changes on every run for remote repos. If an entry with matching `source_repo` + `skill_name` already exists, replace it. Otherwise, append:
+Deduplicate by `source_repo` + `skill_name` (NOT local `path`, which may be ephemeral). Replace existing match or append:
 
 ```yaml
   - source_repo: "{brief.source_repo}"
@@ -209,11 +200,9 @@ Deduplicate by `source_repo` (the canonical upstream URL from brief_data) combin
 
 Write the updated forge-tier.yaml.
 
-**Error handling:**
-- If ccc indexing fails: log the error, continue. Do NOT fail the workflow.
-- If forge-tier.yaml update fails: log the error, continue.
+**Error handling:** If ccc indexing or registry update fails, log and continue — do NOT fail the workflow.
 
-**IF `tools.ccc` is false:** Skip this section silently. No messaging.
+**IF `tools.ccc` is false:** Skip this section silently.
 
 ### 6. Menu Handling Logic
 
@@ -239,9 +228,9 @@ ONLY WHEN all 7 artifact files are written and verified will you proceed to load
 
 ### ✅ SUCCESS:
 
-- Directory structure created (skills/{name}/, forge-data/{name}/)
-- All 4 deliverable files written to skills/{name}/
-- All 3 workspace artifact files written to forge-data/{name}/
+- Directory structure created ({skills_output_folder}/{name}/, {forge_data_folder}/{name}/)
+- All 4 deliverable files written to {skills_output_folder}/{name}/
+- All 3 workspace artifact files written to {forge_data_folder}/{name}/
 - Write completion verified — all 7 files exist
 - Deep tier: QMD collection `{name}-extraction` created/updated and registered in forge-tier.yaml
 - Non-Deep tier: QMD indexing skipped silently

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/manifest-patterns.md

@@ -20,6 +20,28 @@
 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
@@ -32,4 +54,4 @@
 For each dependency, count distinct files that import it:
 - Use grep patterns from Import Pattern column
 - Count unique file paths, not total import statements
-- Exclude test files, config files, and build artifacts from count
+- Exclude test files (`*/test/*`, `*_test.*`, `*.spec.*`, `*.test.*`), config files (`*.config.*`, `.eslintrc`, etc.), and build artifacts (`dist/`, `build/`, `node_modules/`, `target/`, `__pycache__/`) from count

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,8 +81,11 @@ 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
 
+See [knowledge/tool-resolution.md](../../../knowledge/tool-resolution.md) for how each bridge name resolves to concrete tools per IDE environment.
+
 Report tool availability. If a tier-required tool is missing, downgrade tier and note:
 
 "**Tier adjusted:** {original_tier} → {adjusted_tier} — {missing_tool} unavailable."
@@ -99,6 +102,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 +121,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.
 
@@ -66,10 +99,11 @@ Store the explicit list as `raw_dependencies` and skip to section 4.
 
 Load `{manifestPatterns}` for supported ecosystem detection patterns.
 
-Scan the project root (depth 0-1) for manifest files:
+Scan the project root (depth 0-1) for manifest files, **excluding directories listed in the Scan Exclusion Patterns section of `{manifestPatterns}`**:
 
 - Search for each supported manifest filename
 - Record: file path, ecosystem type, file size
+- **Apply exclusion patterns** from `{manifestPatterns}` — skip `node_modules/`, `.venv/`, `vendor/`, `dist/`, `build/`, `target/`, `.git/`, and all hidden directories when globbing
 - Note any unusual structures (monorepo with multiple manifests, workspace configurations)
 
 **If no manifest files found:**

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

@@ -30,7 +30,7 @@ Count import frequency for each dependency across the codebase, rank by usage, a
 - 🎯 Focus on counting imports, ranking, and getting user confirmation
 - 🚫 FORBIDDEN to extract library documentation — that is step 04
 - 💬 Present data clearly so user can make informed scope decisions
-- 🎯 Use subprocess (Pattern 1 grep) for import counting when available
+- 🎯 Use subprocess (Pattern 1 — grep/search): In Claude Code, use the Grep tool or Bash with `rg`. In Cursor, use built-in search. In CLI, use `grep`/`rg` directly. See [knowledge/tool-resolution.md](../../../knowledge/tool-resolution.md)
 
 ## EXECUTION PROTOCOLS:
 
@@ -52,10 +52,36 @@ 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.
 
+**Subprocess resolution:** Use the Grep tool (Claude Code), built-in search (Cursor), or `grep`/`rg` (CLI). See [knowledge/tool-resolution.md](../../../knowledge/tool-resolution.md).
+
 Use ecosystem-appropriate import patterns:
 - JavaScript/TypeScript: `import .* from ['"]library`, `require\(['"]library`
 - Python: `import library`, `from library import`
@@ -136,8 +162,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)
 
 ---