@bongos/core 1.17.0

package/tests/git_merge_regen.mjs

@@ -0,0 +1,151 @@
+// tests/git_merge_regen.mjs
+//
+// Hermetic coverage for the generated-file merge-conflict auto-heal (task 1243 —
+// the prevention for the PR #167 repo-map churn). NO network, NO DB, NO real merge:
+// it drives the pure resolver in scripts/gds/git-merge-regen.js and the merge-driver
+// entrypoint directly.
+//
+//   1. docs/repo-map.md (fully generated) → regenerates clean from the merged tree,
+//      ignoring all three conflicted sides; result is marker-free + matches the
+//      committed file.
+//   2. A nested CLAUDE.md whose conflict is confined to the generated BLOCK →
+//      regenerates clean (the block is overwritten, markers vanish).
+//   3. A nested CLAUDE.md with a HAND-WRITTEN conflict → still fails (ok:false,
+//      markers remain) so a human resolves it — the heal never clobbers real edits.
+//   4. The merge-driver entrypoint writes %A + exits 0 (heal) / 1 (real conflict).
+//   5. A non-generated path is never touched (not in REGENERABLE).
+//
+// Run:  node tests/git_merge_regen.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repo = path.resolve(here, '..');
+const regen = require('../scripts/gds/git-merge-regen.js');
+const G = require('../scripts/gds/gen-repo-map.js');
+
+const MARKERS = /^(<{7}|={7}|>{7})/m;
+
+// ── 1) docs/repo-map.md regenerates clean, ignoring the conflicted sides ────────
+{
+  const r = regen.regenerateResolved('docs/repo-map.md', {
+    base: 'whatever\n', ours: '<<<<<<< ours\nA\n=======\nB\n>>>>>>> theirs\n', theirs: 'nonsense\n',
+  });
+  assert.equal(r.ok, true, 'repo-map heal must succeed');
+  assert.ok(!MARKERS.test(r.content), 'repo-map heal must leave no conflict markers');
+  assert.match(r.content, /AUTO-GENERATED/, 'repo-map heal must produce the generated map');
+  // The heal must equal a fresh generation from the (merged) working tree — i.e.
+  // exactly what gen-repo-map.js would write — regardless of the conflicted sides.
+  // (Comparing to the committed file would be brittle: it's only equal when the
+  // committed copy happens to be fresh; CI's repo_map test owns that invariant.)
+  assert.equal(r.content, G.renderRepoMap(G.buildModel()), 'repo-map heal must equal a fresh generation');
+}
+
+// ── helpers to build nested-CLAUDE.md fixtures from the real committed file ─────
+const NESTED = 'scripts/gds/CLAUDE.md';
+const realNested = fs.readFileSync(path.join(repo, NESTED), 'utf8');
+assert.ok(realNested.includes(G.BEGIN) && realNested.includes(G.END), 'fixture file must carry the generated block markers');
+// Replace the INNER block text (keep the BEGIN/END marker lines intact).
+function withBlockBody(src, body) {
+  const b = src.indexOf(G.BEGIN);
+  const e = src.indexOf(G.END);
+  return src.slice(0, b) + G.BEGIN + '\n' + body + '\n' + G.END + src.slice(e + G.END.length);
+}
+
+// ── 2) nested doc: conflict confined to the generated block → heals clean ───────
+{
+  const base = realNested;
+  const ours = withBlockBody(realNested, '- `ours.js` — `oursOnly()`');
+  const theirs = withBlockBody(realNested, '- `theirs.js` — `theirsOnly()`');
+  const r = regen.regenerateResolved(NESTED, { base, ours, theirs });
+  assert.equal(r.ok, true, 'block-only conflict must heal (ok:true)');
+  assert.ok(!MARKERS.test(r.content), 'block-only heal must leave no markers');
+  assert.ok(r.content.includes(G.BEGIN) && r.content.includes(G.END), 'healed nested doc keeps its block markers');
+}
+
+// ── 3) nested doc: a HAND-WRITTEN conflict must NOT be auto-resolved ────────────
+{
+  const firstNL = realNested.indexOf('\n');
+  const swapFirstLine = (s, line) => line + realNested.slice(firstNL);
+  const base = realNested;
+  const ours = swapFirstLine(realNested, '# OURS hand-written heading');
+  const theirs = swapFirstLine(realNested, '# THEIRS hand-written heading');
+  const r = regen.regenerateResolved(NESTED, { base, ours, theirs });
+  assert.equal(r.ok, false, 'a hand-written conflict must NOT auto-resolve (ok:false)');
+  assert.ok(MARKERS.test(r.content), 'unresolved hand-written conflict keeps its markers');
+}
+
+// ── 4) the merge-driver entrypoint: writes %A, exits 0 (heal) / 1 (conflict) ────
+{
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'otb-mdrv-'));
+  const O = path.join(tmp, 'O'), A = path.join(tmp, 'A'), B = path.join(tmp, 'B');
+  fs.writeFileSync(O, 'base\n'); fs.writeFileSync(A, 'ours\n'); fs.writeFileSync(B, 'theirs\n');
+  const driver = path.join(repo, 'scripts/gds/git-merge-regen.js');
+  const heal = spawnSync('node', [driver, O, A, B, 'docs/repo-map.md'], { encoding: 'utf8' });
+  assert.equal(heal.status, 0, `driver must exit 0 on a healable file; got ${heal.status} :: ${heal.stderr}`);
+  assert.equal(fs.readFileSync(A, 'utf8'), G.renderRepoMap(G.buildModel()),
+    'driver must write the freshly regenerated repo-map into %A');
+
+  // A nested doc with a hand-written conflict → exit 1 (git keeps the conflict).
+  const firstNL = realNested.indexOf('\n');
+  fs.writeFileSync(O, realNested);
+  fs.writeFileSync(A, '# OURS heading' + realNested.slice(firstNL));
+  fs.writeFileSync(B, '# THEIRS heading' + realNested.slice(firstNL));
+  const conflict = spawnSync('node', [driver, O, A, B, NESTED], { encoding: 'utf8' });
+  assert.equal(conflict.status, 1, `driver must exit 1 when a hand-written conflict remains; got ${conflict.status}`);
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ── 5) a non-generated path is never in scope ───────────────────────────────────
+{
+  assert.equal(regen.REGENERABLE.has('CLAUDE.md'), false, 'top-level CLAUDE.md is hand-written — never auto-healed');
+  assert.equal(regen.REGENERABLE.has('scripts/gds/box.js'), false, 'source files are never auto-healed');
+  const r = regen.regenerateResolved('scripts/gds/box.js', { base: 'a', ours: 'b', theirs: 'c' });
+  assert.equal(r.content, null, 'a non-generated path resolves to null content');
+}
+
+// ── 6) END-TO-END: a real `git merge` invokes the driver and auto-resolves ──────
+// Proves the .gitattributes + git-config wiring, not just the resolver. The driver
+// regenerates from the REAL repo (its REPO_ROOT is fixed), so the temp repo's
+// docs/repo-map.md heals to the real map.
+{
+  const driver = path.join(repo, 'scripts/gds/git-merge-regen.js');
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'otb-gitmerge-'));
+  const g = (...a) => {
+    const r = spawnSync('git', a, { cwd: tmp, encoding: 'utf8' });
+    return { status: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
+  };
+  const writeMap = (s) => fs.writeFileSync(path.join(tmp, 'docs', 'repo-map.md'), s);
+  try {
+    g('init', '-q');
+    g('config', 'user.email', 't@t'); g('config', 'user.name', 't');
+    g('config', 'merge.otb-regen.driver', `node ${driver} %O %A %B %P`);
+    fs.writeFileSync(path.join(tmp, '.gitattributes'), 'docs/repo-map.md merge=otb-regen\n');
+    fs.mkdirSync(path.join(tmp, 'docs'));
+    writeMap('base\n'); g('add', '-A'); g('commit', '-qm', 'base');
+    g('checkout', '-qb', 'feature');
+    writeMap('FEATURE side\n'); g('add', '-A'); g('commit', '-qm', 'feat');
+    g('checkout', '-q', 'master');
+    // master may be 'main' depending on git defaults — handle both.
+    if (g('rev-parse', '--verify', 'master').status !== 0) g('checkout', '-q', 'main');
+    writeMap('MASTER side\n'); g('add', '-A'); g('commit', '-qm', 'mast');
+    const merge = g('merge', '--no-edit', 'feature');
+    assert.equal(merge.status, 0, `real git merge must auto-resolve via the driver; got ${merge.status} :: ${merge.out}`);
+    const unmerged = g('diff', '--name-only', '--diff-filter=U').out.trim();
+    assert.equal(unmerged, '', `no file may be left unmerged; got: ${unmerged}`);
+    const healed = fs.readFileSync(path.join(tmp, 'docs', 'repo-map.md'), 'utf8');
+    assert.ok(!MARKERS.test(healed), 'merged repo-map must have no conflict markers');
+    assert.match(healed, /AUTO-GENERATED/, 'merged repo-map must be the regenerated map');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+console.log('git_merge_regen: all assertions passed');

package/tests/github_push_ancestry.mjs

@@ -0,0 +1,119 @@
+// tests/github_push_ancestry.mjs
+//
+// Unit tests for isAncestorOfDefaultBranch (task 1313) in src/bongos/github-push.js —
+// the head_sha land-check that proves a confirmed task merged from the COMMIT, not
+// from a still-existing PR/branch. This is the durable cure for the confirmed→shipped
+// strand class (a merge that deletes its branch leaves no discoverable PR).
+//
+// Pure w.r.t. injected token/repoInfo/fetchImpl, so this runs in the DB-free,
+// network-free unit gate.
+//
+// Run:  node tests/github_push_ancestry.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const gh = require('../modules/lifecycle/github-push.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  Promise.resolve()
+    .then(fn)
+    .then(() => { passed++; console.log(`  ok  ${name}`); })
+    .catch((err) => { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); });
+}
+
+const SHA = 'd79fda340138111931134ff0de8368b986e9e15a';
+
+// A fetchImpl that serves one compare response and records the URL it was asked for.
+function mkFetch({ status = 200, compareStatus = 'behind' } = {}) {
+  const calls = { urls: [] };
+  const fetchImpl = async (url) => {
+    calls.urls.push(String(url));
+    return {
+      ok: status >= 200 && status < 300,
+      status,
+      json: async () => ({ status: compareStatus }),
+    };
+  };
+  return { fetchImpl, calls };
+}
+
+const DEPS = (fetchImpl) => ({ token: 't', repoInfo: { owner: 'o', repo: 'r' }, fetchImpl });
+
+// --- the four compare verdicts ---------------------------------------------
+
+test('compare status "behind" → true (sha is contained in main, with more commits after)', async () => {
+  const { fetchImpl } = mkFetch({ compareStatus: 'behind' });
+  assert.equal(await gh.isAncestorOfDefaultBranch({ sha: SHA }, DEPS(fetchImpl)), true);
+});
+
+test('compare status "identical" → true (sha IS main\'s tip)', async () => {
+  const { fetchImpl } = mkFetch({ compareStatus: 'identical' });
+  assert.equal(await gh.isAncestorOfDefaultBranch({ sha: SHA }, DEPS(fetchImpl)), true);
+});
+
+test('compare status "ahead" → false (sha has commits main lacks — not landed)', async () => {
+  const { fetchImpl } = mkFetch({ compareStatus: 'ahead' });
+  assert.equal(await gh.isAncestorOfDefaultBranch({ sha: SHA }, DEPS(fetchImpl)), false);
+});
+
+test('compare status "diverged" → false (e.g. squash-merged to a different commit)', async () => {
+  const { fetchImpl } = mkFetch({ compareStatus: 'diverged' });
+  assert.equal(await gh.isAncestorOfDefaultBranch({ sha: SHA }, DEPS(fetchImpl)), false);
+});
+
+// --- the compare URL is built correctly ------------------------------------
+
+test('queries compare/<base>...<sha> against the resolved owner/repo', async () => {
+  const { fetchImpl, calls } = mkFetch({ compareStatus: 'behind' });
+  await gh.isAncestorOfDefaultBranch({ sha: SHA }, DEPS(fetchImpl));
+  assert.equal(calls.urls.length, 1);
+  assert.ok(calls.urls[0].includes('/repos/o/r/compare/main...' + SHA), `url was ${calls.urls[0]}`);
+});
+
+test('a custom base is honored', async () => {
+  const { fetchImpl, calls } = mkFetch({ compareStatus: 'behind' });
+  await gh.isAncestorOfDefaultBranch({ sha: SHA, base: 'release' }, DEPS(fetchImpl));
+  assert.ok(calls.urls[0].includes('/compare/release...' + SHA), `url was ${calls.urls[0]}`);
+});
+
+// --- 404 + non-sha guards (the false-positive protections) -----------------
+
+test('404 (unknown commit, never pushed) → false, not an error', async () => {
+  const { fetchImpl } = mkFetch({ status: 404 });
+  assert.equal(await gh.isAncestorOfDefaultBranch({ sha: SHA }, DEPS(fetchImpl)), false);
+});
+
+test('a 5xx → throws (transient, so the caller retries next sweep)', async () => {
+  const { fetchImpl } = mkFetch({ status: 502 });
+  await assert.rejects(() => gh.isAncestorOfDefaultBranch({ sha: SHA }, DEPS(fetchImpl)), /STATUS_FETCH_FAILED/);
+});
+
+test('a ref like "HEAD" is rejected BEFORE any fetch (would resolve to main → false-positive)', async () => {
+  const { fetchImpl, calls } = mkFetch({ compareStatus: 'identical' });
+  assert.equal(await gh.isAncestorOfDefaultBranch({ sha: 'HEAD' }, DEPS(fetchImpl)), false);
+  assert.equal(calls.urls.length, 0, 'must not hit the compare API with a non-sha ref');
+});
+
+test('a branch name is rejected before any fetch', async () => {
+  const { fetchImpl, calls } = mkFetch({ compareStatus: 'identical' });
+  assert.equal(await gh.isAncestorOfDefaultBranch({ sha: 'claude/some-branch' }, DEPS(fetchImpl)), false);
+  assert.equal(calls.urls.length, 0);
+});
+
+test('null / undefined / empty sha → false, no fetch', async () => {
+  const { fetchImpl, calls } = mkFetch({});
+  assert.equal(await gh.isAncestorOfDefaultBranch({ sha: null }, DEPS(fetchImpl)), false);
+  assert.equal(await gh.isAncestorOfDefaultBranch({}, DEPS(fetchImpl)), false);
+  assert.equal(await gh.isAncestorOfDefaultBranch({ sha: '' }, DEPS(fetchImpl)), false);
+  assert.equal(calls.urls.length, 0);
+});
+
+// Drain the microtask queue, then report + exit with the right code.
+setTimeout(() => {
+  console.log(`\nisAncestorOfDefaultBranch (task 1313) tests: ${passed} passed, ${failed} failed`);
+  process.exit(failed > 0 ? 1 : 0);
+}, 100);

