valent-pipeline 0.19.30 → 0.19.32

package/package.json

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

package/src/commands/evidence.js

@@ -16,7 +16,7 @@ import { dirname, join, isAbsolute } from 'path';
 import { randomBytes } from 'crypto';
 import { parse as parseYaml } from 'yaml';
 import {
-  runEvidence, pinGate, formatRunTrailer, formatRunDigest, resolveRoot, evidenceDir, latestRun, latestPins,
+  runEvidence, pinGate, formatRunTrailer, formatRunDigest, resolveRoot, evidenceDir, latestRun, resolveRunForAssert, latestPins,
   verifyIntegrity, assertRules, assertRedRules, pinSourceDelta, snapshotFiles, buildProof, utcCompact,
   latestAssert, collectFailingCases, authenticateBaseline, verifyShipEvidence, sha256Hex,
   validStoryId, recordStageResults,
@@ -180,6 +180,18 @@ export async function evidenceAssertCmd(options) {
     process.exit(2);
   }
 
+  // Required acceptance case ids, read early so the run resolver can bind to the suite that actually
+  // carries them when a project multiplexes suites under one label (HARNESS-GAPS 2026-06-18 Gap 2).
+  // The full manifest is re-read below for the count/skips rules.
+  let requiredCaseIds = [];
+  try {
+    const mp = options.manifest ? abs(options.manifest) : join(root, 'stories', story, 'output', 'qa-test-spec.manifest.json');
+    if (existsSync(mp)) {
+      const m = JSON.parse(readFileSync(mp, 'utf-8'));
+      if (Array.isArray(m?.cases)) requiredCaseIds = m.cases.filter((c) => c?.kind === 'acceptance' && c?.required !== false && c?.id).map((c) => c.id);
+    }
+  } catch { requiredCaseIds = []; }
+
   // Resolve the run: explicit --run, else the newest run for the label. Green demands a report
   // (junit is the verdict's substance); red takes the newest run regardless — "no report at all"
   // is itself a red-gate input (the weak-red rule judges it).
@@ -195,8 +207,10 @@ export async function evidenceAssertCmd(options) {
     // No requireReport filter (review 2026-06-10 #5): a suite that crashes before emitting junit
     // produces the NEWEST run with no reports — filtering it out silently asserted the previous
     // (green, report-bearing) run instead. The newest run is always the one asserted; a report-less
-    // failing run now fails loudly via the green (zero cases) + run-integrity rules.
-    run = latestRun(evDir, { label });
+    // failing run now fails loudly via the green (zero cases) + run-integrity rules. resolveRunForAssert
+    // additionally binds to the same-SHA run carrying the required cases when suites multiplex one label
+    // (Gap 2), preserving the report-less-crash-wins-newest invariant.
+    run = resolveRunForAssert(evDir, { label, requiredCaseIds });
   }
   if (!run) {
     // --require-evidence (review 2026-06-10 #37): the graceful no-op exists for pre-evidence

package/src/lib/crosscheck.js

@@ -96,7 +96,26 @@ export function crosscheckVerdict({ reported = null, bugsBlock = null, assertVer
   // but do not block; they are counted separately so they stay visible).
   if (bugsBlock && Array.isArray(bugsBlock.bugs)) {
     const isPre = (b) => b.preExisting === true || b.category === 'pre-existing';
-    const open = bugsBlock.bugs.filter((b) => OPEN_STATUSES.has(b.status) && ['P1', 'P2', 'P3'].includes(b.priority));
+    // JUDGE severity-demotion auto-flow (HARNESS-GAPS 2026-06-18 Gap 1b; Matt 2026-06-18). JUDGE is the
+    // adjudication authority and may re-grade a bug (e.g. a test-only isolation bug P3->P4). When JUDGE
+    // EXPLICITLY carries a bug in its verdict at a LESS-blocking priority than bugs.md filed, the recount
+    // honors the adjudicated priority — the demotion is an explicit, audited decision (recorded in the
+    // verdict, the verdict-crosscheck.json, and the backlog carry). Safety is unchanged: only a CARRIED
+    // bug is re-graded, and only DOWNWARD; a bug JUDGE does not carry keeps its filed priority, so a
+    // SILENTLY-dropped open P1-P3 (the integrity breach this guards) still mismatches. A promotion is the
+    // safe over-report direction and is left as filed (the recount already tolerates JUDGE over-reporting).
+    const PRI_RANK = { P1: 1, P2: 2, P3: 3, P4: 4 };
+    const adjudicated = new Map(
+      (reported && Array.isArray(reported.bugs) ? reported.bugs : [])
+        .filter((b) => b && b.id && b.priority).map((b) => [b.id, b.priority]),
+    );
+    const effPriority = (b) => {
+      const adj = adjudicated.get(b.id);
+      return adj && (PRI_RANK[adj] ?? 99) > (PRI_RANK[b.priority] ?? 99) ? adj : b.priority;
+    };
+    const demotions = bugsBlock.bugs.filter((b) => effPriority(b) !== b.priority).map((b) => ({ id: b.id, from: b.priority, to: effPriority(b) }));
+    if (demotions.length) recounted.adjudicatedDemotions = demotions;
+    const open = bugsBlock.bugs.filter((b) => OPEN_STATUSES.has(b.status) && ['P1', 'P2', 'P3'].includes(effPriority(b)));
     recounted.preExistingOpen = open.filter(isPre).length;
     compare('openP1toP3', open.filter((b) => !isPre(b)).length);