@dzhechkov/skills-feature-adr 1.3.64 → 1.3.66

package/.dz-manifest.json

@@ -13,7 +13,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "b3095a1ad16fe17c103fb167e2844dabfe61f2a67dde3f797521c7916f41ddb3"
+        "sha256": "5cca2d4a5337177ee9a072d49d14f73386af75398f52d907d757d4c052afdf81"
       },
       {
         "path": "bin/cli.js",
@@ -25,7 +25,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "98aaa022a135e9cf92c534e191c96bdcd0254bf1ea8d7aba42745a82071ad4c2"
+        "sha256": "b76f1b1d1ce3d8b22be0c2354fe3bd22833513da8b418c7c93423ae75f4018ae"
       },
       {
         "path": "scripts/sync-templates.js",
@@ -121,7 +121,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/SKILL.md",
-        "sha256": "c422d1e2b50cf7b8bd56cd5d886d96af30d8bf33a468b925396f395ebf32de53"
+        "sha256": "02d2a081e4bc9e7f5d42e55a4e21a68484af8b45216ff74fe5fc4322cb689a96"
       },
       {
         "path": "templates/.claude/skills/feature-adr/examples/sample-feature-output.md",
@@ -157,7 +157,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/06-implementation-plan.md",
-        "sha256": "7a6c830d63f73953a96f1cb125ab88b7d5c24b2d4b61e997d6d3dfea8262d495"
+        "sha256": "443043f6f3a3c2ebdcc4d40f9d13d799581056fb37890a2bb1fa61662825229b"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/07-code.md",
@@ -165,7 +165,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/08-qe.md",
-        "sha256": "0d314eaeb69a761f68c4beb1ab7df0a2da1964538a8eb33c99cb9b819598d255"
+        "sha256": "97e9a7bc54f196b381c4ef71258cddcb2fb48f216df1ba015927c176bad57084"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/09-fleet-qe.md",
@@ -255,6 +255,10 @@
         "path": "templates/.claude/skills/feature-adr/references/qe-checklist.md",
         "sha256": "238d8896996dc53559f58b24aa7eca966cc8845c3b9dda6d982c717c657b91e4"
       },
+      {
+        "path": "templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs",
+        "sha256": "41d85b012a9d6cc172eaa5d7777294f2c01fb54b752ed61c7cbe2d2cd7b79b67"
+      },
       {
         "path": "templates/.claude/skills/frontend-design/LICENSE.txt",
         "sha256": "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594"
@@ -317,7 +321,7 @@
       },
       {
         "path": "templates/.claude/workflows/feature-adr.js",
-        "sha256": "e02d770867542d0d1505baca64c3008ff1bbc0048b291bd30be7ccc41bdc06a1"
+        "sha256": "4904cf2040f024647c561fb5bd11aab5c7c0b70190dc4505b1bd69572cf25072"
       },
       {
         "path": "templates/lib/memory-protocol.md",
@@ -345,5 +349,5 @@
       }
     ]
   },
-  "signature": "ac1qFz1SL9en2rAGmTGAYgsXlnlNG7tX3LCKhQFdt0nngZoLWW3LIT9pXBKrSAwKLAsqLXc1EVcmx2fmupeyAg=="
+  "signature": "nKR64NSSz41u0CCXl4HdsXqTmS5QUqIIYZdRn4xVoEj/wuzF7Vb7X21mte94etpLINVimxi1pTdUQYOO5GlyCw=="
 }

package/README.md

