@dzhechkov/skills-feature-adr 1.5.8 → 1.5.11

package/.dz-manifest.json

@@ -13,7 +13,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "dc985b443d8ac9d4091b09367330f7f610c35572d99f635855989fd893c5e6ac"
+        "sha256": "889d62c5dfafb53c0664867f0882e5712e47eb8aa7a44c6db46d082e693ed58d"
       },
       {
         "path": "bin/cli.js",
@@ -25,7 +25,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "d57357d1feb9f111d0674f1c307a4d15a41cb005074351d37ebaf7dc1afe3575"
+        "sha256": "d13930ae60a1d849d08b798dbb3b3ed4fb5d0b50c4c3910fc76a455dd9e6ce31"
       },
       {
         "path": "src/cli.js",
@@ -249,7 +249,11 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs",
-        "sha256": "630eb9047258ad0333082f407cd34522e4c278650f22ef6dba1ef897ec5cce71"
+        "sha256": "cbe70a524f6ce7987b5e3961ee412b92c24c00d84066d438c759659d656efaa2"
+      },
+      {
+        "path": "templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs",
+        "sha256": "82c3c48c25f400f3a64d1caba3d47357f3db87460f0746f88706f901eb6ff689"
       },
       {
         "path": "templates/.claude/skills/frontend-design/LICENSE.txt",
@@ -313,7 +317,7 @@
       },
       {
         "path": "templates/.claude/workflows/feature-adr.js",
-        "sha256": "f287a73bdf8c11c99eedbc071c6babb3201a6cec7d644d65f20ece3cd4ca51c1"
+        "sha256": "22416f105c1b988c07f6cb9002a507b54b07842b5b4bb109b7e300ff52272603"
       },
       {
         "path": "templates/lib/memory-protocol.md",
@@ -325,5 +329,5 @@
       }
     ]
   },
-  "signature": "t3rY38fu7zb8GjsIjG0OOeqtw04W4nlzawE//PhPKbHbtLUMgT/1SOaXFUWEyjQvNTb13dCJXrHggR0yf/5RBA=="
+  "signature": "WT7wArJY3aKuIMMVgbBzFO+Rqw7qfcaVh8UQ9MENSltqdTJTFAr/0TBOS5A89UAfczkluCrkTtyUvPOTQvaNCw=="
 }

package/README.md

@@ -106,6 +106,26 @@ ARCHITECTURE → IMPLEMENTATION →  CODE   →   QE    →  FLEET QE
 # Full protocols + 6 extra skills, up to 7 fleet QE agents
 ```
 
+### Advisory micro-recall at two decision points (v1.5.9, staged)
+
+The workflow makes one bounded decision-local recall attempt immediately before the live Step 3
+ADR-alternative choice and one immediately before the live Step 6 plan-route choice. Each attempt
+asks for at most three lessons, uses a decision-specific lesson-bandit context, has a 15-second
+whole-attempt ceiling, and is never retried. The Step 6 Codex-to-Claude fallback reuses the same
+snapshot instead of recalling again.
+
+This is strictly advisory. Empty output, timeout, command/parse/transport failure, an unwritable
+receipt, or an unestablished application probe leaves the original stage prompt, dispatch count,
+result, and verdict unchanged. There is no hard gate or runtime effectiveness threshold.
+
+The append-only evidence lives at
+`features/<slug>/.fa-state/decision-recall.jsonl`: versioned `entered`, `recalled`, `applied`, and
+optional `owner-label` rows. Post-hoc analysis can derive `receipted / eligible`, outcome counts,
+`applied / selected`, owner-label coverage, repeat-hit numerator/denominator, irrelevant injections,
+and explicit uncounted/unknown populations. The motivating timing observation remains external
+`[SRC], n=1`; the required book queries were silent on retrieval timing, so this instrumentation is
+a falsifiable hypothesis, not a claim that decision-point recall is needed or effective here.
+
 ### The K2 plan gate runs on ANY repo, not just JS/TS ones (v1.5.0)
 
 Between Step 6 and Step 7 the pipeline runs a machine plan-completeness gate (K2). Until v1.5.0 it
@@ -325,14 +345,17 @@ Workflow({ scriptPath: '.claude/workflows/feature-adr.js',
 ```
 
 Omit the Codex knobs entirely for today's all-Claude behavior. The run result reports
