valent-pipeline 0.19.21 → 0.19.22

package/package.json

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

package/src/lib/crosscheck.js

@@ -55,11 +55,25 @@ export function crosscheckVerdict({ reported = null, bugsBlock = null, assertVer
   }
 
   const claim = (field) => reported && reported[field] !== undefined && reported[field] !== null;
+  // Counts of BAD things (failures, open blocking bugs): a self-report HIGHER than the machine
+  // recount is the SAFE, conservative direction — the gate was harder on itself than reality (e.g. a
+  // JUDGE that counted a pre-existing, baseline-excluded failure as testsFailed/openP1toP3). That is
+  // NOT the integrity breach this module exists to catch — a gate HIDING failures/bugs to sneak a
+  // ship is claimed < actual — and refusing it stranded genuinely shippable stories. So an
+  // over-report on these fields reconciles to the authoritative recount with a warning; an
+  // under-report stays a hard mismatch. (Prompt tightening alone did not hold — the LLM still
+  // over-counts; this is the mechanical backstop.) Good-thing counts (testsPassed) and exact-match
+  // fields keep strict equality, where over-claiming IS the unsafe direction.
+  const SAFE_IF_OVER_REPORTED = new Set(['testsFailed', 'openP1toP3']);
   const compare = (field, actual) => {
     recounted[field] = actual;
-    if (claim(field) && reported[field] !== actual) {
-      mismatches.push({ field, claimed: reported[field], actual });
+    if (!claim(field) || reported[field] === actual) return;
+    if (SAFE_IF_OVER_REPORTED.has(field) && typeof reported[field] === 'number'
+        && typeof actual === 'number' && reported[field] > actual) {
+      warnings.push(`${field}: self-reported ${reported[field]} but artifacts show ${actual} — over-report (safe, conservative direction), reconciled to the recount`);
+      return;
     }
+    mismatches.push({ field, claimed: reported[field], actual });
   };
 
   // Test counts — from the assert verdict (machine-derived twice over).

package/src/lib/git-flow.js

@@ -402,7 +402,19 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
     snapshotSha = snap.sha || null;
   }
 
-  const target = targetBranch || onBranch;
+  // An inline fix (--from-story) inherits its SOURCE story's recorded target — NOT the
+  // currently-checked-out branch. Running several fixes for one story back-to-back leaves HEAD on the
+  // previous fix's branch; defaulting `target` to onBranch made each later fix target (and, via the
+  // base check below, base on) its SIBLING fix branch — so the fixes silently chained onto the first
+  // fix's branch instead of the story, stranded off the real target (2026-06-14). An explicit
+  // --target still wins; onBranch stays the fallback for a plain story or a fix whose source has no
+  // flow record yet. With the right target, the base check (`!isMergedInto(source, target)`) also
+  // resolves correctly — the source story is unmerged into the REAL target, so the fix bases on it.
+  let inheritedTarget = null;
+  if (fromStory && !targetBranch) {
+    inheritedTarget = readFlowRecord(root, fromStory)?.target || null;
+  }
+  const target = targetBranch || inheritedTarget || onBranch;
   let base = target;
   let basedOnStory = false;
   if (fromStory) {