next-issue 0.12.4 → 0.13.0

package/README.md

@@ -18,13 +18,12 @@ next-issue
 
 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, 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`.
+1. Claim the issue only when it holds the `status:todo` label and holds no
+   `status:in-progress` or `status:in-review` label. A `status:done`,
+   `status:needs-human` or `status:blocked` label always stops the claim, a
+   resume too. An issue with saved state under `.next-issue/` resumes instead,
+   whatever its other labels.
+2. Add `status:in-progress` to the issue.
 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
@@ -96,10 +95,11 @@ 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.
 
-Every status label that the harness puts on the issue goes on the pull request
-too, from the first review round. Thus a draft pull request shows work that the
-harness has not finished, and a `status:needs-human` pull request shows work
-that waits for a person.
+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`
+label of a fresh issue comes before the pull request, and stays on the issue
+alone. Thus a draft pull request shows work that the harness has not finished,
+and a `status:needs-human` pull request shows work that waits for a person.
 
 The harness runs all git and `gh` commands itself. The commit holds all the
 changes in the worktree, so a setup command that writes a file outside
@@ -188,8 +188,8 @@ does not know all stop the run, so a typo cannot pass without a word.
 {
   "remote": "origin",
   "issueLimit": 100,
-  "maxCiFixes": 3,
-  "maxReviewRounds": 3,
+  "maxCiFixes": 5,
+  "maxReviewRounds": 5,
   "checkIntervalSeconds": 15,
   "checkGraceSeconds": 60,
   "checkTimeoutMinutes": 60,
@@ -220,8 +220,8 @@ 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` | `3` | The budget for check fixes per issue |
-| `maxReviewRounds` | `3` | The budget for review rounds per issue |
+| `maxCiFixes` | `5` | The budget for check fixes 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 |
 | `checkTimeoutMinutes` | `60` | The limit for one check wait |
@@ -237,10 +237,10 @@ does not know all stop the run, so a typo cannot pass without a word.
 | `labels` | see above | The names of the labels that the harness reads and sets |
 
 An empty `labels.ready` turns the ready requirement off. The harness then
-claims every open issue that no other label and no assignee holds back.
+claims every open issue that no other label holds back.
 
-The log gives the reason for a skipped issue as `stop-label`, `not-ready`,
-`in-flight` or `assigned`.
+The log gives the reason for a skipped issue as `stop-label`, `not-ready` or
+`in-flight`.
 
 A role set to `null`, or with no entry in `models`, uses the default model of
 the SDK.

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { parseArgs, USAGE } from "./args.mjs";
 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 { defaultBranch, openIssues } from "./github.mjs";
 import { exitCode, runIssues } from "./loop.mjs";
 import { message, pruneRuns, Recorder } from "./observe.mjs";
 import { PORTS, processIssue } from "./pipeline.mjs";
@@ -60,13 +60,12 @@ async function init(root, force) {
     return 0;
 }
 async function handle(args, config, repo, recorder) {
-    const [base, login] = await Promise.all([defaultBranch(repo), currentLogin(repo)]);
-    const context = { repo, config, base, login, reset: args.reset, recorder, ports: PORTS };
+    const base = await defaultBranch(repo);
+    const context = { repo, config, base, reset: args.reset, recorder, ports: PORTS };
     recorder.event("run.start", {
         version: await packageVersion(),
         repo: `${repo.owner}/${repo.name}`,
         base,
-        login,
         log: recorder.logFile,
     }, "quiet");
     const issues = await openIssues(repo, config.issueLimit);

package/dist/config.mjs

@@ -4,8 +4,8 @@ import { message } from "./observe.mjs";
 const DEFAULTS = {
     remote: "origin",
     issueLimit: 100,
-    maxCiFixes: 3,
-    maxReviewRounds: 3,
+    maxCiFixes: 5,
+    maxReviewRounds: 5,
     checkIntervalSeconds: 15,
     checkGraceSeconds: 60,
     checkTimeoutMinutes: 60,
@@ -83,7 +83,7 @@ export async function loadConfig(root) {
     }
     return parseConfig(parsed);
 }
-export function parseConfig(value) {
+function parseConfig(value) {
     const file = record(value, "the file");
     for (const key of Object.keys(file)) {
         if (!FIELDS.includes(key)) {

package/dist/github.mjs

@@ -15,9 +15,6 @@ export async function defaultBranch(repo) {
     });
     return JSON.parse(raw).defaultBranchRef.name;
 }
-export async function currentLogin(repo) {
-    return must("gh", ["api", "user", "--jq", ".login"], { cwd: repo.root });
-}
 export async function openIssues(repo, limit) {
     const raw = await gh(repo, [
         "issue",
@@ -29,7 +26,7 @@ export async function openIssues(repo, limit) {
         "--limit",
         String(limit),
         "--json",
-        "number,title,body,createdAt,labels,assignees",
+        "number,title,body,createdAt,labels",
     ]);
     const parsed = JSON.parse(raw);
     return parsed
@@ -39,7 +36,6 @@ export async function openIssues(repo, limit) {
         body: item.body ?? "",
         createdAt: item.createdAt,
         labels: item.labels.map((label) => label.name),
-        assignees: item.assignees.map((assignee) => assignee.login),
     }))
         .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
@@ -48,10 +44,7 @@ export async function issueComments(repo, issue) {
     const parsed = JSON.parse(raw);
     return parsed.comments.map((comment) => `@${comment.author.login}: ${comment.body}`);
 }
-export async function assignIssue(repo, issue, login) {
-    await gh(repo, ["issue", "edit", String(issue), "--add-assignee", login]);
-}
-export async function labelsOf(repo, kind, number) {
+async function labelsOf(repo, kind, number) {
     const raw = await gh(repo, [kind, "view", String(number), "--json", "labels"]);
     const parsed = JSON.parse(raw);
     return parsed.labels.map((label) => label.name);
@@ -68,7 +61,7 @@ export async function setLabel(repo, kind, number, add, remove) {
     const current = await labelsOf(repo, kind, number);
     await gh(repo, [kind, "edit", String(number), ...labelArgs(add, remove, current)]);
 }
-export async function ensureLabel(repo, label) {
+async function ensureLabel(repo, label) {
     let known = KNOWN_LABELS.get(slug(repo));
     if (known === undefined) {
         const raw = await gh(repo, ["label", "list", "--limit", "1000", "--json", "name"]);
@@ -217,7 +210,14 @@ export async function failedCheckLogs(repo, branch, maxChars) {
             cwd: repo.root,
             tailChars: share,
         });
-        parts.push(logs.stdout.slice(-share));
+        if (logs.code === 0) {
+            parts.push(logs.stdout);
+            continue;
+        }
+        const reason = [`The log read failed with code ${logs.code}.`, logs.stderr.trim()]
+            .filter((line) => line !== "")
+            .join(" ");
+        parts.push([logs.stdout.trim(), reason].filter((line) => line !== "").join("\n"));
     }
     return parts.join("\n\n");
 }

package/dist/pipeline.mjs

@@ -2,7 +2,7 @@ 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, push, removeWorktree, revision, worktreePath, } from "./git.mjs";
-import { assignIssue, commentOnPr, createPr, failedCheckLogs, findPr, issueComments, markPrReady, setLabel, waitForChecks, } from "./github.mjs";
+import { 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 { detectSetupCommand } from "./setup.mjs";
@@ -10,7 +10,6 @@ import { dropState, readState, resetState, writeState, } from "./state.mjs";
 import { blockingFindings, fingerprint, formatFindings, formatVerdict, openFindings, readVerdict, VERDICT_SCHEMA, } from "./verdict.mjs";
 export const PORTS = {
     addWorktree,
-    assignIssue,
     commentOnPr,
     commitAll,
     createPr,
@@ -31,14 +30,14 @@ export const PORTS = {
     setLabel,
     waitForChecks,
 };
-export function skipReason(issue, config, login, resuming) {
+export function skipReason(issue, config, resuming) {
     const labels = new Set(issue.labels);
     const names = config.labels;
     if (labels.has(names.done) || labels.has(names.needsHuman) || labels.has(names.skip)) {
         return "stop-label";
     }
     if (resuming) {
-        return issue.assignees.every((name) => name === login) ? undefined : "assigned";
+        return undefined;
     }
     if (names.ready.length > 0 && !labels.has(names.ready)) {
         return "not-ready";
@@ -46,13 +45,13 @@ export function skipReason(issue, config, login, resuming) {
     if (labels.has(names.inProgress) || labels.has(names.inReview)) {
         return "in-flight";
     }
-    return issue.assignees.length === 0 ? undefined : "assigned";
+    return undefined;
 }
 export async function processIssue(context, issue) {
     const started = Date.now();
     const log = context.recorder.scope({ issue: issue.number });
     const saved = await readState(context.repo, issue.number);
-    const skip = skipReason(issue, context.config, context.login, saved !== undefined);
+    const skip = skipReason(issue, context.config, saved !== undefined);
     if (skip !== undefined) {
         log.event("issue.skip", { title: issue.title, reason: skip });
         return { issue: issue.number, outcome: "skipped", ciFixes: 0, reviewRounds: 0, ms: 0 };
@@ -97,7 +96,6 @@ async function work(context, issue, log, state) {
     const { repo, config, ports } = context;
     const branch = state.branch;
     await log.step("claim", { label: config.labels.inProgress }, async () => {
-        await ports.assignIssue(repo, issue.number, context.login);
         await setStatus(context, issue.number, state.pr, config.labels.inProgress);
         await writeState(repo, state);
     });
@@ -107,25 +105,16 @@ async function work(context, issue, log, state) {
     if (!added.baseUpdated) {
         log.event("base.behind", { base: context.base }, "quiet");
     }
-    const job = { context, issue, log, state, branch, worktree, comments };
-    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,
-            reason,
-            pr: state.pr,
-            ciFixes: state.ciFixes,
-            reviewRounds: state.reviewRounds,
-            ms: Date.now() - started,
-        };
+    const job = {
+        context,
+        issue,
+        log,
+        state,
+        branch,
+        worktree,
+        comments,
+        started,
+        noChecks: false,
     };
     const setupCommand = config.setupCommand ?? (await ports.detectSetupCommand(worktree));
     if (setupCommand !== undefined) {
@@ -133,10 +122,10 @@ async function work(context, issue, log, state) {
         if (setup.code !== 0) {
             const late = setup.timedOut === true;
             log.event("setup.fail", { code: setup.code, timedOut: late, stderr: setup.stderr.trim().slice(-2000) }, "quiet");
-            await escalate(late
+            await escalate(job, late
                 ? `The setup command did not finish in ${config.setupTimeoutMinutes} minutes.`
                 : "The setup command failed in the worktree.");
-            return finish("needs-human", late ? "setup timeout" : "setup failed");
+            return finish(job, "needs-human", late ? "setup timeout" : "setup failed");
         }
     }
     if (state.phase === "claimed") {
@@ -151,138 +140,173 @@ async function work(context, issue, log, state) {
         }));
         const subject = parseCommitSubject(result.text, `fix: resolve issue #${issue.number}`);
         if (!(await commitWork(job, before, subject))) {
-            await escalate("The implementer produced no change.");
-            return finish("needs-human", "no implementation commit");
+            await escalate(job, "The implementer produced no change.");
+            return finish(job, "needs-human", "no implementation commit");
         }
         state.phase = "implemented";
         await writeState(repo, state);
     }
     await log.step("push", { branch }, () => ports.push(worktree, config.remote, branch));
