next-issue 0.17.1 → 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,
@@ -113,17 +122,24 @@ 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
+## Stop a run
 
-Run `touch .next-issue/stop` in a second terminal. The harness reads the file
-only between two issues, finishes the issue that it holds, deletes the file and
-then writes the summary as usual. A file from an earlier run is dropped at the
-start, so it stops nothing.
+Press `Ctrl-C` to stop the run step by step:
 
-`Ctrl-C` is different: the harness passes the signal on to the command that runs
-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.
+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.
+3. The third press 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
+   summary.
+
+Each of the first two presses prints a line that says what happens next. The
+agents and commands run in a process group of their own, so a press reaches only
+the harness.
 
 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`
@@ -342,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/agents.mjs

@@ -1,4 +1,6 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { spawn } from "node:child_process";
+import { track } from "./exec.mjs";
 import { emptyUsage } from "./observe.mjs";
 import { runPi } from "./pi.mjs";
 const REVIEWING = {
@@ -45,6 +47,7 @@ export async function runAgent(recorder, request) {
                 allowDangerouslySkipPermissions: request.profile.allowDangerouslySkipPermissions,
                 systemPrompt: { type: "preset", preset: "claude_code" },
                 abortController: controller,
+                spawnClaudeCodeProcess: spawnClaude,
                 outputFormat: request.outputSchema === undefined
                     ? undefined
                     : { type: "json_schema", schema: request.outputSchema },
@@ -149,3 +152,14 @@ export function toolFields(name, input) {
     const { command } = input;
     return typeof command === "string" ? { tool: name, command } : { tool: name };
 }
+export function spawnClaude(options) {
+    const child = spawn(options.command, options.args, {
+        cwd: options.cwd,
+        env: options.env,
+        signal: options.signal,
+        detached: true,
+        stdio: ["pipe", "pipe", "ignore"],
+    });
+    track(child);
+    return child;
+}

package/dist/cli.mjs

@@ -6,10 +6,11 @@ import { loadConfig, writeDefaultConfig } from "./config.mjs";
 import { setCommandObserver, setDefaultTimeout } from "./exec.mjs";
 import { detectRepo, ensureIgnored, repoRoot } from "./git.mjs";
 import { defaultBranch, openIssues } from "./github.mjs";
+import { listenForInterrupts } from "./interrupt.mjs";
 import { exitCode, runIssues } from "./loop.mjs";
 import { message, pruneRuns, Recorder } from "./observe.mjs";
 import { PORTS, processIssue } from "./pipeline.mjs";
-import { STATE_DIR, takeStop } from "./state.mjs";
+import { STATE_DIR } from "./state.mjs";
 import { formatSummary } from "./summary.mjs";
 import { packageVersion } from "./version.mjs";
 function write(stream, text) {
@@ -61,8 +62,18 @@ async function init(root, force) {
     return 0;
 }
 async function handle(args, config, repo, recorder) {
+    const interrupts = listenForInterrupts((text) => void write(process.stderr, `${text}\n`));
     const base = await defaultBranch(repo);
-    const context = { repo, config, base, reset: args.reset, merge: args.merge, recorder, ports: PORTS };
+    const context = {
+        repo,
+        config,
+        base,
+        reset: args.reset,
+        merge: args.merge,
+        stopAfterRound: interrupts.afterRound,
+        recorder,
+        ports: PORTS,
+    };
     recorder.event("run.start", {
         version: await packageVersion(),
         repo: `${repo.owner}/${repo.name}`,
@@ -74,7 +85,7 @@ async function handle(args, config, repo, recorder) {
     const { reports, stoppedAt } = await runIssues(args, {
         issues,
         process: (issue) => processIssue(context, issue),
-        stop: () => takeStop(repo),
+        stop: interrupts.afterIssue,
     });
     if (stoppedAt !== undefined) {
         recorder.event("run.stop", { issue: stoppedAt }, "quiet");

package/dist/exec.mjs

@@ -3,7 +3,7 @@ let observer;
 let defaultTimeoutMs = 10 * 60_000;
 const STDERR_TAIL = 200_000;
 const groups = new Set();
-function forward(signal) {
+export function stopChildren(signal) {
     for (const pid of groups) {
         try {
             process.kill(-pid, signal);
@@ -11,18 +11,15 @@ function forward(signal) {
         catch { }
     }
     groups.clear();
-    process.off("SIGINT", onInterrupt);
     process.off("SIGTERM", onTerminate);
     process.kill(process.pid, signal);
 }
-const onInterrupt = () => forward("SIGINT");
-const onTerminate = () => forward("SIGTERM");
+const onTerminate = () => stopChildren("SIGTERM");
 function watch(pid) {
     if (pid === undefined) {
         return;
     }
     if (groups.size === 0) {
-        process.on("SIGINT", onInterrupt);
         process.on("SIGTERM", onTerminate);
     }
     groups.add(pid);
@@ -33,10 +30,14 @@ function unwatch(pid) {
     }
     groups.delete(pid);
     if (groups.size === 0) {
-        process.off("SIGINT", onInterrupt);
         process.off("SIGTERM", onTerminate);
     }
 }
+export function track(child) {
+    watch(child.pid);
+    child.on("close", () => unwatch(child.pid));
+    child.on("error", () => unwatch(child.pid));
+}
 export function setCommandObserver(next) {
     observer = next;
 }

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/interrupt.mjs

@@ -0,0 +1,22 @@
+import { stopChildren } from "./exec.mjs";
+export function listenForInterrupts(say) {
+    let presses = 0;
+    const press = () => {
+        presses += 1;
+        if (presses === 1) {
+            say("Stopping after this issue. Press Ctrl-C again to stop after this round.");
+        }
+        else if (presses === 2) {
+            say("Stopping after this round. Press Ctrl-C again to stop now.");
+        }
+        else {
+            process.off("SIGINT", press);
+            stopChildren("SIGINT");
+        }
+    };
+    process.on("SIGINT", press);
+    return {
+        afterIssue: () => presses >= 1,
+        afterRound: () => presses >= 2,
+    };
+}

package/dist/loop.mjs

@@ -1,5 +1,4 @@
 export async function runIssues(args, loop) {
-    await loop.stop();
     const reports = [];
     for (const issue of loop.issues) {
         if (args.max !== undefined && handled(reports) >= args.max) {
@@ -7,7 +6,7 @@ export async function runIssues(args, loop) {
         }
         const report = await loop.process(issue);
         reports.push(report);
-        if (await 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) {
@@ -167,17 +173,16 @@ async function work(context, issue, log, state) {
         state.phase = "implemented";
         await writeState(repo, state);
     }
+    if (context.stopAfterRound()) {
+        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);
+        }
         const gate = await checkGate(job);
         if (gate.done) {
             return gate.report;
@@ -185,12 +190,27 @@ async function work(context, issue, log, state) {
         if (gate.fixed) {
             continue;
         }
+        if (context.stopAfterRound()) {
+            return stop(job);
+        }
         const round = await reviewRound(job);
         if (round.done) {
             return round.report;
         }
     }
 }
+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;
@@ -289,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") };
@@ -321,9 +350,65 @@ 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);
 }
+function stop(job) {
+    const { issue, log, state } = job;
+    log.event("issue.stop", { phase: state.phase }, "quiet");
+    return {
+        issue: issue.number,
+        outcome: "stopped",
+        pr: state.pr,
+        ciFixes: state.ciFixes,
+        reviewRounds: state.reviewRounds,
+        ms: Date.now() - job.started,
+    };
+}
 async function finish(job, outcome, reason) {
     const { context, issue, log, state, branch } = job;
     const { repo, ports } = context;
@@ -342,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/dist/state.mjs

@@ -22,15 +22,6 @@ export async function writeState(repo, state) {
     await mkdir(dir(repo), { recursive: true });
     await writeFile(file(repo, state.issue), `${JSON.stringify(state, null, 2)}\n`);
 }
-export async function takeStop(repo) {
-    try {
-        await rm(join(dir(repo), "stop"));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 export async function dropState(repo, issue) {
     await rm(file(repo, issue), { force: true });
 }

package/dist/summary.mjs

@@ -1,4 +1,4 @@
-const OUTCOMES = ["done", "needs-human", "error", "skipped"];
+const OUTCOMES = ["done", "needs-human", "error", "skipped", "stopped"];
 export function formatSummary(summary) {
     const tally = OUTCOMES.map((outcome) => `${summary.issues.filter((report) => report.outcome === outcome).length} ${outcome}`).join(", ");
     const lines = [`run ${summary.runId}`, `issues ${summary.issues.length}: ${tally}`];

package/package.json

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