valent-pipeline 0.19.49 → 0.19.50

package/package.json

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