next-issue 0.8.0 → 0.9.0

package/README.md

@@ -21,25 +21,31 @@ 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. An issue with saved state under `.next-issue/` resumes instead,
-   whatever its labels, unless another person is now the assignee.
+   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`.
-3. Fetch the default branch, fast-forward the local copy of it when that is
-   safe, then add a git worktree on a new `issue-<n>` branch from it.
+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
+   local branch that fell behind the remote is fast-forwarded.
 4. Let the implementer agent do the work, then commit and push.
 5. Open a draft pull request that closes the issue.
-6. Wait for the checks. A pending state waits again, up to
-   `checkTimeoutMinutes`. A repository that reports no check keeps asking for
-   `checkGraceSeconds`, because a new pull request often shows no check yet,
-   and only then goes straight to the review.
+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
+   is tried three times before the run stops. A repository that reports no
+   check keeps asking for `checkGraceSeconds`, because a new pull request often
+   shows no check yet, and only then goes straight to the review. The later
+   gates of the same issue ask once.
 7. On a red build, give the failed job logs to the fixer agent, then go to step
    6 again. The budget is `maxCiFixes`.
 8. Let the reviewer agent judge the diff, at most `diffMaxChars` of it. The
    reviewer returns a structured verdict that rates each finding `blocking` or
    `minor`. The harness puts the result on the pull request.
 9. No blocking finding means approval: mark the pull request ready for review
-   and set `status:done`. The merge stays with you. A blocking finding always
-   stops the approval, even when the reviewer also says approve.
+   and set `status:done`. The merge stays with you. The worktree, the local
+   branch and the state file go away. The remote branch stays. A blocking
+   finding always stops the approval, even when the reviewer also says approve.
 10. With a blocking finding, run the fixer agent and go to step 6 again. The
     budget is `maxReviewRounds`.
 
@@ -106,18 +112,21 @@ Every run has an id, `<timestamp>`, and writes two files under
   one report per issue with the outcome, the reason, the pull request number
   and the budgets used.
 
+At the start of a run, the harness deletes the files under `.next-issue/runs/`
+that are older than `keepRunDays`. Set the field to `0` to keep them all.
+
 A short text summary of the same data goes to standard output. Use `--json` to
 get the full summary object there instead, so the harness fits in a pipe. All
 progress goes to standard error.
 
-Recorded for each step: `claim`, `comments`, `worktree`, `implement`, `push`,
-`pull-request`, `checks`, `review` and `fix`, each with a `.start`, `.end` or
-`.error` event and a duration in `ms`. Every `git` and `gh` command is recorded
-with its exit code and duration. A `tool` event holds the tool name, and for a
-`Bash` tool the command too. Each agent call adds a `usage` event with the
-tokens, the cost estimate in dollars, the turn count, the tool-call count, the
-model and the session id, so you can open the session again and read the full
-transcript.
+Recorded for each step: `claim`, `comments`, `worktree`, `setup`, `implement`,
+`push`, `pull-request`, `checks`, `review` and `fix`, each with a `.start`,
+`.end` or `.error` event and a duration in `ms`. Every `git` and `gh` command
+is recorded with its exit code and duration. A `tool` event holds the tool
+name, and for a `Bash` tool the command too. Each agent call adds a `usage`
+event with the tokens, the cost estimate in dollars, the turn count, the
+tool-call count, the model and the session id, so you can open the session
+again and read the full transcript.
 
 ```bash
 jq -r 'select(.kind=="usage") | [.issue,.role,.turns,.total] | @tsv' \
@@ -134,7 +143,7 @@ Three levels of console output:
 
 ## Requirements
 
-- Node 24 or later, because the command runs the TypeScript source directly
+- Node 24 or later
 - `gh`, authenticated with write access to the repository
 - Anthropic credentials for the Claude Agent SDK: `ANTHROPIC_API_KEY`, or a
   Claude subscription login
@@ -170,6 +179,7 @@ does not know all stop the run, so a typo cannot pass without a word.
   "commandTimeoutMinutes": 10,
   "logMaxChars": 20000,
   "diffMaxChars": 60000,
