next-issue 1.0.8 → 2.0.0

package/README.md

@@ -1,7 +1,7 @@
 # next-issue
 
 A small harness that works through the open issues of a GitHub repository with
-the Claude Agent SDK. Run it inside a git repository.
+the [pi](https://github.com/earendil-works/pi) SDK. Run it inside a git repository.
 
 ```bash
 npx -y next-issue@latest
@@ -54,7 +54,7 @@ and exits with code 1. For each issue:
    reviewer reads files and runs commands in the worktree, so it can prove a
    finding with the tests or the type check. The harness then throws away every
    change that the reviewer left, so no such change can reach a later commit.
-   The reviewer returns a structured verdict: a summary and one entry per
+   The reviewer returns its verdict with a `submit_result` tool: a summary and one entry per
    finding, each rated `blocking` or `minor`. The findings are the only ground
    truth. The reviewer gives no approve or reject field, because such a field
    can contradict the findings. The harness puts the result on the pull
@@ -146,14 +146,14 @@ Press `Ctrl-C` to stop the run step by step:
    one checks round (wait, then fix) or one review round (review, then fix). The
    issue ends as `stopped`. Its state, worktree and labels stay, so the next run
    carries on from that point.
-3. The third press kills the command that runs and every child of it, so the run
-   dies in the middle of a step. The saved state lets the next run continue the
+3. The third press stops every agent, kills the command that runs and every
+   child of it, so the run dies in the middle of a step. The saved state lets the next run continue the
    issue, but the issue keeps `status:in-progress` and the run writes no
    summary.
 
 Each of the first two presses prints a line that says what happens next. The
-agents and commands run in a process group of their own, so a press reaches only
-the harness.
+agents run inside the harness, and their commands and the harness commands run
+in a process group of their own, so a press reaches only the harness.
 
 A status label that the harness puts on the issue goes on the pull request too,
 but only if the pull request exists at that moment. The `status:in-progress`
@@ -202,10 +202,9 @@ Recorded for each step: `claim`, `comments`, `worktree`, `setup`, `implement`,
 `push`, `pull-request`, `checks`, `review` and `fix`, each with a `.start`,
 `.end` or `.error` event and a duration in `ms`. Every `git` and `gh` command
 is recorded with its exit code and duration. A `tool` event holds the tool
-name, and for a `Bash` tool the command too. Each agent call adds a `usage`
+name, and for a `bash` tool the command too. Each agent call adds a `usage`
 event with the tokens, the cost estimate in dollars, the turn count, the
-tool-call count, the model and the session id, so you can open the session
-again and read the full transcript.
+tool-call count, the model and the session id.
 
 ```bash
 jq -r 'select(.kind=="usage") | [.issue,.role,.turns,.total] | @tsv' \
@@ -224,8 +223,11 @@ Three levels of console output:
 
 - Node 24 or later
 - `gh`, authenticated with write access to the repository
-- Anthropic credentials for the Claude Agent SDK: `ANTHROPIC_API_KEY`, or a
-  Claude subscription login
+- pi, logged in to a model provider. The agents use the model, the thinking
+  level and the extensions from your pi settings, except the `pi-next-issue`
+  extension. The implementer and the fixer get the `read`, `bash`, `edit`,
+  `write`, `grep`, `find` and `ls` tools, and the reviewer gets all of them
+  except `edit` and `write`.
 
 ## Configuration
 
@@ -297,7 +299,7 @@ does not know all stop the run, so a typo cannot pass without a word.
 | `keepRunDays` | `7` | The number of days to keep the run files; `0` keeps them all |
 | `draftPullRequest` | `true` | Open the pull request as a draft, until the review approves |
 | `setupCommand` | from the lock file | A shell command to run in a new worktree, before the implementer |
-| `models` | `null` per role | The model per agent role: `implementer`, `reviewer`, `fixer` |
+| `models` | `null` per role | The pi model per agent role, as `provider/model`: `implementer`, `reviewer`, `fixer` |
 | `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
@@ -307,7 +309,7 @@ The log gives the reason for a skipped issue as `stop-label`, `not-ready`,
 `in-flight` or `blocked`, the last one with the open blockers.
 
 A role set to `null`, or with no entry in `models`, uses the default model of
-the agent.
+your pi settings.
 
 Without a `setupCommand`, the harness looks in the new worktree for a lock file
 and runs the install command that goes with it:
@@ -358,6 +360,7 @@ that a label still holds back stays as it was.
 | `--once` | Stop after the first handled issue |
 | `--max <n>` | Handle at most n issues |
 | `--merge` | Squash-merge the pull request after the approval, delete the remote branch and fix a failure of the checks on the base branch |
+| `--watch` | Keep running, and read the open issues again after each pass |
 | `--reset` | Drop the saved budgets and findings, and keep the rest of the state |
 | `--json` | Print the machine summary instead of the text one |
 | `--verbose` | Show every command and all agent output |
@@ -367,6 +370,33 @@ that a label still holds back stays as it was.
 The exit code is 1 when an issue needs a person or failed, and 0 when it does
 not, so a cron job or a CI step can read the result of the run.
 
+## Watch for new issues
+
+A run without `--watch` ends when no unseen issue is left. With `--watch`, the
+harness then waits, reads the open issues again and runs another pass, so it
+picks up an issue that someone opens during the run, or one whose blocker
+merges. Each pass tries every open issue again, also one that an earlier pass
+skipped.
+
+The waits follow a fixed back-off in minutes: 1, 2, 3, 5, 10, then 10 from then
+on. A pass that handles an issue, with any outcome other than `skipped`, resets
+the back-off to 1 minute. A pass where every issue is skipped does not reset
+it. Each wait prints a line on standard error with the minutes until the next
+pass.
+
+After each pass that handled an issue, the harness prints the summary of that
+pass. The token totals in it cover that pass only. The exit code at the end
+covers all passes. `--max <n>` counts the handled issues across all passes,
+and `--once` is the same as `--max 1`.
+
+The watch stops:
+
+- at the first `Ctrl-C` during a wait, at once;
+- at the first `Ctrl-C` during an issue, after that issue;
+- after a pass that halts the run, for example when the base branch is broken
+  after `--merge`;
+- when the open issues cannot be read.
+
 ## Development
 
 ```bash

package/dist/agents.mjs

@@ -1,186 +1,147 @@
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import { spawn } from "node:child_process";
-import { once } from "node:events";
-import { setTimeout as delay } from "node:timers/promises";
-import { track } from "./exec.mjs";
+import { join, sep } from "node:path";
+import { createAgentSession, DefaultResourceLoader, defineTool, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { onStop } from "./exec.mjs";
 import { emptyUsage } from "./observe.mjs";
 const REVIEWING = {
-    tools: ["Read", "Grep", "Glob", "Bash"],
-    permissionMode: "dontAsk",
+    tools: ["read", "bash", "grep", "find", "ls"],
 };
 const CODING = {
-    tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
-    permissionMode: "bypassPermissions",
-    allowDangerouslySkipPermissions: true,
+    tools: ["read", "bash", "edit", "write", "grep", "find", "ls"],
 };
 export { CODING, REVIEWING };
-const STDERR_TAIL = 2000;
-const STDERR_GRACE_MS = 500;
+export const SUBMIT_TOOL = "submit_result";
+export function isOwnExtension(path) {
+    return path.split(sep).includes("pi-next-issue");
+}
 export async function runAgent(recorder, request) {
     const log = recorder.scope({ role: request.name });
-    const usage = emptyUsage();
-    const toolNames = new Map();
-    let text = "";
-    let toolCalls = 0;
-    let turns = 0;
-    let costUsd = 0;
-    let model = request.model;
-    let sessionId;
-    let structured;
-    let stderr = "";
-    let stderrClosed = Promise.resolve();
+    const runtime = request.runtime ?? {};
+    const agentDir = runtime.agentDir ?? getAgentDir();
     const started = Date.now();
     log.event("agent.start", { model: request.model, timeoutMs: request.timeoutMs }, "normal");
-    const controller = new AbortController();
+    let structured;
+    const customTools = [];
+    if (request.outputSchema !== undefined) {
+        customTools.push(defineTool({
+            name: SUBMIT_TOOL,
+            label: "Submit result",
+            description: "Give the result. Call it once, as your last action.",
+            parameters: request.outputSchema,
+            async execute(_toolCallId, params) {
+                structured = params;
+                return {
+                    content: [{ type: "text", text: "Result saved." }],
+                    details: {},
+                    terminate: true,
+                };
+            },
+        }));
+    }
+    const resourceLoader = new DefaultResourceLoader({
+        cwd: request.cwd,
+        agentDir,
+        extensionsOverride: (base) => ({
+            ...base,
+            extensions: base.extensions.filter((extension) => !isOwnExtension(extension.resolvedPath)),
+        }),
+    });
+    await resourceLoader.reload();
+    const modelRuntime = runtime.modelRuntime ?? (await ModelRuntime.create({
+        authPath: join(agentDir, "auth.json"),
+        modelsPath: join(agentDir, "models.json"),
+    }));
+    const model = request.model === undefined ? undefined : await findModel(modelRuntime, request.model);
+    const { session, modelFallbackMessage } = await createAgentSession({
+        cwd: request.cwd,
+        agentDir,
+        resourceLoader,
+        sessionManager: SessionManager.inMemory(request.cwd),
+        tools: [...request.profile.tools, ...customTools.map((tool) => tool.name)],
+        customTools,
+        modelRuntime,
+        ...(runtime.settingsManager === undefined ? {} : { settingsManager: runtime.settingsManager }),
+        ...(model === undefined ? {} : { model }),
+    });
+    if (modelFallbackMessage !== undefined) {
+        log.event("agent.model", { note: modelFallbackMessage }, "quiet");
+    }
+    let timedOut = false;
     const timer = request.timeoutMs === undefined
         ? undefined
-        : setTimeout(() => controller.abort(), request.timeoutMs);
-    const late = () => new Error(`The ${request.name} agent did not finish in ${request.timeoutMs} ms.`);
+        : setTimeout(() => {
+            timedOut = true;
+            void session.abort();
+        }, request.timeoutMs);
+    const unsubscribe = session.subscribe((event) => observe(log, event));
+    const release = onStop(() => void session.abort());
     try {
-        const stream = query({
-            prompt: request.prompt,
-            options: {
-                cwd: request.cwd,
-                model: request.model,
-                tools: request.profile.tools,
-                allowedTools: request.profile.tools,
-                permissionMode: request.profile.permissionMode,
-                allowDangerouslySkipPermissions: request.profile.allowDangerouslySkipPermissions,
-                systemPrompt: { type: "preset", preset: "claude_code" },
-                abortController: controller,
-                pathToClaudeCodeExecutable: request.executable,
-                spawnClaudeCodeProcess: (options) => {
-                    const child = spawnClaude(options, (chunk) => {
-                        stderr = (stderr + chunk).slice(-STDERR_TAIL);
-                    });
-                    stderrClosed = once(child.stderr, "close").catch(() => undefined);
-                    return child;
-                },
-                outputFormat: request.outputSchema === undefined
-                    ? undefined
-                    : { type: "json_schema", schema: request.outputSchema },
-            },
-        });
-        for await (const message of stream) {
-            if (message.type === "assistant") {
-                for (const block of message.message.content) {
-                    if (block.type === "tool_use") {
-                        toolCalls += 1;
-                        toolNames.set(block.id, block.name);
-                        log.event("tool", toolFields(block.name, block.input));
-                    }
-                    if (block.type === "text") {
-                        text += block.text;
-                        if (log.level === "verbose") {
-                            process.stderr.write(block.text);
-                        }
-                    }
-                }
-            }
-            if (message.type === "user" && Array.isArray(message.message.content)) {
-                for (const block of message.message.content) {
-                    if (block.type === "tool_result" && block.is_error === true) {
-                        log.event("tool.error", { tool: toolNames.get(block.tool_use_id) }, "quiet");
-                    }
-                }
-            }
-            if (message.type === "result") {
-                sessionId = message.session_id;
-                turns = message.num_turns;
-                costUsd = message.total_cost_usd;
-                model = main(message.modelUsage) ?? model;
-                for (const entry of Object.values(message.modelUsage)) {
-                    usage.input += entry.inputTokens;
-                    usage.output += entry.outputTokens;
-                    usage.cacheRead += entry.cacheReadInputTokens;
-                    usage.cacheWrite += entry.cacheCreationInputTokens;
-                    usage.total +=
-                        entry.inputTokens +
-                            entry.outputTokens +
-                            entry.cacheReadInputTokens +
-                            entry.cacheCreationInputTokens;
-                }
-                if (message.subtype === "error_during_execution") {
-                    throw new Error(`The ${request.name} agent failed: ${message.errors.join("; ")}`);
-                }
-                if (message.subtype === "success") {
-                    text = message.result.length > 0 ? message.result : text;
-                    structured = message.structured_output;
-                }
-                else {
-                    log.event("agent.incomplete", { subtype: message.subtype }, "quiet");
-                }
-            }
+        await session.bindExtensions({});
+        await session.prompt(request.prompt, { expandPromptTemplates: false });
+        if (timedOut) {
+            throw new Error(`The ${request.name} agent did not finish in ${request.timeoutMs} ms.`);
         }
-    }
-    catch (error) {
-        if (controller.signal.aborted) {
-            throw late();
+        const last = session.messages.findLast((message) => message.role === "assistant");
+        if (last !== undefined && "stopReason" in last && last.stopReason === "error") {
+            throw new Error(`The ${request.name} agent failed: ${last.errorMessage ?? "no reason given"}`);
         }
-        await Promise.race([stderrClosed, delay(STDERR_GRACE_MS, undefined, { ref: false })]);
-        throw withStderr(error, stderr);
+        const stats = session.getSessionStats();
+        const usage = { ...emptyUsage(), ...stats.tokens };
+        const name = session.model === undefined ? undefined : `${session.model.provider}/${session.model.id}`;
+        const ms = Date.now() - started;
+        recorder.usage(request.name, usage, ms, {
+            turns: stats.assistantMessages,
+            toolCalls: stats.toolCalls,
+            model: name,
+            session: stats.sessionId,
+            costUsd: stats.cost,
+        });
+        return {
+            text: (session.getLastAssistantText() ?? "").trim(),
+            usage,
+            turns: stats.assistantMessages,
+            toolCalls: stats.toolCalls,
+            ms,
+            costUsd: stats.cost,
+            model: name,
+            sessionId: stats.sessionId,
+            structured,
+        };
     }
     finally {
         clearTimeout(timer);
+        release();
+        unsubscribe();
+        session.dispose();
     }
-    if (controller.signal.aborted) {
-        throw late();
+}
+async function findModel(modelRuntime, name) {
+    const slash = name.indexOf("/");
+    if (slash <= 0) {
+        throw new Error(`The model ${name} is not in the form provider/model.`);
     }
-    const ms = Date.now() - started;
-    recorder.usage(request.name, usage, ms, {
-        turns,
-        toolCalls,
-        model,
-        session: sessionId,
-        costUsd,
-    });
-    return {
-        text: text.trim(),
-        usage,
-        turns,
-        toolCalls,
-        ms,
-        costUsd,
-        model,
-        sessionId,
-        structured,
-    };
+    const found = modelRuntime.getModel(name.slice(0, slash), name.slice(slash + 1));
+    if (found === undefined) {
+        throw new Error(`The model ${name} is not known to pi.`);
+    }
+    return found;
 }
-function main(models) {
-    let name;
-    let output = -1;
-    for (const [id, entry] of Object.entries(models)) {
-        if (entry.outputTokens > output) {
-            output = entry.outputTokens;
-            name = id;
-        }
+function observe(log, event) {
+    if (event.type === "tool_execution_start") {
+        log.event("tool", toolFields(event.toolName, event.args));
+    }
+    else if (event.type === "tool_execution_end" && event.isError) {
+        log.event("tool.error", { tool: event.toolName }, "quiet");
+    }
+    else if (event.type === "message_update" &&
+        event.assistantMessageEvent.type === "text_delta" &&
+        log.level === "verbose") {
+        process.stderr.write(event.assistantMessageEvent.delta);
     }
-    return name;
 }
 export function toolFields(name, input) {
-    if (name !== "Bash" || typeof input !== "object" || input === null) {
+    if (name !== "bash" || typeof input !== "object" || input === null) {
         return { tool: name };
     }
     const { command } = input;
     return typeof command === "string" ? { tool: name, command } : { tool: name };
 }
-export function withStderr(error, stderr) {
-    const tail = stderr.trim();
-    if (tail.length === 0 || !(error instanceof Error)) {
-        return error;
-    }
-    return new Error(`${error.message}\nClaude CLI stderr:\n${tail}`, { cause: error });
-}
-export function spawnClaude(options, onStderr = () => undefined) {
-    const child = spawn(options.command, options.args, {
-        cwd: options.cwd,
-        env: options.env,
-        signal: options.signal,
-        detached: true,
-        stdio: ["pipe", "pipe", "pipe"],
-    });
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", onStderr);
-    track(child);
-    return child;
-}

package/dist/args.mjs

@@ -6,6 +6,7 @@ export const USAGE = `next-issue [command] [options]
   --once       stop after the first handled issue
   --max <n>    handle at most n issues
   --merge      squash-merge the pull request after the approval
+  --watch      keep running and read the issues again after each pass
   --reset      drop the saved budgets and findings first
   --json       print the machine summary instead of the text one
   --force      replace an existing config file, with init
@@ -22,6 +23,7 @@ export function parseArgs(argv) {
         reset: false,
         force: false,
         merge: false,
+        watch: false,
         level: "normal",
     };
     for (let index = 0; index < argv.length; index += 1) {
@@ -44,6 +46,9 @@ export function parseArgs(argv) {
         else if (arg === "--merge") {
             args.merge = true;
         }
+        else if (arg === "--watch") {
+            args.watch = true;
+        }
         else if (arg === "--reset") {
             args.reset = true;
         }

package/dist/cli.mjs

@@ -7,7 +7,7 @@ import { setCommandObserver, setDefaultTimeout } from "./exec.mjs";
 import { detectRepo, ensureIgnored, repoRoot, WORKTREE_DIR } from "./git.mjs";
 import { defaultBranch } from "./github.mjs";
 import { listenForInterrupts } from "./interrupt.mjs";
-import { exitCode, runIssues } from "./loop.mjs";
+import { exitCode, runIssues, watchIssues } from "./loop.mjs";
 import { message, pruneRuns, Recorder } from "./observe.mjs";
 import { pendingIssues, PORTS, processIssue } from "./pipeline.mjs";
 import { STATE_DIR } from "./state.mjs";
@@ -82,7 +82,7 @@ async function handle(args, config, repo, recorder) {
         base,
         log: recorder.logFile,
     }, "quiet");
-    const { reports, stoppedAt, error } = await runIssues(args, {
+    const loop = {
         issues: async () => {
             const issues = await pendingIssues(context);
             recorder.event("issues", { open: issues.length }, "quiet");
@@ -90,7 +90,20 @@ async function handle(args, config, repo, recorder) {
         },
         process: (issue) => processIssue(context, issue),
         stop: interrupts.afterIssue,
-    });
+    };
+    const print = (summary) => write(process.stdout, args.json ? `${JSON.stringify(summary, null, 2)}\n` : formatSummary(summary));
+    let passStart = recorder.summary();
+    const { reports, stoppedAt, error } = args.watch
+        ? await watchIssues(args, {
+            ...loop,
+            wait: (minutes) => {
+                recorder.event("watch.wait", { minutes }, "quiet");
+                passStart = recorder.summary();
+                return interrupts.sleep(minutes * 60_000);
+            },
+            passEnd: (issues) => print({ ...recorder.summary(passStart), issues }),
+        })
+        : await runIssues(args, loop);
     if (stoppedAt !== undefined) {
         recorder.event("run.stop", { issue: stoppedAt }, "quiet");
     }
@@ -107,7 +120,9 @@ async function handle(args, config, repo, recorder) {
     const summary = { ...recorder.summary(), issues: reports };
     const summaryFile = join(repo.root, STATE_DIR, "runs", `${recorder.runId}.summary.json`);
     await writeFile(summaryFile, `${JSON.stringify(summary, null, 2)}\n`);
-    await write(process.stdout, args.json ? `${JSON.stringify(summary, null, 2)}\n` : formatSummary(summary));
+    if (!args.watch) {
+        await print(summary);
+    }
     return error === undefined ? exitCode(reports) : 1;
 }
 function count(reports, outcome) {

package/dist/exec.mjs

@@ -3,7 +3,16 @@ let observer;
 let defaultTimeoutMs = 10 * 60_000;
 const STDERR_TAIL = 200_000;
 const groups = new Set();
+const stoppers = new Set();
+export function onStop(stopper) {
+    stoppers.add(stopper);
+    return () => stoppers.delete(stopper);
+}
 export function stopChildren(signal) {
+    for (const stopper of stoppers) {
+        stopper();
+    }
+    stoppers.clear();
     for (const pid of groups) {
         try {
             process.kill(-pid, signal);

package/dist/interrupt.mjs

@@ -1,9 +1,14 @@
 import { stopChildren } from "./exec.mjs";
 export function listenForInterrupts(say) {
     let presses = 0;
+    let wake;
     const press = () => {
         presses += 1;
-        if (presses === 1) {
+        if (presses === 1 && wake !== undefined) {
+            say("Stopping now.");
+            wake();
+        }
+        else if (presses === 1) {
             say("Stopping after this issue. Press Ctrl-C again to stop after this round.");
         }
         else if (presses === 2) {
@@ -18,5 +23,20 @@ export function listenForInterrupts(say) {
     return {
         afterIssue: () => presses >= 1,
         afterRound: () => presses >= 2,
+        sleep: (ms) => new Promise((resolve) => {
+            if (presses >= 1) {
+                resolve(false);
+                return;
+            }
+            const timer = setTimeout(() => {
+                wake = undefined;
+                resolve(true);
+            }, ms);
+            wake = () => {
+                clearTimeout(timer);
+                wake = undefined;
+                resolve(false);
+            };
+        }),
     };
 }

package/dist/loop.mjs

@@ -1,3 +1,4 @@
+export const BACK_OFF_MINUTES = [1, 2, 3, 5, 10];
 export async function runIssues(args, loop) {
     const reports = [];
     const seen = new Set();
@@ -25,6 +26,30 @@ export async function runIssues(args, loop) {
     }
     return { reports };
 }
+export async function watchIssues(args, watch) {
+    const limit = args.once ? 1 : args.max;
+    const reports = [];
+    let step = 0;
+    for (;;) {
+        const pass = await runIssues({ once: false, max: limit === undefined ? undefined : limit - handled(reports) }, watch);
+        reports.push(...pass.reports);
+        if (handled(pass.reports) > 0) {
+            await watch.passEnd(pass.reports);
+            step = 0;
+        }
+        if (pass.error !== undefined || pass.stoppedAt !== undefined) {
+            return { ...pass, reports };
+        }
+        if ((limit !== undefined && handled(reports) >= limit) || watch.stop()) {
+            return { reports };
+        }
+        const minutes = BACK_OFF_MINUTES[Math.min(step, BACK_OFF_MINUTES.length - 1)];
+        step += 1;
+        if (!(await watch.wait(minutes))) {
+            return { reports };
+        }
+    }
+}
 export function exitCode(reports) {
     return reports.some((report) => report.outcome === "needs-human" || report.outcome === "error") ? 1 : 0;
 }

package/dist/observe.mjs

@@ -13,6 +13,15 @@ export function addUsage(target, source) {
     target.cacheWrite += source.cacheWrite;
     target.total += source.total;
 }
+function negate(usage) {
+    return {
+        input: -usage.input,
+        output: -usage.output,
+        cacheRead: -usage.cacheRead,
+        cacheWrite: -usage.cacheWrite,
+        total: -usage.total,
+    };
+}
 class Sink {
     totals = new Map();
     counts = new Map();
@@ -98,20 +107,27 @@ export class Recorder {
             throw error;
         }
     }
-    summary() {
+    summary(since) {
         const total = emptyUsage();
         const roles = {};
         for (const [role, value] of this.sink.totals) {
-            roles[role] = value;
-            addUsage(total, value);
+            const earlier = since?.roles[role] ?? { ...emptyUsage(), calls: 0, ms: 0 };
+            if (value.calls === earlier.calls) {
+                continue;
+            }
+            const usage = { ...value, calls: value.calls - earlier.calls, ms: value.ms - earlier.ms };
+            addUsage(usage, negate(earlier));
+            roles[role] = usage;
+            addUsage(total, usage);
         }
-        return {
-            runId: this.runId,
-            logFile: this.sink.file,
-            roles,
-            counts: Object.fromEntries(this.sink.counts),
-            total,
-        };
+        const counts = {};
+        for (const [kind, value] of this.sink.counts) {
+            const count = value - (since?.counts[kind] ?? 0);
+            if (count > 0) {
+                counts[kind] = count;
+            }
+        }
+        return { runId: this.runId, logFile: this.sink.file, roles, counts, total };
     }
     async close() {
         await this.sink.close();

package/dist/prompts.mjs

@@ -60,7 +60,7 @@ export function reviewPrompt(issue, comments, diff, earlier) {
         "The harness discards each change that you make, so a change is only lost work.",
         scope,
         "Mark a finding blocking only for a wrong result, a missing part of the issue, a regression or a broken convention.",
-        "Give the result as the structured output: a short summary and one entry per finding. The findings decide the outcome, so a problem that you leave out counts as no problem.",
+        "Give the result with the submit_result tool: a short summary and one entry per finding. The findings decide the outcome, so a problem that you leave out counts as no problem.",
     ].join("\n\n");
 }
 const UNRELATED_RULE = [

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "next-issue",
-  "version": "1.0.8",
-  "description": "Autonomous issue harness driven by the Claude Agent SDK",
+  "version": "2.0.0",
+  "description": "Autonomous issue harness driven by the pi SDK",
   "keywords": [
     "github",
     "issues",
     "agent",
-    "claude",
+    "pi",
     "automation",
     "cli"
   ],
@@ -37,10 +37,12 @@
     "prepublishOnly": "npm run typecheck && npm test"
   },
   "devDependencies": {
+    "@earendil-works/pi-ai": "^1.5.0",
     "@types/node": "^26.6.6",
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.316"
+    "@earendil-works/pi-coding-agent": "^1.5.0",
+    "typebox": "^1.4.3"
   }
 }