next-issue 2.5.10 → 2.7.0

package/README.md

@@ -102,6 +102,18 @@ and exits with code 1. For each issue:
     some findings wrong, the fixer fixes the correct ones, and the next round
     holds the rest.
 
+## Issue format
+
+Every agent prompt holds the body and the comments of the issue. An issue reads best with these sections, in this order:
+
+1. `Problem`
+2. `Context and findings`
+3. `Acceptance criteria`
+4. `Out of scope`
+5. `Open questions`, empty when the issue is created
+
+The list lives in `src/issue-format.mts`. The `create-issue` skill of [`@ravshansbox/pi-next-issue`](../pi-next-issue) writes an issue in this format, and a contract test fails when its template and the list disagree. The harness does not reject an issue without the format.
+
 ## Stops for a loop
 
 The harness hands the issue to a person, with the `status:needs-human` label,

package/dist/fix.mjs

@@ -0,0 +1,73 @@
+import { CODING } from './agents.mjs';
+import { HookError } from './git.mjs';
+import { message } from './observe.mjs';
+import { fixPrompt, hookPrompt, parseCommitSubject, parseUnrelated, } from './prompts.mjs';
+import { writeState } from './state.mjs';
+export async function fixRound(job, reason, detail, earlier, kind, force = false, from) {
+    const { context, issue, log, worktree, branch } = job;
+    const { ports } = context;
+    const before = from ?? (await ports.revision(worktree));
+    const result = await log.step('fix', { reason }, () => ports.runAgent(log, {
+        name: 'fixer',
+        cwd: worktree,
+        prompt: fixPrompt(issue, reason, detail, earlier, kind),
+        profile: CODING,
+        model: context.config.models.fixer,
+        timeoutMs: context.config.agentTimeoutMinutes * 60_000,
+    }));
+    const unrelated = parseUnrelated(result.text);
+    if (unrelated !== undefined) {
+        const disputed = await ports.revision(worktree);
+        const moved = disputed !== before;
+        if (moved) {
+            const aside = `${branch}-dispute-${disputed.slice(0, 7)}`;
+            await ports.setAside(worktree, before, aside);
+            log.event('fix.aside', { branch: aside }, 'quiet');
+        }
+        const stray = moved || (await ports.isDirty(worktree));
+        log.event('fix.unrelated', { reason, note: unrelated, stray }, 'quiet');
+        return { committed: false, unrelated, stray };
+    }
+    const subject = parseCommitSubject(result.text, `fix: address feedback on issue #${issue.number}`);
+    if (!(await commitWork(job, before, subject, 'fixer'))) {
+        log.event('commit.empty', { reason }, 'quiet');
+        return { committed: false };
+    }
+    await ports.push(worktree, context.config.remote, branch, force);
+    return { committed: true };
+}
+export async function commitWork(job, before, subject, role) {
+    const { context, issue, log, state, worktree, comments } = job;
+    const { repo, config, ports } = context;
+    for (;;) {
+        try {
+            if (await ports.commitAll(worktree, `${subject}\n\nRefs #${issue.number}`)) {
+                log.event('commit', { subject });
+            }
+            if ((await ports.revision(worktree)) === before) {
+                return false;
+            }
+            state.title = subject;
+            return true;
+        }
+        catch (error) {
+            const used = state.commitFixes ?? 0;
+            if (!(error instanceof HookError) || used >= config.maxCommitFixes) {
+                throw error;
+            }
+            state.commitFixes = used + 1;
+            await writeState(repo, state);
+            const output = message(error).slice(-config.logMaxChars);
+            log.event('commit.fail', { role, output }, 'quiet');
+            const fix = await log.step('commit-fix', { role }, () => ports.runAgent(log, {
+                name: role,
+                cwd: worktree,
+                prompt: hookPrompt(issue, comments, role, output),
+                profile: CODING,
+                model: config.models[role],
+                timeoutMs: config.agentTimeoutMinutes * 60_000,
+            }));
+            subject = parseCommitSubject(fix.text, subject);
+        }
+    }
+}

package/dist/gate.mjs

