valent-pipeline 0.19.22 → 0.19.24

package/package.json

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

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

@@ -837,6 +837,13 @@ const gitBranchPrefix = (typeof (gitCfg.storyBranchPrefix ?? gitCfg.story_branch
 // plain ref-safe names stay bare so the composed commands read naturally in prompts.
 const refq = (s) => (/^[A-Za-z0-9._/-]+$/.test(s) ? s : shq(s))
 const gitFlags = (gitTargetBranch ? ` --target ${refq(gitTargetBranch)}` : '') + (gitBranchPrefix !== 'story/' ? ` --prefix ${refq(gitBranchPrefix)}` : '')
+// Ship-merge retry cap (review 2026-06-14): how many times a non-landed, non-conflict ship-story
+// result (a transient GIT-runner failure — the haiku transcriber dying / returning null, a momentary
+// index lock) is re-attempted before the story is declared merge-blocked. The merge is deterministic
+// and ship-story is idempotent (an already-merged branch returns already:true), so retrying is always
+// safe. A single hiccup used to drop a JUDGE-approved story to merge-blocked → requeued a whole sprint
+// later, silently. Default 3 (1 + 2 retries); pipeline-config.yaml git.ship_merge_attempts overrides.
+const shipMergeAttempts = Math.max(1, Number.isInteger(gitCfg.shipMergeAttempts ?? gitCfg.ship_merge_attempts) ? (gitCfg.shipMergeAttempts ?? gitCfg.ship_merge_attempts) : 3)
 const gitCommitCmd = (sid, phase, extra = '') =>
   `node .valent-pipeline/bin/cli.js git commit-phase --story ${sid} --phase ${phase}${extra}`
 
@@ -1423,6 +1430,16 @@ phase('Backlog')
 // outcomes) is also REQUEUED to `groomed` — the sweep that closes the `sprint-planned` black hole
 // (review #16): nothing the plan tagged may end the sprint still in-flight.
 const isMergeBlocked = (r) => r.verdict === 'blocked' && (r.reason === 'merge-conflict' || r.reason === 'git-ship-failed')
+// Surface merge-blocked stories LOUDLY (review 2026-06-14): a JUDGE-approved story whose merge did
+// not land is requeued to groomed (correct — an infra outcome, not a quality reject), but that
+// requeue used to be silent: a run could end with a green-looking ledger while a shipped-on-paper
+// story sat un-integrated and a later story merged ahead of it. Name them in the summary + return.
+const mergeBlocked = results
+  .filter((r) => !r.resumedSkip && isMergeBlocked(r))
+  .map((r) => ({ storyId: r.storyId, reason: r.reason }))
+if (mergeBlocked.length) {
+  log(`⚠ MERGE-BLOCKED: ${mergeBlocked.length} JUDGE-approved stor${mergeBlocked.length === 1 ? 'y' : 'ies'} did NOT reach the target after ${shipMergeAttempts} ship attempt(s) and ${mergeBlocked.length === 1 ? 'was' : 'were'} requeued to groomed for re-ship — ${mergeBlocked.map((m) => `${m.storyId} (${m.reason})`).join(', ')}. NOT lost, NOT integrated: a follow-up sprint re-ships from the retained branch, or ship manually.`)
+}
 const backlog = await persistBacklog(
   results.filter((r) => r.shipped),
   results.filter((r) => r.partial),
@@ -1439,6 +1456,7 @@ return {
   results,
   integration,
   post_merge_findings: postMergeFindings,
+  merge_blocked: mergeBlocked,
   backlog,
 }
 
@@ -1612,6 +1630,25 @@ async function runGitStep(sid, commands, label, stepPhase, dirPhrase = 'the proj
   return result
 }
 
+// runShipStep: runGitStep specialized for the terminal ship-story merge, with a retry (review
+// 2026-06-14). A single transient GIT-runner failure (null/agent-death, or a non-landed non-conflict
+// result) used to drop a JUDGE-approved story straight to merge-blocked — requeued a whole sprint
+// later, with the only trace a mid-run log line. ship-story is deterministic and idempotent (an
+// already-merged branch returns already:true; a never-merged one re-attempts the same merge), so a
+// non-terminal result is re-run up to shipMergeAttempts. A REAL conflict (conflict===true) is NOT
+// retried — a blind re-merge cannot clear it; that needs the --reship sync/resolve path.
+async function runShipStep(sid, commandStr, stepPhase) {
+  let res = null
+  for (let attempt = 1; attempt <= shipMergeAttempts; attempt++) {
+    res = await runGitStep(sid, [commandStr], 'ship', stepPhase)
+    if (res && (res.merged === true || res.skipped === true || res.conflict === true)) break
+    if (attempt < shipMergeAttempts) {
+      log(`${sid}: ship-story attempt ${attempt}/${shipMergeAttempts} did not land (${res ? 'transient git-runner failure' : 'GIT runner died'}) — retrying the deterministic, idempotent merge`)
+    }
+  }
+  return res
+}
+
 // ===========================================================================
 // runStory: the per-story pipeline (kept inline, not a nested workflow(), so the single
 // workflow() nesting level stays free for plan/retro — see reimplementation-plan §5b).
@@ -1785,8 +1822,8 @@ async function runStory(story) {
         }
       } else if (sync && (sync.synced === true || sync.skipped === true)) {
         // Clean (or non-repo skip): the standing JUDGE verdict still covers the tree — ship directly.
-        const ship = await withShipTurn(storyId, () => runGitStep(storyId,
-          [`node .valent-pipeline/bin/cli.js git ship-story --story ${storyId} --verdict ship${gitFlags}`], 'ship', 'QA'))
+        const ship = await withShipTurn(storyId, () => runShipStep(storyId,
+          `node .valent-pipeline/bin/cli.js git ship-story --story ${storyId} --verdict ship${gitFlags}`, 'QA'))
         const merged = ship && (ship.skipped === true || ship.merged === true)
         if (merged) {
           recordStage('ship', { verdict: 'pass' })
@@ -1855,8 +1892,8 @@ async function runStory(story) {
     if (gitFlowEnabled) {
       if (shipped || shippedPartial) {
         const mergeVerdict = shippedPartial ? 'ship-partial' : decision.verdict === 'ship-with-bugs' ? 'ship-with-bugs' : 'ship'
-        const ship = await withShipTurn(storyId, () => runGitStep(storyId,
-          [`node .valent-pipeline/bin/cli.js git ship-story --story ${storyId} --verdict ${mergeVerdict}${gitFlags}`], 'ship', 'Judge'))
+        const ship = await withShipTurn(storyId, () => runShipStep(storyId,
+          `node .valent-pipeline/bin/cli.js git ship-story --story ${storyId} --verdict ${mergeVerdict}${gitFlags}`, 'Judge'))
         const merged = ship && (ship.skipped === true || ship.merged === true)
         if (!merged) {
           const reason = ship && ship.conflict ? 'merge-conflict' : 'git-ship-failed'
@@ -1993,11 +2030,30 @@ async function runStory(story) {
     }
   }
 
+  // Shift-left pre-handoff self-gate (review 2026-06-15): the dev fan-out used to hand off WITHOUT
+  // knowing which deterministic checks the pre-CRITIC STATIC gate would run the instant it did — so
+  // lint/type failures and un-waived test skips reached the gate and cost a full rework round-trip
+  // (a re-spawn), the dominant avoidable-rework pattern in the field (a soft correction-directive
+  // reduced it but did not close it). Thread the gate's OWN checks into the build prompt so the dev
+  // runs them IN its build turn (same context, no re-spawn) and hands off clean. The gate
+  // (runPreCriticGate) stays the mechanical backstop; this just makes it pass first-try, cutting both
+  // the round-trip cost and the rework-cycle count. Same preCriticChecks the gate runs; the
+  // skip-waiver / spec-conformance rules are always named. Static + args only => journal-replay safe.
+  const preHandoffStaticCmds = preCriticChecks.map((c) => subCmd(c, storyId, effectiveWorkspaces))
+  const preHandoffNote = (preHandoffStaticCmds.length || specConformanceEnabled || traceCheckEnabled)
+    ? '\n\n## Definition of done — run these BEFORE you write your handoff\n' +
+      'The deterministic pre-CRITIC gate runs the moment you hand off; a failure costs a full rework cycle (a re-spawn). Pass them first-try:\n' +
+      preHandoffStaticCmds.map((c) => `  - \`${c}\` — must exit 0 (lint / type / static).\n`).join('') +
+      '  - Every deliberately skipped or pending test MUST carry an inline `// valent-waiver: <reason>` (on the skip line or in the test name) — an un-waived skip is rejected by the spec-conformance check.\n' +
+      '  - Do NOT drop a spec\'d assertion target or omit a spec\'d case to make a suite pass.\n' +
+      'Run them locally, fix EVERYTHING they flag, and only then write your handoff — this is part of the build, not the gate\'s job to find for you.'
+    : ''
+
   phase('Build')
   // Genuine barrier: CRITIC needs ALL active dev agents' work before reviewing.
   const builds = await parallel(
     devTasks.map((t) => () =>
-      spawn(t.agent, `${t.agent.toLowerCase()}.md`, (t.subject || 'Implement production code and tests per the brief and test spec.') + atddReadOnlyNote, {
+      spawn(t.agent, `${t.agent.toLowerCase()}.md`, (t.subject || 'Implement production code and tests per the brief and test spec.') + atddReadOnlyNote + preHandoffNote, {
         label: `build:${t.ref}:${storyId}`,
         phase: 'Build',
       })),
@@ -2094,8 +2150,8 @@ async function runStory(story) {
       // Standalone bugs (no sourceStory — defects in already-shipped code) merge to target as before.
       const intoFlag = itemType === 'bug' && sourceStory ? ` --into ${gitBranchPrefix}${sourceStory}` : ''
       const ship = await withShipTurn(storyId, async () => {
-        const res = await runGitStep(storyId,
-          [`node .valent-pipeline/bin/cli.js git ship-story --story ${storyId} --verdict ${mergeVerdict}${intoFlag}${wtFlag}${gitFlags}`], 'ship', 'Judge')
+        const res = await runShipStep(storyId,
+          `node .valent-pipeline/bin/cli.js git ship-story --story ${storyId} --verdict ${mergeVerdict}${intoFlag}${wtFlag}${gitFlags}`, 'Judge')
         // Post-merge acceptance verify (parallel mode + atdd armed): the story was QA'd on its
         // PRE-merge SHA; other stories' merges may have landed since. Re-run its acceptance suite
         // against the merged target — still under the mutex, so nothing else moves the target