@bongos/core 1.19.650 → 1.19.652

package/tests/ship_ci_deploy.mjs

@@ -44,7 +44,7 @@ function test(name, fn) {
   }
 }
 
-const { parseDeployMode, effectiveDeployMode, buildPrCreateArgv, buildPrMergeArgv, deployRunSucceeded, shouldBailOnFetchFailure, classifyLandOutcome, strandNextStep, pickStaleGateReviewRun, landPollAfterAutoMerge, reconciledCardStatus, landed, landPending, landBailed, strandCommand, landPendingLines } = ship;
+const { parseDeployMode, effectiveDeployMode, buildPrCreateArgv, buildPrMergeArgv, deployRunSucceeded, shouldBailOnFetchFailure, classifyLandOutcome, strandNextStep, pickStaleGateReviewRun, landPollAfterAutoMerge, reconciledCardStatus, landed, landPending, landBailed, strandCommand, landPendingLines, landBailRecoverableByPr, onMainNextStep, LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH, LAND_BAIL_NO_TASK_BRANCH } = ship;
 
 // ---- 1. parseDeployMode precedence + safe default ----
 
@@ -628,6 +628,111 @@ test('1002645 reconcileBlockedLines: never reads as success (no "NOT a failure",
   assert.ok(!/Prod is live/.test(lines), 'nor the success line');
 });
 
+// ---- task 1002572 (PART 2): the single-checkout land fallback ----
+// A builder with ONE checkout can never complete a local merge — the tree that
+// would RECEIVE the merge is the tree holding the feature branch. That used to
+// park the task at 'confirmed', unpaid under ADR 0120, with nothing landing. The
+// branch itself is landable, so that bail now falls back to the push+PR path.
+// What must NOT happen is a blanket conversion: a merge conflict, a red
+// post-merge smoke or a failed push are real failures, and a PR would carry the
+// same breakage to main. The decision is therefore opt-in PER BAIL, and these
+// tests pin both halves of it.
+
+test('1002572 landBailed: carries the bail id, and defaults to none', () => {
+  assert.equal(landBailed('r', 'n', LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH).bailId, LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH);
+  // Fail-safe: every pre-existing bail site passes no id, so it stays terminal.
+  assert.equal(landBailed('r', 'n').bailId, null);
+  // Still a bail — the fallback must not have turned it into a success.
+  assert.equal(landBailed('r', 'n', LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH).ok, false);
+  assert.equal(landBailed('r', 'n', LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH).pending, false);
+});
+
+test('1002572 landBailRecoverableByPr: only the main-checkout-holds-the-branch bail falls back', () => {
+  assert.equal(landBailRecoverableByPr(LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH), true);
+  // On main there is no head branch, so a PR has nothing to open FROM.
+  assert.equal(landBailRecoverableByPr(LAND_BAIL_NO_TASK_BRANCH), false);
+});
+
+test('1002572 landBailRecoverableByPr: an untagged bail is terminal (no blanket conversion)', () => {
+  // The real failures — conflict, red smoke, failed push, unreachable origin —
+  // all reach the caller as untagged bails. Each must stay loud.
+  for (const v of [null, undefined, '', 'merge-conflict', 'post-merge-smoke-failed', 'push-failed', 'fetch-failed']) {
+    assert.equal(landBailRecoverableByPr(v), false, `${JSON.stringify(v)} must not be PR-recoverable`);
+  }
+});
+
+test('1002572 onMainNextStep: names the task branch to re-ship from when it exists', () => {
+  const step = onMainNextStep(1002572, true);
+  assert.match(step, /task-1002572/, 'names the branch to go back to');
+  assert.match(step, /node scripts\/gds\/ship\.js 1002572/, 'and the re-ship command for THIS task');
+  // The old advice pointed back at the same dead end; that is the regression.
+  assert.notEqual(step, '/merge-mode');
+});
+
+test('1002572 onMainNextStep: falls back to /merge-mode rather than inventing a branch', () => {
+  assert.equal(onMainNextStep(1002572, false), '/merge-mode');
+});
+
+// The ROUTING — the actual deliverable. Driven through autoMerge with the merge
+// chain and the PR land stubbed (a real mergeLocally needs a second checkout and
+// an authed gh), so this proves behaviour rather than matching the source.
+const shipMerge = require('../scripts/gds/ship-merge.js');
+
+function driveAutoMerge(mergeOutcome) {
+  const calls = [];
+  const deps = {
+    mergeLocally: async () => mergeOutcome,
+    ciLand: async (taskId, branch, summary) => {
+      calls.push({ taskId, branch, summary });
+      return landPending();
+    },
+    currentBranch: () => 'task-1002572',
+  };
+  return shipMerge.autoMerge(1002572, 'a summary', {}, deps).then((outcome) => ({ outcome, calls }));
+}
+
+await (async () => {
+  const recoverable = await driveAutoMerge(landBailed('main checkout is on a branch', '/merge-mode', LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH));
+  test('1002572 routing: the single-checkout bail lands via the PR path instead of stranding', () => {
+    assert.equal(recoverable.calls.length, 1, 'ciLand was called exactly once');
+    assert.deepEqual(recoverable.calls[0], { taskId: 1002572, branch: 'task-1002572', summary: 'a summary' });
+    // Pending, not bailed: the card may honestly say "landing automatically" now.
+    assert.equal(recoverable.outcome.pending, true);
+    assert.equal(recoverable.outcome.reason, null);
+  });
+
+  const terminal = await driveAutoMerge(landBailed('merging task-1002572 into main failed (conflicts?)', '/merge-mode'));
+  test('1002572 routing: a real failure stays loud — no PR is opened for a conflict', () => {
+    assert.equal(terminal.calls.length, 0, 'a conflict must NOT be converted into a PR');
+    assert.equal(terminal.outcome.pending, false);
+    assert.match(terminal.outcome.reason, /conflicts/);
+  });
+
+  const onMain = await driveAutoMerge(landBailed('nothing to merge — this checkout is on main, not a task branch', onMainNextStep(1002572, true), LAND_BAIL_NO_TASK_BRANCH));
+  test('1002572 routing: standing on main opens no PR (there is no head branch), but names the cure', () => {
+    assert.equal(onMain.calls.length, 0);
+    assert.match(onMain.outcome.nextStep, /task-1002572/);
+  });
+
+  const success = await driveAutoMerge(landed());
+  test('1002572 routing: a successful local merge is untouched (the worktree path does not regress)', () => {
+    assert.equal(success.calls.length, 0, 'a clean local merge must not also open a PR');
+    assert.equal(success.outcome.ok, true);
+  });
+})();
+
+// Only the two documented catch-22 bails may carry an id. Behaviour can't see
+// this — a third tagged bail would silently gain a fallback it was never granted.
+test('1002572 wiring: exactly the two catch-22 bails are tagged', () => {
+  const src = fs.readFileSync(path.join(__dirname, '..', 'scripts', 'gds', 'ship-merge.js'), 'utf8');
+  // Each id appears exactly twice: the require destructure, and its ONE bail site.
+  for (const id of [LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH, LAND_BAIL_NO_TASK_BRANCH]) {
+    const name = `LAND_BAIL_${id.toUpperCase().replace(/-/g, '_')}`;
+    const hits = src.split(name).length - 1;
+    assert.equal(hits, 2, `${name}: imported once + used at exactly one bail site (saw ${hits})`);
+  }
+});
+
 console.log('');
 console.log(`ship_ci_deploy: ${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);