valent-pipeline 0.19.48 → 0.19.50

package/package.json

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

package/src/lib/git-flow.js

@@ -124,6 +124,39 @@ function mergeInProgress(root) {
   }
 }
 
+// The TARGET is the source of truth for these CLI-owned shared-state files: the disposition files a
+// rejected story's bug entries into `pipeline-backlog.yaml` on the target at sprint end (.38
+// commit-at-persist). A reused --from-story branch carries an OLDER copy, so the refresh merge below
+// conflicts on it.
+const REFRESH_TARGET_WINS = new Set(['pipeline-backlog.yaml']);
+
+// On a refresh-merge conflict, if EVERY conflicted path is a target-authoritative shared-state file
+// (REFRESH_TARGET_WINS), resolve it toward the TARGET ("theirs" in a merge run ON the branch is the
+// target being merged in) and CONCLUDE the merge — the branch makes no legitimate edits of its own to
+// these files, so target-wins delivers the filed bug entry and loses nothing. ANY other conflicted
+// path (real code) → return false and let the caller abort exactly as before. Returns true iff it
+// resolved + committed. Closes M-65/M-69: a backlog conflict used to ABORT the refresh, so the filed
+// bug entry never reached the branch and `backlog ship --story <bug>` then errored "not found" →
+// manual reconcile every bug-fix sprint. The ship CLAMP is untouched — evidence still verifies against
+// the branch's own tree; this only delivers the backlog ENTRY the target already committed.
+function resolveRefreshConflict(dir) {
+  if (!mergeInProgress(dir)) return false; // a non-conflict merge failure — the caller aborts
+  let conflicted;
+  try {
+    conflicted = git(dir, ['diff', '--name-only', '--diff-filter=U'])
+      .split('\n').map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return false;
+  }
+  if (!conflicted.length || !conflicted.every((p) => REFRESH_TARGET_WINS.has(p))) return false;
+  for (const p of conflicted) {
+    git(dir, ['checkout', '--theirs', '--', p]);
+    git(dir, ['add', '--', p]);
+  }
+  git(dir, ['commit', '--no-edit']);
+  return true;
+}
+
 /** Is `branch` already merged into `target` (its tip an ancestor of target's tip)? */
 function isMergedInto(root, branch, target) {
   try {
@@ -475,8 +508,15 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
           buildCommitMessage({ storyId: story, phase: 'sync', summary: `sync ${target} into ${branch} (inherit shared state from a behind base)` }), target]);
         refreshedFromTarget = true;
       } catch {
-        if (mergeInProgress(wtPath)) git(wtPath, ['merge', '--abort']);
-        refreshConflict = true;
+        // A conflict ONLY on target-authoritative shared state (the backlog with the filed bug entry)
+        // → resolve toward the target so the entry reaches this branch (M-65/M-69); any real-code
+        // conflict aborts cleanly (setupWorktree re-materializes the install if the sync removed it).
+        if (resolveRefreshConflict(wtPath)) {
+          refreshedFromTarget = true;
+        } else {
+          if (mergeInProgress(wtPath)) git(wtPath, ['merge', '--abort']);
+          refreshConflict = true;
+        }
       }
     }
     const setup = setupWorktree(root, wtPath, setupCommands);
@@ -533,8 +573,16 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
         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;
+      // A conflict ONLY on target-authoritative shared state (the backlog the disposition filed the
+      // bug entry into) is resolved toward the target so the entry reaches this branch (M-65/M-69); a
+      // conflict touching any real code aborts cleanly as before (degraded, but no worse). The M-52
+      // framework-deletion guard below still runs on the concluded merge.
+      if (resolveRefreshConflict(root)) {
+        refreshedFromTarget = true;
+      } else {
+        if (mergeInProgress(root)) git(root, ['merge', '--abort']);
+        refreshConflict = true;
+      }
     }
     // M-52 transition hazard: when `target` UNTRACKS the vendored framework (the post-untrack install
     // model) while THIS branch still TRACKS it (a pre-untrack branch), the merge above applied target's
@@ -582,7 +630,14 @@ export function storyStatus({ root, story, targetBranch = '', prefix = 'story/'
   const branch = storyBranchName(prefix, story);
   const exists = branchExists(root, branch);
   const record = readFlowRecord(root, story);
-  const target = targetBranch || record?.target || currentBranch(root);
+  // A `--from-story` item (an inline bug fix) ships `--into` its SOURCE story branch (recorded as
+  // basedOnStory), NOT the sprint target — so "did it land" is ancestry against basedOnStory. The sprint
+  // `--target` that the post-ship verify passes globally (gitFlags `--target`) is the wrong base for such
+  // an item: it reads a bug correctly merged into its source — but whose source hasn't reached the sprint
+  // target yet — as merged:false → a FALSE git-ship-failed that stranded the parent's revalidation
+  // (M-60, 2.17-BUG-002). basedOnStory is therefore AUTHORITATIVE when present (it overrides even an
+  // explicit --target); an ordinary story (basedOnStory null) still honors --target then the record.
+  const target = record?.basedOnStory || targetBranch || record?.target || currentBranch(root);
   // A missing branch is UNKNOWN (merged:null), never a verdict: the flow retains branches on
   // both ship and reject, so absence means the flow never ran here (or someone pruned by hand) —
   // the caller must treat the state as unverified rather than as landed.