@dzhechkov/skills-feature-adr 1.3.59 → 1.3.60

package/README.md

@@ -44,7 +44,7 @@ After installation, open Claude Code in your project directory and use `/feature
 | Component | Count | Description |
 |-----------|-------|-------------|
 | **Skill** | 1 | `feature-adr` — 11-step pipeline with complexity routing |
-| **Modules** | 11 | Steps 00-09 + 03.5: Router → Requirements → Research → ADR → QCSD → DDD → Architecture → Plan → Code → QE → Fleet QE |
+| **Modules** | 12 | Steps 00-09 + 03.5 + opt-in 10: Router → Requirements → Research → ADR → QCSD → DDD → Architecture → Plan → Code → QE → Fleet QE → Delivery Gate (opt-in) |
 | **References** | 4+15 | Complexity matrix, ADR/C4/QE templates + 15 agentic-qe skill protocols |
 | **Examples** | 1 | Sample M-tier feature output |
 | **Command** | 1 | `/feature-adr` — orchestrator (supports `--full-qe` and `--full-qe-extended`) |
@@ -503,6 +503,26 @@ gate > reviewer judgment > memory). A miss usually means a check lived one layer
 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.
 
+### Step 10 — Delivery Gate (opt-in, v1.3.60)
+
+Step 8 reviews the code as the coder's counterpart; **Step 10 reviews the feature as a PUBLISHED entity** —
+the landed diff, its docs, its claims. Four orthogonal planes run in parallel on the **cross-family of the
+coder** (regressions ‖ security ‖ code-quality ‖ **product-honesty** — the plane Step 8 lacks: fabricated
+completeness, features that do less than their description, misleading degradation text), every BLOCKER/HIGH
+is cross-validated **by index**, and the result is a machine-checkable hand-off verdict in
+`10_delivery_review.md` (`ready` ⇔ 0 BLOCKER + 0 unwaived HIGH).
+
+```js
+Workflow({ scriptPath: '.claude/workflows/feature-adr.js',
+  args: { slug, description, tier: 'L', deliveryGate: true } })   // or models: { delivery: 'codex:gpt-5.5:high' }
+```
+
+Extensibility guarantees (deliberate): **strictly opt-in** — no `deliveryGate`/`models.delivery` ⇒
+byte-identical, zero agents, no artifact; **zero VCS-host specifics** — no merge-request/CI API calls; an
+MR-flow project's extra criteria (`CI terminal`, `draft→ready`) are document rows the owner fills;
+**advisory** — `hand-off: blocked` is a report, nothing auto-aborts, findings are NEVER auto-posted
+anywhere. Promise tag `FEATURE_ADR_DELIVERY_GATED`; the `🚦 Gates:` line gains `delivery ready|blocked|n/a`.
+
 ### The `Model` / `Fable?` columns — read this before swapping models
 
 The `Model` column is the **default recommendation, fully overridable** — the routing rule is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.3.59",
+  "version": "1.3.60",
   "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"
@@ -13,10 +13,6 @@
     "CHANGELOG.md",
     "docs/"
   ],
-  "scripts": {
-    "test": "node --test \"test/**/*.test.js\"",
-    "prepack": "node -e \"const fs=require('fs');const bad=['.claude','.skills-feature-adr.json'].filter(p=>fs.existsSync(p));if(bad.length){console.error('prepack guard: stray init artifacts in package dir: '+bad.join(', ')+' — remove before packing');process.exit(1)}\""
-  },
   "keywords": [
     "claude",
     "claude-code",
@@ -61,5 +57,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "test": "node --test \"test/**/*.test.js\""
   }
-}
+}

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

@@ -53,7 +53,8 @@ Trigger on:
 │   ├── 06-implementation-plan.md      ← Step 6: SPARC-GOAP planning (enhanced)
 │   ├── 07-code.md                     ← Step 7: Code generation
 │   ├── 08-qe.md                       ← Step 8: QE + brutal-honesty review (enhanced)
-│   └── 09-fleet-qe.md                 ← Step 9: Fleet QE assessment (NEW)
+│   ├── 09-fleet-qe.md                 ← Step 9: Fleet QE assessment (NEW)
+│   └── 10-delivery-gate.md            ← Step 10: Delivery Gate (opt-in, post-implementation)
 ├── references/
 │   ├── complexity-matrix.md           ← S/M/L/XL criteria & step activation
 │   ├── adr-template.md                ← ADR document template
@@ -140,6 +141,7 @@ Step                         | S | M | L | XL | Model  | Agentic QE Skill
 7  Code                      | ✓ | ✓ | ✓ | ✓  | opus   | —                      |
 8  QE + Brutal Honesty       | ✓ | ✓ | ✓ | ✓  | sonnet | brutal-honesty-review  |
 9  Fleet QE Assessment       | - | - | ✓ | ✓  | sonnet | qe-req-val + risk-based + integration + regression + coverage |
+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) |
 ```
 
 ## DAG Dependencies