package/tests/github_push_land_proof.mjs

@@ -0,0 +1,127 @@
+// tests/github_push_land_proof.mjs
+//
+// Unit tests for the task-1547 per-task land proof in src/bongos/github-push.js — the
+// fix for the confirmed->shipped FALSE-ship on a reused worktree branch. getPublishStatus
+// matches the most-recent PR for a branch NAME, and worktree branch names get reused, so a
+// merged-but-OLDER PR (the BV1.R04/R05 strand: branch claude/jovial-rosalind-84d6c3 had
+// earlier been PR #386 / task 1297) could satisfy landConfirmed for a task whose own push
+// never landed. landProvenForTask requires THIS task's published tip to be in main (robust),
+// or — when no tip was recorded — that the matched PR references this task id.
+//
+// Also covers prReferencesTask + scrubCredential. Pure w.r.t. injected token/repoInfo/
+// fetchImpl, so this runs in the DB-free, network-free unit gate.
+//
+// Run:  node tests/github_push_land_proof.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const gh = require('../modules/lifecycle/github-push.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  Promise.resolve()
+    .then(fn)
+    .then(() => { passed++; console.log(`  ok  ${name}`); })
+    .catch((err) => { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); });
+}
+
+const SHA = 'd79fda340138111931134ff0de8368b986e9e15a';
+
+// Inject a compare-API response for isAncestorOfDefaultBranch (used by landProvenForTask).
+function depsWithCompare(compareStatus) {
+  return {
+    token: 'x',
+    repoInfo: { owner: 'o', repo: 'r' },
+    fetchImpl: async () => ({ ok: true, status: 200, json: async () => ({ status: compareStatus }) }),
+  };
+}
+
+// --- prReferencesTask (pure) -------------------------------------------------
+
+test('prReferencesTask: server PR body "for task 1299" matches task 1299', () => {
+  assert.equal(gh.prReferencesTask({ pr_body: 'Auto-opened … for task 1299.' }, 1299), true);
+});
+
+test('prReferencesTask: PR title "task 1299: …" matches task 1299', () => {
+  assert.equal(gh.prReferencesTask({ pr_title: 'task 1299: floating toolbar' }, 1299), true);
+});
+
+test('prReferencesTask: a DIFFERENT task id does NOT match (the branch-reuse case)', () => {
+  // PR #386 was task 1297; the reused branch must not bind it to 1299.
+  assert.equal(gh.prReferencesTask({ pr_title: 'task 1297: overlay', pr_body: 'for task 1297' }, 1299), false);
+});
+
+test('prReferencesTask: word-boundary — task 1299 does not match a prefix of 12990', () => {
+  assert.equal(gh.prReferencesTask({ pr_body: 'for task 12990' }, 1299), false);
+});
+
+test('prReferencesTask: null status / bad id → false', () => {
+  assert.equal(gh.prReferencesTask(null, 1299), false);
+  assert.equal(gh.prReferencesTask({ pr_body: 'for task 1299' }, null), false);
+});
+
+// --- landProvenForTask -------------------------------------------------------
+
+test('landProvenForTask: published tip in main → proven', async () => {
+  const r = await gh.landProvenForTask({ taskId: 1, publishedSha: SHA, status: null }, depsWithCompare('behind'));
+  assert.equal(r.proven, true);
+  assert.match(r.reason, /in main/);
+});
+
+test('landProvenForTask: published tip NOT in main → NOT proven (the false-ship guard)', async () => {
+  const r = await gh.landProvenForTask({ taskId: 1, publishedSha: SHA, status: { merged: true } }, depsWithCompare('ahead'));
+  assert.equal(r.proven, false);
+  assert.match(r.reason, /not in main/);
+});
+
+test('landProvenForTask: no published tip but matched PR references this task → proven (legacy fallback)', async () => {
+  const r = await gh.landProvenForTask(
+    { taskId: 999, publishedSha: null, status: { pr_body: 'for task 999' } },
+    depsWithCompare('behind') // must NOT be consulted — no sha
+  );
+  assert.equal(r.proven, true);
+  assert.match(r.reason, /references task 999/);
+});
+
+test('landProvenForTask: no published tip and matched PR references a DIFFERENT task → NOT proven', async () => {
+  const r = await gh.landProvenForTask(
+    { taskId: 1299, publishedSha: null, status: { pr_title: 'task 1297: overlay', pr_body: 'for task 1297' } },
+    depsWithCompare('behind')
+  );
+  assert.equal(r.proven, false);
+});
+
+test('landProvenForTask: a non-sha published tip ("HEAD") falls back to the PR check, never the compare API', async () => {
+  let compareCalled = false;
+  const deps = {
+    token: 'x',
+    repoInfo: { owner: 'o', repo: 'r' },
+    fetchImpl: async () => { compareCalled = true; return { ok: true, status: 200, json: async () => ({ status: 'behind' }) }; },
+  };
+  const r = await gh.landProvenForTask({ taskId: 5, publishedSha: 'HEAD', status: null }, deps);
+  assert.equal(r.proven, false, 'no PR ref and a non-sha tip → not proven');
+  assert.equal(compareCalled, false, 'a non-sha tip must never reach the compare API (would false-positive)');
+});
+
+// --- scrubCredential ---------------------------------------------------------
+
+test('scrubCredential: strips the x-access-token push credential from captured output', () => {
+  const dirty = "fatal: unable to access 'https://x-access-token:ghs_SECRET123@github.com/o/r.git/'";
+  const clean = gh.scrubCredential(dirty);
+  assert.ok(!clean.includes('ghs_SECRET123'), 'token value must be gone');
+  assert.ok(clean.includes('x-access-token:***@'), 'credential is redacted in place');
+});
+
+test('scrubCredential: redacts bare GitHub token forms too', () => {
+  assert.ok(!gh.scrubCredential('using ghp_abc123DEF').includes('ghp_abc123DEF'));
+  assert.match(gh.scrubCredential('using ghp_abc123DEF'), /ghp_\*\*\*/);
+});
+
+// Drain the microtask queue, then report + exit with the right code.
+setTimeout(() => {
+  console.log(`\ngithub-push land proof (task 1547) tests: ${passed} passed, ${failed} failed`);
+  process.exit(failed > 0 ? 1 : 0);
+}, 100);

