atris 3.70.0 → 3.71.1

package/lib/member-autoland.js

@@ -4,6 +4,8 @@
 // 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');
@@ -15,6 +17,7 @@ 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.
@@ -254,16 +257,19 @@ function unsavedHold(cwd) {
   return null;
 }
 
-const MAP_FILE = /(?:^|\/)MAP\.md$/;
+// 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.
+// 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) return null;
+    if (!blob.ok && name !== 'base') return null;
     const out = path.join(tmp, name);
-    fs.writeFileSync(out, blob.stdout);
+    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 });
@@ -275,19 +281,40 @@ function unionMapBlob(file, mergeBase, ours, theirs, cwd, tmp) {
 }
 
 // Merge the main branch into the reviewed commit without touching the
-// checkout. A clean merge pushes the reviewed commit as is. When every clash
-// is a map file, both sides' lines are kept and a merge commit on top of the
-// reviewed commit is pushed instead, so GitHub has nothing left to resolve.
-// Any other clash holds.
-function mergeWithBase(headSha, base, branch, cwd) {
-  const remoteRef = `refs/remotes/origin/${base}`;
-  const fetched = run('git', ['fetch', '-q', 'origin', `+refs/heads/${base}:${remoteRef}`], cwd);
-  if (!fetched.ok) return { hold: `the main branch could not be fetched (${fetched.stderr.split('\n')[0]})` };
-  const baseRead = run('git', ['rev-parse', remoteRef], cwd);
+// 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) return { sha: headSha };
+  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));
@@ -317,17 +344,106 @@ function mergeWithBase(headSha, base, branch, cwd) {
       '-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 };
+    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');
@@ -376,7 +492,8 @@ 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');
@@ -423,7 +540,14 @@ function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', load
 
   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}`);
-  const mapNote = landing.mapMerged ? ' (map lines from both sides kept)' : '';
+  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,
@@ -431,12 +555,265 @@ function autolandMemberRun({ mission, cwd, summary = '', workerEngine = '', load
     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,
 };

package/lib/member-board.js

@@ -454,8 +454,14 @@ function memberBoardCommand(...args) {
   if (args.includes('--follow')) {
     const dir = progressDir();
     const write = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`);
+    // Mark where every log ends before reading the snapshot, so a line written
+    // while the snapshot prints is streamed after it instead of lost.
+    const early = [];
+    let send = (event) => early.push(event);
+    const follower = followBoard({ dir, emit: (event) => { if (!only || only.includes(event.member)) send(event); } });
     write({ kind: 'snapshot', at: new Date().toISOString(), dir, members: readBoard({ dir, all, asleep: sleepingHere(), only }) });
