valent-pipeline 0.19.49 → 0.19.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valent-pipeline",
-  "version": "0.19.49",
+  "version": "0.19.51",
   "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 {
@@ -337,6 +370,19 @@ export function readFlowRecord(root, story) {
   }
 }
 
+// When the flow record isn't in the run context's working tree, read it from a git ref. A --from-story
+// bug's git-flow.json is committed only on its own branch (evidence-on-branch — the class the .50 fixed
+// for the backlog entry), so story-status run from a context that lacks it (the post-ship verify on
+// build/v1) would otherwise read None. Returns null on any failure (missing path/ref) — callers fall
+// back to their prior behavior.
+function readFlowRecordFromRef(root, ref, story) {
+  try {
+    return JSON.parse(git(root, ['show', `${ref}:stories/${story}/evidence/git-flow.json`]));
+  } catch {
+    return null;
+  }
+}
+
 function writeFlowRecord(root, story, record) {
   const dir = join(root, 'stories', story, 'evidence');
   mkdirSync(dir, { recursive: true });
@@ -475,8 +521,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 +586,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
@@ -581,7 +642,13 @@ export function storyStatus({ root, story, targetBranch = '', prefix = 'story/'
   if (!isRepoWithCommits(root)) return NOT_REPO;
   const branch = storyBranchName(prefix, story);
   const exists = branchExists(root, branch);
-  const record = readFlowRecord(root, story);
+  // Evidence-on-branch (M-90/M-91): a --from-story bug's git-flow.json is committed on its OWN branch,
+  // so a story-status run from a context lacking it (the post-ship verify on build/v1) reads None and
+  // defaults the target to build/v1 — a bug merged --into its SOURCE then reads merged:false (a FALSE
+  // git-ship-failed that strands the parent's revalidation). Fall back to the branch ref so basedOnStory
+  // still resolves (the .49 authority can only fire if the record is readable). Mirrors the .50 backlog
+  // branch-resolution. The record CONTENT is identical to the local copy — only the read source differs.
+  const record = readFlowRecord(root, story) || (exists ? readFlowRecordFromRef(root, branch, story) : null);
   // 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