bmad-module-skill-forge 0.4.0 → 0.6.0

package/src/knowledge/ccc-bridge.md

@@ -0,0 +1,110 @@
+# CCC Bridge
+
+## Principle
+
+`ccc_bridge.*` references in workflow steps are **conceptual interfaces**, not callable functions. They describe a semantic code discovery operation to perform. Use the `ccc` MCP server tools (when available) or `ccc` CLI commands to execute these operations. See the TOOL/SUBPROCESS FALLBACK rule — if ccc is unavailable, the calling step falls back to direct ast-grep or source reading without ccc pre-discovery.
+
+## Rationale
+
+Without ccc pre-discovery, extraction steps scan all source files uniformly — processing them in directory order or entry-point-first order. On large codebases (500+ files), this means AST extraction in CLI streaming mode uses `head -N` cutoffs that may miss relevant exports in files that appear late in the scan. Integration detection in Stack Skill relies on grep-based co-import counting, which misses semantic relationships between libraries that don't appear in the same file.
+
+With ccc pre-discovery:
+- Extraction steps receive a relevance-ranked file queue — the most semantically important files are processed first, before any streaming cutoff
+- Integration detection gains semantic augmentation — pairs below the 2-file co-import threshold can be evaluated via natural language queries
+- Audit workflows can detect renamed/moved exports via semantic search before classifying them as deleted
+
+The key architectural constraint: ccc discovers, ast-grep verifies. Discovery method is orthogonal to confidence tier. This keeps the 4-tier confidence system (T1/T1-low/T2/T3) clean and avoids tier proliferation.
+
+## When ccc Is Used
+
+ccc is a **discovery layer only**. It answers "where should I look?" — it does not produce citations or structural claims. Every path or symbol returned by ccc_bridge must be verified by `ast_bridge` (T1) or source reading (T1-low) before it enters the extraction inventory. ccc results never appear in provenance citations.
+
+ccc is available at **Forge+** and **Deep** tiers (when `tools.ccc: true` in forge-tier.yaml).
+
+## Availability
+
+ccc_bridge operations are available when:
+- `tools.ccc: true` in forge-tier.yaml (verified by `ccc --help` + `ccc doctor` in setup-forge)
+- `ccc_index.status` is `"fresh"` or `"stale"` in forge-tier.yaml (an index exists for the project)
+
+When either condition is false, calling steps skip ccc discovery silently and proceed with direct ast-grep or source reading. This is standard Forge tier behavior — not a degradation.
+
+## Operations
+
+### `ccc_bridge.search(query, path?, top_k?)`
+
+**Resolves to:** `ccc search "{query}" --path {path} --top {top_k}` (CLI) or the `ccc` MCP search tool (preferred)
+
+Returns: list of `{file, score, snippet}` entries ranked by semantic relevance to the query. These are **candidates** for ast-grep extraction — not verified exports.
+
+**Usage context:** Called before ast-grep in Forge+ and Deep tier extraction steps to discover semantically relevant source regions. Results pre-rank the file extraction queue so ast-grep processes the most relevant files first.
+
+### `ccc_bridge.ensure_index(path)`
+
+**Resolves to:** Check `ccc_index.status` in forge-tier.yaml. If `"none"` or the indexed_path does not match, run `ccc init {path}` then `ccc index` and update forge-tier.yaml.
+
+**Usage context:** Called by setup-forge step-01b to ensure the project root is indexed. Called lazily by extraction steps when `ccc_index.status` is `"none"` but ccc is available.
+
+### `ccc_bridge.status()`
+
+**Resolves to:** Two-step verification:
+1. `ccc --help` — confirms binary exists (exit 0)
+2. `ccc doctor` — confirms daemon is running, extracts version string, validates embedding model
+
+**Usage context:** Called exclusively by setup-forge step-01 during tool detection. Downstream workflows read the result from forge-tier.yaml — they do not re-verify.
+
+## Confidence
+
+ccc discovery does not produce a confidence tier. The provenance chain is:
+
+1. ccc discovers candidate files (internal hint — not cited)
+2. ast-grep verifies exports in those files → **T1** citation `[AST:file:Lnn]`
+3. Or source reading verifies → **T1-low** citation `[SRC:file:Lnn]`
+
+The ccc search is invisible in the output artifact. A Forge+ skill's citations are indistinguishable from a Forge skill's citations — the difference is in extraction coverage, not citation format.
+
+## Indexing Lifecycle
+
+### When Indexing Happens
+
+1. **setup-forge step-01b:** Indexes the project root when setup-forge runs. This is the primary indexing point.
+2. **Workflow discovery steps:** If `ccc_index.status` is `"stale"` or `"none"`, discovery steps trigger a re-index and warn the user. They do not block.
+3. **ccc daemon:** Incremental indexing means re-indexing unchanged files is a near-no-op.
+
+### Freshness
+
+- Staleness threshold: 24 hours (configurable via `ccc_index.staleness_threshold_hours` in forge-tier.yaml)
+- A stale index still produces useful results — the workflow proceeds with the stale index and notes the staleness
+- setup-forge is the designated refresh authority
+
+### Relationship to QMD Registry
+
+ccc_index and qmd_collections are **orthogonal**:
+- `ccc_index` in forge-tier.yaml tracks the persistent source code index (one per project)
+- `qmd_collections[]` in forge-tier.yaml tracks per-skill workflow artifact collections
+- ccc indexes source code for semantic search; QMD indexes curated artifacts for temporal/knowledge search
+- The janitor role for QMD (setup-forge step-03) operates independently of ccc_index
+
+## Query Volume Bounds
+
+To prevent excessive daemon calls, workflow steps cap ccc queries:
+- **create-skill extraction:** max 2 queries per skill (discovery + optional scope refinement)
+- **analyze-source mapping:** max 1 query per qualifying unit
+- **create-stack-skill integration detection:** max 1 query per library pair
+- **audit-skill re-index:** max 1 query per export missing from its recorded location
+
+## Anti-Patterns
+
+- Using ccc_bridge results as citations without ast-grep verification — ccc output is never a provenance citation
+- Blocking a workflow because ccc is unavailable — ccc is always optional
+- Running ccc_bridge.ensure_index() without checking ccc_index.status first — unnecessary re-indexing
+- Passing ccc results directly to the extraction inventory — they are candidates, not extractions
+- Listing ccc as "unavailable" in reports for Quick/Forge tiers — ccc is a Forge+ capability, not something Quick/Forge tiers are missing
+
+## Related Fragments
+
+- [progressive-capability.md](progressive-capability.md) — Forge+ tier definition and positive framing
+- [confidence-tiers.md](confidence-tiers.md) — why ccc does not create a new confidence tier
+- [qmd-registry.md](qmd-registry.md) — the parallel but separate registry for QMD collections
+
+_Source: designed as part of the Forge+ tier integration for cocoindex-code semantic code search_

