@dzhechkov/skills-feature-adr 1.4.0 → 1.5.0

package/.dz-manifest.json

@@ -5,7 +5,7 @@
     "files": [
       {
         "path": "CHANGELOG.md",
-        "sha256": "bbb43101a686369a8662f47fe7b7aa75073b614a188c2752cd81d9570620bb3d"
+        "sha256": "59592f0b4612a14bdec61c96c20655644701cd77a0bf9d68315e1c98461900ff"
       },
       {
         "path": "LICENSE",
@@ -13,7 +13,7 @@
       },
       {
         "path": "README.md",
-        "sha256": "469873d967c4438afd0b25ec8b013347841e07328f508f6786f90cc6aa2f09b9"
+        "sha256": "8df52c2c7d7c70ef29670339ac01a6c0b0b6a36bb51a0be15dcc03357097cca8"
       },
       {
         "path": "bin/cli.js",
@@ -25,7 +25,7 @@
       },
       {
         "path": "package.json",
-        "sha256": "c1e4d257167fd2462e0c8e09f248fc1aef332aa34fb09dddd5940bdcc30ea34b"
+        "sha256": "0fc1ae047774c2c67c6acf77a88eef8c9532c609bfc68b9e9cb37591cb61158f"
       },
       {
         "path": "scripts/sync-templates.js",
@@ -157,7 +157,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/06-implementation-plan.md",
-        "sha256": "c8fdd1877d8d9515ab29f52c3db49ddd9612b5797bc071e6208def860c02e6f2"
+        "sha256": "3903e2694ad47782914b35869bbf19c5f0803b6dafdcfb629df343a5ff00d1b9"
       },
       {
         "path": "templates/.claude/skills/feature-adr/modules/07-code.md",
@@ -257,7 +257,7 @@
       },
       {
         "path": "templates/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs",
-        "sha256": "41d85b012a9d6cc172eaa5d7777294f2c01fb54b752ed61c7cbe2d2cd7b79b67"
+        "sha256": "2e1afeb8cbc08ce872fc8280a0809e7712ee76879d08b48caa5a0d4082cb8647"
       },
       {
         "path": "templates/.claude/skills/frontend-design/LICENSE.txt",
@@ -321,7 +321,7 @@
       },
       {
         "path": "templates/.claude/workflows/feature-adr.js",
-        "sha256": "1be239d2f02612bc33027767d9930eae8a2d6d5afd427d1485198bbdd821a3c7"
+        "sha256": "3c8838c6a5107ea8a4b909cd9ccfa4d416324bb4ed9341f50b8e23f1b569d244"
       },
       {
         "path": "templates/lib/memory-protocol.md",
@@ -349,5 +349,5 @@
       }
     ]
   },
-  "signature": "gixeRY/3+gjSSS3a+DfVwn40SVlD9Gr2sCh3H8afGWd1+Dzo8R8CmD61qG0cLeDdHn2NgzRWwvICHe+0HFlYCA=="
+  "signature": "8JbfbAiP55HvylGRoFfLwEtYCoo02jM9PwfOcTiYWQXfN/Utcg+Wc7uFo08yfqPUyONXsMCcEfqB7Y5eKWIvDg=="
 }

package/CHANGELOG.md

@@ -1,5 +1,127 @@
 # Changelog
 