@@ -274,8 +274,13 @@ Workflow({ scriptPath: '.claude/workflows/feature-adr.js',
 
 > Note: under the override, coder **and** QE both run on Codex — the cross-model self-QE guard is
 > consciously suspended (a Claude QE reviewer is exactly the agent that dies under limit pressure). The
-> ` (usage-switched)` suffix + `usageEvents` keep it auditable; re-run an independent QE after limits
-> reset if the switch fired during Step 8.
+> ` (usage-switched)` suffix + `usageEvents` keep it auditable — and since v1.3.65 the suspension is a
+> **machine debt**, not a note: the run writes `features/<slug>/.fa-state/reqe-due.json` (idempotent,
+> run-stamped, crash-resume-safe) and returns `reqeDue: true`; after limits reset, `dz usage` shows a
+> `re-QE due:` line, `dz reqe --slug <s>` prints the cross-family review brief, and
+> `dz reqe --slug <s> --done --report <f>` settles FAIL-CLOSED — only against an existing graded
+> report, never the run's own 08_qe_report.md (real-path and inode compared). RU: «перепроверь другой
+> семьёй потом» стало долгом на диске с полным жизненным циклом.
 
 ---
 
@@ -526,6 +531,15 @@ gate > reviewer judgment > memory). A miss usually means a check lived one layer
   control that proved the path was I/O-free. The bundled role-default skills gained the matching entries
   (`code-impl` P25, `code-critic` AP14).
 
+- **No-stubs gate** (backlog 0b403a0106103901, Karpathy-Michaels rule XI). Step 8 greps the files THE RUN
+  touched for unfinished-stub markers — `TODO` / `FIXME` / `HACK` / `XXX` / `PLACEHOLDER` (case-sensitive,
+  word-bounded: `hackathon`/`todos` never fire) plus the `implement later` phrase — **any unwaived match =
+  the task shipped incomplete** (HIGH gap naming file:line). A line may carry an inline
+  `no-stubs: <reason>` waiver; a waiver **without** a reason is itself a HIGH gap, never an exemption. The
+  same scan runs mechanically at publish time as the SOFT `no-stubs` rule in `dz guard check --op publish`
+  (change-set scoped — a deliberate design: a tree-wide scan measured ~78% ancient-marker noise). Markers
+  quoted in the QE report are backticked so the report itself scans clean.
+
 Both forms carry all of it: the interactive skill (step modules + banner template) and the deterministic
 workflow (stage prompts + derived `gates` in its returns) — same shapes, same vocabulary.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.3.64",
+  "version": "1.3.66",
   "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": "b3095a1ad16fe17c103fb167e2844dabfe61f2a67dde3f797521c7916f41ddb3"
+          "content": "5cca2d4a5337177ee9a072d49d14f73386af75398f52d907d757d4c052afdf81"
         }
       ]
     },
@@ -65,7 +65,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "98aaa022a135e9cf92c534e191c96bdcd0254bf1ea8d7aba42745a82071ad4c2"
+          "content": "b76f1b1d1ce3d8b22be0c2354fe3bd22833513da8b418c7c93423ae75f4018ae"
         }
       ]
     },
@@ -305,7 +305,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "c422d1e2b50cf7b8bd56cd5d886d96af30d8bf33a468b925396f395ebf32de53"
+          "content": "02d2a081e4bc9e7f5d42e55a4e21a68484af8b45216ff74fe5fc4322cb689a96"
         }
       ]
     },
@@ -395,7 +395,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "7a6c830d63f73953a96f1cb125ab88b7d5c24b2d4b61e997d6d3dfea8262d495"
+          "content": "443043f6f3a3c2ebdcc4d40f9d13d799581056fb37890a2bb1fa61662825229b"
         }
       ]
     },
@@ -415,7 +415,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "0d314eaeb69a761f68c4beb1ab7df0a2da1964538a8eb33c99cb9b819598d255"
+          "content": "97e9a7bc54f196b381c4ef71258cddcb2fb48f216df1ba015927c176bad57084"
         }
       ]
     },
@@ -639,6 +639,16 @@
         }
       ]
     },
+    {
+      "type": "file",
+      "name": "templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "41d85b012a9d6cc172eaa5d7777294f2c01fb54b752ed61c7cbe2d2cd7b79b67"
+        }
+      ]
+    },
     {
       "type": "file",
       "name": "templates/.claude/skills/frontend-design/LICENSE.txt",
@@ -795,7 +805,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "e02d770867542d0d1505baca64c3008ff1bbc0048b291bd30be7ccc41bdc06a1"
+          "content": "4904cf2040f024647c561fb5bd11aab5c7c0b70190dc4505b1bd69572cf25072"
         }
       ]
     },

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

@@ -100,6 +100,9 @@ ROUTER   →  REQUIREMENTS  →  RESEARCH  →   ADR         →  QCSD SWARM
                                            SPARC-GOAP PLAN
                                                 (all)
                                                    │
+                                        K2 PLAN-COMPLETENESS GATE
+                                       (all — exit 0 or Step 7 waits)
+                                                   │
                                                 Step 7
                                                  CODE
                                                 (all)
