valent-pipeline 0.19.34 → 0.19.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valent-pipeline",
-  "version": "0.19.34",
+  "version": "0.19.36",
   "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, resolveRunForAssert, latestPins,
+  runEvidence, pinGate, formatRunTrailer, formatRunDigest, resolveRoot, evidenceDir, latestRun, resolveRunForAssert, detectLabelMultiplex, latestPins,
   verifyIntegrity, assertRules, assertRedRules, pinSourceDelta, snapshotFiles, buildProof, utcCompact,
   latestAssert, collectFailingCases, authenticateBaseline, verifyShipEvidence, sha256Hex,
   validStoryId, recordStageResults,
@@ -225,6 +225,19 @@ export async function evidenceAssertCmd(options) {
     process.exit(0);
   }
 
+  // Advisory (option C): residual label-multiplex at this SHA. Record-time auto-namespacing heals the
+  // common case (a sibling recorded AFTER the acceptance run); this catches one that recorded BEFORE it
+  // (so it kept the base label). Non-blocking — resolveRunForAssert already bound to the required-case
+  // run; the warning just surfaces the smell so the project fixes its labels at source.
+  try {
+    const mx = detectLabelMultiplex(evDir, { sha: run.record?.git?.sha, label });
+    if (mx.multiplexed) {
+      console.error(`evidence-assert: ⚠ label-multiplex — ${mx.suites.length} disjoint suites share label "${label}" ` +
+        `at SHA ${String(run.record?.git?.sha).slice(0, 8)} (runs ${mx.suites.map((s) => s.runId).join(', ')}). Bound to the ` +
+        `required-case run; give each suite a distinct --label in QA-B to retire this warning. (HARNESS-GAPS option C)`);
+    }
+  } catch { /* advisory only — never block the assert */ }
+
   // Re-parse the frozen reports from disk — machine-derived twice (at run time and here).
   const parsedReports = (run.record.reports || []).map((r) => {
     let parsed = null;

package/src/lib/sprint.js

@@ -226,22 +226,27 @@ export function packSprint(stories, velocity, opts = {}) {
   // groomed story alone — pulling in its groomed prerequisites first so order stays dependency-safe
   // — accepting an over-budget sprint. `over_budget` is flagged so the planner can surface
   // "this story exceeds velocity; planned alone — consider splitting it."
+  // forceAdd: include a story over-budget, pulling in its unsatisfied blocking bugs + groomed deps
+  // FIRST so execution order stays dependency-safe. Shared by both over-budget guards below.
+  const forceAdd = (story) => {
+    if (inSprint.has(story.id)) return;
+    for (const bugId of bugsOf(story)) {
+      const bug = byId.get(bugId);
+      if (bug && !satisfied.has(bug.status) && !inSprint.has(bugId)) forceAdd(bug);
+    }
+    for (const depId of depsOf(story)) {
+      const dep = byId.get(depId);
+      if (dep && dep.status === 'groomed' && !inSprint.has(depId)) forceAdd(dep);
+    }
+    add(story);
+  };
+
   let overBudget = false;
+  // Anti-stall (empty sprint): nothing fit the budget but groomed work exists — the smallest eligible
+  // story exceeds the whole velocity. Plan the highest-priority groomed story alone, over budget, so the
+  // project can never stall on a story that can never be packed. Same out-of-batch guard as the main
+  // loop (review #20): never force-plan a story whose unpacked prerequisite never shipped.
   if (sprintStories.length === 0 && byPriority.length > 0) {
-    const forceAdd = (story) => {
-      if (inSprint.has(story.id)) return;
-      for (const bugId of bugsOf(story)) {
-        const bug = byId.get(bugId);
-        if (bug && !satisfied.has(bug.status) && !inSprint.has(bugId)) forceAdd(bug);
-      }
-      for (const depId of depsOf(story)) {
-        const dep = byId.get(depId);
-        if (dep && dep.status === 'groomed' && !inSprint.has(depId)) forceAdd(dep);
-      }
-      add(story);
-    };
-    // Same out-of-batch guard as the main loop (review #20): the anti-stall must not force-plan
-    // a story whose unpacked prerequisite never shipped.
     const candidate = byPriority.find((s) => outOfBatchDepsSatisfied(s));
     if (candidate) {
       forceAdd(candidate);
@@ -249,6 +254,20 @@ export function packSprint(stories, velocity, opts = {}) {
     }
   }
 
+  // Feature-starvation guard (HARNESS-GAPS 2026-06-18, M-19 Issue 2 / orchestrator-confirmed): the
+  // empty-sprint anti-stall above does NOT fire when a small bug/spike fits — so a 1-pt bug packed while
+  // every groomed FEATURE exceeds velocity strands all feature work indefinitely (a bug-only sprint makes
+  // no product progress). If the packed set has NO feature story yet a deps-satisfied groomed feature
+  // exists, force the highest-priority one in over budget (same dependency-safe forceAdd).
+  const isFeature = (s) => s && s.type !== 'bug' && s.type !== 'spike';
+  if (sprintStories.length > 0 && !sprintStories.some((id) => isFeature(byId.get(id)))) {
+    const topFeature = byPriority.find((s) => isFeature(s) && !inSprint.has(s.id) && outOfBatchDepsSatisfied(s));
+    if (topFeature) {
+      forceAdd(topFeature);
+      overBudget = true;
+    }
+  }
+
   const buffer = groomed.filter((s) => !inSprint.has(s.id)).map((s) => s.id);
   const pointsPlanned = sprintStories.reduce((sum, id) => sum + pointsOf(byId.get(id)), 0);