bughunters 0.1.0 → 0.1.2

package/dist/bin.js

@@ -197,8 +197,6 @@ var toleranceSchema = z.object({
   })).default([])
 }).default({});
 var decisionsSchema = z.object({
-  decider: z.enum(["jev", "model"]).default("jev"),
-  jev: z.object({ via: z.enum(["auto", "typesafe", "openrouter", "vercel"]).default("auto") }).default({}),
   model: z.object({
     via: z.enum(["auto", "openrouter", "vercel", "openai", "anthropic", "custom"]).default("auto"),
     name: z.string().default("")
@@ -310,17 +308,39 @@ function runtimeFor(role, fallback) {
 var roleBase = {
   enabled: z.boolean().default(true),
   maxSteps: z.number().int().positive().default(60),
-  budgetUsd: z.number().nonnegative().default(0.5),
+  /** A cost limit for one session, in USD. No default: the team decides. */
+  budgetUsd: z.number().nonnegative().optional(),
   timeoutMs: z.number().int().positive().default(20 * 60 * 1e3)
 };
+var AGENT_CHECKS = [
+  "usability/contrast",
+  "usability/tap-target",
+  "layout/overlap",
+  "layout/overflow",
+  "layout/occlusion",
+  "layout/zero-size-interactive",
+  "layout/off-viewport",
+  "layout/horizontal-scroll",
+  "layout/shift-versus-baseline",
+  "rendering/broken-imagery",
+  "rendering/unstyled-content",
+  "pixel-diff"
+];
 var agentsSchema = z.object({
+  /** Automatic checks on each recorded screen, for example [usability/contrast, usability/tap-target]. */
+  checks: z.array(z.enum(AGENT_CHECKS)).default([]),
   memory: z.object({
     enabled: z.boolean().default(true),
     maxPerSession: z.number().int().positive().default(5),
     reflectMaxSteps: z.number().int().positive().default(10),
-    reflectBudgetUsd: z.number().nonnegative().default(0.05)
+    reflectBudgetUsd: z.number().nonnegative().optional()
+  }).default({}),
+  explorer: z.object({
+    ...roleBase,
+    use: runtimeFor("explorer", { runtime: "model" }),
+    /** Full coverage needs many actions: one step is one tool call. */
+    maxSteps: z.number().int().positive().default(150)
   }).default({}),
-  explorer: z.object({ ...roleBase, use: runtimeFor("explorer", { runtime: "model" }) }).default({}),
   judge: z.object({
     ...roleBase,
     use: runtimeFor("judge", { runtime: "model" })
@@ -340,7 +360,7 @@ var agentsSchema = z.object({
       /** Fix attempts in total; each attempt after the first gets the last verdict as feedback. */
       attempts: z.number().int().positive().default(2),
       maxSteps: z.number().int().positive().default(30),
-      budgetUsd: z.number().nonnegative().default(0.2)
+      budgetUsd: z.number().nonnegative().optional()
     }).default({}),
     minSeverity: z.enum(["cosmetic", "minor", "major", "critical"]).default("minor"),
     /**
@@ -359,12 +379,25 @@ var agentsSchema = z.object({
     assetsBranch: z.string().default("bughunters-assets"),
     labels: z.array(z.string()).default(["bughunters"]),
     /** The scope in PR titles, e.g. 'app'. Default: the scope in fixer.commitMessage. */
-    prScope: z.string().optional()
+    prScope: z.string().optional(),
+    /** After a PR opens, wait for its CI checks, and let the fixer fix a failed check. */
+    ci: z.object({
+      enabled: z.boolean().default(true),
+      /** Fixer attempts for each PR before Bughunters gives up and tells the team. */
+      attempts: z.number().int().nonnegative().default(2),
+      /** How long one cycle waits for pending checks. */
+      waitMinutes: z.number().nonnegative().default(20)
+    }).default({})
   }).default({}),
   patrol: z.object({
     intervalMinutes: z.number().positive().default(30),
     /** Stop after this many cycles; 0 means run until stopped. */
-    cycles: z.number().int().nonnegative().default(0)
+    cycles: z.number().int().nonnegative().default(0),
+    /**
+     * At the start of each cycle, fetch this `remote/branch` and check out its
+     * latest commit (detached) in the source repository. false keeps the checkout.
+     */
+    pull: z.union([z.string().regex(/^[^/]+\/.+$/, "Use remote/branch, e.g. origin/main"), z.literal(false)]).default("origin/main")
   }).default({})
 }).default({});
 var bughuntersConfigSchema = z.object({
@@ -695,9 +728,10 @@ Agents
   bughunters fix [--issue <id>...]
   bughunters retest --issue <id>
   bughunters publish [--issue <id>] [--dry-run]
+  bughunters ci [--issue <id>] [--wait]
   bughunters github sync
   bughunters worktrees clean
-  bughunters patrol [--once]
+  bughunters patrol [--once] [--force]
   bughunters replay <routine-id>
   bughunters issue list | dismiss <id> --reason "..." [--by name] | reopen <id>
   bughunters memory list [--role r] | add --role r "text" [--scope s]
@@ -743,7 +777,6 @@ var COMMAND_HELP = {
   --app-id <id>          ios, android: the bundle ID or the package name
   --agent <a>            the LLM for all agents: claude | codex | kimi | pi | openrouter | vercel | openai | anthropic
   --explorer, --judge, --fixer <a>   the LLM for one agent
-  --jev <route>          auto | typesafe | openrouter | vercel
   --gate                 write a starter config for the deterministic web gate
 `,
   explore: `bughunters explore [--goal "..."] [--steps N]
@@ -772,10 +805,20 @@ var COMMAND_HELP = {
   --dry-run       write the reports to .bughunters/runs/publish/, and open nothing
   --issue <id>    publish this issue only
 `,
-  patrol: `bughunters patrol [--once]
+  ci: `bughunters ci [--issue <id>]... [--wait]
+  Read the CI checks of each open Bughunters PR. When a check fails, the fixer gets its log,
+  and Bughunters pushes the new commit to the PR branch. After agents.github.ci.attempts tries, it stops.
+  The patrol runs this step after publish.
+  --wait          wait for the running checks, up to agents.github.ci.waitMinutes
+  --issue <id>    only the PR of this issue
+`,
+  patrol: `bughunters patrol [--once] [--force]
   Run the full cycle again and again: setup, explore, judge, teardown, fix, retest, publish.
   The fixer and GitHub steps run only when you turn them on.
+  Explore and judge run only when the commit changed since the last full cycle. The fixes, retests,
+  publish, and CI checks run in each cycle.
   --once          run one cycle, then stop
+  --force         explore and judge in the first cycle also when the commit did not change
 `,
   github: `bughunters github sync
   Read the state of each PR and issue from GitHub. A closed PR becomes a lesson. An issue closed as not planned becomes a dismissal.
@@ -910,9 +953,9 @@ async function startApp(app, opts) {
         if (command2.readyWhen) {
           const ready = new RegExp(command2.readyWhen);
           await new Promise((done, reject) => {
-            const wait = setTimeout(() => finish(new Error("timed out waiting for ready output")), command2.timeoutMs);
+            const wait2 = setTimeout(() => finish(new Error("timed out waiting for ready output")), command2.timeoutMs);
             const finish = (error) => {
-              clearTimeout(wait);
+              clearTimeout(wait2);
               child.stdout?.off("data", check);
               child.stderr?.off("data", check);
               child.off("exit", onExit);
@@ -1037,8 +1080,8 @@ function serialized(file, update) {
 }
 async function listJson(dir) {
   try {
-    const files = (await readdir(dir)).filter((file) => file.endsWith(".json"));
-    return Promise.all(files.map(async (file) => await readJson(join3(dir, file))));
+    const files2 = (await readdir(dir)).filter((file) => file.endsWith(".json"));
+    return Promise.all(files2.map(async (file) => await readJson(join3(dir, file))));
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -1222,8 +1265,8 @@ var Workspace = class {
   async saveScreenshot(sessionId, png, label) {
     const dir = paths.session(this.root, sessionId);
     await mkdir(dir, { recursive: true });
-    const files = await readdir(dir);
-    const number = files.filter((file2) => /^\d{3}-.*\.png$/.test(file2)).length + 1;
+    const files2 = await readdir(dir);
+    const number = files2.filter((file2) => /^\d{3}-.*\.png$/.test(file2)).length + 1;
     const file = join3(dir, `${String(number).padStart(3, "0")}-${basename(label).replace(/[^a-zA-Z0-9_-]/g, "-")}.png`);
     await writeFile(file, png);
     return relative(this.root, file);
@@ -1456,64 +1499,7 @@ function toMcp(part) {
 import { accessSync, constants } from "node:fs";
 import { delimiter, join as join5 } from "node:path";
 
-// ../decide/dist/providers/jev.js
-var JevDecider = class {
-  options;
-  name = "jev";
-  endpoint;
-  model;
-  lastUsage;
-  timeoutMs;
-  constructor(options) {
-    this.options = options;
-    this.endpoint = options.endpoint ?? "https://api.typesafe.ai/v1/systemone";
-    this.model = options.model ?? "jev-latest";
-    this.timeoutMs = options.timeoutMs ?? 1e4;
-  }
-  async ask(state, questions) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-    try {
-      const response3 = await fetch(this.endpoint, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${this.options.apiKey}`
-        },
-        // Every question is evaluated against the same state in one call, so
-        // the entire per-screen analysis is a single round trip.
-        body: JSON.stringify({
-          model: this.model,
-          state,
-          questions: Object.fromEntries(Object.entries(questions).map(([id2, question]) => [
-            id2,
-            question.type === "score" ? { type: "score", instructions: question.instructions, criteria: question.legend } : question
-          ]))
-        }),
-        signal: controller.signal
-      });
-      if (!response3.ok) {
-        throw new InfrastructureError(`Jev returned ${response3.status}: ${await safeText(response3)}`);
-      }
-      const body = await response3.json();
-      this.lastUsage = usageFrom(body.usage) ?? { input: Math.ceil(state.length / 4), output: 0, estimated: true };
-      return normalizeAnswers(body.answers ?? {}, questions);
-    } catch (cause) {
-      if (cause instanceof InfrastructureError)
-        throw cause;
-      throw new InfrastructureError("Jev request failed", { cause });
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-};
-async function safeText(response3) {
-  try {
-    return (await response3.text()).slice(0, 400);
-  } catch {
-    return "<no body>";
-  }
-}
+// ../decide/dist/answers.js
 function normalizeAnswers(raw, questions) {
   const out = {};
   for (const [key, question] of Object.entries(questions)) {
@@ -1940,19 +1926,11 @@ var Budget = class {
     return { spentUsd: this.spent, capUsd: this.capUsd };
   }
 };
-var JEV_USD_PER_INPUT_TOKEN = 0.042 / 1e6;
-function estimateDecisionCost(stateChars, decider = "jev") {
-  if (decider === "jev")
-    return stateChars / 4 * JEV_USD_PER_INPUT_TOKEN;
+function estimateDecisionCost(stateChars) {
   return ((stateChars / 4 + 1500) * 3 + 900 * 15) / 1e6;
 }
 
 // ../decide/dist/index.js
-var JEV_ROUTES = {
-  typesafe: { key: "TYPESAFE_API_KEY", endpoint: "https://api.typesafe.ai/v1/systemone", model: "jev-latest" },
-  openrouter: { key: "OPENROUTER_API_KEY", endpoint: "https://openrouter.ai/api/v1/systemone", model: "jev-latest" },
-  vercel: { key: "AI_GATEWAY_API_KEY", endpoint: "https://ai-gateway.vercel.sh/typesafe/v1/systemone", model: "typesafe-ai/jev" }
-};
 var MODEL_KEYS = {
   openrouter: "OPENROUTER_API_KEY",
   vercel: "AI_GATEWAY_API_KEY",
@@ -1960,24 +1938,8 @@ var MODEL_KEYS = {
   anthropic: "ANTHROPIC_API_KEY",
   custom: "BUGHUNTERS_MODEL_API_KEY"
 };
-var jevOrder = ["typesafe", "openrouter", "vercel"];
 var modelOrder = ["openrouter", "vercel", "openai", "anthropic", "custom"];
 function resolveDecider(config, env) {
-  let jevMissing = "";
-  if (config.decider === "jev") {
-    const routes2 = config.jev.via === "auto" ? jevOrder : [config.jev.via];
-    for (const via of routes2) {
-      const route2 = JEV_ROUTES[via];
-      const key = env[route2.key];
-      if (key)
-        return {
-          decider: new JevDecider({ apiKey: key, endpoint: route2.endpoint, model: route2.model }),
-          via: `jev:${via}`,
-          reason: `Decider: jev via ${via} (${route2.model}).`
-        };
-    }
-    jevMissing = `decider is jev, but no ${routes2.map((via) => JEV_ROUTES[via].key).join(", ").replace(/, ([^,]*)$/, " or $1")} is set`;
-  }
   const routes = config.model.via === "auto" ? modelOrder : [config.model.via];
   for (const via of routes) {
     const key = env[MODEL_KEYS[via]];
@@ -1988,14 +1950,11 @@ function resolveDecider(config, env) {
     return {
       decider: new ModelDecider({ via, apiKey: key, endpoint, model: name }),
       via: `model:${via}`,
-      reason: jevMissing ? `Decider: model via ${via} (${name}) because ${jevMissing}.` : `Decider: model via ${via} (${name}).`
+      reason: `Decider: model via ${via} (${name}).`
     };
   }
-  const modelMissing = routes.map((via) => via === "custom" ? "BUGHUNTERS_MODEL_ENDPOINT and BUGHUNTERS_MODEL_API_KEY" : MODEL_KEYS[via]).join(", ").replace(/, ([^,]*)$/, " or $1");
-  return {
-    via: "none",
-    reason: `Decider: none, so the judge decides each finding, because ${jevMissing ? `${jevMissing}, and ` : ""}no ${modelMissing} is set. Set a Jev key to cut cost.`
-  };
+  const missing2 = routes.map((via) => via === "custom" ? "BUGHUNTERS_MODEL_ENDPOINT and BUGHUNTERS_MODEL_API_KEY" : MODEL_KEYS[via]).join(", ").replace(/, ([^,]*)$/, " or $1");
+  return { via: "none", reason: `Decider: none, because no ${missing2} is set.` };
 }
 
 // ../agents/dist/runtime/cli.js
@@ -2187,7 +2146,7 @@ var ModelRuntime = class {
           return outcome("done", calls.output);
         }
       }
-      if (costUsd >= task.budgetUsd) {
+      if (task.budgetUsd !== void 0 && costUsd >= task.budgetUsd) {
         return outcome("budget", lastText);
       }
     }
@@ -2565,7 +2524,6 @@ var AgentSession = class {
   lastScreenTrailIndex = 0;
   /** Where the app was when lastScreenId was recorded. */
   lastScreenLocation;
-  decisionSpentUsd = 0;
   /** Issues already counted as seen again in this session. */
   seenIssues = /* @__PURE__ */ new Set();
   cancelled = false;
@@ -2664,6 +2622,26 @@ ${lessons.map((lesson) => `- [${lesson.scope ?? "app"}] ${lesson.text}`).join("\
 
 ` : "";
 }
+var MEMORY = {
+  explorer: `- How to reach a screen that is hard to find, or a control that needs a special action.
+- How the app behaves in a way that looks wrong but is correct, for example a slow screen or a test account limit.`,
+  judge: `- A behavior that the team or the code shows is intended, so the explorer does not report it again.
+- For the fixer: why a fix did not work, when the screenshots or the logs show the cause.`,
+  fixer: `- Where the code for a feature lives, or a file that must change together with another file.
+- How to build, test, or run this codebase, for example a platform file (.web.tsx, .ios.tsx) that the app loads.
+- Why an earlier change did not work, when you find the cause.`
+};
+function memoryPart(role) {
+  return `MEMORY
+If you have the save_lesson tool, use it when you learn a lasting fact about this app or its code that a
+later session needs. Write one short, specific sentence. Use "for" to save it for another role. Save facts
+such as these:
+${MEMORY[role]}
+Do not save the details of one bug, or a fact that the app guide or a lesson already says.
+When save_lesson shows a similar lesson, confirm it with "same" if it has the same meaning.
+
+`;
+}
 function explorerCommon(platform, instructions, lessons = []) {
   return `HOW THE TOOLS WORK
 - Each action tool returns a screenshot and a list of elements. Refs such as [e12] are valid only for
@@ -2679,24 +2657,38 @@ RULES
 - Do not use the same failed action more than two times. Try another way, or report the problem.
 - Keep your notes short. Spend your steps on actions, not on long thoughts.
 
-${lessonPart(lessons)}APP GUIDE
+${memoryPart("explorer")}${lessonPart(lessons)}APP GUIDE
 ${instructions.trim() || "(No guide was given. Explore carefully and do not change any data.)"}`;
 }
-function explorerSystem(platform, instructions, lessons = []) {
+function explorerSystem(platform, instructions, lessons = [], checks = []) {
+  const automatic = checks.length ? `record_screen also runs automatic checks (${checks.join(", ")}) and sends what they find to the QA lead.
+Do not report those findings again with report_bug. Report what the checks cannot see.
+` : "";
   return `You are the explorer on an automated QA team. You use the app through tools, like a careful
 human tester, and you look for problems that a real user would notice.
 
-YOUR JOB, IN ORDER
+YOUR JOB IS FULL COVERAGE
+Your goal is to reach every screen of the app and to use every control on each screen. A bug hides in
+the screen or the button that nobody opened. Partial coverage is a failed session.
+
 1. Enter the app. Follow the app guide below. When you are in the app, call save_routine with the id
    "enter-app" at once.
 2. Record each screen that you see for the first time, before you do anything on it. Call record_screen
    with a short kebab-case id, a name, and one sentence about what the screen is for. A dialog, a sheet,
-   or a menu with its own content is a screen too.
+   a menu, a tab, or a modal with its own content is a screen too.
 3. Explore breadth first. Visit each item of the main navigation before you go deep into one area.
-4. Report every problem with report_bug as soon as you see it, with the screenshot on screen. Then
+4. On each screen, use every control that is safe: each button, link, tab, toggle, menu, list row,
+   icon button, and field. Open each menu and each dialog, look at it, then close it. Scroll to the end
+   of each list and each page, and use what appears. Try an empty and a wrong value in each form.
+5. Keep a list in your notes of the controls and the screens that you did not try yet. Go back to them.
+   When a screen is done, go to the next screen that you did not visit.
+6. Report every problem with report_bug as soon as you see it, with the screenshot on screen. Then
    continue. Do not stop at the first problem.
-5. Before your steps run out, call finish with a summary: the screens you covered, the problems you
-   reported, and the areas you did not reach.
+7. Do not spend steps on waits and repeats. Wait for a slow screen at most two times. Use run_routine to
+   go back to a known screen quickly.
+8. Call finish only when you tried every screen and every control that you found, or when your steps are
+   almost gone. The summary names the screens you covered, the problems you reported, and the screens and
+   controls that you did not reach, so the next session starts there.
 
 WHAT TO REPORT
 - A control that does nothing, or does the wrong thing.
@@ -2704,15 +2696,16 @@ WHAT TO REPORT
 - Layout that is broken: content off screen, elements on top of each other, empty gaps, wrong alignment.
 - Wrong, missing, or contradictory data. Placeholder text such as "undefined", "NaN", "null", or "{{".
 - Error messages, crash screens, blank screens.
+- Console errors and failed requests. The tools list them under "Console errors" and "Failed requests".
+  Report one when it breaks what the user sees or does, for example data that does not load or an action
+  that fails. Name the error in what_is_wrong. Do not report noise that has no effect on the user.
 - Use the id from record_screen for the screen you are on when you call report_bug. Use 'unrecorded' if needed.
 - A loading state that does not end. If a screen still shows a spinner or skeleton rows after two waits
   of 10 seconds, report it as a bug and continue somewhere else. Do not wait again and again.
 - A dead end: a screen with no way back.
 - Inconsistent UI: the same thing named or styled in two different ways.
 Do not report the things that the app guide tells you to ignore.
-record_screen runs automatic checks (contrast, overlap, tap size, visual change) and sends what they find
-to the QA lead. Do not report those findings again with report_bug. Report what the checks cannot see.
-
+${automatic}
 ${explorerCommon(platform, instructions, lessons)}`;
 }
 function explorerRetestSystem(platform, instructions, lessons = []) {
@@ -2736,7 +2729,9 @@ Call view_retest to inspect the before and after screenshots. Then call verdict.
 fixed: the problem is gone on EVERY affected screen and nothing new is broken.
 not-fixed: the problem is still visible on at least one screen. Name it.
 unclear: the explorer did not reach at least one screen and none shows the problem still present. Name the missing screens.
-${lessonPart(lessons)}`;
+Give a cause only when the screenshots or the logs show it. Do not guess one.
+
+${memoryPart("judge")}${lessonPart(lessons)}`;
 }
 function explorerPrompt(input) {
   const screens = input.screens.length ? input.screens.map((screen) => `- ${screen.id}: ${screen.name}. ${screen.description}`).join("\n") : "(none yet)";
@@ -2744,7 +2739,7 @@ function explorerPrompt(input) {
     const health = routine.lastReplay ? routine.lastReplay.ok ? "works" : routine.lastReplay.onFixBuild ? "BROKEN (seen on a fix build), repair it" : "BROKEN, repair it" : "not replayed";
     return `- ${routine.id} (${routine.steps.length} steps, ${health}): ${routine.description}`;
   }).join("\n") : "(none yet)";
-  const goal = input.goal ?? (input.screens.length ? 'Enter the app. If "enter-app" works, use run_routine for it. Then look for screens that are NOT in the known list below, and record and test each one. Revisit a known screen only to test something new on it.' : "This is the first visit. Enter the app, then map as many screens as you can and report every problem.");
+  const goal = input.goal ?? (input.screens.length ? 'Enter the app. If "enter-app" works, use run_routine for it. Then find the screens that are NOT in the known list below, and record and test each one. On a known screen, use each control that an earlier session did not try. The goal is every screen and every control of the app.' : "This is the first visit. Enter the app, then map every screen that you can reach, use every safe control on each one, and report every problem.");
   return `GOAL
 ${goal}
 
@@ -2798,11 +2793,12 @@ HOW TO WRITE AN ISSUE
 
 Be strict. A report that nobody can act on costs the team time. When you have decided every candidate,
 call finish with one sentence per decision.
-${lessonPart(lessons)}`;
+
+${memoryPart("judge")}${lessonPart(lessons)}`;
 }
 function judgePrompt(sessionIds, candidates, issues) {
   const list3 = candidates.map((candidate) => {
-    const route2 = candidate.route ? ` Decider: ${candidate.route.reason}` : "";
+    const route2 = candidate.route ? ` Route: ${candidate.route.reason}` : "";
     return `- ${candidate.id} [${candidate.source}, ${candidate.severity}] on ${candidate.screenId ?? "unknown screen"}: ${candidate.summary}.${route2}`;
   }).join("\n");
   const open2 = issues.filter((issue) => issue.status !== "dismissed" && issue.status !== "fixed");
@@ -2855,7 +2851,111 @@ a QA lead confirmed it. Fix the cause, not the symptom.
   your summary, with the file and line. Bughunters shows your explanation to the team.
 - Do not commit and do not push. Bughunters commits the change on its own branch.
 - End with a short summary: the cause, the change, and what you ran to verify it.
-${lessonPart(lessons)}`;
+
+${memoryPart("fixer")}${lessonPart(lessons)}`;
+}
+
+// ../agents/dist/tools/memory.js
+var roles = ["explorer", "judge", "fixer"];
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "that",
+  "this",
+  "from",
+  "into",
+  "not",
+  "are",
+  "was",
+  "has",
+  "have",
+  "its",
+  "use",
+  "when",
+  "then",
+  "than",
+  "there",
+  "can",
+  "does",
+  "will",
+  "must",
+  "only",
+  "also",
+  "you"
+]);
+function words(text3) {
+  return new Set(text3.toLowerCase().match(/[a-z0-9_.:/-]+/g)?.map((word) => word.replace(/[.:]+$/, "").replace(/s$/, "")).filter((word) => word.length > 2 && !STOP.has(word)) ?? []);
+}
+function similarLesson(lessons, role, text3) {
+  const mine = words(text3);
+  let best;
+  for (const lesson of lessons) {
+    if (lesson.role !== role || lesson.retired)
+      continue;
+    const theirs = words(lesson.text);
+    const shared = [...mine].filter((word) => theirs.has(word)).length;
+    const score = shared / Math.max(1, Math.min(mine.size, theirs.size));
+    if (shared >= 4 && score >= 0.6 && (!best || score > best.score))
+      best = { lesson, score };
+  }
+  return best?.lesson;
+}
+function lessonTools(session, role) {
+  const memory = session.config.agents.memory;
+  if (!memory.enabled)
+    return [];
+  let saved = 0;
+  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.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string" },
+        for: { type: "string", enum: roles },
+        scope: { type: "string", description: "A screen id, or leave it out for the whole app." },
+        same: { type: "string", description: "The id of a saved lesson that has the same meaning. It confirms that lesson, and saves no new one." },
+        different: { type: "boolean", description: "true saves the lesson also when a similar lesson exists." }
+      },
+      required: ["text"],
+      additionalProperties: false
+    },
+    async run(input) {
+      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);
+      if (!text3)
+        return { content: [{ type: "text", text: "The lesson needs a text." }], isError: true };
+      const target = roles.includes(input.for) ? input.for : role;
+      const { lessons } = await session.workspace.readMemory();
+      const confirmed = input.same ? lessons.find((lesson2) => lesson2.id === input.same && !lesson2.retired) : void 0;
+      if (confirmed) {
+        await session.workspace.upsertLessons([{
+          role: confirmed.role,
+          text: confirmed.text,
+          source: confirmed.source,
+          scope: confirmed.scope
+        }]);
+        return { content: [{ type: "text", text: `Confirmed ${confirmed.id}. It has one more hit now.` }] };
+      }
+      const similar = input.different === true ? void 0 : similarLesson(lessons, target, text3);
+      if (similar && similar.text.toLowerCase() !== text3.toLowerCase()) {
+        return { content: [{ type: "text", text: `The ${target} already has a similar lesson: ${similar.id}: "${similar.text}" If it has the same meaning, call save_lesson with same: "${similar.id}". If your lesson tells something new, call it again with different: true.` }] };
+      }
+      const [lesson] = await session.workspace.upsertLessons([{
+        role: target,
+        text: text3,
+        source: "agent",
+        scope: input.scope ? String(input.scope) : void 0
+      }]);
+      saved++;
+      session.emit({ kind: "lesson", summary: `Learned (${target}): ${lesson.text}` });
+      return { content: [{ type: "text", text: `Saved ${lesson.id} for the ${target}.` }] };
+    }
+  }];
 }
 
 // ../agents/dist/roles/fixer.js
@@ -3197,10 +3297,10 @@ ${issue.body}
 Evidence:
 ${evidence}
 Reproduction: ${repro}` + (last ? `
-Your last change did not fix the issue. The QA lead said: ${last.reason}. After screenshots:
+Your last change did not fix the issue in the running app. The QA lead said: ${last.reason}. After screenshots:
 ${after}
-Fix it now.` : ""),
-    tools: runtime.label.startsWith("cli:") ? [finishTool()] : [...modelTools(worktree), finishTool()],
+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
@@ -3227,12 +3327,12 @@ function stepWords(step) {
 }
 
 // ../agents/dist/github.js
-var defaultGh = (args2, opts) => new Promise((resolve10, reject) => {
+var defaultGh = (args2, opts) => new Promise((resolve12, reject) => {
   const child = execFile2("gh", args2, { cwd: opts?.cwd, maxBuffer: 16 * 1024 * 1024 }, (error, stdout, stderr) => {
     if (error)
       reject(Object.assign(error, { stderr, stdout }));
     else
-      resolve10(stdout.trim());
+      resolve12(stdout.trim());
   });
   child.stdin?.end(opts?.input);
 });
@@ -4472,14 +4572,15 @@ async function evaluateScreen(session, input) {
   if (firstSight)
     await saveBaseline(session, baseline, screenshot, snapshot);
   const native = observation.platform === "ios" || observation.platform === "android";
+  const enabled = new Set(session.config.agents.checks);
   const violations = evaluateAll(snapshot, {
     baseline: baseline.snapshot,
-    disabled: native ? NATIVE_DISABLED : []
+    disabled: RULES.map((rule) => rule.id).filter((id2) => !enabled.has(id2) || native && NATIVE_DISABLED.includes(id2))
   });
   const entries = groupViolations(violations);
   let diffPath;
   let visual;
-  if (!firstSight) {
+  if (!firstSight && enabled.has("pixel-diff")) {
     diffPath = join8(paths.session(session.root, session.sessionId), `${screenId}-diff.png`);
     const comparison = await diff({
       baselinePath: baseline.png,
@@ -4499,7 +4600,7 @@ async function evaluateScreen(session, input) {
   await closeAbsentChecks(session, screenId, new Set(entries.map((entry) => entryFingerprint(screenId, entry))));
   if (fresh.length === 0)
     return [];
-  const routeResult = await decide(session, screenId, snapshot, violations, visual);
+  const routeResult = { to: "judge", reason: "Automatic check" };
   const candidates = [];
   for (const entry of fresh) {
     const candidate = toCandidate(session, screenId, entry, {
@@ -4608,6 +4709,7 @@ async function addOccurrence(session, issueId) {
 }
 async function closeAbsentChecks(session, screenId, fired) {
   const closed = [];
+  const enabled = new Set(session.config.agents.checks);
   const ids = new Set((await session.workspace.listIssues()).filter((issue) => issue.screenId === screenId && ["new", "filed", "fixing", "fix-proposed"].includes(issue.status)).map((issue) => issue.id));
   const sources = /* @__PURE__ */ new Map();
   for (const record of await session.workspace.listSessions(Infinity)) {
@@ -4621,6 +4723,8 @@ async function closeAbsentChecks(session, screenId, fired) {
     const candidates = issue.candidateIds.map((candidateId) => sources.get(candidateId));
     if (candidates.some((candidate) => !candidate || candidate.source === "explorer" || candidate.screenId !== screenId))
       continue;
+    if (candidates.some((candidate) => !enabled.has(candidate.ruleId ?? candidate.source)))
+      continue;
     if (candidates.some((candidate) => fired.has(candidate.fingerprint))) {
       if (issue.notSeen)
         await session.workspace.saveIssue({ ...issue, notSeen: 0 });
@@ -4670,57 +4774,6 @@ function toCandidate(session, screenId, entry, extra) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-async function decide(session, screenId, snapshot, violations, visual) {
-  const config = session.config.decisions;
-  const { decider } = resolveDecider(config, process.env);
-  if (!decider)
-    return { to: "judge", reason: "no decider key is set, so the judge decides" };
-  const { text: text3 } = buildState({
-    screen: { id: screenId, description: snapshot.title ?? snapshot.url },
-    product: { summary: "", audience: "", domainVocabulary: [] },
-    assertions: violationsToAssertions(violations),
-    diff: visual ? {
-      changedPixels: visual.changedPixels,
-      changedPercent: visual.changedFraction * 100,
-      maskedPercent: visual.maskedFraction * 100,
-      regions: visual.regions.length
-    } : void 0,
-    console: snapshot.consoleErrors
-  });
-  const budget = new Budget(config.budget.perRunUsd);
-  budget.record(session.decisionSpentUsd);
-  const estimate = estimateDecisionCost(text3.length, decider.name);
-  if (!budget.canSpend(estimate)) {
-    return { to: "judge", reason: "decider budget exhausted" };
-  }
-  try {
-    const answers = await decider.ask(text3, SCREEN_QUESTIONS);
-    session.decisionSpentUsd += estimate;
-    const result3 = route({
-      answers,
-      thresholds: config.confidence,
-      hasDeterministicRegression: false,
-      matchedLedger: false
-    });
-    session.emit({
-      kind: "tool-result",
-      tool: "decider",
-      summary: `Decider routed ${screenId} to ${result3.route}`,
-      costUsd: estimate,
-      tokens: decider.lastUsage,
-      model: decider.model ?? decider.name
-    });
-    const choice = answers["route"];
-    const confidence = choice?.confidence;
-    return {
-      to: result3.route === "ignore" || result3.route === "intent" ? "ignore" : "judge",
-      reason: result3.reason,
-      confidence
-    };
-  } catch {
-    return { to: "judge", reason: "decider unavailable" };
-  }
-}
 
 // ../agents/dist/replay.js
 async function replaySteps(session, steps, opts = {}) {
@@ -4851,7 +4904,7 @@ async function actWhenReady(driver, action, session, windowMs) {
     if (result3.ok || !retry || Date.now() >= deadline || session.cancelled) {
       return { ...result3, degraded };
     }
-    await new Promise((resolve10) => setTimeout(resolve10, 500));
+    await new Promise((resolve12) => setTimeout(resolve12, 500));
   }
 }
 function toAction(step, session) {
@@ -4897,14 +4950,20 @@ function elementLine(element) {
   ].filter(Boolean).join(" ");
   return `[${element.ref}] ${element.role} ${JSON.stringify(element.name)} (${box.x},${box.y} ${box.width}x${box.height})${flags ? ` ${flags}` : ""}`;
 }
+function errorLines(observation) {
+  const unique = (items = []) => [...new Set(items)].map((item) => item.slice(0, 200));
+  const lines = (label, items) => items.length ? [`${label}:`, ...items.slice(0, 5).map((item) => `- ${item}`), ...items.length > 5 ? [`- (${items.length - 5} more)`] : []] : [];
+  return [...lines("Console errors", unique(observation.consoleErrors)), ...lines("Failed requests", unique(observation.networkErrors))];
+}
 function observationText(observation) {
   const windows = observation.windows?.map((window) => `${window.active ? "*" : " "} ${window.title} (${window.location})`).join("; ") ?? "(none)";
   return [
     `Location: ${observation.location}`,
     `Windows: ${windows}`,
+    ...errorLines(observation),
     "Elements:",
     ...observation.elements.slice(0, 117).map(elementLine)
-  ].slice(0, 120).join("\n");
+  ].slice(0, 130).join("\n");
 }
 async function observe(session, label, summary) {
   const observation = await session.driver.observe();
@@ -5232,7 +5291,7 @@ function explorerTools(session) {
     },
     {
       name: "record_screen",
-      description: "Record this screen, its routine, and automatic findings.",
+      description: "Record this screen and its routine in the app map.",
       inputSchema: schema({ id: string, name: string, description: string }, ["id", "name", "description"]),
       async run(input) {
         const id2 = slug(arg(input, "id"));
@@ -5242,8 +5301,7 @@ function explorerTools(session) {
         await session.driver.settle();
         const observation = await session.driver.observe();
         const screenshot = await session.capture(observation, id2);
-        const snapshot = session.driver.snapshot(observation, id2);
-        const findings = await evaluateScreen(session, { screenId: id2, observation, snapshot });
+        const findings = session.config.agents.checks.length ? await evaluateScreen(session, { screenId: id2, observation, snapshot: session.driver.snapshot(observation, id2) }) : [];
         const previous = session.lastScreenId;
         const edge = transition(session, id2);
         const routineId = `screen-${id2}`;
@@ -5271,15 +5329,17 @@ function explorerTools(session) {
         session.lastScreenTrailIndex = session.trail.length;
         const screens = (await session.workspace.readAppMap())?.screens ?? [];
         const names = screens.map((screen) => screen.id).join(", ") || id2;
-        const found = findings.length ? `${findings.length} automatic finding(s): ${findings.map((item) => item.summary).join("; ")}` : "no automatic findings";
+        const found = !session.config.agents.checks.length ? "" : findings.length ? ` ${findings.length} automatic finding(s): ${findings.map((item) => item.summary).join("; ")}.` : " No automatic findings.";
+        const errors = errorLines(observation);
         session.emit({
           kind: "screen",
-          summary: `Recorded ${name} (${found.split(":")[0]})`,
+          summary: `Recorded ${name}${findings.length ? ` (${findings.length} automatic finding(s))` : ""}`,
           screenId: id2,
           screenshot
         });
         return {
-          ...text(`Recorded ${name}. ${found}. Known screens: ${names}`),
+          ...text(session.vars.redact(`Recorded ${name}.${found} Known screens: ${names}${errors.length ? `
+${errors.join("\n")}` : ""}`)),
           meta: { summary: "", screenshot, screenId: id2 }
         };
       }
@@ -5395,6 +5455,7 @@ Expected: ${arg(input, "expected")}`),
       run: (input) => act(session, { kind: "window", match: arg(input, "match") })
     });
   }