@@ -271,6 +273,7 @@ features/<feature-slug>/
 | Step 7 | `<promise>FEATURE_ADR_IMPLEMENTED</promise>` |
 | Step 8 | `<promise>FEATURE_ADR_VERIFIED</promise>` |
 | Step 9 | `<promise>FEATURE_ADR_FLEET_VERIFIED</promise>` |
+| Step 10 (opt-in) | `<promise>FEATURE_ADR_DELIVERY_GATED</promise>` |
 
 ## External Skills (loaded as needed)
 
@@ -589,7 +592,7 @@ npx @dzhechkov/skills-feature-adr init --with-learning --knowledge-extractor
 <promise>[PROMISE_TAG]</promise>
 Tier: {COMPLEXITY_TIER} | Active Steps: {ACTIVE_STEPS}
 🎓 Learning: {recalled} patterns recalled for this feature, {stored} new stored this run
-🚦 Gates: challenge-panel ✓ · claim-check ✓ · discrimination not-run · amendments ✓ · fleet —
+🚦 Gates: challenge-panel ✓ · claim-check ✓ · discrimination not-run · amendments ✓ · fleet — · delivery n/a
 
 [2-3 line summary]
 Artifacts: [list] ✅

package/templates/.claude/skills/feature-adr/modules/10-delivery-gate.md

@@ -0,0 +1,63 @@
+# Step 10: Delivery Gate (opt-in) — review the feature as a PUBLISHED ENTITY
+
+> **Opt-in.** This step runs only when explicitly requested (the user asks for a delivery gate, or the
+> workflow form receives `args.deliveryGate: true` / `args.models.delivery`). Absent ⇒ the pipeline is
+> byte-identical to a run without Step 10 — no agents, no artifact.
+
+## Why a separate step (not more Step-8)
+
+Step 8 reviews the code as the coder's counterpart — pre-hand-off, working-tree view. Step 10 reviews the
+feature as a **published entity**: the landed diff, its docs and claims, its behavior as a consumer will
+meet it. Its distinctive plane — **product honesty** — is absent from Step 8 entirely: fabricated
+completeness (output presented as complete when a source was unavailable), a feature that does less than
+its description, misleading user-facing text. Origin: a real incident where a 2-agent fresh-eyes pass said
+SHIP and only the full multi-plane review found the fabricated-completeness and cap-violation defects.
+
+## Protocol
+
+### 1. Four orthogonal planes (parallel, cross-family of the coder)
+
+Each plane reads `07_code_changes/change_manifest.md` + the actual changed files (+ `git diff` for anything
+uncommitted), calibrating on `architecture/vision.md` / `architecture/degradations.md` **when present** (an
+accepted degradation is NOT a finding) and staying generic when absent:
+
+| Plane | Hunts |
+|---|---|
+| **Regressions** | broken consumers/contracts; NEW I/O on previously-pure startup/lifespan/health paths without a negative resource-down test; removed/weakened tests (fixture-swap); silent semantic changes to shared surfaces |
+| **Security** | injection via interpolated paths/refs/commands; secrets in code/artifacts; path traversal/symlink escapes; fail-open where the contract says fail-closed |
+| **Code quality** | god-object growth; parallel implementations vs the reuse map; structurally-dead safeguards; swallowed errors |
+| **Product honesty + common sense** | claims not backed by behavior; fabricated completeness; docs/READMEs promising more than the code does; misleading degradation/limits text |
+
+Findings shape: `{severity: BLOCKER|HIGH|MED|LOW, title, where (file:line), why}` — confirmed only.
+
+### 2. Cross-validation (BLOCKER/HIGH, by index)
+
+Every BLOCKER/HIGH is independently cross-validated by a second agent, matched **positionally by index —
+never by title** (duplicate titles cross-contaminate). Default-to-FP when uncertain. A validator outage
+surfaces the findings **UNVALIDATED** — never silently dropped, never silently confirmed.
+
+### 3. Machine-checkable hand-off criterion
+
+Write `features/<slug>/10_delivery_review.md`:
+- **## Verdict** — `hand-off: ready | blocked` (ready ⇔ 0 BLOCKER and 0 unwaived HIGH, cross-validation complete)
+- **## Findings** — table: severity | plane | title | where | why | crossValidated
+- **## Hand-off criterion** — machine-checkable rows: `0 BLOCKER: PASS/FAIL(n)`, `0 unwaived HIGH: PASS/FAIL(n)`.
+  Projects with a merge-request flow add THEIR OWN rows here (`CI terminal: …`, `draft→ready: …`) — these are
+  **document rows the owner fills**, never API calls made by the pipeline. No merge-request flow ⇒ the rows
+  stay `—`.
+- **## Note** — ADVISORY: the owner decides; nothing auto-aborts.
+
+### Hard rules
+
+1. **Findings only.** Step 10 NEVER posts to a VCS host, tracker, or any external service. Publishing a
+   review anywhere is a separate, explicit user instruction.
+2. **Advisory.** `hand-off: blocked` is a report, not an abort (a false gate kills trust).
+3. **Cross-family.** The planes run on the other model family than the coder (the Step-8 rule) — a model
+   must not deliver-gate its own code.
+4. **Cost control.** One gate per hand-off, not per commit. A stack of related changes gets one Step-10 pass
+   on the combined diff.
+
+## Promise tag
+
+`<promise>FEATURE_ADR_DELIVERY_GATED</promise>` — and the `🚦 Gates:` line gains `delivery ready|blocked`
+(derived from the review doc's Verdict, `n/a` when the gate was not requested).

package/templates/.claude/workflows/feature-adr.js

@@ -8,6 +8,7 @@ export const meta = {
     { title: 'Plan', detail: 'Step 6 - SPARC-GOAP plan' },
     { title: 'Code', detail: 'Step 7 - implement per plan+ADR' },
     { title: 'QE', detail: 'Step 8 - brutal-honesty (agentic-qe) + teach' },
+    { title: 'Delivery', detail: 'Step 10 - delivery gate: 4-plane review of the landed feature (opt-in)' },
     { title: 'FleetQE', detail: 'Step 9 - traceability/coverage (L/XL)' },
   ],
 }