+  "keepRunDays": 7,
   "draftPullRequest": true,
   "models": {},
   "labels": {
@@ -195,8 +205,9 @@ does not know all stop the run, so a typo cannot pass without a word.
 | `agentTimeoutMinutes` | `30` | The limit for one agent call |
 | `setupTimeoutMinutes` | `15` | The limit for the setup command |
 | `commandTimeoutMinutes` | `10` | The limit for one `git` or `gh` command |
-| `logMaxChars` | `20000` | The maximum length of the failed job logs |
+| `logMaxChars` | `20000` | The maximum length of the failed job logs, shared between the failed jobs |
 | `diffMaxChars` | `60000` | The maximum length of the diff that the reviewer reads |
+| `keepRunDays` | `7` | The number of days to keep the run files; `0` keeps them all |
 | `draftPullRequest` | `true` | Open the pull request as a draft, until the review approves |
 | `setupCommand` | none | A shell command to run in a new worktree, before the implementer |
 | `models` | `{}` | The model per agent role |
@@ -221,7 +232,10 @@ A hand-over leaves the state file with the used budgets in it, so the next run
 would hand the issue over again at once. To give the issue another try, take the
 `status:needs-human` label off and run with `--reset`. The flag puts the budgets
 and the findings back to zero and keeps the branch, the pull request and the
-step that the last run reached, so the work carries on where it stopped.
+step that the last run reached, so the work carries on where it stopped. A
+commit that you pushed to the pull request in the meantime is fetched first.
+The flag touches only an issue that the run handles, so the state of an issue
+that a label still holds back stays as it was.
 
 ## Commands and options
 
@@ -237,6 +251,9 @@ step that the last run reached, so the work carries on where it stopped.
 | `--quiet` | Show only the milestones and the summary |
 | `--help` | Show the option list |
 
+The exit code is 1 when an issue needs a person or failed, and 0 when it does
+not, so a cron job or a CI step can read the result of the run.
+
 ## Development
 
 ```bash

package/dist/cli.mjs

@@ -6,9 +6,10 @@ 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 { message, Recorder } from "./observe.mjs";
+import { exitCode, runIssues } from "./loop.mjs";
+import { message, pruneRuns, Recorder } from "./observe.mjs";
 import { PORTS, processIssue } from "./pipeline.mjs";
-import { resetState, STATE_DIR, takeStop } from "./state.mjs";
+import { STATE_DIR, takeStop } from "./state.mjs";
 import { formatSummary } from "./summary.mjs";
 function write(stream, text) {
     return new Promise((resolve, reject) => {
@@ -29,6 +30,10 @@ async function main() {
     setDefaultTimeout(config.commandTimeoutMinutes * 60_000);
     const repo = await detectRepo(root, config.remote);
     const recorder = await Recorder.create(repo.root, args.level);
+    const pruned = await pruneRuns(repo.root, config.keepRunDays);
+    if (pruned > 0) {
+        recorder.event("runs.pruned", { files: pruned, keepDays: config.keepRunDays }, "verbose");
+    }
     setCommandObserver((record) => {
         recorder.event(record.code === 0 ? "command" : "command.fail", {
             cmd: `${record.command} ${record.args.join(" ")}`,
@@ -55,42 +60,30 @@ async function init(root, force) {
 }
 async function handle(args, config, repo, recorder) {
     const [base, login] = await Promise.all([defaultBranch(repo), currentLogin(repo)]);
-    const context = { repo, config, base, login, recorder, ports: PORTS };
+    const context = { repo, config, base, login, reset: args.reset, recorder, ports: PORTS };
     recorder.event("run.start", { repo: `${repo.owner}/${repo.name}`, base, login, log: recorder.logFile }, "quiet");
     const issues = await openIssues(repo, config.issueLimit);
     recorder.event("issues", { open: issues.length }, "quiet");
-    await takeStop(repo);
-    const reports = [];
-    for (const issue of issues) {
-        const handled = reports.filter((report) => report.outcome !== "skipped").length;
-        if (args.max !== undefined && handled >= args.max) {
-            break;
-        }
-        if (args.reset) {
-            await resetState(repo, issue.number);
-        }
-        const report = await processIssue(context, issue);
-        reports.push(report);
-        if (await takeStop(repo)) {
-            recorder.event("run.stop", { issue: issue.number }, "quiet");
-            break;
-        }
-        if (args.once && report.outcome !== "skipped") {
-            break;
-        }
+    const { reports, stoppedAt } = await runIssues(args, {
+        issues,
+        process: (issue) => processIssue(context, issue),
+        stop: () => takeStop(repo),
+    });
+    if (stoppedAt !== undefined) {
+        recorder.event("run.stop", { issue: stoppedAt }, "quiet");
     }
-    const summary = { ...recorder.summary(), issues: reports };
     recorder.event("run.end", {
         done: count(reports, "done"),
         needsHuman: count(reports, "needs-human"),
         failed: count(reports, "error"),
         skipped: count(reports, "skipped"),
-        tokens: summary.total.total,
+        tokens: recorder.summary().total.total,
     }, "quiet");
+    const summary = { ...recorder.summary(), issues: reports };
     const summaryFile = join(repo.root, STATE_DIR, "runs", `${recorder.runId}.summary.json`);
     await writeFile(summaryFile, `${JSON.stringify(summary, null, 2)}\n`);
     await write(process.stdout, args.json ? `${JSON.stringify(summary, null, 2)}\n` : formatSummary(summary));
-    return count(reports, "needs-human") + count(reports, "error") > 0 ? 1 : 0;
+    return exitCode(reports);
 }
 function count(reports, outcome) {
     return reports.filter((report) => report.outcome === outcome).length;

package/dist/config.mjs

@@ -14,6 +14,7 @@ const DEFAULTS = {
     commandTimeoutMinutes: 10,
     logMaxChars: 20000,
     diffMaxChars: 60000,
+    keepRunDays: 7,
     draftPullRequest: true,
     models: {},
     labels: {
@@ -38,6 +39,7 @@ const WHOLE_FIELDS = [
     ["commandTimeoutMinutes", 1],
     ["logMaxChars", 1],
     ["diffMaxChars", 1],
+    ["keepRunDays", 0],
 ];
 const MODEL_ROLES = ["implementer", "reviewer", "fixer"];
 const LABEL_NAMES = ["ready", "inProgress", "inReview", "done", "needsHuman", "skip"];

package/dist/exec.mjs

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 let observer;
 let defaultTimeoutMs = 10 * 60_000;
+const STDERR_TAIL = 200_000;
 export function setCommandObserver(next) {
     observer = next;
 }
@@ -15,7 +16,7 @@ export function run(command, args, options = {}) {
             cwd: options.cwd,
             stdio: [
                 options.input === undefined ? "ignore" : "pipe",
-                options.inherit === true ? "inherit" : "pipe",
+                options.show === true ? 2 : "pipe",
                 "pipe",
             ],
         });
@@ -30,20 +31,19 @@ export function run(command, args, options = {}) {
                 stdout = stdout.slice(-options.tailChars);
             }
         });
+        const stderrLimit = options.tailChars ?? STDERR_TAIL;
         child.stderr?.on("data", (chunk) => {
             stderr += chunk;
+            if (stderr.length > stderrLimit) {
+                stderr = stderr.slice(-stderrLimit);
+            }
         });
         const timer = setTimeout(() => {
             timedOut = true;
             child.kill("SIGKILL");
         }, limit);
         let done = false;
-        child.on("error", (error) => {
-            clearTimeout(timer);
-            done = true;
-            reject(error);
-        });
-        child.on("close", (code) => {
+        const settle = (code) => {
             clearTimeout(timer);
             if (done) {
                 return;
@@ -60,7 +60,21 @@ export function run(command, args, options = {}) {
                 timedOut,
             });
             resolve(result);
+        };
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            done = true;
+            reject(error);
+        });
+        child.on("exit", (code) => {
+            if (!timedOut) {
+                return;
+            }
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            settle(code);
         });
+        child.on("close", settle);
         if (options.input !== undefined) {
             child.stdin?.on("error", () => undefined);
             child.stdin?.end(options.input);

package/dist/git.mjs

@@ -30,21 +30,26 @@ export function worktreePath(repo, issue) {
 export async function addWorktree(repo, issue, base, remote) {
     const path = worktreePath(repo, issue);
     const branch = branchName(issue);
-    await must("git", ["fetch", remote, base], { cwd: repo.root });
+    const upstream = `${remote}/${branch}`;
+    await must("git", ["fetch", remote], { cwd: repo.root });
     await updateBase(repo, base, remote);
     await must("git", ["worktree", "prune"], { cwd: repo.root });
-    if (await hasWorktree(repo, path)) {
-        return path;
+    const pushed = await hasBranch(repo, upstream, "--remotes");
+    if (!(await hasWorktree(repo, path))) {
+        const args = (await hasBranch(repo, branch))
+            ? ["worktree", "add", path, branch]
+            : ["worktree", "add", "-b", branch, path, pushed ? upstream : `${remote}/${base}`];
+        await must("git", args, { cwd: repo.root });
+    }
+    if (pushed) {
+        await run("git", ["merge", "--ff-only", upstream], { cwd: path });
     }
-    const existing = await run("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], {
-        cwd: repo.root,
-    });
-    const args = existing.code === 0
-        ? ["worktree", "add", path, branch]
-        : ["worktree", "add", "-b", branch, path, `${remote}/${base}`];
-    await must("git", args, { cwd: repo.root });
     return path;
 }
+async function hasBranch(repo, name, ...flags) {
+    const list = await must("git", ["branch", "--list", ...flags, name], { cwd: repo.root });
+    return list.length > 0;
+}
 export async function updateBase(repo, base, remote) {
     const head = await run("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd: repo.root });
     const args = head.code === 0 && head.stdout.trim() === base
@@ -98,3 +103,10 @@ export async function commitAll(cwd, message) {
 export async function push(cwd, remote, branch) {
     await must("git", ["push", "-u", remote, branch], { cwd });
 }
+export async function revision(cwd) {
+    return must("git", ["rev-parse", "HEAD"], { cwd });
+}
+export async function deleteBranch(repo, branch) {
+    const result = await run("git", ["branch", "-D", branch], { cwd: repo.root });
+    return result.code === 0;
+}

package/dist/github.mjs

@@ -1,5 +1,7 @@
 import { must, run } from "./exec.mjs";
 const CHECK_PENDING_CODE = 8;
+const READ_TRIES = 3;
+const KNOWN_LABELS = new Map();
 const NO_CHECKS = /no checks reported/i;
 function slug(repo) {
     return `${repo.owner}/${repo.name}`;
@@ -22,6 +24,8 @@ export async function openIssues(repo, limit) {
         "list",
         "--state",
         "open",
+        "--search",
+        "sort:created-asc",
         "--limit",
         String(limit),
         "--json",
@@ -65,7 +69,21 @@ export async function setLabel(repo, kind, number, add, remove) {
     await gh(repo, [kind, "edit", String(number), ...labelArgs(add, remove, current)]);
 }
 export async function ensureLabel(repo, label) {
-    await run("gh", ["label", "create", label, "--repo", slug(repo)], { cwd: repo.root });
+    let known = KNOWN_LABELS.get(slug(repo));
+    if (known === undefined) {
+        const raw = await gh(repo, ["label", "list", "--limit", "1000", "--json", "name"]);
+        known = new Set(JSON.parse(raw).map((item) => item.name));
+        KNOWN_LABELS.set(slug(repo), known);
+    }
+    if (known.has(label)) {
+        return;
+    }
+    const result = await run("gh", ["label", "create", label, "--repo", slug(repo)], {
+        cwd: repo.root,
+    });
+    if (result.code === 0) {
+        known.add(label);
+    }
 }
 export async function findPr(repo, branch) {
     const result = await run("gh", ["pr", "list", "--head", branch, "--state", "open", "--json", "number", "--repo", slug(repo)], { cwd: repo.root });
@@ -76,7 +94,7 @@ export async function findPr(repo, branch) {
     return parsed[0]?.number;
 }
 export async function createPr(repo, branch, base, title, body, draft) {
-    await gh(repo, [
+    const created = await gh(repo, [
         "pr",
         "create",
         "--head",
@@ -89,12 +107,19 @@ export async function createPr(repo, branch, base, title, body, draft) {
         body,
         ...(draft ? ["--draft"] : []),
     ]);
-    const number = await findPr(repo, branch);
+    const number = prNumber(created) ?? (await findPr(repo, branch));
     if (number === undefined) {
         throw new Error(`The pull request for ${branch} was not found after creation.`);
     }
     return number;
 }
+export function prNumber(output) {
+    const match = /\/pull\/(\d+)\b/.exec(output);
+    return match === null ? undefined : Number(match[1]);
+}
+async function prHead(repo, branch) {
+    return gh(repo, ["pr", "view", branch, "--json", "headRefOid", "--jq", ".headRefOid"]);
+}
 async function readChecks(repo, branch) {
     const result = await run("gh", ["pr", "checks", branch, "--json", "name,bucket,link,description", "--repo", slug(repo)], { cwd: repo.root });
     const output = result.stdout.trim();
@@ -107,8 +132,8 @@ async function readChecks(repo, branch) {
     const checks = JSON.parse(output);
     return checks.length === 0 ? "none" : checks;
 }
-async function watchOnce(repo, branch, intervalSeconds, timeoutMs, inherit) {
-    const watch = await run("gh", ["pr", "checks", branch, "--watch", "--fail-fast", "--interval", String(intervalSeconds), "--repo", slug(repo)], { cwd: repo.root, inherit, timeoutMs });
+async function watchOnce(repo, branch, intervalSeconds, timeoutMs, show) {
+    const watch = await run("gh", ["pr", "checks", branch, "--watch", "--fail-fast", "--interval", String(intervalSeconds), "--repo", slug(repo)], { cwd: repo.root, show, timeoutMs });
     if (watch.timedOut) {
         return "timeout";
     }
@@ -125,31 +150,53 @@ const REAL_CLOCK = {
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
 };
 export async function pollChecks(probe, options, clock = REAL_CLOCK) {
-    const started = clock.now();
-    const deadline = started + options.timeoutMs;
+    const deadline = clock.now() + options.timeoutMs;
     const rest = () => Math.max(0, deadline - clock.now());
+    let shown;
+    let failures = 0;
     for (;;) {
         if (rest() === 0) {
             return "timeout";
         }
-        if ((await probe.list()) === "none") {
-            if (clock.now() - started >= options.graceMs) {
-                return "none";
+        const state = await read(probe, options.head, rest(), () => (shown ??= clock.now()));
+        if (state instanceof Error) {
+            failures += 1;
+            if (failures >= READ_TRIES) {
+                throw state;
             }
         }
         else {
-            const state = await probe.watch(rest());
-            if (state !== "pending") {
+            failures = 0;
+            if (state === "none" && clock.now() - (shown ?? 0) >= options.graceMs) {
+                return "none";
+            }
+            if (state !== "none" && state !== "behind" && state !== "pending") {
                 return state;
             }
         }
         await clock.sleep(Math.min(options.intervalSeconds * 1000, rest()));
     }
 }
+async function read(probe, head, timeoutMs, shown) {
+    try {
+        if (head !== undefined && (await probe.head()) !== head) {
+            return "behind";
+        }
+        shown();
+        if ((await probe.list()) === "none") {
+            return "none";
+        }
+        return await probe.watch(timeoutMs);
+    }
+    catch (error) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+}
 export function waitForChecks(repo, branch, options) {
     return pollChecks({
+        head: () => prHead(repo, branch),
         list: async () => ((await readChecks(repo, branch)) === "none" ? "none" : "some"),
-        watch: (timeoutMs) => watchOnce(repo, branch, options.intervalSeconds, timeoutMs, options.inherit),
+        watch: (timeoutMs) => watchOnce(repo, branch, options.intervalSeconds, timeoutMs, options.show),
     }, options);
 }
 export async function failedCheckLogs(repo, branch, maxChars) {
@@ -158,6 +205,7 @@ export async function failedCheckLogs(repo, branch, maxChars) {
         return "The checks failed, but gh reports no check for the branch.";
     }
     const failed = checks.filter((check) => check.bucket === "fail");
+    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}`);
@@ -167,11 +215,11 @@ export async function failedCheckLogs(repo, branch, maxChars) {
         }
         const logs = await run("gh", ["run", "view", runId, "--log-failed", "--repo", slug(repo)], {
             cwd: repo.root,
-            tailChars: maxChars,
+            tailChars: share,
         });
