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

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

@@ -1,196 +0,0 @@
----
-name: 'step-05-detect-integrations'
-description: 'Detect co-import patterns and integration points between confirmed libraries'
-
-nextStepFile: './step-06-compile-stack.md'
-integrationPatterns: '../data/integration-patterns.md'
-composeModeRules: '../data/compose-mode-rules.md'
----
-
-# Step 5: Detect Integrations
-
-## STEP GOAL:
-
-Analyze co-import patterns between confirmed libraries to identify integration points — where and how libraries connect in this specific codebase.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 📖 CRITICAL: Read the complete step file before taking any action
-- ⚙️ TOOL/SUBPROCESS FALLBACK: If any instruction references a subprocess, subagent, or tool you do not have access to, you MUST still achieve the outcome in your main context thread
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT in your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are an integration architect operating in Ferris Architect mode
-- ✅ Zero hallucination — only document integrations evidenced in actual code
-- ✅ Every integration pattern must cite co-import files with file:line references
-
-### Step-Specific Rules:
-
-- 🎯 Focus on detecting cross-library patterns using 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)
-- 🚫 FORBIDDEN to compile SKILL.md — that is step 06
-- 💬 Integration detection is the core differentiator of stack skills vs individual skills
-- ⚙️ If subprocess unavailable, perform grep operations in main thread
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load integration-patterns.md for detection rules
-- 💾 Store integration_graph as workflow state
-- 📖 Auto-proceed to step 06 after detection complete
-- 🚫 Graceful handling if no integrations detected
-
-## CONTEXT BOUNDARIES:
-
-- 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
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
-
-### 1. Generate Library Pairs
-
-From `confirmed_dependencies`, generate all unique pairs:
-- N libraries → N*(N-1)/2 pairs
-- Skip pairs where either library had extraction failure in step 04
-
-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 SKILL.md from the version-aware path: use `skill_package_path` from step-02, or resolve via `{skills_output_folder}/{skill_dir}/active/{skill_dir}/SKILL.md` — see [knowledge/version-paths.md](../../../knowledge/version-paths.md))
-- 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.
-
-**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).
-
-**Subprocess returns:** `{pair: [A, B], co_import_files: [{path, line_A, line_B}], count: N}`
-
-**If subprocess unavailable:** Intersect the file lists from step 03 import counts for each pair.
-
-**Threshold:** A pair must have 2+ co-import files to qualify as an integration pattern (single file co-imports may be incidental).
-
-**CCC Semantic Augmentation (Forge+ and Deep with ccc):**
-
-If `tools.ccc` is true AND `ccc_index.status` is `"fresh"` or `"stale"` in forge-tier.yaml, augment co-import detection with semantic search (max 1 query per library pair):
-
-For each library pair that has exactly 1 co-import file (below the 2-file threshold), run `ccc_bridge.search("{libA} {libB}", source_root, top_k=10)` to find files where the two libraries interact semantically — even without explicit import co-location. If CCC returns additional files where both libraries appear, add them to the pair's co-import candidate list and re-evaluate against the 2-file threshold.
-
-**Tool resolution for ccc_bridge.search:** Use `/ccc` skill search (Claude Code), ccc MCP server (Cursor), or `ccc search "{libA} {libB}" --path {source_root} --top 10` (CLI). See [knowledge/tool-resolution.md](../../../knowledge/tool-resolution.md).
-
-For pairs that already qualify (2+ files), CCC is not needed for detection — but the CCC results may surface additional integration files for richer classification in section 3.
-
-CCC failures: skip augmentation silently, proceed with grep-only results.
-
-### 3. Classify Integration Types
-
-Load `{integrationPatterns}` for classification rules.
-
-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
-- **Type 3: Configuration Bridge** — One library configuring or initializing another
-- **Type 4: Event Handler** — Event patterns crossing library boundaries
-- **Type 5: Adapter/Wrapper** — Thin wrapper connecting library interfaces
-- **Type 6: State Sharing** — Shared state stores or context providers
-
-For each detected integration:
-- Identify the top 3 files demonstrating the pattern
-- Extract a brief description of how the libraries connect
-- Assign confidence: T1 if AST-verified, T1-low if source reading
-
-### 4. Build Integration Graph
-
-Assemble the integration graph:
-- **Nodes:** Confirmed libraries (with extraction data from step 04)
-- **Edges:** Detected integration pairs with type, file count, and description
-- Identify **hub libraries** (connected to 3+ other libraries)
-- Identify **cross-cutting patterns** (patterns spanning 3+ libraries)
-
-### 5. Display Integration Summary
-
-**If integrations detected:**
-
-"**Integration detection complete.**
-
-**Integration graph:** {lib_count} libraries, {pair_count} integration pairs
-
-**Hub libraries** (connected to 3+ others):
-{For each hub:} - **{library}** — integrates with {partner_list}
-
-**Detected integrations:**
-| Library A | Library B | Type | Co-import Files | Confidence |
-|-----------|-----------|------|-----------------|------------|
-| {name} | {name} | {type} | {count} | {tier} |
-
-{If cross-cutting patterns:}
-**Cross-cutting patterns:**
-- {description spanning 3+ libraries}
-
-**Proceeding to stack compilation...**"
-
-**If no integrations detected:**
-
-"**No co-import integration patterns detected** between confirmed libraries.
-
-The libraries in this project appear to operate independently. The stack skill will contain library summaries without an integration layer.
-
-**Proceeding to stack compilation...**"
-
-### 6. Auto-Proceed to Next Step
-
-Load, read the full file and then execute `{nextStepFile}`.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All library pairs analyzed for co-imports
-- Integration types classified using pattern rules
-- Hub libraries and cross-cutting patterns identified
-- Integration graph built with confidence labels
-- Graceful handling of zero integrations (not a failure)
-- Auto-proceeded to step 06
-
-### ❌ SYSTEM FAILURE:
-
-- Fabricating integrations not evidenced in code
-- Not applying the 2+ file threshold for pairs
-- Starting to compile SKILL.md (step 06's job)
-- Treating zero integrations as a workflow failure (it's valid)
-
-**Master Rule:** Only document integrations that exist in actual code. Zero integrations is a valid result.

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

@@ -1,270 +0,0 @@
----
-name: 'step-07-generate-output'
-description: 'Write all output files — SKILL.md, references, metadata, context-snippet, and forge-data'
-
-nextStepFile: './step-08-validate.md'
-stackSkillTemplate: '../data/stack-skill-template.md'
----
-
-# Step 7: Generate Output Files
-
-## STEP GOAL:
-
-Write all deliverable and workspace artifact files to their target directories.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 📖 CRITICAL: Read the complete step file before taking any action
-- ⚙️ TOOL/SUBPROCESS FALLBACK: If any instruction references a subprocess, subagent, or tool you do not have access to, you MUST still achieve the outcome in your main context thread
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT in your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are a skill packager operating in Ferris Architect mode
-- ✅ Precise file writing — every file matches its template structure
-- ✅ Hard halt on any write failure — partial output is worse than no output
-
-### Step-Specific Rules:
-
-- 🎯 Write ALL output files in correct directory structure
-- 🚫 FORBIDDEN to modify compiled content — step 06 produced the approved version
-- 💬 Report each file written with path and size
-- 🎯 Create directory structure before writing files
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Create output directories, write all files
-- 💾 Store written_files list as workflow state
-- 📖 Auto-proceed to validation after all files written
-- 🚫 HARD HALT on any individual file write failure
-
-## CONTEXT BOUNDARIES:
-
-- From step 06: skill_content (approved compiled SKILL.md)
-- From step 04: per_library_extractions[] for reference files
-- From step 05: integration_graph for integration pair references
-- From step 01: forge_tier, project info for metadata
-- This step produces: written_files[] (all output artifacts)
-- Path resolution: See `knowledge/version-paths.md` for canonical path templates. Stack skills use `{project_name}-stack` as the skill name
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
-
-### 1. Create Output Directories
-
-Resolve `{version}` from the primary library version or default to `1.0.0`. Create the directory structure:
-
-```
-{skill_group}                          # {skills_output_folder}/{project_name}-stack/
-{skill_package}                        # {skills_output_folder}/{project_name}-stack/{version}/{project_name}-stack/
-├── references/
-│   └── integrations/
-```
-
-```
-{forge_version}                        # {forge_data_folder}/{project_name}-stack/{version}/
-```
-
-Where the skill name is `{project_name}-stack` and `{version}` is the semver version (with build metadata stripped per `knowledge/version-paths.md`).
-
-If directories already exist, proceed (overwrite previous output).
-
-### 2. Write SKILL.md
-
-Write `{skill_package}/SKILL.md` with the approved skill_content from step 06.
-
-### 3. Write Per-Library Reference Files
-
-For each confirmed library, write `{skill_package}/references/{library_name}.md`:
-
-Load structure from `{stackSkillTemplate}` references section:
-- 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 (**in compose-mode**: usage patterns from source skill SKILL.md)
-- Confidence tier label
-
-### 4. Write Integration Pair Reference Files
-
-For each detected integration pair, write `{skill_package}/references/integrations/{libraryA}-{libraryB}.md`:
-
-Load structure from `{stackSkillTemplate}` integrations section:
-- Library pair and integration type
-- Co-import file count
-- Integration pattern description with file:line citations
-- Usage convention
-- Confidence tier label
-
-**If no integrations detected:** Skip this section (no files to write).
-
-### 5. Write context-snippet.md
-
-Write `{skill_package}/context-snippet.md`:
-
-Use the Vercel-aligned indexed format targeting ~80-120 tokens:
-```
-[{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}
-|gotchas: {1-2 most critical integration pitfalls}
-```
-
-### 6. Write metadata.json
-
-Write `{skill_package}/metadata.json`:
-
-Populate all fields from the metadata.json schema defined in `{stackSkillTemplate}`:
-
-```json
-{
-  "skill_type": "stack",
-  "name": "{project_name}-stack",
-  "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"]],
-  "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}"
-}
-```
-
-### 7. Write Forge Data Artifacts
-
-Write workspace artifacts to `{forge_version}`:
-
-**provenance-map.json:**
-
-**In code-mode:**
-```json
-{
-  "libraries": {
-    "lib_name": {
-      "manifest_source": "package.json",
-      "extraction_method": "ast_bridge|source_reading|qmd_bridge",
-      "confidence": "T1|T1-low|T2",
-      "files_analyzed": N,
-      "exports_found": N
-    }
-  },
-  "integrations": {
-    "libA+libB": {
-      "detection_method": "co-import grep",
-      "co_import_files": N,
-      "type": "pattern_type"
-    }
-  }
-}
-```
-
-**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
-- Warnings and failures encountered
-- Confidence tier distribution
-
-### 8. Create Active Symlink
-
-Create or update the `active` symlink at `{skill_group}/active` pointing to `{version}`:
-
-```
-{skill_group}/active -> {version}
-```
-
-If the symlink already exists, remove it first and recreate. This ensures `{skill_group}/active/{project_name}-stack/` resolves to the just-written skill package.
-
-### 9. Display Write Summary
-
-"**Output files written.**
-
-**Deliverables** ({skill_package}):
-- SKILL.md ({line_count} lines)
-- context-snippet.md ({token_estimate} tokens)
-- metadata.json
-- references/ -- {lib_count} library files
-- references/integrations/ -- {pair_count} integration files
-
-**Workspace** ({forge_version}):
-- provenance-map.json
-- evidence-report.md
-
-**Symlink:** {skill_group}/active -> {version}
-
-**Total files written:** {total_count}
-
-**Proceeding to validation...**"
-
-### 10. Auto-Proceed to Next Step
-
-Load, read the full file and then execute `{nextStepFile}`.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All deliverable files written to {skill_package}
-- All workspace artifacts written to {forge_version}
-- Directory structure created correctly with version nesting
-- Active symlink created at {skill_group}/active -> {version}
-- Each file matches its template structure
-- Write summary displayed with accurate counts
-
-### ❌ SYSTEM FAILURE:
-
-- Any file write failure not caught (hard halt required)
-- Modifying approved skill_content during writing
-- Missing files from the expected output set
-- Wrong directory paths for output
-
-**Master Rule:** Write everything, modify nothing. Hard halt on any write failure.

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

@@ -1,145 +0,0 @@
----
-name: 'step-09-report'
-description: 'Display final stack skill summary with confidence distribution and next workflow recommendations'
----
-
-# Step 9: Stack Skill Report
-
-## STEP GOAL:
-
-Display the final summary of the forged stack skill with confidence distribution, output file listing, and next workflow recommendations.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 📖 CRITICAL: Read the complete step file before taking any action
-- ⚙️ TOOL/SUBPROCESS FALLBACK: If any instruction references a subprocess, subagent, or tool you do not have access to, you MUST still achieve the outcome in your main context thread
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT in your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are Ferris delivering the final forge report
-- ✅ Positive capability framing — lead with what was accomplished
-- ✅ Warnings are secondary — present them only if they exist
-
-### Step-Specific Rules:
-
-- 🎯 This is the FINAL step — no nextStepFile
-- 🚫 FORBIDDEN to write or modify any files — report is console output only
-- 💬 Lead with the positive summary, then details, then warnings if any
-- 🎯 Recommend next workflows based on what was produced
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Compile summary from all previous step results
-- 📖 Display report to user — workflow is complete after this
-- 🚫 No file writes, no state updates — this is terminal output
-
-## CONTEXT BOUNDARIES:
-
-- From step 01: project_name, forge_tier
-- From step 03: confirmed_dependencies[] count
-- From step 04: per_library_extractions[] with confidence tiers
-- From step 05: integration_graph with pair count
-- From step 07: written_files[] with paths
-- From step 08: validation_result with findings
-- This step produces: console report (no stored artifacts)
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
-
-### 1. Display Stack Forged Banner
-
-"**Stack forged: {project_name}-stack — {lib_count} libraries, {integration_count} integration patterns**
-
-Forge tier: **{tier}**"
-
-### 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)
-
-**Only display if warnings exist from any step:**
-
-"**Warnings:**
-{For each warning from steps 04, 05, 07, 08:}
-- {warning_description}"
-
-**If no warnings:** Skip this section entirely.
-
-### 6. Recommend Next Workflows
-
-"**Next steps:**
-- **[TS] test-skill** — Validate the stack skill against its own assertions
-- **[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.**"
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Banner displayed with accurate library and integration counts
-- Confidence distribution table with correct tier counts
-- All output files listed with descriptions
-- Validation summary reflects actual step 08 findings
-- Warnings displayed only when they exist
-- Next workflow recommendations included
-- Positive capability framing throughout
-
-### ❌ SYSTEM FAILURE:
-
-- Inaccurate counts in banner or distribution table
-- Missing output files from the listing
-- Displaying warnings section when no warnings exist
-- Writing or modifying files in this step
-- Not recommending next workflows
-- Negative framing or apologetic tone
-
-**Master Rule:** Celebrate what was built. Report accurately. Recommend next steps. Workflow complete.

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

@@ -1,59 +0,0 @@
----
-name: create-stack-skill
-description: Consolidated project stack skill with integration patterns
-web_bundle: true
-installed_path: '{project-root}/_bmad/skf/workflows/skillforge/create-stack-skill'
----
-
-# Create Stack Skill
-
-**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.
-
----
-
-## WORKFLOW ARCHITECTURE
-
-This uses **step-file architecture** for disciplined execution:
-
-### Core Principles
-
-- **Micro-file Design**: Each step is a self-contained instruction file that must be followed exactly
-- **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. In compose-mode, inferred integrations are permitted but must be labeled `[inferred from shared domain]` per compose-mode-rules.md
-
-### Step Processing Rules
-
-1. **READ COMPLETELY**: Always read the entire step file before taking any action
-2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
-3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
-4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
-5. **LOAD NEXT**: When directed, load, read entire file, then execute the next step file
-
-### Critical Rules (NO EXCEPTIONS)
-
-- 🛑 **NEVER** load multiple step files simultaneously
-- 📖 **ALWAYS** read entire step file before execution
-- 🚫 **NEVER** skip steps or optimize the sequence
-- 🎯 **ALWAYS** follow the exact instructions in the step file
-- ⏸️ **ALWAYS** halt at menus and wait for user input
-- 📋 **NEVER** create mental todo lists from future steps
-- ⚙️ **TOOL/SUBPROCESS FALLBACK**: If any instruction references a subprocess, subagent, or tool you do not have access to, you MUST still achieve the outcome in your main context thread
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT in your Agent communication style with the config `{communication_language}`
-
----
-
-## INITIALIZATION SEQUENCE
-
-### 1. Module Configuration Loading
-
-Load and read full config from {project-root}/_bmad/skf/config.yaml and resolve:
-
-- `project_name`, `output_folder`, `user_name`, `communication_language`, `document_output_language`, `skills_output_folder`, `forge_data_folder`, `sidecar_path`
-
-### 2. First Step Execution
-
-Load, read the full file and then execute `./steps-c/step-01-init.md` to begin the workflow.