next-issue 0.17.0 → 0.18.0

package/README.md

@@ -97,7 +97,10 @@ when:
    because branch protection asks for a human approval;
 - 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 step of the run fails with an error. A `gh` call that is safe to repeat,
+   such as a read or a label edit, is tried up to three times first when the
+   network fails. A `gh pr create` or `gh pr comment` is tried once, so a lost
+   reply never makes a duplicate.
 
 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
@@ -110,17 +113,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`

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

@@ -1,16 +1,34 @@
 import { must, run } from "./exec.mjs";
 const CHECK_PENDING_CODE = 8;
 const READ_TRIES = 3;
+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;
 function slug(repo) {
     return `${repo.owner}/${repo.name}`;
 }
-async function gh(repo, args, input) {
+async function repeatable(args, options) {
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            return await must("gh", args, options);
+        }
+        catch (error) {
+            if (attempt >= NETWORK_TRIES || !(error instanceof Error) || !NETWORK_FAULT.test(error.message)) {
+                throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, attempt * 1000));
+        }
+    }
+}
+async function gh(repo, args) {
+    return repeatable([...args, "--repo", slug(repo)], { cwd: repo.root });
+}
+async function ghOnce(repo, args, input) {
     return must("gh", [...args, "--repo", slug(repo)], { cwd: repo.root, input });
 }
 export async function defaultBranch(repo) {
-    const raw = await must("gh", ["repo", "view", slug(repo), "--json", "defaultBranchRef"], {
+    const raw = await repeatable(["repo", "view", slug(repo), "--json", "defaultBranchRef"], {
         cwd: repo.root,
     });
     return JSON.parse(raw).defaultBranchRef.name;
@@ -45,7 +63,7 @@ export async function issueComments(repo, issue) {
     return parsed.comments.map((comment) => `@${comment.author.login}: ${comment.body}`);
 }
 export async function openBlockers(repo, issue) {
-    const raw = await must("gh", [
+    const raw = await repeatable([
         "api",
         "--paginate",
         `repos/${slug(repo)}/issues/${issue}/dependencies/blocked_by`,
@@ -100,7 +118,7 @@ export async function findPr(repo, branch) {
     return parsed[0]?.number;
 }
 export async function createPr(repo, branch, base, title, body, draft) {
-    const created = await gh(repo, [
+    const created = await ghOnce(repo, [
         "pr",
         "create",
         "--head",
@@ -245,5 +263,5 @@ export async function mergePr(repo, pr) {
     return result.code === 0;
 }
 export async function commentOnPr(repo, pr, body) {
-    await gh(repo, ["pr", "comment", String(pr), "--body-file", "-"], 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()) {
             return { reports, stoppedAt: issue.number };
         }
         if (args.once && report.outcome !== "skipped") {

package/dist/pipeline.mjs

@@ -167,6 +167,9 @@ 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);
@@ -178,6 +181,9 @@ async function work(context, issue, log, state) {
     await writeState(repo, state);
     log.event("pull-request.ready", { pr }, "quiet");
     for (;;) {
+        if (context.stopAfterRound()) {
+            return stop(job);
+        }
         const gate = await checkGate(job);
         if (gate.done) {
             return gate.report;
@@ -185,6 +191,9 @@ 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;
@@ -324,6 +333,18 @@ async function reviewRound(job) {
 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;

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.0",
+  "version": "0.18.0",
   "description": "Autonomous issue harness driven by the Claude Agent SDK",
   "keywords": [
     "github",