valent-pipeline 0.19.32 → 0.19.34

package/package.json

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

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

@@ -2833,8 +2833,9 @@ async function runStory(story) {
     const evidenceNote = hasMachineEvidence
       ? `\n\nMACHINE EVIDENCE (authoritative): the deterministic Evidence gate already ran ` +
         `\`evidence assert\` + \`trace check\` (gate verdict: ${evGate.verdict}${evGate.escalated ? ', escalated after the rework cap' : ''}${evGate.advisory ? ', advisory' : ''}). ` +
-        `Read the NEWEST JSON under \`stories/${sid}/evidence/asserts/\`` +
-        `${evGate.verdictPath ? ` (the gate reported \`${evGate.verdictPath}\`)` : ''} and TRANSCRIBE testsPassed/testsFailed/openP1toP3 ` +
+        (evGate.verdictPath
+          ? `Read the assert JSON the Evidence gate VERIFIED — \`${evGate.verdictPath}\` — NOT merely the newest file under \`stories/${sid}/evidence/asserts/\` (a transient or mislabeled-label run can be newer and carry the wrong counts) — and TRANSCRIBE testsPassed/testsFailed/openP1toP3 `
+          : `Read the NEWEST green qa-b JSON under \`stories/${sid}/evidence/asserts/\` and TRANSCRIBE testsPassed/testsFailed/openP1toP3 `) +
         `from its counts (openP1toP3 = bugs in the \`valent:bugs\` block of bugs.md with status open/fix-in-progress AND priority P1/P2/P3, EXCLUDING any with \`preExisting: true\` or \`category: pre-existing\` — baselined pre-existing bugs are non-blocking and the cross-check counts them separately, so including them here produces a verdict-integrity mismatch and refuses the ship) — do NOT count from execution-report.md prose. ` +
         `Set evidenceVerdict to the assert verdict and gitSha to the evidence run's SHA. Your job on numbers is ANOMALY ` +
         `DETECTION: FLAG as a discrepancy any claim in execution-report.md / traceability-matrix.md / bugs.md that the ` +

package/src/lib/crosscheck.js

@@ -62,17 +62,31 @@ export function crosscheckVerdict({ reported = null, bugsBlock = null, assertVer
   // 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.
+  // over-counts; this is the mechanical backstop.)
+  //
+  // GOOD-thing counts (testsPassed) are the MIRROR IMAGE: the unsafe, ship-sneaking direction is
+  // OVER-claiming (padding green to look more passing than reality), so an over-claim stays a hard
+  // mismatch; an UNDER-report (claimed FEWER passes than the recount) is the safe direction — you
+  // cannot sneak a ship by under-stating passes, because the ship gates on the authoritative recount,
+  // not on this transcribed number — so it reconciles to the recount with a warning. This closes the
+  // JUDGE-verdict-path analogue of Gap 2 (label-multiplexing, 2026-06-18): a transcribed testsPassed
+  // bound to a transient/mislabeled qa-b run under-counts passes, which is harmless and must not
+  // refuse a ship the green assert already proved. Exact-match fields (verdict, reviewedSha) keep
+  // strict equality in both directions.
   const SAFE_IF_OVER_REPORTED = new Set(['testsFailed', 'openP1toP3']);
+  const SAFE_IF_UNDER_REPORTED = new Set(['testsPassed']);
   const compare = (field, actual) => {
     recounted[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) {
+    const numeric = typeof reported[field] === 'number' && typeof actual === 'number';
+    if (numeric && SAFE_IF_OVER_REPORTED.has(field) && reported[field] > actual) {
       warnings.push(`${field}: self-reported ${reported[field]} but artifacts show ${actual} — over-report (safe, conservative direction), reconciled to the recount`);
       return;
     }
+    if (numeric && SAFE_IF_UNDER_REPORTED.has(field) && reported[field] < actual) {
+      warnings.push(`${field}: self-reported ${reported[field]} but artifacts show ${actual} — under-report (safe direction: under-stating passes cannot sneak a ship), reconciled to the recount`);
+      return;
+    }
     mismatches.push({ field, claimed: reported[field], actual });
   };
 

package/src/lib/spec-conformance.js

@@ -66,10 +66,38 @@ export function isGatableToken(token) {
   return true;
 }
 
-/** Remove a trailing line-comment so a commented-out `// it.skip(...)` is not flagged as a skip. */
-function stripLineComment(line) {
-  const i = line.indexOf('//');
-  return i === -1 ? line : line.slice(0, i);
+/**
+ * Blank out JS/TS comments — both line and block comments — so a skip marker that appears only inside
+ * a comment (a commented-out `// it.skip(...)`, or an `it.skip` mentioned inside a JSDoc/block comment)
+ * is not mistaken for a real skip (HARNESS-GAPS 2026-06-18). Comment bytes become spaces; newlines and
+ * tabs are preserved so line numbers and the waiver line-window stay exact. String / template literals
+ * are tracked, so a comment-looking substring INSIDE a string is left intact — a real marker is never
+ * hidden (no false-negatives).
+ */
+export function stripComments(content) {
+  const s = String(content || '');
+  let out = '';
+  let state = 'code'; // code | line | block | sq | dq | tpl
+  const ws = (ch) => (ch === '\n' || ch === '\t' ? ch : ' ');
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    const d = s[i + 1];
+    if (state === 'code') {
+      if (c === '/' && d === '/') { state = 'line'; out += '  '; i++; continue; }
+      if (c === '/' && d === '*') { state = 'block'; out += '  '; i++; continue; }
+      if (c === "'") { state = 'sq'; out += c; continue; }
+      if (c === '"') { state = 'dq'; out += c; continue; }
+      if (c === '`') { state = 'tpl'; out += c; continue; }
+      out += c; continue;
+    }
+    if (state === 'line') { if (c === '\n') { state = 'code'; out += c; } else out += ws(c); continue; }
+    if (state === 'block') { if (c === '*' && d === '/') { state = 'code'; out += '  '; i++; } else out += ws(c); continue; }
+    // inside a string/template literal: copy verbatim, honor backslash escapes, close on the quote
+    out += c;
+    if (c === '\\') { out += (s[i + 1] ?? ''); i++; continue; }
+    if ((state === 'sq' && c === "'") || (state === 'dq' && c === '"') || (state === 'tpl' && c === '`')) state = 'code';
+  }
+  return out;
 }
 
 /**
@@ -81,14 +109,16 @@ function stripLineComment(line) {
  */
 function scanSkips(file) {
   const out = [];
-  const lines = (file.content || '').split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const raw = lines[i];
-    const code = stripLineComment(raw);
+  const raw = (file.content || '').split(/\r?\n/);
+  // Match skip markers in CODE only — comments (line `//` and block `/* */`) are blanked so a marker
+  // that merely appears inside a comment is not flagged. The waiver check still reads the RAW line,
+  // since the `valent-waiver:` token lives in a comment / the it.skip() title.
+  const code = stripComments(file.content || '').split(/\r?\n/);
+  for (let i = 0; i < raw.length; i++) {
     SKIP_MARKER.lastIndex = 0;
-    const m = code.match(SKIP_MARKER);
+    const m = (code[i] || '').match(SKIP_MARKER);
     if (!m) continue;
-    const waived = WAIVER_RE.test(raw) || lines.slice(Math.max(0, i - 3), i).some((l) => WAIVER_RE.test(l));
+    const waived = WAIVER_RE.test(raw[i]) || raw.slice(Math.max(0, i - 3), i).some((l) => WAIVER_RE.test(l));
     if (waived) continue;
     out.push({
       kind: 'unwaived-skip',