valent-pipeline 0.19.65 → 0.19.67

package/package.json

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

package/src/lib/git-flow.js

@@ -139,15 +139,19 @@ const REFRESH_TARGET_WINS = new Set(['pipeline-backlog.yaml']);
 // 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;
+// The repo-relative paths git reports as unmerged (conflicted) in the current merge. [] on error.
+function conflictedPaths(dir) {
   try {
-    conflicted = git(dir, ['diff', '--name-only', '--diff-filter=U'])
+    return git(dir, ['diff', '--name-only', '--diff-filter=U'])
       .split('\n').map((s) => s.trim()).filter(Boolean);
   } catch {
-    return false;
+    return [];
   }
+}
+
+function resolveRefreshConflict(dir) {
+  if (!mergeInProgress(dir)) return false; // a non-conflict merge failure — the caller aborts
+  const conflicted = conflictedPaths(dir);
   if (!conflicted.length || !conflicted.every((p) => REFRESH_TARGET_WINS.has(p))) return false;
   for (const p of conflicted) {
     git(dir, ['checkout', '--theirs', '--', p]);
@@ -167,6 +171,54 @@ function isMergedInto(root, branch, target) {
   }
 }
 
+// RESUME-path backlog refresh (M-208). The create-path sync (startStory, the `merge --no-ff target`
+// below) fires ONLY on create — never on a RESUME, because a full merge there would move HEAD past the
+// critic pin (the documented constraint at the create-path guard). But a --from-story bug-fix branch
+// can still END UP missing the target-filed bug entry across a resume: if the entry is filed to the
+// target AFTER the branch is cut (the rejecting sprint's rollover-persist lands ~seconds after the
+// branch base, or the create launch dies before the entry exists) and the run then RESUMES the branch,
+// the create refresh never re-runs → `backlog ship --story <bug>` errors "backlog item not found"
+// (3.5-BUG-001, the M-36/M-65 class on the resume surface). Bring ONLY the target-canonical backlog
+// forward — a single path-scoped chore commit, NOT a merge — so the entry arrives while the pin and all
+// code stay exactly put (the backlog is already target-wins on every merge, REFRESH_TARGET_WINS). A
+// no-op when the branch backlog already matches the target (the create refresh delivered it, or nothing
+// was filed) so a resume never churns an empty commit; gated to inline --from-story fixes (basedOnStory)
+// whose target genuinely advanced, mirroring the create-path guard.
+function syncBacklogFromTargetOnResume(gitDir, root, story, target) {
+  try {
+    if (!target || !branchExists(root, target)) return false;
+    const rec = readFlowRecord(gitDir, story) || readFlowRecord(root, story);
+    if (!rec || !rec.basedOnStory) return false;          // only inline bug fixes need this
+    if (mergeInProgress(gitDir)) return false;            // never touch a half-merged tree
+    const branch = rec.branch || currentBranch(gitDir);
+    if (!branch || isMergedInto(root, target, branch)) return false; // target not ahead → nothing to inherit
+    return commitTargetBacklog(gitDir, story, target,
+      'inherit target backlog (filed bug entries) on resume — no code merge, pin intact (M-208)');
+  } catch {
+    return false; // best-effort: a sync failure leaves the branch as it was (degraded, not wedged)
+  }
+}
+
+// Deliver ONLY the target's canonical pipeline-backlog.yaml blob onto the CURRENT branch as a
+// path-scoped chore commit (no code merge, HEAD/pin/code untouched). Returns true iff it committed a
+// change (no-op + false when the branch backlog already matches the target — never an empty commit).
+// Shared by the resume-path sync (M-208) and the create-path refresh-abort fallback (M-219): a refresh
+// merge that ABORTS on a non-backlog co-conflict (a project coordination doc, the M-52 untrack reset, …)
+// rolls the cleanly-mergeable bug entry back with the whole merge, so the disposition's filed entry never
+// reaches the branch and `backlog ship --story <bug>` later errors "not found". The backlog is
+// target-canonical (never legitimately branch-edited — target-wins on every merge), so deliver it
+// directly. Caller must ensure no merge is in progress (a clean tree at base).
+function commitTargetBacklog(gitDir, story, target, summary) {
+  const backlogFile = 'pipeline-backlog.yaml';
+  git(gitDir, ['checkout', target, '--', backlogFile]); // stage the target's canonical backlog blob
+  const staged = git(gitDir, ['diff', '--cached', '--name-only'])
+    .split('\n').map((s) => s.trim()).filter(Boolean);
+  if (!staged.includes(backlogFile)) return false;      // already current → no empty commit
+  git(gitDir, ['commit', '-m',
+    buildCommitMessage({ storyId: story, phase: 'sync', summary }), '--', backlogFile]);
+  return true;
+}
+
 // --- worktree mode (parallel story execution) -------------------------------------------------
 // Each parallel story gets its own worktree under `<root>/<worktreeDir>/<storyId>` with the story
 // branch checked out there; the MAIN checkout stays on the target branch and is the only place
@@ -470,7 +522,10 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
   const onBranch = currentBranch(root);
 
   if (!worktree && onBranch === branch) {
-    return { branch, base: readFlowRecord(root, story)?.base ?? null, created: false, resumed: true };
+    const rec = readFlowRecord(root, story);
+    const backlogResynced = syncBacklogFromTargetOnResume(root, root, story, rec?.target);
+    return { branch, base: rec?.base ?? null, created: false, resumed: true,
+      ...(backlogResynced ? { backlogResynced: true } : {}) };
   }
 
   // Leftover dirt belongs to whatever produced it (planning artifacts, a prior crash) — sweep it
@@ -516,7 +571,10 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
       // when intact, and a half-created worktree (crash between `worktree add` and setup) gets
       // its missing pieces — setup_commands must therefore be idempotent (documented).
       const setup = setupWorktree(root, existing, setupCommands);
-      return { branch, base: readFlowRecord(existing, story)?.base ?? null, worktree: existing, created: false, resumed: true, snapshotSha, ...setup };
+      const rec = readFlowRecord(existing, story) || readFlowRecord(root, story);
+      const backlogResynced = syncBacklogFromTargetOnResume(existing, root, story, rec?.target);
+      return { branch, base: rec?.base ?? null, worktree: existing, created: false, resumed: true, snapshotSha,
+        ...(backlogResynced ? { backlogResynced: true } : {}), ...setup };
     }
     const creating = !branchExists(root, branch);
     if (creating) {
@@ -544,6 +602,7 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
     // a conflict aborts cleanly in the worktree, leaving the branch at its base. Needed for parallel:2.
     let refreshedFromTarget = false;
     let refreshConflict = false;
+    let backlogCleanlyMergeable = false;
     if (creating && basedOnStory && branchExists(root, target) && !isMergedInto(root, target, branch)) {
       try {
         git(wtPath, ['merge', '--no-ff', '-m',
@@ -553,14 +612,27 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
         // 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).
+        const conflicted = conflictedPaths(wtPath); // captured BEFORE resolve concludes/abort clears it
         if (resolveRefreshConflict(wtPath)) {
           refreshedFromTarget = true;
         } else {
           if (mergeInProgress(wtPath)) git(wtPath, ['merge', '--abort']);
           refreshConflict = true;
+          backlogCleanlyMergeable = conflicted.length > 0 && !conflicted.some((p) => REFRESH_TARGET_WINS.has(p));
         }
       }
     }
+    // M-219 (worktree variant): the refresh aborted on a non-backlog co-conflict while the backlog itself
+    // would have merged clean → deliver ONLY the target backlog blob into the worktree so the filed bug
+    // entry is present for `backlog ship` (code stays at base; conflict still surfaced via refreshConflict).
+    // Runs in wtPath BEFORE setupWorktree re-materializes the install — the tree is clean at base.
+    let backlogDelivered = false;
+    if (creating && basedOnStory && refreshConflict && !refreshedFromTarget && backlogCleanlyMergeable && branchExists(root, target)) {
+      try {
+        backlogDelivered = commitTargetBacklog(wtPath, story, target,
+          'inherit target backlog (filed bug entries) after refresh aborted on a co-conflict — no code merge (M-219)');
+      } catch { /* best-effort: leave the branch at its base */ }
+    }
     const setup = setupWorktree(root, wtPath, setupCommands);
     if (creating) {
       writeFlowRecord(wtPath, story, {
@@ -580,13 +652,17 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
       ...(orphanMovedTo ? { orphanMovedTo, warning: `orphaned worktree directory moved aside to ${orphanMovedTo} (crashed run; inspect/delete it manually)` } : {}),
       ...(refreshedFromTarget ? { refreshedFromTarget: true } : {}),
       ...(refreshConflict ? { refreshConflict: true } : {}),
+      ...(backlogDelivered ? { backlogDelivered: true } : {}),
       ...setup,
     };
   }
 
   if (branchExists(root, branch)) {
     git(root, ['checkout', branch]);
-    return { branch, base: readFlowRecord(root, story)?.base ?? null, created: false, resumed: true, snapshotSha };
+    const rec = readFlowRecord(root, story);
+    const backlogResynced = syncBacklogFromTargetOnResume(root, root, story, rec?.target);
+    return { branch, base: rec?.base ?? null, created: false, resumed: true, snapshotSha,
+      ...(backlogResynced ? { backlogResynced: true } : {}) };
   }
   if (!branchExists(root, base)) throw new Error(`base branch "${base}" does not exist`);
 
@@ -605,6 +681,7 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
   // than wedging a half-merge that would hard-stop every later commit in this checkout.
   let refreshedFromTarget = false;
   let refreshConflict = false;
+  let backlogCleanlyMergeable = false;
   if (basedOnStory && branchExists(root, target) && !isMergedInto(root, target, branch)) {
     // Capture whether the vendored install is present BEFORE the sync, so the hazard guard below fires
     // ONLY when the merge actually REMOVED it — not when a repo simply never had a materialized install
@@ -619,11 +696,17 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
       // 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.
+      const conflicted = conflictedPaths(root); // captured BEFORE resolve concludes/abort clears it
       if (resolveRefreshConflict(root)) {
         refreshedFromTarget = true;
       } else {
         if (mergeInProgress(root)) git(root, ['merge', '--abort']);
         refreshConflict = true;
+        // M-219: deliver the backlog entry below ONLY when the backlog itself did NOT conflict — i.e. the
+        // entry would have merged clean but an UNRELATED file's conflict (a project coordination doc, …)
+        // aborted the whole merge. A backlog+code divergence is a genuinely diverged branch (recut) —
+        // leave it untouched so the negative guard "never swallows a code conflict" holds.
+        backlogCleanlyMergeable = conflicted.length > 0 && !conflicted.some((p) => REFRESH_TARGET_WINS.has(p));
       }
     }
     // M-52 transition hazard: when `target` UNTRACKS the vendored framework (the post-untrack install
@@ -645,6 +728,19 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
       );
     }
   }
+  // M-219: a refresh that ABORTED (a non-backlog co-conflict — e.g. a project coordination doc whose
+  // conflict makes resolveRefreshConflict bail — or the M-52 untrack reset above) rolled the
+  // cleanly-mergeable target backlog back with the whole merge, so the disposition's filed bug entry
+  // never reached this branch and `backlog ship --story <bug>` would error "not found" (3.5/3.7-BUG-001).
+  // The tree is clean at base here (merge --abort / reset --hard ran), so deliver ONLY the target
+  // backlog blob directly — code stays at base (the conflict is still surfaced via refreshConflict).
+  let backlogDelivered = false;
+  if (basedOnStory && refreshConflict && !refreshedFromTarget && backlogCleanlyMergeable && branchExists(root, target)) {
+    try {
+      backlogDelivered = commitTargetBacklog(root, story, target,
+        'inherit target backlog (filed bug entries) after refresh aborted on a co-conflict — no code merge (M-219)');
+    } catch { /* best-effort: leave the branch at its base */ }
+  }
   writeFlowRecord(root, story, {
     schema: 1,
     kind: 'git-flow',
@@ -657,7 +753,8 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
   });
   return { branch, base, target, created: true, resumed: false, snapshotSha,
     ...(refreshedFromTarget ? { refreshedFromTarget: true } : {}),
-    ...(refreshConflict ? { refreshConflict: true } : {}) };
+    ...(refreshConflict ? { refreshConflict: true } : {}),
+    ...(backlogDelivered ? { backlogDelivered: true } : {}) };
 }
 
 /**