valent-pipeline 0.19.39 → 0.19.41

package/package.json

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

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

@@ -1672,6 +1672,25 @@ async function runShipStep(sid, commandStr, stepPhase) {
       log(`${sid}: ship-story attempt ${attempt}/${shipMergeAttempts} did not land (${res ? 'transient git-runner failure' : 'GIT runner died'}) — retrying the deterministic, idempotent merge`)
     }
   }
+  // Deterministic post-ship verify (M-36/M-37, 2026-06-19): ship-story is a code-owned git merge, but
+  // its result is transcribed by a haiku GIT runner — a transcription slip (or an agent death AFTER the
+  // merge landed) drops `merged:true`, so the loop above reports "did not land" on a merge that ACTUALLY
+  // SUCCEEDED, falsely blocking a shipped story (the git-ship-failed false-positive that stranded 2.20).
+  // Git is the ground truth: when we did NOT confirm a land/conflict/skip, ask `git story-status` — its
+  // `merged` is `isMergedInto` (computed in code, not by the agent); if the branch IS now an ancestor of
+  // the target, the merge LANDED regardless of what the ship runner said → recover to merged:true. A real
+  // conflict (broken out above) and a genuine non-landing (story-status merged:false → real merge-block)
+  // are untouched. The ancestor check cleanly separates the two classes — field-validated by hand on 2.20
+  // (M-38). Only runs on the rare non-landed path, so the happy ship adds zero overhead.
+  const confirmed = !!(res && (res.merged === true || res.skipped === true || res.conflict === true))
+  if (gitFlowEnabled && !confirmed) {
+    const status = await runGitStep(sid,
+      [`node .valent-pipeline/bin/cli.js git story-status --story ${sid}${gitFlags}`], 'merge-verify', stepPhase)
+    if (status && status.merged === true) {
+      log(`${sid}: ship-story runner reported no-land but git story-status confirms the branch IS merged into the target — recovering to merged:true (transcription false-failure, NOT a real merge-block)`)
+      return { ...(res || {}), merged: true, recoveredByVerify: true }
+    }
+  }
   return res
 }
 

package/src/lib/git-flow.js

@@ -489,6 +489,29 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
 
   git(root, ['checkout', base]);
   git(root, ['checkout', '-b', branch]);
+  // BUG-2 (M-36, 2026-06-19): a branch BASED ON a source story branch (--from-story, e.g. an inline bug
+  // fix) starts at the SOURCE's tip — which can predate commits made to the TARGET since the source was
+  // cut, most importantly the rejected story's BUG ENTRIES that the disposition filed to the shared
+  // backlog on the target. The freshly-based branch then can't see them, so `backlog ship --story <bug>`
+  // errors "not found" (and an eventual --into merge fights stale target state). The target is the source
+  // of truth for shared sprint state, so sync it into the new branch. Guarded tightly: ONLY when actually
+  // basing on another branch (basedOnStory) and the target is genuinely ahead — a fresh story off the
+  // target is already current (no-op) — and ONLY on this create path, never on a resume (a refresh after
+  // the critic pin would move HEAD past it). A conflict (source + target diverged on the SAME file) aborts
+  // cleanly and leaves the branch at its base — degraded but no worse than before, and surfaced — rather
+  // than wedging a half-merge that would hard-stop every later commit in this checkout.
+  let refreshedFromTarget = false;
+  let refreshConflict = false;
+  if (basedOnStory && branchExists(root, target) && !isMergedInto(root, target, branch)) {
+    try {
+      git(root, ['merge', '--no-ff', '-m',
+        buildCommitMessage({ storyId: story, phase: 'sync', summary: `sync ${target} into ${branch} (inherit shared state from a behind base)` }), target]);
+      refreshedFromTarget = true;
+    } catch {
+      if (mergeInProgress(root)) git(root, ['merge', '--abort']);
+      refreshConflict = true;
+    }
+  }
   writeFlowRecord(root, story, {
     schema: 1,
     kind: 'git-flow',
@@ -499,7 +522,9 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
     basedOnStory: basedOnStory ? storyBranchName(prefix, fromStory) : null,
     startedAt: new Date().toISOString(),
   });
-  return { branch, base, target, created: true, resumed: false, snapshotSha };
+  return { branch, base, target, created: true, resumed: false, snapshotSha,
+    ...(refreshedFromTarget ? { refreshedFromTarget: true } : {}),
+    ...(refreshConflict ? { refreshConflict: true } : {}) };
 }
 
 /**