package/src/knowledge/confidence-tiers.md

@@ -22,8 +22,8 @@ With confidence tiers:
 
 | Tier | Label | Source | Extraction Method | Available At |
 | --- | --- | --- | --- | --- |
-| T1 | AST-verified | Source code | ast-grep structural parsing | Forge, Deep |
-| T1-low | Source-read | Source code | Pattern matching, file reading | Quick, Forge, Deep |
+| T1 | AST-verified | Source code | ast-grep structural parsing | Forge, Forge+, Deep |
+| T1-low | Source-read | Source code | Pattern matching, file reading | Quick, Forge, Forge+, Deep |
 | T2 | QMD-enriched | Knowledge base | QMD semantic search + synthesis | Deep |
 | T3 | External reference | Docs, URLs | External documentation lookup | All tiers |
 
@@ -131,7 +131,7 @@ Every generated skill includes a confidence distribution in `metadata.json`:
     "t2": 12,
     "t3": 3
   },
-  "extraction_tier": "deep"
+  "extraction_tier": "deep"  // valid values: "quick", "forge", "forge+", "deep"
 }
 ```
 

package/src/knowledge/manual-section-integrity.md

@@ -38,6 +38,14 @@ by the forge during updates or regeneration.
 - Nested \[MANUAL\] blocks are forbidden — trigger an ERROR if detected
 - Markers apply to any output file: `SKILL.md`, `references/*.md`, integration files
 
+### [MANUAL] Subdirectories
+
+User-authored scripts and assets are placed in `scripts/[MANUAL]/` and `assets/[MANUAL]/` subdirectories within the skill package. These follow the same preservation principle as markdown `<!-- [MANUAL] -->` markers:
+
+- Files in `[MANUAL]/` subdirectories are preserved unconditionally during `update-skill`
+- Source-derived scripts/assets (outside `[MANUAL]/`) are refreshed from source during updates
+- Conflicts (user file has same name as source file outside `[MANUAL]/`) are flagged as HIGH severity
+
 ## Pattern Examples
 
 ### Example 1: Adding Manual Context to a Generated Skill

package/src/knowledge/overview.md

@@ -24,12 +24,14 @@ With knowledge files:
 |------------------------------------------------------------|-------------------------------------------------------------------|------------------------------------|
 | [zero-hallucination.md](zero-hallucination.md)             | Every claim traces to source; uncitable content excluded          | AN, BS, CS, QS, SS, US, AS, TS     |
 | [confidence-tiers.md](confidence-tiers.md)                 | T1/T1-low/T2/T3 trust model and citation formats                  | AN, BS, CS, QS, SS, US, AS, TS, EX |
-| [progressive-capability.md](progressive-capability.md)     | Quick/Forge/Deep tier philosophy and behavior adaptation          | All 10                             |
+| [progressive-capability.md](progressive-capability.md)     | Quick/Forge/Forge+/Deep tier philosophy and behavior adaptation          | All 10                             |
 | [agentskills-spec.md](agentskills-spec.md)                 | agentskills.io output format principles and compliance            | CS, QS, SS, US, TS, EX             |
 | [skill-lifecycle.md](skill-lifecycle.md)                   | End-to-end pipeline, artifact flow, workflow selection            | All 10                             |
-| [provenance-tracking.md](provenance-tracking.md)           | Provenance-map.json, evidence reports, claim traceability         | CS, QS, SS, US, AS, TS             |
+| [provenance-tracking.md](provenance-tracking.md)           | Provenance-map.json entries and file_entries, evidence reports, claim traceability | CS, QS, SS, US, AS, TS             |
 | [manual-section-integrity.md](manual-section-integrity.md) | \[MANUAL\] marker preservation and merge algorithm                | CS, US, AS, TS, EX                 |
 | [qmd-registry.md](qmd-registry.md)                         | Progressive QMD collection registry and collection gate principle | SF, BS, CS, US, AS                 |
+| [ccc-bridge.md](ccc-bridge.md)                             | ccc_bridge interface, indexing lifecycle, Forge+ discovery-before-extraction | SF, CS, SS, AS, US, BS             |
+| [split-body-strategy.md](split-body-strategy.md)           | Selective vs full split-body, detection pattern, agent accuracy   | CS, QS, US, TS, EX                |
 
 ## JiT Loading Protocol
 

package/src/knowledge/progressive-capability.md

@@ -2,7 +2,7 @@
 
 ## Principle
 
-Every capability tier — Quick, Forge, and Deep — produces legitimate, useful skills. Tiers describe what tools are available, not a quality hierarchy. A Quick skill is complete at its tier; a Deep skill adds depth, not correctness. Framing is always positive: describe what each tier enables, never what it lacks.
+Every capability tier — Quick, Forge, Forge+, and Deep — produces legitimate, useful skills. Tiers describe what tools are available, not a quality hierarchy. A Quick skill is complete at its tier; a Deep skill adds depth, not correctness. Framing is always positive: describe what each tier enables, never what it lacks.
 
 ## Rationale
 
@@ -24,6 +24,7 @@ With progressive capability:
 | --- | --- | --- | --- |
 | Quick | No tools required | Fast, template-driven, package-name resolution | Speed-first skill creation |
 | Forge | ast-grep available | AST-backed structural analysis, line-level citations | Precision-focused compilation |
+| Forge+ | ast-grep + ccc | Semantic discovery + AST verification, pre-ranked extraction | Intelligent precision compilation |
 | Deep | ast-grep + gh + qmd | AST + GitHub exploration + QMD synthesis, maximum provenance | Full intelligence pipeline |
 
 ## Pattern Examples
@@ -35,12 +36,13 @@ With progressive capability:
 **Implementation:** Each tool is verified by executing its version command — presence in PATH is insufficient. The tier is the highest level where all required tools pass verification:
 
 ```
-ast-grep --version  → required for Forge
+ast-grep --version  → required for Forge and above
+ccc --help + ccc doctor → required for Forge+
 gh --version        → required for Deep
 qmd status          → required for Deep
 ```
 
-If ast-grep passes but gh fails, the tier is Forge (not a "degraded Deep").
+If ast-grep passes but gh fails, the tier is Forge (not a "degraded Deep"). If ast-grep and ccc pass but gh and qmd fail, the tier is Forge+ (not a "degraded Deep").
 
 **Key Points:**
 - Tools must be functional, not just installed
@@ -59,6 +61,10 @@ Quick:  "Fast, template-driven skill creation — package-name resolution and
 Forge:  "AST-backed structural analysis — line-level citations with verified
          signatures. Precision-focused compilation."
 
+Forge+: "Semantic-guided precision compilation — cocoindex-code maps the codebase
+         semantically before AST extraction runs. Every skill begins with a ranked
+         discovery pass, then AST-backed verification."
+
 Deep:   "Full intelligence pipeline — AST verification plus GitHub exploration
          and QMD knowledge synthesis. Maximum provenance depth."
 ```
@@ -75,6 +81,7 @@ Deep:   "Full intelligence pipeline — AST verification plus GitHub exploration
 **Implementation:**
 - **Quick:** Reads source files, applies pattern matching for exports and signatures, produces T1-low citations. Uses `gh_bridge` for file structure when available as a convenience, not a requirement.
 - **Forge:** Uses `ast_bridge.scan_definitions()` for structural parsing, produces T1 citations with exact AST node types. Falls back to source reading for files ast-grep cannot parse.
+- **Forge+:** Identical extraction to Forge, plus ccc semantic pre-discovery narrows the file set before ast-grep runs. For large codebases, `ccc_bridge.search()` produces a ranked candidate list. ast-grep operates on that list rather than the full tree. All results remain T1 (AST-verified) — ccc is upstream, not in the extraction chain.
 - **Deep:** Identical extraction to Forge, plus QMD enrichment in a separate step. T2 annotations layer on top of the T1 base without replacing it.
 
 **Key Points:**
@@ -89,6 +96,7 @@ Deep:   "Full intelligence pipeline — AST verification plus GitHub exploration
 **Implementation:**
 - **Quick (Naive mode):** Export Coverage 45%, Signature Accuracy 25%, Type Coverage 20%, External Validation 10%. No coherence check — AST verification unavailable. When external validation tools (skill-check, tessl) are unavailable, their 10% is redistributed proportionally across the remaining categories.
 - **Forge (Contextual mode):** Export Coverage 40%, Signature Accuracy 25%, Type Coverage 15%, Coherence 20%. Full AST-backed verification.
+- **Forge+ (Contextual mode):** Same weights as Forge. The improved extraction coverage (from ccc pre-ranking) may increase T1 count and reduce gaps, but the scoring weights themselves do not change.
 - **Deep (Contextual mode):** Same weights as Forge, plus cross-repo verification and QMD coherence checks feed into the coherence score.
 
 **Key Points:**
@@ -104,7 +112,7 @@ When a tool becomes unavailable mid-session (e.g., ast-grep uninstalled between
 3. New extractions use the current tier's capabilities
 4. The tier change is logged in the sidecar for audit trail
 
-When source is remote (GitHub URL) and tier is Forge or Deep:
+When source is remote (GitHub URL) and tier is Forge, Forge+, or Deep:
 1. AST extraction requires local files — ast-grep cannot operate on remote URLs
 2. The extraction step attempts an **ephemeral shallow clone** to a system temp path (if `git` is available)
 3. If the clone succeeds: AST extraction proceeds on the local clone, then the temp directory is cleaned up

package/src/knowledge/provenance-tracking.md

@@ -147,6 +147,19 @@ With provenance tracking:
 - Provenance timestamps show when each entry was last verified
 - The merge preserves \[MANUAL\] section provenance (author: "manual", no source location)
 
+### File-Level Provenance (file_entries)
+
+Scripts and assets use a separate `file_entries` array in `provenance-map.json`, distinct from the export-level `entries` array:
+
+| Field | Description |
+|-------|-------------|
+| `file_name` | Path relative to skill root (e.g., `scripts/validate.sh`) |
+| `file_type` | `script` or `asset` |
+| `source_file` | Path relative to source root |
+| `confidence` | Always `T1-low` (file-copy, not AST-verified) |
+| `extraction_method` | Always `file-copy` |
+| `content_hash` | SHA-256 of file content (for drift detection) |
+
 ## Inline Citation Rules
 
 Citations appear directly in SKILL.md content:

package/src/knowledge/qmd-registry.md

@@ -95,6 +95,20 @@ Human readability alone is not sufficient justification — the file is already
 
 **Rejection reason:** Decision artifact, not a compilation input. The analyze-source report tells users which skills to create, but create-stack-skill works from individual skill artifacts, not the analysis report. The only consumer would be a human reading the file — which they can do directly.
 
+## Relationship to CCC Index Registry
+
+The `ccc_index_registry` array in forge-tier.yaml is a **parallel but separate** registry from `qmd_collections`. They track different things:
+
+| Aspect | QMD Collections | CCC Index Registry |
+|--------|----------------|-------------------|
+| **What is indexed** | Curated workflow artifacts (SKILL.md, briefs, temporal data) | Source code (the actual codebase) |
+| **Index engine** | QMD (BM25 + optional vector search) | cocoindex-code (AST + vector embeddings) |
+| **Lifecycle** | Per-skill: created by create-skill, consumed by audit/update-skill | Per-project: created by setup-forge, verified by create-skill |
+| **Janitor** | setup-forge step-03 (orphan/stale QMD collection cleanup) | setup-forge step-03 section 5b (stale path cleanup) |
+| **Availability** | Deep tier only | Forge+ and Deep tiers |
+
+These registries are orthogonal — they never reference each other, and their janitor sections operate independently.
+
 ## Pattern Examples
 
 ### Example 1: Producer Registration (create-skill)

package/src/knowledge/skf-knowledge-index.csv

@@ -2,10 +2,12 @@ id,name,description,tags,tier,fragment_file
 overview,Knowledge Overview,"Entry point — knowledge map, JiT loading protocol, relationship to workflow data/ files","knowledge,navigation,jit-loading",core,knowledge/overview.md
 zero-hallucination,Zero Hallucination Principle,"Foundational principle — uncitable content is excluded not guessed, every claim traces to source","integrity,provenance,extraction",core,knowledge/zero-hallucination.md
 confidence-tiers,Confidence Tiers,"Trust model — T1/T1-low/T2/T3 labels, citation formats, tier interaction rules","confidence,citations,evidence,tiers",core,knowledge/confidence-tiers.md
-progressive-capability,Progressive Capability,"Quick/Forge/Deep philosophy — every tier is legitimate, positive framing, graceful degradation","tiers,quick,forge,deep,capability",core,knowledge/progressive-capability.md
-agentskills-spec,agentskills.io Specification,"Format principles — frontmatter, progressive disclosure, directory structure, compliance rules","agentskills,format,compliance,output",core,knowledge/agentskills-spec.md
+progressive-capability,Progressive Capability,"Quick/Forge/Forge+/Deep philosophy — every tier is legitimate, positive framing, graceful degradation","tiers,quick,forge,forge+,deep,capability",core,knowledge/progressive-capability.md
+ccc-bridge,CCC Bridge,"cocoindex-code semantic discovery — ccc_bridge interface, indexing lifecycle, Forge+ tier, discovery-before-extraction principle","ccc,cocoindex,semantic,discovery,forge+,bridge",core,knowledge/ccc-bridge.md
+agentskills-spec,agentskills.io Specification,"Format principles — frontmatter, progressive disclosure, directory structure, compliance rules, MCP tool naming, script quality, development methodology","agentskills,format,compliance,output,mcp,scripts,methodology",core,knowledge/agentskills-spec.md
 skill-lifecycle,Skill Lifecycle,"End-to-end pipeline — workflow connections, artifact flow, decision rules for workflow selection","lifecycle,pipeline,workflows,artifacts",core,knowledge/skill-lifecycle.md
-provenance-tracking,Provenance Tracking,"Provenance mechanism — provenance-map.json, evidence reports, claim traceability","provenance,evidence,traceability,citations",core,knowledge/provenance-tracking.md
+provenance-tracking,Provenance Tracking,"Provenance mechanism — provenance-map.json entries and file_entries, evidence reports, claim traceability","provenance,evidence,traceability,citations,file-entries",core,knowledge/provenance-tracking.md
 manual-section-integrity,Manual Section Integrity,"[MANUAL] preservation — marker format, merge algorithm, orphan detection","manual,preservation,merge,markers",core,knowledge/manual-section-integrity.md
 qmd-registry,QMD Collection Registry,"Progressive registry architecture — producer/consumer/janitor roles, collection gate principle, forge-tier.yaml registry schema","qmd,registry,collections,deep,indexing",core,knowledge/qmd-registry.md
 doc-fetcher,Doc Fetcher,"T3 external documentation — tool-agnostic URL fetching, quarantine rules, conflict resolution","doc-fetcher,t3,external,documentation,quarantine",extended,knowledge/doc-fetcher.md
+split-body-strategy,Split-Body Strategy,"Selective split guidance — detection pattern, recommended approach, impact on tessl scores and snippet anchors","split-body,selective-split,references,body-size",core,knowledge/split-body-strategy.md

package/src/knowledge/skill-lifecycle.md

@@ -25,7 +25,7 @@ With lifecycle awareness:
 | Setup | SF (Setup Forge) | Detect environment and set capability tier | `forge-tier.yaml` |
 | Discovery | AN (Analyze Source) | Scan project, identify skillable units | Analysis report, skill briefs |
 | Design | BS (Brief Skill) | Interactive scope definition for one skill | `skill-brief.yaml` |
-| Compilation | CS, QS, SS (Create/Quick/Stack) | Extract source and compile skill | `SKILL.md`, metadata, provenance |
+| Compilation | CS, QS, SS (Create/Quick/Stack) | Extract source and compile skill | `SKILL.md`, metadata, provenance, `scripts/`, `assets/` (when source contains them) |
 | Maintenance | US, AS (Update/Audit) | Detect drift and refresh skills | Updated `SKILL.md`, drift report |
 | Verification | TS (Test Skill) | Quality gate — completeness scoring | Test report, pass/fail decision |
 | Distribution | EX (Export Skill) | Package and inject into agent context | agentskills.io bundle, snippets |
@@ -108,7 +108,7 @@ SF → forge-tier.yaml
        ↓ (read by all subsequent workflows)
 AN → analysis-report.md + skill-brief.yaml[]
        ↓ (briefs consumed by CS)
-CS → SKILL.md + metadata.json + provenance-map.json + evidence-report.md
+CS → SKILL.md + metadata.json + provenance-map.json + scripts/ + assets/ (when present) + evidence-report.md
        ↓ (skill consumed by TS)
 TS → test-report.md (pass/fail gate)
        ↓ (passing skill consumed by EX)

package/src/knowledge/split-body-strategy.md

@@ -0,0 +1,41 @@
+# Split-Body Strategy
+
+## Principle
+
+Selective split is the recommended strategy when `split-body` is needed. Extract only the largest Tier 2 section(s) to stay under the `body.max_lines` limit — keep all actionable Tier 1 content inline. Full split-body reduces agent accuracy because on-demand retrieval underperforms inline passive context.
+
+## Rationale
+
+Vercel research shows inline passive context achieves 100% task accuracy vs 79% for on-demand retrieval. Full split-body moves all Tier 2 content to `references/`, forcing agents to retrieve it on demand. Selective split preserves the most-used content inline while still satisfying the body size constraint.
+
+Without selective split awareness:
+- `skill-check split-body --write` extracts everything, reducing agent effectiveness
+- tessl content scores drop dramatically (65% → 38%) because only SKILL.md body is evaluated
+- Context snippet anchors (`#quick-start`, `#key-types`) may break if those sections move to references
+
+With selective split awareness:
+- Only the largest Tier 2 section(s) are extracted (usually Full API Reference or Full Type Definitions)
+- Quick Start, Key API Summary, Key Types, Migration Warnings stay inline
+- Agent accuracy remains high for common tasks
+- tessl scores reflect actual inline content quality
+
+## Split-Body Detection Pattern
+
+A split-body skill is identified by:
+1. A `references/` directory exists alongside SKILL.md
+2. SKILL.md Tier 2 sections (headings starting with `## Full`) contain only stubs or are absent — their content lives in `references/*.md`
+3. The skill's full documented content spans SKILL.md + `references/*.md`
+
+When processing a split-body skill, any workflow step that reads SKILL.md content must also traverse `references/*.md` to get the complete picture.
+
+## Recommended Approach
+
+When `body.max_lines` is exceeded:
+1. Identify which Tier 2 section(s) are largest (usually `## Full API Reference`)
+2. Extract only those specific sections to `references/`
+3. Keep all Tier 1 sections and smaller Tier 2 sections inline
+4. Verify context snippet anchors still resolve after extraction
+
+## Scripts and Assets Interaction
+
+Split-body affects only SKILL.md content movement to `references/`. The `scripts/` and `assets/` directories are unaffected — they remain as top-level siblings of SKILL.md regardless of split-body decisions. They do not count toward the body line limit.

package/src/module-help.csv

@@ -1,5 +1,5 @@
 module,phase,name,code,sequence,workflow-file,command,required,agent,options,description,output-location,outputs,
-skf,anytime,Setup Forge,SF,,_bmad/skf/workflows/skillforge/setup-forge/workflow.md,skf_setup_forge,false,ferris,Create Mode,"Initialize forge environment — detect tools and set capability tier (Quick/Forge/Deep)",,forge-config.yaml,
+skf,anytime,Setup Forge,SF,,_bmad/skf/workflows/skillforge/setup-forge/workflow.md,skf_setup_forge,false,ferris,Create Mode,"Initialize forge environment — detect tools and set capability tier (Quick/Forge/Forge+/Deep)",,forge-config.yaml,
 skf,anytime,Analyze Source,AN,,_bmad/skf/workflows/skillforge/analyze-source/workflow.md,skf_analyze_source,false,ferris,Create Mode,"Discover what to skill in a large repo — produces recommended skill briefs",forge_data_folder,skill-brief.yaml,
 skf,anytime,Brief Skill,BS,,_bmad/skf/workflows/skillforge/brief-skill/workflow.md,skf_brief_skill,false,ferris,Create Mode,"Design a skill scope through guided discovery",forge_data_folder,skill-brief.yaml,
 skf,anytime,Create Skill,CS,,_bmad/skf/workflows/skillforge/create-skill/workflow.md,skf_create_skill,false,ferris,Create Mode,"Compile a skill from a brief — supports --batch for multiple briefs",skills_output_folder,SKILL.md,

package/src/module.yaml

@@ -2,7 +2,7 @@ code: skf
 name: "SKF: Skill Forge — Evidence-Based Agent Skills Compiler"
 header: "Turn code and docs into instructions AI agents can actually follow"
 subheader: "Every instruction traces to source. Zero hallucination tolerance."
-description: "Skill Forge transforms code repositories, documentation, and developer discourse into agentskills.io-compliant, version-pinned, provenance-backed agent skills. Uses ast-grep for structural truth, QMD for knowledge intelligence, and a progressive capability model (Quick/Forge/Deep). Standalone module — no other modules required. Recommended alongside BMM for full development workflow integration."
+description: "Skill Forge transforms code repositories, documentation, and developer discourse into agentskills.io-compliant, version-pinned, provenance-backed agent skills. Uses ast-grep for structural truth, cocoindex-code for semantic discovery, QMD for knowledge intelligence, and a progressive capability model (Quick/Forge/Forge+/Deep). Standalone module — no other modules required. Recommended alongside BMM for full development workflow integration."
 default_selected: false
 
 skills_output_folder:

package/src/workflows/README.md

@@ -91,7 +91,7 @@ Steps execute sequentially via just-in-time loading. Only the current step is in
 
 **4 steps** | **Data:** tier-rules.md
 
-Detects available tools (ast-grep, gh, QMD), determines the capability tier (Quick/Forge/Deep), writes `forge-tier.yaml` to the sidecar, and optionally indexes the project. Run this first — all other workflows adapt behavior to the detected tier.
+Detects available tools (ast-grep, gh, QMD), determines the capability tier (Quick/Forge/Forge+/Deep), writes `forge-tier.yaml` to the sidecar, and optionally indexes the project. Run this first — all other workflows adapt behavior to the detected tier.
 
 ### analyze-source (AN)
 

package/src/workflows/analyze-source/data/skill-brief-schema.md

@@ -14,7 +14,7 @@ Defines the output contract for skill-brief.yaml files generated by analyze-sour
 | language | string | Recognized language | Primary programming language |
 | scope | object | See Scope Object below | Boundary definition |
 | description | string | 1-3 sentences | What the skill covers |
-| forge_tier | string | `quick` / `forge` / `deep` | Inherited from forge-tier.yaml |
+| forge_tier | string | `quick` / `forge` / `forge+` / `deep` | Inherited from forge-tier.yaml |
 | created | string | ISO date `YYYY-MM-DD` | Generation date |
 | created_by | string | user_name from config | Who generated the brief |
 
@@ -24,6 +24,8 @@ Defines the output contract for skill-brief.yaml files generated by analyze-sour
 |-------|------|------------|-------------|
 | source_type | string | `source` or `docs-only` | Default `source`. When `docs-only`: `source_repo` optional, `doc_urls` required |
 | doc_urls | array | `{url, label}` objects | Documentation URLs for T3 content. Required when `source_type: "docs-only"` |
+| `scripts_intent` | string | `detect` / `none` / free-text | Describes whether scripts should be extracted. Values: `detect` (auto-detect from source — default when absent), `none` (skip scripts), or a free-text description of expected scripts (e.g., "CLI validation tools in bin/"). |
+| `assets_intent` | string | `detect` / `none` / free-text | Describes whether assets should be extracted. Values: `detect` (auto-detect from source — default when absent), `none` (skip assets), or a free-text description of expected assets (e.g., "JSON schemas in schemas/"). |
 
 ## Version Detection
 

package/src/workflows/analyze-source/data/unit-detection-heuristics.md

@@ -70,6 +70,32 @@ Do NOT recommend as a skillable unit if:
 5. **Vendor/dependency**: Third-party code copied into project
 6. **Already skilled**: Existing skill found in forge_data_folder (recommend update-skill instead)
 
+## Script/Asset Detection Signals
+
+During per-unit analysis, check for scripts and assets alongside code exports.
+
+**Script signals:**
+
+| Strength | Signal | Example |
+|----------|--------|---------|
+| Strong | Entry point in `package.json` `bin`, Cargo.toml `[[bin]]`, pyproject.toml `[project.scripts]` | `"bin": { "migrate": "scripts/migrate.js" }` |
+| Strong | Shebang + executable file | `#!/usr/bin/env python` in `scripts/setup.py` |
+| Moderate | File in `scripts/`, `bin/`, `tools/`, `cli/` directory | `scripts/validate.sh` |
+| Moderate | CI/CD reference to script | `.github/workflows/test.yml` runs `scripts/test.sh` |
+
+**Asset signals:**
+
+| Strength | Signal | Example |
+|----------|--------|---------|
+| Strong | JSON Schema file with `$schema` key | `schemas/config.schema.json` |
+| Strong | Config template with `.example` or `.template` extension | `config.yaml.example` |
+| Moderate | File in `assets/`, `templates/`, `schemas/`, `configs/`, `examples/` directory | `templates/report.hbs` |
+| Moderate | OpenAPI/GraphQL definition | `openapi.json`, `schema.graphql` |
+
+**Per-unit output:** Record `has_scripts: boolean`, `has_assets: boolean`, `script_files: string[]`, `asset_files: string[]`.
+
+**Disqualify:** Generated files (dist/, build/), vendored dependencies, IDE configs (.vscode/, .idea/), binary files (.so, .dll, .jar).
+
 ## Stack Skill Candidate Detection
 
 Flag units as stack skill candidates when:
@@ -85,4 +111,5 @@ Flag units as stack skill candidates when:
 |------------|-------------------|
 | Quick | File structure analysis: directory trees, manifest files, entry points, naming conventions |
 | Forge | AST analysis: export surfaces, import graphs, dependency trees, type hierarchies |
+| Forge+ | AST + CCC: semantic file pre-ranking before structural analysis, CCC signals for relevance scoring |
 | Deep | AST + QMD: temporal evolution, refactoring patterns, semantic relationships, architectural drift |

package/src/workflows/analyze-source/steps-c/step-01-init.md

@@ -73,10 +73,10 @@ Look for {outputFile}.
 
 **Check forge-tier.yaml:**
 - Look for `{sidecar_path}/forge-tier.yaml`
-- **IF missing:** HARD HALT — "**Cannot proceed.** forge-tier.yaml not found at `{sidecar_path}/forge-tier.yaml`. Please run the setup-forge workflow first to configure your forge tier (Quick/Forge/Deep)."
+- **IF missing:** HARD HALT — "**Cannot proceed.** forge-tier.yaml not found at `{sidecar_path}/forge-tier.yaml`. Please run the setup-forge workflow first to configure your forge tier (Quick/Forge/Forge+/Deep)."
 - **IF found:** Read and note the forge tier value
 
-**Apply tier override:** Read `{sidecar_path}/preferences.yaml`. If `tier_override` is set and is a valid tier value (Quick, Forge, or Deep), use it instead of the detected tier.
+**Apply tier override:** Read `{sidecar_path}/preferences.yaml`. If `tier_override` is set and is a valid tier value (Quick, Forge, Forge+, or Deep), use it instead of the detected tier.
 
 "**Forge tier detected:** {tier} — analysis depth will be calibrated accordingly."
 

package/src/workflows/analyze-source/steps-c/step-02-scan-project.md

@@ -167,7 +167,7 @@ Replace the placeholder `[Appended by step-02-scan-project]` with the full scan
 
 Update {outputFile} frontmatter:
 ```yaml
-stepsCompleted: ['step-01-init', 'step-02-scan-project']
+stepsCompleted: [append 'step-02-scan-project' to existing array]
 lastStep: 'step-02-scan-project'
 ```
 

package/src/workflows/analyze-source/steps-c/step-03-identify-units.md

@@ -150,7 +150,7 @@ Replace the placeholder `[Appended by step-03-identify-units]` with:
 
 Update {outputFile} frontmatter:
 ```yaml
-stepsCompleted: ['step-01-init', 'step-02-scan-project', 'step-03-identify-units']
+stepsCompleted: [append 'step-03-identify-units' to existing array]
 lastStep: 'step-03-identify-units'
 ```
 

package/src/workflows/analyze-source/steps-c/step-04-map-and-detect.md

@@ -81,6 +81,10 @@ DO NOT BE LAZY — For EACH qualifying unit, launch a subprocess (or analyze in
 2. Counts and categorizes exports based on forge tier:
    - **Quick tier:** Count files by type, identify index/barrel files, list directory structure
    - **Forge tier:** Parse export statements, identify public API surface, count exported functions/classes/types
+   - **Forge+ tier:** All Forge analysis plus:
+     - If `tools.ccc` is true: run `ccc_bridge.search("{unit_name} exports public API", top_k=15)` to discover semantically relevant files beyond directory scan
+     - Merge CCC-discovered files with scoped file list — files from CCC that are within the unit's directory are added to the analysis queue
+     - Record CCC signals in per-unit findings: top 3 CCC-ranked file names (or "—" if no ccc results)
    - **Deep tier:** All Forge analysis plus:
      - ast-grep structural export extraction: `ast-grep -p 'export $$$' --lang typescript` or equivalent per language to build a verified export inventory
      - ast-grep type/interface mapping: `ast-grep -p 'interface $NAME' --lang typescript` or `ast-grep -p 'class $NAME($$$)' --lang python`
@@ -91,13 +95,14 @@ DO NOT BE LAZY — For EACH qualifying unit, launch a subprocess (or analyze in
    - Primary export patterns (barrel exports, direct exports, re-exports)
    - Public API surface size estimate
    - Key entry points
+   - Script/asset presence: check for `scripts/`, `bin/`, `assets/`, `templates/` directories and files matching detection signals in `{heuristicsFile}`. Record counts in per-unit findings.
    - Analysis strategy used and coverage confidence
 
 **Per-unit export summary:**
 
-| Unit | Files | Exports | Export Pattern | API Surface |
-|------|-------|---------|----------------|-------------|
-| {name} | {count} | {count} | {pattern} | {small/medium/large} |
+| Unit | Files | Exports | Export Pattern | API Surface | Scripts/Assets | CCC Signals |
+|------|-------|---------|----------------|-------------|----------------|-------------|
+| {name} | {count} | {count} | {pattern} | {small/medium/large} | {N scripts, M assets or --} | {CCC signals or --} |
 
 ### 3. Map Import Graph
 
@@ -187,7 +192,7 @@ Replace `[Appended by step-04-map-and-detect]` under Integration Points with:
 
 Update {outputFile} frontmatter:
 ```yaml
-stepsCompleted: ['step-01-init', 'step-02-scan-project', 'step-03-identify-units', 'step-04-map-and-detect']
+stepsCompleted: [append 'step-04-map-and-detect' to existing array]
 lastStep: 'step-04-map-and-detect'
 stack_skill_candidates: [{list flagged candidate groupings}]
 ```

package/src/workflows/analyze-source/steps-c/step-05-recommend.md

@@ -181,7 +181,7 @@ Replace `[Appended by step-05-recommend]` with:
 
 Update {outputFile} frontmatter:
 ```yaml
-stepsCompleted: ['step-01-init', 'step-02-scan-project', 'step-03-identify-units', 'step-04-map-and-detect', 'step-05-recommend']
+stepsCompleted: [append 'step-05-recommend' to existing array]
 lastStep: 'step-05-recommend'
 confirmed_units: [{list of confirmed unit names}]
 stack_skill_candidates: [{updated list with user decisions}]

package/src/workflows/analyze-source/steps-c/step-06-generate-briefs.md

@@ -179,7 +179,7 @@ Replace `[Appended by step-06-generate-briefs]` with:
 
 Update {outputFile} frontmatter:
 ```yaml
-stepsCompleted: ['step-01-init', 'step-02-scan-project', 'step-03-identify-units', 'step-04-map-and-detect', 'step-05-recommend', 'step-06-generate-briefs']
+stepsCompleted: [append 'step-06-generate-briefs' to existing array]
 lastStep: 'step-06-generate-briefs'
 nextWorkflow: '{primary recommendation}'
 ```

package/src/workflows/analyze-source/validation-report.md

@@ -499,7 +499,7 @@ All steps include: "TOOL/SUBPROCESS FALLBACK: If any instruction references a su
 - **Evidence-based approach** — every recommendation backed by specific file citations
 - **Well-placed collaborative gate** (step 05) — user has agency without slowing autonomous analysis
 - **Complete data flow** — no orphaned data, every piece feeds forward
-- **Tier-aware analysis depth** — adapts to Quick/Forge/Deep
+- **Tier-aware analysis depth** — adapts to Quick/Forge/Forge+/Deep
 - **Continuation support** — large repo analysis can resume across sessions
 - **Stack skill candidate detection** — value beyond individual skills
 - **Schema validation before writing** — prevents downstream workflow failures
@@ -647,7 +647,7 @@ A developer onboarding a brownfield project would experience:
 - Complete evidence-based analysis pipeline with zero-hallucination principle
 - Well-placed collaborative gate at step 05 with Y/N/M + "why?" support
 - Perfect data flow — every step builds on previous work
-- Tier-aware analysis depth (Quick/Forge/Deep)
+- Tier-aware analysis depth (Quick/Forge/Forge+/Deep)
 - Continuation support for interrupted sessions
 - Schema validation before file writing
 - Clear downstream workflow recommendations

package/src/workflows/analyze-source/workflow-plan-analyze-source.md

@@ -150,7 +150,7 @@ Decomposition engine — discover what to skill, recommend stack skill. Analyzes
 **Inputs Required:**
 - Required: Project root or repo path
 - Required: SKF module config (forge_data_folder, skills_output_folder, forge_tier)
-- Required: forge-tier.yaml (determines Quick/Forge/Deep analysis depth)
+- Required: forge-tier.yaml (determines Quick/Forge/Forge+/Deep analysis depth)
 - Optional: Scope hints (monorepo packages, service directories to focus on)
 - Optional: Exclusion patterns (vendor dirs, test dirs, generated code to skip)
 - Prerequisites: setup-forge workflow must have been run

package/src/workflows/audit-skill/data/drift-report-template.md

@@ -13,15 +13,15 @@ nextWorkflow: ''
 previousWorkflow: 'create-skill'
 ---
 
-# Drift Report: {{skill_name}}
+# Drift Report: {skill_name}
 
 ## Audit Summary
 
-**Skill:** {{skill_name}}
-**Source:** {{source_path}}
-**Tier:** {{forge_tier}}
-**Date:** {{date}}
-**Overall Drift Score:** {{drift_score}}
+**Skill:** {skill_name}
+**Source:** {source_path}
+**Tier:** {forge_tier}
+**Date:** {date}
+**Overall Drift Score:** {drift_score}
 
 | Category | Count |
 |----------|-------|

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

@@ -82,10 +82,10 @@ Load `{sidecar_path}/forge-tier.yaml` to detect available tools.
 - HALT workflow
 
 **If found:**
-- Extract tier level: Quick / Forge / Deep
+- Extract tier level: Quick / Forge / Forge+ / Deep
 - Extract available tools: gh_bridge, ast_bridge, qmd_bridge
 
-**Apply tier override:** Read `{sidecar_path}/preferences.yaml`. If `tier_override` is set and is a valid tier value (Quick, Forge, or Deep), use it instead of the detected tier.
+**Apply tier override:** Read `{sidecar_path}/preferences.yaml`. If `tier_override` is set and is a valid tier value (Quick, Forge, Forge+, or Deep), use it instead of the detected tier.
 
 ### 3. Load Skill Artifacts
 
@@ -99,6 +99,8 @@ Load the following from the skill directory:
 - `name`, `version`, `generation_date`, `confidence_tier` used during creation
 - `source_root` — Resolved source code path used during extraction
 
+**Detect split-body state:** If a `references/` directory exists and SKILL.md's `## Full` headings are absent or stubs, this is a split-body skill. Flag `split_body: true` in the baseline so downstream steps (especially semantic diff in step-04) know to also read `references/*.md` for complete content comparison.
+
 ### 4. Load Provenance Map
 
 Search for provenance map at `{forge_data_folder}/{skill_name}/provenance-map.json`