@@ -0,0 +1,57 @@
+import { fixRound } from './fix.mjs';
+import { escalate, finish } from './handover.mjs';
+import { history } from './job.mjs';
+import { writeState } from './state.mjs';
+export async function checkGate(job) {
+    const { context, log, state, 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, state.pr, {
+        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 === 'none' &&
+        (await ports.prConflicts(repo, state.pr, {
+            intervalSeconds: config.checkIntervalSeconds,
+            timeoutMs: config.checkTimeoutMinutes * 60_000,
+        }))) {
+        await escalate(job, 'The pull request conflicts with its base, so no checks ran.');
+        return { done: true, report: await finish(job, 'needs-human', 'merge conflict') };
+    }
+    if (checks === 'moved') {
+        await escalate(job, 'Someone pushed to the pull request while the harness waited for the checks.');
+        return { done: true, report: await finish(job, 'needs-human', 'pull request moved') };
+    }
+    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, state.pr, 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'),
+        };
+    }
+    return { done: false, fixed: true };
+}

package/dist/handover.mjs

@@ -0,0 +1,70 @@
+import { setStatus } from './job.mjs';
+import { message } from './observe.mjs';
+import { dropState, writeState } from './state.mjs';
+export function escalate(job, reason) {
+    return handOver(job.context, job.log, job.issue.number, job.state, reason);
+}
+export 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,
+    };
+}
+export async function finish(job, outcome, reason) {
+    const { context, issue, log, state, branch } = job;
+    const { repo, ports } = context;
+    await cleanUp(context, log, branch);
+    if (outcome === 'done') {
+        for (const name of [branch, ...(await ports.disputeBranches(repo, branch))]) {
+            if (!(await ports.deleteBranch(repo, name))) {
+                log.event('branch.kept', { branch: name }, '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,
+        ...(job.mainBroken && outcome !== 'done' ? { halt: true } : {}),
+    };
+}
+export async function cleanUp(context, log, branch) {
+    try {
+        const path = await context.ports.findWorktree(context.repo, branch);
+        if (path === undefined) {
+            return;
+        }
+        if (!(await context.ports.removeWorktree(context.repo, path))) {
+            log.event('worktree.kept', { path }, 'quiet');
+        }
+    }
+    catch (error) {
+        log.event('worktree.error', { error: message(error) }, 'quiet');
+    }
+}
+export async function handOver(context, log, issue, state, reason) {
+    log.event('hand-over', { reason }, 'quiet');
+    await writeState(context.repo, state);
+    await setStatus(context, issue, state.pr, context.config.labels.needsHuman);
+    const body = `next-issue needs help: ${reason}`;
+    if (state.pr === undefined) {
+        await context.ports.commentOnIssue(context.repo, issue, body);
+    }
+    else {
+        await context.ports.commentOnPr(context.repo, state.pr, body);
+    }
+}
+export function skipped(issue) {
+    return { issue: issue.number, outcome: 'skipped', ciFixes: 0, reviewRounds: 0, ms: 0 };
+}

package/dist/issue-format.mjs

@@ -0,0 +1,7 @@
+export const ISSUE_SECTIONS = [
+    'Problem',
+    'Context and findings',
+    'Acceptance criteria',
+    'Out of scope',
+    'Open questions',
+];

package/dist/job.mjs

@@ -0,0 +1,29 @@
+import { managedLabels } from './config.mjs';
+import { writeState } from './state.mjs';
+export 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, state.title ?? `fix: resolve issue #${issue.number}`, `Closes #${issue.number}\n\nOpened by next-issue.`, config.draftPullRequest));
+    });
+    state.pr = pr;
+    await writeState(repo, state);
+    log.event('pull-request.ready', { pr }, 'quiet');
+}
+export async function setStatus(context, issue, pr, label) {
+    const managed = managedLabels(context.config);
+    await context.ports.setLabel(context.repo, 'issue', issue, label, managed);
+    if (pr !== undefined) {
+        await context.ports.setLabel(context.repo, 'pr', pr, label, managed);
+    }
+}
+export function history(rounds) {
+    return rounds.map((round) => {
+        const head = `Round ${round.round}:\n${round.findings}`;
+        return round.dispute === undefined
+            ? head
+            : `${head}\nThe fixer disputed every finding of this round: ${round.dispute}`;
+    });
+}