+## [1.5.0] - 2026-08-21
+
+### Changed — feature `qe-scoped-review`
+
+### Changed — Step-8 Codex QE is SCOPED, and every fallback names its cause
+
+Not published. Behaviour change to the Step-8 QE dispatch only; routing, the Claude belt, checkpoints
+and training-pair capture are untouched.
+
+- **The measurement that forced it** (same question, same model `gpt-5.6-sol` at effort `high`,
+  2026-08-21): an UNSCOPED `codex exec` QE prompt of 19 038 chars spent 280 s, exited 124 and produced
+  416 KB of exploration with NO verdict — and did it again under a 1500 s ceiling. The same question
+  scoped to two named files answered in 41 s with `Grade: B`; `codex review --commit` answered in
+  146 s with the scope derived from the diff. The budget went on RECONNAISSANCE, so raising the
+  timeout buys more of it, and the prompt ceiling was never the binding constraint (19 038 < 24 000,
+  with ~5 000 chars of headroom). The harm was not the minutes: on timeout the dispatch returns null,
+  the belt runs a Claude reviewer, and cross-family QE is lost SILENTLY on exactly the large features
+  that need it most.
+- **Mode A — `codex review`** is now the primary Step-8 Codex pass; the diff defines the scope.
+  Default `--uncommitted`, overridable with `args.qeScope` / `args.qeScopeRef`. The builder can never
+  emit `-m` and never appends a positional prompt: MEASURED, `codex review` rejects `-m` with exit 2,
+  and EVERY scope flag (`--commit`, `--base`, `--uncommitted`) rejects `[PROMPT]` with exit 2. Either
+  mistake would present as a review that silently did not happen.
+- **Mode B — a NARROWED `codex exec`** carries our own questions over at most 3 named files and ends
+  with `Grade: <A|B|C|D>`. An unscoped mode-B dispatch is not constructible: an empty file list yields
+  `''`, and `codexExecPlan` now refuses an unscoped `qe` prompt outright.
+- **A locked decline taxonomy** — `timeout | no-verdict | tool-error | unusable-output | unavailable |
+  over-ceiling` — replaces the single generic reason. A timeout ("narrow the scope") and a broken
+  invocation ("fix the command") can no longer render the same string inside
+  `opus (cross-family QE DID NOT happen — …)`. An unknown kind throws rather than rendering something
+  plausible.
+- **A machine sentinel** (`CODEX-QE-SIGNAL exit=… elapsed=…s bytes=…`, the Step-7.5 landing-signal
+  grammar) carries the exit code past the shell agent, so a timeout is knowable without asking a model
+  to self-report its own failure. A MISSING sentinel is classified `tool-error` on the pipeline path —
+  never a pass.
+- **Zero findings is never an `A`.** Mode A cannot be asked for a letter, so its grade is derived from
+  the severities the reviewer reported and labelled `gradeSource: 'derived-from-findings'`; an empty or
+  unparseable finding set yields `null` and declines. MEASURED: `codex review` on a clean tree exits 0
+  with a well-formed, entirely empty review — the exact input that a default letter would have turned
+  into a clean bill of health.
+- **`qe` now returns `gaps` from the reviewer's actual findings**, plus `gradeSource` and
+  `qeScope {mode, ref, files}`; the review scope enters the `qe` checkpoint hash so a resume cannot
+  present a mode-B verdict as a mode-A one.
+- **`CODEX_EXEC_PROMPT_CEILING_CHARS` is retained but DEMOTED** — it is a sanity bound on an absurd
+  payload, and is no longer documented as the thing that prevents a stall. The defence is scope.
+- **Unchanged on purpose:** `resolveQeSpec` / `coderIsCodex` / `qeShouldUseCodex` (verified correct by
+  direct call), the `crossFamilyQe` label format, and the Claude belt — the pipeline still never blocks
+  on Codex.
+
+### Fixed — the K2 plan gate could not complete a run on a non-JS repository
+
+- **C2 recognises test paths in every ecosystem.** The gate demanded a `.test.(ts|mjs|js)` suffix, so
+  a Python/Go/Rust/JVM/.NET feature could never satisfy it (measured: 4/4 JS forms matched, 0/11
+  non-JS). Replaced by a two-stage predicate — a language-neutral candidate-path extractor plus one
+  `$`-anchored rule per ecosystem (JS/TS, pytest `test_*.py` + `*_test.py`, Go, Rust `tests/*.rs` +
+  `tests.rs`, JVM, .NET). Widening it to "contains the word test" was rejected: `docs/testing.md`,
+  `src/latest.rs` and prose are still refused. An unknown ecosystem stays a FAIL, never a WARN.
+- **New opt-in `testPathRules`** in the existing `architecture/project-skills.json`: additive rules,
+  each anchored by wrapping so an alternation cannot leak, capped at 200 characters, and FATAL when
+  malformed (`NOT-ESTABLISHED`, exit 3) rather than silently falling back to the built-ins.
+- **The gate script is resolved from the WORKSPACE first.** The command `cd`s into the target repo,
+  so the repo-relative path died with `Cannot find module` on any repo without its own feature-adr
+  install. Order: `args.gateScript` (new, absolute, validated) → workspace copy → repo copy, with
+  `K2_GATE_SCRIPT=` / `K2_GATE_TRIED=` echoed for audit. Nothing found ⇒ reason `tooling-missing`
+  (a NOT-ESTABLISHED, never a skip), and the operator note now says the gate could not be RUN and
+  that this is not a plan defect — it no longer tells you to fix a plan that is fine.
+- **A relative `args.dzBin` is pinned to the workspace root once**, before any `cd`, so the six
+  commands that splice it stop resolving against three different bases (a null usage probe was being
+  read upstream as "the Claude limit was hit").
+
+### Changed — `EXPECTED_CODE_TARGETS` admissibility (C3)
+
+- Dotfile targets (`.claude/…`, `.github/workflows/ci.yml`, `.gitignore`, `.env.example`) are
+  admissible — previously feature-adr could not name its own files or any CI config, in any language.
+- Directory-shaped targets are now REJECTED (`trailing slash — names a directory, not a file`): a bare
+  directory gives plan-vs-diff matching nothing concrete to verify.
+- Every refusal names its own defect instead of one catch-all: `path traversal ('..' segment)`,
+  `degenerate path segment`, `empty path segment`, `path segment ends with '.'`,
+  `illegal character '<c>'`, `empty stem after the leading dot`. The traversal check is a SEGMENT
+  test now, so the ordinary filename `foo..bar.ts` is no longer called a path traversal.
+
+### Requires
+
+- Nothing new at runtime: the workflow INLINES the gate command builder and its parser (the sandbox
+  cannot import), so this release is self-contained. The pure halves it mirrors live in
+  `@dzhechkov/harness-core` (`planCompletenessGateCmd` gained an optional 4th argument;
+  `refusalNoteFor` and `normalizeDzBin` are new) and a drift test pins the two copies together.
+
+
+### Fixed — Step 0 wrote nothing down, so the tier was unreadable and the acid check had no input
+
+- **Step 0 now WRITES `00_complexity_assessment.md`** before returning: the tier with its decisive
+  criterion, the active steps, the recalled patterns, and an acid-case table whose rows are pinned to
+  the exact `| A<n> | <bad input> | <what must happen> |` shape the K2 gate parses. MEASURED
+  2026-08-21: 66 of 199 features carried that file and the last four in a row did not. Two silent
+  consequences — the tier was recorded NOWHERE while a run was alive (the checkpoint lands at phase
+  end, the result object only at the very end), and the C4 acid check quietly switched itself off,
+  including for the features that introduced it. An honest no-acid-cases run still writes prose and
+  no table; the gate now tells an ABSENT file from a deliberate skip.
+- **A caller-forced tier is the tier of record.** `tier = args.tier || router.tier` means the run
+  executes the override while Step 0 wrote down its own classification. The artifact now carries
+  `Effective tier: <forced> (forced by the caller)` alongside the router's own recommendation, and
+  sizes the acid table for the effective tier. With no override the prompt is byte-identical.
+- **A pre-contract router checkpoint no longer resumes into the new contract** — the resume gate only
+  asks whether the artifact is PRESENT, and any of the 66 features with a tableless file satisfied it.
+
+### Fixed — the Step-8 QE stage measured the wrong thing in four different ways
+
+- the change set is the run's DELTA (pre-code baseline vs after), not the working tree's current dirt;
+- a finding whose location cannot be parsed is `unlocatable` and stays in the graded set — it used to
+  be filed as someone else's dirt, i.e. unknown counted as clean;
+- mode B refuses a scope built from unlanded code, an unmeasured change set or an empty intersection;
+- the QE scribe is WITNESSED: the report is re-hashed before and after, so an existing file from an
+  earlier run can no longer stand in for one this run never wrote.
+
+### Fixed — durable state is written by a command, not by hand
+
+- checkpoint lines now go through `dz feature-adr-checkpoint`. The subagent RUNS a command instead of
+  hand-writing state into a file: a security classifier blocked NINE consecutive checkpoint writes in
+  one run, `.fa-state/checkpoints.jsonl` was never created, resume was silently dead, and the run
+  reported success.
+
 ## [1.4.0] - 2026-08-20
 
 ### Changed — the composite design checkpoint