-    state.pr = await log.step("pull-request", { branch }, async () => {
+    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: state.pr }, "quiet");
-    let noChecks = false;
-    const gate = async () => {
-        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: noChecks ? 0 : config.checkGraceSeconds * 1000,
-            timeoutMs: config.checkTimeoutMinutes * 60_000,
-            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") };
-        }
-        if (checks !== "fail") {
-            return { done: false, fixed: false };
-        }
-        if (state.ciFixes >= config.maxCiFixes) {
-            await escalate(`The limit of ${config.maxCiFixes} check fixes was reached.`);
-            return { done: true, report: await finish("needs-human", "check budget") };
-        }
-        state.ciFixes += 1;
-        await writeState(repo, state);
-        const logs = await ports.failedCheckLogs(repo, branch, config.logMaxChars);
-        log.event("checks.logs", { chars: logs.length });
-        const fix = await fixRound(job, "The continuous integration checks failed.", logs, history(state.reviewLog), "checks");
-        if (!fix.committed) {
-            const note = fix.unrelated;
-            await escalate(note === undefined
-                ? "The fixer added no commit for the failed checks."
-                : `The checks fail for a reason this change did not cause: ${note}`);
-            return {
-                done: true,
-                report: await finish("needs-human", note === undefined ? "no fix commit" : "unrelated failure"),
-            };
-        }
-        return { done: false, fixed: true };
-    };
+    log.event("pull-request.ready", { pr }, "quiet");
     for (;;) {
-        const before = await gate();
-        if (before.done) {
-            return before.report;
+        const gate = await checkGate(job);
+        if (gate.done) {
+            return gate.report;
         }
-        if (before.fixed) {
+        if (gate.fixed) {
             continue;
         }
-        if (state.reviewRounds >= config.maxReviewRounds) {
-            await escalate(`The limit of ${config.maxReviewRounds} review rounds was reached.`);
-            return finish("needs-human", "review budget");
+        const round = await reviewRound(job);
+        if (round.done) {
+            return round.report;
         }
-        state.reviewRounds += 1;
-        await writeState(repo, state);
-        await setStatus(context, issue.number, state.pr, config.labels.inReview);
-        const full = await ports.diff(worktree, context.base, config.remote);
-        const patch = capDiff(full, config.diffMaxChars);
-        const fields = {
-            round: state.reviewRounds,
-            diffChars: full.length,
-            cut: full.length > config.diffMaxChars,
+    }
+}
+async function checkGate(job) {
+    const { context, log, state, branch, worktree } = job;
+    const { repo, config, ports } = context;
+    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: job.noChecks ? 0 : config.checkGraceSeconds * 1000,
+        timeoutMs: config.checkTimeoutMinutes * 60_000,
+        show: log.level === "verbose",
+    }));
+    log.event("checks.state", { state: checks });
+    job.noChecks ||= checks === "none";
+    if (checks === "timeout") {
+        await escalate(job, "The checks did not finish in time.");
+        return { done: true, report: await finish(job, "needs-human", "checks timeout") };
+    }
+    if (checks !== "fail") {
+        return { done: false, fixed: false };
+    }
+    if (state.ciFixes >= config.maxCiFixes) {
+        await escalate(job, `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);
+    const logs = await ports.failedCheckLogs(repo, branch, config.logMaxChars);
+    log.event("checks.logs", { chars: logs.length });
+    const fix = await fixRound(job, "The continuous integration checks failed.", logs, history(state.reviewLog), "checks");
+    if (!fix.committed) {
+        const note = fix.unrelated;
+        await escalate(job, note === undefined
+            ? "The fixer added no commit for the failed checks."
+            : `The checks 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"),
         };
-        const review = await log.step("review", fields, () => ports.runAgent(log, {
-            name: "reviewer",
-            cwd: worktree,
-            prompt: reviewPrompt(issue, comments, patch, history(state.reviewLog)),
-            profile: REVIEWING,
-            model: config.models.reviewer,
-            timeoutMs: config.agentTimeoutMinutes * 60_000,
-            outputSchema: VERDICT_SCHEMA,
-        }));
-        if (await ports.discardChanges(worktree)) {
-            log.event("review.discard", { round: state.reviewRounds }, "quiet");
-        }
-        const verdict = readVerdict(review.structured);
-        if (verdict === undefined) {
-            await escalate("The reviewer gave no verdict.");
-            return finish("needs-human", "no verdict");
+    }
+    return { done: false, fixed: true };
+}
+async function reviewRound(job) {
+    const { context, issue, log, state, worktree, comments } = job;
+    const { repo, config, ports } = context;
+    const pr = state.pr;
+    if (state.reviewRounds >= config.maxReviewRounds) {
+        await escalate(job, `The limit of ${config.maxReviewRounds} review rounds was reached.`);
+        return { done: true, report: await finish(job, "needs-human", "review budget") };
+    }
+    state.reviewRounds += 1;
+    await writeState(repo, state);
+    await setStatus(context, issue.number, pr, config.labels.inReview);
+    const full = await ports.diff(worktree, context.base, config.remote);
+    const patch = capDiff(full, config.diffMaxChars);
+    const fields = {
+        round: state.reviewRounds,
+        diffChars: full.length,
+        cut: full.length > config.diffMaxChars,
+    };
+    const review = await log.step("review", fields, () => ports.runAgent(log, {
+        name: "reviewer",
+        cwd: worktree,
+        prompt: reviewPrompt(issue, comments, patch, history(state.reviewLog)),
+        profile: REVIEWING,
+        model: config.models.reviewer,
+        timeoutMs: config.agentTimeoutMinutes * 60_000,
+        outputSchema: VERDICT_SCHEMA,
+    }));
+    if (await ports.discardChanges(worktree)) {
+        log.event("review.discard", { round: state.reviewRounds }, "quiet");
+    }
+    const verdict = readVerdict(review.structured);
+    if (verdict === undefined) {
+        await escalate(job, "The reviewer gave no verdict.");
+        return { done: true, report: await finish(job, "needs-human", "no verdict") };
+    }
+    const blocking = blockingFindings(verdict);
+    const open = openFindings(verdict, state.reviewRounds >= config.maxReviewRounds);
+    log.event("verdict", {
+        round: state.reviewRounds,
+        blocking: blocking.length,
+        minor: verdict.findings.length - blocking.length,
+        open: open.length,
+        summary: verdict.summary,
+    }, "quiet");
+    await ports.commentOnPr(repo, pr, formatVerdict(verdict, open));
+    if (open.length === 0) {
+        const gate = await checkGate(job);
+        if (gate.done) {
+            return { done: true, report: gate.report };
         }
-        const blocking = blockingFindings(verdict);
-        const open = openFindings(verdict, state.reviewRounds >= config.maxReviewRounds);
-        log.event("verdict", {
-            round: state.reviewRounds,
-            blocking: blocking.length,
-            minor: verdict.findings.length - blocking.length,
-            open: open.length,
-            summary: verdict.summary,
-        }, "quiet");
-        await ports.commentOnPr(repo, state.pr, formatVerdict(verdict, open));
-        if (open.length === 0) {
-            const after = await gate();
-            if (after.done) {
-                return after.report;
-            }
-            if (after.fixed) {
-                continue;
-            }
-            if (config.draftPullRequest && !(await ports.markPrReady(repo, state.pr))) {
-                log.event("pull-request.undraft.fail", { pr: state.pr }, "quiet");
-            }
-            await setStatus(context, issue.number, state.pr, config.labels.done);
-            return finish("done");
+        if (gate.fixed) {
+            return { done: false };
         }
-        const mark = fingerprint(open);
-        if (state.reviewLog.some((round) => round.fingerprint === mark)) {
-            await escalate("The reviewer repeated findings that an earlier round did not fix.");
-            return finish("needs-human", "repeated findings");
+        if (config.draftPullRequest && !(await ports.markPrReady(repo, pr))) {
+            log.event("pull-request.undraft.fail", { pr }, "quiet");
         }
-        const earlier = history(state.reviewLog);
-        state.reviewLog.push({ round: state.reviewRounds, fingerprint: mark, findings: formatFindings(open) });
-        await writeState(repo, state);
-        const fix = await fixRound(job, "The reviewer requested changes.", formatFindings(open), earlier, "review");
-        if (!fix.committed) {
-            await escalate("The fixer added no commit for the review findings.");
-            return finish("needs-human", "no fix commit");
+        await setStatus(context, issue.number, pr, config.labels.done);
+        return { done: true, report: await finish(job, "done") };
+    }
+    const mark = fingerprint(open);
+    if (state.reviewLog.some((round) => round.fingerprint === mark)) {
+        await escalate(job, "The reviewer repeated findings that an earlier round did not fix.");
+        return { done: true, report: await finish(job, "needs-human", "repeated findings") };
+    }
+    const earlier = history(state.reviewLog);
+    state.reviewLog.push({ round: state.reviewRounds, fingerprint: mark, findings: formatFindings(open) });
+    await writeState(repo, state);
+    const fix = await fixRound(job, "The reviewer requested changes.", formatFindings(open), earlier, "review");
+    if (!fix.committed) {
+        await escalate(job, "The fixer added no commit for the review findings.");
+        return { done: true, report: await finish(job, "needs-human", "no fix commit") };
+    }
+    return { done: false };
+}
+function escalate(job, reason) {
+    return handOver(job.context, job.log, job.issue.number, job.state, reason);
+}
+async function finish(job, outcome, reason) {
+    const { context, issue, log, state, branch } = job;
+    const { repo, ports } = context;
+    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,
+        reason,
+        pr: state.pr,
+        ciFixes: state.ciFixes,
+        reviewRounds: state.reviewRounds,
+        ms: Date.now() - job.started,
+    };
 }
 async function fixRound(job, reason, detail, earlier, kind) {
     const { context, issue, log, worktree, branch } = job;

package/package.json

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