next-issue 2.14.0 → 2.15.0

package/README.md

@@ -12,8 +12,16 @@ npx -y next-issue@latest
 Before each issue, fetch the open issues again and take the oldest one not yet
 seen in this run. An issue seen once in a run, also a skipped or failed one, is
 not tried again in that run. The run ends when no unseen issue is left. When
-the fetch fails, the run ends there, writes the summary of the issues it handled
-and exits with code 1. For each issue:
+the fetch fails, the run claims no new issue, ends once the running issues end,
+writes the summary of the issues it handled and exits with code 1.
+
+A run handles up to `concurrency` issues at the same time, 1 by default. When an
+issue ends, the run fetches the open issues again and claims the oldest unseen
+one for the free slot. Each issue has its own worktree and branch. Step 3 below
+and the removal of a worktree or branch run for one issue at a time, so two
+issues never change the git refs or worktrees of the repository at once. An issue blocked by a running issue is skipped and not tried again in
+that run, even when the blocker closes before the run ends. `--max <n>` counts the handled issues across the run, and with `--once`
+the run handles one issue. For each issue:
 
 1. Claim the issue only when it holds the `status:todo` label and holds no
    `status:in-progress` or `status:in-review` label. A `status:done`,
@@ -104,7 +112,7 @@ and exits with code 1. For each issue:
 
 ## Issue format
 
-Every agent prompt holds the body and the comments of the issue. An issue reads best with these sections, in this order:
+Every agent prompt holds the body of the issue and the comments of users with write or admin access to the repository. An issue reads best with these sections, in this order:
 
 1. `Problem`
 2. `Context and findings`
@@ -120,7 +128,9 @@ The harness hands the issue to a person, with the `status:needs-human` label,
 and comments the reason on the pull request, or on the issue when there is no
 pull request yet, when:
 
-- the check budget or the review budget runs out;
+- the check budget or the review budget runs out. A finding that the reviewer
+  repeats, even one that the fixer disputed, goes back to the fixer until the
+  review budget runs out;
 - a fixer round adds no commit and gives no reason, so there is no progress;
 - the fixer reports that the checks fail for a reason the change did not cause,
   such as a test already broken on the base branch or one that fails only under
@@ -138,9 +148,6 @@ pull request yet, when:
   holds the reason of the dispute, and the change is on the machine that ran
   the harness. The `<n>-dispute-<commit>` branches go away with the `<n>`
   branch when the issue is done;
-- the reviewer repeats a finding set from an earlier round, which shows a
-  ping-pong between the fixer and the reviewer, or a finding that the fixer
-  disputed and the reviewer holds to. The person then decides;
 - the reviewer gives no verdict, or the checks do not finish in time;
 - someone pushes to the pull request while the harness waits for the checks,
   so the pull request no longer shows the commit that the harness pushed;
@@ -150,7 +157,8 @@ pull request yet, when:
   the pull request closes without a merge;
 - with `--merge`, the checks on the base branch fail after the merge and the
   fixer cannot fix them, or they do not finish in time. The base branch is
-  then broken, so the run stops after this issue;
+  then broken, so the run claims no new issue and ends once the running
+  issues end;
 - an agent does not finish in `agentTimeoutMinutes`;
 - the setup command fails, or does not finish in `setupTimeoutMinutes`;
 - a step of the run fails with an error. A `gh` call that is safe to repeat,
@@ -175,12 +183,12 @@ exception is the answer to a hand-over, see
 
 Press `Ctrl-C` to stop the run step by step:
 
-1. The first press stops the run after the current issue. The harness finishes
-   the issue that it holds and then writes the summary as usual.
-2. The second press stops the run after the current round: the implementation,
-   one checks round (wait, then fix) or one review round (review, then fix). The
-   issue ends as `stopped`. Its state, worktree and labels stay, so the next run
-   carries on from that point.
+1. The first press stops new claims. The harness finishes every issue that it
+   holds and then writes the summary as usual.
+2. The second press stops every running issue after its current round: the
+   implementation, one checks round (wait, then fix) or one review round
+   (review, then fix). The issue ends as `stopped`. Its state, worktree and
+   labels stay, so the next run carries on from that point.
 3. The third press stops every agent, kills the command that runs and every
    child of it, so the run dies in the middle of a step. The saved state lets the next run continue the
    issue, but the issue keeps `status:in-progress` and the run writes no
@@ -208,12 +216,15 @@ Every agent can run a shell command. The implementer and the fixer run with the
 permission checks off; the reviewer runs with a smaller tool set, but its shell
 has no limit on the commands. They all start in the worktree, but nothing holds
 them there: they can run any command, with your rights, anywhere on the machine.
-The prompt holds the title, the body and the comments of the issue, which come
-from GitHub.
+The prompt holds the title and the body of the issue, which come from GitHub.
+It also holds the comments of the issue, but only those by users with write or
+admin access to the repository. The harness leaves out every other comment and
+writes a `comment.skip` event with its author to the run log. If an access check
+fails for a reason other than a 404, the issue stops with an error.
 
-Thus a person who can write an issue or a comment can try to give an
-instruction to the agent. Use the harness only on a repository where you trust
-the issue authors, or run it in a container.
+Thus a person who can write an issue, or a writer who can comment, can try to
+give an instruction to the agent. Use the harness only on a repository where you
+trust the issue authors, or run it in a container.
 
 ## Observability
 
@@ -298,6 +309,7 @@ does not know all stop the run, so a typo cannot pass without a word.
 {
   "remote": "origin",
   "issueLimit": 100,
+  "concurrency": 1,
   "maxCiFixes": 5,
   "maxCommitFixes": 10,
   "maxReviewRounds": 5,
@@ -331,6 +343,7 @@ does not know all stop the run, so a typo cannot pass without a word.
 | ----------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------ |
 | `remote`                | `origin`           | The git remote for the repository and the branches                                                                                   |
 | `issueLimit`            | `100`              | The maximum number of open issues to read. With `labels.ready` set, only issues with the ready, in-progress or in-review label count |
+| `concurrency`           | `1`                | The most issues that a run handles at the same time                                                                                  |
 | `maxCiFixes`            | `5`                | The budget for check fixes per issue                                                                                                 |
 | `maxCommitFixes`        | `10`               | The budget for fixes of a commit that a git hook stopped, per issue                                                                  |
 | `maxReviewRounds`       | `5`                | The budget for review rounds per issue                                                                                               |
@@ -453,7 +466,7 @@ and `--once` is the same as `--max 1`.
 The watch stops:
 
 - at the first `Ctrl-C` during a wait, at once;
-- at the first `Ctrl-C` during an issue, after that issue;
+- at the first `Ctrl-C` during an issue, after the running issues;
 - after a pass that halts the run, for example when the base branch is broken
   after `--merge`;
 - when the open issues cannot be read.
@@ -475,8 +488,8 @@ to it. The worker:
   once. Each run is like `next-issue` without `--watch`, and the client says
   whether it merges;
 - sends every client the progress of every run when it connects and on every
-  change: the issue, the step, the tool count, the last tool and the handled
-  issues;
+  change: for each running issue the issue, the step, the tool count and the
+  last tool, and the handled issues;
 - sends every client a `questions` message for each repository: the open
   issues with the `needsHuman` label, each with its number, title, the reason
   of the hand-over, the url of the comment that holds it, the `owner/name`
@@ -491,8 +504,8 @@ to it. The worker:
   a newer one. When the client adds an `"id"` to its message, the list that
   answers it carries the same `id` and is read after the message arrived. When the list cannot be read, the client gets
   `{ "type": "questions-error", "root": "<path>", "message": "<text>" }`;
-- stops a run, when a client asks, like a second `Ctrl-C`: after the current
-  round, with the state kept;
+- stops a run, when a client asks, like a second `Ctrl-C`: each running issue
+  after its current round, with the state kept;
 - stays when all clients close;
 - closes once no run is going when a client with a newer version connects, so
   that the client can start the newer worker;

package/dist/config.mjs

@@ -4,6 +4,7 @@ import { message } from './observe.mjs';
 const DEFAULTS = {
     remote: 'origin',
     issueLimit: 100,
+    concurrency: 1,
     maxCiFixes: 5,
     maxCommitFixes: 10,
     maxReviewRounds: 5,
@@ -33,6 +34,7 @@ function defaults() {
 const FIELDS = [...Object.keys(DEFAULTS), 'setupCommand'];
 const WHOLE_FIELDS = [
     ['issueLimit', 1],
+    ['concurrency', 1],
     ['maxCiFixes', 0],
     ['maxCommitFixes', 0],
     ['maxReviewRounds', 1],

package/dist/github.mjs

@@ -72,7 +72,7 @@ export async function viewIssue(repo, issue) {
 export async function issueComments(repo, issue) {
     const raw = await gh(repo, ['issue', 'view', String(issue), '--json', 'comments']);
     const parsed = JSON.parse(raw);
-    return parsed.comments.map((comment) => `@${comment.author.login}: ${comment.body}`);
+    return parsed.comments.map((comment) => ({ author: comment.author.login, body: comment.body }));
 }
 export async function threadComments(repo, number) {
     const raw = await repeatable([

package/dist/handover.mjs

@@ -1,4 +1,4 @@
-import { setStatus } from './job.mjs';
+import { oneAtATime, setStatus, } from './job.mjs';
 import { message } from './observe.mjs';
 import { dropState, readState, writeState } from './state.mjs';
 export const HAND_OVER = 'next-issue needs help:';
@@ -40,6 +40,20 @@ export async function waitingQuestions(repo, config, ports) {
     }
     return questions;
 }
+export async function writerComments(context, log, issue) {
+    const { repo, ports } = context;
+    const writer = writers(repo, ports);
+    const kept = [];
+    for (const comment of await ports.issueComments(repo, issue)) {
+        if (await writer(comment.author)) {
+            kept.push(`@${comment.author}: ${comment.body}`);
+        }
+        else {
+            log.event('comment.skip', { author: comment.author }, 'quiet');
+        }
+    }
+    return kept;
+}
 export async function handOverReply(context, issue, pr) {
     const { repo, ports } = context;
     const comments = await ports.threadComments(repo, pr ?? issue);
@@ -77,7 +91,7 @@ export async function finish(job, outcome, reason) {
     await cleanUp(context, log, branch);
     if (outcome === 'done') {
         for (const name of [branch, ...(await ports.disputeBranches(repo, branch))]) {
-            if (!(await ports.deleteBranch(repo, name))) {
+            if (!(await oneAtATime(repo.root, () => ports.deleteBranch(repo, name)))) {
                 log.event('branch.kept', { branch: name }, 'quiet');
             }
         }
@@ -100,7 +114,7 @@ export async function cleanUp(context, log, branch) {
         if (path === undefined) {
             return;
         }
-        if (!(await context.ports.removeWorktree(context.repo, path))) {
+        if (!(await oneAtATime(context.repo.root, () => context.ports.removeWorktree(context.repo, path)))) {
             log.event('worktree.kept', { path }, 'quiet');
         }
     }

package/dist/interrupt.mjs

@@ -9,10 +9,10 @@ export function listenForInterrupts(say) {
             wake();
         }
         else if (presses === 1) {
-            say('Stopping after this issue. Press Ctrl-C again to stop after this round.');
+            say('Stopping after the running issues. Press Ctrl-C again to stop after the current round.');
         }
         else if (presses === 2) {
-            say('Stopping after this round. Press Ctrl-C again to stop now.');
+            say('Stopping after the current round. Press Ctrl-C again to stop now.');
         }
         else {
             process.off('SIGINT', press);

package/dist/job.mjs

@@ -1,5 +1,11 @@
 import { managedLabels } from './config.mjs';
 import { writeState } from './state.mjs';
+const worktreeQueues = new Map();
+export function oneAtATime(root, work) {
+    const result = (worktreeQueues.get(root) ?? Promise.resolve()).then(work);
+    worktreeQueues.set(root, result.catch(() => undefined));
+    return result;
+}
 export async function openPr(job) {
     const { context, issue, log, state, branch } = job;
     const { repo, config, ports } = context;

package/dist/loop.mjs

@@ -1,29 +1,55 @@
 export const BACK_OFF_MINUTES = [1, 2, 3, 5, 10];
 export async function runIssues(args, loop, seen = new Set()) {
+    const limit = args.once ? Math.min(1, args.max ?? 1) : args.max;
+    const concurrency = loop.concurrency ?? 1;
     const reports = [];
-    while (args.max === undefined || handled(reports) < args.max) {
-        let issues;
-        try {
-            issues = await loop.issues();
-        }
-        catch (error) {
-            return { reports, error };
+    const running = new Map();
+    let stoppedAt;
+    let error;
+    let crash;
+    let claiming = true;
+    const room = () => running.size < concurrency && (limit === undefined || handled(reports) + running.size < limit);
+    for (;;) {
+        if (claiming && room()) {
+            try {
+                const issues = await loop.issues();
+                for (const issue of issues.filter((candidate) => !seen.has(candidate.number))) {
+                    if (!room()) {
+                        break;
+                    }
+                    seen.add(issue.number);
+                    running.set(issue.number, loop.process(issue).then((report) => ({ issue: issue.number, report }), (failure) => ({ issue: issue.number, failure })));
+                }
+            }
+            catch (failure) {
+                error = failure;
+                claiming = false;
+            }
         }
-        const issue = issues.find((candidate) => !seen.has(candidate.number));
-        if (issue === undefined) {
+        if (running.size === 0) {
             break;
         }
-        seen.add(issue.number);
-        const report = await loop.process(issue);
-        reports.push(report);
-        if (loop.stop() || report.halt === true) {
-            return { reports, stoppedAt: issue.number };
+        const { issue, report, failure } = await Promise.race(running.values());
+        running.delete(issue);
+        if (report === undefined) {
+            crash ??= { failure };
+            claiming = false;
+            continue;
         }
-        if (args.once && report.outcome !== 'skipped') {
-            break;
+        reports.push(report);
+        if (claiming && (loop.stop() || report.halt === true)) {
+            stoppedAt = issue;
+            claiming = false;
         }
     }
-    return { reports };
+    if (crash !== undefined) {
+        throw crash.failure;
+    }
+    return {
+        reports,
+        ...(stoppedAt === undefined ? {} : { stoppedAt }),
+        ...(error === undefined ? {} : { error }),
+    };
 }
 export async function watchIssues(args, watch) {
     const limit = args.once ? 1 : args.max;

package/dist/pipeline.mjs

@@ -2,8 +2,8 @@ import { CODING } from './agents.mjs';
 import { commitWork } from './fix.mjs';
 import { checkGate } from './gate.mjs';
 import { branchName } from './git.mjs';
-import { cleanUp, escalate, finish, handOver, handOverReply, skipped, stop } from './handover.mjs';
-import { openPr, setStatus } from './job.mjs';
+import { cleanUp, escalate, finish, handOver, handOverReply, skipped, stop, writerComments, } from './handover.mjs';
+import { oneAtATime, openPr, setStatus } from './job.mjs';
 import { afterMerge, fixBase } from './merge.mjs';
 import { message } from './observe.mjs';
 import { implementPrompt, parseCommitSubject } from './prompts.mjs';
@@ -144,11 +144,11 @@ async function work(context, issue, log, state, start, handedOver) {
         await setStatus(context, issue.number, state.pr, config.labels.inProgress);
         await writeState(repo, state);
     });
-    const comments = await log.step('comments', {}, () => ports.issueComments(repo, issue.number));
+    const comments = await log.step('comments', {}, () => writerComments(context, log, issue.number));
     const reply = handedOver
         ? await log.step('reply', {}, () => handOverReply(context, issue.number, state.pr))
         : [];
-    const added = await log.step('worktree', { branch }, () => ports.addWorktree(repo, issue.number, branch, context.base, config.remote, start));
+    const added = await log.step('worktree', { branch }, () => oneAtATime(repo.root, () => ports.addWorktree(repo, issue.number, branch, context.base, config.remote, start)));
     const worktree = added.path;
     if (!added.baseUpdated) {
         log.event('base.behind', { base: context.base }, 'quiet');

package/dist/progress.mjs

@@ -1,11 +1,7 @@
 const TOOL_LINE_MAX = 80;
 const NOT_STAGES = new Set(['issue.start', 'agent.start', 'run.start']);
 export function startProgress() {
-    return { status: 'running', tools: 0, handled: [] };
-}
-function idle(progress) {
-    const { issue: _issue, title: _title, stage: _stage, lastTool: _lastTool, issueStartedAt: _at, ...rest } = progress;
-    return { ...rest, tools: 0 };
+    return { status: 'running', issues: [], handled: [] };
 }
 function toolLine(record) {
     const tool = String(record['tool']);
@@ -13,36 +9,52 @@ function toolLine(record) {
     const line = typeof command === 'string' ? `${tool} ${command.split('\n')[0]}` : tool;
     return line.length > TOOL_LINE_MAX ? `${line.slice(0, TOOL_LINE_MAX - 1)}…` : line;
 }
+function change(progress, issue, update) {
+    return {
+        ...progress,
+        issues: progress.issues.map((current) => (current.issue === issue ? update(current) : current)),
+    };
+}
 export function applyEvent(progress, record) {
     const kind = String(record['kind']);
+    const issue = Number(record['issue']);
     if (kind === 'issue.start') {
         const next = {
-            ...idle(progress),
-            issue: Number(record['issue']),
-            issueStartedAt: Date.parse(String(record['ts'])),
+            issue,
+            tools: 0,
+            startedAt: Date.parse(String(record['ts'])),
         };
         if (typeof record['title'] === 'string') {
             next.title = record['title'];
         }
-        return next;
+        const others = progress.issues.filter((current) => current.issue !== issue);
+        return { ...progress, issues: [...others, next] };
     }
     if (kind === 'tool') {
-        return { ...progress, tools: progress.tools + 1, lastTool: toolLine(record) };
+        return change(progress, issue, (current) => ({
+            ...current,
+            tools: current.tools + 1,
+            lastTool: toolLine(record),
+        }));
     }
     if (kind === 'issue.end' || kind === 'issue.error') {
         const outcome = kind === 'issue.error' ? 'error' : record['outcome'];
         const handled = outcome === 'done' || outcome === 'needs-human' || outcome === 'error'
-            ? [...progress.handled, { issue: Number(record['issue']), outcome }]
+            ? [...progress.handled, { issue, outcome }]
             : progress.handled;
-        return { ...idle(progress), handled };
+        const issues = progress.issues.filter((current) => current.issue !== issue);
+        return { ...progress, issues, handled };
     }
     if (kind === 'issues.fail') {
         return { ...progress, error: String(record['error']) };
     }
-    if (kind.endsWith('.start') && !NOT_STAGES.has(kind) && progress.issue !== undefined) {
+    if (kind.endsWith('.start') && !NOT_STAGES.has(kind)) {
         const stage = kind.slice(0, -'.start'.length);
         const round = record['round'];
-        return { ...progress, stage: typeof round === 'number' ? `${stage} ${round}` : stage };
+        return change(progress, issue, (current) => ({
+            ...current,
+            stage: typeof round === 'number' ? `${stage} ${round}` : stage,
+        }));
     }
     return progress;
 }

package/dist/review.mjs

@@ -6,7 +6,7 @@ import { history, setStatus } from './job.mjs';
 import { afterMerge } from './merge.mjs';
 import { capDiff, reviewPrompt } from './prompts.mjs';
 import { writeState } from './state.mjs';
-import { blockingFindings, fingerprint, formatFindings, formatVerdict, openFindings, parseVerdict, } from './verdict.mjs';
+import { blockingFindings, formatFindings, formatVerdict, openFindings, parseVerdict, } from './verdict.mjs';
 export async function reviewRound(job) {
     const { context, issue, log, state, worktree, comments } = job;
     const { repo, config, ports } = context;
@@ -73,15 +73,9 @@ export async function reviewRound(job) {
         await setStatus(context, issue.number, pr, config.labels.done);
         return { done: true, report: await finish(job, 'done') };
     }
-    const mark = fingerprint(open);
-    if (state.reviewLog.some((round) => round.fingerprint === mark)) {
-        await escalate(job, 'The reviewer repeated findings that an earlier round did not fix.');
-        return { done: true, report: await finish(job, 'needs-human', 'repeated findings') };
-    }
     const earlier = history(state.reviewLog);
     state.reviewLog.push({
         round: state.reviewRounds,
-        fingerprint: mark,
         findings: formatFindings(open),
     });
     await writeState(repo, state);

package/dist/run.mjs

@@ -68,6 +68,7 @@ async function handle(args, config, repo, recorder, controls) {
         },
         process: (issue) => processIssue(context, issue),
         stop: interrupts.afterIssue,
+        concurrency: config.concurrency,
     };
     const print = controls.print ?? (async () => undefined);
     let passStart = recorder.summary();

package/dist/state.mjs

@@ -44,7 +44,6 @@ function isBaseFix(value) {
 function isReviewRound(value) {
     return (isRecord(value) &&
         typeof value.round === 'number' &&
-        typeof value.fingerprint === 'string' &&
         typeof value.findings === 'string' &&
         isOptional(value.dispute, 'string'));
 }

package/dist/verdict.mjs

@@ -54,12 +54,3 @@ export function formatVerdict(verdict, open) {
 export function formatFindings(findings) {
     return findings.map((finding) => `- ${finding.detail}`).join('\n');
 }
-export function fingerprint(findings) {
-    return findings
-        .map((finding) => finding.detail
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, ' ')
-        .trim())
-        .sort()
-        .join('|');
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-issue",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "Autonomous issue harness driven by the pi SDK",
   "keywords": [
     "github",