bmad-module-skill-forge 0.4.0 → 0.6.0

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

@@ -71,6 +71,16 @@ For each library pair (A, B):
 
 **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.
+
+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.

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

@@ -72,8 +72,8 @@ description: >
 
 **Frontmatter rules:**
 
-- `name`: lowercase alphanumeric + hyphens only, must match skill output directory name
-- `description`: non-empty, max 1024 chars, trigger-optimized for agent discovery
+- `name`: lowercase alphanumeric + hyphens only, must match skill output directory name. Prefer gerund form (`processing-pdfs`) for clarity.
+- `description`: non-empty, max 1024 chars, trigger-optimized for agent discovery. MUST use third-person voice ("Processes..." not "I can..." or "You can...").
 - No other frontmatter fields — only `name`, `description`, `license`, `compatibility`, `metadata`, `allowed-tools` are permitted by spec
 
 ### 3. Compile Integration Layer

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

@@ -83,7 +83,7 @@ Run: `npx skill-check -h`
 
 This validates frontmatter, description, body limits, links, formatting — and auto-fixes deterministic issues. Parse JSON for `qualityScore`, `diagnostics[]`, `fixed[]`.
 
-**If `body.max_lines` reported**, run: `npx skill-check split-body <skill-dir> --write`, then re-validate.
+**If `body.max_lines` reported**, prefer selective split: extract only the largest Tier 2 section(s) to `references/`, keeping Tier 1 content inline (inline passive context achieves 100% task accuracy vs 79% for on-demand retrieval). Fall back to `npx skill-check split-body <skill-dir> --write` if not feasible. Verify `#quick-start` and `#key-types` anchors still resolve after split. Then re-validate.
 
 **If unavailable**, perform manual frontmatter check:
 - [ ] Frontmatter present with `---` delimiters

package/src/workflows/create-stack-skill/validation-report.md

@@ -309,7 +309,7 @@ The workflow progresses logically from initialization through discovery, confirm
 **Strengths:**
 - Integration layer as primary value — not just concatenated library docs
 - Confidence tier system (T1/T1-low/T2) throughout all outputs