package/dist/merge.mjs

@@ -0,0 +1,75 @@
+import { fixRound } from './fix.mjs';
+import { escalate, finish } from './handover.mjs';
+import { openPr, setStatus } from './job.mjs';
+import { writeState } from './state.mjs';
+export async function afterMerge(job) {
+    const { context, issue, state } = job;
+    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, state.pr, context.config.labels.done);
+    return { done: true, report: await finish(job, 'done') };
+}
+async function watchBase(job) {
+    const { context, log, state, worktree } = job;
+    const { repo, config, ports } = context;
+    const sha = await ports.mergeCommit(repo, state.pr, {
+        intervalSeconds: config.checkIntervalSeconds,
+        timeoutMs: config.checkTimeoutMinutes * 60_000,
+    });
+    if (sha === undefined) {
+        await escalate(job, 'The pull request did not merge in time, or it closed without a merge.');
+        return { done: true, report: await finish(job, 'needs-human', 'not merged') };
+    }
+    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') };
+    }
+    await ports.resetToBase(worktree, context.base, config.remote);
+    state.ciFixes += 1;
+    state.baseFix = { sha, head: await ports.revision(worktree) };
+    await writeState(repo, state);
+    return fixBase(job);
+}
+export async function fixBase(job) {
+    const { context, issue, log, state } = job;
+    const { repo, config, ports } = context;
+    const { sha, head } = state.baseFix;
+    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', true, head);
+    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 = [];
+    state.baseFix = undefined;
+    await openPr(job);
+    return { done: false, fixed: true };
+}

package/dist/pipeline.mjs

@@ -1,51 +1,15 @@
-import { CODING, REVIEWING, runAgent } from './agents.mjs';
-import { managedLabels } from './config.mjs';
-import { run } from './exec.mjs';
-import { addWorktree, branchName, commitAll, deleteBranch, diff, discardChanges, disputeBranches, findWorktree, HookError, isDirty, latestSubject, push, removeWorktree, resetToBase, revision, setAside, } from './git.mjs';
-import { commentOnIssue, commentOnPr, createPr, failedBaseLogs, failedCheckLogs, findPr, issueComments, markPrReady, mergeCommit, mergePr, openBlockers, openIssues, prConflicts, prMerged, reopenIssue, setLabel, viewIssue, waitForBaseChecks, waitForChecks, } from './github.mjs';
+import { CODING } from './agents.mjs';
+import { commitWork } from './fix.mjs';
+import { checkGate } from './gate.mjs';
+import { branchName } from './git.mjs';
+import { cleanUp, escalate, finish, handOver, skipped, stop } from './handover.mjs';
+import { openPr, setStatus } from './job.mjs';
+import { afterMerge, fixBase } from './merge.mjs';
 import { message } from './observe.mjs';
-import { capDiff, fixPrompt, hookPrompt, implementPrompt, parseCommitSubject, parseUnrelated, reviewPrompt, } from './prompts.mjs';
-import { detectSetupCommand } from './setup.mjs';
-import { dropState, readState, resetState, savedIssues, writeState, } from './state.mjs';
-import { blockingFindings, fingerprint, formatFindings, formatVerdict, openFindings, parseVerdict, } from './verdict.mjs';
-export const PORTS = {
-    addWorktree,
-    commentOnIssue,
-    commentOnPr,
-    commitAll,
-    createPr,
-    deleteBranch,
-    detectSetupCommand,
-    diff,
-    discardChanges,
-    disputeBranches,
-    failedBaseLogs,
-    failedCheckLogs,
-    findPr,
-    findWorktree,
-    isDirty,
-    issueComments,
-    latestSubject,
-    markPrReady,
-    mergeCommit,
-    mergePr,
-    openBlockers,
-    openIssues,
-    prConflicts,
-    prMerged,
-    push,
-    removeWorktree,
-    reopenIssue,
-    resetToBase,
-    revision,
-    runAgent,
-    runSetup: async (command, cwd, timeoutMs) => run('bash', ['-lc', command], { cwd, timeoutMs }),
-    setAside,
-    setLabel,
-    viewIssue,
-    waitForBaseChecks,
-    waitForChecks,
-};
+import { implementPrompt, parseCommitSubject } from './prompts.mjs';
+import { reviewRound } from './review.mjs';
+import { readState, resetState, savedIssues, writeState } from './state.mjs';
+export { PORTS } from './ports.mjs';
 export function skipReason(issue, config, resuming) {
     const labels = new Set(issue.labels);
     const names = config.labels;
@@ -168,9 +132,6 @@ export async function processIssue(context, issue) {
         };
     }
 }