-`plannerUsed` / `coderUsed` / `qeReviewerUsed` / `codexModel` / `modelsUsed` so you can see who did what.
-
-**Live model visibility in `/workflows`:** each stage's agent label is decorated with its *resolved*
-model — e.g. `adr · codex:gpt-5.5:xhigh`, `plan · opus` — so you see which model actually ran a stage in
-the live progress tree, not just in the final report. This matters because a Codex stage's auto
-model-badge shows the `codex:codex-rescue` Claude wrapper (the session model), never `codex`; the label
-text is the honest signal. A Claude fallback appears as its own distinct node (never mislabeled as Codex),
-and a routing-off run adds no suffix (byte-identical to today).
+`plannerUsed` / `coderUsed` / `qeReviewerUsed` / `codexModel` / `modelsUsed` as a legacy routing
+summary. `dispatchOutcomes` is the authoritative who-did-what ledger: it contains only settled
+attempts, never pre-dispatch intent.
+
+**Live model visibility in `/workflows`:** each stage prints a two-phase line. `▸ ... · intent`
+appears before the target model starts and names the resolved model and selection reason;
+`◆ ... · outcome: ...` appears only after that attempt settles. Only the latter enters `dispatchOutcomes`.
+This matters because a Codex stage's auto
+model-badge shows the `codex:codex-rescue` Claude wrapper (the session model), never `codex`; the
+two-phase lines are the honest signal. A Claude fallback appears as its own distinct attempt (never
+mislabeled as Codex), and a routing-off intent explicitly says `routing not requested`.
 
 ### Per-stage model routing — `args.models`
 
@@ -675,7 +698,7 @@ sufficiency + honesty, overengineering, silent decisions, runtime consistency, s
   `dz challenge --plan <plan.md>` or the `challenge-panel` skill; scaffold the degradations registry via
   `dz feature-adr-setup --from-spec <spec with {"degradations":true}> --apply`.
 