-- Forge-tier dependent extraction (Quick/Forge/Deep)
+- Forge-tier dependent extraction (Quick/Forge/Forge+/Deep)
 - Workspace artifacts (provenance-map.json, evidence-report.md) for traceability
 - Graceful degradation (single library failure doesn't halt; zero integrations is valid)
 

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

@@ -111,7 +111,7 @@ Multi-file document-producing workflow:
 ### Address (gaps identified from memory)
 
 - `manifest_reader` does not exist — needs self-contained dependency detection with fallback chain (npm/PyPI/crates.io/Cargo registry APIs → file parsing → web search)
-- No forge-tier awareness — must implement Quick/Forge/Deep tier behavior matching create-skill, quick-skill, test-skill, export-skill patterns
+- No forge-tier awareness — must implement Quick/Forge/Forge+/Deep tier behavior matching create-skill, quick-skill, test-skill, export-skill patterns
 - No tool bridge specifications — needs gh_bridge (all tiers), ast_bridge (Forge/Deep), qmd_bridge (Deep only)
 - No error handling matrix — needs hard halt / graceful degradation / silent skip / advisory categories
 - "Absorbs analyze-stack internally" undefined — must define concrete analyze-stack functionality within steps 01-05
@@ -273,7 +273,7 @@ create-stack-skill/
 
 **Step 01 (init):**
 - Load SKF module config from `_bmad/skf/config.yaml`
-- Load forge-tier.yaml from sidecar: determine Quick/Forge/Deep tier and available tools
+- Load forge-tier.yaml from sidecar: determine Quick/Forge/Forge+/Deep tier and available tools
 - Validate prerequisites: forge-tier.yaml exists, project root accessible
 - Accept optional explicit dependency list (skip auto-detection if provided)
 - Accept optional scope overrides per library

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

@@ -2,7 +2,7 @@
 name: create-stack-skill
 description: Consolidated project stack skill with integration patterns
 web_bundle: true
-installed_path: '{project-root}/_bmad/skf/workflows/create-stack-skill'
+installed_path: '{project-root}/_bmad/skf/workflows/skillforge/create-stack-skill'
 ---
 
 # Create Stack Skill

package/src/workflows/export-skill/data/snippet-format.md

@@ -47,5 +47,5 @@
 - **integrations line**: Co-import patterns from metadata.json `integrations` for stack skills
 - If fewer exports than the limit, list all available
 - If no exports data available, omit the api line
-- Section anchors must be verified against actual SKILL.md headings during generation
+- Section anchors must be verified against actual SKILL.md headings during generation. For split-body skills (where `references/` exists and `## Full` headings are stubs), if a heading is missing from SKILL.md, rewrite the anchor to point to the reference file path (preferred). Omit the anchor line only if the heading cannot be found in either SKILL.md or `references/*.md`
 - Skill path is relative to project root

package/src/workflows/export-skill/steps-c/step-01-load-skill.md

@@ -103,7 +103,7 @@ Extract from `metadata.json`:
 - `source_authority` — `official`, `internal`, or `community`
 - `exports` — Array of exported functions/types
 - `generation_date` — When the skill was last generated
-- `confidence_tier` — Quick/Forge/Deep
+- `confidence_tier` — Quick/Forge/Forge+/Deep
 
 **For stack skills, also extract:**
 - `components` — Array of dependencies with versions

package/src/workflows/export-skill/steps-c/step-02-package.md

@@ -59,9 +59,11 @@ Verify the skill directory contains the expected agentskills.io package layout:
 ├── SKILL.md              ← Required: Active skill document
 ├── metadata.json         ← Required: Machine-readable metadata
 ├── context-snippet.md    ← Will be generated/updated in step-03
-└── references/           ← Optional: Progressive disclosure
-    ├── {function-a}.md
-    └── {function-b}.md
+├── references/           ← Optional: Progressive disclosure
+│   ├── {function-a}.md
+│   └── {function-b}.md
+├── scripts/              ← Optional: Executable automation
+└── assets/               ← Optional: Templates, schemas, configs
 ```
 
 **Check each component:**
@@ -73,8 +75,10 @@ Verify the skill directory contains the expected agentskills.io package layout:
    - `source_authority` ("official", "internal", or "community")
    - `exports` (array)
    - `generation_date` (ISO date string)
-   - `confidence_tier` ("Quick", "Forge", or "Deep")
+   - `confidence_tier` ("Quick", "Forge", "Forge+", or "Deep")
 3. `references/` — If exists, check at least one .md file present
+4. `scripts/` — If exists, verify at least one file present and each file referenced in SKILL.md Section 7b exists. Warn for orphaned scripts (present but not referenced).
+5. `assets/` — If exists, verify at least one file present and each file referenced in SKILL.md Section 7b exists. Warn for orphaned assets (present but not referenced).
 
 ### 2. Validate Metadata Completeness
 

package/src/workflows/export-skill/steps-c/step-03-generate-snippet.md

@@ -73,7 +73,8 @@ Load {snippetFormatData} and read the format template for the skill type.
 1. Read metadata.json for `version`, `exports` array
 2. Select top exports (up to 10 for Deep tier, 5 otherwise). Append `()` to function names.
 3. Read SKILL.md to extract: heading slugs for `#quick-start` and `#key-types`, inline summary of key types (~10 words)
-4. Derive gotchas from: T2-future annotations in evidence report (breaking changes), async requirements, version-specific behavior. If no gotchas, omit the gotchas line.
+4. **Anchor verification (split-body awareness):** For each section anchor (`#quick-start`, `#key-types`), verify the heading exists in SKILL.md. If a `references/` directory exists and `## Full` headings in SKILL.md are absent or stubs (indicating split-body, not a stack skill's structural references), rewrite the anchor to point to the reference file path (e.g., `references/{file}.md#key-types`). If the heading cannot be resolved in either location, omit that anchor line from the snippet.
+5. Derive gotchas from: T2-future annotations in evidence report (breaking changes), async requirements, version-specific behavior. If no gotchas, omit the gotchas line.
 
 Generate:
 ```
@@ -157,6 +158,7 @@ ONLY WHEN snippet generation is complete (or skipped due to passive_context opt-
 
 - Snippet format loaded from {snippetFormatData}
 - Content generated matching exact Vercel-aligned format
+- Section anchors verified against SKILL.md headings (split-body anchors rewritten or omitted)
 - Token count estimated and within target
 - File written (or previewed in dry-run)
 - Passive context opt-out correctly handled (skip when disabled)

package/src/workflows/export-skill/workflow-plan-export-skill.md

@@ -174,7 +174,7 @@ Three CLAUDE.md cases:
 **Output Specifications:**
 - Type: Action-based (file writes + console output)
 - Files written:
-  1. `{skills_output_folder}/{name}/context-snippet.md` — ADR-L v2 format (~50-80 tokens/skill)
+  1. `{skills_output_folder}/{name}/context-snippet.md` — ADR-L v2 format (~80-120 tokens/skill)
   2. CLAUDE.md or AGENTS.md — managed `<!-- SKF:BEGIN/END -->` section per ADR-J (3 cases: create/append/regenerate)
   3. agentskills.io package structure — ready for `npx skills publish`
 - Console output: Token count report + export summary with distribution instructions

package/src/workflows/quick-skill/data/skill-template.md

@@ -73,7 +73,15 @@ Indexed format targeting ~80-120 tokens per skill:
   "generated_by": "quick-skill",
   "generation_date": "{date}",
   "confidence_tier": "Quick",
+  "extraction_tier": "quick",
+  "spec_version": "1.3",
   "exports": ["{export_1}", "{export_2}"],
+  "confidence_distribution": {
+    "t1": 0,
+    "t1_low": "{exports_count}",
+    "t2": 0,
+    "t3": 0
+  },
   "stats": {
     "exports_documented": "{number}",
     "exports_public_api": "{number}",

package/src/workflows/quick-skill/steps-c/step-02-ecosystem-check.md

@@ -71,9 +71,7 @@ Search for an existing official skill matching `{repo_name}` in the agentskills.
 
 **If no match found:**
 - Set `ecosystem_status: no-match`
-- Auto-proceed to step 3:
-
-"**No existing official skill found for {repo_name}. Proceeding to extraction...**"
+- Auto-proceed silently to step 3. Do not display any message — absence of a match is the expected case.
 
 **If match found:**
 - Set `ecosystem_status: match`

package/src/workflows/quick-skill/steps-c/step-04-compile.md

@@ -79,8 +79,8 @@ description: >
 ```
 
 **Frontmatter rules:**
-- `name`: lowercase alphanumeric + hyphens only, must match the skill output directory name
-- `description`: non-empty, max 1024 chars, optimized for agent discovery
+- `name`: lowercase alphanumeric + hyphens only, must match the skill output directory name. Prefer gerund form (`processing-pdfs`) for clarity.
+- `description`: non-empty, max 1024 chars, optimized for agent discovery. MUST use third-person voice ("Processes..." not "I can..." or "You can...").
 - No other frontmatter fields — only `name` and `description` for community skills
 
 **Required sections (after frontmatter):**
@@ -93,6 +93,7 @@ description: >
 - **Configuration:** If configuration options were found in source
 - **Dependencies:** Key dependencies from manifest
 - **Notes:** Caveats, limitations, extraction confidence level
+- **Scripts & Assets Note** (if source contains `scripts/`, `bin/`, `assets/`, `templates/`, or `schemas/` directories): "This package may include scripts and assets. Run create-skill for full extraction with provenance tracking."
 
 **If confidence is low:**
 - Include a note: "This skill was generated with limited source data. Consider running create-skill for a more thorough compilation."

package/src/workflows/setup-forge/data/tier-rules.md

@@ -7,16 +7,20 @@
 | ast-grep | `ast-grep --version` | Returns version string without error |
 | gh | `gh --version` | Returns version string without error |
 | qmd | `qmd status` | Returns status indicating initialized and operational |
+| ccc | Step A: `ccc --help` Step B: `ccc doctor` | Step A: exits 0 (binary exists). Step B: daemon running, version string, model check OK |
 
-**Important:** Use verification commands, not existence checks (`which`, `command -v`). A tool must be functional, not just present on PATH.
+**Important:** Use verification commands, not existence checks (`which`, `command -v`). A tool must be functional, not just present on PATH. For daemon-based tools (ccc), verify both binary existence and daemon health.
 
 ## Tier Calculation
 
-| Tier | Required Tools | Rule |
-|------|---------------|------|
-| Quick | None | Default when no tools are available |
-| Forge | ast-grep | ast-grep available, regardless of gh/qmd |
-| Deep | ast-grep + gh + qmd | All three tools available and functional |
+| Priority | Tier | Required Tools | Rule |
+|----------|------|---------------|------|
+| 1 (highest) | Deep | ast-grep + gh + qmd | All three core tools available and functional |
+| 2 | Forge+ | ast-grep + ccc | ast-grep AND ccc available, regardless of gh/qmd |
+| 3 | Forge | ast-grep | ast-grep available, without ccc/gh/qmd |
+| 4 (default) | Quick | None | Default when no tools are available |
+
+**Evaluation order:** Check Deep first, then Forge+, then Forge. The first match wins. This ensures Deep always takes priority when all tools are present.
 
 **Override:** If `tier_override` is set in preferences.yaml, use that value instead of calculated tier.
 
@@ -24,6 +28,9 @@
 - gh available but no ast-grep → Quick (gh alone doesn't unlock Forge)
 - ast-grep + gh but no qmd → Forge (qmd required for Deep)
 - ast-grep + qmd but no gh → Forge (gh required for Deep)
+- ccc available but no ast-grep → Quick (ccc alone doesn't unlock Forge+)
+- ast-grep + ccc + gh but no qmd → Forge+ (qmd required for Deep)
+- ast-grep + gh + qmd + ccc → Deep (Deep subsumes Forge+; ccc enhances transparently)
 
 ## Tier Capability Descriptions
 
@@ -35,6 +42,9 @@ Use these for positive-framing in the report step. Describe what the tier GIVES,
 ### Forge Tier
 "Forge tier active. You have AST-backed structural code analysis with line-level citations, plus template-driven generation. Every skill instruction traces to verified source code."
 
+### Forge+ Tier
+"Forge+ tier active. Semantic-guided precision compilation — cocoindex-code maps the codebase semantically before AST extraction runs. Every skill begins with a ranked discovery pass that surfaces the most relevant source regions, then AST-backed verification gives each export its line-level citation."
+
 ### Deep Tier
 "Deep tier active. Full capability unlocked — AST-backed code analysis, GitHub repository exploration, and QMD knowledge search with cross-repository synthesis. Maximum provenance and intelligence."
 

package/src/workflows/setup-forge/steps-c/step-01-detect-and-tier.md

@@ -2,7 +2,7 @@
 name: 'step-01-detect-and-tier'
 description: 'Detect available tools and determine forge capability tier'
 
-nextStepFile: './step-02-write-config.md'
+nextStepFile: './step-01b-ccc-index.md'
 tierRulesData: '../data/tier-rules.md'
 ---
 
@@ -10,7 +10,7 @@ tierRulesData: '../data/tier-rules.md'
 
 ## STEP GOAL:
 
-Verify availability of the three forge tools (ast-grep, gh, qmd), read any existing configuration for re-run comparison, check for tier override, and calculate the capability tier.
+Verify availability of the four forge tools (ast-grep, gh, qmd, ccc), read any existing configuration for re-run comparison, check for tier override, and calculate the capability tier.
 
 ## MANDATORY EXECUTION RULES (READ FIRST):
 
@@ -30,7 +30,7 @@ Verify availability of the three forge tools (ast-grep, gh, qmd), read any exist
 
 - 🎯 Focus only on tool detection and tier calculation
 - 🚫 FORBIDDEN to write any files — that is step-02's job
-- 🚫 FORBIDDEN to skip any tool check — all 3 must be verified
+- 🚫 FORBIDDEN to skip any tool check — all 4 must be verified
 - 💬 Tool command failures are NOT errors — they indicate unavailability
 
 ## EXECUTION PROTOCOLS:
@@ -38,7 +38,7 @@ Verify availability of the three forge tools (ast-grep, gh, qmd), read any exist
 - 🎯 Follow the MANDATORY SEQUENCE exactly
 - 💾 Store all results in memory for step-02
 - 📖 Load tier-rules.md for calculation reference
-- 🚫 FORBIDDEN to proceed without checking all 3 tools
+- 🚫 FORBIDDEN to proceed without checking all 4 tools
 
 ## CONTEXT BOUNDARIES:
 
@@ -95,22 +95,38 @@ Check if the `SNYK_TOKEN` environment variable is set:
 
 This is informational only — security scan availability does NOT affect the tier level. It is recorded in forge-tier.yaml so that create-skill's validation step can report actionable guidance when security scanning is unavailable.
 
-### 7. Calculate Tier
+### 7. Verify Tool: ccc (cocoindex-code)
 
-**If `{tier_override}` is set and valid (Quick, Forge, or Deep):**
+**Step A — Binary existence:** Run `ccc --help`
+
+- If exits 0: binary confirmed. Continue to Step B.
+- If fails (command not found or error): record `{ccc: false}`. Skip Step B.
+
+**Step B — Daemon health:** Run `ccc doctor`
+
+- If daemon is running and model check OK: record `{ccc: true}` and store version string from output
+- If daemon is not running: record `{ccc: true, ccc_daemon: "stopped"}` — binary available, daemon needs starting. Step-01b will handle this.
+- If error or timeout: record `{ccc: true, ccc_daemon: "error"}` — binary works but daemon has issues.
+
+ccc availability gates the Forge+ tier and enhances Deep tier when present.
+
+### 8. Calculate Tier
+
+**If `{tier_override}` is set and valid (Quick, Forge, Forge+, or Deep):**
 - Use `{tier_override}` as `{calculated_tier}`
 - Note that override is active for the report step
 
-**If no override, apply tier rules from {tierRulesData}:**
+**If no override, apply tier rules from {tierRulesData} in order — the first matching rule wins. Do not continue checking once a match is found:**
 - `{ast_grep}` AND `{gh_cli}` AND `{qmd}` all true → **Deep**
-- `{ast_grep}` true (regardless of gh/qmd) → **Forge**
+- `{ast_grep}` AND `{ccc}` both true (regardless of gh/qmd) → **Forge+**
+- `{ast_grep}` true (regardless of ccc/gh/qmd) → **Forge**
 - Otherwise → **Quick**
 
 **If `{tier_override}` is set but invalid:** ignore it, use detected tier, flag for warning in report.
 
-### 8. Auto-Proceed
+### 9. Auto-Proceed
 
-"**Proceeding to write configuration...**"
+"**Proceeding to CCC index check...**"
 
 #### Menu Handling Logic:
 
@@ -123,7 +139,7 @@ This is informational only — security scan availability does NOT affect the ti
 
 ## CRITICAL STEP COMPLETION NOTE
 
-ONLY WHEN all 3 core tools have been verified, optional security scan checked, and the tier calculated will you load and read fully `{nextStepFile}` to execute the configuration write step.
+ONLY WHEN all 4 core tools have been verified, optional security scan checked, and the tier calculated will you load and read fully `{nextStepFile}` to execute the CCC index check step.
 
 ---
 
@@ -131,19 +147,20 @@ ONLY WHEN all 3 core tools have been verified, optional security scan checked, a
 
 ### ✅ SUCCESS:
 
-- All 3 tools checked via verification commands (not existence checks)
+- All 4 tools checked via verification commands (not existence checks)
 - Existing forge-tier.yaml read for re-run comparison (if present)
 - Existing preferences.yaml read for tier_override (if present)
 - Tier correctly calculated from tool results or override applied
-- All results stored in context for step-02
-- Auto-proceeded to step-02
+- All results stored in context for step-01b and step-02
+- Auto-proceeded to step-01b
 
 ### ❌ SYSTEM FAILURE:
 
-- Skipping any tool verification
+- Skipping any tool verification (ast-grep, gh, qmd, ccc — all 4 must be checked)
 - Using `which` or `command -v` instead of verification commands
 - Assuming tool availability without running the command
 - Writing files in this step (that is step-02)
 - Not checking for existing configuration on re-runs
+- Not checking ccc availability (both binary and daemon health)
 
 **Master Rule:** Every tool MUST be verified empirically. No assumptions, no shortcuts.

package/src/workflows/setup-forge/steps-c/step-01b-ccc-index.md

@@ -0,0 +1,148 @@
+---
+name: 'step-01b-ccc-index'
+description: 'Ensure ccc project index exists — Forge+ and Deep tiers when ccc is available'
+
+nextStepFile: './step-02-write-config.md'
+---
+
+# Step 1b: CCC Index Verification
+
+## STEP GOAL:
+
+If ccc is available (`{ccc: true}` from step-01), verify that the ccc index exists for the project root. If no index exists, create it. Store index state in context for step-02 to write into forge-tier.yaml.
+
+For Quick and Forge tiers, or when ccc is unavailable, skip silently and proceed.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step, ensure entire file is read
+- 🎯 Execute all operations autonomously — no user interaction
+
+### Role Reinforcement:
+
+- ✅ You are a system executor verifying the ccc index state
+- ✅ ccc indexing failure is never a workflow error — degrade gracefully
+- ✅ No negative messaging for tiers that skip this step
+
+### Step-Specific Rules:
+
+- 🎯 Focus only on ccc index verification and creation
+- 🚫 FORBIDDEN to display skip messages for Quick/Forge tiers
+- 🚫 FORBIDDEN to fail the workflow if ccc indexing fails
+- 🚫 FORBIDDEN to re-index if ccc index already exists and is fresh (< staleness threshold)
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 💾 Store ccc index state in context for step-02
+- 🚫 FORBIDDEN to write forge-tier.yaml — that is step-02's job
+
+## CONTEXT BOUNDARIES:
+
+- Available: {ccc} boolean and {ccc_daemon} status from step-01
+- Available: {calculated_tier} from step-01
+- Available: existing forge-tier.yaml may contain prior `ccc_index` state
+- Focus: ccc index state verification and creation only
+- Dependencies: step-01 must have completed with tool detection results
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+### 1. Check Eligibility
+
+Read `{ccc}` from step-01 context.
+
+**If `{ccc}` is false:** Set `{ccc_index_result: "none", ccc_indexed_path: null, ccc_last_indexed: null}`. Proceed directly to section 4 (Auto-Proceed) — no output, no messaging.
+
+**If `{ccc}` is true:** Continue to section 2.
+
+### 2. Check Existing Index State
+
+Read existing forge-tier.yaml at `{project-root}/_bmad/_memory/forger-sidecar/forge-tier.yaml` (if it exists from a previous run).
+
+Check the `ccc_index` section:
+- If `ccc_index.indexed_path` matches `{project-root}` AND `ccc_index.status` is `"fresh"`:
+  - Check freshness: if `ccc_index.last_indexed` is within `staleness_threshold_hours` (default 24h) of now → index is fresh
+  - Store `{ccc_index_result: "fresh", ccc_indexed_path: {project-root}, ccc_last_indexed: {existing timestamp}}`
+  - Proceed to section 4
+
+- If `ccc_index.indexed_path` matches `{project-root}` but timestamp is older than threshold:
+  - Store `{ccc_index_result: "stale", ccc_indexed_path: {existing path}, ccc_last_indexed: {existing timestamp}}` — proceed to section 3 for re-index
+
+- If `ccc_index` is missing, has null values, or path doesn't match:
+  - Proceed to section 3 for initial index
+
+### 3. Create or Refresh CCC Index
+
+**If `{ccc_daemon}` is `"stopped"` or undefined (healthy daemon where no explicit state was recorded):**
+
+The `ccc index` command auto-starts the daemon when needed. Proceed with indexing below.
+
+**If `{ccc_daemon}` is `"error"`:**
+
+Attempt indexing anyway — errors will be caught below.
+
+Run:
+```bash
+ccc init {project-root}
+```
+
+**If init fails** (project may already be initialized): continue — this is not an error.
+
+Then run:
+```bash
+ccc index
+```
+
+**If succeeds:**
+- Run `ccc status` to get file count
+- Store `{ccc_index_result: "created", ccc_indexed_path: {project-root}, ccc_last_indexed: {current ISO timestamp}, ccc_file_count: {count from status}}`
+- Display: "**CCC index created.** {file_count} files indexed for semantic discovery."
+
+**If fails:**
+- Store `{ccc_index_result: "failed", ccc_indexed_path: null, ccc_last_indexed: null}`
+- Display: "CCC indexing failed: {error}. Extraction will use direct AST scanning — semantic pre-ranking unavailable this session."
+- Continue — this is NOT a workflow error
+
+### 4. Auto-Proceed
+
+"**Proceeding to write configuration...**"
+
+#### Menu Handling Logic:
+
+- After ccc index check completes (or is skipped), immediately load, read entire file, then execute {nextStepFile}
+
+#### EXECUTION RULES:
+
+- This is an auto-proceed step with no user choices
+- Proceed directly to next step after ccc index verification
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN ccc index verification is complete (or step is skipped for ccc unavailable) will you load and read fully `{nextStepFile}` to execute the configuration write step.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- ccc unavailable: skipped silently with no output, context variables set to null/none
+- ccc available with fresh index: verified freshness, skipped re-index, context variables set
+- ccc available with stale/missing index: index created, context variables set with fresh timestamp
+- ccc indexing fails: logged gracefully, workflow continues, context variables set to failed/null
+- Auto-proceeded to step-02
+
+### ❌ SYSTEM FAILURE:
+
+- Displaying skip messages when ccc is unavailable
+- Halting the workflow on ccc index failure
+- Re-indexing when index is already fresh and path matches
+- Writing forge-tier.yaml (that is step-02's responsibility)
+- Not storing ccc index context variables for step-02
+
+**Master Rule:** CCC indexing is always best-effort. Failures degrade gracefully. The workflow never halts over ccc issues.

package/src/workflows/setup-forge/steps-c/step-02-write-config.md

@@ -63,18 +63,32 @@ tools:
   ast_grep: {true/false from detection}
   gh_cli: {true/false from detection}
   qmd: {true/false from detection}
+  ccc: {true/false from detection}
+  ccc_daemon: {ccc_daemon from step-01 if available: "healthy"|"stopped"|"error", or ~}
   security_scan: {true/false — true when SNYK_TOKEN is set}
 
 # Capability tier (derived from tool availability)
-# Quick = no tools required | Forge = + ast-grep | Deep = + ast-grep + gh + QMD
+# Quick = no tools | Forge = + ast-grep | Forge+ = + ast-grep + ccc | Deep = + ast-grep + gh + QMD
 tier: {calculated_tier}
 tier_detected_at: {current ISO timestamp}
 
+# CCC semantic index state (managed by setup-forge step-01b and extraction workflows)
+ccc_index:
+  indexed_path: {ccc_indexed_path from step-01b, or ~}
+  last_indexed: {ccc_last_indexed from step-01b, or ~}
+  status: {ccc_index_status from step-01b: "fresh"|"created"|"none"|"failed"}
+  staleness_threshold_hours: 24
+
+# CCC index registry (tracks which source paths have been indexed for skill workflows)
+ccc_index_registry: []
+
 # QMD collection registry (populated by create-skill, consumed by audit/update-skill)
 # Each entry tracks a QMD collection created during skill workflows
 qmd_collections: []
 ```
 
+**Note on re-runs:** The `qmd_collections` and `ccc_index_registry` arrays must be preserved across re-runs. Before overwriting forge-tier.yaml, read the existing `qmd_collections` and `ccc_index_registry` arrays and re-inject them into the new write. These arrays are populated by create-skill workflows and must not be reset.
+
 **This file is ALWAYS overwritten** on every run — it reflects current tool state.
 
 If the write fails, report the error and halt the workflow.
@@ -90,15 +104,19 @@ Check if `{project-root}/_bmad/_memory/forger-sidecar/preferences.yaml` exists:
 # Created by setup-forge workflow on first run
 # Edit this file to customize Ferris behavior
 
-# Override detected tier (set to Quick, Forge, or Deep to force a tier)
+# Override detected tier (set to Quick, Forge, Forge+, or Deep to force a tier)
 tier_override: ~
 
 # Passive context injection (set to false to skip snippet generation and CLAUDE.md updates during export)
 passive_context: true
 
-# Skill generation defaults
-default_source_authority: community
-default_confidence_threshold: 0.7
+# Language defaults
+output_language: ~
+skill_format_version: ~
+
+# Output preferences
+citation_style: ~
+confidence_display: ~
 ```
 
 **If it DOES exist:** Do not modify. Preserve entirely.
@@ -133,7 +151,7 @@ ONLY WHEN forge-tier.yaml has been written successfully and preferences.yaml exi
 
 ### ✅ SUCCESS:
 
-- forge-tier.yaml written with accurate tool booleans, tier, timestamp, and empty qmd_collections registry
+- forge-tier.yaml written with accurate tool booleans (including ccc), tier, timestamp, ccc_index state, and preserved qmd_collections/ccc_index_registry arrays
 - preferences.yaml exists (created with defaults on first run, preserved on re-run)
 - forge-data/ directory exists (created or pre-existing)
 - Auto-proceeded to step-03