next-issue 0.12.5 → 0.14.0

package/README.md

@@ -18,13 +18,12 @@ next-issue
 
 For each open issue, oldest first:
 
-1. Claim the issue only when it holds the `status:todo` label, holds no
-   `status:in-progress` or `status:in-review` label, and has no assignee. A
-   `status:done`, `status:needs-human` or `status:blocked` label always stops
-   the claim, a resume too. An issue with saved state under `.next-issue/`
-   resumes instead, whatever its other labels, unless another person is now the
-   assignee.
-2. Assign the issue to you and add `status:in-progress`.
+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`,
+   `status:needs-human` or `status:blocked` label always stops the claim, a
+   resume too. An issue with saved state under `.next-issue/` resumes instead,
+   whatever its other labels.
+2. Add `status:in-progress` to the issue.
 3. Fetch the remote, fast-forward the local copy of the default branch when
    that is safe, then add a git worktree at `../<repo>-issue-<n>` on the
    `issue-<n>` branch. A branch that exists on the remote is the start, and a
@@ -61,7 +60,12 @@ For each open issue, oldest first:
     reviewer leaves out of the findings thus gets an approval: only the findings
     count.
 11. With an open finding, run the fixer agent and go to step 6 again. The
-    budget is `maxReviewRounds`.
+    budget is `maxReviewRounds`. A fixer that holds every finding to be wrong
+    changes nothing and gives its reason instead. The reason goes on the pull
+    request and into the next round, where it answers every finding of its own
+    round, so the reviewer withdraws them all or repeats them all. With only
+    some findings wrong, the fixer fixes the correct ones, and the next round
+    holds the rest.
 
 ## Stops for a loop
 
@@ -69,20 +73,35 @@ The harness hands the issue to a person, with the `status:needs-human` label,
 when:
 
 - the check budget or the review budget runs out;
-- a fixer round adds no commit, so there is no progress;
+- 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
    load. It changes nothing and the reason reaches the pull request, rather than
    the fixer spending its whole budget on a failure it cannot fix;
+- a fixer disputes the findings and leaves a change behind, either in the
+   worktree or in a commit of its own. A dispute carries a reason, not a diff,
+   so the harness throws none of it away: an unclean worktree stays on the
+   disk, and a commit of the fixer stays on the local branch. Neither is
+   pushed, so the pull request shows no such change. It holds the reason of the
+   dispute, and the change is on the machine that ran the harness;
 - the reviewer repeats a finding set from an earlier round, which shows a
-   ping-pong between the fixer and the reviewer;
+   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;
 - 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.
 
-The fixer sees the findings of all earlier rounds, not only the last one. From
-round two, the reviewer judges only the earlier findings and any regression.
+The fixer sees the findings of all earlier rounds, not only the last one, with
+its own disputes next to them. From round two, the reviewer judges only the
+earlier findings and any regression.
+
+Each agent that writes to the pull request names itself in the first line of the
+comment: `### Review: approved`, `### Review: changes requested` and
+`### Fixer: no change`. The account is the same for all of them, so the heading,
+not the author, tells them apart. The agents read the comments of the issue, not
+of the pull request, so a comment of an agent never returns to a prompt: the
+dispute of the fixer reaches the reviewer through the state file.
 
 ## Stop after the current issue
 
@@ -96,10 +115,11 @@ and to 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 summary.
 
-Every status label that the harness puts on the issue goes on the pull request
-too, from the first review round. Thus a draft pull request shows work that the
-harness has not finished, and a `status:needs-human` pull request shows work
-that waits for a person.
+A status label that the harness puts on the issue goes on the pull request too,
+but only if the pull request exists at that moment. The `status:in-progress`
+label of a fresh issue comes before the pull request, and stays on the issue
+alone. Thus a draft pull request shows work that the harness has not finished,
+and a `status:needs-human` pull request shows work that waits for a person.
 
 The harness runs all git and `gh` commands itself. The commit holds all the
 changes in the worktree, so a setup command that writes a file outside
