@dzhechkov/skills-feature-adr 1.3.0 → 1.3.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dzhechko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Adaptive Feature Development skill pack for Claude Code — 11-step pipeline with Complexity Router (S/M/L/XL), ADR-driven architecture, 15 agentic-qe skills, multi-agent fleet QE. Supports --full-qe, --full-qe-extended, --with-learning, and --knowledge-extractor modes.",
   "main": "src/cli.js",
   "bin": {
@@ -9,12 +9,9 @@
   "files": [
     "bin/",
     "src/",
-    "templates/"
+    "templates/",
+    "LICENSE"
   ],
-  "scripts": {
-    "test": "node bin/cli.js doctor",
-    "prepublishOnly": "node scripts/sync-templates.js"
-  },
   "keywords": [
     "claude",
     "claude-code",
@@ -42,9 +39,10 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/dzhechko/product-keysarium-2026"
+    "url": "https://github.com/djd1m/dz-harness-hub.git",
+    "directory": "packages/@dzhechkov/skills-feature-adr"
   },
-  "homepage": "https://github.com/dzhechko/product-keysarium-2026#readme",
+  "homepage": "https://github.com/djd1m/dz-harness-hub/tree/main/packages/@dzhechkov/skills-feature-adr#readme",
   "bugs": {
     "url": "https://github.com/dzhechko/product-keysarium-2026/issues"
   },
@@ -55,5 +53,8 @@
     "@dzhechkov/keysarium-core": {
       "optional": true
     }
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/commands/init.js

@@ -167,14 +167,21 @@ async function run(options) {
     installedFiles.push(...files);
   }
 
-  // ── e2) Install optional components ────────────────────────────────────
+  // ── e2) Install optional components — track which actually installed ──
+  // Components whose template source is missing return [] from installComponent;
+  // we must NOT record them in the manifest, otherwise `update` reports
+  // "Unknown component" on subsequent runs.
+  const installedOptionalKeys = [];
   for (const key of optionalKeys) {
     stepNum++;
     const comp = OPTIONAL_COMPONENTS[key];
     step(stepNum, totalComponents, `Installing ${comp.label}...`);
 
     const files = installComponent(key, comp, templatesDir, targetDir);
-    installedFiles.push(...files);
+    if (files.length > 0) {
+      installedFiles.push(...files);
+      installedOptionalKeys.push(key);
+    }
   }
 
   // ── f) Write manifest ──────────────────────────────────────────────────
@@ -182,13 +189,14 @@ async function run(options) {
   const pkg = readJSON(pkgPath);
   const version = pkg ? pkg.version : '0.0.0';
 
-  const allKeys = [...componentKeys, ...optionalKeys];
+  // Only manifest components whose templates were actually present on disk
+  const allKeys = [...componentKeys, ...installedOptionalKeys];
   const manifest = createManifest(version, allKeys, installedFiles.sort());
 
-  // Track optional features in manifest
+  // Track optional features in manifest based on actual installs
   manifest.optional = {
-    withLearning: optionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'learning'),
-    knowledgeExtractor: optionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'knowledge-extractor'),
+    withLearning: installedOptionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'learning'),
+    knowledgeExtractor: installedOptionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'knowledge-extractor'),
   };
 
   writeManifest(targetDir, manifest);
@@ -204,7 +212,7 @@ async function run(options) {
     const comp = COMPONENTS[key];
     console.log(`  ${green('\u2713')} ${comp.label}`);
   }
