@dzhechkov/skills-feature-adr 1.3.16 → 1.3.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.3.16",
+  "version": "1.3.20",
   "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.",
   "bin": {
     "skills-feature-adr": "./bin/cli.js"

package/templates/.claude/skills/feature-adr/SKILL.md

@@ -216,7 +216,7 @@ After Step 8 (or Step 9 for L/XL) completes, verify:
 | `{COMPLEXITY_TIER}` | Step 0 | All steps | S/M/L/XL |
 | `{ACTIVE_STEPS}` | Step 0 | Orchestrator | list[int] |
 | `{TIME_BUDGET}` | Step 0 | All steps | dict |
-| `{LEARNED_PATTERNS}` | Step 0 | Step 1 (brief); Steps 8-9 do their own namespace recalls | list[pattern] (Direct modes only) |
+| `{LEARNED_PATTERNS}` | Step 0 | Step 1 (brief); Steps 8-9 do their own namespace recalls | list[pattern] (dz recall = ALL modes; aqe adds semantic in Direct modes) |
 | `{REQUIREMENTS}` | Step 1 | Steps 2-9 | structured |
 | `{RESEARCH_FINDINGS}` | Step 2 | Steps 3-5 | structured |
 | `{ADR_DECISIONS}` | Step 3 | Steps 3.5-7 | list[ADR] |
@@ -343,24 +343,52 @@ Step 0 (Complexity Router) checks:
 3. If flag + installed → set `{AGENTIC_QE_MODE}` = `direct` or `direct-extended`
 4. If flag present but not installed → WARN and fall back to reference mode
 
-### Pattern memory loop (Direct modes)
+### Pattern memory loop (self-learning — runs in ALL modes)
 
-When `{AGENTIC_QE_MODE}` = `direct` | `direct-extended`, the pipeline runs a recall → store cycle
+**Self-learning is MANDATORY on EVERY `/feature-adr` run — including plain `/feature-adr` without any
+`--full-qe` flag and outside ultracode.** The **dz durable loop runs UNCONDITIONALLY** (no MCP, no
+`fleet_init` needed): **Step 0** `dz recall "<domain terms>"` → fold the top patterns into
+`{LEARNED_PATTERNS}` → apply in Step 1; **Step 8** `dz teach "<durable lesson>"` for each real lesson;
+each step records the live panel via `dz statusline --fa-record`. This half NEVER depends on the mode.
+
+The **agentic-qe MCP layer below is an ADDITIONAL enrichment, active only in Direct modes**
+(`--full-qe` / `--full-qe-extended`, needs `fleet_init`) — it adds semantic in-session recall on top of
+the always-on dz loop.
+
+When `{AGENTIC_QE_MODE}` = `direct` | `direct-extended`, the pipeline ALSO runs a recall → store cycle
 over agentic-qe's MCP pattern memory (`namespace: "learning"`, `fleet_init` first):
 
 - **Step 0** — `memory_query("patterns/feature-adr/*")` **plus** `dz recall --json` over the durable
   dz store → merged top-3 set `{LEARNED_PATTERNS}`; Step 1 folds them into the requirements brief as advisory lessons.
+  After the recall, record live state:
+  `dz statusline --fa-record --slug <feature-slug> --step "Step 0" --recalled <count of patterns loaded> --stored 0 --mode <reference|direct|direct-extended>`.
 - **Step 8** — recalls `patterns/feature-adr/qe/*` to prime the review checklist; after the gap loop
   closes, stores a `qe-outcome` record in aqe **and** the same lesson via `dz teach` (durable).
+  After the store: `dz statusline --fa-record --slug <slug> --step "Step 8 QE" --recalled <recalled so far> --stored <stored so far>`.
 - **Step 9** — recalls `patterns/feature-adr/fleet/*` to prime agent focus; after the fleet verdict,
   stores a `fleet-qe-finding` in aqe **and** the same lesson via `dz teach`.
+  After the store: `dz statusline --fa-record --slug <slug> --step "Step 9 Fleet" --recalled <recalled so far> --stored <stored so far>` with updated counts.
 
 **Two stores by design:** the aqe kv store is *ephemeral across MCP-server restarts* (janitor/TTL —
 observed live), so it serves fast in-session semantic recall; the dz lexical store
 (`dz teach`/`dz recall`) is the durable half that survives to the next day. All calls are
 non-blocking — an error or empty result never stalls the pipeline. This layer is
 **distinct from the Keysarium reward layer** installed by `--with-learning`: it uses agentic-qe MCP
-memory + the dz store, is gated on Direct modes only, and never touches `.keysarium/memory/`.
+memory + the dz store, is UNCONDITIONAL for the dz half (recall/teach/fa-record run in every mode) and Direct-mode-only for the aqe-MCP half, and never touches `.keysarium/memory/`.
+
+**Live learning panel (`dz statusline`).** The pipeline **drives** the panel: at each pattern-memory-loop
+step above it records its live state via `dz statusline --fa-record …`, so `dz statusline` can surface
+per-run learning (which feature, which step, how many patterns recalled vs. newly stored). Each of the
+Step 0 / Step 8 / Step 9 call-outs above emits one `--fa-record`; the counts accumulate across the run.
+Every checkpoint banner **also** prints a human-visible line so the state shows in the conversation, not
+only the statusline:
+
+```
+🎓 Learning: {recalled} patterns recalled for this feature, {stored} new stored this run
+```
+
+*Honesty note:* the panel is live only insofar as the pipeline records state — it reflects what the
+pipeline actually did with the loop (recalls that ran, stores that landed), not an aspirational count.
 
 ### What changes with `--full-qe`
 
@@ -448,6 +476,7 @@ npx @dzhechkov/skills-feature-adr init --with-learning --knowledge-extractor
 ⏸️ STEP N: [Step Name] Complete
 <promise>[PROMISE_TAG]</promise>
 Tier: {COMPLEXITY_TIER} | Active Steps: {ACTIVE_STEPS}
+🎓 Learning: {recalled} patterns recalled for this feature, {stored} new stored this run
 
 [2-3 line summary]
 Artifacts: [list] ✅