atris 3.82.25 → 3.82.26

package/commands/worktree.js

@@ -201,6 +201,23 @@ function shipHelp() {
   console.log('  recommended flight verify: npm run test:fast && node --test <focused files>');
 }
 
+// A pull request GitHub left open for its checks goes on the list the autoland
+// tick watches. A flaky merge-line run that drops it is then queued again
+// without a person. Failing to write the list never fails the ship.
+function recordPendingShip(root, { branch, targetRef, number }) {
+  try {
+    const pushed = runGit(['rev-parse', 'HEAD'], { cwd: root }).stdout.trim();
+    const autoland = require('../lib/member-autoland');
+    autoland.recordQueuedPullRequest(root, { branch, base: baseBranchName(targetRef), number, pushed });
+    // The tick skips the whole list while self-landing is off.
+    console.log(autoland.policyOn(root)
+      ? `queue: recorded pull request ${number} for the tick's catch-up`
+      : `queue: recorded pull request ${number}, catch-up is off until self-landing is on`);
+  } catch (error) {
+    console.log(`queue: not recorded (${String(error.message || error).split('\n')[0]})`);
+  }
+}
+
 function shipWorktree(args) {
   if (hasFlag(args, '--help') || hasFlag(args, '-h') || args[0] === 'help') {
     shipHelp();
@@ -396,6 +413,7 @@ function shipWorktree(args) {
         }
         if (state.state === 'OPEN' && !state.mergedAt) {
           console.log('merge: pending; kept the source branch while required checks finish');
+          recordPendingShip(root, { branch, targetRef, number: state.number });
           finishShippedCopy({ root, primary, branch, keep: keepCopy });
           return 0;
         }

package/lib/member-autoland.js

@@ -384,14 +384,36 @@ function writeQueue(file, entries) {
   fs.renameSync(tmp, file);
 }
 
-function recordQueued(cwd, entry) {
+// Put a pull request on the list the sweep watches, keyed by its branch. Autoland
+// does this when it queues a member's change; `atris worktree ship --merge`
+// does it when GitHub leaves the pull request open for its checks. A flaky
+// merge-line run that drops it is then caught up by the sweep too. A later
+// record for the same branch keeps its catch-up count and retry mark while
+// the pushed commit and pull request stay the same. A new commit starts them
+// over. A new pull request number starts a new entry: the jobs and mission
+// of the earlier pull request do not carry over, or its merge would close
+// jobs it never carried. fresh: true replaces the entry outright. Throws when
+// the details cannot be recorded; the caller decides whether that matters.
+function recordQueuedPullRequest(cwd, fields, { fresh = false } = {}) {
   const file = queueFile(cwd);
-  if (!file) return;
-  try {
-    const entries = readQueue(file);
-    entries[entry.branch] = entry;
-    writeQueue(file, entries);
-  } catch {}
+  if (!file) throw new Error('not inside a git checkout');
+  const { branch, base, number, pushed } = fields || {};
+  const valid = typeof branch === 'string' && branch && typeof base === 'string' && base
+    && Number.isInteger(number) && number > 0 && /^[0-9a-f]{40,64}$/.test(String(pushed || ''));
+  if (!valid) throw new Error('the branch, base, pull request number, or pushed commit could not be read');
+  const entries = readQueue(file);
+  const found = fresh ? null : entries[branch];
+  const prior = found && typeof found === 'object' && found.number === number ? found : null;
+  const same = Boolean(prior) && prior.pushed === pushed;
+  const entry = { ...(prior || {}), ...fields };
+  if (!fresh) {
+    entry.requeues = same ? Number(prior.requeues) || 0 : 0;
+    entry.reran = same ? prior.reran || false : false;
+  }
+  entry.queued_at = new Date().toISOString();
+  entries[branch] = entry;
+  writeQueue(file, entries);
+  return entry;
 }
 
 function held(gate, line) {
@@ -566,12 +588,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}`);
-  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(),
-  });
+  try {
+    recordQueuedPullRequest(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,
+    }, { fresh: true });
+  } catch {}
   const mapNote = landing.mapInboxed?.length ? ' (map edits saved to the map inbox)'
     : landing.mapMerged ? ' (map lines from both sides kept)' : '';
   return {
@@ -931,6 +955,8 @@ module.exports = {
   sweepAfterMissionRun,
   landingDestination,
   requeueDroppedAutolands,
+  recordQueuedPullRequest,
+  policyOn,
   codeStatus,
   gitCodeState,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.82.25",
+  "version": "3.82.26",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof. project memory your coding agents share across sessions.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",