+  tools.push(...lessonTools(session, "explorer"));
   return tools;
 }
 
@@ -5412,9 +5473,9 @@ var string2 = { type: "string" };
 function issueTitle(value) {
   if (value.length <= 80)
     return value;
-  const words = value.trim().split(/\s+/);
+  const words2 = value.trim().split(/\s+/);
   let title = "";
-  for (const word of words) {
+  for (const word of words2) {
     const next = title ? `${title} ${word}` : word;
     if (next.length > 79)
       break;
@@ -5467,6 +5528,7 @@ function triageEntries(candidates, decision, reason, issueId) {
 }
 function judgeTools(session, sessionIds, runtimeLabel) {
   return [
+    ...lessonTools(session, "judge"),
     {
       name: "list_candidates",
       description: "List undecided candidates and existing issues.",
@@ -5823,7 +5885,7 @@ async function runExplorer(session, runtime, opts = {}) {
   const task = {
     role: "explorer",
     sessionId: session.sessionId,
-    system: explorerSystem(session.config.app.platform, instructions, lessonsFor(await session.workspace.readMemory(), "explorer")),
+    system: explorerSystem(session.config.app.platform, instructions, lessonsFor(await session.workspace.readMemory(), "explorer"), session.config.agents.checks),
     prompt: explorerPrompt({
       goal: opts.goal,
       screens: map?.screens ?? [],
@@ -5846,13 +5908,13 @@ async function runExplorer(session, runtime, opts = {}) {
     await session.workspace.endSession(session.sessionId, {
       status: outcome.stop === "error" ? "failed" : "finished",
       steps: outcome.steps,
-      costUsd: outcome.costUsd + session.decisionSpentUsd,
+      costUsd: outcome.costUsd,
       summary: outcome.summary,
       candidates: candidates.length,
       screensFound: screens.map((item) => item.id)
     });
     session.emit({ kind: "session-end", summary: outcome.summary ?? `Explorer stopped: ${outcome.stop}` });
-    await session.idle(outcome.costUsd + session.decisionSpentUsd);
+    await session.idle(outcome.costUsd);
     const learned = await reflectOnSession(session.root, session.config, session.sessionId, { vars: session.vars, onLog: (message2) => session.emit({ kind: "error", summary: message2 }) });
     if (learned)
       session.emit({ kind: "lesson", summary: `Saved ${learned} lesson(s) for the next sessions` });
@@ -6026,7 +6088,7 @@ async function deleteBranch(fix, onLog) {
 
 // ../agents/dist/roles/retest.js
 import { execFile as execFile5 } from "node:child_process";
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 import { resolve as resolve7 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
@@ -6086,7 +6148,7 @@ async function observeDom(page) {
     };
     const trim = (value) => value?.trim().replace(/\s+/g, " ").slice(0, 80) ?? "";
     const implicitRole = (tag, type) => {
-      const roles3 = {
+      const roles4 = {
         a: "link",
         button: "button",
         select: "combobox",
@@ -6109,7 +6171,7 @@ async function observeDom(page) {
       if (/^h[1-6]$/.test(tag)) {
         return "heading";
       }
-      return roles3[tag] ?? "button";
+      return roles4[tag] ?? "button";
     };
     for (const element of Array.from(document.querySelectorAll(candidates))) {
       if (result3.length >= 150) {
@@ -6262,6 +6324,7 @@ var WebDriver = class {
   page;
   lastObservation;
   errors = /* @__PURE__ */ new Map();
+  failures = /* @__PURE__ */ new Map();
   watched = /* @__PURE__ */ new WeakSet();
   constructor(options) {
     this.options = options;
@@ -6291,11 +6354,30 @@ var WebDriver = class {
     const errors = [];
     this.errors.set(page, errors);
     page.on("console", (message2) => {
-      if (message2.type() === "error") {
+      if (message2.type() === "error" && !message2.text().startsWith("Failed to load resource:")) {
         errors.push(message2.text());
       }
     });
     page.on("pageerror", (error) => errors.push(`${error.name}: ${error.message}`));
+    const failures = [];
+    this.failures.set(page, failures);
+    const add = (line) => {
+      if (failures.length < 50)
+        failures.push(line);
+    };
+    page.on("response", (response3) => {
+      const type = response3.request().resourceType();
+      if (response3.status() >= 400 && ["fetch", "xhr", "document"].includes(type)) {
+        add(`${response3.request().method()} ${response3.url()} \u2192 ${response3.status()}`);
+      }
+    });
+    page.on("requestfailed", (request) => {
+      const reason = request.failure()?.errorText ?? "failed";
+      if (/ERR_ABORTED|NS_BINDING_ABORTED|cancelled/i.test(reason))
+        return;
+      if (["fetch", "xhr", "document"].includes(request.resourceType()))
+        add(`${request.method()} ${request.url()} \u2192 ${reason}`);
+    });
   }
   async observe() {
     const page = this.activePage();
@@ -6327,6 +6409,7 @@ var WebDriver = class {
       windows,
       volatileRegions: [],
       consoleErrors: errors.splice(0),
+      networkErrors: (this.failures.get(page) ?? []).splice(0),
       at: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.lastObservation = observation;
@@ -6952,7 +7035,7 @@ var MaestroDriver = class {
     await this.run([`openLink: ${yamlString(action.url)}`]);
   }
   async wait(action) {
-    await new Promise((resolve10) => setTimeout(resolve10, action.ms));
+    await new Promise((resolve12) => setTimeout(resolve12, action.ms));
   }
   async switchWindow() {
     throw new Error("Window switching is unsupported on mobile");
@@ -7013,7 +7096,7 @@ var MaestroDriver = class {
         return { frames, stable: true };
       }
       previous = current;
-      await new Promise((resolve10) => setTimeout(resolve10, interval));
+      await new Promise((resolve12) => setTimeout(resolve12, interval));
     }
     return { frames, stable: false };
   }
@@ -7055,6 +7138,60 @@ function createDriver(config, vars) {
   });
 }
 
+// ../agents/dist/roles/overlay.js
+import { mkdir as mkdir4, readFile as readFile9, readdir as readdir3, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname3, join as join11, relative as relative3, sep as sep3 } from "node:path";
+async function files(dir, skip) {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir3(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const path = join11(dir, entry.name);
+    if (path === skip)
+      continue;
+    if (entry.isDirectory())
+      out.push(...await files(path, skip));
+    else if (entry.isFile())
+      out.push(path);
+  }
+  return out;
+}
+async function overlayBughunters(root2, source, worktree) {
+  const where = relative3(source, root2);
+  if (where.startsWith("..") || where.split(sep3)[0] === "..")
+    return async () => {
+    };
+  const from = join11(root2, BUGHUNTERS_DIR);
+  const saved = [];
+  for (const file of await files(from, join11(from, DATA_DIR))) {
+    const target = join11(worktree, where, relative3(root2, file));
+    const content = await readFile9(file);
+    let before;
+    try {
+      before = await readFile9(target);
+    } catch {
+      before = void 0;
+    }
+    if (before?.equals(content))
+      continue;
+    saved.push({ path: target, content: before });
+    await mkdir4(dirname3(target), { recursive: true });
+    await writeFile6(target, content);
+  }
+  return async () => {
+    for (const item of saved.reverse()) {
+      if (item.content)
+        await writeFile6(item.path, item.content);
+      else
+        await rm4(item.path, { force: true });
+    }
+  };
+}
+
 // ../agents/dist/roles/retest.js
 var exec4 = promisify5(execFile5);
 var schema4 = (properties = {}, required = []) => ({ type: "object", properties, required, additionalProperties: false });
@@ -7064,7 +7201,7 @@ async function image2(root2, file) {
   if (!file)
     return [];
   try {
-    return [{ type: "image", png: await readFile9(resolve7(root2, file)) }];
+    return [{ type: "image", png: await readFile10(resolve7(root2, file)) }];
   } catch {
     return [];
   }
@@ -7130,9 +7267,13 @@ async function retestFix(root2, config, issue, fix, attempt, deps, options = {})
   const vars = new Vars(config.app.secrets);
   let app;
   let driver;
+  let restore = async () => {
+  };
   try {
     if (!options.build)
       await linkEnvFiles(fix.repo, fix.worktree);
+    if (!options.build)
+      restore = await overlayBughunters(root2, fix.repo, fix.worktree);
     if (!options.build && config.agents.fixer.retest.prepare) {
       await exec4("/bin/sh", ["-c", config.agents.fixer.retest.prepare], { cwd: fix.worktree, timeout: 6e5, maxBuffer: 4 * 1024 * 1024 });
     }
@@ -7169,7 +7310,8 @@ async function retestFix(root2, config, issue, fix, attempt, deps, options = {})
         "open",
         "wait",
         "run_routine",
-        "switch_window"
+        "switch_window",
+        "save_lesson"
       ]);
       const tools = explorerTools(session2).filter((tool) => allowed.has(tool.name)).map((tool) => tool.name !== "run_routine" ? tool : { ...tool, async run(input) {
         const id2 = String(input.id ?? "");
@@ -7259,7 +7401,7 @@ async function retestFix(root2, config, issue, fix, attempt, deps, options = {})
         }
       });
       const guide = config.app.instructions;
-      const instructions = guide ? await readFile9(resolve7(root2, guide), "utf8") : "";
+      const instructions = guide ? await readFile10(resolve7(root2, guide), "utf8") : "";
       const result3 = await explorerRuntime.run({
         role: "explorer",
         sessionId: record2.id,
@@ -7313,12 +7455,17 @@ ${targets.map((target, index) => `${index + 1}. screen ${target.shot.screenId ??
   } catch (error) {
     retest.outcome = "error";
     retest.reason = `Retest preparation or exploration failed: ${String(error)}`;
+    deps.onLog?.(retest.reason);
     return retest;
   } finally {
     try {
       await driver?.close();
     } finally {
-      await app?.stop();
+      try {
+        await app?.stop();
+      } finally {
+        await restore();
+      }
     }
   }
   if (!targets.some((target) => target.shot.after)) {
@@ -7362,7 +7509,7 @@ Fixer: ${fix.summary ?? ""}` }
         judged = { outcome: input.outcome, reason: String(input.reason ?? "") };
         return { ...response2(`Retest verdict: ${judged.outcome} \u2014 ${judged.reason}`), done: true };
       }
-    }];
+    }, ...lessonTools(session, "judge")];
     const result3 = await judgeRuntime.run({
       role: "judge",
       sessionId: record.id,
@@ -7531,8 +7678,8 @@ async function runFixCycle(root2, config, deps = {}) {
 }
 
 // ../agents/dist/roles/publish.js
-import { mkdir as mkdir4, readFile as readFile10, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join11, resolve as resolve8 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile11, writeFile as writeFile7 } from "node:fs/promises";
+import { join as join12, resolve as resolve8 } from "node:path";
 
 // ../agents/dist/report.js
 function buildReport(input) {
@@ -7650,7 +7797,7 @@ async function image3(root2, path) {
   if (!path)
     return [];
   try {
-    return [{ type: "image", png: await readFile10(resolve8(root2, path)) }];
+    return [{ type: "image", png: await readFile11(resolve8(root2, path)) }];
   } catch {
     return [];
   }
@@ -7842,9 +7989,9 @@ Retest: ${last?.outcome ?? "none"} \u2014 ${last?.reason ?? ""}`;
           let url;
           if (deps.dryRun) {
             const dir = paths.publish(root2);
-            await mkdir4(dir, { recursive: true });
-            url = join11(dir, `${item.issue.id}.md`);
-            await writeFile6(url, body);
+            await mkdir5(dir, { recursive: true });
+            url = join12(dir, `${item.issue.id}.md`);
+            await writeFile7(url, body);
           } else if (item.kind === "pr" && item.fix) {
             const opened = await createPr(gh, {
               repo: resolved.repo,
@@ -7951,10 +8098,276 @@ ${items.map((item) => `${item.issue.id}: ${item.issue.title}`).join("\n")}`),
   return outcomes;
 }
 
+// ../agents/dist/roles/ci.js
+import { execFile as execFile6 } from "node:child_process";
+import { access } from "node:fs/promises";
+import { resolve as resolve9 } from "node:path";
+import { promisify as promisify6 } from "node:util";
+var git4 = async (cwd, ...args2) => (await promisify6(execFile6)("git", args2, { cwd, maxBuffer: 16 * 1024 * 1024 })).stdout.trim();
+async function readChecks(gh, repo, pr) {
+  let out;
+  try {
+    out = await gh(["pr", "checks", String(pr), "--repo", repo, "--json", "name,bucket,link,description,workflow"]);
+  } catch (error) {
+    out = String(error.stdout ?? "");
+    if (!out.trim().startsWith("[")) {
+      if (/no checks/i.test(String(error.stderr ?? "")))
+        return [];
+      throw error;
+    }
+  }
+  return out.trim() ? JSON.parse(out) : [];
+}
+async function failureLog(gh, repo, failed2) {
+  const parts = [];
+  const runs = /* @__PURE__ */ new Set();
+  for (const check of failed2) {
+    const run2 = check.link?.match(/\/actions\/runs\/(\d+)/)?.[1];
+    if (run2 && !runs.has(run2)) {
+      runs.add(run2);
+      try {
+        const log = await gh(["run", "view", run2, "--repo", repo, "--log-failed"]);
+        parts.push(`### ${check.workflow || check.name} (run ${run2})
+${log.split("\n").slice(-150).join("\n")}`);
+        continue;
+      } catch {
+      }
+    }
+    if (!run2)
+      parts.push(`### ${check.name}
+${check.description ?? ""}
+${check.link ?? ""}`);
+  }
+  return parts.join("\n\n").slice(-12e3);
+}
+function ciPrompt(pr, failed2, log) {
+  return `The CI checks failed on PR #${pr}, which has your earlier fix. Make every check pass.
+
+FAILED CHECKS
+${failed2.map((check) => `- ${check.name}${check.link ? ` (${check.link})` : ""}`).join("\n")}
+
+THE END OF THE FAILED LOGS
+${log || "(no log is available)"}
+
+- Find the cause in the log. Fix the code or the test, not the CI config.
+- Run the same command as the failed check in this worktree, and make it pass before you finish.
+- Keep the original fix. Do not revert it to make CI pass.
+- If the failure has nothing to do with this change (a flaky test, an outage), change nothing, and say so.`;
+}
+async function watchCi(root2, config, deps = {}) {
+  const problems = [];
+  const settings = config.agents.github.ci;
+  if (!config.agents.github.enabled || !settings.enabled)
+    return { problems };
+  const gh = deps.gh ?? defaultGh;
+  const ready = await ghReady(gh);
+  if (!ready.ok) {
+    deps.onLog?.(ready.reason);
+    return { problems };
+  }
+  const workspace = new Workspace(root2);
+  const fixes = (await workspace.listFixes()).filter((fix) => fix.pr && (fix.pr.state ?? "open") === "open" && (!deps.issueIds || deps.issueIds.includes(fix.issueId)));
+  if (!fixes.length)
+    return { problems };
+  const { repo } = await resolveRepo(gh, config, resolve9(root2, config.app.source));
+  const sleep = deps.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+  for (const fix of fixes) {
+    const pr = fix.pr.number;
+    const deadline = Date.now() + settings.waitMinutes * 6e4;
+    for (; ; ) {
+      const checks = await readChecks(gh, repo, pr);
+      const pending = checks.filter((check) => check.bucket === "pending");
+      const failed2 = checks.filter((check) => check.bucket === "fail" || check.bucket === "cancel");
+      const save = async (state) => {
+        fix.ci = {
+          state,
+          head: fix.commit,
+          failing: failed2.map((check) => check.name),
+          attempts: fix.ci?.attempts ?? 0,
+          checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await workspace.saveFix(fix);
+      };
+      if (!checks.length) {
+        await save("none");
+        break;
+      }
+      if (pending.length && !failed2.length) {
+        if (deps.wait && Date.now() < deadline) {
+          await sleep(3e4);
+          continue;
+        }
+        await save("pending");
+        deps.onLog?.(`CI: PR #${pr} has ${pending.length} check(s) still running. The next cycle looks again.`);
+        break;
+      }
+      if (!failed2.length) {
+        await save("passed");
+        deps.onLog?.(`CI: all ${checks.length} check(s) passed on PR #${pr}.`);
+        break;
+      }
+      if ((fix.ci?.attempts ?? 0) >= 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);
+        deps.onLog?.(problem);
+        break;
+      }
+      await save("failed");
+      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) {
+          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);
+          problems.push(problem);
+          deps.onLog?.(problem);
+          break;
+        }
+        continue;
+      }
+      if (!deps.wait) {
+        fix.ci = { ...fix.ci, state: "pending" };
+        await workspace.saveFix(fix);
+        break;
+      }
+      await sleep(3e4);
+    }
+  }
+  return { problems };
+}
+async function fixCi(root2, config, fix, failed2, log, deps) {
+  try {
+    await access(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);
+  const fixer = config.agents.fixer;
+  const runtime = (deps.createRuntime ?? createRuntime)(fixer.use);
+  session.emit({ kind: "fix", summary: `Fixing CI on PR #${fix.pr.number}: ${failed2.map((check) => check.name).join(", ")}` });
+  let summary = "";
+  let status = "failed";
+  try {
+    const outcome = await runtime.run({
+      role: "fixer",
+      sessionId: session.sessionId,
+      workdir: fix.worktree,
+      system: fixerSystem(lessonsFor(await workspace.readMemory(), "fixer")),
+      prompt: ciPrompt(fix.pr.number, failed2, log),
+      tools: [...runtime.label.startsWith("cli:") ? [] : modelTools(fix.worktree), ...lessonTools(session, "fixer"), finishTool()],
+      maxSteps: fixer.maxSteps,
+      budgetUsd: fixer.budgetUsd,
+      timeoutMs: fixer.timeoutMs
+    }, session.emit);
+    summary = outcome.summary ?? "";
+    if (outcome.stop !== "done")
+      throw new Error(outcome.error ?? `Fixer stopped: ${outcome.stop}`);
+    if (!await git4(fix.worktree, "status", "--porcelain")) {
+      summary = summary || "The fixer made 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 });
+    }
+    await git4(fix.worktree, "add", "-A");
+    const committed = await commitFix(fix.worktree, "pass the CI checks", fixer.commitMessage);
+    if (!committed.ok)
+      throw new Error(`The commit hook rejected the commit: ${committed.reason}`);
+    fix.commit = await git4(fix.worktree, "rev-parse", "HEAD");
+    await git4(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)})` });
+    status = "finished";
+    return true;
+  } catch (error) {
+    summary = String(error).slice(0, 500);
+    session.emit({ kind: "error", summary: `CI fix failed on PR #${fix.pr.number}: ${summary}` });
+    return false;
+  } finally {
+    await workspace.endSession(session.sessionId, { status, summary });
+    await session.idle();
+  }
+}
+
 // ../agents/dist/patrol.js
+import { execFile as execFile7 } from "node:child_process";
+import { resolve as resolve10 } from "node:path";
+import { promisify as promisify7 } from "node:util";
+var exec5 = promisify7(execFile7);
+async function git5(cwd, ...args2) {
+  return (await exec5("git", args2, { cwd })).stdout.trim();
+}
+async function pullSource(root2, config, onLog) {
+  const target = config.agents.patrol.pull;
+  if (!target)
+    return false;
+  const slash = target.indexOf("/");
+  const remote = target.slice(0, slash);
+  const branch = target.slice(slash + 1);
+  const source = resolve10(root2, config.app.source);
+  try {
+    if (await git5(source, "status", "--porcelain", "--untracked-files=no")) {
+      onLog?.(`Did not pull ${target}: the source repository has uncommitted changes.`);
+      return false;
+    }
+    await git5(source, "fetch", "-q", remote, `+refs/heads/${branch}:refs/remotes/${remote}/${branch}`);
+    await git5(source, "checkout", "-q", "--detach", `${remote}/${branch}`);
+    onLog?.(`Pulled ${target} at ${await git5(source, "rev-parse", "--short", "HEAD")}.`);
+    return true;
+  } catch (error) {
+    const reason = error.stderr?.trim() || error.message;
+    onLog?.(`Did not pull ${target}: ${reason}. The cycle uses the current checkout.`);
+    return false;
+  }
+}
+async function sourceCommit(root2, config) {
+  const source = resolve10(root2, config.app.source);
+  try {
+    if (await git5(source, "status", "--porcelain", "--untracked-files=no"))
+      return void 0;
+    return await git5(source, "rev-parse", "HEAD");
+  } catch {
+    return void 0;
+  }
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function wait(minutes) {
+  return new Promise((done) => {
+    const finish = () => {
+      clearTimeout(timer);
+      process.off("SIGINT", finish);
+      process.off("SIGTERM", finish);
+      done();
+    };
+    const timer = setTimeout(finish, minutes * 6e4);
+    process.once("SIGINT", finish);
+    process.once("SIGTERM", finish);
+  });
+}
 async function runPatrol(options) {
+  const problems = [];
   const { root: root2, config } = options;
   const workspace = new Workspace(root2);
+  const previous = (await workspace.readAgents()).patrol;
+  if (previous?.state === "running" && previous.pid && previous.pid !== process.pid && alive(previous.pid)) {
+    options.onLog?.(`A patrol already runs (pid ${previous.pid}): did not start another.`);
+    return { problems };
+  }
   const runtime = options.createRuntime ?? createRuntime;
   let interrupted = false;
   let activeSession;
@@ -7964,6 +8377,11 @@ async function runPatrol(options) {
       activeSession.cancelled = true;
     }
   };
+  const idle = () => workspace.setPatrol({
+    state: "stopped",
+    nextAt: new Date(Date.now() + config.agents.patrol.intervalMinutes * 6e4).toISOString()
+  });
+  let tested = options.force ? void 0 : previous?.commit;
   process.on("SIGINT", onSignal);
   process.on("SIGTERM", onSignal);
   try {
@@ -7971,46 +8389,65 @@ async function runPatrol(options) {
       if (config.agents.patrol.cycles && cycle > config.agents.patrol.cycles) {
         break;
       }
+      if (cycle > 1) {
+        await wait(config.agents.patrol.intervalMinutes);
+        if (interrupted)
+          break;
+      }
       await workspace.setPatrol({ state: "running", cycle, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      await pullSource(root2, config, options.onLog);
       if (config.agents.github.enabled)
         await syncGitHub(root2, config, { onLog: options.onLog });
       await cleanWorktrees(root2, config, { onLog: options.onLog });
-      for (const role of ["explorer", "judge", "fixer"]) {
-        if (!config.agents[role].enabled) {
-          await workspace.setAgentStatus(role, { state: "off" });
-        }
-      }
-      const vars = new Vars(config.app.secrets);
-      let app;
-      let driver;
-      try {
-        app = await startApp(config.app, { root: root2, vars, emit: options.onLog });
-        driver = (options.createDriver ?? createDriver)(config, vars.resolve.bind(vars));
-        await driver.connect();
-        let explorerId;
-        if (config.agents.explorer.enabled && !interrupted) {
-          const record = await workspace.startSession("explorer");
-          explorerId = record.id;
-          const session = new AgentSession(root2, config, vars, record.id, "explorer", driver, options.onLog);
-          activeSession = session;
-          if (!interrupted) {
-            await runExplorer(session, runtime(config.agents.explorer.use));
-          } else {
-            await workspace.endSession(record.id, { summary: "Interrupted" });
+      const commit = await sourceCommit(root2, config);
+      const fresh = !commit || commit !== tested;
+      if (!fresh) {
+        options.onLog?.(`No new commit since the last cycle (${commit.slice(0, 7)}): skipped explore and judge. The pending fixes, retests, publish, and CI checks still run.`);
+      }
+      const before = problems.length;
+      if (fresh) {
+        for (const role of ["explorer", "judge", "fixer"]) {
+          if (!config.agents[role].enabled) {
+            await workspace.setAgentStatus(role, { state: "off" });
           }
-          activeSession = void 0;
         }
-        if (config.agents.judge.enabled && explorerId && !interrupted) {
-          const record = await workspace.startSession("judge");
-          const session = new AgentSession(root2, config, vars, record.id, "judge", void 0, options.onLog);
-          activeSession = session;
-          await runJudge(session, runtime(config.agents.judge.use), { sessionIds: [explorerId] });
-        }
-      } finally {
+        const vars = new Vars(config.app.secrets);
+        let app;
+        let driver;
         try {
-          await driver?.close();
+          app = await startApp(config.app, { root: root2, vars, emit: options.onLog });
+          driver = (options.createDriver ?? createDriver)(config, vars.resolve.bind(vars));
+          await driver.connect();
+          let explorerId;
+          if (config.agents.explorer.enabled && !interrupted) {
+            const record = await workspace.startSession("explorer");
+            explorerId = record.id;
+            const session = new AgentSession(root2, config, vars, record.id, "explorer", driver, options.onLog);
+            activeSession = session;
+            if (!interrupted) {
+              await runExplorer(session, runtime(config.agents.explorer.use));
+            } else {
+              await workspace.endSession(record.id, { summary: "Interrupted" });
+            }
+            activeSession = void 0;
+          }
+          if (config.agents.judge.enabled && explorerId && !interrupted) {
+            const record = await workspace.startSession("judge");
+            const session = new AgentSession(root2, config, vars, record.id, "judge", void 0, options.onLog);
+            activeSession = session;
+            await runJudge(session, runtime(config.agents.judge.use), { sessionIds: [explorerId] });
+          }
+        } catch (error) {
+          activeSession = void 0;
+          const problem = `Cycle ${cycle}: ${String(error)}`;
+          problems.push(problem);
+          options.onLog?.(problem);
         } finally {
-          await app?.stop();
+          try {
+            await driver?.close();
+          } finally {
+            await app?.stop();
+          }
         }
       }
       if (!interrupted && config.agents.explorer.enabled && config.agents.judge.enabled) {
@@ -8024,16 +8461,21 @@ async function runPatrol(options) {
           isInterrupted: () => interrupted
         });
       }
-      if (!interrupted)
-        await runFixCycle(root2, config, {
-          createDriver: options.createDriver,
-          createRuntime: options.createRuntime,
-          onLog: options.onLog,
-          onSession: (session) => {
-            activeSession = session;
-          },
-          isInterrupted: () => interrupted
-        });
+      const fixes = interrupted ? [] : await runFixCycle(root2, config, {
+        createDriver: options.createDriver,
+        createRuntime: options.createRuntime,
+        onLog: options.onLog,
+        onSession: (session) => {
+          activeSession = session;
+        },
+        isInterrupted: () => interrupted
+      });
+      for (const fix of fixes) {
+        const last = fix.retests?.at(-1);
+        if (last?.outcome === "error")
+          problems.push(`Cycle ${cycle}: the retest of ${fix.issueId} failed: ${last.reason}`);
+      }
+      const cycleFailed = problems.length > before;
       if (!interrupted && config.agents.github.enabled)
         await runPublisher(root2, config, {
           createRuntime: options.createRuntime,
@@ -8042,31 +8484,27 @@ async function runPatrol(options) {
             activeSession = session;
           }
         });
+      if (!interrupted && config.agents.github.enabled) {
+        const ci = await watchCi(root2, config, { createRuntime: options.createRuntime, onLog: options.onLog, wait: true });
+        problems.push(...ci.problems.map((problem) => `Cycle ${cycle}: ${problem}`));
+      }
       if (!interrupted && config.agents.github.enabled)
         await syncGitHub(root2, config, { onLog: options.onLog });
-      const nextAt = new Date(Date.now() + config.agents.patrol.intervalMinutes * 6e4).toISOString();
-      await workspace.setPatrol({ state: "stopped", nextAt });
+      if (!interrupted && fresh && commit && !cycleFailed) {
+        tested = commit;
+        await workspace.setPatrol({ commit });
+      }
+      await idle();
       if (options.once || interrupted) {
         break;
       }
-      await new Promise((done) => {
-        const finish = () => {
-          clearTimeout(timer);
-          process.off("SIGINT", stop);
-          process.off("SIGTERM", stop);
-          done();
-        };
-        const timer = setTimeout(finish, config.agents.patrol.intervalMinutes * 6e4);
-        const stop = () => finish();
-        process.once("SIGINT", stop);
-        process.once("SIGTERM", stop);
-      });
     }
   } finally {
-    await workspace.setPatrol({ state: "stopped" });
+    await workspace.setPatrol({ state: "stopped", nextAt: void 0 });
     process.off("SIGINT", onSignal);
     process.off("SIGTERM", onSignal);
   }
+  return { problems };
 }
 
 // ../cli/dist/commands/doctor.js
@@ -8115,15 +8553,13 @@ function runChecks(root2, config) {
 }
 function agentChecks(config, env = process.env) {
   const checks = [];
-  const roles3 = ["explorer", "judge", "fixer"].filter((role) => role !== "fixer" || config.agents.fixer.enabled);
-  for (const role of roles3) {
+  const roles4 = ["explorer", "judge", "fixer"].filter((role) => role !== "fixer" || config.agents.fixer.enabled);
+  for (const role of roles4) {
     const use = config.agents[role].use;
     const problem = runtimeProblem(role, use, env);
     const label = use.runtime === "cli" ? `cli: ${use.agent ?? use.command.split(" ")[0]}` : `${use.via}: ${use.model ?? "default model"}`;
     checks.push({ name: role, ok: !problem, detail: problem ?? `The ${role} uses ${label}`, fatal: true });
   }
-  const decider = resolveDecider(config.decisions, env);
-  checks.push({ name: "decider", ok: Boolean(decider.decider), detail: decider.reason, fatal: false });
   if (config.agents.github.enabled) {
     const installed = spawnSync("gh", ["--version"], { stdio: "ignore" }).status === 0;
     const loggedIn = installed && spawnSync("gh", ["auth", "status"], { stdio: "ignore" }).status === 0;
@@ -8138,12 +8574,12 @@ function doctorExitCode(checks) {
 // ../cli/dist/commands/init.js
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { appendFileSync, existsSync as existsSync6, readFileSync as readFileSync5, readdirSync, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join13, relative as relative3 } from "node:path";
+import { join as join14, relative as relative4 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // ../recon/dist/bringup.js
 import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function detectBringUp(root2) {
   const candidates = [];
   for (const workflow of listWorkflows(root2)) {
@@ -8153,7 +8589,7 @@ function detectBringUp(root2) {
       candidates.push({ command: match[0].replace(/^run:\s*/, ""), rung: "precedent", source: workflow, confidence: 0.8 });
     }
   }
-  const pkgPath = join12(root2, "package.json");
+  const pkgPath = join13(root2, "package.json");
   if (existsSync5(pkgPath)) {
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     const manager = detectPackageManager(root2);
@@ -8168,20 +8604,20 @@ function detectBringUp(root2) {
       }
     }
   }
-  if (existsSync5(join12(root2, "docker-compose.yml")) || existsSync5(join12(root2, "compose.yaml"))) {
+  if (existsSync5(join13(root2, "docker-compose.yml")) || existsSync5(join13(root2, "compose.yaml"))) {
     candidates.push({ command: "docker compose up", rung: "convention", source: "docker-compose.yml", confidence: 0.5 });
   }
-  if (existsSync5(join12(root2, "Procfile"))) {
+  if (existsSync5(join13(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 (existsSync5(join12(root2, "pnpm-lock.yaml")))
+  if (existsSync5(join13(root2, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync5(join12(root2, "bun.lockb")))
+  if (existsSync5(join13(root2, "bun.lockb")))
     return "bun";
-  if (existsSync5(join12(root2, "yarn.lock")))
+  if (existsSync5(join13(root2, "yarn.lock")))
     return "yarn";
   return "npm";
 }
@@ -8202,7 +8638,7 @@ function detectStack(root2) {
     ["app.json", "expo"]
   ];
   for (const [file, name] of signatures) {
-    if (!existsSync5(join12(root2, file)))
+    if (!existsSync5(join13(root2, file)))
       continue;
     framework ??= name;
     detectedFrom.push(file);
@@ -8217,12 +8653,12 @@ function detectStack(root2) {
   };
 }
 function listWorkflows(root2) {
-  const dir = join12(root2, ".github", "workflows");
+  const dir = join13(root2, ".github", "workflows");
   if (!existsSync5(dir))
     return [];
   try {
     const { readdirSync: readdirSync4 } = __require("node:fs");
-    return readdirSync4(dir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml")).map((f) => join12(dir, f));
+    return readdirSync4(dir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml")).map((f) => join13(dir, f));
   } catch {
     return [];
   }
@@ -8236,21 +8672,15 @@ var KEY_PROVIDERS = {
   openai: { env: "OPENAI_API_KEY", label: "OpenAI", url: "https://platform.openai.com/api-keys", model: "gpt-5-mini" },
   anthropic: { env: "ANTHROPIC_API_KEY", label: "Anthropic", url: "https://console.anthropic.com/settings/keys", model: "claude-haiku-4-5" }
 };
-var JEV_ROUTES2 = {
-  typesafe: { env: "TYPESAFE_API_KEY", label: "TypeSafe", url: "https://typesafe.ai" },
-  openrouter: { env: "OPENROUTER_API_KEY", label: "OpenRouter", url: "https://openrouter.ai/keys" },
-  vercel: { env: "AI_GATEWAY_API_KEY", label: "Vercel AI Gateway", url: "https://vercel.com/ai-gateway" }
-};
 var CLI_LABELS = { claude: "Claude Code", codex: "Codex", kimi: "Kimi CLI", pi: "pi" };
 var run = (command2, args2) => spawnSync2(command2, args2, { encoding: "utf8", timeout: 1e4 }).stdout ?? "";
-function detectProviders(env = process.env, exec5 = run) {
+function detectProviders(env = process.env, exec6 = run) {
   const found = CLI_AGENTS.filter((agent) => onPath(agent, env));
-  const piList = found.includes("pi") ? exec5("pi", ["list"]) : "";
+  const piList = found.includes("pi") ? exec6("pi", ["list"]) : "";
   const piWithoutMcp = found.includes("pi") && !piList.includes("pi-mcp-adapter");
   return {
     clis: found.filter((agent) => agent !== "pi" || !piWithoutMcp),
     keys: Object.keys(KEY_PROVIDERS).filter((key) => env[KEY_PROVIDERS[key].env]),
-    jev: Object.keys(JEV_ROUTES2).filter((route2) => env[JEV_ROUTES2[route2].env]),
     piWithoutMcp,
     piPermissionModes: piList.includes("pi-permission-modes")
   };
@@ -8285,18 +8715,18 @@ function list(dir) {
   }
 }
 function xcodeProjects(root2) {
-  return [".", "ios"].flatMap((dir) => list(join13(root2, dir)).filter((name) => name.endsWith(".xcodeproj")).map((name) => join13(root2, dir, name, "project.pbxproj")));
+  return [".", "ios"].flatMap((dir) => list(join14(root2, dir)).filter((name) => name.endsWith(".xcodeproj")).map((name) => join14(root2, dir, name, "project.pbxproj")));
 }
 function gradleFiles(root2) {
-  return ["android/app", "app"].flatMap((dir) => ["build.gradle", "build.gradle.kts"].map((file) => join13(root2, dir, file))).filter((file) => existsSync6(file));
+  return ["android/app", "app"].flatMap((dir) => ["build.gradle", "build.gradle.kts"].map((file) => join14(root2, dir, file))).filter((file) => existsSync6(file));
 }
 function detectAppId(root2, platform) {
-  const expo = readJson2(join13(root2, "app.json"))?.expo;
+  const expo = readJson2(join14(root2, "app.json"))?.expo;
   const fromJson = platform === "ios" ? expo?.ios?.bundleIdentifier : expo?.android?.package;
   if (fromJson)
     return { appId: fromJson, source: "app.json" };
   for (const file of ["app.config.ts", "app.config.js"]) {
-    const match = readText(join13(root2, file)).match(platform === "ios" ? /bundleIdentifier:\s*['"`]([\w.-]+)['"`]/ : /package:\s*['"`]([\w.-]+)['"`]/);
+    const match = readText(join14(root2, file)).match(platform === "ios" ? /bundleIdentifier:\s*['"`]([\w.-]+)['"`]/ : /package:\s*['"`]([\w.-]+)['"`]/);
     if (match)
       return { appId: match[1], source: file };
   }
@@ -8322,21 +8752,21 @@ function detectPort(root2, pkg, framework) {
   if (fromScript)
     return { port: Number(fromScript), source: "package.json" };
   for (const file of ["vite.config.ts", "vite.config.js", "vite.config.mjs"]) {
-    const match = readText(join13(root2, file)).match(/\bport:\s*(\d{2,5})\b/);
+    const match = readText(join14(root2, file)).match(/\bport:\s*(\d{2,5})\b/);
     if (match)
       return { port: Number(match[1]), source: file };
   }
-  const fromEnv = readText(join13(root2, ".env")).match(/^PORT=(\d{2,5})\s*$/m)?.[1];
+  const fromEnv = readText(join14(root2, ".env")).match(/^PORT=(\d{2,5})\s*$/m)?.[1];
   if (fromEnv)
     return { port: Number(fromEnv), source: ".env" };
   return { port: framework && FRAMEWORK_PORTS[framework] || 3e3, source: framework ? `the ${framework} default` : "the usual default" };
 }
 function mobilePlatform(root2) {
-  const hasIos = xcodeProjects(root2).length > 0 || existsSync6(join13(root2, "app.json")) || existsSync6(join13(root2, "ios"));
+  const hasIos = xcodeProjects(root2).length > 0 || existsSync6(join14(root2, "app.json")) || existsSync6(join14(root2, "ios"));
   return process.platform === "darwin" && hasIos ? "ios" : "android";
 }
 function detectApp(root2) {
-  const pkg = readJson2(join13(root2, "package.json")) ?? {};
+  const pkg = readJson2(join14(root2, "package.json")) ?? {};
   const deps = { ...pkg.dependencies, ...pkg.devDependencies };
   const notes = [];
   if (deps.electron) {
@@ -8344,8 +8774,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 = !existsSync6(join13(root2, "package.json")) && xcodeProjects(root2).length > 0;
-  const nativeAndroid = !existsSync6(join13(root2, "package.json")) && gradleFiles(root2).length > 0;
+  const nativeIos = !existsSync6(join14(root2, "package.json")) && xcodeProjects(root2).length > 0;
+  const nativeAndroid = !existsSync6(join14(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"}.`);
@@ -8415,7 +8845,7 @@ function renderConfig(answers) {
     lines.push(`    appId: ${answers.appId ?? "com.example.app"}${answers.appId ? "" : "   # TODO: your bundle ID or package name"}`);
     lines.push("    # device: <simulator UDID or emulator serial>   # default: the booted one");
   }
-  lines.push("  instructions: .bughunters/instructions.md   # plain English for the explorer: sign in, main flows, never-do list", "  secrets: []                        # env var names the explorer may use as {{NAME}}, e.g. [TEST_PASSWORD]", "", "# Each agent runs on an LLM: a local agent CLI (claude, codex, kimi, pi) or an API key.", "agents:", "  explorer:                          # uses the app and reports what looks wrong", `    use: ${useLine("explorer", answers.providers.explorer, answers.piPermissionModes)}`, "  judge:                             # decides which reports are real bugs, and writes the issues", `    use: ${useLine("judge", answers.providers.judge, answers.piPermissionModes)}`, "  fixer:                             # writes a fix in its own git worktree", "    enabled: false                   # turn on when you want Bughunters to fix bugs", `    use: ${useLine("fixer", answers.providers.fixer, answers.piPermissionModes)}`, "  github:", "    enabled: false                   # turn on to open PRs and issues (needs the gh CLI)", "", "# Jev triages each finding in one fast, low-cost call, so the LLM judge sees only the real ones.", "# With no Jev key, a general model or the judge does this work, at a higher cost.", "decisions:", "  decider: jev", `  jev: { via: ${answers.jev} }${answers.jev === "auto" ? "             # tries TYPESAFE_API_KEY, OPENROUTER_API_KEY, AI_GATEWAY_API_KEY" : ""}`, "");
+  lines.push("  instructions: .bughunters/instructions.md   # plain English for the explorer: sign in, main flows, never-do list", "  secrets: []                        # env var names the explorer may use as {{NAME}}, e.g. [TEST_PASSWORD]", "", "# Each agent runs on an LLM: a local agent CLI (claude, codex, kimi, pi) or an API key.", "agents:", "  explorer:                          # uses the app and reports what looks wrong", `    use: ${useLine("explorer", answers.providers.explorer, answers.piPermissionModes)}`, "  judge:                             # decides which reports are real bugs, and writes the issues", `    use: ${useLine("judge", answers.providers.judge, answers.piPermissionModes)}`, "  fixer:                             # writes a fix in its own git worktree", "    enabled: false                   # turn on when you want Bughunters to fix bugs", `    use: ${useLine("fixer", answers.providers.fixer, answers.piPermissionModes)}`, "  github:", "    enabled: false                   # turn on to open PRs and issues (needs the gh CLI)", "");
   return lines.join("\n");
 }
 var INSTRUCTIONS = `# About the app
@@ -8438,7 +8868,7 @@ Example: Sign in with the email {{TEST_EMAIL}} and the password {{TEST_PASSWORD}
 - Do not make payments.
 `;
 function ignoreData(root2) {
-  const gitignore = join13(root2, ".gitignore");
+  const gitignore = join14(root2, ".gitignore");
   const ignored = existsSync6(gitignore) ? readFileSync5(gitignore, "utf8") : "";
   const lines = ignored.split("\n");
   if (lines.some((line) => /^\/?\.bughunters\/runs\/?$/.test(line.trim())))
@@ -8455,7 +8885,7 @@ ${IGNORE_LINE}
   return true;
 }
 function relativeConfig(root2) {
-  const shown = relative3(process.cwd(), paths.config(root2));
+  const shown = relative4(process.cwd(), paths.config(root2));
   return shown && !shown.startsWith("..") ? shown : paths.config(root2);
 }
 var IGNORE_LINE = `${BUGHUNTERS_DIR}/${DATA_DIR}/`;
@@ -8470,7 +8900,7 @@ function writeInitialConfig(root2, answers) {
     writeFileSync3(configPath, renderConfig(answers));
     result3.written.push(configName);
   }
-  const guidePath = join13(paths.dir(root2), "instructions.md");
+  const guidePath = join14(paths.dir(root2), "instructions.md");
   if (existsSync6(guidePath))
     result3.skipped.push(`${BUGHUNTERS_DIR}/instructions.md`);
   else {
@@ -8485,12 +8915,6 @@ function writeInitialConfig(root2, answers) {
       result3.warnings.push(`Set ${route2.env} before you run Bughunters. Get a key at ${route2.url}`);
     }
   }
-  if (answers.jev !== "auto" && !process.env[JEV_ROUTES2[answers.jev].env]) {
-    result3.warnings.push(`Set ${JEV_ROUTES2[answers.jev].env} to use Jev. Get a key at ${JEV_ROUTES2[answers.jev].url}`);
-  }
-  if (answers.jev === "auto" && !Object.values(JEV_ROUTES2).some((route2) => process.env[route2.env])) {
-    result3.warnings.push("No Jev key is set, so Bughunters costs more. Get a key at https://typesafe.ai");
-  }
   return result3;
 }
 var PROVIDERS = [...CLI_AGENTS, ...Object.keys(KEY_PROVIDERS)];
@@ -8535,9 +8959,6 @@ function parseInitFlags(args2) {
       case "--fixer":
         flags[flag2.slice(2)] = oneOf(flag2, args2[++index], PROVIDERS);
         break;
-      case "--jev":
-        flags.jev = oneOf(flag2, args2[++index], ["typesafe", "openrouter", "vercel", "auto"]);
-        break;
       default:
         throw new ConfigError(`Unknown flag for init: ${flag2}`);
     }
@@ -8584,7 +9005,6 @@ function defaultAnswers(guess, detected, flags) {
     cdpPort: guess.cdpPort,
     ready: platform === guess.platform ? guess.ready : void 0,
     providers,
-    jev: flags.jev ?? detected.jev[0] ?? "auto",
     piPermissionModes: detected.piPermissionModes
   };
 }
@@ -8637,15 +9057,6 @@ async function interview(ask, root2, guess, detected, answers) {
   next.providers.explorer = await choose(ask, "Explorer: it uses the app and reports what looks wrong.", options, next.providers.explorer);
   next.providers.judge = await choose(ask, "Judge: it decides which reports are real bugs.", options, next.providers.explorer);
   next.providers.fixer = await choose(ask, "Fixer: it writes the fixes (off until you turn it on).", options, next.providers.fixer);
-  process.stdout.write("\nJev triages each finding in one fast, low-cost call. The LLM judge then sees only the real findings.\n");
-  const jevOptions = [
-    ...Object.keys(JEV_ROUTES2).map((route2) => ({
-      value: route2,
-      label: `${JEV_ROUTES2[route2].label} (${JEV_ROUTES2[route2].env}${detected.jev.includes(route2) ? " is set" : `, get a key at ${JEV_ROUTES2[route2].url}`})`
-    })),
-    { value: "auto", label: "Try each key in order (with no key, the LLM does this work at a higher cost)" }
-  ];
-  next.jev = await choose(ask, "How does Bughunters reach Jev?", jevOptions, next.jev === "auto" ? detected.jev[0] ?? "typesafe" : next.jev);
   return next;
 }
 async function runInit(root2, args2, log) {
@@ -8778,9 +9189,6 @@ determinism:
   blockThirdPartyRequests: true
 
 decisions:
-  decider: jev                 # jev | model
-  jev:
-    via: auto                  # auto | typesafe | openrouter | vercel
   model:
     via: auto                  # auto | openrouter | vercel | openai | anthropic | custom
     name: ""                   # optional model id override
@@ -8812,7 +9220,7 @@ production:
 
 // ../cli/dist/commands/run.js
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 
 // ../capture/dist/determinism.js
 var DETERMINISTIC_CHROMIUM_ARGS = [
@@ -9004,7 +9412,7 @@ async function assertNoFontFallback(page, failOnFallback) {
 
 // ../capture/dist/capture.js
 import { mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname4 } from "node:path";
 
 // ../capture/dist/pixel-contrast.js
 import { PNG as PNG3 } from "pngjs";
@@ -9077,7 +9485,7 @@ async function captureScreen(page, config, request) {
   const stability = await waitForStableFrame(page, config.determinism.stabilityGate);
   const masks = await resolveMasks(page, config.mask, request.url);
   const consoleErrors2 = collectedErrors.get(page) ?? [];
-  mkdirSync3(dirname3(request.outPath), { recursive: true });
+  mkdirSync3(dirname4(request.outPath), { recursive: true });
   const buffer = await page.screenshot({
     path: request.outPath,
     fullPage: request.fullPage ?? true,
@@ -9215,7 +9623,7 @@ function bodyMentions(body, selector) {
 async function stopProcess(child) {
   if (child.exitCode !== null || child.pid === void 0)
     return;
-  const done = new Promise((resolve10) => child.once("exit", () => resolve10()));
+  const done = new Promise((resolve12) => child.once("exit", () => resolve12()));
   try {
     process.kill(-child.pid, "SIGTERM");
   } catch {
@@ -9233,7 +9641,7 @@ async function stopProcess(child) {
 
 // ../cli/dist/commands/run-pipeline.js
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 
 // ../triage/dist/ledger.js
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync7 } from "node:fs";
@@ -9335,8 +9743,8 @@ async function cluster(findings, options = {}) {
 function deterministicPass(findings, changedFilesByFinding) {
   const buckets = /* @__PURE__ */ new Map();
   for (const finding of findings) {
-    const files = changedFilesByFinding?.get(finding.id) ?? finding.suspectedFiles;
-    const key = [finding.ruleId, [...files].sort().join(",")].join("::");
+    const files2 = changedFilesByFinding?.get(finding.id) ?? finding.suspectedFiles;
+    const key = [finding.ruleId, [...files2].sort().join(",")].join("::");
     const bucket = buckets.get(key);
     if (bucket)
       bucket.push(finding);
@@ -9664,7 +10072,7 @@ async function executeRun(options) {
       console: screen.snapshot.consoleErrors,
       knownIntents: ledger.summaries()
     });
-    const estimate = decider ? estimateDecisionCost(text3.length, decider.name) : 0;
+    const estimate = decider ? estimateDecisionCost(text3.length) : 0;
     let answers = {};
     if (!decider) {
       trace2.decision = {
@@ -9913,13 +10321,13 @@ function worstOf(a, b) {
 function writeArtifacts(root2, run2, findings, meta) {
   const dir = paths.run(root2, run2.id);
   mkdirSync4(dir, { recursive: true });
-  const reportPath = join14(dir, "report.html");
+  const reportPath = join15(dir, "report.html");
   writeFileSync5(reportPath, renderHtml({ run: run2, findings, suppressed: meta.suppressed, quarantined: 0, notes: meta.notes }));
-  writeFileSync5(join14(dir, "junit.xml"), toJUnit(run2, findings));
-  writeFileSync5(join14(dir, "results.sarif"), toSarif(findings));
-  writeFileSync5(join14(dir, "run.json"), `${JSON.stringify({ run: run2, findings }, null, 2)}
+  writeFileSync5(join15(dir, "junit.xml"), toJUnit(run2, findings));
+  writeFileSync5(join15(dir, "results.sarif"), toSarif(findings));
+  writeFileSync5(join15(dir, "run.json"), `${JSON.stringify({ run: run2, findings }, null, 2)}
 `);
-  writeFileSync5(join14(dir, "trace.json"), `${JSON.stringify(meta.trace, null, 2)}
+  writeFileSync5(join15(dir, "trace.json"), `${JSON.stringify(meta.trace, null, 2)}
 `);
   return { reportPath, runDir: dir };
 }
@@ -9948,7 +10356,7 @@ async function runCommand(options) {
   if (server.external)
     log(`Using the app already serving at ${requireRun(config).url}`);
   const captured = [];
-  const runDir = join15(paths.runs(root2), "latest");
+  const runDir = join16(paths.runs(root2), "latest");
   mkdirSync5(runDir, { recursive: true });
   const live = new LiveProgressWriter(root2, targets.length * config.viewports.length);
   live.start();
@@ -10052,7 +10460,7 @@ var LiveProgressWriter = class {
 async function captureOne(args2) {
   const { target, viewport, session, config, store, runDir } = args2;
   const slug2 = `${slugify(target.id)}--${viewport.name}`;
-  const actualPath = join15(runDir, `${slug2}.actual.png`);
+  const actualPath = join16(runDir, `${slug2}.actual.png`);
   const output = await captureScreen(session.page, config, {
     screenId: target.id,
     url: target.url,
@@ -10077,7 +10485,7 @@ async function captureOne(args2) {
       missingFonts: output.missingFonts
     };
   }
-  const diffPath = join15(runDir, `${slug2}.diff.png`);
+  const diffPath = join16(runDir, `${slug2}.diff.png`);
   const comparison = await diff({
     baselinePath,
     actualPath,
@@ -10140,7 +10548,7 @@ function loadBaselineSnapshot(root2, key) {
   }
 }
 function snapshotFile(root2, key) {
-  return join15(paths.baselines(root2), `${slugify(key)}-${shortHash(key, 8)}.snapshot.json`);
+  return join16(paths.baselines(root2), `${slugify(key)}-${shortHash(key, 8)}.snapshot.json`);
 }
 function saveBaselineSnapshot(root2, key, snapshot) {
   mkdirSync5(paths.baselines(root2), { recursive: true });
@@ -10241,12 +10649,12 @@ function formatRunSummary(result3) {
 // ../dashboard/dist/server.js
 import { createServer as createServer2 } from "node:http";
 import { createReadStream, existsSync as existsSync10, realpathSync, statSync as statSync2, watch } from "node:fs";
-import { extname, join as join18, relative as relative4, resolve as resolve9, sep as sep3 } from "node:path";
+import { extname, join as join19, relative as relative5, resolve as resolve11, sep as sep4 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../dashboard/dist/project.js
 import { existsSync as existsSync9, readFileSync as readFileSync8, readdirSync as readdirSync2, statSync } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 var ProjectReader = class {
   root;
   constructor(root2) {
@@ -10263,16 +10671,16 @@ var ProjectReader = class {
     const dir = paths.runs(this.root);
     if (!existsSync9(dir))
       return [];
-    return readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "latest").map((e) => ({ name: e.name, mtime: safeMtime(join16(dir, e.name)) })).sort((a, b) => b.mtime - a.mtime).map((e) => e.name);
+    return readdirSync2(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "latest").map((e) => ({ name: e.name, mtime: safeMtime(join17(dir, e.name)) })).sort((a, b) => b.mtime - a.mtime).map((e) => e.name);
   }
   readRun(runId) {
-    const dir = join16(paths.runs(this.root), runId);
-    const runFile = join16(dir, "run.json");
+    const dir = join17(paths.runs(this.root), runId);
+    const runFile = join17(dir, "run.json");
     if (!existsSync9(runFile))
       return void 0;
     try {
       const parsed = JSON.parse(readFileSync8(runFile, "utf8"));
-      const traceFile = join16(dir, "trace.json");
+      const traceFile = join17(dir, "trace.json");
       const trace = existsSync9(traceFile) ? JSON.parse(readFileSync8(traceFile, "utf8")) : void 0;
       return { id: runId, dir, run: parsed.run, findings: parsed.findings, trace, mtimeMs: safeMtime(dir) };
     } catch {
@@ -10358,8 +10766,8 @@ function safeMtime(path) {
 
 // ../dashboard/dist/agents.js
 import { readFileSync as readFileSync9, readdirSync as readdirSync3 } from "node:fs";
-import { basename as basename4, join as join17 } from "node:path";
-var roles = ["explorer", "judge", "fixer"];
+import { basename as basename4, join as join18 } from "node:path";
+var roles2 = ["explorer", "judge", "fixer"];
 var severity = { critical: 0, major: 1, minor: 2, cosmetic: 3 };
 var open = /* @__PURE__ */ new Set(["new", "filed", "fixing", "fix-proposed"]);
 function readJson3(file) {
@@ -10415,7 +10823,7 @@ var AgentReader = class {
     const value = readJson3(paths.agents(this.root));
     if (!Array.isArray(value?.agents))
       return void 0;
-    const agents = value.agents.filter((agent) => agent && roles.includes(agent.role) && typeof agent.state === "string").map((agent) => {
+    const agents = value.agents.filter((agent) => agent && roles2.includes(agent.role) && typeof agent.state === "string").map((agent) => {
       const busy = agent.state === "working" || agent.state === "waiting";
       return busy && !processAlive(agent.pid) ? { ...agent, state: "idle", activity: STOPPED } : agent;
     });
@@ -10430,28 +10838,31 @@ var AgentReader = class {
   }
   issues() {
     const fixes = this.fixes();
-    return list2(paths.issues(this.root)).filter((name) => name.endsWith(".json")).map((name) => readJson3(join17(paths.issues(this.root), name))).filter((issue) => Boolean(issue?.id && issue.title && issue.lastSeenAt && issue.evidence && issue.judgement && Array.isArray(issue.candidateIds))).map((issue) => ({ ...issue, pr: fixes.find((fix) => fix.id === issue.fixId || fix.issueId === issue.id)?.pr })).sort((a, b) => (severity[a.severity] ?? 9) - (severity[b.severity] ?? 9) || b.lastSeenAt.localeCompare(a.lastSeenAt));
+    return list2(paths.issues(this.root)).filter((name) => name.endsWith(".json")).map((name) => readJson3(join18(paths.issues(this.root), name))).filter((issue) => Boolean(issue?.id && issue.title && issue.lastSeenAt && issue.evidence && issue.judgement && Array.isArray(issue.candidateIds))).map((issue) => {
+      const fix = fixes.find((entry) => entry.id === issue.fixId || entry.issueId === issue.id);
+      return { ...issue, pr: fix?.pr ? { ...fix.pr, ci: fix.ci?.state } : void 0 };
+    }).sort((a, b) => (severity[a.severity] ?? 9) - (severity[b.severity] ?? 9) || b.lastSeenAt.localeCompare(a.lastSeenAt));
   }
   fixes() {
-    return list2(paths.fixes(this.root)).filter((name) => name.endsWith(".json")).map((name) => readJson3(join17(paths.fixes(this.root), name))).filter((fix) => Boolean(fix?.id && fix.issueId));
+    return list2(paths.fixes(this.root)).filter((name) => name.endsWith(".json")).map((name) => readJson3(join18(paths.fixes(this.root), name))).filter((fix) => Boolean(fix?.id && fix.issueId));
   }
   routines() {
-    return list2(paths.routines(this.root)).filter((name) => name.endsWith(".json")).map((name) => readJson3(join17(paths.routines(this.root), name))).filter((routine) => Boolean(routine?.id && Array.isArray(routine.steps)));
+    return list2(paths.routines(this.root)).filter((name) => name.endsWith(".json")).map((name) => readJson3(join18(paths.routines(this.root), name))).filter((routine) => Boolean(routine?.id && Array.isArray(routine.steps)));
   }
   sessions(limit = 50) {
-    return list2(paths.sessions(this.root)).filter((id2) => /^[\w-]+$/.test(id2)).map((id2) => ({ id: id2, value: readJson3(join17(paths.session(this.root, id2), "session.json")) })).filter(({ id: id2, value }) => value?.id === id2).map(({ value }) => value).filter((session) => Boolean(session?.id && session.startedAt && Array.isArray(session.screensFound) && Array.isArray(session.issues))).map((session) => session.status === "running" && !processAlive(session.pid) ? { ...session, status: "failed", summary: session.summary ?? `Interrupted. ${STOPPED}` } : session).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, limit);
+    return list2(paths.sessions(this.root)).filter((id2) => /^[\w-]+$/.test(id2)).map((id2) => ({ id: id2, value: readJson3(join18(paths.session(this.root, id2), "session.json")) })).filter(({ id: id2, value }) => value?.id === id2).map(({ value }) => value).filter((session) => Boolean(session?.id && session.startedAt && Array.isArray(session.screensFound) && Array.isArray(session.issues))).map((session) => session.status === "running" && !processAlive(session.pid) ? { ...session, status: "failed", summary: session.summary ?? `Interrupted. ${STOPPED}` } : session).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, limit);
   }
   session(id2) {
     const session = this.sessions(Infinity).find((entry) => entry.id === id2);
     if (!session)
       return void 0;
     const dir = paths.session(this.root, id2);
-    const events = jsonLines(join17(dir, "events.jsonl"));
+    const events = jsonLines(join18(dir, "events.jsonl"));
     return {
       // A running session has no totals yet: add up its events so far.
       session: session.status === "running" ? { ...session, ...usageOf(events) } : session,
       events,
-      candidates: jsonLines(join17(dir, "candidates.jsonl"))
+      candidates: jsonLines(join18(dir, "candidates.jsonl"))
     };
   }
   issue(id2) {
@@ -10461,7 +10872,7 @@ var AgentReader = class {
     const fix = this.fixes().find((entry) => entry.id === issue.fixId || entry.issueId === id2);
     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(join17(paths.session(this.root, session.id), "candidates.jsonl"))).filter((candidate) => ids.has(candidate.id));
+    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 };
   }
   screens() {
@@ -10510,6 +10921,10 @@ var AgentReader = class {
         edges.push({ from: "__start", to: screen.id, kind: "route", via: "route", count: 1, steps: 0 });
       }
     }
+    if (map.screens.length && !edges.some((edge) => edge.from === "__start")) {
+      const entry = byRoutine.get("enter-app")?.requires?.map((id2) => screenByRoutine.get(id2)).find(Boolean) ?? map.screens[0].id;
+      edges.push({ from: "__start", to: entry, kind: "route", via: "route", count: 1, steps: 0 });
+    }
     const screens = map.screens.map((screen) => ({
       ...screen,
       openIssues: issues.filter((issue) => issue.screenId === screen.id).length
@@ -10518,16 +10933,30 @@ var AgentReader = class {
       screens.push({ id: "__start", name: "App start", virtual: true, openIssues: 0 });
     return { ...map, screens, edges, entryId: screens.length ? "__start" : void 0 };
   }
+  /** Each role as the config sets it, in the same form as the runtime labels. */
+  configuredAgents() {
+    try {
+      const config = loadConfig(this.root);
+      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 }];
+      }));
+    } catch {
+      return void 0;
+    }
+  }
   overview(now = /* @__PURE__ */ new Date()) {
     const agentFile = this.agents();
     const appmap = this.appmap();
     const issues = this.issues();
     const sessions = this.sessions(Infinity);
     const today = now.toLocaleDateString("en-CA");
-    const agents = roles.map((role) => agentFile?.agents.find((agent) => agent.role === role) ?? {
+    const configured = this.configuredAgents();
+    const agents = roles2.map((role) => agentFile?.agents.find((agent) => agent.role === role) ?? {
       role,
-      state: "off",
-      runtime: "",
+      state: configured?.[role].enabled === false ? "off" : configured ? "idle" : "off",
+      runtime: configured?.[role].runtime ?? "",
       updatedAt: "",
       spentUsd: 0
     });
@@ -10537,9 +10966,9 @@ var AgentReader = class {
     const screenshot = [...detail?.events ?? []].reverse().find((event) => event.screenshot)?.screenshot;
     const openIssues = issues.filter((issue) => open.has(issue.status));
     const fixes = this.fixes();
-    const attention = openIssues.filter((issue) => ["new", "filed", "fix-proposed"].includes(issue.status)).slice(0, 8).map((issue) => {
+    const attention = openIssues.slice(0, 8).map((issue) => {
       const fix = fixes.find((entry) => entry.id === issue.fixId || entry.issueId === issue.id);
-      return { ...issue, pr: fix?.pr, fix: fix ? { status: fix.status } : void 0 };
+      return { ...issue, pr: fix?.pr ? { ...fix.pr, ci: fix.ci?.state } : void 0, fix: fix ? { status: fix.status } : void 0 };
     });
     const prStates = fixes.map((fix) => fix.pr?.state).filter(Boolean);
     const issueStates = issues.map((issue) => issue.github?.state).filter(Boolean);
@@ -10591,7 +11020,7 @@ function usageReport(sessions, now = /* @__PURE__ */ new Date()) {
       rows.set(key, row);
     }
   }
-  const week = [...rows.values()].sort((a, b) => roles.indexOf(a.role) - roles.indexOf(b.role) || b.tokens.input + b.tokens.output - (a.tokens.input + a.tokens.output));
+  const week = [...rows.values()].sort((a, b) => roles2.indexOf(a.role) - roles2.indexOf(b.role) || b.tokens.input + b.tokens.output - (a.tokens.input + a.tokens.output));
   return { todayByRole, week, ...weekTotal ? { weekTotal } : {} };
 }
 function isFeedEvent(event) {
@@ -10859,7 +11288,7 @@ function hostOf(href) {
 }
 
 // ../dashboard/dist/server.js
-var UI_DIR = resolve9(fileURLToPath(new URL(".", import.meta.url)), "..", "src", "ui");
+var UI_DIR = resolve11(fileURLToPath(new URL(".", import.meta.url)), "..", "src", "ui");
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -10870,7 +11299,7 @@ var MIME = {
   ".json": "application/json; charset=utf-8"
 };
 async function startDashboard(options) {
-  const root2 = resolve9(options.root);
+  const root2 = resolve11(options.root);
   const host = options.host ?? "127.0.0.1";
   const reader = new ProjectReader(root2);
   const agents = new AgentReader(root2);
@@ -10965,7 +11394,7 @@ async function handle2(req, res, ctx) {
   return serveUi(res, path);
 }
 function resolveArtifactPath(root2, requested) {
-  const candidate = resolve9(root2, requested);
+  const candidate = resolve11(root2, requested);
   if (!existsSync10(candidate))
     return void 0;
   let real;
@@ -10976,8 +11405,8 @@ function resolveArtifactPath(root2, requested) {
   } catch {
     return void 0;
   }
-  const rel = relative4(allowed, real);
-  if (rel === "" || rel.startsWith("..") || rel.startsWith(`..${sep3}`))
+  const rel = relative5(allowed, real);
+  if (rel === "" || rel.startsWith("..") || rel.startsWith(`..${sep4}`))
     return void 0;
   const stat = statSync2(real);
   if (!stat.isFile())
@@ -10998,7 +11427,7 @@ function serveArtifact(res, root2, requested) {
 }
 function serveUi(res, path) {
   const name = path === "/" ? "index.html" : path.replace(/^\//, "");
-  const file = resolve9(UI_DIR, name);
+  const file = resolve11(UI_DIR, name);
   if (!file.startsWith(UI_DIR) || !existsSync10(file) || !statSync2(file).isFile()) {
     return serveUi(res, "/");
   }
@@ -11131,14 +11560,19 @@ function parseAgentFlags(command2, args2) {
     fix: ["--issue"],
     retest: ["--issue"],
     publish: ["--issue"],
+    ci: ["--issue"],
     patrol: []
   };
   if (!values[command2])
     throw new ConfigError(`Unknown agent command ${command2}`);
   for (let index = 0; index < args2.length; index++) {
     const flag2 = args2[index];
-    if (command2 === "patrol" && flag2 === "--once") {
-      flags.once = true;
+    if (command2 === "patrol" && (flag2 === "--once" || flag2 === "--force")) {
+      flags[flag2.slice(2)] = true;
+      continue;
+    }
+    if (command2 === "ci" && flag2 === "--wait") {
+      flags.wait = true;
       continue;
     }
     if (command2 === "publish" && flag2 === "--dry-run") {
@@ -11178,6 +11612,8 @@ function rolesFor(command2, config) {
     case "judge":
     case "publish":
       return ["judge"];
+    case "ci":
+      return ["fixer"];
     case "retest":
       return ["explorer", "judge"];
     case "fix":
@@ -11192,15 +11628,36 @@ function preflight(command2, config, env = process.env) {
   const problems = rolesFor(command2, config).map((role) => runtimeProblem(role, config.agents[role].use, env)).filter((problem) => Boolean(problem));
   if (problems.length)
     throw new ConfigError(problems.join("\n"));
-  return ["explore", "patrol"].includes(command2) ? [resolveDecider(config.decisions, env).reason] : [];
 }
 async function runAgentCommand(command2, args2, root2, config, log) {
   const flags = parseAgentFlags(command2, args2);
-  for (const line of preflight(command2, config))
-    log(line);
+  preflight(command2, config);
   const workspace = new Workspace(root2);
   if (command2 === "patrol") {
-    await runPatrol({ root: root2, config, once: Boolean(flags.once), onLog: log });
+    const { problems } = await runPatrol({ root: root2, config, once: Boolean(flags.once), force: Boolean(flags.force), onLog: log });
+    if (problems.length) {
+      log(`The patrol had ${problems.length} problem(s):
+${problems.map((problem) => `- ${problem.split("\n")[0]}`).join("\n")}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (command2 === "ci") {
+    if (!config.agents.github.enabled) {
+      throw new ConfigError("GitHub is off. Set agents.github.enabled: true in .bughunters/bughunters.yml.");
+    }
+    const { problems } = await watchCi(root2, config, {
+      onLog: log,
+      wait: Boolean(flags.wait),
+      issueIds: flags.issue
+    });
+    const fixes = (await workspace.listFixes()).filter((fix) => fix.pr && fix.ci && (!flags.issue || flags.issue.includes(fix.issueId)));
+    if (!fixes.length)
+      log("No open Bughunters PR has CI checks yet.");
+    for (const fix of fixes)
+      log(`  PR #${fix.pr.number}  ${fix.ci.state.padEnd(8)} ${fix.issueId}  ${fix.pr.url}`);
+    if (problems.length)
+      process.exitCode = 1;
     return;
   }
   if (command2 === "publish") {
@@ -11392,7 +11849,7 @@ function bySeverity(a, b) {
 }
 
 // ../cli/dist/commands/memory.js
-var roles2 = /* @__PURE__ */ new Set(["explorer", "judge", "fixer"]);
+var roles3 = /* @__PURE__ */ new Set(["explorer", "judge", "fixer"]);
 var flag = (args2, name) => {
   const at = args2.indexOf(name);
   return at < 0 ? void 0 : args2[at + 1];
@@ -11402,7 +11859,7 @@ async function runMemoryCommand(args2, root2, log) {
   const workspace = new Workspace(root2);
   if (action === "list") {
     const role = flag(args2.slice(1), "--role");
-    if (role && !roles2.has(role))
+    if (role && !roles3.has(role))
       throw new ConfigError(`Unknown memory role: ${role}`);
     const lessons = (await workspace.readMemory()).lessons.filter((lesson) => !role || lesson.role === role);
     log("id  role  hits  source  scope  text");
@@ -11415,7 +11872,7 @@ async function runMemoryCommand(args2, root2, log) {
   if (action === "add") {
     const role = flag(args2.slice(1), "--role");
     const text3 = args2.slice(1).find((part, index, all) => !part.startsWith("--") && all[index - 1] !== "--role" && all[index - 1] !== "--scope");
-    if (!role || !roles2.has(role) || !text3?.trim())
+    if (!role || !roles3.has(role) || !text3?.trim())
       throw new ConfigError('Usage: bughunters memory add --role explorer|judge|fixer "text" [--scope s]');
     const [lesson] = await workspace.upsertLessons([{
       role,
@@ -11449,7 +11906,7 @@ var [command, ...args] = process.argv.slice(2);
 var root = findProjectRoot(process.cwd());
 function version() {
   if (true)
-    return "0.1.0";
+    return "0.1.2";
   try {
     return JSON.parse(readFileSync10(new URL("../package.json", import.meta.url), "utf8")).version;
   } catch {
@@ -11513,6 +11970,7 @@ try {
     case "fix":
     case "retest":
     case "publish":
+    case "ci":
     case "patrol":
     case "replay": {
       const config = loadConfig(root);