next-issue 0.18.0 → 0.19.0

package/README.md

@@ -59,9 +59,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 +101,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,
@@ -349,7 +358,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/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,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, 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 { detectSetupCommand } from "./setup.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) {
@@ -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) {

package/package.json

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