bugpatrol 0.2.1 → 0.3.0

package/dist/bin.js

@@ -948,6 +948,7 @@ var paths = {
   issue: (root2, id2) => data(root2, "issues", `${recordId(id2)}.json`),
   fixes: (root2) => data(root2, "fixes"),
   fix: (root2, id2) => data(root2, "fixes", `${recordId(id2)}.json`),
+  fixAttemptDiff: (root2, id2, n) => data(root2, "fixes", recordId(id2), `attempt-${n}.diff`),
   publish: (root2) => data(root2, "publish"),
   review: (root2, pr) => data(root2, "reviews", `pr-${pr}.json`),
   /** What one review keeps besides its record: the claim routines and their replays. Nothing else reads it. */
@@ -973,9 +974,8 @@ function findProjectRoot(start) {
 }
 function instructionsPath(root2, configured) {
   if (configured)
-    return resolve(root2, configured);
-  const fallback = join(dir(root2), "instructions.md");
-  return existsSync(fallback) ? fallback : void 0;
+    return { path: resolve(root2, configured), required: true };
+  return { path: join(dir(root2), "instructions.md"), required: false };
 }
 function legacyLayout(root2) {
   if (!existsSync(join(root2, LEGACY_CONFIG_FILENAME)))
@@ -1178,7 +1178,6 @@ var InfrastructureError = class extends BugpatrolError {
 
 // ../core/dist/config/schema.js
 import { z } from "zod";
-var secretRefString = z.string().describe("A ${ENV_VAR} reference. Never a literal credential (spec 11.4).");
 var viewportSchema = z.object({
   name: z.string(),
   width: z.number().int().positive(),
@@ -1196,27 +1195,6 @@ var runSchema = z.object({
   }).default({}),
   seeds: z.array(z.string()).default([])
 });
-var authSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("none") }),
-  z.object({
-    kind: z.literal("form"),
-    loginUrl: z.string(),
-    credentials: secretRefString.optional(),
-    steps: z.array(actionSchema).default([])
-  }),
-  z.object({ kind: z.literal("storageState"), path: z.string(), expiresAt: z.string().optional() }),
-  z.object({
-    kind: z.literal("seededUser"),
-    seedCommand: z.string(),
-    credentials: secretRefString.optional()
-  }),
-  z.object({
-    kind: z.literal("ssoBypass"),
-    header: z.string().optional(),
-    token: secretRefString.optional()
-  }),
-  z.object({ kind: z.literal("manual"), path: z.string() })
-]);
 var maskSchema = z.object({
   selector: z.string(),
   screen: z.string().optional(),
@@ -1445,12 +1423,18 @@ var agentsSchema = z.object({
     enabled: z.boolean().default(false),
     /** Run after the change; a non-zero exit marks the fix failed. */
     verify: z.string().optional(),
+    /**
+     * Fix attempts on one issue before the fixer gives up on it: first
+     * fixes, reruns after a failure, and refixes. CI fixes have their own
+     * limit. `bugpatrol fix --issue` still runs an issue at the limit.
+     */
+    attempts: z.number().int().positive().default(3),
     /** After a fix, start the app from the fix worktree and repeat the issue's flow. */
     retest: z.object({
       enabled: z.boolean().default(true),
       /** Shell command run in the worktree before the app starts, e.g. `bun install`. */
       prepare: z.string().optional(),
-      /** Fix attempts in total; each attempt after the first gets the last verdict as feedback. */
+      /** Retest verdicts in total; a not-fixed verdict gets a refix with the verdict as feedback. */
       attempts: z.number().int().positive().default(2),
       maxSteps: z.number().int().positive().default(30),
       budgetUsd: z.number().nonnegative().optional()
@@ -1484,6 +1468,12 @@ var agentsSchema = z.object({
   }).default({}),
   /** `bugpatrol review <pr>`. */
   review: z.object({
+    /**
+     * Tells this review apart from another Bugpatrol review of the same pull
+     * request, for example one per app of a monorepo. Each name keeps its own
+     * review and its own check run, and never replaces the other's.
+     */
+    name: z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "Use lowercase letters, digits and dashes").optional(),
     /** The claim check: test what the pull request says it does. Off until a team opts in. */
     claims: z.boolean().default(false),
     /**
@@ -1538,7 +1528,14 @@ var bugpatrolConfigSchema = z.object({
   run: runSchema.optional(),
   app: appSchema,
   agents: agentsSchema,
-  auth: authSchema.default({ kind: "none" }),
+  /** Never read. Accept the `kind: none` older `init` wrote; reject a login flow instead of ignoring it. */
+  auth: z.object({
+    kind: z.literal("none", {
+      errorMap: () => ({
+        message: "Bugpatrol does not read `auth`. Sign in through `app.setup` and `app.instructions`."
+      })
+    })
+  }).optional(),
   viewports: z.array(viewportSchema).min(1).default([
     { name: "desktop", width: 1440, height: 900, deviceScaleFactor: 1 },
     { name: "mobile", width: 390, height: 844, deviceScaleFactor: 1 }
@@ -1606,9 +1603,28 @@ function requireRun(config) {
 }
 
 // ../core/dist/types/agents.js
+var LESSON_MAX_LENGTH = 200;
+function fitLesson(text3) {
+  const trimmed = text3.trim();
+  if (trimmed.length <= LESSON_MAX_LENGTH)
+    return trimmed;
+  const space = trimmed.lastIndexOf(" ", LESSON_MAX_LENGTH - 1);
+  return `${trimmed.slice(0, space > 0 ? space : LESSON_MAX_LENGTH - 1).trimEnd()}\u2026`;
+}
+function lessonTooLong(text3) {
+  const length = text3.trim().length;
+  if (length > LESSON_MAX_LENGTH)
+    return `The lesson has ${length} characters, and the limit is ${LESSON_MAX_LENGTH}. Nothing was saved. Write it shorter.`;
+}
 function judgedRetests(retests = []) {
   return retests.filter((retest) => retest.outcome !== "error" && retest.outcome !== "skipped");
 }
+function fixerAttempts(attempts = []) {
+  return attempts.filter((attempt) => attempt.kind !== "ci");
+}
+function ciAttempts(attempts = []) {
+  return attempts.filter((attempt) => attempt.kind === "ci");
+}
 
 // ../core/dist/types/ids.js
 var id = {
@@ -2345,6 +2361,18 @@ function firstLine(text3) {
   const line = text3.split("\n").find((item) => item.trim()) ?? "";
   return line.length > 160 ? `${line.slice(0, 157)}...` : line;
 }
+function tell(messages, text3) {
+  const last = messages.at(-1);
+  if (last?.role === "user" && typeof last.content === "string") {
+    last.content = `${last.content}
+
+${text3}`;
+  } else if (last?.role === "user" && Array.isArray(last.content)) {
+    last.content.push({ type: "text", text: text3 });
+  } else {
+    messages.push({ role: "user", content: text3 });
+  }
+}
 function textOf(result3) {
   return result3.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
 }
@@ -2373,14 +2401,17 @@ function prune(messages) {
     }
   }
 }
+var REQUEST_TIMEOUT_MS = 4 * 60 * 1e3;
 var ModelRuntime = class {
   use;
   label;
   request;
+  requestTimeoutMs;
   constructor(use, options = {}) {
     this.use = use;
     this.label = `model:${use.via}/${use.model}`;
     this.request = options.fetch ?? fetch;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
   }
   async run(task, emit) {
     const keyName = MODEL_KEYS[this.use.via];
@@ -2403,6 +2434,7 @@ var ModelRuntime = class {
     let costUsd = 0;
     let lastText = "";
     let textOnly = 0;
+    let handBack;
     const outcome = (stop, summary, error) => ({
       stop,
       steps,
@@ -2410,12 +2442,21 @@ var ModelRuntime = class {
       summary,
       error
     });
-    while (steps < task.maxSteps) {
+    for (; ; ) {
+      if (steps >= task.maxSteps) {
+        const finish = task.tools.filter((tool) => tool.name.startsWith("finish"));
+        if (handBack || !finish.length) {
+          return outcome("max-steps", lastText);
+        }
+        handBack = { ...task, tools: finish };
+        tell(messages, "Your steps are used. Call finish now with what you did and what you did not reach.");
+      }
+      const current = handBack ?? task;
       if (Date.now() - started >= task.timeoutMs) {
         return outcome("timeout", lastText);
       }
       prune(messages);
-      const body2 = requestBody(this.use, task, messages, anthropic);
+      const body2 = requestBody(this.use, current, messages, anthropic);
       let payload;
       try {
         payload = await this.call(endpoint, apiKey, anthropic, body2, deadline);
@@ -2442,22 +2483,21 @@ var ModelRuntime = class {
         if (textOnly >= 3) {
           return outcome("done", lastText);
         }
-        messages.push({ role: "user", content: "Call one of the tools. Call finish when you are done." });
+        tell(messages, "Call one of the tools. Call finish when you are done.");
       } else {
         textOnly = 0;
-        const calls = await this.runCalls(task, parsed.calls, emit, messages, anthropic, deadline, stepCost, step);
+        const calls = await this.runCalls(current, parsed.calls, emit, messages, anthropic, deadline, stepCost, step);
         if (calls.timeout) {
           return outcome("timeout", lastText);
         }
         if (calls.done) {
-          return outcome("done", calls.output);
+          return { ...outcome(handBack ? "max-steps" : "done", calls.output), finished: true };
         }
       }
       if (task.budgetUsd !== void 0 && costUsd >= task.budgetUsd) {
         return outcome("budget", lastText);
       }
     }
-    return outcome("max-steps", lastText);
   }
   async runCalls(task, calls, emit, messages, anthropic, deadline, stepCost, step) {
     const anthroResults = [];
@@ -2541,7 +2581,12 @@ var ModelRuntime = class {
   async call(endpoint, apiKey, anthropic, body2, deadline) {
     for (let attempt = 0; attempt < 3; attempt++) {
       const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), Math.max(1, deadline - Date.now()));
+      const left = Math.max(1, deadline - Date.now());
+      let stalled = false;
+      const timer = setTimeout(() => {
+        stalled = this.requestTimeoutMs < left;
+        controller.abort();
+      }, Math.min(left, this.requestTimeoutMs));
       try {
         const response7 = await this.request(endpoint, {
           method: "POST",
@@ -2559,7 +2604,7 @@ var ModelRuntime = class {
           throw new Error(`Model returned ${response7.status}`);
         }
       } catch (error) {
-        if (attempt === 2 || error instanceof Error && (/^Model returned 4(?!29)/.test(error.message) || error.name === "AbortError")) {
+        if (attempt === 2 || error instanceof Error && (/^Model returned 4(?!29)/.test(error.message) || error.name === "AbortError" && !stalled)) {
           throw error;
         }
       } finally {
@@ -2634,6 +2679,7 @@ var CliRuntime = class {
   async run(task, emit) {
     const temp = await mkdtemp(join3(tmpdir(), "bugpatrol-agent-"));
     let summary = "";
+    let finished = false;
     let steps = 0;
     let stderr = "";
     let stdout = "";
@@ -2677,6 +2723,7 @@ var CliRuntime = class {
         });
         if (result3.done) {
           summary = output2;
+          finished = true;
         }
       }
     });
@@ -2761,7 +2808,8 @@ ${task.prompt}`;
           stop: "timeout",
           steps,
           costUsd: 0,
-          summary: summary || text3
+          summary: summary || text3,
+          finished
         };
       }
       if (code !== 0 || inputError) {
@@ -2776,7 +2824,8 @@ ${task.prompt}`;
         stop: "done",
         steps,
         costUsd: 0,
-        summary: summary || text3
+        summary: summary || text3,
+        finished
       };
     } finally {
       await mcp.close();
@@ -2922,17 +2971,17 @@ function boundingRegions(pixels, gridPx = 32) {
   const cells = /* @__PURE__ */ new Map();
   for (const p of pixels) {
     const key = `${Math.floor(p.x / gridPx)},${Math.floor(p.y / gridPx)}`;
-    const cell = cells.get(key);
-    if (!cell) {
+    const cell2 = cells.get(key);
+    if (!cell2) {
       cells.set(key, { x: p.x, y: p.y, width: 1, height: 1 });
       continue;
     }
-    const right = Math.max(cell.x + cell.width, p.x + 1);
-    const bottom = Math.max(cell.y + cell.height, p.y + 1);
-    cell.x = Math.min(cell.x, p.x);
-    cell.y = Math.min(cell.y, p.y);
-    cell.width = right - cell.x;
-    cell.height = bottom - cell.y;
+    const right = Math.max(cell2.x + cell2.width, p.x + 1);
+    const bottom = Math.max(cell2.y + cell2.height, p.y + 1);
+    cell2.x = Math.min(cell2.x, p.x);
+    cell2.y = Math.min(cell2.y, p.y);
+    cell2.width = right - cell2.x;
+    cell2.height = bottom - cell2.y;
   }
   return [...cells.values()].sort((a, b) => a.y - b.y || a.x - b.x);
 }
@@ -3826,14 +3875,14 @@ function severityRank(s) {
 // ../agents/dist/github.js
 import { execFile as execFile3 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { mkdtemp as mkdtemp2, readFile as readFile3, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdtemp as mkdtemp2, readFile as readFile3, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
 import { basename as basename3, join as join7, resolve as resolve3 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // ../agents/dist/roles/fixer.js
 import { execFile as execFile2 } from "node:child_process";
-import { lstat, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, realpath, symlink, writeFile as writeFile3 } from "node:fs/promises";
+import { lstat, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, realpath, rm as rm2, symlink, writeFile as writeFile3 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname2, join as join6, relative as relative3, resolve as resolve2, sep } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
@@ -3961,7 +4010,9 @@ Find the problems that this pull request causes, before it merges.
 
 YOUR JOB, IN ORDER
 1. Read the pull request and its diff in the prompt. Work out which screens and flows the change can affect:
-   the screens that the changed files render, and the flows that use the changed logic.
+   the screens that the changed files render, and the flows that use the changed logic. If the app does not
+   render or run any changed file (a change to tests, CI, docs, or code outside the app), call finish at once
+   and say so in untested. Do not look for a screen that the change cannot reach.
 2. Enter the app. If the routine "enter-app" is known, use run_routine for it. To reach a known screen, use
    run_routine with its routine. A flow that starts from a routine is a flow that Bugpatrol can repeat.
 3. Test each affected screen and flow like a careful user. Use each control that the change touches. Try an
@@ -3970,7 +4021,9 @@ YOUR JOB, IN ORDER
    after a changed flow.
 5. Report each problem with report_bug as soon as you see it, with the problem on screen. Then continue.
 6. Do not test the rest of the app. Call finish when you tested what the change can affect, or when your steps
-   are almost gone. The summary names the screens and flows that you tested, and the ones that you did not reach.
+   are almost gone. In tested, name each screen or flow that you tested. In untested, name each one that the
+   change can affect and that you did not reach, with why. A developer scans these lines: one short line each,
+   such as "Rename a project from settings", not a paragraph.
 
 Report each problem that you see, also when it looks older than this pull request. Bugpatrol repeats the flow of
 each report on the base build, and the QA lead compares the two builds.
@@ -4340,7 +4393,7 @@ function lessonTools(session, role) {
   return [
     {
       name: "save_lesson",
-      description: 'Save one lasting fact about this app or its code for later sessions: one short, specific sentence. Use "for" to save it for another role (explorer, judge, or fixer). When a similar lesson exists, the tool shows it and saves nothing.',
+      description: `Save one lasting fact about this app or its code for later sessions: one short, specific sentence of at most ${LESSON_MAX_LENGTH} characters. Use "for" to save it for another role (explorer, judge, or fixer). When a similar lesson exists, the tool shows it and saves nothing.`,
       inputSchema: {
         type: "object",
         properties: {
@@ -4360,7 +4413,7 @@ function lessonTools(session, role) {
         if (saved >= memory.maxPerSession) {
           return { content: [{ type: "text", text: "The lesson limit for this session is reached." }] };
         }
-        const text3 = session.vars.redact(String(input.text ?? "")).trim().slice(0, 240);
+        const text3 = session.vars.redact(String(input.text ?? "")).trim();
         if (!text3)
           return { content: [{ type: "text", text: "The lesson needs a text." }], isError: true };
         const target = roles.includes(input.for) ? input.for : role;
@@ -4372,6 +4425,9 @@ function lessonTools(session, role) {
           ]);
           return { content: [{ type: "text", text: `Confirmed ${confirmed.id}. It has one more hit now.` }] };
         }
+        const tooLong = lessonTooLong(text3);
+        if (tooLong)
+          return { content: [{ type: "text", text: tooLong }], isError: true };
         const similar = input.different === true ? void 0 : similarLesson(lessons, target, text3);
         if (similar && similar.text.toLowerCase() !== text3.toLowerCase()) {
           return {
@@ -4448,7 +4504,7 @@ var Workspace = class {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const saved = [];
       for (const lesson of lessons) {
-        const text3 = lesson.text.trim().slice(0, 200);
+        const text3 = lesson.text.trim();
         if (!text3)
           continue;
         const id2 = `les_${shortHash(`${lesson.role}:${text3.toLowerCase().replace(/\s+/g, " ")}`)}`;
@@ -4583,6 +4639,20 @@ var Workspace = class {
   saveFix(value) {
     return atomic(paths.fix(this.root, value.id), value);
   }
+  async readFixAttemptDiff(id2, n) {
+    try {
+      return await readFile(paths.fixAttemptDiff(this.root, id2, n), "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return void 0;
+      throw error;
+    }
+  }
+  async saveFixAttemptDiff(id2, n, diff2) {
+    const file = paths.fixAttemptDiff(this.root, id2, n);
+    await mkdir(join5(file, ".."), { recursive: true });
+    await writeFile2(file, diff2);
+  }
   readReview(pr) {
     return readJson(paths.review(this.root, pr));
   }
@@ -4947,6 +5017,27 @@ async function linkEnvFiles(source, worktree) {
   }
   return linked;
 }
+async function change(worktree, source) {
+  await git(worktree, "add", "-A");
+  const base = await git(worktree, "merge-base", "HEAD", await git(source, "rev-parse", "HEAD"));
+  return {
+    diffStat: await git(worktree, "diff", "--cached", "--stat", base),
+    diff: await git(worktree, "diff", "--cached", base)
+  };
+}
+async function closeAttempt(workspace, fixId, attempt, worktree, source) {
+  attempt.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    await rm2(join6(worktree, LAST_DIFF), { force: true });
+    const { diffStat, diff: diff2 } = await change(worktree, source);
+    attempt.diffStat = diffStat || void 0;
+    if (diff2)
+      await workspace.saveFixAttemptDiff(fixId, attempt.n, `${diff2}
+`);
+  } catch (error) {
+    attempt.reason = `${attempt.reason ? `${attempt.reason} ` : ""}(The change could not be read: ${String(error).slice(0, 200)})`;
+  }
+}
 async function updateIssue(session, id2, patch) {
   const current = await session.workspace.readIssue(id2);
   if (!current || current.status === "dismissed")
@@ -4968,6 +5059,8 @@ async function runFixer(session, runtime, opts = {}) {
       return false;
     if (!opts.issueIds && (issue.fixRejected || fixes.some((fix) => fix.issueId === issue.id && fix.status === "rejected")))
       return false;
+    if (!opts.issueIds && fixerAttempts(fixes.find((fix) => fix.issueId === issue.id)?.attempts).length >= config.attempts)
+      return false;
     const pending = ["new", "filed"].includes(issue.status) || failed2.has(issue.id) || retry.has(issue.id);
     return pending && (!issue.fixId || failed2.has(issue.id) || retry.has(issue.id) || fixes.some((fix) => fix.issueId === issue.id && fix.worktreeRemovedAt) || opts.issueIds && fixes.some((fix) => fix.issueId === issue.id && fix.status === "rejected")) && ranks[issue.severity] >= ranks[config.minSeverity];
   });
@@ -4978,6 +5071,7 @@ async function runFixer(session, runtime, opts = {}) {
     if (session.cancelled)
       break;
     const oldFix = fixes.find((fix) => fix.issueId === issue.id);
+    const fixId = `fix_${issue.id}`;
     const baseBranch = `bugpatrol/fix-${issue.id}`;
     let branch = baseBranch;
     if (oldFix?.worktreeRemovedAt && (await branchExists(source, oldFix.branch) || await branchExists(source, baseBranch))) {
@@ -4995,7 +5089,18 @@ async function runFixer(session, runtime, opts = {}) {
     } catch {
       await git(source, "worktree", "add", "-b", branch, worktree, "HEAD");
     }
-    if (existing && failed2.has(issue.id)) {
+    const earlier = (oldFix?.attempts ?? []).map((item) => ({ ...item }));
+    const unfinished2 = earlier.at(-1);
+    if (unfinished2 && !unfinished2.outcome) {
+      unfinished2.outcome = "abandoned";
+      unfinished2.reason = "The fixer was stopped before it finished.";
+      if (existing)
+        await closeAttempt(session.workspace, fixId, unfinished2, worktree, source);
+      else
+        unfinished2.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    const start = !existing ? "clean" : !failed2.has(issue.id) ? "continue" : earlier.at(-1)?.outcome === "verify-failed" ? "repair" : "clean";
+    if (existing && start === "clean") {
       const base = await git(worktree, "merge-base", "HEAD", await git(source, "rev-parse", "HEAD"));
       await git(worktree, "reset", "--hard", base);
       await git(worktree, "clean", "-fd");
@@ -5017,10 +5122,16 @@ async function runFixer(session, runtime, opts = {}) {
       }
     }
     const previous = retry.get(issue.id);
+    const attempt = {
+      n: (earlier.at(-1)?.n ?? 0) + 1,
+      kind: previous ? "refix" : earlier.length || failed2.has(issue.id) ? "rerun" : "first",
+      sessionId: session.sessionId,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
     const proposal = {
       ...previous,
       version: 1,
-      id: `fix_${issue.id}`,
+      id: fixId,
       issueId: issue.id,
       status: "running",
       runtime: runtime.label,
@@ -5030,96 +5141,102 @@ async function runFixer(session, runtime, opts = {}) {
       worktreeRemovedAt: void 0,
       ...oldFix?.worktreeRemovedAt ? { pr: void 0, commit: void 0 } : {},
       startedAt: previous?.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-      error: void 0
+      error: void 0,
+      attempts: [...earlier, attempt]
     };
     await session.workspace.saveFix(proposal);
     await session.workspace.saveIssue({ ...issue, status: "fixing" });
     session.emit({ kind: "fix", summary: `Fixing ${issue.title}` });
     try {
-      const outcome = await runOne(session, runtime, issue, worktree, previous?.retests?.at(-1));
+      const outcome = await runOne(session, runtime, issue, worktree, previous?.retests?.at(-1), { earlier, start });
+      attempt.costUsd = outcome.costUsd;
       if (outcome.stop !== "done") {
+        attempt.outcome = outcome.stop === "timeout" ? "timeout" : "error";
         throw new Error(outcome.error ?? `Fixer stopped: ${outcome.stop}`);
       }
       proposal.costUsd = (previous?.costUsd ?? 0) + outcome.costUsd;
       proposal.summary = outcome.summary;
+      attempt.reason = outcome.summary;
       await git(worktree, "add", "-A");
       const newDiff = await git(worktree, "diff", "--cached");
-      const sourceHead = await git(source, "rev-parse", "HEAD");
-      const base = await git(worktree, "merge-base", "HEAD", sourceHead);
-      proposal.diffStat = await git(worktree, "diff", "--cached", "--stat", base);
-      proposal.diff = Buffer.from(await git(worktree, "diff", "--cached", base)).subarray(0, 2e5).toString("utf8");
+      Object.assign(proposal, await change(worktree, source));
+      proposal.diff = Buffer.from(proposal.diff ?? "").subarray(0, 2e5).toString("utf8");
       if (!newDiff && previous) {
+        attempt.outcome = "no-change";
         proposal.status = "proposed";
-        proposal.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await session.workspace.saveFix(proposal);
         await updateIssue(session, issue.id, { status: "fix-proposed", fixId: proposal.id });
-        proposals.push(proposal);
-        continue;
-      }
-      if (!newDiff) {
+      } else if (!newDiff) {
         proposal.status = outcome.summary ? "declined" : "failed";
+        attempt.outcome = outcome.summary ? "declined" : "no-change";
         if (proposal.status === "declined")
           await session.workspace.upsertLessons([
             {
               role: "judge",
               source: "fixer-decline",
               scope: issue.screenId,
-              text: `Likely by design: ${issue.title} \u2014 ${outcome.summary?.split(/(?<=[.!?])\s/)[0] ?? ""}`.slice(0, 200)
+              text: fitLesson(`Likely by design: ${issue.title} \u2014 ${outcome.summary?.split(/(?<=[.!?])\s/)[0] ?? ""}`)
             }
           ]);
         if (!outcome.summary)
           proposal.error = "The fixer made no change and gave no reason.";
         await updateIssue(session, issue.id, { status: issue.status });
-        proposal.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await session.workspace.saveFix(proposal);
-        proposals.push(proposal);
-        continue;
-      }
-      if (config.verify) {
-        try {
-          await exec2("/bin/sh", ["-c", config.verify], {
-            cwd: worktree,
-            timeout: 3e5,
-            maxBuffer: 4 * 1024 * 1024
-          });
-        } catch (error) {
-          const output2 = error;
-          const last = (output2.stderr || output2.stdout || output2.message).trim().split("\n").at(-1) ?? "unknown error";
+      } else {
+        if (config.verify) {
+          try {
+            await exec2("/bin/sh", ["-c", config.verify], {
+              cwd: worktree,
+              timeout: 3e5,
+              maxBuffer: 4 * 1024 * 1024
+            });
+          } catch (error) {
+            const output2 = error;
+            const text3 = `${output2.stdout ?? ""}${output2.stderr ?? ""}`.trim() || output2.message;
+            const last = text3.split("\n").at(-1) ?? "unknown error";
+            await session.workspace.upsertLessons([
+              {
+                role: "fixer",
+                source: "verify",
+                text: fitLesson(`The verify command failed with: ${last}. Run it before you finish.`)
+              }
+            ]);
+            attempt.outcome = "verify-failed";
+            attempt.reason = `The verify command failed: ${last}`.slice(0, 500);
+            attempt.verifyOutput = text3.slice(-4e3);
+            throw new Error(`Verification failed: ${attempt.verifyOutput}`, {
+              cause: error
+            });
+          }
+        }
+        attempt.outcome = "proposed";
+        proposal.checks = config.verify;
+        proposal.status = "proposed";
+        const committed = await commitFix(worktree, issue.title, config.commitMessage);
+        if (!committed.ok) {
           await session.workspace.upsertLessons([
             {
               role: "fixer",
-              source: "verify",
-              text: `The verify command failed with: ${last}. Run it before you finish.`.slice(0, 200)
+              source: "commit-hook",
+              text: fitLesson(`The commit hook rejected a commit: ${committed.reason}. Make the change pass it.`)
             }
           ]);
-          throw new Error(`Verification failed: ${(output2.stderr || output2.stdout || output2.message).slice(-4e3)}`, {
-            cause: error
-          });
+          proposal.error = `Left uncommitted in the worktree: ${committed.reason}`;
+        } else {
+          proposal.commit = await git(worktree, "rev-parse", "HEAD");
         }
+        if (committed.ok && config.retest.enabled && session.config.agents.explorer.enabled && session.config.agents.judge.enabled && (issue.evidence.routineId || issue.evidence.steps?.length || issue.candidateIds.length))
+          proposal.status = "retesting";
+        await updateIssue(session, issue.id, { status: "fix-proposed", fixId: proposal.id });
       }
-      proposal.checks = config.verify;
-      proposal.status = "proposed";
-      const committed = await commitFix(worktree, issue.title, config.commitMessage);
-      if (!committed.ok) {
-        await session.workspace.upsertLessons([
-          {
-            role: "fixer",
-            source: "commit-hook",
-            text: `The commit hook rejected a commit: ${committed.reason}. Make the change pass it.`.slice(0, 200)
-          }
-        ]);
-        proposal.error = `Left uncommitted in the worktree: ${committed.reason}`;
-      } else {
-        proposal.commit = await git(worktree, "rev-parse", "HEAD");
-      }
-      if (committed.ok && config.retest.enabled && session.config.agents.explorer.enabled && session.config.agents.judge.enabled && (issue.evidence.routineId || issue.evidence.steps?.length || issue.candidateIds.length))
-        proposal.status = "retesting";
-      await updateIssue(session, issue.id, { status: "fix-proposed", fixId: proposal.id });
     } catch (error) {
       proposal.status = "failed";
       proposal.error = String(error);
+      attempt.outcome ??= "error";
+      attempt.reason ??= String(error).slice(0, 500);
       await updateIssue(session, issue.id, { status: issue.status });
     }
+    await closeAttempt(session.workspace, proposal.id, attempt, worktree, source);
+    if (proposal.status === "failed" && fixerAttempts(proposal.attempts).length >= config.attempts)
+      proposal.error = `Gave up after ${config.attempts} fix attempts. The last one: ${proposal.error}`;
     proposal.endedAt = (/* @__PURE__ */ new Date()).toISOString();
     await session.workspace.saveFix(proposal);
     proposals.push(proposal);
@@ -5131,7 +5248,7 @@ async function runFixer(session, runtime, opts = {}) {
   await session.idle(proposals.reduce((sum, item) => sum + (item.costUsd ?? 0), 0));
   return proposals;
 }
-async function runOne(session, runtime, issue, worktree, last) {
+async function runOne(session, runtime, issue, worktree, last, history) {
   const config = session.config.agents.fixer;
   const evidencePaths = Object.entries(issue.evidence).filter(([key]) => ["screenshot", "baseline", "diff"].includes(key)).map(([key, value]) => `${key}: ${resolve2(session.root, String(value))}`);
   const evidence = evidencePaths.join("\n");
@@ -5139,29 +5256,67 @@ async function runOne(session, runtime, issue, worktree, last) {
   const repro = `Run the routine ${issue.evidence.routineId ?? "(none)"}, then:
 ${steps.join("\n")}`;
   const after = last?.shots?.length ? last.shots.map((shot) => `${shot.screenId ?? "(unknown screen)"}: ${shot.after ? resolve2(session.root, shot.after) : "(unavailable)"}`).join("\n") : last?.after ? resolve2(session.root, last.after) : "(unavailable)";
-  return runtime.run({
-    role: "fixer",
-    sessionId: session.sessionId,
-    workdir: worktree,
-    system: fixerSystem(lessonsFor(await session.workspace.readMemory(), "fixer")),
-    prompt: `Issue: ${issue.title}
+  const earlierAttempts = await attemptsPrompt(session, `fix_${issue.id}`, worktree, history);
+  try {
+    return await runtime.run({
+      role: "fixer",
+      sessionId: session.sessionId,
+      workdir: worktree,
+      system: fixerSystem(lessonsFor(await session.workspace.readMemory(), "fixer")),
+      prompt: `Issue: ${issue.title}
 Severity: ${issue.severity}
 ${issue.body}
 Evidence:
 ${evidence}
-Reproduction: ${repro}` + (last ? `
+Reproduction: ${repro}` + earlierAttempts + (last ? `
 Your last change did not fix the issue in the running app. The QA lead said: ${last.reason}. After screenshots:
 ${after}
 First find why your last change had no effect in the running app, for example a different file that the app loads on this platform. Do not trust a guess from the QA lead: check the code. When you find the cause, call save_lesson with it, so that later fixes avoid it. Then fix the issue.` : ""),
-    tools: [
-      ...runtime.label.startsWith("cli:") ? [] : modelTools(worktree),
-      ...lessonTools(session, "fixer"),
-      finishTool()
-    ],
-    maxSteps: config.maxSteps,
-    budgetUsd: config.budgetUsd,
-    timeoutMs: config.timeoutMs
-  }, session.emit);
+      tools: [
+        ...runtime.label.startsWith("cli:") ? [] : modelTools(worktree),
+        ...lessonTools(session, "fixer"),
+        finishTool()
+      ],
+      maxSteps: config.maxSteps,
+      budgetUsd: config.budgetUsd,
+      timeoutMs: config.timeoutMs
+    }, session.emit);
+  } finally {
+    await rm2(join6(worktree, LAST_DIFF), { force: true });
+  }
+}
+var LAST_DIFF = ".bugpatrol-last-attempt.diff";
+async function attemptsPrompt(session, fixId, worktree, { earlier, start }) {
+  const last = earlier.at(-1);
+  if (!last)
+    return "";
+  const lines = earlier.map((attempt) => {
+    const reason2 = attempt.reason?.split("\n")[0]?.slice(0, 200);
+    const files2 = attempt.diffStat?.split("\n").slice(0, -1).map((line) => line.trim()).join(", ").slice(0, 300);
+    return `${attempt.n}. ${attempt.kind}, ${attempt.outcome ?? "unfinished"}${reason2 ? `: ${reason2}` : ""}${files2 ? ` (${files2})` : ""}`;
+  });
+  const parts = [`
+
+Earlier fix attempts on this issue:
+${lines.join("\n")}`];
+  if (last.verifyOutput)
+    parts.push(`The last attempt failed the verify command \`${session.config.agents.fixer.verify ?? ""}\` with:
+${last.verifyOutput}`);
+  if (start === "repair")
+    parts.push("Your last change is still in the worktree. Repair that change. Do not start over.");
+  else if (start === "clean") {
+    const diff2 = await session.workspace.readFixAttemptDiff(fixId, last.n);
+    if (diff2 && diff2.length <= 2e4)
+      parts.push(`The worktree starts clean. The last attempt's change was:
+\`\`\`diff
+${diff2}\`\`\``);
+    else if (diff2) {
+      await writeFile3(join6(worktree, LAST_DIFF), diff2);
+      parts.push(`The worktree starts clean. The last attempt's change is in ${LAST_DIFF}; that file goes away after you finish.`);
+    }
+  }
+  return `${parts.join("\n\n")}
+`;
 }
 function stepWords(step) {
   if (step.kind === "tap") {
@@ -5304,7 +5459,7 @@ async function syncGitHub(root2, config, deps = {}) {
             role,
             source: "rejected-pr",
             scope: issue.screenId,
-            text: lesson
+            text: fitLesson(lesson)
           })));
           const record = await workspace.startSession("judge");
           await workspace.appendEvent(record.id, {
@@ -5351,7 +5506,7 @@ async function syncGitHub(root2, config, deps = {}) {
             role: "judge",
             source: "human",
             scope: issue.screenId,
-            text: `Not a bug: ${issue.title} \u2014 ${reason2}`.slice(0, 200)
+            text: fitLesson(`Not a bug: ${issue.title} \u2014 ${reason2}`)
           }
         ]);
       } else if (state === "closed" && stateReason === "completed") {
@@ -5423,7 +5578,7 @@ async function withBody(body2, run3) {
     await writeFile4(file, limitBody(body2));
     return await run3(file);
   } finally {
-    await rm2(dir2, { recursive: true, force: true });
+    await rm3(dir2, { recursive: true, force: true });
   }
 }
 var fromUrl = (url) => ({ url: url.trim(), number: Number(url.trim().split("/").at(-1)) });
@@ -5438,7 +5593,7 @@ async function createPr(gh, input) {
           {
             role: "fixer",
             source: "commit-hook",
-            text: `The commit hook rejected a commit: ${committed.reason}. Make the change pass it.`.slice(0, 200)
+            text: fitLesson(`The commit hook rejected a commit: ${committed.reason}. Make the change pass it.`)
           }
         ]);
       throw new Error(committed.reason);
@@ -6278,7 +6433,7 @@ async function captureSessionFlow(options) {
 
 // ../agents/dist/patrol.js
 import { execFile as execFile9 } from "node:child_process";
-import { relative as relative5, resolve as resolve13 } from "node:path";
+import { relative as relative6, resolve as resolve13 } from "node:path";
 import { promisify as promisify9 } from "node:util";
 
 // ../drivers/dist/api.js
@@ -10362,7 +10517,7 @@ import { PNG as PNG3 } from "pngjs";
 // ../drivers/dist/video.js
 import { execFile as execFile4 } from "node:child_process";
 import { accessSync as accessSync2, constants as constants2 } from "node:fs";
-import { mkdtemp as mkdtemp3, rm as rm3, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdtemp as mkdtemp3, rm as rm4, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
 import { delimiter as delimiter2, join as join9 } from "node:path";
 import { promisify as promisify4 } from "node:util";
@@ -10405,7 +10560,7 @@ async function encodeFrames(frames, file, endAt) {
       ...["-c:v", "libx264", "-movflags", "+faststart", "-an", file]
     ]);
   } finally {
-    await rm3(dir2, { recursive: true, force: true });
+    await rm4(dir2, { recursive: true, force: true });
   }
 }
 var GIF_TRIES = [
@@ -10428,7 +10583,7 @@ async function inlineGif(video, gif) {
     if ((await stat2(gif)).size <= GIF_MAX_BYTES)
       return true;
   }
-  await rm3(gif, { force: true });
+  await rm4(gif, { force: true });
   return false;
 }
 
@@ -10532,7 +10687,7 @@ var Terminal = class {
   }
   /** The lines that scrolled off, then the screen, with no trailing spaces or empty lines. */
   text() {
-    const lines = [...this.history, ...this.grid.map((row) => row.map((cell) => cell.char).join(""))].map((line) => line.trimEnd());
+    const lines = [...this.history, ...this.grid.map((row) => row.map((cell2) => cell2.char).join(""))].map((line) => line.trimEnd());
     while (lines.length && !lines.at(-1))
       lines.pop();
     return lines.join("\n");
@@ -10543,9 +10698,9 @@ var Terminal = class {
     const out = new Uint8Array(width * this.rows * GLYPH.height);
     for (let row = 0; row < this.rows; row++) {
       for (let col = 0; col < this.cols; col++) {
-        const cell = this.grid[row][col];
-        const [fg, bg] = cell.inverse ? [cell.bg, cell.fg] : [cell.fg, cell.bg];
-        const bits = glyph(cell.char, cell.bold);
+        const cell2 = this.grid[row][col];
+        const [fg, bg] = cell2.inverse ? [cell2.bg, cell2.fg] : [cell2.fg, cell2.bg];
+        const bits = glyph(cell2.char, cell2.bold);
         for (let line = 0; line < GLYPH.height; line++) {
           const start = (row * GLYPH.height + line) * width + col * GLYPH.width;
           for (let bit = 0; bit < GLYPH.width; bit++)
@@ -10573,7 +10728,7 @@ var Terminal = class {
       this.y++;
       return;
     }
-    this.history.push(this.grid.shift().map((cell) => cell.char).join(""));
+    this.history.push(this.grid.shift().map((cell2) => cell2.char).join(""));
     if (this.history.length > 1e4)
       this.history.shift();
     this.grid.push(this.blank());
@@ -11637,7 +11792,7 @@ import { spawn as spawn5 } from "node:child_process";
 import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { once } from "node:events";
-import { copyFile as copyFile2, mkdtemp as mkdtemp4, readFile as readFile6, rm as rm4 } from "node:fs/promises";
+import { copyFile as copyFile2, mkdtemp as mkdtemp4, readFile as readFile6, rm as rm5 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
 import { dirname as dirname3, join as join10 } from "node:path";
 import { promisify as promisify5 } from "node:util";
@@ -11704,13 +11859,35 @@ function nativeRole(leaf, hint, val, name, a11y, rid, txt) {
   }
   return "group";
 }
+function rootBounds(roots, read) {
+  const first = bounds(read(roots[0] ?? {}, "bounds"));
+  if (first) {
+    return first;
+  }
+  let level = roots;
+  while (level.length > 0) {
+    const boxes = level.map((node) => bounds(read(node, "bounds"))).filter((box) => box !== void 0);
+    if (boxes.length > 0) {
+      const x1 = Math.min(...boxes.map((box) => box.x));
+      const y1 = Math.min(...boxes.map((box) => box.y));
+      const x2 = Math.max(...boxes.map((box) => box.x + box.width));
+      const y2 = Math.max(...boxes.map((box) => box.y + box.height));
+      return { x: x1, y: y1, width: x2 - x1, height: y2 - y1 };
+    }
+    level = level.flatMap((node) => {
+      const children = read(node, "children");
+      return Array.isArray(children) ? children : [];
+    });
+  }
+  return void 0;
+}
 function flattenHierarchy(schema10) {
   const aliases = schema10.ui_schema?.abbreviations ?? {};
   const defaults = schema10.ui_schema?.defaults ?? {};
   const key = (name) => Object.entries(aliases).find(([, expanded]) => expanded === name)?.[0] ?? name;
   const read = (node, name) => node[key(name)] ?? node[name] ?? defaults[key(name)] ?? defaults[name];
   const roots = schema10.elements;
-  const root2 = bounds(read(roots[0] ?? {}, "bounds"));
+  const root2 = rootBounds(roots, read);
   if (!root2) {
     throw new Error("Maestro hierarchy has no root bounds");
   }
@@ -11948,7 +12125,7 @@ var MaestroDriver = class {
       await exec3("xcrun", ["simctl", "io", this.deviceId, "screenshot", file]);
       return await readFile6(file);
     } finally {
-      await rm4(dir2, { recursive: true, force: true });
+      await rm5(dir2, { recursive: true, force: true });
     }
   }
   async observe() {
@@ -12149,7 +12326,7 @@ var MaestroDriver = class {
       }
     } catch (error) {
       child.kill("SIGKILL");
-      await rm4(dir2, { recursive: true, force: true });
+      await rm5(dir2, { recursive: true, force: true });
       throw error;
     }
     return { child, exited, file };
@@ -12201,7 +12378,7 @@ var MaestroDriver = class {
         await within(recording.exited, 3e4, "Stopping the recording");
         await copyFile2(recording.file, file);
       } finally {
-        await rm4(dirname3(recording.file), { recursive: true, force: true });
+        await rm5(dirname3(recording.file), { recursive: true, force: true });
       }
       return file;
     }
@@ -12224,7 +12401,7 @@ var MaestroDriver = class {
       });
     } else if (recording) {
       recording.child.kill("SIGKILL");
-      await rm4(dirname3(recording.file), { recursive: true, force: true });
+      await rm5(dirname3(recording.file), { recursive: true, force: true });
     }
     await this.client?.close();
     await this.transport?.close();
@@ -12475,7 +12652,7 @@ var Control = class {
 
 // ../drivers/dist/cua/isolation.js
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { access, mkdir as mkdir4, mkdtemp as mkdtemp5, rm as rm5 } from "node:fs/promises";
+import { access, mkdir as mkdir4, mkdtemp as mkdtemp5, rm as rm6 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
 import { join as join11 } from "node:path";
 import { getDefaultEnvironment, StdioClientTransport as StdioClientTransport2 } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -12541,9 +12718,9 @@ async function isolatedTransport(command, windowManager, width, height) {
       env,
       stderr: "pipe"
     });
-    return { transport, directory, remove: () => rm5(directory, { recursive: true, force: true }) };
+    return { transport, directory, remove: () => rm6(directory, { recursive: true, force: true }) };
   } catch (error) {
-    await rm5(directory, { recursive: true, force: true });
+    await rm6(directory, { recursive: true, force: true });
     throw error;
   }
 }
@@ -13433,7 +13610,6 @@ async function watchCi(root2, config, deps = {}) {
           state,
           head: fix.commit,
           failing: failed2.map((check) => check.name),
-          attempts: fix.ci?.attempts ?? 0,
           checkedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         await workspace.saveFix(fix);
@@ -13456,7 +13632,7 @@ async function watchCi(root2, config, deps = {}) {
         deps.onLog?.(`CI: all ${checks.length} check(s) passed on PR #${pr}.`);
         break;
       }
-      if ((fix.ci?.attempts ?? 0) >= settings.attempts) {
+      if (ciAttempts(fix.attempts).length >= settings.attempts) {
         await save("gave-up");
         const problem = `CI: PR #${pr} still fails ${failed2.map((check) => check.name).join(", ")} after ${settings.attempts} fixer attempt(s). A person must look at it.`;
         problems.push(problem);
@@ -13468,12 +13644,21 @@ async function watchCi(root2, config, deps = {}) {
         deps.onLog?.(`CI: PR #${pr} failed ${failed2.map((check) => check.name).join(", ")}. The fixer is off, so a person must fix it.`);
         break;
       }
+      try {
+        await access2(fix.worktree);
+      } catch {
+        fix.ci = { ...fix.ci, state: "gave-up" };
+        await workspace.saveFix(fix);
+        const problem = `CI: the worktree of ${fix.issueId} is gone, so the fixer cannot change PR #${pr}. A person must look at it.`;
+        problems.push(problem);
+        deps.onLog?.(problem);
+        break;
+      }
       deps.onLog?.(`CI: PR #${pr} failed ${failed2.map((check) => check.name).join(", ")}. The fixer tries to fix it.`);
       const pushed = await fixCi(root2, config, fix, failed2, await failureLog(gh, repo, failed2), deps);
-      fix.ci = { ...fix.ci, attempts: (fix.ci?.attempts ?? 0) + 1 };
       await workspace.saveFix(fix);
       if (!pushed) {
-        if (fix.ci.attempts >= settings.attempts) {
+        if (ciAttempts(fix.attempts).length >= settings.attempts) {
           const problem = `CI: the fixer could not fix PR #${pr}. A person must look at it.`;
           fix.ci = { ...fix.ci, state: "gave-up" };
           await workspace.saveFix(fix);
@@ -13494,12 +13679,6 @@ async function watchCi(root2, config, deps = {}) {
   return { problems };
 }
 async function fixCi(root2, config, fix, failed2, log, deps) {
-  try {
-    await access2(fix.worktree);
-  } catch {
-    deps.onLog?.(`CI: the worktree of ${fix.issueId} is gone, so the fixer cannot change PR #${fix.pr.number}.`);
-    return false;
-  }
   const workspace = new Workspace(root2);
   const record = await workspace.startSession("fixer");
   const session = new AgentSession(root2, config, new Vars(config.app.secrets), record.id, "fixer", void 0, deps.onLog);
@@ -13511,6 +13690,20 @@ async function fixCi(root2, config, fix, failed2, log, deps) {
   });
   let summary = "";
   let status = "failed";
+  const unfinished2 = fix.attempts?.at(-1);
+  if (unfinished2 && !unfinished2.outcome) {
+    unfinished2.outcome = "abandoned";
+    unfinished2.reason = "The fixer was stopped before it finished.";
+    unfinished2.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  const attempt = {
+    n: (fix.attempts?.at(-1)?.n ?? 0) + 1,
+    kind: "ci",
+    sessionId: session.sessionId,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fix.attempts = [...fix.attempts ?? [], attempt];
+  await workspace.saveFix(fix);
   try {
     const outcome = await runtime.run({
       role: "fixer",
@@ -13528,20 +13721,31 @@ async function fixCi(root2, config, fix, failed2, log, deps) {
       timeoutMs: fixer.timeoutMs
     }, session.emit);
     summary = outcome.summary ?? "";
-    if (outcome.stop !== "done")
+    attempt.costUsd = outcome.costUsd;
+    if (outcome.stop !== "done") {
+      attempt.outcome = outcome.stop === "timeout" ? "timeout" : "error";
       throw new Error(outcome.error ?? `Fixer stopped: ${outcome.stop}`);
+    }
     if (!await git3(fix.worktree, "status", "--porcelain")) {
       summary = summary || "The fixer made no change.";
+      attempt.outcome = "no-change";
       session.emit({ kind: "fix", summary: `No change for CI on PR #${fix.pr.number}: ${summary.split("\n")[0]}` });
       status = "finished";
       return false;
     }
     if (fixer.verify) {
-      await promisify6(execFile6)("/bin/sh", ["-c", fixer.verify], {
-        cwd: fix.worktree,
-        timeout: 3e5,
-        maxBuffer: 4 * 1024 * 1024
-      });
+      try {
+        await promisify6(execFile6)("/bin/sh", ["-c", fixer.verify], {
+          cwd: fix.worktree,
+          timeout: 3e5,
+          maxBuffer: 4 * 1024 * 1024
+        });
+      } catch (error) {
+        const output2 = error;
+        attempt.outcome = "verify-failed";
+        attempt.verifyOutput = (`${output2.stdout ?? ""}${output2.stderr ?? ""}`.trim() || output2.message).slice(-4e3);
+        throw error;
+      }
     }
     await git3(fix.worktree, "add", "-A");
     const committed = await commitFix(fix.worktree, "pass the CI checks", fixer.commitMessage);
@@ -13550,20 +13754,31 @@ async function fixCi(root2, config, fix, failed2, log, deps) {
     fix.commit = await git3(fix.worktree, "rev-parse", "HEAD");
     await git3(fix.worktree, "push", "origin", fix.branch);
     session.emit({ kind: "fix", summary: `Pushed a CI fix to PR #${fix.pr.number} (${fix.commit.slice(0, 7)})` });
+    attempt.outcome = "proposed";
     status = "finished";
     return true;
   } catch (error) {
     summary = String(error).slice(0, 500);
+    attempt.outcome ??= "error";
     session.emit({ kind: "error", summary: `CI fix failed on PR #${fix.pr.number}: ${summary}` });
     return false;
   } finally {
+    attempt.reason = summary || void 0;
+    await closeAttempt(workspace, fix.id, attempt, fix.worktree, fix.repo);
     await workspace.endSession(session.sessionId, { status, summary });
     await session.idle();
   }
 }
 
-// ../agents/dist/roles/explorer.js
-import { readFile as readFile8 } from "node:fs/promises";
+// ../agents/dist/guide.js
+import { existsSync as existsSync5 } from "node:fs";
+import { readFile as readFile7 } from "node:fs/promises";
+import { relative as relative4 } from "node:path";
+async function readGuide(root2, config) {
+  const { path, required } = instructionsPath(root2, config.app.instructions);
+  return required || existsSync5(path) ? { path, text: await readFile7(path, "utf8") } : { path };
+}
+var noGuide = (root2, guide) => `No app guide at ${relative4(root2, guide.path)}, so the explorer runs without one.`;
 
 // ../agents/dist/tools/explorer.js
 import { randomUUID as randomUUID3 } from "node:crypto";
@@ -14442,7 +14657,6 @@ Expected: ${arg(input, "expected")}`),
 }
 
 // ../agents/dist/roles/reflect.js
-import { readFile as readFile7 } from "node:fs/promises";
 import { stripVTControlCharacters } from "node:util";
 var schema2 = (properties = {}, required = []) => ({
   type: "object",
@@ -14505,8 +14719,7 @@ async function reflectOnSession(root2, config, sessionId, deps = {}) {
   const existing = lessonsFor(memory, "explorer");
   const ids = new Set(existing.map((item) => item.id));
   const vars = deps.vars ?? new Vars(config.app.secrets);
-  const file = instructionsPath(root2, config.app.instructions);
-  const guide = file ? await readFile7(file, "utf8") : "";
+  const guide = (await readGuide(root2, config)).text ?? "";
   const record = await workspace.startSession("explorer");
   const emit = workspace.recordEvent(record.id, "explorer", vars);
   let added = 0;
@@ -14515,14 +14728,17 @@ async function reflectOnSession(root2, config, sessionId, deps = {}) {
     const tools = [
       {
         name: "add_lesson",
-        description: "Save one specific imperative lesson.",
+        description: `Save one specific imperative lesson of at most ${LESSON_MAX_LENGTH} characters.`,
         inputSchema: schema2({ text: string2, scope: string2 }, ["text"]),
         async run(input) {
           if (added >= config.agents.memory.maxPerSession)
             return reply("Lesson limit reached.");
-          const text3 = vars.redact(String(input.text ?? "")).trim().slice(0, 200);
+          const text3 = vars.redact(String(input.text ?? "")).trim();
           if (!text3)
             return reply("Lesson text is required.");
+          const tooLong = lessonTooLong(text3);
+          if (tooLong)
+            return { ...reply(tooLong), isError: true };
           const [lesson] = await workspace.upsertLessons([
             { role: "explorer", text: text3, scope: input.scope ? String(input.scope) : void 0, source: "reflection" }
           ]);
@@ -14568,7 +14784,7 @@ async function reflectOnSession(root2, config, sessionId, deps = {}) {
     outcome = await (deps.createRuntime ?? createRuntime)(config.agents.explorer.use).run({
       role: "explorer",
       sessionId: record.id,
-      system: `You review a QA explorer's run of this app. Write lessons that would have saved steps or avoided a mistake. Each lesson is ONE imperative sentence a future explorer can follow: what to do and where. Be specific to this app: name the screen, field, or control. Never include a secret value; placeholders such as {{E2E_RUN_ID}} are fine. Do not restate the app guide. Add at most ${config.agents.memory.maxPerSession} lessons. If an existing lesson already says it, call keep_lesson with its id. If one was followed and still failed, or is wrong, call retire_lesson with a reason. Then call finish.`,
+      system: `You review a QA explorer's run of this app. Write lessons that would have saved steps or avoided a mistake. Each lesson is ONE imperative sentence of at most ${LESSON_MAX_LENGTH} characters that a future explorer can follow: what to do and where. Be specific to this app: name the screen, field, or control. Never include a secret value; placeholders such as {{E2E_RUN_ID}} are fine. Do not restate the app guide. Add at most ${config.agents.memory.maxPerSession} lessons. If an existing lesson already says it, call keep_lesson with its id. If one was followed and still failed, or is wrong, call retire_lesson with a reason. Then call finish.`,
       prompt: `TROUBLE LOG
 ${lines.join("\n")}
 
@@ -14623,12 +14839,13 @@ async function runExplorer(session, runtime, opts = {}) {
   const config = session.config.agents.explorer;
   const map = await session.workspace.readAppMap();
   const routines = await session.workspace.listRoutines();
-  const guide = instructionsPath(session.root, session.config.app.instructions);
-  const instructions = guide ? await readFile8(guide, "utf8") : "";
+  const guide = await readGuide(session.root, session.config);
+  if (guide.text === void 0)
+    session.emit({ kind: "setup", summary: noGuide(session.root, guide) });
   const task = {
     role: "explorer",
     sessionId: session.sessionId,
-    system: explorerSystem(session.config.app.platform, instructions, lessonsFor(await session.workspace.readMemory(), "explorer"), session.config.agents.checks),
+    system: explorerSystem(session.config.app.platform, guide.text ?? "", lessonsFor(await session.workspace.readMemory(), "explorer"), session.config.agents.checks),
     prompt: explorerPrompt({
       goal: opts.goal,
       screens: map?.screens ?? [],
@@ -14673,7 +14890,7 @@ async function runExplorer(session, runtime, opts = {}) {
 }
 
 // ../agents/dist/tools/judge.js
-import { appendFile as appendFile2, copyFile as copyFile3, readFile as readFile9 } from "node:fs/promises";
+import { appendFile as appendFile2, copyFile as copyFile3, readFile as readFile8 } from "node:fs/promises";
 import { join as join12, resolve as resolve8 } from "node:path";
 var response = (value) => ({ content: [{ type: "text", text: value }] });
 var schema3 = (properties, required = []) => ({
@@ -14698,7 +14915,7 @@ function issueTitle(value) {
 }
 async function decisions(session, sessionId) {
   try {
-    const lines = await readFile9(join12(paths.session(session.root, sessionId), "decisions.jsonl"), "utf8");
+    const lines = await readFile8(join12(paths.session(session.root, sessionId), "decisions.jsonl"), "utf8");
     return new Set(lines.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line).candidateId));
   } catch (error) {
     if (error.code === "ENOENT")
@@ -14743,7 +14960,7 @@ async function image(session, file) {
   if (!file)
     return [];
   try {
-    return [{ type: "image", png: await readFile9(resolve8(session.root, file)) }];
+    return [{ type: "image", png: await readFile8(resolve8(session.root, file)) }];
   } catch {
     return [];
   }
@@ -14929,7 +15146,7 @@ function judgeTools(session, sessionIds, runtimeLabel) {
                 role: "explorer",
                 source: "dismissal",
                 scope: candidate.screenId,
-                text: `Do not report: ${candidate.summary} \u2014 ${String(input.reason)}`.slice(0, 200)
+                text: fitLesson(`Do not report: ${candidate.summary} \u2014 ${String(input.reason)}`)
               }
             ]);
           }
@@ -14993,7 +15210,7 @@ async function runJudge(session, runtime, opts) {
 }
 
 // ../agents/dist/roles/publish.js
-import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile9, writeFile as writeFile8 } from "node:fs/promises";
 import { join as join13, resolve as resolve9 } from "node:path";
 
 // ../agents/dist/pr-title.js
@@ -15127,7 +15344,7 @@ async function image2(root2, path) {
   if (!path)
     return [];
   try {
-    return [{ type: "image", png: await readFile10(resolve9(root2, path)) }];
+    return [{ type: "image", png: await readFile9(resolve9(root2, path)) }];
   } catch {
     return [];
   }
@@ -15461,12 +15678,11 @@ ${items.map((item) => `${item.issue.id}: ${item.issue.title}`).join("\n")}`),
 
 // ../agents/dist/roles/retest.js
 import { execFile as execFile7 } from "node:child_process";
-import { readFile as readFile13 } from "node:fs/promises";
 import { resolve as resolve11 } from "node:path";
 import { promisify as promisify7 } from "node:util";
 
 // ../agents/dist/roles/capture.js
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 import { resolve as resolve10 } from "node:path";
 var schema5 = (properties = {}, required = []) => ({
   type: "object",
@@ -15480,7 +15696,7 @@ async function image3(root2, file) {
   if (!file)
     return [];
   try {
-    return [{ type: "image", png: await readFile11(resolve10(root2, file)) }];
+    return [{ type: "image", png: await readFile10(resolve10(root2, file)) }];
   } catch {
     return [];
   }
@@ -15619,8 +15835,8 @@ async function captureTargets(session, runtime, targets, task) {
 }
 
 // ../agents/dist/roles/overlay.js
-import { mkdir as mkdir6, readdir as readdir3, readFile as readFile12, rm as rm6, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname4, join as join14, relative as relative4, sep as sep2 } from "node:path";
+import { mkdir as mkdir6, readdir as readdir3, readFile as readFile11, rm as rm7, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname4, join as join14, relative as relative5, sep as sep2 } from "node:path";
 async function files(dir2, skip) {
   const out = [];
   let entries;
@@ -15641,7 +15857,7 @@ async function files(dir2, skip) {
   return out;
 }
 async function overlayBugpatrol(root2, source, worktree) {
-  const where = relative4(source, root2);
+  const where = relative5(source, root2);
   if (where.startsWith("..") || where.split(sep2)[0] === "..")
     return async () => {
     };
@@ -15649,11 +15865,11 @@ async function overlayBugpatrol(root2, source, worktree) {
   const saved = [];
   const skip = [join14(from, DATA_DIR), paths.routines(root2), paths.appMap(root2)];
   for (const file of await files(from, skip)) {
-    const target = join14(worktree, where, relative4(root2, file));
-    const content = await readFile12(file);
+    const target = join14(worktree, where, relative5(root2, file));
+    const content = await readFile11(file);
     let before;
     try {
-      before = await readFile12(target);
+      before = await readFile11(target);
     } catch {
       before = void 0;
     }
@@ -15668,7 +15884,7 @@ async function overlayBugpatrol(root2, source, worktree) {
       if (item.content)
         await writeFile9(item.path, item.content);
       else
-        await rm6(item.path, { force: true });
+        await rm7(item.path, { force: true });
     }
   };
 }
@@ -15726,6 +15942,7 @@ async function retestFix(root2, config, issue, fix, attempt, deps, options = {})
   const targets = await loadRetestTargets(workspace, issue);
   const retest = {
     attempt,
+    fixAttempt: [...fix.attempts ?? []].reverse().find((item) => item.outcome === "proposed")?.n,
     outcome: "unclear",
     reason: "",
     shots: targets.map((target) => target.shot),
@@ -15775,8 +15992,7 @@ async function retestFix(root2, config, issue, fix, attempt, deps, options = {})
     session2.emit({ kind: "session-start", summary: `Retesting the fix for: ${issue.title}` });
     let outcome;
     try {
-      const guide = config.app.instructions;
-      const instructions = guide ? await readFile13(resolve11(root2, guide), "utf8") : "";
+      const instructions = (await readGuide(root2, config)).text ?? "";
       outcome = await captureTargets(session2, explorerRuntime, targets, {
         replay: { save: false, onFixBuild: !options.build },
         system: explorerRetestSystem(config.app.platform, instructions, lessonsFor(await workspace.readMemory(), "explorer")).replace("a build with a proposed fix", options.build === "main" ? "the main build after a merged fix" : "a build with a proposed fix"),
@@ -15911,12 +16127,15 @@ function needsRetest(fix) {
 }
 function applyRetest(config, fix, result3) {
   fix.retests = [...fix.retests ?? [], result3];
-  const attemptsLeft = judgedRetests(fix.retests).length < config.agents.fixer.retest.attempts;
+  const retestsLeft = judgedRetests(fix.retests).length < config.agents.fixer.retest.attempts;
+  const refixLeft = fixerAttempts(fix.attempts).length < config.agents.fixer.attempts;
   if (result3.outcome === "fixed")
     fix.status = "verified";
   else if (result3.outcome === "error")
     fix.status = "retesting";
-  else if ((result3.outcome === "not-fixed" || result3.outcome === "unclear") && attemptsLeft)
+  else if (result3.outcome === "not-fixed" && retestsLeft && refixLeft)
+    fix.status = "retesting";
+  else if (result3.outcome === "unclear" && retestsLeft)
     fix.status = "retesting";
   else
     fix.status = "proposed";
@@ -16165,7 +16384,7 @@ async function git5(cwd, ...args) {
   return (await exec6("git", args, { cwd })).stdout.trim();
 }
 async function dirty(root2, source) {
-  const own = [paths.routines(root2), paths.appMap(root2)].map((path) => relative5(source, path)).filter((path) => !path.startsWith(".."));
+  const own = [paths.routines(root2), paths.appMap(root2)].map((path) => relative6(source, path)).filter((path) => !path.startsWith(".."));
   const exclude = own.map((path) => `:(exclude)${path}`);
   return Boolean(await git5(source, "status", "--porcelain", "--untracked-files=no", "--", ".", ...exclude));
 }
@@ -16390,22 +16609,26 @@ async function runPatrol(options) {
 }
 
 // ../agents/dist/roles/promote.js
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 import { resolve as resolve14 } from "node:path";
 
 // ../agents/dist/review-comment.js
-var REVIEW_MARKER = "<!-- bugpatrol:review -->";
+function reviewMarker(name) {
+  return name ? `<!-- bugpatrol:review:${name} -->` : "<!-- bugpatrol:review -->";
+}
+var REVIEW_MARKER = reviewMarker();
 var SUPERSEDED_MARKER = "<!-- bugpatrol:superseded -->";
 var rank2 = { cosmetic: 0, minor: 1, major: 2, critical: 3 };
 var short = (commit) => commit.slice(0, 7);
 var stoppedAt = (replay) => `stopped at step ${(replay?.failedStep ?? 0) + 1}`;
-function details(summary, lines) {
-  return lines.length ? [`<details><summary>${summary}</summary>
+function details(summary, lines, open3 = false) {
+  return lines.length ? [`<details${open3 ? " open" : ""}><summary>${summary}</summary>
 
 ${lines.join("\n")}
 
 </details>`] : [];
 }
+var cell = (text3) => text3.replaceAll("|", "\\|").replace(/\s*\n\s*/g, " ");
 function numberDiff(diff2) {
   const lines = /* @__PURE__ */ new Map();
   const text3 = [];
@@ -16484,9 +16707,7 @@ function claimLines(review, image4, url) {
     return [];
   const head = `\`${short(review.head)}\``;
   const base = `\`${short(review.base)}\``;
-  const tested = claims.filter((finding) => finding.verdict !== "untested");
-  const untested = claims.filter((finding) => finding.verdict === "untested");
-  const cell = (path, fallback) => image4(path) ?? `_${fallback}_`;
+  const shot = (path, fallback) => image4(path) ?? `_${fallback}_`;
   const stopped = (finding, build) => {
     const replay = finding[build];
     return replay && !replay.ok ? `The replay ${stoppedAt(replay)}.` : "No screenshot.";
@@ -16495,18 +16716,18 @@ function claimLines(review, image4, url) {
     const recording = finding[build]?.recording;
     const video = recording && url(recording.file);
     const label = recording?.file.endsWith(".cast") ? "Terminal recording" : "Full video";
-    return cell(recording?.gif ?? finding[build]?.shots.at(-1), stopped(finding, build)) + (video ? `<br><a href="${video}">${label}</a>` : recording ? `<br>${label}: \`${recording.file}\` in the run, and in the dashboard` : "");
+    return shot(recording?.gif ?? finding[build]?.shots.at(-1), stopped(finding, build)) + (video ? `<br><a href="${video}">${label}</a>` : recording ? `<br>${label}: \`${recording.file}\` in the run, and in the dashboard` : "");
   };
   const checks = (finding) => {
     const results = finding.head?.assertions;
     if (!results?.length)
       return [];
     const cellText = (text3) => text3.replaceAll("|", "\\|");
-    const result3 = (item2) => !item2 ? "-" : item2.ok ? "Passed" : item2.actual !== void 0 ? `Failed, ${assertionWords(item2, true)}` : "Failed";
+    const result3 = (item) => !item ? "-" : item.ok ? "Passed" : item.actual !== void 0 ? `Failed, ${assertionWords(item, true)}` : "Failed";
     return [
       `| Check | Base ${base} | This pull request ${head} |
 | --- | --- | --- |
-` + results.map((item2, index) => `| ${cellText(assertionWords(item2))} | ${cellText(result3(finding.base?.assertions?.[index]))} | ${cellText(result3(item2))} |`).join("\n")
+` + results.map((item, index) => `| ${cellText(assertionWords(item))} | ${cellText(result3(finding.base?.assertions?.[index]))} | ${cellText(result3(item))} |`).join("\n")
     ];
   };
   const compared = (finding) => {
@@ -16529,8 +16750,7 @@ ${fence}`;
     const replayed2 = Boolean(finding.head);
     const steps = finding.steps ?? [];
     return [
-      `#### ${finding.claim.text}`,
-      `\`${finding.verdict}\` \xB7 From ${sourceWords(finding.claim.source)}.` + (finding.evidence ? ` Evidence: ${finding.evidence === "explored" && replayed2 ? judgedReplay : evidenceWords[finding.evidence]}.` : ""),
+      `From ${sourceWords(finding.claim.source)}.` + (finding.evidence ? ` Evidence: ${finding.evidence === "explored" && replayed2 ? judgedReplay : evidenceWords[finding.evidence]}.` : ""),
       finding.reason,
       // With a replay, the screenshots show the rest.
       ...finding.saw && (finding.verdict === "not-proven" || !replayed2) ? [`Bugpatrol saw: ${finding.saw}`] : [],
@@ -16547,21 +16767,36 @@ ${fence}`;
         ...details("Each step", recorded(finding) ? [] : [
           `| Step | Base ${base} | This pull request ${head} |
 | --- | --- | --- |`,
-          ...["Start", ...steps].map((step, index) => `| ${index ? `${index}. ${step}` : step} | ${cell(finding.base?.shots[index], "-")} | ${cell(finding.head?.shots[index], "-")} |`)
+          ...["Start", ...steps].map((step, index) => `| ${index ? `${index}. ${step}` : step} | ${shot(finding.base?.shots[index], "-")} | ${shot(finding.head?.shots[index], "-")} |`)
         ])
       ] : []
     ].join("\n\n");
   };
-  const item = (finding) => `- **${finding.claim.text}**<br><sub>From ${sourceWords(finding.claim.source)}. ${finding.reason}</sub>`;
+  if (!claims.length)
+    return ["#### Claims (0)", "Bugpatrol found no claim in the pull request."];
+  const order = ["not-proven", "partly-proven", "proven", "untested"];
+  const sorted = [...claims].sort((a, b) => order.indexOf(a.verdict) - order.indexOf(b.verdict));
+  const counts = ["proven", "partly-proven", "not-proven", "untested"].map((verdict) => [verdict, claims.filter((finding) => finding.verdict === verdict).length]).filter(([, count]) => count).map(([verdict, count]) => `${count} ${verdictWords[verdict].toLowerCase()}`);
+  const evidence = (finding) => finding.evidence === "explored" && finding.head ? "replay, judged" : finding.evidence ? evidenceLabel[finding.evidence] : "";
   return [
-    `#### What this pull request says it does (${claims.length})`,
-    claims.length ? `Bugpatrol compared this pull request (${head}) with its base (${base} on \`${review.baseRef}\`).` : "Bugpatrol found no claim in the pull request.",
-    ...tested.map(section),
-    ...untested.length ? [`#### Claims that Bugpatrol could not test (${untested.length})`, untested.map(item).join("\n")] : [],
-    "#### Problems that this pull request introduces"
+    `#### Claims (${claims.length}): ${counts.join(" \xB7 ")}`,
+    "| Claim | Verdict | Evidence |\n| --- | --- | --- |\n" + sorted.map((finding) => finding.verdict === "untested" ? `| ${cell(finding.claim.text)} | Untested: ${cell(finding.reason)} | |` : `| ${cell(finding.claim.text)} | ${verdictWords[finding.verdict]} | ${evidence(finding)} |`).join("\n"),
+    ...sorted.filter((finding) => finding.verdict !== "untested").flatMap((finding) => details(`${verdictWords[finding.verdict]}: ${finding.claim.text}`, [section(finding)], finding.verdict !== "proven"))
   ];
 }
-function renderReview(review, imageUrl, inDiff) {
+var verdictWords = {
+  proven: "Proven",
+  "partly-proven": "Partly proven",
+  "not-proven": "Not proven",
+  untested: "Untested"
+};
+var evidenceLabel = {
+  replay: "replay",
+  assertion: "exact check",
+  explored: "explored",
+  bench: "benchmark"
+};
+function renderReview(review, imageUrl, inDiff, name) {
   const of = (verdict) => review.findings.filter((finding) => finding.verdict === verdict).sort((a, b) => rank2[b.severity] - rank2[a.severity]);
   const introduced = of("introduced");
   const onLine = (finding) => Boolean(finding.file && finding.line && inDiff(finding.file, finding.line));
@@ -16576,32 +16811,59 @@ function renderReview(review, imageUrl, inDiff) {
     heading,
     `**${finding.severity}**${finding.screenId ? ` \xB7 screen \`${finding.screenId}\`` : ""}`,
     finding.reason,
+    ...shots(finding)
+  ].join("\n\n");
+  const shots = (finding) => [
     `| Base ${base} | This pull request ${head} |
 | --- | --- |
 | ${image4(finding.base) ?? `_${finding.baseNote ?? "No screenshot."}_`} | ${image4(finding.head) ?? "_No screenshot._"} |`,
     ...details("Steps", finding.steps.map((step, number) => `${number + 1}. ${step}`))
-  ].join("\n\n");
-  const line = (finding) => `- **${finding.title}** (${finding.severity}): ${finding.reason}`;
-  const where = located.length === 0 ? [] : located.length === introduced.length ? ["Each one is a comment on the changed line that causes it."] : [
-    `${located.length} of them ${located.length === 1 ? "is a comment on the changed line that causes it" : "are comments on the changed lines that cause them"}. The others are below.`
   ];
+  const problem = (finding, index) => {
+    const where = onLine(finding) ? `on \`${finding.file}:${finding.line}\` (line comment)` : finding.file && finding.line ? `\`${finding.file}:${finding.line}\`` : finding.screenId ? `screen \`${finding.screenId}\`` : "";
+    const headline = [`**${index + 1}. ${finding.title}**`, finding.severity, where].filter(Boolean).join(" \xB7 ");
+    if (onLine(finding))
+      return headline;
+    return [
+      headline,
+      finding.reason,
+      ...details("Screenshots and steps", [
+        shots(finding)[0],
+        ...finding.steps.map((step, number) => `${number + 1}. ${step}`)
+      ])
+    ].join("\n\n");
+  };
+  const others = [
+    ...of("pre-existing").map((finding) => [finding, `Already on \`${review.baseRef}\``]),
+    ...of("unclear").map((finding) => [finding, "Could not compare"]),
+    ...of("not-a-bug").map((finding) => [finding, "Not a bug"])
+  ];
+  const otherCounts = [
+    [of("pre-existing").length, `already on \`${review.baseRef}\``],
+    [of("unclear").length, "could not compare"],
+    [of("not-a-bug").length, "not a bug"]
+  ].filter(([count]) => count).map(([count, words2]) => `${count} ${words2}`);
+  const coverage = review.coverage;
+  const hint = nextRunHint(review);
   const body2 = [
-    REVIEW_MARKER,
-    "### Bugpatrol review",
+    reviewMarker(name),
+    name ? `### Bugpatrol review: ${name}` : "### Bugpatrol review",
+    `**${introduced.length ? `${introduced.length} ${introduced.length === 1 ? "problem" : "problems"}` : "No problem"} introduced** \xB7 tested ${head} against \`${review.baseRef}\` ${base}`,
+    ...hint ? [`> **Next run:** ${hint}`] : [],
+    ...introduced.length ? [`#### Problems this pull request introduces (${introduced.length})`, ...introduced.map(problem)] : [],
     ...claimLines(review, image4, imageUrl),
-    introduced.length ? `**${introduced.length} ${introduced.length === 1 ? "problem" : "problems"} that this pull request introduces.**` : "**No problem found that this pull request introduces.**",
-    ...where,
-    review.sessions.base ? `Bugpatrol ran the app from this pull request (${head}) and from its base (${base} on \`${review.baseRef}\`), and repeated the same flows on both.` : `Bugpatrol ran the app from this pull request (${head}) and tested what the diff can affect.`,
-    ...introduced.filter((finding) => !onLine(finding)).map((finding, index) => section(finding, `#### ${index + 1}. ${finding.title}`)),
-    ...details(`Already on \`${review.baseRef}\`, not from this pull request (${of("pre-existing").length})`, [
-      ...of("pre-existing").map(line)
-    ]),
-    ...details(`Could not compare (${of("unclear").length})`, [
-      ...of("unclear").map((finding) => `${line(finding)}${finding.baseNote ? ` Base build: ${finding.baseNote}` : ""}`)
-    ]),
-    ...details(`Reported, then judged not a bug (${of("not-a-bug").length})`, [...of("not-a-bug").map(line)]),
-    ...details("What Bugpatrol tested", review.tested ? [review.tested] : []),
-    `<sub>Bugpatrol tested only what the diff can affect, not the whole app. This review does not block the merge.</sub>`
+    ...coverage ? [
+      ...coverage.tested.length ? ["#### Tested", coverage.tested.map((line) => `- ${line}`).join("\n")] : [],
+      ...coverage.untested.length ? [
+        "#### Not tested",
+        coverage.untested.map((item) => `- ${item.what}${item.why ? `: ${item.why}` : ""}`).join("\n")
+      ] : []
+    ] : review.tested ? ["#### Tested", review.tested] : [],
+    ...others.length ? details(`Other findings (${others.length}): ${otherCounts.join(" \xB7 ")}`, [
+      "| Finding | Severity | Verdict | Why |\n| --- | --- | --- | --- |",
+      ...others.map(([finding, verdict]) => `| ${cell(finding.title)} | ${finding.severity} | ${verdict} | ${cell(`${finding.reason}${finding.verdict === "unclear" && finding.baseNote ? ` Base build: ${finding.baseNote}` : ""}`)} |`)
+    ]) : [],
+    `<sub>Updated on each push. Tests only what the diff can affect.${review.check ? "" : " Does not block the merge."}</sub>`
   ].join("\n\n");
   return {
     body: body2,
@@ -16612,8 +16874,25 @@ function renderReview(review, imageUrl, inDiff) {
     }))
   };
 }
-function supersededBody(head) {
-  return `${REVIEW_MARKER}
+function lineReviewBody(count, comment, name) {
+  return [
+    reviewMarker(name),
+    `**Bugpatrol review${name ? `: ${name}` : ""}**: ${count} ${count === 1 ? "problem" : "problems"} on the changed lines. [The full review](${comment}) is updated on each push.`
+  ].join("\n\n");
+}
+function nextRunHint(review) {
+  if (review.cutShort?.by === "max-steps")
+    return `The explorer used all ${review.cutShort.limit} steps. Raise \`agents.explorer.maxSteps\`, or the Action's \`steps\` input.`;
+  if (review.cutShort?.by === "timeout")
+    return `The explorer used its ${Math.round(review.cutShort.limit / 6e4)} minutes. Raise \`agents.explorer.timeoutMs\`.`;
+  if (review.cutShort?.by === "budget")
+    return `The explorer spent its $${review.cutShort.limit.toFixed(2)} budget. Raise \`agents.explorer.budgetUsd\`.`;
+  if (review.files && !review.files.guide)
+    return "Add `.bugpatrol/instructions.md`, an app guide that tells the explorer how to use the app.";
+  return void 0;
+}
+function supersededBody(head, name) {
+  return `${reviewMarker(name)}
 ${SUPERSEDED_MARKER}
 _A Bugpatrol review of \`${short(head)}\` replaced this one._`;
 }
@@ -16647,7 +16926,7 @@ async function promoteClaims(root2, config, number, claimIds, opts = {}) {
   for (const finding of chosen) {
     let saved;
     try {
-      saved = JSON.parse(await readFile14(resolve14(root2, finding.routine), "utf8"));
+      saved = JSON.parse(await readFile12(resolve14(root2, finding.routine), "utf8"));
     } catch {
       throw new ConfigError(`The routine of ${finding.claim.id} is gone from ${finding.routine}. Run \`bugpatrol review ${number} --claims --force\` again.`);
     }
@@ -16672,8 +16951,8 @@ async function promoteClaims(root2, config, number, claimIds, opts = {}) {
 
 // ../agents/dist/roles/review.js
 import { execFile as execFile11 } from "node:child_process";
-import { appendFile as appendFile3, lstat as lstat3, mkdir as mkdir8, readFile as readFile15, rm as rm7, stat as stat3, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname5, join as join16, resolve as resolve15 } from "node:path";
+import { appendFile as appendFile3, lstat as lstat3, mkdir as mkdir8, rm as rm8, stat as stat3, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname5, join as join16, relative as relative8, resolve as resolve15 } from "node:path";
 import { promisify as promisify11 } from "node:util";
 
 // ../agents/dist/roles/benches.js
@@ -16909,7 +17188,7 @@ function benchWords(bench) {
 
 // ../agents/dist/roles/claims.js
 import { mkdir as mkdir7, writeFile as writeFile10 } from "node:fs/promises";
-import { join as join15, relative as relative6 } from "node:path";
+import { join as join15, relative as relative7 } from "node:path";
 
 // ../agents/dist/outputs.js
 var RULES2 = [
@@ -17066,7 +17345,7 @@ async function reproClaims(ctx, first) {
       did: `Replayed the repro routine of #${issue.number}, and checked whether the last screen ${checkWords(routine.bug)}.`,
       routine: { ...routine, steps, requires: void 0 },
       check: routine.bug,
-      path: relative6(ctx.root, paths.routine(ctx.root, id2))
+      path: relative7(ctx.root, paths.routine(ctx.root, id2))
     });
   }
   return { claims, flows };
@@ -17197,7 +17476,7 @@ function claimTools(session, ctx, claims, flows) {
           did: routine.description,
           saw: redact(input.saw),
           routine,
-          path: relative6(ctx.root, file)
+          path: relative7(ctx.root, file)
         });
         end();
         if (same)
@@ -17293,13 +17572,13 @@ async function saveRecording(ctx, driver, name, what) {
     ctx.log(`Could not record ${what}: ${String(error).split("\n")[0]}`);
     return void 0;
   }
-  const recording = { file: relative6(ctx.root, file) };
+  const recording = { file: relative7(ctx.root, file) };
   const gif = file.endsWith(".cast") ? castGif : /\.(mp4|mov|webm)$/.test(file) ? inlineGif : void 0;
   if (!gif)
     return recording;
   try {
     if (await gif(file, `${name}.gif`))
-      return { ...recording, gif: relative6(ctx.root, `${name}.gif`) };
+      return { ...recording, gif: relative7(ctx.root, `${name}.gif`) };
     ctx.log(`The GIF of ${what} is over the size budget. The review shows its screenshots.`);
   } catch (error) {
     ctx.log(`Could not make a GIF of ${what}: ${String(error).split("\n")[0]}`);
@@ -17334,7 +17613,7 @@ async function replayClaims(ctx, review, build, routines, driver, vars, fresh) {
         last = await current.observe();
         errors.push(...last.consoleErrors, ...last.networkErrors ?? []);
         await writeFile10(file, last.screenshot);
-        shots.push(relative6(root2, file));
+        shots.push(relative7(root2, file));
       };
       const what = `${claim} on ${where}`;
       let recording = false;
@@ -17740,7 +18019,7 @@ var schema9 = (properties = {}, required = []) => ({
 });
 var string9 = { type: "string" };
 var response6 = (value) => ({ content: [{ type: "text", text: value }] });
-var CHECK_NAME = "Bugpatrol claim check";
+var checkName = (name) => name ? `Bugpatrol claim check (${name})` : "Bugpatrol claim check";
 var DIFF_PATHS = [".", ":(exclude,glob)**/*.lock", ":(exclude,glob)**/*-lock.*", ":(exclude,glob)**/*.lockb"];
 var DIFF_LIMIT = 4e4;
 var ISSUE_LIMIT = 4e3;
@@ -17762,9 +18041,44 @@ var REVIEW_TOOLS = /* @__PURE__ */ new Set([
   "run_routine",
   "switch_window",
   "report_bug",
-  "list_screens",
-  "finish"
+  "list_screens"
 ]);
+var COVERAGE_LINE = 140;
+function coverageFinish(keep) {
+  const refuse = (message2) => ({ ...response6(message2), isError: true });
+  return {
+    name: "finish",
+    description: `Finish with each screen or flow that you tested, and each one the change can affect that you did not reach, with why. One short line each, under ${COVERAGE_LINE} characters.`,
+    inputSchema: schema9({
+      tested: { type: "array", items: string9 },
+      untested: { type: "array", items: schema9({ what: string9, why: string9 }, ["what", "why"]) }
+    }, ["tested", "untested"]),
+    async run(input) {
+      const tested = (Array.isArray(input.tested) ? input.tested : []).map((line) => String(line).trim());
+      const untested = (Array.isArray(input.untested) ? input.untested : []).map((item) => {
+        if (typeof item === "string") {
+          const [what2 = "", ...why2] = item.split(": ");
+          return { what: what2.trim(), why: why2.join(": ").trim() };
+        }
+        const { what, why } = item ?? {};
+        return { what: String(what ?? "").trim(), why: String(why ?? "").trim() };
+      });
+      if (tested.some((line) => !line) || untested.some((item) => !item.what))
+        return refuse("Each line needs text: a screen or flow in tested, and what (with why) in untested.");
+      if (!tested.length && !untested.length)
+        return refuse("Name what you tested in tested, and what you did not reach in untested.");
+      const long = [...tested, ...untested.flatMap((item) => [item.what, item.why])].find((line) => line.length > COVERAGE_LINE);
+      if (long)
+        return refuse(`Keep each line under ${COVERAGE_LINE} characters. Too long: ${long}`);
+      keep({ tested, untested });
+      const text3 = [
+        tested.length ? `Tested: ${tested.join("; ")}.` : "",
+        untested.length ? `Not reached: ${untested.map((item) => item.why ? `${item.what} (${item.why})` : item.what).join("; ")}.` : ""
+      ];
+      return { ...response6(text3.filter(Boolean).join(" ")), done: true };
+    }
+  };
+}
 var claimCheck = (ctx) => Boolean(ctx.opts.claims ?? ctx.config.agents.review.claims);
 var blocking = (ctx) => ctx.config.agents.review.block;
 var headRefOf = (number) => `refs/bugpatrol/pr-${number}`;
@@ -17864,7 +18178,7 @@ async function withBuild(ctx, name, commit, run3) {
     }
   });
 }
-async function exploreHead(ctx, review, claims, flows) {
+async function exploreHead(ctx, review, guide, claims, flows) {
   const { root: root2, config, workspace, pr, opts } = ctx;
   return withBuild(ctx, "head", pr.head, async (driver, vars) => {
     const record = await workspace.startSession("explorer");
@@ -17874,14 +18188,13 @@ async function exploreHead(ctx, review, claims, flows) {
     const runtime = (opts.createRuntime ?? createRuntime)(config.agents.explorer.use);
     const claimWork = claims.length ? claimTools(session, ctx, claims, flows) : void 0;
     const maxSteps = opts.maxSteps ?? config.agents.explorer.maxSteps;
-    const guide = instructionsPath(root2, config.app.instructions);
     await session.activity(`Reviewing PR #${pr.number}`, 0, runtime.label);
     session.emit({ kind: "session-start", summary: `Reviewing PR #${pr.number}: ${pr.title}` });
     try {
       const outcome = await withSessionLogs({ config, root: root2, vars, onLog: ctx.log, workspace, session: record }, async () => runtime.run({
         role: "explorer",
         sessionId: record.id,
-        system: explorerReviewSystem(config.app.platform, guide ? await readFile15(guide, "utf8") : "", lessonsFor(await workspace.readMemory(), "explorer")),
+        system: explorerReviewSystem(config.app.platform, guide.text ?? "", lessonsFor(await workspace.readMemory(), "explorer")),
         prompt: [
           explorerReviewPrompt({
             pr,
@@ -17894,18 +18207,31 @@ async function exploreHead(ctx, review, claims, flows) {
         ].join("\n\n"),
         tools: [
           ...explorerTools(session, { replay: { save: false } }).filter((tool) => REVIEW_TOOLS.has(tool.name)),
+          coverageFinish((coverage) => {
+            review.coverage = vars.redact(coverage);
+          }),
           ...claimWork?.tools ?? []
         ].map((tool) => stopOnCancellation(session, claimWork ? claimWork.meter(tool) : tool)),
         maxSteps,
         budgetUsd: config.agents.explorer.budgetUsd,
         timeoutMs: config.agents.explorer.timeoutMs
       }, session.emit));
-      if (outcome.stop === "error" || outcome.stop === "timeout")
+      if (outcome.stop === "error" || outcome.stop === "timeout" && !outcome.steps)
         throw new InfrastructureError(`The explorer did not finish (${outcome.stop}): ${outcome.error ?? outcome.summary ?? "no result"}`);
       claimWork?.charge(outcome);
       const candidates = await workspace.readCandidates(record.id);
       review.costUsd += outcome.costUsd;
-      review.tested = outcome.stop === "done" && outcome.summary ? vars.redact(outcome.summary.trim()) : `The explorer stopped before it finished (${outcome.stop}), so it tested a part of the change only.`;
+      const summary = outcome.summary?.trim();
+      const cutShort = `The explorer stopped before it finished (${outcome.stop}), so it tested a part of the change only.`;
+      if (outcome.stop === "max-steps")
+        review.cutShort = { by: "max-steps", limit: maxSteps };
+      if (outcome.stop === "timeout")
+        review.cutShort = { by: "timeout", limit: config.agents.explorer.timeoutMs };
+      if (outcome.stop === "budget" && config.agents.explorer.budgetUsd !== void 0)
+        review.cutShort = { by: "budget", limit: config.agents.explorer.budgetUsd };
+      review.tested = summary && (outcome.stop === "done" || outcome.finished) ? vars.redact(outcome.stop === "done" ? summary : `${cutShort}
+
+${summary}`) : cutShort;
       await workspace.endSession(record.id, {
         steps: outcome.steps,
         costUsd: outcome.costUsd,
@@ -17924,7 +18250,7 @@ async function exploreHead(ctx, review, claims, flows) {
     }
   });
 }
-async function captureBase(ctx, review, candidates) {
+async function captureBase(ctx, review, guide, candidates) {
   const { root: root2, config, workspace, pr, opts } = ctx;
   const targets = candidates.map((candidate) => ({
     shot: {
@@ -17941,7 +18267,6 @@ async function captureBase(ctx, review, candidates) {
       const session = new AgentSession(root2, config, vars, record.id, "explorer", driver, ctx.log);
       opts.onSession?.(session);
       const runtime = (opts.createRuntime ?? createRuntime)(config.agents.explorer.use);
-      const guide = instructionsPath(root2, config.app.instructions);
       const summary = `Repeating ${targets.length} flow(s) on the base of PR #${pr.number}`;
       await session.activity(summary, 0, runtime.label);
       session.emit({ kind: "session-start", summary });
@@ -17950,7 +18275,7 @@ async function captureBase(ctx, review, candidates) {
       try {
         const outcome = await captureTargets(session, runtime, targets, {
           replay: { save: false },
-          system: explorerBaseSystem(config.app.platform, guide ? await readFile15(guide, "utf8") : "", lessonsFor(await workspace.readMemory(), "explorer")),
+          system: explorerBaseSystem(config.app.platform, guide.text ?? "", lessonsFor(await workspace.readMemory(), "explorer")),
           prompt: `Pull request #${pr.number}: ${pr.title}
 Findings:
 ${candidates.map((candidate, index) => `${index + 1}. ${candidate.summary}`).join("\n")}
@@ -18307,7 +18632,11 @@ ${pr.diff}`
   return claims;
 }
 async function runReview(ctx) {
-  const { workspace, pr } = ctx;
+  const { root: root2, workspace, pr } = ctx;
+  const guide = await readGuide(root2, ctx.config);
+  const configFile = relative8(root2, paths.config(root2, ctx.opts.configFile));
+  const guideFile = guide.text === void 0 ? void 0 : relative8(root2, guide.path);
+  ctx.log(`Config: ${configFile}. ${guideFile ? `App guide: ${guideFile}.` : noGuide(root2, guide)}`);
   const review = {
     version: 1,
     pr: { number: pr.number, url: pr.url, title: pr.title },
@@ -18317,6 +18646,7 @@ async function runReview(ctx) {
     status: "running",
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     sessions: {},
+    files: { config: configFile, ...guideFile && { guide: guideFile } },
     findings: [],
     costUsd: 0
   };
@@ -18333,7 +18663,7 @@ async function runReview(ctx) {
     });
     if (claims) {
       review.claims = claims.map((claim) => notYet(claim, "The review stopped before it tested this claim."));
-      await rm7(paths.reviewDir(ctx.root, pr.number), { recursive: true, force: true });
+      await rm8(paths.reviewDir(ctx.root, pr.number), { recursive: true, force: true });
     }
     const platform = ctx.config.app.platform;
     const testable = (claims ?? []).filter((claim) => claim.testable);
@@ -18353,7 +18683,7 @@ async function runReview(ctx) {
       const flows = new Map(repros.flows);
       const picks = testable.some(explorable) && ctx.config.agents.review.benches.length ? await pickBenches(ctx, review, testable.filter(explorable)) : /* @__PURE__ */ new Map();
       const toExplore = toTest.filter((claim) => explorable(claim) && !picks.has(claim.id));
-      const candidates = await exploreHead(ctx, review, toExplore, flows);
+      const candidates = await exploreHead(ctx, review, guide, toExplore, flows);
       if (claims) {
         const measured = await ctx.budget.timed(() => runBenches(ctx, picks, (run3) => withWorktree(ctx, "base", pr.base, (base) => withWorktree(ctx, "head", pr.head, (head) => run3({ head, base })))));
         const build = (name, commit, run3) => withBuild(ctx, name, commit, run3);
@@ -18367,7 +18697,7 @@ async function runReview(ctx) {
         review.claims = claims.map((claim) => tested.find((finding) => finding.claim.id === claim.id) ?? untestedHere(claim));
       }
       if (candidates.length) {
-        const targets = await captureBase(ctx, review, candidates);
+        const targets = await captureBase(ctx, review, guide, candidates);
         review.findings = await judgeFindings(ctx, review, candidates, targets);
         await settleCandidates(ctx, review.sessions.explorer, review.findings);
       }
@@ -18385,19 +18715,30 @@ async function runReview(ctx) {
   }
   return review;
 }
-async function openReviews(gh, reviews) {
-  const select = `.[] | select(.body | contains("${REVIEW_MARKER}")) | select(.body | contains("${SUPERSEDED_MARKER}") | not)`;
-  return (await gh(["api", "--paginate", reviews, "--jq", `${select} | "\\(.id) \\(.commit_id)"`])).split("\n").filter(Boolean).map((row) => {
-    const [id2, commit] = row.split(" ");
-    return { id: id2, commit };
+async function openReviews(gh, reviews, name) {
+  const select = `.[] | select(.body | contains("${reviewMarker(name)}")) | select(.body | contains("${SUPERSEDED_MARKER}") | not)`;
+  return (await gh(["api", "--paginate", reviews, "--jq", `${select} | "\\(.id) \\(.commit_id) \\(.node_id)"`])).split("\n").filter(Boolean).map((row) => {
+    const [id2, commit, node] = row.split(" ");
+    return { id: id2, commit, node };
   });
 }
+async function saveSticky(gh, repo, pr, marker, body2) {
+  const comments = `repos/${repo}/issues/${pr}/comments`;
+  const [id2] = (await gh(["api", "--paginate", comments, "--jq", `.[] | select(.body | contains("${marker}")) | .id`])).split("\n").filter(Boolean);
+  const input = JSON.stringify({ body: body2 });
+  if (id2) {
+    const edited = JSON.parse(await gh(["api", "-X", "PATCH", `repos/${repo}/issues/comments/${id2}`, "--input", "-"], { input }));
+    return { html_url: edited.html_url, created: false };
+  }
+  const made = JSON.parse(await gh(["api", "-X", "POST", comments, "--input", "-"], { input }));
+  return { html_url: made.html_url, created: true };
+}
 async function supersede(ctx, gh, old, head) {
   const pulls = `repos/${ctx.repo}/pulls`;
   const ids = new Set(old.map((review) => review.id));
   for (const id2 of ids)
     await gh(["api", "-X", "PUT", `${pulls}/${ctx.pr.number}/reviews/${id2}`, "--input", "-"], {
-      input: JSON.stringify({ body: supersededBody(head) })
+      input: JSON.stringify({ body: supersededBody(head, ctx.config.agents.review.name) })
     });
   const rows = (await gh([
     "api",
@@ -18410,6 +18751,15 @@ async function supersede(ctx, gh, old, head) {
   for (const [id2, review, parent] of rows)
     if (ids.has(review) && parent === "null" && !answered.has(id2))
       await gh(["api", "-X", "DELETE", `${pulls}/comments/${id2}`]);
+  for (const { node } of old)
+    await gh([
+      "api",
+      "graphql",
+      "-f",
+      "query=mutation($id: ID!) { minimizeComment(input: {subjectId: $id, classifier: OUTDATED}) { clientMutationId } }",
+      "-f",
+      `id=${node}`
+    ]);
 }
 async function publishReview(ctx, gh, review, tested) {
   const { root: root2, config, repo, pr } = ctx;
@@ -18417,7 +18767,7 @@ async function publishReview(ctx, gh, review, tested) {
   const inDiff = (file, line) => pr.lines.get(file)?.has(line) ?? false;
   if (ctx.opts.dryRun) {
     const file = paths.review(root2, pr.number).replace(/\.json$/, ".md");
-    const rendered2 = renderReview(review, (path) => resolve15(root2, path), inDiff);
+    const rendered2 = renderReview(review, (path) => resolve15(root2, path), inDiff, config.agents.review.name);
     await mkdir8(dirname5(file), { recursive: true });
     await writeFile11(file, redact([
       rendered2.body,
@@ -18429,7 +18779,7 @@ ${comment.body}`),
       ...review.check ? [
         `---
 
-Check run ${CHECK_NAME}: \`${review.check.conclusion}\`, ${review.check.title}
+Check run ${checkName(config.agents.review.name)}: \`${review.check.conclusion}\`, ${review.check.title}
 
 ${review.check.summary}`
       ] : []
@@ -18457,37 +18807,36 @@ ${review.check.summary}`
       ctx.log(`Could not upload ${path}: ${String(error).split("\n")[0]}`);
     }
   }
-  const rendered = renderReview(review, (path) => urls.get(path), inDiff);
+  const rendered = renderReview(review, (path) => urls.get(path), inDiff, config.agents.review.name);
   const body2 = limitBody(redact(rendered.body));
-  const reviews = `repos/${repo}/pulls/${pr.number}/reviews`;
-  const open3 = await openReviews(gh, reviews);
-  const current = open3.find((item) => item.commit === review.head);
-  let posted;
-  if (current && !tested) {
-    posted = JSON.parse(await gh(["api", "-X", "PUT", `${reviews}/${current.id}`, "--input", "-"], { input: JSON.stringify({ body: body2 }) }));
-  } else {
-    posted = JSON.parse(await gh(["api", "-X", "POST", reviews, "--input", "-"], {
-      input: JSON.stringify({
-        commit_id: review.head,
-        event: "COMMENT",
-        body: body2,
-        comments: rendered.comments.map((comment) => ({
-          path: comment.path,
-          line: comment.line,
-          side: "RIGHT",
-          body: limitBody(redact(comment.body))
-        }))
-      })
-    }));
+  const name = config.agents.review.name;
+  const posted = await saveSticky(gh, repo, pr.number, reviewMarker(name), body2);
+  review.posted = { url: posted.html_url, at: (/* @__PURE__ */ new Date()).toISOString() };
+  if (tested) {
+    const reviews = `repos/${repo}/pulls/${pr.number}/reviews`;
+    const open3 = await openReviews(gh, reviews, name);
+    if (rendered.comments.length)
+      await gh(["api", "-X", "POST", reviews, "--input", "-"], {
+        input: JSON.stringify({
+          commit_id: review.head,
+          event: "COMMENT",
+          body: lineReviewBody(rendered.comments.length, posted.html_url, name),
+          comments: rendered.comments.map((comment) => ({
+            path: comment.path,
+            line: comment.line,
+            side: "RIGHT",
+            body: limitBody(redact(comment.body))
+          }))
+        })
+      });
     try {
       await supersede(ctx, gh, open3, review.head);
     } catch (error) {
       ctx.log(`Could not replace the older review(s) of PR #${pr.number}: ${String(error).split("\n")[0]}`);
     }
   }
-  review.posted = { url: posted.html_url, at: (/* @__PURE__ */ new Date()).toISOString() };
   await ctx.workspace.saveReview(review);
-  ctx.log(`${current && !tested ? "Updated" : "Posted"} the review of PR #${pr.number}: ${posted.html_url}`);
+  ctx.log(`${posted.created ? "Posted" : "Updated"} the review of PR #${pr.number}: ${posted.html_url}`);
   if (review.check)
     await setCheckRun(ctx, gh, review, review.check);
 }
@@ -18496,7 +18845,7 @@ async function setCheckRun(ctx, gh, review, check) {
   try {
     const run3 = JSON.parse(await gh(["api", "-X", "POST", `repos/${ctx.repo}/check-runs`, "--input", "-"], {
       input: JSON.stringify({
-        name: CHECK_NAME,
+        name: checkName(ctx.config.agents.review.name),
         head_sha: review.head,
         status: "completed",
         conclusion: check.conclusion,
@@ -18809,7 +19158,7 @@ function hostOf(href) {
 }
 
 // ../dashboard/dist/project.js
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "node:fs";
 import { join as join17 } from "node:path";
 var ProjectReader = class {
   root;
@@ -18822,24 +19171,24 @@ var ProjectReader = class {
     return paths.dir(this.root);
   }
   hasProject() {
-    return existsSync5(paths.config(this.root)) || existsSync5(this.bugpatrolDir);
+    return existsSync6(paths.config(this.root)) || existsSync6(this.bugpatrolDir);
   }
   /** Newest first. `latest/` holds loose capture artifacts, not a run. */
   listRunIds() {
     const dir2 = paths.runs(this.root);
-    if (!existsSync5(dir2))
+    if (!existsSync6(dir2))
       return [];
     return readdirSync2(dir2, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "latest").map((e) => ({ name: e.name, mtime: safeMtime(join17(dir2, e.name)) })).sort((a, b) => b.mtime - a.mtime).map((e) => e.name);
   }
   readRun(runId) {
     const dir2 = join17(paths.runs(this.root), runId);
     const runFile = join17(dir2, "run.json");
-    if (!existsSync5(runFile))
+    if (!existsSync6(runFile))
       return void 0;
     try {
       const parsed = JSON.parse(readFileSync4(runFile, "utf8"));
       const traceFile = join17(dir2, "trace.json");
-      const trace = existsSync5(traceFile) ? JSON.parse(readFileSync4(traceFile, "utf8")) : void 0;
+      const trace = existsSync6(traceFile) ? JSON.parse(readFileSync4(traceFile, "utf8")) : void 0;
       return { id: runId, dir: dir2, run: parsed.run, findings: parsed.findings, trace, mtimeMs: safeMtime(dir2) };
     } catch {
       return void 0;
@@ -18858,7 +19207,7 @@ var ProjectReader = class {
   }
   readAppModel() {
     const file = paths.appModel(this.root);
-    if (!existsSync5(file))
+    if (!existsSync6(file))
       return void 0;
     try {
       return JSON.parse(readFileSync4(file, "utf8"));
@@ -18868,7 +19217,7 @@ var ProjectReader = class {
   }
   readIntents() {
     const file = paths.intents(this.root);
-    if (!existsSync5(file))
+    if (!existsSync6(file))
       return [];
     try {
       return JSON.parse(readFileSync4(file, "utf8")).intents ?? [];
@@ -18879,7 +19228,7 @@ var ProjectReader = class {
   /** Progress for a run currently in flight, if one is. */
   readLive() {
     const file = paths.live(this.root);
-    if (!existsSync5(file))
+    if (!existsSync6(file))
       return void 0;
     try {
       return JSON.parse(readFileSync4(file, "utf8"));
@@ -18889,7 +19238,7 @@ var ProjectReader = class {
   }
   readConfigRaw() {
     const file = paths.config(this.root, this.configFile);
-    return existsSync5(file) ? readFileSync4(file, "utf8") : void 0;
+    return existsSync6(file) ? readFileSync4(file, "utf8") : void 0;
   }
 };
 function summarize(record) {
@@ -18923,14 +19272,14 @@ function safeMtime(path) {
 }
 
 // ../dashboard/dist/server.js
-import { createReadStream, existsSync as existsSync6, realpathSync, statSync as statSync3, watch } from "node:fs";
+import { createReadStream, existsSync as existsSync8, realpathSync, statSync as statSync3, watch } from "node:fs";
 import { createServer as createServer4 } from "node:http";
-import { extname as extname2, join as join19, relative as relative8, resolve as resolve16, sep as sep5 } from "node:path";
+import { extname as extname2, join as join19, relative as relative10, resolve as resolve16, sep as sep5 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../dashboard/dist/agents.js
-import { readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
-import { basename as basename4, dirname as dirname6, extname, join as join18, relative as relative7, sep as sep4 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
+import { basename as basename4, dirname as dirname6, extname, join as join18, relative as relative9, sep as sep4 } from "node:path";
 var roles2 = ["explorer", "judge", "fixer"];
 var severity = { critical: 0, major: 1, minor: 2, cosmetic: 3 };
 var open2 = /* @__PURE__ */ new Set(["new", "filed", "fixing", "fix-proposed"]);
@@ -19064,7 +19413,26 @@ var AgentReader = class {
     const routine = this.routines().find((entry) => entry.id === issue.evidence?.routineId);
     const ids = new Set(issue.candidateIds);
     const candidates = this.sessions(Infinity).flatMap((session) => jsonLines(join18(paths.session(this.root, session.id), "candidates.jsonl"))).filter((candidate) => ids.has(candidate.id));
-    return { issue, fix, candidates, routine };
+    return {
+      issue,
+      fix,
+      gaveUpAfter: fix && this.gaveUpAfter(fix),
+      attemptDiffs: fix && this.attemptDiffs(fix),
+      candidates,
+      routine
+    };
+  }
+  /** Each attempt's diff file that exists, by attempt number, as an artifact path. */
+  attemptDiffs(fix) {
+    return Object.fromEntries((fix.attempts ?? []).map((attempt) => [attempt.n, paths.fixAttemptDiff(this.root, fix.id, attempt.n)]).filter(([, file]) => existsSync7(file)).map(([n, file]) => [n, relative9(this.root, file).split(sep4).join("/")]));
+  }
+  /** The fixer's attempt count, when this fix failed and reached the limit. CI fix attempts have their own limit. */
+  gaveUpAfter(fix) {
+    const limit = this.config()?.agents.fixer.attempts;
+    const count = fixerAttempts(fix.attempts).length;
+    if (fix.status !== "failed" || limit === void 0)
+      return void 0;
+    return count >= limit ? count : void 0;
   }
   screens() {
     const map = this.appmap();
@@ -19144,8 +19512,8 @@ var AgentReader = class {
     if (!review)
       return void 0;
     const recordings = walk(paths.reviewDir(this.root, pr)).map((file) => ({ file, kind: recordingKinds[extname(file).toLowerCase()] })).filter((entry) => Boolean(entry.kind)).map(({ file, kind }) => {
-      const path = relative7(this.root, file).split(sep4).join("/");
-      const inside2 = relative7(paths.reviewDir(this.root, pr), file);
+      const path = relative9(this.root, file).split(sep4).join("/");
+      const inside2 = relative9(paths.reviewDir(this.root, pr), file);
       const claimId = inside2.match(/\bclaim-\d+(?!\d)/)?.[0];
       const build = inside2.match(/\b(head|base)\b/)?.[1];
       return { path, kind, ...claimId ? { claimId } : {}, ...build ? { build } : {} };
@@ -19158,13 +19526,19 @@ var AgentReader = class {
   }
   /** Each role as the config sets it, in the same form as the runtime labels. */
   configuredAgents() {
+    const config = this.config();
+    if (!config)
+      return void 0;
+    return Object.fromEntries(roles2.map((role) => {
+      const { enabled, use } = config.agents[role];
+      const runtime = use.runtime === "cli" ? `cli:${use.command.split(/\s+/)[0]}` : `model:${use.via}/${use.model}`;
+      return [role, { enabled, runtime }];
+    }));
+  }
+  /** Undefined when the project has no config, unless the dashboard was given one. */
+  config() {
     try {
-      const config = loadConfig(this.root, {}, this.configFile);
-      return Object.fromEntries(roles2.map((role) => {
-        const { enabled, use } = config.agents[role];
-        const runtime = use.runtime === "cli" ? `cli:${use.command.split(/\s+/)[0]}` : `model:${use.via}/${use.model}`;
-        return [role, { enabled, runtime }];
-      }));
+      return loadConfig(this.root, {}, this.configFile);
     } catch (error) {
       if (this.configFile)
         throw error;
@@ -19270,9 +19644,10 @@ var MIME = {
   ".webm": "video/webm",
   ".cast": "application/x-asciicast",
   ".svg": "image/svg+xml",
-  ".json": "application/json; charset=utf-8"
+  ".json": "application/json; charset=utf-8",
+  ".diff": "text/x-diff; charset=utf-8"
 };
-var ARTIFACTS = [".png", ".jpg", ".jpeg", ".webp", ".gif", ".mp4", ".webm", ".cast", ".json"];
+var ARTIFACTS = [".png", ".jpg", ".jpeg", ".webp", ".gif", ".mp4", ".webm", ".cast", ".json", ".diff"];
 async function startDashboard(options) {
   const root2 = resolve16(options.root);
   const host = options.host ?? "127.0.0.1";
@@ -19383,7 +19758,7 @@ async function handle2(req, res, ctx) {
 }
 function resolveArtifactPath(root2, requested) {
   const candidate = resolve16(root2, requested);
-  if (!existsSync6(candidate))
+  if (!existsSync8(candidate))
     return void 0;
   let real;
   let allowed;
@@ -19393,7 +19768,7 @@ function resolveArtifactPath(root2, requested) {
   } catch {
     return void 0;
   }
-  const rel = relative8(allowed, real);
+  const rel = relative10(allowed, real);
   if (rel === "" || rel.startsWith("..") || rel.startsWith(`..${sep5}`))
     return void 0;
   const stat4 = statSync3(real);
@@ -19444,7 +19819,7 @@ function byteRange(header, size) {
 function serveUi(res, path) {
   const name = path === "/" ? "index.html" : path.replace(/^\//, "");
   const file = resolve16(UI_DIR, name);
-  if (!file.startsWith(UI_DIR) || !existsSync6(file) || !statSync3(file).isFile()) {
+  if (!file.startsWith(UI_DIR) || !existsSync8(file) || !statSync3(file).isFile()) {
     serveUi(res, "/");
     return;
   }
@@ -19485,7 +19860,7 @@ function watchProject(root2, onChange) {
     timer = setTimeout(onChange, 250);
   };
   const attach = () => {
-    if (!existsSync6(dir2))
+    if (!existsSync8(dir2))
       return;
     try {
       const next = watch(dir2, { recursive: true }, changed);
@@ -19502,17 +19877,17 @@ function watchProject(root2, onChange) {
     }
   };
   try {
-    watcher = existsSync6(dir2) ? watch(dir2, { recursive: true }, changed) : watch(root2, { recursive: false }, () => {
-      if (existsSync6(dir2))
+    watcher = existsSync8(dir2) ? watch(dir2, { recursive: true }, changed) : watch(root2, { recursive: false }, () => {
+      if (existsSync8(dir2))
         attach();
     });
     watcher.on("error", () => {
       watcher.close();
       fallback = setInterval(changed, 5e3);
     });
-    if (!existsSync6(dir2))
+    if (!existsSync8(dir2))
       probe = setInterval(() => {
-        if (existsSync6(dir2))
+        if (existsSync8(dir2))
           attach();
       }, 100);
     return {
@@ -19590,7 +19965,7 @@ import { chmod, mkdir as mkdir9, writeFile as writeFile12 } from "node:fs/promis
 import { join as join22, resolve as resolve17 } from "node:path";
 
 // ../cli/dist/commands/run.js
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join21 } from "node:path";
 
 // ../capture/dist/app-server.js
@@ -20279,7 +20654,7 @@ function severityRank2(f) {
 }
 
 // ../triage/dist/ledger.js
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
 var IntentLedger = class _IntentLedger {
   intents;
   constructor(intents = []) {
@@ -20287,7 +20662,7 @@ var IntentLedger = class _IntentLedger {
   }
   static load(root2) {
     const file = paths.intents(root2);
-    if (!existsSync7(file))
+    if (!existsSync9(file))
       return new _IntentLedger([]);
     const parsed = JSON.parse(readFileSync6(file, "utf8"));
     return new _IntentLedger(parsed.intents.map((i) => ({
@@ -20881,7 +21256,7 @@ async function captureOne(args) {
   });
   const key = baselineKeyFor(target.id, viewport.name);
   const baselinePath = store.pathFor(key);
-  if (!baselinePath || !existsSync8(baselinePath)) {
+  if (!baselinePath || !existsSync10(baselinePath)) {
     store.put(key, viewport.name, readFileSync7(actualPath));
     saveBaselineSnapshot(args.root, key, output2.snapshot);
     return {
@@ -20941,7 +21316,7 @@ function resolveTargets(config, model, options) {
 }
 function loadAppModel(root2) {
   const file = paths.appModel(root2);
-  if (!existsSync8(file))
+  if (!existsSync10(file))
     return void 0;
   try {
     return JSON.parse(readFileSync7(file, "utf8"));
@@ -20951,7 +21326,7 @@ function loadAppModel(root2) {
 }
 function loadBaselineSnapshot(root2, key) {
   const file = snapshotFile(root2, key);
-  if (!existsSync8(file))
+  if (!existsSync10(file))
     return void 0;
   try {
     return JSON.parse(readFileSync7(file, "utf8"));
@@ -21090,7 +21465,7 @@ function preflight(command, config, env = process.env) {
   if (problems.length)
     throw new ConfigError(problems.join("\n"));
 }
-async function runAgentCommand(command, args, root2, config, log) {
+async function runAgentCommand(command, args, root2, config, log, configFile) {
   const flags = parseAgentFlags(command, args);
   preflight(command, config);
   const workspace = new Workspace(root2);
@@ -21170,7 +21545,8 @@ ${problems.map((problem) => `- ${problem.split("\n")[0]}`).join("\n")}`);
         allowFork: Boolean(flags.allowFork),
         maxSteps: flags.steps,
         // Without the flag, agents.review.claims decides.
-        claims: flags.claims ? true : void 0
+        claims: flags.claims ? true : void 0,
+        configFile
       });
       const count = (verdict) => review.findings.filter((finding) => finding.verdict === verdict).length;
       const claims = review.claims ? `${review.claims.length} claim(s), ` : "";
@@ -21223,7 +21599,7 @@ ${problems.map((problem) => `- ${problem.split("\n")[0]}`).join("\n")}`);
     const result3 = await retestFix(root2, config, issue, fix, (fix.retests?.length ?? 0) + 1, { onLog: log });
     applyRetest(config, fix, result3);
     await workspace.saveFix(fix);
-    log(`Retest: ${result3.outcome} \u2014 ${result3.reason}`);
+    log(`Retest: ${result3.outcome}: ${result3.reason}`);
     return;
   }
   let app;
@@ -21289,13 +21665,13 @@ ${problems.map((problem) => `- ${problem.split("\n")[0]}`).join("\n")}`);
 
 // ../cli/dist/commands/doctor.js
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 function runChecks(root2, config) {
   const checks = [];
   checks.push({
     name: "config",
-    ok: existsSync9(paths.config(root2)),
-    detail: existsSync9(paths.config(root2)) ? `${paths.config(root2)} found` : legacyLayout(root2) ?? "No .bugpatrol/bugpatrol.yml. Run `bugpatrol init`.",
+    ok: existsSync11(paths.config(root2)),
+    detail: existsSync11(paths.config(root2)) ? `${paths.config(root2)} found` : legacyLayout(root2) ?? "No .bugpatrol/bugpatrol.yml. Run `bugpatrol init`.",
     fatal: true
   });
   const nodeMajor = Number(process.versions.node.split(".")[0]);
@@ -21345,14 +21721,14 @@ function runChecks(root2, config) {
   });
   checks.push({
     name: "app-model",
-    ok: existsSync9(paths.appModel(root2)),
-    detail: existsSync9(paths.appModel(root2)) ? "AppModel present" : "No AppModel. Run `bugpatrol recon`.",
+    ok: existsSync11(paths.appModel(root2)),
+    detail: existsSync11(paths.appModel(root2)) ? "AppModel present" : "No AppModel. Run `bugpatrol recon`.",
     fatal: false
   });
   checks.push({
     name: "intent-ledger",
     ok: true,
-    detail: existsSync9(paths.intents(root2)) ? "Intent Ledger present" : "No Intent Ledger yet (created on first accept)",
+    detail: existsSync11(paths.intents(root2)) ? "Intent Ledger present" : "No Intent Ledger yet (created on first accept)",
     fatal: false
   });
   return checks;
@@ -21384,12 +21760,12 @@ function doctorExitCode(checks) {
 
 // ../cli/dist/commands/init.js
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { appendFileSync, existsSync as existsSync11, mkdirSync as mkdirSync6, readdirSync as readdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join24, relative as relative9 } from "node:path";
+import { appendFileSync, existsSync as existsSync13, mkdirSync as mkdirSync6, readdirSync as readdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join24, relative as relative11 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // ../recon/dist/bringup.js
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "node:fs";
 import { join as join23 } from "node:path";
 function detectBringUp(root2) {
   const candidates = [];
@@ -21406,7 +21782,7 @@ function detectBringUp(root2) {
     }
   }
   const pkgPath = join23(root2, "package.json");
-  if (existsSync10(pkgPath)) {
+  if (existsSync12(pkgPath)) {
     const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
     const manager = detectPackageManager(root2);
     for (const script of ["dev", "start", "preview", "serve"]) {
@@ -21420,7 +21796,7 @@ function detectBringUp(root2) {
       }
     }
   }
-  if (existsSync10(join23(root2, "docker-compose.yml")) || existsSync10(join23(root2, "compose.yaml"))) {
+  if (existsSync12(join23(root2, "docker-compose.yml")) || existsSync12(join23(root2, "compose.yaml"))) {
     candidates.push({
       command: "docker compose up",
       rung: "convention",
@@ -21428,17 +21804,17 @@ function detectBringUp(root2) {
       confidence: 0.5
     });
   }
-  if (existsSync10(join23(root2, "Procfile"))) {
+  if (existsSync12(join23(root2, "Procfile"))) {
     candidates.push({ command: "foreman start", rung: "convention", source: "Procfile", confidence: 0.3 });
   }
   return candidates.sort((a, b) => b.confidence - a.confidence);
 }
 function detectPackageManager(root2) {
-  if (existsSync10(join23(root2, "pnpm-lock.yaml")))
+  if (existsSync12(join23(root2, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync10(join23(root2, "bun.lockb")))
+  if (existsSync12(join23(root2, "bun.lockb")))
     return "bun";
-  if (existsSync10(join23(root2, "yarn.lock")))
+  if (existsSync12(join23(root2, "yarn.lock")))
     return "yarn";
   return "npm";
 }
@@ -21459,7 +21835,7 @@ function detectStack(root2) {
     ["app.json", "expo"]
   ];
   for (const [file, name] of signatures) {
-    if (!existsSync10(join23(root2, file)))
+    if (!existsSync12(join23(root2, file)))
       continue;
     framework ??= name;
     detectedFrom.push(file);
@@ -21475,7 +21851,7 @@ function detectStack(root2) {
 }
 function listWorkflows(root2) {
   const dir2 = join23(root2, ".github", "workflows");
-  if (!existsSync10(dir2))
+  if (!existsSync12(dir2))
     return [];
   try {
     return readdirSync4(dir2).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml")).map((f) => join23(dir2, f));
@@ -21553,7 +21929,7 @@ function xcodeProjects(root2) {
   return [".", "ios"].flatMap((dir2) => list2(join24(root2, dir2)).filter((name) => name.endsWith(".xcodeproj")).map((name) => join24(root2, dir2, name, "project.pbxproj")));
 }
 function gradleFiles(root2) {
-  return ["android/app", "app"].flatMap((dir2) => ["build.gradle", "build.gradle.kts"].map((file) => join24(root2, dir2, file))).filter((file) => existsSync11(file));
+  return ["android/app", "app"].flatMap((dir2) => ["build.gradle", "build.gradle.kts"].map((file) => join24(root2, dir2, file))).filter((file) => existsSync13(file));
 }
 function detectAppId(root2, platform) {
   const expo = readJson3(join24(root2, "app.json"))?.expo;
@@ -21600,7 +21976,7 @@ function detectPort(root2, pkg, framework) {
   };
 }
 function mobilePlatform(root2) {
-  const hasIos = xcodeProjects(root2).length > 0 || existsSync11(join24(root2, "app.json")) || existsSync11(join24(root2, "ios"));
+  const hasIos = xcodeProjects(root2).length > 0 || existsSync13(join24(root2, "app.json")) || existsSync13(join24(root2, "ios"));
   return process.platform === "darwin" && hasIos ? "ios" : "android";
 }
 function detectApp(root2) {
@@ -21612,8 +21988,8 @@ function detectApp(root2) {
     return { platform: "electron", start: "npx electron . --remote-debugging-port=9222", cdpPort: 9222, notes };
   }
   const reactNative = deps.expo || deps["react-native"];
-  const nativeIos = !existsSync11(join24(root2, "package.json")) && xcodeProjects(root2).length > 0;
-  const nativeAndroid = !existsSync11(join24(root2, "package.json")) && gradleFiles(root2).length > 0;
+  const nativeIos = !existsSync13(join24(root2, "package.json")) && xcodeProjects(root2).length > 0;
+  const nativeAndroid = !existsSync13(join24(root2, "package.json")) && gradleFiles(root2).length > 0;
   if (reactNative || nativeIos || nativeAndroid) {
     const platform = nativeIos ? "ios" : nativeAndroid ? "android" : mobilePlatform(root2);
     notes.push(`Platform ${platform}: detected from ${reactNative ? "package.json" : platform === "ios" ? "the Xcode project" : "the Gradle files"}.`);
@@ -21717,7 +22093,7 @@ Example: Sign in with the email {{TEST_EMAIL}} and the password {{TEST_PASSWORD}
 `;
 function ignoreData(root2) {
   const gitignore = join24(root2, ".gitignore");
-  const ignored = existsSync11(gitignore) ? readFileSync9(gitignore, "utf8") : "";
+  const ignored = existsSync13(gitignore) ? readFileSync9(gitignore, "utf8") : "";
   const lines = ignored.split("\n");
   const { dir: dir2 } = layout(root2);
   const line = `${dir2}/${DATA_DIR}/`;
@@ -21735,7 +22111,7 @@ ${line}
   return true;
 }
 function relativeConfig(root2) {
-  const shown = relative9(process.cwd(), paths.config(root2));
+  const shown = relative11(process.cwd(), paths.config(root2));
   return shown && !shown.startsWith("..") ? shown : paths.config(root2);
 }
 function writeInitialConfig(root2, answers) {
@@ -21743,14 +22119,14 @@ function writeInitialConfig(root2, answers) {
   mkdirSync6(paths.dir(root2), { recursive: true });
   const configPath = paths.config(root2);
   const configName = `${BUGPATROL_DIR}/${CONFIG_FILENAME}`;
-  if (existsSync11(configPath))
+  if (existsSync13(configPath))
     result3.skipped.push(configName);
   else {
     writeFileSync6(configPath, renderConfig(answers));
     result3.written.push(configName);
   }
   const guidePath = join24(paths.dir(root2), "instructions.md");
-  if (existsSync11(guidePath))
+  if (existsSync13(guidePath))
     result3.skipped.push(`${BUGPATROL_DIR}/instructions.md`);
   else {
     writeFileSync6(guidePath, INSTRUCTIONS);
@@ -21922,7 +22298,7 @@ async function runInit(root2, args, log) {
     log("\nNext: review the TODO markers, then run `bugpatrol doctor`.");
     return;
   }
-  if (existsSync11(paths.config(root2))) {
+  if (existsSync13(paths.config(root2))) {
     throw new ConfigError(`${relativeConfig(root2)} already exists. Edit it, or delete it and run init again.`);
   }
   const legacy = legacyLayout(root2);
@@ -22004,9 +22380,6 @@ run:
     timeoutMs: 60000
   seeds: []
 
-auth:
-  kind: none                   # none | form | storageState | seededUser | ssoBypass | manual
-
 viewports:
   - { name: desktop, width: 1440, height: 900 }
   - { name: mobile,  width: 390,  height: 844 }
@@ -22062,7 +22435,7 @@ production:
 `;
   const configPath = paths.config(root2);
   mkdirSync6(paths.dir(root2), { recursive: true });
-  if (!existsSync11(configPath))
+  if (!existsSync13(configPath))
     writeFileSync6(configPath, config);
   else
     notes.push(`${relativeConfig(root2)} already exists and was left untouched.`);
@@ -22110,7 +22483,7 @@ ${issues.length} issue(s). Status: new = filed by the judge, not on GitHub; file
         role: "judge",
         source: "human",
         scope: issue.screenId,
-        text: `Not a bug: ${issue.title} \u2014 ${reason2}`.slice(0, 200)
+        text: fitLesson(`Not a bug: ${issue.title} \u2014 ${reason2}`)
       }
     ]);
     log(`Dismissed ${issue.id}: ${issue.title}`);
@@ -22165,6 +22538,9 @@ async function runMemoryCommand(args, root2, log) {
     const text3 = args.slice(1).find((part, index, all) => !part.startsWith("--") && all[index - 1] !== "--role" && all[index - 1] !== "--scope");
     if (!role || !roles3.has(role) || !text3?.trim())
       throw new ConfigError('Usage: bugpatrol memory add --role explorer|judge|fixer "text" [--scope s]');
+    const tooLong = lessonTooLong(text3);
+    if (tooLong)
+      throw new ConfigError(tooLong);
     const [lesson] = await workspace.upsertLessons([
       { role, source: "human", scope: flag(args.slice(1), "--scope"), text: text3 }
     ]);
@@ -22361,7 +22737,7 @@ var COMMAND_HELP = {
   init: `bugpatrol init [flags]
   Find the app and the LLMs, and write .bugpatrol/bugpatrol.yml and .bugpatrol/instructions.md.
   --yes, -y              use the detected values, with no questions
-  --platform <p>         web | electron | ios | android
+  --platform <p>         web | electron | ios | android | api | desktop | cli
   --start "<command>"    the command that starts the app
   --url <url>            web: the app URL
   --app-id <id>          ios, android: the bundle ID or the package name
@@ -22461,7 +22837,7 @@ legacyEnv(process.env);
 var root = findProjectRoot(process.cwd());
 function version() {
   if (true)
-    return "0.2.1";
+    return "0.3.0";
   try {
     return JSON.parse(readFileSync10(new URL("../package.json", import.meta.url), "utf8")).version;
   } catch {
@@ -22539,7 +22915,7 @@ try {
     case "replay": {
       const config = readConfig();
       await runAgentCommand(command, args, root, config, (message2) => process.stdout.write(`${message2}
-`));
+`), selected.configFile);
       break;
     }
     case "promote": {
@@ -22606,7 +22982,7 @@ try {
         onReady: (url) => {
           process.stdout.write(`Bugpatrol dashboard on ${url}
 `);
-          process.stdout.write("Watching .bugpatrol/runs/ \u2014 runs appear as they finish. Ctrl-C to stop.\n");
+          process.stdout.write("Watching .bugpatrol/runs/: runs appear as they finish. Ctrl-C to stop.\n");
         }
       });
       const stop = () => {