@@ -144,6 +147,26 @@ Step                         | S | M | L | XL | Model  | Agentic QE Skill
 10 Delivery Gate (OPT-IN)    | o | o | o | o  | cross-family of coder | 4 planes: regressions ‖ security ‖ code-quality ‖ product-honesty (o = runs only when explicitly requested; absent ⇒ byte-identical) |
 ```
 
+### K2 plan-completeness gate (Step-6/7 boundary, MANDATORY, all tiers)
+
+Step 7 does not start until the plan passes a SCRIPT — not a reviewer's impression:
+
+```bash
+node .claude/skills/feature-adr/scripts/check-plan-completeness.mjs features/<slug>
+```
+
+Pass the run's tier (`--tier=S|M|L|XL`): M/L/XL with no `03_adr/` FAILS rather than skipping C1/C2.
+Every tier — S included — writes a real `06_implementation_plan.md`; an inline-only S-tier checklist
+cannot be gated and is no longer permitted.
+
+`exit 0` → proceed to Step 7 · `exit 1` → return to Step 6 and fix every `FAIL C*` line · `exit 3`
+→ INCONCLUSIVE (inputs unreadable) — fix them and rerun. **Never proceed on a non-zero exit, and
+never read empty output as a pass**: the verdict is the last line
+(`K2 plan-completeness: PASS|FAIL|NOT-ESTABLISHED`), and its absence is not a verdict. The checkpoint
+banner's Gates line carries it: `🚦 Gates: K2 plan-completeness ✓ | ✗ | inconclusive`. Details and the
+per-check list: `modules/06-implementation-plan.md`. In the ultracode workflow the gate runs
+automatically and a non-PASS returns `phase: 'plan-gate-failed'` without dispatching the coder.
+
 ## DAG Dependencies
 
 Steps are NOT purely linear. The DAG defines what can run in parallel:
@@ -321,10 +344,17 @@ Two flags for integrating with the full agentic-qe package:
 
 | Flag | Mode | What it does |
 |------|------|-------------|
-| (none) | Reference | Condensed copies of 9 core skills, no install needed |
-| `--full-qe` | Direct | Full agentic-qe protocols for existing 9 core skills |
+| (none) | Reference | Condensed copies of 9 core skills, no install needed — the **no-install fallback** |
+| `--full-qe` | Direct | **RECOMMENDED DEFAULT when agentic-qe is installed.** Full agentic-qe protocols for the 9 core skills, and BOTH halves of the learning loop run: Step-0 recall = `memory_query("patterns/feature-adr/*")` **+** `dz recall`; Step-8 teach = the aqe `qe-outcome` store **+** `dz teach` |
 | `--full-qe-extended` | Direct Extended | Full protocols + 6 additional skills (chaos, security, performance, mutation, TDD, production-swarm) |
 
+**Which one to run:** if `aqe` is installed (`which aqe` or `node_modules/agentic-qe/`), run
+`--full-qe` — it is the recommended default at every tier, because the aqe pattern memory only
+contributes when the Direct half of the loop is active. Reference mode is the honest fallback for a
+machine without agentic-qe; it is not a lesser-quality choice there, it is the only correct one.
+This is a RECOMMENDATION about which flag to pass — the mode LOGIC is unchanged (flag + installed →
+direct; flag without install → WARN + reference).
+
 ### Installation
 
 ```bash
@@ -338,8 +368,8 @@ cd your-project && aqe init --auto
 ### Activation
 
 ```
-/feature-adr [описание фичи]                      # Reference Mode (default)
-/feature-adr --full-qe [описание фичи]             # Direct Mode: full protocols, same skills
+/feature-adr --full-qe [описание фичи]             # RECOMMENDED when agentic-qe is installed
+/feature-adr [описание фичи]                      # Reference Mode: the no-install fallback
 /feature-adr --full-qe-extended [описание фичи]     # Direct Extended: full protocols + extra skills
 ```
 
@@ -454,7 +484,8 @@ each step records the live panel via `dz statusline --fa-record`. This half NEVE
 
 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.
+the always-on dz loop. This is why `--full-qe` is the RECOMMENDED default wherever agentic-qe is
+installed: only then do BOTH recall halves run at Step 0 and BOTH teach halves at Step 8.
 
 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):