-function skipped(issue) {
-    return { issue: issue.number, outcome: 'skipped', ciFixes: 0, reviewRounds: 0, ms: 0 };
-}
 async function work(context, issue, log, state, start) {
     const started = Date.now();
     const { repo, config, ports } = context;
@@ -280,381 +241,3 @@ async function work(context, issue, log, state, start) {
         }
     }
 }
-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, state.title ?? `fix: resolve issue #${issue.number}`, `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, 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, state.pr, {
-        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 === 'none' &&
-        (await ports.prConflicts(repo, state.pr, {
-            intervalSeconds: config.checkIntervalSeconds,
-            timeoutMs: config.checkTimeoutMinutes * 60_000,
-        }))) {
-        await escalate(job, 'The pull request conflicts with its base, so no checks ran.');
-        return { done: true, report: await finish(job, 'needs-human', 'merge conflict') };
-    }
-    if (checks === 'moved') {
-        await escalate(job, 'Someone pushed to the pull request while the harness waited for the checks.');
-        return { done: true, report: await finish(job, 'needs-human', 'pull request moved') };
-    }
-    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, state.pr, 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'),
-        };
-    }
-    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 before = await ports.revision(worktree);
-    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,
-    }));
-    if (await ports.discardChanges(worktree, before)) {
-        log.event('review.discard', { round: state.reviewRounds }, 'quiet');
-    }
-    const verdict = parseVerdict(review.text);
-    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 };
-        }
-        if (gate.fixed) {
-            return { done: false };
-        }
-        if (config.draftPullRequest && !(await ports.markPrReady(repo, pr))) {
-            log.event('pull-request.undraft.fail', { pr }, 'quiet');
-        }
-        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') };
-            }
-            return afterMerge(job);
-        }
-        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) {
-        const note = fix.unrelated;
-        if (note === undefined) {
-            await escalate(job, 'The fixer added no commit for the review findings.');
-            return { done: true, report: await finish(job, 'needs-human', 'no fix commit') };
-        }
-        if (fix.stray === true) {
-            await escalate(job, `The fixer disputed the findings and left a change behind: ${note}`);
-            return { done: true, report: await finish(job, 'needs-human', 'dispute with changes') };
-        }
-        state.reviewLog.at(-1).dispute = note;
-        await writeState(repo, state);
-        await ports.commentOnPr(repo, pr, `### Fixer: no change\n\n${note}`);
-    }
-    return { done: false };
-}
-async function afterMerge(job) {
-    const { context, issue, state } = job;
-    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, state.pr, context.config.labels.done);
-    return { done: true, report: await finish(job, 'done') };
-}
-async function watchBase(job) {
-    const { context, log, state, worktree } = job;
-    const { repo, config, ports } = context;
-    const sha = await ports.mergeCommit(repo, state.pr, {
-        intervalSeconds: config.checkIntervalSeconds,
-        timeoutMs: config.checkTimeoutMinutes * 60_000,
-    });
-    if (sha === undefined) {
-        await escalate(job, 'The pull request did not merge in time, or it closed without a merge.');
-        return { done: true, report: await finish(job, 'needs-human', 'not merged') };
-    }
-    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') };
-    }
-    await ports.resetToBase(worktree, context.base, config.remote);
-    state.ciFixes += 1;
-    state.baseFix = { sha, head: await ports.revision(worktree) };
-    await writeState(repo, state);
-    return fixBase(job);
-}
-async function fixBase(job) {
-    const { context, issue, log, state } = job;
-    const { repo, config, ports } = context;
-    const { sha, head } = state.baseFix;
-    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', true, head);
-    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 = [];
-    state.baseFix = undefined;
-    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;
-    await cleanUp(context, log, branch);
-    if (outcome === 'done') {
-        for (const name of [branch, ...(await ports.disputeBranches(repo, branch))]) {
-            if (!(await ports.deleteBranch(repo, name))) {
-                log.event('branch.kept', { branch: name }, '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,
-        ...(job.mainBroken && outcome !== 'done' ? { halt: true } : {}),
-    };
-}
-async function fixRound(job, reason, detail, earlier, kind, force = false, from) {
-    const { context, issue, log, worktree, branch } = job;
-    const { ports } = context;
-    const before = from ?? (await ports.revision(worktree));
-    const result = await log.step('fix', { reason }, () => ports.runAgent(log, {
-        name: 'fixer',
-        cwd: worktree,
-        prompt: fixPrompt(issue, reason, detail, earlier, kind),
-        profile: CODING,
-        model: context.config.models.fixer,
-        timeoutMs: context.config.agentTimeoutMinutes * 60_000,
-    }));
-    const unrelated = parseUnrelated(result.text);
-    if (unrelated !== undefined) {
-        const disputed = await ports.revision(worktree);
-        const moved = disputed !== before;
-        if (moved) {
-            const aside = `${branch}-dispute-${disputed.slice(0, 7)}`;
-            await ports.setAside(worktree, before, aside);
-            log.event('fix.aside', { branch: aside }, 'quiet');
-        }
-        const stray = moved || (await ports.isDirty(worktree));
-        log.event('fix.unrelated', { reason, note: unrelated, stray }, 'quiet');
-        return { committed: false, unrelated, stray };
-    }
-    const subject = parseCommitSubject(result.text, `fix: address feedback on issue #${issue.number}`);
-    if (!(await commitWork(job, before, subject, 'fixer'))) {
-        log.event('commit.empty', { reason }, 'quiet');
-        return { committed: false };
-    }
-    await ports.push(worktree, context.config.remote, branch, force);
-    return { committed: true };
-}
-async function commitWork(job, before, subject, role) {
-    const { context, issue, log, state, worktree, comments } = job;
-    const { repo, config, ports } = context;
-    for (;;) {
-        try {
-            if (await ports.commitAll(worktree, `${subject}\n\nRefs #${issue.number}`)) {
-                log.event('commit', { subject });
-            }
-            if ((await ports.revision(worktree)) === before) {
-                return false;
-            }
-            state.title = subject;
-            return true;
-        }
-        catch (error) {
-            const used = state.commitFixes ?? 0;
-            if (!(error instanceof HookError) || used >= config.maxCommitFixes) {
-                throw error;
-            }
-            state.commitFixes = used + 1;
-            await writeState(repo, state);
-            const output = message(error).slice(-config.logMaxChars);
-            log.event('commit.fail', { role, output }, 'quiet');
-            const fix = await log.step('commit-fix', { role }, () => ports.runAgent(log, {
-                name: role,
-                cwd: worktree,
-                prompt: hookPrompt(issue, comments, role, output),
-                profile: CODING,
-                model: config.models[role],
-                timeoutMs: config.agentTimeoutMinutes * 60_000,
-            }));
-            subject = parseCommitSubject(fix.text, subject);
-        }
-    }
-}
-async function cleanUp(context, log, branch) {
-    try {
-        const path = await context.ports.findWorktree(context.repo, branch);
-        if (path === undefined) {
-            return;
-        }
-        if (!(await context.ports.removeWorktree(context.repo, path))) {
-            log.event('worktree.kept', { path }, 'quiet');
-        }
-    }
-    catch (error) {
-        log.event('worktree.error', { error: message(error) }, 'quiet');
-    }
-}
-async function handOver(context, log, issue, state, reason) {
-    log.event('hand-over', { reason }, 'quiet');
-    await writeState(context.repo, state);
-    await setStatus(context, issue, state.pr, context.config.labels.needsHuman);
-    const body = `next-issue needs help: ${reason}`;
-    if (state.pr === undefined) {
-        await context.ports.commentOnIssue(context.repo, issue, body);
-    }
-    else {
-        await context.ports.commentOnPr(context.repo, state.pr, body);
-    }
-}
-async function setStatus(context, issue, pr, label) {
-    const managed = managedLabels(context.config);
-    await context.ports.setLabel(context.repo, 'issue', issue, label, managed);
-    if (pr !== undefined) {
-        await context.ports.setLabel(context.repo, 'pr', pr, label, managed);
-    }
-}
-function history(rounds) {
-    return rounds.map((round) => {
-        const head = `Round ${round.round}:\n${round.findings}`;
-        return round.dispute === undefined
-            ? head
-            : `${head}\nThe fixer disputed every finding of this round: ${round.dispute}`;
-    });
-}

package/dist/ports.mjs

@@ -0,0 +1,43 @@
+import { runAgent } from './agents.mjs';
+import { run } from './exec.mjs';
+import { addWorktree, commitAll, deleteBranch, diff, discardChanges, disputeBranches, findWorktree, isDirty, latestSubject, push, removeWorktree, resetToBase, revision, setAside, } from './git.mjs';
+import { commentOnIssue, commentOnPr, createPr, failedBaseLogs, failedCheckLogs, findPr, issueComments, markPrReady, mergeCommit, mergePr, openBlockers, openIssues, prConflicts, prMerged, reopenIssue, setLabel, viewIssue, waitForBaseChecks, waitForChecks, } from './github.mjs';
+import { detectSetupCommand } from './setup.mjs';
+export const PORTS = {
+    addWorktree,
+    commentOnIssue,
+    commentOnPr,
+    commitAll,
+    createPr,
+    deleteBranch,
+    detectSetupCommand,
+    diff,
+    discardChanges,
+    disputeBranches,
+    failedBaseLogs,
+    failedCheckLogs,
+    findPr,
+    findWorktree,
+    isDirty,
+    issueComments,
+    latestSubject,
+    markPrReady,
+    mergeCommit,
+    mergePr,
+    openBlockers,
+    openIssues,
+    prConflicts,
+    prMerged,
+    push,
+    removeWorktree,
+    reopenIssue,
+    resetToBase,
+    revision,
+    runAgent,
+    runSetup: async (command, cwd, timeoutMs) => run('bash', ['-lc', command], { cwd, timeoutMs }),
+    setAside,
+    setLabel,
+    viewIssue,
+    waitForBaseChecks,
+    waitForChecks,
+};

package/dist/review.mjs

@@ -0,0 +1,104 @@
+import { REVIEWING } from './agents.mjs';
+import { fixRound } from './fix.mjs';
+import { checkGate } from './gate.mjs';
+import { escalate, finish } from './handover.mjs';
+import { history, setStatus } from './job.mjs';
+import { afterMerge } from './merge.mjs';
+import { capDiff, reviewPrompt } from './prompts.mjs';
+import { writeState } from './state.mjs';
+import { blockingFindings, fingerprint, formatFindings, formatVerdict, openFindings, parseVerdict, } from './verdict.mjs';
+export 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 before = await ports.revision(worktree);
+    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,
+    }));
+    if (await ports.discardChanges(worktree, before)) {
+        log.event('review.discard', { round: state.reviewRounds }, 'quiet');
+    }
+    const verdict = parseVerdict(review.text);
+    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 };
+        }
+        if (gate.fixed) {
+            return { done: false };
+        }
+        if (config.draftPullRequest && !(await ports.markPrReady(repo, pr))) {
+            log.event('pull-request.undraft.fail', { pr }, 'quiet');
+        }
+        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') };
+            }
+            return afterMerge(job);
+        }
+        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) {
+        const note = fix.unrelated;
+        if (note === undefined) {
+            await escalate(job, 'The fixer added no commit for the review findings.');
+            return { done: true, report: await finish(job, 'needs-human', 'no fix commit') };
+        }
+        if (fix.stray === true) {
+            await escalate(job, `The fixer disputed the findings and left a change behind: ${note}`);
+            return { done: true, report: await finish(job, 'needs-human', 'dispute with changes') };
+        }
+        state.reviewLog.at(-1).dispute = note;
+        await writeState(repo, state);
+        await ports.commentOnPr(repo, pr, `### Fixer: no change\n\n${note}`);
+    }
+    return { done: false };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-issue",
-  "version": "2.5.10",
+  "version": "2.7.0",
   "description": "Autonomous issue harness driven by the pi SDK",
   "keywords": [
     "github",