@@ -188,8 +208,8 @@ does not know all stop the run, so a typo cannot pass without a word.
 {
   "remote": "origin",
   "issueLimit": 100,
-  "maxCiFixes": 3,
-  "maxReviewRounds": 3,
+  "maxCiFixes": 5,
+  "maxReviewRounds": 5,
   "checkIntervalSeconds": 15,
   "checkGraceSeconds": 60,
   "checkTimeoutMinutes": 60,
@@ -220,8 +240,8 @@ 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 |
-| `maxCiFixes` | `3` | The budget for check fixes per issue |
-| `maxReviewRounds` | `3` | The budget for review rounds per issue |
+| `maxCiFixes` | `5` | The budget for check fixes per issue |
+| `maxReviewRounds` | `5` | The budget for review rounds per issue |
 | `checkIntervalSeconds` | `15` | The time between two check states |
 | `checkGraceSeconds` | `60` | The time to wait for the first check to show |
 | `checkTimeoutMinutes` | `60` | The limit for one check wait |
@@ -237,10 +257,10 @@ does not know all stop the run, so a typo cannot pass without a word.
 | `labels` | see above | The names of the labels that the harness reads and sets |
 
 An empty `labels.ready` turns the ready requirement off. The harness then
-claims every open issue that no other label and no assignee holds back.
+claims every open issue that no other label holds back.
 
-The log gives the reason for a skipped issue as `stop-label`, `not-ready`,
-`in-flight` or `assigned`.
+The log gives the reason for a skipped issue as `stop-label`, `not-ready` or
+`in-flight`.
 
 A role set to `null`, or with no entry in `models`, uses the default model of
 the SDK.

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { parseArgs, USAGE } from "./args.mjs";
 import { loadConfig, writeDefaultConfig } from "./config.mjs";
 import { setCommandObserver, setDefaultTimeout } from "./exec.mjs";
 import { detectRepo, ensureIgnored, repoRoot } from "./git.mjs";
-import { currentLogin, defaultBranch, openIssues } from "./github.mjs";
+import { defaultBranch, openIssues } from "./github.mjs";
 import { exitCode, runIssues } from "./loop.mjs";
 import { message, pruneRuns, Recorder } from "./observe.mjs";
 import { PORTS, processIssue } from "./pipeline.mjs";
@@ -60,13 +60,12 @@ async function init(root, force) {
     return 0;
 }
 async function handle(args, config, repo, recorder) {
-    const [base, login] = await Promise.all([defaultBranch(repo), currentLogin(repo)]);
-    const context = { repo, config, base, login, reset: args.reset, recorder, ports: PORTS };
+    const base = await defaultBranch(repo);
+    const context = { repo, config, base, reset: args.reset, recorder, ports: PORTS };
     recorder.event("run.start", {
         version: await packageVersion(),
         repo: `${repo.owner}/${repo.name}`,
         base,
-        login,
         log: recorder.logFile,
     }, "quiet");
     const issues = await openIssues(repo, config.issueLimit);

package/dist/config.mjs

@@ -4,8 +4,8 @@ import { message } from "./observe.mjs";
 const DEFAULTS = {
     remote: "origin",
     issueLimit: 100,
-    maxCiFixes: 3,
-    maxReviewRounds: 3,
+    maxCiFixes: 5,
+    maxReviewRounds: 5,
     checkIntervalSeconds: 15,
     checkGraceSeconds: 60,
     checkTimeoutMinutes: 60,
@@ -83,7 +83,7 @@ export async function loadConfig(root) {
     }
     return parseConfig(parsed);
 }
-export function parseConfig(value) {
+function parseConfig(value) {
     const file = record(value, "the file");
     for (const key of Object.keys(file)) {
         if (!FIELDS.includes(key)) {

package/dist/github.mjs

@@ -15,9 +15,6 @@ export async function defaultBranch(repo) {
     });
     return JSON.parse(raw).defaultBranchRef.name;
 }
-export async function currentLogin(repo) {
-    return must("gh", ["api", "user", "--jq", ".login"], { cwd: repo.root });
-}
 export async function openIssues(repo, limit) {
     const raw = await gh(repo, [
         "issue",
@@ -29,7 +26,7 @@ export async function openIssues(repo, limit) {
         "--limit",
         String(limit),
         "--json",
-        "number,title,body,createdAt,labels,assignees",
+        "number,title,body,createdAt,labels",
     ]);
     const parsed = JSON.parse(raw);
     return parsed
@@ -39,7 +36,6 @@ export async function openIssues(repo, limit) {
         body: item.body ?? "",
         createdAt: item.createdAt,
         labels: item.labels.map((label) => label.name),
-        assignees: item.assignees.map((assignee) => assignee.login),
     }))
         .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
@@ -48,10 +44,7 @@ export async function issueComments(repo, issue) {
     const parsed = JSON.parse(raw);
     return parsed.comments.map((comment) => `@${comment.author.login}: ${comment.body}`);
 }
-export async function assignIssue(repo, issue, login) {
-    await gh(repo, ["issue", "edit", String(issue), "--add-assignee", login]);
-}
-export async function labelsOf(repo, kind, number) {
+async function labelsOf(repo, kind, number) {
     const raw = await gh(repo, [kind, "view", String(number), "--json", "labels"]);
     const parsed = JSON.parse(raw);
     return parsed.labels.map((label) => label.name);
@@ -68,7 +61,7 @@ export async function setLabel(repo, kind, number, add, remove) {
     const current = await labelsOf(repo, kind, number);
     await gh(repo, [kind, "edit", String(number), ...labelArgs(add, remove, current)]);
 }
-export async function ensureLabel(repo, label) {
+async function ensureLabel(repo, label) {
     let known = KNOWN_LABELS.get(slug(repo));
     if (known === undefined) {
         const raw = await gh(repo, ["label", "list", "--limit", "1000", "--json", "name"]);

package/dist/pipeline.mjs

@@ -1,8 +1,8 @@
 import { CODING, REVIEWING, runAgent } from "./agents.mjs";
 import { managedLabels } from "./config.mjs";
 import { run } from "./exec.mjs";
-import { addWorktree, branchName, commitAll, deleteBranch, diff, discardChanges, hasWorktree, push, removeWorktree, revision, worktreePath, } from "./git.mjs";
-import { assignIssue, commentOnPr, createPr, failedCheckLogs, findPr, issueComments, markPrReady, setLabel, waitForChecks, } from "./github.mjs";
+import { addWorktree, branchName, commitAll, deleteBranch, diff, discardChanges, hasWorktree, isDirty, push, removeWorktree, revision, worktreePath, } from "./git.mjs";
+import { commentOnPr, createPr, failedCheckLogs, findPr, issueComments, markPrReady, setLabel, waitForChecks, } from "./github.mjs";
 import { message } from "./observe.mjs";
 import { capDiff, fixPrompt, implementPrompt, parseCommitSubject, parseUnrelated, reviewPrompt, } from "./prompts.mjs";
 import { detectSetupCommand } from "./setup.mjs";
@@ -10,7 +10,6 @@ import { dropState, readState, resetState, writeState, } from "./state.mjs";
 import { blockingFindings, fingerprint, formatFindings, formatVerdict, openFindings, readVerdict, VERDICT_SCHEMA, } from "./verdict.mjs";
 export const PORTS = {
     addWorktree,
-    assignIssue,
     commentOnPr,
     commitAll,
     createPr,
@@ -21,6 +20,7 @@ export const PORTS = {
     failedCheckLogs,
     findPr,
     hasWorktree,
+    isDirty,
     issueComments,
     markPrReady,
     push,
@@ -31,14 +31,14 @@ export const PORTS = {
     setLabel,
     waitForChecks,
 };
-export function skipReason(issue, config, login, resuming) {
+export function skipReason(issue, config, resuming) {
     const labels = new Set(issue.labels);
     const names = config.labels;
     if (labels.has(names.done) || labels.has(names.needsHuman) || labels.has(names.skip)) {
         return "stop-label";
     }
     if (resuming) {
-        return issue.assignees.every((name) => name === login) ? undefined : "assigned";
+        return undefined;
     }
     if (names.ready.length > 0 && !labels.has(names.ready)) {
         return "not-ready";
@@ -46,13 +46,13 @@ export function skipReason(issue, config, login, resuming) {
     if (labels.has(names.inProgress) || labels.has(names.inReview)) {
         return "in-flight";
     }
-    return issue.assignees.length === 0 ? undefined : "assigned";
+    return undefined;
 }
 export async function processIssue(context, issue) {
     const started = Date.now();
     const log = context.recorder.scope({ issue: issue.number });
     const saved = await readState(context.repo, issue.number);
-    const skip = skipReason(issue, context.config, context.login, saved !== undefined);
+    const skip = skipReason(issue, context.config, saved !== undefined);
     if (skip !== undefined) {
         log.event("issue.skip", { title: issue.title, reason: skip });
         return { issue: issue.number, outcome: "skipped", ciFixes: 0, reviewRounds: 0, ms: 0 };
@@ -97,7 +97,6 @@ async function work(context, issue, log, state) {
     const { repo, config, ports } = context;
     const branch = state.branch;
     await log.step("claim", { label: config.labels.inProgress }, async () => {
-        await ports.assignIssue(repo, issue.number, context.login);
         await setStatus(context, issue.number, state.pr, config.labels.inProgress);
         await writeState(repo, state);
     });
@@ -107,25 +106,16 @@ async function work(context, issue, log, state) {
     if (!added.baseUpdated) {
         log.event("base.behind", { base: context.base }, "quiet");
     }
-    const job = { context, issue, log, state, branch, worktree, comments };
-    const escalate = (reason) => handOver(context, log, issue.number, state, reason);
-    const finish = async (outcome, reason) => {
-        await cleanUp(context, log, issue.number);
-        if (outcome === "done") {
-            if (!(await ports.deleteBranch(repo, branch))) {
-                log.event("branch.kept", { branch }, "quiet");
-            }
-            await dropState(repo, issue.number);
-        }
-        return {
-            issue: issue.number,
-            outcome,
-            reason,
-            pr: state.pr,
-            ciFixes: state.ciFixes,
-            reviewRounds: state.reviewRounds,
-            ms: Date.now() - started,
-        };
+    const job = {
+        context,
+        issue,
+        log,
+        state,
+        branch,
+        worktree,
+        comments,
+        started,
+        noChecks: false,
     };
     const setupCommand = config.setupCommand ?? (await ports.detectSetupCommand(worktree));
     if (setupCommand !== undefined) {
@@ -133,10 +123,10 @@ async function work(context, issue, log, state) {
         if (setup.code !== 0) {
             const late = setup.timedOut === true;
             log.event("setup.fail", { code: setup.code, timedOut: late, stderr: setup.stderr.trim().slice(-2000) }, "quiet");
-            await escalate(late
+            await escalate(job, late
                 ? `The setup command did not finish in ${config.setupTimeoutMinutes} minutes.`
                 : "The setup command failed in the worktree.");
-            return finish("needs-human", late ? "setup timeout" : "setup failed");
+            return finish(job, "needs-human", late ? "setup timeout" : "setup failed");
         }
     }
     if (state.phase === "claimed") {
@@ -151,138 +141,183 @@ async function work(context, issue, log, state) {
         }));
         const subject = parseCommitSubject(result.text, `fix: resolve issue #${issue.number}`);
         if (!(await commitWork(job, before, subject))) {
-            await escalate("The implementer produced no change.");
-            return finish("needs-human", "no implementation commit");
+            await escalate(job, "The implementer produced no change.");
+            return finish(job, "needs-human", "no implementation commit");
         }
         state.phase = "implemented";
         await writeState(repo, state);
     }
     await log.step("push", { branch }, () => ports.push(worktree, config.remote, branch));
-    state.pr = await log.step("pull-request", { branch }, async () => {
+    const pr = await log.step("pull-request", { branch }, async () => {
         const existing = await ports.findPr(repo, branch);
         return (existing ??
             ports.createPr(repo, branch, context.base, issue.title, `Closes #${issue.number}\n\nOpened by next-issue.`, config.draftPullRequest));
     });
+    state.pr = pr;
     state.phase = "review";
     await writeState(repo, state);
-    log.event("pull-request.ready", { pr: state.pr }, "quiet");
-    let noChecks = false;
-    const gate = async () => {
-        const head = await ports.revision(worktree);
-        const checks = await log.step("checks", { pr: state.pr, head }, () => ports.waitForChecks(repo, branch, {
-            head,
-            intervalSeconds: config.checkIntervalSeconds,
-            graceMs: noChecks ? 0 : config.checkGraceSeconds * 1000,
-            timeoutMs: config.checkTimeoutMinutes * 60_000,
-            show: log.level === "verbose",
-        }));
-        log.event("checks.state", { state: checks });
-        noChecks ||= checks === "none";
-        if (checks === "timeout") {
-            await escalate("The checks did not finish in time.");
-            return { done: true, report: await finish("needs-human", "checks timeout") };
-        }
-        if (checks !== "fail") {
-            return { done: false, fixed: false };
-        }
-        if (state.ciFixes >= config.maxCiFixes) {
-            await escalate(`The limit of ${config.maxCiFixes} check fixes was reached.`);
-            return { done: true, report: await finish("needs-human", "check budget") };
-        }
-        state.ciFixes += 1;
-        await writeState(repo, state);
-        const logs = await ports.failedCheckLogs(repo, branch, config.logMaxChars);
-        log.event("checks.logs", { chars: logs.length });
-        const fix = await fixRound(job, "The continuous integration checks failed.", logs, history(state.reviewLog), "checks");
-        if (!fix.committed) {
-            const note = fix.unrelated;
-            await escalate(note === undefined
-                ? "The fixer added no commit for the failed checks."
-                : `The checks fail for a reason this change did not cause: ${note}`);
-            return {
-                done: true,
-                report: await finish("needs-human", note === undefined ? "no fix commit" : "unrelated failure"),
-            };
-        }
-        return { done: false, fixed: true };
-    };
+    log.event("pull-request.ready", { pr }, "quiet");
     for (;;) {
-        const before = await gate();
-        if (before.done) {
-            return before.report;
+        const gate = await checkGate(job);
+        if (gate.done) {
+            return gate.report;
         }
-        if (before.fixed) {
+        if (gate.fixed) {
             continue;
         }
-        if (state.reviewRounds >= config.maxReviewRounds) {
-            await escalate(`The limit of ${config.maxReviewRounds} review rounds was reached.`);
-            return finish("needs-human", "review budget");
+        const round = await reviewRound(job);
+        if (round.done) {
+            return round.report;
         }
-        state.reviewRounds += 1;
-        await writeState(repo, state);
-        await setStatus(context, issue.number, state.pr, config.labels.inReview);
-        const full = await ports.diff(worktree, context.base, config.remote);
-        const patch = capDiff(full, config.diffMaxChars);
-        const fields = {
-            round: state.reviewRounds,
-            diffChars: full.length,
-            cut: full.length > config.diffMaxChars,
+    }
+}
+async function checkGate(job) {
+    const { context, log, state, branch, worktree } = job;
+    const { repo, config, ports } = context;
+    const head = await ports.revision(worktree);
+    const checks = await log.step("checks", { pr: state.pr, head }, () => ports.waitForChecks(repo, branch, {
+        head,
+        intervalSeconds: config.checkIntervalSeconds,
+        graceMs: job.noChecks ? 0 : config.checkGraceSeconds * 1000,
+        timeoutMs: config.checkTimeoutMinutes * 60_000,
+        show: log.level === "verbose",
+    }));
+    log.event("checks.state", { state: checks });
+    job.noChecks ||= checks === "none";
+    if (checks === "timeout") {
+        await escalate(job, "The checks did not finish in time.");
+        return { done: true, report: await finish(job, "needs-human", "checks timeout") };
+    }
+    if (checks !== "fail") {
+        return { done: false, fixed: false };
+    }
+    if (state.ciFixes >= config.maxCiFixes) {
+        await escalate(job, `The limit of ${config.maxCiFixes} check fixes was reached.`);
+        return { done: true, report: await finish(job, "needs-human", "check budget") };
+    }
+    state.ciFixes += 1;
+    await writeState(repo, state);
+    const logs = await ports.failedCheckLogs(repo, branch, config.logMaxChars);
+    log.event("checks.logs", { chars: logs.length });
+    const fix = await fixRound(job, "The continuous integration checks failed.", logs, history(state.reviewLog), "checks");
+    if (!fix.committed) {
+        const note = fix.unrelated;
+        await escalate(job, note === undefined
+            ? "The fixer added no commit for the failed checks."
+            : `The checks fail for a reason this change did not cause: ${note}`);
+        return {
+            done: true,
+            report: await finish(job, "needs-human", note === undefined ? "no fix commit" : "unrelated failure"),
         };
-        const review = await log.step("review", fields, () => ports.runAgent(log, {
-            name: "reviewer",
-            cwd: worktree,
-            prompt: reviewPrompt(issue, comments, patch, history(state.reviewLog)),
-            profile: REVIEWING,
-            model: config.models.reviewer,
-            timeoutMs: config.agentTimeoutMinutes * 60_000,
-            outputSchema: VERDICT_SCHEMA,
-        }));
-        if (await ports.discardChanges(worktree)) {
-            log.event("review.discard", { round: state.reviewRounds }, "quiet");
+    }
+    return { done: false, fixed: true };
+}
+async function reviewRound(job) {
+    const { context, issue, log, state, worktree, comments } = job;
+    const { repo, config, ports } = context;
+    const pr = state.pr;
+    if (state.reviewRounds >= config.maxReviewRounds) {
+        await escalate(job, `The limit of ${config.maxReviewRounds} review rounds was reached.`);
+        return { done: true, report: await finish(job, "needs-human", "review budget") };
+    }
+    state.reviewRounds += 1;
+    await writeState(repo, state);
+    await setStatus(context, issue.number, pr, config.labels.inReview);
+    const full = await ports.diff(worktree, context.base, config.remote);
+    const patch = capDiff(full, config.diffMaxChars);
+    const fields = {
+        round: state.reviewRounds,
+        diffChars: full.length,
+        cut: full.length > config.diffMaxChars,
+    };
+    const review = await log.step("review", fields, () => ports.runAgent(log, {
+        name: "reviewer",
+        cwd: worktree,
+        prompt: reviewPrompt(issue, comments, patch, history(state.reviewLog)),
+        profile: REVIEWING,
+        model: config.models.reviewer,
+        timeoutMs: config.agentTimeoutMinutes * 60_000,
+        outputSchema: VERDICT_SCHEMA,
+    }));
+    if (await ports.discardChanges(worktree)) {
+        log.event("review.discard", { round: state.reviewRounds }, "quiet");
+    }
+    const verdict = readVerdict(review.structured);
+    if (verdict === undefined) {
+        await escalate(job, "The reviewer gave no verdict.");
+        return { done: true, report: await finish(job, "needs-human", "no verdict") };
+    }
+    const blocking = blockingFindings(verdict);
+    const open = openFindings(verdict, state.reviewRounds >= config.maxReviewRounds);
+    log.event("verdict", {
+        round: state.reviewRounds,
+        blocking: blocking.length,
+        minor: verdict.findings.length - blocking.length,
+        open: open.length,
+        summary: verdict.summary,
+    }, "quiet");
+    await ports.commentOnPr(repo, pr, formatVerdict(verdict, open));
+    if (open.length === 0) {
+        const gate = await checkGate(job);
+        if (gate.done) {
+            return { done: true, report: gate.report };
+        }
+        if (gate.fixed) {
+            return { done: false };
         }
-        const verdict = readVerdict(review.structured);
-        if (verdict === undefined) {
-            await escalate("The reviewer gave no verdict.");
-            return finish("needs-human", "no verdict");
+        if (config.draftPullRequest && !(await ports.markPrReady(repo, pr))) {
+            log.event("pull-request.undraft.fail", { pr }, "quiet");
         }
-        const blocking = blockingFindings(verdict);
-        const open = openFindings(verdict, state.reviewRounds >= config.maxReviewRounds);
-        log.event("verdict", {
-            round: state.reviewRounds,
-            blocking: blocking.length,
-            minor: verdict.findings.length - blocking.length,
-            open: open.length,
-            summary: verdict.summary,
-        }, "quiet");
-        await ports.commentOnPr(repo, state.pr, formatVerdict(verdict, open));
-        if (open.length === 0) {
-            const after = await gate();
-            if (after.done) {
-                return after.report;
-            }
-            if (after.fixed) {
-                continue;
-            }
-            if (config.draftPullRequest && !(await ports.markPrReady(repo, state.pr))) {
-                log.event("pull-request.undraft.fail", { pr: state.pr }, "quiet");
-            }
-            await setStatus(context, issue.number, state.pr, config.labels.done);
-            return finish("done");
+        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);
+    const fix = await fixRound(job, "The reviewer requested changes.", formatFindings(open), earlier, "review");
+    if (!fix.committed) {
+        const note = fix.unrelated;
+        if (note === undefined) {
+            await escalate(job, "The fixer added no commit for the review findings.");
+            return { done: true, report: await finish(job, "needs-human", "no fix commit") };
         }
-        const mark = fingerprint(open);
-        if (state.reviewLog.some((round) => round.fingerprint === mark)) {
-            await escalate("The reviewer repeated findings that an earlier round did not fix.");
-            return finish("needs-human", "repeated findings");
+        if (fix.stray === true) {
+            await escalate(job, `The fixer disputed the findings and left a change behind: ${note}`);
+            return { done: true, report: await finish(job, "needs-human", "dispute with changes") };
         }
-        const earlier = history(state.reviewLog);
-        state.reviewLog.push({ round: state.reviewRounds, fingerprint: mark, findings: formatFindings(open) });
+        state.reviewLog.at(-1).dispute = note;
         await writeState(repo, state);
-        const fix = await fixRound(job, "The reviewer requested changes.", formatFindings(open), earlier, "review");
-        if (!fix.committed) {
-            await escalate("The fixer added no commit for the review findings.");
-            return finish("needs-human", "no fix commit");
+        await ports.commentOnPr(repo, pr, `### Fixer: no change\n\n${note}`);
+    }
+    return { done: false };
+}
+function escalate(job, reason) {
+    return handOver(job.context, job.log, job.issue.number, job.state, reason);
+}
+async function finish(job, outcome, reason) {
+    const { context, issue, log, state, branch } = job;
+    const { repo, ports } = context;
+    await cleanUp(context, log, issue.number);
+    if (outcome === "done") {
+        if (!(await ports.deleteBranch(repo, branch))) {
+            log.event("branch.kept", { branch }, "quiet");
         }
+        await dropState(repo, issue.number);
     }
+    return {
+        issue: issue.number,
+        outcome,
+        reason,
+        pr: state.pr,
+        ciFixes: state.ciFixes,
+        reviewRounds: state.reviewRounds,
+        ms: Date.now() - job.started,
+    };
 }
 async function fixRound(job, reason, detail, earlier, kind) {
     const { context, issue, log, worktree, branch } = job;
@@ -298,8 +333,9 @@ async function fixRound(job, reason, detail, earlier, kind) {
     }));
     const unrelated = parseUnrelated(result.text);
     if (unrelated !== undefined) {
-        log.event("fix.unrelated", { reason, note: unrelated }, "quiet");
-        return { committed: false, unrelated };
+        const stray = (await ports.revision(worktree)) !== before || (await ports.isDirty(worktree));
+        log.event("fix.unrelated", { reason, note: unrelated, stray }, "quiet");
+        return { committed: false, unrelated, stray };
     }
     const subject = parseCommitSubject(result.text, `fix: address feedback on issue #${issue.number}`);
     if (!(await commitWork(job, before, subject))) {
@@ -346,5 +382,10 @@ async function setStatus(context, issue, pr, label) {
     }
 }
 function history(rounds) {
-    return rounds.map((round) => `Round ${round.round}:\n${round.findings}`);
+    return rounds.map((round) => {
+        const head = `Round ${round.round}:\n${round.findings}`;
+        return round.dispute === undefined
+            ? head
+            : `${head}\nThe fixer disputed every finding of this round: ${round.dispute}`;
+    });
 }

package/dist/prompts.mjs

@@ -33,6 +33,8 @@ export function reviewPrompt(issue, comments, diff, earlier) {
             "This is a later round. Judge two things only:",
             "whether the earlier findings below are now fixed, and whether the new commits broke something.",
             "Do not raise a new point of taste. Do not repeat a finding that is fixed.",
+            "A `The fixer disputed every finding of this round` line answers all of the findings of that round, not one of them.",
+            "Withdraw every finding of that round if the dispute is correct. Repeat them all if the dispute is wrong.",
             `## Earlier findings\n${earlier.join("\n")}`,
         ].join("\n");
     return [
@@ -56,6 +58,12 @@ const UNRELATED_RULE = [
     "Establish that before you fix anything. If the failure is not yours, change nothing and end your final message with one line in the form `unrelated: <one sentence on what fails and why it is not this change>`.",
     "A person then reads it. Do not weaken, skip or re-record a test to make the checks pass.",
 ].join("\n");
+const DISPUTE_RULE = [
+    "A finding can be wrong: it can miss a convention of this repository, ask for work that the issue does not want, or describe behaviour that the code does not have.",
+    "Establish that before you change anything. If every finding is wrong, change nothing and end your final message with one line in the form `unrelated: <one sentence on why the findings are wrong>`.",
+    "If only some of the findings are wrong, fix the correct ones and change nothing for the wrong ones. Write no `unrelated` line in that round. The next round holds only the findings that are left, and you can dispute them there.",
+    "The reviewer reads that line in the next round. Do not make a change that you hold to be wrong only to end the round.",
+].join("\n");
 export function fixPrompt(issue, reason, detail, earlier, kind) {
     return [
         `You are the fixer. Correct the work for issue #${issue.number}: ${issue.title}.`,
@@ -70,7 +78,7 @@ export function fixPrompt(issue, reason, detail, earlier, kind) {
             : "",
         "## Rules",
         "Fix the cause, not the symptom. Keep the change minimal.",
-        kind === "checks" ? UNRELATED_RULE : "",
+        kind === "checks" ? UNRELATED_RULE : DISPUTE_RULE,
         COMMIT_RULES,
     ]
         .filter((part) => part.length > 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-issue",
-  "version": "0.12.5",
+  "version": "0.14.0",
   "description": "Autonomous issue harness driven by the Claude Agent SDK",
   "keywords": [
     "github",