atris 3.69.0 → 3.71.0

package/lib/member-autoland.js

@@ -4,8 +4,11 @@
 // GitHub auto-merge. Every local gate fails closed: the branch stays put and
 // one plain line says which gate held it. GitHub then waits for the branch to
 // be up to date and CI green; this never merges, rebases, or polls itself.
+// The one exception is a project with no remote: there the branch merges into
+// the main checkout's branch on this computer, past the same gates.
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const {
@@ -14,15 +17,18 @@ const {
   sniffedProtectedLane,
 } = require('./auto-accept-certified');
 const { isDecisionHoldTag, isDecisionTask } = require('./task-decision');
+const { inboxMapEdits } = require('./member-map-inbox');
 
 // Git replacement refs can make a local check read different code than the
 // commit that gets pushed; every git and gh call here ignores them.
-function run(cmd, args, cwd) {
-  const env = { ...process.env, GIT_NO_REPLACE_OBJECTS: '1' };
+function run(cmd, args, cwd, extraEnv = {}, { raw = false } = {}) {
+  const env = { ...process.env, ...extraEnv, GIT_NO_REPLACE_OBJECTS: '1' };
   const res = spawnSync(cmd, args, { cwd, encoding: 'utf8', timeout: 120000, env });
+  const stdout = String(res.stdout || '');
   return {
     ok: res.status === 0,
-    stdout: String(res.stdout || '').trim(),
+    status: res.status,
+    stdout: raw ? stdout : stdout.trim(),
     stderr: String(res.stderr || res.error?.message || '').trim(),
   };
 }
@@ -251,11 +257,193 @@ function unsavedHold(cwd) {
   return null;
 }
 
+// Files where every side only adds lines: map files, the map notes file, and
+// member logs. A clash in these keeps both sides' lines instead of holding.
+const MAP_FILE = /(?:^|\/)MAP(?:-NOTES)?\.md$|^atris\/team\/[^/]+\/logs\/[^/]+\.md$/;
+
+// Keep both sides' lines of one clashing map file, as a stored blob. A file
+// both sides created, like the same day's member log, merges against empty.
+function unionMapBlob(file, mergeBase, ours, theirs, cwd, tmp) {
+  const sides = [];
+  for (const [name, rev] of [['base', mergeBase], ['ours', ours], ['theirs', theirs]]) {
+    const blob = run('git', ['cat-file', 'blob', `${rev}:${file}`], cwd, {}, { raw: true });
+    if (!blob.ok && name !== 'base') return null;
+    const out = path.join(tmp, name);
+    fs.writeFileSync(out, blob.ok ? blob.stdout : '');
+    sides.push(out);
+  }
+  const merged = run('git', ['merge-file', '-p', '--union', sides[1], sides[0], sides[2]], cwd, {}, { raw: true });
+  if (!merged.ok) return null;
+  const out = path.join(tmp, 'merged');
+  fs.writeFileSync(out, merged.stdout);
+  const blob = run('git', ['hash-object', '-w', out], cwd);
+  return blob.ok && /^[0-9a-f]{40,64}$/.test(blob.stdout) ? blob.stdout : null;
+}
+
+// Merge the main branch into the reviewed commit without touching the
+// checkout. Edits to the shared map files first move to the map inbox in a
+// commit on top of the reviewed commit, so they never clash. A clean merge
+// pushes that commit as is. When every clash is a map file or member log, both
+// sides' lines are kept and a merge commit is pushed instead, so GitHub has
+// nothing left to resolve. Any other clash holds. With catchUp, a clean merge
+// against a main branch that moved also becomes a merge commit, so the branch
+// is up to date. With localBase, the main branch is the local one and nothing
+// is fetched.
+function mergeWithBase(reviewedSha, base, branch, cwd, { catchUp = false, localBase = false } = {}) {
+  const baseRef = localBase ? `refs/heads/${base}` : `refs/remotes/origin/${base}`;
+  if (!localBase) {
+    const fetched = run('git', ['fetch', '-q', 'origin', `+refs/heads/${base}:${baseRef}`], cwd);
+    if (!fetched.ok) return { hold: `the main branch could not be fetched (${fetched.stderr.split('\n')[0]})` };
+  }
+  const baseRead = run('git', ['rev-parse', baseRef], cwd);
+  const baseSha = baseRead.ok ? baseRead.stdout : '';
+  if (!/^[0-9a-f]{40,64}$/.test(baseSha)) return { hold: 'the main branch could not be read' };
+  const inboxed = inboxMapEdits({ headSha: reviewedSha, baseSha, branch, cwd });
+  if (inboxed.hold) return { hold: inboxed.hold };
+  const headSha = inboxed.sha;
+  const mapInboxed = inboxed.moved;
+  const tree = run('git', ['merge-tree', '--write-tree', '--name-only', headSha, baseSha], cwd);
+  if (tree.status === 0) {
+    if (!catchUp) return { sha: headSha, mapInboxed };
+    if (headSha === reviewedSha && run('git', ['merge-base', '--is-ancestor', baseSha, headSha], cwd).ok) {
+      return { sha: headSha, current: true };
+    }
+    const commit = run('git', [
+      'commit-tree', tree.stdout.split(/\r?\n/)[0], '-p', headSha, '-p', baseSha,
+      '-m', `Merge ${base} into ${branch} to catch up`,
+    ], cwd);
+    if (!commit.ok || !/^[0-9a-f]{40,64}$/.test(commit.stdout)) return { hold: 'the catch-up merge could not be saved' };
+    return { sha: commit.stdout, mapInboxed };
+  }
+  if (tree.status !== 1) return { hold: 'the branch could not be compared with the main branch' };
+  const [treeId, ...files] = tree.stdout.split(/\r?\n\r?\n/)[0].split(/\r?\n/).filter(Boolean);
+  const clashes = files.filter((file) => !MAP_FILE.test(file));
+  if (!files.length || clashes.length) {
+    return { hold: `the branch clashes with the main branch in ${(clashes.length ? clashes : ['unknown files']).join(', ')}` };
+  }
+  const bases = run('git', ['merge-base', '--all', headSha, baseSha], cwd);
+  const mergeBase = bases.ok ? bases.stdout.split('\n').filter(Boolean) : [];
+  if (mergeBase.length !== 1) return { hold: 'the branch and the main branch share no single starting point' };
+
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-map-merge-'));
+  try {
+    const index = { GIT_INDEX_FILE: path.join(tmp, 'index') };
+    if (!run('git', ['read-tree', treeId], cwd, index).ok) return { hold: 'the merged map could not be built' };
+    for (const file of files) {
+      const blob = unionMapBlob(file, mergeBase[0], headSha, baseSha, cwd, tmp);
+      const mode = (run('git', ['ls-tree', headSha, '--', file], cwd).stdout.match(/^(\d{6}) blob /) || [])[1];
+      if (!blob || !mode) return { hold: `the map file ${file} could not be merged line by line` };
+      if (!run('git', ['update-index', '--cacheinfo', `${mode},${blob},${file}`], cwd, index).ok) {
+        return { hold: 'the merged map could not be built' };
+      }
+    }
+    const merged = run('git', ['write-tree'], cwd, index);
+    if (!merged.ok) return { hold: 'the merged map could not be built' };
+    const commit = run('git', [
+      'commit-tree', merged.stdout, '-p', headSha, '-p', baseSha,
+      '-m', `Merge ${base} into ${branch}, keeping map lines from both sides`,
+    ], cwd);
+    if (!commit.ok || !/^[0-9a-f]{40,64}$/.test(commit.stdout)) return { hold: 'the map merge could not be saved' };
+    return { sha: commit.stdout, mapMerged: files, mapInboxed };
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// Every branch autoland handed to GitHub, so a sweep can tell when GitHub
+// dropped one. Lives in the main checkout beside the policy.
+function queueFile(cwd) {
+  const root = mainCheckoutRoot(cwd);
+  return root ? path.join(root, '.atris', 'state', 'autoland-queue.json') : null;
+}
+
+function readQueue(file) {
+  try {
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (data && typeof data.entries === 'object' && !Array.isArray(data.entries)) return data.entries;
+  } catch {}
+  return {};
+}
+
+function writeQueue(file, entries) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify({ schema: 'atris.autoland_queue.v1', entries }, null, 2)}\n`);
+  fs.renameSync(tmp, file);
+}
+
+function recordQueued(cwd, entry) {
+  const file = queueFile(cwd);
+  if (!file) return;
+  try {
+    const entries = readQueue(file);
+    entries[entry.branch] = entry;
+    writeQueue(file, entries);
+  } catch {}
+}
+
 function held(gate, line) {
   return { merged: false, auto_merge: false, gate, line: `left the branch for you: ${line}` };
 }
 
-function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', loadTask = defaultLoadTask } = {}) {
+function hasOrigin(cwd) {
+  return run('git', ['remote', 'get-url', 'origin'], cwd).ok;
+}
+
+// The branch the main checkout is on, or '' when it is not on one.
+function mainCheckoutBranch(cwd) {
+  const root = mainCheckoutRoot(cwd);
+  const read = root ? run('git', ['symbolic-ref', '--quiet', '--short', 'HEAD'], root) : null;
+  return read?.ok ? read.stdout : '';
+}
+
+// Where a finished run's work goes, as one plain line for the start of a run.
+function landingDestination(cwd) {
+  if (!policyOn(cwd)) return 'finished work stays on its own branch for you; self-landing is off';
+  if (!hasOrigin(cwd)) {
+    const base = mainCheckoutBranch(cwd);
+    return `finished work merges into ${base || 'the main branch'} on this computer once its check and review pass`;
+  }
+  return 'finished work goes to GitHub as a pull request that merges itself once checks pass';
+}
+
+// A project with no remote has no GitHub to hand the branch to, so the main
+// checkout's own branch is the target. The reviewed commit catches up with it
+// without touching any checkout, then the main checkout fast-forwards to that
+// commit, which refuses rather than overwrite anything there.
+function landLocally({ headSha, branch, cwd, pinnedTree }) {
+  const root = mainCheckoutRoot(cwd);
+  const base = mainCheckoutBranch(cwd);
+  if (!root || !base) return held('base', 'the main checkout is not on a branch');
+  if (base === branch) return held('branch', 'the work is not on its own branch');
+  const mainState = gitCodeState(root);
+  if (mainState.hidden || codeStatus(mainState) !== '') {
+    return held('unsaved', 'the main checkout has unsaved changes; merging there could mix them in');
+  }
+  const landing = mergeWithBase(headSha, base, branch, cwd, { catchUp: true, localBase: true });
+  if (landing.hold) return held('conflict', landing.hold);
+  if (!pinnedTree()) return held('review', 'the reviewed commit no longer holds the reviewed code');
+  const forward = run('git', ['merge', '--ff-only', '-q', landing.sha], root);
+  if (!forward.ok) return held('merge', `the main checkout could not move forward (${forward.stderr.split('\n')[0]})`);
+  const mapNote = landing.mapInboxed?.length ? ' (map edits saved to the map inbox)'
+    : landing.mapMerged ? ' (map lines from both sides kept)' : '';
+  return {
+    merged: true,
+    auto_merge: false,
+    local: true,
+    gate: null,
+    base,
+    landed: landing.sha,
+    map_merged: landing.mapMerged || [],
+    map_inboxed: landing.mapInboxed || [],
+    line: `merged into ${base} on this computer${mapNote}; this project has no GitHub remote`,
+  };
+}
+
+// closeTaskIds: jobs taken off the list for this run. They only ride along
+// so the sweep can close them once the change merges; unlike the mission's
+// own linked tasks they do not gate the landing.
+function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', loadTask = defaultLoadTask, closeTaskIds = [] } = {}) {
   if (!mission || typeof mission !== 'object') return held('mission', 'the mission could not be read');
   if (mission.verifier_result?.passed !== true) return held('check', 'the check did not pass');
   if (!policyOn(cwd)) return held('policy', 'self-landing is not switched on in the main checkout');
@@ -274,6 +462,12 @@ function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', load
     if (!task || typeof task !== 'object') return held('protected', `a linked task (${id}) could not be read`);
     const lane = protectedLane(task);
     if (lane) return held('protected', `a linked task sits in a protected area (${lane})`);
+    // A passing run cannot override a person's send-back. Read the current
+    // task, not historical events: submitting fresh proof resets it to pending.
+    const approvals = [task.review?.approval_status, task.metadata?.approval_status];
+    if (approvals.some((value) => ['revise', 'revised', 'rejected'].includes(String(value || '').trim().toLowerCase()))) {
+      return held('approval', 'a linked task was turned down; it needs fresh proof before it can go to github');
+    }
   }
 
   const unsaved = unsavedHold(cwd);
@@ -281,8 +475,9 @@ function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', load
   const pin = {};
   const reviewGap = reviewHold(mission, workerEngine, cwd, pin);
   if (reviewGap) return held('review', reviewGap);
-  // Pin the commit the review passed on. Only this commit is pushed and
-  // merged, so a commit made after this point never rides along.
+  // Pin the commit the review passed on. Only this commit (or a map-only
+  // merge built on it) is pushed and merged, so a commit made after this
+  // point never rides along.
   const headRead = run('git', ['rev-parse', 'HEAD'], cwd);
   const headSha = headRead.ok ? headRead.stdout : '';
   if (!/^[0-9a-f]{40,64}$/.test(headSha)) return held('branch', 'the latest commit could not be read');
@@ -297,13 +492,18 @@ function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', load
   if (!branch || branch === 'HEAD' || branch === 'master' || branch === 'main') {
     return held('branch', 'the work is not on its own branch');
   }
-  const remoteHead = run('git', ['ls-remote', '--symref', 'origin', 'HEAD'], cwd);
+  if (!hasOrigin(cwd)) return landLocally({ headSha, branch, cwd, pinnedTree });
+  const remoteHead =run('git', ['ls-remote', '--symref', 'origin', 'HEAD'], cwd);
   const base = (remoteHead.stdout.match(/^ref: refs\/heads\/(\S+)\s+HEAD$/m) || [])[1] || '';
   if (!remoteHead.ok || !base) return held('base', 'the main branch on GitHub could not be read');
   if (branch === base) return held('branch', 'the work is not on its own branch');
 
+  const landing = mergeWithBase(headSha, base, branch, cwd);
+  if (landing.hold) return held('conflict', landing.hold);
+  const pushSha = landing.sha;
+
   if (!pinnedTree()) return held('review', 'the reviewed commit no longer holds the reviewed code');
-  const push = run('git', ['push', 'origin', `${headSha}:refs/heads/${branch}`], cwd);
+  const push = run('git', ['push', 'origin', `${pushSha}:refs/heads/${branch}`], cwd);
   if (!push.ok) return held('push', `the branch could not be pushed (${push.stderr.split('\n')[0]})`);
 
   // Find the open pull request from exactly this branch into the main
@@ -338,13 +538,282 @@ function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', load
   }
   const label = url || `pull request #${number}`;
 
-  const merge = run('gh', ['pr', 'merge', String(number), '--auto', '--merge', '--match-head-commit', headSha], cwd);
+  const merge = run('gh', ['pr', 'merge', String(number), '--auto', '--merge', '--match-head-commit', pushSha], cwd);
   if (!merge.ok) return held('auto-merge', `auto-merge could not be switched on for ${label}`);
-  return { merged: false, auto_merge: true, gate: null, url: label, line: `merges on its own once checks pass: ${label}` };
+  recordQueued(cwd, {
+    branch, base, number, pushed: pushSha, mission_id: mission.id || null,
+    task_ids: [...new Set([...taskIds, ...(Array.isArray(closeTaskIds) ? closeTaskIds : [])
+      .filter((id) => typeof id === 'string' && id.trim()).map((id) => id.trim())])],
+    requeues: 0, queued_at: new Date().toISOString(),
+  });
+  const mapNote = landing.mapInboxed?.length ? ' (map edits saved to the map inbox)'
+    : landing.mapMerged ? ' (map lines from both sides kept)' : '';
+  return {
+    merged: false,
+    auto_merge: true,
+    gate: null,
+    url: label,
+    pushed: pushSha,
+    map_merged: landing.mapMerged || [],
+    map_inboxed: landing.mapInboxed || [],
+    line: `merges on its own once checks pass${mapNote}: ${label}`,
+  };
+}
+
+const MAX_REQUEUES = 3;
+
+// One queued branch: leave it, forget it, or catch it up and queue it again.
+// Only the exact commit autoland queued (or its own catch-up) is re-queued; a
+// push by anyone else, a closed pull request, or a real clash leaves it.
+// GitHub keeps auto-merge on when master moves under a queued branch and the
+// two clash, so a clashing branch is caught up even while still queued.
+// GitHub runs holding a failed check on this pull request. gh exits nonzero
+// when any check failed, so the list is read either way.
+function failedCheckRuns(number, cwd) {
+  const out = run('gh', ['pr', 'checks', String(number), '--json', 'bucket,link'], cwd);
+  let checks = [];
+  try {
+    checks = JSON.parse(out.stdout || '[]');
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(checks)) return [];
+  const ids = checks
+    .filter((check) => check && check.bucket === 'fail')
+    .map((check) => (String(check.link || '').match(/\/actions\/runs\/(\d+)/) || [])[1])
+    .filter(Boolean);
+  return [...new Set(ids)];
+}
+
+function inMergeQueue(number, cwd) {
+  const out = run('gh', ['api', 'graphql', '-F', 'owner={owner}', '-F', 'name={repo}', '-F', `number=${number}`,
+    '-f', 'query=query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){pullRequest(number:$number){isInMergeQueue}}}',
+    '--jq', '.data.repository.pullRequest.isInMergeQueue'], cwd);
+  return out.ok && out.stdout === 'true';
+}
+
+function requeueOne(entry, cwd, maxRequeues) {
+  const { branch, base, number } = entry;
+  const label = `pull request #${number} (${branch})`;
+  const keep = (state, line) => ({ branch, number, state, keep: true, line: `${label}: ${line}` });
+  const forget = (state, line) => ({ branch, number, state, keep: false, line: `${label}: ${line}` });
+  const viewed = run('gh', ['pr', 'view', String(number), '--json',
+    'number,state,headRefName,baseRefName,headRefOid,isCrossRepository,autoMergeRequest,mergeable'], cwd);
+  let pr = null;
+  try {
+    pr = viewed.ok ? JSON.parse(viewed.stdout) : null;
+  } catch {
+    pr = null;
+  }
+  if (!pr || typeof pr !== 'object') return keep('unreadable', 'github could not be read; will look again');
+  // Only the commit autoland pushed counts as the member's own change; a merge
+  // that carried someone else's push leaves the job for a person.
+  if (pr.state === 'MERGED') {
+    if (pr.headRefOid !== entry.pushed) return forget('merged', 'merged with commits someone else pushed; its job is left for you');
+    return { ...forget('merged', 'merged'), own: true };
+  }
+  if (pr.state !== 'OPEN') return forget('closed', 'closed by someone; left alone');
+  if (pr.headRefName !== branch || pr.baseRefName !== base || pr.isCrossRepository !== false) {
+    return forget('moved', 'no longer points from this branch into the main branch; left for you');
+  }
+  // In GitHub's merge line a change shows no auto-merge request and its
+  // branch is locked, so a catch-up push there fails. Leave it to the line.
+  if (!pr.autoMergeRequest && inMergeQueue(number, cwd)) return keep('queued', 'in github\'s merge line');
+  if (pr.autoMergeRequest && pr.mergeable !== 'CONFLICTING') {
+    // A failed check holds the change forever. Run the failed checks again
+    // once per pushed commit: a test that fails now and then passes, a real
+    // failure fails twice and waits for a fix.
+    const failed = pr.headRefOid === entry.pushed ? failedCheckRuns(number, cwd) : [];
+    if (failed.length && entry.reran !== entry.pushed) {
+      const reran = failed.filter((id) => run('gh', ['run', 'rerun', id, '--failed'], cwd).ok);
+      if (reran.length) return { ...keep('rerun', 'a check failed; ran the failed checks again once'), reran: entry.pushed };
+      return keep('queued', 'a check failed and could not be run again; will look again');
+    }
+    if (failed.length) return keep('failing', 'its checks failed again after one retry; it needs a fix');
+    return keep('queued', 'still queued');
+  }
+  if (pr.headRefOid !== entry.pushed) return forget('changed', 'someone pushed to it after it was queued; left for you');
+  if ((Number(entry.requeues) || 0) >= maxRequeues) {
+    return forget('gave-up', `dropped again after ${maxRequeues} catch-ups; left for you`);
+  }
+  const fetched = run('git', ['fetch', '-q', 'origin', `+refs/heads/${branch}:refs/remotes/origin/${branch}`], cwd);
+  const remote = run('git', ['rev-parse', `refs/remotes/origin/${branch}`], cwd);
+  if (!fetched.ok || !remote.ok || remote.stdout !== entry.pushed) {
+    return keep('unreadable', 'the branch on github could not be read; will look again');
+  }
+  const landing = mergeWithBase(entry.pushed, base, branch, cwd, { catchUp: true });
+  if (landing.hold) return { ...forget('clash', `${landing.hold}; left for you`), why: landing.hold };
+  if (!landing.current) {
+    const push = run('git', ['push', 'origin', `${landing.sha}:refs/heads/${branch}`], cwd);
+    if (!push.ok) return keep('push', `the catch-up could not be pushed (${push.stderr.split('\n')[0]})`);
+  }
+  const merge = run('gh', ['pr', 'merge', String(number), '--auto', '--merge', '--match-head-commit', landing.sha], cwd);
+  // The catch-up may already be on github; carry it so the next look does not
+  // mistake our own push for someone else's.
+  if (!merge.ok) return { ...keep('auto-merge', 'auto-merge could not be switched back on; will look again'), pushed: landing.sha };
+  return {
+    branch, number, state: 'requeued', keep: true, pushed: landing.sha,
+    line: `${label}: ${landing.current ? 'queued again' : 'caught up with the main branch and queued again'}`,
+  };
+}
+
+// The job picker's own hold test, so the two never drift apart. A row that
+// cannot be read counts as held.
+function heldAtClose(row) {
+  if (!row || typeof row !== 'object') return true;
+  return Boolean(require('./member-task-pick').heldForPerson(row));
+}
+
+function defaultCloseTask(id, { number }) {
+  const taskDb = require('./task-db');
+  const db = taskDb.open();
+  // A hold put on the job while its change waited to merge still wins: that
+  // job stays for a person.
+  const row = taskDb.getTask(db, id);
+  if (heldAtClose(row)) return { updated: false };
+  const out = taskDb.doneTask(db, {
+    id, actor: 'autoland', allowReview: true, autoAccepted: true,
+    action: 'merged', proof: `its own pull request #${number} merged`,
+  });
+  return { ...out, replaced: row.metadata && row.metadata.replaced_pull_requests };
+}
+
+// The member's own change merged: close every job it was queued for. A job
+// already closed, or one that cannot be read, is left as it is. Each closed
+// job hands back the clashing pull requests its redo replaced.
+function closeMergedJobs(entry, closeTask) {
+  const ids = Array.isArray(entry.task_ids) ? entry.task_ids.filter((id) => typeof id === 'string' && id.trim()) : [];
+  const closed = [];
+  const replaced = [];
+  for (const id of ids) {
+    let out = null;
+    try {
+      out = closeTask(id, { number: entry.number, branch: entry.branch });
+    } catch {
+      out = null;
+    }
+    if (!out || !out.updated) continue;
+    closed.push(id);
+    if (Array.isArray(out.replaced)) replaced.push(...out.replaced);
+  }
+  return { closed, replaced };
+}
+
+// A clashing pull request stayed open after its job's redo merged, one more
+// stale change for a person to sweep (2026-10-15: 29 open, most of them
+// replaced). Close it once the redo merges, unless someone else pushed to it
+// or it is no longer open.
+function closeReplacedPullRequests(replaced, number, cwd) {
+  const closed = [];
+  for (const old of replaced) {
+    if (!old || !Number.isInteger(old.number) || old.number <= 0 || old.number === number) continue;
+    if (closed.includes(old.number)) continue;
+    const viewed = run('gh', ['pr', 'view', String(old.number), '--json', 'state,headRefOid'], cwd);
+    let pr = null;
+    try {
+      pr = viewed.ok ? JSON.parse(viewed.stdout) : null;
+    } catch {
+      pr = null;
+    }
+    if (!pr || pr.state !== 'OPEN' || pr.headRefOid !== old.pushed) continue;
+    const done = run('gh', ['pr', 'close', String(old.number), '--comment',
+      `Replaced by #${number}, which merged. Its job is done.`], cwd);
+    if (done.ok) closed.push(old.number);
+  }
+  return closed;
+}
+
+// A clashing change is dropped from the merge line, and its job used to sit in
+// review forever with one line in a terminal (2026-10-15: fifteen green pull
+// requests stuck clashing, none picked up again). The job goes back on the
+// list instead; the member's next run sees the old branch clashes and starts
+// from the main branch. After two such restarts it stays for a person.
+const MAX_CLASH_RESTARTS = 2;
+
+function defaultSendBack(id, { number, pushed, why }) {
+  const taskDb = require('./task-db');
+  const db = taskDb.open();
+  const row = taskDb.getTask(db, id);
+  if (!row || row.status !== 'review' || heldAtClose(row)) return { reopened: false };
+  const restarts = Number(row.metadata && row.metadata.clash_restarts) || 0;
+  if (restarts >= MAX_CLASH_RESTARTS) return { reopened: false };
+  // Remember the clashing change so the redo's merge can close it.
+  const prior = Array.isArray(row.metadata && row.metadata.replaced_pull_requests) ? row.metadata.replaced_pull_requests : [];
+  return taskDb.reopenTask(db, {
+    id, actor: 'autoland', fromReview: true,
+    metadata: { clash_restarts: restarts + 1, replaced_pull_requests: [...prior, { number, pushed }] },
+    reason: `pull request #${number} could not merge: ${why}; start again from the main branch`,
+  });
+}
+
+function sendBackClashedJobs(entry, why, sendBack) {
+  const ids = Array.isArray(entry.task_ids) ? entry.task_ids.filter((id) => typeof id === 'string' && id.trim()) : [];
+  const sent = [];
+  for (const id of ids) {
+    let out = null;
+    try {
+      out = sendBack(id, { number: entry.number, branch: entry.branch, pushed: entry.pushed, why });
+    } catch {
+      out = null;
+    }
+    if (out && out.reopened) sent.push(id);
+  }
+  return sent;
+}
+
+// Look at every branch autoland queued and re-queue the ones GitHub dropped.
+// A branch whose own change merged closes the jobs it was queued for; one that
+// clashes sends its jobs back on the list.
+function requeueDroppedAutolands({ cwd, maxRequeues = MAX_REQUEUES, closeTask = defaultCloseTask, sendBack = defaultSendBack } = {}) {
+  const file = queueFile(cwd);
+  if (!file) return { checked: 0, results: [], line: 'not inside a git checkout' };
+  if (!policyOn(cwd)) return { checked: 0, results: [], line: 'self-landing is not switched on in the main checkout' };
+  const entries = readQueue(file);
+  const results = [];
+  for (const [key, entry] of Object.entries(entries)) {
+    const valid = entry && typeof entry.branch === 'string' && entry.branch === key && typeof entry.base === 'string'
+      && Number.isInteger(entry.number) && entry.number > 0 && /^[0-9a-f]{40,64}$/.test(String(entry.pushed || ''));
+    const result = valid ? requeueOne(entry, cwd, maxRequeues)
+      : { branch: key, state: 'unreadable', keep: false, line: `${key}: queue entry could not be read; dropped from the list` };
+    if (valid && result.own) {
+      const merged = closeMergedJobs(entry, closeTask);
+      result.closed = merged.closed;
+      const n = result.closed.length;
+      if (n) result.line += `; closed ${n === 1 ? 'its job' : `its ${n} jobs`}`;
+      result.replaced = closeReplacedPullRequests(merged.replaced, entry.number, cwd);
+      if (result.replaced.length) {
+        result.line += `; closed the clashing ${result.replaced.length === 1 ? 'change' : 'changes'} it replaced (${result.replaced.map((r) => `#${r}`).join(', ')})`;
+      }
+    }
+    if (valid && result.state === 'clash') {
+      result.sent_back = sendBackClashedJobs(entry, result.why, sendBack);
+      const n = result.sent_back.length;
+      if (n) result.line = result.line.replace(/; left for you$/, `; ${n === 1 ? 'its job went' : `its ${n} jobs went`} back on the list`);
+    }
+    results.push(result);
+    if (!result.keep) delete entries[key];
+    else if (result.state === 'requeued' || (result.pushed && result.pushed !== entry.pushed)) {
+      entries[key] = { ...entry, pushed: result.pushed, requeues: (Number(entry.requeues) || 0) + 1, requeued_at: new Date().toISOString() };
+    } else if (result.reran) {
+      entries[key] = { ...entry, reran: result.reran, reran_at: new Date().toISOString() };
+    }
+  }
+  if (results.length) writeQueue(file, entries);
+  const requeued = results.filter((r) => r.state === 'requeued').length;
+  const rerun = results.filter((r) => r.state === 'rerun').length;
+  const closed = results.reduce((sum, r) => sum + (r.closed ? r.closed.length : 0), 0);
+  const closedNote = (closed ? `; ${closed} finished ${closed === 1 ? 'job' : 'jobs'} closed after merging` : '')
+    + (rerun ? `; ${rerun} failed ${rerun === 1 ? 'check' : 'checks'} run again` : '');
+  const line = results.length
+    ? `${requeued} of ${results.length} queued ${results.length === 1 ? 'change' : 'changes'} put back in line${closedNote}`
+    : 'nothing is waiting in github\'s merge line';
+  return { checked: results.length, requeued, rerun, closed, results, line };
 }
 
 module.exports = {
   autolandMemberRun,
+  landingDestination,
+  requeueDroppedAutolands,
   codeStatus,
   gitCodeState,
 };