valent-pipeline 0.19.29 → 0.19.31

package/package.json

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

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);
 

package/src/lib/sprint.js

@@ -154,14 +154,21 @@ export function packSprint(stories, velocity, opts = {}) {
   const groomed = stories.filter((s) => (!scope || scope.has(s.id)) && isExecReady(s) && bugsResolvable(s));
   const byId = new Map(groomed.map((s) => [s.id, s]));
 
-  // Out-of-batch prerequisite check (review 2026-06-10 #20): a depends_on that is not packable
-  // this sprint clears only if it already landed (or is absent from the file — pre-backlog work);
-  // a pending/stranded/blocked prerequisite withholds the dependent.
-  const outOfBatchDepsSatisfied = (story) => depsOf(story).every((depId) => {
-    if (byId.has(depId)) return true; // packable this sprint — sequenced before the story below
-    const known = byIdAll.get(depId);
-    return !known || satisfied.has(known.status);
-  });
+  // Out-of-batch prerequisite check (review 2026-06-10 #20), now TRANSITIVE (HARNESS-GAPS 2026-06-18
+  // Gap 3): a depends_on clears only if it already landed (or is absent — pre-backlog work), OR is
+  // packable this sprint AND its OWN dependency chain likewise clears. Checking only DIRECT deps let
+  // an in-sprint dep whose prerequisite is unshipped slip in as a velocity-filler, building against
+  // unbuilt code — `resolveEligibleStories` already requires the WHOLE chain to be live; the packer
+  // must agree or the two disagree about what runs.
+  const outOfBatchDepsSatisfied = (story, seen = new Set()) => {
+    if (seen.has(story.id)) return true; // cycle guard — a dependency cycle is a backlog error, not the packer's to resolve
+    seen.add(story.id);
+    return depsOf(story).every((depId) => {
+      if (byId.has(depId)) return outOfBatchDepsSatisfied(byId.get(depId), seen); // in-sprint dep — its chain must hold too
+      const known = byIdAll.get(depId);
+      return !known || satisfied.has(known.status);
+    });
+  };
 
   const byPriority = [...groomed].sort(
     (a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity),