ci(oss): cap open issues per contributor, reserve an issue for its opener, release claims after 48h

.github/scripts/claim-ttl.mjs

@@ -1,4 +1,6 @@
 const MAINTAINER_PERMISSIONS = new Set(['admin', 'maintain', 'write']);
+// Labels that open an issue for claiming (issue-triage.yml uses the same list).
+const ACCEPT_LABELS = new Set(['accepted', 'good first issue', 'help wanted']);
 const HOUR_MS = 60 * 60 * 1000;
 
 function latestAssignment(events, login) {
@@ -9,6 +11,14 @@ function latestAssignment(events, login) {
     .sort((a, b) => b.getTime() - a.getTime())[0];
 }
 
+function latestAcceptance(events) {
+  return events
+    .filter(event => event.event === 'labeled' && ACCEPT_LABELS.has(event.label?.name))
+    .map(event => new Date(event.created_at))
+    .filter(date => !Number.isNaN(date.getTime()))
+    .sort((a, b) => b.getTime() - a.getTime())[0];
+}
+
 // Same keywords the PR gate (pr-triage.yml) accepts as an issue reference.
 const ISSUE_REFERENCE =
   /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?|part\s+of|refs?|references?|related\s+to)\s*:?\s+#(\d+)/gi;
@@ -33,16 +43,21 @@ function readHours(value, fallback) {
   return value === undefined ? fallback : Number(value);
 }
 
-export function evaluateClaim({ events, login, issueNumber, now, since, warn, ttl }) {
+export function evaluateClaim({ events, login, issueNumber, now, since, warn, ttl, opener }) {
   const assignedAt = latestAssignment(events, login);
   if (!assignedAt) return { action: 'skip', reason: 'no-assignment-event' };
   if (assignedAt < since) return { action: 'skip', reason: 'grandfathered' };
   if (hasOpenLinkedPr(events, login, issueNumber))
     return { action: 'skip', reason: 'linked-open-pr' };
 
-  const age = (now.getTime() - assignedAt.getTime()) / HOUR_MS;
+  // The opener's reservation and claim share one window: their clock starts
+  // when the issue was accepted, not when they claimed it.
+  const acceptedAt = login === opener ? latestAcceptance(events) : undefined;
+  const fromAcceptance = acceptedAt !== undefined && acceptedAt < assignedAt;
+  const start = fromAcceptance ? acceptedAt : assignedAt;
+  const age = (now.getTime() - start.getTime()) / HOUR_MS;
   if (age < warn) return { action: 'skip', reason: 'under-warning-age' };
-  return { action: age >= ttl ? 'expired' : 'warn', assignedAt };
+  return { action: age >= ttl ? 'expired' : 'warn', assignedAt, fromAcceptance };
 }
 
 export async function run({ github, context, core, env, now = new Date() }) {
@@ -134,6 +149,7 @@ export async function run({ github, context, core, env, now = new Date() }) {
           since,
           warn,
           ttl,
+          opener: issue.user?.login,
         });
         if (evaluation.action === 'skip') {
           skip(evaluation.reason);
@@ -147,7 +163,7 @@ export async function run({ github, context, core, env, now = new Date() }) {
           per_page: 100,
         });
         const stage = evaluation.action;
-        const { assignedAt } = evaluation;
+        const { assignedAt, fromAcceptance } = evaluation;
         const marker = `<!-- claim-ttl:${stage}:${login}:${assignedAt.toISOString()} -->`;
         const alreadyCommented = comments.some(comment => (comment.body ?? '').includes(marker));
         if (stage === 'warn') {
@@ -158,7 +174,7 @@ export async function run({ github, context, core, env, now = new Date() }) {
           if (dryRun) {
             core.info(`DRY_RUN: would warn @${login} on #${issue.number}`);
           } else {
-            const body = `@${login}, your claim on this issue expires in about 24 hours unless you open a PR that links it (for example, \`Closes #${issue.number}\` or \`Part of #${issue.number}\`). You can re-claim later with \`/assign\` if the issue is still free.\n\n${marker}`;
+            const body = `@${login}, your claim on this issue expires in about ${ttl - warn} hours unless you open a PR that links it (for example, \`Closes #${issue.number}\` or \`Part of #${issue.number}\`). You can re-claim later with \`/assign\` if the issue is still free.\n\n${marker}`;
             await github.rest.issues.createComment({
               owner,
               repo,
@@ -193,7 +209,8 @@ export async function run({ github, context, core, env, now = new Date() }) {
             }
           }
           if (!alreadyCommented) {
-            const body = `@${login}, your claim expired after ${ttl} hours without a linked PR. This issue is open for others now, and you're welcome to \`/assign\` again if it's still free.\n\n${marker}`;
+            const counted = fromAcceptance ? ' (counted from when this issue was accepted)' : '';
+            const body = `@${login}, your claim expired after ${ttl} hours${counted} without a linked PR. This issue is open for others now, and you're welcome to \`/assign\` again if it's still free.\n\n${marker}`;
             await github.rest.issues.createComment({
               owner,
               repo,

.github/scripts/claim-ttl.test.mjs

@@ -368,11 +368,72 @@ test('scheduled workflow pins the policy and runs only in the public repo', () =
   const path = fileURLToPath(new URL('../workflows/claim-ttl.yml', import.meta.url));
   const workflow = readFileSync(path, 'utf8');
   assert.match(workflow, /^ {4}if: github\.repository == 'TestSprite\/testsprite-cli'$/m);
-  assert.match(workflow, /^ {2}CLAIM_TTL_HOURS: '72'$/m);
-  assert.match(workflow, /^ {2}CLAIM_WARN_HOURS: '48'$/m);
+  assert.match(workflow, /^ {2}CLAIM_TTL_HOURS: '48'$/m);
+  assert.match(workflow, /^ {2}CLAIM_WARN_HOURS: '24'$/m);
   assert.match(workflow, /^ {2}CLAIM_TTL_SINCE: '2026-09-24T00:00:00Z'$/m);
   assert.match(
     workflow,
     /^ {2}DRY_RUN: \$\{\{ inputs\.dry_run == true && 'true' \|\| 'false' \}\}$/m,
   );
 });
+
+const accepted = hours => ({
+  event: 'labeled',
+  label: { name: 'accepted' },
+  created_at: assignedAt(hours),
+});
+const openerIssue = {
+  number: 42,
+  user: { login: 'contributor' },
+  assignees: [{ login: 'contributor' }],
+  labels: [],
+};
+
+test('the opener’s window starts at acceptance, not at the claim', async () => {
+  // Accepted 72h ago, claimed by the opener 30h ago: the opener's 72h are up.
+  const h = harness({
+    issues: [openerIssue],
+    events: { 42: [accepted(72), claim('contributor', 30)] },
+  });
+  await h.execute();
+  assert.equal(h.of('removeAssignees').length, 1);
+  assert.match(h.of('createComment')[0].body, /counted from when this issue was accepted/);
+  // The marker still names the assignment, so a later re-claim gets its own notices.
+  assert.match(
+    h.of('createComment')[0].body,
+    /claim-ttl:expired:contributor:2026-09-28T18:00:00.000Z/,
+  );
+});
+
+test('a non-opener’s window starts at their own claim', async () => {
+  const h = harness({
+    issues: [{ ...openerIssue, user: { login: 'opener' } }],
+    events: { 42: [accepted(72), claim('contributor', 30)] },
+  });
+  await h.execute();
+  assert.deepEqual(h.writes(), []);
+});
+
+test('a linked draft PR keeps the opener’s claim past the window', async () => {
+  const h = harness({
+    issues: [openerIssue],
+    events: { 42: [accepted(72), claim('contributor', 30), linkedPr('contributor', 'open', true)] },
+  });
+  await h.execute();
+  assert.deepEqual(h.writes(), []);
+});
+
+test('the warning states the hours left under the configured policy', async () => {
+  const h = harness({
+    events: { 42: [claim('contributor', 24)] },
+    env: { CLAIM_TTL_HOURS: '48', CLAIM_WARN_HOURS: '24' },
+  });
+  await h.execute();
+  assert.match(h.of('createComment')[0].body, /expires in about 24 hours/);
+  const expired = harness({
+    events: { 42: [claim('contributor', 48)] },
+    env: { CLAIM_TTL_HOURS: '48', CLAIM_WARN_HOURS: '24' },
+  });
+  await expired.execute();
+  assert.match(expired.of('createComment')[0].body, /expired after 48 hours without a linked PR/);
+});

.github/scripts/issue-open-cap.test.mjs

@@ -0,0 +1,141 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { test } from 'node:test';
+
+const workflowPath = fileURLToPath(new URL('../workflows/issue-open-cap.yml', import.meta.url));
+const workflow = readFileSync(workflowPath, 'utf8');
+const lines = workflow.split('\n');
+const scriptStart = lines.indexOf('          script: |');
+assert.notEqual(scriptStart, -1);
+const script = lines
+  .slice(scriptStart + 1)
+  .map(line => {
+    if (line.length === 0) return '';
+    assert.ok(line.startsWith('            '));
+    return line.slice(12);
+  })
+  .join('\n');
+const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+const runScript = new AsyncFunction('github', 'context', script);
+
+async function runIssue({
+  // Open items the author created, as listForRepo returns them (PRs included).
+  open = [],
+  action = 'opened',
+  sender = 'contributor',
+  permission = 'read',
+  association = 'NONE',
+} = {}) {
+  const calls = [];
+  const issues = {
+    listForRepo: () => {},
+    createComment: async args => calls.push(['createComment', args]),
+    update: async args => calls.push(['update', args]),
+  };
+  const repos = {
+    getCollaboratorPermissionLevel: async () => {
+      if (permission === 'error') throw new Error('permission lookup failed');
+      return { data: { permission } };
+    },
+  };
+  const github = {
+    paginate: async (method, params) => {
+      assert.equal(method, issues.listForRepo);
+      assert.equal(params.creator, 'contributor');
+      assert.equal(params.state, 'open');
+      return open;
+    },
+    rest: { issues, repos },
+  };
+  const context = {
+    repo: { owner: 'TestSprite', repo: 'testsprite-cli' },
+    payload: {
+      action,
+      sender: { login: sender },
+      issue: { number: 50, user: { login: 'contributor' }, author_association: association },
+    },
+  };
+  const previous = process.env.OPEN_CAP;
+  process.env.OPEN_CAP = '3';
+  try {
+    await runScript(github, context);
+  } finally {
+    if (previous === undefined) delete process.env.OPEN_CAP;
+    else process.env.OPEN_CAP = previous;
+  }
+  return name => calls.filter(([method]) => method === name).map(([, args]) => args);
+}
+
+const issueItems = numbers => numbers.map(number => ({ number, title: `Issue ${number}` }));
+
+test('the cap is three open issues', () => {
+  assert.match(workflow, /^ {2}OPEN_CAP: '3'$/m);
+});
+
+test('a fourth open issue is closed with a comment listing the other three', async () => {
+  const of = await runIssue({ open: issueItems([11, 12, 13, 50]) });
+  const [comment] = of('createComment');
+  assert.equal(comment.issue_number, 50);
+  assert.match(comment.body, /at most 3 open at a time/);
+  assert.match(comment.body, /#11 — Issue 11/);
+  assert.doesNotMatch(comment.body, /#50/);
+  assert.deepEqual(of('update'), [
+    {
+      owner: 'TestSprite',
+      repo: 'testsprite-cli',
+      issue_number: 50,
+      state: 'closed',
+      state_reason: 'not_planned',
+    },
+  ]);
+});
+
+test('up to three open issues, and PRs, are left alone', async () => {
+  const of = await runIssue({
+    open: [...issueItems([11, 12, 50]), { number: 14, pull_request: {} }],
+  });
+  assert.equal(of('createComment').length, 0);
+  assert.equal(of('update').length, 0);
+});
+
+test('an issue claimed by someone else does not count, one claimed by the author does', async () => {
+  const claimedByOther = { number: 13, title: 'Issue 13', assignees: [{ login: 'someone-else' }] };
+  const claimedBySelf = { number: 14, title: 'Issue 14', assignees: [{ login: 'contributor' }] };
+  const under = await runIssue({ open: [...issueItems([11, 12]), claimedByOther] });
+  assert.equal(under('update').length, 0);
+  const over = await runIssue({ open: [...issueItems([11, 12]), claimedBySelf] });
+  assert.equal(over('update').length, 1);
+  assert.match(over('createComment')[0].body, /#14 — Issue 14/);
+});
+
+test('maintainers are exempt, by permission or by association when the lookup fails', async () => {
+  for (const permission of ['write', 'maintain', 'admin']) {
+    const of = await runIssue({ open: issueItems([11, 12, 13]), permission });
+    assert.equal(of('update').length, 0);
+  }
+  const fallback = await runIssue({
+    open: issueItems([11, 12, 13]),
+    permission: 'error',
+    association: 'MEMBER',
+  });
+  assert.equal(fallback('update').length, 0);
+  const community = await runIssue({ open: issueItems([11, 12, 13]), permission: 'error' });
+  assert.equal(community('update').length, 1);
+});
+
+test('reopening over the cap closes again, unless a maintainer reopened it', async () => {
+  const self = await runIssue({ open: issueItems([11, 12, 13]), action: 'reopened' });
+  assert.equal(self('update').length, 1);
+  const byMaintainer = await runIssue({
+    open: issueItems([11, 12, 13]),
+    action: 'reopened',
+    sender: 'maintainer',
+  });
+  assert.equal(byMaintainer('update').length, 0);
+});
+
+test('runs are serialised per author and skip bots', () => {
+  assert.match(workflow, /group: issue-open-cap-\$\{\{ github\.event\.issue\.user\.login \}\}/);
+  assert.match(workflow, /github\.event\.issue\.user\.type != 'Bot'/);
+});