atris 3.74.27 → 3.74.28

package/lib/auto-accept-certified.js

@@ -318,6 +318,56 @@ function unmergedPullRequestBoundaryResult(ref, proof) {
   };
 }
 
+// The pull request the task names, as task ready recorded it: the row keeps the
+// newest word on it, and a row written before that falls back to the newest proof
+// event that named one. Only this attempt's events count: reopening a job clears
+// the row's pull request and starts it over, so whatever the history said before
+// the latest reopen is about an attempt that is over. A send-back for changes is
+// not a reopen; its pull request is still open. Null when the task names none.
+function recordedPullRequest(task) {
+  const metadata = task.metadata || {};
+  if (metadata.pull_request && typeof metadata.pull_request === 'object') return metadata.pull_request;
+  const events = Array.isArray(task.events) ? task.events : [];
+  let attemptStart = 0;
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    if (events[index] && events[index].event_type === 'reopened') {
+      attemptStart = index + 1;
+      break;
+    }
+  }
+  for (let index = events.length - 1; index >= attemptStart; index -= 1) {
+    const event = events[index];
+    const named = event && event.event_type === 'proof_ready' && event.payload && event.payload.pull_request;
+    if (named && typeof named === 'object') return named;
+  }
+  return null;
+}
+
+// A pull request still open, with no merge commit, is work waiting for a person:
+// whatever the proof says, the change has not landed.
+function openPullRequestOf(task) {
+  if (!task) return null;
+  const pullRequest = recordedPullRequest(task);
+  if (!pullRequest || pullRequest.merge_commit || pullRequest.merged_at) return null;
+  return String(pullRequest.state || '').toLowerCase() === 'open' ? pullRequest : null;
+}
+
+// The one refusal for a job whose pull request is still open, in any mode, whatever
+// its proof or its stored check says. Every path that accepts without a person
+// answers with this, so none can complete a job nobody has landed: this
+// evaluator, the sweep, and the shared acceptor. Null when nothing is open.
+function openPullRequestRefusal(task, ref) {
+  const openPullRequest = openPullRequestOf(task);
+  if (!openPullRequest) return null;
+  return {
+    eligible: false,
+    ref,
+    reason: 'pull_request_open',
+    pull_request: openPullRequest,
+    next_action: 'a person lands the pull request, then accepts the job with `atris task accept <ref> --as <human>`',
+  };
+}
+
 function distinctReviewActors(task) {
   return reviewIntegrity.reviewEventActors(task);
 }
@@ -1219,6 +1269,11 @@ function evaluateAutoAccept(task, options = {}) {
     };
   }
 
+  // A job whose pull request is still open has not landed, in any mode, whatever
+  // its proof says. A person lands the pull request and then accepts the job.
+  const pullRequestOpen = openPullRequestRefusal(task, ref);
+  if (pullRequestOpen) return pullRequestOpen;
+
   // Load lazily: the human accept gate reuses this module's parser and runner.
   const verifyCommand = resolveTaskVerify(task).verify;
   if (verifyCommand && require('./accept-verify-gate').nonFalsifyingIssue(verifyCommand)) {
@@ -1418,6 +1473,7 @@ module.exports = {
   verifyRunnability,
   evaluateAutoAccept,
   isAutoCertifyVerifyCommandAllowed,
+  openPullRequestRefusal,
   parseVerifyChain,
   isAgentCertified,
   parseVerifyCommand,

package/lib/campaign-keep.js

@@ -29,9 +29,13 @@ const CAMPAIGN_WAKE_JOB = Object.freeze({
   marker: MARKER,
 });
 
+// The minute field only counts within one hour: */180 would fire hourly.
 function cronSchedule(seconds) {
   const minutes = Math.max(1, Math.round(Number(seconds || 60) / 60));
-  return minutes === 1 ? '* * * * *' : `*/${minutes} * * * *`;
+  if (minutes === 1) return '* * * * *';
+  if (minutes < 60) return `*/${minutes} * * * *`;
+  const hours = Math.round(minutes / 60);
+  return hours >= 24 ? '0 0 * * *' : `0 */${hours} * * *`;
 }
 
 // One timer per checkout: the label and marker carry a short hash of its root.