valent-pipeline 0.19.52 → 0.19.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valent-pipeline",
-  "version": "0.19.52",
+  "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')
@@ -2115,10 +2134,21 @@ async function runStory(story) {
   // the round-trip cost and the rework-cycle count. Same preCriticChecks the gate runs; the
   // skip-waiver / spec-conformance rules are always named. Static + args only => journal-replay safe.
   const preHandoffStaticCmds = preCriticChecks.map((c) => subCmd(c, storyId, effectiveWorkspaces))
-  const preHandoffNote = (preHandoffStaticCmds.length || specConformanceEnabled || traceCheckEnabled)
+  // Fix #3 (rework-reduction, 2026-06-24): the pre-CRITIC gate ALSO runs spec-conformance + trace check
+  // (runPreCriticGate below), but the dev was only TOLD the rules, never handed the commands to run them.
+  // The field's `rework after static` round-trips were test files with a dropped assertion target / a
+  // missing AC trace-id / a mis-placed waiver — all catchable by running these two CLIs in the build turn.
+  // Thread the SAME commands the gate runs into the self-gate so the dev catches them in-context (no
+  // re-spawn). Static + args only => journal-replay safe.
+  const preHandoffSpecCmds = [
+    ...(specConformanceEnabled ? [`node .valent-pipeline/bin/cli.js check-spec-conformance --story ${storyId}`] : []),
+    ...(traceCheckEnabled ? [`node .valent-pipeline/bin/cli.js trace check --story ${storyId}`] : []),
+  ]
+  const preHandoffNote = (preHandoffStaticCmds.length || preHandoffSpecCmds.length)
     ? '\n\n## Definition of done — run these BEFORE you write your handoff\n' +
       'The deterministic pre-CRITIC gate runs the moment you hand off; a failure costs a full rework cycle (a re-spawn). Pass them first-try:\n' +
       preHandoffStaticCmds.map((c) => `  - \`${c}\` — must exit 0 (lint / type / static).\n`).join('') +
+      preHandoffSpecCmds.map((c) => `  - \`${c}\` — must exit 0 (spec-conformance / trace: catches a dropped assertion target, an omitted spec\'d case, a missing AC trace-id, or an un-waived skip BEFORE the gate round-trips you).\n`).join('') +
       '  - Every deliberately skipped or pending test MUST carry an inline `// valent-waiver: <reason>` (on the skip line or in the test name) — an un-waived skip is rejected by the spec-conformance check.\n' +
       '  - Do NOT drop a spec\'d assertion target or omit a spec\'d case to make a suite pass.\n' +
       'Run them locally, fix EVERYTHING they flag, and only then write your handoff — this is part of the build, not the gate\'s job to find for you.'

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.