-### ADR quality gate (Step 3 generates → Step 8 enforces)
+### ADR quality review + Confirmation file gate (Step 3 generates → Step 8 checks)
 
 Step 3 and Step 8 share an ADR best-practices contract distilled from the
 [architecture-decision-record monograph](https://github.com/architecture-decision-record/architecture-decision-record):
@@ -686,12 +709,17 @@ Step 3 and Step 8 share an ADR best-practices contract distilled from the
   links + after-action review, a **`## Confirmation`** stanza (method, monitoring, success metric, owner)
   naming the load-bearing property, and a **`## Links`** traceability block. Template weight is tier-mapped:
   S/M → Nygard/ITD-lightweight, L/XL → MADR + Confirmation.
-- **Step 8** runs a **13-point ADR fitness checklist** (`qe-code-reviewer`) against every generated ADR and
-  **fails the gate** on any miss — decision-shaped title, controlled-vocabulary Status + reversibility,
+- **Step 8** runs a **13-point advisory ADR fitness checklist** (`qe-code-reviewer`) against every generated ADR —
+  decision-shaped title, controlled-vocabulary Status + reversibility,
   neutral Context-before-Decision, symmetric options, driver-mapped rationale, concrete/testable decision,
   negative consequences, traceability links, no placeholder, and **rejects explainer-masquerading-as-ADR**.
-  The **Confirmation→test link is load-bearing**: if the named safety property has no automated test the ADR
-  grades no better than C.
+  Those judgment-based items remain findings; they do not independently force the workflow verdict.
+- The **one mandatory gate** runs after Step 7.5 and before the QE verdict: every test-file path named
+  under an ADR heading beginning with `## Confirmation` must exist as a readable regular file. Missing
+  files or unreadable/unparseable paths force a non-passing Step-8 grade while the independent QE review
+  still runs. A feature with no ADR prints `пропущено: ADR нет, проверять нечего` and is not failed.
+  `dz discrimination-check` and `dz mutation-gate` remain advisory: existence does not prove that a test
+  actually discriminates the load-bearing property.
 
 The pipeline **dog-foods** this: a harness test runs the gate against feature-adr's own generated ADR, so a
 Step-3↔Step-8 drift fails CI rather than shipping.
@@ -1113,6 +1141,24 @@ deliberately excluded — "skeleton first" is nonsense there.
 
 ## Status
 
+`1.5.10` — **staged, not published: every finished phase reports to the 📐 live panel, whatever the
+checkpoint does.** The packaged workflow's `withCheckpoint` computes the next phase label from STAGE
+COMPLETION alone, before any checkpoint branch, so `args.checkpoints:false`, an oversize or
+unserializable result, a stage with no declared artifact, and a refused persist predicate all still
+move the panel. On the common path the `dz statusline --fa-record` command RIDES the existing
+ckpt-write agent — **zero new agents** — joined by `;`, never `&&`: with `&&`, a checkpoint write
+that legitimately refuses short-circuits the phase report away while the workflow has already
+recorded that it ran, and the panel silently stops on a run that is still progressing. Only where no
+checkpoint agent is dispatched at all does the stage spend one extra effort-low `fa-phase:<stage>`
+dispatch, announced in the log. A dead or partial stage reports nothing — the panel must never claim
+progress a stage did not make. Requires `@dzhechkov/harness-cli >= 0.8.11` for the `--tier` flag and
+the second-line panel; the two workflow twins stay byte-identical (`gen-loop-blobs --check`).
+
+`1.5.9` — **staged, not published: advisory decision-point micro-recall.** Step 3 ADR selection and
+Step 6 plan routing each make one top-3, 15-second, no-retry attempt inside the live checkpoint thunk.
+All recall/receipt/probe failures preserve the original dispatch. Versioned `.fa-state` receipts make
+coverage and repeat-related outcomes countable offline; no threshold controls the workflow.
+
 `1.5.4` — **Step 5 now asks how the shipped feature will be watched.** The architecture artifact must
 carry a section headed exactly `Observability` answering what the feature logs, what it counts, what a
 failure looks like from outside, and who would notice. **"Nothing to observe" is a complete answer** —
@@ -1160,3 +1206,21 @@ Also in this release, both halves of the K2 plan-completeness gate that field us
   installed in the workspace was never found (`NOT-ESTABLISHED`, exit 3, the coding step never ran).
   New `args.workspace` pins it, the shipped call site passes it, each candidate is now labelled in the
   audit line, and a `K2_GATE_NOTE` fires when the two collapse onto one path.
+
+## Двухфазная строка диспатча (шаблон воркфлоу)
+
+Шаблон `.claude/workflows/feature-adr.js` печатает две разные строки без флага: намерение
+`▸ <стадия> · <модель> · <причина выбора> · intent` непосредственно до запуска модели и итог
+`◆ <стадия> · <модель> · outcome: <исход>` после окончательного состояния той же ступени.
+Даже долгий или бросивший исключение запуск заранее виден человеку; при этом только итог попадает в
+`dispatchOutcomes` отчёта. Причина отказа остаётся у outcome отказавшей ступени, а intent следующего
+fallback получает нейтральную причину `fallback-rung`. Регион `stage-line` принадлежит генератору
+`gen-loop-blobs` и не правится руками.
+
+### Shared Markdown masking in feature-adr gates
+
+The standalone plan-completeness gate ships with `markdown-masker.mjs`, copied byte-for-byte from
+harness-core's `src/markdown-masker.ts`. It runs without a core build. Amendment checks, swarm briefs
+and K2 share the parser while retaining their existing unclosed-block and indentation policies.
+The four-space indented-code gap remains open for amendment checks and K2; swarm briefs retain their
+existing masking of indented code. Versions are unchanged in this staged change.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.5.8",
+  "version": "1.5.11",
   "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/sbom.json

@@ -35,7 +35,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "dc985b443d8ac9d4091b09367330f7f610c35572d99f635855989fd893c5e6ac"
+          "content": "889d62c5dfafb53c0664867f0882e5712e47eb8aa7a44c6db46d082e693ed58d"
         }
       ]
     },
@@ -69,7 +69,7 @@
         },
         {
           "name": "dz:canonical-json-sha256-v2",
-          "value": "d57357d1feb9f111d0674f1c307a4d15a41cb005074351d37ebaf7dc1afe3575"
+          "value": "d13930ae60a1d849d08b798dbb3b3ed4fb5d0b50c4c3910fc76a455dd9e6ce31"
         }
       ]
     },
@@ -629,7 +629,17 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "630eb9047258ad0333082f407cd34522e4c278650f22ef6dba1ef897ec5cce71"
+          "content": "cbe70a524f6ce7987b5e3961ee412b92c24c00d84066d438c759659d656efaa2"
+        }
+      ]
+    },
+    {
+      "type": "file",
+      "name": "templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "82c3c48c25f400f3a64d1caba3d47357f3db87460f0746f88706f901eb6ff689"
         }
       ]
     },
