valent-pipeline 0.19.53 → 0.19.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valent-pipeline",
-  "version": "0.19.53",
+  "version": "0.19.54",
   "description": "v3 multi-agent AI pipeline for software development lifecycle",
   "type": "module",
   "bin": {

package/pipeline/orchestrators/claude-code/sprint.workflow.js

@@ -2076,6 +2076,25 @@ async function runStory(story) {
     if (has('uxa')) {
       await spawn('UXA', 'uxa.md', 'Translate the brief into uxa-spec.md.', { phase: 'Spec' })
     }
+    // Fix D (rework-reduction, 2026-06-24): QA-A proves its acceptance suite is honestly RED BEFORE
+    // handoff, instead of the RED gate discovering a premature-pass a cycle later — after the dev
+    // fan-out is already staged (the 2.29 class: 10 cycles, an escalation, a build break, zero
+    // implementation burned). The lever mirrors the dev pre-handoff self-gate (Fix #3): thread the
+    // SAME acceptance command the RED gate will run into QA-A's authoring turn so it self-checks in
+    // context. Deliberately the RAW command (not the `evidence run` wrapper) — QA-A only needs to
+    // OBSERVE pass/fail, and minting a labeled `acceptance` assert here would shadow the baseline the
+    // RED/green/evidence gates freeze against. The RED gate stays the mechanical backstop. atddEnabled
+    // + args only => journal-replay safe.
+    const qaaRedSelfCheck = atddEnabled
+      ? ` Then prove the suite is honestly RED before handoff (Fix D — shift-left the RED gate): run ` +
+        `\`${subCmd(atddCommandTpl, storyId, effectiveWorkspaces)}\` against the current (unimplemented) tree. ` +
+        `Every \`required: true\` case MUST run and FAIL for a behavioral reason (404 / empty / missing element) — ` +
+        `exactly what the RED gate will demand. A required case that PASSES now is a premature-pass spec bug: ` +
+        `re-target it to assert a NEW endpoint/element this story has not built yet, or — if it only guards an ` +
+        `already-established infrastructure invariant — mark it \`required: false\` ` +
+        `(steps/qa-a/write-acceptance-tests.md Step C), never weakening or deleting the guard. Fix every ` +
+        `premature-pass before handoff so the RED gate passes first-try.`
+      : ''
     await spawn('QA-A', 'qa-a.md',
       'Produce qa-test-spec.md before any code is written.' +
         (atddEnabled
@@ -2083,7 +2102,7 @@ async function runStory(story) {
             `under ${atddDir}/${storyId}/ — one+ per AC, TC id in the test title, black-box against the running system, ` +
             `no mocks — plus the manifest kind:"acceptance"/testFile/files[] fields. The prose spec is companion notes. ` +
             `Then self-attack your tests (steps/qa-a/self-attack.md) and fix what you find before handoff.`
-          : ''),
+          : '') + qaaRedSelfCheck,
       { phase: 'Spec' })
 
     phase('SpecCheck')

package/pipeline/steps/qa-a/self-attack.md

@@ -12,3 +12,15 @@ Probe each acceptance case as the laziest implementer who wants green with minim
 - **Implementation sniffing (ATDD):** the dev can read your tests. Avoid magic fixture values an implementation could special-case; randomize or parameterize identifying data where cheap. (CRITIC's acceptance pass audits the implementation side of this.)
 
 Rate residual gameability **low | medium | high** per AC. HIGH means you have not finished — strengthen the test and re-rate. Record the final ratings + what you hardened in `qa-test-spec.md#self-attack` so CRITIC and JUDGE see what was already attacked.
+
+## Prove the suite is RED before handoff (ATDD)
+
+This is the mechanical close-out, run AFTER the gameability pass above. The orchestrator hands you the exact acceptance command to run — execute it against the current, **unimplemented** tree and read the result:
+
+- **Every `required: true` case MUST run and FAIL for a behavioral reason** — a 404, an empty/absent response, a missing element. That is precisely what the RED gate checks a cycle later; proving it here means the gate passes first-try instead of bouncing your spec back after the dev fan-out is already staged.
+- **A `required: true` case that PASSES now is a premature-pass spec bug.** It does not assert anything this story builds — it asserts behavior that already exists. Two fixes, both before handoff:
+  - **Re-target it** so it asserts a NEW endpoint/element/field this story has not built yet (e.g. route the assertion through a new path that 404s until implemented). This is the right fix when the case is meant to prove new behavior.
+  - **Or mark it `required: false`** (write-acceptance-tests.md Step C) when it only guards an already-established infrastructure invariant — still executed and asserted at the GREEN gate, but exempt from the red-required set. **Never weaken or delete the guard** — just make red honest.
+- A required case that **errors for a non-behavioral reason** (import failure, harness misconfig, syntax) is not honest red either — fix the test so it fails *because the feature is absent*, not because it cannot run.
+
+Do not hand off while any `required: true` case passes against the unimplemented tree. The RED gate will dead-end the story if you do; catching it here costs one self-run instead of a full round-trip.