next-issue 0.18.0 → 0.20.0

package/README.md

@@ -33,7 +33,9 @@ For each open issue, oldest first:
    local branch that fell behind the remote is fast-forwarded. A fast-forward
    of the base that is not safe leaves the local base branch as it is and
    writes a `base.behind` event. A new branch then starts from the remote base.
-4. Let the implementer agent do the work, then commit and push.
+4. Let the implementer agent do the work, then commit and push. When a git
+   hook stops a commit, the agent that made the change gets the hook output,
+   fixes it, and the harness commits again. The budget is `maxCommitFixes`.
 5. Open a draft pull request that closes the issue.
 6. Wait for the checks, once the pull request shows the pushed commit. A
    pending state waits again, up to `checkTimeoutMinutes`. A read that fails
@@ -59,9 +61,15 @@ For each open issue, oldest first:
    finding.
 10. No open finding means approval: mark the pull request ready for review and
     set `status:done`. The merge stays with you, unless you pass `--merge`:
-    then the harness squash-merges the pull request and deletes the remote
-    branch. The worktree, the local branch and the state file go away. Without
-    `--merge`, the remote branch stays. A problem that the
+    then the harness squash-merges the pull request, deletes the remote
+    branch and waits for the checks that the merge commit starts on the base
+    branch. A cancelled run there is no failure. When those checks fail, the
+    fixer gets their logs on a branch reset to the base branch, from the check
+    budget, and the harness reopens the issue and opens a new pull request that
+    goes to step 6 again, with fresh review rounds. The next issue waits for
+    this, and a second ctrl-c stops only after it. The worktree, the local
+    branch and the state file go away. Without `--merge`, the remote branch
+    stays. A problem that the
     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
@@ -95,6 +103,9 @@ when:
 - the reviewer gives no verdict, or the checks do not finish in time;
 - with `--merge`, the merge of an approved pull request fails, for example
    because branch protection asks for a human approval;
+- 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;
 - 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,
@@ -229,6 +240,7 @@ does not know all stop the run, so a typo cannot pass without a word.
   "remote": "origin",
   "issueLimit": 100,
   "maxCiFixes": 5,
+  "maxCommitFixes": 10,
   "maxReviewRounds": 5,
   "checkIntervalSeconds": 15,
   "checkGraceSeconds": 60,