-    const follower = followBoard({ dir, emit: (event) => { if (!only || only.includes(event.member)) write(event); } });
+    send = write;
+    early.forEach(write);
     // Runs until ctrl-c or the reader closes the pipe.
     return new Promise((resolve) => {
       const done = () => { follower.stop(); resolve(); };

package/lib/member-map-fold.js

@@ -0,0 +1,126 @@
+'use strict';
+
+// Member changes save map notes as their own small files under
+// atris/refs/map-notes.d/ instead of editing atris/refs/MAP-NOTES.md, so two
+// changes never clash on the shared map. Once an hour the autoland tick folds
+// those files into MAP-NOTES.md on the main branch and removes them, in one
+// commit built without touching any checkout. A push that loses a race with
+// another landing is dropped; the next hour tries again from the new main.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const NOTES_FILE = 'atris/refs/MAP-NOTES.md';
+const DROP_DIR = 'atris/refs/map-notes.d';
+const FOLD_EVERY_MS = 60 * 60 * 1000;
+
+function git(args, cwd, extraEnv = {}) {
+  const res = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: 120000,
+    env: { ...process.env, ...extraEnv, GIT_NO_REPLACE_OBJECTS: '1' },
+  });
+  return {
+    ok: res.status === 0,
+    stdout: String(res.stdout || ''),
+    stderr: String(res.stderr || res.error?.message || '').trim(),
+  };
+}
+
+function foldDue(lastAt, now = Date.now()) {
+  const last = Date.parse(lastAt || '');
+  return !Number.isFinite(last) || now - last >= FOLD_EVERY_MS;
+}
+
+const isHeading = (line) => /^## \S/.test(line);
+const trimEnd = (text) => String(text || '').replace(/\r\n/g, '\n').replace(/\s+$/, '');
+
+// Fold drop texts into the notes text. A drop that opens with a "## " heading
+// already in the notes adds its new lines at the end of that section; any
+// other drop is added at the end of the file as written. A drop whose lines
+// are all already there adds nothing.
+function foldNotesText(notes, drops) {
+  const lines = trimEnd(notes) ? trimEnd(notes).split('\n') : [];
+  let added = 0;
+  for (const drop of drops) {
+    const body = trimEnd(drop.text).split('\n');
+    while (body.length && !body[0].trim()) body.shift();
+    if (!body.length) continue;
+    const at = isHeading(body[0]) ? lines.findIndex((l) => l.trim() === body[0].trim()) : -1;
+    if (at >= 0) {
+      let end = lines.findIndex((l, i) => i > at && isHeading(l));
+      if (end < 0) end = lines.length;
+      const seen = new Set(lines.slice(at, end).map((l) => l.trim()));
+      const fresh = body.slice(1).filter((l) => l.trim() && !seen.has(l.trim()));
+      if (!fresh.length) continue;
+      while (end > at + 1 && !lines[end - 1].trim()) end--;
+      lines.splice(end, 0, ...fresh);
+      added += fresh.length;
+    } else {
+      const seen = new Set(lines.map((l) => l.trim()));
+      const content = body.filter((l) => l.trim());
+      if (content.every((l) => seen.has(l.trim()))) continue;
+      if (lines.length) lines.push('');
+      lines.push(...body);
+      added += content.length;
+    }
+  }
+  return { text: lines.length ? `${lines.join('\n')}\n` : '', added };
+}
+
+function mainBranch(root, remote) {
+  const head = git(['symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`], root).stdout.trim();
+  return head.startsWith(`${remote}/`) ? head.slice(remote.length + 1) : 'master';
+}
+
+// Fold every drop file on the main branch into the shared map notes and push
+// the result. Returns what happened; never throws for an ordinary miss.
+function foldMapNotesOnMain(root, { base = '', remote = 'origin', push = true } = {}) {
+  base = base || mainBranch(root, remote);
+  const remoteRef = `refs/remotes/${remote}/${base}`;
+  const fetched = git(['fetch', '-q', remote, `+refs/heads/${base}:${remoteRef}`], root);
+  if (!fetched.ok) return { folded: 0, reason: 'main_unreadable', detail: fetched.stderr.split('\n')[0] };
+  const baseSha = git(['rev-parse', remoteRef], root).stdout.trim();
+  if (!/^[0-9a-f]{40,64}$/.test(baseSha)) return { folded: 0, reason: 'main_unreadable' };
+
+  const listed = git(['ls-tree', '-r', '--name-only', baseSha, '--', `${DROP_DIR}/`], root);
+  const files = listed.stdout.split('\n').filter((f) => f.endsWith('.md')).sort();
+  if (!files.length) return { folded: 0, reason: 'nothing_to_fold', base: baseSha };
+
+  const drops = [];
+  for (const file of files) {
+    const blob = git(['cat-file', 'blob', `${baseSha}:${file}`], root);
+    if (!blob.ok) return { folded: 0, reason: 'drop_unreadable', detail: file };
+    drops.push({ file, text: blob.stdout });
+  }
+  const current = git(['cat-file', 'blob', `${baseSha}:${NOTES_FILE}`], root);
+  const { text, added } = foldNotesText(current.ok ? current.stdout : '', drops);
+
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-map-fold-'));
+  try {
+    const index = { GIT_INDEX_FILE: path.join(tmp, 'index') };
+    const notesPath = path.join(tmp, 'notes');
+    fs.writeFileSync(notesPath, text);
+    const blob = git(['hash-object', '-w', notesPath], root).stdout.trim();
+    const built = git(['read-tree', baseSha], root, index).ok
+      && /^[0-9a-f]{40,64}$/.test(blob)
+      && git(['update-index', '--add', '--cacheinfo', `100644,${blob},${NOTES_FILE}`], root, index).ok
+      && git(['update-index', '--force-remove', '--', ...files], root, index).ok;
+    const tree = built ? git(['write-tree'], root, index).stdout.trim() : '';
+    const message = `Fold ${files.length} map ${files.length === 1 ? 'note' : 'notes'} from member changes into the shared map`;
+    const commit = tree ? git(['commit-tree', tree, '-p', baseSha, '-m', message], root).stdout.trim() : '';
+    if (!/^[0-9a-f]{40,64}$/.test(commit)) return { folded: 0, reason: 'commit_failed' };
+    if (!push) return { folded: files.length, added, sha: commit, pushed: false, files };
+    const pushed = git(['push', '-q', remote, `${commit}:refs/heads/${base}`], root);
+    if (!pushed.ok) return { folded: 0, reason: 'push_rejected', detail: pushed.stderr.split('\n')[0], sha: commit };
+    git(['update-ref', remoteRef, commit], root);
+    return { folded: files.length, added, sha: commit, pushed: true, files };
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+module.exports = { NOTES_FILE, DROP_DIR, FOLD_EVERY_MS, foldDue, foldNotesText, foldMapNotesOnMain };