next-issue 2.4.1 → 2.4.2

package/dist/pipeline.mjs

@@ -1,13 +1,13 @@
-import { CODING, REVIEWING, runAgent } from "./agents.mjs";
-import { managedLabels } from "./config.mjs";
-import { run } from "./exec.mjs";
-import { addWorktree, branchName, commitAll, deleteBranch, diff, discardChanges, findWorktree, isDirty, push, removeWorktree, resetToBase, revision, } from "./git.mjs";
-import { commentOnPr, createPr, failedBaseLogs, failedCheckLogs, findPr, issueComments, markPrReady, mergeCommit, mergePr, openBlockers, openIssues, prMerged, reopenIssue, setLabel, viewIssue, waitForBaseChecks, waitForChecks, } from "./github.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, readVerdict, VERDICT_SCHEMA, } from "./verdict.mjs";
+import { CODING, REVIEWING, runAgent } from './agents.mjs';
+import { managedLabels } from './config.mjs';
+import { run } from './exec.mjs';
+import { addWorktree, branchName, commitAll, deleteBranch, diff, discardChanges, findWorktree, isDirty, push, removeWorktree, resetToBase, revision, } from './git.mjs';
+import { commentOnPr, createPr, failedBaseLogs, failedCheckLogs, findPr, issueComments, markPrReady, mergeCommit, mergePr, openBlockers, openIssues, prMerged, reopenIssue, setLabel, viewIssue, waitForBaseChecks, waitForChecks, } from './github.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, readVerdict, VERDICT_SCHEMA, } from './verdict.mjs';
 export const PORTS = {
     addWorktree,
     commentOnPr,
@@ -35,7 +35,7 @@ export const PORTS = {
     resetToBase,
     revision,
     runAgent,
-    runSetup: async (command, cwd, timeoutMs) => run("bash", ["-lc", command], { cwd, timeoutMs }),
+    runSetup: async (command, cwd, timeoutMs) => run('bash', ['-lc', command], { cwd, timeoutMs }),
     setLabel,
     viewIssue,
     waitForBaseChecks,
@@ -45,16 +45,16 @@ 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";
+        return 'stop-label';
     }
     if (resuming) {
         return undefined;
     }
     if (names.ready.length > 0 && !labels.has(names.ready)) {
-        return "not-ready";
+        return 'not-ready';
     }
     if (labels.has(names.inProgress) || labels.has(names.inReview)) {
-        return "in-flight";
+        return 'in-flight';
     }
     return undefined;
 }
@@ -87,12 +87,17 @@ export async function processIssue(context, issue) {
         saved = await readState(context.repo, issue.number);
     }
     catch (error) {
-        log.event("issue.error", { error: message(error), ms: Date.now() - started }, "quiet");
-        return { ...skipped(issue), outcome: "error", reason: message(error), ms: Date.now() - started };
+        log.event('issue.error', { error: message(error), ms: Date.now() - started }, 'quiet');
+        return {
+            ...skipped(issue),
+            outcome: 'error',
+            reason: message(error),
+            ms: Date.now() - started,
+        };
     }
     const skip = skipReason(issue, context.config, saved !== undefined);
     if (skip !== undefined) {
-        log.event("issue.skip", { title: issue.title, reason: skip });
+        log.event('issue.skip', { title: issue.title, reason: skip });
         return skipped(issue);
     }
     if (saved === undefined) {
@@ -101,18 +106,23 @@ export async function processIssue(context, issue) {
             blockers = await context.ports.openBlockers(context.repo, issue.number);
         }
         catch (error) {
-            log.event("issue.error", { error: message(error), ms: Date.now() - started }, "quiet");
-            return { ...skipped(issue), outcome: "error", reason: message(error), ms: Date.now() - started };
+            log.event('issue.error', { error: message(error), ms: Date.now() - started }, 'quiet');
+            return {
+                ...skipped(issue),
+                outcome: 'error',
+                reason: message(error),
+                ms: Date.now() - started,
+            };
         }
         if (blockers.length > 0) {
-            log.event("issue.skip", { title: issue.title, reason: "blocked", blockers });
+            log.event('issue.skip', { title: issue.title, reason: 'blocked', blockers });
             return skipped(issue);
         }
     }