package/README.md

@@ -106,6 +106,108 @@ ARCHITECTURE → IMPLEMENTATION →  CODE   →   QE    →  FLEET QE
 # Full protocols + 6 extra skills, up to 7 fleet QE agents
 ```
 
+### 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
+could not finish a run on a non-JS repository — three separate defects, all closed here.
+
+**1. Test paths in every ecosystem.** C2 checks that each ADR's Confirmation names a test file and
+that the plan names the same path. It used to demand a `.test.(ts|mjs|js)` suffix, so on a Python,
+Go, Rust, JVM or .NET repo it found nothing and failed the plan (measured: 4/4 JS forms matched,
+0/11 non-JS forms did). It now uses a two-stage predicate — candidate paths are extracted from the
+Confirmation text, then matched against one anchored rule per ecosystem:
+
+| Ecosystem | Recognised |
+|---|---|
+| JS/TS | `*.test.*` / `*.spec.*` (`ts tsx mts cts mjs cjs js jsx`) |
+| pytest | `test_*.py` **and** `*_test.py` |
+| Go | `*_test.go` |
+| Rust | `tests/*.rs` **and** `tests.rs` |
+| JVM | `*Test|Tests|IT|Spec.(java kt kts scala groovy)` |
+| .NET | `*Test|Tests.(cs fs vb)` |
+
+Deliberately NOT "any path containing the word test": `docs/testing.md`, `src/latest.rs`,
+`contests/results.py` and a sentence like *"the staleness test will verify this"* are all refused. A
+gate that passes prose is worse than one that fails Python. An unknown ecosystem is still a FAIL,
+never a warning — the message names the recognised set and points at the override below.
+
+**Extending the vocabulary — `testPathRules`.** Add rules to the manifest the pipeline already
+reads, `architecture/project-skills.json` (no second dotfile):
+
+```json
+{
+  "testPathRules": [
+    { "ecosystem": "elixir", "pattern": "(?:^|/)test/[^/]+_test\\.exs" }
+  ]
+}
+```
+
+Rules are ADDED to the built-ins, never replace them, and each pattern is anchored by wrapping
+(`(?:<pattern>)$`) so every branch of an alternation is anchored. A malformed `testPathRules`
+(bad JSON, not an array, missing `ecosystem`/`pattern`, an invalid regex, over 200 characters, or a
+nested quantifier) is **NOT-ESTABLISHED, exit 3** — never a quiet fall-back to the built-ins.
+
+**2. The gate script is found where it is installed — `args.gateScript`.** The skill lives in your
+WORKSPACE; the gate command `cd`s into the TARGET repo, so a repo-relative lookup died with
+`Cannot find module` on every repo that is not itself a feature-adr install. The resolution order is
+now:
+
+1. `args.gateScript` — an explicit ABSOLUTE path (validated: absolute, no `..`, or the run fails loudly);
+2. the WORKSPACE copy (`$WS/.claude/skills/feature-adr/scripts/check-plan-completeness.mjs`);
+3. the target-repo copy.
+
+Workspace before repo on purpose: the verdict contract is defined by the parser inside the running
+workflow, so only that installation's own copy is known to speak it. Every run echoes
+`K2_GATE_SCRIPT=` (which copy ran) and `K2_GATE_TRIED=` (all candidates) for audit. If none exists
+the run refuses with reason `tooling-missing` — a NOT-ESTABLISHED, never a skip — and the operator
+message says the gate could not be RUN and that this is **not** a plan defect.
+
+**3. Dotfile targets are admissible; directory-shaped ones are not.** `EXPECTED_CODE_TARGETS` may
+now name `.claude/…`, `.github/workflows/ci.yml`, `.gitignore`, `.env.example`. What is refused is
+refused BY NAME: `path traversal ('..' segment)`, `degenerate path segment`, `empty path segment`,
+`trailing slash — names a directory, not a file`, `path segment ends with '.'`,
+`illegal character '<c>'`, `empty stem after the leading dot`. The old substring traversal test also
+rejected the ordinary filename `foo..bar.ts`; it is a segment test now.
+
+### Step 0 writes the assessment down, and the acid check gets its input back (v1.5.0)
+
+Step 0 classifies the feature and now **writes `00_complexity_assessment.md` before it returns** — the
+tier with the criterion that decided it, the active steps, the recalled patterns, and an acid-case
+table. MEASURED 2026-08-21: 66 of 199 features carried that file and the last four in a row did not,
+with two silent consequences. The tier was recorded NOWHERE while a run was alive (the router
+checkpoint lands at phase end and the result object only at the very end), so mid-run it had to be
+guessed from which artifacts happened to exist. And the K2 gate reads its acid corpus from that file,
+so the C4 check quietly switched itself off — including for the features that introduced it.
+
+Acid rows are pinned to the exact shape the gate parses, `| A<n> | <the bad input> | <what must
+happen> |`; a loose shape disables the check just as silently as a missing file. A feature with no
+acid cases still says so in prose and writes no table — the gate now tells an ABSENT file (a warning
+that names the missing artifact) from a deliberate skip.
+
+Two ways the tier could still go unrecorded, both closed here:
+
+- a **pre-contract router checkpoint** used to resume into the new contract. The resume gate only asks
+  whether the artifact is PRESENT, and any of the 66 features carrying a tableless file satisfied it,
+  so Step 0 never re-ran. A router-scoped hash token now makes those entries re-run — once, and only
+  the router, rather than every in-flight stage.
+- a **caller-forced `args.tier`** is now the tier of record. The run executes the override, so the
+  file carries `Effective tier: <forced> (forced by the caller)` alongside the router's own
+  recommendation, and sizes the acid table for the effective tier. With no override the prompt is
+  byte-identical to before.
+
+Requires `@dzhechkov/harness-core >= 0.6.0`.
+
+### The Step-8 QE stage measures the run, not the room (v1.5.0)
+
+Four separate ways the QE stage graded the wrong thing, all closed: the change set is this run's DELTA
+(a pre-code baseline against the state after) instead of the working tree's current dirt, so an
+unrelated dirty file can no longer grade your feature; a finding whose location cannot be parsed is
+`unlocatable` and stays in the graded set, where it used to be filed as someone else's dirt — unknown
+counted as clean, inside the function whose job is honest attribution; mode B refuses a scope built
+from unlanded code, an unmeasured change set, or an empty intersection; and the QE scribe is
+WITNESSED — the report is re-hashed before and after, so a file left by an earlier run can no longer
+stand in for one this run never wrote.
+
 ### The design fan resumes per sibling, and an incomplete design is REFUSED (v1.4.0)
 
 Step 1–5 run as one parallel fan — requirements, ADR, QCSD, architecture. Until v1.4.0 the whole fan
@@ -237,6 +339,49 @@ family than the coder** — a model that writes code must not also self-QE; inde
 catches what self-review misses. coder=Codex ⇒ QE=Claude (`opus`); coder=Claude ⇒ QE=Codex
 (`codex:<top>:high`), or a Claude reviewer if Codex is unavailable (never blocks).
 
+### Step 8 on Codex is SCOPED — two modes, and every fallback names its cause
+
+When QE routes to Codex, Step 8 no longer hands it one unscoped `codex exec` prompt. Why, MEASURED
+2026-08-21 — same question, same model (`gpt-5.6-sol`, effort `high`), three dispatches:
+
+| dispatch | prompt | wall time | exit | verdict? |
+|---|---|---|---|---|
+| `codex exec`, unscoped | 19 038 chars | 280 s (and again under a 1500 s ceiling) | 124 | **none** — 416 KB of exploration |
+| `codex exec`, scoped (*"read ONLY these two files"*) | 1 461 chars | 41 s | 0 | `Grade: B` + findings |
+| `codex review --commit <SHA>` | scope from the diff | 146 s | 0 | verdict + findings |
+
+The unscoped run spent its budget on **reconnaissance of the tree**, not on reasoning about the change.
+So raising the timeout does not help, and the prompt-length ceiling was never the binding constraint
+(19 038 sat under `CODEX_EXEC_PROMPT_CEILING_CHARS` = 24 000 with ~5 000 to spare). The cost is not the
+wasted minutes: on timeout the dispatch returns `null`, the belt runs a Claude reviewer, and
+cross-family QE is silently lost — on exactly the big features that need it most.
+
+- **Mode A (primary): `codex review`.** The scope comes from the DIFF, so Codex computes for free the
+  thing we were paying a model to do badly. Default scope `--uncommitted`; override with
+  `args.qeScope: 'commit' | 'base'` + `args.qeScopeRef`. Two CLI facts are encoded as refusals, both
+  measured: `codex review` rejects `-m` (exit 2 — the model goes through `-c model=`), and **every**
+  scope flag rejects a positional prompt (`--commit`, `--base` and `--uncommitted` alike, exit 2). So
+  mode A runs on Codex's built-in review instructions and cannot be asked our questions.
+- **Mode B (follow-up): a NARROWED `codex exec`.** Carries our own questions over at most 3 named
+  files with the load-bearing clause *"read ONLY these files, do not explore the repository"*, and
+  ends with `Grade: <A|B|C|D>`. An unscoped mode-B prompt is not constructible: an empty file list
+  returns `''` and `codexExecPlan` refuses an unscoped `qe` prompt outright.
+- **The verdict is parsed, never synthesised.** A `Grade: D` is a SUCCESSFUL cross-family review; a
+  review with no grade is a FAILED one. Mode A cannot state a letter, so its grade is DERIVED from the
+  severities it reported and labelled `gradeSource: 'derived-from-findings'` — and **zero findings
+  yields `null`, never `A`** (measured: `codex review` on a clean tree exits 0 with a polite, entirely
+  empty review; calling that an `A` would be a review of nothing reported as a pass).
+- **Every fallback names its cause.** The reason carried into
+  `opus (cross-family QE DID NOT happen — …)` comes from a locked taxonomy —
+  `timeout` (narrow the scope) · `no-verdict` · `tool-error` (fix the invocation) · `unusable-output` ·
+  `unavailable` (fix the account/model) · `over-ceiling`. A timeout and an unusable output can never
+  render the same string, because the operator's next move differs.
+- **The pipeline still never blocks on Codex.** Both modes fail into the same Claude belt as before.
+
+After a Codex verdict a cheap Claude agent transcribes it into `08_qe_report.md` (mode A takes no
+prompt, so the reviewer cannot be asked to write anything). It is a scribe, not a second reviewer: the
+grade is Codex's and is stated as final.
+
 **Precedence:** `args.models[stage]` wins; the legacy `planner`/`coder`/`qeReviewer`/`codexModel` knobs
 fill only unspecified stages. `codexModel` seeds the id for a bare `'codex'` spec. gpt-5.6-ready: a new
 Codex id is a data-only allowlist edit.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "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

@@ -15,7 +15,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "bbb43101a686369a8662f47fe7b7aa75073b614a188c2752cd81d9570620bb3d"
+          "content": "59592f0b4612a14bdec61c96c20655644701cd77a0bf9d68315e1c98461900ff"
         }
       ]
     },
@@ -35,7 +35,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "469873d967c4438afd0b25ec8b013347841e07328f508f6786f90cc6aa2f09b9"
+          "content": "8df52c2c7d7c70ef29670339ac01a6c0b0b6a36bb51a0be15dcc03357097cca8"
         }
       ]
     },
@@ -65,7 +65,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "c1e4d257167fd2462e0c8e09f248fc1aef332aa34fb09dddd5940bdcc30ea34b"
+          "content": "0fc1ae047774c2c67c6acf77a88eef8c9532c609bfc68b9e9cb37591cb61158f"
         }
       ]
     },
@@ -395,7 +395,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "c8fdd1877d8d9515ab29f52c3db49ddd9612b5797bc071e6208def860c02e6f2"
+          "content": "3903e2694ad47782914b35869bbf19c5f0803b6dafdcfb629df343a5ff00d1b9"
         }
       ]
     },
@@ -645,7 +645,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "41d85b012a9d6cc172eaa5d7777294f2c01fb54b752ed61c7cbe2d2cd7b79b67"
+          "content": "2e1afeb8cbc08ce872fc8280a0809e7712ee76879d08b48caa5a0d4082cb8647"
         }
       ]
     },
@@ -805,7 +805,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "1be239d2f02612bc33027767d9930eae8a2d6d5afd427d1485198bbdd821a3c7"
+          "content": "3c8838c6a5107ea8a4b909cd9ccfa4d416324bb4ed9341f50b8e23f1b569d244"
         }
       ]
     },

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

@@ -198,6 +198,13 @@ After the plan is written, run the gate. It is a script, not a judgement call:
 node .claude/skills/feature-adr/scripts/check-plan-completeness.mjs features/<slug>
 ```
 
+The path above is relative to the workspace the skill is INSTALLED in. Working inside a target repo
+that has no feature-adr install of its own? Pass the absolute path to the script instead — the
+ultracode workflow does this for you (it tries `args.gateScript`, then the workspace copy, then the
+target-repo copy, and refuses with `tooling-missing` if none exists). The gate is language-neutral:
+C2 recognises JS/TS, pytest, Go, Rust, JVM and .NET test paths, extensible per project with
+`testPathRules` in `architecture/project-skills.json`.
+
 | Exit | Verdict | What you do |
 |------|---------|-------------|
 | `0` | PASS | proceed to Step 7 |

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

@@ -85,6 +85,79 @@ const adrFiles = existsSync(adrDir) ? readdirSync(adrDir).filter(f => f.endsWith
 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');
 
+// ── C2 test-path predicate (P16/D1) — language-neutral, two stages ────────────────────────────
+// The shipped rule demanded a `.test.(ts|mjs|js)` SUFFIX, so C2 could never be satisfied outside
+// JS/TS: MEASURED 2026-08-20 over a 15-path corpus, 4/4 JS forms matched and 0/11 non-JS forms did
+// (`tests/test_x.py`, `x_test.go`, `tests/x.rs`, `XTest.java`, `XTests.cs`, …) — and zero matches is
+// the C2 FAIL branch, so the gate blocked every non-JS repo. The fix is a PREDICATE, not a wider
+// regex: "contains the word test" would admit `docs/testing.md` and `src/latest.rs`, and a gate that
+// passes prose is worse than one that fails Python.
+//
+// STAGE 1 (extractCandidatePaths) — pull candidate PATHS out of prose. The left edge is ANCHORED on
+// a boundary character so a longer token can never donate a substring (`xcontests/foo.test.ts` must
+// not yield `foo.test.ts`), and a candidate MUST carry at least one directory segment and an
+// extension — a bare `test_staleness.py` written inside a sentence is a name, not a path.
+// STAGE 2 (isTestPath) — ONE `$`-anchored rule per ecosystem. The anchoring IS the safety argument:
+// every acid item is refused by construction rather than by a blocklist.
+// DELIBERATELY NOT DONE: no `existsSync` decides whether a Confirmation path is valid — C2 runs
+// BEFORE Step 7 writes the test, so a file-existence probe there would fail every honest plan.
+const CANDIDATE_PATH_RE = /(?:^|[\s`'"(|])((?:[.\w@][\w@.-]*\/)+[\w@.-]+\.[A-Za-z0-9]+)/g;
+const extractCandidatePaths = (text) => {
+  const found = [];
+  CANDIDATE_PATH_RE.lastIndex = 0;
+  let m;
+  while ((m = CANDIDATE_PATH_RE.exec(String(text))) !== null) found.push(m[1]);
+  return [...new Set(found)];
+};
+
+// One rule per ecosystem, each anchored at the END of the path. Adding an ecosystem is a data edit.
+const BUILTIN_TEST_PATH_RULES = [
+  { ecosystem: 'js', re: /\.(?:test|spec)\.(?:ts|tsx|mts|cts|mjs|cjs|js|jsx)$/ },
+  { ecosystem: 'pytest', re: /(?:^|\/)test_[^/]+\.py$/ },
+  { ecosystem: 'pytest', re: /[^/]+_test\.py$/ },
+  { ecosystem: 'go', re: /[^/]+_test\.go$/ },
+  { ecosystem: 'rust', re: /(?:^|\/)tests\/[^/]+\.rs$/ },
+  { ecosystem: 'rust', re: /(?:^|\/)tests\.rs$/ },
+  { ecosystem: 'jvm', re: /[^/]+(?:Test|Tests|IT|Spec)\.(?:java|kt|kts|scala|groovy)$/ },
+  { ecosystem: 'dotnet', re: /[^/]+(?:Test|Tests)\.(?:cs|fs|vb)$/ },
+];
+const KNOWN_ECOSYSTEMS = 'JS/TS *.test|spec.[tj]s, pytest test_*.py + *_test.py, Go *_test.go, Rust tests/*.rs + tests.rs, JVM *Test|Tests|IT|Spec.java|kt|kts|scala|groovy, .NET *Test|Tests.cs|fs|vb';
+// The override channel lives in the manifest the pipeline ALREADY probes at Step 0 — a second
+// dotfile would be a second thing to keep in sync. Resolved against the TARGET REPO cwd (the gate
+// command cd's into the repo first); never shelled out to `dz project-skills`, because a gate that
+// needs a working `dz` to decide whether a path is a test inherits every one of dz's own failures.
+const MANIFEST_REL = 'architecture/project-skills.json';
+function loadTestPathRules() {
+  const rules = BUILTIN_TEST_PATH_RULES.slice();
+  const manifestPath = join(process.cwd(), MANIFEST_REL);
+  if (!existsSync(manifestPath)) return rules;
+  let text = null;
+  try { text = readFileSync(manifestPath, 'utf-8'); } catch { notEstablished(`testPathRules unreadable: ${MANIFEST_REL} could not be read`); }
+  let manifest = null;
+  try { manifest = JSON.parse(text); } catch { notEstablished(`testPathRules unreadable: ${MANIFEST_REL} is not valid JSON`); }
+  const extra = (manifest !== null && typeof manifest === 'object' && !Array.isArray(manifest)) ? manifest.testPathRules : undefined;
+  // ABSENT is not an error — the built-ins stand. Only a PRESENT-but-broken override is fatal: a
+  // silent fall-back to built-ins would tell a project its rules are live when they are not.
+  if (extra === undefined || extra === null) return rules;
+  if (!Array.isArray(extra)) notEstablished('testPathRules unreadable: testPathRules is present but is not an array');
+  for (const entry of extra) {
+    if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) notEstablished('testPathRules unreadable: an entry is not a {ecosystem, pattern} object');
+    const eco = typeof entry.ecosystem === 'string' ? entry.ecosystem.trim() : '';
+    if (eco === '') notEstablished('testPathRules unreadable: an entry has no non-empty "ecosystem"');
+    if (typeof entry.pattern !== 'string' || entry.pattern === '') notEstablished(`testPathRules unreadable: entry "${eco}" has no non-empty "pattern"`);
+    if (entry.pattern.length > 200) notEstablished(`testPathRules unreadable: entry "${eco}" pattern exceeds 200 characters`);
+    // The ONE catastrophic-backtracking shape a length cap does not bound. Refused by SHAPE, because
+    // this sandboxless script cannot enforce a match timeout.
+    if (/\([^)]*[+*][^)]*\)[+*]/.test(entry.pattern)) notEstablished(`testPathRules unreadable: entry "${eco}" pattern nests a quantifier over a quantified group (catastrophic backtracking)`);
+    let re = null;
+    // WRAP, never append a bare `$`: `foo|bar` + `$` anchors only the LAST branch, so `src/foolish.py`
+    // would match `foo` unanchored and an arbitrary source file would count as a Confirmation test.
+    try { re = new RegExp('(?:' + entry.pattern + ')$'); } catch { notEstablished(`testPathRules unreadable: entry "${eco}" pattern is not a valid regular expression`); }
+    rules.push({ ecosystem: eco, re: re });
+  }
+  return rules;
+}
+
 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`);
@@ -101,18 +174,78 @@ if (adrFiles.length === 0 && TIER_REQUIRES_ADR) {
   }
 
   // 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;
+  const testPathRules = loadTestPathRules();
+  const isTestPath = (p) => testPathRules.some((r) => r.re.test(p));
   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; }
+    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
+    // in the message instead.
+    if (paths.length === 0) { failures.push(`C2: ${safe(f)} Confirmation names no test file paths (recognised: ${KNOWN_ECOSYSTEMS}; extend the vocabulary with a "testPathRules" array in ${MANIFEST_REL})`); 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 target-path admissibility (P16/D3) — named rules, not one character class ───────────────
+// A LEADING DOT is legitimate: `.claude/`, `.github/workflows/ci.yml`, `.gitignore`, `.env.example`
+// are ordinary targets in every ecosystem, and until the 2026-08-20 bootstrap fix the `^[\w@]…`
+// class rejected every one of them — so feature-adr could not name its OWN files and no feature
+// could touch CI config. Found by a run that stopped at this very gate while trying to fix the gate.
+//
+// This is the HARDENING of that minimal fix, and it answers the three holes it left:
+//  (a) the traversal rule was a SUBSTRING test, so an ordinary filename `foo..bar.ts` collected the
+//      label `path traversal` (MEASURED). It is replaced by SEGMENT rules: a segment exactly `..` is
+//      traversal; a segment of nothing but dots is a DEGENERATE NAME — a different defect that must
+//      not borrow the traversal label. Coverage is not weakened: `..`, `../`, `../etc/passwd` and
+//      `.a/../b` all carry a `..` SEGMENT and are still refused.
+//  (b) a directory-shaped target (`.claude/`) was ACCEPTED and gives Step-6/7 plan-vs-diff matching
+//      nothing concrete to verify against — rejected now, by its own name.
+//  (c) every refusal names WHAT is wrong. The old catch-all `not a plain repo-relative path` fired
+//      for an illegal character, a bad first character and a stray dot alike.
+// A named reason that LIES is worse than a generic one: the leading-stem message is emitted ONLY for
+// a path that actually starts with a dot, never for `-foo.ts` or `+x.ts`.
+const MARKDOWN_RESIDUE_RE = /[*#\[\]()]/;
+const LEGAL_TARGET_CHAR_RE = /[A-Za-z0-9_@./-]/;
+function classifyTargetPath(path) {
+  const reasons = [];
+  if (/\s/.test(path)) reasons.push('contains whitespace');
+  if (MARKDOWN_RESIDUE_RE.test(path)) reasons.push('markdown residue');
+  if (path.startsWith('/')) reasons.push('absolute path — targets are repo-relative');
+  if (path.startsWith('~')) reasons.push('home-relative path — targets are repo-relative');
+  const anchoredHere = path === '.' || path.startsWith('./');
+  if (anchoredHere) reasons.push('not repo-relative (anchored at the current directory)');
+  const segs = path.split('/');
+  let dotDot = false, degenerate = false, emptySeg = false, trailingDotSeg = false;
+  for (let i = 0; i < segs.length; i++) {
+    const s = segs[i];
+    if (s === '..') { dotDot = true; continue; }
+    if (/^\.+$/.test(s)) { if (s.length >= 3 || (i > 0 && !anchoredHere)) degenerate = true; continue; }
+    if (s === '') { if (i > 0 && i < segs.length - 1) emptySeg = true; continue; }
+    if (s.endsWith('.')) trailingDotSeg = true;
+  }
+  if (dotDot) reasons.push("path traversal ('..' segment)");
+  if (degenerate) reasons.push('degenerate path segment');
+  if (emptySeg) reasons.push('empty path segment');
+  if (path.endsWith('/')) reasons.push('trailing slash — names a directory, not a file');
+  if (trailingDotSeg) reasons.push("path segment ends with '.'");
+  // Residual character check — LAST, and it names the first offender instead of shrugging. Characters
+  // already explained by the whitespace/markdown rules are skipped so one defect gets one reason.
+  const scanned = path.startsWith('~') ? path.slice(1) : path;
+  const illegal = [...scanned].find((c) => !LEGAL_TARGET_CHAR_RE.test(c) && !/\s/.test(c) && !MARKDOWN_RESIDUE_RE.test(c));
+  if (illegal !== undefined) reasons.push(`illegal character '${illegal}'`);
+  // The leading stem: a dot must be followed by a REAL name (`.-` has an empty stem), and any other
+  // path must start with a word character, '@' or '.'. Suppressed where a structural rule above
+  // already explains the first character, so the operator is never handed a reason that is false.
+  else if (!/^\.?[\w@]/.test(path) && !path.startsWith('/') && !path.startsWith('~') && !anchoredHere && !dotDot && !degenerate) {
+    reasons.push(path.startsWith('.') ? 'empty stem after the leading dot' : "path does not start with a letter, digit, '_', '@' or '.'");
+  }
+  return reasons;
+}
+
 // 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');
@@ -121,11 +254,7 @@ else {
   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');
+    const reasons = classifyTargetPath(path);
     if (reasons.length) failures.push(`C3: target line rejected: "${safe(ln)}" — ${reasons.join(', ')}`);
   }
 }
@@ -152,7 +281,15 @@ if (acidArg) {
   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');
+// ABSENT INPUT is not a deliberate skip. Until 2026-08-21 both read the same: `SKIP C4`. The owner
+  // asked why the tier is recorded nowhere, and the answer was that Step 0 never writes
+  // 00_complexity_assessment.md at all (MEASURED: 66 of 199 features have it; the last four in a row
+  // did not) — so the acid check quietly switched itself off for every one of them, including the
+  // features that INTRODUCED it. A check that could not read its input must not look like a check that
+  // read its input and found nothing to do.
+  if (acidTokens.length === 0 && !acidArg && !existsSync(complexityPath)) {
+    warnings.push('C4: 00_complexity_assessment.md is ABSENT — the acid-naming check had no input to read (a missing Step-0 artifact, not a clean skip)');
+  } else 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