@@ -537,8 +568,9 @@ Everything from `--full-qe` plus 6 additional skills and up to 3 extra agents in
 
 | Scenario | Mode |
 |----------|------|
-| S/M tier features | Reference (always) |
-| L tier, standard QE | Reference or `--full-qe` |
+| agentic-qe installed (any tier) | `--full-qe` — the recommended default |
+| agentic-qe NOT installed | Reference (the fallback; the dz half of the loop still runs) |
+| S/M tier, agentic-qe installed | `--full-qe` |
 | L tier, high QE maturity | `--full-qe` |
 | XL tier features | `--full-qe` recommended |
 | XL + security-critical (banking, ФЗ-152) | `--full-qe-extended` recommended |

package/templates/.claude/skills/feature-adr/modules/06-implementation-plan.md

@@ -4,8 +4,11 @@
 
 ## When
 
-Always runs. Adapts depth by tier:
-- **S:** Inline checklist (3-5 items, no file)
+Always runs, and ALWAYS writes `features/<slug>/06_implementation_plan.md` — every tier. Depth adapts:
+- **S:** minimal plan FILE (3-5 tasks + an `EXPECTED_CODE_TARGETS:` block). An inline-only checklist is
+  no longer permitted: the K2 gate below is mandatory at every tier and it reads the file, so a plan
+  that exists only in the conversation makes the gate answer NOT-ESTABLISHED and the run stops. The
+  file must clear the gate's own floor: >200 characters and a non-empty targets block.
 - **M/L/XL:** Full structured plan document
 
 ## Model
@@ -134,13 +137,17 @@ This gap-check loop ensures the implementation plan is complete before coding be
 
 ## Output
 
-### S-tier (inline)
-Inline checklist in conversation:
+### S-tier (minimal file — NOT inline-only)
+Write `features/<slug>/06_implementation_plan.md` with the checklist plus the machine-read block, and
+show the same checklist inline at the checkpoint:
 ```
 Implementation plan:
 - [ ] {task 1}
 - [ ] {task 2}
 - [ ] {task 3}
+
+EXPECTED_CODE_TARGETS:
+- {repo-relative path Step 7 will create or modify}
 ```
 
 ### M/L/XL
@@ -157,6 +164,41 @@ Create `features/<slug>/06_implementation_plan.md` with:
 
 Set `{IMPL_PLAN}` variable.
 
