@exodus/xqa 3.0.0 → 3.0.1

package/dist/xqa.cjs

@@ -3733,7 +3733,7 @@ var require_index_cjs = __commonJS({
     }
     var fromPromise = ResultAsync20.fromPromise;
     var fromSafePromise2 = ResultAsync20.fromSafePromise;
-    var fromAsyncThrowable9 = ResultAsync20.fromThrowable;
+    var fromAsyncThrowable8 = ResultAsync20.fromThrowable;
     var combineResultList = (resultList) => {
       let acc = ok36([]);
       for (const result of resultList) {
@@ -3950,7 +3950,7 @@ var require_index_cjs = __commonJS({
     exports2.ResultAsync = ResultAsync20;
     exports2.err = err36;
     exports2.errAsync = errAsync11;
-    exports2.fromAsyncThrowable = fromAsyncThrowable9;
+    exports2.fromAsyncThrowable = fromAsyncThrowable8;
     exports2.fromPromise = fromPromise;
     exports2.fromSafePromise = fromSafePromise2;
     exports2.fromThrowable = fromThrowable18;
@@ -24656,8 +24656,108 @@ var {
 // src/bootstrap.ts
 var import_neverthrow77 = __toESM(require_index_cjs(), 1);
 
-// src/commands/analyse-command.ts
-var import_promises19 = require("node:fs/promises");
+// src/commands/analyse/input-validation.ts
+var import_promises = require("node:fs/promises");
+var import_neverthrow = __toESM(require_index_cjs(), 1);
+var checkFileExists = import_neverthrow.ResultAsync.fromThrowable(import_promises.access, () => ({
+  type: "FILE_MISSING"
+}));
+function requireApiKey(input) {
+  const apiKey = input.config.GOOGLE_GENERATIVE_AI_API_KEY ?? "";
+  if (!apiKey) {
+    return (0, import_neverthrow.errAsync)({ type: "MISSING_API_KEY" });
+  }
+  return (0, import_neverthrow.okAsync)(apiKey);
+}
+function requireVideoPath(input) {
+  if (input.videoPath === void 0) {
+    return (0, import_neverthrow.errAsync)({ type: "MISSING_VIDEO_PATH" });
+  }
+  const path29 = input.videoPath;
+  return checkFileExists(path29).map(() => path29).mapErr(() => ({ type: "VIDEO_NOT_FOUND", path: path29 }));
+}
+function validateAnalyseInput(input) {
+  return requireApiKey(input).andThen(
+    (apiKey) => requireVideoPath(input).map((videoPath) => ({ videoPath, apiKey, debug: input.debug }))
+  );
+}
+
+// src/commands/item-events.ts
+function emitItemStart(identity, at) {
+  const { display, itemId, itemName, simulatorUdid } = identity;
+  display.onEvent({ type: "ITEM_QUEUED", item: { id: itemId, name: itemName } });
+  display.onEvent({ type: "ITEM_STARTED", itemId, itemName, simulatorUdid, at });
+}
+function emitItemCompleted(input) {
+  const { identity, startedAt, findingsCount, dismissedCount } = input;
+  const { display, itemId, itemName } = identity;
+  const at = Date.now();
+  display.onEvent({
+    type: "ITEM_COMPLETED",
+    itemId,
+    itemName,
+    findingsCount,
+    dismissedCount,
+    durationMs: at - startedAt,
+    at
+  });
+}
+function emitItemFailed(input) {
+  const { identity, startedAt, error: error48 } = input;
+  const { display, itemId, itemName } = identity;
+  const at = Date.now();
+  display.onEvent({
+    type: "ITEM_FAILED",
+    itemId,
+    itemName,
+    error: error48,
+    durationMs: at - startedAt,
+    at
+  });
+}
+
+// src/commands/analyse/result-handlers.ts
+var JSON_INDENT = 2;
+function formatInputError(error48) {
+  switch (error48.type) {
+    case "MISSING_API_KEY": {
+      return "GOOGLE_GENERATIVE_AI_API_KEY is not set\n";
+    }
+    case "MISSING_VIDEO_PATH": {
+      return 'A video path is required. Pass the path printed by "xqa explore".\n';
+    }
+    case "VIDEO_NOT_FOUND": {
+      return `Video file not found: ${error48.path}
+`;
+    }
+  }
+}
+function buildSuccessHandler(state) {
+  return (findings) => {
+    emitItemCompleted({
+      identity: state.identity,
+      startedAt: state.startedAt,
+      findingsCount: findings.length,
+      dismissedCount: 0
+    });
+    state.identity.display.cleanup();
+    process.stdout.write(JSON.stringify(findings, void 0, JSON_INDENT));
+    process.exit(0);
+  };
+}
+function buildErrorHandler(state) {
+  return (errorType) => {
+    emitItemFailed({ identity: state.identity, startedAt: state.startedAt, error: errorType });
+    state.identity.display.cleanup();
+    process.stderr.write(`Analysis failed: ${errorType}
+`);
+    process.exit(1);
+  };
+}
+function handleInputError(error48) {
+  process.stderr.write(formatInputError(error48));
+  process.exit(1);
+}
 
 // ../../node_modules/.pnpm/@anthropic-ai+claude-agent-sdk@0.2.91_zod@4.3.6/node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 var import_path = require("path");
@@ -24668,15 +24768,15 @@ var import_readline = require("readline");
 var import_os = require("os");
 var import_path2 = require("path");
 var import_crypto = require("crypto");
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_path3 = require("path");
 var import_fs = require("fs");
 var import_process = require("process");
 var import_crypto2 = require("crypto");
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_path4 = require("path");
 var r = __toESM(require("fs"), 1);
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 var import_child_process2 = require("child_process");
 var import_util = require("util");
 var IL = Object.create;
@@ -31026,7 +31126,7 @@ function yF() {
   if (!B6(process.env.DEBUG_CLAUDE_AGENT_SDK)) return X0 = null, $0 = Promise.resolve(), $0;
   let $ = (0, import_path3.join)(c1(), "debug");
   return X0 = (0, import_path3.join)($, `sdk-${(0, import_crypto.randomUUID)()}.txt`), process.stderr.write(`SDK debug logs: ${X0}
-`), $0 = (0, import_promises.mkdir)($, { recursive: true }).then(() => {
+`), $0 = (0, import_promises2.mkdir)($, { recursive: true }).then(() => {
   }).catch(() => {
   }), $0;
 }
@@ -31035,7 +31135,7 @@ function s$($) {
   let J = `${(/* @__PURE__ */ new Date()).toISOString()} ${$}
 `;
   yF().then(() => {
-    if (X0) (0, import_promises.appendFile)(X0, J).catch(() => {
+    if (X0) (0, import_promises2.appendFile)(X0, J).catch(() => {
     });
   });
 }
@@ -31159,25 +31259,25 @@ var sF = { cwd() {
     V$(J, Y, z6);
   }
 }, async stat($) {
-  return (0, import_promises3.stat)($);
+  return (0, import_promises4.stat)($);
 }, async readdir($) {
-  return (0, import_promises3.readdir)($, { withFileTypes: true });
+  return (0, import_promises4.readdir)($, { withFileTypes: true });
 }, async unlink($) {
-  return (0, import_promises3.unlink)($);
+  return (0, import_promises4.unlink)($);
 }, async rmdir($) {
-  return (0, import_promises3.rmdir)($);
+  return (0, import_promises4.rmdir)($);
 }, async rm($, X) {
-  return (0, import_promises3.rm)($, X);
+  return (0, import_promises4.rm)($, X);
 }, async mkdir($, X) {
   try {
-    await (0, import_promises3.mkdir)($, { recursive: true, ...X });
+    await (0, import_promises4.mkdir)($, { recursive: true, ...X });
   } catch (J) {
     if (H1(J) !== "EEXIST") throw J;
   }
 }, async readFile($, X) {
-  return (0, import_promises3.readFile)($, { encoding: X.encoding });
+  return (0, import_promises4.readFile)($, { encoding: X.encoding });
 }, async rename($, X) {
-  return (0, import_promises3.rename)($, X);
+  return (0, import_promises4.rename)($, X);
 }, statSync($) {
   let J = [];
   try {
@@ -31396,8 +31496,8 @@ var sF = { cwd() {
 }, createWriteStream($) {
   return r.createWriteStream($);
 }, async readFileBytes($, X) {
-  if (X === void 0) return (0, import_promises3.readFile)($);
-  let J = await (0, import_promises3.open)($, "r");
+  if (X === void 0) return (0, import_promises4.readFile)($);
+  let J = await (0, import_promises4.open)($, "r");
   try {
     let { size: Q } = await J.stat(), Y = Math.min(Q, X), z6 = Buffer.allocUnsafe(Y), W = 0;
     while (W < Y) {
@@ -31458,9 +31558,9 @@ var HM = false;
 var ZJ = null;
 var xz = Promise.resolve();
 async function KM($, X, J, Q) {
-  if ($) await (0, import_promises2.mkdir)(X, { recursive: true }).catch(() => {
+  if ($) await (0, import_promises3.mkdir)(X, { recursive: true }).catch(() => {
   });
-  await (0, import_promises2.appendFile)(J, Q), RK();
+  await (0, import_promises3.appendFile)(J, Q), RK();
 }
 function NM() {
 }
@@ -31503,8 +31603,8 @@ function EK() {
 var RK = E6(async () => {
   try {
     let $ = EK(), X = (0, import_path4.dirname)($), J = (0, import_path4.join)(X, "latest");
-    await (0, import_promises2.unlink)(J).catch(() => {
-    }), await (0, import_promises2.symlink)($, J);
+    await (0, import_promises3.unlink)(J).catch(() => {
+    }), await (0, import_promises3.symlink)($, J);
   } catch {
   }
 });
@@ -41786,12 +41886,12 @@ function Qs({ prompt: $, options: X }) {
 }
 
 // ../../packages/mobile-ios/dist/index.js
-var import_promises4 = require("node:timers/promises");
-var import_neverthrow = __toESM(require_index_cjs(), 1);
+var import_promises5 = require("node:timers/promises");
 var import_neverthrow2 = __toESM(require_index_cjs(), 1);
-var import_node_child_process = require("node:child_process");
 var import_neverthrow3 = __toESM(require_index_cjs(), 1);
+var import_node_child_process = require("node:child_process");
 var import_neverthrow4 = __toESM(require_index_cjs(), 1);
+var import_neverthrow5 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -55562,18 +55662,18 @@ function date4(params) {
 config(en_default());
 
 // ../../packages/mobile-ios/dist/index.js
-var import_promises5 = require("node:timers/promises");
-var import_promises6 = require("node:fs/promises");
+var import_promises6 = require("node:timers/promises");
+var import_promises7 = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = __toESM(require("node:path"), 1);
-var import_neverthrow5 = __toESM(require_index_cjs(), 1);
-var import_sharp = __toESM(require("sharp"), 1);
 var import_neverthrow6 = __toESM(require_index_cjs(), 1);
-var import_promises7 = require("node:timers/promises");
+var import_sharp = __toESM(require("sharp"), 1);
+var import_neverthrow7 = __toESM(require_index_cjs(), 1);
+var import_promises8 = require("node:timers/promises");
 var import_node_crypto = require("node:crypto");
 var import_node_child_process2 = require("node:child_process");
 var import_node_events = require("node:events");
-var import_neverthrow7 = __toESM(require_index_cjs(), 1);
+var import_neverthrow8 = __toESM(require_index_cjs(), 1);
 async function execFilePromise(command, arguments_) {
   const { promise: promise2, resolve, reject } = Promise.withResolvers();
   (0, import_node_child_process.execFile)(command, arguments_, (error48, stdout) => {
@@ -55586,13 +55686,13 @@ async function execFilePromise(command, arguments_) {
   return promise2;
 }
 function runCommand(command, arguments_) {
-  return (0, import_neverthrow3.fromAsyncThrowable)(
+  return (0, import_neverthrow4.fromAsyncThrowable)(
     execFilePromise,
     (cause) => ({ type: "COMMAND_FAILED", command, args: arguments_, cause })
   )(command, arguments_);
 }
 var cache = /* @__PURE__ */ new Map();
-var safeParseSimctlOutput = (0, import_neverthrow2.fromThrowable)(
+var safeParseSimctlOutput = (0, import_neverthrow3.fromThrowable)(
   JSON.parse,
   (cause) => ({
     type: "COMMAND_FAILED",
@@ -55621,19 +55721,19 @@ function findBootedUdid(parsed) {
 }
 function resolveUdid(udid) {
   if (udid !== "booted") {
-    return (0, import_neverthrow2.okAsync)(udid);
+    return (0, import_neverthrow3.okAsync)(udid);
   }
   const cached2 = cache.get(udid);
   if (cached2 !== void 0) {
-    return (0, import_neverthrow2.okAsync)(cached2);
+    return (0, import_neverthrow3.okAsync)(cached2);
   }
   return runCommand("xcrun", ["simctl", "list", "devices", "booted", "--json"]).andThen((raw) => safeParseSimctlOutput(raw)).andThen((parsed) => {
     const result = findBootedUdid(parsed);
     if (typeof result === "string") {
       cache.set(udid, result);
-      return (0, import_neverthrow2.ok)(result);
+      return (0, import_neverthrow3.ok)(result);
     }
-    return (0, import_neverthrow2.err)(result);
+    return (0, import_neverthrow3.err)(result);
   });
 }
 var FULLSCREEN_THRESHOLD = 0.9;
@@ -55772,7 +55872,7 @@ function structuralSignature(elements) {
 }
 var STABILITY_POLL_ATTEMPTS = 10;
 var STABILITY_POLL_DELAY_MS = 500;
-var parseIdbTree = (0, import_neverthrow.fromThrowable)(
+var parseIdbTree = (0, import_neverthrow2.fromThrowable)(
   (raw) => JSON.parse(raw),
   (cause) => ({ type: "SNAPSHOT_PARSE_FAILED", cause })
 );
@@ -55790,22 +55890,22 @@ async function pollUntilStable(udid) {
     const raw = result.value;
     const parsed = parseIdbTree(raw);
     if (parsed.isErr()) {
-      return (0, import_neverthrow.err)(parsed.error);
+      return (0, import_neverthrow2.err)(parsed.error);
     }
     const signature = structuralSignature(parsed.value);
     if (signature === previousSignature) {
-      return (0, import_neverthrow.ok)(raw);
+      return (0, import_neverthrow2.ok)(raw);
     }
     previousSignature = signature;
     previousRaw = raw;
     if (index < STABILITY_POLL_ATTEMPTS - 1) {
-      await (0, import_promises4.setTimeout)(STABILITY_POLL_DELAY_MS);
+      await (0, import_promises5.setTimeout)(STABILITY_POLL_DELAY_MS);
     }
   }
-  return (0, import_neverthrow.ok)(previousRaw);
+  return (0, import_neverthrow2.ok)(previousRaw);
 }
 function waitForStableSnapshot(udid) {
-  return import_neverthrow.ResultAsync.fromSafePromise(pollUntilStable(udid)).andThen((result) => result);
+  return import_neverthrow2.ResultAsync.fromSafePromise(pollUntilStable(udid)).andThen((result) => result);
 }
 function captureAccessibilityTree(udid = "booted") {
   return resolveUdid(udid).andThen((resolvedUdid) => waitForStableSnapshot(resolvedUdid)).andThen((raw) => parseIdbTree(raw));
@@ -55843,7 +55943,7 @@ function errorResult(error48) {
     isError: true
   };
 }
-var safeJsonParse = (0, import_neverthrow4.fromThrowable)(
+var safeJsonParse = (0, import_neverthrow5.fromThrowable)(
   JSON.parse,
   (cause) => ({ type: "PARSE_FAILED", cause })
 );
@@ -55880,7 +55980,7 @@ function parseAppList(raw) {
   for (const line of lines) {
     const lineResult = safeJsonParse(line);
     if (lineResult.isErr()) {
-      return (0, import_neverthrow4.err)(lineResult.error);
+      return (0, import_neverthrow5.err)(lineResult.error);
     }
     const value = lineResult.value;
     if (Array.isArray(value)) {
@@ -55889,7 +55989,7 @@ function parseAppList(raw) {
       parsed.push(value);
     }
   }
-  return (0, import_neverthrow4.ok)(parsed);
+  return (0, import_neverthrow5.ok)(parsed);
 }
 async function handleListApps(udid) {
   const result = await resolveUdid(udid).andThen(
@@ -55948,7 +56048,7 @@ function buildTapArguments(resolvedUdid, input) {
   return ["ui", "tap", "--udid", resolvedUdid, String(input.x), String(input.y)];
 }
 async function handleTap(input) {
-  await (0, import_promises5.setTimeout)(GESTURE_SETTLE_MS);
+  await (0, import_promises6.setTimeout)(GESTURE_SETTLE_MS);
   const result = await resolveUdid(input.udid).andThen(
     (resolvedUdid) => runCommand("idb", buildTapArguments(resolvedUdid, input))
   );
@@ -56151,7 +56251,7 @@ function getDeviceInfo(udid) {
   return resolveUdid(udid).andThen((resolvedUdid) => {
     const cached2 = cache2.get(resolvedUdid);
     if (cached2 !== void 0) {
-      return (0, import_neverthrow6.okAsync)(cached2);
+      return (0, import_neverthrow7.okAsync)(cached2);
     }
     return runCommand("idb", ["describe", "--udid", resolvedUdid, "--json"]).map((raw) => {
       const info = parseDeviceInfo(raw);
@@ -56164,7 +56264,7 @@ async function sharpResize(buffer, dimensions) {
   return (0, import_sharp.default)(buffer).resize(dimensions.widthPoints, dimensions.heightPoints).png().toBuffer();
 }
 function resizeToLogicalPixels(buffer, dimensions) {
-  return (0, import_neverthrow5.fromAsyncThrowable)(
+  return (0, import_neverthrow6.fromAsyncThrowable)(
     sharpResize,
     (cause) => ({
       type: "COMMAND_FAILED",
@@ -56175,15 +56275,15 @@ function resizeToLogicalPixels(buffer, dimensions) {
   )(buffer, dimensions);
 }
 async function readAndDelete(filePath) {
-  const data = await (0, import_promises6.readFile)(filePath);
-  void (0, import_promises6.rm)(filePath, { force: true });
+  const data = await (0, import_promises7.readFile)(filePath);
+  void (0, import_promises7.rm)(filePath, { force: true });
   return data;
 }
 function captureScreenshot(udid = "booted") {
   const screenshotPath = import_node_path.default.join((0, import_node_os.tmpdir)(), `explorer-screenshot-${String(Date.now())}.png`);
   return resolveUdid(udid).andThen(
     (resolvedUdid) => runCommand("xcrun", ["simctl", "io", resolvedUdid, "screenshot", screenshotPath]).andThen(
-      () => (0, import_neverthrow5.fromAsyncThrowable)(
+      () => (0, import_neverthrow6.fromAsyncThrowable)(
         readAndDelete,
         (cause) => ({
           type: "COMMAND_FAILED",
@@ -56194,7 +56294,7 @@ function captureScreenshot(udid = "booted") {
       )(screenshotPath)
     ).andThen(
       (buffer) => getDeviceInfo(resolvedUdid).andThen(
-        ({ widthPoints, heightPoints, density }) => density > 1 ? resizeToLogicalPixels(buffer, { widthPoints, heightPoints }) : (0, import_neverthrow5.okAsync)(buffer)
+        ({ widthPoints, heightPoints, density }) => density > 1 ? resizeToLogicalPixels(buffer, { widthPoints, heightPoints }) : (0, import_neverthrow6.okAsync)(buffer)
       )
     ).map((buffer) => buffer.toString("base64"))
   );
@@ -56241,7 +56341,7 @@ function createWaitSecondsTool() {
           isError: true
         };
       }
-      await (0, import_promises7.setTimeout)(parsed.data * MS_PER_SECOND2);
+      await (0, import_promises8.setTimeout)(parsed.data * MS_PER_SECOND2);
       return { content: [{ type: "text", text: `Waited ${String(parsed.data)}s` }] };
     }
   );
@@ -56315,7 +56415,7 @@ function computeScreenFingerprint(elements) {
     elements: fingerprintElements
   };
 }
-var safeParseJson = (0, import_neverthrow7.fromThrowable)(
+var safeParseJson = (0, import_neverthrow8.fromThrowable)(
   JSON.parse,
   (cause) => ({ type: "SIMULATOR_COMMAND_FAILED", cause })
 );
@@ -56336,16 +56436,16 @@ function extractBootedSimulators(output) {
 }
 function handleClose(code) {
   if (code === 0) {
-    return (0, import_neverthrow7.ok)();
+    return (0, import_neverthrow8.ok)();
   }
-  return (0, import_neverthrow7.err)({
+  return (0, import_neverthrow8.err)({
     type: "SIMULATOR_COMMAND_FAILED",
     cause: new RangeError(`xcrun exited with code ${String(code)}`)
   });
 }
 function runSimctlCommand(arguments_) {
   const proc = (0, import_node_child_process2.spawn)("xcrun", arguments_);
-  return import_neverthrow7.ResultAsync.fromPromise(
+  return import_neverthrow8.ResultAsync.fromPromise(
     (0, import_node_events.once)(proc, "close"),
     (cause) => ({ type: "SIMULATOR_COMMAND_FAILED", cause })
   ).andThen(([code]) => handleClose(code));
@@ -56403,7 +56503,7 @@ function createMobileIosServer(udid = "booted", extraTools = []) {
 }
 
 // ../../agents/analyser/dist/index.js
-var import_promises8 = require("node:fs/promises");
+var import_promises9 = require("node:fs/promises");
 
 // ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -56906,7 +57006,7 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // ../../packages/display/dist/index.js
-var import_neverthrow8 = __toESM(require_index_cjs(), 1);
+var import_neverthrow9 = __toESM(require_index_cjs(), 1);
 var ESC = "\x1B";
 var CTRL_C = "";
 var CTRL_O = "";
@@ -57276,6 +57376,15 @@ function normalizeItemTimeout(event) {
     }
   ];
 }
+function normalizeItemAborted(event) {
+  return [
+    {
+      kind: "text",
+      style: "error",
+      text: `[${event.itemName}] ABORTED (${formatDuration(event.durationMs)}) ${event.reason}`
+    }
+  ];
+}
 function normalizeSimulatorUnhealthy(event) {
   return [
     {
@@ -57300,6 +57409,7 @@ var HANDLERS = {
   ITEM_COMPLETED: (event) => normalizeItemCompleted(event),
   ITEM_FAILED: (event) => normalizeItemFailed(event),
   ITEM_TIMEOUT: (event) => normalizeItemTimeout(event),
+  ITEM_ABORTED: (event) => normalizeItemAborted(event),
   SIMULATOR_UNHEALTHY: (event) => normalizeSimulatorUnhealthy(event),
   SUITE_COMPLETED: (event) => normalizeSuiteCompleted(event)
 };
@@ -57702,6 +57812,7 @@ var SUITE_EVENT_TYPES = /* @__PURE__ */ new Set([
   "ITEM_COMPLETED",
   "ITEM_FAILED",
   "ITEM_TIMEOUT",
+  "ITEM_ABORTED",
   "SIMULATOR_UNHEALTHY",
   "SUITE_COMPLETED"
 ]);
@@ -57715,7 +57826,8 @@ var UI_EVENT_TYPES = /* @__PURE__ */ new Set([
 var TERMINAL_STATUS = {
   ITEM_COMPLETED: "completed",
   ITEM_FAILED: "failed",
-  ITEM_TIMEOUT: "timeout"
+  ITEM_TIMEOUT: "timeout",
+  ITEM_ABORTED: "aborted"
 };
 function isSuiteEvent(event) {
   return SUITE_EVENT_TYPES.has(event.type);
@@ -57822,7 +57934,8 @@ function reduceSuiteEvent(state, event) {
     }
     case "ITEM_COMPLETED":
     case "ITEM_FAILED":
-    case "ITEM_TIMEOUT": {
+    case "ITEM_TIMEOUT":
+    case "ITEM_ABORTED": {
       return reduceItemTerminal(state, event);
     }
     case "SIMULATOR_UNHEALTHY": {
@@ -57845,7 +57958,12 @@ function reduce(state, event) {
   }
   return { ...state, spinnerFrame: state.spinnerFrame + 1 };
 }
-var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "timeout"]);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "timeout",
+  "aborted"
+]);
 function isTerminal(item) {
   if (item === void 0) {
     return false;
@@ -57925,7 +58043,7 @@ ${body}::endgroup::
 function failureCount(state) {
   let count = 0;
   for (const item of state.items.values()) {
-    if (item.status === "failed" || item.status === "timeout") {
+    if (item.status === "failed" || item.status === "timeout" || item.status === "aborted") {
       count += 1;
     }
   }
@@ -58112,14 +58230,14 @@ function safeHandler(handler2) {
 `);
       return void 0;
     };
-    const safe = (0, import_neverthrow8.fromThrowable)(bounded, errorMapper);
+    const safe = (0, import_neverthrow9.fromThrowable)(bounded, errorMapper);
     safe(event).isOk();
   };
 }
 
 // ../../agents/analyser/dist/index.js
-var import_neverthrow9 = __toESM(require_index_cjs(), 1);
-var import_promises9 = require("node:timers/promises");
+var import_neverthrow10 = __toESM(require_index_cjs(), 1);
+var import_promises10 = require("node:timers/promises");
 
 // ../../node_modules/.pnpm/@google+generative-ai@0.24.1/node_modules/@google/generative-ai/dist/index.mjs
 var SchemaType;
@@ -59500,8 +59618,8 @@ var DynamicRetrievalMode2;
 })(DynamicRetrievalMode2 || (DynamicRetrievalMode2 = {}));
 
 // ../../agents/analyser/dist/index.js
-var import_neverthrow10 = __toESM(require_index_cjs(), 1);
 var import_neverthrow11 = __toESM(require_index_cjs(), 1);
+var import_neverthrow12 = __toESM(require_index_cjs(), 1);
 var FINDINGS_RESPONSE_SCHEMA = {
   type: "array",
   items: {
@@ -59537,19 +59655,19 @@ var categoricalFindingSchema = external_exports.object({
   agent: external_exports.string()
 });
 var categoricalFindingsArraySchema = external_exports.array(categoricalFindingSchema);
-var safeJsonParse2 = (0, import_neverthrow11.fromThrowable)(JSON.parse);
+var safeJsonParse2 = (0, import_neverthrow12.fromThrowable)(JSON.parse);
 function parseAnalysisResponse(text) {
   const parseResult = safeJsonParse2(text);
   if (parseResult.isErr()) {
-    return (0, import_neverthrow11.err)({ type: "MALFORMED_JSON", cause: parseResult.error });
+    return (0, import_neverthrow12.err)({ type: "MALFORMED_JSON", cause: parseResult.error });
   }
   const raw = parseResult.value;
   const validated = categoricalFindingsArraySchema.safeParse(raw);
   if (!validated.success) {
-    return (0, import_neverthrow11.err)({ type: "SCHEMA_VALIDATION_FAILED", cause: validated.error });
+    return (0, import_neverthrow12.err)({ type: "SCHEMA_VALIDATION_FAILED", cause: validated.error });
   }
   const findings = validated.data.map((finding) => ({ ...finding }));
-  return (0, import_neverthrow11.ok)(findings);
+  return (0, import_neverthrow12.ok)(findings);
 }
 var MAX_POLL_ATTEMPTS = 30;
 var POLL_INTERVAL_MS = 2e3;
@@ -59572,7 +59690,7 @@ async function runPollLoop(checkState, onTick) {
     if (state === FileState.FAILED) {
       return "failed";
     }
-    await (0, import_promises9.setTimeout)(POLL_INTERVAL_MS);
+    await (0, import_promises10.setTimeout)(POLL_INTERVAL_MS);
   }
   return "timeout";
 }
@@ -59621,16 +59739,16 @@ function toFindings(text) {
 }
 function pollOutcomeToResult(outcome, fileUri) {
   if (outcome === "active") {
-    return (0, import_neverthrow10.ok)(fileUri);
+    return (0, import_neverthrow11.ok)(fileUri);
   }
   if (outcome === "failed") {
-    return (0, import_neverthrow10.err)({ type: "PROCESSING_FAILED", fileUri });
+    return (0, import_neverthrow11.err)({ type: "PROCESSING_FAILED", fileUri });
   }
-  return (0, import_neverthrow10.err)({ type: "POLL_TIMEOUT", fileUri });
+  return (0, import_neverthrow11.err)({ type: "POLL_TIMEOUT", fileUri });
 }
 function uploadVideo(videoPath, apiKey) {
   const fileManager = new GoogleAIFileManager(apiKey);
-  return (0, import_neverthrow10.fromAsyncThrowable)(
+  return (0, import_neverthrow11.fromAsyncThrowable)(
     uploadVideoFile,
     (cause) => ({ type: "UPLOAD_FAILED", cause })
   )(fileManager, videoPath);
@@ -59639,7 +59757,7 @@ function pollUntilActive(fileUri, options2) {
   const fileManager = new GoogleAIFileManager(options2.apiKey);
   const fileName2 = extractFileName(fileUri);
   const checkState = async () => checkFileState(fileManager, fileName2);
-  return (0, import_neverthrow10.fromAsyncThrowable)(
+  return (0, import_neverthrow11.fromAsyncThrowable)(
     runPollLoop,
     (cause) => ({ type: "UPLOAD_FAILED", cause })
   )(checkState, options2.onTick).andThen((outcome) => pollOutcomeToResult(outcome, fileUri));
@@ -59647,7 +59765,7 @@ function pollUntilActive(fileUri, options2) {
 function analyseArtifacts(options2) {
   const { videoUri, prompt, apiKey, model } = options2;
   const genModel = buildGenerativeModel(apiKey, model);
-  return (0, import_neverthrow10.fromAsyncThrowable)(
+  return (0, import_neverthrow11.fromAsyncThrowable)(
     generateAnalysisText,
     (cause) => ({ type: "REQUEST_FAILED", cause })
   )({ genModel, videoUri, prompt }).andThen(toFindings);
@@ -59708,7 +59826,7 @@ var DEFAULT_MODEL = "gemini-2.5-pro";
 var BYTES_PER_MB = 1048576;
 var MAX_POLL_ATTEMPTS2 = 30;
 async function getFileSize(filePath) {
-  const fileStats = await (0, import_promises8.stat)(filePath);
+  const fileStats = await (0, import_promises9.stat)(filePath);
   return fileStats.size;
 }
 function emitStageEnd(onEvent, start) {
@@ -59744,7 +59862,7 @@ function emitUploadProgress(onEvent, bytes) {
 }
 function runUploadPipeline(context) {
   const { apiKey, model, onEvent, start, videoPath, prompt } = context;
-  return (0, import_neverthrow9.fromAsyncThrowable)(
+  return (0, import_neverthrow10.fromAsyncThrowable)(
     getFileSize,
     (cause) => ({ type: "UPLOAD_FAILED", cause })
   )(videoPath).andThen((bytes) => {
@@ -59764,17 +59882,17 @@ function runAnalyser(artifacts, config2) {
   onEvent?.({ type: "STAGE_START", agent: "analyser" });
   if (!videoPath) {
     emitStageEnd(onEvent, start);
-    return (0, import_neverthrow9.errAsync)({ type: "VIDEO_PATH_MISSING" });
+    return (0, import_neverthrow10.errAsync)({ type: "VIDEO_PATH_MISSING" });
   }
   return runUploadPipeline(context);
 }
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow35 = __toESM(require_index_cjs(), 1);
-var import_promises17 = require("node:timers/promises");
+var import_neverthrow36 = __toESM(require_index_cjs(), 1);
+var import_promises18 = require("node:timers/promises");
 
 // ../../agents/consolidator/dist/index.js
-var import_neverthrow14 = __toESM(require_index_cjs(), 1);
+var import_neverthrow15 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.87.0_zod@4.3.6/node_modules/@anthropic-ai/sdk/internal/tslib.mjs
 function __classPrivateFieldSet(receiver, state, value, kind, f6) {
@@ -65614,19 +65732,19 @@ var findingInputSchema = findingSchema.omit({ agent: true, screenshots: true, co
 
 // ../../packages/shared/dist/run-paths.js
 var import_node_path2 = __toESM(require("node:path"), 1);
-var import_neverthrow12 = __toESM(require_index_cjs(), 1);
+var import_neverthrow13 = __toESM(require_index_cjs(), 1);
 function resolveRunPaths({ outputDirectory, runId, date: date5 }) {
   if (!outputDirectory) {
-    return (0, import_neverthrow12.err)({ type: "EMPTY_OUTPUT_DIRECTORY" });
+    return (0, import_neverthrow13.err)({ type: "EMPTY_OUTPUT_DIRECTORY" });
   }
   if (!runId) {
-    return (0, import_neverthrow12.err)({ type: "EMPTY_RUN_ID" });
+    return (0, import_neverthrow13.err)({ type: "EMPTY_RUN_ID" });
   }
   if (runId.includes("/") || runId.includes("\\")) {
-    return (0, import_neverthrow12.err)({ type: "INVALID_RUN_ID", value: runId });
+    return (0, import_neverthrow13.err)({ type: "INVALID_RUN_ID", value: runId });
   }
   const baseDirectory = import_node_path2.default.join(outputDirectory, date5, runId);
-  return (0, import_neverthrow12.ok)({
+  return (0, import_neverthrow13.ok)({
     baseDir: baseDirectory,
     videoPath: import_node_path2.default.join(baseDirectory, "recording.mp4"),
     findingsPath: import_node_path2.default.join(baseDirectory, "findings.json"),
@@ -65644,7 +65762,7 @@ function dismissalsPath(baseDirectory, override) {
 }
 
 // ../../packages/tools/dist/index.js
-var import_neverthrow13 = __toESM(require_index_cjs(), 1);
+var import_neverthrow14 = __toESM(require_index_cjs(), 1);
 function buildGetOutputTool() {
   return {
     name: "get_output",
@@ -65661,22 +65779,22 @@ function buildSetOutputTool(schema2) {
 }
 function dispatchToolCall(request2) {
   if (request2.name === "get_output") {
-    return (0, import_neverthrow13.ok)(request2.getOutputJson());
+    return (0, import_neverthrow14.ok)(request2.getOutputJson());
   }
   if (request2.name === "set_output") {
     return request2.setOutput(request2.input).map(() => JSON.stringify({ ok: true }));
   }
-  return (0, import_neverthrow13.err)({ type: "UNKNOWN_TOOL", name: request2.name });
+  return (0, import_neverthrow14.err)({ type: "UNKNOWN_TOOL", name: request2.name });
 }
 function createOutputTools(schema2) {
   let current;
   function setOutput(value) {
     const parsed = schema2.safeParse(value);
     if (!parsed.success) {
-      return (0, import_neverthrow13.err)({ type: "VALIDATION_ERROR", cause: parsed.error });
+      return (0, import_neverthrow14.err)({ type: "VALIDATION_ERROR", cause: parsed.error });
     }
     current = parsed.data;
-    return (0, import_neverthrow13.ok)();
+    return (0, import_neverthrow14.ok)();
   }
   return {
     tools: [buildGetOutputTool(), buildSetOutputTool(schema2)],
@@ -65692,8 +65810,8 @@ function createOutputTools(schema2) {
 }
 
 // ../../agents/consolidator/dist/index.js
-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 MODEL = "claude-opus-4-6";
 var MAX_TOKENS = 4096;
 var findingWithoutConfidenceSchema = findingSchema.omit({ confidence: true });
@@ -65733,16 +65851,16 @@ function processToolUseBlock(toolUseBlock, context) {
   });
   const result = context.factory.handleToolCall(toolUseBlock.name, toolUseBlock.input);
   if (result.isErr()) {
-    return (0, import_neverthrow15.err)({
+    return (0, import_neverthrow16.err)({
       type: "REQUEST_FAILED",
       cause: result.error
     });
   }
   const output = context.factory.getOutput();
   if (output === void 0) {
-    return (0, import_neverthrow15.err)({ type: "UNEXPECTED_RESPONSE" });
+    return (0, import_neverthrow16.err)({ type: "UNEXPECTED_RESPONSE" });
   }
-  return (0, import_neverthrow15.ok)(output);
+  return (0, import_neverthrow16.ok)(output);
 }
 function extractRawOutput(response, context) {
   emitThoughts(response, context.onEvent);
@@ -65750,7 +65868,7 @@ function extractRawOutput(response, context) {
     (block) => block.type === "tool_use" && block.name === "set_output"
   );
   if (!toolUseBlock) {
-    return (0, import_neverthrow15.err)({ type: "UNEXPECTED_RESPONSE" });
+    return (0, import_neverthrow16.err)({ type: "UNEXPECTED_RESPONSE" });
   }
   return processToolUseBlock(toolUseBlock, context);
 }
@@ -65758,7 +65876,7 @@ function consolidateFindings(prompt, onEvent) {
   const client = new Anthropic();
   const factory = createOutputTools(rawConsolidationOutputSchema);
   const tools = [factory.tools[1]];
-  return (0, import_neverthrow15.fromAsyncThrowable)(
+  return (0, import_neverthrow16.fromAsyncThrowable)(
     fetchMessage,
     (cause) => ({ type: "REQUEST_FAILED", cause })
   )({ client, prompt, tools }).andThen(
@@ -65780,15 +65898,15 @@ function resolveConfidence(output, pool) {
   const metadataMatch = findByKey(pool.metadataFindings, key);
   const visualMatch = findByKey(pool.visualFindings, key);
   if (metadataMatch !== void 0 && visualMatch !== void 0) {
-    return (0, import_neverthrow16.ok)(maxConfidence(metadataMatch.confidence, visualMatch.confidence));
+    return (0, import_neverthrow17.ok)(maxConfidence(metadataMatch.confidence, visualMatch.confidence));
   }
   if (metadataMatch !== void 0) {
-    return (0, import_neverthrow16.ok)(metadataMatch.confidence);
+    return (0, import_neverthrow17.ok)(metadataMatch.confidence);
   }
   if (visualMatch !== void 0) {
-    return (0, import_neverthrow16.ok)(visualMatch.confidence);
+    return (0, import_neverthrow17.ok)(visualMatch.confidence);
   }
-  return (0, import_neverthrow16.err)({
+  return (0, import_neverthrow17.err)({
     type: "UNMATCHED_OUTPUT_FINDING",
     flow: output.flow,
     description: output.description
@@ -65799,7 +65917,7 @@ function attachConfidence(output, pool) {
 }
 function mergeFindings(outputs, state) {
   if (outputs.length === 0) {
-    return (0, import_neverthrow16.ok)(state.accumulated);
+    return (0, import_neverthrow17.ok)(state.accumulated);
   }
   const [head, ...tail] = outputs;
   return attachConfidence(head, state.pool).andThen(
@@ -65808,7 +65926,7 @@ function mergeFindings(outputs, state) {
 }
 function mergeDismissed(outputs, state) {
   if (outputs.length === 0) {
-    return (0, import_neverthrow16.ok)(state.accumulated);
+    return (0, import_neverthrow17.ok)(state.accumulated);
   }
   const [head, ...tail] = outputs;
   return attachConfidence(head.finding, state.pool).andThen(
@@ -65907,7 +66025,7 @@ function runPipeline(input, context) {
 }
 function runConsolidator(input, config2) {
   if (input.metadataFindings.length === 0 && input.visualFindings.length === 0) {
-    return (0, import_neverthrow14.okAsync)({ findings: [], dismissed: [] });
+    return (0, import_neverthrow15.okAsync)({ findings: [], dismissed: [] });
   }
   const start = Date.now();
   config2?.onEvent?.({ type: "STAGE_START", agent: "consolidator" });
@@ -65915,39 +66033,39 @@ function runConsolidator(input, config2) {
 }
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow36 = __toESM(require_index_cjs(), 1);
 var import_neverthrow37 = __toESM(require_index_cjs(), 1);
-var import_promises18 = require("node:timers/promises");
+var import_neverthrow38 = __toESM(require_index_cjs(), 1);
+var import_promises19 = require("node:timers/promises");
 
 // ../../agents/explorer/dist/index.js
-var import_neverthrow17 = __toESM(require_index_cjs(), 1);
-var import_promises10 = require("node:timers/promises");
 var import_neverthrow18 = __toESM(require_index_cjs(), 1);
+var import_promises11 = require("node:timers/promises");
 var import_neverthrow19 = __toESM(require_index_cjs(), 1);
-var import_promises11 = require("node:fs/promises");
-var import_node_path4 = __toESM(require("node:path"), 1);
 var import_neverthrow20 = __toESM(require_index_cjs(), 1);
-var import_node_path5 = __toESM(require("node:path"), 1);
 var import_promises12 = require("node:fs/promises");
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
 var import_neverthrow21 = __toESM(require_index_cjs(), 1);
-var import_node_child_process3 = require("node:child_process");
+var import_node_path5 = __toESM(require("node:path"), 1);
 var import_promises13 = require("node:fs/promises");
+var import_node_path6 = __toESM(require("node:path"), 1);
 var import_neverthrow22 = __toESM(require_index_cjs(), 1);
+var import_node_child_process3 = require("node:child_process");
+var import_promises14 = require("node:fs/promises");
 var import_neverthrow23 = __toESM(require_index_cjs(), 1);
+var import_neverthrow24 = __toESM(require_index_cjs(), 1);
 var import_node_child_process4 = require("node:child_process");
 var import_node_fs = require("node:fs");
 var import_node_path7 = __toESM(require("node:path"), 1);
-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_node_path8 = __toESM(require("node:path"), 1);
 var import_neverthrow26 = __toESM(require_index_cjs(), 1);
+var import_promises15 = require("node:fs/promises");
+var import_node_path8 = __toESM(require("node:path"), 1);
+var import_neverthrow27 = __toESM(require_index_cjs(), 1);
 var INTERRUPT_DRAIN_TIMEOUT_MS = 1e4;
 async function interruptOrTimeout(queryRunner) {
-  await Promise.race([queryRunner.interrupt(), (0, import_promises10.setTimeout)(INTERRUPT_DRAIN_TIMEOUT_MS)]);
+  await Promise.race([queryRunner.interrupt(), (0, import_promises11.setTimeout)(INTERRUPT_DRAIN_TIMEOUT_MS)]);
 }
-var safeInterruptOrTimeout = import_neverthrow18.ResultAsync.fromThrowable(
+var safeInterruptOrTimeout = import_neverthrow19.ResultAsync.fromThrowable(
   interruptOrTimeout,
   (error48) => error48
 );
@@ -66077,8 +66195,8 @@ function buildFinding({
 }
 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_neverthrow20.fromAsyncThrowable)(
-  import_promises11.writeFile,
+var safeWriteFile = (0, import_neverthrow21.fromAsyncThrowable)(
+  import_promises12.writeFile,
   (cause) => ({ type: "WRITE_FAILED", cause })
 );
 async function persistScreenshot(params) {
@@ -66183,8 +66301,8 @@ function maybeEmitVisualStep({
   });
   return structuralHash;
 }
-var safeWriteFile2 = (0, import_neverthrow21.fromAsyncThrowable)(
-  import_promises12.writeFile,
+var safeWriteFile2 = (0, import_neverthrow22.fromAsyncThrowable)(
+  import_promises13.writeFile,
   (cause) => ({ type: "WRITE_FAILED", cause })
 );
 async function persistScreenshot2(params) {
@@ -66430,23 +66548,23 @@ function processMessage(message, state) {
   }
   if (message.type === "result") {
     if (message.subtype !== "success" && !state.timedOut.value && !state.aborted.value) {
-      return (0, import_neverthrow19.err)(message.errors.join("; "));
+      return (0, import_neverthrow20.err)(message.errors.join("; "));
     }
-    return (0, import_neverthrow19.ok)(true);
+    return (0, import_neverthrow20.ok)(true);
   }
-  return (0, import_neverthrow19.ok)(false);
+  return (0, import_neverthrow20.ok)(false);
 }
 async function processMessages(queryRunner, state) {
   for await (const message of queryRunner) {
     const result = processMessage(message, state);
     if (result.isErr()) {
-      return (0, import_neverthrow19.err)(result.error);
+      return (0, import_neverthrow20.err)(result.error);
     }
     if (result.value) {
       break;
     }
   }
-  return (0, import_neverthrow19.ok)(null);
+  return (0, import_neverthrow20.ok)(null);
 }
 var MessageQueue = class {
   pending = [];
@@ -66602,18 +66720,18 @@ function setupQuery(config2) {
 }
 function awaitMessagesAndResolve({ queryRunner, state }, { cleanup: cleanup2, getOutput }) {
   const messagesPromise = processMessages(queryRunner, state);
-  return import_neverthrow17.ResultAsync.fromPromise(messagesPromise, String).andThen((innerResult) => {
+  return import_neverthrow18.ResultAsync.fromPromise(messagesPromise, String).andThen((innerResult) => {
     cleanup2();
     if (innerResult.isErr()) {
-      return (0, import_neverthrow17.err)(innerResult.error);
+      return (0, import_neverthrow18.err)(innerResult.error);
     }
-    return (0, import_neverthrow17.ok)(getOutput());
+    return (0, import_neverthrow18.ok)(getOutput());
   }).orElse((sdkError) => {
     cleanup2();
     if (!state.timedOut.value && !state.aborted.value) {
-      return (0, import_neverthrow17.err)(sdkError);
+      return (0, import_neverthrow18.err)(sdkError);
     }
-    return (0, import_neverthrow17.ok)(getOutput());
+    return (0, import_neverthrow18.ok)(getOutput());
   });
 }
 function primeAndStartQuery({
@@ -66625,14 +66743,14 @@ function primeAndStartQuery({
     message: { role: "user", content: prompt },
     parent_tool_use_id: null
   });
-  return (0, import_neverthrow17.fromThrowable)(Qs, String)({ prompt: inputQueue, options: options2 });
+  return (0, import_neverthrow18.fromThrowable)(Qs, String)({ prompt: inputQueue, options: options2 });
 }
 function executeQuery(context) {
   const { config: config2, setup } = context;
   const { inputQueue, state, linkedController } = setup;
   const queryRunnerResult = primeAndStartQuery(context);
   if (queryRunnerResult.isErr()) {
-    return (0, import_neverthrow17.errAsync)(queryRunnerResult.error);
+    return (0, import_neverthrow18.errAsync)(queryRunnerResult.error);
   }
   const queryRunner = queryRunnerResult.value;
   const cleanup2 = startQueryLifecycle(config2, {
@@ -66655,8 +66773,8 @@ function collectAgentOutput(prompt, config2) {
   return runQuery(prompt, config2).mapErr((cause) => ({ type: "QUERY_FAILED", cause }));
 }
 function spawnRecorder(outputPath) {
-  const safeMkdirSync = (0, import_neverthrow24.fromThrowable)(import_node_fs.mkdirSync, (cause) => cause);
-  const safeSpawn2 = (0, import_neverthrow24.fromThrowable)(
+  const safeMkdirSync = (0, import_neverthrow25.fromThrowable)(import_node_fs.mkdirSync, (cause) => cause);
+  const safeSpawn2 = (0, import_neverthrow25.fromThrowable)(
     (command, arguments_) => (0, import_node_child_process4.spawn)(command, arguments_),
     (cause) => cause
   );
@@ -66683,7 +66801,7 @@ function earlyExitError(code) {
 function waitForRecordingStart(proc) {
   const { stderr } = proc;
   if (!stderr) {
-    return (0, import_neverthrow24.errAsync)({ type: "SPAWN_FAILED", cause: new RangeError("proc has no stderr pipe") });
+    return (0, import_neverthrow25.errAsync)({ type: "SPAWN_FAILED", cause: new RangeError("proc has no stderr pipe") });
   }
   const { promise: promise2, resolve, reject } = Promise.withResolvers();
   proc.once("error", reject);
@@ -66699,7 +66817,7 @@ function waitForRecordingStart(proc) {
       resolve({ process: proc, startedAt: Date.now() });
     }
   });
-  return import_neverthrow24.ResultAsync.fromPromise(
+  return import_neverthrow25.ResultAsync.fromPromise(
     promise2,
     (cause) => ({ type: "SPAWN_FAILED", cause })
   );
@@ -66707,7 +66825,7 @@ function waitForRecordingStart(proc) {
 function startRecording(outputPath) {
   const procOrError = spawnRecorder(outputPath);
   if (procOrError instanceof Error) {
-    return (0, import_neverthrow24.errAsync)({ type: "SPAWN_FAILED", cause: procOrError });
+    return (0, import_neverthrow25.errAsync)({ type: "SPAWN_FAILED", cause: procOrError });
   }
   return waitForRecordingStart(procOrError);
 }
@@ -66722,7 +66840,7 @@ function stopRecording(handle) {
   } else {
     resolve(true);
   }
-  return import_neverthrow24.ResultAsync.fromPromise(
+  return import_neverthrow25.ResultAsync.fromPromise(
     promise2,
     (cause) => ({ type: "STOP_FAILED", cause })
   );
@@ -66735,7 +66853,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_neverthrow23.errAsync)(error48)).orElse(() => (0, import_neverthrow23.errAsync)(error48))
+    (error48) => stopRecording(handle).mapErr(toRecordingError).andThen(() => (0, import_neverthrow24.errAsync)(error48)).orElse(() => (0, import_neverthrow24.errAsync)(error48))
   );
 }
 function startAndRun(params) {
@@ -67093,29 +67211,29 @@ var INLINE_ASSERTION_DELIMITER = " \u2192 ";
 var NUMBERED_STEP_PREFIX = /^\d+\.\s+/;
 function parseTagsValue(value) {
   if (!value.startsWith("[") || !value.endsWith("]")) {
-    return (0, import_neverthrow25.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid tags format: ${value}` });
+    return (0, import_neverthrow26.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid tags format: ${value}` });
   }
-  return (0, import_neverthrow25.ok)(
+  return (0, import_neverthrow26.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_neverthrow25.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid timeout: ${value}` });
+    return (0, import_neverthrow26.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid timeout: ${value}` });
   }
-  return (0, import_neverthrow25.ok)(parsed);
+  return (0, import_neverthrow26.ok)(parsed);
 }
 function parseFrontmatterLine(line) {
   const colonIndex = line.indexOf(":");
   if (colonIndex === -1) {
-    return (0, import_neverthrow25.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid line: ${line}` });
+    return (0, import_neverthrow26.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_neverthrow25.ok)({ description: value });
+      return (0, import_neverthrow26.ok)({ description: value });
     }
     case "tags": {
       return parseTagsValue(value).map((tags) => ({ tags }));
@@ -67124,10 +67242,10 @@ function parseFrontmatterLine(line) {
       return parseTimeoutValue(value).map((timeout) => ({ timeout }));
     }
     case "scenarioId": {
-      return (0, import_neverthrow25.ok)(value.length > 0 ? { scenarioId: value } : {});
+      return (0, import_neverthrow26.ok)(value.length > 0 ? { scenarioId: value } : {});
     }
     default: {
-      return (0, import_neverthrow25.ok)({});
+      return (0, import_neverthrow26.ok)({});
     }
   }
 }
@@ -67150,18 +67268,18 @@ function mergePartials(partials) {
 }
 function combineFrontmatterLines(lines) {
   const lineResults = lines.filter((line) => line.trim().length > 0).map((line) => parseFrontmatterLine(line));
-  return import_neverthrow25.Result.combine(lineResults).map((partials) => mergePartials(partials)).map((merged) => normalizeFrontmatter(merged));
+  return import_neverthrow26.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_neverthrow25.ok)({ frontmatter: emptyFrontmatter(), body: content });
+    return (0, import_neverthrow26.ok)({ frontmatter: emptyFrontmatter(), body: content });
   }
   const afterOpenFence = trimmed.slice(FRONTMATTER_FENCE.length);
   const closeIndex = afterOpenFence.indexOf(`
 ${FRONTMATTER_FENCE}`);
   if (closeIndex === -1) {
-    return (0, import_neverthrow25.err)({ type: "MALFORMED_FRONTMATTER", cause: "Unclosed frontmatter fence" });
+    return (0, import_neverthrow26.err)({ type: "MALFORMED_FRONTMATTER", cause: "Unclosed frontmatter fence" });
   }
   const rawFrontmatter = afterOpenFence.slice(0, closeIndex);
   const body = afterOpenFence.slice(closeIndex + FRONTMATTER_FENCE.length + 1);
@@ -67203,13 +67321,13 @@ function parseTestSpec(name, content) {
     const sections = splitIntoSections(body);
     const setup = sections.Setup;
     if (setup === void 0) {
-      return (0, import_neverthrow25.err)({ type: "MISSING_SETUP_SECTION" });
+      return (0, import_neverthrow26.err)({ type: "MISSING_SETUP_SECTION" });
     }
     const stepsSection = sections.Steps;
     if (stepsSection === void 0) {
-      return (0, import_neverthrow25.err)({ type: "MISSING_STEPS_SECTION" });
+      return (0, import_neverthrow26.err)({ type: "MISSING_STEPS_SECTION" });
     }
-    return (0, import_neverthrow25.ok)({
+    return (0, import_neverthrow26.ok)({
       name,
       frontmatter,
       setup,
@@ -67254,25 +67372,25 @@ function direntToSpecEntry(directory, entry) {
   return [];
 }
 function scanDirectory(directory) {
-  const safeReaddir3 = (0, import_neverthrow26.fromAsyncThrowable)(
-    async () => (0, import_promises14.readdir)(directory, { withFileTypes: true }),
+  const safeReaddir3 = (0, import_neverthrow27.fromAsyncThrowable)(
+    async () => (0, import_promises15.readdir)(directory, { withFileTypes: true }),
     (cause) => ({ type: "DIR_READ_FAILED", dir: directory, cause })
   );
-  return safeReaddir3().orElse((error48) => isNotFound(error48.cause) ? (0, import_neverthrow26.okAsync)([]) : (0, import_neverthrow26.errAsync)(error48)).map(
+  return safeReaddir3().orElse((error48) => isNotFound(error48.cause) ? (0, import_neverthrow27.okAsync)([]) : (0, import_neverthrow27.errAsync)(error48)).map(
     (entries) => entries.flatMap((entry) => direntToSpecEntry(directory, entry))
   );
 }
 function readEntries(entries) {
-  return import_neverthrow26.ResultAsync.combine(entries.map((entry) => readEntry(entry))).map(
+  return import_neverthrow27.ResultAsync.combine(entries.map((entry) => readEntry(entry))).map(
     (results) => results.flat()
   );
 }
 function readEntry(entry) {
-  const safeReadFile6 = (0, import_neverthrow26.fromAsyncThrowable)(
-    async () => (0, import_promises14.readFile)(entry.path, "utf8"),
+  const safeReadFile6 = (0, import_neverthrow27.fromAsyncThrowable)(
+    async () => (0, import_promises15.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_neverthrow26.errAsync)(error48) : (0, import_neverthrow26.okAsync)([]));
+  return safeReadFile6().map((content) => [{ name: entry.name, content }]).orElse((error48) => entry.required ? (0, import_neverthrow27.errAsync)(error48) : (0, import_neverthrow27.okAsync)([]));
 }
 function specNameFromPath(filePath) {
   const parts = filePath.split("/");
@@ -67304,7 +67422,7 @@ function buildPrompt2(safeConfig, specs) {
   });
 }
 function parseSpecs(resolvedSpecs) {
-  return import_neverthrow22.Result.combine(
+  return import_neverthrow23.Result.combine(
     resolvedSpecs.map(
       (spec) => parseTestSpec(spec.name, spec.content).mapErr(
         (cause) => ({ type: "SPEC_PARSE_FAILED", specName: spec.name, cause })
@@ -67362,7 +67480,7 @@ function collectAndFinalize({
 }
 function resolveAndParseSpecs(safeConfig) {
   if (safeConfig.mode === "freestyle") {
-    return (0, import_neverthrow22.okAsync)([]);
+    return (0, import_neverthrow23.okAsync)([]);
   }
   return resolveSpecs(safeConfig).mapErr((cause) => ({ type: "SPEC_RESOLVE_FAILED", cause })).andThen((specs) => parseSpecs(specs));
 }
@@ -67393,33 +67511,33 @@ function runExplorer(config2) {
     date: date5
   });
   if (runPathsResult.isErr()) {
-    return (0, import_neverthrow22.errAsync)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
+    return (0, import_neverthrow23.errAsync)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
   }
   const runPaths = runPathsResult.value;
   if (config2.signal?.aborted) {
-    return (0, import_neverthrow22.okAsync)(toArtifacts({ findings: [], snapshots: [] }, runPaths));
+    return (0, import_neverthrow23.okAsync)(toArtifacts({ findings: [], snapshots: [] }, runPaths));
   }
   const safeConfig = buildSafeConfig(config2, runPaths);
   safeConfig.onEvent?.({ type: "STAGE_START", agent: "explorer" });
-  return import_neverthrow22.ResultAsync.fromSafePromise(
-    (0, import_promises13.mkdir)(runPaths.screenshotsDir, { recursive: true }).catch(() => null)
+  return import_neverthrow23.ResultAsync.fromSafePromise(
+    (0, import_promises14.mkdir)(runPaths.screenshotsDir, { recursive: true }).catch(() => null)
   ).andThen(() => runPipeline2({ safeConfig, runPaths, start }));
 }
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow38 = __toESM(require_index_cjs(), 1);
+var import_neverthrow39 = __toESM(require_index_cjs(), 1);
 
 // ../../agents/inspector/dist/index.js
-var import_neverthrow27 = __toESM(require_index_cjs(), 1);
-var import_promises15 = require("node:fs/promises");
 var import_neverthrow28 = __toESM(require_index_cjs(), 1);
+var import_promises16 = require("node:fs/promises");
 var import_neverthrow29 = __toESM(require_index_cjs(), 1);
 var import_neverthrow30 = __toESM(require_index_cjs(), 1);
 var import_neverthrow31 = __toESM(require_index_cjs(), 1);
-var import_sharp2 = __toESM(require("sharp"), 1);
 var import_neverthrow32 = __toESM(require_index_cjs(), 1);
+var import_sharp2 = __toESM(require("sharp"), 1);
 var import_neverthrow33 = __toESM(require_index_cjs(), 1);
-var import_promises16 = require("node:fs/promises");
+var import_neverthrow34 = __toESM(require_index_cjs(), 1);
+var import_promises17 = require("node:fs/promises");
 var import_node_path9 = __toESM(require("node:path"), 1);
 
 // ../../node_modules/.pnpm/js-yaml@4.1.1/node_modules/js-yaml/dist/js-yaml.mjs
@@ -70047,7 +70165,7 @@ var jsYaml = {
 };
 
 // ../../agents/inspector/dist/index.js
-var import_neverthrow34 = __toESM(require_index_cjs(), 1);
+var import_neverthrow35 = __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) {
@@ -70163,7 +70281,7 @@ function matchArtboardName(name, artboardNames) {
   const lower = name.toLowerCase();
   return artboardNames.find((artboard) => artboard.toLowerCase() === lower);
 }
-var safeJsonParse3 = (0, import_neverthrow30.fromThrowable)(JSON.parse, (cause) => ({ cause }));
+var safeJsonParse3 = (0, import_neverthrow31.fromThrowable)(JSON.parse, (cause) => ({ cause }));
 function isRawFindingShape(value, isValidSeverity2) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
@@ -70184,15 +70302,15 @@ function mapRawFinding(item, mappers) {
 }
 function validateFindingArray(parsed, context) {
   if (!Array.isArray(parsed)) {
-    return (0, import_neverthrow30.err)({ type: "NOT_AN_ARRAY", raw: context.raw });
+    return (0, import_neverthrow31.err)({ type: "NOT_AN_ARRAY", raw: context.raw });
   }
   const invalidIndex = parsed.findIndex(
     (item) => !isRawFindingShape(item, context.isValidSeverity)
   );
   if (invalidIndex !== -1) {
-    return (0, import_neverthrow30.err)({ type: "INVALID_FINDING", raw: context.raw, index: invalidIndex });
+    return (0, import_neverthrow31.err)({ type: "INVALID_FINDING", raw: context.raw, index: invalidIndex });
   }
-  return (0, import_neverthrow30.ok)(parsed);
+  return (0, import_neverthrow31.ok)(parsed);
 }
 function parseFindings({
   raw,
@@ -70236,7 +70354,7 @@ async function downscaleBuffer(buffer) {
   return (0, import_sharp2.default)(buffer).resize({ width: targetWidth }).toBuffer();
 }
 function downscale(buffer) {
-  return (0, import_neverthrow31.fromAsyncThrowable)(
+  return (0, import_neverthrow32.fromAsyncThrowable)(
     downscaleBuffer,
     (cause) => ({ type: "CLAUDE_API_FAILED", cause })
   )(buffer);
@@ -70262,7 +70380,7 @@ async function fetchClaudeText({
   return block?.type === "text" ? block.text : "";
 }
 function callClaude(options2) {
-  return (0, import_neverthrow29.fromAsyncThrowable)(
+  return (0, import_neverthrow30.fromAsyncThrowable)(
     fetchClaudeText,
     (cause) => ({ type: "CLAUDE_API_FAILED", cause })
   )(options2);
@@ -70289,12 +70407,12 @@ async function fetchResolveName({
 }
 function resolveArtboard(screenshot, artboardNames) {
   if (artboardNames.length === 0) {
-    return (0, import_neverthrow29.okAsync)(void 0);
+    return (0, import_neverthrow30.okAsync)(void 0);
   }
   const anthropic = new Anthropic();
   return downscale(screenshot).andThen((scaled) => {
     const screenshotBase64 = scaled.toString("base64");
-    return (0, import_neverthrow29.fromAsyncThrowable)(
+    return (0, import_neverthrow30.fromAsyncThrowable)(
       fetchResolveName,
       (cause) => ({ type: "CLAUDE_API_FAILED", cause })
     )({ anthropic, screenshotBase64, artboardNames }).map(
@@ -70407,7 +70525,7 @@ Artboards: ${artboardNames.join(", ")}`
     }
   ];
 }
-var safeJsonParse22 = (0, import_neverthrow33.fromThrowable)(JSON.parse, (cause) => ({ cause }));
+var safeJsonParse22 = (0, import_neverthrow34.fromThrowable)(JSON.parse, (cause) => ({ cause }));
 function resolveCandidateNames(parsed, artboardNames) {
   const matched = parsed.filter((name) => typeof name === "string").map((name) => {
     const lower = name.toLowerCase();
@@ -70419,7 +70537,7 @@ function parseCandidateNames(raw, artboardNames) {
   return safeJsonParse22(raw).mapErr(
     ({ cause }) => ({ type: "CANDIDATES_MALFORMED_JSON", raw, cause })
   ).andThen(
-    (parsed) => Array.isArray(parsed) ? (0, import_neverthrow33.ok)(resolveCandidateNames(parsed, artboardNames)) : (0, import_neverthrow33.err)({ type: "CANDIDATES_NOT_AN_ARRAY", raw })
+    (parsed) => Array.isArray(parsed) ? (0, import_neverthrow34.ok)(resolveCandidateNames(parsed, artboardNames)) : (0, import_neverthrow34.err)({ type: "CANDIDATES_NOT_AN_ARRAY", raw })
   );
 }
 var MODEL22 = "claude-sonnet-4-6";
@@ -70471,18 +70589,18 @@ function toCandidateNames(text, artboardNames) {
 async function downscaleAll(buffers) {
   return Promise.all(buffers.map(async (buf) => downscaleBuffer(buf)));
 }
-var downscaleAllBuffers = (0, import_neverthrow32.fromAsyncThrowable)(
+var downscaleAllBuffers = (0, import_neverthrow33.fromAsyncThrowable)(
   downscaleAll,
   (cause) => ({ type: "CLAUDE_API_FAILED", cause })
 );
 function findCandidates(screenshot, artboardNames) {
   if (artboardNames.length === 0) {
-    return (0, import_neverthrow32.okAsync)([]);
+    return (0, import_neverthrow33.okAsync)([]);
   }
   const anthropic = new Anthropic();
   return downscale(screenshot).andThen((scaled) => {
     const screenshotBase64 = scaled.toString("base64");
-    return (0, import_neverthrow32.fromAsyncThrowable)(
+    return (0, import_neverthrow33.fromAsyncThrowable)(
       fetchCandidatesText,
       (cause) => ({ type: "CLAUDE_API_FAILED", cause })
     )({ anthropic, screenshotBase64, artboardNames }).andThen(
@@ -70496,7 +70614,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_neverthrow32.fromAsyncThrowable)(
+      return (0, import_neverthrow33.fromAsyncThrowable)(
         fetchDesignContextText,
         (cause) => ({ type: "CLAUDE_API_FAILED", cause })
       )({ anthropic, screenshotBase64, artboardBase64s }).andThen(toDesignContextFindings);
@@ -70730,8 +70848,8 @@ async function initArtboardNames({ designStore, config: config2, state }) {
   );
 }
 function readScreenshot(screenshotPath, stepIndex) {
-  return import_neverthrow28.ResultAsync.fromThrowable(
-    import_promises15.readFile,
+  return import_neverthrow29.ResultAsync.fromThrowable(
+    import_promises16.readFile,
     (cause) => ({ type: "SCREENSHOT_READ_FAILED", stepIndex, cause })
   )(screenshotPath);
 }
@@ -70803,7 +70921,7 @@ function buildInspector(state, context) {
       const { promise: promise2, resolve } = Promise.withResolvers();
       state.setResolve(resolve);
       applyTryResolve(state);
-      return (0, import_neverthrow27.fromSafePromise)(promise2);
+      return (0, import_neverthrow28.fromSafePromise)(promise2);
     }
   };
 }
@@ -70852,14 +70970,14 @@ function parseMeta(raw) {
   return {};
 }
 async function readAndParseSidecar(sidecarPath) {
-  const raw = await (0, import_promises16.readFile)(sidecarPath, "utf8");
+  const raw = await (0, import_promises17.readFile)(sidecarPath, "utf8");
   return parseMeta(raw);
 }
 function readSidecarFile(sidecarPath) {
-  return (0, import_neverthrow34.fromAsyncThrowable)(
+  return (0, import_neverthrow35.fromAsyncThrowable)(
     readAndParseSidecar,
     () => ({})
-  )(sidecarPath).orElse(() => (0, import_neverthrow34.okAsync)({}));
+  )(sidecarPath).orElse(() => (0, import_neverthrow35.okAsync)({}));
 }
 function isEnoent(error48) {
   return error48?.code === "ENOENT";
@@ -70868,13 +70986,13 @@ function wrapFsError(cause) {
   return { type: "FS_ERROR", cause };
 }
 function toFsError(fsError) {
-  return (0, import_neverthrow34.errAsync)(fsError);
+  return (0, import_neverthrow35.errAsync)(fsError);
 }
 function missingBuffer() {
-  return (0, import_neverthrow34.okAsync)(void 0);
+  return (0, import_neverthrow35.okAsync)(void 0);
 }
 function missingArtboard() {
-  return (0, import_neverthrow34.okAsync)(void 0);
+  return (0, import_neverthrow35.okAsync)(void 0);
 }
 var FsDesignStore = class {
   designsDirectory;
@@ -70882,12 +71000,12 @@ var FsDesignStore = class {
     this.designsDirectory = designsDirectory;
   }
   listArtboards() {
-    return (0, import_neverthrow34.fromAsyncThrowable)(
-      import_promises16.readdir,
+    return (0, import_neverthrow35.fromAsyncThrowable)(
+      import_promises17.readdir,
       wrapFsError
     )(this.designsDirectory).orElse((fsError) => {
       if (fsError.type === "FS_ERROR" && isEnoent(fsError.cause)) {
-        return (0, import_neverthrow34.okAsync)([]);
+        return (0, import_neverthrow35.okAsync)([]);
       }
       return toFsError(fsError);
     }).map(
@@ -70897,8 +71015,8 @@ var FsDesignStore = class {
   getArtboard(filename) {
     const pngPath = import_node_path9.default.join(this.designsDirectory, `${filename}.png`);
     const sidecarPath = import_node_path9.default.join(this.designsDirectory, `${filename}.meta.yaml`);
-    return (0, import_neverthrow34.fromAsyncThrowable)(
-      import_promises16.readFile,
+    return (0, import_neverthrow35.fromAsyncThrowable)(
+      import_promises17.readFile,
       wrapFsError
     )(pngPath).orElse((fsError) => {
       if (fsError.type === "FS_ERROR" && isEnoent(fsError.cause)) {
@@ -70918,13 +71036,13 @@ var FsDesignStore = class {
 
 // ../../packages/pipeline/dist/index.js
 var import_node_fs2 = require("node:fs");
-var import_neverthrow39 = __toESM(require_index_cjs(), 1);
 var import_neverthrow40 = __toESM(require_index_cjs(), 1);
 var import_neverthrow41 = __toESM(require_index_cjs(), 1);
-var import_node_fs3 = require("node:fs");
 var import_neverthrow42 = __toESM(require_index_cjs(), 1);
-var import_node_fs4 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 var import_neverthrow43 = __toESM(require_index_cjs(), 1);
+var import_node_fs4 = require("node:fs");
+var import_neverthrow44 = __toESM(require_index_cjs(), 1);
 function createDefaultMcpServers(udid) {
   return {
     "mobile-ios": createMobileIosServer(udid)
@@ -70940,10 +71058,10 @@ function attemptRetry(options2) {
   const { factory, config: config2, delayFunction, onRetry, attempt } = options2;
   return factory().orElse((error48) => {
     if (attempt >= config2.maxAttempts) {
-      return (0, import_neverthrow37.errAsync)(error48);
+      return (0, import_neverthrow38.errAsync)(error48);
     }
     const delay = config2.baseDelayMs * Math.pow(2, attempt - 1);
-    return import_neverthrow37.ResultAsync.fromPromise(
+    return import_neverthrow38.ResultAsync.fromPromise(
       (onRetry?.({ attempt, maxAttempts: config2.maxAttempts, delayMs: delay, error: error48 }), delayFunction(delay)),
       () => error48
     ).andThen(
@@ -70963,7 +71081,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_neverthrow36.okAsync)(artifacts.findings);
+  return (0, import_neverthrow37.okAsync)(artifacts.findings);
 }
 function runAnalyserWithRetry(params) {
   const { artifacts, config: config2, onEvent } = params;
@@ -70973,7 +71091,7 @@ function runAnalyserWithRetry(params) {
     ),
     {
       config: { maxAttempts: RETRY_MAX_ATTEMPTS, baseDelayMs: RETRY_BASE_DELAY_MS },
-      delayFunction: import_promises17.setTimeout,
+      delayFunction: import_promises18.setTimeout,
       onRetry: ({ attempt, maxAttempts, delayMs, error: error48 }) => {
         onEvent?.({
           type: "AGENT_RETRY",
@@ -70993,7 +71111,7 @@ function resolveVisualFindings({
   onEvent
 }) {
   if (config2.analyser === void 0 || config2.signal?.aborted) {
-    return (0, import_neverthrow36.okAsync)(artifacts.findings);
+    return (0, import_neverthrow37.okAsync)(artifacts.findings);
   }
   return runAnalyserWithRetry({ artifacts, config: config2, onEvent });
 }
@@ -71003,7 +71121,7 @@ function unmergedFallback(allFindings, onEvent) {
     agent: CONSOLIDATOR_AGENT,
     message: "Consolidation failed, returning unmerged findings"
   });
-  return (0, import_neverthrow36.okAsync)({ findings: allFindings, dismissed: [] });
+  return (0, import_neverthrow37.okAsync)({ findings: allFindings, dismissed: [] });
 }
 function mergeWithFallback(options2) {
   const {
@@ -71030,7 +71148,7 @@ function consolidate(options2) {
   const { artifacts, inspectorFindings, runId, dismissals, config: config2, consolidatorConfig, onEvent } = options2;
   return resolveVisualFindings({ artifacts, config: config2, onEvent }).andThen((visualFindings) => {
     if (config2.signal?.aborted) {
-      return (0, import_neverthrow36.okAsync)({ findings: artifacts.findings, dismissed: [] });
+      return (0, import_neverthrow37.okAsync)({ findings: artifacts.findings, dismissed: [] });
     }
     return mergeWithFallback({
       artifacts,
@@ -71127,14 +71245,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_neverthrow38.errAsync)(error48)).orElse(() => (0, import_neverthrow38.errAsync)(error48))
+    (error48) => disableTouchIndicators(udid).mapErr(toSimulatorError).andThen(() => (0, import_neverthrow39.errAsync)(error48)).orElse(() => (0, import_neverthrow39.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_promises18.setTimeout,
+    delayFunction: import_promises19.setTimeout,
     onRetry: ({ attempt, maxAttempts, delayMs, error: error48 }) => {
       onEvent?.({
         type: "AGENT_RETRY",
@@ -71153,12 +71271,12 @@ async function drainAfterExplorer(options2) {
   inspector?.close();
   const inspectorFindings = inspector ? await collectInspectorFindings({ inspector, onEvent, totalSteps: enqueuedCount.value }) : [];
   if (explorerResult.isErr()) {
-    return (0, import_neverthrow38.err)(explorerResult.error);
+    return (0, import_neverthrow39.err)(explorerResult.error);
   }
-  return (0, import_neverthrow38.ok)({ artifacts: explorerResult.value, inspectorFindings });
+  return (0, import_neverthrow39.ok)({ artifacts: explorerResult.value, inspectorFindings });
 }
 function runExplorerAndDrain(options2) {
-  return import_neverthrow38.ResultAsync.fromSafePromise(drainAfterExplorer(options2)).andThen((result) => result);
+  return import_neverthrow39.ResultAsync.fromSafePromise(drainAfterExplorer(options2)).andThen((result) => result);
 }
 function filterByConfidence(findings, threshold) {
   return {
@@ -71166,7 +71284,7 @@ function filterByConfidence(findings, threshold) {
     dropped: findings.filter((finding) => !meetsConfidenceThreshold(finding.confidence, threshold)).map((finding) => ({ finding, reason: "low-confidence" }))
   };
 }
-var writeOutputFile = (0, import_neverthrow39.fromThrowable)(
+var writeOutputFile = (0, import_neverthrow40.fromThrowable)(
   (params) => {
     const { findingsPath, outputDirectory, json: json3 } = params;
     (0, import_node_fs2.mkdirSync)(outputDirectory, { recursive: true });
@@ -71212,8 +71330,8 @@ function buildExplorerConfig({
 function getDismissalsPathOverride() {
   return process.env.QA_DISMISSALS_PATH;
 }
-var safeReadFile = (0, import_neverthrow42.fromThrowable)((filePath) => (0, import_node_fs3.readFileSync)(filePath, "utf8"));
-var safeParseJson2 = (0, import_neverthrow42.fromThrowable)(JSON.parse);
+var safeReadFile = (0, import_neverthrow43.fromThrowable)((filePath) => (0, import_node_fs3.readFileSync)(filePath, "utf8"));
+var safeParseJson2 = (0, import_neverthrow43.fromThrowable)(JSON.parse);
 function isEnoent2(error48) {
   if (!(error48 instanceof Error)) {
     return false;
@@ -71225,19 +71343,19 @@ function loadDismissals(filePath) {
   const readResult = safeReadFile(filePath);
   if (readResult.isErr()) {
     if (isEnoent2(readResult.error)) {
-      return (0, import_neverthrow42.ok)([]);
+      return (0, import_neverthrow43.ok)([]);
     }
-    return (0, import_neverthrow42.err)({ type: "DISMISSALS_LOAD_FAILED", cause: readResult.error });
+    return (0, import_neverthrow43.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_neverthrow42.err)({
+      return (0, import_neverthrow43.err)({
         type: "DISMISSALS_LOAD_FAILED",
         cause: "invalid shape: dismissed is not an array"
       });
     }
-    return (0, import_neverthrow42.ok)(store.dismissed);
+    return (0, import_neverthrow43.ok)(store.dismissed);
   });
 }
 var ISO_DATE_LENGTH2 = 10;
@@ -71247,7 +71365,7 @@ function computeNextRunId(entries) {
   const max = parsed.length === 0 ? 0 : Math.max(...parsed);
   return String(max + 1).padStart(RUN_ID_PAD_LENGTH, "0");
 }
-var safeReaddirSync = (0, import_neverthrow43.fromThrowable)((directory) => (0, import_node_fs4.readdirSync)(directory));
+var safeReaddirSync = (0, import_neverthrow44.fromThrowable)((directory) => (0, import_node_fs4.readdirSync)(directory));
 function nextRunId(outputDirectory, date5) {
   const entries = safeReaddirSync(`${outputDirectory}/${date5}`).unwrapOr([]);
   return computeNextRunId(entries);
@@ -71259,15 +71377,15 @@ function resolvePipelineConfig({
   const runId = config2.runId ?? nextRunId(config2.outputDir, date5);
   const runPathsResult = resolveRunPaths({ outputDirectory: config2.outputDir, runId, date: date5 });
   if (runPathsResult.isErr()) {
-    return (0, import_neverthrow41.err)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
+    return (0, import_neverthrow42.err)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
   }
   const dismissalsResult = loadDismissals(
     dismissalsPath(config2.outputDir, getDismissalsPathOverride())
   );
   if (dismissalsResult.isErr()) {
-    return (0, import_neverthrow41.err)(dismissalsResult.error);
+    return (0, import_neverthrow42.err)(dismissalsResult.error);
   }
-  return (0, import_neverthrow41.ok)({ runId, date: date5, runPaths: runPathsResult.value, dismissals: dismissalsResult.value });
+  return (0, import_neverthrow42.ok)({ runId, date: date5, runPaths: runPathsResult.value, dismissals: dismissalsResult.value });
 }
 function assemblePipelineSetup({
   config: config2,
@@ -71300,10 +71418,10 @@ function buildPipelineSetup({
 }) {
   const resolvedResult = resolvePipelineConfig({ config: config2, date: date5 });
   if (resolvedResult.isErr()) {
-    return (0, import_neverthrow40.err)(resolvedResult.error);
+    return (0, import_neverthrow41.err)(resolvedResult.error);
   }
   const { runId, runPaths, dismissals } = resolvedResult.value;
-  return (0, import_neverthrow40.ok)(assemblePipelineSetup({ config: config2, date: date5, runId, runPaths, dismissals }));
+  return (0, import_neverthrow41.ok)(assemblePipelineSetup({ config: config2, date: date5, runId, runPaths, dismissals }));
 }
 function runAgentPhases(setup, config2) {
   const { onEvent } = config2;
@@ -71340,50 +71458,18 @@ function runPipeline3(config2) {
   const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, ISO_DATE_LENGTH2);
   const setupResult = buildPipelineSetup({ config: config2, date: date5 });
   if (setupResult.isErr()) {
-    return (0, import_neverthrow35.errAsync)(setupResult.error);
+    return (0, import_neverthrow36.errAsync)(setupResult.error);
   }
   return executePipeline(setupResult.value, config2);
 }
 
-// src/commands/analyse-command.ts
-var import_neverthrow45 = __toESM(require_index_cjs(), 1);
-
-// src/commands/item-events.ts
-function emitItemStart(identity, at) {
-  const { display, itemId, itemName, simulatorUdid } = identity;
-  display.onEvent({ type: "ITEM_QUEUED", item: { id: itemId, name: itemName } });
-  display.onEvent({ type: "ITEM_STARTED", itemId, itemName, simulatorUdid, at });
-}
-function emitItemCompleted(input) {
-  const { identity, startedAt, findingsCount, dismissedCount } = input;
-  const { display, itemId, itemName } = identity;
-  const at = Date.now();
-  display.onEvent({
-    type: "ITEM_COMPLETED",
-    itemId,
-    itemName,
-    findingsCount,
-    dismissedCount,
-    durationMs: at - startedAt,
-    at
-  });
-}
-function emitItemFailed(input) {
-  const { identity, startedAt, error: error48 } = input;
-  const { display, itemId, itemName } = identity;
-  const at = Date.now();
-  display.onEvent({
-    type: "ITEM_FAILED",
-    itemId,
-    itemName,
-    error: error48,
-    durationMs: at - startedAt,
-    at
-  });
+// src/commands/analyse/artifacts.ts
+function buildArtifacts(videoPath) {
+  return { videoPath, findings: [], snapshots: [] };
 }
 
 // src/shell/debug-agent-events.ts
-var import_neverthrow44 = __toESM(require_index_cjs(), 1);
+var import_neverthrow45 = __toESM(require_index_cjs(), 1);
 
 // src/constants.ts
 var MOBILE_IOS_TOOLS = [
@@ -71467,7 +71553,7 @@ function tryStringify(value) {
   const result = JSON.stringify(value);
   return result ?? UNSERIALIZABLE;
 }
-var safeStringify = (0, import_neverthrow44.fromThrowable)(tryStringify, () => ({
+var safeStringify = (0, import_neverthrow45.fromThrowable)(tryStringify, () => ({
   type: "STRINGIFY_FAILED"
 }));
 function toolKey(scope, event) {
@@ -71592,6 +71678,12 @@ function handleItemFailed(logger, event) {
 function handleItemTimeout(logger, event) {
   logger.log("ITEM_TIMEOUT", `id=${event.itemId} duration=${String(event.durationMs)}ms`);
 }
+function handleItemAborted(logger, event) {
+  logger.log(
+    "ITEM_ABORTED",
+    `id=${event.itemId} reason=${event.reason} duration=${String(event.durationMs)}ms`
+  );
+}
 function handleSimulatorUnhealthy(logger, event) {
   logger.log(
     "SIMULATOR_UNHEALTHY",
@@ -71610,6 +71702,7 @@ var SUITE_EVENT_HANDLERS = {
   ITEM_COMPLETED: handleItemCompleted,
   ITEM_FAILED: handleItemFailed,
   ITEM_TIMEOUT: handleItemTimeout,
+  ITEM_ABORTED: handleItemAborted,
   SIMULATOR_UNHEALTHY: handleSimulatorUnhealthy,
   SUITE_COMPLETED: handleSuiteCompleted
 };
@@ -71680,36 +71773,9 @@ function createSuiteDisplay() {
   });
 }
 
-// src/commands/analyse-command.ts
-var JSON_INDENT = 2;
+// src/commands/analyse/run-state.ts
 var ITEM_ID = "analyse";
 var ITEM_NAME = "analyse";
-function buildArtifacts(videoPath) {
-  return { videoPath, findings: [], snapshots: [] };
-}
-async function checkVideoPathExists(videoPath) {
-  const safeAccess = (0, import_neverthrow45.fromAsyncThrowable)(import_promises19.access, () => ({ type: "FILE_NOT_FOUND" }));
-  const result = await safeAccess(videoPath);
-  return result.isOk();
-}
-function handleAnalyseSuccess(state, findings) {
-  emitItemCompleted({
-    identity: state.identity,
-    startedAt: state.startedAt,
-    findingsCount: findings.length,
-    dismissedCount: 0
-  });
-  state.identity.display.cleanup();
-  process.stdout.write(JSON.stringify(findings, void 0, JSON_INDENT));
-  process.exit(0);
-}
-function handleAnalyseError(state, errorType) {
-  emitItemFailed({ identity: state.identity, startedAt: state.startedAt, error: errorType });
-  state.identity.display.cleanup();
-  process.stderr.write(`Analysis failed: ${errorType}
-`);
-  process.exit(1);
-}
 function buildAnalyseIdentity() {
   return {
     display: createSoloDisplay(),
@@ -71725,62 +71791,36 @@ function buildAnalyseEventHandler(identity, isDebug) {
   };
   return debugLogger.wrapAgentHandler(baseHandler);
 }
-async function runAnalysisAndExit(input) {
+function buildAnalyseRunState(isDebug) {
   const identity = buildAnalyseIdentity();
   const startedAt = Date.now();
-  emitItemStart(identity, startedAt);
-  const onEvent = buildAnalyseEventHandler(identity, input.debug);
-  const state = { identity, startedAt };
-  const result = await runAnalysis(input.artifacts, {
-    apiKey: input.apiKey,
-    onEvent
+  const onEvent = buildAnalyseEventHandler(identity, isDebug);
+  return { identity, startedAt, onEvent };
+}
+
+// src/commands/analyse/runner.ts
+async function runValidatedAnalysis(validated) {
+  const state = buildAnalyseRunState(validated.debug);
+  emitItemStart(state.identity, state.startedAt);
+  const onSuccess = buildSuccessHandler(state);
+  const onError = buildErrorHandler(state);
+  const result = await runAnalysis(buildArtifacts(validated.videoPath), {
+    apiKey: validated.apiKey,
+    onEvent: state.onEvent
+  });
+  result.match(onSuccess, (error48) => {
+    onError(error48.type);
   });
-  result.match(
-    (findings) => {
-      handleAnalyseSuccess(state, findings);
-    },
-    (error48) => {
-      handleAnalyseError(state, error48.type);
-    }
-  );
-}
-function ensureApiKey(config2) {
-  const apiKey = config2.GOOGLE_GENERATIVE_AI_API_KEY ?? "";
-  if (!apiKey) {
-    process.stderr.write("GOOGLE_GENERATIVE_AI_API_KEY is not set\n");
-    process.exit(1);
-    return;
-  }
-  return apiKey;
-}
-async function resolveVideoPath(videoPath) {
-  if (videoPath === void 0) {
-    process.stderr.write('A video path is required. Pass the path printed by "xqa explore".\n');
-    process.exit(1);
-    return;
-  }
-  if (!await checkVideoPathExists(videoPath)) {
-    process.stderr.write(`Video file not found: ${videoPath}
-`);
-    process.exit(1);
-    return;
-  }
-  return videoPath;
 }
+
+// src/commands/analyse-command.ts
 async function runAnalyseCommand(input) {
-  const apiKey = ensureApiKey(input.config);
-  if (apiKey === void 0) {
+  const validated = await validateAnalyseInput(input);
+  if (validated.isErr()) {
+    handleInputError(validated.error);
     return;
   }
-  const videoPath = await resolveVideoPath(input.videoPath);
-  if (videoPath === void 0) {
-    return;
-  }
-  await runAnalysisAndExit({
-    artifacts: buildArtifacts(videoPath),
-    apiKey,
-    debug: input.debug
-  });
+  await runValidatedAnalysis(validated.value);
 }
 
 // src/commands/register/analyse.ts
@@ -72067,7 +72107,7 @@ function buildSuccessMessage(output) {
   return `${base}${String(output.findings.length)} finding${output.findings.length === 1 ? "" : "s"} \u2014 run \`xqa review\` to triage.
 `;
 }
-function buildSuccessHandler({
+function buildSuccessHandler2({
   input,
   xqaDirectory,
   identity,
@@ -72089,7 +72129,7 @@ function buildSuccessHandler({
     process.exit(0);
   };
 }
-function buildErrorHandler(identity, startedAt) {
+function buildErrorHandler2(identity, startedAt) {
   return (error48) => {
     emitItemFailed({ identity, startedAt, error: error48.type });
     identity.display.cleanup();
@@ -72165,8 +72205,8 @@ function buildExploreRunState({
     identity.display.onEvent({ ...event, itemId: ITEM_ID2 });
   };
   const onEvent = debugLogger.wrapAgentHandler(baseHandler);
-  const onSuccess = buildSuccessHandler({ input, xqaDirectory, identity, startedAt });
-  const onError = buildErrorHandler(identity, startedAt);
+  const onSuccess = buildSuccessHandler2({ input, xqaDirectory, identity, startedAt });
+  const onError = buildErrorHandler2(identity, startedAt);
   return { input, config: config2, xqaDirectory, onEvent, onSuccess, onError, simulatorUdid };
 }
 
@@ -79460,6 +79500,7 @@ var PriorityQueue = class {
 };
 
 // src/suite/shell/item-result-builder.ts
+var ABORTED_ITEM_ERROR_MESSAGE = "aborted by suite shutdown";
 function getSpecPath(item) {
   if (item.type === "spec") {
     return item.specPath;
@@ -79516,21 +79557,82 @@ function buildTimedOutItem(context) {
     error: "timeout"
   };
 }
-function buildAbortedItem(item, simulatorUdid) {
+function buildAbortedItem(context) {
   return {
-    id: item.id,
-    type: item.type,
-    name: item.name,
+    id: context.item.id,
+    type: context.item.type,
+    name: context.item.name,
     status: "aborted",
-    simulatorUdid,
-    specPath: getSpecPath(item),
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    simulatorUdid: context.simulatorUdid,
+    specPath: getSpecPath(context.item),
+    startedAt: context.startedAt,
     findingsPath: null,
     findings: [],
-    durationMs: 0
+    durationMs: context.durationMs
   };
 }
 
+// src/suite/shell/aborted-item-drainer.ts
+function emitAbortedTerminal(input) {
+  input.observer({
+    type: "ITEM_ABORTED",
+    itemId: input.item.id,
+    itemName: input.item.name,
+    reason: ABORTED_ITEM_ERROR_MESSAGE,
+    durationMs: input.durationMs,
+    at: Date.now()
+  });
+}
+function recordAbortedEntry(context, itemContext) {
+  if (context.recordedIds.has(itemContext.item.id)) {
+    return;
+  }
+  context.results.push(buildAbortedItem(itemContext));
+  context.recordedIds.add(itemContext.item.id);
+  emitAbortedTerminal({
+    observer: context.observer,
+    item: itemContext.item,
+    durationMs: itemContext.durationMs
+  });
+}
+function drainQueuedItems(input, context) {
+  const { queue, fallbackUdid } = input;
+  while (!queue.isEmpty) {
+    const item = queue.dequeue();
+    if (item === void 0) {
+      break;
+    }
+    recordAbortedEntry(context, {
+      item,
+      simulatorUdid: fallbackUdid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: 0
+    });
+  }
+}
+function drainInFlightItems(input, context) {
+  const { inFlight } = input;
+  for (const entry of inFlight.values()) {
+    recordAbortedEntry(context, {
+      item: entry.item,
+      simulatorUdid: entry.simulatorUdid,
+      startedAt: entry.startedAt,
+      durationMs: Date.now() - entry.startMs
+    });
+  }
+  inFlight.clear();
+}
+function drainAbortedItems(input) {
+  const recordedIds = new Set(input.results.map((item) => item.id));
+  const context = {
+    results: input.results,
+    observer: input.observer,
+    recordedIds
+  };
+  drainInFlightItems(input, context);
+  drainQueuedItems(input, context);
+}
+
 // src/suite/shell/item-result-recorder.ts
 function isTimeoutError(error48) {
   return error48.type.toUpperCase().includes("TIMEOUT");
@@ -79833,6 +79935,14 @@ function handleHookFailure(state, error48) {
     observer: workerContext.config.observer
   });
 }
+function trackInFlight(workerContext, state) {
+  workerContext.inFlight.set(state.item.id, {
+    item: state.item,
+    simulatorUdid: workerContext.simulatorUdid,
+    startedAt: state.startedAt,
+    startMs: state.startMs
+  });
+}
 async function processItem(workerContext, item) {
   const state = {
     workerContext,
@@ -79840,13 +79950,25 @@ async function processItem(workerContext, item) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     startMs: Date.now()
   };
+  trackInFlight(workerContext, state);
   emitItemStarted(state);
   const hookOutcome = await maybeInvokeHook(buildHookInvokeInput(workerContext, item));
   if (hookOutcome.isErr()) {
-    return handleHookFailure(state, hookOutcome.error);
+    const failCount2 = handleHookFailure(state, hookOutcome.error);
+    workerContext.inFlight.delete(item.id);
+    return failCount2;
   }
-  return runAndRecordItem(state);
+  const failCount = await runAndRecordItem(state);
+  workerContext.inFlight.delete(item.id);
+  return failCount;
 }
+var safeProcessItem = import_neverthrow59.ResultAsync.fromThrowable(
+  processItem,
+  (cause) => ({
+    type: "PROCESS_ITEM_FAILED",
+    cause
+  })
+);
 async function runWorker(workerContext) {
   const { simulatorUdid, queue, config: config2 } = workerContext;
   let consecutiveFailures = 0;
@@ -79855,7 +79977,11 @@ async function runWorker(workerContext) {
     if (item === void 0) {
       break;
     }
-    const failCount = await processItem(workerContext, item);
+    const outcome = await safeProcessItem(workerContext, item);
+    const failCount = outcome.match(
+      (value) => value,
+      () => 1
+    );
     consecutiveFailures = failCount === 0 ? 0 : consecutiveFailures + 1;
     if (consecutiveFailures >= CONSECUTIVE_FAILURES_THRESHOLD) {
       config2.observer({ type: "SIMULATOR_UNHEALTHY", simulatorUdid, consecutiveFailures });
@@ -79871,25 +79997,20 @@ function setupQueue(config2) {
   }
   return queue;
 }
-function drainAbortedItems(runContext) {
-  const { queue, results, config: config2 } = runContext;
-  const fallbackUdid = config2.simulatorUdids[0] ?? "";
-  while (!queue.isEmpty) {
-    const item = queue.dequeue();
-    if (item === void 0) {
-      break;
-    }
-    results.push(buildAbortedItem(item, fallbackUdid));
-  }
-}
 async function runAllWorkers(runContext) {
-  const { config: config2, queue, results, suiteStartMs } = runContext;
+  const { config: config2, queue, results, suiteStartMs, inFlight } = runContext;
   const workerPromises = config2.simulatorUdids.map(
-    async (udid) => runWorker({ simulatorUdid: udid, queue, results, config: config2 })
+    async (udid) => runWorker({ simulatorUdid: udid, queue, results, config: config2, inFlight })
   );
   await Promise.allSettled(workerPromises);
-  if (config2.signal.aborted) {
-    drainAbortedItems(runContext);
+  if (config2.signal.aborted || inFlight.size > 0 || !queue.isEmpty) {
+    drainAbortedItems({
+      queue,
+      results,
+      observer: config2.observer,
+      inFlight,
+      fallbackUdid: config2.simulatorUdids[0] ?? ""
+    });
   }
   const totalFindings = results.reduce((sum, item) => sum + item.findings.length, 0);
   config2.observer({
@@ -79904,9 +80025,10 @@ async function runAllWorkers(runContext) {
 function runWorkerPool(config2) {
   const queue = setupQueue(config2);
   const results = [];
+  const inFlight = /* @__PURE__ */ new Map();
   const suiteStartMs = Date.now();
   const safeRun = import_neverthrow59.ResultAsync.fromThrowable(
-    async () => runAllWorkers({ config: config2, queue, results, suiteStartMs }),
+    async () => runAllWorkers({ config: config2, queue, results, suiteStartMs, inFlight }),
     (cause) => ({ type: "WORKER_POOL_FAILED", cause })
   );
   return safeRun();
@@ -82413,8 +82535,6 @@ function buildDecision(input) {
     metaPr: input.metaPr
   };
 }
-var HIGH_MATCH_RATIO = 0.7;
-var MEDIUM_MATCH_RATIO = 0.3;
 var REASON_SAMPLE_LIMIT = 3;
 function matchesAnyGlob(path29, patterns) {
   return patterns.some((pattern) => minimatch(path29, pattern));
@@ -82422,38 +82542,24 @@ function matchesAnyGlob(path29, patterns) {
 function collectMatchingPaths(diff, covers) {
   return diff.files.filter((file2) => matchesAnyGlob(file2.path, covers)).map((file2) => file2.path);
 }
-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 formatReason(paths) {
+  const sample = paths.slice(0, REASON_SAMPLE_LIMIT).join(", ");
+  const overflow = paths.length > REASON_SAMPLE_LIMIT ? ", \u2026" : "";
+  const suffix = paths.length === 1 ? "" : "s";
+  return `touched ${String(paths.length)} covered file${suffix}: ${sample}${overflow}`;
 }
 function scoreGroup(diff, group) {
   if (!group.covers || group.covers.length === 0) {
     return void 0;
   }
-  const total = diff.files.length;
   const matchingPaths = collectMatchingPaths(diff, group.covers);
-  const matches = matchingPaths.length;
-  const confidence = resolvePickConfidence(matches, total);
-  if (confidence === void 0) {
+  if (matchingPaths.length === 0) {
     return void 0;
   }
   return {
     groupId: group.id,
-    confidence,
-    reason: formatReason({ matches, total, paths: matchingPaths }),
+    confidence: "HIGH",
+    reason: formatReason(matchingPaths),
     evidence: matchingPaths.map((matchPath) => `diff:${matchPath}`)
   };
 }
@@ -83131,7 +83237,7 @@ function buildBootstrap(options2) {
 function selectGroups(options2) {
   return runPipeline4(buildBootstrap(options2));
 }
-var DEFAULT_MODEL2 = "claude-opus-4-6";
+var DEFAULT_MODEL2 = "claude-sonnet-4-6";
 var CONFIDENCE_RANK = {
   HIGH: 2,
   MEDIUM: 1,
@@ -83194,19 +83300,10 @@ function toSuitePromptInput(group, context) {
 function buildSuitePromptInputs(context) {
   return context.groups.map((group) => toSuitePromptInput(group, context));
 }
-var MATCH_COUNT_PATTERN = /matched (\d+)/;
-var COUNT_GROUP_INDEX = 1;
-function extractMatchCount(reason) {
-  const match2 = MATCH_COUNT_PATTERN.exec(reason);
-  if (match2 === null) {
-    return 0;
-  }
-  return Number.parseInt(match2[COUNT_GROUP_INDEX] ?? "0", 10);
-}
 function buildGlobHits(diff, groups) {
   return scoreGroups(diff, groups).map((pick2) => ({
     groupId: pick2.groupId,
-    fileCount: extractMatchCount(pick2.reason)
+    fileCount: pick2.evidence.length
   }));
 }
 function mergePickPair(existing, incoming) {
@@ -83281,12 +83378,6 @@ function combineAiOutcome(staticPicks, aiResult) {
 function runAiTiebreaker(context, staticPicks) {
   return selectGroups(buildSelectGroupsOptions(context)).mapErr(mapAiError).map((aiResult) => combineAiOutcome(staticPicks, aiResult));
 }
-function shouldSkipAi(context, decision) {
-  if (!context.useAi) {
-    return true;
-  }
-  return decision.confidence === "high";
-}
 function runTriager(options2) {
   const { groups, config: config2 } = options2;
   if (groups.length === 0) {
@@ -83297,9 +83388,8 @@ function runTriager(options2) {
   }
   const context = buildContext2(options2);
   const staticPicks = scoreGroups(context.diff, context.groups);
-  const initial = buildDecision({ picks: staticPicks, metaPr: false });
-  if (shouldSkipAi(context, initial)) {
-    return (0, import_neverthrow65.okAsync)(initial);
+  if (!context.useAi) {
+    return (0, import_neverthrow65.okAsync)(buildDecision({ picks: staticPicks, metaPr: false }));
   }
   return runAiTiebreaker(context, staticPicks);
 }
@@ -87935,7 +88025,7 @@ function buildProgram(options2) {
 
 // src/index.ts
 process.title = "xqa";
-var version2 = `${"3.0.0"}${false ? ` (dev build +${"76b2340"})` : ""}`;
+var version2 = `${"3.0.1"}${false ? ` (dev build +${"c388107"})` : ""}`;
 var programResult = buildProgram({ version: version2 });
 if (programResult.isErr()) {
   process.stderr.write(programResult.error.message + "\n");