@exodus/xqa 1.17.0 → 2.0.0

package/dist/xqa.cjs

@@ -1621,9 +1621,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (fn) {
           this._exitCallback = fn;
         } else {
-          this._exitCallback = (err25) => {
-            if (err25.code !== "commander.executeSubCommandAsync") {
-              throw err25;
+          this._exitCallback = (err26) => {
+            if (err26.code !== "commander.executeSubCommandAsync") {
+              throw err26;
             } else {
             }
           };
@@ -1699,12 +1699,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
       _callParseArg(target, value, previous, invalidArgumentMessage) {
         try {
           return target.parseArg(value, previous);
-        } catch (err25) {
-          if (err25.code === "commander.invalidArgument") {
-            const message = `${invalidArgumentMessage} ${err25.message}`;
-            this.error(message, { exitCode: err25.exitCode, code: err25.code });
+        } catch (err26) {
+          if (err26.code === "commander.invalidArgument") {
+            const message = `${invalidArgumentMessage} ${err26.message}`;
+            this.error(message, { exitCode: err26.exitCode, code: err26.code });
           }
-          throw err25;
+          throw err26;
         }
       }
       /**
@@ -2293,14 +2293,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
             );
           }
         });
-        proc.on("error", (err25) => {
-          if (err25.code === "ENOENT") {
+        proc.on("error", (err26) => {
+          if (err26.code === "ENOENT") {
             this._checkForMissingExecutable(
               executableFile,
               executableDir,
               subcommand._name
             );
-          } else if (err25.code === "EACCES") {
+          } else if (err26.code === "EACCES") {
             throw new Error(`'${executableFile}' not executable`);
           }
           if (!exitCallback) {
@@ -2311,7 +2311,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
               "commander.executeSubCommandAsync",
               "(error)"
             );
-            wrappedError.nestedError = err25;
+            wrappedError.nestedError = err26;
             exitCallback(wrappedError);
           }
         });
@@ -3688,8 +3688,8 @@ var require_index_cjs = __commonJS({
           return new Ok(res.value);
         })));
       }
-      match(ok27, _err) {
-        return this._promise.then((res) => res.match(ok27, _err));
+      match(ok28, _err) {
+        return this._promise.then((res) => res.match(ok28, _err));
       }
       unwrapOr(t) {
         return this._promise.then((res) => res.unwrapOr(t));
@@ -3728,17 +3728,17 @@ var require_index_cjs = __commonJS({
     function okAsync10(value) {
       return new ResultAsync18(Promise.resolve(new Ok(value)));
     }
-    function errAsync10(err26) {
-      return new ResultAsync18(Promise.resolve(new Err(err26)));
+    function errAsync10(err27) {
+      return new ResultAsync18(Promise.resolve(new Err(err27)));
     }
     var fromPromise = ResultAsync18.fromPromise;
     var fromSafePromise2 = ResultAsync18.fromSafePromise;
     var fromAsyncThrowable10 = ResultAsync18.fromThrowable;
     var combineResultList = (resultList) => {
-      let acc = ok26([]);
+      let acc = ok27([]);
       for (const result of resultList) {
         if (result.isErr()) {
-          acc = err25(result.error);
+          acc = err26(result.error);
           break;
         } else {
           acc.map((list) => list.push(result.value));
@@ -3748,12 +3748,12 @@ var require_index_cjs = __commonJS({
     };
     var combineResultAsyncList = (asyncResultList) => ResultAsync18.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
     var combineResultListWithAllErrors = (resultList) => {
-      let acc = ok26([]);
+      let acc = ok27([]);
       for (const result of resultList) {
         if (result.isErr() && acc.isErr()) {
           acc.error.push(result.error);
         } else if (result.isErr() && acc.isOk()) {
-          acc = err25([result.error]);
+          acc = err26([result.error]);
         } else if (result.isOk() && acc.isOk()) {
           acc.value.push(result.value);
         }
@@ -3767,9 +3767,9 @@ var require_index_cjs = __commonJS({
         return (...args) => {
           try {
             const result = fn(...args);
-            return ok26(result);
+            return ok27(result);
           } catch (e3) {
-            return err25(errorFn ? errorFn(e3) : e3);
+            return err26(errorFn ? errorFn(e3) : e3);
           }
         };
       }
@@ -3783,11 +3783,11 @@ var require_index_cjs = __commonJS({
       }
       Result3.combineWithAllErrors = combineWithAllErrors;
     })(exports2.Result || (exports2.Result = {}));
-    function ok26(value) {
+    function ok27(value) {
       return new Ok(value);
     }
-    function err25(err26) {
-      return new Err(err26);
+    function err26(err27) {
+      return new Err(err27);
     }
     function safeTry(body) {
       const n3 = body().next();
@@ -3807,11 +3807,11 @@ var require_index_cjs = __commonJS({
         return !this.isOk();
       }
       map(f6) {
-        return ok26(f6(this.value));
+        return ok27(f6(this.value));
       }
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       mapErr(_f) {
-        return ok26(this.value);
+        return ok27(this.value);
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
       andThen(f6) {
@@ -3826,14 +3826,14 @@ var require_index_cjs = __commonJS({
           f6(this.value);
         } catch (e3) {
         }
-        return ok26(this.value);
+        return ok27(this.value);
       }
       orTee(_f) {
-        return ok26(this.value);
+        return ok27(this.value);
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
       orElse(_f) {
-        return ok26(this.value);
+        return ok27(this.value);
       }
       asyncAndThen(f6) {
         return f6(this.value);
@@ -3850,8 +3850,8 @@ var require_index_cjs = __commonJS({
         return this.value;
       }
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      match(ok27, _err) {
-        return ok27(this.value);
+      match(ok28, _err) {
+        return ok28(this.value);
       }
       safeUnwrap() {
         const value = this.value;
@@ -3882,27 +3882,27 @@ var require_index_cjs = __commonJS({
       }
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       map(_f) {
-        return err25(this.error);
+        return err26(this.error);
       }
       mapErr(f6) {
-        return err25(f6(this.error));
+        return err26(f6(this.error));
       }
       andThrough(_f) {
-        return err25(this.error);
+        return err26(this.error);
       }
       andTee(_f) {
-        return err25(this.error);
+        return err26(this.error);
       }
       orTee(f6) {
         try {
           f6(this.error);
         } catch (e3) {
         }
-        return err25(this.error);
+        return err26(this.error);
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
       andThen(_f) {
-        return err25(this.error);
+        return err26(this.error);
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
       orElse(f6) {
@@ -3922,13 +3922,13 @@ var require_index_cjs = __commonJS({
       unwrapOr(v2) {
         return v2;
       }
-      match(_ok, err26) {
-        return err26(this.error);
+      match(_ok, err27) {
+        return err27(this.error);
       }
       safeUnwrap() {
         const error48 = this.error;
         return (function* () {
-          yield err25(error48);
+          yield err26(error48);
           throw new Error("Do not use this generator out of `safeTry`");
         })();
       }
@@ -3948,13 +3948,13 @@ var require_index_cjs = __commonJS({
     exports2.Err = Err;
     exports2.Ok = Ok;
     exports2.ResultAsync = ResultAsync18;
-    exports2.err = err25;
+    exports2.err = err26;
     exports2.errAsync = errAsync10;
     exports2.fromAsyncThrowable = fromAsyncThrowable10;
     exports2.fromPromise = fromPromise;
     exports2.fromSafePromise = fromSafePromise2;
     exports2.fromThrowable = fromThrowable17;
-    exports2.ok = ok26;
+    exports2.ok = ok27;
     exports2.okAsync = okAsync10;
     exports2.safeTry = safeTry;
   }
@@ -11117,12 +11117,12 @@ var require_lib2 = __commonJS({
     var detectFile = (filepath, opts = {}) => new Promise((resolve, reject) => {
       let fd;
       const fs4 = (0, node_1.default)();
-      const handler2 = (err25, buffer) => {
+      const handler2 = (err26, buffer) => {
         if (fd) {
           fs4.closeSync(fd);
         }
-        if (err25) {
-          reject(err25);
+        if (err26) {
+          reject(err26);
         } else if (buffer) {
           resolve((0, exports2.detect)(buffer));
         } else {
@@ -11133,9 +11133,9 @@ var require_lib2 = __commonJS({
       if (sampleSize > 0) {
         fd = fs4.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs4.read(fd, sample, 0, sampleSize, opts.offset, (err25, bytesRead) => {
-          if (err25) {
-            handler2(err25, null);
+        fs4.read(fd, sample, 0, sampleSize, opts.offset, (err26, bytesRead) => {
+          if (err26) {
+            handler2(err26, null);
           } else {
             if (bytesRead < sampleSize) {
               sample = sample.subarray(0, bytesRead);
@@ -15059,8 +15059,8 @@ var require_kind_of = __commonJS({
         if (typeof val.length === "number" && typeof val.callee === "function") {
           return true;
         }
-      } catch (err25) {
-        if (err25.message.indexOf("callee") !== -1) {
+      } catch (err26) {
+        if (err26.message.indexOf("callee") !== -1) {
           return true;
         }
       }
@@ -16283,7 +16283,7 @@ var require_function = __commonJS({
           return false;
         }
         return true;
-      } catch (err25) {
+      } catch (err26) {
         return false;
       }
     }
@@ -18070,11 +18070,11 @@ var require_engines = __commonJS({
             str = "(function() {\nreturn " + str.trim() + ";\n}());";
           }
           return eval(str) || {};
-        } catch (err25) {
-          if (wrap !== false && /(unexpected|identifier)/i.test(err25.message)) {
+        } catch (err26) {
+          if (wrap !== false && /(unexpected|identifier)/i.test(err26.message)) {
             return parse(str, options, false);
           }
-          throw new SyntaxError(err25);
+          throw new SyntaxError(err26);
         }
       },
       stringify: function() {
@@ -18636,9 +18636,9 @@ var require_main = __commonJS({
       options2.path = vaultPath;
       const result = DotenvModule.configDotenv(options2);
       if (!result.parsed) {
-        const err25 = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
-        err25.code = "MISSING_DATA";
-        throw err25;
+        const err26 = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err26.code = "MISSING_DATA";
+        throw err26;
       }
       const keys = _dotenvKey(options2).split(",");
       const length = keys.length;
@@ -18681,30 +18681,30 @@ var require_main = __commonJS({
         uri = new URL(dotenvKey);
       } catch (error48) {
         if (error48.code === "ERR_INVALID_URL") {
-          const err25 = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
-          err25.code = "INVALID_DOTENV_KEY";
-          throw err25;
+          const err26 = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err26.code = "INVALID_DOTENV_KEY";
+          throw err26;
         }
         throw error48;
       }
       const key = uri.password;
       if (!key) {
-        const err25 = new Error("INVALID_DOTENV_KEY: Missing key part");
-        err25.code = "INVALID_DOTENV_KEY";
-        throw err25;
+        const err26 = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err26.code = "INVALID_DOTENV_KEY";
+        throw err26;
       }
       const environment = uri.searchParams.get("environment");
       if (!environment) {
-        const err25 = new Error("INVALID_DOTENV_KEY: Missing environment part");
-        err25.code = "INVALID_DOTENV_KEY";
-        throw err25;
+        const err26 = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err26.code = "INVALID_DOTENV_KEY";
+        throw err26;
       }
       const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
       const ciphertext = result.parsed[environmentKey];
       if (!ciphertext) {
-        const err25 = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
-        err25.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
-        throw err25;
+        const err26 = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err26.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err26;
       }
       return { ciphertext, key };
     }
@@ -18834,13 +18834,13 @@ var require_main = __commonJS({
         const invalidKeyLength = error48.message === "Invalid key length";
         const decryptionFailed = error48.message === "Unsupported state or unable to authenticate data";
         if (isRange || invalidKeyLength) {
-          const err25 = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
-          err25.code = "INVALID_DOTENV_KEY";
-          throw err25;
+          const err26 = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err26.code = "INVALID_DOTENV_KEY";
+          throw err26;
         } else if (decryptionFailed) {
-          const err25 = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
-          err25.code = "DECRYPTION_FAILED";
-          throw err25;
+          const err26 = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err26.code = "DECRYPTION_FAILED";
+          throw err26;
         } else {
           throw error48;
         }
@@ -18850,9 +18850,9 @@ var require_main = __commonJS({
       const debug = Boolean(options2 && options2.debug);
       const override = Boolean(options2 && options2.override);
       if (typeof parsed !== "object") {
-        const err25 = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
-        err25.code = "OBJECT_REQUIRED";
-        throw err25;
+        const err26 = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err26.code = "OBJECT_REQUIRED";
+        throw err26;
       }
       for (const key of Object.keys(parsed)) {
         if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
@@ -21993,8 +21993,8 @@ var require_picomatch = __commonJS({
       try {
         const opts = options2 || {};
         return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
-      } catch (err25) {
-        if (options2 && options2.debug === true) throw err25;
+      } catch (err26) {
+        if (options2 && options2.debug === true) throw err26;
         return /$^/;
       }
     };
@@ -22401,8 +22401,8 @@ var require_merge2 = __commonJS({
             }
             next();
           }
-          function onerror(err25) {
-            mergedStream.emit("error", err25);
+          function onerror(err26) {
+            mergedStream.emit("error", err26);
           }
           if (stream._readableState.endEmitted) {
             return next();
@@ -22766,8 +22766,8 @@ var require_out = __commonJS({
 var require_queue_microtask = __commonJS({
   "../../node_modules/.pnpm/queue-microtask@1.2.3/node_modules/queue-microtask/index.js"(exports2, module2) {
     var promise2;
-    module2.exports = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : global) : (cb2) => (promise2 || (promise2 = Promise.resolve())).then(cb2).catch((err25) => setTimeout(() => {
-      throw err25;
+    module2.exports = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : global) : (cb2) => (promise2 || (promise2 = Promise.resolve())).then(cb2).catch((err26) => setTimeout(() => {
+      throw err26;
     }, 0));
   }
 });
@@ -22788,32 +22788,32 @@ var require_run_parallel = __commonJS({
         results = {};
         pending = keys.length;
       }
-      function done(err25) {
+      function done(err26) {
         function end() {
-          if (cb2) cb2(err25, results);
+          if (cb2) cb2(err26, results);
           cb2 = null;
         }
         if (isSync) queueMicrotask2(end);
         else end();
       }
-      function each(i3, err25, result) {
+      function each(i3, err26, result) {
         results[i3] = result;
-        if (--pending === 0 || err25) {
-          done(err25);
+        if (--pending === 0 || err26) {
+          done(err26);
         }
       }
       if (!pending) {
         done(null);
       } else if (keys) {
         keys.forEach(function(key) {
-          tasks[key](function(err25, result) {
-            each(key, err25, result);
+          tasks[key](function(err26, result) {
+            each(key, err26, result);
           });
         });
       } else {
         tasks.forEach(function(task, i3) {
-          task(function(err25, result) {
-            each(i3, err25, result);
+          task(function(err26, result) {
+            each(i3, err26, result);
           });
         });
       }
@@ -23385,16 +23385,16 @@ var require_queue = __commonJS({
       this.context = null;
       this.errorHandler = null;
       var self2 = this;
-      this.worked = function worked(err25, result) {
+      this.worked = function worked(err26, result) {
         var callback = self2.callback;
         var errorHandler = self2.errorHandler;
         var val = self2.value;
         self2.value = null;
         self2.callback = noop4;
         if (self2.errorHandler) {
-          errorHandler(err25, val);
+          errorHandler(err26, val);
         }
-        callback.call(self2.context, err25, result);
+        callback.call(self2.context, err26, result);
         self2.release(self2);
       };
     }
@@ -23418,9 +23418,9 @@ var require_queue = __commonJS({
       return queue;
       function push(value) {
         var p = new Promise(function(resolve, reject) {
-          pushCb(value, function(err25, result) {
-            if (err25) {
-              reject(err25);
+          pushCb(value, function(err26, result) {
+            if (err26) {
+              reject(err26);
               return;
             }
             resolve(result);
@@ -23431,9 +23431,9 @@ var require_queue = __commonJS({
       }
       function unshift(value) {
         var p = new Promise(function(resolve, reject) {
-          unshiftCb(value, function(err25, result) {
-            if (err25) {
-              reject(err25);
+          unshiftCb(value, function(err26, result) {
+            if (err26) {
+              reject(err26);
               return;
             }
             resolve(result);
@@ -24654,7 +24654,7 @@ var {
 } = import_index.default;
 
 // src/commands/analyse-command.ts
-var import_promises17 = require("node:fs/promises");
+var import_promises18 = require("node:fs/promises");
 
 // ../../packages/pipeline/dist/index.js
 var import_node_fs2 = require("node:fs");
@@ -27947,9 +27947,9 @@ var tq = k((oq) => {
 });
 var sq = k((aq) => {
   Object.defineProperty(aq, "__esModule", { value: true });
-  var ok26 = Q$(), tk = { keyword: "not", schemaType: ["object", "boolean"], trackErrors: true, code($) {
+  var ok27 = Q$(), tk = { keyword: "not", schemaType: ["object", "boolean"], trackErrors: true, code($) {
     let { gen: X, schema: J, it: Q } = $;
-    if ((0, ok26.alwaysValidSchema)(Q, J)) {
+    if ((0, ok27.alwaysValidSchema)(Q, J)) {
       $.fail();
       return;
     }
@@ -56400,6 +56400,24 @@ function createMobileIosServer(udid = "booted", extraTools = []) {
   });
 }
 
+// ../../packages/shared/dist/confidence.js
+var CONFIDENCE_LABELS = ["HIGH", "MEDIUM", "LOW"];
+var confidenceLabelSchema = external_exports.enum(CONFIDENCE_LABELS);
+var CONFIDENCE_ORDER = {
+  LOW: 0,
+  MEDIUM: 1,
+  HIGH: 2
+};
+function compareConfidence(left, right) {
+  return CONFIDENCE_ORDER[left] - CONFIDENCE_ORDER[right];
+}
+function maxConfidence(left, right) {
+  return compareConfidence(left, right) >= 0 ? left : right;
+}
+function meetsConfidenceThreshold(label, threshold) {
+  return compareConfidence(label, threshold) >= 0;
+}
+
 // ../../packages/shared/dist/finding-schema.js
 var findingSchema = external_exports.object({
   triggerType: external_exports.enum([
@@ -56420,12 +56438,15 @@ var findingSchema = external_exports.object({
   ]),
   flow: external_exports.string(),
   steps: external_exports.array(external_exports.string()),
-  confidence: external_exports.number(),
+  confidence: confidenceLabelSchema,
   description: external_exports.string(),
   screenshots: external_exports.array(external_exports.string()),
   agent: external_exports.string()
 });
 
+// ../../packages/shared/dist/finding-input-schema.js
+var findingInputSchema = findingSchema.omit({ agent: true, screenshots: true, confidence: true }).extend({ confidence: confidenceLabelSchema });
+
 // ../../packages/shared/dist/run-paths.js
 var import_node_path2 = __toESM(require("node:path"), 1);
 var import_neverthrow8 = __toESM(require_index_cjs(), 1);
@@ -56458,8 +56479,8 @@ function dismissalsPath(baseDirectory, override) {
 }
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow30 = __toESM(require_index_cjs(), 1);
-var import_promises15 = require("node:timers/promises");
+var import_neverthrow32 = __toESM(require_index_cjs(), 1);
+var import_promises16 = require("node:timers/promises");
 
 // ../../agents/analyser/dist/index.js
 var import_promises7 = require("node:fs/promises");
@@ -57424,6 +57445,47 @@ function formatMemoryElements(elements) {
     (element) => `${element.label} [${String(Math.round(element.confidence * PCT_MULTIPLIER))}%${element.phase === "after-scroll" ? "\u2193" : ""}]`
   ).join(", ");
 }
+function inspectorLabel(stepIndex, screenLabel) {
+  return `inspector: step ${String(stepIndex + 1)} (${screenLabel})`;
+}
+function inspectorFailLines(label, event) {
+  const desc = event.finding?.description ?? "unknown finding";
+  return [
+    { kind: "text", style: "error", text: `${label} \u2014 \u2716 ${desc}`, source: "inspector" },
+    { kind: "annotation", level: "warning", message: `${label} \u2014 ${desc}` }
+  ];
+}
+function normalizeInspectorStepStart(event) {
+  return [
+    {
+      kind: "text",
+      style: "default",
+      text: `inspector: analysing step ${String(event.stepIndex + 1)} (${event.screenLabel})`,
+      source: "inspector"
+    }
+  ];
+}
+function normalizeInspectorStep(event) {
+  const label = inspectorLabel(event.stepIndex, event.screenLabel);
+  switch (event.outcome) {
+    case "pass": {
+      return [
+        { kind: "text", style: "success", text: `${label} \u2014 matches design`, source: "inspector" }
+      ];
+    }
+    case "fail": {
+      return inspectorFailLines(label, event);
+    }
+    case "stale": {
+      return [
+        { kind: "text", style: "default", text: `${label} \u2014 stale artboard`, source: "inspector" }
+      ];
+    }
+    case "skip": {
+      return [{ kind: "text", style: "default", text: `${label} \u2014 skipped`, source: "inspector" }];
+    }
+  }
+}
 var HIDDEN_TOOL_ARGS = /* @__PURE__ */ new Set(["device"]);
 var SCREEN_PREVIEW_LENGTH = 80;
 var MS_PER_SECOND22 = 1e3;
@@ -57442,7 +57504,20 @@ function normalizeTimeoutGraceEntered(event) {
     {
       kind: "annotation",
       level: "warning",
-      message: `${event.agent}: soft deadline reached \u2014 ${String(seconds)}s grace period to emit findings`
+      message: `${event.agent}: soft deadline reached \u2014 ${String(seconds)}s grace period before interrupt`
+    }
+  ];
+}
+function normalizeFindingReported(event) {
+  const marker = `#${String(event.findingIndex + 1)} [${event.finding.triggerType}]`;
+  const header = `${event.agent}: finding ${marker} \u2014 ${event.finding.description}`;
+  return [
+    { kind: "text", style: "error", text: header },
+    { kind: "text", style: "dim", text: `  screenshot: ${event.screenshotPath}` },
+    {
+      kind: "annotation",
+      level: "warning",
+      message: `${event.agent} finding ${marker}`
     }
   ];
 }
@@ -57556,47 +57631,6 @@ function normalizeError(event) {
   }
   return lines;
 }
-function inspectorLabel(stepIndex, screenLabel) {
-  return `inspector: step ${String(stepIndex + 1)} (${screenLabel})`;
-}
-function normalizeInspectorStepStart(event) {
-  return [
-    {
-      kind: "text",
-      style: "default",
-      text: `inspector: analysing step ${String(event.stepIndex + 1)} (${event.screenLabel})`,
-      source: "inspector"
-    }
-  ];
-}
-function inspectorFailLines(label, event) {
-  const desc = event.finding?.description ?? "unknown finding";
-  return [
-    { kind: "text", style: "error", text: `${label} \u2014 \u2716 ${desc}`, source: "inspector" },
-    { kind: "annotation", level: "warning", message: `${label} \u2014 ${desc}` }
-  ];
-}
-function normalizeInspectorStep(event) {
-  const label = inspectorLabel(event.stepIndex, event.screenLabel);
-  switch (event.outcome) {
-    case "pass": {
-      return [
-        { kind: "text", style: "success", text: `${label} \u2014 matches design`, source: "inspector" }
-      ];
-    }
-    case "fail": {
-      return inspectorFailLines(label, event);
-    }
-    case "stale": {
-      return [
-        { kind: "text", style: "default", text: `${label} \u2014 stale artboard`, source: "inspector" }
-      ];
-    }
-    case "skip": {
-      return [{ kind: "text", style: "default", text: `${label} \u2014 skipped`, source: "inspector" }];
-    }
-  }
-}
 var HANDLERS2 = {
   STAGE_START: (event) => normalizeStageStart(event),
   STAGE_END: (event) => normalizeStageEnd(event),
@@ -57615,7 +57649,8 @@ var HANDLERS2 = {
   INSPECTOR_STEP_START: (event) => normalizeInspectorStepStart(event),
   INSPECTOR_STEP: (event) => normalizeInspectorStep(event),
   TIMEOUT_GRACE_ENTERED: (event) => normalizeTimeoutGraceEntered(event),
-  VISUAL_STEP: () => []
+  VISUAL_STEP: () => [],
+  FINDING_REPORTED: (event) => normalizeFindingReported(event)
 };
 function normalizeAgentEvent(event, verbose) {
   return HANDLERS2[event.type](event, verbose);
@@ -58361,15 +58396,15 @@ async function makeRequest(url2, fetchOptions, fetchFn = fetch) {
   return response;
 }
 function handleResponseError(e3, url2) {
-  let err25 = e3;
-  if (err25.name === "AbortError") {
-    err25 = new GoogleGenerativeAIAbortError(`Request aborted when fetching ${url2.toString()}: ${e3.message}`);
-    err25.stack = e3.stack;
+  let err26 = e3;
+  if (err26.name === "AbortError") {
+    err26 = new GoogleGenerativeAIAbortError(`Request aborted when fetching ${url2.toString()}: ${e3.message}`);
+    err26.stack = e3.stack;
   } else if (!(e3 instanceof GoogleGenerativeAIFetchError || e3 instanceof GoogleGenerativeAIRequestInputError)) {
-    err25 = new GoogleGenerativeAIError(`Error fetching from ${url2.toString()}: ${e3.message}`);
-    err25.stack = e3.stack;
+    err26 = new GoogleGenerativeAIError(`Error fetching from ${url2.toString()}: ${e3.message}`);
+    err26.stack = e3.stack;
   }
-  throw err25;
+  throw err26;
 }
 async function handleResponseNotOk(response, url2) {
   let message = "";
@@ -58616,14 +58651,14 @@ function getResponseStream(inputStream) {
           }
           return pump();
         }).catch((e3) => {
-          let err25 = e3;
-          err25.stack = e3.stack;
-          if (err25.name === "AbortError") {
-            err25 = new GoogleGenerativeAIAbortError("Request aborted when reading from the stream");
+          let err26 = e3;
+          err26.stack = e3.stack;
+          if (err26.name === "AbortError") {
+            err26 = new GoogleGenerativeAIAbortError("Request aborted when reading from the stream");
           } else {
-            err25 = new GoogleGenerativeAIError("Error reading from the stream");
+            err26 = new GoogleGenerativeAIError("Error reading from the stream");
           }
-          throw err25;
+          throw err26;
         });
       }
     }
@@ -59219,15 +59254,15 @@ async function makeRequest2(url2, fetchOptions, fetchFn = fetch) {
   return response;
 }
 function handleResponseError2(e3, url2) {
-  let err25 = e3;
-  if (err25.name === "AbortError") {
-    err25 = new GoogleGenerativeAIAbortError2(`Request aborted when fetching ${url2.toString()}: ${e3.message}`);
-    err25.stack = e3.stack;
+  let err26 = e3;
+  if (err26.name === "AbortError") {
+    err26 = new GoogleGenerativeAIAbortError2(`Request aborted when fetching ${url2.toString()}: ${e3.message}`);
+    err26.stack = e3.stack;
   } else if (!(e3 instanceof GoogleGenerativeAIFetchError2 || e3 instanceof GoogleGenerativeAIRequestInputError2)) {
-    err25 = new GoogleGenerativeAIError2(`Error fetching from ${url2.toString()}: ${e3.message}`);
-    err25.stack = e3.stack;
+    err26 = new GoogleGenerativeAIError2(`Error fetching from ${url2.toString()}: ${e3.message}`);
+    err26.stack = e3.stack;
   }
-  throw err25;
+  throw err26;
 }
 async function handleResponseNotOk2(response, url2) {
   let message = "";
@@ -59542,7 +59577,16 @@ var DynamicRetrievalMode2;
 var import_neverthrow11 = __toESM(require_index_cjs(), 1);
 var MAX_POLL_ATTEMPTS = 30;
 var POLL_INTERVAL_MS = 2e3;
-var findingsArraySchema = external_exports.array(findingSchema);
+var categoricalFindingSchema = external_exports.object({
+  triggerType: external_exports.string(),
+  flow: external_exports.string(),
+  steps: external_exports.array(external_exports.string()),
+  description: external_exports.string(),
+  confidence: external_exports.enum(["HIGH", "MEDIUM"]),
+  screenshots: external_exports.array(external_exports.string()),
+  agent: external_exports.string()
+});
+var categoricalFindingsArraySchema = external_exports.array(categoricalFindingSchema);
 var safeJsonParse2 = (0, import_neverthrow11.fromThrowable)(JSON.parse);
 var FINDINGS_RESPONSE_SCHEMA = {
   type: "array",
@@ -59561,12 +59605,12 @@ var FINDINGS_RESPONSE_SCHEMA = {
       },
       flow: { type: "string" },
       steps: { type: "array", items: { type: "string" } },
-      confidence: { type: "number" },
       description: { type: "string" },
+      confidence: { type: "string", format: "enum", enum: ["HIGH", "MEDIUM"] },
       screenshots: { type: "array", items: { type: "string" } },
       agent: { type: "string", format: "enum", enum: ["analyser"] }
     },
-    required: ["triggerType", "flow", "steps", "confidence", "description", "screenshots", "agent"]
+    required: ["triggerType", "flow", "steps", "description", "confidence", "screenshots", "agent"]
   }
 };
 function extractFileName(fileUri) {
@@ -59615,17 +59659,21 @@ function parseAnalysisResponse(text) {
     return (0, import_neverthrow11.err)({ type: "REQUEST_FAILED", cause: parseResult.error });
   }
   const raw = parseResult.value;
-  const validated = findingsArraySchema.safeParse(raw);
+  const validated = categoricalFindingsArraySchema.safeParse(raw);
   if (!validated.success) {
     return (0, import_neverthrow11.err)({ type: "SCHEMA_VALIDATION_FAILED", cause: validated.error });
   }
-  return (0, import_neverthrow11.ok)(validated.data);
+  const findings = validated.data.map((finding) => ({ ...finding }));
+  return (0, import_neverthrow11.ok)(findings);
 }
+var STEP_BY_STEP_DIRECTIVE = "Think step by step before calling set_output.";
 function buildGenerativeModel(apiKey, model) {
   const genAI = new GoogleGenerativeAI(apiKey);
   return genAI.getGenerativeModel({
     model,
+    systemInstruction: STEP_BY_STEP_DIRECTIVE,
     generationConfig: {
+      temperature: 0,
       responseMimeType: "application/json",
       responseSchema: FINDINGS_RESPONSE_SCHEMA
     }
@@ -59687,9 +59735,11 @@ var OUTPUT_FIELDS_SECTION = `For each finding:
 - \`triggerType\`: the category in parentheses from the section headings above
 - \`flow\`: name of the user flow from the snapshots (e.g. "send-funds", "onboarding")
 - \`steps\`: stepIndex values from the snapshots visible during or immediately before the issue
-- \`confidence\`: 0.8\u20131.0 for unambiguous issues; 0.5\u20130.8 for visible but possibly intentional; omit anything below 0.5
-- \`description\`: name the element, state what it was doing, and state how long or across how many steps the issue persisted
-- \`screenshots\`: the \`screenshotPath\` values from the matching snapshots as reference identifiers \u2014 or the stepIndex as a string if no path is present`;
+- \`description\`: name the element, state what it was doing, and state how long or across how many steps the issue persisted \u2014 write this first, before committing to a confidence label
+- \`confidence\`: HIGH for unambiguous regressions visible repeatedly with no plausible intentional cause; MEDIUM for issues that are visible but ambiguous (could be a deliberate design choice); LOW \u2014 do not include the finding at all, omit it entirely
+- \`screenshots\`: the \`screenshotPath\` values from the matching snapshots as reference identifiers \u2014 or the stepIndex as a string if no path is present
+
+Write the description first \u2014 justify what you saw and across how many steps \u2014 only then commit to a HIGH or MEDIUM label.`;
 function buildAnalyserPrompt(snapshots) {
   const snapshotHistory = JSON.stringify(snapshots, void 0, 2);
   return `You are a QA engineer watching a recorded mobile app session. Your task is to identify issues that can only be detected by watching the full video \u2014 things a static screenshot or accessibility tree cannot reveal.
@@ -59812,34 +59862,34 @@ var uuid42 = function() {
 };
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.87.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/errors.mjs
-function isAbortError(err25) {
-  return typeof err25 === "object" && err25 !== null && // Spec-compliant fetch implementations
-  ("name" in err25 && err25.name === "AbortError" || // Expo fetch
-  "message" in err25 && String(err25.message).includes("FetchRequestCanceledException"));
-}
-var castToError = (err25) => {
-  if (err25 instanceof Error)
-    return err25;
-  if (typeof err25 === "object" && err25 !== null) {
+function isAbortError(err26) {
+  return typeof err26 === "object" && err26 !== null && // Spec-compliant fetch implementations
+  ("name" in err26 && err26.name === "AbortError" || // Expo fetch
+  "message" in err26 && String(err26.message).includes("FetchRequestCanceledException"));
+}
+var castToError = (err26) => {
+  if (err26 instanceof Error)
+    return err26;
+  if (typeof err26 === "object" && err26 !== null) {
     try {
-      if (Object.prototype.toString.call(err25) === "[object Error]") {
-        const error48 = new Error(err25.message, err25.cause ? { cause: err25.cause } : {});
-        if (err25.stack)
-          error48.stack = err25.stack;
-        if (err25.cause && !error48.cause)
-          error48.cause = err25.cause;
-        if (err25.name)
-          error48.name = err25.name;
+      if (Object.prototype.toString.call(err26) === "[object Error]") {
+        const error48 = new Error(err26.message, err26.cause ? { cause: err26.cause } : {});
+        if (err26.stack)
+          error48.stack = err26.stack;
+        if (err26.cause && !error48.cause)
+          error48.cause = err26.cause;
+        if (err26.name)
+          error48.name = err26.name;
         return error48;
       }
     } catch {
     }
     try {
-      return new Error(JSON.stringify(err25));
+      return new Error(JSON.stringify(err26));
     } catch {
     }
   }
-  return new Error(err25);
+  return new Error(err26);
 };
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.87.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/core/error.mjs
@@ -59969,7 +60019,7 @@ var validatePositiveInteger = (name, n3) => {
 var safeJSON = (text) => {
   try {
     return JSON.parse(text);
-  } catch (err25) {
+  } catch (err26) {
     return void 0;
   }
 };
@@ -60533,8 +60583,8 @@ var Stream = class _Stream {
             return ctrl.close();
           const bytes = encodeUTF8(JSON.stringify(value) + "\n");
           ctrl.enqueue(bytes);
-        } catch (err25) {
-          ctrl.error(err25);
+        } catch (err26) {
+          ctrl.error(err26);
         }
       },
       async cancel() {
@@ -62441,8 +62491,8 @@ var BetaMessageStream = class _BetaMessageStream {
               if (jsonBuf) {
                 try {
                   newContent.input = partialParse(jsonBuf);
-                } catch (err25) {
-                  const error48 = new AnthropicError(`Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${err25}. JSON: ${jsonBuf}`);
+                } catch (err26) {
+                  const error48 = new AnthropicError(`Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${err26}. JSON: ${jsonBuf}`);
                   __classPrivateFieldGet(this, _BetaMessageStream_handleError, "f").call(this, error48);
                 }
               }
@@ -62504,17 +62554,17 @@ var BetaMessageStream = class _BetaMessageStream {
       }
       readQueue.length = 0;
     });
-    this.on("abort", (err25) => {
+    this.on("abort", (err26) => {
       done = true;
       for (const reader of readQueue) {
-        reader.reject(err25);
+        reader.reject(err26);
       }
       readQueue.length = 0;
     });
-    this.on("error", (err25) => {
+    this.on("error", (err26) => {
       done = true;
       for (const reader of readQueue) {
-        reader.reject(err25);
+        reader.reject(err26);
       }
       readQueue.length = 0;
     });
@@ -64757,17 +64807,17 @@ var MessageStream = class _MessageStream {
       }
       readQueue.length = 0;
     });
-    this.on("abort", (err25) => {
+    this.on("abort", (err26) => {
       done = true;
       for (const reader of readQueue) {
-        reader.reject(err25);
+        reader.reject(err26);
       }
       readQueue.length = 0;
     });
-    this.on("error", (err25) => {
+    this.on("error", (err26) => {
       done = true;
       for (const reader of readQueue) {
-        reader.reject(err25);
+        reader.reject(err26);
       }
       readQueue.length = 0;
     });
@@ -65347,7 +65397,7 @@ var BaseAnthropic = class {
       }
       const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
       loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
-      const errText = await response.text().catch((err26) => castToError(err26).message);
+      const errText = await response.text().catch((err27) => castToError(err27).message);
       const errJSON = safeJSON(errText);
       const errMessage = errJSON ? void 0 : errText;
       loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
@@ -65358,8 +65408,8 @@ var BaseAnthropic = class {
         message: errMessage,
         durationMs: Date.now() - startTime
       }));
-      const err25 = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
-      throw err25;
+      const err26 = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
+      throw err26;
     }
     loggerFor(this).info(responseInfo);
     loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({
@@ -65616,51 +65666,20 @@ function createOutputTools(schema2) {
     })
   };
 }
-function buildOutputServer(options2) {
-  return xx({
-    name: options2.serverName,
-    tools: [
-      _x(
-        "set_output",
-        "Report the final output when the task is complete. Call once at the end of the session.",
-        options2.shape,
-        async (input) => {
-          options2.store(input);
-          return await Promise.resolve({ content: [{ type: "text", text: "ok" }] });
-        }
-      )
-    ]
-  });
-}
-function createOutputTool(shape, options2) {
-  const serverName = options2?.serverName ?? "output";
-  const schema2 = external_exports.object(shape);
-  let current;
-  function store(input) {
-    const parsed = schema2.safeParse(input);
-    if (parsed.success) {
-      current = parsed.data;
-    }
-  }
-  return {
-    server: buildOutputServer({ serverName, shape, store }),
-    getOutput: () => current,
-    captureInput: store,
-    allowedToolNames: [`mcp__${serverName}__set_output`]
-  };
-}
 
 // ../../agents/consolidator/dist/index.js
 var import_neverthrow14 = __toESM(require_index_cjs(), 1);
+var import_neverthrow15 = __toESM(require_index_cjs(), 1);
 var MODEL = "claude-opus-4-6";
 var MAX_TOKENS = 4096;
-var dismissedFindingSchema = external_exports.object({
-  finding: findingSchema,
+var findingWithoutConfidenceSchema = findingSchema.omit({ confidence: true });
+var dismissedRawFindingSchema = external_exports.object({
+  finding: findingWithoutConfidenceSchema,
   reason: external_exports.string()
 });
-var consolidationResultSchema = external_exports.object({
-  findings: external_exports.array(findingSchema),
-  dismissed: external_exports.array(dismissedFindingSchema)
+var rawConsolidationOutputSchema = external_exports.object({
+  findings: external_exports.array(findingWithoutConfidenceSchema),
+  dismissed: external_exports.array(dismissedRawFindingSchema)
 });
 async function fetchMessage({
   client,
@@ -65690,7 +65709,10 @@ function processToolUseBlock(toolUseBlock, context) {
   });
   const result = context.factory.handleToolCall(toolUseBlock.name, toolUseBlock.input);
   if (result.isErr()) {
-    return (0, import_neverthrow14.err)({ type: "REQUEST_FAILED", cause: result.error });
+    return (0, import_neverthrow14.err)({
+      type: "REQUEST_FAILED",
+      cause: result.error
+    });
   }
   const output = context.factory.getOutput();
   if (output === void 0) {
@@ -65698,7 +65720,7 @@ function processToolUseBlock(toolUseBlock, context) {
   }
   return (0, import_neverthrow14.ok)(output);
 }
-function extractConsolidationResult(response, context) {
+function extractRawOutput(response, context) {
   emitThoughts(response, context.onEvent);
   const toolUseBlock = response.content.find(
     (block) => block.type === "tool_use" && block.name === "set_output"
@@ -65710,13 +65732,74 @@ function extractConsolidationResult(response, context) {
 }
 function consolidateFindings(prompt, onEvent) {
   const client = new Anthropic();
-  const factory = createOutputTools(consolidationResultSchema);
+  const factory = createOutputTools(rawConsolidationOutputSchema);
   const tools = [factory.tools[1]];
   return (0, import_neverthrow14.fromAsyncThrowable)(
     fetchMessage,
     (cause) => ({ type: "REQUEST_FAILED", cause })
   )({ client, prompt, tools }).andThen(
-    (response) => extractConsolidationResult(response, { factory, onEvent })
+    (response) => extractRawOutput(response, { factory, onEvent })
+  );
+}
+function normalizeKey(value) {
+  return value.toLowerCase().trim();
+}
+function findByKey(findings, key) {
+  const normalizedFlow = normalizeKey(key.flow);
+  const normalizedDescription = normalizeKey(key.description);
+  return findings.find(
+    (finding) => normalizeKey(finding.flow) === normalizedFlow && normalizeKey(finding.description) === normalizedDescription
+  );
+}
+function resolveConfidence(output, pool) {
+  const key = { flow: output.flow, description: output.description };
+  const metadataMatch = findByKey(pool.metadataFindings, key);
+  const visualMatch = findByKey(pool.visualFindings, key);
+  if (metadataMatch !== void 0 && visualMatch !== void 0) {
+    return (0, import_neverthrow15.ok)(maxConfidence(metadataMatch.confidence, visualMatch.confidence));
+  }
+  if (metadataMatch !== void 0) {
+    return (0, import_neverthrow15.ok)(metadataMatch.confidence);
+  }
+  if (visualMatch !== void 0) {
+    return (0, import_neverthrow15.ok)(visualMatch.confidence);
+  }
+  return (0, import_neverthrow15.err)({
+    type: "UNMATCHED_OUTPUT_FINDING",
+    flow: output.flow,
+    description: output.description
+  });
+}
+function attachConfidence(output, pool) {
+  return resolveConfidence(output, pool).map((confidence) => ({ ...output, confidence }));
+}
+function mergeFindings(outputs, state) {
+  if (outputs.length === 0) {
+    return (0, import_neverthrow15.ok)(state.accumulated);
+  }
+  const [head, ...tail] = outputs;
+  return attachConfidence(head, state.pool).andThen(
+    (finding) => mergeFindings(tail, { pool: state.pool, accumulated: [...state.accumulated, finding] })
+  );
+}
+function mergeDismissed(outputs, state) {
+  if (outputs.length === 0) {
+    return (0, import_neverthrow15.ok)(state.accumulated);
+  }
+  const [head, ...tail] = outputs;
+  return attachConfidence(head.finding, state.pool).andThen(
+    (finding) => mergeDismissed(tail, {
+      pool: state.pool,
+      accumulated: [...state.accumulated, { finding, reason: head.reason }]
+    })
+  );
+}
+function attachAllConfidences(raw, pool) {
+  return mergeFindings(raw.findings, { pool, accumulated: [] }).andThen(
+    (findings) => mergeDismissed(raw.dismissed, { pool, accumulated: [] }).map((dismissed) => ({
+      findings,
+      dismissed
+    }))
   );
 }
 function buildDismissalSection(dismissals) {
@@ -65736,14 +65819,14 @@ function buildRulesSection() {
   return `## Rules
 
 1. Merge findings that share the same \`flow\` AND describe the same failure (overlapping \`steps\` or matching \`description\` intent). Do NOT merge findings from different flows.
-2. When merging: set \`confidence\` to the higher of the two scores; on a tie, keep the metadata channel's score. Combine \`steps\` and \`screenshots\` from both findings into the merged output.
+2. When merging: combine \`steps\` and \`screenshots\` from both findings into the merged output. The system computes \`confidence\` after consolidation \u2014 do not emit it.
 3. Preserve unique findings unchanged.
 4. When uncertain if two findings are duplicates: keep both.
 5. Place a finding in \`dismissed\` only when it matches a dismissed entry on the same \`flow\` AND describes substantively the same failure (not just topically related). Copy the reason verbatim. When in doubt, keep it in \`findings\`.
 6. Every input finding MUST appear in exactly one of \`findings\` or \`dismissed\` \u2014 never both, never neither.
 
 CRITICAL: Call \`set_output\` exactly once when done. Do not reply in plain text.
-- \`findings\`: array of Finding objects \u2014 preserve all original fields (\`triggerType\`, \`flow\`, \`steps\`, \`confidence\`, \`description\`, \`screenshots\`, \`agent\`)
+- \`findings\`: array of Finding objects \u2014 preserve all original fields (\`triggerType\`, \`flow\`, \`steps\`, \`description\`, \`screenshots\`, \`agent\`)
 - \`dismissed\`: array of objects with shape \`{ finding: Finding, reason: string }\` \u2014 populate \`finding\` with the full Finding object and copy \`reason\` verbatim from the dismissed context entry`;
 }
 function buildConsolidationPrompt({
@@ -65774,55 +65857,156 @@ function serializeDismissals(dismissals) {
     ({ finding, reason }) => `${finding.flow} \u2014 ${finding.description}${reason ? ` (reason: ${reason})` : ""}`
   );
 }
-function emitStageEnd2(config3, start) {
-  config3?.onEvent?.({ type: "STAGE_END", agent: "consolidator", durationMs: Date.now() - start });
+function emitStageEnd2(context) {
+  context.config?.onEvent?.({
+    type: "STAGE_END",
+    agent: "consolidator",
+    durationMs: Date.now() - context.start
+  });
 }
-function runConsolidator(input, config3) {
-  if (input.metadataFindings.length === 0 && input.visualFindings.length === 0) {
-    return (0, import_neverthrow13.okAsync)({ findings: [], dismissed: [] });
-  }
-  const start = Date.now();
-  config3?.onEvent?.({ type: "STAGE_START", agent: "consolidator" });
-  const prompt = buildConsolidationPrompt({
+function buildPrompt(input) {
+  return buildConsolidationPrompt({
     metadataFindings: input.metadataFindings,
     visualFindings: input.visualFindings,
     dismissals: serializeDismissals(input.dismissals)
   });
-  return consolidateFindings(prompt, config3?.onEvent).map((result) => {
-    emitStageEnd2(config3, start);
+}
+function runPipeline(input, context) {
+  const pool = { metadataFindings: input.metadataFindings, visualFindings: input.visualFindings };
+  return consolidateFindings(buildPrompt(input), context.config?.onEvent).andThen((raw) => attachAllConfidences(raw, pool)).map((result) => {
+    emitStageEnd2(context);
     return result;
   }).mapErr((error48) => {
-    emitStageEnd2(config3, start);
+    emitStageEnd2(context);
     return error48;
   });
 }
+function runConsolidator(input, config3) {
+  if (input.metadataFindings.length === 0 && input.visualFindings.length === 0) {
+    return (0, import_neverthrow13.okAsync)({ findings: [], dismissed: [] });
+  }
+  const start = Date.now();
+  config3?.onEvent?.({ type: "STAGE_START", agent: "consolidator" });
+  return runPipeline(input, { config: config3, start });
+}
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow31 = __toESM(require_index_cjs(), 1);
-var import_neverthrow32 = __toESM(require_index_cjs(), 1);
-var import_node_fs3 = require("node:fs");
 var import_neverthrow33 = __toESM(require_index_cjs(), 1);
-var import_promises16 = require("node:timers/promises");
+var import_neverthrow34 = __toESM(require_index_cjs(), 1);
+var import_node_fs3 = require("node:fs");
+var import_neverthrow35 = __toESM(require_index_cjs(), 1);
+var import_promises17 = require("node:timers/promises");
 
 // ../../agents/explorer/dist/index.js
 var import_promises9 = require("node:timers/promises");
-var import_neverthrow15 = __toESM(require_index_cjs(), 1);
 var import_neverthrow16 = __toESM(require_index_cjs(), 1);
+var import_neverthrow17 = __toESM(require_index_cjs(), 1);
 var import_promises10 = require("node:fs/promises");
 var import_node_path4 = __toESM(require("node:path"), 1);
-var import_neverthrow17 = __toESM(require_index_cjs(), 1);
-var import_node_child_process3 = require("node:child_process");
-var import_promises11 = require("node:fs/promises");
 var import_neverthrow18 = __toESM(require_index_cjs(), 1);
-var import_neverthrow19 = __toESM(require_index_cjs(), 1);
-var import_node_child_process4 = require("node:child_process");
-var import_node_fs = require("node:fs");
+var import_promises11 = require("node:fs/promises");
 var import_node_path5 = __toESM(require("node:path"), 1);
+var import_neverthrow19 = __toESM(require_index_cjs(), 1);
+var import_node_child_process3 = require("node:child_process");
+var import_promises12 = require("node:fs/promises");
 var import_neverthrow20 = __toESM(require_index_cjs(), 1);
 var import_neverthrow21 = __toESM(require_index_cjs(), 1);
-var import_promises12 = require("node:fs/promises");
+var import_node_child_process4 = require("node:child_process");
+var import_node_fs = require("node:fs");
 var import_node_path6 = __toESM(require("node:path"), 1);
 var import_neverthrow22 = __toESM(require_index_cjs(), 1);
+var import_neverthrow23 = __toESM(require_index_cjs(), 1);
+var import_promises13 = require("node:fs/promises");
+var import_node_path7 = __toESM(require("node:path"), 1);
+var import_neverthrow24 = __toESM(require_index_cjs(), 1);
+function buildFinding(input, screenshotPath) {
+  return {
+    ...input,
+    agent: "explorer",
+    screenshots: [screenshotPath]
+  };
+}
+var REPORT_FINDING_TOOL_NAME = "mcp__mobile-ios__report_finding";
+var REPORT_FINDING_DESCRIPTION = `Report a single finding the moment you observe it. Call this immediately when a finding condition is triggered \u2014 before taking any further actions. The current screen is captured automatically and attached to the finding. Do not pass screenshot paths. Do not batch findings for the end of the run.`;
+var safeWriteFile = (0, import_neverthrow18.fromAsyncThrowable)(
+  import_promises10.writeFile,
+  (cause) => ({ type: "WRITE_FAILED", cause })
+);
+async function persistScreenshot(params) {
+  const filePath = import_node_path4.default.join(
+    params.screenshotsDirectory,
+    `finding-${String(params.findingIndex)}.png`
+  );
+  return safeWriteFile(filePath, Buffer.from(params.data, "base64")).match(
+    () => filePath,
+    () => ""
+  );
+}
+function emitFindingEvent(params) {
+  params.onEvent?.({
+    type: "FINDING_REPORTED",
+    agent: "explorer",
+    finding: params.finding,
+    findingIndex: params.findingIndex,
+    screenshotPath: params.screenshotPath
+  });
+}
+async function resolveScreenshotPath(params) {
+  if (params.screenshotsDir === void 0) {
+    return "";
+  }
+  return persistScreenshot({
+    screenshotsDirectory: params.screenshotsDir,
+    findingIndex: params.findingIndex,
+    data: params.data
+  });
+}
+async function recordFinding(params) {
+  const screenshotPath = await resolveScreenshotPath({
+    screenshotsDir: params.screenshotsDir,
+    findingIndex: params.findingIndex,
+    data: params.screenshotData
+  });
+  const finding = buildFinding(params.input, screenshotPath);
+  params.findings.push(finding);
+  emitFindingEvent({
+    onEvent: params.onEvent,
+    finding,
+    findingIndex: params.findingIndex,
+    screenshotPath
+  });
+  return { content: [{ type: "text", text: "ok" }] };
+}
+function screenshotErrorResult(cause) {
+  return {
+    content: [{ type: "text", text: `Screenshot failed: ${String(cause)}` }],
+    isError: true
+  };
+}
+function createHandler(context) {
+  const counter = context.findingCounter;
+  const { findings, onEvent, screenshotsDir, udid } = context;
+  return async (input) => {
+    const screenshotResult = await captureScreenshot(udid);
+    if (screenshotResult.isErr()) {
+      return screenshotErrorResult(screenshotResult.error.cause);
+    }
+    const findingIndex = counter.value;
+    counter.value += 1;
+    return recordFinding({
+      findings,
+      onEvent,
+      screenshotsDir,
+      input,
+      screenshotData: screenshotResult.value,
+      findingIndex
+    });
+  };
+}
+function createReportFindingTool(context) {
+  const handler2 = createHandler(context);
+  return _x("report_finding", REPORT_FINDING_DESCRIPTION, findingInputSchema.shape, handler2);
+}
 var VIEW_UI_DESCRIPTION = `Capture current screen state: accessibility tree (element labels, positions, attributes) and screenshot in one call. Use when you need to tap an element, assert element presence or labels, check attributes, or track screen identity via <screen_id>.
 
 The result begins with a <screen_id> tag containing the current screen identifier. Use this to detect screen changes and track navigation history.
@@ -65831,14 +66015,14 @@ Do not call \`screenshot\` immediately before or after this tool for the same st
 
 IMPORTANT: Snapshot coordinates and screenshot pixels are in the same logical point space. Do not apply any scaling factor (no 2x retina adjustment).`;
 var VIEW_UI_TOOL_NAME = "mcp__mobile-ios__view_ui";
-async function persistScreenshot(params) {
+async function persistScreenshot2(params) {
   const targetSnapshot = params.snapshot;
-  const screenshotPath = import_node_path4.default.join(params.screenshotsDirectory, `${params.screenLabel}.png`);
-  const safeWriteFile = (0, import_neverthrow17.fromAsyncThrowable)(
-    import_promises10.writeFile,
+  const screenshotPath = import_node_path5.default.join(params.screenshotsDirectory, `${params.screenLabel}.png`);
+  const safeWriteFile2 = (0, import_neverthrow19.fromAsyncThrowable)(
+    import_promises11.writeFile,
     (cause) => ({ type: "WRITE_FAILED", cause })
   );
-  const writeResult = safeWriteFile(screenshotPath, Buffer.from(params.data, "base64"));
+  const writeResult = safeWriteFile2(screenshotPath, Buffer.from(params.data, "base64"));
   const succeeded = await writeResult.match(
     () => true,
     () => false
@@ -65899,16 +66083,16 @@ function buildSnapshotRecord(rawElements, { stepIndex, context }) {
 }
 async function handleScreenshotData(data, params) {
   if (params.context.screenshotsDir !== void 0) {
-    const safeWrite2 = (0, import_neverthrow17.fromAsyncThrowable)(
-      import_promises10.writeFile,
+    const safeWrite2 = (0, import_neverthrow19.fromAsyncThrowable)(
+      import_promises11.writeFile,
       (cause) => ({ type: "WRITE_FAILED", cause })
     );
-    const snapshotPath = import_node_path4.default.join(params.context.screenshotsDir, `${params.screenLabel}.txt`);
+    const snapshotPath = import_node_path5.default.join(params.context.screenshotsDir, `${params.screenLabel}.txt`);
     await safeWrite2(snapshotPath, params.formatted).match(
       () => true,
       () => false
     );
-    await persistScreenshot({
+    await persistScreenshot2({
       snapshot: params.snapshot,
       data,
       screenLabel: params.screenLabel,
@@ -66002,7 +66186,7 @@ function captureThinkingOrText(blk, state) {
   }
 }
 function captureToolUse(blk, state) {
-  if (typeof blk.name === "string") {
+  if (typeof blk.name === "string" && blk.name !== REPORT_FINDING_TOOL_NAME) {
     state.onEvent?.({
       type: "TOOL_CALL",
       agent: "explorer",
@@ -66013,10 +66197,6 @@ function captureToolUse(blk, state) {
   if (typeof blk.id === "string" && typeof blk.name === "string") {
     state.pendingToolCallNames.set(blk.id, blk.name);
   }
-  if (typeof blk.name === "string" && blk.name.endsWith("set_output")) {
-    state.captureInput(blk.input);
-    state.closeQueue();
-  }
 }
 function extractResultText(block) {
   const typed = block;
@@ -66032,7 +66212,7 @@ function extractResultText(block) {
 }
 function emitToolResultEvent(emission) {
   const { block, toolName, blk, state } = emission;
-  if (toolName === VIEW_UI_TOOL_NAME) {
+  if (toolName === VIEW_UI_TOOL_NAME || toolName === REPORT_FINDING_TOOL_NAME) {
     return;
   }
   const resultText = extractResultText(block);
@@ -66084,23 +66264,23 @@ function processMessage(message, state) {
   }
   if (message.type === "result") {
     if (message.subtype !== "success" && !state.timedOut.value && !state.aborted.value) {
-      return (0, import_neverthrow16.err)(message.errors.join("; "));
+      return (0, import_neverthrow17.err)(message.errors.join("; "));
     }
-    return (0, import_neverthrow16.ok)(true);
+    return (0, import_neverthrow17.ok)(true);
   }
-  return (0, import_neverthrow16.ok)(false);
+  return (0, import_neverthrow17.ok)(false);
 }
 async function processMessages(queryRunner, state) {
   for await (const message of queryRunner) {
     const result = processMessage(message, state);
     if (result.isErr()) {
-      return (0, import_neverthrow16.err)(result.error);
+      return (0, import_neverthrow17.err)(result.error);
     }
     if (result.value) {
       break;
     }
   }
-  return (0, import_neverthrow16.ok)(null);
+  return (0, import_neverthrow17.ok)(null);
 }
 var MessageQueue = class {
   pending = [];
@@ -66165,26 +66345,25 @@ function spawnDetached(options2) {
     off: child.off.bind(child)
   };
 }
-function buildQueryOptions({
-  config: config3,
-  outputTools,
-  mobileIosServer,
-  allowedTools
-}) {
-  const base = {
+function buildBaseOptions(context) {
+  const { config: config3, mobileIosServer, allowedTools } = context;
+  return {
     mcpServers: {
       ...config3.mcpServers,
-      "mobile-ios": mobileIosServer,
-      output: outputTools.server
+      "mobile-ios": mobileIosServer
     },
     allowedTools,
     tools: [],
     permissionMode: "bypassPermissions",
     allowDangerouslySkipPermissions: true,
     spawnClaudeCodeProcess: spawnDetached,
+    thinking: { type: "adaptive" },
     ...config3.cwd ? { cwd: config3.cwd } : {}
   };
-  if (!config3.signal) {
+}
+function buildQueryOptions(context) {
+  const base = buildBaseOptions(context);
+  if (!context.config.signal) {
     return { options: base, linkedController: void 0 };
   }
   const linkedController = new AbortController();
@@ -66203,14 +66382,14 @@ function buildSendMessageFunction(inputQueue) {
 }
 function buildAgentState({
   config: config3,
-  outputTools,
   inputQueue
 }) {
   return {
     pendingToolCallNames: /* @__PURE__ */ new Map(),
     snapshots: [],
     stepCounter: { value: 0 },
-    captureInput: outputTools.captureInput,
+    findings: [],
+    findingCounter: { value: 0 },
     sendMessage: buildSendMessageFunction(inputQueue),
     closeQueue: () => {
       inputQueue.close();
@@ -66228,28 +66407,34 @@ function buildMobileIosServer(config3, state) {
     onEvent: config3.onEvent,
     screenshotsDir: config3.screenshotsDir
   });
-  return createMobileIosServer(config3.udid ?? "booted", [viewUiTool]);
+  const reportFindingTool = createReportFindingTool({
+    udid: config3.udid,
+    findings: state.findings,
+    findingCounter: state.findingCounter,
+    onEvent: config3.onEvent,
+    screenshotsDir: config3.screenshotsDir
+  });
+  return createMobileIosServer(config3.udid ?? "booted", [viewUiTool, reportFindingTool]);
 }
-function setupQuery(config3, outputTools) {
+function setupQuery(config3) {
   const allowedTools = [
     ...config3.allowedTools ?? [],
-    ...outputTools.allowedToolNames,
     VIEW_UI_TOOL_NAME,
+    REPORT_FINDING_TOOL_NAME,
     WAIT_SECONDS_TOOL_NAME
-  ].filter((tool2) => typeof tool2 === "string");
+  ].filter((tool3) => typeof tool3 === "string");
   const inputQueue = new MessageQueue();
-  const state = buildAgentState({ config: config3, outputTools, inputQueue });
+  const state = buildAgentState({ config: config3, inputQueue });
   const mobileIosServer = buildMobileIosServer(config3, state);
   const { options: options2, linkedController } = buildQueryOptions({
     config: config3,
-    outputTools,
     mobileIosServer,
     allowedTools
   });
   return { inputQueue, state, options: options2, linkedController };
 }
-var DEFAULT_GRACE_PERIOD_MS = 6e4;
-var SOFT_DEADLINE_MESSAGE = "Your time limit has been reached. Call set_output immediately with any findings you have collected so far. Do not take any further actions.";
+var DEFAULT_GRACE_PERIOD_MS = 1e4;
+var SOFT_DEADLINE_MESSAGE = "Your time limit has been reached. Do not take any further actions.";
 function buildInterruptErrorEvent(agent, error48) {
   const message = `interrupt failed: ${error48 instanceof Error ? error48.message : String(error48)}`;
   const stack = error48 instanceof Error ? error48.stack : void 0;
@@ -66308,18 +66493,14 @@ function startTimeout(timeoutMs, context) {
   const gracePeriodMs = context.gracePeriodMs ?? DEFAULT_GRACE_PERIOD_MS;
   return startActiveTimeout({ timeoutMs, gracePeriodMs, context });
 }
-var EXPLORER_FINDING_SCHEMA = findingSchema.omit({ agent: true });
 var INTERRUPT_DRAIN_TIMEOUT_MS = 1e4;
 async function interruptOrTimeout(queryRunner) {
   await Promise.race([queryRunner.interrupt(), (0, import_promises9.setTimeout)(INTERRUPT_DRAIN_TIMEOUT_MS)]);
 }
-var safeInterruptOrTimeout = import_neverthrow15.ResultAsync.fromThrowable(
+var safeInterruptOrTimeout = import_neverthrow16.ResultAsync.fromThrowable(
   interruptOrTimeout,
   (error48) => error48
 );
-function stampExplorerAgent(raw) {
-  return { ...raw, agent: "explorer" };
-}
 async function drainInterruptThenAbort(context) {
   const { queryRunner, state, linkedController, reason } = context;
   const result = await safeInterruptOrTimeout(queryRunner);
@@ -66365,24 +66546,23 @@ function startQueryTimers(config3, context) {
 }
 function awaitMessagesAndResolve({ queryRunner, state }, { cleanup: cleanup2, getOutput }) {
   const messagesPromise = processMessages(queryRunner, state);
-  return import_neverthrow15.ResultAsync.fromPromise(messagesPromise, String).andThen((innerResult) => {
+  return import_neverthrow16.ResultAsync.fromPromise(messagesPromise, String).andThen((innerResult) => {
     cleanup2();
     if (innerResult.isErr()) {
-      return (0, import_neverthrow15.err)(innerResult.error);
+      return (0, import_neverthrow16.err)(innerResult.error);
     }
-    return (0, import_neverthrow15.ok)(getOutput());
+    return (0, import_neverthrow16.ok)(getOutput());
   }).orElse((sdkError) => {
     cleanup2();
     if (!state.timedOut.value && !state.aborted.value) {
-      return (0, import_neverthrow15.err)(sdkError);
+      return (0, import_neverthrow16.err)(sdkError);
     }
-    return (0, import_neverthrow15.ok)(getOutput());
+    return (0, import_neverthrow16.ok)(getOutput());
   });
 }
 function executeQuery({
   prompt,
   config: config3,
-  outputTools,
   setup: { inputQueue, state, options: options2, linkedController }
 }) {
   inputQueue.enqueue({
@@ -66390,35 +66570,32 @@ function executeQuery({
     message: { role: "user", content: prompt },
     parent_tool_use_id: null
   });
-  const queryRunnerResult = (0, import_neverthrow15.fromThrowable)(Qs, String)({ prompt: inputQueue, options: options2 });
+  const queryRunnerResult = (0, import_neverthrow16.fromThrowable)(Qs, String)({ prompt: inputQueue, options: options2 });
   if (queryRunnerResult.isErr()) {
-    return (0, import_neverthrow15.errAsync)(queryRunnerResult.error);
+    return (0, import_neverthrow16.errAsync)(queryRunnerResult.error);
   }
   const queryRunner = queryRunnerResult.value;
   const cleanup2 = startQueryTimers(config3, { state, queryRunner, inputQueue, linkedController });
   const getOutput = () => ({
-    findings: (outputTools.getOutput()?.findings ?? []).map(
-      (raw) => stampExplorerAgent(raw)
-    ),
+    findings: state.findings,
     snapshots: state.snapshots
   });
   return awaitMessagesAndResolve({ queryRunner, state }, { cleanup: cleanup2, getOutput });
 }
 function runQuery(prompt, config3) {
-  const outputTools = createOutputTool({ findings: external_exports.array(EXPLORER_FINDING_SCHEMA) });
-  const setup = setupQuery(config3, outputTools);
-  return executeQuery({ prompt, config: config3, outputTools, setup });
+  const setup = setupQuery(config3);
+  return executeQuery({ prompt, config: config3, setup });
 }
 function collectAgentOutput(prompt, config3) {
   return runQuery(prompt, config3).mapErr((cause) => ({ type: "QUERY_FAILED", cause }));
 }
 function spawnRecorder(outputPath) {
-  const safeMkdirSync = (0, import_neverthrow20.fromThrowable)(import_node_fs.mkdirSync, (cause) => cause);
-  const safeSpawn2 = (0, import_neverthrow20.fromThrowable)(
+  const safeMkdirSync = (0, import_neverthrow22.fromThrowable)(import_node_fs.mkdirSync, (cause) => cause);
+  const safeSpawn2 = (0, import_neverthrow22.fromThrowable)(
     (command, arguments_) => (0, import_node_child_process4.spawn)(command, arguments_),
     (cause) => cause
   );
-  const mkdirResult = safeMkdirSync(import_node_path5.default.dirname(outputPath), { recursive: true });
+  const mkdirResult = safeMkdirSync(import_node_path6.default.dirname(outputPath), { recursive: true });
   if (mkdirResult.isErr()) {
     return mkdirResult.error;
   }
@@ -66441,7 +66618,7 @@ function earlyExitError(code) {
 function waitForRecordingStart(proc) {
   const { stderr } = proc;
   if (!stderr) {
-    return (0, import_neverthrow20.errAsync)({ type: "SPAWN_FAILED", cause: new RangeError("proc has no stderr pipe") });
+    return (0, import_neverthrow22.errAsync)({ type: "SPAWN_FAILED", cause: new RangeError("proc has no stderr pipe") });
   }
   const { promise: promise2, resolve, reject } = Promise.withResolvers();
   proc.once("error", reject);
@@ -66457,7 +66634,7 @@ function waitForRecordingStart(proc) {
       resolve({ process: proc, startedAt: Date.now() });
     }
   });
-  return import_neverthrow20.ResultAsync.fromPromise(
+  return import_neverthrow22.ResultAsync.fromPromise(
     promise2,
     (cause) => ({ type: "SPAWN_FAILED", cause })
   );
@@ -66465,7 +66642,7 @@ function waitForRecordingStart(proc) {
 function startRecording(outputPath) {
   const procOrError = spawnRecorder(outputPath);
   if (procOrError instanceof Error) {
-    return (0, import_neverthrow20.errAsync)({ type: "SPAWN_FAILED", cause: procOrError });
+    return (0, import_neverthrow22.errAsync)({ type: "SPAWN_FAILED", cause: procOrError });
   }
   return waitForRecordingStart(procOrError);
 }
@@ -66480,7 +66657,7 @@ function stopRecording(handle) {
   } else {
     resolve(true);
   }
-  return import_neverthrow20.ResultAsync.fromPromise(
+  return import_neverthrow22.ResultAsync.fromPromise(
     promise2,
     (cause) => ({ type: "STOP_FAILED", cause })
   );
@@ -66493,7 +66670,7 @@ function runWithRecording(handle, collectOutput) {
   return collectOutput().andThen(
     ({ findings, snapshots }) => stopRecording(handle).mapErr(toRecordingError).map(() => ({ findings, snapshots }))
   ).orElse(
-    (error48) => stopRecording(handle).mapErr(toRecordingError).andThen(() => (0, import_neverthrow19.errAsync)(error48)).orElse(() => (0, import_neverthrow19.errAsync)(error48))
+    (error48) => stopRecording(handle).mapErr(toRecordingError).andThen(() => (0, import_neverthrow21.errAsync)(error48)).orElse(() => (0, import_neverthrow21.errAsync)(error48))
   );
 }
 function startAndRun(params) {
@@ -66540,9 +66717,21 @@ var LOADING_STATE_RULE = `Transient loading state: when the screen shows spinner
 var EXPECTED_CONTENT_MISSING_RULE = `Expected content missing: when \`view_ui\` shows no loading indicator yet omits an element named or strongly implied by spec or app context \u2014 and its absence is not semantically consistent with the current screen \u2014 call \`wait_seconds\` with 2\u20135 seconds and retry \`view_ui\` up to 2 times; if element remains absent, emit a \`missing-content\` finding stating what was expected and what was observed`;
 var CLIPPED_ELEMENT_RULE = `Never tap an element tagged \`[clipped-top]\`, \`[clipped-bottom]\`, \`[clipped-left]\`, or \`[clipped-right]\` \u2014 scroll to fully reveal it first, then re-call \`view_ui\` before tapping`;
 var SCROLL_FOLD_RULE = `Scrollable lists: elements outside the visible viewport are absent from the a11y tree by design \u2014 this applies to elements below the fold in vertical lists AND elements clipped off-left or off-right in horizontal lists \u2014 scroll or swipe in the appropriate axis to reveal before asserting presence or absence; never emit a finding solely because list items, rows, or tabs are missing from the tree on a scrollable screen; if swipe attempts yield no position change across 2+ cycles, apply the scroll-stall path in STUCK_LOOP_RULE.`;
+var CONFIDENCE_RUBRIC_SECTION = `## Confidence
+
+Write the description (what you saw vs. expected, where, when) before committing to a confidence label.
+
+- HIGH \u2014 definite bug or deviation; the evidence is unambiguous
+- MEDIUM \u2014 probable bug, but could be intentional behavior you cannot verify
+- LOW \u2014 speculative; only include when freestyle/low-confidence triggers require it`;
 var FINDING_TAXONOMY_SECTION = `## Finding Types
 
-You may emit only these trigger types: \`back-nav-failure\`, \`dead-end\`, \`stuck-modal\`, \`stuck-loop\`, \`missing-a11y-element\`, \`missing-content\`, \`spec-deviation\`, \`destructive-only-exit\`. Do NOT emit \`design-system-violation\`, \`motion-regression\`, \`continuity-regression\`, \`interaction-regression\`, or \`loading-regression\` \u2014 those belong to other agents.`;
+You may emit only these trigger types: \`back-nav-failure\`, \`dead-end\`, \`stuck-modal\`, \`stuck-loop\`, \`missing-a11y-element\`, \`missing-content\`, \`spec-deviation\`, \`destructive-only-exit\`. Do NOT emit \`design-system-violation\`, \`motion-regression\`, \`continuity-regression\`, \`interaction-regression\`, or \`loading-regression\` \u2014 those belong to other agents.
+
+${CONFIDENCE_RUBRIC_SECTION}`;
+var REPORTING_FINDINGS_SECTION = `## Reporting Findings
+
+CRITICAL: When you observe a finding, call \`report_finding\` IMMEDIATELY \u2014 before taking any further actions. Do not batch findings. Do not wait until the end of the run. Each \`report_finding\` call atomically records one finding with the current screen attached; the server captures the screenshot. Do not pass screenshot paths or step indices. If you are uncertain whether something warrants a finding, do not report it \u2014 \`report_finding\` is for confirmed observations only.`;
 var A11Y_FALLBACK_RULE = `Missing a11y element: if you intend to tap or interact with a UI element and that element is absent from the most recent \`view_ui\` a11y tree \u2014 visible in the screenshot does NOT imply interactable; the a11y tree is authoritative \u2014 do NOT estimate its coordinates from the screenshot, do NOT attempt any pixel-based tap, do NOT retry at different coordinates, do NOT long-press or swipe in the element's visual region as a fallback; a failed pixel tap is never an \`interaction-regression\` \u2014 it is a \`missing-a11y-element\` \u2014 instead, emit a \`missing-a11y-element\` finding that states: (1) your intent (what you were trying to do), (2) the approximate visual region where the element appeared (coords/size from the screenshot), (3) nearby labeled elements from the a11y tree that serve as landmarks \u2014 then continue: in freestyle mode keep exploring other reachable screens; in spec mode advance to the next step`;
 var OUTCOME_LITERAL_RULE = `When verifying a step outcome or assertion, interpret all quantifiers literally and apply them exhaustively: any keyword that imposes a universal or count-bound constraint \u2014 including but not limited to \`only\`, \`all\`, \`every\`, \`each\`, \`both\`, \`no\`, \`none\`, \`neither\`, \`exactly N\`, \`at least N\`, \`fewer than N\`, \`more than N\` \u2014 a single counter-example observed in \`view_ui\` or \`screenshot\` constitutes a failed constraint; this rule applies only when the outcome text contains a universal or count-bound quantifier; positive-existence outcomes (\`X appears\`, \`Y becomes active\`, \`screen is visible\`) are not subject to counter-example scanning and are governed by SPEC_STEP_READING_SECTION; on a scrollable list, scroll through the full list before concluding pass or fail on a universal quantifier \u2014 apply SCROLL_FOLD_RULE to reveal all items, then evaluate across the complete visible set; if the screen shows any loading indicator at the time of observation, apply LOADING_STATE_RULE first and re-verify after resolution before emitting; do NOT soften (\`mostly\`, \`essentially\`, \`largely\`) and do NOT narrow the target class post-hoc to exclude the counter-example; when the counter-evidence is an element absent from the a11y tree, A11Y_FALLBACK_RULE takes precedence and determines the finding type (\`missing-a11y-element\`) \u2014 OUTCOME_LITERAL_RULE governs unwanted-presence violations only; if one item violates the constraint, emit \`spec-deviation\` immediately with: (a) the literal outcome text, (b) the specific element(s) that violate it, (c) the constraint keyword that is broken.`;
 var ANTI_RATIONALIZATION_RULE = `During outcome verification, monitor your own reasoning for reconciliation hypotheses: if you generate any reasoning that re-frames, redefines, or reinterprets the observed counter-example or target class in order to produce agreement with the spec outcome \u2014 regardless of phrasing \u2014 treat that reasoning as a deviation signal, not a resolution; stop, do NOT mark the step complete, and emit \`spec-deviation\` with: (a) the literal outcome text, (b) the specific observation that triggered the hypothesis, (c) the reconciliation reasoning itself verbatim; before marking any quantifier-bearing outcome complete, state explicitly in your reasoning: \`No reconciliation hypothesis generated. Counter-examples found: [list or none].\` If you cannot make that statement honestly, a hypothesis exists \u2014 emit \`spec-deviation\`; when outcome verification is ambiguous and no reconciliation hypothesis is generated, still default to emitting \`spec-deviation\`; silence is not a pass.`;
@@ -66677,9 +66866,7 @@ ${FINDING_TAXONOMY_SECTION}
 
 ${specContent}${environmentSection}
 
-## Output
-
-CRITICAL: Call \`set_output\` each time your findings change \u2014 when you discover something new, confirm a false positive, or revise a finding. Each call replaces the previous output entirely, so always pass the full current list. Do not reply in plain text.`;
+${REPORTING_FINDINGS_SECTION}`;
 }
 var SPEC_MODE_TEMPLATE = (specContent, options2) => {
   const contextBlock = buildContextSections(options2.appContext, options2.initialState);
@@ -66723,9 +66910,7 @@ ${DEAD_END_SECTION}
 
 ${FINDING_TAXONOMY_SECTION}${environmentSection}
 
-## Output
-
-CRITICAL: Call \`set_output\` each time your findings change \u2014 when you discover something new, confirm a false positive, or revise a finding. Each call replaces the previous output entirely, so always pass the full current list. Do not reply in plain text.`;
+${REPORTING_FINDINGS_SECTION}`;
 }
 var FREESTYLE_TEMPLATE = (options2) => {
   const { appContext, initialState: initialState2, buildEnv } = options2 ?? {};
@@ -66776,29 +66961,29 @@ var INLINE_ASSERTION_DELIMITER = " \u2192 ";
 var NUMBERED_STEP_PREFIX = /^\d+\.\s+/;
 function parseTagsValue(value) {
   if (!value.startsWith("[") || !value.endsWith("]")) {
-    return (0, import_neverthrow21.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid tags format: ${value}` });
+    return (0, import_neverthrow23.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid tags format: ${value}` });
   }
-  return (0, import_neverthrow21.ok)(
+  return (0, import_neverthrow23.ok)(
     value.slice(1, -1).split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0)
   );
 }
 function parseTimeoutValue(value) {
   const parsed = Number(value);
   if (Number.isNaN(parsed) || parsed <= 0) {
-    return (0, import_neverthrow21.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid timeout: ${value}` });
+    return (0, import_neverthrow23.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid timeout: ${value}` });
   }
-  return (0, import_neverthrow21.ok)(parsed);
+  return (0, import_neverthrow23.ok)(parsed);
 }
 function parseFrontmatterLine(line) {
   const colonIndex = line.indexOf(":");
   if (colonIndex === -1) {
-    return (0, import_neverthrow21.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid line: ${line}` });
+    return (0, import_neverthrow23.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid line: ${line}` });
   }
   const key = line.slice(0, colonIndex).trim();
   const value = line.slice(colonIndex + 1).trim();
   switch (key) {
     case "description": {
-      return (0, import_neverthrow21.ok)({ description: value });
+      return (0, import_neverthrow23.ok)({ description: value });
     }
     case "tags": {
       return parseTagsValue(value).map((tags) => ({ tags }));
@@ -66807,7 +66992,7 @@ function parseFrontmatterLine(line) {
       return parseTimeoutValue(value).map((timeout) => ({ timeout }));
     }
     default: {
-      return (0, import_neverthrow21.ok)({});
+      return (0, import_neverthrow23.ok)({});
     }
   }
 }
@@ -66826,18 +67011,18 @@ function mergePartials(partials) {
 }
 function combineFrontmatterLines(lines) {
   const lineResults = lines.filter((line) => line.trim().length > 0).map((line) => parseFrontmatterLine(line));
-  return import_neverthrow21.Result.combine(lineResults).map((partials) => mergePartials(partials)).map((merged) => normalizeFrontmatter(merged));
+  return import_neverthrow23.Result.combine(lineResults).map((partials) => mergePartials(partials)).map((merged) => normalizeFrontmatter(merged));
 }
 function extractFrontmatter(content) {
   const trimmed = content.trimStart();
   if (!trimmed.startsWith(FRONTMATTER_FENCE)) {
-    return (0, import_neverthrow21.ok)({ frontmatter: emptyFrontmatter(), body: content });
+    return (0, import_neverthrow23.ok)({ frontmatter: emptyFrontmatter(), body: content });
   }
   const afterOpenFence = trimmed.slice(FRONTMATTER_FENCE.length);
   const closeIndex = afterOpenFence.indexOf(`
 ${FRONTMATTER_FENCE}`);
   if (closeIndex === -1) {
-    return (0, import_neverthrow21.err)({ type: "MALFORMED_FRONTMATTER", cause: "Unclosed frontmatter fence" });
+    return (0, import_neverthrow23.err)({ type: "MALFORMED_FRONTMATTER", cause: "Unclosed frontmatter fence" });
   }
   const rawFrontmatter = afterOpenFence.slice(0, closeIndex);
   const body = afterOpenFence.slice(closeIndex + FRONTMATTER_FENCE.length + 1);
@@ -66879,13 +67064,13 @@ function parseTestSpec(name, content) {
     const sections = splitIntoSections(body);
     const setup = sections.Setup;
     if (setup === void 0) {
-      return (0, import_neverthrow21.err)({ type: "MISSING_SETUP_SECTION" });
+      return (0, import_neverthrow23.err)({ type: "MISSING_SETUP_SECTION" });
     }
     const stepsSection = sections.Steps;
     if (stepsSection === void 0) {
-      return (0, import_neverthrow21.err)({ type: "MISSING_STEPS_SECTION" });
+      return (0, import_neverthrow23.err)({ type: "MISSING_STEPS_SECTION" });
     }
-    return (0, import_neverthrow21.ok)({
+    return (0, import_neverthrow23.ok)({
       name,
       frontmatter,
       setup,
@@ -66912,8 +67097,8 @@ function direntToSpecEntry(directory, entry) {
   if (entry.isFile() && entry.name.endsWith(".md")) {
     return [
       {
-        path: import_node_path6.default.join(directory, entry.name),
-        name: import_node_path6.default.basename(entry.name, import_node_path6.default.extname(entry.name)),
+        path: import_node_path7.default.join(directory, entry.name),
+        name: import_node_path7.default.basename(entry.name, import_node_path7.default.extname(entry.name)),
         required: true
       }
     ];
@@ -66921,7 +67106,7 @@ function direntToSpecEntry(directory, entry) {
   if (entry.isDirectory()) {
     return [
       {
-        path: import_node_path6.default.join(directory, entry.name, "spec.md"),
+        path: import_node_path7.default.join(directory, entry.name, "spec.md"),
         name: entry.name,
         required: false
       }
@@ -66930,25 +67115,25 @@ function direntToSpecEntry(directory, entry) {
   return [];
 }
 function scanDirectory(directory) {
-  const safeReaddir3 = (0, import_neverthrow22.fromAsyncThrowable)(
-    async () => (0, import_promises12.readdir)(directory, { withFileTypes: true }),
+  const safeReaddir3 = (0, import_neverthrow24.fromAsyncThrowable)(
+    async () => (0, import_promises13.readdir)(directory, { withFileTypes: true }),
     (cause) => ({ type: "DIR_READ_FAILED", dir: directory, cause })
   );
-  return safeReaddir3().orElse((error48) => isNotFound(error48.cause) ? (0, import_neverthrow22.okAsync)([]) : (0, import_neverthrow22.errAsync)(error48)).map(
+  return safeReaddir3().orElse((error48) => isNotFound(error48.cause) ? (0, import_neverthrow24.okAsync)([]) : (0, import_neverthrow24.errAsync)(error48)).map(
     (entries) => entries.flatMap((entry) => direntToSpecEntry(directory, entry))
   );
 }
 function readEntries(entries) {
-  return import_neverthrow22.ResultAsync.combine(entries.map((entry) => readEntry(entry))).map(
+  return import_neverthrow24.ResultAsync.combine(entries.map((entry) => readEntry(entry))).map(
     (results) => results.flat()
   );
 }
 function readEntry(entry) {
-  const safeReadFile6 = (0, import_neverthrow22.fromAsyncThrowable)(
-    async () => (0, import_promises12.readFile)(entry.path, "utf8"),
+  const safeReadFile6 = (0, import_neverthrow24.fromAsyncThrowable)(
+    async () => (0, import_promises13.readFile)(entry.path, "utf8"),
     (cause) => ({ type: "FILE_READ_FAILED", path: entry.path, cause })
   );
-  return safeReadFile6().map((content) => [{ name: entry.name, content }]).orElse((error48) => entry.required ? (0, import_neverthrow22.errAsync)(error48) : (0, import_neverthrow22.okAsync)([]));
+  return safeReadFile6().map((content) => [{ name: entry.name, content }]).orElse((error48) => entry.required ? (0, import_neverthrow24.errAsync)(error48) : (0, import_neverthrow24.okAsync)([]));
 }
 function specNameFromPath(filePath) {
   const parts = filePath.split("/");
@@ -66956,7 +67141,7 @@ function specNameFromPath(filePath) {
   if (fileName === "spec.md" && parts.length >= 2) {
     return parts.at(-2) ?? fileName;
   }
-  return import_node_path6.default.basename(fileName, import_node_path6.default.extname(fileName));
+  return import_node_path7.default.basename(fileName, import_node_path7.default.extname(fileName));
 }
 function filterByNames(specs, specNames) {
   if (!specNames || specNames.length === 0) {
@@ -66965,11 +67150,11 @@ function filterByNames(specs, specNames) {
   return specs.filter((spec) => specNames.includes(spec.name));
 }
 function resolveSpecs(config3, repoRoot = process.cwd()) {
-  const source = config3.specFiles && config3.specFiles.length > 0 ? loadFromFiles(config3.specFiles) : loadFromDirectory(import_node_path6.default.join(repoRoot, "openspec", "specs"));
+  const source = config3.specFiles && config3.specFiles.length > 0 ? loadFromFiles(config3.specFiles) : loadFromDirectory(import_node_path7.default.join(repoRoot, "openspec", "specs"));
   return source.map((specs) => filterByNames(specs, config3.specNames));
 }
 var ISO_DATE_LENGTH = 10;
-function buildPrompt(safeConfig, specs) {
+function buildPrompt2(safeConfig, specs) {
   return generateExplorerPrompt({
     mode: safeConfig.mode,
     specs,
@@ -66979,7 +67164,7 @@ function buildPrompt(safeConfig, specs) {
   });
 }
 function parseSpecs(resolvedSpecs) {
-  return import_neverthrow18.Result.combine(
+  return import_neverthrow20.Result.combine(
     resolvedSpecs.map(
       (spec) => parseTestSpec(spec.name, spec.content).mapErr(
         (cause) => ({ type: "SPEC_PARSE_FAILED", specName: spec.name, cause })
@@ -67034,16 +67219,16 @@ function collectAndFinalize({
 }
 function resolveAndParseSpecs(safeConfig) {
   if (safeConfig.mode === "freestyle") {
-    return (0, import_neverthrow18.okAsync)([]);
+    return (0, import_neverthrow20.okAsync)([]);
   }
   return resolveSpecs(safeConfig).mapErr((cause) => ({ type: "SPEC_RESOLVE_FAILED", cause })).andThen((specs) => parseSpecs(specs));
 }
-function runPipeline({
+function runPipeline2({
   safeConfig,
   runPaths,
   start
 }) {
-  return resolveAndParseSpecs(safeConfig).map((parsedSpecs) => buildPrompt(safeConfig, parsedSpecs)).map((prompt) => {
+  return resolveAndParseSpecs(safeConfig).map((parsedSpecs) => buildPrompt2(safeConfig, parsedSpecs)).map((prompt) => {
     safeConfig.onEvent?.({ type: "SYSTEM_PROMPT", agent: "explorer", prompt });
     return prompt;
   }).andThen((prompt) => collectAndFinalize({ safeConfig, prompt, runPaths, start }));
@@ -67057,11 +67242,11 @@ function runExplorer(config3) {
     date: date5
   });
   if (runPathsResult.isErr()) {
-    return (0, import_neverthrow18.errAsync)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
+    return (0, import_neverthrow20.errAsync)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
   }
   const runPaths = runPathsResult.value;
   if (config3.signal?.aborted) {
-    return (0, import_neverthrow18.okAsync)(toArtifacts({ findings: [], snapshots: [] }, runPaths));
+    return (0, import_neverthrow20.okAsync)(toArtifacts({ findings: [], snapshots: [] }, runPaths));
   }
   const safeConfig = {
     ...config3,
@@ -67069,25 +67254,25 @@ function runExplorer(config3) {
     onEvent: config3.onEvent === void 0 ? void 0 : safeHandler(config3.onEvent)
   };
   safeConfig.onEvent?.({ type: "STAGE_START", agent: "explorer" });
-  return import_neverthrow18.ResultAsync.fromSafePromise(
-    (0, import_promises11.mkdir)(runPaths.screenshotsDir, { recursive: true }).catch(() => null)
-  ).andThen(() => runPipeline({ safeConfig, runPaths, start }));
+  return import_neverthrow20.ResultAsync.fromSafePromise(
+    (0, import_promises12.mkdir)(runPaths.screenshotsDir, { recursive: true }).catch(() => null)
+  ).andThen(() => runPipeline2({ safeConfig, runPaths, start }));
 }
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow34 = __toESM(require_index_cjs(), 1);
+var import_neverthrow36 = __toESM(require_index_cjs(), 1);
 
 // ../../agents/inspector/dist/index.js
-var import_neverthrow23 = __toESM(require_index_cjs(), 1);
-var import_promises13 = require("node:fs/promises");
-var import_neverthrow24 = __toESM(require_index_cjs(), 1);
 var import_neverthrow25 = __toESM(require_index_cjs(), 1);
+var import_promises14 = require("node:fs/promises");
 var import_neverthrow26 = __toESM(require_index_cjs(), 1);
 var import_neverthrow27 = __toESM(require_index_cjs(), 1);
-var import_sharp2 = __toESM(require("sharp"), 1);
 var import_neverthrow28 = __toESM(require_index_cjs(), 1);
-var import_promises14 = require("node:fs/promises");
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_neverthrow29 = __toESM(require_index_cjs(), 1);
+var import_sharp2 = __toESM(require("sharp"), 1);
+var import_neverthrow30 = __toESM(require_index_cjs(), 1);
+var import_promises15 = require("node:fs/promises");
+var import_node_path8 = __toESM(require("node:path"), 1);
 
 // ../../node_modules/.pnpm/js-yaml@4.1.1/node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
@@ -68052,7 +68237,7 @@ var directiveHandlers = {
     }
     try {
       prefix = decodeURIComponent(prefix);
-    } catch (err25) {
+    } catch (err26) {
       throwError(state, "tag prefix is malformed: " + prefix);
     }
     state.tagMap[handle] = prefix;
@@ -68733,7 +68918,7 @@ function readTagProperty(state) {
   }
   try {
     tagName = decodeURIComponent(tagName);
-  } catch (err25) {
+  } catch (err26) {
     throwError(state, "tag name is malformed: " + tagName);
   }
   if (isVerbatim) {
@@ -69714,7 +69899,7 @@ var jsYaml = {
 };
 
 // ../../agents/inspector/dist/index.js
-var import_neverthrow29 = __toESM(require_index_cjs(), 1);
+var import_neverthrow31 = __toESM(require_index_cjs(), 1);
 var MS_PER_DAY = 864e5;
 function dequeue(context, current) {
   if (current.remainingQueue.length === 0 || context.activeCount + current.events.length >= context.maxConcurrency) {
@@ -69752,20 +69937,21 @@ function scheduleNext(state, maxConcurrency) {
     { events: [], remainingQueue: state.queue }
   );
 }
-var CONFIDENCE_HIGH = 0.9;
-var CONFIDENCE_MEDIUM = 0.6;
-var CONFIDENCE_LOW = 0.3;
 function toTriggerType(type2) {
   return type2 === "localization-issue" ? "localization-issue" : "visual-regression";
 }
-function toConfidence(severity) {
-  if (severity === "high") {
-    return CONFIDENCE_HIGH;
-  }
-  if (severity === "medium") {
-    return CONFIDENCE_MEDIUM;
+function severityToConfidence(severity) {
+  switch (severity) {
+    case "high": {
+      return "HIGH";
+    }
+    case "medium": {
+      return "MEDIUM";
+    }
+    case "low": {
+      return "LOW";
+    }
   }
-  return CONFIDENCE_LOW;
 }
 function parseJson(raw) {
   return JSON.parse(raw);
@@ -69785,13 +69971,13 @@ function mapRawFinding(item) {
     triggerType: toTriggerType(item.type),
     flow: "",
     steps: [],
-    confidence: toConfidence(item.severity),
+    confidence: severityToConfidence(item.severity),
     description: `[${item.element}] ${item.description}`,
     screenshots: [],
     agent: "inspector"
   };
 }
-var safeJsonParse3 = (0, import_neverthrow26.fromThrowable)(parseJson);
+var safeJsonParse3 = (0, import_neverthrow28.fromThrowable)(parseJson);
 function parseClaudeResponse(raw) {
   const parseResult = safeJsonParse3(raw);
   if (parseResult.isErr()) {
@@ -69818,7 +70004,7 @@ async function downscaleBuffer(buffer) {
   return (0, import_sharp2.default)(buffer).resize({ width: targetWidth }).toBuffer();
 }
 function downscale(buffer) {
-  return (0, import_neverthrow27.fromAsyncThrowable)(
+  return (0, import_neverthrow29.fromAsyncThrowable)(
     downscaleBuffer,
     (cause) => ({ type: "CLAUDE_API_FAILED", cause })
   )(buffer);
@@ -69893,7 +70079,7 @@ async function fetchClaudeText({
   return block?.type === "text" ? block.text : "";
 }
 function callClaude(options2) {
-  return (0, import_neverthrow25.fromAsyncThrowable)(
+  return (0, import_neverthrow27.fromAsyncThrowable)(
     fetchClaudeText,
     (cause) => ({ type: "CLAUDE_API_FAILED", cause })
   )(options2);
@@ -69905,9 +70091,9 @@ function toFindings(text) {
   const cleaned = stripCodeFences(text);
   const findings = parseClaudeResponse(cleaned);
   if (!findings) {
-    return (0, import_neverthrow25.errAsync)({ type: "CLAUDE_RESPONSE_INVALID", raw: cleaned });
+    return (0, import_neverthrow27.errAsync)({ type: "CLAUDE_RESPONSE_INVALID", raw: cleaned });
   }
-  return (0, import_neverthrow25.okAsync)(findings);
+  return (0, import_neverthrow27.okAsync)(findings);
 }
 function buildResolveMessages(screenshotBase64, artboardNames) {
   return [
@@ -69944,12 +70130,12 @@ async function fetchResolveName({
 }
 function resolveArtboard(screenshot, artboardNames) {
   if (artboardNames.length === 0) {
-    return (0, import_neverthrow25.okAsync)(void 0);
+    return (0, import_neverthrow27.okAsync)(void 0);
   }
   const anthropic = new Anthropic();
   return downscale(screenshot).andThen((scaled) => {
     const screenshotBase64 = scaled.toString("base64");
-    return (0, import_neverthrow25.fromAsyncThrowable)(
+    return (0, import_neverthrow27.fromAsyncThrowable)(
       fetchResolveName,
       (cause) => ({ type: "CLAUDE_API_FAILED", cause })
     )({ anthropic, screenshotBase64, artboardNames }).map((name) => {
@@ -69977,8 +70163,6 @@ var MAX_TOKENS22 = 2048;
 var CANDIDATES_MAX_TOKENS = 64;
 var MAX_CANDIDATES = 3;
 var TEMPERATURE2 = 0;
-var CONFIDENCE_MEDIUM2 = 0.6;
-var CONFIDENCE_LOW2 = 0.3;
 var DESIGN_CONTEXT_SYSTEM_PROMPT = `You are a visual QA engineer performing design-system inference. You will receive multiple candidate artboards followed by an actual screenshot.
 
 Infer the design system (color palette, typography scale, component patterns) from the candidate artboards. Then compare the screenshot against the inferred design system.
@@ -70008,11 +70192,17 @@ function isRawConservativeFinding(value) {
   const object2 = value;
   return typeof object2.type === "string" && typeof object2.element === "string" && typeof object2.description === "string" && typeof object2.severity === "string" && isValidConservativeSeverity(object2.severity);
 }
-var SEVERITY_CONFIDENCE = {
-  medium: CONFIDENCE_MEDIUM2,
-  low: CONFIDENCE_LOW2
-};
-var safeJsonParse22 = (0, import_neverthrow28.fromThrowable)(JSON.parse);
+function conservativeSeverityToConfidence(severity) {
+  switch (severity) {
+    case "medium": {
+      return "MEDIUM";
+    }
+    case "low": {
+      return "LOW";
+    }
+  }
+}
+var safeJsonParse22 = (0, import_neverthrow30.fromThrowable)(JSON.parse);
 function resolveNamesFromParsed(parsed, artboardNames) {
   return parsed.filter((name) => typeof name === "string").map((name) => {
     const lower = name.toLowerCase();
@@ -70075,7 +70265,7 @@ function parseConservativeResponse(raw) {
     triggerType: "design-system-violation",
     flow: "",
     steps: [],
-    confidence: SEVERITY_CONFIDENCE[item.severity],
+    confidence: conservativeSeverityToConfidence(item.severity),
     description: `[${item.element}] ${item.description}`,
     screenshots: [],
     agent: "inspector"
@@ -70101,9 +70291,9 @@ async function fetchDesignContextText({
 function toDesignContextFindings(text) {
   const findings = parseConservativeResponse(text);
   if (!findings) {
-    return (0, import_neverthrow28.errAsync)({ type: "CLAUDE_RESPONSE_INVALID", raw: text });
+    return (0, import_neverthrow30.errAsync)({ type: "CLAUDE_RESPONSE_INVALID", raw: text });
   }
-  return (0, import_neverthrow28.okAsync)(findings);
+  return (0, import_neverthrow30.okAsync)(findings);
 }
 async function downscaleAll(buffers) {
   return Promise.all(buffers.map(async (buf) => downscaleBuffer(buf)));
@@ -70129,12 +70319,12 @@ Artboards: ${artboardNames.join(", ")}`
 }
 function findCandidates(screenshot, artboardNames) {
   if (artboardNames.length === 0) {
-    return (0, import_neverthrow28.okAsync)([]);
+    return (0, import_neverthrow30.okAsync)([]);
   }
   const anthropic = new Anthropic();
   return downscale(screenshot).andThen((scaled) => {
     const screenshotBase64 = scaled.toString("base64");
-    return (0, import_neverthrow28.fromAsyncThrowable)(
+    return (0, import_neverthrow30.fromAsyncThrowable)(
       fetchCandidateNames,
       (cause) => ({ type: "CLAUDE_API_FAILED", cause })
     )({ anthropic, screenshotBase64, artboardNames });
@@ -70158,7 +70348,7 @@ function buildDesignContextMessages(screenshotBase64, artboardBase64s) {
     }
   ];
 }
-var downscaleAllBuffers = (0, import_neverthrow28.fromAsyncThrowable)(
+var downscaleAllBuffers = (0, import_neverthrow30.fromAsyncThrowable)(
   downscaleAll,
   (cause) => ({ type: "CLAUDE_API_FAILED", cause })
 );
@@ -70168,7 +70358,7 @@ function compareWithDesignContext(screenshot, artboards) {
     const screenshotBase64 = scaledScreenshot.toString("base64");
     return downscaleAllBuffers(artboards).andThen((scaledArtboards) => {
       const artboardBase64s = scaledArtboards.map((buf) => buf.toString("base64"));
-      return (0, import_neverthrow28.fromAsyncThrowable)(
+      return (0, import_neverthrow30.fromAsyncThrowable)(
         fetchDesignContextText,
         (cause) => ({ type: "CLAUDE_API_FAILED", cause })
       )({ anthropic, screenshotBase64, artboardBase64s }).andThen(toDesignContextFindings);
@@ -70402,8 +70592,8 @@ async function initArtboardNames({ designStore, config: config3, state }) {
   );
 }
 function readScreenshot(screenshotPath, stepIndex) {
-  return import_neverthrow24.ResultAsync.fromThrowable(
-    import_promises13.readFile,
+  return import_neverthrow26.ResultAsync.fromThrowable(
+    import_promises14.readFile,
     (cause) => ({ type: "SCREENSHOT_READ_FAILED", stepIndex, cause })
   )(screenshotPath);
 }
@@ -70475,7 +70665,7 @@ function buildInspector(state, context) {
       const { promise: promise2, resolve } = Promise.withResolvers();
       state.setResolve(resolve);
       applyTryResolve(state);
-      return (0, import_neverthrow23.fromSafePromise)(promise2);
+      return (0, import_neverthrow25.fromSafePromise)(promise2);
     }
   };
 }
@@ -70524,14 +70714,14 @@ function parseMeta(raw) {
   return {};
 }
 async function readAndParseSidecar(sidecarPath) {
-  const raw = await (0, import_promises14.readFile)(sidecarPath, "utf8");
+  const raw = await (0, import_promises15.readFile)(sidecarPath, "utf8");
   return parseMeta(raw);
 }
 function readSidecarFile(sidecarPath) {
-  return (0, import_neverthrow29.fromAsyncThrowable)(
+  return (0, import_neverthrow31.fromAsyncThrowable)(
     readAndParseSidecar,
     () => ({})
-  )(sidecarPath).orElse(() => (0, import_neverthrow29.okAsync)({}));
+  )(sidecarPath).orElse(() => (0, import_neverthrow31.okAsync)({}));
 }
 function isEnoent(error48) {
   return error48?.code === "ENOENT";
@@ -70540,13 +70730,13 @@ function wrapFsError(cause) {
   return { type: "FS_ERROR", cause };
 }
 function toFsError(fsError) {
-  return (0, import_neverthrow29.errAsync)(fsError);
+  return (0, import_neverthrow31.errAsync)(fsError);
 }
 function missingBuffer() {
-  return (0, import_neverthrow29.okAsync)(void 0);
+  return (0, import_neverthrow31.okAsync)(void 0);
 }
 function missingArtboard() {
-  return (0, import_neverthrow29.okAsync)(void 0);
+  return (0, import_neverthrow31.okAsync)(void 0);
 }
 var FsDesignStore = class {
   designsDirectory;
@@ -70554,12 +70744,12 @@ var FsDesignStore = class {
     this.designsDirectory = designsDirectory;
   }
   listArtboards() {
-    return (0, import_neverthrow29.fromAsyncThrowable)(
-      import_promises14.readdir,
+    return (0, import_neverthrow31.fromAsyncThrowable)(
+      import_promises15.readdir,
       wrapFsError
     )(this.designsDirectory).orElse((fsError) => {
       if (fsError.type === "FS_ERROR" && isEnoent(fsError.cause)) {
-        return (0, import_neverthrow29.okAsync)([]);
+        return (0, import_neverthrow31.okAsync)([]);
       }
       return toFsError(fsError);
     }).map(
@@ -70567,10 +70757,10 @@ var FsDesignStore = class {
     );
   }
   getArtboard(filename) {
-    const pngPath = import_node_path7.default.join(this.designsDirectory, `${filename}.png`);
-    const sidecarPath = import_node_path7.default.join(this.designsDirectory, `${filename}.meta.yaml`);
-    return (0, import_neverthrow29.fromAsyncThrowable)(
-      import_promises14.readFile,
+    const pngPath = import_node_path8.default.join(this.designsDirectory, `${filename}.png`);
+    const sidecarPath = import_node_path8.default.join(this.designsDirectory, `${filename}.meta.yaml`);
+    return (0, import_neverthrow31.fromAsyncThrowable)(
+      import_promises15.readFile,
       wrapFsError
     )(pngPath).orElse((fsError) => {
       if (fsError.type === "FS_ERROR" && isEnoent(fsError.cause)) {
@@ -70591,21 +70781,21 @@ var FsDesignStore = class {
 // ../../packages/pipeline/dist/index.js
 var RETRY_MAX_ATTEMPTS = 3;
 var RETRY_BASE_DELAY_MS = 1e3;
-var CONFIDENCE_THRESHOLD = 0.7;
+var CONFIDENCE_THRESHOLD = "HIGH";
 function filterByConfidence(findings, threshold) {
   return {
-    kept: findings.filter((finding) => finding.confidence >= threshold),
-    dropped: findings.filter((finding) => finding.confidence < threshold).map((finding) => ({ finding, reason: "low-confidence" }))
+    kept: findings.filter((finding) => meetsConfidenceThreshold(finding.confidence, threshold)),
+    dropped: findings.filter((finding) => !meetsConfidenceThreshold(finding.confidence, threshold)).map((finding) => ({ finding, reason: "low-confidence" }))
   };
 }
 function attemptRetry(options2) {
   const { factory, config: config3, delayFunction, onRetry, attempt } = options2;
   return factory().orElse((error48) => {
     if (attempt >= config3.maxAttempts) {
-      return (0, import_neverthrow32.errAsync)(error48);
+      return (0, import_neverthrow34.errAsync)(error48);
     }
     const delay = config3.baseDelayMs * Math.pow(2, attempt - 1);
-    return import_neverthrow32.ResultAsync.fromPromise(
+    return import_neverthrow34.ResultAsync.fromPromise(
       (onRetry?.({ attempt, maxAttempts: config3.maxAttempts, delayMs: delay, error: error48 }), delayFunction(delay)),
       () => error48
     ).andThen(
@@ -70625,7 +70815,7 @@ function withRetry(factory, options2) {
 var CONSOLIDATOR_AGENT = "consolidator";
 function analyserFallback(artifacts, onEvent) {
   onEvent?.({ type: "AGENT_FAILED_NON_CRITICAL", agent: "analyser", attempts: RETRY_MAX_ATTEMPTS });
-  return (0, import_neverthrow31.okAsync)(artifacts.findings);
+  return (0, import_neverthrow33.okAsync)(artifacts.findings);
 }
 function runAnalyserWithRetry(params) {
   const { artifacts, config: config3, onEvent } = params;
@@ -70635,7 +70825,7 @@ function runAnalyserWithRetry(params) {
     ),
     {
       config: { maxAttempts: RETRY_MAX_ATTEMPTS, baseDelayMs: RETRY_BASE_DELAY_MS },
-      delayFunction: import_promises15.setTimeout,
+      delayFunction: import_promises16.setTimeout,
       onRetry: ({ attempt, maxAttempts, delayMs, error: error48 }) => {
         onEvent?.({
           type: "AGENT_RETRY",
@@ -70655,7 +70845,7 @@ function resolveVisualFindings({
   onEvent
 }) {
   if (config3.analyser === void 0 || config3.signal?.aborted) {
-    return (0, import_neverthrow31.okAsync)(artifacts.findings);
+    return (0, import_neverthrow33.okAsync)(artifacts.findings);
   }
   return runAnalyserWithRetry({ artifacts, config: config3, onEvent });
 }
@@ -70665,7 +70855,7 @@ function unmergedFallback(allFindings, onEvent) {
     agent: CONSOLIDATOR_AGENT,
     message: "Consolidation failed, returning unmerged findings"
   });
-  return (0, import_neverthrow31.okAsync)({ findings: allFindings, dismissed: [] });
+  return (0, import_neverthrow33.okAsync)({ findings: allFindings, dismissed: [] });
 }
 function mergeWithFallback(options2) {
   const {
@@ -70692,7 +70882,7 @@ function consolidate(options2) {
   const { artifacts, inspectorFindings, runId, dismissals, config: config3, consolidatorConfig, onEvent } = options2;
   return resolveVisualFindings({ artifacts, config: config3, onEvent }).andThen((visualFindings) => {
     if (config3.signal?.aborted) {
-      return (0, import_neverthrow31.okAsync)({ findings: artifacts.findings, dismissed: [] });
+      return (0, import_neverthrow33.okAsync)({ findings: artifacts.findings, dismissed: [] });
     }
     return mergeWithFallback({
       artifacts,
@@ -70705,8 +70895,8 @@ function consolidate(options2) {
     });
   });
 }
-var safeReadFile = (0, import_neverthrow33.fromThrowable)((filePath) => (0, import_node_fs3.readFileSync)(filePath, "utf8"));
-var safeParseJson2 = (0, import_neverthrow33.fromThrowable)(JSON.parse);
+var safeReadFile = (0, import_neverthrow35.fromThrowable)((filePath) => (0, import_node_fs3.readFileSync)(filePath, "utf8"));
+var safeParseJson2 = (0, import_neverthrow35.fromThrowable)(JSON.parse);
 function isEnoent2(error48) {
   if (!(error48 instanceof Error)) {
     return false;
@@ -70718,19 +70908,19 @@ function loadDismissals(filePath) {
   const readResult = safeReadFile(filePath);
   if (readResult.isErr()) {
     if (isEnoent2(readResult.error)) {
-      return (0, import_neverthrow33.ok)([]);
+      return (0, import_neverthrow35.ok)([]);
     }
-    return (0, import_neverthrow33.err)({ type: "DISMISSALS_LOAD_FAILED", cause: readResult.error });
+    return (0, import_neverthrow35.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_neverthrow33.err)({
+      return (0, import_neverthrow35.err)({
         type: "DISMISSALS_LOAD_FAILED",
         cause: "invalid shape: dismissed is not an array"
       });
     }
-    return (0, import_neverthrow33.ok)(store.dismissed);
+    return (0, import_neverthrow35.ok)(store.dismissed);
   });
 }
 function toInspectorStepEvent(event) {
@@ -70817,14 +71007,14 @@ function runExplorerWithTeardown(explorerConfig, udid) {
   return runExplorer(explorerConfig).mapErr((cause) => ({ type: "EXPLORER_FAILED", cause })).andThen(
     (artifacts) => disableTouchIndicators(udid).mapErr(toSimulatorError).map(() => artifacts)
   ).orElse(
-    (error48) => disableTouchIndicators(udid).mapErr(toSimulatorError).andThen(() => (0, import_neverthrow34.errAsync)(error48)).orElse(() => (0, import_neverthrow34.errAsync)(error48))
+    (error48) => disableTouchIndicators(udid).mapErr(toSimulatorError).andThen(() => (0, import_neverthrow36.errAsync)(error48)).orElse(() => (0, import_neverthrow36.errAsync)(error48))
   );
 }
 function runExplorerWithRetry(options2) {
   const { explorerConfig, udid, onEvent } = options2;
   return withRetry(() => runExplorerWithTeardown(explorerConfig, udid), {
     config: { maxAttempts: RETRY_MAX_ATTEMPTS, baseDelayMs: RETRY_BASE_DELAY_MS },
-    delayFunction: import_promises16.setTimeout,
+    delayFunction: import_promises17.setTimeout,
     onRetry: ({ attempt, maxAttempts, delayMs, error: error48 }) => {
       onEvent?.({
         type: "AGENT_RETRY",
@@ -70843,12 +71033,12 @@ async function drainAfterExplorer(options2) {
   inspector?.close();
   const inspectorFindings = inspector ? await collectInspectorFindings({ inspector, onEvent, totalSteps: enqueuedCount.value }) : [];
   if (explorerResult.isErr()) {
-    return (0, import_neverthrow34.err)(explorerResult.error);
+    return (0, import_neverthrow36.err)(explorerResult.error);
   }
-  return (0, import_neverthrow34.ok)({ artifacts: explorerResult.value, inspectorFindings });
+  return (0, import_neverthrow36.ok)({ artifacts: explorerResult.value, inspectorFindings });
 }
 function runExplorerAndDrain(options2) {
-  return import_neverthrow34.ResultAsync.fromSafePromise(drainAfterExplorer(options2)).andThen((result) => result);
+  return import_neverthrow36.ResultAsync.fromSafePromise(drainAfterExplorer(options2)).andThen((result) => result);
 }
 function createDefaultMcpServers(udid) {
   return {
@@ -70860,7 +71050,7 @@ function runAnalysis(artifacts, config3) {
 }
 var ISO_DATE_LENGTH2 = 10;
 var RUN_ID_PAD_LENGTH = 4;
-var safeReaddirSync = (0, import_neverthrow30.fromThrowable)((directory) => (0, import_node_fs2.readdirSync)(directory));
+var safeReaddirSync = (0, import_neverthrow32.fromThrowable)((directory) => (0, import_node_fs2.readdirSync)(directory));
 function nextRunId(outputDirectory, date5) {
   const entries = safeReaddirSync(`${outputDirectory}/${date5}`).unwrapOr([]);
   let max = 0;
@@ -70872,7 +71062,7 @@ function nextRunId(outputDirectory, date5) {
   }
   return String(max + 1).padStart(RUN_ID_PAD_LENGTH, "0");
 }
-var writeOutputFile = (0, import_neverthrow30.fromThrowable)(
+var writeOutputFile = (0, import_neverthrow32.fromThrowable)(
   (params) => {
     const { findingsPath, outputDirectory, json: json3 } = params;
     (0, import_node_fs2.mkdirSync)(outputDirectory, { recursive: true });
@@ -70885,15 +71075,15 @@ function validatePipelineConfig(config3) {
   const runId = config3.runId ?? nextRunId(config3.outputDir, date5);
   const runPathsResult = resolveRunPaths({ outputDirectory: config3.outputDir, runId, date: date5 });
   if (runPathsResult.isErr()) {
-    return (0, import_neverthrow30.err)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
+    return (0, import_neverthrow32.err)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
   }
   const dismissalsResult = loadDismissals(
     dismissalsPath(config3.outputDir, process.env.QA_DISMISSALS_PATH)
   );
   if (dismissalsResult.isErr()) {
-    return (0, import_neverthrow30.err)(dismissalsResult.error);
+    return (0, import_neverthrow32.err)(dismissalsResult.error);
   }
-  return (0, import_neverthrow30.ok)({ runId, date: date5, runPaths: runPathsResult.value, dismissals: dismissalsResult.value });
+  return (0, import_neverthrow32.ok)({ runId, date: date5, runPaths: runPathsResult.value, dismissals: dismissalsResult.value });
 }
 function buildExplorerConfig({
   config: config3,
@@ -70931,11 +71121,11 @@ function buildOutput(consolidationResult, options2) {
 function buildPipelineSetup(config3) {
   const validatedResult = validatePipelineConfig(config3);
   if (validatedResult.isErr()) {
-    return (0, import_neverthrow30.err)(validatedResult.error);
+    return (0, import_neverthrow32.err)(validatedResult.error);
   }
   const { runId, date: date5, runPaths, dismissals } = validatedResult.value;
   const { inspector, explorerOnEvent, enqueuedCount } = buildInspectorSetup(config3);
-  return (0, import_neverthrow30.ok)({
+  return (0, import_neverthrow32.ok)({
     runId,
     udid: config3.simulatorUdid ?? "booted",
     runPaths,
@@ -70977,16 +71167,16 @@ function executePipeline(setup, config3) {
     })
   );
 }
-function runPipeline2(config3) {
+function runPipeline3(config3) {
   const setupResult = buildPipelineSetup(config3);
   if (setupResult.isErr()) {
-    return (0, import_neverthrow30.errAsync)(setupResult.error);
+    return (0, import_neverthrow32.errAsync)(setupResult.error);
   }
   return executePipeline(setupResult.value, config3);
 }
 
 // src/commands/analyse-command.ts
-var import_neverthrow36 = __toESM(require_index_cjs(), 1);
+var import_neverthrow38 = __toESM(require_index_cjs(), 1);
 
 // src/commands/item-events.ts
 function emitItemStart(identity, at) {
@@ -71022,7 +71212,7 @@ function emitItemFailed(input) {
 }
 
 // src/shell/debug-agent-events.ts
-var import_neverthrow35 = __toESM(require_index_cjs(), 1);
+var import_neverthrow37 = __toESM(require_index_cjs(), 1);
 
 // src/constants.ts
 var MOBILE_IOS_TOOLS = [
@@ -71105,7 +71295,7 @@ function tryStringify(value) {
   const result = JSON.stringify(value);
   return result ?? UNSERIALIZABLE;
 }
-var safeStringify = (0, import_neverthrow35.fromThrowable)(tryStringify, () => ({
+var safeStringify = (0, import_neverthrow37.fromThrowable)(tryStringify, () => ({
   type: "STRINGIFY_FAILED"
 }));
 function toolKey(scope, event) {
@@ -71326,7 +71516,7 @@ function buildArtifacts(videoPath) {
   return { videoPath, findings: [], snapshots: [] };
 }
 async function checkVideoPathExists(videoPath) {
-  const safeAccess = (0, import_neverthrow36.fromAsyncThrowable)(import_promises17.access, () => ({ type: "FILE_NOT_FOUND" }));
+  const safeAccess = (0, import_neverthrow38.fromAsyncThrowable)(import_promises18.access, () => ({ type: "FILE_NOT_FOUND" }));
   const result = await safeAccess(videoPath);
   return result.isOk();
 }
@@ -71421,7 +71611,7 @@ async function runAnalyseCommand(input) {
 }
 
 // src/core/completion-generator.ts
-var import_neverthrow37 = __toESM(require_index_cjs(), 1);
+var import_neverthrow39 = __toESM(require_index_cjs(), 1);
 function extractLongFlags(flags) {
   return flags.split(/[\s,]+/).filter((token) => token.startsWith("--"));
 }
@@ -71511,9 +71701,9 @@ complete -F _xqa_completion xqa`;
 }
 function generateCompletion(commands, shell) {
   if (shell !== "bash" && shell !== "zsh") {
-    return (0, import_neverthrow37.err)({ type: "UNSUPPORTED_SHELL", shell });
+    return (0, import_neverthrow39.err)({ type: "UNSUPPORTED_SHELL", shell });
   }
-  return (0, import_neverthrow37.ok)(shell === "zsh" ? generateZshCompletion(commands) : generateBashCompletion(commands));
+  return (0, import_neverthrow39.ok)(shell === "zsh" ? generateZshCompletion(commands) : generateBashCompletion(commands));
 }
 
 // src/commands/completion-command.ts
@@ -71546,33 +71736,33 @@ function runCompletionCommand(program3, shell) {
 }
 
 // src/commands/explore-command.ts
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
 
 // src/core/last-path.ts
 var import_node_fs4 = require("node:fs");
-var import_node_path8 = __toESM(require("node:path"), 1);
-var import_neverthrow38 = __toESM(require_index_cjs(), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
+var import_neverthrow40 = __toESM(require_index_cjs(), 1);
 function resolveLastPath(argument, stateContent) {
   if (argument !== void 0) {
-    return (0, import_neverthrow38.ok)(argument);
+    return (0, import_neverthrow40.ok)(argument);
   }
   const trimmed = stateContent?.trim();
   if (trimmed) {
-    return (0, import_neverthrow38.ok)(trimmed);
+    return (0, import_neverthrow40.ok)(trimmed);
   }
-  return (0, import_neverthrow38.err)({ type: "NO_ARG_AND_NO_STATE" });
+  return (0, import_neverthrow40.err)({ type: "NO_ARG_AND_NO_STATE" });
 }
 function lastPathFilePath(xqaDirectoryectory) {
-  return import_node_path8.default.join(xqaDirectoryectory, "last-findings-path");
+  return import_node_path9.default.join(xqaDirectoryectory, "last-findings-path");
 }
 function writeLastPath(xqaDirectory, findingsPath) {
   (0, import_node_fs4.writeFileSync)(lastPathFilePath(xqaDirectory), findingsPath);
 }
 
 // src/shell/app-context.ts
-var import_promises18 = require("node:fs/promises");
-var import_node_path9 = __toESM(require("node:path"), 1);
-var import_neverthrow39 = __toESM(require_index_cjs(), 1);
+var import_promises19 = require("node:fs/promises");
+var import_node_path10 = __toESM(require("node:path"), 1);
+var import_neverthrow41 = __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";
@@ -71582,10 +71772,10 @@ function toAppContextError(cause) {
 }
 function absentContext() {
   const absent = void 0;
-  return (0, import_neverthrow39.ok)(absent);
+  return (0, import_neverthrow41.ok)(absent);
 }
-var safeReadFile2 = import_neverthrow39.ResultAsync.fromThrowable(
-  async (filePath) => (0, import_promises18.readFile)(filePath, "utf8"),
+var safeReadFile2 = import_neverthrow41.ResultAsync.fromThrowable(
+  async (filePath) => (0, import_promises19.readFile)(filePath, "utf8"),
   toAppContextError
 );
 function stripAndNormalize(content) {
@@ -71593,12 +71783,12 @@ function stripAndNormalize(content) {
   return stripped.length === 0 ? void 0 : stripped;
 }
 function readContextFile(xqaDirectory, filename) {
-  const filePath = import_node_path9.default.join(xqaDirectory, filename);
+  const filePath = import_node_path10.default.join(xqaDirectory, filename);
   return safeReadFile2(filePath).map((content) => stripAndNormalize(content)).orElse((error48) => {
     if (isEnoentError(error48.cause)) {
       return absentContext();
     }
-    return (0, import_neverthrow39.err)(error48);
+    return (0, import_neverthrow41.err)(error48);
   });
 }
 function readAppContext(xqaDirectory) {
@@ -71647,12 +71837,12 @@ function buildPipelineConfig({
   simulatorUdid
 }) {
   const base = {
-    outputDir: import_node_path10.default.join(xqaDirectory, "output"),
+    outputDir: import_node_path11.default.join(xqaDirectory, "output"),
     runId: config3.QA_RUN_ID,
     simulatorUdid,
     onEvent,
     signal: input.signal,
-    inspector: { designsDirectory: import_node_path10.default.join(xqaDirectory, "designs") },
+    inspector: { designsDirectory: import_node_path11.default.join(xqaDirectory, "designs") },
     explorer
   };
   if (!config3.GOOGLE_GENERATIVE_AI_API_KEY) {
@@ -71714,7 +71904,7 @@ function runExplorePipeline(state, contexts) {
     appContext: contexts.appContext,
     initialState: contexts.exploreContext
   });
-  void runPipeline2(
+  void runPipeline3(
     buildPipelineConfig({
       input,
       config: config3,
@@ -71794,21 +71984,21 @@ function runExploreCommand(input, options2) {
 
 // src/commands/init-command.ts
 var import_node_fs6 = require("node:fs");
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 
 // src/commands/install-skills.ts
 var import_node_child_process5 = require("node:child_process");
 var import_node_fs5 = require("node:fs");
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
 var import_node_url = require("node:url");
 function resolveSkillsRoot() {
-  const packageDistributionDirectory = import_node_path11.default.dirname((0, import_node_url.fileURLToPath)(__importMetaUrl));
-  return import_node_path11.default.join(packageDistributionDirectory, "skills");
+  const packageDistributionDirectory = import_node_path12.default.dirname((0, import_node_url.fileURLToPath)(__importMetaUrl));
+  return import_node_path12.default.join(packageDistributionDirectory, "skills");
 }
 function installSkills() {
   const skillsRoot = resolveSkillsRoot();
   for (const skill of (0, import_node_fs5.readdirSync)(skillsRoot)) {
-    (0, import_node_child_process5.spawnSync)("npx", ["skills", "add", import_node_path11.default.join(skillsRoot, skill), "-y"], {
+    (0, import_node_child_process5.spawnSync)("npx", ["skills", "add", import_node_path12.default.join(skillsRoot, skill), "-y"], {
       stdio: "inherit"
     });
   }
@@ -71860,7 +72050,7 @@ Scope applies from the starting screen. If the focus area requires navigation, d
 -->
 `;
 function runInitCommand() {
-  const xqaDirectory = import_node_path12.default.join(process.cwd(), ".xqa");
+  const xqaDirectory = import_node_path13.default.join(process.cwd(), ".xqa");
   installSkills();
   if ((0, import_node_fs6.existsSync)(xqaDirectory)) {
     process.stdout.write(`Skills updated. .xqa already exists, skipping project init.
@@ -71868,12 +72058,12 @@ function runInitCommand() {
     return;
   }
   (0, import_node_fs6.mkdirSync)(xqaDirectory);
-  (0, import_node_fs6.writeFileSync)(import_node_path12.default.join(xqaDirectory, ".gitignore"), GITIGNORE_CONTENT);
-  (0, import_node_fs6.writeFileSync)(import_node_path12.default.join(xqaDirectory, "app.md"), APP_TEMPLATE);
-  (0, import_node_fs6.writeFileSync)(import_node_path12.default.join(xqaDirectory, "explore.md"), EXPLORE_TEMPLATE);
+  (0, import_node_fs6.writeFileSync)(import_node_path13.default.join(xqaDirectory, ".gitignore"), GITIGNORE_CONTENT);
+  (0, import_node_fs6.writeFileSync)(import_node_path13.default.join(xqaDirectory, "app.md"), APP_TEMPLATE);
+  (0, import_node_fs6.writeFileSync)(import_node_path13.default.join(xqaDirectory, "explore.md"), EXPLORE_TEMPLATE);
   for (const subdir of ["designs", "specs", "suites"]) {
-    (0, import_node_fs6.mkdirSync)(import_node_path12.default.join(xqaDirectory, subdir));
-    (0, import_node_fs6.writeFileSync)(import_node_path12.default.join(xqaDirectory, subdir, ".gitkeep"), "");
+    (0, import_node_fs6.mkdirSync)(import_node_path13.default.join(xqaDirectory, subdir));
+    (0, import_node_fs6.writeFileSync)(import_node_path13.default.join(xqaDirectory, subdir, ".gitkeep"), "");
   }
   process.stdout.write(`Initialized xqa project: ${xqaDirectory}
 `);
@@ -71885,8 +72075,8 @@ function runInitCommand() {
 
 // src/commands/review-command.ts
 var import_node_fs7 = require("node:fs");
-var import_node_path14 = __toESM(require("node:path"), 1);
-var import_neverthrow41 = __toESM(require_index_cjs(), 1);
+var import_node_path15 = __toESM(require("node:path"), 1);
+var import_neverthrow43 = __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 = []) => (
@@ -73224,7 +73414,7 @@ var esm_default2 = createPrompt((config3, done) => {
 var import_chardet = __toESM(require_lib2(), 1);
 var import_child_process3 = require("child_process");
 var import_fs3 = require("fs");
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 var import_node_os3 = __toESM(require("node:os"), 1);
 var import_node_crypto2 = require("node:crypto");
 var import_iconv_lite = __toESM(require_lib3(), 1);
@@ -73268,9 +73458,9 @@ var RemoveFileError = class extends Error {
 // ../../node_modules/.pnpm/@inquirer+external-editor@1.0.3_@types+node@22.19.15/node_modules/@inquirer/external-editor/dist/esm/index.js
 function editAsync(text = "", callback, fileOptions) {
   const editor = new ExternalEditor(text, fileOptions);
-  editor.runAsync((err25, result) => {
-    if (err25) {
-      setImmediate(callback, err25, void 0);
+  editor.runAsync((err26, result) => {
+    if (err26) {
+      setImmediate(callback, err26, void 0);
     } else {
       try {
         editor.cleanup();
@@ -73360,8 +73550,8 @@ var ExternalEditor = class {
       const prefix = sanitizeAffix(this.fileOptions.prefix);
       const postfix = sanitizeAffix(this.fileOptions.postfix);
       const filename = `${prefix}${id}${postfix}`;
-      const candidate = import_node_path13.default.resolve(baseDir, filename);
-      const baseResolved = import_node_path13.default.resolve(baseDir) + import_node_path13.default.sep;
+      const candidate = import_node_path14.default.resolve(baseDir, filename);
+      const baseResolved = import_node_path14.default.resolve(baseDir) + import_node_path14.default.sep;
       if (!candidate.startsWith(baseResolved)) {
         throw new Error("Resolved temporary file escaped the base directory");
       }
@@ -74291,11 +74481,10 @@ var esm_default11 = createPrompt((config3, done) => {
 });
 
 // src/review-session.ts
-var import_neverthrow40 = __toESM(require_index_cjs(), 1);
-var CONFIDENCE_PERCENT = 100;
+var import_neverthrow42 = __toESM(require_index_cjs(), 1);
 var FLOW_COL_WIDTH = 35;
 var TRIGGER_COL_WIDTH = 16;
-var CONFIDENCE_COL_WIDTH = 5;
+var CONFIDENCE_COL_WIDTH = 6;
 var COL_SEPARATOR_WIDTH = 6;
 var FIXED_COLS_WIDTH = FLOW_COL_WIDTH + TRIGGER_COL_WIDTH + CONFIDENCE_COL_WIDTH + COL_SEPARATOR_WIDTH;
 var DEFAULT_TERMINAL_WIDTH = 80;
@@ -74362,7 +74551,7 @@ function applyDismissal(dismissal, state) {
   state.stagedKeys.add(key);
 }
 async function selectFinding(findings, state) {
-  const activeSorted = findings.filter((finding) => !state.dismissedKeys.has(dismissalKey(finding))).toSorted((fa, fb2) => fa.confidence - fb2.confidence);
+  const activeSorted = findings.filter((finding) => !state.dismissedKeys.has(dismissalKey(finding))).toSorted((fa, fb2) => compareConfidence(fa.confidence, fb2.confidence));
   const reconsidered = activeSorted.filter(
     (finding) => state.undoneKeys.has(dismissalKey(finding))
   );
@@ -74401,9 +74590,7 @@ function buildChoiceName(finding, state) {
   const maxDescWidth = terminalWidth - CURSOR_MARGIN - FIXED_COLS_WIDTH - suffix.length;
   const flow = source_default.bold(finding.flow.padEnd(FLOW_COL_WIDTH));
   const triggerType = source_default.dim(finding.triggerType.padEnd(TRIGGER_COL_WIDTH));
-  const confidence = `${String(Math.round(finding.confidence * CONFIDENCE_PERCENT))}%`.padEnd(
-    CONFIDENCE_COL_WIDTH
-  );
+  const confidence = finding.confidence.padEnd(CONFIDENCE_COL_WIDTH);
   const rawDescription = finding.description.split(".")[0] ?? finding.description;
   const description = rawDescription.length > maxDescWidth ? `${rawDescription.slice(0, maxDescWidth - ELLIPSIS_LENGTH)}...` : rawDescription;
   return `${flow}  ${triggerType}  ${confidence}  ${description}${suffix ? source_default.dim(suffix) : ""}`;
@@ -74417,10 +74604,8 @@ function printDetail(finding) {
     process.stdout.write(`  ${String(index + 1)}. ${step}
 `);
   }
-  process.stdout.write(
-    `${source_default.bold("\nConfidence: ")}${String(Math.round(finding.confidence * CONFIDENCE_PERCENT))}%
-`
-  );
+  process.stdout.write(`${source_default.bold("\nConfidence: ")}${finding.confidence}
+`);
   if (finding.screenshots.length > 0) {
     process.stdout.write(source_default.bold("\nScreenshots:\n"));
     for (const screenshot of finding.screenshots) {
@@ -74444,15 +74629,15 @@ async function runInteractiveLoop(findings, existing) {
   }
   return { staged: state.staged, undoneKeys: state.undoneKeys };
 }
-var safeRunInteractiveLoop = (0, import_neverthrow40.fromAsyncThrowable)(
+var safeRunInteractiveLoop = (0, import_neverthrow42.fromAsyncThrowable)(
   runInteractiveLoop,
   (error48) => error48 instanceof Error && error48.name === "ExitPromptError" ? "exit-prompt" : "unexpected"
 );
 
 // src/commands/review-command.ts
-var safeReadFile3 = (0, import_neverthrow41.fromThrowable)((filePath) => (0, import_node_fs7.readFileSync)(filePath, "utf8"));
-var safeParseJson3 = (0, import_neverthrow41.fromThrowable)(JSON.parse);
-var safeWrite = (0, import_neverthrow41.fromThrowable)((filePath, content) => {
+var safeReadFile3 = (0, import_neverthrow43.fromThrowable)((filePath) => (0, import_node_fs7.readFileSync)(filePath, "utf8"));
+var safeParseJson3 = (0, import_neverthrow43.fromThrowable)(JSON.parse);
+var safeWrite = (0, import_neverthrow43.fromThrowable)((filePath, content) => {
   (0, import_node_fs7.writeFileSync)(filePath, content);
 });
 function readLastPath(xqaDirectory) {
@@ -74469,13 +74654,13 @@ function isPipelineOutput(data) {
 function readFindings(filePath) {
   const readResult = safeReadFile3(filePath);
   if (readResult.isErr()) {
-    return (0, import_neverthrow41.err)("not-found");
+    return (0, import_neverthrow43.err)("not-found");
   }
   return safeParseJson3(readResult.value).mapErr(() => "invalid").andThen((data) => {
     if (!isPipelineOutput(data)) {
-      return (0, import_neverthrow41.err)("invalid");
+      return (0, import_neverthrow43.err)("invalid");
     }
-    return (0, import_neverthrow41.ok)(data);
+    return (0, import_neverthrow43.ok)(data);
   });
 }
 function loadExistingDismissals(filePath) {
@@ -74548,7 +74733,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_neverthrow41.err)();
+    return (0, import_neverthrow43.err)();
   }
   const resolvedPath = resolvedPathResult.value;
   const findingsResult = readFindings(resolvedPath);
@@ -74561,9 +74746,9 @@ function resolveAndReadFindings(findingsPath, xqaDirectory) {
 `);
     }
     process.exit(1);
-    return (0, import_neverthrow41.err)();
+    return (0, import_neverthrow43.err)();
   }
-  return (0, import_neverthrow41.ok)({ resolvedPath, output: findingsResult.value });
+  return (0, import_neverthrow43.ok)({ resolvedPath, output: findingsResult.value });
 }
 async function runReviewLoop({
   findings,
@@ -74591,7 +74776,7 @@ async function executeReview({
     return;
   }
   const dismissalsFilePath = dismissalsPath(
-    import_node_path14.default.dirname(xqaDirectory),
+    import_node_path15.default.dirname(xqaDirectory),
     process.env.QA_DISMISSALS_PATH
   );
   await runReviewLoop({
@@ -74614,16 +74799,16 @@ async function runReviewCommand(findingsPath, xqaDirectory) {
 }
 
 // src/commands/spec-command.ts
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 
 // src/spec-slug.ts
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
 var SPECS_DIR = "specs";
 function stripExtensions(filename) {
   return filename.replace(/\.test\.md$/, "").replace(/\.[^.]+$/, "");
 }
 function deriveSpecSlug(specFilePath) {
-  const parts = specFilePath.split(import_node_path15.default.sep);
+  const parts = specFilePath.split(import_node_path16.default.sep);
   const specsIndex = parts.lastIndexOf(SPECS_DIR);
   if (specsIndex !== -1) {
     const relativeParts = parts.slice(specsIndex + 1);
@@ -74631,17 +74816,17 @@ function deriveSpecSlug(specFilePath) {
     relativeParts[relativeParts.length - 1] = stripExtensions(last);
     return relativeParts.join("__");
   }
-  return stripExtensions(import_node_path15.default.basename(specFilePath));
+  return stripExtensions(import_node_path16.default.basename(specFilePath));
 }
 
 // src/commands/spec-resolver.ts
 var import_node_fs8 = require("node:fs");
-var import_node_path16 = __toESM(require("node:path"), 1);
-var import_neverthrow43 = __toESM(require_index_cjs(), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
+var import_neverthrow45 = __toESM(require_index_cjs(), 1);
 
 // src/spec-frontmatter.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
-var import_neverthrow42 = __toESM(require_index_cjs(), 1);
+var import_neverthrow44 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports2 = {};
@@ -75381,8 +75566,8 @@ var ZodType2 = class {
         } : {
           issues: ctx.common.issues
         };
-      } catch (err25) {
-        if (err25?.message?.toLowerCase()?.includes("encountered")) {
+      } catch (err26) {
+        if (err26?.message?.toLowerCase()?.includes("encountered")) {
           this["~standard"].async = true;
         }
         ctx.common = {
@@ -78689,45 +78874,45 @@ var frontmatterSchema = external_exports2.object({
   feature: external_exports2.string().min(1),
   timeout: external_exports2.number().int().positive().optional()
 });
-var safeParseMatter = (0, import_neverthrow42.fromThrowable)(
+var safeParseMatter = (0, import_neverthrow44.fromThrowable)(
   import_gray_matter.default,
   (cause) => ({ type: "SPEC_FRONTMATTER_INVALID", cause })
 );
 function validate(data) {
   const parsed = frontmatterSchema.safeParse(data);
   if (!parsed.success) {
-    return (0, import_neverthrow42.err)({ type: "SPEC_FRONTMATTER_INVALID", cause: parsed.error });
+    return (0, import_neverthrow44.err)({ type: "SPEC_FRONTMATTER_INVALID", cause: parsed.error });
   }
   const { feature, timeout } = parsed.data;
   if (timeout === void 0) {
-    return (0, import_neverthrow42.ok)({ feature });
+    return (0, import_neverthrow44.ok)({ feature });
   }
-  return (0, import_neverthrow42.ok)({ feature, timeoutSeconds: timeout });
+  return (0, import_neverthrow44.ok)({ feature, timeoutSeconds: timeout });
 }
 function parseSpecFrontmatter(raw) {
   return safeParseMatter(raw).andThen((parsed) => validate(parsed.data));
 }
 
 // src/commands/spec-resolver.ts
-var safeReadFile4 = (0, import_neverthrow43.fromThrowable)((filePath) => (0, import_node_fs8.readFileSync)(filePath, "utf8"));
-var safeReaddir = (0, import_neverthrow43.fromThrowable)(
+var safeReadFile4 = (0, import_neverthrow45.fromThrowable)((filePath) => (0, import_node_fs8.readFileSync)(filePath, "utf8"));
+var safeReaddir = (0, import_neverthrow45.fromThrowable)(
   (directory) => (0, import_node_fs8.readdirSync)(directory, { recursive: true, encoding: "utf8" })
 );
 var CANCEL = "xqa:cancel";
-var safeSelect = import_neverthrow43.ResultAsync.fromThrowable(
+var safeSelect = import_neverthrow45.ResultAsync.fromThrowable(
   esm_default11,
   (error48) => error48 instanceof Error && error48.name === "ExitPromptError" ? "cancelled" : "failed"
 );
 function findSpecFiles(xqaDirectory) {
-  const specsDirectory = import_node_path16.default.join(xqaDirectory, "specs");
-  return safeReaddir(specsDirectory).unwrapOr([]).filter((file2) => file2.endsWith(".test.md")).map((file2) => import_node_path16.default.join(specsDirectory, file2));
+  const specsDirectory = import_node_path17.default.join(xqaDirectory, "specs");
+  return safeReaddir(specsDirectory).unwrapOr([]).filter((file2) => file2.endsWith(".test.md")).map((file2) => import_node_path17.default.join(specsDirectory, file2));
 }
 async function promptForSpec(specFiles, xqaDirectory) {
   const result = await safeSelect({
     message: "Select a spec",
     choices: [
       ...specFiles.map((specFile) => ({
-        name: import_node_path16.default.relative(xqaDirectory, specFile),
+        name: import_node_path17.default.relative(xqaDirectory, specFile),
         value: specFile
       })),
       new Separator(),
@@ -78786,10 +78971,10 @@ function buildSpecExplorer(input, context) {
 }
 function buildPipelineConfig2({ input, context, onEvent }) {
   return {
-    outputDir: import_node_path17.default.join(context.xqaDirectory, "output", context.slug),
+    outputDir: import_node_path18.default.join(context.xqaDirectory, "output", context.slug),
     signal: input.signal,
     onEvent,
-    inspector: { designsDirectory: import_node_path17.default.join(context.xqaDirectory, "designs") },
+    inspector: { designsDirectory: import_node_path18.default.join(context.xqaDirectory, "designs") },
     explorer: buildSpecExplorer(input, context)
   };
 }
@@ -78833,7 +79018,7 @@ async function executeSpec(input, context) {
   const identity = {
     display: createSoloDisplay(input.verbose),
     itemId: "spec",
-    itemName: import_node_path17.default.basename(context.absolutePath, ".test.md"),
+    itemName: import_node_path18.default.basename(context.absolutePath, ".test.md"),
     simulatorUdid: ""
   };
   const startedAt = Date.now();
@@ -78844,7 +79029,7 @@ async function executeSpec(input, context) {
   };
   const onEvent = debugLogger.wrapAgentHandler(baseHandler);
   const { onSuccess, onError } = handleSpecResult({ identity, startedAt }, context);
-  const result = await runPipeline2(buildPipelineConfig2({ input, context, onEvent }));
+  const result = await runPipeline3(buildPipelineConfig2({ input, context, onEvent }));
   result.match(onSuccess, onError);
 }
 function handleAppContextError(error48) {
@@ -78874,7 +79059,7 @@ async function resolveSpecContext(input, options2) {
   if (resolvedSpecFile === void 0) {
     return;
   }
-  const absolutePath = import_node_path17.default.resolve(resolvedSpecFile);
+  const absolutePath = import_node_path18.default.resolve(resolvedSpecFile);
   const frontmatter = readAndParseSpec(absolutePath);
   if (frontmatter === void 0) {
     return;
@@ -78895,7 +79080,7 @@ async function runSpecCommand(input, options2) {
 }
 
 // ../../agents/triager/dist/index.js
-var import_neverthrow44 = __toESM(require_index_cjs(), 1);
+var import_neverthrow46 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.87.0_zod@3.25.76/node_modules/@anthropic-ai/sdk/internal/tslib.mjs
 function __classPrivateFieldSet2(receiver, state, value, kind, f6) {
@@ -78928,34 +79113,34 @@ var uuid43 = function() {
 };
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.87.0_zod@3.25.76/node_modules/@anthropic-ai/sdk/internal/errors.mjs
-function isAbortError2(err25) {
-  return typeof err25 === "object" && err25 !== null && // Spec-compliant fetch implementations
-  ("name" in err25 && err25.name === "AbortError" || // Expo fetch
-  "message" in err25 && String(err25.message).includes("FetchRequestCanceledException"));
-}
-var castToError2 = (err25) => {
-  if (err25 instanceof Error)
-    return err25;
-  if (typeof err25 === "object" && err25 !== null) {
+function isAbortError2(err26) {
+  return typeof err26 === "object" && err26 !== null && // Spec-compliant fetch implementations
+  ("name" in err26 && err26.name === "AbortError" || // Expo fetch
+  "message" in err26 && String(err26.message).includes("FetchRequestCanceledException"));
+}
+var castToError2 = (err26) => {
+  if (err26 instanceof Error)
+    return err26;
+  if (typeof err26 === "object" && err26 !== null) {
     try {
-      if (Object.prototype.toString.call(err25) === "[object Error]") {
-        const error48 = new Error(err25.message, err25.cause ? { cause: err25.cause } : {});
-        if (err25.stack)
-          error48.stack = err25.stack;
-        if (err25.cause && !error48.cause)
-          error48.cause = err25.cause;
-        if (err25.name)
-          error48.name = err25.name;
+      if (Object.prototype.toString.call(err26) === "[object Error]") {
+        const error48 = new Error(err26.message, err26.cause ? { cause: err26.cause } : {});
+        if (err26.stack)
+          error48.stack = err26.stack;
+        if (err26.cause && !error48.cause)
+          error48.cause = err26.cause;
+        if (err26.name)
+          error48.name = err26.name;
         return error48;
       }
     } catch {
     }
     try {
-      return new Error(JSON.stringify(err25));
+      return new Error(JSON.stringify(err26));
     } catch {
     }
   }
-  return new Error(err25);
+  return new Error(err26);
 };
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.87.0_zod@3.25.76/node_modules/@anthropic-ai/sdk/core/error.mjs
@@ -79085,7 +79270,7 @@ var validatePositiveInteger2 = (name, n3) => {
 var safeJSON2 = (text) => {
   try {
     return JSON.parse(text);
-  } catch (err25) {
+  } catch (err26) {
     return void 0;
   }
 };
@@ -79649,8 +79834,8 @@ var Stream2 = class _Stream {
             return ctrl.close();
           const bytes = encodeUTF82(JSON.stringify(value) + "\n");
           ctrl.enqueue(bytes);
-        } catch (err25) {
-          ctrl.error(err25);
+        } catch (err26) {
+          ctrl.error(err26);
         }
       },
       async cancel() {
@@ -81557,8 +81742,8 @@ var BetaMessageStream2 = class _BetaMessageStream {
               if (jsonBuf) {
                 try {
                   newContent.input = partialParse2(jsonBuf);
-                } catch (err25) {
-                  const error48 = new AnthropicError2(`Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${err25}. JSON: ${jsonBuf}`);
+                } catch (err26) {
+                  const error48 = new AnthropicError2(`Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${err26}. JSON: ${jsonBuf}`);
                   __classPrivateFieldGet2(this, _BetaMessageStream_handleError2, "f").call(this, error48);
                 }
               }
@@ -81620,17 +81805,17 @@ var BetaMessageStream2 = class _BetaMessageStream {
       }
       readQueue.length = 0;
     });
-    this.on("abort", (err25) => {
+    this.on("abort", (err26) => {
       done = true;
       for (const reader of readQueue) {
-        reader.reject(err25);
+        reader.reject(err26);
       }
       readQueue.length = 0;
     });
-    this.on("error", (err25) => {
+    this.on("error", (err26) => {
       done = true;
       for (const reader of readQueue) {
-        reader.reject(err25);
+        reader.reject(err26);
       }
       readQueue.length = 0;
     });
@@ -83873,17 +84058,17 @@ var MessageStream2 = class _MessageStream {
       }
       readQueue.length = 0;
     });
-    this.on("abort", (err25) => {
+    this.on("abort", (err26) => {
       done = true;
       for (const reader of readQueue) {
-        reader.reject(err25);
+        reader.reject(err26);
       }
       readQueue.length = 0;
     });
-    this.on("error", (err25) => {
+    this.on("error", (err26) => {
       done = true;
       for (const reader of readQueue) {
-        reader.reject(err25);
+        reader.reject(err26);
       }
       readQueue.length = 0;
     });
@@ -84463,7 +84648,7 @@ var BaseAnthropic2 = class {
       }
       const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
       loggerFor2(this).info(`${responseInfo} - ${retryMessage}`);
-      const errText = await response.text().catch((err26) => castToError2(err26).message);
+      const errText = await response.text().catch((err27) => castToError2(err27).message);
       const errJSON = safeJSON2(errText);
       const errMessage = errJSON ? void 0 : errText;
       loggerFor2(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails2({
@@ -84474,8 +84659,8 @@ var BaseAnthropic2 = class {
         message: errMessage,
         durationMs: Date.now() - startTime
       }));
-      const err25 = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
-      throw err25;
+      const err26 = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
+      throw err26;
     }
     loggerFor2(this).info(responseInfo);
     loggerFor2(this).debug(`[${requestLogID}] response start`, formatRequestDetails2({
@@ -84686,7 +84871,7 @@ Anthropic2.Models = Models4;
 Anthropic2.Beta = Beta2;
 
 // ../../agents/triager/dist/index.js
-var import_neverthrow45 = __toESM(require_index_cjs(), 1);
+var import_neverthrow47 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js
 var balanced = (a3, b, str3) => {
@@ -86492,16 +86677,16 @@ minimatch.unescape = unescape2;
 
 // ../../agents/triager/dist/index.js
 var MAX_TOKENS3 = 1024;
+var THINKING_BUDGET_TOKENS = 1024;
 var TEMPERATURE3 = 0;
 var TOOL_NAME = "select_test_groups";
+var pickSchema = external_exports2.object({
+  groupId: external_exports2.string(),
+  reason: external_exports2.string(),
+  confidence: external_exports2.enum(["HIGH", "MEDIUM", "LOW"])
+});
 var toolInputSchema = external_exports2.object({
-  picks: external_exports2.array(
-    external_exports2.object({
-      groupId: external_exports2.string(),
-      score: external_exports2.number(),
-      reason: external_exports2.string()
-    })
-  )
+  picks: external_exports2.array(pickSchema)
 });
 var TOOL_DEFINITION = {
   name: TOOL_NAME,
@@ -86515,16 +86700,17 @@ var TOOL_DEFINITION = {
           type: "object",
           properties: {
             groupId: { type: "string" },
-            score: { type: "number" },
-            reason: { type: "string" }
+            reason: { type: "string" },
+            confidence: { type: "string", enum: ["HIGH", "MEDIUM", "LOW"] }
           },
-          required: ["groupId", "score", "reason"]
+          required: ["groupId", "reason", "confidence"]
         }
       }
     },
     required: ["picks"]
   }
 };
+var GRADER_SYSTEM_PROMPT = "Act as a senior QA auditor reviewing another engineer's test selection. For each pick below, confirm HIGH, confirm MEDIUM, or downgrade to LOW. Require citing the file path driving your verdict. Respond via the select_test_groups tool.";
 function findToolUseInput(response) {
   const block = response.content.find((entry) => entry.type === "tool_use");
   if (block?.type !== "tool_use") {
@@ -86538,63 +86724,79 @@ function serialiseResponse(response) {
 function parseToolResponse(response) {
   const input = findToolUseInput(response);
   if (input === void 0) {
-    return (0, import_neverthrow45.err)({ type: "AI_INVALID_RESPONSE", raw: serialiseResponse(response) });
+    return (0, import_neverthrow47.err)({ type: "AI_INVALID_RESPONSE", raw: serialiseResponse(response) });
   }
   const parsed = toolInputSchema.safeParse(input);
   if (!parsed.success) {
-    return (0, import_neverthrow45.err)({ type: "AI_INVALID_RESPONSE", raw: JSON.stringify(input) });
+    return (0, import_neverthrow47.err)({ type: "AI_INVALID_RESPONSE", raw: JSON.stringify(input) });
   }
-  return (0, import_neverthrow45.ok)(parsed.data.picks);
+  return (0, import_neverthrow47.ok)(parsed.data.picks);
+}
+function filterKnownGroupIds(picks, validGroupIds) {
+  const validIds = new Set(validGroupIds);
+  return picks.filter((pick2) => validIds.has(pick2.groupId));
 }
 async function fetchSelection(options2) {
-  const { anthropic, prompt, model } = options2;
-  return anthropic.messages.create({
+  const { anthropic, prompt, model, systemPrompt } = options2;
+  const base = {
     model,
     max_tokens: MAX_TOKENS3,
     temperature: TEMPERATURE3,
+    thinking: { type: "enabled", budget_tokens: THINKING_BUDGET_TOKENS },
     tools: [TOOL_DEFINITION],
     tool_choice: { type: "tool", name: TOOL_NAME },
     messages: [{ role: "user", content: prompt }]
-  });
+  };
+  if (systemPrompt !== void 0) {
+    return anthropic.messages.create({ ...base, system: systemPrompt });
+  }
+  return anthropic.messages.create(base);
+}
+function buildGraderPrompt(originalPicks, basePrompt) {
+  const picksText = originalPicks.map((pick2) => `- groupId: ${pick2.groupId}
+  reason: ${pick2.reason}`).join("\n");
+  return `${basePrompt}
+
+## Picks Under Review
+
+${picksText}`;
 }
 function selectGroups(options2) {
   const anthropic = new Anthropic2({ apiKey: options2.apiKey });
-  return (0, import_neverthrow45.fromAsyncThrowable)(
+  return (0, import_neverthrow47.fromAsyncThrowable)(
     fetchSelection,
     (cause) => ({ type: "AI_CALL_FAILED", cause })
-  )({ anthropic, prompt: options2.prompt, model: options2.model }).andThen(parseToolResponse);
+  )({ anthropic, prompt: options2.prompt, model: options2.model }).andThen(parseToolResponse).map((picks) => filterKnownGroupIds(picks, options2.validGroupIds));
 }
-var HIGH_CONFIDENCE_THRESHOLD = 0.5;
-function resolveConfidence(selected) {
-  if (selected.some((pick2) => pick2.score >= HIGH_CONFIDENCE_THRESHOLD)) {
+function graderSelectGroups(options2) {
+  const anthropic = new Anthropic2({ apiKey: options2.apiKey });
+  const graderPrompt = buildGraderPrompt(options2.originalPicks, options2.prompt);
+  return (0, import_neverthrow47.fromAsyncThrowable)(
+    fetchSelection,
+    (cause) => ({ type: "AI_CALL_FAILED", cause })
+  )({ anthropic, prompt: graderPrompt, model: options2.model, systemPrompt: GRADER_SYSTEM_PROMPT }).andThen(parseToolResponse).map((picks) => filterKnownGroupIds(picks, options2.validGroupIds));
+}
+function resolveConfidence2(selected) {
+  if (selected.some((pick2) => pick2.confidence === "HIGH")) {
     return "high";
   }
-  if (selected.length > 0) {
+  if (selected.some((pick2) => pick2.confidence === "MEDIUM")) {
     return "medium";
   }
   return "low";
 }
-function buildDecision(picks, threshold) {
-  const selected = picks.filter((pick2) => pick2.score >= threshold);
-  const skipped = picks.filter((pick2) => pick2.score < threshold);
+function buildDecision(picks) {
+  const selected = picks.filter((pick2) => pick2.confidence !== "LOW");
+  const skipped = picks.filter((pick2) => pick2.confidence === "LOW");
   return {
     picks: selected,
     skipped,
-    confidence: resolveConfidence(selected)
+    confidence: resolveConfidence2(selected)
   };
 }
-var MIN_SCORE = 0;
-var MAX_SCORE = 1;
+var HIGH_MATCH_RATIO = 0.7;
+var MEDIUM_MATCH_RATIO = 0.3;
 var REASON_SAMPLE_LIMIT = 3;
-function clampScore(value) {
-  if (value < MIN_SCORE) {
-    return MIN_SCORE;
-  }
-  if (value > MAX_SCORE) {
-    return MAX_SCORE;
-  }
-  return value;
-}
 function matchesAnyGlob(path27, patterns) {
   return patterns.some((pattern) => minimatch(path27, pattern));
 }
@@ -86605,6 +86807,19 @@ function formatReason(parts) {
   const sample = parts.paths.slice(0, REASON_SAMPLE_LIMIT).join(", ");
   return `matched ${String(parts.matches)}/${String(parts.total)} files: ${sample}`;
 }
+function resolvePickConfidence(matches, total) {
+  if (total === 0 || matches === 0) {
+    return void 0;
+  }
+  const ratio = matches / total;
+  if (ratio >= HIGH_MATCH_RATIO) {
+    return "HIGH";
+  }
+  if (ratio >= MEDIUM_MATCH_RATIO) {
+    return "MEDIUM";
+  }
+  return "LOW";
+}
 function scoreGroup(diff, group) {
   if (!group.covers || group.covers.length === 0) {
     return void 0;
@@ -86612,28 +86827,62 @@ function scoreGroup(diff, group) {
   const total = diff.files.length;
   const matchingPaths = collectMatchingPaths(diff, group.covers);
   const matches = matchingPaths.length;
-  const score = total === 0 ? 0 : clampScore(matches / total);
+  const confidence = resolvePickConfidence(matches, total);
+  if (confidence === void 0) {
+    return void 0;
+  }
   return {
     groupId: group.id,
-    score,
+    confidence,
     reason: formatReason({ matches, total, paths: matchingPaths })
   };
 }
 function scoreGroups(diff, groups) {
   return groups.map((group) => scoreGroup(diff, group)).filter((pick2) => pick2 !== void 0);
 }
-var HEADER = `You are a QA engineer selecting which test groups to run against a pull request. Each group covers a surface of the product. Pick the groups whose coverage overlaps with the changed files. Skip groups unrelated to this change.`;
+var MAX_BODY_CHARS = 400;
+var HEADER = `You are a QA engineer selecting which test groups to run against a pull request. Each group covers a product surface. Err toward inclusion \u2014 a missed regression is far worse than wasted CI minutes.`;
 var INSTRUCTIONS = `Call the \`select_test_groups\` tool with an array of picks. For each selected group include:
-- \`groupId\`: the exact id from the list below
-- \`score\`: a number in [0, 1] indicating how strongly the change exercises this group
-- \`reason\`: a short justification grounded in the changed files`;
+- \`groupId\`: an id that appears verbatim in the Test Groups list below \u2014 do not invent, paraphrase, or infer ids
+- \`reason\`: cite the specific file path(s) and which \`covers\` glob or heuristic matched; write the reason first; only then commit to HIGH/MEDIUM/LOW
+- \`confidence\`: label using the rubric below
+
+If no group is relevant, call the tool with \`picks: []\`.
+
+### Confidence rubric
+
+- HIGH: change clearly exercises this group \u2014 changed files are the primary implementation or directly call/are called by covered paths
+- MEDIUM: shared dependency or indirect but plausible \u2014 change modifies a shared dependency of covered paths or has a tangential but credible relationship
+- LOW: tangential \u2014 the heuristics would force inclusion but only as a safety net
+
+### Selection heuristics
+
+- Config or infra changes (\`*.yaml\`, \`*.json\`, \`Dockerfile\`, \`*.tf\`) fan out broadly \u2014 include integration and e2e groups
+- Shared utility changes (\`**/core/**\`, \`**/utils/**\`, \`**/shared/**\`) fan out to consumers \u2014 include every group that depends on them
+- Doc-only changes (\`*.md\`, \`*.mdx\`, \`docs/**\`) \u2014 return empty picks
+- Test-only changes (\`*.test.*\`, \`__tests__/**\`) \u2014 skip execution groups unless production code in the same diff requires them
+- Breaking API changes (deleted exports, renamed public types) \u2014 include every group (full regression)
+- Deleted files \u2014 groups that covered the deleted path must still run to verify no breakage
+
+### Process
+
+Before emitting picks, list the changed areas, then match each to candidate groups. If two groups overlap on the same file, include both and give the more specific one a higher confidence. When uncertain, include the group.`;
 function formatFile(file2) {
-  return `- [${file2.status}] ${file2.path}`;
+  const hunkCount = file2.hunks?.length ?? 0;
+  const hunkSuffix = hunkCount > 0 ? ` (${String(hunkCount)} hunk(s))` : "";
+  return `- [${file2.status}] ${file2.path}${hunkSuffix}`;
+}
+function formatBody(body) {
+  if (!body) {
+    return "Body: (none)";
+  }
+  const trimmed = body.length > MAX_BODY_CHARS ? `${body.slice(0, MAX_BODY_CHARS)}\u2026` : body;
+  return `Body:
+${trimmed}`;
 }
 function formatDiffSection(diff) {
   const title = diff.title ? `Title: ${diff.title}` : "Title: (none)";
-  const body = diff.body ? `Body:
-${diff.body}` : "Body: (none)";
+  const body = formatBody(diff.body);
   const files = diff.files.map((file2) => formatFile(file2)).join("\n");
   return `${title}
 ${body}
@@ -86659,20 +86908,40 @@ function formatGroupsSection(groups) {
 function buildTriagerPrompt(diff, groups) {
   return `${HEADER}
 
+## Instructions
+
+${INSTRUCTIONS}
+
 ## Change
 
 ${formatDiffSection(diff)}
 
 ## Test Groups
 
-${formatGroupsSection(groups)}
-
-## Instructions
-
-${INSTRUCTIONS}`;
+${formatGroupsSection(groups)}`;
 }
 var DEFAULT_MODEL2 = "claude-opus-4-6";
-var DEFAULT_SCORE_THRESHOLD = 0.3;
+var CONFIDENCE_RANK = {
+  HIGH: 2,
+  MEDIUM: 1,
+  LOW: 0
+};
+function applyGraderResults(mediumPicks, graderPicks) {
+  const graderById = /* @__PURE__ */ new Map();
+  for (const pick2 of graderPicks) {
+    graderById.set(pick2.groupId, pick2);
+  }
+  return mediumPicks.flatMap((pick2) => {
+    const graderResult = graderById.get(pick2.groupId);
+    if (graderResult === void 0) {
+      return [pick2];
+    }
+    if (graderResult.confidence === "LOW") {
+      return [];
+    }
+    return [graderResult];
+  });
+}
 function buildContext2(options2) {
   const { diff, groups, config: config3 } = options2;
   return {
@@ -86680,10 +86949,27 @@ function buildContext2(options2) {
     groups,
     apiKey: config3?.apiKey ?? "",
     model: config3?.model ?? DEFAULT_MODEL2,
-    threshold: config3?.scoreThreshold ?? DEFAULT_SCORE_THRESHOLD,
     useAi: config3?.useAi ?? true
   };
 }
+function mapAiError(error48) {
+  switch (error48.type) {
+    case "AI_CALL_FAILED": {
+      return { type: "AI_CALL_FAILED", cause: error48.cause };
+    }
+    case "AI_INVALID_RESPONSE": {
+      return { type: "AI_INVALID_RESPONSE", raw: error48.raw };
+    }
+  }
+}
+function mergePickPair(existing, incoming) {
+  const existingRank = CONFIDENCE_RANK[existing.confidence];
+  const incomingRank = CONFIDENCE_RANK[incoming.confidence];
+  if (incomingRank > existingRank) {
+    return incoming;
+  }
+  return existing;
+}
 function mergePicks(staticPicks, aiPicks) {
   const byId = /* @__PURE__ */ new Map();
   for (const pick2 of staticPicks) {
@@ -86691,48 +86977,64 @@ function mergePicks(staticPicks, aiPicks) {
   }
   for (const pick2 of aiPicks) {
     const existing = byId.get(pick2.groupId);
-    if (!existing || pick2.score > existing.score) {
+    if (existing === void 0) {
       byId.set(pick2.groupId, pick2);
+    } else {
+      byId.set(pick2.groupId, mergePickPair(existing, pick2));
     }
   }
   return [...byId.values()];
 }
+function runGraderPass(options2) {
+  const { context, prompt, mediumPicks, highPicks, skippedPicks } = options2;
+  const validGroupIds = context.groups.map((group) => group.id);
+  return graderSelectGroups({
+    prompt,
+    apiKey: context.apiKey,
+    model: context.model,
+    validGroupIds,
+    originalPicks: mediumPicks
+  }).mapErr(mapAiError).map((graderPicks) => {
+    const survivingMedium = applyGraderResults(mediumPicks, graderPicks);
+    const downgraded = mediumPicks.filter((pick2) => !survivingMedium.some((kept) => kept.groupId === pick2.groupId)).map((pick2) => ({ ...pick2, confidence: "LOW" }));
+    return buildDecision([...highPicks, ...survivingMedium, ...skippedPicks, ...downgraded]);
+  });
+}
+function runAiTiebreaker(context, staticPicks) {
+  const prompt = buildTriagerPrompt(context.diff, context.groups);
+  const validGroupIds = context.groups.map((group) => group.id);
+  return selectGroups({ prompt, apiKey: context.apiKey, model: context.model, validGroupIds }).mapErr(mapAiError).map((aiPicks) => mergePicks(staticPicks, aiPicks)).andThen((merged) => {
+    const highPicks = merged.filter((pick2) => pick2.confidence === "HIGH");
+    const mediumPicks = merged.filter((pick2) => pick2.confidence === "MEDIUM");
+    const skippedPicks = merged.filter((pick2) => pick2.confidence === "LOW");
+    if (mediumPicks.length === 0) {
+      return (0, import_neverthrow46.okAsync)(buildDecision(merged));
+    }
+    return runGraderPass({ context, prompt, mediumPicks, highPicks, skippedPicks });
+  });
+}
 function shouldSkipAi(context, decision) {
   if (!context.useAi) {
     return true;
   }
   return decision.confidence === "high";
 }
-function mapAiError(error48) {
-  switch (error48.type) {
-    case "AI_CALL_FAILED": {
-      return { type: "AI_CALL_FAILED", cause: error48.cause };
-    }
-    case "AI_INVALID_RESPONSE": {
-      return { type: "AI_INVALID_RESPONSE", raw: error48.raw };
-    }
-  }
-}
-function runAiTiebreaker(context, staticPicks) {
-  const prompt = buildTriagerPrompt(context.diff, context.groups);
-  return selectGroups({ prompt, apiKey: context.apiKey, model: context.model }).mapErr(mapAiError).map((aiPicks) => mergePicks(staticPicks, aiPicks)).map((merged) => buildDecision(merged, context.threshold));
-}
 function runTriager(options2) {
   const { diff, groups, config: config3 } = options2;
   if (groups.length === 0) {
-    return (0, import_neverthrow44.errAsync)({ type: "NO_GROUPS" });
+    return (0, import_neverthrow46.errAsync)({ type: "NO_GROUPS" });
   }
   const context = buildContext2({ diff, groups, config: config3 });
   const staticPicks = scoreGroups(diff, groups);
-  const initial = buildDecision(staticPicks, context.threshold);
+  const initial = buildDecision(staticPicks);
   if (shouldSkipAi(context, initial)) {
-    return (0, import_neverthrow44.okAsync)(initial);
+    return (0, import_neverthrow46.okAsync)(initial);
   }
   return runAiTiebreaker(context, staticPicks);
 }
 
 // src/commands/triage-command.ts
-var import_neverthrow49 = __toESM(require_index_cjs(), 1);
+var import_neverthrow51 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/universal-user-agent@7.0.3/node_modules/universal-user-agent/index.js
 function getUserAgent() {
@@ -87330,7 +87632,7 @@ async function getResponseData(response) {
     try {
       text = await response.text();
       return JSON.parse(text);
-    } catch (err25) {
+    } catch (err26) {
       return text;
     }
   } else if (mimetype.type.startsWith("text/") || mimetype.parameters.charset?.toLowerCase() === "utf-8") {
@@ -90282,7 +90584,7 @@ var Octokit2 = Octokit.plugin(requestLog, legacyRestEndpointMethods, paginateRes
 );
 
 // src/triage/github-pr-fetcher.ts
-var import_neverthrow46 = __toESM(require_index_cjs(), 1);
+var import_neverthrow48 = __toESM(require_index_cjs(), 1);
 var STATUS_MAP = {
   added: "added",
   modified: "modified",
@@ -90318,11 +90620,11 @@ async function runListFiles(octokit, options2) {
     per_page: 100
   });
 }
-var safeGet = import_neverthrow46.ResultAsync.fromThrowable(
+var safeGet = import_neverthrow48.ResultAsync.fromThrowable(
   runPullRequestGet,
   (cause) => ({ type: "PR_FETCH_FAILED", cause })
 );
-var safeList = import_neverthrow46.ResultAsync.fromThrowable(
+var safeList = import_neverthrow48.ResultAsync.fromThrowable(
   runListFiles,
   (cause) => ({ type: "PR_FETCH_FAILED", cause })
 );
@@ -90336,13 +90638,13 @@ function toDiff(summary, files) {
 }
 function fetchPullRequestDiff(options2) {
   const octokit = new Octokit2({ auth: options2.token });
-  return import_neverthrow46.ResultAsync.combine([safeGet(octokit, options2), safeList(octokit, options2)]).map(
+  return import_neverthrow48.ResultAsync.combine([safeGet(octokit, options2), safeList(octokit, options2)]).map(
     ([summary, files]) => toDiff(summary, files)
   );
 }
 
 // src/triage/github-pr-labeller.ts
-var import_neverthrow47 = __toESM(require_index_cjs(), 1);
+var import_neverthrow49 = __toESM(require_index_cjs(), 1);
 async function runAddLabels(octokit, options2) {
   await octokit.issues.addLabels({
     owner: options2.owner,
@@ -90351,7 +90653,7 @@ async function runAddLabels(octokit, options2) {
     labels: [...options2.labels]
   });
 }
-var safeAddLabels = import_neverthrow47.ResultAsync.fromThrowable(
+var safeAddLabels = import_neverthrow49.ResultAsync.fromThrowable(
   runAddLabels,
   (cause) => ({ type: "LABEL_APPLY_FAILED", cause })
 );
@@ -90382,9 +90684,9 @@ function formatXqaLabels(decision) {
 }
 
 // src/triage/suite-loader.ts
-var import_promises19 = require("node:fs/promises");
-var import_node_path18 = __toESM(require("node:path"), 1);
-var import_neverthrow48 = __toESM(require_index_cjs(), 1);
+var import_promises20 = require("node:fs/promises");
+var import_node_path19 = __toESM(require("node:path"), 1);
+var import_neverthrow50 = __toESM(require_index_cjs(), 1);
 var SUITE_FILE_SUFFIX = ".suite.json";
 var freestyleEntrySchema = external_exports2.object({
   timeoutSeconds: external_exports2.number().int().positive()
@@ -90394,39 +90696,39 @@ var suiteFileSchema = external_exports2.object({
   freestyle: external_exports2.array(freestyleEntrySchema).optional(),
   hooks: external_exports2.record(external_exports2.unknown()).optional()
 });
-var safeJsonParse4 = (0, import_neverthrow48.fromThrowable)(JSON.parse);
+var safeJsonParse4 = (0, import_neverthrow50.fromThrowable)(JSON.parse);
 async function runReadFile(filePath) {
-  return (0, import_promises19.readFile)(filePath, "utf8");
+  return (0, import_promises20.readFile)(filePath, "utf8");
 }
 async function runStat(filePath) {
-  return (0, import_promises19.stat)(filePath);
+  return (0, import_promises20.stat)(filePath);
 }
 async function runReadDirectory(filePath) {
-  return (0, import_promises19.readdir)(filePath);
+  return (0, import_promises20.readdir)(filePath);
 }
 function readSuiteFile(filePath) {
-  const safeRead = import_neverthrow48.ResultAsync.fromThrowable(
+  const safeRead = import_neverthrow50.ResultAsync.fromThrowable(
     runReadFile,
     (cause) => ({ type: "SUITE_READ_FAILED", path: filePath, cause })
   );
   return safeRead(filePath);
 }
 function readSpecFile(filePath) {
-  const safeRead = import_neverthrow48.ResultAsync.fromThrowable(
+  const safeRead = import_neverthrow50.ResultAsync.fromThrowable(
     runReadFile,
     () => ({ type: "SPEC_NOT_FOUND", path: filePath })
   );
   return safeRead(filePath);
 }
 function statDirectory(directory) {
-  const safeStat = import_neverthrow48.ResultAsync.fromThrowable(
+  const safeStat = import_neverthrow50.ResultAsync.fromThrowable(
     runStat,
     () => ({ type: "SUITE_DIR_MISSING", path: directory })
   );
   return safeStat(directory);
 }
 function readDirectoryEntries(directory) {
-  const safeReadDirectory = import_neverthrow48.ResultAsync.fromThrowable(
+  const safeReadDirectory = import_neverthrow50.ResultAsync.fromThrowable(
     runReadDirectory,
     (cause) => ({ type: "SUITE_READ_FAILED", path: directory, cause })
   );
@@ -90435,34 +90737,34 @@ function readDirectoryEntries(directory) {
 function listSuiteFiles(directory) {
   return statDirectory(directory).andThen((stats) => {
     if (!stats.isDirectory()) {
-      return (0, import_neverthrow48.errAsync)({ type: "SUITE_DIR_MISSING", path: directory });
+      return (0, import_neverthrow50.errAsync)({ type: "SUITE_DIR_MISSING", path: directory });
     }
     return readDirectoryEntries(directory);
   }).map(
-    (entries) => entries.filter((entry) => entry.endsWith(SUITE_FILE_SUFFIX)).map((entry) => import_node_path18.default.resolve(directory, entry)).toSorted()
+    (entries) => entries.filter((entry) => entry.endsWith(SUITE_FILE_SUFFIX)).map((entry) => import_node_path19.default.resolve(directory, entry)).toSorted()
   );
 }
 function parseSuiteFile(filePath, raw) {
   const parsed = safeJsonParse4(raw);
   if (parsed.isErr()) {
-    return (0, import_neverthrow48.err)({ type: "SUITE_INVALID", path: filePath, cause: parsed.error });
+    return (0, import_neverthrow50.err)({ type: "SUITE_INVALID", path: filePath, cause: parsed.error });
   }
   const validated = suiteFileSchema.safeParse(parsed.value);
   if (!validated.success) {
-    return (0, import_neverthrow48.err)({ type: "SUITE_INVALID", path: filePath, cause: validated.error });
+    return (0, import_neverthrow50.err)({ type: "SUITE_INVALID", path: filePath, cause: validated.error });
   }
-  return (0, import_neverthrow48.ok)(validated.data);
+  return (0, import_neverthrow50.ok)(validated.data);
 }
 function suiteIdFromPath(filePath) {
-  const name = import_node_path18.default.basename(filePath);
+  const name = import_node_path19.default.basename(filePath);
   return name.slice(0, name.length - SUITE_FILE_SUFFIX.length);
 }
 function loadSpecReference(xqaDirectory, specPath) {
-  const absolute = import_node_path18.default.resolve(xqaDirectory, specPath);
+  const absolute = import_node_path19.default.resolve(xqaDirectory, specPath);
   return readSpecFile(absolute).andThen((raw) => {
     const parsed = parseSpecFrontmatter(raw);
     if (parsed.isErr()) {
-      return (0, import_neverthrow48.err)({
+      return (0, import_neverthrow50.err)({
         type: "SPEC_FRONTMATTER_INVALID",
         path: absolute,
         cause: parsed.error.cause
@@ -90470,19 +90772,19 @@ function loadSpecReference(xqaDirectory, specPath) {
     }
     const { feature, timeoutSeconds } = parsed.value;
     if (timeoutSeconds === void 0) {
-      return (0, import_neverthrow48.ok)({ path: specPath, feature });
+      return (0, import_neverthrow50.ok)({ path: specPath, feature });
     }
-    return (0, import_neverthrow48.ok)({ path: specPath, feature, timeoutSeconds });
+    return (0, import_neverthrow50.ok)({ path: specPath, feature, timeoutSeconds });
   });
 }
 function loadSpecReferences(xqaDirectory, specs) {
   if (specs.length === 0) {
-    return (0, import_neverthrow48.okAsync)([]);
+    return (0, import_neverthrow50.okAsync)([]);
   }
-  return import_neverthrow48.ResultAsync.combine(specs.map((specPath) => loadSpecReference(xqaDirectory, specPath)));
+  return import_neverthrow50.ResultAsync.combine(specs.map((specPath) => loadSpecReference(xqaDirectory, specPath)));
 }
 function addSpecTokens(tokens, spec) {
-  const stem = import_node_path18.default.basename(spec.path).replace(/\.test\.md$/u, "");
+  const stem = import_node_path19.default.basename(spec.path).replace(/\.test\.md$/u, "");
   for (const part of stem.split(".")) {
     if (part.length > 0) {
       tokens.add(part);
@@ -90547,12 +90849,12 @@ function loadSuite(suiteFilePath, xqaDirectory) {
   );
 }
 function loadXqaSuites(directory) {
-  const xqaDirectory = import_node_path18.default.dirname(import_node_path18.default.resolve(directory));
+  const xqaDirectory = import_node_path19.default.dirname(import_node_path19.default.resolve(directory));
   return listSuiteFiles(directory).andThen((files) => {
     if (files.length === 0) {
-      return (0, import_neverthrow48.okAsync)([]);
+      return (0, import_neverthrow50.okAsync)([]);
     }
-    return import_neverthrow48.ResultAsync.combine(files.map((file2) => loadSuite(file2, xqaDirectory)));
+    return import_neverthrow50.ResultAsync.combine(files.map((file2) => loadSuite(file2, xqaDirectory)));
   });
 }
 
@@ -90563,77 +90865,57 @@ 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_neverthrow49.err)({ type: "CLI_INVALID_ARG", message: `invalid --repo value: ${input}` });
+    return (0, import_neverthrow51.err)({ type: "CLI_INVALID_ARG", message: `invalid --repo value: ${input}` });
   }
-  return (0, import_neverthrow49.ok)({ owner, repo });
+  return (0, import_neverthrow51.ok)({ owner, repo });
 }
 function parsePrNumber(input) {
   const parsed = Number.parseInt(input, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
-    return (0, import_neverthrow49.err)({ type: "CLI_INVALID_ARG", message: `invalid --pr value: ${input}` });
+    return (0, import_neverthrow51.err)({ type: "CLI_INVALID_ARG", message: `invalid --pr value: ${input}` });
   }
-  return (0, import_neverthrow49.ok)(parsed);
-}
-function parseThresholdValue(input) {
-  const parsed = Number.parseFloat(input);
-  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
-    return (0, import_neverthrow49.err)({ type: "CLI_INVALID_ARG", message: `invalid --threshold value: ${input}` });
-  }
-  return (0, import_neverthrow49.ok)(parsed);
-}
-function parseThreshold(input) {
-  if (input === void 0) {
-    return (0, import_neverthrow49.ok)(void 0);
-  }
-  return parseThresholdValue(input);
+  return (0, import_neverthrow51.ok)(parsed);
 }
 function parseCliInputs(options2) {
   const repoResult = parseRepo(options2.repo);
   if (repoResult.isErr()) {
-    return (0, import_neverthrow49.err)(repoResult.error);
+    return (0, import_neverthrow51.err)(repoResult.error);
   }
   const prResult = parsePrNumber(options2.pr);
   if (prResult.isErr()) {
-    return (0, import_neverthrow49.err)(prResult.error);
-  }
-  const thresholdResult = parseThreshold(options2.threshold);
-  if (thresholdResult.isErr()) {
-    return (0, import_neverthrow49.err)(thresholdResult.error);
+    return (0, import_neverthrow51.err)(prResult.error);
   }
-  return (0, import_neverthrow49.ok)({
+  return (0, import_neverthrow51.ok)({
     owner: repoResult.value.owner,
     repo: repoResult.value.repo,
-    prNumber: prResult.value,
-    threshold: thresholdResult.value
+    prNumber: prResult.value
   });
 }
 function buildInputs(options2, config3) {
   if (config3.GITHUB_TOKEN === void 0) {
-    return (0, import_neverthrow49.err)({ type: "CONFIG_MISSING", key: "GITHUB_TOKEN" });
+    return (0, import_neverthrow51.err)({ type: "CONFIG_MISSING", key: "GITHUB_TOKEN" });
   }
   const parsed = parseCliInputs(options2);
   if (parsed.isErr()) {
-    return (0, import_neverthrow49.err)(parsed.error);
+    return (0, import_neverthrow51.err)(parsed.error);
   }
-  return (0, import_neverthrow49.ok)({
+  return (0, import_neverthrow51.ok)({
     owner: parsed.value.owner,
     repo: parsed.value.repo,
     prNumber: parsed.value.prNumber,
     suitesDir: options2.suitesDir ?? config3.XQA_SUITES_DIR,
     applyLabels: options2.applyLabels === true,
     model: options2.model,
-    threshold: parsed.value.threshold,
     anthropicApiKey: config3.ANTHROPIC_API_KEY,
     githubToken: config3.GITHUB_TOKEN
   });
 }
 function buildTriagerConfig(inputs) {
   const base = { apiKey: inputs.anthropicApiKey };
-  const withModel = inputs.model === void 0 ? base : { ...base, model: inputs.model };
-  if (inputs.threshold === void 0) {
-    return withModel;
+  if (inputs.model === void 0) {
+    return base;
   }
-  return { ...withModel, scoreThreshold: inputs.threshold };
+  return { ...base, model: inputs.model };
 }
 function callTriager(options2) {
   const { inputs, groups, diff } = options2;
@@ -90643,7 +90925,7 @@ function callTriager(options2) {
 }
 function maybeApplyLabels(inputs, labels) {
   if (!inputs.applyLabels || labels.length === 0) {
-    return import_neverthrow49.ResultAsync.fromSafePromise(Promise.resolve(labels));
+    return import_neverthrow51.ResultAsync.fromSafePromise(Promise.resolve(labels));
   }
   return applyPullRequestLabels({
     owner: inputs.owner,
@@ -90653,8 +90935,8 @@ function maybeApplyLabels(inputs, labels) {
     token: inputs.githubToken
   }).map(() => labels);
 }
-function runPipeline3(inputs) {
-  return import_neverthrow49.ResultAsync.combine([
+function runPipeline4(inputs) {
+  return import_neverthrow51.ResultAsync.combine([
     loadXqaSuites(inputs.suitesDir),
     fetchPullRequestDiff({
       owner: inputs.owner,
@@ -90681,7 +90963,7 @@ async function runTriageCommand(options2, config3) {
     printError(inputs.error);
     return EXIT_FAILURE;
   }
-  const outcome = await runPipeline3(inputs.value);
+  const outcome = await runPipeline4(inputs.value);
   return outcome.match(
     (payload) => {
       printSuccess(payload);
@@ -90701,10 +90983,10 @@ function runUpdateCommand() {
 }
 
 // src/config.ts
-var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 var import_dotenv = __toESM(require_main(), 1);
-var import_neverthrow50 = __toESM(require_index_cjs(), 1);
+var import_neverthrow52 = __toESM(require_index_cjs(), 1);
 
 // src/config-schema.ts
 var configSchema = external_exports2.object({
@@ -90718,18 +91000,18 @@ var configSchema = external_exports2.object({
 });
 
 // src/config.ts
-var packageDirectory = import_node_path19.default.dirname((0, import_node_url2.fileURLToPath)(__importMetaUrl));
+var packageDirectory = import_node_path20.default.dirname((0, import_node_url2.fileURLToPath)(__importMetaUrl));
 function loadConfig() {
-  (0, import_dotenv.config)({ path: import_node_path19.default.resolve(packageDirectory, "..", ".env.local") });
+  (0, import_dotenv.config)({ path: import_node_path20.default.resolve(packageDirectory, "..", ".env.local") });
   const result = configSchema.safeParse(process.env);
   if (!result.success) {
     const messages = result.error.issues.map(
       (issue2) => `  - ${issue2.path.join(".")}: ${issue2.message}`
     );
-    return (0, import_neverthrow50.err)({ type: "INVALID_CONFIG", message: `Configuration error:
+    return (0, import_neverthrow52.err)({ type: "INVALID_CONFIG", message: `Configuration error:
 ${messages.join("\n")}` });
   }
-  return (0, import_neverthrow50.ok)(result.data);
+  return (0, import_neverthrow52.ok)(result.data);
 }
 
 // src/core/parse-timeout-seconds.ts
@@ -90762,7 +91044,7 @@ function parseVerboseOption(value) {
 
 // src/pid-lock.ts
 var import_node_fs9 = require("node:fs");
-var import_neverthrow51 = __toESM(require_index_cjs(), 1);
+var import_neverthrow53 = __toESM(require_index_cjs(), 1);
 var PID_FILE = "/tmp/xqa.pid";
 var SIGINT_EXIT_CODE = 130;
 var SIGTERM_EXIT_CODE = 143;
@@ -90771,7 +91053,7 @@ var HARD_TIMEOUT_MS = 1e4;
 var cleanup = () => {
   (0, import_node_fs9.rmSync)(PID_FILE, { force: true });
 };
-var checkProcessRunning = (0, import_neverthrow51.fromThrowable)(
+var checkProcessRunning = (0, import_neverthrow53.fromThrowable)(
   (pid) => {
     process.kill(pid, 0);
     return true;
@@ -90836,32 +91118,32 @@ function acquireLock() {
 
 // src/shell/xqa-directory.ts
 var import_node_fs10 = require("node:fs");
-var import_node_path20 = __toESM(require("node:path"), 1);
-var import_neverthrow52 = __toESM(require_index_cjs(), 1);
+var import_node_path21 = __toESM(require("node:path"), 1);
+var import_neverthrow54 = __toESM(require_index_cjs(), 1);
 function findXqaDirectory(startDirectory) {
   let current = startDirectory;
   for (; ; ) {
-    const candidate = import_node_path20.default.join(current, ".xqa");
+    const candidate = import_node_path21.default.join(current, ".xqa");
     if ((0, import_node_fs10.existsSync)(candidate)) {
-      return (0, import_neverthrow52.ok)(candidate);
+      return (0, import_neverthrow54.ok)(candidate);
     }
-    const parent = import_node_path20.default.dirname(current);
+    const parent = import_node_path21.default.dirname(current);
     if (parent === current) {
-      return (0, import_neverthrow52.err)({ type: "XQA_NOT_INITIALIZED" });
+      return (0, import_neverthrow54.err)({ type: "XQA_NOT_INITIALIZED" });
     }
     current = parent;
   }
 }
 
 // src/suite/commands/run-command.ts
-var import_promises22 = __toESM(require("node:fs/promises"), 1);
-var import_node_path24 = __toESM(require("node:path"), 1);
+var import_promises23 = __toESM(require("node:fs/promises"), 1);
+var import_node_path25 = __toESM(require("node:path"), 1);
 var import_fast_glob = __toESM(require_out4(), 1);
-var import_neverthrow60 = __toESM(require_index_cjs(), 1);
+var import_neverthrow62 = __toESM(require_index_cjs(), 1);
 
 // src/suite/core/suite-config-parser.ts
-var import_neverthrow53 = __toESM(require_index_cjs(), 1);
-var import_neverthrow54 = __toESM(require_index_cjs(), 1);
+var import_neverthrow55 = __toESM(require_index_cjs(), 1);
+var import_neverthrow56 = __toESM(require_index_cjs(), 1);
 var RESERVED_HOOK_ENV_KEYS = [
   "XQA_SIM_UDID",
   "XQA_ITEM_ID",
@@ -90913,7 +91195,7 @@ var suiteConfigSchema = external_exports2.object({
 }).refine((data) => data.specs.length > 0 || data.freestyle.length > 0, {
   message: "Suite must declare at least one spec or freestyle entry"
 });
-var safeJsonParse5 = (0, import_neverthrow53.fromThrowable)(
+var safeJsonParse5 = (0, import_neverthrow55.fromThrowable)(
   JSON.parse,
   (cause) => ({
     type: "INVALID_SUITE_CONFIG",
@@ -90947,16 +91229,16 @@ function parseSuiteConfig(raw) {
   return safeJsonParse5(raw).andThen((data) => {
     const parsed = suiteConfigSchema.safeParse(data);
     if (!parsed.success) {
-      return (0, import_neverthrow54.err)({ type: "INVALID_SUITE_CONFIG", cause: parsed.error });
+      return (0, import_neverthrow56.err)({ type: "INVALID_SUITE_CONFIG", cause: parsed.error });
     }
     const hooks = normalizeHooks(parsed.data.hooks);
     if (hooks === void 0) {
-      return (0, import_neverthrow54.ok)({
+      return (0, import_neverthrow56.ok)({
         specs: parsed.data.specs,
         freestyle: parsed.data.freestyle
       });
     }
-    return (0, import_neverthrow54.ok)({
+    return (0, import_neverthrow56.ok)({
       specs: parsed.data.specs,
       freestyle: parsed.data.freestyle,
       hooks
@@ -91013,25 +91295,25 @@ function buildFreestyleItems(entries) {
 }
 
 // src/suite/shell/suite-findings-writer.ts
-var import_promises20 = __toESM(require("node:fs/promises"), 1);
-var import_node_path21 = __toESM(require("node:path"), 1);
-var import_neverthrow55 = __toESM(require_index_cjs(), 1);
+var import_promises21 = __toESM(require("node:fs/promises"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
+var import_neverthrow57 = __toESM(require_index_cjs(), 1);
 var INDENT_SPACES = 2;
 function writeSuiteFindings(findings, options2) {
-  const directory = import_node_path21.default.join(
+  const directory = import_node_path22.default.join(
     options2.outputDirectory,
     "suite",
     findings.suiteId,
     options2.date,
     findings.runId
   );
-  const finalPath = import_node_path21.default.join(directory, "findings.json");
+  const finalPath = import_node_path22.default.join(directory, "findings.json");
   const temporaryPath = `${finalPath}.tmp`;
-  const safeWriteAtomically = import_neverthrow55.ResultAsync.fromThrowable(
+  const safeWriteAtomically = import_neverthrow57.ResultAsync.fromThrowable(
     async () => {
-      await import_promises20.default.mkdir(directory, { recursive: true });
-      await import_promises20.default.writeFile(temporaryPath, JSON.stringify(findings, void 0, INDENT_SPACES));
-      await import_promises20.default.rename(temporaryPath, finalPath);
+      await import_promises21.default.mkdir(directory, { recursive: true });
+      await import_promises21.default.writeFile(temporaryPath, JSON.stringify(findings, void 0, INDENT_SPACES));
+      await import_promises21.default.rename(temporaryPath, finalPath);
       return finalPath;
     },
     (cause) => ({ type: "FINDINGS_WRITE_FAILED", cause })
@@ -91040,7 +91322,7 @@ function writeSuiteFindings(findings, options2) {
 }
 
 // src/suite/shell/worker-pool.ts
-var import_neverthrow58 = __toESM(require_index_cjs(), 1);
+var import_neverthrow60 = __toESM(require_index_cjs(), 1);
 
 // src/suite/core/priority-queue.ts
 var PriorityQueue = class {
@@ -91224,7 +91506,7 @@ function recordHookFailure(input) {
 }
 
 // src/suite/shell/hook-invoker.ts
-var import_neverthrow57 = __toESM(require_index_cjs(), 1);
+var import_neverthrow59 = __toESM(require_index_cjs(), 1);
 
 // src/suite/core/hook-env-builder.ts
 function buildReservedKeys(input) {
@@ -91251,7 +91533,7 @@ function buildHookEnv(input) {
 
 // src/suite/shell/hook-runner.ts
 var import_node_child_process6 = require("node:child_process");
-var import_neverthrow56 = __toESM(require_index_cjs(), 1);
+var import_neverthrow58 = __toESM(require_index_cjs(), 1);
 function makeDeferred() {
   const raw = Promise.withResolvers();
   return { promise: raw.promise, resolve: raw.resolve };
@@ -91281,7 +91563,7 @@ var HookRuntime = class {
     this.deferred = makeDeferred();
     this.onAbort = () => {
       this.child.kill("SIGTERM");
-      this.settle((0, import_neverthrow56.err)({ type: "HOOK_ABORTED" }));
+      this.settle((0, import_neverthrow58.err)({ type: "HOOK_ABORTED" }));
     };
   }
   async start() {
@@ -91306,20 +91588,20 @@ var HookRuntime = class {
   attachTimeout() {
     this.timeoutHandle = setTimeout(() => {
       this.child.kill("SIGTERM");
-      this.settle((0, import_neverthrow56.err)({ type: "HOOK_TIMEOUT", timeoutMs: this.timeoutMs }));
+      this.settle((0, import_neverthrow58.err)({ type: "HOOK_TIMEOUT", timeoutMs: this.timeoutMs }));
     }, this.timeoutMs);
   }
   attachChildListeners() {
     this.child.on("error", (cause) => {
-      this.settle((0, import_neverthrow56.err)({ type: "HOOK_SPAWN_FAILED", cause }));
+      this.settle((0, import_neverthrow58.err)({ type: "HOOK_SPAWN_FAILED", cause }));
     });
     this.child.on("exit", (code) => {
       if (code === 0) {
-        this.settle((0, import_neverthrow56.ok)());
+        this.settle((0, import_neverthrow58.ok)());
         return;
       }
       this.settle(
-        (0, import_neverthrow56.err)({
+        (0, import_neverthrow58.err)({
           type: "HOOK_EXIT_NONZERO",
           code: code ?? -1,
           stderr: this.stderrBuffer
@@ -91342,7 +91624,7 @@ var HookRuntime = class {
     this.signal.removeEventListener("abort", this.onAbort);
   }
 };
-var safeSpawn = import_neverthrow56.ResultAsync.fromThrowable(
+var safeSpawn = import_neverthrow58.ResultAsync.fromThrowable(
   spawnHook,
   (cause) => ({ type: "HOOK_SPAWN_FAILED", cause })
 );
@@ -91370,7 +91652,7 @@ async function invokeHook(input) {
 async function maybeInvokeHook(input) {
   const { hook: hook2 } = input;
   if (hook2 === void 0) {
-    return (0, import_neverthrow57.ok)();
+    return (0, import_neverthrow59.ok)();
   }
   return invokeHook({ ...input, hook: hook2 });
 }
@@ -91509,7 +91791,7 @@ function runWorkerPool(config3) {
   const queue = setupQueue(config3);
   const results = [];
   const suiteStartMs = Date.now();
-  const safeRun = import_neverthrow58.ResultAsync.fromThrowable(
+  const safeRun = import_neverthrow60.ResultAsync.fromThrowable(
     async () => runAllWorkers({ config: config3, queue, results, suiteStartMs }),
     (cause) => ({ type: "WORKER_POOL_FAILED", cause })
   );
@@ -91519,7 +91801,7 @@ function runWorkerPool(config3) {
 // src/suite/commands/execute-item.ts
 var import_node_fs11 = require("node:fs");
 var import_node_os4 = __toESM(require("node:os"), 1);
-var import_node_path22 = __toESM(require("node:path"), 1);
+var import_node_path23 = __toESM(require("node:path"), 1);
 var DEFAULT_FREESTYLE_TIMEOUT_SECONDS2 = 300;
 function buildDeviceInstruction(simulatorUdid) {
   return `You MUST use device "${simulatorUdid}" for ALL mobile tool calls. The simulator UDID is already configured \u2014 use it directly.`;
@@ -91528,7 +91810,7 @@ function composeAppContext(parts) {
   return parts.filter((part) => part !== void 0 && part.length > 0).join("\n\n");
 }
 function ensureWorkerCwd(simulatorUdid) {
-  const workerDirectory = import_node_path22.default.join(import_node_os4.default.tmpdir(), "xqa-workers", simulatorUdid);
+  const workerDirectory = import_node_path23.default.join(import_node_os4.default.tmpdir(), "xqa-workers", simulatorUdid);
   (0, import_node_fs11.mkdirSync)(workerDirectory, { recursive: true });
   return workerDirectory;
 }
@@ -91542,7 +91824,7 @@ function buildFreestylePipelineConfig(input) {
   const { item, context, signal, simulatorUdid, onEvent } = input;
   const { config: config3, xqaDirectory, runId, date: date5, appContext } = context;
   return {
-    outputDir: import_node_path22.default.join(xqaDirectory, "output", item.id),
+    outputDir: import_node_path23.default.join(xqaDirectory, "output", item.id),
     runId,
     simulatorUdid,
     signal,
@@ -91564,13 +91846,13 @@ function buildFreestylePipelineConfig(input) {
   };
 }
 function executeFreestyleItem(input) {
-  return runPipeline2(buildFreestylePipelineConfig(input)).map((output) => ({ findings: output.findings, findingsPath: output.findingsPath })).mapErr((cause) => ({ type: "PIPELINE_FAILED", cause }));
+  return runPipeline3(buildFreestylePipelineConfig(input)).map((output) => ({ findings: output.findings, findingsPath: output.findingsPath })).mapErr((cause) => ({ type: "PIPELINE_FAILED", cause }));
 }
 function buildSpecPipelineConfig(input) {
   const { item, context, signal, simulatorUdid, onEvent } = input;
   const { config: config3, xqaDirectory, runId, appContext } = context;
   return {
-    outputDir: import_node_path22.default.join(xqaDirectory, "output", item.id),
+    outputDir: import_node_path23.default.join(xqaDirectory, "output", item.id),
     runId,
     simulatorUdid,
     signal,
@@ -91587,7 +91869,7 @@ function buildSpecPipelineConfig(input) {
   };
 }
 function executeSpecItem(input) {
-  return runPipeline2(buildSpecPipelineConfig(input)).map((output) => ({ findings: output.findings, findingsPath: output.findingsPath })).mapErr((cause) => ({ type: "PIPELINE_FAILED", cause }));
+  return runPipeline3(buildSpecPipelineConfig(input)).map((output) => ({ findings: output.findings, findingsPath: output.findingsPath })).mapErr((cause) => ({ type: "PIPELINE_FAILED", cause }));
 }
 function makeExecuteItem(context) {
   return (options2) => {
@@ -91600,9 +91882,9 @@ function makeExecuteItem(context) {
 }
 
 // src/suite/commands/suite-run-context.ts
-var import_promises21 = __toESM(require("node:fs/promises"), 1);
-var import_node_path23 = __toESM(require("node:path"), 1);
-var import_neverthrow59 = __toESM(require_index_cjs(), 1);
+var import_promises22 = __toESM(require("node:fs/promises"), 1);
+var import_node_path24 = __toESM(require("node:path"), 1);
+var import_neverthrow61 = __toESM(require_index_cjs(), 1);
 
 // src/suite/core/run-id.ts
 var RUN_ID_PAD_LENGTH2 = 4;
@@ -91637,16 +91919,16 @@ function deriveSuiteId(input) {
 
 // src/suite/commands/suite-run-context.ts
 var ISO_DATE_LENGTH3 = 10;
-var safeReaddir2 = import_neverthrow59.ResultAsync.fromThrowable(
+var safeReaddir2 = import_neverthrow61.ResultAsync.fromThrowable(
   async (directoryPath) => {
-    const entries = await import_promises21.default.readdir(directoryPath, { withFileTypes: true });
+    const entries = await import_promises22.default.readdir(directoryPath, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   },
   () => "READDIR_FAILED"
 );
 async function listRunDirectories(input) {
   const { outputDirectory, suiteId, date: date5 } = input;
-  const directoryPath = import_node_path23.default.join(outputDirectory, "suite", suiteId, date5);
+  const directoryPath = import_node_path24.default.join(outputDirectory, "suite", suiteId, date5);
   const result = await safeReaddir2(directoryPath);
   return result.unwrapOr([]);
 }
@@ -91670,7 +91952,7 @@ ${cause}
 async function buildSuiteRunContext(input) {
   const suiteId = deriveSuiteIdFromMode(input.mode);
   const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, ISO_DATE_LENGTH3);
-  const outputDirectory = import_node_path23.default.join(input.xqaDirectory, "output");
+  const outputDirectory = import_node_path24.default.join(input.xqaDirectory, "output");
   const existingDirectories = await listRunDirectories({ outputDirectory, suiteId, date: date5 });
   const runId = computeNextRunId(existingDirectories);
   const appContext = await loadAppContext(input.xqaDirectory);
@@ -91685,15 +91967,15 @@ async function buildSuiteRunContext(input) {
 }
 
 // src/suite/commands/run-command.ts
-var safeReadFile5 = import_neverthrow60.ResultAsync.fromThrowable(
-  async (filePath) => import_promises22.default.readFile(filePath, "utf8"),
+var safeReadFile5 = import_neverthrow62.ResultAsync.fromThrowable(
+  async (filePath) => import_promises23.default.readFile(filePath, "utf8"),
   () => "READ_FAILED"
 );
 async function resolveGlobs(input) {
   return (0, import_fast_glob.default)(input.globs, { cwd: input.cwd, absolute: true });
 }
 async function loadSuiteConfig(xqaDirectory, name) {
-  const suitePath = import_node_path24.default.join(xqaDirectory, "suites", `${name}.suite.json`);
+  const suitePath = import_node_path25.default.join(xqaDirectory, "suites", `${name}.suite.json`);
   const contentResult = await safeReadFile5(suitePath);
   if (contentResult.isErr()) {
     return;
@@ -91889,7 +92171,7 @@ function resolveXqaDirectory() {
   return result.value;
 }
 var program2 = new Command();
-program2.name("xqa").description("AI-powered QA agent CLI").version(`${"1.17.0"}${false ? ` (dev build +${"c37f65b"})` : ""}`);
+program2.name("xqa").description("AI-powered QA agent CLI").version(`${"2.0.0"}${false ? ` (dev build +${"e8d216b"})` : ""}`);
 program2.command("init").description("Initialize a new xqa project in the current directory").action(() => {
   runInitCommand();
 });