-        parts.push(logs.stdout.slice(-maxChars));
+        parts.push(logs.stdout.slice(-share));
     }
-    return parts.join("\n\n").slice(-maxChars);
+    return parts.join("\n\n");
 }
 export async function markPrReady(repo, pr) {
     const result = await run("gh", ["pr", "ready", String(pr), "--repo", slug(repo)], {

package/dist/loop.mjs

@@ -0,0 +1,24 @@
+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) {
+            break;
+        }
+        const report = await loop.process(issue);
+        reports.push(report);
+        if (await loop.stop()) {
+            return { reports, stoppedAt: issue.number };
+        }
+        if (args.once && report.outcome !== "skipped") {
+            break;
+        }
+    }
+    return { reports };
+}
+export function exitCode(reports) {
+    return reports.some((report) => report.outcome === "needs-human" || report.outcome === "error") ? 1 : 0;
+}
+function handled(reports) {
+    return reports.filter((report) => report.outcome !== "skipped").length;
+}

package/dist/observe.mjs

@@ -1,5 +1,5 @@
 import { createWriteStream } from "node:fs";
-import { mkdir } from "node:fs/promises";
+import { mkdir, readdir, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { STATE_DIR } from "./state.mjs";
 const VISIBILITY = { quiet: 0, normal: 1, verbose: 2 };
@@ -117,6 +117,35 @@ export class Recorder {
         await this.sink.close();
     }
 }
