valent-pipeline 0.19.31 → 0.19.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valent-pipeline",
-  "version": "0.19.31",
+  "version": "0.19.33",
   "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/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',