@exodus/xqa 8.0.0 → 8.2.0

package/dist/xqa.cjs

@@ -164,7 +164,7 @@ var require_index_cjs = __commonJS({
         }, reject);
       }
     }
-    var ResultAsync48 = class _ResultAsync {
+    var ResultAsync49 = class _ResultAsync {
       constructor(res) {
         this._promise = res;
       }
@@ -303,14 +303,14 @@ var require_index_cjs = __commonJS({
       }
     };
     function okAsync40(value) {
-      return new ResultAsync48(Promise.resolve(new Ok(value)));
+      return new ResultAsync49(Promise.resolve(new Ok(value)));
     }
     function errAsync38(err60) {
-      return new ResultAsync48(Promise.resolve(new Err(err60)));
+      return new ResultAsync49(Promise.resolve(new Err(err60)));
     }
-    var fromPromise = ResultAsync48.fromPromise;
-    var fromSafePromise = ResultAsync48.fromSafePromise;
-    var fromAsyncThrowable12 = ResultAsync48.fromThrowable;
+    var fromPromise = ResultAsync49.fromPromise;
+    var fromSafePromise = ResultAsync49.fromSafePromise;
+    var fromAsyncThrowable12 = ResultAsync49.fromThrowable;
     var combineResultList = (resultList) => {
       let acc = ok59([]);
       for (const result of resultList) {
@@ -323,7 +323,7 @@ var require_index_cjs = __commonJS({
       }
       return acc;
     };
-    var combineResultAsyncList = (asyncResultList) => ResultAsync48.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+    var combineResultAsyncList = (asyncResultList) => ResultAsync49.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
     var combineResultListWithAllErrors = (resultList) => {
       let acc = ok59([]);
       for (const result of resultList) {
@@ -337,7 +337,7 @@ var require_index_cjs = __commonJS({
       }
       return acc;
     };
-    var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync48.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+    var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync49.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
     exports2.Result = void 0;
     (function(Result3) {
       function fromThrowable44(fn, errorFn) {
@@ -369,7 +369,7 @@ var require_index_cjs = __commonJS({
     function safeTry(body) {
       const n3 = body().next();
       if (n3 instanceof Promise) {
-        return new ResultAsync48(n3.then((r4) => r4.value));
+        return new ResultAsync49(n3.then((r4) => r4.value));
       }
       return n3.value;
     }
@@ -420,7 +420,7 @@ var require_index_cjs = __commonJS({
         return f11(this.value).map(() => this.value);
       }
       asyncMap(f11) {
-        return ResultAsync48.fromSafePromise(f11(this.value));
+        return ResultAsync49.fromSafePromise(f11(this.value));
       }
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       unwrapOr(_v) {
@@ -524,7 +524,7 @@ var require_index_cjs = __commonJS({
     var fromThrowable43 = exports2.Result.fromThrowable;
     exports2.Err = Err;
     exports2.Ok = Ok;
-    exports2.ResultAsync = ResultAsync48;
+    exports2.ResultAsync = ResultAsync49;
     exports2.err = err59;
     exports2.errAsync = errAsync38;
     exports2.fromAsyncThrowable = fromAsyncThrowable12;
@@ -2460,7 +2460,7 @@ ${indent}${line}` : "\n";
           str2 += ",";
         } else if (ctx.options.trailingComma) {
           if (ctx.options.lineWidth > 0) {
-            reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str2.length + 2) > ctx.options.lineWidth);
+            reqNewline || (reqNewline = lines.reduce((sum2, line) => sum2 + line.length + 2, 2) + (str2.length + 2) > ctx.options.lineWidth);
           }
           if (reqNewline) {
             str2 += ",";
@@ -2476,7 +2476,7 @@ ${indent}${line}` : "\n";
         return start + end;
       } else {
         if (!reqNewline) {
-          const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
+          const len = lines.reduce((sum2, line) => sum2 + line.length + 2, 2);
           reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
         }
         if (reqNewline) {
@@ -22806,9 +22806,9 @@ var require_bignumber = __commonJS({
           };
         })();
         BigNumber2.sum = function() {
-          var i4 = 1, args = arguments, sum = new BigNumber2(args[0]);
-          for (; i4 < args.length; ) sum = sum.plus(args[i4++]);
-          return sum;
+          var i4 = 1, args = arguments, sum2 = new BigNumber2(args[0]);
+          for (; i4 < args.length; ) sum2 = sum2.plus(args[i4++]);
+          return sum2;
         };
         convertBase = /* @__PURE__ */ (function() {
           var decimal = "0123456789";
@@ -35485,14 +35485,14 @@ var require_sharp_phash = __commonJS({
       for (var u = 0; u < N; u++) {
         F11[u] = new Array(N);
         for (var v3 = 0; v3 < N; v3++) {
-          var sum = 0;
+          var sum2 = 0;
           for (var i4 = 0; i4 < N; i4++) {
             for (var j = 0; j < N; j++) {
-              sum += COS[i4][u] * COS[j][v3] * f11[i4][j];
+              sum2 += COS[i4][u] * COS[j][v3] * f11[i4][j];
             }
           }
-          sum *= SQRT[u] * SQRT[v3] / 4;
-          F11[u][v3] = sum;
+          sum2 *= SQRT[u] * SQRT[v3] / 4;
+          F11[u][v3] = sum2;
         }
       }
       return F11;
@@ -85278,7 +85278,7 @@ var {
 } = import_index.default;
 
 // src/bootstrap.ts
-var import_neverthrow148 = __toESM(require_index_cjs(), 1);
+var import_neverthrow149 = __toESM(require_index_cjs(), 1);
 
 // src/config/error-formatter.ts
 function formatIssues(issues) {
@@ -102720,6 +102720,7 @@ function collectElements(elements, screen) {
 }
 var OCCLUDED_BY_OVERLAP_TAG = "[occluded-by-overlap]";
 var FULL_BBOX_CONTAINMENT_RATIO = 0.85;
+var LATER_UNION_COVERAGE_THRESHOLD = 0.7;
 function frameContainsPoint(frame, point) {
   return point.x >= frame.x && point.x < frame.x + frame.width && point.y >= frame.y && point.y < frame.y + frame.height;
 }
@@ -102796,6 +102797,78 @@ function fullyCoversBoundingBox(target, candidate) {
   }
   return intersectionArea(target.frame, candidate.frame) / targetArea >= FULL_BBOX_CONTAINMENT_RATIO;
 }
+function clipFrameToTarget(target, candidate) {
+  const x1 = Math.max(target.x, candidate.x);
+  const y12 = Math.max(target.y, candidate.y);
+  const x22 = Math.min(target.x + target.width, candidate.x + candidate.width);
+  const y22 = Math.min(target.y + target.height, candidate.y + candidate.height);
+  if (x22 <= x1 || y22 <= y12) {
+    return void 0;
+  }
+  return { x: x1, y: y12, width: x22 - x1, height: y22 - y12 };
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].toSorted((left, right) => left - right);
+}
+function rectCoversCell(rect, cell) {
+  return rect.x <= cell.x1 && rect.x + rect.width >= cell.x2 && rect.y <= cell.y1 && rect.y + rect.height >= cell.y2;
+}
+function cellAt(grid, indices) {
+  const x1 = grid.xs[indices.xIndex];
+  const x22 = grid.xs[indices.xIndex + 1];
+  const y12 = grid.ys[indices.yIndex];
+  const y22 = grid.ys[indices.yIndex + 1];
+  if (x1 === void 0 || x22 === void 0 || y12 === void 0 || y22 === void 0) {
+    return void 0;
+  }
+  return { x1, y1: y12, x2: x22, y2: y22 };
+}
+function cellCoveredArea(grid, indices) {
+  const cell = cellAt(grid, indices);
+  if (!cell) {
+    return 0;
+  }
+  const covered = grid.rects.some((rect) => rectCoversCell(rect, cell));
+  return covered ? (cell.x2 - cell.x1) * (cell.y2 - cell.y1) : 0;
+}
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function rowCoveredArea(grid, yIndex) {
+  return sum(
+    grid.xs.slice(0, -1).map((_value, xIndex) => cellCoveredArea(grid, { xIndex, yIndex }))
+  );
+}
+function buildGrid(target, clipped) {
+  const xs = uniqueSorted([
+    target.x,
+    target.x + target.width,
+    ...clipped.flatMap((rect) => [rect.x, rect.x + rect.width])
+  ]);
+  const ys = uniqueSorted([
+    target.y,
+    target.y + target.height,
+    ...clipped.flatMap((rect) => [rect.y, rect.y + rect.height])
+  ]);
+  return { rects: clipped, xs, ys };
+}
+function totalCoveredArea(grid) {
+  return sum(grid.ys.slice(0, -1).map((_value, yIndex) => rowCoveredArea(grid, yIndex)));
+}
+function unionCoverageRatio(target, laterNodes) {
+  const targetArea = frameArea(target.frame);
+  if (targetArea <= 0) {
+    return 0;
+  }
+  const clipped = laterNodes.map((node) => clipFrameToTarget(target.frame, node.frame)).filter((rect) => rect !== void 0);
+  if (clipped.length === 0) {
+    return 0;
+  }
+  return totalCoveredArea(buildGrid(target.frame, clipped)) / targetArea;
+}
+function coveredByLaterUnion(target, laterNodes) {
+  return unionCoverageRatio(target, laterNodes) >= LATER_UNION_COVERAGE_THRESHOLD;
+}
 function isOccluder(target, candidate) {
   if (candidate.treeOrder <= target.treeOrder) {
     return false;
@@ -102808,8 +102881,16 @@ function isOccluder(target, candidate) {
   }
   return blocksTapPoint(target, candidate) || fullyCoversBoundingBox(target, candidate);
 }
+function laterNonRelativeNodes(target, nodes) {
+  return nodes.filter(
+    (candidate) => candidate.treeOrder > target.treeOrder && !candidate.ancestors.has(target.element) && !target.ancestors.has(candidate.element)
+  );
+}
 function isOccluded(target, nodes) {
-  return nodes.some((candidate) => isOccluder(target, candidate));
+  if (nodes.some((candidate) => isOccluder(target, candidate))) {
+    return true;
+  }
+  return coveredByLaterUnion(target, laterNonRelativeNodes(target, nodes));
 }
 function detectOccludedElements(elements, screen) {
   const nodes = flatten(elements, screen);
@@ -103671,26 +103752,20 @@ function createSwipeTool(udid = "booted") {
   );
 }
 var MOBILE_KEYS_SCRIPT = "mobile: keys";
-function splitCodePoints(text) {
-  return text.match(/[\s\S]/gu) ?? [];
-}
-function postKeys(input) {
+function typeText(input) {
   return wdaPost({
     baseUrl: input.baseUrl,
-    path: `/session/${input.sessionId}/execute/sync`,
-    body: { script: MOBILE_KEYS_SCRIPT, args: [{ keys: input.keys }] }
+    path: `/session/${input.sessionId}/wda/keys`,
+    body: { value: [input.text] }
   });
 }
-function typeText(input) {
-  return postKeys({
+function pressEnter(input) {
+  return wdaPost({
     baseUrl: input.baseUrl,
-    sessionId: input.sessionId,
-    keys: splitCodePoints(input.text)
+    path: `/session/${input.sessionId}/execute/sync`,
+    body: { script: MOBILE_KEYS_SCRIPT, args: [{ keys: ["\n"] }] }
   });
 }
-function pressEnter(input) {
-  return postKeys({ baseUrl: input.baseUrl, sessionId: input.sessionId, keys: ["\n"] });
-}
 var TYPE_TEXT_SCHEMA = { text: external_exports.string(), submit: external_exports.boolean().optional() };
 async function handleTypeText({ udid, text, submit }) {
   const result = await getOrCreateSession(APPIUM_BASE_URL, udid).andThen((sessionId) => {
@@ -105494,9 +105569,39 @@ function formatMemoryElements(elements) {
     (element) => `${element.label} [${String(Math.round(element.confidence * PCT_MULTIPLIER))}%${element.phase === "after-scroll" ? "\u2193" : ""}]`
   ).join(", ");
 }
+var MS_PER_SECOND22 = 1e3;
+function visualPassMarker(event) {
+  if (event.outcome === "ok") {
+    return "\xB7";
+  }
+  if (event.outcome === "skipped_similar") {
+    return "\u21B7";
+  }
+  return "\u26A0";
+}
+function visualPassStyle(event) {
+  if (event.outcome === "ok") {
+    return "default";
+  }
+  if (event.outcome === "skipped_similar") {
+    return "dim";
+  }
+  return "error";
+}
+function visualPassSummaryText(event) {
+  if (event.outcome === "skipped_similar") {
+    const distance = event.similarDistance ?? 0;
+    return `${visualPassMarker(event)} ${event.agent} visual_pass skipped \u2014 similar to a previously analysed screen (distance ${String(distance)})`;
+  }
+  const duration3 = (event.durationMs / MS_PER_SECOND22).toFixed(1);
+  return `${visualPassMarker(event)} ${event.agent} visual_pass ${event.outcome} \u2014 ${String(event.findingsEmitted)} finding(s) in ${duration3}s`;
+}
+function renderVisualPassRun(event) {
+  return [{ kind: "text", style: visualPassStyle(event), text: visualPassSummaryText(event) }];
+}
 var HIDDEN_TOOL_ARGS = /* @__PURE__ */ new Set(["device"]);
 var SCREEN_PREVIEW_LENGTH = 80;
-var MS_PER_SECOND22 = 1e3;
+var MS_PER_SECOND32 = 1e3;
 var COST_DECIMAL_PLACES = 4;
 function formatToolName(name) {
   return name.replace(/^mcp_(?:mobile_)?/, "").replace(/_on_screen$/, "");
@@ -105508,7 +105613,7 @@ function buildToolArgumentString(input) {
   return Object.entries(input).filter(([key]) => !HIDDEN_TOOL_ARGS.has(key)).map(([key, value]) => `${key}: ${String(value)}`).join(", ");
 }
 function normalizeTimeoutGraceEntered(event) {
-  const seconds = Math.round(event.gracePeriodMs / MS_PER_SECOND22);
+  const seconds = Math.round(event.gracePeriodMs / MS_PER_SECOND32);
   return [
     {
       kind: "annotation",
@@ -105531,11 +105636,7 @@ function normalizeFindingReported(event) {
   ];
 }
 function normalizeVisualPassRun(event) {
-  const duration3 = (event.durationMs / MS_PER_SECOND22).toFixed(1);
-  const marker = event.outcome === "ok" ? "\xB7" : "\u26A0";
-  const summary = `${marker} ${event.agent} visual_pass ${event.outcome} \u2014 ${String(event.findingsEmitted)} finding(s) in ${duration3}s`;
-  const style = event.outcome === "ok" ? "default" : "error";
-  return [{ kind: "text", style, text: summary }];
+  return renderVisualPassRun(event);
 }
 function normalizeStageStart(event) {
   return [
@@ -105544,7 +105645,7 @@ function normalizeStageStart(event) {
   ];
 }
 function normalizeStageEnd(event) {
-  const duration3 = (event.durationMs / MS_PER_SECOND22).toFixed(1);
+  const duration3 = (event.durationMs / MS_PER_SECOND32).toFixed(1);
   return [
     { kind: "text", style: "dim", text: `${event.agent} done in ${duration3}s` },
     { kind: "group-close" }
@@ -143806,12 +143907,12 @@ function partitionClusters(clusters, rangeOf) {
   const unranged = clusters.filter((cluster) => rangeOf(cluster) === void 0);
   return { ranged, unranged };
 }
-var MS_PER_SECOND32 = 1e3;
+var MS_PER_SECOND33 = 1e3;
 var SECONDS_PER_MINUTE2 = 60;
 var TIMESTAMP_PAD = 2;
 var TITLE_MAX_LENGTH2 = 120;
 function formatTimestamp2(ms) {
-  const totalSeconds = Math.max(0, Math.floor(ms / MS_PER_SECOND32));
+  const totalSeconds = Math.max(0, Math.floor(ms / MS_PER_SECOND33));
   const minutes = Math.floor(totalSeconds / SECONDS_PER_MINUTE2);
   const seconds = totalSeconds % SECONDS_PER_MINUTE2;
   return `${String(minutes).padStart(TIMESTAMP_PAD, "0")}:${String(seconds).padStart(TIMESTAMP_PAD, "0")}`;
@@ -144499,7 +144600,7 @@ var analyserConfigSchema = agentBaseConfigSchema.extend({
 }).strict();
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow59 = __toESM(require_index_cjs(), 1);
+var import_neverthrow60 = __toESM(require_index_cjs(), 1);
 
 // ../../agents/consolidator/dist/index.js
 var import_neverthrow37 = __toESM(require_index_cjs(), 1);
@@ -150592,7 +150693,7 @@ function runConsolidator(input, config2) {
 var consolidatorConfigSchema = agentBaseConfigSchema.extend({ enabled: external_exports.boolean().default(true) }).strict();
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow60 = __toESM(require_index_cjs(), 1);
+var import_neverthrow61 = __toESM(require_index_cjs(), 1);
 var import_promises25 = require("node:timers/promises");
 
 // ../../agents/explorer/dist/index.js
@@ -150607,29 +150708,17 @@ var import_node_path13 = __toESM(require("node:path"), 1);
 var import_promises18 = require("node:fs/promises");
 var import_node_path14 = __toESM(require("node:path"), 1);
 var import_neverthrow44 = __toESM(require_index_cjs(), 1);
-var import_node_child_process5 = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_neverthrow45 = __toESM(require_index_cjs(), 1);
 var import_promises19 = require("node:fs/promises");
 var import_node_path15 = __toESM(require("node:path"), 1);
-var import_neverthrow45 = __toESM(require_index_cjs(), 1);
 var import_neverthrow46 = __toESM(require_index_cjs(), 1);
 var import_neverthrow47 = __toESM(require_index_cjs(), 1);
-var import_promises20 = require("node:fs/promises");
-var import_node_path16 = __toESM(require("node:path"), 1);
 var import_neverthrow48 = __toESM(require_index_cjs(), 1);
-var import_neverthrow49 = __toESM(require_index_cjs(), 1);
-var import_node_child_process6 = require("node:child_process");
-var import_promises21 = require("node:fs/promises");
-var import_node_path17 = __toESM(require("node:path"), 1);
-var import_neverthrow50 = __toESM(require_index_cjs(), 1);
-var import_node_child_process7 = require("node:child_process");
-var import_node_fs5 = require("node:fs");
-var import_node_path18 = __toESM(require("node:path"), 1);
-var import_neverthrow51 = __toESM(require_index_cjs(), 1);
-var import_node_crypto2 = require("node:crypto");
-var import_neverthrow52 = __toESM(require_index_cjs(), 1);
+var import_node_child_process5 = require("node:child_process");
 var import_node_crypto3 = require("node:crypto");
 var import_sharp_phash = __toESM(require_sharp_phash(), 1);
-var import_neverthrow53 = __toESM(require_index_cjs(), 1);
+var import_neverthrow49 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {
@@ -150788,11 +150877,25 @@ function validateConcurrency(concurrency) {
 }
 
 // ../../agents/explorer/dist/index.js
+var import_promises20 = require("node:fs/promises");
+var import_node_path16 = __toESM(require("node:path"), 1);
+var import_neverthrow50 = __toESM(require_index_cjs(), 1);
+var import_neverthrow51 = __toESM(require_index_cjs(), 1);
+var import_sharp2 = __toESM(require("sharp"), 1);
+var import_promises21 = require("node:fs/promises");
+var import_node_path17 = __toESM(require("node:path"), 1);
+var import_neverthrow52 = __toESM(require_index_cjs(), 1);
+var import_neverthrow53 = __toESM(require_index_cjs(), 1);
+var import_node_child_process6 = require("node:child_process");
 var import_promises22 = require("node:fs/promises");
-var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var import_neverthrow54 = __toESM(require_index_cjs(), 1);
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs5 = require("node:fs");
+var import_node_path19 = __toESM(require("node:path"), 1);
 var import_neverthrow55 = __toESM(require_index_cjs(), 1);
-var import_sharp2 = __toESM(require("sharp"), 1);
+var import_node_crypto4 = require("node:crypto");
+var import_neverthrow56 = __toESM(require_index_cjs(), 1);
 var import_promises23 = require("node:fs/promises");
 var import_node_path20 = __toESM(require("node:path"), 1);
 
@@ -153421,11 +153524,11 @@ var jsYaml = {
 };
 
 // ../../agents/explorer/dist/index.js
-var import_neverthrow56 = __toESM(require_index_cjs(), 1);
 var import_neverthrow57 = __toESM(require_index_cjs(), 1);
+var import_neverthrow58 = __toESM(require_index_cjs(), 1);
 var import_promises24 = require("node:fs/promises");
 var import_node_path21 = __toESM(require("node:path"), 1);
-var import_neverthrow58 = __toESM(require_index_cjs(), 1);
+var import_neverthrow59 = __toESM(require_index_cjs(), 1);
 var INTERRUPT_DRAIN_TIMEOUT_MS = 1e4;
 async function interruptOrTimeout(queryRunner) {
   await Promise.race([queryRunner.interrupt(), (0, import_promises16.setTimeout)(INTERRUPT_DRAIN_TIMEOUT_MS)]);
@@ -153988,122 +154091,7 @@ function captureFromUser(content, state) {
     captureToolResult(block, state);
   }
 }
-function processMessage(message, state) {
-  if (message.type === "assistant" && Array.isArray(message.message.content)) {
-    captureFromAssistant(message.message.content, state);
-  }
-  if (message.type === "user" && Array.isArray(message.message.content)) {
-    captureFromUser(message.message.content, state);
-  }
-  if (message.type === "result") {
-    const resultMessage = message;
-    const { tokenUsage } = state;
-    tokenUsage.value = {
-      inputTokens: resultMessage.usage.input_tokens,
-      outputTokens: resultMessage.usage.output_tokens,
-      cacheReadInputTokens: resultMessage.usage.cache_read_input_tokens,
-      cacheCreationInputTokens: resultMessage.usage.cache_creation_input_tokens,
-      totalCostUsd: resultMessage.total_cost_usd
-    };
-    if (message.subtype !== "success" && !state.timedOut.value && !state.aborted.value) {
-      return (0, import_neverthrow42.err)(message.errors.join("; "));
-    }
-    return (0, import_neverthrow42.ok)(true);
-  }
-  return (0, import_neverthrow42.ok)(false);
-}
-async function processMessages(queryRunner, state) {
-  for await (const message of queryRunner) {
-    const result = processMessage(message, state);
-    if (result.isErr()) {
-      return (0, import_neverthrow42.err)(result.error);
-    }
-    if (result.value) {
-      break;
-    }
-  }
-  return (0, import_neverthrow42.ok)(null);
-}
-function buildSendMessageFunction(inputQueue) {
-  return (content) => {
-    const message = {
-      type: "user",
-      message: { role: "user", content },
-      parent_tool_use_id: null,
-      isSynthetic: true
-    };
-    inputQueue.enqueue(message);
-  };
-}
-function buildAgentState({
-  config: config2,
-  inputQueue
-}) {
-  return {
-    pendingToolCallNames: /* @__PURE__ */ new Map(),
-    snapshots: [],
-    stepCounter: { value: 0 },
-    findings: [],
-    findingCounter: { value: 0 },
-    sendMessage: buildSendMessageFunction(inputQueue),
-    closeQueue: () => {
-      inputQueue.close();
-    },
-    timedOut: { value: false },
-    aborted: { value: false },
-    onEvent: config2.onEvent,
-    tokenUsage: { value: { ...EMPTY_TOKEN_USAGE } }
-  };
-}
-function spawnDetached(options) {
-  const child = (0, import_node_child_process5.spawn)(options.command, options.args, {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: ["pipe", "pipe", "pipe"],
-    detached: true,
-    signal: options.signal
-  });
-  child.stderr.pipe(process.stderr);
-  return {
-    stdin: child.stdin,
-    stdout: child.stdout,
-    get killed() {
-      return child.killed;
-    },
-    get exitCode() {
-      return child.exitCode;
-    },
-    kill: child.kill.bind(child),
-    on: child.on.bind(child),
-    once: child.once.bind(child),
-    off: child.off.bind(child)
-  };
-}
-function buildBaseOptions(context) {
-  const { config: config2, mobileIosServer, allowedTools } = context;
-  return {
-    mcpServers: {
-      ...config2.mcpServers,
-      "mobile-ios": mobileIosServer
-    },
-    allowedTools,
-    tools: [],
-    permissionMode: "bypassPermissions",
-    allowDangerouslySkipPermissions: true,
-    spawnClaudeCodeProcess: spawnDetached,
-    thinking: { type: "adaptive" },
-    ...config2.cwd ? { cwd: config2.cwd } : {}
-  };
-}
-function buildQueryOptions(context) {
-  const base = buildBaseOptions(context);
-  if (!context.config.signal) {
-    return { options: base, linkedController: void 0 };
-  }
-  const linkedController = new AbortController();
-  return { options: { ...base, abortController: linkedController }, linkedController };
-}
-var safeWriteFile3 = (0, import_neverthrow45.fromAsyncThrowable)(
+var safeWriteFile3 = (0, import_neverthrow46.fromAsyncThrowable)(
   import_promises19.writeFile,
   (cause) => ({ type: "WRITE_FAILED", cause })
 );
@@ -154408,14 +154396,21 @@ function buildVisualScanTool() {
   return {
     name: VISUAL_SCAN_TOOL_NAME,
     description: VISUAL_SCAN_DESCRIPTION,
-    input_schema: external_exports.toJSONSchema(visualScanInputSchema)
+    input_schema: external_exports.toJSONSchema(visualScanInputSchema),
+    cache_control: { type: "ephemeral" }
   };
 }
 function buildVisualPassRequest(input) {
   return {
     model: input.model ?? VISUAL_PASS_DEFAULT_MODEL,
     max_tokens: input.maxTokens ?? VISUAL_PASS_DEFAULT_MAX_TOKENS,
-    system: buildVisualPassSystemPrompt(input.visualMode),
+    system: [
+      {
+        type: "text",
+        text: buildVisualPassSystemPrompt(input.visualMode),
+        cache_control: { type: "ephemeral" }
+      }
+    ],
     tools: [buildVisualScanTool()],
     tool_choice: { type: "tool", name: VISUAL_SCAN_TOOL_NAME },
     messages: [buildUserMessage2(input)]
@@ -154436,18 +154431,18 @@ function checkConsistency(decisions, findings) {
   const emitDecisions = findEmitDecisions(decisions);
   const visualFindings = findings.filter((finding) => isVisualTrigger(finding));
   if (emitDecisions.length > 0 && visualFindings.length === 0) {
-    return (0, import_neverthrow47.err)({
+    return (0, import_neverthrow48.err)({
       type: "VISUAL_PASS_INCONSISTENT",
       emitDecisions,
       findingCount: findings.length
     });
   }
-  return (0, import_neverthrow47.ok)(visualFindings);
+  return (0, import_neverthrow48.ok)(visualFindings);
 }
 function parseVisualScanBlock(block) {
   const result = visualScanInputSchema.safeParse(block.input);
   if (!result.success) {
-    return (0, import_neverthrow47.err)({
+    return (0, import_neverthrow48.err)({
       type: "VISUAL_PASS_INPUT_INVALID",
       issues: formatIssues2(result.error),
       raw: block.input
@@ -154468,11 +154463,18 @@ function parseVisualPassMessage(message) {
   const parsed = blocks.map((block) => parseVisualScanBlock(block));
   const failure = parsed.find((result) => result.isErr());
   if (failure?.isErr() === true) {
-    return (0, import_neverthrow47.err)(failure.error);
+    return (0, import_neverthrow48.err)(failure.error);
   }
-  return (0, import_neverthrow47.ok)(parsed.flatMap((result) => result.isOk() ? result.value : []));
+  return (0, import_neverthrow48.ok)(parsed.flatMap((result) => result.isOk() ? result.value : []));
 }
 var ANTHROPIC_MAX_RETRIES = 5;
+var EMPTY_VISUAL_PASS_USAGE = {
+  model: "",
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadInputTokens: 0,
+  cacheCreationInputTokens: 0
+};
 async function createMessage(input) {
   const client = new Anthropic({ maxRetries: ANTHROPIC_MAX_RETRIES });
   const request2 = buildVisualPassRequest({
@@ -154482,19 +154484,68 @@ async function createMessage(input) {
   });
   return client.messages.create(request2);
 }
-function extractFindings(message) {
+function extractUsage(message) {
+  return {
+    model: message.model,
+    inputTokens: message.usage.input_tokens,
+    outputTokens: message.usage.output_tokens,
+    cacheReadInputTokens: message.usage.cache_read_input_tokens ?? 0,
+    cacheCreationInputTokens: message.usage.cache_creation_input_tokens ?? 0
+  };
+}
+function extractOutput(message) {
   const parsed = parseVisualPassMessage(message);
-  return parsed.isOk() ? (0, import_neverthrow46.okAsync)(parsed.value) : (0, import_neverthrow46.errAsync)(parsed.error);
+  if (parsed.isErr()) {
+    return (0, import_neverthrow47.errAsync)(parsed.error);
+  }
+  return (0, import_neverthrow47.okAsync)({ findings: parsed.value, usage: extractUsage(message) });
 }
 function runVisualPass(input) {
   if (input.visualMode.kind === "disabled") {
-    return (0, import_neverthrow46.okAsync)([]);
+    return (0, import_neverthrow47.okAsync)({ findings: [], usage: { ...EMPTY_VISUAL_PASS_USAGE } });
   }
-  const safeCreate = (0, import_neverthrow46.fromAsyncThrowable)(
+  const safeCreate = (0, import_neverthrow47.fromAsyncThrowable)(
     createMessage,
     (cause) => ({ type: "VISUAL_PASS_API_FAILED", cause })
   );
-  return safeCreate(input).andThen(extractFindings);
+  return safeCreate(input).andThen(extractOutput);
+}
+var MATCH_TOLERANCE_VALUES = ["strict", "balanced", "loose"];
+var STRICT_HAMMING_THRESHOLD = 6;
+var BALANCED_HAMMING_THRESHOLD = 12;
+var LOOSE_HAMMING_THRESHOLD = 20;
+var HAMMING_THRESHOLD_BY_TOLERANCE = {
+  strict: STRICT_HAMMING_THRESHOLD,
+  balanced: BALANCED_HAMMING_THRESHOLD,
+  loose: LOOSE_HAMMING_THRESHOLD
+};
+function hammingDistance(left, right) {
+  const xor2 = left ^ right;
+  return (xor2.toString(2).match(/1/g) ?? []).length;
+}
+function selectTopK(input) {
+  const scored = input.candidates.map(
+    (candidate) => ({
+      name: candidate.name,
+      distance: hammingDistance(input.target, candidate.hash)
+    })
+  );
+  const within = scored.filter((entry) => entry.distance <= input.threshold);
+  const sorted = within.toSorted((left, right) => left.distance - right.distance);
+  return sorted.slice(0, input.topK);
+}
+function pickClosestDistance(target, entries) {
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return Math.min(...entries.map((hash2) => hammingDistance(target, hash2)));
+}
+function findSimilarAnalyzedScreen(input) {
+  const closest = pickClosestDistance(input.targetHash, input.entries);
+  if (closest === void 0 || closest > input.similarityThreshold) {
+    return { matched: false };
+  }
+  return { matched: true, distance: closest };
 }
 function outcomeFromError(error48) {
   if (error48.type === "VISUAL_PASS_API_FAILED") {
@@ -154503,13 +154554,31 @@ function outcomeFromError(error48) {
   return "input_invalid";
 }
 function emitRunEvent(params) {
-  params.onEvent?.({
+  const base = {
     type: "VISUAL_PASS_RUN",
     agent: "explorer",
     durationMs: params.durationMs,
     findingsEmitted: params.findingsEmitted,
     outcome: params.outcome
+  };
+  params.onEvent?.(
+    params.similarDistance === void 0 ? base : { ...base, similarDistance: params.similarDistance }
+  );
+}
+function nextUsage(current, usage) {
+  const cost = calculateAnthropicCost(usage.model, {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheReadInputTokens: usage.cacheReadInputTokens,
+    cacheCreationInputTokens: usage.cacheCreationInputTokens
   });
+  return {
+    inputTokens: current.inputTokens + usage.inputTokens,
+    outputTokens: current.outputTokens + usage.outputTokens,
+    cacheReadInputTokens: current.cacheReadInputTokens + usage.cacheReadInputTokens,
+    cacheCreationInputTokens: current.cacheCreationInputTokens + usage.cacheCreationInputTokens,
+    totalCostUsd: current.totalCostUsd + cost
+  };
 }
 async function recordFindingsIfAny(arguments_) {
   if (arguments_.findings.length === 0) {
@@ -154521,35 +154590,401 @@ async function recordFindingsIfAny(arguments_) {
     screenshotData: arguments_.screenshotData
   });
 }
-async function runHookOnce(arguments_) {
-  const { context, input, now } = arguments_;
-  const start = now();
+function buildLookup(cache3, hash2) {
+  return {
+    hash: hash2,
+    match: findSimilarAnalyzedScreen({
+      targetHash: hash2,
+      entries: cache3.store.entries(),
+      similarityThreshold: cache3.similarityThreshold
+    })
+  };
+}
+async function lookupCache(cache3, screenshotBase64) {
+  if (cache3 === void 0) {
+    return void 0;
+  }
+  const safeCompute = import_neverthrow45.ResultAsync.fromThrowable(
+    cache3.computeScreenshotPhash,
+    () => ({ type: "PHASH_COMPUTE_FAILED" })
+  );
+  const computed = await safeCompute(Buffer.from(screenshotBase64, "base64"));
+  if (computed.isErr()) {
+    return void 0;
+  }
+  return buildLookup(cache3, computed.value);
+}
+function emitSkippedEvent(arguments_) {
+  emitRunEvent({
+    onEvent: arguments_.context.onEvent,
+    durationMs: arguments_.durationMs,
+    findingsEmitted: 0,
+    outcome: "skipped_similar",
+    similarDistance: arguments_.distance
+  });
+}
+async function executeAndRecord(arguments_) {
+  const { context, input, cacheLookup, start, now } = arguments_;
   const result = await runVisualPass({
     visualMode: context.visualMode,
     screenshotBase64: input.screenshotBase64,
     accessibilityTreeText: input.accessibilityTreeText
   });
-  const durationMs = now() - start;
   const outcome = result.isErr() ? outcomeFromError(result.error) : "ok";
-  const findings = result.isErr() ? [] : result.value;
-  await recordFindingsIfAny({
-    context,
-    findings,
-    screenshotData: input.screenshotBase64
-  });
+  const findings = result.isErr() ? [] : result.value.findings;
+  if (result.isOk()) {
+    context.visualUsage.value = nextUsage(context.visualUsage.value, result.value.usage);
+  }
+  await recordFindingsIfAny({ context, findings, screenshotData: input.screenshotBase64 });
+  if (cacheLookup !== void 0 && context.cache !== void 0 && result.isOk()) {
+    context.cache.store.add(cacheLookup.hash);
+  }
   emitRunEvent({
     onEvent: context.onEvent,
-    durationMs,
+    durationMs: now() - start,
     findingsEmitted: findings.length,
     outcome
   });
 }
+async function runHookOnce(arguments_) {
+  const { context, input, now } = arguments_;
+  const start = now();
+  const cacheLookup = await lookupCache(context.cache, input.screenshotBase64);
+  if (cacheLookup?.match.matched === true) {
+    emitSkippedEvent({
+      context,
+      durationMs: now() - start,
+      distance: cacheLookup.match.distance
+    });
+    return;
+  }
+  await executeAndRecord({ context, input, cacheLookup, start, now });
+}
+function computeScreenDigest(input) {
+  return (0, import_node_crypto2.createHash)("sha256").update(input.accessibilityTreeText).update(":").update(input.screenshotBase64).digest("hex");
+}
+async function runAfterPrevious(previous, arguments_) {
+  await previous;
+  await runHookOnce(arguments_);
+}
+async function drainVisualPassHook(pending) {
+  await pending.value;
+}
 function createVisualPassHook(context) {
   if (context.visualMode.kind === "disabled") {
     return void 0;
   }
   const now = context.now ?? (() => Date.now());
-  return async (input) => runHookOnce({ context, input, now });
+  const { lastDigest, pendingPasses } = context;
+  return async (input) => {
+    const digest = computeScreenDigest(input);
+    if (digest === lastDigest.value) {
+      return;
+    }
+    lastDigest.value = digest;
+    pendingPasses.value = runAfterPrevious(pendingPasses.value, { context, input, now });
+    await Promise.resolve();
+  };
+}
+function sumTokenUsage(result, visual) {
+  return {
+    inputTokens: result.usage.input_tokens + visual.inputTokens,
+    outputTokens: result.usage.output_tokens + visual.outputTokens,
+    cacheReadInputTokens: result.usage.cache_read_input_tokens + visual.cacheReadInputTokens,
+    cacheCreationInputTokens: result.usage.cache_creation_input_tokens + visual.cacheCreationInputTokens,
+    totalCostUsd: result.total_cost_usd + visual.totalCostUsd
+  };
+}
+async function processMessage(message, state) {
+  if (message.type === "assistant" && Array.isArray(message.message.content)) {
+    captureFromAssistant(message.message.content, state);
+  }
+  if (message.type === "user" && Array.isArray(message.message.content)) {
+    captureFromUser(message.message.content, state);
+  }
+  if (message.type === "result") {
+    await drainVisualPassHook(state.visualPassesPending);
+    const resultMessage = message;
+    const { tokenUsage } = state;
+    tokenUsage.value = sumTokenUsage(resultMessage, state.visualUsage.value);
+    if (message.subtype !== "success" && !state.timedOut.value && !state.aborted.value) {
+      return (0, import_neverthrow42.err)(message.errors.join("; "));
+    }
+    return (0, import_neverthrow42.ok)(true);
+  }
+  return (0, import_neverthrow42.ok)(false);
+}
+async function processMessages(queryRunner, state) {
+  for await (const message of queryRunner) {
+    const result = await processMessage(message, state);
+    if (result.isErr()) {
+      return (0, import_neverthrow42.err)(result.error);
+    }
+    if (result.value) {
+      break;
+    }
+  }
+  return (0, import_neverthrow42.ok)(null);
+}
+function buildCloseQueueFunction(inputQueue) {
+  return () => {
+    inputQueue.close();
+  };
+}
+function buildSendMessageFunction(inputQueue) {
+  return (content) => {
+    const message = {
+      type: "user",
+      message: { role: "user", content },
+      parent_tool_use_id: null,
+      isSynthetic: true
+    };
+    inputQueue.enqueue(message);
+  };
+}
+function buildAgentState({
+  config: config2,
+  inputQueue
+}) {
+  return {
+    pendingToolCallNames: /* @__PURE__ */ new Map(),
+    snapshots: [],
+    stepCounter: { value: 0 },
+    findings: [],
+    findingCounter: { value: 0 },
+    sendMessage: buildSendMessageFunction(inputQueue),
+    closeQueue: buildCloseQueueFunction(inputQueue),
+    timedOut: { value: false },
+    aborted: { value: false },
+    onEvent: config2.onEvent,
+    tokenUsage: { value: { ...EMPTY_TOKEN_USAGE } },
+    visualUsage: { value: { ...EMPTY_TOKEN_USAGE } },
+    visualLastDigest: { value: void 0 },
+    visualPassesPending: { value: Promise.resolve() }
+  };
+}
+function spawnDetached(options) {
+  const child = (0, import_node_child_process5.spawn)(options.command, options.args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: ["pipe", "pipe", "pipe"],
+    detached: true,
+    signal: options.signal
+  });
+  child.stderr.pipe(process.stderr);
+  return {
+    stdin: child.stdin,
+    stdout: child.stdout,
+    get killed() {
+      return child.killed;
+    },
+    get exitCode() {
+      return child.exitCode;
+    },
+    kill: child.kill.bind(child),
+    on: child.on.bind(child),
+    once: child.once.bind(child),
+    off: child.off.bind(child)
+  };
+}
+function buildBaseOptions(context) {
+  const { config: config2, mobileIosServer, allowedTools } = context;
+  return {
+    mcpServers: {
+      ...config2.mcpServers,
+      "mobile-ios": mobileIosServer
+    },
+    allowedTools,
+    tools: [],
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    spawnClaudeCodeProcess: spawnDetached,
+    thinking: { type: "adaptive" },
+    ...config2.cwd ? { cwd: config2.cwd } : {}
+  };
+}
+function buildQueryOptions(context) {
+  const base = buildBaseOptions(context);
+  if (!context.config.signal) {
+    return { options: base, linkedController: void 0 };
+  }
+  const linkedController = new AbortController();
+  return { options: { ...base, abortController: linkedController }, linkedController };
+}
+function createAnalyzedScreenStore() {
+  const context = { entries: [] };
+  return {
+    entries: () => context.entries,
+    add: (hash2) => {
+      context.entries.push(hash2);
+    }
+  };
+}
+function emptyDirectoryError(directory) {
+  return { type: "ARTBOARD_INDEX_BUILD_FAILED", reason: "EMPTY_DIRECTORY", directory };
+}
+function zeroSuccessesError(attempted) {
+  return { type: "ARTBOARD_INDEX_BUILD_FAILED", reason: "ZERO_SUCCESSFUL_PHASHES", attempted };
+}
+function compactSuccesses(results) {
+  return results.filter((entry) => entry !== void 0);
+}
+function buildArtboardPhashIndex(input) {
+  if (input.artboardNames.length === 0) {
+    return (0, import_neverthrow49.errAsync)(emptyDirectoryError(input.directory ?? ""));
+  }
+  const limit = pLimit(input.concurrency);
+  const tasks = input.artboardNames.map(async (name) => limit(async () => input.computeOne(name)));
+  return import_neverthrow49.ResultAsync.fromSafePromise(Promise.all(tasks)).andThen((results) => {
+    const successful = compactSuccesses(results);
+    if (successful.length === 0) {
+      return (0, import_neverthrow49.errAsync)(zeroSuccessesError(input.artboardNames.length));
+    }
+    return (0, import_neverthrow49.okAsync)(successful);
+  });
+}
+var PHASH_ALGO_VERSION = "v1";
+function wrapIoError(cause) {
+  return { type: "PHASH_CACHE_IO_FAILED", cause };
+}
+function cacheFile(directory, key) {
+  const filename = `${key.algoVersion}-${String(key.maxEdgePx)}-${key.fileSha256}.json`;
+  return import_node_path16.default.join(directory, filename);
+}
+function isEnoent(cause) {
+  return cause?.code === "ENOENT";
+}
+var safeReadFile = import_neverthrow50.ResultAsync.fromThrowable(
+  import_promises20.readFile,
+  wrapIoError
+);
+var safeWriteFile4 = import_neverthrow50.ResultAsync.fromThrowable(
+  import_promises20.writeFile,
+  wrapIoError
+);
+var safeMkdir2 = import_neverthrow50.ResultAsync.fromThrowable(
+  import_promises20.mkdir,
+  wrapIoError
+);
+var safeParsePayload = (0, import_neverthrow50.fromThrowable)(
+  (raw) => JSON.parse(raw),
+  wrapIoError
+);
+var safeBigInt = (0, import_neverthrow50.fromThrowable)(BigInt, wrapIoError);
+function readPhashCache(directory, key) {
+  return safeReadFile(cacheFile(directory, key), "utf8").andThen((raw) => safeParsePayload(raw)).andThen((payload) => safeBigInt(payload.hash)).map((hash2) => hash2).orElse((error48) => {
+    if (isEnoent(error48.cause)) {
+      return (0, import_neverthrow50.okAsync)(void 0);
+    }
+    return (0, import_neverthrow50.errAsync)(error48);
+  });
+}
+function writePhashCache(directory, entry) {
+  return safeMkdir2(directory, { recursive: true }).andThen(
+    () => safeWriteFile4(cacheFile(directory, entry.key), JSON.stringify({ hash: entry.hash.toString() }))
+  );
+}
+function computeArtboardPhashFactory(deps) {
+  return async (name) => {
+    const buffer = await deps.loadArtboardBuffer(name);
+    if (buffer === void 0) {
+      return void 0;
+    }
+    const fileSha256 = await deps.sha256(buffer);
+    const key = {
+      fileSha256,
+      maxEdgePx: deps.maxEdgePx,
+      algoVersion: PHASH_ALGO_VERSION
+    };
+    const cached2 = await deps.readFromCache(deps.cacheDirectory, key);
+    if (cached2 !== void 0) {
+      return { name, hash: cached2 };
+    }
+    const preprocessed = await deps.preprocess(buffer, deps.maxEdgePx);
+    const hash2 = await deps.computePhash(preprocessed);
+    await deps.writeToCache(deps.cacheDirectory, { key, hash: hash2 });
+    return { name, hash: hash2 };
+  };
+}
+var PNG_COMPRESSION_LEVEL = 9;
+async function runSharp(input) {
+  return (0, import_sharp2.default)(input.buffer).resize({
+    width: input.maxEdgePx,
+    height: input.maxEdgePx,
+    fit: "inside",
+    withoutEnlargement: true
+  }).png({ compressionLevel: PNG_COMPRESSION_LEVEL }).toBuffer();
+}
+var safeRunSharp = import_neverthrow51.ResultAsync.fromThrowable(
+  runSharp,
+  (cause) => ({ type: "IMAGE_PREPROCESS_FAILED", cause })
+);
+function preprocessImage(input) {
+  return safeRunSharp(input);
+}
+var INDEX_BUILD_CONCURRENCY = 4;
+var HEX_ENCODING = "hex";
+function returnUndefined() {
+  return void 0;
+}
+function returnEmptyArray() {
+  return [];
+}
+async function sha256(buffer) {
+  return await Promise.resolve((0, import_node_crypto3.createHash)("sha256").update(buffer).digest(HEX_ENCODING));
+}
+async function preprocessForPhash(buffer, maxEdgePx) {
+  const result = await preprocessImage({ buffer, maxEdgePx });
+  return result.match(
+    (preprocessed) => preprocessed,
+    () => buffer
+  );
+}
+async function readPhashFromDisk(cacheDirectory, key) {
+  const result = await readPhashCache(cacheDirectory, key);
+  return result.match((hash2) => hash2, returnUndefined);
+}
+async function writePhashToDisk(cacheDirectory, entry) {
+  const result = await writePhashCache(cacheDirectory, entry);
+  result.match(returnUndefined, returnUndefined);
+}
+async function loadArtboardBuffer(designStore, name) {
+  const result = await designStore.getArtboard(name);
+  return result.match((artboard) => artboard?.buffer, returnUndefined);
+}
+async function listArtboardNames(designStore) {
+  const result = await designStore.listArtboards();
+  return result.match(
+    (names) => names,
+    () => []
+  );
+}
+function makeComputeOne(arguments_) {
+  return computeArtboardPhashFactory({
+    readFromCache: readPhashFromDisk,
+    writeToCache: writePhashToDisk,
+    loadArtboardBuffer: async (name) => loadArtboardBuffer(arguments_.designStore, name),
+    preprocess: preprocessForPhash,
+    computePhash: computeArtboardPhash,
+    sha256,
+    maxEdgePx: arguments_.maxEdgePx,
+    cacheDirectory: arguments_.runCacheDirectory
+  });
+}
+async function computeArtboardPhash(buffer) {
+  const hashString = await (0, import_sharp_phash.default)(buffer);
+  return BigInt(`0b${hashString}`);
+}
+async function buildArtboardIndex(arguments_) {
+  const names = await listArtboardNames(arguments_.designStore);
+  const computeOne = makeComputeOne(arguments_);
+  const result = await buildArtboardPhashIndex({
+    artboardNames: names,
+    concurrency: INDEX_BUILD_CONCURRENCY,
+    computeOne,
+    directory: arguments_.runCacheDirectory
+  });
+  return result.match((artboards) => artboards, returnEmptyArray);
 }
 function buildReportFindingTool(input) {
   const findingScreenshotsDirectory = input.config.capabilities.findingScreenshots ? input.config.screenshotsDir : void 0;
@@ -154563,6 +154998,17 @@ function buildReportFindingTool(input) {
     visualMode: input.visualWiring?.mode
   });
 }
+function buildVisualPassCache(input) {
+  const visual = input.config.visual;
+  if (visual === void 0) {
+    return void 0;
+  }
+  return {
+    store: createAnalyzedScreenStore(),
+    computeScreenshotPhash: computeArtboardPhash,
+    similarityThreshold: HAMMING_THRESHOLD_BY_TOLERANCE[visual.cacheTolerance]
+  };
+}
 function buildVisualPassHookForInput(input) {
   if (input.visualWiring === void 0 || input.visualWiring.mode.kind === "disabled") {
     return void 0;
@@ -154571,13 +155017,17 @@ function buildVisualPassHookForInput(input) {
   return createVisualPassHook({
     visualMode: input.visualWiring.mode,
     onEvent: input.config.onEvent,
+    visualUsage: input.state.visualUsage,
+    lastDigest: input.state.visualLastDigest,
+    pendingPasses: input.state.visualPassesPending,
     recorder: {
       findings: input.state.findings,
       findingCounter: input.state.findingCounter,
       onEvent: input.config.onEvent,
       screenshotsDir: findingScreenshotsDirectory,
       findingsPath: input.config.findingsPath
-    }
+    },
+    cache: buildVisualPassCache(input)
   });
 }
 function buildViewUiTool(input) {
@@ -154763,12 +155213,12 @@ function buildFfmpegArguments(params) {
 }
 var TEMP_SUFFIX = ".compressed.mp4";
 function temporaryOutputFor(inputPath) {
-  const directory = import_node_path17.default.dirname(inputPath);
-  const base = import_node_path17.default.basename(inputPath, import_node_path17.default.extname(inputPath));
-  return import_node_path17.default.join(directory, `${base}${TEMP_SUFFIX}`);
+  const directory = import_node_path18.default.dirname(inputPath);
+  const base = import_node_path18.default.basename(inputPath, import_node_path18.default.extname(inputPath));
+  return import_node_path18.default.join(directory, `${base}${TEMP_SUFFIX}`);
 }
 function spawnFfmpeg2(arguments_) {
-  const safeSpawn2 = (0, import_neverthrow50.fromThrowable)(
+  const safeSpawn2 = (0, import_neverthrow54.fromThrowable)(
     (command, spawnArguments) => (0, import_node_child_process6.spawn)(command, spawnArguments),
     (cause) => cause
   );
@@ -154788,7 +155238,7 @@ function awaitFfmpegExit2(child) {
   child.once("exit", (code) => {
     resolve({ code: code ?? -1, stderr });
   });
-  return import_neverthrow50.ResultAsync.fromPromise(
+  return import_neverthrow54.ResultAsync.fromPromise(
     promise2,
     (cause) => ({ type: "FFMPEG_SPAWN_FAILED", cause })
   );
@@ -154796,31 +155246,31 @@ function awaitFfmpegExit2(child) {
 function runFfmpeg2(arguments_) {
   const childOrError = spawnFfmpeg2(arguments_);
   if (childOrError instanceof Error) {
-    return (0, import_neverthrow50.errAsync)({ type: "FFMPEG_SPAWN_FAILED", cause: childOrError });
+    return (0, import_neverthrow54.errAsync)({ type: "FFMPEG_SPAWN_FAILED", cause: childOrError });
   }
   return awaitFfmpegExit2(childOrError);
 }
 function ensureSuccess2(result) {
   if (result.code === 0) {
-    return (0, import_neverthrow50.okAsync)(true);
+    return (0, import_neverthrow54.okAsync)(true);
   }
-  return (0, import_neverthrow50.errAsync)({
+  return (0, import_neverthrow54.errAsync)({
     type: "FFMPEG_NONZERO_EXIT",
     code: result.code,
     stderr: result.stderr
   });
 }
-var safeRename = import_neverthrow50.ResultAsync.fromThrowable(
-  import_promises21.rename,
+var safeRename = import_neverthrow54.ResultAsync.fromThrowable(
+  import_promises22.rename,
   (cause) => ({ type: "FFMPEG_SPAWN_FAILED", cause })
 );
 function replaceFile(temporaryPath, finalPath) {
   return safeRename(temporaryPath, finalPath).map(() => finalPath);
 }
 var CLEANED = { type: "CLEANED" };
-var safeUnlink = import_neverthrow50.ResultAsync.fromThrowable(import_promises21.unlink, () => CLEANED);
+var safeUnlink = import_neverthrow54.ResultAsync.fromThrowable(import_promises22.unlink, () => CLEANED);
 function cleanupTemporaryAndPropagate(temporaryPath, error48) {
-  return safeUnlink(temporaryPath).orElse(() => (0, import_neverthrow50.okAsync)(CLEANED)).andThen(() => (0, import_neverthrow50.errAsync)(error48));
+  return safeUnlink(temporaryPath).orElse(() => (0, import_neverthrow54.okAsync)(CLEANED)).andThen(() => (0, import_neverthrow54.errAsync)(error48));
 }
 function compressRecording(inputPath, options = DEFAULT_VIDEO_COMPRESS_OPTIONS) {
   const temporaryPath = temporaryOutputFor(inputPath);
@@ -154828,12 +155278,12 @@ function compressRecording(inputPath, options = DEFAULT_VIDEO_COMPRESS_OPTIONS)
   return runFfmpeg2(arguments_).andThen(ensureSuccess2).andThen(() => replaceFile(temporaryPath, inputPath)).orElse((error48) => cleanupTemporaryAndPropagate(temporaryPath, error48));
 }
 function spawnRecorder(outputPath) {
-  const safeMkdirSync = (0, import_neverthrow51.fromThrowable)(import_node_fs5.mkdirSync, (cause) => cause);
-  const safeSpawn2 = (0, import_neverthrow51.fromThrowable)(
+  const safeMkdirSync = (0, import_neverthrow55.fromThrowable)(import_node_fs5.mkdirSync, (cause) => cause);
+  const safeSpawn2 = (0, import_neverthrow55.fromThrowable)(
     (command, arguments_) => (0, import_node_child_process7.spawn)(command, arguments_),
     (cause) => cause
   );
-  const mkdirResult = safeMkdirSync(import_node_path18.default.dirname(outputPath), { recursive: true });
+  const mkdirResult = safeMkdirSync(import_node_path19.default.dirname(outputPath), { recursive: true });
   if (mkdirResult.isErr()) {
     return mkdirResult.error;
   }
@@ -154858,7 +155308,7 @@ function earlyExitError(code) {
 function waitForRecordingStart(proc) {
   const { stderr } = proc;
   if (!stderr) {
-    return (0, import_neverthrow51.errAsync)({ type: "SPAWN_FAILED", cause: new RangeError("proc has no stderr pipe") });
+    return (0, import_neverthrow55.errAsync)({ type: "SPAWN_FAILED", cause: new RangeError("proc has no stderr pipe") });
   }
   const { promise: promise2, resolve, reject } = Promise.withResolvers();
   proc.once("error", reject);
@@ -154874,7 +155324,7 @@ function waitForRecordingStart(proc) {
       resolve({ process: proc, startedAt: Date.now() });
     }
   });
-  return import_neverthrow51.ResultAsync.fromPromise(
+  return import_neverthrow55.ResultAsync.fromPromise(
     promise2,
     (cause) => ({ type: "SPAWN_FAILED", cause })
   );
@@ -154882,7 +155332,7 @@ function waitForRecordingStart(proc) {
 function startRecording(outputPath) {
   const procOrError = spawnRecorder(outputPath);
   if (procOrError instanceof Error) {
-    return (0, import_neverthrow51.errAsync)({ type: "SPAWN_FAILED", cause: procOrError });
+    return (0, import_neverthrow55.errAsync)({ type: "SPAWN_FAILED", cause: procOrError });
   }
   return waitForRecordingStart(procOrError);
 }
@@ -154897,7 +155347,7 @@ function stopRecording(handle) {
   } else {
     resolve(true);
   }
-  return import_neverthrow51.ResultAsync.fromPromise(
+  return import_neverthrow55.ResultAsync.fromPromise(
     promise2,
     (cause) => ({ type: "STOP_FAILED", cause })
   );
@@ -154907,7 +155357,7 @@ var toRecordingError = (cause) => ({
   cause
 });
 function stopAndPropagate(handle, originalError) {
-  return stopRecording(handle).mapErr(toRecordingError).andThen(() => (0, import_neverthrow49.errAsync)(originalError)).orElse(() => (0, import_neverthrow49.errAsync)(originalError));
+  return stopRecording(handle).mapErr(toRecordingError).andThen(() => (0, import_neverthrow53.errAsync)(originalError)).orElse(() => (0, import_neverthrow53.errAsync)(originalError));
 }
 function compressIfRequested({
   videoPath,
@@ -154915,7 +155365,7 @@ function compressIfRequested({
   result
 }) {
   if (!shouldCompress) {
-    return (0, import_neverthrow49.okAsync)(result);
+    return (0, import_neverthrow53.okAsync)(result);
   }
   return compressRecording(videoPath).map(() => result).mapErr((cause) => ({ type: "VIDEO_COMPRESS_FAILED", cause }));
 }
@@ -154945,196 +155395,6 @@ function startAndRun(params) {
     });
   });
 }
-function emptyDirectoryError(directory) {
-  return { type: "ARTBOARD_INDEX_BUILD_FAILED", reason: "EMPTY_DIRECTORY", directory };
-}
-function zeroSuccessesError(attempted) {
-  return { type: "ARTBOARD_INDEX_BUILD_FAILED", reason: "ZERO_SUCCESSFUL_PHASHES", attempted };
-}
-function compactSuccesses(results) {
-  return results.filter((entry) => entry !== void 0);
-}
-function buildArtboardPhashIndex(input) {
-  if (input.artboardNames.length === 0) {
-    return (0, import_neverthrow53.errAsync)(emptyDirectoryError(input.directory ?? ""));
-  }
-  const limit = pLimit(input.concurrency);
-  const tasks = input.artboardNames.map(async (name) => limit(async () => input.computeOne(name)));
-  return import_neverthrow53.ResultAsync.fromSafePromise(Promise.all(tasks)).andThen((results) => {
-    const successful = compactSuccesses(results);
-    if (successful.length === 0) {
-      return (0, import_neverthrow53.errAsync)(zeroSuccessesError(input.artboardNames.length));
-    }
-    return (0, import_neverthrow53.okAsync)(successful);
-  });
-}
-var PHASH_ALGO_VERSION = "v1";
-function wrapIoError(cause) {
-  return { type: "PHASH_CACHE_IO_FAILED", cause };
-}
-function cacheFile(directory, key) {
-  const filename = `${key.algoVersion}-${String(key.maxEdgePx)}-${key.fileSha256}.json`;
-  return import_node_path19.default.join(directory, filename);
-}
-function isEnoent(cause) {
-  return cause?.code === "ENOENT";
-}
-var safeReadFile = import_neverthrow54.ResultAsync.fromThrowable(
-  import_promises22.readFile,
-  wrapIoError
-);
-var safeWriteFile4 = import_neverthrow54.ResultAsync.fromThrowable(
-  import_promises22.writeFile,
-  wrapIoError
-);
-var safeMkdir2 = import_neverthrow54.ResultAsync.fromThrowable(
-  import_promises22.mkdir,
-  wrapIoError
-);
-var safeParsePayload = (0, import_neverthrow54.fromThrowable)(
-  (raw) => JSON.parse(raw),
-  wrapIoError
-);
-var safeBigInt = (0, import_neverthrow54.fromThrowable)(BigInt, wrapIoError);
-function readPhashCache(directory, key) {
-  return safeReadFile(cacheFile(directory, key), "utf8").andThen((raw) => safeParsePayload(raw)).andThen((payload) => safeBigInt(payload.hash)).map((hash2) => hash2).orElse((error48) => {
-    if (isEnoent(error48.cause)) {
-      return (0, import_neverthrow54.okAsync)(void 0);
-    }
-    return (0, import_neverthrow54.errAsync)(error48);
-  });
-}
-function writePhashCache(directory, entry) {
-  return safeMkdir2(directory, { recursive: true }).andThen(
-    () => safeWriteFile4(cacheFile(directory, entry.key), JSON.stringify({ hash: entry.hash.toString() }))
-  );
-}
-function computeArtboardPhashFactory(deps) {
-  return async (name) => {
-    const buffer = await deps.loadArtboardBuffer(name);
-    if (buffer === void 0) {
-      return void 0;
-    }
-    const fileSha256 = await deps.sha256(buffer);
-    const key = {
-      fileSha256,
-      maxEdgePx: deps.maxEdgePx,
-      algoVersion: PHASH_ALGO_VERSION
-    };
-    const cached2 = await deps.readFromCache(deps.cacheDirectory, key);
-    if (cached2 !== void 0) {
-      return { name, hash: cached2 };
-    }
-    const preprocessed = await deps.preprocess(buffer, deps.maxEdgePx);
-    const hash2 = await deps.computePhash(preprocessed);
-    await deps.writeToCache(deps.cacheDirectory, { key, hash: hash2 });
-    return { name, hash: hash2 };
-  };
-}
-var PNG_COMPRESSION_LEVEL = 9;
-async function runSharp(input) {
-  return (0, import_sharp2.default)(input.buffer).resize({
-    width: input.maxEdgePx,
-    height: input.maxEdgePx,
-    fit: "inside",
-    withoutEnlargement: true
-  }).png({ compressionLevel: PNG_COMPRESSION_LEVEL }).toBuffer();
-}
-var safeRunSharp = import_neverthrow55.ResultAsync.fromThrowable(
-  runSharp,
-  (cause) => ({ type: "IMAGE_PREPROCESS_FAILED", cause })
-);
-function preprocessImage(input) {
-  return safeRunSharp(input);
-}
-var INDEX_BUILD_CONCURRENCY = 4;
-var HEX_ENCODING = "hex";
-function returnUndefined() {
-  return void 0;
-}
-function returnEmptyArray() {
-  return [];
-}
-async function sha256(buffer) {
-  return await Promise.resolve((0, import_node_crypto3.createHash)("sha256").update(buffer).digest(HEX_ENCODING));
-}
-async function preprocessForPhash(buffer, maxEdgePx) {
-  const result = await preprocessImage({ buffer, maxEdgePx });
-  return result.match(
-    (preprocessed) => preprocessed,
-    () => buffer
-  );
-}
-async function readPhashFromDisk(cacheDirectory, key) {
-  const result = await readPhashCache(cacheDirectory, key);
-  return result.match((hash2) => hash2, returnUndefined);
-}
-async function writePhashToDisk(cacheDirectory, entry) {
-  const result = await writePhashCache(cacheDirectory, entry);
-  result.match(returnUndefined, returnUndefined);
-}
-async function loadArtboardBuffer(designStore, name) {
-  const result = await designStore.getArtboard(name);
-  return result.match((artboard) => artboard?.buffer, returnUndefined);
-}
-async function listArtboardNames(designStore) {
-  const result = await designStore.listArtboards();
-  return result.match(
-    (names) => names,
-    () => []
-  );
-}
-function makeComputeOne(arguments_) {
-  return computeArtboardPhashFactory({
-    readFromCache: readPhashFromDisk,
-    writeToCache: writePhashToDisk,
-    loadArtboardBuffer: async (name) => loadArtboardBuffer(arguments_.designStore, name),
-    preprocess: preprocessForPhash,
-    computePhash: computeArtboardPhash,
-    sha256,
-    maxEdgePx: arguments_.maxEdgePx,
-    cacheDirectory: arguments_.runCacheDirectory
-  });
-}
-async function computeArtboardPhash(buffer) {
-  const hashString = await (0, import_sharp_phash.default)(buffer);
-  return BigInt(`0b${hashString}`);
-}
-async function buildArtboardIndex(arguments_) {
-  const names = await listArtboardNames(arguments_.designStore);
-  const computeOne = makeComputeOne(arguments_);
-  const result = await buildArtboardPhashIndex({
-    artboardNames: names,
-    concurrency: INDEX_BUILD_CONCURRENCY,
-    computeOne,
-    directory: arguments_.runCacheDirectory
-  });
-  return result.match((artboards) => artboards, returnEmptyArray);
-}
-var MATCH_TOLERANCE_VALUES = ["strict", "balanced", "loose"];
-var STRICT_HAMMING_THRESHOLD = 6;
-var BALANCED_HAMMING_THRESHOLD = 12;
-var LOOSE_HAMMING_THRESHOLD = 20;
-var HAMMING_THRESHOLD_BY_TOLERANCE = {
-  strict: STRICT_HAMMING_THRESHOLD,
-  balanced: BALANCED_HAMMING_THRESHOLD,
-  loose: LOOSE_HAMMING_THRESHOLD
-};
-function hammingDistance(left, right) {
-  const xor2 = left ^ right;
-  return (xor2.toString(2).match(/1/g) ?? []).length;
-}
-function selectTopK(input) {
-  const scored = input.candidates.map(
-    (candidate) => ({
-      name: candidate.name,
-      distance: hammingDistance(input.target, candidate.hash)
-    })
-  );
-  const within = scored.filter((entry) => entry.distance <= input.threshold);
-  const sorted = within.toSorted((left, right) => left.distance - right.distance);
-  return sorted.slice(0, input.topK);
-}
 function parseMeta(raw) {
   const parsed = jsYaml.load(raw);
   if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
@@ -155150,10 +155410,10 @@ async function readAndParseSidecar(sidecarPath) {
   return parseMeta(raw);
 }
 function readSidecarFile(sidecarPath) {
-  return (0, import_neverthrow56.fromAsyncThrowable)(
+  return (0, import_neverthrow57.fromAsyncThrowable)(
     readAndParseSidecar,
     () => ({})
-  )(sidecarPath).orElse(() => (0, import_neverthrow56.okAsync)({}));
+  )(sidecarPath).orElse(() => (0, import_neverthrow57.okAsync)({}));
 }
 function isEnoent2(error48) {
   return error48?.code === "ENOENT";
@@ -155162,13 +155422,13 @@ function wrapFsError(cause) {
   return { type: "FS_ERROR", cause };
 }
 function toFsError(fsError) {
-  return (0, import_neverthrow56.errAsync)(fsError);
+  return (0, import_neverthrow57.errAsync)(fsError);
 }
 function missingBuffer() {
-  return (0, import_neverthrow56.okAsync)(void 0);
+  return (0, import_neverthrow57.okAsync)(void 0);
 }
 function missingArtboard() {
-  return (0, import_neverthrow56.okAsync)(void 0);
+  return (0, import_neverthrow57.okAsync)(void 0);
 }
 var FsDesignStore = class {
   designsDirectory;
@@ -155176,12 +155436,12 @@ var FsDesignStore = class {
     this.designsDirectory = designsDirectory;
   }
   listArtboards() {
-    return (0, import_neverthrow56.fromAsyncThrowable)(
+    return (0, import_neverthrow57.fromAsyncThrowable)(
       import_promises23.readdir,
       wrapFsError
     )(this.designsDirectory).orElse((fsError) => {
       if (fsError.type === "FS_ERROR" && isEnoent2(fsError.cause)) {
-        return (0, import_neverthrow56.okAsync)([]);
+        return (0, import_neverthrow57.okAsync)([]);
       }
       return toFsError(fsError);
     }).map(
@@ -155191,7 +155451,7 @@ var FsDesignStore = class {
   getArtboard(filename) {
     const pngPath = import_node_path20.default.join(this.designsDirectory, `${filename}.png`);
     const sidecarPath = import_node_path20.default.join(this.designsDirectory, `${filename}.meta.yaml`);
-    return (0, import_neverthrow56.fromAsyncThrowable)(
+    return (0, import_neverthrow57.fromAsyncThrowable)(
       import_promises23.readFile,
       wrapFsError
     )(pngPath).orElse((fsError) => {
@@ -155385,7 +155645,7 @@ function toUndefined() {
   return void 0;
 }
 async function resolvePhashTarget(screenshot, compute) {
-  const safeCompute = import_neverthrow57.ResultAsync.fromThrowable(
+  const safeCompute = import_neverthrow58.ResultAsync.fromThrowable(
     compute,
     (cause) => ({ type: "PHASH_COMPUTE_FAILED", cause })
   );
@@ -155409,7 +155669,7 @@ var SCREENSHOT_PHASH_CACHE_CAPACITY = 32;
 var TOKENS_PER_READ_ARTBOARD_FETCH = 2e3;
 var HEX_ENCODING2 = "hex";
 function bufferKey(buffer) {
-  return (0, import_node_crypto2.createHash)("sha256").update(buffer).digest(HEX_ENCODING2);
+  return (0, import_node_crypto4.createHash)("sha256").update(buffer).digest(HEX_ENCODING2);
 }
 async function computeScreenshotPhashWithCache(buffer, context) {
   const key = bufferKey(buffer);
@@ -155424,9 +155684,9 @@ async function computeScreenshotPhashWithCache(buffer, context) {
 function adaptGetArtboard(designStore, name) {
   return designStore.getArtboard(name).andThen((artboard) => {
     if (artboard === void 0) {
-      return (0, import_neverthrow52.errAsync)({ type: "ARTBOARD_NOT_FOUND" });
+      return (0, import_neverthrow56.errAsync)({ type: "ARTBOARD_NOT_FOUND" });
     }
-    return (0, import_neverthrow52.okAsync)({
+    return (0, import_neverthrow56.okAsync)({
       buffer: artboard.buffer,
       lastUpdated: artboard.lastUpdated
     });
@@ -156100,25 +156360,25 @@ function direntToSpecEntry(directory, entry) {
   return [];
 }
 function scanDirectory(directory) {
-  const safeReaddir5 = (0, import_neverthrow58.fromAsyncThrowable)(
+  const safeReaddir5 = (0, import_neverthrow59.fromAsyncThrowable)(
     async () => (0, import_promises24.readdir)(directory, { withFileTypes: true }),
     (cause) => ({ type: "DIR_READ_FAILED", dir: directory, cause })
   );
-  return safeReaddir5().orElse((error48) => isNotFound(error48.cause) ? (0, import_neverthrow58.okAsync)([]) : (0, import_neverthrow58.errAsync)(error48)).map(
+  return safeReaddir5().orElse((error48) => isNotFound(error48.cause) ? (0, import_neverthrow59.okAsync)([]) : (0, import_neverthrow59.errAsync)(error48)).map(
     (entries) => entries.flatMap((entry) => direntToSpecEntry(directory, entry))
   );
 }
 function readEntries(entries) {
-  return import_neverthrow58.ResultAsync.combine(entries.map((entry) => readEntry2(entry))).map(
+  return import_neverthrow59.ResultAsync.combine(entries.map((entry) => readEntry2(entry))).map(
     (results) => results.flat()
   );
 }
 function readEntry2(entry) {
-  const safeReadFile22 = (0, import_neverthrow58.fromAsyncThrowable)(
+  const safeReadFile22 = (0, import_neverthrow59.fromAsyncThrowable)(
     async () => (0, import_promises24.readFile)(entry.path, "utf8"),
     (cause) => ({ type: "FILE_READ_FAILED", path: entry.path, cause })
   );
-  return safeReadFile22().map((content) => [{ name: entry.name, content }]).orElse((error48) => entry.required ? (0, import_neverthrow58.errAsync)(error48) : (0, import_neverthrow58.okAsync)([]));
+  return safeReadFile22().map((content) => [{ name: entry.name, content }]).orElse((error48) => entry.required ? (0, import_neverthrow59.errAsync)(error48) : (0, import_neverthrow59.okAsync)([]));
 }
 function specNameFromPath(filePath) {
   const parts = filePath.split("/");
@@ -156161,7 +156421,7 @@ function toParsedSpec(name, raw) {
   })).mapErr((cause) => ({ type: "SPEC_PARSE_FAILED", specName: name, cause }));
 }
 function parseSpecs(resolvedSpecs) {
-  return import_neverthrow48.Result.combine(resolvedSpecs.map((spec) => toParsedSpec(spec.name, spec.content)));
+  return import_neverthrow52.Result.combine(resolvedSpecs.map((spec) => toParsedSpec(spec.name, spec.content)));
 }
 function toArtifacts(result, runPaths) {
   return {
@@ -156217,7 +156477,7 @@ function collectAndFinalize({
 }
 function resolveAndParseSpecs(safeConfig) {
   if (safeConfig.mode === "freestyle") {
-    return (0, import_neverthrow48.okAsync)([]);
+    return (0, import_neverthrow52.okAsync)([]);
   }
   return resolveSpecs(safeConfig).mapErr((cause) => ({ type: "SPEC_RESOLVE_FAILED", cause })).andThen((specs) => parseSpecs(specs));
 }
@@ -156235,7 +156495,7 @@ function runPipeline2({
 function resolveWiring(safeConfig, runPaths) {
   const visual = safeConfig.visual;
   if (visual === void 0) {
-    return import_neverthrow48.ResultAsync.fromSafePromise(
+    return import_neverthrow52.ResultAsync.fromSafePromise(
       Promise.resolve({
         mode: { kind: "disabled" },
         tools: [],
@@ -156244,11 +156504,11 @@ function resolveWiring(safeConfig, runPaths) {
     );
   }
   const mode = resolveVisualMode({ enabled: visual.enabled, designsDir: visual.designsDir });
-  return import_neverthrow48.ResultAsync.fromSafePromise(
+  return import_neverthrow52.ResultAsync.fromSafePromise(
     resolveExplorerVisualWiring({
       mode,
       visualConfig: visual,
-      runCacheDirectory: import_node_path16.default.join(runPaths.baseDir, PHASH_CACHE_SUBDIRECTORY)
+      runCacheDirectory: import_node_path17.default.join(runPaths.baseDir, PHASH_CACHE_SUBDIRECTORY)
     })
   );
 }
@@ -156269,18 +156529,18 @@ function runExplorer(config2) {
     date: date5
   });
   if (runPathsResult.isErr()) {
-    return (0, import_neverthrow48.errAsync)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
+    return (0, import_neverthrow52.errAsync)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
   }
   const runPaths = runPathsResult.value;
   if (config2.signal?.aborted) {
-    return (0, import_neverthrow48.okAsync)(
+    return (0, import_neverthrow52.okAsync)(
       toArtifacts({ findings: [], snapshots: [], tokenUsage: EMPTY_TOKEN_USAGE }, runPaths)
     );
   }
   const safeConfig = buildSafeConfig(config2, runPaths);
   safeConfig.onEvent?.({ type: "STAGE_START", agent: "explorer" });
-  return import_neverthrow48.ResultAsync.fromSafePromise(
-    (0, import_promises20.mkdir)(runPaths.screenshotsDir, { recursive: true }).catch(() => null)
+  return import_neverthrow52.ResultAsync.fromSafePromise(
+    (0, import_promises21.mkdir)(runPaths.screenshotsDir, { recursive: true }).catch(() => null)
   ).andThen(() => resolveWiring(safeConfig, runPaths)).andThen((visualWiring) => runPipeline2({ safeConfig, runPaths, start, visualWiring }));
 }
 var MAX_CANDIDATE_COUNT = 10;
@@ -156300,7 +156560,8 @@ var visualConfigSchema = external_exports.object({
   candidateCount: external_exports.number().int().positive().max(MAX_CANDIDATE_COUNT).default(DEFAULT_CANDIDATE_COUNT),
   matchTolerance: external_exports.enum(MATCH_TOLERANCE_VALUES).default("balanced"),
   preprocessMaxEdgePx: external_exports.number().int().positive().default(DEFAULT_PREPROCESS_MAX_EDGE_PX),
-  readArtboardImageTokenBudget: external_exports.number().int().positive().default(DEFAULT_READ_ARTBOARD_IMAGE_TOKEN_BUDGET)
+  readArtboardImageTokenBudget: external_exports.number().int().positive().default(DEFAULT_READ_ARTBOARD_IMAGE_TOKEN_BUDGET),
+  cacheTolerance: external_exports.enum(MATCH_TOLERANCE_VALUES).default("strict")
 }).strict();
 var DEFAULT_VISUAL = visualConfigSchema.parse({});
 var explorerConfigSchema = agentBaseConfigSchema.extend({
@@ -156315,13 +156576,13 @@ var explorerConfigSchema = agentBaseConfigSchema.extend({
 
 // ../../packages/pipeline/dist/index.js
 var import_node_fs6 = require("node:fs");
-var import_neverthrow61 = __toESM(require_index_cjs(), 1);
 var import_neverthrow62 = __toESM(require_index_cjs(), 1);
 var import_neverthrow63 = __toESM(require_index_cjs(), 1);
-var import_node_fs7 = require("node:fs");
 var import_neverthrow64 = __toESM(require_index_cjs(), 1);
-var import_node_fs8 = require("node:fs");
+var import_node_fs7 = require("node:fs");
 var import_neverthrow65 = __toESM(require_index_cjs(), 1);
+var import_node_fs8 = require("node:fs");
+var import_neverthrow66 = __toESM(require_index_cjs(), 1);
 function createDefaultMcpServers(udid) {
   return {
     "mobile-ios": createMobileIosServer(udid)
@@ -156346,7 +156607,7 @@ function analyserFallback({
     attempts: ANALYSER_RETRY_ATTEMPTS,
     cause
   });
-  return (0, import_neverthrow60.okAsync)(artifacts.findings);
+  return (0, import_neverthrow61.okAsync)(artifacts.findings);
 }
 function runAnalyserWithFallback(params) {
   const { artifacts, config: config2, onEvent } = params;
@@ -156358,7 +156619,7 @@ function resolveVisualFindings({
   onEvent
 }) {
   if (config2.analyser === void 0 || config2.signal?.aborted) {
-    return (0, import_neverthrow60.okAsync)(artifacts.findings);
+    return (0, import_neverthrow61.okAsync)(artifacts.findings);
   }
   return runAnalyserWithFallback({ artifacts, config: config2, onEvent });
 }
@@ -156368,7 +156629,7 @@ function unmergedFallback(allFindings, onEvent) {
     agent: CONSOLIDATOR_AGENT,
     message: "Consolidation failed, returning unmerged findings"
   });
-  return (0, import_neverthrow60.okAsync)({ findings: allFindings, dismissed: [] });
+  return (0, import_neverthrow61.okAsync)({ findings: allFindings, dismissed: [] });
 }
 function mergeWithFallback(options) {
   const { artifacts, visualFindings, runId, dismissals, consolidatorConfig, onEvent } = options;
@@ -156387,7 +156648,7 @@ function consolidate(options) {
   const { artifacts, runId, dismissals, config: config2, consolidatorConfig, onEvent } = options;
   return resolveVisualFindings({ artifacts, config: config2, onEvent }).andThen((visualFindings) => {
     if (config2.signal?.aborted) {
-      return (0, import_neverthrow60.okAsync)({ findings: artifacts.findings, dismissed: [] });
+      return (0, import_neverthrow61.okAsync)({ findings: artifacts.findings, dismissed: [] });
     }
     return mergeWithFallback({
       artifacts,
@@ -156434,7 +156695,7 @@ function filterByConfidence(findings, options) {
     dropped: findings.filter((finding) => !passes(finding, options)).map((finding) => ({ finding, reason: "low-confidence" }))
   };
 }
-var writeOutputFile = (0, import_neverthrow61.fromThrowable)(
+var writeOutputFile = (0, import_neverthrow62.fromThrowable)(
   (params) => {
     const { findingsPath, outputDirectory, json: json3 } = params;
     (0, import_node_fs6.mkdirSync)(outputDirectory, { recursive: true });
@@ -156483,8 +156744,8 @@ function buildExplorerConfig({
 function getDismissalsPathOverride() {
   return process.env.QA_DISMISSALS_PATH;
 }
-var safeReadFile2 = (0, import_neverthrow64.fromThrowable)((filePath) => (0, import_node_fs7.readFileSync)(filePath, "utf8"));
-var safeParseJson2 = (0, import_neverthrow64.fromThrowable)(JSON.parse);
+var safeReadFile2 = (0, import_neverthrow65.fromThrowable)((filePath) => (0, import_node_fs7.readFileSync)(filePath, "utf8"));
+var safeParseJson2 = (0, import_neverthrow65.fromThrowable)(JSON.parse);
 function isEnoent3(error48) {
   if (!(error48 instanceof Error)) {
     return false;
@@ -156496,19 +156757,19 @@ function loadDismissals(filePath) {
   const readResult = safeReadFile2(filePath);
   if (readResult.isErr()) {
     if (isEnoent3(readResult.error)) {
-      return (0, import_neverthrow64.ok)([]);
+      return (0, import_neverthrow65.ok)([]);
     }
-    return (0, import_neverthrow64.err)({ type: "DISMISSALS_LOAD_FAILED", cause: readResult.error });
+    return (0, import_neverthrow65.err)({ type: "DISMISSALS_LOAD_FAILED", cause: readResult.error });
   }
   return safeParseJson2(readResult.value).mapErr((cause) => ({ type: "DISMISSALS_LOAD_FAILED", cause })).andThen((data) => {
     const store = data;
     if (!Array.isArray(store.dismissed)) {
-      return (0, import_neverthrow64.err)({
+      return (0, import_neverthrow65.err)({
         type: "DISMISSALS_LOAD_FAILED",
         cause: "invalid shape: dismissed is not an array"
       });
     }
-    return (0, import_neverthrow64.ok)(store.dismissed);
+    return (0, import_neverthrow65.ok)(store.dismissed);
   });
 }
 var ISO_DATE_LENGTH2 = 10;
@@ -156518,7 +156779,7 @@ function computeNextRunId(entries) {
   const max = parsed.length === 0 ? 0 : Math.max(...parsed);
   return String(max + 1).padStart(RUN_ID_PAD_LENGTH, "0");
 }
-var safeReaddirSync = (0, import_neverthrow65.fromThrowable)((directory) => (0, import_node_fs8.readdirSync)(directory));
+var safeReaddirSync = (0, import_neverthrow66.fromThrowable)((directory) => (0, import_node_fs8.readdirSync)(directory));
 function nextRunId(outputDirectory, date5) {
   const entries = safeReaddirSync(`${outputDirectory}/${date5}`).unwrapOr([]);
   return computeNextRunId(entries);
@@ -156530,15 +156791,15 @@ function resolvePipelineConfig({
   const runId = config2.runId ?? nextRunId(config2.outputDir, date5);
   const runPathsResult = resolveRunPaths({ outputDirectory: config2.outputDir, runId, date: date5 });
   if (runPathsResult.isErr()) {
-    return (0, import_neverthrow63.err)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
+    return (0, import_neverthrow64.err)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
   }
   const dismissalsResult = loadDismissals(
     dismissalsPath(config2.outputDir, getDismissalsPathOverride())
   );
   if (dismissalsResult.isErr()) {
-    return (0, import_neverthrow63.err)(dismissalsResult.error);
+    return (0, import_neverthrow64.err)(dismissalsResult.error);
   }
-  return (0, import_neverthrow63.ok)({ runId, date: date5, runPaths: runPathsResult.value, dismissals: dismissalsResult.value });
+  return (0, import_neverthrow64.ok)({ runId, date: date5, runPaths: runPathsResult.value, dismissals: dismissalsResult.value });
 }
 function assemblePipelineSetup({
   config: config2,
@@ -156568,10 +156829,10 @@ function buildPipelineSetup({
 }) {
   const resolvedResult = resolvePipelineConfig({ config: config2, date: date5 });
   if (resolvedResult.isErr()) {
-    return (0, import_neverthrow62.err)(resolvedResult.error);
+    return (0, import_neverthrow63.err)(resolvedResult.error);
   }
   const { runId, runPaths, dismissals } = resolvedResult.value;
-  return (0, import_neverthrow62.ok)(assemblePipelineSetup({ config: config2, date: date5, runId, runPaths, dismissals }));
+  return (0, import_neverthrow63.ok)(assemblePipelineSetup({ config: config2, date: date5, runId, runPaths, dismissals }));
 }
 function buildExplorerOptions(setup, config2) {
   return {
@@ -156598,7 +156859,7 @@ function runAgentPhases(setup, config2) {
 }
 function installAppIfRequested(udid, appPath) {
   if (appPath === void 0) {
-    return (0, import_neverthrow59.okAsync)(udid);
+    return (0, import_neverthrow60.okAsync)(udid);
   }
   return installApp(udid, appPath).mapErr(
     (cause) => ({ type: "SIMULATOR_SETUP_FAILED", cause })
@@ -156606,11 +156867,11 @@ function installAppIfRequested(udid, appPath) {
 }
 function provisionSimulator(udid, appPath) {
   if (udid === "booted") {
-    return (0, import_neverthrow59.okAsync)(udid);
+    return (0, import_neverthrow60.okAsync)(udid);
   }
   const parsed = parseUdid(udid);
   if (parsed.isErr()) {
-    return (0, import_neverthrow59.errAsync)({ type: "SIMULATOR_SETUP_FAILED", cause: parsed.error });
+    return (0, import_neverthrow60.errAsync)({ type: "SIMULATOR_SETUP_FAILED", cause: parsed.error });
   }
   return bootAndAwait(parsed.value).mapErr((cause) => ({ type: "SIMULATOR_SETUP_FAILED", cause })).andThen((bootedUdid) => installAppIfRequested(bootedUdid, appPath)).map(String);
 }
@@ -156631,7 +156892,7 @@ function runPipeline3(config2) {
   const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, ISO_DATE_LENGTH2);
   const setupResult = buildPipelineSetup({ config: config2, date: date5 });
   if (setupResult.isErr()) {
-    return (0, import_neverthrow59.errAsync)(setupResult.error);
+    return (0, import_neverthrow60.errAsync)(setupResult.error);
   }
   return executePipeline(setupResult.value, config2);
 }
@@ -156642,7 +156903,7 @@ function buildArtifacts(videoPath) {
 }
 
 // src/shell/debug-agent-events.ts
-var import_neverthrow66 = __toESM(require_index_cjs(), 1);
+var import_neverthrow67 = __toESM(require_index_cjs(), 1);
 
 // src/constants.ts
 var MOBILE_IOS_TOOLS = [
@@ -156725,7 +156986,7 @@ function tryStringify(value) {
   const result = JSON.stringify(value);
   return result ?? UNSERIALIZABLE2;
 }
-var safeStringify2 = (0, import_neverthrow66.fromThrowable)(tryStringify, () => ({
+var safeStringify2 = (0, import_neverthrow67.fromThrowable)(tryStringify, () => ({
   type: "STRINGIFY_FAILED"
 }));
 function toolKey(scope, event) {
@@ -157040,7 +157301,7 @@ var catalogSchema = external_exports.discriminatedUnion("type", [localCatalogSch
 var import_node_fs9 = __toESM(require("node:fs"), 1);
 var import_node_path22 = __toESM(require("node:path"), 1);
 var import_jiti = require("jiti");
-var import_neverthrow67 = __toESM(require_index_cjs(), 1);
+var import_neverthrow68 = __toESM(require_index_cjs(), 1);
 
 // ../../packages/catalog/dist/core/validate-catalog.js
 var ZERO_ARITY = 0;
@@ -157068,8 +157329,8 @@ function isCatalog(value) {
 var WORLD_WRITABLE_MASK = 18;
 var ROOT_PATH_MIN_LENGTH = 2;
 var swallowError = () => false;
-var safeRealpath = (0, import_neverthrow67.fromThrowable)((target) => import_node_fs9.default.realpathSync(target), swallowError);
-var safeStat = (0, import_neverthrow67.fromThrowable)((target) => import_node_fs9.default.statSync(target), swallowError);
+var safeRealpath = (0, import_neverthrow68.fromThrowable)((target) => import_node_fs9.default.realpathSync(target), swallowError);
+var safeStat = (0, import_neverthrow68.fromThrowable)((target) => import_node_fs9.default.statSync(target), swallowError);
 function stripTrailingSeparator(value) {
   if (value.length > ROOT_PATH_MIN_LENGTH && value.endsWith(import_node_path22.default.sep)) {
     return value.slice(0, -1);
@@ -157156,13 +157417,13 @@ function resolveRealPaths(input) {
   const resolved = import_node_path22.default.resolve(input.configDir, input.modulePath);
   const realResolvedResult = safeRealpath(resolved);
   if (realResolvedResult.isErr()) {
-    return (0, import_neverthrow67.errAsync)({ type: "CATALOG_MODULE_NOT_FOUND", path: resolved });
+    return (0, import_neverthrow68.errAsync)({ type: "CATALOG_MODULE_NOT_FOUND", path: resolved });
   }
   const realRepoRootResult = safeRealpath(input.repoRoot);
   if (realRepoRootResult.isErr()) {
-    return (0, import_neverthrow67.errAsync)(buildLoadFailedError(resolved, "repo root realpath failed"));
+    return (0, import_neverthrow68.errAsync)(buildLoadFailedError(resolved, "repo root realpath failed"));
   }
-  return (0, import_neverthrow67.okAsync)({
+  return (0, import_neverthrow68.okAsync)({
     realResolved: realResolvedResult.value,
     realRepoRoot: realRepoRootResult.value
   });
@@ -157204,7 +157465,7 @@ function runPreImportChecks(realResolved, realRepoRoot) {
 }
 function importModuleViaJiti(realResolved) {
   const jiti = (0, import_jiti.createJiti)(__importMetaUrl, { fsCache: false, moduleCache: false });
-  const wrapped = import_neverthrow67.ResultAsync.fromThrowable(async (target) => jiti.import(target, { default: true }), (cause) => ({
+  const wrapped = import_neverthrow68.ResultAsync.fromThrowable(async (target) => jiti.import(target, { default: true }), (cause) => ({
     type: "CATALOG_MODULE_LOAD_FAILED",
     path: realResolved,
     cause: redactCause(cause)
@@ -157214,19 +157475,19 @@ function importModuleViaJiti(realResolved) {
 function verifyPostStatAndShape(input) {
   const postResult = safeStat(input.realResolved);
   if (postResult.isErr()) {
-    return (0, import_neverthrow67.errAsync)(buildLoadFailedError(input.realResolved, "post-stat failed"));
+    return (0, import_neverthrow68.errAsync)(buildLoadFailedError(input.realResolved, "post-stat failed"));
   }
   if (!statsEqual(input.pre, statToPreStat(postResult.value))) {
-    return (0, import_neverthrow67.errAsync)(buildLoadFailedError(input.realResolved, "inode-changed"));
+    return (0, import_neverthrow68.errAsync)(buildLoadFailedError(input.realResolved, "inode-changed"));
   }
   if (!isCatalog(input.imported)) {
-    return (0, import_neverthrow67.errAsync)({
+    return (0, import_neverthrow68.errAsync)({
       type: "CATALOG_MODULE_INVALID_SHAPE",
       path: input.realResolved,
       reason: "default export does not satisfy Catalog interface"
     });
   }
-  return (0, import_neverthrow67.okAsync)(input.imported);
+  return (0, import_neverthrow68.okAsync)(input.imported);
 }
 function loadAfterChecks(realResolved, pre) {
   return importModuleViaJiti(realResolved).andThen((imported) => verifyPostStatAndShape({ realResolved, pre, imported }));
@@ -157235,23 +157496,23 @@ function loadCatalog(input) {
   return resolveRealPaths(input).andThen(({ realResolved, realRepoRoot }) => {
     const checks = runPreImportChecks(realResolved, realRepoRoot);
     if ("error" in checks) {
-      return (0, import_neverthrow67.errAsync)(checks.error);
+      return (0, import_neverthrow68.errAsync)(checks.error);
     }
     return loadAfterChecks(realResolved, checks.pre);
   });
 }
 
 // ../../packages/catalog/dist/shell/resolve-catalog.js
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 var import_promises30 = require("node:fs/promises");
 var import_node_path27 = __toESM(require("node:path"), 1);
-var import_neverthrow81 = __toESM(require_index_cjs(), 1);
+var import_neverthrow82 = __toESM(require_index_cjs(), 1);
 
 // ../../packages/catalog/dist/shell/cleanup-cache.js
 var import_node_fs10 = require("node:fs");
 var import_promises26 = require("node:fs/promises");
 var import_node_path23 = __toESM(require("node:path"), 1);
-var import_neverthrow68 = __toESM(require_index_cjs(), 1);
+var import_neverthrow69 = __toESM(require_index_cjs(), 1);
 var MS_PER_SECOND6 = 1e3;
 var SECONDS_PER_MINUTE4 = 60;
 var MINUTES_PER_HOUR = 60;
@@ -157262,7 +157523,7 @@ var LOCK_FILE_NAME = ".lock";
 var LINUX_BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id";
 var PROBE_SIGNAL = 0;
 var swallowError2 = () => void 0;
-var safeReadBootId = (0, import_neverthrow68.fromThrowable)(() => (0, import_node_fs10.readFileSync)(LINUX_BOOT_ID_PATH, "utf8").trim(), swallowError2);
+var safeReadBootId = (0, import_neverthrow69.fromThrowable)(() => (0, import_node_fs10.readFileSync)(LINUX_BOOT_ID_PATH, "utf8").trim(), swallowError2);
 function readBootId() {
   if (process.platform !== "linux") {
     return void 0;
@@ -157270,11 +157531,11 @@ function readBootId() {
   const result = safeReadBootId();
   return result.isOk() ? result.value : void 0;
 }
-var safePidProbe = (0, import_neverthrow68.fromThrowable)((pid) => process.kill(pid, PROBE_SIGNAL), swallowError2);
+var safePidProbe = (0, import_neverthrow69.fromThrowable)((pid) => process.kill(pid, PROBE_SIGNAL), swallowError2);
 function isPidAlive2(pid) {
   return safePidProbe(pid).isOk();
 }
-var safeJsonParse3 = (0, import_neverthrow68.fromThrowable)(JSON.parse, swallowError2);
+var safeJsonParse3 = (0, import_neverthrow69.fromThrowable)(JSON.parse, swallowError2);
 function isValidLock(value) {
   return value !== null && typeof value === "object" && typeof value.pid === "number" && typeof value.startedAtMs === "number";
 }
@@ -157287,7 +157548,7 @@ function parseLock(raw) {
   return isValidLock(value) ? value : void 0;
 }
 function safeReadLockText(lockPath) {
-  const wrapped = import_neverthrow68.ResultAsync.fromThrowable(async (target) => (0, import_promises26.readFile)(target, "utf8"), swallowError2);
+  const wrapped = import_neverthrow69.ResultAsync.fromThrowable(async (target) => (0, import_promises26.readFile)(target, "utf8"), swallowError2);
   return wrapped(lockPath);
 }
 async function readLock(runDirectory) {
@@ -157297,9 +157558,9 @@ async function readLock(runDirectory) {
   }
   return parseLock(raw.value);
 }
-var safeStat2 = import_neverthrow68.ResultAsync.fromThrowable(async (target) => (0, import_promises26.stat)(target), swallowError2);
+var safeStat2 = import_neverthrow69.ResultAsync.fromThrowable(async (target) => (0, import_promises26.stat)(target), swallowError2);
 function safeWriteLock(filePath, content) {
-  const wrapped = import_neverthrow68.ResultAsync.fromThrowable(async (target, body) => {
+  const wrapped = import_neverthrow69.ResultAsync.fromThrowable(async (target, body) => {
     await (0, import_promises26.writeFile)(target, body);
     return void 0;
   }, (cause) => ({
@@ -157310,7 +157571,7 @@ function safeWriteLock(filePath, content) {
   return wrapped(filePath, content);
 }
 function safeReadDirectory(directoryPath) {
-  const wrapped = import_neverthrow68.ResultAsync.fromThrowable(async (target) => (0, import_promises26.readdir)(target, { withFileTypes: true, encoding: "utf8" }), (cause) => ({
+  const wrapped = import_neverthrow69.ResultAsync.fromThrowable(async (target) => (0, import_promises26.readdir)(target, { withFileTypes: true, encoding: "utf8" }), (cause) => ({
     type: "CATALOG_CACHE_CLEANUP_FAILED",
     path: directoryPath,
     cause: redactCause(cause)
@@ -157318,7 +157579,7 @@ function safeReadDirectory(directoryPath) {
   return wrapped(directoryPath);
 }
 function safeRm(target) {
-  const wrapped = import_neverthrow68.ResultAsync.fromThrowable(async (targetPath) => {
+  const wrapped = import_neverthrow69.ResultAsync.fromThrowable(async (targetPath) => {
     await (0, import_promises26.rm)(targetPath, { recursive: true, force: true });
     return void 0;
   }, (cause) => ({
@@ -157382,7 +157643,7 @@ async function reapAllEntries(context, entryNames) {
   return results.filter((entry) => entry !== void 0);
 }
 function reapDirectories(input) {
-  const wrapped = import_neverthrow68.ResultAsync.fromThrowable(async (request2) => reapAllEntries(request2.context, request2.directoryNames), (cause) => ({
+  const wrapped = import_neverthrow69.ResultAsync.fromThrowable(async (request2) => reapAllEntries(request2.context, request2.directoryNames), (cause) => ({
     type: "CATALOG_CACHE_CLEANUP_FAILED",
     path: input.context.cacheRoot,
     cause: redactCause(cause)
@@ -157397,7 +157658,7 @@ function writeLockFile(runDirectory) {
 function reapStaleCacheDirectories(cacheRoot, options = {}) {
   const gracePeriodMs = options.gracePeriodMs ?? DEFAULT_GRACE_PERIOD_MS2;
   if (!(0, import_node_fs10.existsSync)(cacheRoot)) {
-    return (0, import_neverthrow68.okAsync)([]);
+    return (0, import_neverthrow69.okAsync)([]);
   }
   const currentBootId = readBootId();
   const reapStartMs = Date.now();
@@ -157409,11 +157670,11 @@ function reapStaleCacheDirectories(cacheRoot, options = {}) {
 }
 
 // ../../packages/catalog/dist/shell/github/github-catalog.js
-var import_neverthrow77 = __toESM(require_index_cjs(), 1);
+var import_neverthrow78 = __toESM(require_index_cjs(), 1);
 
 // ../../packages/catalog/dist/shell/github/build-spec.js
 var import_node_path24 = __toESM(require("node:path"), 1);
-var import_neverthrow69 = __toESM(require_index_cjs(), 1);
+var import_neverthrow70 = __toESM(require_index_cjs(), 1);
 var SPEC_FILE_SUFFIX = ".test.md";
 function specParseErrorMessage(error48) {
   switch (error48.type) {
@@ -157437,7 +157698,7 @@ function buildSpec2(filePath, raw) {
     type: "CATALOG_FETCH_FAILED",
     phase: "specs",
     cause: redactCause(specParseErrorMessage(parseError))
-  })).andThen((parsed) => parsed.spec.id === expectedId ? (0, import_neverthrow69.ok)({ id: parsed.spec.id, spec: parsed.spec }) : (0, import_neverthrow69.err)({
+  })).andThen((parsed) => parsed.spec.id === expectedId ? (0, import_neverthrow70.ok)({ id: parsed.spec.id, spec: parsed.spec }) : (0, import_neverthrow70.err)({
     type: "CATALOG_INVALID_ID",
     kind: "spec",
     id: parsed.spec.id
@@ -157446,9 +157707,9 @@ function buildSpec2(filePath, raw) {
 
 // ../../packages/catalog/dist/shell/github/build-suite.js
 var import_node_path25 = __toESM(require("node:path"), 1);
-var import_neverthrow70 = __toESM(require_index_cjs(), 1);
+var import_neverthrow71 = __toESM(require_index_cjs(), 1);
 var SUITE_FILE_SUFFIX = ".suite.json";
-var safeJsonParse4 = (0, import_neverthrow70.fromThrowable)(JSON.parse, (cause) => ({
+var safeJsonParse4 = (0, import_neverthrow71.fromThrowable)(JSON.parse, (cause) => ({
   type: "CATALOG_FETCH_FAILED",
   phase: "suites",
   cause: redactCause(cause)
@@ -157461,43 +157722,43 @@ function isFreestyleArray(value) {
 }
 function validateSpecs(value) {
   if (value === void 0) {
-    return (0, import_neverthrow70.ok)([]);
+    return (0, import_neverthrow71.ok)([]);
   }
   if (!isStringArray(value)) {
-    return (0, import_neverthrow70.err)({
+    return (0, import_neverthrow71.err)({
       type: "CATALOG_FETCH_FAILED",
       phase: "suites",
       cause: redactCause("suite.specs must be an array of strings")
     });
   }
-  return (0, import_neverthrow70.ok)(value);
+  return (0, import_neverthrow71.ok)(value);
 }
 function validateFreestyle(value) {
   if (value === void 0) {
-    return (0, import_neverthrow70.ok)([]);
+    return (0, import_neverthrow71.ok)([]);
   }
   if (!isFreestyleArray(value)) {
-    return (0, import_neverthrow70.err)({
+    return (0, import_neverthrow71.err)({
       type: "CATALOG_FETCH_FAILED",
       phase: "suites",
       cause: redactCause("suite.freestyle must be an array")
     });
   }
-  return (0, import_neverthrow70.ok)(value);
+  return (0, import_neverthrow71.ok)(value);
 }
 function validateHooks(value) {
   if (value === void 0) {
     const empty = void 0;
-    return (0, import_neverthrow70.ok)(empty);
+    return (0, import_neverthrow71.ok)(empty);
   }
   if (typeof value !== "object" || value === null) {
-    return (0, import_neverthrow70.err)({
+    return (0, import_neverthrow71.err)({
       type: "CATALOG_FETCH_FAILED",
       phase: "suites",
       cause: redactCause("suite.hooks must be an object")
     });
   }
-  return (0, import_neverthrow70.ok)(value);
+  return (0, import_neverthrow71.ok)(value);
 }
 function assembleSuiteConfig(parts) {
   if (parts.hooks === void 0) {
@@ -157510,10 +157771,10 @@ function validateSuiteParts(candidate) {
 }
 function buildSuiteConfig(parsed) {
   if (parsed === null || parsed === void 0) {
-    return (0, import_neverthrow70.ok)({ specs: [], freestyle: [] });
+    return (0, import_neverthrow71.ok)({ specs: [], freestyle: [] });
   }
   if (typeof parsed !== "object") {
-    return (0, import_neverthrow70.err)({
+    return (0, import_neverthrow71.err)({
       type: "CATALOG_FETCH_FAILED",
       phase: "suites",
       cause: redactCause("suite file must contain an object")
@@ -157529,7 +157790,7 @@ function buildSuite(filePath, raw) {
 // ../../packages/catalog/dist/shell/github/exec-gh.js
 var import_node_child_process8 = require("node:child_process");
 var import_promises27 = require("node:timers/promises");
-var import_neverthrow71 = __toESM(require_index_cjs(), 1);
+var import_neverthrow72 = __toESM(require_index_cjs(), 1);
 var KILOBYTE = 1024;
 var MEGABYTE = KILOBYTE * KILOBYTE;
 var MAX_BUFFER_MEGABYTES = 16;
@@ -157619,9 +157880,9 @@ function buildFetchError(cause, phase) {
 }
 function execGh(input) {
   if (input.token.length === 0) {
-    return (0, import_neverthrow71.errAsync)(buildFetchError({ message: "spec token required for github catalog (XQA_SPEC_TOKEN/LOCAL_XQA_SPEC_TOKEN)" }, input.phase));
+    return (0, import_neverthrow72.errAsync)(buildFetchError({ message: "spec token required for github catalog (XQA_SPEC_TOKEN/LOCAL_XQA_SPEC_TOKEN)" }, input.phase));
   }
-  return import_neverthrow71.ResultAsync.fromSafePromise(runExecGhWithRetry(input)).andThen((outcome) => outcome.ok ? (0, import_neverthrow71.okAsync)(outcome.stdout) : (0, import_neverthrow71.errAsync)(buildFetchError(outcome.cause, input.phase)));
+  return import_neverthrow72.ResultAsync.fromSafePromise(runExecGhWithRetry(input)).andThen((outcome) => outcome.ok ? (0, import_neverthrow72.okAsync)(outcome.stdout) : (0, import_neverthrow72.errAsync)(buildFetchError(outcome.cause, input.phase)));
 }
 function loadSpecTokenFromEnv() {
   return process.env.XQA_SPEC_TOKEN ?? process.env.LOCAL_XQA_SPEC_TOKEN ?? "";
@@ -157631,15 +157892,15 @@ function resolvePhase(phase) {
 }
 
 // ../../packages/catalog/dist/shell/github/fetch-blobs.js
-var import_neverthrow72 = __toESM(require_index_cjs(), 1);
+var import_neverthrow73 = __toESM(require_index_cjs(), 1);
 var KILOBYTE2 = 1024;
 var MEGABYTE2 = KILOBYTE2 * KILOBYTE2;
 var MAX_FILE_BYTES = MEGABYTE2;
 var FETCH_CONCURRENCY_LIMIT = 8;
-var tryParseJson = (0, import_neverthrow72.fromThrowable)(JSON.parse, (cause) => ({
+var tryParseJson = (0, import_neverthrow73.fromThrowable)(JSON.parse, (cause) => ({
   cause
 }));
-var safeBase64Decode = (0, import_neverthrow72.fromThrowable)((text) => Buffer.from(text, "base64").toString("utf8"), (cause) => ({ cause }));
+var safeBase64Decode = (0, import_neverthrow73.fromThrowable)((text) => Buffer.from(text, "base64").toString("utf8"), (cause) => ({ cause }));
 function parseJson(stdout, phase) {
   return tryParseJson(stdout).mapErr(({ cause }) => buildFetchError(cause, phase));
 }
@@ -157652,16 +157913,16 @@ function isBlobResponse(value) {
 }
 function parseBlobResponse(parsed, phase) {
   if (!isBlobResponse(parsed)) {
-    return (0, import_neverthrow72.err)(buildFetchError("blob endpoint missing content/encoding", phase));
+    return (0, import_neverthrow73.err)(buildFetchError("blob endpoint missing content/encoding", phase));
   }
-  return (0, import_neverthrow72.ok)(parsed);
+  return (0, import_neverthrow73.ok)(parsed);
 }
 function decodeBlobContent(blob, phase) {
   if (blob.truncated === true) {
-    return (0, import_neverthrow72.err)(buildFetchError("blob truncated by GitHub API", phase));
+    return (0, import_neverthrow73.err)(buildFetchError("blob truncated by GitHub API", phase));
   }
   if (blob.encoding !== "base64") {
-    return (0, import_neverthrow72.err)(buildFetchError(`unexpected encoding: ${blob.encoding}`, phase));
+    return (0, import_neverthrow73.err)(buildFetchError(`unexpected encoding: ${blob.encoding}`, phase));
   }
   return safeBase64Decode(blob.content).mapErr(({ cause }) => buildFetchError(cause, phase));
 }
@@ -157670,7 +157931,7 @@ function buildBlobPath(input) {
 }
 function fetchBlob(input) {
   if (input.entry.size > MAX_FILE_BYTES) {
-    return (0, import_neverthrow72.errAsync)(buildFetchError(`file ${input.entry.path} exceeds size cap`, input.phase));
+    return (0, import_neverthrow73.errAsync)(buildFetchError(`file ${input.entry.path} exceeds size cap`, input.phase));
   }
   const apiPath = buildBlobPath({ owner: input.owner, repo: input.repo, sha: input.entry.sha });
   return execGh({ apiPath, phase: input.phase, token: input.token, timeoutMs: input.timeoutMs }).andThen((stdout) => parseJson(stdout, input.phase)).andThen((parsed) => parseBlobResponse(parsed, input.phase)).andThen((blob) => decodeBlobContent(blob, input.phase));
@@ -157727,7 +157988,7 @@ async function runPool(factories, limit) {
   const workers = Array.from({ length: workerCount }, async () => runPoolWorker(driver.handle));
   await Promise.all(workers);
   const error48 = driver.readError();
-  return error48 === void 0 ? (0, import_neverthrow72.ok)(driver.readResults()) : (0, import_neverthrow72.err)(error48);
+  return error48 === void 0 ? (0, import_neverthrow73.ok)(driver.readResults()) : (0, import_neverthrow73.err)(error48);
 }
 function buildFactories(input) {
   return input.entries.map((entry) => () => fetchBlob({
@@ -157740,15 +158001,15 @@ function buildFactories(input) {
   }).map((content) => ({ entry, content })));
 }
 function fetchBlobs(input) {
-  return import_neverthrow72.ResultAsync.fromSafePromise(runPool(buildFactories(input), FETCH_CONCURRENCY_LIMIT)).andThen((result) => result);
+  return import_neverthrow73.ResultAsync.fromSafePromise(runPool(buildFactories(input), FETCH_CONCURRENCY_LIMIT)).andThen((result) => result);
 }
 
 // ../../packages/catalog/dist/shell/github/fetch-compat.js
-var import_neverthrow74 = __toESM(require_index_cjs(), 1);
+var import_neverthrow75 = __toESM(require_index_cjs(), 1);
 
 // ../../packages/catalog/dist/core/xqa-compat.js
-var import_neverthrow73 = __toESM(require_index_cjs(), 1);
-var safeJsonParse5 = (0, import_neverthrow73.fromThrowable)(JSON.parse, (cause) => ({ type: "XQA_COMPAT_PARSE_FAILED", cause }));
+var import_neverthrow74 = __toESM(require_index_cjs(), 1);
+var safeJsonParse5 = (0, import_neverthrow74.fromThrowable)(JSON.parse, (cause) => ({ type: "XQA_COMPAT_PARSE_FAILED", cause }));
 function isXqaCompat(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -157757,13 +158018,13 @@ function isXqaCompat(value) {
   return Array.isArray(candidate.xqaMajor) && candidate.xqaMajor.every((entry) => typeof entry === "number");
 }
 function parseXqaCompat(raw) {
-  return safeJsonParse5(raw).andThen((value) => isXqaCompat(value) ? (0, import_neverthrow73.ok)(value) : (0, import_neverthrow73.err)({ type: "XQA_COMPAT_MISSING_FIELD" }));
+  return safeJsonParse5(raw).andThen((value) => isXqaCompat(value) ? (0, import_neverthrow74.ok)(value) : (0, import_neverthrow74.err)({ type: "XQA_COMPAT_MISSING_FIELD" }));
 }
 function checkCompat(manifest, currentMajor) {
   if (manifest.xqaMajor.includes(currentMajor)) {
-    return (0, import_neverthrow73.ok)();
+    return (0, import_neverthrow74.ok)();
   }
-  return (0, import_neverthrow73.err)({
+  return (0, import_neverthrow74.err)({
     type: "XQA_COMPAT_MISMATCH",
     current: currentMajor,
     supported: manifest.xqaMajor
@@ -157772,10 +158033,10 @@ function checkCompat(manifest, currentMajor) {
 
 // ../../packages/catalog/dist/shell/github/fetch-compat.js
 var XQA_CURRENT_MAJOR = 6;
-var safeJsonParse6 = (0, import_neverthrow74.fromThrowable)(JSON.parse, (cause) => ({
+var safeJsonParse6 = (0, import_neverthrow75.fromThrowable)(JSON.parse, (cause) => ({
   cause
 }));
-var safeDecodeBase64 = (0, import_neverthrow74.fromThrowable)((text) => Buffer.from(text, "base64").toString("utf8"), (cause) => ({ cause }));
+var safeDecodeBase64 = (0, import_neverthrow75.fromThrowable)((text) => Buffer.from(text, "base64").toString("utf8"), (cause) => ({ cause }));
 function isGitHubContentsResponse(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -157789,9 +158050,9 @@ function buildApiPath(input) {
 }
 function validateContentsResponse(parsed) {
   if (!isGitHubContentsResponse(parsed)) {
-    return (0, import_neverthrow74.err)(buildFetchError("unexpected GitHub Contents API response shape", "compat"));
+    return (0, import_neverthrow75.err)(buildFetchError("unexpected GitHub Contents API response shape", "compat"));
   }
-  return (0, import_neverthrow74.ok)(parsed);
+  return (0, import_neverthrow75.ok)(parsed);
 }
 function mapCompatError(error48) {
   switch (error48.type) {
@@ -157819,8 +158080,8 @@ function fetchCompat(input) {
 }
 
 // ../../packages/catalog/dist/shell/github/fetch-tree.js
-var import_neverthrow75 = __toESM(require_index_cjs(), 1);
-var tryParseJson2 = (0, import_neverthrow75.fromThrowable)(JSON.parse, (cause) => ({
+var import_neverthrow76 = __toESM(require_index_cjs(), 1);
+var tryParseJson2 = (0, import_neverthrow76.fromThrowable)(JSON.parse, (cause) => ({
   cause
 }));
 function buildApiPath2(input) {
@@ -157844,17 +158105,17 @@ function parseJson2(stdout, phase) {
 }
 function extractAllBlobs(parsed, phase) {
   if (typeof parsed !== "object" || parsed === null) {
-    return (0, import_neverthrow75.err)(buildFetchError("tree endpoint did not return an object", phase));
+    return (0, import_neverthrow76.err)(buildFetchError("tree endpoint did not return an object", phase));
   }
   const candidate = parsed;
   if (candidate.truncated === true) {
-    return (0, import_neverthrow75.err)(buildFetchError("TREE_TRUNCATED", phase));
+    return (0, import_neverthrow76.err)(buildFetchError("TREE_TRUNCATED", phase));
   }
   if (!Array.isArray(candidate.tree)) {
-    return (0, import_neverthrow75.err)(buildFetchError("tree endpoint did not return an array", phase));
+    return (0, import_neverthrow76.err)(buildFetchError("tree endpoint did not return an array", phase));
   }
   const entries = candidate.tree.filter((entry) => isTreeBlobEntry(entry));
-  return (0, import_neverthrow75.ok)(entries.filter((entry) => !entryHasTraversal(entry.path)));
+  return (0, import_neverthrow76.ok)(entries.filter((entry) => !entryHasTraversal(entry.path)));
 }
 function fetchAllTreeBlobs(input) {
   const apiPath = buildApiPath2({ owner: input.owner, repo: input.repo, reference: input.ref });
@@ -157870,7 +158131,7 @@ function filterTreeEntries(input) {
 }
 
 // ../../packages/catalog/dist/core/github-config.js
-var import_neverthrow76 = __toESM(require_index_cjs(), 1);
+var import_neverthrow77 = __toESM(require_index_cjs(), 1);
 function toPathArray(value) {
   return typeof value === "string" ? [value] : value;
 }
@@ -157888,9 +158149,9 @@ function normalizeGithubConfig(input) {
   const paths = toPathArray(input.path);
   const dup = findDuplicate(paths);
   if (dup !== void 0) {
-    return (0, import_neverthrow76.err)({ type: "GITHUB_CATALOG_DUPLICATE_PATH", value: dup });
+    return (0, import_neverthrow77.err)({ type: "GITHUB_CATALOG_DUPLICATE_PATH", value: dup });
   }
-  return (0, import_neverthrow76.ok)({
+  return (0, import_neverthrow77.ok)({
     owner: input.owner,
     repo: input.repo,
     ref: input.ref,
@@ -157901,13 +158162,13 @@ function normalizeGithubConfig(input) {
 
 // ../../packages/catalog/dist/shell/github/github-catalog.js
 function buildItems(files, builder) {
-  return import_neverthrow77.Result.combine(files.map((file2) => builder(file2.entry.path, file2.content)));
+  return import_neverthrow78.Result.combine(files.map((file2) => builder(file2.entry.path, file2.content)));
 }
 function memoize(factory) {
   let pending;
   return () => {
     pending ??= factory().match((value) => ({ success: true, value }), (error48) => ({ success: false, error: error48 }));
-    return import_neverthrow77.ResultAsync.fromSafePromise(pending).andThen((entry) => entry.success ? (0, import_neverthrow77.okAsync)(entry.value) : (0, import_neverthrow77.errAsync)(entry.error));
+    return import_neverthrow78.ResultAsync.fromSafePromise(pending).andThen((entry) => entry.success ? (0, import_neverthrow78.okAsync)(entry.value) : (0, import_neverthrow78.errAsync)(entry.error));
   };
 }
 function makeTreeLoader(context) {
@@ -157976,7 +158237,7 @@ function buildCatalog(pipeline2) {
 function createGithubCatalog(input) {
   const normalized = normalizeGithubConfig(input);
   if (normalized.isErr()) {
-    return (0, import_neverthrow77.errAsync)({
+    return (0, import_neverthrow78.errAsync)({
       type: "CATALOG_FETCH_FAILED",
       phase: "specs",
       cause: redactCause(normalized.error.type)
@@ -157984,18 +158245,18 @@ function createGithubCatalog(input) {
   }
   const token = loadSpecTokenFromEnv();
   if (token.length === 0) {
-    return (0, import_neverthrow77.errAsync)({
+    return (0, import_neverthrow78.errAsync)({
       type: "CATALOG_FETCH_FAILED",
       phase: "specs",
       cause: redactCause("spec token required for github catalog (XQA_SPEC_TOKEN/LOCAL_XQA_SPEC_TOKEN)")
     });
   }
-  return (0, import_neverthrow77.okAsync)(buildCatalog(buildPipeline(buildContext(normalized.value, token))));
+  return (0, import_neverthrow78.okAsync)(buildCatalog(buildPipeline(buildContext(normalized.value, token))));
 }
 
 // ../../packages/catalog/dist/shell/with-timeout.js
 var import_promises28 = require("node:timers/promises");
-var import_neverthrow78 = __toESM(require_index_cjs(), 1);
+var import_neverthrow79 = __toESM(require_index_cjs(), 1);
 async function buildOperationPromise(operation) {
   return operation.match((value) => ({ kind: "value", value }), (error48) => ({ kind: "error", error: error48 }));
 }
@@ -158008,14 +158269,14 @@ function withTimeout(input) {
     buildOperationPromise(input.operation),
     buildTimerPromise(input.timeoutMs)
   ]);
-  return import_neverthrow78.ResultAsync.fromSafePromise(racePromise).andThen((settlement) => {
+  return import_neverthrow79.ResultAsync.fromSafePromise(racePromise).andThen((settlement) => {
     if (settlement.kind === "value") {
-      return (0, import_neverthrow78.okAsync)(settlement.value);
+      return (0, import_neverthrow79.okAsync)(settlement.value);
     }
     if (settlement.kind === "error") {
-      return (0, import_neverthrow78.errAsync)(settlement.error);
+      return (0, import_neverthrow79.errAsync)(settlement.error);
     }
-    return (0, import_neverthrow78.errAsync)({
+    return (0, import_neverthrow79.errAsync)({
       type: "CATALOG_FETCH_TIMEOUT",
       phase: input.phase,
       timeoutMs: input.timeoutMs
@@ -158026,7 +158287,7 @@ function withTimeout(input) {
 // ../../packages/catalog/dist/shell/write-cache.js
 var import_promises29 = require("node:fs/promises");
 var import_node_path26 = __toESM(require("node:path"), 1);
-var import_neverthrow79 = __toESM(require_index_cjs(), 1);
+var import_neverthrow80 = __toESM(require_index_cjs(), 1);
 var DIRECTORY_MODE = 448;
 var FILE_MODE2 = 384;
 async function runMkdir(directoryPath) {
@@ -158037,7 +158298,7 @@ async function runWriteFile(filePath, content) {
   return void 0;
 }
 function safeMkdir3(directoryPath) {
-  const wrapped = import_neverthrow79.ResultAsync.fromThrowable(runMkdir, (cause) => ({
+  const wrapped = import_neverthrow80.ResultAsync.fromThrowable(runMkdir, (cause) => ({
     type: "CATALOG_CACHE_WRITE_FAILED",
     path: directoryPath,
     cause: redactCause(cause)
@@ -158045,7 +158306,7 @@ function safeMkdir3(directoryPath) {
   return wrapped(directoryPath);
 }
 function safeWriteFile5(filePath, content) {
-  const wrapped = import_neverthrow79.ResultAsync.fromThrowable(runWriteFile, (cause) => ({
+  const wrapped = import_neverthrow80.ResultAsync.fromThrowable(runWriteFile, (cause) => ({
     type: "CATALOG_CACHE_WRITE_FAILED",
     path: filePath,
     cause: redactCause(cause)
@@ -158053,7 +158314,7 @@ function safeWriteFile5(filePath, content) {
   return wrapped(filePath, content);
 }
 function writeAllFiles(cacheRoot, files) {
-  return import_neverthrow79.ResultAsync.combine(Array.from(files.entries(), ([relativePath, content]) => safeWriteFile5(import_node_path26.default.join(cacheRoot, relativePath), content)));
+  return import_neverthrow80.ResultAsync.combine(Array.from(files.entries(), ([relativePath, content]) => safeWriteFile5(import_node_path26.default.join(cacheRoot, relativePath), content)));
 }
 function writeCache(cacheRoot, files) {
   const specsDirectory = import_node_path26.default.join(cacheRoot, "specs");
@@ -158062,7 +158323,7 @@ function writeCache(cacheRoot, files) {
 }
 
 // ../../packages/catalog/dist/core/materialize.js
-var import_neverthrow80 = __toESM(require_index_cjs(), 1);
+var import_neverthrow81 = __toESM(require_index_cjs(), 1);
 var CONTROL_CHAR_PATTERN = /[\u0000-\u0009\u000B\u000C\u000D\u000E-\u001F]/u;
 var JSON_INDENT3 = 2;
 function findControlCharsInStep(step) {
@@ -158097,48 +158358,48 @@ function revalidateSpecIds(specs) {
   for (const item of specs) {
     const reValidated = toSpecId(item.id);
     if (reValidated.isErr()) {
-      return (0, import_neverthrow80.err)(reValidated.error);
+      return (0, import_neverthrow81.err)(reValidated.error);
     }
   }
-  return (0, import_neverthrow80.ok)();
+  return (0, import_neverthrow81.ok)();
 }
 function revalidateSuiteIds(suites) {
   for (const item of suites) {
     const reValidated = toSuiteId(item.id);
     if (reValidated.isErr()) {
-      return (0, import_neverthrow80.err)(reValidated.error);
+      return (0, import_neverthrow81.err)(reValidated.error);
     }
   }
-  return (0, import_neverthrow80.ok)();
+  return (0, import_neverthrow81.ok)();
 }
 function checkUniqueSpecIds(specs) {
   const seen = /* @__PURE__ */ new Set();
   for (const item of specs) {
     if (seen.has(item.id)) {
-      return (0, import_neverthrow80.err)({ type: "CATALOG_DUPLICATE_ID", kind: "spec", id: item.id });
+      return (0, import_neverthrow81.err)({ type: "CATALOG_DUPLICATE_ID", kind: "spec", id: item.id });
     }
     seen.add(item.id);
   }
-  return (0, import_neverthrow80.ok)();
+  return (0, import_neverthrow81.ok)();
 }
 function checkUniqueSuiteIds(suites) {
   const seen = /* @__PURE__ */ new Set();
   for (const item of suites) {
     if (seen.has(item.id)) {
-      return (0, import_neverthrow80.err)({ type: "CATALOG_DUPLICATE_ID", kind: "suite", id: item.id });
+      return (0, import_neverthrow81.err)({ type: "CATALOG_DUPLICATE_ID", kind: "suite", id: item.id });
     }
     seen.add(item.id);
   }
-  return (0, import_neverthrow80.ok)();
+  return (0, import_neverthrow81.ok)();
 }
 function checkSpecContent(specs) {
   for (const item of specs) {
     const reason = findControlCharsInSpec(item);
     if (reason !== void 0) {
-      return (0, import_neverthrow80.err)({ type: "CATALOG_SPEC_CONTENT_REJECTED", kind: "spec", id: item.id, reason });
+      return (0, import_neverthrow81.err)({ type: "CATALOG_SPEC_CONTENT_REJECTED", kind: "spec", id: item.id, reason });
     }
   }
-  return (0, import_neverthrow80.ok)();
+  return (0, import_neverthrow81.ok)();
 }
 function buildSpecFile(catalogSpec) {
   return [`specs/${catalogSpec.id}.test.md`, renderSpec(catalogSpec.spec)];
@@ -158174,7 +158435,7 @@ function resolveLocal(catalog) {
 var CACHE_DIRECTORY_NAME = import_node_path27.default.join(".xqa", "cache");
 var RUN_DIRECTORY_MODE = 448;
 function safeCreateRunDirectory(target) {
-  const wrapped = import_neverthrow81.ResultAsync.fromThrowable(async (directoryPath) => {
+  const wrapped = import_neverthrow82.ResultAsync.fromThrowable(async (directoryPath) => {
     await (0, import_promises30.mkdir)(directoryPath, { recursive: true, mode: RUN_DIRECTORY_MODE });
   }, (cause) => ({
     type: "CATALOG_CACHE_WRITE_FAILED",
@@ -158188,17 +158449,17 @@ function deriveCacheRoot(repoRoot) {
 }
 function enforceSizeBound(count, phase) {
   if (count > CATALOG_MAX_ITEMS_PER_KIND) {
-    return (0, import_neverthrow81.errAsync)({
+    return (0, import_neverthrow82.errAsync)({
       type: "CATALOG_RESULT_TOO_LARGE",
       phase,
       count,
       limit: CATALOG_MAX_ITEMS_PER_KIND
     });
   }
-  return (0, import_neverthrow81.okAsync)();
+  return (0, import_neverthrow82.okAsync)();
 }
 function fetchCatalogItems(catalog, options) {
-  return import_neverthrow81.ResultAsync.combine([
+  return import_neverthrow82.ResultAsync.combine([
     withTimeout({
       operation: catalog.getSpecs(),
       timeoutMs: options.fetchTimeoutMs,
@@ -158235,7 +158496,7 @@ function runGithubPipeline(context) {
 }
 function buildRemoteContext(input, remote) {
   const cacheRoot = deriveCacheRoot(input.repoRoot);
-  const runDirectory = import_node_path27.default.join(cacheRoot, (0, import_node_crypto4.randomUUID)());
+  const runDirectory = import_node_path27.default.join(cacheRoot, (0, import_node_crypto5.randomUUID)());
   return {
     remote,
     configDir: input.configDir,
@@ -158246,12 +158507,12 @@ function buildRemoteContext(input, remote) {
 }
 function buildGithubContext(input, github) {
   const cacheRoot = deriveCacheRoot(input.repoRoot);
-  const runDirectory = import_node_path27.default.join(cacheRoot, (0, import_node_crypto4.randomUUID)());
+  const runDirectory = import_node_path27.default.join(cacheRoot, (0, import_node_crypto5.randomUUID)());
   return { github, runDirectory, cacheRoot };
 }
 function resolveCatalog(input) {
   if (input.catalog.type === "local") {
-    return (0, import_neverthrow81.okAsync)(resolveLocal(input.catalog));
+    return (0, import_neverthrow82.okAsync)(resolveLocal(input.catalog));
   }
   if (input.catalog.type === "remote") {
     return runRemotePipeline(buildRemoteContext(input, input.catalog));
@@ -158260,7 +158521,7 @@ function resolveCatalog(input) {
 }
 
 // src/commands/catalog/dry-run.ts
-var import_neverthrow82 = __toESM(require_index_cjs(), 1);
+var import_neverthrow83 = __toESM(require_index_cjs(), 1);
 var DEFAULT_FETCH_TIMEOUT_MS = 6e4;
 async function runGitToplevel() {
   const deferred = Promise.withResolvers();
@@ -158273,7 +158534,7 @@ async function runGitToplevel() {
   });
   return deferred.promise;
 }
-var safeGitToplevel = import_neverthrow82.ResultAsync.fromThrowable(
+var safeGitToplevel = import_neverthrow83.ResultAsync.fromThrowable(
   runGitToplevel,
   (cause) => ({
     type: "CATALOG_MODULE_LOAD_FAILED",
@@ -158282,7 +158543,7 @@ var safeGitToplevel = import_neverthrow82.ResultAsync.fromThrowable(
   })
 );
 function fetchCounts(catalog, timeoutMs) {
-  return import_neverthrow82.ResultAsync.combine([
+  return import_neverthrow83.ResultAsync.combine([
     withTimeout({ operation: catalog.getSpecs(), timeoutMs, phase: "specs" }),
     withTimeout({ operation: catalog.getSuites(), timeoutMs, phase: "suites" })
   ]).map(([specs, suites]) => ({ specsCount: specs.length, suitesCount: suites.length }));
@@ -158343,7 +158604,7 @@ function registerCatalogCommand(program3) {
 }
 
 // src/core/completion-generator.ts
-var import_neverthrow83 = __toESM(require_index_cjs(), 1);
+var import_neverthrow84 = __toESM(require_index_cjs(), 1);
 function extractLongFlags(flags) {
   return flags.split(/[\s,]+/).filter((token) => token.startsWith("--"));
 }
@@ -158433,9 +158694,9 @@ complete -F _xqa_completion xqa`;
 }
 function generateCompletion(commands, shell) {
   if (shell !== "bash" && shell !== "zsh") {
-    return (0, import_neverthrow83.err)({ type: "UNSUPPORTED_SHELL", shell });
+    return (0, import_neverthrow84.err)({ type: "UNSUPPORTED_SHELL", shell });
   }
-  return (0, import_neverthrow83.ok)(shell === "zsh" ? generateZshCompletion(commands) : generateBashCompletion(commands));
+  return (0, import_neverthrow84.ok)(shell === "zsh" ? generateZshCompletion(commands) : generateBashCompletion(commands));
 }
 
 // src/commands/completion-command.ts
@@ -158514,17 +158775,17 @@ function parseVerboseOption(value) {
 // src/shell/xqa-directory.ts
 var import_node_fs11 = require("node:fs");
 var import_node_path28 = __toESM(require("node:path"), 1);
-var import_neverthrow84 = __toESM(require_index_cjs(), 1);
+var import_neverthrow85 = __toESM(require_index_cjs(), 1);
 function findXqaDirectory(startDirectory) {
   let current = startDirectory;
   for (; ; ) {
     const candidate = import_node_path28.default.join(current, ".xqa");
     if ((0, import_node_fs11.existsSync)(candidate)) {
-      return (0, import_neverthrow84.ok)(candidate);
+      return (0, import_neverthrow85.ok)(candidate);
     }
     const parent = import_node_path28.default.dirname(current);
     if (parent === current) {
-      return (0, import_neverthrow84.err)({ type: "XQA_NOT_INITIALIZED" });
+      return (0, import_neverthrow85.err)({ type: "XQA_NOT_INITIALIZED" });
     }
     current = parent;
   }
@@ -158615,16 +158876,16 @@ function buildPipelineConfig({
 // src/core/last-path.ts
 var import_node_fs12 = require("node:fs");
 var import_node_path30 = __toESM(require("node:path"), 1);
-var import_neverthrow85 = __toESM(require_index_cjs(), 1);
+var import_neverthrow86 = __toESM(require_index_cjs(), 1);
 function resolveLastPath(argument, stateContent) {
   if (argument !== void 0) {
-    return (0, import_neverthrow85.ok)(argument);
+    return (0, import_neverthrow86.ok)(argument);
   }
   const trimmed = stateContent?.trim();
   if (trimmed) {
-    return (0, import_neverthrow85.ok)(trimmed);
+    return (0, import_neverthrow86.ok)(trimmed);
   }
-  return (0, import_neverthrow85.err)({ type: "NO_ARG_AND_NO_STATE" });
+  return (0, import_neverthrow86.err)({ type: "NO_ARG_AND_NO_STATE" });
 }
 function lastPathFilePath(xqaDirectoryectory) {
   return import_node_path30.default.join(xqaDirectoryectory, "last-findings-path");
@@ -158690,25 +158951,25 @@ ${cause}
 }
 
 // src/commands/explore/simulator.ts
-var import_neverthrow87 = __toESM(require_index_cjs(), 1);
+var import_neverthrow88 = __toESM(require_index_cjs(), 1);
 
 // src/core/simulator-selector.ts
-var import_neverthrow86 = __toESM(require_index_cjs(), 1);
+var import_neverthrow87 = __toESM(require_index_cjs(), 1);
 function matchesUdid(simulator, udid) {
   return simulator.udid.toLowerCase() === udid.toLowerCase();
 }
 function selectSimulators(simulators, udidOverride) {
   if (simulators.length === 0) {
-    return (0, import_neverthrow86.err)({ type: "NO_BOOTED_SIMULATORS" });
+    return (0, import_neverthrow87.err)({ type: "NO_BOOTED_SIMULATORS" });
   }
   if (udidOverride === void 0) {
-    return (0, import_neverthrow86.ok)([...simulators]);
+    return (0, import_neverthrow87.ok)([...simulators]);
   }
   const match2 = simulators.find((simulator) => matchesUdid(simulator, udidOverride));
   if (match2 === void 0) {
-    return (0, import_neverthrow86.err)({ type: "SIMULATOR_UDID_NOT_FOUND", udid: udidOverride });
+    return (0, import_neverthrow87.err)({ type: "SIMULATOR_UDID_NOT_FOUND", udid: udidOverride });
   }
-  return (0, import_neverthrow86.ok)([match2]);
+  return (0, import_neverthrow87.ok)([match2]);
 }
 
 // src/commands/explore/simulator.ts
@@ -158716,9 +158977,9 @@ var ITEM_ID2 = "explore";
 function firstUdid(selected) {
   const first = selected[0];
   if (first === void 0) {
-    return (0, import_neverthrow87.err)({ type: "NO_BOOTED_SIMULATORS" });
+    return (0, import_neverthrow88.err)({ type: "NO_BOOTED_SIMULATORS" });
   }
-  return (0, import_neverthrow87.ok)(first.udid);
+  return (0, import_neverthrow88.ok)(first.udid);
 }
 function buildItemName(simulatorUdid) {
   return `${simulatorUdid} - explorer`;
@@ -158752,7 +159013,7 @@ function buildExploreRunState({
 var import_node_path31 = __toESM(require("node:path"), 1);
 var import_node_url3 = require("node:url");
 var import_dotenv = __toESM(require_main(), 1);
-var import_neverthrow88 = __toESM(require_index_cjs(), 1);
+var import_neverthrow89 = __toESM(require_index_cjs(), 1);
 
 // src/config-schema.ts
 var configSchema = external_exports.object({
@@ -158770,10 +159031,10 @@ function loadConfig2() {
     const messages = result.error.issues.map(
       (issue2) => `  - ${issue2.path.join(".")}: ${issue2.message}`
     );
-    return (0, import_neverthrow88.err)({ type: "INVALID_CONFIG", message: `Configuration error:
+    return (0, import_neverthrow89.err)({ type: "INVALID_CONFIG", message: `Configuration error:
 ${messages.join("\n")}` });
   }
-  return (0, import_neverthrow88.ok)(result.data);
+  return (0, import_neverthrow89.ok)(result.data);
 }
 function getGithubShaEnv() {
   return process.env.GITHUB_SHA;
@@ -158794,7 +159055,7 @@ function getAppiumUrlEnv() {
 // src/shell/app-context.ts
 var import_promises31 = require("node:fs/promises");
 var import_node_path32 = __toESM(require("node:path"), 1);
-var import_neverthrow89 = __toESM(require_index_cjs(), 1);
+var import_neverthrow90 = __toESM(require_index_cjs(), 1);
 var HTML_COMMENT_PATTERN = /<!--[\s\S]*?-->/g;
 function isEnoentError(value) {
   return value !== null && typeof value === "object" && "code" in value && value.code === "ENOENT";
@@ -158804,9 +159065,9 @@ function toAppContextError(cause) {
 }
 function absentContext() {
   const absent = void 0;
-  return (0, import_neverthrow89.ok)(absent);
+  return (0, import_neverthrow90.ok)(absent);
 }
-var safeReadFile3 = import_neverthrow89.ResultAsync.fromThrowable(
+var safeReadFile3 = import_neverthrow90.ResultAsync.fromThrowable(
   async (filePath) => (0, import_promises31.readFile)(filePath, "utf8"),
   toAppContextError
 );
@@ -158820,7 +159081,7 @@ function readContextFile(xqaDirectory, filename) {
     if (isEnoentError(error48.cause)) {
       return absentContext();
     }
-    return (0, import_neverthrow89.err)(error48);
+    return (0, import_neverthrow90.err)(error48);
   });
 }
 function readAppContext(xqaDirectory) {
@@ -158834,7 +159095,7 @@ function readExploreContext(xqaDirectory) {
 var import_node_fs13 = require("node:fs");
 var import_node_os3 = require("node:os");
 var import_node_path33 = __toESM(require("node:path"), 1);
-var import_neverthrow90 = __toESM(require_index_cjs(), 1);
+var import_neverthrow91 = __toESM(require_index_cjs(), 1);
 function resolveDaemonPaths() {
   const home = import_node_path33.default.join((0, import_node_os3.homedir)(), XQA_HOME_DIR);
   (0, import_node_fs13.mkdirSync)(home, { recursive: true });
@@ -158856,7 +159117,7 @@ function ensureDaemonForAutoSpawn() {
 }
 function noDaemon() {
   const noInfo = void 0;
-  return (0, import_neverthrow90.okAsync)(noInfo);
+  return (0, import_neverthrow91.okAsync)(noInfo);
 }
 function runPreflightChecks(options) {
   return checkAppiumAvailable().mapErr(() => ({ type: "APPIUM_NOT_FOUND" })).andThen(() => {
@@ -159142,34 +159403,34 @@ function registerInitCommand(program3) {
 var import_node_path40 = __toESM(require("node:path"), 1);
 
 // ../../agents/planner/dist/index.js
-var import_neverthrow91 = __toESM(require_index_cjs(), 1);
 var import_neverthrow92 = __toESM(require_index_cjs(), 1);
-var yaml3 = __toESM(require_dist(), 1);
 var import_neverthrow93 = __toESM(require_index_cjs(), 1);
+var yaml3 = __toESM(require_dist(), 1);
+var import_neverthrow94 = __toESM(require_index_cjs(), 1);
 var import_promises32 = require("node:fs/promises");
 var import_node_path36 = __toESM(require("node:path"), 1);
-var import_neverthrow94 = __toESM(require_index_cjs(), 1);
-var import_promises33 = require("node:fs/promises");
 var import_neverthrow95 = __toESM(require_index_cjs(), 1);
+var import_promises33 = require("node:fs/promises");
 var import_neverthrow96 = __toESM(require_index_cjs(), 1);
 var import_neverthrow97 = __toESM(require_index_cjs(), 1);
+var import_neverthrow98 = __toESM(require_index_cjs(), 1);
 var import_node_child_process11 = require("node:child_process");
 var import_node_util4 = require("node:util");
-var import_neverthrow98 = __toESM(require_index_cjs(), 1);
+var import_neverthrow99 = __toESM(require_index_cjs(), 1);
 var import_node_process2 = require("node:process");
 var import_node_child_process12 = require("node:child_process");
 var import_node_util5 = require("node:util");
-var import_neverthrow99 = __toESM(require_index_cjs(), 1);
 var import_neverthrow100 = __toESM(require_index_cjs(), 1);
 var import_neverthrow101 = __toESM(require_index_cjs(), 1);
+var import_neverthrow102 = __toESM(require_index_cjs(), 1);
 var import_promises34 = require("node:fs/promises");
 var import_node_path37 = __toESM(require("node:path"), 1);
-var import_neverthrow102 = __toESM(require_index_cjs(), 1);
+var import_neverthrow103 = __toESM(require_index_cjs(), 1);
 var import_promises35 = require("node:fs/promises");
 var import_node_path38 = __toESM(require("node:path"), 1);
-var import_neverthrow103 = __toESM(require_index_cjs(), 1);
-var import_promises36 = require("node:fs/promises");
 var import_neverthrow104 = __toESM(require_index_cjs(), 1);
+var import_promises36 = require("node:fs/promises");
+var import_neverthrow105 = __toESM(require_index_cjs(), 1);
 function isEmptySummary(summary) {
   return summary.touchedFiles.length === 0 && summary.uncommittedFiles.length === 0;
 }
@@ -159487,15 +159748,15 @@ function branchReferenceToString(reference) {
 }
 function resolveBaseReference(context) {
   if (context.input.baseOverride !== void 0) {
-    return (0, import_neverthrow91.okAsync)(context.input.baseOverride);
+    return (0, import_neverthrow92.okAsync)(context.input.baseOverride);
   }
   return context.deps.resolveBaseBranch(context.input.gitContext);
 }
 function assertNonEmptyDiff(state) {
   if (isEmptySummary(state.summary)) {
-    return (0, import_neverthrow91.err)({ type: "EMPTY_DIFF" });
+    return (0, import_neverthrow92.err)({ type: "EMPTY_DIFF" });
   }
-  return (0, import_neverthrow91.ok)(state);
+  return (0, import_neverthrow92.ok)(state);
 }
 function emitDrafts(input) {
   const { context, summary } = input;
@@ -159527,7 +159788,7 @@ function runEmitAndPersist(input) {
   return emitDrafts({ summary: state.summary, context }).andThen((drafts) => {
     context.deps.emitDebug?.(`[plan] drafts count=${String(drafts.length)}`);
     if (drafts.length === 0) {
-      return (0, import_neverthrow91.okAsync)({
+      return (0, import_neverthrow92.okAsync)({
         specs: [],
         emptyReason: "model-abstained"
       });
@@ -159542,7 +159803,7 @@ function dispatchClassification(input) {
   const emitDebug = input.context.deps.emitDebug;
   if (classification.kind === "empty") {
     emitClassificationDebug({ emitDebug, kind: "empty", reason: classification.reason });
-    return (0, import_neverthrow91.okAsync)({ specs: [], emptyReason: classification.reason });
+    return (0, import_neverthrow92.okAsync)({ specs: [], emptyReason: classification.reason });
   }
   emitClassificationDebug({ emitDebug, kind: "actionable" });
   return runEmitAndPersist(input);
@@ -159581,7 +159842,7 @@ function resolveHead(input) {
 function collectChangeSummary(input) {
   const diff = input.gitDiff({ context: input.gitContext, baseSha: input.baseRef });
   const status = input.gitStatusPorcelain(input.gitContext);
-  return import_neverthrow91.ResultAsync.combine([diff, status]).map(([rawDiff, porcelainLines]) => ({
+  return import_neverthrow92.ResultAsync.combine([diff, status]).map(([rawDiff, porcelainLines]) => ({
     rawDiff,
     summary: summarizeDiff(rawDiff, extractUncommittedFiles(porcelainLines))
   }));
@@ -159596,9 +159857,9 @@ function toSpecSummaries(entries) {
 function recoverPlanMissing(result) {
   return result.orElse((error48) => {
     if (error48.type === "PLAN_DIR_MISSING") {
-      return (0, import_neverthrow91.okAsync)([]);
+      return (0, import_neverthrow92.okAsync)([]);
     }
-    return (0, import_neverthrow91.errAsync)(error48);
+    return (0, import_neverthrow92.errAsync)(error48);
   });
 }
 function generatePlan(input, deps) {
@@ -159741,13 +160002,13 @@ function loadExistingSpec(input) {
 }
 function assertOriginalMetaComplete(spec, path410) {
   if (!isMetaComplete(spec)) {
-    return (0, import_neverthrow92.err)({
+    return (0, import_neverthrow93.err)({
       type: "SPEC_PARSE_FAILED",
       path: path410,
       reason: "missing required meta field"
     });
   }
-  return (0, import_neverthrow92.ok)(spec);
+  return (0, import_neverthrow93.ok)(spec);
 }
 function buildApplyInput(input) {
   return {
@@ -159760,9 +160021,9 @@ function buildApplyInput(input) {
 function assertMetaPreserved(input) {
   const violated = IMMUTABLE_META_KEYS.find((key) => input.updated[key] !== input.original[key]);
   if (violated !== void 0) {
-    return (0, import_neverthrow92.err)({ type: "SCENARIO_ID_LOST_IN_EDIT", path: input.path });
+    return (0, import_neverthrow93.err)({ type: "SCENARIO_ID_LOST_IN_EDIT", path: input.path });
   }
-  return (0, import_neverthrow92.ok)({
+  return (0, import_neverthrow93.ok)({
     ...input.updated,
     scenarioId: input.original.scenarioId,
     baseCommit: input.original.baseCommit,
@@ -159824,12 +160085,12 @@ function editScenario(input, deps) {
 function loadEntries(context) {
   return context.deps.readPlan({ directory: context.input.outputDirectory }).andThen((entries) => {
     if (entries.length === 0) {
-      return (0, import_neverthrow93.errAsync)({
+      return (0, import_neverthrow94.errAsync)({
         type: "PLAN_EMPTY",
         path: context.input.outputDirectory
       });
     }
-    return (0, import_neverthrow93.okAsync)(entries);
+    return (0, import_neverthrow94.okAsync)(entries);
   });
 }
 function emitDrafts2(input) {
@@ -159872,7 +160133,7 @@ function runEmitAndPersist2(state, context) {
   return emitDrafts2({ summary: state.summary, entries: state.entries, context }).andThen(
     (drafts) => {
       if (drafts.length === 0) {
-        return (0, import_neverthrow93.okAsync)({
+        return (0, import_neverthrow94.okAsync)({
           appended: [],
           emptyReason: "model-abstained"
         });
@@ -159888,11 +160149,11 @@ function runEmitAndPersist2(state, context) {
 }
 function dispatchState(state, context) {
   if (isEmptySummary(state.summary)) {
-    return (0, import_neverthrow93.okAsync)({ appended: [], emptyReason: "other" });
+    return (0, import_neverthrow94.okAsync)({ appended: [], emptyReason: "other" });
   }
   const classification = classifyActionability(state.summary, state.rawDiff);
   if (classification.kind === "empty") {
-    return (0, import_neverthrow93.okAsync)({ appended: [], emptyReason: classification.reason });
+    return (0, import_neverthrow94.okAsync)({ appended: [], emptyReason: classification.reason });
   }
   return runEmitAndPersist2(state, context);
 }
@@ -159915,14 +160176,14 @@ function pickSinceSha(entries) {
 }
 function ensureSinceShaExists(input) {
   if (input.sinceSha === void 0) {
-    return (0, import_neverthrow93.errAsync)({ type: "GIT_SINCE_SHA_UNRECORDED" });
+    return (0, import_neverthrow94.errAsync)({ type: "GIT_SINCE_SHA_UNRECORDED" });
   }
   const sha = input.sinceSha;
   return input.gitCommitExists({ context: input.gitContext, sha }).andThen((exists) => {
     if (!exists) {
-      return (0, import_neverthrow93.errAsync)({ type: "GIT_SINCE_SHA_MISSING", sha });
+      return (0, import_neverthrow94.errAsync)({ type: "GIT_SINCE_SHA_MISSING", sha });
     }
-    return (0, import_neverthrow93.okAsync)(sha);
+    return (0, import_neverthrow94.okAsync)(sha);
   });
 }
 function extendPlan(input, deps) {
@@ -159934,7 +160195,7 @@ async function writeAndRename(input) {
   await (0, import_promises33.writeFile)(temporaryPath, input.content, "utf8");
   await (0, import_promises33.rename)(temporaryPath, input.path);
 }
-var rawAtomicWrite = import_neverthrow95.ResultAsync.fromThrowable(
+var rawAtomicWrite = import_neverthrow96.ResultAsync.fromThrowable(
   writeAndRename,
   (cause) => ({ cause })
 );
@@ -159965,24 +160226,24 @@ function toScenarioMeta2(spec) {
 }
 function toScenario(entry) {
   if (!isMetaComplete(entry.spec)) {
-    return (0, import_neverthrow96.err)({
+    return (0, import_neverthrow97.err)({
       type: "SPEC_PARSE_FAILED",
       path: entry.path,
       reason: "missing required meta field"
     });
   }
-  return (0, import_neverthrow96.ok)({ ...toScenarioDraft2(entry.spec), ...toScenarioMeta2(entry.spec) });
+  return (0, import_neverthrow97.ok)({ ...toScenarioDraft2(entry.spec), ...toScenarioMeta2(entry.spec) });
 }
 function collectScenarios(entries) {
   const scenarios = [];
   for (const entry of entries) {
     const result = toScenario(entry);
     if (result.isErr()) {
-      return (0, import_neverthrow96.err)(result.error);
+      return (0, import_neverthrow97.err)(result.error);
     }
     scenarios.push(result.value);
   }
-  return (0, import_neverthrow96.ok)(scenarios);
+  return (0, import_neverthrow97.ok)(scenarios);
 }
 function buildFilesMap(entries) {
   const pairs2 = entries.flatMap((entry) => {
@@ -160083,11 +160344,11 @@ var REPORT_FILENAME = "report.json";
 var RUNS_FILENAME = "scenario-runs.json";
 var ENOENT_CODE = "ENOENT";
 var findingsArraySchema = external_exports.array(findingSchema);
-var safeJsonParse7 = (0, import_neverthrow94.fromThrowable)(
+var safeJsonParse7 = (0, import_neverthrow95.fromThrowable)(
   JSON.parse,
   (cause) => ({ cause })
 );
-var rawReadFile = import_neverthrow94.ResultAsync.fromThrowable(
+var rawReadFile = import_neverthrow95.ResultAsync.fromThrowable(
   async (filePath) => (0, import_promises32.readFile)(filePath, "utf8"),
   (cause) => ({ cause })
 );
@@ -160098,9 +160359,9 @@ function isEnoentError2(error48) {
 function readFileOptional(filePath) {
   return rawReadFile(filePath).map((content) => content).orElse(({ cause }) => {
     if (isEnoentError2(cause)) {
-      return (0, import_neverthrow94.ok)(void 0);
+      return (0, import_neverthrow95.ok)(void 0);
     }
-    return (0, import_neverthrow94.err)({ type: "FINDINGS_READ_FAILED", path: filePath, cause });
+    return (0, import_neverthrow95.err)({ type: "FINDINGS_READ_FAILED", path: filePath, cause });
   });
 }
 function parseFindingsJson(input) {
@@ -160111,9 +160372,9 @@ function parseFindingsJson(input) {
 function validateFindingsSchema(data, filePath) {
   const parsed = findingsArraySchema.safeParse(data);
   if (!parsed.success) {
-    return (0, import_neverthrow94.err)({ type: "FINDINGS_READ_FAILED", path: filePath, cause: parsed.error });
+    return (0, import_neverthrow95.err)({ type: "FINDINGS_READ_FAILED", path: filePath, cause: parsed.error });
   }
-  return (0, import_neverthrow94.ok)(parsed.data);
+  return (0, import_neverthrow95.ok)(parsed.data);
 }
 function validateFindings(input) {
   return parseFindingsJson(input).andThen((data) => validateFindingsSchema(data, input.path));
@@ -160121,12 +160382,12 @@ function validateFindings(input) {
 function parseRunsSchema(data, filePath) {
   const parsed = scenarioRunsFileSchema.safeParse(data);
   if (!parsed.success) {
-    return (0, import_neverthrow94.err)({ type: "FINDINGS_READ_FAILED", path: filePath, cause: parsed.error });
+    return (0, import_neverthrow95.err)({ type: "FINDINGS_READ_FAILED", path: filePath, cause: parsed.error });
   }
   const entries = parsed.data.records.map(
     (record2) => [record2.scenarioId, record2]
   );
-  return (0, import_neverthrow94.ok)(Object.fromEntries(entries));
+  return (0, import_neverthrow95.ok)(Object.fromEntries(entries));
 }
 function parseRunsJson(raw, filePath) {
   return safeJsonParse7(raw).mapErr(({ cause }) => ({ type: "FINDINGS_READ_FAILED", path: filePath, cause })).andThen((data) => parseRunsSchema(data, filePath));
@@ -160169,14 +160430,14 @@ function correlateAndPersist(input) {
 }
 function loadRunRecords(input) {
   if (input.readRunsFileFn === void 0) {
-    return import_neverthrow94.ResultAsync.fromSafePromise(
+    return import_neverthrow95.ResultAsync.fromSafePromise(
       Promise.resolve(void 0)
     );
   }
   const resolvedRunsPath = runsPathFor(input.findingsPath, input.runsPath);
   return input.readRunsFileFn(resolvedRunsPath).andThen((raw) => {
     if (raw === void 0) {
-      return (0, import_neverthrow94.ok)(void 0);
+      return (0, import_neverthrow95.ok)(void 0);
     }
     return parseRunsJson(raw, resolvedRunsPath);
   });
@@ -160243,13 +160504,13 @@ async function createMessage2(input) {
 function extractText(message, operation) {
   const firstBlock = message.content[0];
   if (firstBlock?.type !== "text") {
-    return (0, import_neverthrow97.err)({
+    return (0, import_neverthrow98.err)({
       type: "AI_RESPONSE_INVALID",
       operation,
       raw: JSON.stringify(message.content)
     });
   }
-  return (0, import_neverthrow97.ok)(firstBlock.text);
+  return (0, import_neverthrow98.ok)(firstBlock.text);
 }
 function buildClient(apiKey) {
   return new Anthropic({ apiKey });
@@ -160257,7 +160518,7 @@ function buildClient(apiKey) {
 function invokeAi(arguments_) {
   const { input, operation } = arguments_;
   const client = buildClient(input.config.apiKey);
-  const callMessage = (0, import_neverthrow97.fromAsyncThrowable)(
+  const callMessage = (0, import_neverthrow98.fromAsyncThrowable)(
     createMessage2,
     (cause) => ({ type: "AI_CALL_FAILED", operation, cause })
   );
@@ -160308,7 +160569,7 @@ async function runGit(input) {
 }
 function execGit(commandArguments, context) {
   const command = `git ${commandArguments.join(" ")}`;
-  return (0, import_neverthrow98.fromAsyncThrowable)(
+  return (0, import_neverthrow99.fromAsyncThrowable)(
     runGit,
     (cause) => toExecError(cause, command)
   )({ commandArguments, context });
@@ -160322,9 +160583,9 @@ function splitNonEmptyLines(value) {
 }
 function foldCommitExists(error48) {
   if (error48.type === "GIT_EXEC_FAILED") {
-    return (0, import_neverthrow98.okAsync)(false);
+    return (0, import_neverthrow99.okAsync)(false);
   }
-  return (0, import_neverthrow98.errAsync)(error48);
+  return (0, import_neverthrow99.errAsync)(error48);
 }
 function resolveDetachedHead(context) {
   return execGit(["rev-parse", "HEAD"], context).map(
@@ -160377,7 +160638,7 @@ async function runGh(input) {
   });
   return { stdout, stderr };
 }
-var safeRunGh = (0, import_neverthrow99.fromAsyncThrowable)(
+var safeRunGh = (0, import_neverthrow100.fromAsyncThrowable)(
   runGh,
   (cause) => ({ type: "GH_PR_LOOKUP_FAILED", cause })
 );
@@ -160388,9 +160649,9 @@ function ghDetectPrBaseBranch(context) {
   }).andThen((result) => {
     const value = result.stdout.trim();
     if (value.length === 0) {
-      return (0, import_neverthrow99.errAsync)({ type: "GH_PR_LOOKUP_FAILED", cause: "empty-output" });
+      return (0, import_neverthrow100.errAsync)({ type: "GH_PR_LOOKUP_FAILED", cause: "empty-output" });
     }
-    return (0, import_neverthrow99.okAsync)(value);
+    return (0, import_neverthrow100.okAsync)(value);
   });
 }
 function resolveBaseBranch(gitContext, deps) {
@@ -160537,20 +160798,20 @@ var scenarioDraftSchema = external_exports.object({
   coverageNote: external_exports.string().optional()
 });
 var payloadSchema = external_exports.object({ scenarios: external_exports.array(scenarioDraftSchema) });
-var safeParseJson3 = (0, import_neverthrow100.fromThrowable)(
+var safeParseJson3 = (0, import_neverthrow101.fromThrowable)(
   (raw) => JSON.parse(raw),
   () => ({ type: "AI_RESPONSE_JSON_PARSE" })
 );
 function validatePayload(raw) {
   const parsed = safeParseJson3(raw);
   if (parsed.isErr()) {
-    return (0, import_neverthrow100.err)({ type: "AI_RESPONSE_INVALID", operation: "scenario-emit", raw });
+    return (0, import_neverthrow101.err)({ type: "AI_RESPONSE_INVALID", operation: "scenario-emit", raw });
   }
   const validated = payloadSchema.safeParse(parsed.value);
   if (!validated.success) {
-    return (0, import_neverthrow100.err)({ type: "AI_RESPONSE_INVALID", operation: "scenario-emit", raw });
+    return (0, import_neverthrow101.err)({ type: "AI_RESPONSE_INVALID", operation: "scenario-emit", raw });
   }
-  return (0, import_neverthrow100.ok)(validated.data.scenarios);
+  return (0, import_neverthrow101.ok)(validated.data.scenarios);
 }
 function emitScenarios(input, deps) {
   const prompt = buildScenarioEmitterPrompt({
@@ -160632,14 +160893,14 @@ function validateCandidate(validateInput) {
   const { raw, existingSpec, specPath } = validateInput;
   const parsed = parseSpec(raw, specPath);
   if (parsed.isErr()) {
-    return (0, import_neverthrow101.err)({ type: "AI_RESPONSE_INVALID", operation: "edit-apply", raw });
+    return (0, import_neverthrow102.err)({ type: "AI_RESPONSE_INVALID", operation: "edit-apply", raw });
   }
   const candidate = parsed.value;
   const violated = findMissingOrChangedKey(candidate, existingSpec);
   if (violated !== void 0) {
-    return (0, import_neverthrow101.err)({ type: "SCENARIO_ID_LOST_IN_EDIT", path: specPath });
+    return (0, import_neverthrow102.err)({ type: "SCENARIO_ID_LOST_IN_EDIT", path: specPath });
   }
-  return (0, import_neverthrow101.ok)(candidate);
+  return (0, import_neverthrow102.ok)(candidate);
 }
 function applyEdit(input, deps) {
   const prompt = buildEditApplierPrompt(input.existingSpec, input.userFeedback);
@@ -160657,14 +160918,14 @@ function mapReaddirError(input) {
   }
   return { type: "SPEC_READ_FAILED", path: input.directory, cause: input.cause };
 }
-var rawReaddir = import_neverthrow102.ResultAsync.fromThrowable(
+var rawReaddir = import_neverthrow103.ResultAsync.fromThrowable(
   async (directory) => (0, import_promises34.readdir)(directory),
   (cause) => ({ cause })
 );
 function safeReaddir(directory) {
   return rawReaddir(directory).mapErr(({ cause }) => mapReaddirError({ directory, cause }));
 }
-var rawReadFile2 = import_neverthrow102.ResultAsync.fromThrowable(
+var rawReadFile2 = import_neverthrow103.ResultAsync.fromThrowable(
   async (input) => (0, import_promises34.readFile)(input.path, "utf8"),
   (cause) => ({ cause })
 );
@@ -160684,17 +160945,17 @@ function readEntry3(input) {
 }
 function readEntries2(directory, filenames) {
   const tasks = filenames.map((filename) => readEntry3({ directory, filename }));
-  return import_neverthrow102.ResultAsync.combine([...tasks]);
+  return import_neverthrow103.ResultAsync.combine([...tasks]);
 }
 function readPlan(input) {
   return safeReaddir(input.directory).map((filenames) => filterAndSortSpecs(filenames)).andThen((filenames) => readEntries2(input.directory, filenames));
 }
 var SCENARIO_FILENAME_PATTERN = /^scenario-(\d+)\.test\.md$/;
-var safeMkdir4 = import_neverthrow103.ResultAsync.fromThrowable(
+var safeMkdir4 = import_neverthrow104.ResultAsync.fromThrowable(
   async (path410) => (0, import_promises35.mkdir)(path410, { recursive: true }),
   (cause) => ({ type: "SPEC_WRITE_FAILED", path: "", cause })
 );
-var safeReaddir2 = import_neverthrow103.ResultAsync.fromThrowable(
+var safeReaddir2 = import_neverthrow104.ResultAsync.fromThrowable(
   async (path410) => (0, import_promises35.readdir)(path410),
   (cause) => ({ type: "SPEC_WRITE_FAILED", path: "", cause })
 );
@@ -160745,12 +161006,12 @@ function writeAllScenarios(input, startIndex) {
       context: input.context
     })
   );
-  return import_neverthrow103.ResultAsync.combine([...tasks]);
+  return import_neverthrow104.ResultAsync.combine([...tasks]);
 }
 function writeScenarios(input) {
   return ensureDirectory(input.directory).andThen(() => listScenarioIndices(input.directory)).map((indices) => computeNextIndex(indices)).andThen((startIndex) => writeAllScenarios(input, startIndex));
 }
-var readFileByPath = import_neverthrow104.ResultAsync.fromThrowable(
+var readFileByPath = import_neverthrow105.ResultAsync.fromThrowable(
   async (path410) => (0, import_promises36.readFile)(path410, "utf8"),
   (cause) => ({ cause })
 );
@@ -160786,10 +161047,10 @@ var EXIT_PLAN_EMPTY = 45;
 var EXIT_SCENARIO_ID_LOST_IN_EDIT = 51;
 
 // src/commands/plan/format-diagnostic.ts
-var import_neverthrow105 = __toESM(require_index_cjs(), 1);
+var import_neverthrow106 = __toESM(require_index_cjs(), 1);
 var RAW_TRUNCATION_LIMIT = 200;
 var UNSERIALIZABLE3 = "[unserializable]";
-var safeStringify3 = (0, import_neverthrow105.fromThrowable)(
+var safeStringify3 = (0, import_neverthrow106.fromThrowable)(
   (value) => JSON.stringify(value),
   () => UNSERIALIZABLE3
 );
@@ -160903,7 +161164,7 @@ function runPlanEdit(input, options) {
 }
 
 // ../../node_modules/.pnpm/ulid@3.0.2/node_modules/ulid/dist/node/index.js
-var import_node_crypto5 = __toESM(require("node:crypto"), 1);
+var import_node_crypto6 = __toESM(require("node:crypto"), 1);
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var ENCODING_LEN = 32;
 var RANDOM_LEN = 16;
@@ -160935,7 +161196,7 @@ function randomChar(prng) {
 }
 function detectPRNG(root) {
   const rootLookup = detectRoot();
-  const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto5.default !== "undefined" ? import_node_crypto5.default : null);
+  const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto6.default !== "undefined" ? import_node_crypto6.default : null);
   if (typeof globalCrypto?.getRandomValues === "function") {
     return () => {
       const buffer = new Uint8Array(1);
@@ -160944,8 +161205,8 @@ function detectPRNG(root) {
     };
   } else if (typeof globalCrypto?.randomBytes === "function") {
     return () => globalCrypto.randomBytes(1).readUInt8() / 256;
-  } else if (import_node_crypto5.default?.randomBytes) {
-    return () => import_node_crypto5.default.randomBytes(1).readUInt8() / 256;
+  } else if (import_node_crypto6.default?.randomBytes) {
+    return () => import_node_crypto6.default.randomBytes(1).readUInt8() / 256;
   }
   throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
 }
@@ -161166,11 +161427,11 @@ function registerPlanCommand(program3, loader2) {
 }
 
 // ../../packages/reporter-github/dist/index.js
-var import_neverthrow108 = __toESM(require_index_cjs(), 1);
 var import_neverthrow109 = __toESM(require_index_cjs(), 1);
-var import_node_buffer3 = require("node:buffer");
 var import_neverthrow110 = __toESM(require_index_cjs(), 1);
+var import_node_buffer3 = require("node:buffer");
 var import_neverthrow111 = __toESM(require_index_cjs(), 1);
+var import_neverthrow112 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports2 = {};
@@ -168762,7 +169023,7 @@ var Octokit2 = Octokit.plugin(requestLog, legacyRestEndpointMethods, paginateRes
 
 // ../../packages/reporter-github/dist/index.js
 var import_node_fs16 = require("node:fs");
-var import_neverthrow112 = __toESM(require_index_cjs(), 1);
+var import_neverthrow113 = __toESM(require_index_cjs(), 1);
 var import_node_fs17 = require("node:fs");
 var import_node_path42 = __toESM(require("node:path"), 1);
 
@@ -170100,29 +170361,29 @@ var completeMultipartUpload2 = createCompleteMultipartUploadMethod({
 });
 
 // ../../packages/artifacts/dist/shell/put-artifact.js
-var import_neverthrow107 = __toESM(require_index_cjs(), 1);
+var import_neverthrow108 = __toESM(require_index_cjs(), 1);
 
 // ../../packages/artifacts/dist/core/validate-key.js
-var import_neverthrow106 = __toESM(require_index_cjs(), 1);
+var import_neverthrow107 = __toESM(require_index_cjs(), 1);
 var KEY_MAX_LENGTH = 1024;
 var KEY_REGEX = /^[a-zA-Z0-9._\-/]+$/;
 function validateKey(key) {
   if (key.length === 0) {
-    return (0, import_neverthrow106.err)({ type: "INVALID_KEY", key, reason: "EMPTY" });
+    return (0, import_neverthrow107.err)({ type: "INVALID_KEY", key, reason: "EMPTY" });
   }
   if (key.length > KEY_MAX_LENGTH) {
-    return (0, import_neverthrow106.err)({ type: "INVALID_KEY", key, reason: "TOO_LONG" });
+    return (0, import_neverthrow107.err)({ type: "INVALID_KEY", key, reason: "TOO_LONG" });
   }
   if (key.startsWith("/") || key.endsWith("/")) {
-    return (0, import_neverthrow106.err)({ type: "INVALID_KEY", key, reason: "EDGE_SLASH" });
+    return (0, import_neverthrow107.err)({ type: "INVALID_KEY", key, reason: "EDGE_SLASH" });
   }
   if (key.includes("..")) {
-    return (0, import_neverthrow106.err)({ type: "INVALID_KEY", key, reason: "PARENT_TRAVERSAL" });
+    return (0, import_neverthrow107.err)({ type: "INVALID_KEY", key, reason: "PARENT_TRAVERSAL" });
   }
   if (!KEY_REGEX.test(key)) {
-    return (0, import_neverthrow106.err)({ type: "INVALID_KEY", key, reason: "DISALLOWED_CHARACTERS" });
+    return (0, import_neverthrow107.err)({ type: "INVALID_KEY", key, reason: "DISALLOWED_CHARACTERS" });
   }
-  return (0, import_neverthrow106.ok)(key);
+  return (0, import_neverthrow107.ok)(key);
 }
 
 // ../../packages/artifacts/dist/shell/put-artifact.js
@@ -170146,7 +170407,7 @@ function toUploadError(cause) {
   };
 }
 function callBlobPut(deps, input) {
-  const safePut = import_neverthrow107.ResultAsync.fromThrowable(deps.put, toUploadError);
+  const safePut = import_neverthrow108.ResultAsync.fromThrowable(deps.put, toUploadError);
   return safePut({
     key: input.key,
     content: input.content,
@@ -170156,30 +170417,30 @@ function callBlobPut(deps, input) {
 }
 function putArtifact(input, dependencies = defaultDependencies) {
   if (input.token.length === 0) {
-    return (0, import_neverthrow107.errAsync)({ type: "EMPTY_TOKEN" });
+    return (0, import_neverthrow108.errAsync)({ type: "EMPTY_TOKEN" });
   }
   if (input.content.length === 0) {
-    return (0, import_neverthrow107.errAsync)({ type: "EMPTY_CONTENT" });
+    return (0, import_neverthrow108.errAsync)({ type: "EMPTY_CONTENT" });
   }
   return validateKey(input.key).asyncAndThen(() => callBlobPut(dependencies, input));
 }
 
 // ../../packages/reporter-github/dist/index.js
-var import_neverthrow113 = __toESM(require_index_cjs(), 1);
+var import_neverthrow114 = __toESM(require_index_cjs(), 1);
 var import_node_child_process13 = require("node:child_process");
 var import_node_fs18 = require("node:fs");
-var import_neverthrow114 = __toESM(require_index_cjs(), 1);
-var import_node_child_process14 = require("node:child_process");
 var import_neverthrow115 = __toESM(require_index_cjs(), 1);
+var import_node_child_process14 = require("node:child_process");
+var import_neverthrow116 = __toESM(require_index_cjs(), 1);
 var import_node_child_process15 = require("node:child_process");
 var import_node_fs19 = require("node:fs");
-var import_neverthrow116 = __toESM(require_index_cjs(), 1);
 var import_neverthrow117 = __toESM(require_index_cjs(), 1);
+var import_neverthrow118 = __toESM(require_index_cjs(), 1);
 var import_node_fs20 = require("node:fs");
 var import_node_path43 = __toESM(require("node:path"), 1);
-var import_neverthrow118 = __toESM(require_index_cjs(), 1);
 var import_neverthrow119 = __toESM(require_index_cjs(), 1);
 var import_neverthrow120 = __toESM(require_index_cjs(), 1);
+var import_neverthrow121 = __toESM(require_index_cjs(), 1);
 var __defProp2 = Object.defineProperty;
 var __export2 = (target, all) => {
   for (var name in all)
@@ -170205,9 +170466,9 @@ function isValidAnchorId(id) {
 }
 function buildAnchor(input) {
   if (!isValidAnchorId(input.id)) {
-    return (0, import_neverthrow108.err)({ type: "INVALID_ANCHOR_ID", id: input.id });
+    return (0, import_neverthrow109.err)({ type: "INVALID_ANCHOR_ID", id: input.id });
   }
-  return (0, import_neverthrow108.ok)({
+  return (0, import_neverthrow109.ok)({
     start: `<!-- xqa:${input.kind}:${input.id}:start -->`,
     end: `<!-- xqa:${input.kind}:${input.id}:end -->`
   });
@@ -170256,7 +170517,7 @@ function suiteLabel(items) {
 }
 var MS_PER_SECOND7 = 1e3;
 function totalDurationSeconds(items) {
-  const ms = items.reduce((sum, item) => sum + item.durationMs, 0);
+  const ms = items.reduce((sum2, item) => sum2 + item.durationMs, 0);
   return Math.round(ms / MS_PER_SECOND7);
 }
 function metaLine(input) {
@@ -170270,7 +170531,7 @@ function buildCleanSuiteBody(input) {
   const markdown = `${header2}
 
 ${metaLine(input)}`;
-  return (0, import_neverthrow109.ok)({ markdown, truncated: [] });
+  return (0, import_neverthrow110.ok)({ markdown, truncated: [] });
 }
 var THUMBNAIL_WIDTH_PX = 180;
 var HTTPS_PREFIX = "https://";
@@ -170321,10 +170582,10 @@ function passCount(items) {
   return items.filter((item) => item.status === "completed" && item.findings.length === 0).length;
 }
 function findingsTotal(items) {
-  return items.reduce((sum, item) => sum + item.findings.length, 0);
+  return items.reduce((sum2, item) => sum2 + item.findings.length, 0);
 }
 function totalDurationSeconds2(items) {
-  return Math.round(items.reduce((sum, item) => sum + item.durationMs, 0) / MS_PER_SECOND24);
+  return Math.round(items.reduce((sum2, item) => sum2 + item.durationMs, 0) / MS_PER_SECOND24);
 }
 function itemNeedsBody(item) {
   if (item.status !== "completed") {
@@ -170475,7 +170736,7 @@ function buildSuiteBodyWithOverflow(input) {
   const initialRendered = new Map(initialEntries);
   const initialParts = partsFor({ headerString, blocks, renderedById: initialRendered });
   if (totalSize(initialParts) <= input.maxBodyBytes) {
-    return (0, import_neverthrow110.ok)({ markdown: initialParts.join("\n\n"), truncated: [] });
+    return (0, import_neverthrow111.ok)({ markdown: initialParts.join("\n\n"), truncated: [] });
   }
   const final = findFittingState({
     headerString,
@@ -170487,9 +170748,9 @@ function buildSuiteBodyWithOverflow(input) {
   const finalParts = partsFor({ headerString, blocks, renderedById: final.renderedById });
   const finalSize = totalSize(finalParts);
   if (finalSize > input.maxBodyBytes) {
-    return (0, import_neverthrow110.err)({ type: "BODY_TOO_LARGE", size: finalSize, max: input.maxBodyBytes });
+    return (0, import_neverthrow111.err)({ type: "BODY_TOO_LARGE", size: finalSize, max: input.maxBodyBytes });
   }
-  return (0, import_neverthrow110.ok)({ markdown: finalParts.join("\n\n"), truncated: final.truncated });
+  return (0, import_neverthrow111.ok)({ markdown: finalParts.join("\n\n"), truncated: final.truncated });
 }
 function isCleanSuite(suite) {
   return suite.items.every(
@@ -170683,7 +170944,7 @@ function listComments(reference) {
     issue_number: reference.context.prNumber,
     per_page: PAGE_SIZE
   });
-  return import_neverthrow111.ResultAsync.fromPromise(
+  return import_neverthrow112.ResultAsync.fromPromise(
     promise2,
     makeRedactedErrorFactory("COMMENT_FETCH_FAILED", reference.context.token)
   );
@@ -170695,7 +170956,7 @@ function createComment(payload) {
     issue_number: payload.reference.context.prNumber,
     body: payload.body
   });
-  return import_neverthrow111.ResultAsync.fromPromise(
+  return import_neverthrow112.ResultAsync.fromPromise(
     promise2,
     makeRedactedErrorFactory("COMMENT_WRITE_FAILED", payload.reference.context.token)
   ).map(({ data }) => ({ commentUrl: data.html_url }));
@@ -170707,7 +170968,7 @@ function updateComment(payload) {
     comment_id: payload.commentId,
     body: payload.body
   });
-  return import_neverthrow111.ResultAsync.fromPromise(
+  return import_neverthrow112.ResultAsync.fromPromise(
     promise2,
     makeRedactedErrorFactory("COMMENT_WRITE_FAILED", payload.reference.context.token)
   ).map(({ data }) => ({ commentUrl: data.html_url }));
@@ -170731,7 +170992,7 @@ function patchExistingAfterRace(reference, firstError) {
   return listComments(commentReference).andThen((retryComments) => {
     const after = findExistingXqaComment(retryComments);
     if (after === void 0) {
-      return (0, import_neverthrow111.errAsync)(firstError);
+      return (0, import_neverthrow112.errAsync)(firstError);
     }
     const body = mergeIntoExisting({
       existing: after,
@@ -170764,7 +171025,7 @@ function createWithRaceRetry(reference) {
   const body = buildNewBody(reference.anchor, reference.blockBody);
   return createComment({ reference: toCommentReference(reference), body }).orElse((firstError) => {
     if (!isDuplicateCommentError(firstError)) {
-      return (0, import_neverthrow111.errAsync)(firstError);
+      return (0, import_neverthrow112.errAsync)(firstError);
     }
     return patchExistingAfterRace(reference, firstError);
   });
@@ -170815,7 +171076,7 @@ var rootSchema = external_exports2.object({
 async function readUtf8(filePath) {
   return import_node_fs16.promises.readFile(filePath, "utf8");
 }
-var safeRead = import_neverthrow112.ResultAsync.fromThrowable(readUtf8, () => void 0);
+var safeRead = import_neverthrow113.ResultAsync.fromThrowable(readUtf8, () => void 0);
 function parseYaml(raw) {
   return jsYaml.load(raw) ?? {};
 }
@@ -170837,12 +171098,12 @@ function toResolved(parsed) {
 function validate(data) {
   const parsed = rootSchema.safeParse(data);
   if (parsed.success) {
-    return (0, import_neverthrow112.okAsync)(toResolved(parsed.data.report.github));
+    return (0, import_neverthrow113.okAsync)(toResolved(parsed.data.report.github));
   }
-  return (0, import_neverthrow112.errAsync)({ type: "CONFIG_LOAD_FAILED", cause: parsed.error });
+  return (0, import_neverthrow113.errAsync)({ type: "CONFIG_LOAD_FAILED", cause: parsed.error });
 }
 function loadReportConfig(options) {
-  return safeRead(options.configPath).map((raw) => parseYaml(raw)).orElse(() => (0, import_neverthrow112.okAsync)({})).andThen((data) => validate(data));
+  return safeRead(options.configPath).map((raw) => parseYaml(raw)).orElse(() => (0, import_neverthrow113.okAsync)({})).andThen((data) => validate(data));
 }
 var defaultDependencies2 = {
   putArtifact
@@ -170856,9 +171117,9 @@ async function statIsDirectory(directory) {
   const stat6 = await import_node_fs17.promises.stat(directory);
   return stat6.isDirectory();
 }
-var safeStatIsDirectory = (0, import_neverthrow113.fromAsyncThrowable)(statIsDirectory, () => void 0);
+var safeStatIsDirectory = (0, import_neverthrow114.fromAsyncThrowable)(statIsDirectory, () => void 0);
 function statDirectory(directory) {
-  return safeStatIsDirectory(directory).orElse(() => (0, import_neverthrow113.okAsync)(false));
+  return safeStatIsDirectory(directory).orElse(() => (0, import_neverthrow114.okAsync)(false));
 }
 function shouldSkipItem(item) {
   if (item.findings.length === 0) {
@@ -170902,7 +171163,7 @@ function selectReferencedFiles(arguments_) {
   return [...arguments_.files].filter((name) => referenced.has(name)).toSorted().map((name) => import_node_path42.default.join(arguments_.screenshotsDirectory, name));
 }
 function gatherFiles(arguments_) {
-  const safeReadDirectory2 = (0, import_neverthrow113.fromAsyncThrowable)(
+  const safeReadDirectory2 = (0, import_neverthrow114.fromAsyncThrowable)(
     readDirectoryEntries,
     toReadError(arguments_.itemId)
   );
@@ -170922,7 +171183,7 @@ function toUploadError2(error48) {
   return { type: "SCREENSHOT_UPLOAD_FAILED", reason: "BLOB_FAILURE", cause: error48.type };
 }
 function uploadFile(deps, arguments_) {
-  const safeRead3 = (0, import_neverthrow113.fromAsyncThrowable)(readBinary, toReadError(arguments_.itemId));
+  const safeRead3 = (0, import_neverthrow114.fromAsyncThrowable)(readBinary, toReadError(arguments_.itemId));
   return safeRead3(arguments_.filePath).andThen(
     (content) => deps.putArtifact({
       key: buildKey(arguments_),
@@ -170941,12 +171202,12 @@ function uploadFiles(deps, arguments_) {
       filePath
     }).map((result) => result.url)
   );
-  return import_neverthrow113.ResultAsync.combine(tasks);
+  return import_neverthrow114.ResultAsync.combine(tasks);
 }
 function uploadItemFiles(deps, arguments_) {
   const runId = deriveRunId(arguments_.item.findingsPath);
   if (!PATH_COMPONENT_REGEX.test(runId)) {
-    return (0, import_neverthrow113.errAsync)({ type: "SCREENSHOT_INVALID_PATH", component: "runId", value: runId });
+    return (0, import_neverthrow114.errAsync)({ type: "SCREENSHOT_INVALID_PATH", component: "runId", value: runId });
   }
   return gatherFiles({
     itemId: arguments_.item.id,
@@ -170961,7 +171222,7 @@ function uploadValidatedItem(deps, arguments_) {
   return statDirectory(screenshotsDirectory).andThen(
     (exists) => {
       if (!exists) {
-        return (0, import_neverthrow113.errAsync)({
+        return (0, import_neverthrow114.errAsync)({
           type: "SCREENSHOT_DIR_NOT_FOUND",
           itemId: arguments_.item.id,
           expected: screenshotsDirectory
@@ -170977,11 +171238,11 @@ function uploadValidatedItem(deps, arguments_) {
 }
 function processItem(deps, arguments_) {
   if (shouldSkipItem(arguments_.item)) {
-    return (0, import_neverthrow113.okAsync)({ id: arguments_.item.id, urls: [] });
+    return (0, import_neverthrow114.okAsync)({ id: arguments_.item.id, urls: [] });
   }
   const validationError = validatePathInputs(arguments_);
   if (validationError !== void 0) {
-    return (0, import_neverthrow113.errAsync)(validationError);
+    return (0, import_neverthrow114.errAsync)(validationError);
   }
   return uploadValidatedItem(deps, arguments_);
 }
@@ -170993,10 +171254,10 @@ function emptyUrlMap(items) {
 }
 function uploadScreenshots(input, dependencies = defaultDependencies2) {
   if (input.blobToken.length === 0) {
-    return (0, import_neverthrow113.okAsync)(emptyUrlMap(input.items));
+    return (0, import_neverthrow114.okAsync)(emptyUrlMap(input.items));
   }
   const tasks = input.items.map((item) => processItem(dependencies, { input, item }));
-  return import_neverthrow113.ResultAsync.combine(tasks).map((entries) => combineEntries(entries));
+  return import_neverthrow114.ResultAsync.combine(tasks).map((entries) => combineEntries(entries));
 }
 var DEFAULT_CONFIG_PATH = ".xqa/config.yaml";
 var KIND_HANDLERS = {
@@ -171081,13 +171342,13 @@ async function readEventFile(eventPath) {
   const number_ = data.pull_request?.number;
   return typeof number_ === "number" ? number_ : void 0;
 }
-var safeReadEventFile = (0, import_neverthrow114.fromAsyncThrowable)(readEventFile, () => void 0);
+var safeReadEventFile = (0, import_neverthrow115.fromAsyncThrowable)(readEventFile, () => void 0);
 function fromEventPath() {
   const eventPath = getGithubEventPathEnv();
   if (eventPath === void 0) {
-    return (0, import_neverthrow114.okAsync)(NO_PR);
+    return (0, import_neverthrow115.okAsync)(NO_PR);
   }
-  return safeReadEventFile(eventPath).orElse(() => (0, import_neverthrow114.okAsync)(NO_PR));
+  return safeReadEventFile(eventPath).orElse(() => (0, import_neverthrow115.okAsync)(NO_PR));
 }
 function fromReference() {
   const reference = getGithubReferenceEnv();
@@ -171111,12 +171372,12 @@ function filterCandidates(prs, context) {
 }
 function resolveFiltered(filtered) {
   if (filtered.length === 0) {
-    return (0, import_neverthrow114.okAsync)(NO_PR);
+    return (0, import_neverthrow115.okAsync)(NO_PR);
   }
   if (filtered.length === 1) {
-    return (0, import_neverthrow114.okAsync)(filtered[0]?.number);
+    return (0, import_neverthrow115.okAsync)(filtered[0]?.number);
   }
-  return (0, import_neverthrow114.errAsync)({
+  return (0, import_neverthrow115.errAsync)({
     type: "PR_AMBIGUOUS",
     candidates: filtered.map((candidate) => candidate.number)
   });
@@ -171130,7 +171391,7 @@ async function fetchAssociatedPrs(input, sha) {
   });
   return response.data;
 }
-var safeFetchAssociatedPrs = (0, import_neverthrow114.fromAsyncThrowable)(fetchAssociatedPrs, (cause) => cause);
+var safeFetchAssociatedPrs = (0, import_neverthrow115.fromAsyncThrowable)(fetchAssociatedPrs, (cause) => cause);
 function toFetchPrError(token) {
   return (cause) => {
     const safeCause = cause instanceof Error ? redactToken(cause, token) : void 0;
@@ -171144,7 +171405,7 @@ function fromAssocList(input) {
   const sha = getGithubShaEnv2();
   const repoFull = getGithubRepositoryEnv2();
   if (sha === void 0 || repoFull === void 0) {
-    return (0, import_neverthrow114.okAsync)(NO_PR);
+    return (0, import_neverthrow115.okAsync)(NO_PR);
   }
   return safeFetchAssociatedPrs(input, sha).mapErr(toFetchPrError(input.token)).andThen(
     (prs) => resolveFiltered(filterCandidates(prs, { expectedSha: sha, expectedRepo: repoFull }))
@@ -171176,7 +171437,7 @@ function toGhPrViewError(token) {
     return { type: "PR_NOT_RESOLVED", reason: "CANNOT_INFER", cause: safeCause };
   };
 }
-var safeReadGhPrView = (0, import_neverthrow114.fromAsyncThrowable)(readGhPrView, (cause) => cause);
+var safeReadGhPrView = (0, import_neverthrow115.fromAsyncThrowable)(readGhPrView, (cause) => cause);
 function parseGhPrView(stdout) {
   const data = JSON.parse(stdout);
   return typeof data.number === "number" ? data.number : void 0;
@@ -171186,13 +171447,13 @@ function fromGhPrView(token) {
 }
 function finalizeResolution(maybe, token) {
   if (maybe !== void 0) {
-    return (0, import_neverthrow114.okAsync)(maybe);
+    return (0, import_neverthrow115.okAsync)(maybe);
   }
   return fromGhPrView(token).andThen((ghResult) => {
     if (ghResult !== void 0) {
-      return (0, import_neverthrow114.okAsync)(ghResult);
+      return (0, import_neverthrow115.okAsync)(ghResult);
     }
-    return (0, import_neverthrow114.errAsync)({
+    return (0, import_neverthrow115.errAsync)({
       type: "PR_NOT_RESOLVED",
       reason: "NO_SOURCE"
     });
@@ -171201,18 +171462,18 @@ function finalizeResolution(maybe, token) {
 function resolveFromEnv(input) {
   return fromEventPath().andThen((eventPr) => {
     if (eventPr !== void 0) {
-      return (0, import_neverthrow114.okAsync)(eventPr);
+      return (0, import_neverthrow115.okAsync)(eventPr);
     }
     const referencePr = fromReference();
     if (referencePr !== void 0) {
-      return (0, import_neverthrow114.okAsync)(referencePr);
+      return (0, import_neverthrow115.okAsync)(referencePr);
     }
     return fromAssocList(input);
   });
 }
 function resolvePr(input) {
   if (input.explicitPr !== void 0) {
-    return (0, import_neverthrow114.okAsync)(input.explicitPr);
+    return (0, import_neverthrow115.okAsync)(input.explicitPr);
   }
   return resolveFromEnv(input).andThen((maybe) => finalizeResolution(maybe, input.token));
 }
@@ -171254,24 +171515,24 @@ async function readGitRemote() {
   });
   return promise2;
 }
-var safeReadGitRemote = (0, import_neverthrow115.fromAsyncThrowable)(
+var safeReadGitRemote = (0, import_neverthrow116.fromAsyncThrowable)(
   readGitRemote,
   () => ({ type: "REPO_NOT_RESOLVED" })
 );
 function resolveRepo(input) {
   if (input.owner !== void 0 && input.repo !== void 0) {
-    return (0, import_neverthrow115.okAsync)({ owner: input.owner, repo: input.repo });
+    return (0, import_neverthrow116.okAsync)({ owner: input.owner, repo: input.repo });
   }
   const env3 = fromEnv();
   if (env3 !== void 0) {
-    return (0, import_neverthrow115.okAsync)(env3);
+    return (0, import_neverthrow116.okAsync)(env3);
   }
   return safeReadGitRemote().andThen((stdout) => {
     const parsed = parseRemote(stdout);
     if (parsed === void 0) {
-      return (0, import_neverthrow115.errAsync)({ type: "REPO_NOT_RESOLVED" });
+      return (0, import_neverthrow116.errAsync)({ type: "REPO_NOT_RESOLVED" });
     }
-    return (0, import_neverthrow115.okAsync)(parsed);
+    return (0, import_neverthrow116.okAsync)(parsed);
   });
 }
 var TRAILING_WHITESPACE_REGEX = /\s+$/;
@@ -171282,7 +171543,7 @@ function trimTrailing(value) {
 async function readTokenFile(filePath) {
   return import_node_fs19.promises.readFile(filePath, "utf8");
 }
-var safeReadTokenFile = (0, import_neverthrow116.fromAsyncThrowable)(
+var safeReadTokenFile = (0, import_neverthrow117.fromAsyncThrowable)(
   readTokenFile,
   () => ({ type: "TOKEN_NOT_RESOLVED" })
 );
@@ -171297,7 +171558,7 @@ async function readGhAuthToken() {
   });
   return promise2;
 }
-var safeReadGhAuthToken = (0, import_neverthrow116.fromAsyncThrowable)(
+var safeReadGhAuthToken = (0, import_neverthrow117.fromAsyncThrowable)(
   readGhAuthToken,
   () => ({ type: "TOKEN_NOT_RESOLVED" })
 );
@@ -171312,11 +171573,11 @@ function resolveToken(input) {
   }
   if (input.token !== void 0) {
     emitDeprecation(input.onWarn);
-    return (0, import_neverthrow116.okAsync)(trimTrailing(input.token));
+    return (0, import_neverthrow117.okAsync)(trimTrailing(input.token));
   }
   const env3 = getGithubTokenEnv();
   if (env3 !== void 0 && env3.length > 0) {
-    return (0, import_neverthrow116.okAsync)(env3);
+    return (0, import_neverthrow117.okAsync)(env3);
   }
   return safeReadGhAuthToken().map((value) => trimTrailing(value));
 }
@@ -171341,14 +171602,14 @@ function listCurrentLabels(reference) {
     issue_number: reference.issueNumber,
     per_page: PAGE_SIZE2
   });
-  return import_neverthrow117.ResultAsync.fromPromise(
+  return import_neverthrow118.ResultAsync.fromPromise(
     promise2,
     makeRedactedErrorFactory("LABEL_APPLY_FAILED", reference.token)
   ).map((labels) => labels.map((label) => label.name));
 }
 function addLabels(reference, labels) {
   if (labels.length === 0) {
-    return (0, import_neverthrow117.okAsync)();
+    return (0, import_neverthrow118.okAsync)();
   }
   const promise2 = reference.client.rest.issues.addLabels({
     owner: reference.owner,
@@ -171356,7 +171617,7 @@ function addLabels(reference, labels) {
     issue_number: reference.issueNumber,
     labels: [...labels]
   });
-  return import_neverthrow117.ResultAsync.fromPromise(
+  return import_neverthrow118.ResultAsync.fromPromise(
     promise2,
     makeRedactedErrorFactory("LABEL_APPLY_FAILED", reference.token)
   );
@@ -171368,17 +171629,17 @@ function removeOne(reference, name) {
     issue_number: reference.issueNumber,
     name
   });
-  return import_neverthrow117.ResultAsync.fromPromise(
+  return import_neverthrow118.ResultAsync.fromPromise(
     promise2,
     makeRedactedErrorFactory("LABEL_APPLY_FAILED", reference.token)
   );
 }
 function removeLabels(reference, labels) {
   if (labels.length === 0) {
-    return (0, import_neverthrow117.okAsync)([]);
+    return (0, import_neverthrow118.okAsync)([]);
   }
   const removals = labels.map((name) => removeOne(reference, name));
-  return import_neverthrow117.ResultAsync.combine(removals);
+  return import_neverthrow118.ResultAsync.combine(removals);
 }
 function computeDiff(input, current) {
   if (input.removeStale === true) {
@@ -171416,29 +171677,29 @@ function looksLikePipeline(record2) {
 }
 function fromOverride(kindOverride) {
   if (kindOverride === "suite") {
-    return (0, import_neverthrow119.ok)(kindOverride);
+    return (0, import_neverthrow120.ok)(kindOverride);
   }
-  return (0, import_neverthrow119.err)({ type: "KIND_NOT_IMPLEMENTED", kind: kindOverride });
+  return (0, import_neverthrow120.err)({ type: "KIND_NOT_IMPLEMENTED", kind: kindOverride });
 }
 function fromExplicitField(explicit) {
   if (explicit === "suite") {
-    return (0, import_neverthrow119.ok)(explicit);
+    return (0, import_neverthrow120.ok)(explicit);
   }
-  return (0, import_neverthrow119.err)({ type: "KIND_NOT_IMPLEMENTED", kind: explicit });
+  return (0, import_neverthrow120.err)({ type: "KIND_NOT_IMPLEMENTED", kind: explicit });
 }
 function fromStructure(record2, path310) {
   const isSuite = looksLikeSuite(record2);
   const isPipeline = looksLikePipeline(record2);
   if (isSuite && isPipeline) {
-    return (0, import_neverthrow119.err)({ type: "INPUT_INVALID", path: path310, cause: "ambiguous shape" });
+    return (0, import_neverthrow120.err)({ type: "INPUT_INVALID", path: path310, cause: "ambiguous shape" });
   }
   if (isSuite) {
-    return (0, import_neverthrow119.ok)("suite");
+    return (0, import_neverthrow120.ok)("suite");
   }
   if (isPipeline) {
-    return (0, import_neverthrow119.err)({ type: "KIND_NOT_IMPLEMENTED", kind: "pipeline" });
+    return (0, import_neverthrow120.err)({ type: "KIND_NOT_IMPLEMENTED", kind: "pipeline" });
   }
-  return (0, import_neverthrow119.err)({ type: "INPUT_INVALID", path: path310, cause: "unknown shape" });
+  return (0, import_neverthrow120.err)({ type: "INPUT_INVALID", path: path310, cause: "unknown shape" });
 }
 function sniffKind(input) {
   const path310 = input.path ?? FALLBACK_PATH;
@@ -171446,7 +171707,7 @@ function sniffKind(input) {
     return fromOverride(input.kindOverride);
   }
   if (!isRecord(input.data)) {
-    return (0, import_neverthrow119.err)({ type: "INPUT_INVALID", path: path310, cause: "not an object" });
+    return (0, import_neverthrow120.err)({ type: "INPUT_INVALID", path: path310, cause: "not an object" });
   }
   const explicit = input.data.kind;
   if (typeof explicit === "string") {
@@ -171473,7 +171734,7 @@ function workspaceCheck(absolutePath) {
 async function lstatPath(filePath) {
   return import_node_fs20.promises.lstat(filePath);
 }
-var safeLstat = import_neverthrow118.ResultAsync.fromThrowable(
+var safeLstat = import_neverthrow119.ResultAsync.fromThrowable(
   lstatPath,
   (cause) => ({
     type: "INPUT_READ_FAILED",
@@ -171484,7 +171745,7 @@ var safeLstat = import_neverthrow118.ResultAsync.fromThrowable(
 async function readUtf82(filePath) {
   return import_node_fs20.promises.readFile(filePath, "utf8");
 }
-var safeRead2 = import_neverthrow118.ResultAsync.fromThrowable(
+var safeRead2 = import_neverthrow119.ResultAsync.fromThrowable(
   readUtf82,
   (cause) => ({
     type: "INPUT_READ_FAILED",
@@ -171492,7 +171753,7 @@ var safeRead2 = import_neverthrow118.ResultAsync.fromThrowable(
     cause
   })
 );
-var safeJsonParse8 = (0, import_neverthrow118.fromThrowable)(
+var safeJsonParse8 = (0, import_neverthrow119.fromThrowable)(
   (raw) => JSON.parse(raw),
   (cause) => ({
     type: "INPUT_INVALID",
@@ -171508,21 +171769,21 @@ function fixPath(error48, absolutePath) {
 }
 function checkStat(stat6, absolutePath) {
   if (stat6.isSymbolicLink()) {
-    return (0, import_neverthrow118.err)({
+    return (0, import_neverthrow119.err)({
       type: "INPUT_READ_FAILED",
       path: absolutePath,
       cause: "symlink not allowed"
     });
   }
   if (stat6.size > INPUT_MAX_BYTES) {
-    return (0, import_neverthrow118.err)({
+    return (0, import_neverthrow119.err)({
       type: "INPUT_TOO_LARGE",
       path: absolutePath,
       size: stat6.size,
       max: INPUT_MAX_BYTES
     });
   }
-  return (0, import_neverthrow118.ok)(stat6);
+  return (0, import_neverthrow119.ok)(stat6);
 }
 function buildSniffInput(arguments_) {
   if (arguments_.kindOverride === void 0) {
@@ -171551,15 +171812,15 @@ function buildArguments(input) {
 }
 function liftBuilt(built) {
   if (built.isErr()) {
-    return (0, import_neverthrow118.errAsync)(built.error);
+    return (0, import_neverthrow119.errAsync)(built.error);
   }
-  return (0, import_neverthrow118.okAsync)(built.value);
+  return (0, import_neverthrow119.okAsync)(built.value);
 }
 function readReportInput(options) {
   const absolutePath = import_node_path43.default.resolve(options.path);
   const workspaceError = workspaceCheck(absolutePath);
   if (workspaceError !== void 0) {
-    return (0, import_neverthrow118.errAsync)(workspaceError);
+    return (0, import_neverthrow119.errAsync)(workspaceError);
   }
   return safeLstat(absolutePath).mapErr((error48) => fixPath(error48, absolutePath)).andThen((stat6) => checkStat(stat6, absolutePath)).andThen(() => safeRead2(absolutePath).mapErr((error48) => fixPath(error48, absolutePath))).andThen(
     (raw) => liftBuilt(
@@ -171579,12 +171840,12 @@ function fetchLabel(reference) {
     name: reference.name
   });
   const toError = makeRedactedErrorFactory("LABEL_SYNC_FAILED", reference.token);
-  return import_neverthrow120.ResultAsync.fromPromise(promise2, (cause) => {
+  return import_neverthrow121.ResultAsync.fromPromise(promise2, (cause) => {
     if (isHttpStatus(cause, HTTP_NOT_FOUND)) {
       return "NOT_FOUND";
     }
     return toError(cause);
-  }).map((response) => ({ kind: "found", label: response.data })).orElse((error48) => error48 === "NOT_FOUND" ? (0, import_neverthrow120.okAsync)(MISSING_OUTCOME) : (0, import_neverthrow120.errAsync)(error48));
+  }).map((response) => ({ kind: "found", label: response.data })).orElse((error48) => error48 === "NOT_FOUND" ? (0, import_neverthrow121.okAsync)(MISSING_OUTCOME) : (0, import_neverthrow121.errAsync)(error48));
 }
 function isMatching(existing, spec) {
   const descriptionMatches = (existing.description ?? "") === (spec.description ?? "");
@@ -171604,7 +171865,7 @@ function createLabel(reference) {
     repo: reference.repo,
     ...payload
   });
-  return import_neverthrow120.ResultAsync.fromPromise(
+  return import_neverthrow121.ResultAsync.fromPromise(
     promise2,
     makeRedactedErrorFactory("LABEL_SYNC_FAILED", reference.token)
   ).map(() => "created");
@@ -171619,14 +171880,14 @@ function updateLabel(reference) {
     color: payload.color,
     ...payload.description === void 0 ? {} : { description: payload.description }
   });
-  return import_neverthrow120.ResultAsync.fromPromise(
+  return import_neverthrow121.ResultAsync.fromPromise(
     promise2,
     makeRedactedErrorFactory("LABEL_SYNC_FAILED", reference.token)
   ).map(() => "updated");
 }
 function reconcileExisting(reference, existing) {
   if (isMatching(existing, reference.spec)) {
-    return (0, import_neverthrow120.okAsync)("unchanged");
+    return (0, import_neverthrow121.okAsync)("unchanged");
   }
   return updateLabel(reference);
 }
@@ -171672,7 +171933,7 @@ function syncLabelSet(input) {
       (outcome) => [spec.name, outcome]
     )
   );
-  return import_neverthrow120.ResultAsync.combine(reconciliations).map((entries) => classifyOutcomes(entries));
+  return import_neverthrow121.ResultAsync.combine(reconciliations).map((entries) => classifyOutcomes(entries));
 }
 
 // src/commands/error-exit-mapping.ts
@@ -171979,20 +172240,20 @@ async function runWithContext2(options) {
 }
 
 // src/shell/resolve-commit-sha.ts
-var import_neverthrow121 = __toESM(require_index_cjs(), 1);
+var import_neverthrow122 = __toESM(require_index_cjs(), 1);
 function resolveCommitSha(input) {
   if (input.explicitSha !== void 0 && input.explicitSha.length > 0) {
-    return (0, import_neverthrow121.okAsync)(input.explicitSha);
+    return (0, import_neverthrow122.okAsync)(input.explicitSha);
   }
   const env3 = getGithubShaEnv();
   if (env3 !== void 0 && env3.length > 0) {
-    return (0, import_neverthrow121.okAsync)(env3);
+    return (0, import_neverthrow122.okAsync)(env3);
   }
-  return (0, import_neverthrow121.errAsync)({ type: "COMMIT_SHA_NOT_RESOLVED" });
+  return (0, import_neverthrow122.errAsync)({ type: "COMMIT_SHA_NOT_RESOLVED" });
 }
 
 // src/shell/resolve-report-links.ts
-var import_neverthrow122 = __toESM(require_index_cjs(), 1);
+var import_neverthrow123 = __toESM(require_index_cjs(), 1);
 var SHA_SHORT_LENGTH = 7;
 var SERVER_URL_PATTERN = /^https:\/\/[a-z0-9.-]+$/i;
 var REPOSITORY_PATTERN = /^[\w.-]+\/[\w.-]+$/;
@@ -172028,14 +172289,14 @@ function checkEnv() {
     reasons.push("NO_REPOSITORY");
   }
   if (!nonEmpty(runId) || !nonEmpty(serverUrl) || !nonEmpty(repository)) {
-    return (0, import_neverthrow122.err)(reasons);
+    return (0, import_neverthrow123.err)(reasons);
   }
   const env3 = { runId, serverUrl, repository };
   const formatReasons = collectFormatReasons(env3);
   if (formatReasons.length > 0) {
-    return (0, import_neverthrow122.err)(formatReasons);
+    return (0, import_neverthrow123.err)(formatReasons);
   }
-  return (0, import_neverthrow122.ok)(env3);
+  return (0, import_neverthrow123.ok)(env3);
 }
 function buildLinks(env3, commitSha) {
   return {
@@ -172242,7 +172503,7 @@ function registerReportCommand(program3) {
 // src/commands/review-command.ts
 var import_node_fs21 = require("node:fs");
 var import_node_path45 = __toESM(require("node:path"), 1);
-var import_neverthrow124 = __toESM(require_index_cjs(), 1);
+var import_neverthrow125 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/@inquirer+core@10.3.2_@types+node@22.19.15/node_modules/@inquirer/core/dist/esm/lib/key.js
 var isUpKey = (key, keybindings = []) => (
@@ -173582,7 +173843,7 @@ var import_child_process3 = require("child_process");
 var import_fs3 = require("fs");
 var import_node_path44 = __toESM(require("node:path"), 1);
 var import_node_os4 = __toESM(require("node:os"), 1);
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 var import_iconv_lite = __toESM(require_lib4(), 1);
 
 // ../../node_modules/.pnpm/@inquirer+external-editor@1.0.3_@types+node@22.19.15/node_modules/@inquirer/external-editor/dist/esm/errors/CreateFileError.js
@@ -173712,7 +173973,7 @@ var ExternalEditor = class {
   createTemporaryFile() {
     try {
       const baseDir = this.fileOptions.dir ?? import_node_os4.default.tmpdir();
-      const id = (0, import_node_crypto6.randomUUID)();
+      const id = (0, import_node_crypto7.randomUUID)();
       const prefix = sanitizeAffix(this.fileOptions.prefix);
       const postfix = sanitizeAffix(this.fileOptions.postfix);
       const filename = `${prefix}${id}${postfix}`;
@@ -174647,7 +174908,7 @@ var esm_default11 = createPrompt((config2, done) => {
 });
 
 // src/review-session.ts
-var import_neverthrow123 = __toESM(require_index_cjs(), 1);
+var import_neverthrow124 = __toESM(require_index_cjs(), 1);
 var FLOW_COL_WIDTH = 35;
 var TRIGGER_COL_WIDTH = 16;
 var CONFIDENCE_COL_WIDTH = 6;
@@ -174800,15 +175061,15 @@ async function runInteractiveLoop(findings, existing) {
   }
   return { staged: state.staged, undoneKeys: state.undoneKeys };
 }
-var safeRunInteractiveLoop = (0, import_neverthrow123.fromAsyncThrowable)(
+var safeRunInteractiveLoop = (0, import_neverthrow124.fromAsyncThrowable)(
   runInteractiveLoop,
   (error48) => error48 instanceof Error && error48.name === "ExitPromptError" ? "exit-prompt" : "unexpected"
 );
 
 // src/commands/review-command.ts
-var safeReadFile5 = (0, import_neverthrow124.fromThrowable)((filePath) => (0, import_node_fs21.readFileSync)(filePath, "utf8"));
-var safeParseJson4 = (0, import_neverthrow124.fromThrowable)(JSON.parse);
-var safeWrite = (0, import_neverthrow124.fromThrowable)((filePath, content) => {
+var safeReadFile5 = (0, import_neverthrow125.fromThrowable)((filePath) => (0, import_node_fs21.readFileSync)(filePath, "utf8"));
+var safeParseJson4 = (0, import_neverthrow125.fromThrowable)(JSON.parse);
+var safeWrite = (0, import_neverthrow125.fromThrowable)((filePath, content) => {
   (0, import_node_fs21.writeFileSync)(filePath, content);
 });
 function readLastPath(xqaDirectory) {
@@ -174825,13 +175086,13 @@ function isPipelineOutput(data) {
 function readFindings(filePath) {
   const readResult = safeReadFile5(filePath);
   if (readResult.isErr()) {
-    return (0, import_neverthrow124.err)("not-found");
+    return (0, import_neverthrow125.err)("not-found");
   }
   return safeParseJson4(readResult.value).mapErr(() => "invalid").andThen((data) => {
     if (!isPipelineOutput(data)) {
-      return (0, import_neverthrow124.err)("invalid");
+      return (0, import_neverthrow125.err)("invalid");
     }
-    return (0, import_neverthrow124.ok)(data);
+    return (0, import_neverthrow125.ok)(data);
   });
 }
 function loadExistingDismissals(filePath) {
@@ -174904,7 +175165,7 @@ function resolveAndReadFindings(findingsPath, xqaDirectory) {
       "No findings path provided and no last path found. Run: xqa review <findings-path>\n"
     );
     process.exit(1);
-    return (0, import_neverthrow124.err)();
+    return (0, import_neverthrow125.err)();
   }
   const resolvedPath = resolvedPathResult.value;
   const findingsResult = readFindings(resolvedPath);
@@ -174917,9 +175178,9 @@ function resolveAndReadFindings(findingsPath, xqaDirectory) {
 `);
     }
     process.exit(1);
-    return (0, import_neverthrow124.err)();
+    return (0, import_neverthrow125.err)();
   }
-  return (0, import_neverthrow124.ok)({ resolvedPath, output: findingsResult.value });
+  return (0, import_neverthrow125.ok)({ resolvedPath, output: findingsResult.value });
 }
 async function runReviewLoop({
   findings,
@@ -174992,11 +175253,11 @@ function discoverSimulators(udidOverride) {
 var import_promises37 = __toESM(require("node:fs/promises"), 1);
 var import_node_path46 = __toESM(require("node:path"), 1);
 var import_fast_glob = __toESM(require_out4(), 1);
-var import_neverthrow127 = __toESM(require_index_cjs(), 1);
+var import_neverthrow128 = __toESM(require_index_cjs(), 1);
 
 // src/suite/core/suite-config-parser.ts
-var import_neverthrow125 = __toESM(require_index_cjs(), 1);
 var import_neverthrow126 = __toESM(require_index_cjs(), 1);
+var import_neverthrow127 = __toESM(require_index_cjs(), 1);
 var RESERVED_HOOK_ENV_KEYS = [
   "XQA_SIM_UDID",
   "XQA_ITEM_ID",
@@ -175050,7 +175311,7 @@ var suiteConfigSchema = external_exports.object({
 }).refine((data) => data.specs.length > 0 || data.freestyle.length > 0, {
   message: "Suite must declare at least one spec or freestyle entry"
 });
-var safeJsonParse9 = (0, import_neverthrow125.fromThrowable)(
+var safeJsonParse9 = (0, import_neverthrow126.fromThrowable)(
   JSON.parse,
   (cause) => ({
     type: "INVALID_SUITE_CONFIG",
@@ -175086,16 +175347,16 @@ function parseSuiteConfig(raw) {
   return safeJsonParse9(raw).andThen((data) => {
     const parsed = suiteConfigSchema.safeParse(data);
     if (!parsed.success) {
-      return (0, import_neverthrow126.err)({ type: "INVALID_SUITE_CONFIG", cause: parsed.error });
+      return (0, import_neverthrow127.err)({ type: "INVALID_SUITE_CONFIG", cause: parsed.error });
     }
     const hooks = normalizeHooks(parsed.data.hooks);
     if (hooks === void 0) {
-      return (0, import_neverthrow126.ok)({
+      return (0, import_neverthrow127.ok)({
         specs: parsed.data.specs,
         freestyle: parsed.data.freestyle
       });
     }
-    return (0, import_neverthrow126.ok)({
+    return (0, import_neverthrow127.ok)({
       specs: parsed.data.specs,
       freestyle: parsed.data.freestyle,
       hooks
@@ -175143,7 +175404,7 @@ function buildFreestyleItems(entries) {
 }
 
 // src/suite/commands/run/resolve-work-items.ts
-var safeReadFile6 = import_neverthrow127.ResultAsync.fromThrowable(
+var safeReadFile6 = import_neverthrow128.ResultAsync.fromThrowable(
   async (filePath) => import_promises37.default.readFile(filePath, "utf8"),
   () => "READ_FAILED"
 );
@@ -175231,7 +175492,7 @@ async function resolveAndFilterItems(input) {
 }
 
 // src/suite/shell/worker-pool.ts
-var import_neverthrow130 = __toESM(require_index_cjs(), 1);
+var import_neverthrow131 = __toESM(require_index_cjs(), 1);
 
 // src/suite/core/priority-queue.ts
 var PriorityQueue = class {
@@ -175478,7 +175739,7 @@ function recordHookFailure(input) {
 }
 
 // src/suite/shell/hook-invoker.ts
-var import_neverthrow129 = __toESM(require_index_cjs(), 1);
+var import_neverthrow130 = __toESM(require_index_cjs(), 1);
 
 // src/suite/core/hook-env-builder.ts
 function buildReservedKeys(input) {
@@ -175505,7 +175766,7 @@ function buildHookEnv(input) {
 
 // src/suite/shell/hook-runner.ts
 var import_node_child_process16 = require("node:child_process");
-var import_neverthrow128 = __toESM(require_index_cjs(), 1);
+var import_neverthrow129 = __toESM(require_index_cjs(), 1);
 function makeDeferred() {
   const raw = Promise.withResolvers();
   return { promise: raw.promise, resolve: raw.resolve };
@@ -175535,7 +175796,7 @@ var HookRuntime = class {
     this.deferred = makeDeferred();
     this.onAbort = () => {
       this.child.kill("SIGTERM");
-      this.settle((0, import_neverthrow128.err)({ type: "HOOK_ABORTED" }));
+      this.settle((0, import_neverthrow129.err)({ type: "HOOK_ABORTED" }));
     };
   }
   async start() {
@@ -175560,20 +175821,20 @@ var HookRuntime = class {
   attachTimeout() {
     this.timeoutHandle = setTimeout(() => {
       this.child.kill("SIGTERM");
-      this.settle((0, import_neverthrow128.err)({ type: "HOOK_TIMEOUT", timeoutMs: this.timeoutMs }));
+      this.settle((0, import_neverthrow129.err)({ type: "HOOK_TIMEOUT", timeoutMs: this.timeoutMs }));
     }, this.timeoutMs);
   }
   attachChildListeners() {
     this.child.on("error", (cause) => {
-      this.settle((0, import_neverthrow128.err)({ type: "HOOK_SPAWN_FAILED", cause }));
+      this.settle((0, import_neverthrow129.err)({ type: "HOOK_SPAWN_FAILED", cause }));
     });
     this.child.on("exit", (code) => {
       if (code === 0) {
-        this.settle((0, import_neverthrow128.ok)());
+        this.settle((0, import_neverthrow129.ok)());
         return;
       }
       this.settle(
-        (0, import_neverthrow128.err)({
+        (0, import_neverthrow129.err)({
           type: "HOOK_EXIT_NONZERO",
           code: code ?? -1,
           stderr: this.stderrBuffer
@@ -175596,7 +175857,7 @@ var HookRuntime = class {
     this.signal.removeEventListener("abort", this.onAbort);
   }
 };
-var safeSpawn = import_neverthrow128.ResultAsync.fromThrowable(
+var safeSpawn = import_neverthrow129.ResultAsync.fromThrowable(
   spawnHook,
   (cause) => ({ type: "HOOK_SPAWN_FAILED", cause })
 );
@@ -175662,7 +175923,7 @@ function buildAttemptContext(input) {
 }
 function invokeHook(input) {
   const context = buildAttemptContext(input);
-  return import_neverthrow129.ResultAsync.fromSafePromise(runAllAttempts(context)).andThen((result) => result);
+  return import_neverthrow130.ResultAsync.fromSafePromise(runAllAttempts(context)).andThen((result) => result);
 }
 function isRetryableHookError(error48) {
   return RETRYABLE_HOOK_ERROR_TYPES.has(error48.type);
@@ -175670,7 +175931,7 @@ function isRetryableHookError(error48) {
 function maybeInvokeHook(input) {
   const { hook: hook2 } = input;
   if (hook2 === void 0) {
-    return (0, import_neverthrow129.okAsync)();
+    return (0, import_neverthrow130.okAsync)();
   }
   return invokeHook({ ...input, hook: hook2 });
 }
@@ -175765,7 +176026,7 @@ async function processItem2(workerContext, item) {
   workerContext.inFlight.delete(item.id);
   return failCount;
 }
-var safeProcessItem = import_neverthrow130.ResultAsync.fromThrowable(
+var safeProcessItem = import_neverthrow131.ResultAsync.fromThrowable(
   processItem2,
   (cause) => ({
     type: "PROCESS_ITEM_FAILED",
@@ -175815,7 +176076,7 @@ async function runAllWorkers(runContext) {
       fallbackUdid: config2.simulatorUdids[0] ?? ""
     });
   }
-  const totalFindings = results.reduce((sum, item) => sum + item.findings.length, 0);
+  const totalFindings = results.reduce((sum2, item) => sum2 + item.findings.length, 0);
   config2.observer({
     type: "SUITE_COMPLETED",
     totalItems: results.length,
@@ -175830,7 +176091,7 @@ function runWorkerPool(config2) {
   const results = [];
   const inFlight = /* @__PURE__ */ new Map();
   const suiteStartMs = Date.now();
-  const safeRun = import_neverthrow130.ResultAsync.fromThrowable(
+  const safeRun = import_neverthrow131.ResultAsync.fromThrowable(
     async () => runAllWorkers({ config: config2, queue, results, suiteStartMs, inFlight }),
     (cause) => ({ type: "WORKER_POOL_FAILED", cause })
   );
@@ -176016,8 +176277,8 @@ function buildSuiteFindings(input) {
 
 // src/suite/shell/spec-scenario-id-reader.ts
 var import_promises38 = require("node:fs/promises");
-var import_neverthrow131 = __toESM(require_index_cjs(), 1);
-var safeReadFile7 = import_neverthrow131.ResultAsync.fromThrowable(
+var import_neverthrow132 = __toESM(require_index_cjs(), 1);
+var safeReadFile7 = import_neverthrow132.ResultAsync.fromThrowable(
   async (filePath) => (0, import_promises38.readFile)(filePath, "utf8"),
   (cause) => ({ specPath: "", cause })
 );
@@ -176040,17 +176301,17 @@ function entriesToRecord(results) {
   const entries = [];
   for (const result of results) {
     if (result.isErr()) {
-      return (0, import_neverthrow131.err)(result.error);
+      return (0, import_neverthrow132.err)(result.error);
     }
     entries.push(result.value);
   }
-  return (0, import_neverthrow131.ok)(Object.fromEntries(entries));
+  return (0, import_neverthrow132.ok)(Object.fromEntries(entries));
 }
 function readScenarioIdsBySpecPaths(specPaths) {
   if (specPaths.length === 0) {
-    return import_neverthrow131.ResultAsync.fromSafePromise(Promise.resolve({}));
+    return import_neverthrow132.ResultAsync.fromSafePromise(Promise.resolve({}));
   }
-  const awaitAll = import_neverthrow131.ResultAsync.fromSafePromise(
+  const awaitAll = import_neverthrow132.ResultAsync.fromSafePromise(
     Promise.all(specPaths.map((specPath) => readOneSpecEntry(specPath)))
   );
   return awaitAll.andThen(entriesToRecord);
@@ -176059,7 +176320,7 @@ function readScenarioIdsBySpecPaths(specPaths) {
 // src/suite/shell/suite-findings-writer.ts
 var import_promises39 = __toESM(require("node:fs/promises"), 1);
 var import_node_path48 = __toESM(require("node:path"), 1);
-var import_neverthrow132 = __toESM(require_index_cjs(), 1);
+var import_neverthrow133 = __toESM(require_index_cjs(), 1);
 var INDENT_SPACES = 2;
 function writeSuiteFindings(findings, options) {
   const directory = import_node_path48.default.join(
@@ -176071,7 +176332,7 @@ function writeSuiteFindings(findings, options) {
   );
   const finalPath = import_node_path48.default.join(directory, "findings.json");
   const temporaryPath = `${finalPath}.tmp`;
-  const safeWriteAtomically = import_neverthrow132.ResultAsync.fromThrowable(
+  const safeWriteAtomically = import_neverthrow133.ResultAsync.fromThrowable(
     async () => {
       await import_promises39.default.mkdir(directory, { recursive: true });
       await import_promises39.default.writeFile(temporaryPath, JSON.stringify(findings, void 0, INDENT_SPACES));
@@ -176086,7 +176347,7 @@ function writeSuiteFindings(findings, options) {
 // src/suite/shell/suite-runs-writer.ts
 var import_promises40 = __toESM(require("node:fs/promises"), 1);
 var import_node_path49 = __toESM(require("node:path"), 1);
-var import_neverthrow133 = __toESM(require_index_cjs(), 1);
+var import_neverthrow134 = __toESM(require_index_cjs(), 1);
 var INDENT_SPACES2 = 2;
 var RUNS_FILENAME2 = "scenario-runs.json";
 function writeSuiteRuns(runsFile, options) {
@@ -176099,7 +176360,7 @@ function writeSuiteRuns(runsFile, options) {
   );
   const finalPath = import_node_path49.default.join(directory, RUNS_FILENAME2);
   const temporaryPath = `${finalPath}.tmp`;
-  const safeWriteAtomically = import_neverthrow133.ResultAsync.fromThrowable(
+  const safeWriteAtomically = import_neverthrow134.ResultAsync.fromThrowable(
     async () => {
       await import_promises40.default.mkdir(directory, { recursive: true });
       await import_promises40.default.writeFile(temporaryPath, JSON.stringify(runsFile, void 0, INDENT_SPACES2));
@@ -176154,7 +176415,7 @@ async function writeAndReport(input) {
 // src/suite/commands/suite-run-context.ts
 var import_promises41 = __toESM(require("node:fs/promises"), 1);
 var import_node_path50 = __toESM(require("node:path"), 1);
-var import_neverthrow134 = __toESM(require_index_cjs(), 1);
+var import_neverthrow135 = __toESM(require_index_cjs(), 1);
 
 // src/suite/core/run-id.ts
 var RUN_ID_PAD_LENGTH2 = 4;
@@ -176189,7 +176450,7 @@ function deriveSuiteId(input) {
 
 // src/suite/commands/suite-run-context.ts
 var ISO_DATE_LENGTH3 = 10;
-var safeReaddir3 = import_neverthrow134.ResultAsync.fromThrowable(
+var safeReaddir3 = import_neverthrow135.ResultAsync.fromThrowable(
   async (directoryPath) => {
     const entries = await import_promises41.default.readdir(directoryPath, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -176337,18 +176598,18 @@ async function runSuiteCommand(input) {
 }
 
 // src/suite/commands/validate-run-arguments.ts
-var import_neverthrow135 = __toESM(require_index_cjs(), 1);
+var import_neverthrow136 = __toESM(require_index_cjs(), 1);
 function validateRunArguments(options) {
   if (options.suite === void 0 && options.spec === void 0) {
-    return (0, import_neverthrow135.err)({ type: "MISSING_SUITE_OR_SPEC" });
+    return (0, import_neverthrow136.err)({ type: "MISSING_SUITE_OR_SPEC" });
   }
   if (options.suite !== void 0 && options.spec !== void 0) {
-    return (0, import_neverthrow135.err)({ type: "BOTH_SUITE_AND_SPEC" });
+    return (0, import_neverthrow136.err)({ type: "BOTH_SUITE_AND_SPEC" });
   }
   if (options.only !== void 0 && options.suite === void 0) {
-    return (0, import_neverthrow135.err)({ type: "ONLY_REQUIRES_SUITE" });
+    return (0, import_neverthrow136.err)({ type: "ONLY_REQUIRES_SUITE" });
   }
-  return (0, import_neverthrow135.ok)(
+  return (0, import_neverthrow136.ok)(
     options.suite === void 0 ? { type: "spec", globs: options.spec ?? [] } : { type: "suite", name: options.suite }
   );
 }
@@ -176492,13 +176753,13 @@ function deriveSpecSlug(specFilePath) {
 // src/commands/spec-resolver.ts
 var import_node_fs23 = require("node:fs");
 var import_node_path53 = __toESM(require("node:path"), 1);
-var import_neverthrow136 = __toESM(require_index_cjs(), 1);
-var safeReadFile8 = (0, import_neverthrow136.fromThrowable)((filePath) => (0, import_node_fs23.readFileSync)(filePath, "utf8"));
-var safeReaddir4 = (0, import_neverthrow136.fromThrowable)(
+var import_neverthrow137 = __toESM(require_index_cjs(), 1);
+var safeReadFile8 = (0, import_neverthrow137.fromThrowable)((filePath) => (0, import_node_fs23.readFileSync)(filePath, "utf8"));
+var safeReaddir4 = (0, import_neverthrow137.fromThrowable)(
   (directory) => (0, import_node_fs23.readdirSync)(directory, { recursive: true, encoding: "utf8" })
 );
 var CANCEL = "xqa:cancel";
-var safeSelect = import_neverthrow136.ResultAsync.fromThrowable(
+var safeSelect = import_neverthrow137.ResultAsync.fromThrowable(
   esm_default11,
   (error48) => error48 instanceof Error && error48.name === "ExitPromptError" ? "cancelled" : "failed"
 );
@@ -176635,10 +176896,10 @@ async function runSpecCommand(input, options) {
 var import_promises44 = __toESM(require("node:fs/promises"), 1);
 var import_node_path56 = __toESM(require("node:path"), 1);
 var import_fast_glob2 = __toESM(require_out4(), 1);
-var import_neverthrow142 = __toESM(require_index_cjs(), 1);
+var import_neverthrow143 = __toESM(require_index_cjs(), 1);
 
 // ../../agents/triager/dist/index.js
-var import_neverthrow137 = __toESM(require_index_cjs(), 1);
+var import_neverthrow138 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js
 var balanced = (a3, b2, str2) => {
@@ -178443,14 +178704,14 @@ minimatch.escape = escape2;
 minimatch.unescape = unescape2;
 
 // ../../agents/triager/dist/index.js
-var import_neverthrow138 = __toESM(require_index_cjs(), 1);
-var import_promises42 = require("node:fs/promises");
 var import_neverthrow139 = __toESM(require_index_cjs(), 1);
+var import_promises42 = require("node:fs/promises");
+var import_neverthrow140 = __toESM(require_index_cjs(), 1);
 var import_node_child_process17 = require("node:child_process");
 var import_promises43 = require("node:fs/promises");
 var import_node_path55 = __toESM(require("node:path"), 1);
-var import_neverthrow140 = __toESM(require_index_cjs(), 1);
 var import_neverthrow141 = __toESM(require_index_cjs(), 1);
+var import_neverthrow142 = __toESM(require_index_cjs(), 1);
 function resolveConfidence2(selected) {
   if (selected.some((pick2) => pick2.confidence === "HIGH")) {
     return "high";
@@ -179115,7 +179376,7 @@ async function drainMessages(runner, state) {
     }
   }
 }
-var safeDrainMessages = import_neverthrow138.ResultAsync.fromThrowable(
+var safeDrainMessages = import_neverthrow139.ResultAsync.fromThrowable(
   drainMessages,
   (cause) => ({ type: "AI_CALL_FAILED", cause })
 );
@@ -179141,25 +179402,25 @@ function finalizeRun(bootstrap) {
   const telemetry = buildTelemetry(bootstrap.telemetryInput, bootstrap.state);
   const error48 = resolveError(bootstrap.state);
   if (error48 !== void 0) {
-    return (0, import_neverthrow138.errAsync)(error48);
+    return (0, import_neverthrow139.errAsync)(error48);
   }
   const output = bootstrap.state.output;
   if (output === void 0) {
-    return (0, import_neverthrow138.errAsync)({ type: "AI_NO_FINAL_TOOL_CALL" });
+    return (0, import_neverthrow139.errAsync)({ type: "AI_NO_FINAL_TOOL_CALL" });
   }
   bootstrap.reportTelemetry(telemetry);
-  return (0, import_neverthrow138.okAsync)({ picks: output.picks, metaPr: output.metaPr, telemetry });
+  return (0, import_neverthrow139.okAsync)({ picks: output.picks, metaPr: output.metaPr, telemetry });
 }
 function launchQuery(input) {
-  const safeLaunch = (0, import_neverthrow138.fromThrowable)(
+  const safeLaunch = (0, import_neverthrow139.fromThrowable)(
     input.queryRunner,
     (cause) => ({ type: "AI_CALL_FAILED", cause })
   );
   const result = safeLaunch({ prompt: input.inputQueue, options: input.queryOptions });
   if (result.isErr()) {
-    return (0, import_neverthrow138.errAsync)(result.error);
+    return (0, import_neverthrow139.errAsync)(result.error);
   }
-  return (0, import_neverthrow138.okAsync)(result.value);
+  return (0, import_neverthrow139.okAsync)(result.value);
 }
 function runPipeline4(bootstrap) {
   return launchQuery({
@@ -179213,9 +179474,9 @@ var STATIC_ONLY_FIELDS = {
   freestyleByGroup: /* @__PURE__ */ new Map(),
   appIndex: [],
   handlers: {
-    readSpec: () => (0, import_neverthrow137.errAsync)({ type: "FILE_NOT_FOUND", path: "" }),
-    readAppSection: () => (0, import_neverthrow137.errAsync)({ type: "FILE_NOT_FOUND", path: "" }),
-    grepCodebase: () => (0, import_neverthrow137.errAsync)({ type: "FILE_NOT_FOUND", path: "" })
+    readSpec: () => (0, import_neverthrow138.errAsync)({ type: "FILE_NOT_FOUND", path: "" }),
+    readAppSection: () => (0, import_neverthrow138.errAsync)({ type: "FILE_NOT_FOUND", path: "" }),
+    grepCodebase: () => (0, import_neverthrow138.errAsync)({ type: "FILE_NOT_FOUND", path: "" })
   }
 };
 function resolveAiFields(config2) {
@@ -179336,15 +179597,15 @@ function runAiTiebreaker(context, staticPicks) {
 function runTriager(options) {
   const { groups, config: config2 } = options;
   if (groups.length === 0) {
-    return (0, import_neverthrow137.errAsync)({ type: "NO_GROUPS" });
+    return (0, import_neverthrow138.errAsync)({ type: "NO_GROUPS" });
   }
   if (config2?.useAi === true && config2.ai === void 0) {
-    return (0, import_neverthrow137.errAsync)({ type: "AI_CONFIG_MISSING" });
+    return (0, import_neverthrow138.errAsync)({ type: "AI_CONFIG_MISSING" });
   }
   const context = buildContext3(options);
   const staticPicks = scoreGroups(context.diff, context.groups);
   if (!context.useAi) {
-    return (0, import_neverthrow137.okAsync)(buildDecision({ picks: staticPicks, metaPr: false }));
+    return (0, import_neverthrow138.okAsync)(buildDecision({ picks: staticPicks, metaPr: false }));
   }
   return runAiTiebreaker(context, staticPicks);
 }
@@ -179405,9 +179666,9 @@ function parseSections(text) {
 function lookupSection(sections, screenName) {
   const section = sections.get(screenName);
   if (section === void 0) {
-    return (0, import_neverthrow139.errAsync)({ type: "SECTION_NOT_FOUND", screenName });
+    return (0, import_neverthrow140.errAsync)({ type: "SECTION_NOT_FOUND", screenName });
   }
-  return (0, import_neverthrow139.okAsync)(section);
+  return (0, import_neverthrow140.okAsync)(section);
 }
 async function readUtf8File(filePath) {
   return (0, import_promises42.readFile)(filePath, UTF8);
@@ -179415,7 +179676,7 @@ async function readUtf8File(filePath) {
 function createAppMdReader(options) {
   const filePath = options.path;
   let sectionCache;
-  const safeReadFile10 = import_neverthrow139.ResultAsync.fromThrowable(
+  const safeReadFile10 = import_neverthrow140.ResultAsync.fromThrowable(
     readUtf8File,
     (cause) => classifyReadError(cause, filePath)
   );
@@ -179533,15 +179794,15 @@ async function invokeRipgrep(options) {
   return runExecFile({ binary: binary2, arguments_, cwd });
 }
 function execRipgrepRaw(options) {
-  const safeExec = import_neverthrow140.ResultAsync.fromThrowable(invokeRipgrep, classifyRawExecError);
+  const safeExec = import_neverthrow141.ResultAsync.fromThrowable(invokeRipgrep, classifyRawExecError);
   return safeExec(options);
 }
 function handleExecResult(options) {
   return execRipgrepRaw(options).orElse((error48) => {
     if (error48.type === "GREP_FAILED" && error48.cause.code === RIPGREP_NO_MATCH_CODE) {
-      return (0, import_neverthrow140.ok)({ stdout: "", stderr: "" });
+      return (0, import_neverthrow141.ok)({ stdout: "", stderr: "" });
     }
-    return (0, import_neverthrow140.err)(error48);
+    return (0, import_neverthrow141.err)(error48);
   });
 }
 async function readUtf8File2(filePath) {
@@ -179550,7 +179811,7 @@ async function readUtf8File2(filePath) {
 function makeReadFile(cwd) {
   return (filePath) => {
     const resolvedPath = resolveFilePath(filePath, cwd);
-    const safeRead3 = import_neverthrow140.ResultAsync.fromThrowable(
+    const safeRead3 = import_neverthrow141.ResultAsync.fromThrowable(
       readUtf8File2,
       (cause) => classifyReadError2(cause, resolvedPath)
     );
@@ -179617,9 +179878,9 @@ function applyHeading(state, screenName) {
 function handleHeading(state, indexed) {
   const screenName = indexed.text.slice(LEVEL_2_HEADING_MARKER.length).trim();
   if (screenName.length === 0) {
-    return (0, import_neverthrow141.err)({ type: "APP_MD_MALFORMED", line: indexed.number });
+    return (0, import_neverthrow142.err)({ type: "APP_MD_MALFORMED", line: indexed.number });
   }
-  return (0, import_neverthrow141.ok)(applyHeading(state, screenName));
+  return (0, import_neverthrow142.ok)(applyHeading(state, screenName));
 }
 function handleFenceLine(state, lineNumber) {
   if (state.insideFence) {
@@ -179653,23 +179914,23 @@ function isLevel2Heading(line) {
 }
 function processLine2(state, indexed) {
   if (indexed.text.startsWith(FENCE_MARKER)) {
-    return (0, import_neverthrow141.ok)(handleFenceLine(state, indexed.number));
+    return (0, import_neverthrow142.ok)(handleFenceLine(state, indexed.number));
   }
   if (state.insideFence) {
-    return (0, import_neverthrow141.ok)(state);
+    return (0, import_neverthrow142.ok)(state);
   }
   if (isLevel2Heading(indexed.text)) {
     return handleHeading(state, indexed);
   }
   if (indexed.text.trim().length === 0) {
-    return (0, import_neverthrow141.ok)(handleBlankLine(state));
+    return (0, import_neverthrow142.ok)(handleBlankLine(state));
   }
-  return (0, import_neverthrow141.ok)(handleContentLine(state, indexed.text));
+  return (0, import_neverthrow142.ok)(handleContentLine(state, indexed.text));
 }
 function processIndexedLines(indexedLines, state) {
   const [head, ...tail] = indexedLines;
   if (head === void 0) {
-    return (0, import_neverthrow141.ok)(state);
+    return (0, import_neverthrow142.ok)(state);
   }
   return processLine2(state, head).andThen((next) => processIndexedLines(tail, next));
 }
@@ -179681,9 +179942,9 @@ function buildFinalEntries(state) {
 }
 function finaliseState(state) {
   if (state.insideFence) {
-    return (0, import_neverthrow141.err)({ type: "APP_MD_MALFORMED", line: state.fenceOpenLine });
+    return (0, import_neverthrow142.err)({ type: "APP_MD_MALFORMED", line: state.fenceOpenLine });
   }
-  return (0, import_neverthrow141.ok)([...buildFinalEntries(state)]);
+  return (0, import_neverthrow142.ok)([...buildFinalEntries(state)]);
 }
 function buildAppIndex(appMd) {
   const indexedLines = toIndexedLines(appMd.split("\n"));
@@ -179761,11 +180022,11 @@ var rootConfigSchema = external_exports.object({
 var DEFAULT_SPECS_DIR = ".xqa/specs";
 var SPEC_GLOB_SUFFIX = "**/*.test.md";
 var GLOB_CHARS = /[*?{}[\]!]/;
-var safeReadFile9 = import_neverthrow142.ResultAsync.fromThrowable(
+var safeReadFile9 = import_neverthrow143.ResultAsync.fromThrowable(
   async (filePath) => import_promises44.default.readFile(filePath, "utf8"),
   (cause) => ({ type: "READ_FAILED", cause })
 );
-var safeStat3 = import_neverthrow142.ResultAsync.fromThrowable(
+var safeStat3 = import_neverthrow143.ResultAsync.fromThrowable(
   async (filePath) => import_promises44.default.stat(filePath),
   (cause) => ({ type: "STAT_FAILED", cause })
 );
@@ -179994,11 +180255,11 @@ function registerSyncLabelsCommand(program3, loader2) {
 }
 
 // src/commands/triage-command.ts
-var import_neverthrow146 = __toESM(require_index_cjs(), 1);
+var import_neverthrow147 = __toESM(require_index_cjs(), 1);
 
 // src/triage/ai-context-builder.ts
 var import_node_path57 = __toESM(require("node:path"), 1);
-var import_neverthrow143 = __toESM(require_index_cjs(), 1);
+var import_neverthrow144 = __toESM(require_index_cjs(), 1);
 var PROMPT_VERSION = "v1";
 var MAX_GREP_PATTERN_LENGTH = 200;
 var DENIED_SAMPLE_PATHS = [
@@ -180077,7 +180338,7 @@ function isDeniedGlob(pathGlob) {
   return normalized !== pathGlob && matchesDeniedSample(normalized);
 }
 function pathDenied(reason) {
-  return (0, import_neverthrow143.errAsync)({ type: "PATH_DENIED", reason });
+  return (0, import_neverthrow144.errAsync)({ type: "PATH_DENIED", reason });
 }
 function buildHandlers(cwd, validSpecIds) {
   const reader = createCodebaseReader({ cwd });
@@ -180110,13 +180371,13 @@ function loadAppIndex(appMdPath) {
   return appMdReader.readFile(appMdPath).mapErr(() => ({ type: "SPEC_NOT_FOUND", path: appMdPath })).andThen((content) => {
     const indexResult = buildAppIndex(content);
     if (indexResult.isErr()) {
-      return (0, import_neverthrow143.errAsync)({
+      return (0, import_neverthrow144.errAsync)({
         type: "SUITE_INVALID",
         path: appMdPath,
         cause: indexResult.error
       });
     }
-    return (0, import_neverthrow143.okAsync)(indexResult.value);
+    return (0, import_neverthrow144.okAsync)(indexResult.value);
   });
 }
 function collectSpecIds(specSummariesByGroup) {
@@ -180184,7 +180445,7 @@ function toXqaError(error48) {
 }
 
 // src/triage/github-pr-fetcher.ts
-var import_neverthrow144 = __toESM(require_index_cjs(), 1);
+var import_neverthrow145 = __toESM(require_index_cjs(), 1);
 var STATUS_MAP = {
   added: "added",
   modified: "modified",
@@ -180220,11 +180481,11 @@ async function runListFiles(octokit, options) {
     per_page: 100
   });
 }
-var safeGet = import_neverthrow144.ResultAsync.fromThrowable(
+var safeGet = import_neverthrow145.ResultAsync.fromThrowable(
   runPullRequestGet,
   (cause) => ({ type: "PR_FETCH_FAILED", cause })
 );
-var safeList = import_neverthrow144.ResultAsync.fromThrowable(
+var safeList = import_neverthrow145.ResultAsync.fromThrowable(
   runListFiles,
   (cause) => ({ type: "PR_FETCH_FAILED", cause })
 );
@@ -180238,7 +180499,7 @@ function toDiff(summary, files) {
 }
 function fetchPullRequestDiff(options) {
   const octokit = new Octokit2({ auth: options.token });
-  return import_neverthrow144.ResultAsync.combine([safeGet(octokit, options), safeList(octokit, options)]).map(
+  return import_neverthrow145.ResultAsync.combine([safeGet(octokit, options), safeList(octokit, options)]).map(
     ([summary, files]) => toDiff(summary, files)
   );
 }
@@ -180274,7 +180535,7 @@ function formatXqaLabels(decision) {
 // src/triage/suite-loader.ts
 var import_promises45 = require("node:fs/promises");
 var import_node_path58 = __toESM(require("node:path"), 1);
-var import_neverthrow145 = __toESM(require_index_cjs(), 1);
+var import_neverthrow146 = __toESM(require_index_cjs(), 1);
 var SUITE_FILE_SUFFIX2 = ".suite.json";
 var freestyleEntrySchema2 = external_exports.object({
   timeoutSeconds: external_exports.number().int().positive(),
@@ -180285,7 +180546,7 @@ var suiteFileSchema = external_exports.object({
   freestyle: external_exports.array(freestyleEntrySchema2).optional(),
   hooks: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 });
-var safeJsonParse10 = (0, import_neverthrow145.fromThrowable)(JSON.parse);
+var safeJsonParse10 = (0, import_neverthrow146.fromThrowable)(JSON.parse);
 async function runReadFile(filePath) {
   return (0, import_promises45.readFile)(filePath, "utf8");
 }
@@ -180296,28 +180557,28 @@ async function runReadDirectory(filePath) {
   return (0, import_promises45.readdir)(filePath);
 }
 function readSuiteFile(filePath) {
-  const safeRead3 = import_neverthrow145.ResultAsync.fromThrowable(
+  const safeRead3 = import_neverthrow146.ResultAsync.fromThrowable(
     runReadFile,
     (cause) => ({ type: "SUITE_READ_FAILED", path: filePath, cause })
   );
   return safeRead3(filePath);
 }
 function readSpecFile2(filePath) {
-  const safeRead3 = import_neverthrow145.ResultAsync.fromThrowable(
+  const safeRead3 = import_neverthrow146.ResultAsync.fromThrowable(
     runReadFile,
     () => ({ type: "SPEC_NOT_FOUND", path: filePath })
   );
   return safeRead3(filePath);
 }
 function statDirectory2(directory) {
-  const safeStat4 = import_neverthrow145.ResultAsync.fromThrowable(
+  const safeStat4 = import_neverthrow146.ResultAsync.fromThrowable(
     runStat,
     () => ({ type: "SUITE_DIR_MISSING", path: directory })
   );
   return safeStat4(directory);
 }
 function readDirectoryEntries2(directory) {
-  const safeReadDirectory2 = import_neverthrow145.ResultAsync.fromThrowable(
+  const safeReadDirectory2 = import_neverthrow146.ResultAsync.fromThrowable(
     runReadDirectory,
     (cause) => ({ type: "SUITE_READ_FAILED", path: directory, cause })
   );
@@ -180326,7 +180587,7 @@ function readDirectoryEntries2(directory) {
 function listSuiteFiles(directory) {
   return statDirectory2(directory).andThen((stats) => {
     if (!stats.isDirectory()) {
-      return (0, import_neverthrow145.errAsync)({ type: "SUITE_DIR_MISSING", path: directory });
+      return (0, import_neverthrow146.errAsync)({ type: "SUITE_DIR_MISSING", path: directory });
     }
     return readDirectoryEntries2(directory);
   }).map(
@@ -180336,13 +180597,13 @@ function listSuiteFiles(directory) {
 function parseSuiteFile(filePath, raw) {
   const parsed = safeJsonParse10(raw);
   if (parsed.isErr()) {
-    return (0, import_neverthrow145.err)({ type: "SUITE_INVALID", path: filePath, cause: parsed.error });
+    return (0, import_neverthrow146.err)({ type: "SUITE_INVALID", path: filePath, cause: parsed.error });
   }
   const validated = suiteFileSchema.safeParse(parsed.value);
   if (!validated.success) {
-    return (0, import_neverthrow145.err)({ type: "SUITE_INVALID", path: filePath, cause: validated.error });
+    return (0, import_neverthrow146.err)({ type: "SUITE_INVALID", path: filePath, cause: validated.error });
   }
-  return (0, import_neverthrow145.ok)(validated.data);
+  return (0, import_neverthrow146.ok)(validated.data);
 }
 function suiteIdFromPath(filePath) {
   const name = import_node_path58.default.basename(filePath);
@@ -180353,7 +180614,7 @@ function loadSpecReference(xqaDirectory, specPath) {
   return readSpecFile2(absolute).andThen((raw) => {
     const parsed = parseSpecShared(raw);
     if (parsed.isErr()) {
-      return (0, import_neverthrow145.err)({
+      return (0, import_neverthrow146.err)({
         type: "SPEC_FRONTMATTER_INVALID",
         path: absolute,
         cause: parsed.error
@@ -180361,16 +180622,16 @@ function loadSpecReference(xqaDirectory, specPath) {
     }
     const { feature, timeoutSeconds } = parsed.value.spec;
     if (timeoutSeconds === void 0) {
-      return (0, import_neverthrow145.ok)({ path: specPath, feature });
+      return (0, import_neverthrow146.ok)({ path: specPath, feature });
     }
-    return (0, import_neverthrow145.ok)({ path: specPath, feature, timeoutSeconds });
+    return (0, import_neverthrow146.ok)({ path: specPath, feature, timeoutSeconds });
   });
 }
 function loadSpecReferences(xqaDirectory, specs) {
   if (specs.length === 0) {
-    return (0, import_neverthrow145.okAsync)([]);
+    return (0, import_neverthrow146.okAsync)([]);
   }
-  return import_neverthrow145.ResultAsync.combine(specs.map((specPath) => loadSpecReference(xqaDirectory, specPath)));
+  return import_neverthrow146.ResultAsync.combine(specs.map((specPath) => loadSpecReference(xqaDirectory, specPath)));
 }
 function addSpecTokens(tokens, spec) {
   const stem = import_node_path58.default.basename(spec.path).replace(/\.test\.md$/u, "");
@@ -180449,9 +180710,9 @@ function loadXqaSuites(directory) {
   const xqaDirectory = import_node_path58.default.dirname(import_node_path58.default.resolve(directory));
   return listSuiteFiles(directory).andThen((files) => {
     if (files.length === 0) {
-      return (0, import_neverthrow145.okAsync)([]);
+      return (0, import_neverthrow146.okAsync)([]);
     }
-    return import_neverthrow145.ResultAsync.combine(files.map((file2) => loadSuite(file2, xqaDirectory)));
+    return import_neverthrow146.ResultAsync.combine(files.map((file2) => loadSuite(file2, xqaDirectory)));
   });
 }
 
@@ -180462,27 +180723,27 @@ function parseRepo(input) {
   const parts = input.split("/");
   const [owner, repo] = parts;
   if (parts.length !== 2 || owner === void 0 || owner === "" || repo === void 0 || repo === "") {
-    return (0, import_neverthrow146.err)({ type: "CLI_INVALID_ARG", message: `invalid --repo value: ${input}` });
+    return (0, import_neverthrow147.err)({ type: "CLI_INVALID_ARG", message: `invalid --repo value: ${input}` });
   }
-  return (0, import_neverthrow146.ok)({ owner, repo });
+  return (0, import_neverthrow147.ok)({ owner, repo });
 }
 function parsePrNumber3(input) {
   const parsed = Number.parseInt(input, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
-    return (0, import_neverthrow146.err)({ type: "CLI_INVALID_ARG", message: `invalid --pr value: ${input}` });
+    return (0, import_neverthrow147.err)({ type: "CLI_INVALID_ARG", message: `invalid --pr value: ${input}` });
   }
-  return (0, import_neverthrow146.ok)(parsed);
+  return (0, import_neverthrow147.ok)(parsed);
 }
 function parseCliInputs(options) {
   const repoResult = parseRepo(options.repo);
   if (repoResult.isErr()) {
-    return (0, import_neverthrow146.err)(repoResult.error);
+    return (0, import_neverthrow147.err)(repoResult.error);
   }
   const prResult = parsePrNumber3(options.pr);
   if (prResult.isErr()) {
-    return (0, import_neverthrow146.err)(prResult.error);
+    return (0, import_neverthrow147.err)(prResult.error);
   }
-  return (0, import_neverthrow146.ok)({
+  return (0, import_neverthrow147.ok)({
     owner: repoResult.value.owner,
     repo: repoResult.value.repo,
     prNumber: prResult.value
@@ -180490,23 +180751,23 @@ function parseCliInputs(options) {
 }
 function resolveGithubToken(context) {
   if (!context.rootConfig.agents.triager.enabled) {
-    return (0, import_neverthrow146.err)({ type: "TRIAGER_DISABLED" });
+    return (0, import_neverthrow147.err)({ type: "TRIAGER_DISABLED" });
   }
   if (context.config.GITHUB_TOKEN === void 0) {
-    return (0, import_neverthrow146.err)({ type: "CONFIG_MISSING", key: "GITHUB_TOKEN" });
+    return (0, import_neverthrow147.err)({ type: "CONFIG_MISSING", key: "GITHUB_TOKEN" });
   }
-  return (0, import_neverthrow146.ok)(context.config.GITHUB_TOKEN);
+  return (0, import_neverthrow147.ok)(context.config.GITHUB_TOKEN);
 }
 function buildPartialInputs(options, context) {
   const tokenResult = resolveGithubToken(context);
   if (tokenResult.isErr()) {
-    return (0, import_neverthrow146.err)(tokenResult.error);
+    return (0, import_neverthrow147.err)(tokenResult.error);
   }
   const parsed = parseCliInputs(options);
   if (parsed.isErr()) {
-    return (0, import_neverthrow146.err)(parsed.error);
+    return (0, import_neverthrow147.err)(parsed.error);
   }
-  return (0, import_neverthrow146.ok)({
+  return (0, import_neverthrow147.ok)({
     owner: parsed.value.owner,
     repo: parsed.value.repo,
     prNumber: parsed.value.prNumber,
@@ -180515,7 +180776,7 @@ function buildPartialInputs(options, context) {
 }
 function resolveSuitesDirectory2(options, context) {
   if (options.suitesDir !== void 0) {
-    return import_neverthrow146.ResultAsync.fromSafePromise(Promise.resolve(options.suitesDir));
+    return import_neverthrow147.ResultAsync.fromSafePromise(Promise.resolve(options.suitesDir));
   }
   const cwd = process.cwd();
   return resolveCatalog({
@@ -180552,7 +180813,7 @@ function callTriager(options) {
 }
 function maybeApplyLabels(inputs, labels) {
   if (!inputs.applyLabels || labels.length === 0) {
-    return import_neverthrow146.ResultAsync.fromSafePromise(Promise.resolve(labels));
+    return import_neverthrow147.ResultAsync.fromSafePromise(Promise.resolve(labels));
   }
   return applyTriageLabels({
     context: {
@@ -180565,7 +180826,7 @@ function maybeApplyLabels(inputs, labels) {
   }).map(() => labels).mapErr(toXqaError);
 }
 function runPipeline5(inputs) {
-  return import_neverthrow146.ResultAsync.combine([
+  return import_neverthrow147.ResultAsync.combine([
     loadXqaSuites(inputs.suitesDir),
     fetchPullRequestDiff({
       owner: inputs.owner,
@@ -180632,7 +180893,7 @@ function registerUpdateCommand(program3) {
 
 // src/pid-lock.ts
 var import_node_fs24 = require("node:fs");
-var import_neverthrow147 = __toESM(require_index_cjs(), 1);
+var import_neverthrow148 = __toESM(require_index_cjs(), 1);
 var PID_FILE = "/tmp/xqa.pid";
 var SIGINT_EXIT_CODE = 130;
 var SIGTERM_EXIT_CODE = 143;
@@ -180641,7 +180902,7 @@ var HARD_TIMEOUT_MS = 1e4;
 var cleanup = () => {
   (0, import_node_fs24.rmSync)(PID_FILE, { force: true });
 };
-var checkProcessRunning = (0, import_neverthrow147.fromThrowable)(
+var checkProcessRunning = (0, import_neverthrow148.fromThrowable)(
   (pid) => {
     process.kill(pid, 0);
     return true;
@@ -180708,16 +180969,16 @@ function acquireLock() {
 function loadCliContext(signal) {
   const configResult = loadConfig2();
   if (configResult.isErr()) {
-    return (0, import_neverthrow148.err)(configResult.error);
+    return (0, import_neverthrow149.err)(configResult.error);
   }
   const rootConfigResult = loadConfigSync({
     cwd: process.cwd(),
     schema: rootConfigSchema
   });
   if (rootConfigResult.isErr()) {
-    return (0, import_neverthrow148.err)(rootConfigResult.error);
+    return (0, import_neverthrow149.err)(rootConfigResult.error);
   }
-  return (0, import_neverthrow148.ok)({
+  return (0, import_neverthrow149.ok)({
     config: configResult.value,
     rootConfig: rootConfigResult.value,
     signal
@@ -180754,7 +181015,7 @@ function buildProgram(options) {
 
 // src/index.ts
 process.title = "xqa";
-var version2 = `${"8.0.0"}${false ? ` (dev build +${"c960939"})` : ""}`;
+var version2 = `${"8.2.0"}${false ? ` (dev build +${"36aae72"})` : ""}`;
 var program2 = buildProgram({ version: version2 });
 void program2.parseAsync(process.argv);
 /*! Bundled license information: