@dzhechkov/p-replicator 1.0.0 → 1.1.0

package/README.md

@@ -23,10 +23,10 @@ The system walks you through 4-5 phases with interactive checkpoints. At each ch
 
 | Component | Count | Description |
 |-----------|-------|-------------|
-| **Skills** | 10 | SPARC docs, research, problem-solving, validation, review, reverse engineering, toolkit generation, pipeline forge, knowledge extraction, task exploration |
+| **Skills** | 10 | 90+ files (~200K chars). Modular architecture: foundation → composite → master orchestrator |
 | **Commands** | 2 | `/replicate` (full pipeline), `/harvest` (knowledge extraction) |
 | **Agents** | 4 | replicate-coordinator, product-discoverer, doc-validator, harvest-coordinator |
-| **Rules** | 1 | replicate-pipeline (phase constraints) |
+| **Rules** | 2 | replicate-pipeline (phase constraints), skill-interface-protocol (composition standard) |
 
 After running `/replicate`, the toolkit generates additional commands, agents, rules, and skills specific to your project (see [Post-Pipeline Commands](#post-pipeline-commands)).
 
@@ -40,11 +40,33 @@ After running `/replicate`, the toolkit generates additional commands, agents, r
 | `problem-solver-enhanced` | First principles + TRIZ (9 modules) |
 | `requirements-validator` | INVEST/SMART validation + BDD scenarios |
 | `brutal-honesty-review` | Unvarnished technical criticism |
-| `cc-toolkit-generator-enhanced` | Claude Code toolkit generator |
+| `cc-toolkit-generator-enhanced` | Modular toolkit generator (9 modules, ~165K chars) + cross-project learning |
 | `reverse-engineering-unicorn` | Company reverse engineering + playbook |
 | `pipeline-forge` | Meta-skill: build AI pipelines from patterns |
 | `knowledge-extractor` | Extract reusable knowledge from projects |
 
+## Skill Architecture
+
+Skills use a **composable module system** with three tiers:
+
+- **Foundation** (explore, problem-solver, goap-research, brutal-honesty-review) — self-contained, no dependencies
+- **Composite** (sparc-prd-mini, requirements-validator, knowledge-extractor) — compose foundation skills via `view()`
+- **Master Orchestrator** (cc-toolkit-generator-enhanced) — 9 modular phases with quality gates
+
+The `cc-toolkit-generator-enhanced` skill is the largest component (~165K chars) split into modules:
+
+| Module | Purpose |
+|--------|---------|
+| 01-detect-parse | Document detection → Internal Project Model (IPM) |
+| 02-analyze-map | Instrument mapping + scoring engine |
+| 03-generate-p0 | P0 mandatory instruments (CLAUDE.md, /start, etc.) |
+| 04-generate-p1 | P1 recommended + enterprise lifecycle |
+| 05-generate-p2p3 | P2 optional + MCP + fitness functions |
+| 06-package-deliver | Master validation checklist (710 lines) |
+| 07-harvest-feedback | Post-project learning loop |
+| 08-skill-composition | Dependency graph + path rewriting |
+| 09-cross-project-learning | Pattern reuse via maturity model |
+
 ## CLI Commands
 
 ```bash

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@dzhechkov/p-replicator",
-  "version": "1.0.0",
-  "description": "P-Replicator — Claude Code toolkit for AI-assisted product development (Vibe Coding). Full /replicate pipeline, 10 skills, /harvest knowledge extraction, swarm agents, quality gates.",
+  "version": "1.1.0",
+  "description": "P-Replicator — Claude Code toolkit for AI-assisted product development (Vibe Coding). Full /replicate pipeline, 10 modular skills (165K+ chars), /harvest knowledge extraction, swarm agents, quality gates, cross-project learning.",
   "main": "src/cli.js",
   "bin": {
-    "p-replicator": "./bin/cli.js"
+    "p-replicator": "bin/cli.js"
   },
   "files": [
     "bin/",
@@ -36,7 +36,10 @@
     "invest",
     "smart",
     "documentation",
-    "skill-pack"
+    "skill-pack",
+    "modular-skills",
+    "cross-project-learning",
+    "composable-architecture"
   ],
   "author": "dzhechko",
   "license": "MIT",

package/src/commands/doctor.js

@@ -35,7 +35,7 @@ const EXPECTED_AGENTS = [
   'harvest-coordinator',
 ];
 
-const EXPECTED_RULES = ['replicate-pipeline'];
+const EXPECTED_RULES = ['replicate-pipeline', 'skill-interface-protocol'];
 
 function run(options) {
   const { targetDir } = options;
@@ -110,7 +110,7 @@ function run(options) {
   console.log('');
 
   // ── 6) Rules ────────────────────────────────────────────────────────────
-  console.log(bold('Rules (expected 1):'));
+  console.log(bold('Rules (expected 2):'));
   for (const rule of EXPECTED_RULES) {
     const rulePath = path.join(claudeDir, 'rules', `${rule}.md`);
     if (fileExists(rulePath)) {

package/src/commands/list.js

@@ -20,7 +20,7 @@ const SKILL_DETAILS = {
   'problem-solver-enhanced':       'First principles + TRIZ (9 modules)',
   'requirements-validator':        'INVEST/SMART validation + BDD scenarios',
   'brutal-honesty-review':         'Unvarnished technical criticism',
-  'cc-toolkit-generator-enhanced': 'Claude Code toolkit generator',
+  'cc-toolkit-generator-enhanced': 'Modular toolkit generator (9 modules, ~165K chars)',
   'reverse-engineering-unicorn':   'Company reverse engineering + playbook',
   'pipeline-forge':                'Meta-skill: build AI pipelines from patterns',
   'knowledge-extractor':           'Extract reusable knowledge from projects',

package/templates/.claude/rules/replicate-pipeline.md

@@ -20,6 +20,17 @@ When executing skills during the pipeline:
 3. When a skill references `/mnt/user-data/uploads/` — read from `docs/` instead
 4. When a skill outputs to `/output/` — write to `docs/` or project root instead
 5. `goap-research` skill name maps to `goap-research-ed25519` in this repo
+6. When a skill has `modules/` directory — read the module file referenced by the phase
+7. See `.claude/rules/skill-interface-protocol.md` for full interface specification
+
+## Modular Skills
+
+Skills with `modules/` directories delegate phases to self-contained module files.
+Each module follows: INPUT → PROCESS → OUTPUT → QUALITY GATE interface.
+
+Currently modularized skills:
+- `cc-toolkit-generator-enhanced` — 9 modules (6 core pipeline + 3 extensions)
+- `knowledge-extractor` — 4 modules (agent review → classify → decontextualize → integrate)
 
 ## Output Paths
 
@@ -61,7 +72,7 @@ Commit after each major phase completion:
 ## What Gets Generated vs Pre-existing
 
 ### Pre-existing (template files — do NOT overwrite)
-- `.claude/skills/*` — all 10 skills
+- `.claude/skills/*` — all 10 skills (with modules/ subdirectories)
 - `.claude/commands/replicate.md` — this pipeline
 - `.claude/commands/harvest.md` — knowledge extraction pipeline
 - `.claude/agents/replicate-coordinator.md`
@@ -69,6 +80,7 @@ Commit after each major phase completion:
 - `.claude/agents/doc-validator.md`
 - `.claude/agents/harvest-coordinator.md`
 - `.claude/rules/replicate-pipeline.md` — this file
+- `.claude/rules/skill-interface-protocol.md` — skill composition rules
 
 ### Generated by /replicate (create new)
 - `.claude/commands/start.md`, `feature.md`, `plan.md`, `myinsights.md`, `deploy.md`

package/templates/.claude/rules/skill-interface-protocol.md

@@ -0,0 +1,148 @@
+# Skill Interface Protocol
+
+Standard protocol for how skills discover, reference, and interact in this ecosystem.
+All skills, orchestrators, and agents MUST follow these rules.
+
+## 1. Skill Identity (Frontmatter)
+
+Every `SKILL.md` MUST begin with YAML frontmatter containing:
+
+```yaml
+---
+name: kebab-case-name          # REQUIRED — unique identifier
+description: >                 # REQUIRED — what, when, triggers (2-5 sentences)
+  What the skill does. When to use it. Trigger words/phrases.
+version: "1.0"                 # RECOMMENDED — semver
+maturity: production           # RECOMMENDED — see Maturity Tagging below
+---
+```
+
+A skill without `name` and `description` in frontmatter is invalid.
+
+## 2. view() Contract
+
+Skills reference each other via `view()` — a read-only lookup that loads another skill's content at runtime.
+
+**Rules:**
+- `view()` is read-only. Never modify a referenced skill's files.
+- Always resolve the path using the Path Mapping Rules below before reading.
+- If the target file does not exist, apply the Fallback Protocol (section 6).
+- Never inline another skill's content into your own SKILL.md. Always use view() at runtime.
+
+**Syntax:**
+```
+view() .claude/skills/[skill-name]/SKILL.md
+view() .claude/skills/[skill-name]/references/[file].md
+```
+
+## 3. Path Mapping Rules
+
+Skills originating from claude.ai use `/mnt/` paths. Apply these rewrites in order:
+
+| Source Pattern | Target Pattern | Notes |
+|----------------|----------------|-------|
+| `/mnt/skills/user/[name]/` | `.claude/skills/[name]/` | Skill root directories |
+| `/mnt/user-data/uploads/` | `docs/` | User-uploaded documents |
+| `/output/` | `docs/` or project root | Generated artifacts |
+
+**Skill Name Aliases:** `goap-research` always resolves to `goap-research-ed25519`.
+
+**Rewrite order:** Resolve aliases first, then apply path pattern mapping.
+
+## 4. Module Interface Contract
+
+Skills with `modules/` subdirectories MUST structure each module with these sections:
+
+| Section | Required | Purpose |
+|---------|----------|---------|
+| **Input** | YES | Parameters with types, descriptions, required flag |
+| **Process** | YES | Numbered steps describing the transformation |
+| **Output** | YES | Artifacts produced, with location and format |
+| **Quality Gate** | YES | Checks, thresholds, and whether they block |
+| **Dependencies** | YES | External skills or system capabilities needed |
+| **Reusability** | RECOMMENDED | How this module can be extracted or reused elsewhere |
+
+Modules are numbered (`01-name.md`, `02-name.md`) to indicate execution order.
+SKILL.md acts as orchestrator, referencing modules in sequence.
+
+## 5. Dependency Declaration
+
+Skills declare dependencies in a table within SKILL.md under `## External Dependencies (loaded via view() at runtime)`:
+
+| Phase | Skill | Path | Required | Purpose |
+|-------|-------|------|----------|---------|
+| Phase 1 | explore | `.claude/skills/explore/SKILL.md` | OPTIONAL | Task clarification |
+
+**Dependency types:**
+- **REQUIRED** — skill will not function without it. Pipeline halts if missing.
+- **OPTIONAL** — skill has a documented fallback if missing.
+
+## 6. Fallback Protocol
+
+Every OPTIONAL dependency MUST have a documented fallback immediately after the dependency table:
+
+```markdown
+**Fallbacks:**
+- `explore` unavailable → built-in 3-5 clarification questions
+```
+
+**Rules:**
+1. Check if the dependency's SKILL.md exists before loading.
+2. REQUIRED and missing — halt with error naming the missing skill.
+3. OPTIONAL and missing — execute fallback and log warning in output.
+4. Never silently ignore a missing dependency.
+
+## 7. Maturity Tagging
+
+Skills declare maturity in frontmatter. Consumers use this to decide trust level.
+
+| Level | Meaning | Safe to Depend On |
+|-------|---------|-------------------|
+| `experimental` | Prototype, interface may change | No — use with fallback only |
+| `beta` | Functional, interface stabilizing | Yes — with fallback recommended |
+| `production` | Stable, tested in pipelines | Yes — safe for REQUIRED dependencies |
+| `deprecated` | Being replaced, will be removed | No — migrate to replacement |
+
+**Rule:** REQUIRED dependencies SHOULD point to `production` or `beta` skills only.
+
+## 8. Composition Rules
+
+**Orchestrator skills** (e.g., `replicate-coordinator`, `pipeline-forge`):
+- Invoke other skills in a defined phase sequence
+- Own the checkpoint and context-passing logic
+- Never duplicate skill logic — always delegate via view()
+- Handle dependency resolution and fallbacks for the entire pipeline
+
+**Foundation skills** (e.g., `explore`, `goap-research-ed25519`):
+- Self-contained with no required cross-skill dependencies
+- Provide a single well-defined capability
+- Declare explicit input/output formats
+- Can be used independently outside any pipeline
+
+**Composite skills** (e.g., `sparc-prd-mini`, `cc-toolkit-generator-enhanced`):
+- Combine multiple foundation skills to produce complex output
+- Declare all dependencies (both required and optional)
+- Split complex logic into `modules/` with SKILL.md as orchestrator
+
+## 9. Output Path Convention
+
+All skill output goes directly into the project. Never create a separate output directory.
+
+| Artifact Type | Path |
+|---------------|------|
+| Documentation (SPARC, validation, BDD, features) | `docs/` |
+| Plans | `docs/plans/` |
+| Commands, Agents, Rules, Skills | `.claude/commands/`, `.claude/agents/`, `.claude/rules/`, `.claude/skills/` |
+| Hooks config | `.claude/settings.json` |
+| Project context | `CLAUDE.md` (root) |
+| Scaffolds (Dockerfile, docker-compose, .gitignore) | Project root |
+
+## Anti-Patterns
+
+- Hardcoding `/mnt/` paths without a mapping table
+- Using view() to write or modify another skill's files
+- Declaring a dependency as OPTIONAL without providing a fallback
+- Depending on an `experimental` skill as REQUIRED
+- Duplicating another skill's logic instead of referencing via view()
+- Creating output directories outside the project root
+- Circular dependencies between skills (always detected, always blocked)

package/templates/.claude/skills/cc-toolkit-generator-enhanced/SKILL.md

@@ -1,5 +1,7 @@
 ---
 name: cc-toolkit-generator-enhanced
+version: "2.0"
+maturity: production
 description: >
   Generate complete Claude Code toolkit from idea2prd-manual or SPARC documentation.
   Supports: PRD, SPARC, DDD, ADR, C4, Pseudocode, Gherkin, Fitness Functions.
@@ -9,6 +11,9 @@ description: >
   Feature suggestions: /next + feature-navigator skill + SessionStart hook.
   Insights: /myinsights + index/detail architecture. Plans: /plan with auto-commit.
   Automation: /go (smart pipeline), /run (autonomous build loop), /docs (bilingual RU/EN docs).
+  Harvest feedback: post-project learning loop from knowledge-extractor.
+  Cross-project learning: pattern reuse from previous projects via maturity model.
+  Skill composition: automated dependency resolution, copying, and path rewriting.
   Triggers: "cc-toolkit-enhanced", "generate toolkit from docs", "создай инструменты из документации".
   Three modes: AUTO, HYBRID (default), MANUAL.
 ---
@@ -17,6 +22,44 @@ description: >
 
 Generate production-ready Claude Code instruments from **SPARC or idea2prd-manual documentation**.
 
+## Modular Architecture
+
+This skill uses a composable module system. Each phase is a self-contained module with
+clear INPUT → PROCESS → OUTPUT → QUALITY GATE interface.
+
+### Core Pipeline Modules
+
+| Phase | Module | File |
+|-------|--------|------|
+| 1 | Detect & Parse | `modules/01-detect-parse.md` |
+| 2 | Analyze & Map | `modules/02-analyze-map.md` |
+| 3 | Generate P0 (Mandatory) | `modules/03-generate-p0.md` |
+| 4 | Generate P1 (Recommended) | `modules/04-generate-p1.md` |
+| 5 | Generate P2-P3 (Optional) | `modules/05-generate-p2p3.md` |
+| 6 | Package & Deliver | `modules/06-package-deliver.md` |
+
+### Extension Modules
+
+| Module | File | Purpose |
+|--------|------|---------|
+| Harvest Feedback | `modules/07-harvest-feedback.md` | Post-project learning loop |
+| Skill Composition | `modules/08-skill-composition.md` | Dependency resolution + path rewriting |
+| Cross-Project Learning | `modules/09-cross-project-learning.md` | Pattern reuse via maturity model |
+
+### Module Execution Protocol
+
+```
+view(modules/01-detect-parse.md)     → IPM (Internal Project Model)
+view(modules/02-analyze-map.md)      → Instrument Map (scored items)
+  ↓ [OPTIONAL] view(modules/09-cross-project-learning.md) → Augmented Instrument Map
+view(modules/03-generate-p0.md)      → P0 files
+  ↓ view(modules/08-skill-composition.md) → Skills copied + paths rewritten
+view(modules/04-generate-p1.md)      → P1 files (conditional)
+view(modules/05-generate-p2p3.md)    → P2-P3 files (optional)
+view(modules/06-package-deliver.md)  → Validated package
+  ↓ [POST-PROJECT] view(modules/07-harvest-feedback.md) → Template improvements
+```
+
 ## Input Documents
 
 ### SPARC Pipeline
@@ -60,98 +103,76 @@ Generate production-ready Claude Code instruments from **SPARC or idea2prd-manua
 
 ## Workflow
 
+> Each phase delegates to a self-contained module. Read the module file for full details.
+> Modules can be used independently outside this skill for other pipelines.
+
 ### Phase 1: Detect & Parse
 
-1. Scan `/mnt/user-data/uploads/` for documents
-   - If no documents found: ask user to upload SPARC or idea2prd documentation set
-   - Minimum required: at least PRD.md + Architecture.md (SPARC) or docs/ddd/ (idea2prd)
-2. Detect source pipeline:
-   - Has `docs/ddd/` → idea2prd-manual
-   - Has `Architecture.md` + `Solution_Strategy.md` → SPARC
-   - Has `Architecture.md` only → SPARC minimal
-   - Mixed → Use unified mapping
-3. Detect project characteristics:
-   - **has_external_apis** — scan for API integrations
-   - **has_database** — scan for DB services
-   - **monorepo_packages** — extract from project structure
-   - **docker_services** — extract from docker-compose
-4. Build Internal Project Model (IPM)
+**Read module:** `modules/01-detect-parse.md`
+
+Summary: Scan docs directory, detect pipeline type (SPARC/idea2prd), detect project
+characteristics, build Internal Project Model (IPM).
 
 **MANUAL Checkpoint 1:** Document Detection Review
 
 ### Phase 2: Analyze & Map
 
-**SPARC Pipeline:** See [SPARC Mapping](#sparc-document-mapping) below.
-**idea2prd Pipeline:** See `references/extended-mapping.md` for complete DDD/ADR/Gherkin/Fitness mappings.
+**Read module:** `modules/02-analyze-map.md`
+
+Summary: Map documents to toolkit instruments using scoring rules.
+SPARC mapping: see [SPARC Document Mapping](#sparc-document-mapping) below.
+idea2prd mapping: see `references/extended-mapping.md`.
 
 **MANUAL Checkpoint 2:** Mapping Approval
 
+### Phase 2.5: Cross-Project Learning (Optional)
+
+**Read module:** `modules/09-cross-project-learning.md`
+
+Summary: If a cross-project artifact registry exists, match proven patterns against the
+new project's characteristics and augment the Instrument Map with battle-tested defaults.
+
 ### Phase 3: Generate P0 (Mandatory)
 
-Always generate these items:
-
-| # | Instrument | Template Source |
-|---|-----------|----------------|
-| 1 | **CLAUDE.md** | `references/claude-md-strategy.md` — pipeline-specific strategy |
-| 2 | **security.md** rule | From Specification NFRs or ADRs + Fitness Functions |
-| 3 | **coding-style.md** rule | From Architecture tech stack or DDD Tactical + ADRs |
-| 4 | **commands/start.md** | `references/templates/start-command.md` |
-| 5 | **commands/myinsights.md** | `references/templates/insights-system.md` |
-| 6 | **commands/feature.md** | `references/templates/feature-lifecycle.md` |
-| 7 | **rules/git-workflow.md** | Semantic commit conventions |
-| 8 | **rules/insights-capture.md** | `references/templates/insights-system.md` |
-| 9 | **rules/feature-lifecycle.md** | `references/templates/feature-lifecycle.md` |
-| 10 | **settings.json** hooks | insights + plans auto-commit, SessionStart |
-| 11-16 | **6 lifecycle skills** | `references/templates/feature-lifecycle.md` — copy protocol + path rewrite |
-
-**Conditional P0:**
-- **rules/secrets-management.md** + **skills/security-patterns/** — IF has_external_apis
-- **rules/domain-model.md** — IF has DDD Strategic docs
+**Read module:** `modules/03-generate-p0.md`
+
+Summary: Generate all mandatory toolkit items (CLAUDE.md, rules, commands, settings, lifecycle skills).
+Uses `modules/08-skill-composition.md` for skill copying and path rewriting.
 
 **MANUAL Checkpoint 3:** P0 Review
 
 ### Phase 4: Generate P1 (Recommended)
 
-| Instrument | Source (SPARC) | Source (idea2prd) |
-|------------|----------------|-------------------|
-| planner.md agent | Pseudocode, PRD | Pseudocode, PRD |
-| code-reviewer.md agent | Refinement, Specification | Fitness, ADR |
-| architect.md agent | Architecture, Solution_Strategy | C4, ADR, DDD Strategic |
-| project-context/ skill | Research_Findings, Final_Summary | Research, .ai-context |
-| coding-standards/ skill | Architecture (tech stack) | DDD Tactical, ADR |
-| testing-patterns/ skill | Refinement (test strategy) | Gherkin, Fitness |
-| /plan command | PRD, Pseudocode | PRD, Pseudocode |
-| /test command | Refinement, Specification | Gherkin |
-| /deploy command | Completion | Completion Checklist |
-| testing.md rule | Refinement | Fitness Functions |
-
-**Enterprise Lifecycle (IF DDD detected) — see `references/templates/feature-lifecycle-ent.md`:**
-- /feature-ent command, feature-lifecycle-ent.md rule
-- Copy skills: idea2prd-manual/, goap-research-ed25519/
-
-**Feature Suggestions System — see `references/templates/feature-suggestions.md`:**
-- /next command, feature-navigator/ skill, feature-roadmap.json, SessionStart hook
-
-**Automation Commands — see `references/templates/automation-commands.md`:**
-- /go (smart pipeline), /run (autonomous build loop), /docs (bilingual RU/EN)
+**Read module:** `modules/04-generate-p1.md`
+
+Summary: Generate recommended items — agents, skills, commands, enterprise lifecycle,
+feature suggestions, automation commands. All conditional on project characteristics.
 
 **MANUAL Checkpoint 4:** P1 Selection
 
 ### Phase 5: Generate P2-P3 (Optional)
 
-**P2:** tdd-guide.md agent, settings.json hooks, /review command
-**P2 DDD-only:** ddd-validator.md agent, aggregate-patterns/ skill, event-handlers/ skill, /validate-ddd
-**P3:** .mcp.json (see `references/templates/mcp.md`), Coolify MCP, Docker MCP
+**Read module:** `modules/05-generate-p2p3.md`
+
+Summary: Generate optional advanced items — TDD guide, DDD validators, MCP configs.
 
 **MANUAL Checkpoint 5:** P2-P3 Selection
 
 ### Phase 6: Package & Deliver
 
-Create output archive per [Output Structure](#output-structure).
-Run the [Master Validation Checklist](#master-validation-checklist) before delivery.
+**Read module:** `modules/06-package-deliver.md`
+
+Summary: Run Master Validation Checklist, verify all placeholders, create output package.
 
 **MANUAL Checkpoint 6:** Final Review
 
+### Post-Project: Harvest Feedback (After project completion)
+
+**Read module:** `modules/07-harvest-feedback.md`
+
+Summary: After /harvest extracts knowledge from a completed project, this module feeds
+improvements back into toolkit templates for future generations.
+
 ## Output Structure
 
 ```
@@ -369,6 +390,38 @@ Run in Phase 6 before delivery.
 
 ## Dependencies
 
+### Required
 - SPARC documentation set (11 files) — primary pipeline
 - Alternatively: idea2prd-manual/auto output
-- Optional: .ai-context/ directory
+
+### Optional
+- `.ai-context/` directory — enhanced CLAUDE.md integration
+- `knowledge-extractor` skill — for harvest feedback loop (module 07)
+- Cross-project artifact registry — for pattern reuse (module 09)
+
+### Skill Dependencies (managed by module 08)
+
+| Skill | Copied To | Priority | Condition |
+|-------|-----------|----------|-----------|
+| sparc-prd-mini | .claude/skills/ | P0 | Always |
+| explore | .claude/skills/ | P0 | Always |
+| goap-research | .claude/skills/ | P0 | Always |
+| problem-solver-enhanced | .claude/skills/ | P0 | Always |
+| requirements-validator | .claude/skills/ | P0 | Always |
+| brutal-honesty-review | .claude/skills/ | P0 | Always |
+| idea2prd-manual | .claude/skills/ | P1 | IF DDD detected |
+| goap-research-ed25519 | .claude/skills/ | P1 | IF DDD detected |
+| feature-navigator | .claude/skills/ | P1 | Always (recommended) |
+
+## Reusability
+
+This skill's modules are designed for reuse across different IT contexts:
+
+| Module | Reuse Context |
+|--------|--------------|
+| 01-detect-parse | Any pipeline needing document type detection |
+| 02-analyze-map | Any document-to-artifact mapping with scoring |
+| 03-06 (generation) | Template-based code/config generation |
+| 07-harvest-feedback | Any system with post-production learning loops |
+| 08-skill-composition | Any project that composes AI skills/plugins |
+| 09-cross-project-learning | Any AI pipeline that learns from past projects |