-  for (const key of optionalKeys) {
+  for (const key of installedOptionalKeys) {
     const comp = OPTIONAL_COMPONENTS[key];
     console.log(`  ${green('\u2713')} ${comp.label} ${yellow('[optional]')}`);
   }

package/templates/.claude/commands/harvest.md

@@ -0,0 +1,49 @@
+# Harvest — Ритуал извлечения знаний из проекта
+
+## Использование
+```
+/harvest [путь к директории или "all"] [only категория1,категория2]
+```
+
+## Аргумент
+$ARGUMENTS
+
+## Скилл
+
+```
+Read: .claude/skills/knowledge-extractor/SKILL.md
+```
+
+Загрузи knowledge-extractor skill и следуй его Pipeline Protocol.
+
+## Парсинг аргументов
+
+1. **Путь:** Первый аргумент — путь к директории исследования или `"all"` для всех директорий в `researches/`
+2. **Scope filter:** Если после пути есть `only X,Y` — передай как `{SCOPE_FILTER}` в skill
+   - Допустимые значения: `skills`, `commands`, `hooks`, `rules`, `templates`, `patterns`, `snippets`
+   - Множественные через запятую: `only rules,templates`
+3. Если аргументов нет — запроси путь у пользователя
+
+## Примеры
+
+```
+/harvest researches/bank-kc-automation/          ← полный harvest одной директории
+/harvest researches/bank-kc-automation/ only patterns  ← только паттерны
+/harvest all                                     ← все исследования
+/harvest all only rules,templates                ← все исследования, только правила и шаблоны
+/harvest features/add-user-auth/                 ← harvest фичи (не только исследования)
+```
+
+## Параллелизация
+
+Если путь = `"all"`:
+1. Получи список всех директорий в `researches/`
+2. Для каждой директории запусти отдельную harvest сессию
+3. Каждая сессия создаёт свой findings JSON и проходит полный pipeline
+4. По завершении всех сессий — объедини отчёты
+
+## Суть
+
+Систематический процесс извлечения и организации полезных знаний после завершения проекта. Использует 5 параллельных агентов-экстракторов, 7-категорийную классификацию, 8 блокирующих quality gates, и автоматическое размещение артефактов.
+
+Pipeline: Extract (5 agents) → Classify (7 categories) → User Checkpoint → Gate (8 checks) → Integrate (auto-place)

package/templates/.claude/rules/reward-learning.md

@@ -0,0 +1,124 @@
+# Reward Learning Rules
+
+## Purpose
+
+Govern how the Keysarium pipeline integrates with the Reward-Calibrated Learning System. These rules define when and how to call `memory_query()` and `memory_store()`, how reward scores are assigned, and how historical patterns influence phase execution.
+
+## Core Protocol
+
+Read `lib/memory-protocol.md` for the full protocol specification.
+Read `lib/reward-tracker.md` for analytics and pattern detection.
+
+## When to Call memory_query()
+
+**Trigger:** At the START of every pipeline phase (Phase 0 through Phase 5).
+
+**Protocol:**
+1. Before loading the phase's governance shard, check if `.keysarium/memory/` exists.
+2. If it exists, call `memory_query()` with the current context:
+   - `phase`: Current phase identifier (e.g., "phase-2")
+   - `domain`: Detected domain from Phase 0 (or "unknown" if Phase 0 has not run yet)
+   - `slug`: Current case slug
+   - `skill`: Skill about to be loaded for this phase
+3. Log the number of patterns loaded.
+4. If relevant patterns are found, incorporate the top 3 into the phase brief:
+   - Include high-reward approaches from similar past cases
+   - Apply actionable advice from domain patterns
+   - Note any bottleneck warnings for the current phase/domain combination
+5. If no patterns are found (first run or no relevant data), proceed normally.
+
+**Exception:** Phase 0 (Discovery) may not have a domain yet. Query with `domain: "unknown"` to load cross-domain patterns.
+
+## When to Call memory_store()
+
+**Trigger:** At every CHECKPOINT, after the user responds.
+
+**Protocol:**
+1. After displaying the checkpoint banner and receiving user response.
+2. Classify the user response into a reward level (see Reward Assignment below).
+3. Call `memory_store()` with:
+   - The phase result (artifacts created, promise tag emitted)
+   - The reward score and label
+   - Context metadata (upstream promises, patterns loaded, agent count)
+   - Outcome metadata (user response, iteration count)
+4. Log the stored reward.
+5. Continue with the checkpoint protocol as normal (proceed / adjust / redo).
+
+**Exception:** If the session ends without a user response at the checkpoint, do NOT store a record. Only explicit user responses generate reward data.
+
+## Reward Assignment
+
+Map the user's checkpoint response to a reward score:
+
+| User Response Pattern | Reward | Label | Examples |
+|----------------------|--------|-------|----------|
+| Immediate approval | 1.0 | excellent | "ok", "ок", "next", "продолжай", "good", single-word approval |
+| Minor adjustments | 0.7 | good | "углуби X", "expand section Y", "add one more competitor", feedback on 1 area |
+| Significant rework | 0.3 | needs_work | "rework the approach", "this misses the point of X and Y", feedback on 3+ areas |
+| Complete restart | 0.0 | failed | "start over", "this is wrong", "redo this phase completely" |
+
+### Classification Rules
+
+1. **Count the areas of feedback:** 0 areas = 1.0, 1 area = 0.7, 2+ areas = 0.3, full restart = 0.0
+2. **Positive feedback with minor note** counts as 1.0 (e.g., "great work, just fix the typo")
+3. **Multiple rounds:** If user gives feedback more than twice on the same phase, cap reward at 0.3
+4. **Ambiguous responses:** Default to 0.7 (assume minor adjustment)
+
+## Integration with Promise Tags
+
+Every `memory_store()` call includes the promise tag emitted at the checkpoint:
+
+| Phase | Promise Tag in Record |
+|-------|----------------------|
+| Phase 0 | `DISCOVERY_COMPLETE` |
+| Phase 1 | `CASE_EXPLORED` |
+| Phase 2 | `RESEARCH_PARANOID_PASSED` |
+| Phase 2.5 | `CJM_VALIDATED` |
+| Phase 3 | `SOLUTION_DESIGNED` |
+| Phase 4 | `ARCHITECTURE_DEFINED` |
+| Phase 5 | `PRESENTATION_READY` |
+
+If a promise is `_INCOMPLETE`, the reward should be 0.3 or lower.
+
+## Integration with Feedback Loops
+
+This system adds a new feedback loop to the Variable Registry (see `.claude/rules/feedback-loops.md`):
+
+### Loop 7: Memory -> All Phases
+
+| Property | Value |
+|----------|-------|
+| Direction | `.keysarium/memory/` -> Phase 0-5 start |
+| Variable | `{MEMORY_PATTERNS}` |
+| Payload | Top reward records + domain patterns from memory_query() |
+| Consumers | All phases (loaded at phase start) |
+| Persistence | `.keysarium/memory/{domain}/{slug}/` |
+
+**Contract:** `memory_query()` is called before each phase starts. Empty result is acceptable (first run).
+
+## Retention Policy
+
+- **Default:** 90 days from record creation
+- **Configuration:** Set in `.keysarium/memory/config.json` via `retention_days`
+- **Enforcement:** Expired records are purged during `memory_query()` calls
+- **Override:** Set `retention_days: 0` to disable expiration (keep forever)
+- **Manual purge:** Delete `.keysarium/memory/` directory to reset all memory
+
+## Error Handling
+
+| Situation | Behavior |
+|-----------|----------|
+| `.keysarium/memory/` does not exist | `memory_query()` returns empty; `memory_store()` creates it |
+| `config.json` missing | Use defaults (90 days, 10 max results, enabled) |
+| Corrupted JSON file during query | Skip file, log warning, continue with other records |
+| Write failure during store | Log error, continue pipeline (memory is non-blocking) |
+| Unknown domain | Store under `unknown/` directory |
+
+## Rules Summary
+
+1. **ALWAYS** call `memory_query()` at the start of every phase
+2. **ALWAYS** call `memory_store()` at every checkpoint after user responds
+3. **NEVER** block the pipeline if memory operations fail
+4. **NEVER** store a record without an explicit user response
+5. **ALWAYS** log memory operations (patterns loaded, reward stored)
+6. Memory operations are **advisory** -- they enhance quality but are not mandatory gates

package/templates/.claude/skills/knowledge-extractor/SKILL.md

@@ -0,0 +1,254 @@
+---
+name: knowledge-extractor
+description: >
+  Multi-agent knowledge harvesting system that extracts reusable patterns, commands,
+  rules, templates, and snippets from any project directory. Uses 5 parallel extractor
+  agents, 7-category classification, 8 blocking quality gates, and auto-placement.
+  Triggers on "harvest", "extract knowledge", "извлеки знания", "/harvest".
+trust_tier: 2
+trust_tier_label: "Validated"
+bto_score: 7.5
+bto_date: "2026-03-03"
+trust_tier_path: "Run /bto-test, score >= 8.5 + eval tests for Tier 3"
+---
+
+# Knowledge Extractor
+
+> Domain-agnostic multi-agent system for extracting, classifying, gating, and placing
+> reusable knowledge from completed projects into the toolkit.
+
+## When To Activate
+
+Trigger on:
+- `/harvest [path]` or `/harvest all`
+- "extract knowledge from [path]"
+- "извлеки знания из [path]"
+- "harvest patterns from [project]"
+- "что можно переиспользовать из [project]"
+
+## What You Get
+
+After a successful harvest session:
+- **Findings JSON** — structured extraction results at `.keysarium/harvest/findings-{SESSION_ID}.json`
+- **Placed artifacts** — skills, commands, and rules placed in `.claude/skills/`, `.claude/commands/`, `.claude/rules/`
+- **TOOLKIT_HARVEST.md** — updated with new patterns, templates, snippets, and hooks
+- **Harvest report** — session summary with metrics (extracted → approved → placed counts, gate pass rates)
+- **Memory record** — reward data stored via `memory_store()` for future session optimization
+
+## Architecture
+
+```
+.claude/skills/knowledge-extractor/
+├── SKILL.md                              ← This file (orchestrator)
+├── modules/
+│   ├── 01-extract.md                     ← 5 parallel extractor agents
+│   ├── 02-classify.md                    ← 7-category classification + dedup
+│   ├── 03-gate.md                        ← 8 quality gates (2-pass)
+│   └── 04-integrate.md                   ← Auto-placement + harvest report
+├── references/
+│   ├── quality-gates.md                  ← Gate definitions (G1-G8)
+│   ├── artifact-categories.md            ← 7 categories with destinations
+│   └── maturity-model.md                 ← Alpha → Beta → Stable
+└── templates/
+    ├── artifact-card.md                  ← Per-finding output template
+    └── harvest-report.md                 ← Session summary template
+```
+
+## Modules
+
+| Module | Purpose | Agents | Model |
+|--------|---------|--------|-------|
+| 01-extract | Scan project via 5 focused lenses | 5 parallel | sonnet |
+| 02-classify | Assign categories, deduplicate, cross-ref | 0 (inline) | — |
+| 03-gate | Evaluate 8 quality gates in 2 passes | 1 (semantic) | haiku |
+| 04-integrate | Place artifacts, generate report | 0 (inline) | — |
+
+## Pipeline Protocol
+
+### Step 0: Initialize Session
+
+1. Parse arguments: `{TARGET_PATH}` (directory or "all"), `{SCOPE_FILTER}` (optional `only X,Y`)
+2. **Resolve target path:**
+   - If `{TARGET_PATH}` is a specific directory → validate it exists, set `{slug}` = directory basename
+   - If `{TARGET_PATH}` is `"all"` → list all subdirectories in `researches/`. For each directory, run a separate harvest session (each gets its own findings JSON, session ID, and pipeline run). Merge reports at the end.
+   - If `{TARGET_PATH}` does not exist → report error and stop
+3. **Resolve domain:** If running inside a `/casarium` pipeline, inherit `{domain}` from Phase 0 discovery. If standalone, detect domain from file content keywords (banking/retail/enterprise/healthcare). If unable to detect, set `{domain}` = `"unknown"`.
+4. Generate session ID: `{slug}-{YYYYMMDDHHmmss}`
+5. If `TOOLKIT_HARVEST.md` does not exist at repo root → create it with a standard skeleton (title + empty section headers for each category).
+6. Call `memory_query({phase: "harvest", domain, slug, skill: "knowledge-extractor"})`
+7. Log loaded patterns count
+
+### Step 1: Extract (Module 01)
+
+```
+Read: modules/01-extract.md
+```
+
+Spawn 5 parallel extractor agents (sonnet), each with a focused lens:
+
+| Agent | Lens | Seeks |
+|-------|------|-------|
+| extractor-patterns | patterns | Architecture patterns, design patterns, agent topologies |
+| extractor-commands | commands | Scripts, CLI workflows, pipeline stages, automation |
+| extractor-rules | rules | Constraints, anti-patterns, lessons learned, domain rules |
+| extractor-templates | templates | Document structures, config templates, diagram templates |
+| extractor-snippets | snippets | Reusable code fragments, hooks, utility functions |
+
+Each agent returns numbered findings with reusability confidence (0.0-1.0).
+Orchestrator merges all findings into a single numbered list and writes to JSON:
+`.keysarium/harvest/findings-{SESSION_ID}.json`
+
+**Scope filtering:** If `{SCOPE_FILTER}` is set, only spawn matching agents. See mapping in `references/artifact-categories.md`.
+
+### Step 2: Classify (Module 02)
+
+```
+Read: modules/02-classify.md
+Read: references/artifact-categories.md
+```
+
+1. Read findings from JSON file
+2. Assign each finding to one of 7 categories
+3. Deduplicate: check content similarity across findings and against TOOLKIT_HARVEST.md
+4. Cross-reference: link findings that reference existing skills/commands
+5. Write classified findings back to JSON
+
+### Step 3: User Checkpoint (Interactive)
+
+Display all findings grouped by category as a numbered list:
+
+```
+═══════════════════════════════════════════════════════
+📋 HARVEST FINDINGS: {N} items extracted
+
+## patterns (K items)
+#1  [0.85] Agent Swarm Topology — parallel agents with merge pattern
+#4  [0.72] Event-Driven Pipeline — phase-to-phase data flow via files
+
+## rules (M items)
+#2  [0.91] Domain Detection Rule — auto-detect domain from keywords
+#7  [0.65] Regulatory Constraint — ФЗ-152 data isolation requirement
+
+## snippets (P items)
+#3  [0.78] CJM Renderer — universal React component for CJM display
+...
+
+Commands:
+• "убери #N"                    — remove finding
+• "переклассифицируй #N в X"   — reclassify to category X
+• "доработай #N"                — expand/improve finding
+• "объедини #N и #M"            — merge two findings
+• "покажи только X"             — filter by category
+• "ок"                          — proceed to quality gates
+═══════════════════════════════════════════════════════
+```
+
+Apply user mutations to JSON file. Numbers are stable (removed items leave gaps).
+Loop until user says "ок".
+
+### Step 4: Gate (Module 03)
+
+```
+Read: modules/03-gate.md
+Read: references/quality-gates.md
+```
+
+Evaluate each active finding against 8 quality gates in 2 passes:
+
+**Pass 1 — Deterministic (zero LLM cost):**
+- G1: Has "When to use" section
+- G2: Has "When NOT to use" section
+- G5: Reusability confidence >= 0.5
+- G6: Not a duplicate of existing toolkit entry
+- G7: Has maturity label (alpha/beta/stable)
+
+**Pass 2 — Semantic (haiku agent):**
+- G3: Properly decontextualized (no project-specific refs)
+- G4: Has at least one concrete example
+- G8: Passes brutal-honesty review (self-critical assessment)
+
+Findings passing all gates → status `approved`.
+Findings failing any gate → status `blocked` with gate IDs.
+
+Display blocked findings and allow overrides:
+```
+⚠️ BLOCKED: #7 — failed G3 (project-specific references remain)
+• "пропусти G3 для #7" — override gate
+• "ок" — accept blocks, proceed with approved only
+```
+
+### Step 5: Integrate (Module 04)
+
+```
+Read: modules/04-integrate.md
+Read: templates/artifact-card.md
+Read: templates/harvest-report.md
+```
+
+1. Render artifact cards for each approved finding
+2. Auto-place by category:
+   - `skills` → create `.claude/skills/<name>/SKILL.md` (skeleton)
+   - `commands` → create `.claude/commands/<name>.md`
+   - `hooks` → document in TOOLKIT_HARVEST.md (hooks section)
+   - `rules` → create `.claude/rules/<name>.md`
+   - `templates` → document in TOOLKIT_HARVEST.md (templates section)
+   - `patterns` → document in TOOLKIT_HARVEST.md (patterns section)
+   - `snippets` → document in TOOLKIT_HARVEST.md (snippets section)
+3. Update TOOLKIT_HARVEST.md "Обработанные проекты" table
+4. Generate harvest report
+5. Call `memory_store()` with harvest results and user reward
+6. Update `.keysarium/insights/trigger-state.json` (case_completion event)
+7. Clean up findings JSON file
+
+## Scope Filtering
+
+The `only` keyword filters which extractor agents are spawned:
+
+```
+/harvest path/                      → all 5 agents
+/harvest path/ only patterns        → extractor-patterns only
+/harvest path/ only rules,templates → extractor-rules + extractor-templates
+/harvest all only snippets          → extractor-snippets for each directory
+```
+
+Category-to-agent mapping (see `references/artifact-categories.md`):
+- patterns → extractor-patterns
+- commands → extractor-commands
+- hooks → extractor-commands (shared lens)
+- rules → extractor-rules
+- templates → extractor-templates
+- snippets → extractor-snippets
+- skills → all agents (skills are cross-cutting)
+
+## Integration Points
+
+| System | When | Operation |
+|--------|------|-----------|
+| memory_query() | Pipeline start | Load historical harvest patterns |
+| memory_store() | After user checkpoint | Store harvest reward data |
+| brain-export | N/A (passive) | Findings JSON is brain-compatible schema |
+| BTO | Post-harvest | Placed skills can be evaluated via `/bto-test` |
+| dream cycles | Pipeline end | Update trigger-state.json |
+| /harvest command | Entry point | Thin wrapper loads this skill |
+
+## Anti-Patterns
+
+| Anti-Pattern | Detection | Fix |
+|-------------|-----------|-----|
+| Extracting project-specific details | Finding contains project names, slugs, dates | Decontextualize: replace specifics with generic placeholders |
+| Duplicate extraction | content_hash matches existing TOOLKIT_HARVEST.md entry | Skip or merge; gate G6 blocks duplicates |
+| Extracting from incomplete phases | Artifact lacks promise tag or checkpoint | Only harvest from completed projects |
+| Over-classifying snippets as patterns | Single-use code without abstraction | Require reuse evidence before promoting to pattern |
+| Under-specifying maturity | All findings marked "stable" on first run | First extraction is always "alpha" or "beta" |
+| Skipping user checkpoint | Proceeding to gates without user review | BLOCK — user checkpoint is mandatory |
+| Running all agents when scope is filtered | `only patterns` but 5 agents spawned | Check SCOPE_FILTER before spawning |
+
+## Dependencies
+
+| Resource | Path | Purpose |
+|----------|------|---------|
+| quality-gates.md | references/quality-gates.md | Gate definitions for Module 03 |
+| artifact-categories.md | references/artifact-categories.md | 7-category taxonomy |
+| maturity-model.md | references/maturity-model.md | Alpha/Beta/Stable criteria |
+| artifact-card.md | templates/artifact-card.md | Per-finding output format |
+| harvest-report.md | templates/harvest-report.md | Session report format |