+export async function pruneRuns(root, keepDays) {
+    if (keepDays <= 0) {
+        return 0;
+    }
+    const dir = join(root, STATE_DIR, "runs");
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return 0;
+    }
+    const cutoff = Date.now() - keepDays * 24 * 60 * 60_000;
+    let dropped = 0;
+    for (const name of names) {
+        const path = join(dir, name);
+        try {
+            const info = await stat(path);
+            if (info.isFile() && info.mtimeMs < cutoff) {
+                await rm(path, { force: true });
+                dropped += 1;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return dropped;
+}
 export function message(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/pipeline.mjs

@@ -1,11 +1,11 @@
 import { CODING, READ_ONLY, runAgent } from "./agents.mjs";
 import { managedLabels } from "./config.mjs";
 import { run } from "./exec.mjs";
-import { addWorktree, branchName, commitAll, diff, hasWorktree, push, removeWorktree, worktreePath, } from "./git.mjs";
+import { addWorktree, branchName, commitAll, deleteBranch, diff, hasWorktree, push, removeWorktree, revision, worktreePath, } from "./git.mjs";
 import { assignIssue, 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 { readState, writeState } from "./state.mjs";
+import { dropState, readState, resetState, writeState, } from "./state.mjs";
 import { blockingFindings, fingerprint, formatFindings, formatVerdict, isApproved, readVerdict, VERDICT_SCHEMA, } from "./verdict.mjs";
 export const PORTS = {
     addWorktree,
@@ -13,6 +13,7 @@ export const PORTS = {
     commentOnPr,
     commitAll,
     createPr,
+    deleteBranch,
     diff,
     failedCheckLogs,
     findPr,
@@ -21,6 +22,7 @@ export const PORTS = {
     markPrReady,
     push,
     removeWorktree,
+    revision,
     runAgent,
     runSetup: async (command, cwd, timeoutMs) => run("bash", ["-lc", command], { cwd, timeoutMs }),
     setLabel,
@@ -53,7 +55,7 @@ export async function processIssue(context, issue) {
         return { issue: issue.number, outcome: "skipped", ciFixes: 0, reviewRounds: 0, ms: 0 };
     }
     log.event("issue.start", { title: issue.title, createdAt: issue.createdAt }, "quiet");
-    const state = saved ?? {
+    const fresh = {
         issue: issue.number,
         phase: "claimed",
         branch: branchName(issue.number),
@@ -61,6 +63,7 @@ export async function processIssue(context, issue) {
         reviewRounds: 0,
         reviewLog: [],
     };
+    const state = saved === undefined ? fresh : context.reset ? resetState(saved) : saved;
     try {
         const report = await work(context, issue, log, state);
         log.event("issue.end", { outcome: report.outcome, reason: report.reason, ms: report.ms }, "quiet");
@@ -101,6 +104,12 @@ async function work(context, issue, log, state) {
     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,
@@ -123,6 +132,7 @@ async function work(context, issue, log, state) {
         }
     }
     if (state.phase === "claimed") {
+        const before = await ports.revision(worktree);
         const result = await log.step("implement", {}, () => ports.runAgent(log, {
             name: "implementer",
             cwd: worktree,
@@ -132,11 +142,10 @@ async function work(context, issue, log, state) {
             timeoutMs: config.agentTimeoutMinutes * 60_000,
         }));
         const subject = parseCommitSubject(result.text, `fix: resolve issue #${issue.number}`);
-        if (!(await ports.commitAll(worktree, `${subject}\n\nRefs #${issue.number}`))) {
+        if (!(await commitWork(job, before, subject))) {
             await escalate("The implementer produced no change.");
             return finish("needs-human", "no implementation commit");
         }
-        log.event("commit", { subject });
         state.phase = "implemented";
         await writeState(repo, state);
     }
@@ -149,14 +158,18 @@ async function work(context, issue, log, state) {
     state.phase = "review";
     await writeState(repo, state);
     log.event("pull-request.ready", { pr: state.pr }, "quiet");
+    let noChecks = false;
     const gate = async () => {
-        const checks = await log.step("checks", { pr: state.pr }, () => ports.waitForChecks(repo, branch, {
+        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: config.checkGraceSeconds * 1000,
+            graceMs: noChecks ? 0 : config.checkGraceSeconds * 1000,
             timeoutMs: config.checkTimeoutMinutes * 60_000,
-            inherit: log.level === "verbose",
+            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") };
@@ -210,7 +223,7 @@ async function work(context, issue, log, state) {
         const review = await log.step("review", fields, () => ports.runAgent(log, {
             name: "reviewer",
             cwd: worktree,
-            prompt: reviewPrompt(issue, comments, patch, state.reviewRounds, history(state.reviewLog)),
+            prompt: reviewPrompt(issue, comments, patch, history(state.reviewLog)),
             profile: READ_ONLY,
             model: config.models.reviewer,
             timeoutMs: config.agentTimeoutMinutes * 60_000,
@@ -242,8 +255,6 @@ async function work(context, issue, log, state) {
                 log.event("pull-request.undraft.fail", { pr: state.pr }, "quiet");
             }
             await setStatus(context, issue.number, state.pr, config.labels.done);
-            state.phase = "done";
-            await writeState(repo, state);
             return finish("done");
         }
         const mark = fingerprint(blocking);
@@ -264,6 +275,7 @@ async function work(context, issue, log, state) {
 async function fixRound(job, reason, detail, earlier, kind) {
     const { context, issue, log, worktree, branch } = job;
     const { ports } = context;
+    const before = await ports.revision(worktree);
     const result = await log.step("fix", { reason }, () => ports.runAgent(log, {
         name: "fixer",
         cwd: worktree,
@@ -278,14 +290,20 @@ async function fixRound(job, reason, detail, earlier, kind) {
         return { committed: false, unrelated };
     }
     const subject = parseCommitSubject(result.text, `fix: address feedback on issue #${issue.number}`);
-    if (!(await ports.commitAll(worktree, `${subject}\n\nRefs #${issue.number}`))) {
+    if (!(await commitWork(job, before, subject))) {
         log.event("commit.empty", { reason }, "quiet");
         return { committed: false };
     }
-    log.event("commit", { subject });
     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 });
+    }
+    return (await context.ports.revision(worktree)) !== before;
+}
 async function cleanUp(context, log, issue) {
     const path = worktreePath(context.repo, issue);
     try {

package/dist/prompts.mjs

@@ -26,8 +26,8 @@ export function capDiff(diff, maxChars) {
         ? diff
         : `${diff.slice(0, maxChars)}\n... The diff is cut here, after ${maxChars} characters.`;
 }
-export function reviewPrompt(issue, comments, diff, round, earlier) {
-    const scope = round === 1
+export function reviewPrompt(issue, comments, diff, earlier) {
+    const scope = earlier.length === 0
         ? "Check correctness, scope, repository conventions and test cover."
         : [
             "This is a later round. Judge two things only:",

package/dist/state.mjs

@@ -15,15 +15,10 @@ export async function readState(repo, issue) {
         return undefined;
     }
 }
-export async function resetState(repo, issue) {
-    const state = await readState(repo, issue);
-    if (state === undefined) {
-        return false;
-    }
+export function resetState(state) {
     const next = { ...state, ciFixes: 0, reviewRounds: 0, reviewLog: [] };
     delete next.handedOver;
-    await writeState(repo, next);
-    return true;
+    return next;
 }
 export async function writeState(repo, state) {
     await mkdir(dir(repo), { recursive: true });
@@ -38,3 +33,6 @@ export async function takeStop(repo) {
         return false;
     }
 }
+export async function dropState(repo, issue) {
+    await rm(file(repo, issue), { force: true });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-issue",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Autonomous issue harness driven by the Claude Agent SDK",
   "keywords": [
     "github",
@@ -37,10 +37,10 @@
     "prepublishOnly": "npm run typecheck && npm test"
   },
   "devDependencies": {
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.241"
+    "@anthropic-ai/claude-agent-sdk": "^0.3.261"
   }
 }