package/tests/github_push_merge_driver.mjs

@@ -0,0 +1,175 @@
+// tests/github_push_merge_driver.mjs
+//
+// Unit tests for the active merge driver (task 1162) in src/bongos/github-push.js —
+// the server-side cure for a stalled GitHub auto-merge daemon (the PR #125 case:
+// all checks green + CLEAN, auto-merge re-armed on an already-green PR, never
+// fires, PR sits open forever, task strands at confirmed).
+//
+// getMergeState / mergeIfGreen / mergeBlockReason are pure w.r.t. injected
+// token/repoInfo/fetchImpl, so this runs in the DB-free, network-free unit gate.
+//
+// Run:  node tests/github_push_merge_driver.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const gh = require('../modules/lifecycle/github-push.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  Promise.resolve()
+    .then(fn)
+    .then(() => { passed++; console.log(`  ok  ${name}`); })
+    .catch((err) => { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); });
+}
+
+// Build a GraphQL pull-request node and a fetchImpl that serves it for the
+// graphql call and records any merge PUT. mergeStatus controls the merge API.
+function mkFetch({ node, mergeStatus = 200, mergeBody = '{}' } = {}) {
+  const calls = { graphql: 0, merge: 0, mergeArgs: null };
+  const fetchImpl = async (url, opts = {}) => {
+    if (String(url).includes('/graphql')) {
+      calls.graphql++;
+      const nodes = node ? [node] : [];
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ data: { repository: { pullRequests: { nodes } } } }),
+      };
+    }
+    if (String(url).includes('/merge')) {
+      calls.merge++;
+      calls.mergeArgs = { url, body: JSON.parse(opts.body || '{}') };
+      return {
+        ok: mergeStatus >= 200 && mergeStatus < 300,
+        status: mergeStatus,
+        json: async () => JSON.parse(mergeBody),
+        text: async () => mergeBody,
+      };
+    }
+    throw new Error(`unexpected fetch: ${url}`);
+  };
+  return { fetchImpl, calls };
+}
+
+const DEPS = (fetchImpl) => ({ token: 't', repoInfo: { owner: 'o', repo: 'r' }, fetchImpl });
+
+function prNode({ state = 'OPEN', merged = false, mergeable = 'MERGEABLE', mergeStateStatus = 'CLEAN', reviewDecision = null, rollup = 'SUCCESS', checks = [], oid = 'deadbee' } = {}) {
+  return {
+    number: 125, id: 'PR_node', state, merged, mergeable, reviewDecision, mergeStateStatus,
+    commits: { nodes: [{ commit: { oid,
+      statusCheckRollup: { state: rollup, contexts: { nodes: checks } } } }] },
+  };
+}
+
+// --- getMergeState parsing -------------------------------------------------
+
+test('getMergeState parses state, mergeability, checks, head sha', async () => {
+  const checks = [
+    { __typename: 'CheckRun', name: 'unit', conclusion: 'SUCCESS', status: 'COMPLETED' },
+    { __typename: 'StatusContext', context: 'trufflehog', state: 'SUCCESS' },
+  ];
+  const { fetchImpl } = mkFetch({ node: prNode({ checks }) });
+  const s = await gh.getMergeState({ branch: 'claude/wt' }, DEPS(fetchImpl));
+  assert.equal(s.pr_state, 'open');
+  assert.equal(s.merged, false);
+  assert.equal(s.mergeable, 'MERGEABLE');
+  assert.equal(s.merge_state, 'CLEAN');
+  assert.equal(s.head_sha, 'deadbee');
+  assert.equal(s.checks.length, 2);
+  assert.equal(s.checks[1].name, 'trufflehog');     // StatusContext mapped to {name,conclusion}
+  assert.equal(s.checks[1].conclusion, 'SUCCESS');
+});
+
+test('getMergeState on no PR → pr_state none, empty checks', async () => {
+  const { fetchImpl } = mkFetch({ node: null });
+  const s = await gh.getMergeState({ branch: 'claude/wt' }, DEPS(fetchImpl));
+  assert.equal(s.pr_state, 'none');
+  assert.equal(s.merged, false);
+  assert.deepEqual(s.checks, []);
+});
+
+// --- mergeIfGreen decision -------------------------------------------------
+
+test('CLEAN + MERGEABLE → performs the merge (merged_now), pins head sha', async () => {
+  const { fetchImpl, calls } = mkFetch({ node: prNode({ oid: 'abc1234' }) });
+  const r = await gh.mergeIfGreen({ branch: 'claude/wt' }, DEPS(fetchImpl));
+  assert.equal(r.merged, true);
+  assert.equal(r.merged_now, true);
+  assert.equal(calls.merge, 1, 'the merge API was called exactly once');
+  assert.equal(calls.mergeArgs.body.merge_method, 'merge');
+  assert.equal(calls.mergeArgs.body.sha, 'abc1234', 'expected head sha pinned on the merge');
+});
+
+test('already merged → merged:true, merged_now:false, NO merge API call', async () => {
+  const { fetchImpl, calls } = mkFetch({ node: prNode({ state: 'MERGED', merged: true }) });
+  const r = await gh.mergeIfGreen({ branch: 'claude/wt' }, DEPS(fetchImpl));
+  assert.equal(r.merged, true);
+  assert.equal(r.merged_now, false);
+  assert.equal(calls.merge, 0);
+});
+
+test('BLOCKED (required review) → no merge, reason surfaced', async () => {
+  const { fetchImpl, calls } = mkFetch({
+    node: prNode({ mergeStateStatus: 'BLOCKED', reviewDecision: 'REVIEW_REQUIRED' }),
+  });
+  const r = await gh.mergeIfGreen({ branch: 'claude/wt' }, DEPS(fetchImpl));
+  assert.equal(r.merged, false);
+  assert.equal(r.merged_now, false);
+  assert.equal(r.reason, 'review_required');
+  assert.equal(calls.merge, 0, 'a review-gated PR is never force-merged');
+});
+
+test('mergeability still computing (UNKNOWN) → no merge, reason mergeability_computing', async () => {
+  const { fetchImpl, calls } = mkFetch({
+    node: prNode({ mergeable: 'UNKNOWN', mergeStateStatus: 'UNKNOWN' }),
+  });
+  const r = await gh.mergeIfGreen({ branch: 'claude/wt' }, DEPS(fetchImpl));
+  assert.equal(r.merged, false);
+  assert.equal(r.reason, 'mergeability_computing');
+  assert.equal(calls.merge, 0);
+});
+
+test('conflict (DIRTY/CONFLICTING) → no merge, reason merge_conflict', async () => {
+  const { fetchImpl } = mkFetch({
+    node: prNode({ mergeable: 'CONFLICTING', mergeStateStatus: 'DIRTY' }),
+  });
+  const r = await gh.mergeIfGreen({ branch: 'claude/wt' }, DEPS(fetchImpl));
+  assert.equal(r.reason, 'merge_conflict');
+});
+
+test('merge API 405 (not allowed) → merged false, reason merge_api_405', async () => {
+  const { fetchImpl } = mkFetch({ node: prNode(), mergeStatus: 405, mergeBody: '{"message":"not mergeable"}' });
+  const r = await gh.mergeIfGreen({ branch: 'claude/wt' }, DEPS(fetchImpl));
+  assert.equal(r.merged, false);
+  assert.equal(r.reason, 'merge_api_405');
+});
+
+test('no open PR → reason no_open_pr, no merge call', async () => {
+  const { fetchImpl, calls } = mkFetch({ node: prNode({ state: 'CLOSED', merged: false }) });
+  const r = await gh.mergeIfGreen({ branch: 'claude/wt' }, DEPS(fetchImpl));
+  assert.equal(r.reason, 'no_open_pr');
+  assert.equal(calls.merge, 0);
+});
+
+// --- mergeBlockReason mapping ---------------------------------------------
+
+test('mergeBlockReason maps the common blocker states', () => {
+  const open = { pr_state: 'open', merged: false, checks: [] };
+  assert.equal(gh.mergeBlockReason({ ...open, mergeable: 'CONFLICTING', merge_state: 'DIRTY' }), 'merge_conflict');
+  assert.equal(gh.mergeBlockReason({ ...open, merge_state: 'BEHIND' }), 'branch_behind_base');
+  assert.equal(gh.mergeBlockReason({ ...open, merge_state: 'DRAFT' }), 'draft_pr');
+  assert.equal(gh.mergeBlockReason({ ...open, review_decision: 'CHANGES_REQUESTED' }), 'changes_requested');
+  assert.equal(
+    gh.mergeBlockReason({ ...open, merge_state: 'BLOCKED', checks: [{ name: 'unit', conclusion: 'FAILURE' }] }),
+    'failing_check:unit'
+  );
+  assert.equal(gh.mergeBlockReason({ ...open, merged: true }), null);
+});
+
+setTimeout(() => {
+  console.log(`\ngithub-push merge driver (task 1162) tests: ${passed} passed, ${failed} failed`);
+  process.exit(failed > 0 ? 1 : 0);
+}, 100);