@@ -262,6 +274,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 |
 | `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 |
 | `checkIntervalSeconds` | `15` | The time between two check states |
 | `checkGraceSeconds` | `60` | The time to wait for the first check to show |
@@ -349,7 +362,7 @@ that a label still holds back stays as it was.
 | `--once` | Stop after the first handled issue |
 | `--max <n>` | Handle at most n issues |
 | `--agent <a>` | Run the agents with `claude` or `pi`, whatever the config file says |
-| `--merge` | Squash-merge the pull request after the approval, and delete the remote branch |
+| `--merge` | Squash-merge the pull request after the approval, delete the remote branch and fix a failure of the checks on the base branch |
 | `--reset` | Drop the saved budgets and findings, and keep the rest of the state |
 | `--json` | Print the machine summary instead of the text one |
 | `--verbose` | Show every command and all agent output |

package/dist/config.mjs

@@ -7,6 +7,7 @@ const DEFAULTS = {
     remote: "origin",
     issueLimit: 100,
     maxCiFixes: 5,
+    maxCommitFixes: 10,
     maxReviewRounds: 5,
     checkIntervalSeconds: 15,
     checkGraceSeconds: 60,
@@ -35,6 +36,7 @@ const FIELDS = [...Object.keys(DEFAULTS), "setupCommand"];
 const WHOLE_FIELDS = [
     ["issueLimit", 1],
     ["maxCiFixes", 0],
+    ["maxCommitFixes", 0],
     ["maxReviewRounds", 1],
     ["checkIntervalSeconds", 1],
     ["checkGraceSeconds", 0],

package/dist/git.mjs

@@ -111,6 +111,10 @@ export async function discardChanges(cwd) {
 export async function push(cwd, remote, branch) {
     await must("git", ["push", "-u", remote, branch], { cwd });
 }
+export async function resetToBase(cwd, base, remote) {
+    await must("git", ["fetch", remote, base], { cwd });
+    await must("git", ["reset", "--hard", `${remote}/${base}`], { cwd });
+}
 export async function revision(cwd) {
     return must("git", ["rev-parse", "HEAD"], { cwd });
 }

package/dist/github.mjs

@@ -5,6 +5,7 @@ const NETWORK_TRIES = 3;
 const NETWORK_FAULT = /unexpected EOF|connection reset|connection refused|i\/o timeout|TLS handshake timeout|HTTP 50[234]/i;
 const KNOWN_LABELS = new Map();
 const NO_CHECKS = /no checks reported/i;
+const FAILED_CONCLUSIONS = new Set(["failure", "timed_out", "startup_failure"]);
 function slug(repo) {
     return `${repo.owner}/${repo.name}`;
 }
@@ -228,12 +229,42 @@ export async function failedCheckLogs(repo, branch, maxChars) {
     if (checks === "none") {
         return "The checks failed, but gh reports no check for the branch.";
     }
-    const failed = checks.filter((check) => check.bucket === "fail");
+    const failed = checks
+        .filter((check) => check.bucket === "fail")
+        .map((check) => ({
+        heading: `## ${check.name}\n${check.description}`,
+        runId: /\/actions\/runs\/(\d+)/.exec(check.link)?.[1],
+    }));
+    return runLogs(repo, failed, maxChars);
+}
+async function baseRuns(repo, sha) {
+    const raw = await gh(repo, ["run", "list", "--commit", sha, "--json", "databaseId,name,status,conclusion"]);
+    return JSON.parse(raw);
+}
+function baseState(runs) {
+    if (runs.some((entry) => entry.status === "completed" && FAILED_CONCLUSIONS.has(entry.conclusion))) {
+        return "fail";
+    }
+    return runs.every((entry) => entry.status === "completed") ? "pass" : "pending";
+}
+export function waitForBaseChecks(repo, sha, options) {
+    return pollChecks({
+        head: async () => sha,
+        list: async () => ((await baseRuns(repo, sha)).length === 0 ? "none" : "some"),
+        watch: async () => baseState(await baseRuns(repo, sha)),
+    }, options);
+}
+export async function failedBaseLogs(repo, sha, maxChars) {
+    const failed = (await baseRuns(repo, sha))
+        .filter((entry) => entry.status === "completed" && FAILED_CONCLUSIONS.has(entry.conclusion))
+        .map((entry) => ({ heading: `## ${entry.name}`, runId: String(entry.databaseId) }));
+    return runLogs(repo, failed, maxChars);
+}
+async function runLogs(repo, failed, maxChars) {
     const share = Math.max(1, Math.floor(maxChars / Math.max(1, failed.length)));
     const parts = [];
-    for (const check of failed) {
-        parts.push(`## ${check.name}\n${check.description}`);
-        const runId = /\/actions\/runs\/(\d+)/.exec(check.link)?.[1];
+    for (const { heading, runId } of failed) {
+        parts.push(heading);
         if (runId === undefined) {
             continue;
         }
@@ -262,6 +293,12 @@ export async function mergePr(repo, pr) {
     const result = await run("gh", ["pr", "merge", String(pr), "--squash", "--delete-branch", "--repo", slug(repo)], { cwd: repo.root });
     return result.code === 0;
 }
+export async function mergeCommit(repo, pr) {
+    return gh(repo, ["pr", "view", String(pr), "--json", "mergeCommit", "--jq", ".mergeCommit.oid"]);
+}
+export async function reopenIssue(repo, issue) {
+    await gh(repo, ["issue", "reopen", String(issue)]);
+}
 export async function commentOnPr(repo, pr, body) {
     await ghOnce(repo, ["pr", "comment", String(pr), "--body-file", "-"], body);
 }

package/dist/loop.mjs

@@ -6,7 +6,7 @@ export async function runIssues(args, loop) {
         }
         const report = await loop.process(issue);
         reports.push(report);
-        if (loop.stop()) {
+        if (loop.stop() || report.halt === true) {
             return { reports, stoppedAt: issue.number };
         }
         if (args.once && report.outcome !== "skipped") {

package/dist/pipeline.mjs

@@ -1,10 +1,10 @@
 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, isDirty, push, removeWorktree, revision, worktreePath, } from "./git.mjs";
-import { commentOnPr, createPr, failedCheckLogs, findPr, issueComments, markPrReady, mergePr, openBlockers, setLabel, waitForChecks, } from "./github.mjs";
+import { addWorktree, branchName, commitAll, deleteBranch, diff, discardChanges, hasWorktree, isDirty, push, removeWorktree, resetToBase, revision, worktreePath, } from "./git.mjs";
+import { commentOnPr, createPr, failedBaseLogs, failedCheckLogs, findPr, issueComments, markPrReady, mergeCommit, mergePr, openBlockers, reopenIssue, setLabel, waitForBaseChecks, waitForChecks, } from "./github.mjs";
 import { message } from "./observe.mjs";
-import { capDiff, fixPrompt, implementPrompt, parseCommitSubject, parseUnrelated, reviewPrompt, } from "./prompts.mjs";
+import { capDiff, fixPrompt, hookPrompt, implementPrompt, parseCommitSubject, parseUnrelated, reviewPrompt, } from "./prompts.mjs";
 import { detectSetupCommand } from "./setup.mjs";
 import { dropState, readState, resetState, writeState, } from "./state.mjs";
 import { blockingFindings, fingerprint, formatFindings, formatVerdict, openFindings, readVerdict, VERDICT_SCHEMA, } from "./verdict.mjs";
@@ -17,20 +17,25 @@ export const PORTS = {
     detectSetupCommand,
     diff,
     discardChanges,
+    failedBaseLogs,
     failedCheckLogs,
     findPr,
     hasWorktree,
     isDirty,
     issueComments,
     markPrReady,
+    mergeCommit,
     mergePr,
     openBlockers,
     push,
     removeWorktree,
+    reopenIssue,
+    resetToBase,
     revision,
     runAgent,
     runSetup: async (command, cwd, timeoutMs) => run("bash", ["-lc", command], { cwd, timeoutMs }),
     setLabel,
+    waitForBaseChecks,
     waitForChecks,
 };
 export function skipReason(issue, config, resuming) {
@@ -135,6 +140,7 @@ async function work(context, issue, log, state) {
         comments,
         started,
         noChecks: false,
+        mainBroken: false,
     };
     const setupCommand = config.setupCommand ?? (await ports.detectSetupCommand(worktree));
     if (setupCommand !== undefined) {
@@ -160,7 +166,7 @@ async function work(context, issue, log, state) {
             timeoutMs: config.agentTimeoutMinutes * 60_000,
         }));
         const subject = parseCommitSubject(result.text, `fix: resolve issue #${issue.number}`);
-        if (!(await commitWork(job, before, subject))) {
+        if (!(await commitWork(job, before, subject, "implementer"))) {
             await escalate(job, "The implementer produced no change.");
             return finish(job, "needs-human", "no implementation commit");
         }
@@ -171,15 +177,8 @@ async function work(context, issue, log, state) {
         return stop(job);
     }
     await log.step("push", { branch }, () => ports.push(worktree, config.remote, branch));
-    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 }, "quiet");
+    await openPr(job);
     for (;;) {
         if (context.stopAfterRound()) {
             return stop(job);
@@ -200,6 +199,18 @@ async function work(context, issue, log, state) {
         }
     }
 }
+async function openPr(job) {
+    const { context, issue, log, state, branch } = job;
+    const { repo, config, ports } = context;
+    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;
+    await writeState(repo, state);
+    log.event("pull-request.ready", { pr }, "quiet");
+}
 async function checkGate(job) {
     const { context, log, state, branch, worktree } = job;
     const { repo, config, ports } = context;
@@ -298,9 +309,18 @@ async function reviewRound(job) {
         if (config.draftPullRequest && !(await ports.markPrReady(repo, pr))) {
             log.event("pull-request.undraft.fail", { pr }, "quiet");
         }
-        if (context.merge && !(await ports.mergePr(repo, pr))) {
-            await escalate(job, "The merge of the pull request failed.");
-            return { done: true, report: await finish(job, "needs-human", "merge failed") };
+        if (context.merge) {
+            if (!(await ports.mergePr(repo, pr))) {
+                await escalate(job, "The merge of the pull request failed.");
+                return { done: true, report: await finish(job, "needs-human", "merge failed") };
+            }
+            const watched = await watchBase(job);
+            if (watched.done) {
+                return { done: true, report: watched.report };
+            }
+            if (watched.fixed) {
+                return { done: false };
+            }
         }
         await setStatus(context, issue.number, pr, config.labels.done);
         return { done: true, report: await finish(job, "done") };
@@ -330,6 +350,50 @@ async function reviewRound(job) {
     }
     return { done: false };
 }
+async function watchBase(job) {
+    const { context, issue, log, state, worktree } = job;
+    const { repo, config, ports } = context;
+    const sha = await ports.mergeCommit(repo, state.pr);
+    const checks = await log.step("main-checks", { pr: state.pr, sha }, () => ports.waitForBaseChecks(repo, sha, {
+        intervalSeconds: config.checkIntervalSeconds,
+        graceMs: config.checkGraceSeconds * 1000,
+        timeoutMs: config.checkTimeoutMinutes * 60_000,
+    }));
+    log.event("main-checks.state", { state: checks });
+    if (checks === "pass" || checks === "none") {
+        return { done: false, fixed: false };
+    }
+    job.mainBroken = true;
+    if (checks !== "fail") {
+        await escalate(job, "The checks on main did not finish in time.");
+        return { done: true, report: await finish(job, "needs-human", "main checks timeout") };
+    }
+    if (state.ciFixes >= config.maxCiFixes) {
+        await escalate(job, `The checks on main failed and 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);
+    await ports.resetToBase(worktree, context.base, config.remote);
+    const logs = await ports.failedBaseLogs(repo, sha, config.logMaxChars);
+    log.event("main-checks.logs", { chars: logs.length });
+    const fix = await fixRound(job, "The checks on main failed after the merge.", logs, [], "checks");
+    if (!fix.committed) {
+        const note = fix.unrelated;
+        await escalate(job, note === undefined
+            ? "The fixer added no commit for the failed checks on main."
+            : `The checks on main 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"),
+        };
+    }
+    await ports.reopenIssue(repo, issue.number);
+    state.reviewRounds = 0;
+    state.reviewLog = [];
+    await openPr(job);
+    return { done: false, fixed: true };
+}
 function escalate(job, reason) {
     return handOver(job.context, job.log, job.issue.number, job.state, reason);
 }
@@ -363,6 +427,7 @@ async function finish(job, outcome, reason) {
         ciFixes: state.ciFixes,
         reviewRounds: state.reviewRounds,
         ms: Date.now() - job.started,
+        ...(job.mainBroken && outcome !== "done" ? { halt: true } : {}),
     };
 }
 async function fixRound(job, reason, detail, earlier, kind) {
@@ -385,19 +450,43 @@ async function fixRound(job, reason, detail, earlier, kind) {
         return { committed: false, unrelated, stray };
     }
     const subject = parseCommitSubject(result.text, `fix: address feedback on issue #${issue.number}`);
-    if (!(await commitWork(job, before, subject))) {
+    if (!(await commitWork(job, before, subject, "fixer"))) {
         log.event("commit.empty", { reason }, "quiet");
         return { committed: false };
     }
     await ports.push(worktree, context.config.remote, branch);
     return { committed: true };
 }
-async function commitWork(job, before, subject) {
-    const { context, issue, log, worktree } = job;
-    if (await context.ports.commitAll(worktree, `${subject}\n\nRefs #${issue.number}`)) {
-        log.event("commit", { subject });
+async function commitWork(job, before, subject, role) {
+    const { context, issue, log, state, worktree, comments } = job;
+    const { repo, config, ports } = context;
+    for (;;) {
+        try {
+            if (await ports.commitAll(worktree, `${subject}\n\nRefs #${issue.number}`)) {
+                log.event("commit", { subject });
+            }
+            return (await ports.revision(worktree)) !== before;
+        }
+        catch (error) {
+            const used = state.commitFixes ?? 0;
+            if (used >= config.maxCommitFixes) {
+                throw error;
+            }
+            state.commitFixes = used + 1;
+            await writeState(repo, state);
+            const output = message(error).slice(-config.logMaxChars);
+            log.event("commit.fail", { role, output }, "quiet");
+            await log.step("commit-fix", { role }, () => ports.runAgent(log, {
+                name: role,
+                cwd: worktree,
+                prompt: hookPrompt(issue, comments, role, output),
+                profile: CODING,
+                model: config.models[role],
+                agent: config.agent,
+                timeoutMs: config.agentTimeoutMinutes * 60_000,
+            }));
+        }
     }
-    return (await context.ports.revision(worktree)) !== before;
 }
 async function cleanUp(context, log, issue) {
     const path = worktreePath(context.repo, issue);

package/dist/prompts.mjs

@@ -21,6 +21,16 @@ export function implementPrompt(issue, comments) {
         COMMIT_RULES,
     ].join("\n\n");
 }
+export function hookPrompt(issue, comments, role, output) {
+    return [
+        `You are the ${role}. The harness could not commit your work for the issue below, because a git hook failed.`,
+        issueBlock(issue, comments),
+        `## Hook output\n${output}`,
+        "## Rules",
+        "Fix what the hook reports and keep the rest of the work in this worktree. Do not skip or weaken the hook.",
+        COMMIT_RULES,
+    ].join("\n\n");
+}
 export function capDiff(diff, maxChars) {
     return diff.length <= maxChars
         ? diff

package/dist/state.mjs

@@ -16,7 +16,7 @@ export async function readState(repo, issue) {
     }
 }
 export function resetState(state) {
-    return { ...state, ciFixes: 0, reviewRounds: 0, reviewLog: [] };
+    return { ...state, ciFixes: 0, commitFixes: 0, reviewRounds: 0, reviewLog: [] };
 }
 export async function writeState(repo, state) {
     await mkdir(dir(repo), { recursive: true });

package/package.json

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