+## K2 plan-completeness gate (MANDATORY — Step 7 does not start until it exits 0)
+
+After the plan is written, run the gate. It is a script, not a judgement call:
+
+```bash
+node .claude/skills/feature-adr/scripts/check-plan-completeness.mjs features/<slug>
+```
+
+| Exit | Verdict | What you do |
+|------|---------|-------------|
+| `0` | PASS | proceed to Step 7 |
+| `1` | FAIL | **return to Step 6** — fix the plan for every `FAIL C*` line, rerun the gate |
+| `3` | NOT-ESTABLISHED | **INCONCLUSIVE** — the gate could not read its inputs (no plan, plan under the size floor, ADR claims it cannot see). Fix the inputs and rerun. Never proceed. |
+
+Never proceed on a non-zero exit, and never treat empty output as a pass — the last line
+(`K2 plan-completeness: PASS|FAIL|NOT-ESTABLISHED`) is the verdict, and its absence is not one.
+What it checks: C1 every ADR has a plan task citing it · C2 every ADR Confirmation test path is named
+in the plan · C3 the `EXPECTED_CODE_TARGETS:` block parses line by line · C4 the feature's declared
+acid corpus is named · C5 (WARN) the `Inputs read:` line. An S-tier run with no `03_adr/` skips C1/C2
+with a note (it cannot be failed for ADRs it never had) — unless the plan itself cites `ADR-<n>`,
+which is NOT-ESTABLISHED. C1 is a grep: it catches "forgot entirely", not "mentioned but not tasked".
+
+Pass the run's tier so the check cannot be dodged: `--tier=S|M|L|XL`. An M/L/XL feature with no
+`03_adr/` FAILS C1/C2 (an M+ feature owes ADRs); only `--tier=S` — or no tier at all, and then the
+skip note says so — takes the skip. A declared-but-malformed acid table (lowercase `| a1 |`, a header
+with no parsable rows) FAILS as `C4-malformed`; it is not a skip.
+
+**If the gate fails in the ultracode workflow:** the run returns `phase: 'plan-gate-failed'` and the
+plan stage is CHECKPOINTED, so a bare re-invoke resumes the same failing plan. Repair it from outside:
+edit `features/<slug>/06_implementation_plan.md` to fix each `FAIL` line and re-invoke (the checkpoint
+is keyed on run INPUTS, not on the file, so your edit survives), or re-invoke with `args.resume:
+'never'` (or delete `features/<slug>/.fa-state/`) to force a fresh plan.
+
+The checkpoint banner's Gates line carries the verdict: `K2 plan-completeness ✓ | ✗ | inconclusive`.
+
 ## Checkpoint Format
 
 ```
@@ -167,6 +209,7 @@ Tier: {COMPLEXITY_TIER}
 
 {N} tasks in {M} parallel groups
 Estimated {K} files to create/modify
+🚦 Gates: K2 plan-completeness ✓ (exit 0)   ← ✗/inconclusive ⇒ do NOT start Step 7
 
 • "ок" — start coding
 • "разбей [TASK-N]" — split task further
@@ -196,3 +239,4 @@ re-flagging it. In the ultracode workflow this врезка runs automatically a
 - [ ] Parallel groups correctly identified
 - [ ] Each task touches identifiable files
 - [ ] Total file count matches complexity tier expectation
+- [ ] `check-plan-completeness.mjs features/<slug>` exited 0 (its output quoted at the checkpoint)

package/templates/.claude/skills/feature-adr/modules/08-qe.md

@@ -152,7 +152,7 @@ Fail the ADR gate for any miss:
 | Follow-up discipline | Consequences link follow-up ADRs or state none; after-action review is scheduled |
 | Confirmation stanza | Names verification method, monitoring, success metric, and owner |
 | Confirmation-to-test link | The named load-bearing property has a real automated test/fitness check by file/name |
-| No placeholders | No TODO, template hint text, raw prompt/generation scaffold, or empty tail sections |
+| No placeholders | No `TODO`, template hint text, raw prompt/generation scaffold, or empty tail sections |
 
 Reject explainer-masquerading-as-ADR: if the document describes a problem space or technology landscape but has no concrete `Decision`, record a BLOCKER.
 
@@ -182,6 +182,19 @@ paths — especially startup/lifespan/health: require a negative resource-down t
 path degrades per its declared contract: fail-open for advisory, explicit fail-fast for load-bearing).
 Missing → HIGH gap.
 
+### 3d. No-stubs gate (backlog 0b403a0106103901 — layer 1 of the cost-of-detection ladder)
+
+Over the files THIS RUN touched (the Step-7 change list; for a Codex coder, the landed-barrier file
+list), grep for unfinished-stub markers: `TODO` / `FIXME` / `HACK` / `XXX` / `PLACEHOLDER`
+(case-SENSITIVE, word-bounded — never add `-i`; `hackathon`/`todos` must not fire) plus the phrase
+`implement later` (case-insensitive). **Any match = the task shipped incomplete** → HIGH gap naming
+file:line, UNLESS the line carries an inline `no-stubs: <reason>` waiver WITH a non-empty reason, or
+`.dz/guard.json` `stubWaivers` lists the path WITH a reason. A REASONLESS waiver is itself a HIGH gap,
+never an exemption. Cross-check mechanically: `dz guard check --op publish --json` runs the same scan
+as the SOFT `no-stubs` rule over the working-tree diff. When you QUOTE a marker in `08_qe_report.md`,
+backtick it so the report itself scans clean (the claim-check forbidden-phrase convention). Record the
+verdict in the ADR Fitness section.
+
 ### 4. Multi-Agent Review Panel (L/XL)
 
 For L/XL features, spawn 3 parallel review agents using brutal-honesty modes:

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

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+// K2 — machine plan-completeness gate for /feature-adr, run BETWEEN Step 6 (plan) and Step 7 (code).
+// Generalized from features/wave1-instrument-repair/check-plan-completeness.mjs (that copy is the
+// historical artifact of its run and stays untouched); this one is parameterized by feature dir.
+//
+// USAGE:  node .claude/skills/feature-adr/scripts/check-plan-completeness.mjs [<feature-dir>] [--tier=M] [--acid=A1,A2]
+//         <feature-dir> defaults to the current working directory.
+//         --tier=S|M|L|XL closes the ADR-less dodge (see S-TIER HONESTY); omitting it keeps the
+//         heuristic, and the skip note then names the dodge out loud.
+//
+// VERDICT CONTRACT (unchanged from the proven copy — never a silent pass):
+//   PASS            exit 0   last line: `K2 plan-completeness: PASS (...)`
+//   FAIL            exit 1   last line: `K2 plan-completeness: FAIL (...)`
+//   NOT-ESTABLISHED exit 3   last line: `K2 plan-completeness: NOT-ESTABLISHED — <reason>`
+// (the wave1 copy printed the exit-3 line as `K2: NOT-ESTABLISHED — …`; the prefix is unified here so
+//  ONE regex parses all three verdicts — the exit codes and their meanings are identical.)
+// Set difference over IDENTIFIERS, not text similarity.
+//
+// KNOWN LIMITATION (measured on the discrimination twin, 2026-08-19): C1 is a grep — a PROSE
+// mention of "ADR-002" satisfies it exactly like a task reference. The real N14 (backlog
+// 3dbd2851-adjacent) must parse task structure. Kept honest here: C1 catches "forgot entirely",
+// not "mentioned but not tasked".
+//
+// Checks:
+//  C1  every ADR file in 03_adr/ has >=1 task line in 06_implementation_plan.md citing it (ADR-00N)
+//  C2  every Confirmation-numbered check in each ADR is named in the plan (by its test-file path)
+//  C3  the plan carries an EXPECTED_CODE_TARGETS: block, non-empty, and EVERY line parses to a
+//      plausible repo-relative path (no spaces unless quoted, no traversal, no markdown residue)
+//      — SFDIPOT condition: line-level validation, reject-with-reason, not just block presence
+//  C4  the plan names the feature's OWN acid corpus (see "acid corpus" below)
+//  C5  the plan has an 'Inputs read:' line naming 03_adr, 05_architecture (wave-2 seam, cheap here)
+//
+// S-TIER HONESTY (no 03_adr/): an S-tier run legitimately has no ADR files, and forcing it to fail a
+// plan gate it can never satisfy would make the gate a nuisance to route around. So:
+//   - no ADR files BUT the plan cites `ADR-<digits>`  → NOT-ESTABLISHED (exit 3): the plan claims
+//     decisions the gate cannot see, so its completeness is unknown — that is never a pass.
+//   - no ADR files AND --tier is M/L/XL → FAIL: an M+ feature owes ADRs, and skipping C1/C2 for it
+//     would let a whole tier dodge the check by simply not writing 03_adr/ (G-F3).
+//   - no ADR files AND (--tier=S or no --tier) AND the plan claims no ADR work
+//       → C1 + C2 are SKIPPED-with-note (printed as SKIP lines; the run can still PASS on C3-C5).
+//     Without --tier the skip note NAMES the dodge, because the gate cannot tell an honest S-run
+//     from an M+ run that deleted its ADR directory.
+//
+// ECHO SAFETY (G-F1, reproduced by execution): this script echoes plan-controlled content (rejected
+// target lines, acid tokens, the feature path). A plan line carrying the literal verdict marker was
+// echoed verbatim and a first-match parser upstream read the PLANT instead of the real verdict. Every
+// echoed value now goes through `safe()`, which defangs the marker and the exit trailer and truncates,
+// so the only spellable verdict line in this stream is the one this script writes last.
+//
+// ACID CORPUS (C4): the wave1 copy hard-coded ITS run's tokens. Here the corpus is DISCOVERED from
+// 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 { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+
+const argv = process.argv.slice(2);
+const acidArg = argv.find((a) => a.startsWith('--acid='));
+const tierArg = argv.find((a) => a.startsWith('--tier='));
+const TIER = tierArg ? tierArg.slice('--tier='.length).trim().toUpperCase() : null;
+const TIER_REQUIRES_ADR = TIER === 'M' || TIER === 'L' || TIER === 'XL';
+const dirArg = argv.find((a) => !a.startsWith('--'));
+const FDIR = resolve(dirArg && dirArg !== '' ? (isAbsolute(dirArg) ? dirArg : join(process.cwd(), dirArg)) : process.cwd());
+const planPath = join(FDIR, '06_implementation_plan.md');
+const adrDir = join(FDIR, '03_adr');
+const complexityPath = join(FDIR, '00_complexity_assessment.md');
+
+// Defang any value this script echoes back: a plan (or a path, or an ADR) must never be able to spell
+// the verdict marker or the exit trailer into this stream. Truncated so one hostile line cannot bury
+// the verdict either. The offender stays READABLE — defanged, not dropped.
+const safe = (v) => String(v)
+  .replace(/K2 plan-completeness:/g, 'K2 plan-completeness[echoed]:')
+  .replace(/K2_EXIT=/g, 'K2_EXIT[echoed]=')
+  .replace(/[\r\n]+/g, ' ')
+  .slice(0, 300);
+const out = (s) => console.log(s);
+const notEstablished = (why) => { out(`K2 plan-completeness: NOT-ESTABLISHED — ${safe(why)}`); process.exit(3); };
+let failures = [], warnings = [], skips = [];
+
+if (!existsSync(FDIR)) notEstablished(`feature dir absent: ${FDIR}`);
+if (!existsSync(planPath)) notEstablished('06_implementation_plan.md absent');
+const plan = readFileSync(planPath, 'utf-8');
+if (plan.trim().length < 200) notEstablished('plan suspiciously small (<200 chars)');
+const adrFiles = existsSync(adrDir) ? readdirSync(adrDir).filter(f => f.endsWith('.md')).sort() : [];
+const planClaimsAdrWork = /\bADR-\d+/.test(plan);
+if (adrFiles.length === 0 && planClaimsAdrWork) notEstablished('no ADR files under 03_adr/, yet the plan cites ADR-<n> — completeness cannot be established');
+
+if (adrFiles.length === 0 && TIER_REQUIRES_ADR) {
+  failures.push(`C1: tier ${TIER} has NO ADR files under 03_adr/ — an M/L/XL feature owes at least one ADR; the plan cannot be complete against decisions that were never written`);
+  failures.push(`C2: tier ${TIER} has no 03_adr/ — no Confirmation test can be checked`);
+} else if (adrFiles.length === 0) {
+  skips.push(`C1: no 03_adr/ and the plan claims no ADR work — ADR-coverage check SKIPPED${TIER === 'S' ? ' (--tier=S, the legitimate S-tier shape)' : ' (NO --tier supplied: an M/L/XL run that simply never wrote 03_adr/ would dodge C1/C2 here — pass --tier to close it)'}`);
+  skips.push('C2: no 03_adr/ — Confirmation-test coverage check SKIPPED');
+} else {
+  // C1 — ADR ids referenced by plan tasks
+  for (const f of adrFiles) {
+    const m = f.match(/^(\d{3})-/); if (!m) { warnings.push(`C1: unparseable ADR filename ${safe(f)}`); continue; }
+    const id = `ADR-${m[1]}`;
+    const re = new RegExp(`ADR-0*${Number(m[1])}\\b`);
+    if (!re.test(plan)) failures.push(`C1: ${id} (${safe(f)}) has NO task in the plan referencing it`);
+  }
+
+  // C2 — every Confirmation-listed test file path appears in the plan
+  const testPathRe = /(?:packages\/[\w@/.-]+\/test\/[\w./-]+\.test\.(?:ts|mjs|js)|tests?\/[\w./-]+\.test\.(?:ts|mjs|js))/g;
+  for (const f of adrFiles) {
+    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);
+    const paths = [...new Set((conf.match(testPathRe) ?? []))];
+    if (paths.length === 0) { failures.push(`C2: ${safe(f)} Confirmation names no test file paths`); continue; }
+    for (const p of paths) if (!plan.includes(p)) failures.push(`C2: ${safe(f)} Confirmation test ${safe(p)} NOT named in the plan`);
+  }
+}
+
+// C3 — EXPECTED_CODE_TARGETS block, line-level validation
+const blockM = plan.match(/EXPECTED_CODE_TARGETS:\s*\n((?:\s*[-*]\s*.+\n?)+)/);
+if (!blockM) failures.push('C3: no EXPECTED_CODE_TARGETS: block in the plan');
+else {
+  const lines = blockM[1].split('\n').map(s => s.trim()).filter(Boolean);
+  if (lines.length === 0) failures.push('C3: EXPECTED_CODE_TARGETS block is empty');
+  for (const ln of lines) {
+    const path = ln.replace(/^[-*]\s*/, '').replace(/`/g, '').trim();
+    const reasons = [];
+    if (/\s/.test(path)) reasons.push('contains whitespace');
+    if (/\.\./.test(path)) reasons.push('path traversal');
+    if (/[*#\[\]()]/.test(path)) reasons.push('markdown residue');
+    if (!/^[\w@][\w@/.-]*$/.test(path)) reasons.push('not a plain repo-relative path');
+    if (reasons.length) failures.push(`C3: target line rejected: "${safe(ln)}" — ${reasons.join(', ')}`);
+  }
+}
+
+// C4 — the feature's OWN acid corpus is named in the plan (discovered, or --acid=…)
+// G-F5: a corpus that was DECLARED but declared BADLY (lowercase `| a1 |`, a row with trailing junk,
+// or an acid-case table header with no parsable rows) is a FAILURE, not a skip. Silently skipping it
+// let a malformed declaration buy the same green as an honest "no acid cases here". The strict row
+// shape is `| A<digits> |`; anything that LOOKS like an acid row under the loose shape but is not
+// strict is reported by name. (Honest scope: rows that look nothing like an acid row — a defect table
+// `| D1 |`, say — are not acid candidates and are left alone.)
+let acidTokens = [];
+let acidSource = null;
+if (acidArg) {
+  acidTokens = acidArg.slice('--acid='.length).split(',').map(s => s.trim()).filter(Boolean);
+  acidSource = '--acid';
+  if (acidTokens.length === 0) failures.push('C4-malformed: --acid was passed but declares no tokens');
+} else if (existsSync(complexityPath)) {
+  const complexity = readFileSync(complexityPath, 'utf-8');
+  acidTokens = [...new Set((complexity.match(/^\|\s*(A\d+)\s*\|/gm) ?? []).map(r => r.replace(/[|\s]/g, '')))];
+  if (acidTokens.length) acidSource = '00_complexity_assessment.md acid-case table';
+  const loose = [...new Set((complexity.match(/^\|\s*([Aa]\d+[A-Za-z]?)\s*\|/gm) ?? []).map(r => r.replace(/[|\s]/g, '')))];
+  for (const cand of loose) if (!acidTokens.includes(cand)) failures.push(`C4-malformed: acid row "${safe(cand)}" does not match the required \`| A<n> |\` shape (case-sensitive, digits only) — it is declared but uncheckable`);
+  const declaresTable = /\|\s*Acid case\s*\|/i.test(complexity);
+  if (declaresTable && acidTokens.length === 0) failures.push('C4-malformed: 00_complexity_assessment.md declares an acid-case table but NO `| A<n> |` row parsed from it');
+}
+if (acidTokens.length === 0) skips.push('C4: no acid corpus declared (no --acid, no `| A<n> |` table in 00_complexity_assessment.md) — acid-naming check SKIPPED');
+else for (const t of acidTokens) if (!new RegExp(`\\b${t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i').test(plan)) failures.push(`C4: acid token "${safe(t)}" (from ${acidSource}) not named in the plan`);
+
+// C5 — Inputs read line
+if (!/Inputs read:/i.test(plan)) warnings.push('C5: no "Inputs read:" line (wave-2 seam, WARN only)');
+else for (const need of ['03_adr','05_architecture']) if (!plan.includes(need)) warnings.push(`C5: Inputs read line missing ${need}`);
+
+for (const s of skips) out('SKIP  ' + s);
+for (const w of warnings) out('WARN  ' + w);
+for (const f of failures) out('FAIL  ' + f);
+out(`K2 plan-completeness: ${failures.length === 0 ? 'PASS' : 'FAIL'} (${failures.length} failure(s), ${warnings.length} warning(s), ${skips.length} skip(s)) over ${adrFiles.length} ADRs, tier ${TIER === null ? '(unspecified)' : safe(TIER)}, in ${safe(FDIR)}`);
+process.exit(failures.length === 0 ? 0 : 1);