@@ -789,7 +799,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "f287a73bdf8c11c99eedbc071c6babb3201a6cec7d644d65f20ece3cd4ca51c1"
+          "content": "22416f105c1b988c07f6cb9002a507b54b07842b5b4bb109b7e300ff52272603"
         }
       ]
     },

package/templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs

@@ -51,6 +51,7 @@
 // the feature's own `00_complexity_assessment.md` acid-case table (rows shaped `| A<N> | … |`), or
 // supplied explicitly with `--acid=T1,T2,…`. If neither establishes a corpus, C4 is SKIPPED-with-note
 // (a feature that declared no acid cases cannot be failed for not naming them).
+import { maskMarkdown } from './markdown-masker.mjs';
 import { readFileSync, readdirSync, existsSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
 
@@ -180,7 +181,21 @@ if (adrFiles.length === 0 && TIER_REQUIRES_ADR) {
     const adr = readFileSync(join(adrDir, f), 'utf-8');
     const confIdx = adr.search(/^##+\s*Confirmation/mi);
     if (confIdx < 0) { failures.push(`C2: ${safe(f)} has no Confirmation section`); continue; }
-    const conf = adr.slice(confIdx);
+    // The section ENDS at the next heading of the same or higher level — it does not run to EOF.
+    // Slicing to EOF swallowed every later section, so a `Links` entry citing an existing test as
+    // PRECEDENT was read as this ADR's own Confirmation and demanded of the plan (measured
+    // 2026-08-31 on features/finding-identity-closure: reqe.test.ts, cited under
+    // "Implementation precedent", failed C2 while the real Confirmation test was named correctly).
+    // Deeper subsections stay inside: a Confirmation with ### children is one section.
+    const rest = adr.slice(confIdx);
+    const confLevel = (rest.match(/^(#+)/) || ['', '##'])[1].length;
+    // Search AFTER the Confirmation heading's own line — searching from the heading itself matches
+    // it and collapses the section to nothing, which turns a scoping fix into a gate that reports
+    // "Confirmation names no test file paths" for every ADR (caught by running it).
+    const bodyStart = rest.indexOf('\n') + 1;
+    const afterHeading = rest.slice(bodyStart);
+    const nextHeading = afterHeading.search(new RegExp('^#{1,' + confLevel + '}[^#]', 'm'));
+    const conf = nextHeading < 0 ? rest : rest.slice(0, bodyStart + nextHeading);
     const paths = extractCandidatePaths(conf).filter(isTestPath);
     // UNKNOWN ECOSYSTEM STAYS A FAILURE, never a WARN: a gate that downgrades itself on the one
     // repo it cannot read is a gate that is off exactly where it is needed. The remedy is named
@@ -305,21 +320,7 @@ else for (const t of acidTokens) if (!new RegExp(`\\b${t.replace(/[.*+?^${}()|[\
   // `## Amendments` could become the section heading, and a fenced example row could either open a
   // phantom amendment or hand a real testless one someone else's marker. Third fence-blindness
   // found in a checker today, so it is closed here by construction rather than by care.
-  const rawLines = plan.split('\n');
-  const planLines = [];
-  {
-    let fence = null;
-    for (const line of rawLines) {
-      const open = /^ {0,3}(```+|~~~+)/.exec(line);
-      if (fence === null && open) { fence = open[1][0]; planLines.push(''); continue; }
-      if (fence !== null) {
-        planLines.push('');
-        if (new RegExp('^ {0,3}' + fence + '{3,}\\s*$').test(line)) fence = null;
-        continue;
-      }
-      planLines.push(line);
-    }
-  }
+  const planLines = maskMarkdown(plan, { unclosed: 'mask' }).split('\n');
   let sectionStart = -1, sectionEnd = -1, cursor = 0;
   for (const pl of planLines) {
     // The SAME heading shape amendment-trace.ts accepts: up to three leading spaces, two to four

package/templates/.claude/skills/feature-adr/scripts/markdown-masker.mjs

@@ -0,0 +1,109 @@
+/**
+ * Canonical Markdown block masker; copied byte-for-byte as markdown-masker.mjs beside K2.
+ * Keep this file valid JavaScript (inferred TS types, no build needed by the copy).
+ *
+ * CommonMark fences and type-2 HTML comments; same UTF-16 length and newline positions.
+ * Inline code cannot open an HTML block. HTML delimiters within a block are consumed left to
+ * right, including close/reopen on one line. This is not a complete CommonMark parser.
+ *
+ * Reader policies are deliberate: amendment-trace restores unclosed blocks; brief/K2 hide them.
+ * Four-space code is still unsupported by default. ONLY brief keeps its pre-existing policy.
+ * Containers, tab indentation and HTML block types other than comments remain unsupported.
+ * Callbacks expose line facts; callers own semantic diagnostics and list-barrier representation.
+ */
+export function maskMarkdown(md = '', {
+  unclosed = 'restore',
+  indentedCode = false,
+  inlineComments = false,
+  onMasked = (_line = 0) => {},
+  onDisputed = (_line = 0) => {},
+} = {}) {
+  const lines = md.split('\n');
+  const out = lines.slice();
+  const masked = lines.map(() => false);
+  let state = 'text';
+  let marker = '';
+  let markerLength = 0;
+  let openedAt = -1;
+  let nestedOpener = false;
+  let disputed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? '';
+    const blank = () => { out[i] = ' '.repeat(line.length); masked[i] = true; };
+    if (state === 'fence') {
+      blank();
+      const close = /^ {0,3}(`{3,}|~{3,})\s*$/.exec(line);
+      if (close) {
+        const run = close[1] ?? '';
+        if (run[0] === marker && run.length >= markerLength) {
+          state = 'text';
+          openedAt = -1;
+        }
+      }
+      continue;
+    }
+    if (state === 'text') {
+      const fence = /^ {0,3}(`{3,}|~{3,})([^\n]*)$/.exec(line);
+      if (fence && !(fence[1]?.[0] === '`' && fence[2]?.includes('`'))) {
+        const run = fence[1] ?? '';
+        state = 'fence';
+        marker = run[0] ?? '';
+        markerLength = run.length;
+        openedAt = i;
+        blank();
+        continue;
+      }
+      if (indentedCode && /^ {4,}/.test(line)) {
+        blank();
+        continue;
+      }
+    }
+    // Outside HTML only a block opener counts: code-spanned delimiters in prose are inert.
+    // Inside HTML, backticks are literal and do not protect a delimiter.
+    const htmlStart = /^ {0,3}<!--/.test(line);
+    const wasDisputed = disputed;
+    // Ambiguity is diagnostic state, never permission to scan otherwise-visible prose.
+    // Brief deliberately keeps that diagnostic across blocks until the author's outer close;
+    // block-only readers must not hide an unrelated arrow or opener because it is pending.
+    if (state === 'html' || htmlStart || inlineComments) {
+      let maskLine = state === 'html' || htmlStart;
+      const tokens = [...line.matchAll(/`+|<!--|-->/g)];
+      for (let t = 0; t < tokens.length; t++) {
+        const token = tokens[t];
+        if (!token) continue;
+        if (token[0][0] === '`') {
+          // Code spans require an EXACT matching run; a shorter embedded run is literal.
+          // HTML blocks treat backticks literally. Inline-comment support is brief's existing
+          // policy; other readers only enter this scan at a block opener or while disputed.
+          if (state !== 'html') {
+            const end = tokens.findIndex((next, j) => j > t && next[0] === token[0]);
+            if (end >= 0) t = end;
+          }
+          continue;
+        }
+        if (token[0] === '<!--') {
+          if (state === 'html') nestedOpener = true;
+          else { state = 'html'; openedAt = i; }
+          maskLine = true;
+        } else if (state === 'html') {
+          state = 'text';
+          openedAt = -1;
+          if (nestedOpener) { disputed = true; nestedOpener = false; }
+        } else if (disputed) {
+          disputed = false;
+          maskLine = true;
+        }
+      }
+      if (maskLine) blank();
+    }
+    if (wasDisputed || disputed) onDisputed(i);
+  }
+  if (openedAt >= 0 && unclosed === 'restore') {
+    for (let i = openedAt; i < lines.length; i++) {
+      out[i] = lines[i] ?? '';
+      masked[i] = false;
+    }
+  }
+  for (let i = 0; i < masked.length; i++) if (masked[i]) onMasked(i);
+  return out.join('\n');
+}