next-issue 0.20.0 → 1.0.1

package/README.md

@@ -1,20 +1,12 @@
 # next-issue
 
 A small harness that works through the open issues of a GitHub repository with
-the Claude Agent SDK, or with [pi](https://pi.dev). Run it inside a git
-repository.
+the Claude Agent SDK. Run it inside a git repository.
 
 ```bash
 npx -y next-issue@latest
 ```
 
-Or install it once:
-
-```bash
-npm install -g next-issue@latest
-next-issue
-```
-
 ## What it does
 
 For each open issue, oldest first:
@@ -35,11 +27,16 @@ For each open issue, oldest first:
    writes a `base.behind` event. A new branch then starts from the remote base.
 4. Let the implementer agent do the work, then commit and push. When a git
    hook stops a commit, the agent that made the change gets the hook output,
-   fixes it, and the harness commits again. The budget is `maxCommitFixes`.
-5. Open a draft pull request that closes the issue.
+   fixes it, and the harness commits again. A `commit:` line in the reply of
+   the agent replaces the subject, so a hook that rejects the subject can pass.
+   The budget is `maxCommitFixes`.
+5. Open a draft pull request that closes the issue. Its title is the subject
+   of the commit that starts it, so a squash merge gives a conventional
+   commit.
 6. Wait for the checks, once the pull request shows the pushed commit. A
    pending state waits again, up to `checkTimeoutMinutes`. A read that fails
-   is tried three times before the run stops. A repository that reports no
+   is tried three times before the run stops. A watch that exits with an error
+   while no check failed counts as such a read, not as a red build. A repository that reports no
    check keeps asking for `checkGraceSeconds`, because a new pull request often
    shows no check yet, and only then goes straight to the review. The later
    gates of the same issue ask once.
@@ -62,16 +59,16 @@ For each open issue, oldest first:
 10. No open finding means approval: mark the pull request ready for review and
     set `status:done`. The merge stays with you, unless you pass `--merge`:
     then the harness squash-merges the pull request, deletes the remote
-    branch and waits for the checks that the merge commit starts on the base
-    branch. A cancelled run there is no failure. When those checks fail, the
-    fixer gets their logs on a branch reset to the base branch, from the check
-    budget, and the harness reopens the issue and opens a new pull request that
-    goes to step 6 again, with fresh review rounds. The next issue waits for
-    this, and a second ctrl-c stops only after it. The worktree, the local
-    branch and the state file go away. Without `--merge`, the remote branch
-    stays. A problem that the
-    reviewer leaves out of the findings thus gets an approval: only the findings
-    count.
+    branch, waits until the pull request is merged, for example through a
+    merge queue, and then waits for the checks that the merge commit starts on
+    the base branch. A cancelled run there is no failure. When those checks
+    fail, the fixer gets their logs on a branch reset to the base branch, from
+    the check budget, and the harness reopens the issue and opens a new pull
+    request that goes to step 6 again, with fresh review rounds. The next
+    issue waits for this, and a second ctrl-c stops only after it. The
+    worktree, the local branch and the state file go away. Without `--merge`,
+    the remote branch stays. A problem that the reviewer leaves out of the
+    findings thus gets an approval: only the findings count.
 11. With an open finding, run the fixer agent and go to step 6 again. The
     budget is `maxReviewRounds`. A fixer that holds every finding to be wrong
     changes nothing and gives its reason instead. The reason goes on the pull
@@ -103,6 +100,8 @@ when:
 - the reviewer gives no verdict, or the checks do not finish in time;
 - with `--merge`, the merge of an approved pull request fails, for example
    because branch protection asks for a human approval;
+- with `--merge`, a queued merge does not finish in `checkTimeoutMinutes`, or
+   the pull request closes without a merge;
 - with `--merge`, the checks on the base branch fail after the merge and the
    fixer cannot fix them, or they do not finish in time. The base branch is
    then broken, so the run stops after this issue;
@@ -152,15 +151,14 @@ and a `status:needs-human` pull request shows work that waits for a person.
 The harness runs all git and `gh` commands itself. The commit holds all the
 changes in the worktree, so a setup command that writes a file outside
 `.gitignore` puts that file in the commit. The reviewer is the one agent whose
-changes never get that far: the harness discards them before it reads the
-verdict.
+changes never get that far: the harness discards them, and undoes any commit
+that the reviewer made, before it reads the verdict.
 
 ## Safety
 
 Every agent can run a shell command. The implementer and the fixer run with the
 permission checks off; the reviewer runs with a smaller tool set, but its shell
-has no limit on the commands. pi has no permission checks, so with the `pi`
-agent the reviewer only runs without the `edit` and `write` tools. They all start in the worktree, but nothing holds
+has no limit on the commands. They all start in the worktree, but nothing holds
 them there: they can run any command, with your rights, anywhere on the machine.
 The prompt holds the title, the body and the comments of the issue, which come
 from GitHub.
@@ -215,7 +213,6 @@ Three levels of console output:
 - `gh`, authenticated with write access to the repository
 - Anthropic credentials for the Claude Agent SDK: `ANTHROPIC_API_KEY`, or a
   Claude subscription login
-- With the `pi` agent: `pi` on the `PATH`, set up with a model instead
 
 ## Configuration
 
@@ -236,7 +233,6 @@ does not know all stop the run, so a typo cannot pass without a word.
 
 ```json
 {
-  "agent": "claude",
   "remote": "origin",
   "issueLimit": 100,
   "maxCiFixes": 5,
@@ -270,7 +266,6 @@ does not know all stop the run, so a typo cannot pass without a word.
 
 | Field | Default | Effect |
 | --- | --- | --- |
-| `agent` | `claude` | The agent that does the work: `claude` or `pi` |
 | `remote` | `origin` | The git remote for the repository and the branches |
 | `issueLimit` | `100` | The maximum number of open issues to read |
 | `maxCiFixes` | `5` | The budget for check fixes per issue |
@@ -299,22 +294,6 @@ The log gives the reason for a skipped issue as `stop-label`, `not-ready`,
 A role set to `null`, or with no entry in `models`, uses the default model of
 the agent.
 
-## The pi agent
-
-With `"agent": "pi"` or `--agent pi`, each agent call runs `pi --mode json` in
-the worktree with the prompt on standard input. pi loads your own settings,
-extensions, skills and context files, as it does when you run it yourself. The
-flag wins over the config file.
-
-- The implementer and the fixer use your default pi tools.
-- The reviewer runs with `--tools -edit,-write`, so it keeps `bash`.
-- A model in `models` goes to `pi --model` as it is, so use a name that pi
-  knows.
-- pi has no structured output, so the reviewer is asked to end its reply with
-  a JSON verdict. A reply with no valid verdict hands the issue to a person.
-- A run fails when its last reply ends with an error, when pi exits with an
-  error, or when pi stops before the run settles.
-
 Without a `setupCommand`, the harness looks in the new worktree for a lock file
 and runs the install command that goes with it:
 
@@ -340,7 +319,8 @@ A `setupCommand` that fails, or that does not finish in `setupTimeoutMinutes`,
 hands the issue to a person. The wait for the checks has its own limit, so
 `commandTimeoutMinutes` holds for every other `git` and `gh` command. State per
 issue goes to `.next-issue/<issue>.json`, so a new run continues where the last
-run stopped.
+run stopped. A state file that is not valid JSON gives the issue an `error`
+outcome that names the file, rather than a silent skip.
 
 ## Retry an issue that waits for a person
 
@@ -361,7 +341,6 @@ that a label still holds back stays as it was.
 | `--force` | Replace an existing config file, with `init` |
 | `--once` | Stop after the first handled issue |
 | `--max <n>` | Handle at most n issues |
-| `--agent <a>` | Run the agents with `claude` or `pi`, whatever the config file says |
 | `--merge` | Squash-merge the pull request after the approval, delete the remote branch and fix a failure of the checks on the base branch |
 | `--reset` | Drop the saved budgets and findings, and keep the rest of the state |
 | `--json` | Print the machine summary instead of the text one |
@@ -396,6 +375,7 @@ The workflow then bumps the version and publishes the package to npm with a
 [trusted publish](https://docs.npmjs.com/trusted-publishers), so no token is
 stored. Only after the publish does it push the tag and make the GitHub release,
 so a failed publish leaves no half-release behind. A manual run of the workflow
-publishes the version in `package.json` and changes nothing else, which repairs
-a release that reached GitHub but not npm. The release job stays on a
-GitHub runner, because npm takes provenance only from a GitHub runner.
+checks out the last tag and publishes that commit under the tag version, and
+changes nothing else. This repairs a release that reached GitHub but not npm.
+The release job stays on a GitHub runner, because npm takes provenance only
+from a GitHub runner.

package/dist/agents.mjs

@@ -1,12 +1,12 @@
 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 { emptyUsage } from "./observe.mjs";
-import { runPi } from "./pi.mjs";
 const REVIEWING = {
     tools: ["Read", "Grep", "Glob", "Bash"],
     permissionMode: "dontAsk",
-    piTools: "-edit,-write",
 };
 const CODING = {
     tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
@@ -14,10 +14,9 @@ const CODING = {
     allowDangerouslySkipPermissions: true,
 };
 export { CODING, REVIEWING };
+const STDERR_TAIL = 2000;
+const STDERR_GRACE_MS = 500;
 export async function runAgent(recorder, request) {
-    if (request.agent === "pi") {
-        return runPi(recorder, request);
-    }
     const log = recorder.scope({ role: request.name });
     const usage = emptyUsage();
     const toolNames = new Map();
@@ -28,6 +27,8 @@ export async function runAgent(recorder, request) {
     let model = request.model;
     let sessionId;
     let structured;
+    let stderr = "";
+    let stderrClosed = Promise.resolve();
     const started = Date.now();
     log.event("agent.start", { model: request.model, timeoutMs: request.timeoutMs }, "normal");
     const controller = new AbortController();
@@ -47,7 +48,14 @@ export async function runAgent(recorder, request) {
                 allowDangerouslySkipPermissions: request.profile.allowDangerouslySkipPermissions,
                 systemPrompt: { type: "preset", preset: "claude_code" },
                 abortController: controller,
-                spawnClaudeCodeProcess: spawnClaude,
+                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 },
@@ -106,7 +114,11 @@ export async function runAgent(recorder, request) {
         }
     }
     catch (error) {
-        throw controller.signal.aborted ? late() : error;
+        if (controller.signal.aborted) {
+            throw late();
+        }
+        await Promise.race([stderrClosed, delay(STDERR_GRACE_MS, undefined, { ref: false })]);
+        throw withStderr(error, stderr);
     }
     finally {
         clearTimeout(timer);
@@ -146,20 +158,29 @@ function main(models) {
     return name;
 }
 export function toolFields(name, input) {
-    if ((name !== "Bash" && 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 spawnClaude(options) {
+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", "ignore"],
+        stdio: ["pipe", "pipe", "pipe"],
     });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", onStderr);
     track(child);
     return child;
 }

package/dist/args.mjs

@@ -1,11 +1,10 @@
-import { AGENT_NAMES, CONFIG_FILE } from "./config.mjs";
+import { CONFIG_FILE } from "./config.mjs";
 export const USAGE = `next-issue [command] [options]
 
   init         write ${CONFIG_FILE} with the defaults
 
   --once       stop after the first handled issue
   --max <n>    handle at most n issues
-  --agent <a>  run the agents with claude or pi
   --merge      squash-merge the pull request after the approval
   --reset      drop the saved budgets and findings first
   --json       print the machine summary instead of the text one
@@ -57,13 +56,6 @@ export function parseArgs(argv) {
         else if (arg === "--quiet") {
             args.level = "quiet";
         }
-        else if (arg === "--agent") {
-            const value = argv[++index];
-            if (value === undefined || !AGENT_NAMES.includes(value)) {
-                throw new Error("--agent needs claude or pi");
-            }
-            args.agent = value;
-        }
         else if (arg === "--max") {
             args.max = whole(argv[++index], arg);
         }

package/dist/cli.mjs

@@ -29,7 +29,6 @@ async function main() {
         return init(root, args.force);
     }
     const config = await loadConfig(root);
-    config.agent = args.agent ?? config.agent;
     setDefaultTimeout(config.commandTimeoutMinutes * 60_000);
     const repo = await detectRepo(root, config.remote);
     const recorder = await Recorder.create(repo.root, args.level);

package/dist/config.mjs

@@ -1,9 +1,7 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { message } from "./observe.mjs";
-export const AGENT_NAMES = ["claude", "pi"];
 const DEFAULTS = {
-    agent: "claude",
     remote: "origin",
     issueLimit: 100,
     maxCiFixes: 5,
@@ -95,12 +93,6 @@ function parseConfig(value) {
         }
     }
     const config = defaults();
-    if (file.agent !== undefined) {
-        if (typeof file.agent !== "string" || !AGENT_NAMES.includes(file.agent)) {
-            throw new Error(`${CONFIG_FILE}: agent must be claude or pi.`);
-        }
-        config.agent = file.agent;
-    }
     if (file.remote !== undefined) {
         config.remote = text(file.remote, "remote", false);
     }

package/dist/git.mjs

@@ -100,11 +100,11 @@ export async function commitAll(cwd, message) {
     await must("git", ["commit", "-m", message], { cwd });
     return true;
 }
-export async function discardChanges(cwd) {
-    if (!(await isDirty(cwd))) {
+export async function discardChanges(cwd, target) {
+    if (!(await isDirty(cwd)) && (await revision(cwd)) === target) {
         return false;
     }
-    await must("git", ["reset", "--hard", "HEAD"], { cwd });
+    await must("git", ["reset", "--hard", target], { cwd });
     await must("git", ["clean", "-fd"], { cwd });
     return true;
 }

package/dist/github.mjs

@@ -168,7 +168,11 @@ async function watchOnce(repo, branch, intervalSeconds, timeoutMs, show) {
     if (watch.code === CHECK_PENDING_CODE) {
         return "pending";
     }
-    return "fail";
+    const checks = await readChecks(repo, branch);
+    if (checks !== "none" && checks.some((check) => check.bucket === "fail")) {
+        return "fail";
+    }
+    throw new Error(`gh pr checks ${branch} --watch failed with code ${watch.code} and no check failed: ${watch.stderr.trim()}`);
 }
 const REAL_CLOCK = {
     now: () => Date.now(),
@@ -293,8 +297,20 @@ export async function mergePr(repo, pr) {
     const result = await run("gh", ["pr", "merge", String(pr), "--squash", "--delete-branch", "--repo", slug(repo)], { cwd: repo.root });
     return result.code === 0;
 }
-export async function mergeCommit(repo, pr) {
-    return gh(repo, ["pr", "view", String(pr), "--json", "mergeCommit", "--jq", ".mergeCommit.oid"]);
+export async function mergeCommit(repo, pr, options, clock = REAL_CLOCK) {
+    const deadline = clock.now() + options.timeoutMs;
+    for (;;) {
+        const raw = await gh(repo, ["pr", "view", String(pr), "--json", "state,mergeCommit"]);
+        const view = JSON.parse(raw);
+        if (view.state === "MERGED" && view.mergeCommit?.oid) {
+            return view.mergeCommit.oid;
+        }
+        const rest = deadline - clock.now();
+        if (view.state === "CLOSED" || rest <= 0) {
+            return undefined;
+        }
+        await clock.sleep(Math.min(options.intervalSeconds * 1000, rest));
+    }
 }
 export async function reopenIssue(repo, issue) {
     await gh(repo, ["issue", "reopen", String(issue)]);

package/dist/pipeline.mjs

@@ -58,7 +58,14 @@ export function skipReason(issue, config, resuming) {
 export async function processIssue(context, issue) {
     const started = Date.now();
     const log = context.recorder.scope({ issue: issue.number });
-    const saved = await readState(context.repo, issue.number);
+    let saved;
+    try {
+        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 };
+    }
     const skip = skipReason(issue, context.config, saved !== undefined);
     if (skip !== undefined) {
         log.event("issue.skip", { title: issue.title, reason: skip });
@@ -162,7 +169,6 @@ async function work(context, issue, log, state) {
             prompt: implementPrompt(issue, comments),
             profile: CODING,
             model: config.models.implementer,
-            agent: config.agent,
             timeoutMs: config.agentTimeoutMinutes * 60_000,
         }));
         const subject = parseCommitSubject(result.text, `fix: resolve issue #${issue.number}`);
@@ -205,7 +211,7 @@ async function openPr(job) {
     const pr = await log.step("pull-request", { branch }, async () => {
         const existing = await ports.findPr(repo, branch);
         return (existing ??
-            ports.createPr(repo, branch, context.base, issue.title, `Closes #${issue.number}\n\nOpened by next-issue.`, config.draftPullRequest));
+            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);
@@ -270,17 +276,17 @@ async function reviewRound(job) {
         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,
-        agent: config.agent,
         timeoutMs: config.agentTimeoutMinutes * 60_000,
         outputSchema: VERDICT_SCHEMA,
     }));
-    if (await ports.discardChanges(worktree)) {
+    if (await ports.discardChanges(worktree, before)) {
         log.event("review.discard", { round: state.reviewRounds }, "quiet");
     }
     const verdict = readVerdict(review.structured);
@@ -353,7 +359,14 @@ async function reviewRound(job) {
 async function watchBase(job) {
     const { context, issue, log, state, worktree } = job;
     const { repo, config, ports } = context;
-    const sha = await ports.mergeCommit(repo, state.pr);
+    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,
@@ -440,7 +453,6 @@ async function fixRound(job, reason, detail, earlier, kind) {
         prompt: fixPrompt(issue, reason, detail, earlier, kind),
         profile: CODING,
         model: context.config.models.fixer,
-        agent: context.config.agent,
         timeoutMs: context.config.agentTimeoutMinutes * 60_000,
     }));
     const unrelated = parseUnrelated(result.text);
@@ -465,7 +477,11 @@ async function commitWork(job, before, subject, role) {
             if (await ports.commitAll(worktree, `${subject}\n\nRefs #${issue.number}`)) {
                 log.event("commit", { subject });
             }
-            return (await ports.revision(worktree)) !== before;
+            if ((await ports.revision(worktree)) === before) {
+                return false;
+            }
+            state.title = subject;
+            return true;
         }
         catch (error) {
             const used = state.commitFixes ?? 0;
@@ -476,15 +492,15 @@ async function commitWork(job, before, subject, role) {
             await writeState(repo, state);
             const output = message(error).slice(-config.logMaxChars);
             log.event("commit.fail", { role, output }, "quiet");
-            await log.step("commit-fix", { role }, () => ports.runAgent(log, {
+            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],
-                agent: config.agent,
                 timeoutMs: config.agentTimeoutMinutes * 60_000,
             }));
+            subject = parseCommitSubject(fix.text, subject);
         }
     }
 }

package/dist/prompts.mjs

@@ -95,12 +95,12 @@ export function fixPrompt(issue, reason, detail, earlier, kind) {
         .join("\n\n");
 }
 export function parseUnrelated(text) {
-    const match = /^unrelated:\s*(.+)$/im.exec(text);
+    const match = [...text.matchAll(/^unrelated:\s*(.+)$/gim)].at(-1);
     const note = match?.[1]?.trim();
     return note !== undefined && note.length > 0 ? note : undefined;
 }
 export function parseCommitSubject(text, fallback) {
-    const match = /^commit:\s*(.+)$/im.exec(text);
+    const match = [...text.matchAll(/^commit:\s*(.+)$/gim)].at(-1);
     const subject = match?.[1]
         ?.trim()
         .replace(/^`+|`+$/g, "")

package/dist/state.mjs

@@ -8,11 +8,22 @@ function file(repo, issue) {
     return join(dir(repo), `${issue}.json`);
 }
 export async function readState(repo, issue) {
+    const path = file(repo, issue);
+    let text;
     try {
-        return JSON.parse(await readFile(file(repo, issue), "utf8"));
+        text = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+    try {
+        return JSON.parse(text);
     }
     catch {
-        return undefined;
+        throw new Error(`the state file ${path} is not valid JSON`);
     }
 }
 export function resetState(state) {

package/package.json

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

package/dist/pi.mjs

@@ -1,159 +0,0 @@
-import { toolFields } from "./agents.mjs";
-import { run } from "./exec.mjs";
-import { emptyUsage } from "./observe.mjs";
-const NO_LIMIT = 2 ** 31 - 1;
-const OUTPUT_TAIL = 200_000;
-export async function runPi(recorder, request) {
-    const log = recorder.scope({ role: request.name });
-    const usage = emptyUsage();
-    let text = "";
-    let toolCalls = 0;
-    let turns = 0;
-    let costUsd = 0;
-    let model = request.model;
-    let sessionId;
-    let settled = false;
-    let last;
-    const read = (line) => {
-        let event;
-        try {
-            event = JSON.parse(line);
-        }
-        catch {
-            return;
-        }
-        if (event.type === "session") {
-            sessionId = event.id;
-        }
-        else if (event.type === "message_end" && event.message?.role === "assistant") {
-            const message = event.message;
-            last = message;
-            turns += 1;
-            model = message.model ?? model;
-            const input = message.usage?.input ?? 0;
-            const output = message.usage?.output ?? 0;
-            const cacheRead = message.usage?.cacheRead ?? 0;
-            const cacheWrite = message.usage?.cacheWrite ?? 0;
-            usage.input += input;
-            usage.output += output;
-            usage.cacheRead += cacheRead;
-            usage.cacheWrite += cacheWrite;
-            usage.total += input + output + cacheRead + cacheWrite;
-            costUsd += message.usage?.cost?.total ?? 0;
-            const said = textOf(message.content);
-            if (said.length > 0) {
-                text = said;
-                if (log.level === "verbose") {
-                    process.stderr.write(said);
-                }
-            }
-        }
-        else if (event.type === "tool_execution_start") {
-            toolCalls += 1;
-            log.event("tool", toolFields(event.toolName ?? "unknown", event.args));
-        }
-        else if (event.type === "tool_execution_end" && event.isError === true) {
-            log.event("tool.error", { tool: event.toolName }, "quiet");
-        }
-        else if (event.type === "agent_settled") {
-            settled = true;
-        }
-    };
-    const started = Date.now();
-    log.event("agent.start", { model: request.model, timeoutMs: request.timeoutMs, agent: "pi" }, "normal");
-    let rest = "";
-    const result = await run("pi", piArgs(request), {
-        cwd: request.cwd,
-        input: piPrompt(request),
-        timeoutMs: request.timeoutMs ?? NO_LIMIT,
-        tailChars: OUTPUT_TAIL,
-        onStdout: (chunk) => {
-            rest += chunk;
-            let end = rest.indexOf("\n");
-            while (end !== -1) {
-                read(rest.slice(0, end).replace(/\r$/, ""));
-                rest = rest.slice(end + 1);
-                end = rest.indexOf("\n");
-            }
-        },
-    });
-    if (rest.length > 0) {
-        read(rest);
-    }
-    const failed = (reason) => new Error(`The ${request.name} agent failed: ${reason}`);
-    if (result.timedOut) {
-        throw new Error(`The ${request.name} agent did not finish in ${request.timeoutMs} ms.`);
-    }
-    if (last?.stopReason === "error" || last?.stopReason === "aborted") {
-        throw failed(last.errorMessage ?? last.stopReason);
-    }
-    if (result.code !== 0) {
-        throw failed(`pi exited with code ${result.code}: ${result.stderr.trim()}`);
-    }
-    if (!settled) {
-        throw failed("pi stopped before the run settled");
-    }
-    if (last?.stopReason === "length") {
-        log.event("agent.incomplete", { subtype: "length" }, "quiet");
-    }
-    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: request.outputSchema === undefined ? undefined : jsonOf(text),
-    };
-}
-function piArgs(request) {
-    return [
-        "--mode",
-        "json",
-        ...(request.model === undefined ? [] : ["--model", request.model]),
-        ...(request.profile.piTools === undefined ? [] : ["--tools", request.profile.piTools]),
-    ];
-}
-function piPrompt(request) {
-    if (request.outputSchema === undefined) {
-        return request.prompt;
-    }
-    return [
-        request.prompt,
-        "",
-        "End your reply with only a JSON object in a json code block. The object must match this JSON schema:",
-        JSON.stringify(request.outputSchema),
-    ].join("\n");
-}
-function textOf(content) {
-    if (typeof content === "string") {
-        return content;
-    }
-    if (!Array.isArray(content)) {
-        return "";
-    }
-    return content
-        .filter((block) => block?.type === "text" && typeof block.text === "string")
-        .map((block) => block.text)
-        .join("");
-}
-function jsonOf(text) {
-    const fenced = [...text.matchAll(/```(?:json)?[ \t]*\n([\s\S]*?)```/g)].at(-1)?.[1];
-    const candidate = fenced ?? text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1);
-    try {
-        return JSON.parse(candidate);
-    }
-    catch {
-        return undefined;
-    }
-}