@@ -957,6 +958,74 @@ if (isLplus) {
   fleet = 'run'
 }
 
+// ── Step 10 (OPT-IN): Delivery Gate — post-implementation full review of the LANDED feature ──
+// P1 of fa-improvements, adapted to dz: Step 8 reviews the code as the coder's counterpart; Step 10 reviews
+// the feature as a PUBLISHED ENTITY across 4 orthogonal planes (regressions ‖ security ‖ code-quality ‖
+// product-honesty — the plane Step-8 lacks entirely), then cross-validates BLOCKER/HIGH positionally (the
+// challenge-panel lesson) and emits a MACHINE-CHECKABLE hand-off verdict. EXTENSIBILITY GUARANTEES: strictly
+// opt-in (`args.deliveryGate: true` or `args.models.delivery` — absent ⇒ byte-identical, zero agents, no
+// artifact); ZERO VCS-host specifics (no MR/undraft/CI API calls — an MR-flow project's extra criteria are
+// documented rows the orchestrator fills, not code); planes calibrate on architecture/vision.md when present,
+// generic otherwise (the R5 pattern). ADVISORY: `handoff: blocked` is a report — nothing auto-aborts, and
+// findings are NEVER auto-posted anywhere (findings-only hard rule).
+const DELIVERY_ON = A.deliveryGate === true || !!(A.models && typeof A.models === 'object' && A.models.delivery)
+let delivery = null
+if (DELIVERY_ON) {
+  try {
+    phase('Delivery')
+    await usageProbe('Delivery')
+    // Planes run on the CROSS-FAMILY of the coder (the same load-bearing rule as Step-8 QE): an explicit
+    // args.models.delivery wins; else mirror the qe resolution (which already derives the other family).
+    const dModel = (A.models && A.models.delivery) ? resolveStageModel('delivery') : resolveStageModel('qe')
+    modelsUsed.delivery = modelLabel(mergeOpts({}, dModel))
+    const DELIVERY_SCHEMA = { type: 'object', additionalProperties: false, required: ['findings'], properties: { findings: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['severity', 'title', 'where', 'why'], properties: { severity: { type: 'string' }, title: { type: 'string' }, where: { type: 'string' }, why: { type: 'string' } } } } } }
+    const D_SEVS = new Set(['BLOCKER', 'HIGH', 'MED', 'LOW'])
+    const dBase = 'You are a Step-10 Delivery Gate reviewer for the LANDED feature "' + DESC + '" (' + SLUG + ', repo ' + REPO + '). Review the feature as a PUBLISHED ENTITY: read ' + FDIR + '/07_code_changes/change_manifest.md and the actual changed files (plus `git status`/`git diff` for anything uncommitted). Calibrate on architecture/vision.md + architecture/degradations.md when they exist (an accepted degradation is NOT a finding); stay generic when they do not. Report ONLY confirmed findings as {severity: BLOCKER|HIGH|MED|LOW, title, where (file:line), why}. FINDINGS ONLY — do NOT post to any VCS host, tracker, or external service. '
+    const planePrompts = [
+      ['regressions', 'PLANE 1 — REGRESSIONS: behavior changes that break existing consumers/contracts; NEW I/O added to previously-pure startup/lifespan/health paths without a negative resource-down test; removed/weakened tests (fixture-swap); silent semantic changes to shared surfaces.'],
+      ['security', 'PLANE 2 — SECURITY: injection via interpolated paths/refs/commands; secrets in code/lessons/artifacts; key custody; path traversal/symlink escapes; fail-open where the contract says fail-closed.'],
+      ['code-quality', 'PLANE 3 — CODE QUALITY: god-object growth, duplicated parallel implementations vs the reuse map, dead/unreachable safeguards (code paths that can never fire), error handling that swallows, complexity without a named reason.'],
+      ['product-honesty', 'PLANE 4 — PRODUCT HONESTY + COMMON SENSE (the plane Step-8 lacks): claims in docs/READMEs/reports not backed by behavior; FABRICATED COMPLETENESS (output presented as complete when a source was unavailable); a feature that does less than its description; user-facing text that misleads about limits or degradation.'],
+    ]
+    const planeThunks = planePrompts.map(([pl, focus]) => () => agent(dBase + focus + ' Return the findings object.' + codexEffortHint(dModel), mergeOpts({ label: stageLabel('delivery:' + pl, dModel), phase: 'Delivery', schema: DELIVERY_SCHEMA }, dModel)))
+    const planeResults = await parallel(planeThunks)
+    const all = []
+    planeResults.forEach((r, pi) => {
+      const fs = (r && Array.isArray(r.findings)) ? r.findings : []
+      for (const f of fs) { if (f && typeof f === 'object' && D_SEVS.has(String(f.severity)) && typeof f.title === 'string' && f.title !== '') all.push({ plane: planePrompts[pi][0], severity: String(f.severity), title: f.title, where: String(f.where || ''), why: String(f.why || '') }) }
+    })
+    // Cross-validate BLOCKER/HIGH by INDEX (never title). Validator outage ⇒ surface UNVALIDATED, never drop.
+    const dRank = { BLOCKER: 4, HIGH: 3, MED: 2, LOW: 1 }
+    const bh = all.filter((f) => f.severity === 'BLOCKER' || f.severity === 'HIGH').sort((a, b) => (dRank[b.severity] - dRank[a.severity]) || (a.plane < b.plane ? -1 : 1))
+    let confirmed = all.filter((f) => f.severity === 'MED' || f.severity === 'LOW')
+    let dStatus = 'ok'
+    if (bh.length > 0) {
+      const numbered = bh.map((f, i) => ({ i: i, plane: f.plane, severity: f.severity, title: f.title, where: f.where, why: f.why }))
+      const CV_SCHEMA = { type: 'object', additionalProperties: false, required: ['results'], properties: { results: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['i', 'real'], properties: { i: { type: 'number' }, real: { type: 'boolean' } } } } } }
+      const cv = await agent('Independently CROSS-VALIDATE these delivery-gate findings against the ACTUAL code in repo ' + REPO + ' (read the files). For EACH by its "i" index decide real (reachable, evidenced) vs FP/theory; default real=false when uncertain. Findings: ' + JSON.stringify(numbered), mergeOpts({ label: stageLabel('delivery:cross-validate', dModel), phase: 'Delivery', schema: CV_SCHEMA }, dModel))
+      const realByIndex = new Map((cv && Array.isArray(cv.results) ? cv.results : []).map((r) => [Number(r.i), r.real === true]))
+      if (!bh.every((_, i) => realByIndex.has(i))) {
+        dStatus = 'cross-validation-incomplete'
+        log('Delivery gate: cross-validator did not cover every BLOCKER/HIGH — surfacing them UNVALIDATED (not dropped)')
+        for (const f of bh) confirmed.push(Object.assign({}, f, { crossValidated: false, unvalidated: true }))
+      } else {
+        bh.forEach((f, i) => { if (realByIndex.get(i) === true) confirmed.push(Object.assign({}, f, { crossValidated: true })) })
+      }
+    }
+    confirmed.sort((a, b) => (dRank[b.severity] - dRank[a.severity]) || (a.plane < b.plane ? -1 : 1))
+    const blockers = confirmed.filter((f) => f.severity === 'BLOCKER').length
+    const highs = confirmed.filter((f) => f.severity === 'HIGH').length
+    const handoff = (dStatus === 'ok' && blockers === 0 && highs === 0) ? 'ready' : 'blocked'
+    // Consolidation (cheap): write the review artifact incl. the machine-checkable hand-off criterion. The
+    // MR-flow rows (CI terminal, draft→ready) are DOCUMENT rows the orchestrator/owner fills — never API calls.
+    await agent('Write ' + FDIR + '/10_delivery_review.md consolidating this Step-10 Delivery Gate result (do not re-review): status=' + dStatus + ', hand-off=' + handoff + ', findings JSON: ' + JSON.stringify(confirmed) + '. Structure: ## Verdict (hand-off: ' + handoff + '), ## Findings (a table: severity | plane | title | where | why | crossValidated), ## Hand-off criterion (machine-checkable rows: "0 BLOCKER: ' + (blockers === 0 ? 'PASS' : 'FAIL (' + blockers + ')') + '", "0 unwaived HIGH: ' + (highs === 0 ? 'PASS' : 'FAIL (' + highs + ')') + '", plus rows the owner fills ONLY if an MR flow exists: "CI terminal: —", "draft→ready: —"), ## Note (ADVISORY — findings only; nothing was posted anywhere; the owner decides).', { label: 'delivery:consolidate', phase: 'Delivery', effort: 'low' })
+    delivery = { handoff: handoff, status: dStatus, blockers: blockers, highs: highs, findings: confirmed }
+  } catch (e) {
+    log('Delivery gate errored (advisory, ignored): ' + (e && e.message ? e.message : String(e)))
+    delivery = { handoff: 'errored', status: 'error', blockers: 0, highs: 0, findings: [] }
+  }
+}
+
 // R1 product-architecture-lens (FR-3): refresh architecture/map.json at the END of a COMPLETE run so the
 // NEXT feature's Step-0 сверка sees what this run added. Best-effort, non-blocking. (Not reached on the
 // L/XL checkpoint-after-plan return above — no code has landed there yet.)
@@ -964,6 +1033,7 @@ await agent('Run EXACTLY this one shell command via your Bash tool and report it
 
 const tags = ['FEATURE_ADR_ROUTED', 'FEATURE_ADR_DESIGNED', 'FEATURE_ADR_PLANNED', 'FEATURE_ADR_IMPLEMENTED', 'FEATURE_ADR_VERIFIED']
 if (isLplus) tags.push('FEATURE_ADR_FLEET_VERIFIED')
+if (delivery) tags.push('FEATURE_ADR_DELIVERY_GATED')
 return {
   slug: SLUG, tier: tier, mode: MODE, artifactsDir: FDIR,
   design: design.filter(Boolean).map((d) => d.wrote).flat(),
@@ -991,6 +1061,8 @@ return {
     qe: (qe ? (qe.grade || 'ran') : 'not-run'),
     claimCheck: (qe && qe.claimCheck ? (qe.claimCheck.high > 0 ? 'high-findings' : 'clean') : 'not-run'),
     fleet: (isLplus ? (fleet ? 'ran' : 'not-run') : 'n/a'),
+    delivery: (DELIVERY_ON ? (delivery ? delivery.handoff : 'errored') : 'n/a'),
   },
+  delivery: delivery,
   promiseTags: tags,
 }