-    log.event("issue.start", { title: issue.title, createdAt: issue.createdAt }, "quiet");
+    log.event('issue.start', { title: issue.title, createdAt: issue.createdAt }, 'quiet');
     const fresh = {
         issue: issue.number,
-        phase: "claimed",
+        phase: 'claimed',
         branch: branchName(issue.number),
         ciFixes: 0,
         reviewRounds: 0,
@@ -121,21 +131,21 @@ export async function processIssue(context, issue) {
     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");
+        log.event('issue.end', { outcome: report.outcome, reason: report.reason, ms: report.ms }, 'quiet');
         return report;
     }
     catch (error) {
-        log.event("issue.error", { error: message(error), ms: Date.now() - started }, "quiet");
+        log.event('issue.error', { error: message(error), ms: Date.now() - started }, 'quiet');
         try {
             await handOver(context, log, issue.number, state, `The run failed: ${message(error)}`);
         }
         catch (failure) {
-            log.event("hand-over.error", { error: message(failure) }, "quiet");
+            log.event('hand-over.error', { error: message(failure) }, 'quiet');
         }
         await cleanUp(context, log, state.branch);
         return {
             issue: issue.number,
-            outcome: "error",
+            outcome: 'error',
             reason: message(error),
             pr: state.pr,
             ciFixes: state.ciFixes,
@@ -145,21 +155,21 @@ export async function processIssue(context, issue) {
     }
 }
 function skipped(issue) {
-    return { issue: issue.number, outcome: "skipped", ciFixes: 0, reviewRounds: 0, ms: 0 };
+    return { issue: issue.number, outcome: 'skipped', ciFixes: 0, reviewRounds: 0, ms: 0 };
 }
 async function work(context, issue, log, state) {
     const started = Date.now();
     const { repo, config, ports } = context;
     const branch = state.branch;
-    await log.step("claim", { label: config.labels.inProgress }, async () => {
+    await log.step('claim', { label: config.labels.inProgress }, async () => {
         await setStatus(context, issue.number, state.pr, config.labels.inProgress);
         await writeState(repo, state);
     });
-    const comments = await log.step("comments", {}, () => ports.issueComments(repo, issue.number));
-    const added = await log.step("worktree", { branch }, () => ports.addWorktree(repo, issue.number, branch, context.base, config.remote));
+    const comments = await log.step('comments', {}, () => ports.issueComments(repo, issue.number));
+    const added = await log.step('worktree', { branch }, () => ports.addWorktree(repo, issue.number, branch, context.base, config.remote));
     const worktree = added.path;
     if (!added.baseUpdated) {
-        log.event("base.behind", { base: context.base }, "quiet");
+        log.event('base.behind', { base: context.base }, 'quiet');
     }
     const job = {
         context,
@@ -175,20 +185,20 @@ async function work(context, issue, log, state) {
     };
     const setupCommand = config.setupCommand ?? (await ports.detectSetupCommand(worktree));
     if (setupCommand !== undefined) {
-        const setup = await log.step("setup", { cmd: setupCommand, found: config.setupCommand === undefined }, () => ports.runSetup(setupCommand, worktree, config.setupTimeoutMinutes * 60_000));
+        const setup = await log.step('setup', { cmd: setupCommand, found: config.setupCommand === undefined }, () => ports.runSetup(setupCommand, worktree, config.setupTimeoutMinutes * 60_000));
         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");
+            log.event('setup.fail', { code: setup.code, timedOut: late, stderr: setup.stderr.trim().slice(-2000) }, 'quiet');
             await escalate(job, late
                 ? `The setup command did not finish in ${config.setupTimeoutMinutes} minutes.`
-                : "The setup command failed in the worktree.");
-            return finish(job, "needs-human", late ? "setup timeout" : "setup failed");
+                : 'The setup command failed in the worktree.');
+            return finish(job, 'needs-human', late ? 'setup timeout' : 'setup failed');
         }
     }
-    if (state.phase === "claimed") {
+    if (state.phase === 'claimed') {
         const before = await ports.revision(worktree);
-        const result = await log.step("implement", {}, () => ports.runAgent(log, {
-            name: "implementer",
+        const result = await log.step('implement', {}, () => ports.runAgent(log, {
+            name: 'implementer',
             cwd: worktree,
             prompt: implementPrompt(issue, comments),
             profile: CODING,
@@ -196,11 +206,11 @@ async function work(context, issue, log, state) {
             timeoutMs: config.agentTimeoutMinutes * 60_000,
         }));
         const subject = parseCommitSubject(result.text, `fix: resolve issue #${issue.number}`);
-        if (!(await commitWork(job, before, subject, "implementer"))) {
-            await escalate(job, "The implementer produced no change.");
-            return finish(job, "needs-human", "no implementation commit");
+        if (!(await commitWork(job, before, subject, 'implementer'))) {
+            await escalate(job, 'The implementer produced no change.');
+            return finish(job, 'needs-human', 'no implementation commit');
         }
-        state.phase = "implemented";
+        state.phase = 'implemented';
         await writeState(repo, state);
     }
     if (context.stopAfterRound()) {
@@ -213,11 +223,13 @@ async function work(context, issue, log, state) {
             return fixed.report;
         }
     }
-    else if (state.phase === "review" && state.pr !== undefined && (await ports.prMerged(repo, state.pr))) {
-        log.event("pull-request.merged", { pr: state.pr }, "quiet");
+    else if (state.phase === 'review' &&
+        state.pr !== undefined &&
+        (await ports.prMerged(repo, state.pr))) {
+        log.event('pull-request.merged', { pr: state.pr }, 'quiet');
         if (!context.merge) {
             await setStatus(context, issue.number, state.pr, config.labels.done);
-            return finish(job, "done");
+            return finish(job, 'done');
         }
         const landed = await afterMerge(job);
         if (landed.done) {
@@ -225,8 +237,8 @@ async function work(context, issue, log, state) {
         }
     }
     else {
-        await log.step("push", { branch }, () => ports.push(worktree, config.remote, branch));
-        state.phase = "review";
+        await log.step('push', { branch }, () => ports.push(worktree, config.remote, branch));
+        state.phase = 'review';
         await openPr(job);
     }
     for (;;) {
@@ -252,52 +264,52 @@ async function work(context, issue, log, state) {
 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 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");
+    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, {
+    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",
+        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") };
+    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") {
+    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") };
+        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");
+    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 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"),
+            report: await finish(job, 'needs-human', note === undefined ? 'no fix commit' : 'unrelated failure'),
         };
     }
     return { done: false, fixed: true };
@@ -308,7 +320,7 @@ async function reviewRound(job) {
     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") };
+        return { done: true, report: await finish(job, 'needs-human', 'review budget') };
     }
     state.reviewRounds += 1;
     await writeState(repo, state);
@@ -321,8 +333,8 @@ async function reviewRound(job) {
         cut: full.length > config.diffMaxChars,
     };
     const before = await ports.revision(worktree);
-    const review = await log.step("review", fields, () => ports.runAgent(log, {
-        name: "reviewer",
+    const review = await log.step('review', fields, () => ports.runAgent(log, {
+        name: 'reviewer',
         cwd: worktree,
         prompt: reviewPrompt(issue, comments, patch, history(state.reviewLog)),
         profile: REVIEWING,
@@ -331,22 +343,22 @@ async function reviewRound(job) {
         outputSchema: VERDICT_SCHEMA,
     }));
     if (await ports.discardChanges(worktree, before)) {
-        log.event("review.discard", { round: state.reviewRounds }, "quiet");
+        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") };
+        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", {
+    log.event('verdict', {
         round: state.reviewRounds,
         blocking: blocking.length,
         minor: verdict.findings.length - blocking.length,
         open: open.length,
         summary: verdict.summary,
-    }, "quiet");
+    }, 'quiet');
     await ports.commentOnPr(repo, pr, formatVerdict(verdict, open));
     if (open.length === 0) {
         const gate = await checkGate(job);
@@ -357,36 +369,40 @@ async function reviewRound(job) {
             return { done: false };
         }
         if (config.draftPullRequest && !(await ports.markPrReady(repo, pr))) {
-            log.event("pull-request.undraft.fail", { pr }, "quiet");
+            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") };
+                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") };
+        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") };
+        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) });
+    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");
+    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") };
+            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") };
+            return { done: true, report: await finish(job, 'needs-human', 'dispute with changes') };
         }
         state.reviewLog.at(-1).dispute = note;
         await writeState(repo, state);
@@ -404,7 +420,7 @@ async function afterMerge(job) {
         return { done: false };
     }
     await setStatus(context, issue.number, state.pr, context.config.labels.done);
-    return { done: true, report: await finish(job, "done") };
+    return { done: true, report: await finish(job, 'done') };
 }
 async function watchBase(job) {
     const { context, log, state, worktree } = job;
@@ -414,26 +430,26 @@ async function watchBase(job) {
         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") };
+        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, {
+    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") {
+    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 (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") };
+        return { done: true, report: await finish(job, 'needs-human', 'check budget') };
     }
     await ports.resetToBase(worktree, context.base, config.remote);
     state.ciFixes += 1;
@@ -446,16 +462,16 @@ async function fixBase(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);
+    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 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"),
+            report: await finish(job, 'needs-human', note === undefined ? 'no fix commit' : 'unrelated failure'),
         };
     }
     await ports.reopenIssue(repo, issue.number);
@@ -470,10 +486,10 @@ function escalate(job, reason) {
 }
 function stop(job) {
     const { issue, log, state } = job;
-    log.event("issue.stop", { phase: state.phase }, "quiet");
+    log.event('issue.stop', { phase: state.phase }, 'quiet');
     return {
         issue: issue.number,
-        outcome: "stopped",
+        outcome: 'stopped',
         pr: state.pr,
         ciFixes: state.ciFixes,
         reviewRounds: state.reviewRounds,
@@ -484,9 +500,9 @@ 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") {
+    if (outcome === 'done') {
         if (!(await ports.deleteBranch(repo, branch))) {
-            log.event("branch.kept", { branch }, "quiet");
+            log.event('branch.kept', { branch }, 'quiet');
         }
         await dropState(repo, issue.number);
     }
@@ -498,15 +514,15 @@ async function finish(job, outcome, reason) {
         ciFixes: state.ciFixes,
         reviewRounds: state.reviewRounds,
         ms: Date.now() - job.started,
-        ...(job.mainBroken && outcome !== "done" ? { halt: true } : {}),
+        ...(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",
+    const result = await log.step('fix', { reason }, () => ports.runAgent(log, {
+        name: 'fixer',
         cwd: worktree,
         prompt: fixPrompt(issue, reason, detail, earlier, kind),
         profile: CODING,
@@ -516,12 +532,12 @@ async function fixRound(job, reason, detail, earlier, kind, force = false, from)
     const unrelated = parseUnrelated(result.text);
     if (unrelated !== undefined) {
         const stray = (await ports.revision(worktree)) !== before || (await ports.isDirty(worktree));
-        log.event("fix.unrelated", { reason, note: unrelated, stray }, "quiet");
+        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");
+    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);
@@ -533,7 +549,7 @@ async function commitWork(job, before, subject, role) {
     for (;;) {
         try {
             if (await ports.commitAll(worktree, `${subject}\n\nRefs #${issue.number}`)) {
-                log.event("commit", { subject });
+                log.event('commit', { subject });
             }
             if ((await ports.revision(worktree)) === before) {
                 return false;
@@ -549,8 +565,8 @@ async function commitWork(job, before, subject, role) {
             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, {
+            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),
@@ -569,15 +585,15 @@ async function cleanUp(context, log, branch) {
             return;
         }
         if (!(await context.ports.removeWorktree(context.repo, path))) {
-            log.event("worktree.kept", { path }, "quiet");
+            log.event('worktree.kept', { path }, 'quiet');
         }
     }
     catch (error) {
-        log.event("worktree.error", { error: message(error) }, "quiet");
+        log.event('worktree.error', { error: message(error) }, 'quiet');
     }
 }
 async function handOver(context, log, issue, state, reason) {
-    log.event("hand-over", { reason }, "quiet");
+    log.event('hand-over', { reason }, 'quiet');
     await writeState(context.repo, state);
     await setStatus(context, issue, state.pr, context.config.labels.needsHuman);
     if (state.pr !== undefined) {
@@ -586,9 +602,9 @@ async function handOver(context, log, issue, state, reason) {
 }
 async function setStatus(context, issue, pr, label) {
     const managed = managedLabels(context.config);
-    await context.ports.setLabel(context.repo, "issue", issue, label, managed);
+    await context.ports.setLabel(context.repo, 'issue', issue, label, managed);
     if (pr !== undefined) {
-        await context.ports.setLabel(context.repo, "pr", pr, label, managed);
+        await context.ports.setLabel(context.repo, 'pr', pr, label, managed);
     }
 }
 function history(rounds) {

package/dist/progress.mjs

@@ -1,48 +1,48 @@
 const TOOL_LINE_MAX = 80;
-const NOT_STAGES = new Set(["issue.start", "agent.start", "run.start"]);
+const NOT_STAGES = new Set(['issue.start', 'agent.start', 'run.start']);
 export function startProgress() {
-    return { status: "running", tools: 0, handled: [] };
+    return { status: 'running', tools: 0, handled: [] };
 }
 function idle(progress) {
     const { issue: _issue, title: _title, stage: _stage, lastTool: _lastTool, issueStartedAt: _at, ...rest } = progress;
     return { ...rest, tools: 0 };
 }
 function toolLine(record) {
-    const tool = String(record["tool"]);
-    const command = record["command"];
-    const line = typeof command === "string" ? `${tool} ${command.split("\n")[0]}` : tool;
+    const tool = String(record['tool']);
+    const command = record['command'];
+    const line = typeof command === 'string' ? `${tool} ${command.split('\n')[0]}` : tool;
     return line.length > TOOL_LINE_MAX ? `${line.slice(0, TOOL_LINE_MAX - 1)}…` : line;
 }
 export function applyEvent(progress, record) {
-    const kind = String(record["kind"]);
-    if (kind === "issue.start") {
+    const kind = String(record['kind']);
+    if (kind === 'issue.start') {
         const next = {
             ...idle(progress),
-            issue: Number(record["issue"]),
-            issueStartedAt: Date.parse(String(record["ts"])),
+            issue: Number(record['issue']),
+            issueStartedAt: Date.parse(String(record['ts'])),
         };
-        if (typeof record["title"] === "string") {
-            next.title = record["title"];
+        if (typeof record['title'] === 'string') {
+            next.title = record['title'];
         }
         return next;
     }
-    if (kind === "tool") {
+    if (kind === 'tool') {
         return { ...progress, tools: progress.tools + 1, lastTool: toolLine(record) };
     }
-    if (kind === "issue.end" || kind === "issue.error") {
-        const outcome = kind === "issue.error" ? "error" : record["outcome"];
-        const handled = outcome === "done" || outcome === "needs-human" || outcome === "error"
-            ? [...progress.handled, { issue: Number(record["issue"]), outcome }]
+    if (kind === 'issue.end' || kind === 'issue.error') {
+        const outcome = kind === 'issue.error' ? 'error' : record['outcome'];
+        const handled = outcome === 'done' || outcome === 'needs-human' || outcome === 'error'
+            ? [...progress.handled, { issue: Number(record['issue']), outcome }]
             : progress.handled;
         return { ...idle(progress), handled };
     }
-    if (kind === "issues.fail") {
-        return { ...progress, error: String(record["error"]) };
+    if (kind === 'issues.fail') {
+        return { ...progress, error: String(record['error']) };
     }
-    if (kind.endsWith(".start") && !NOT_STAGES.has(kind) && progress.issue !== undefined) {
-        const stage = kind.slice(0, -".start".length);
-        const round = record["round"];
-        return { ...progress, stage: typeof round === "number" ? `${stage} ${round}` : stage };
+    if (kind.endsWith('.start') && !NOT_STAGES.has(kind) && progress.issue !== undefined) {
+        const stage = kind.slice(0, -'.start'.length);
+        const round = record['round'];
+        return { ...progress, stage: typeof round === 'number' ? `${stage} ${round}` : stage };
     }
     return progress;
 }