@exodus/xqa 1.6.1 → 1.8.0

package/dist/xqa.cjs

@@ -3719,7 +3719,7 @@ var require_index_cjs = __commonJS({
         return __asyncGenerator2(this, arguments, function* _a3() {
           const result = yield __await2(this._promise);
           if (result.isErr()) {
-            yield yield __await2(errAsync7(result.error));
+            yield yield __await2(errAsync8(result.error));
           }
           return yield __await2(result.value);
         });
@@ -3728,7 +3728,7 @@ var require_index_cjs = __commonJS({
     function okAsync8(value) {
       return new ResultAsync12(Promise.resolve(new Ok(value)));
     }
-    function errAsync7(err19) {
+    function errAsync8(err19) {
       return new ResultAsync12(Promise.resolve(new Err(err19)));
     }
     var fromPromise = ResultAsync12.fromPromise;
@@ -3910,14 +3910,14 @@ var require_index_cjs = __commonJS({
       }
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       asyncAndThen(_f) {
-        return errAsync7(this.error);
+        return errAsync8(this.error);
       }
       asyncAndThrough(_f) {
-        return errAsync7(this.error);
+        return errAsync8(this.error);
       }
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       asyncMap(_f) {
-        return errAsync7(this.error);
+        return errAsync8(this.error);
       }
       unwrapOr(v2) {
         return v2;
@@ -3949,7 +3949,7 @@ var require_index_cjs = __commonJS({
     exports2.Ok = Ok;
     exports2.ResultAsync = ResultAsync12;
     exports2.err = err18;
-    exports2.errAsync = errAsync7;
+    exports2.errAsync = errAsync8;
     exports2.fromAsyncThrowable = fromAsyncThrowable10;
     exports2.fromPromise = fromPromise;
     exports2.fromSafePromise = fromSafePromise2;
@@ -52810,7 +52810,7 @@ function dismissalsPath(baseDirectory, override) {
 }
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow29 = __toESM(require_index_cjs(), 1);
+var import_neverthrow30 = __toESM(require_index_cjs(), 1);
 var import_promises14 = require("node:timers/promises");
 
 // ../../agents/analyser/dist/index.js
@@ -62129,10 +62129,10 @@ function runConsolidator(input, config3) {
 }
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow30 = __toESM(require_index_cjs(), 1);
 var import_neverthrow31 = __toESM(require_index_cjs(), 1);
-var import_node_fs3 = require("node:fs");
 var import_neverthrow32 = __toESM(require_index_cjs(), 1);
+var import_node_fs3 = require("node:fs");
+var import_neverthrow33 = __toESM(require_index_cjs(), 1);
 var import_promises15 = require("node:timers/promises");
 
 // ../../agents/explorer/dist/index.js
@@ -62150,9 +62150,10 @@ var import_node_child_process4 = require("node:child_process");
 var import_promises10 = require("node:fs/promises");
 var import_neverthrow19 = __toESM(require_index_cjs(), 1);
 var import_neverthrow20 = __toESM(require_index_cjs(), 1);
+var import_neverthrow21 = __toESM(require_index_cjs(), 1);
 var import_promises11 = require("node:fs/promises");
 var import_node_path6 = __toESM(require("node:path"), 1);
-var import_neverthrow21 = __toESM(require_index_cjs(), 1);
+var import_neverthrow22 = __toESM(require_index_cjs(), 1);
 async function runFfmpeg(arguments_) {
   const { promise: promise2, resolve, reject } = Promise.withResolvers();
   (0, import_node_child_process3.execFile)("ffmpeg", arguments_, (error48) => {
@@ -62846,6 +62847,53 @@ function runQuery(prompt, config3) {
 function collectAgentOutput(prompt, config3) {
   return runQuery(prompt, config3).mapErr((cause) => ({ type: "QUERY_FAILED", cause }));
 }
+var SPEED_2X = 2;
+var SPEED_4X = 4;
+function applySpeedUpVariants({
+  result,
+  params,
+  toRecordingError
+}) {
+  const { findings, snapshots } = result;
+  const { videoPath, videoPath2x, videoPath4x, signal } = params;
+  if (signal?.aborted) {
+    return (0, import_neverthrow20.okAsync)({ findings, snapshots });
+  }
+  return speedUpVideo({ inputPath: videoPath, factor: SPEED_2X, outputPath: videoPath2x }).mapErr(toRecordingError).andThen(
+    () => speedUpVideo({ inputPath: videoPath, factor: SPEED_4X, outputPath: videoPath4x }).mapErr(toRecordingError).map(() => ({ findings, snapshots }))
+  );
+}
+function runWithRecording(handle, collectOutput) {
+  const toRecordingError = (cause) => ({
+    type: "RECORDING_FAILED",
+    cause
+  });
+  return collectOutput().andThen(
+    ({ findings, snapshots }) => stopRecording(handle).mapErr(toRecordingError).map(() => ({ findings, snapshots }))
+  ).orElse(
+    (error48) => stopRecording(handle).mapErr(toRecordingError).andThen(() => (0, import_neverthrow20.errAsync)(error48)).orElse(() => (0, import_neverthrow20.errAsync)(error48))
+  );
+}
+function startAndRun(params) {
+  const { videoPath, signal, collectOutput } = params;
+  const toRecordingError = (cause) => ({
+    type: "RECORDING_FAILED",
+    cause
+  });
+  return startRecording(videoPath).mapErr(toRecordingError).andThen((handle) => {
+    const onAbort = () => {
+      void stopRecording(handle).unwrapOr(null);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    return runWithRecording(handle, collectOutput).map((result) => {
+      signal?.removeEventListener("abort", onAbort);
+      return result;
+    }).mapErr((error48) => {
+      signal?.removeEventListener("abort", onAbort);
+      return error48;
+    }).andThen((result) => applySpeedUpVariants({ result, params, toRecordingError }));
+  });
+}
 var DEV_ENVIRONMENT_SECTION = `## Environment
 
 This is a development build. Debug overlays and internal messages are expected artifacts \u2014 do not report them as findings.`;
@@ -62915,8 +62963,6 @@ A step MAY be skipped if and only if:
 - The action's direct target (element, modal, screen) is not present, AND
 - The current screen state already satisfies the expected postcondition of this step (i.e. the step's effect has already occurred or was never needed).
 
-When skipping, emit a \`step-skipped\` finding with a one-sentence reason explaining what was absent and what already-satisfied condition justified the skip.
-
 Do NOT skip if:
 - The target is absent but the screen is in an unexpected or intermediate state.
 - You are uncertain whether the postcondition is satisfied.
@@ -63057,29 +63103,29 @@ var INLINE_ASSERTION_DELIMITER = " \u2192 ";
 var NUMBERED_STEP_PREFIX = /^\d+\.\s+/;
 function parseTagsValue(value) {
   if (!value.startsWith("[") || !value.endsWith("]")) {
-    return (0, import_neverthrow20.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid tags format: ${value}` });
+    return (0, import_neverthrow21.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid tags format: ${value}` });
   }
-  return (0, import_neverthrow20.ok)(
+  return (0, import_neverthrow21.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_neverthrow20.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid timeout: ${value}` });
+    return (0, import_neverthrow21.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid timeout: ${value}` });
   }
-  return (0, import_neverthrow20.ok)(parsed);
+  return (0, import_neverthrow21.ok)(parsed);
 }
 function parseFrontmatterLine(line) {
   const colonIndex = line.indexOf(":");
   if (colonIndex === -1) {
-    return (0, import_neverthrow20.err)({ type: "MALFORMED_FRONTMATTER", cause: `Invalid line: ${line}` });
+    return (0, import_neverthrow21.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_neverthrow20.ok)({ description: value });
+      return (0, import_neverthrow21.ok)({ description: value });
     }
     case "tags": {
       return parseTagsValue(value).map((tags) => ({ tags }));
@@ -63088,7 +63134,7 @@ function parseFrontmatterLine(line) {
       return parseTimeoutValue(value).map((timeout) => ({ timeout }));
     }
     default: {
-      return (0, import_neverthrow20.ok)({});
+      return (0, import_neverthrow21.ok)({});
     }
   }
 }
@@ -63107,18 +63153,18 @@ function mergePartials(partials) {
 }
 function combineFrontmatterLines(lines) {
   const lineResults = lines.filter((line) => line.trim().length > 0).map((line) => parseFrontmatterLine(line));
-  return import_neverthrow20.Result.combine(lineResults).map((partials) => mergePartials(partials)).map((merged) => normalizeFrontmatter(merged));
+  return import_neverthrow21.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_neverthrow20.ok)({ frontmatter: emptyFrontmatter(), body: content });
+    return (0, import_neverthrow21.ok)({ frontmatter: emptyFrontmatter(), body: content });
   }
   const afterOpenFence = trimmed.slice(FRONTMATTER_FENCE.length);
   const closeIndex = afterOpenFence.indexOf(`
 ${FRONTMATTER_FENCE}`);
   if (closeIndex === -1) {
-    return (0, import_neverthrow20.err)({ type: "MALFORMED_FRONTMATTER", cause: "Unclosed frontmatter fence" });
+    return (0, import_neverthrow21.err)({ type: "MALFORMED_FRONTMATTER", cause: "Unclosed frontmatter fence" });
   }
   const rawFrontmatter = afterOpenFence.slice(0, closeIndex);
   const body = afterOpenFence.slice(closeIndex + FRONTMATTER_FENCE.length + 1);
@@ -63160,13 +63206,13 @@ function parseTestSpec(name, content) {
     const sections = splitIntoSections(body);
     const setup = sections.Setup;
     if (setup === void 0) {
-      return (0, import_neverthrow20.err)({ type: "MISSING_SETUP_SECTION" });
+      return (0, import_neverthrow21.err)({ type: "MISSING_SETUP_SECTION" });
     }
     const stepsSection = sections.Steps;
     if (stepsSection === void 0) {
-      return (0, import_neverthrow20.err)({ type: "MISSING_STEPS_SECTION" });
+      return (0, import_neverthrow21.err)({ type: "MISSING_STEPS_SECTION" });
     }
-    return (0, import_neverthrow20.ok)({
+    return (0, import_neverthrow21.ok)({
       name,
       frontmatter,
       setup,
@@ -63215,25 +63261,25 @@ function direntToSpecEntry(directory, entry) {
   return [];
 }
 function scanDirectory(directory) {
-  const safeReaddir3 = (0, import_neverthrow21.fromAsyncThrowable)(
+  const safeReaddir3 = (0, import_neverthrow22.fromAsyncThrowable)(
     async () => (0, import_promises11.readdir)(directory, { withFileTypes: true }),
     (cause) => ({ type: "DIR_READ_FAILED", dir: directory, cause })
   );
-  return safeReaddir3().orElse((error48) => isNotFound(error48.cause) ? (0, import_neverthrow21.okAsync)([]) : (0, import_neverthrow21.errAsync)(error48)).map(
+  return safeReaddir3().orElse((error48) => isNotFound(error48.cause) ? (0, import_neverthrow22.okAsync)([]) : (0, import_neverthrow22.errAsync)(error48)).map(
     (entries) => entries.flatMap((entry) => direntToSpecEntry(directory, entry))
   );
 }
 function readEntries(entries) {
-  return import_neverthrow21.ResultAsync.combine(entries.map((entry) => readEntry(entry))).map(
+  return import_neverthrow22.ResultAsync.combine(entries.map((entry) => readEntry(entry))).map(
     (results) => results.flat()
   );
 }
 function readEntry(entry) {
-  const safeReadFile6 = (0, import_neverthrow21.fromAsyncThrowable)(
+  const safeReadFile6 = (0, import_neverthrow22.fromAsyncThrowable)(
     async () => (0, import_promises11.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_neverthrow21.errAsync)(error48) : (0, import_neverthrow21.okAsync)([]));
+  return safeReadFile6().map((content) => [{ name: entry.name, content }]).orElse((error48) => entry.required ? (0, import_neverthrow22.errAsync)(error48) : (0, import_neverthrow22.okAsync)([]));
 }
 function specNameFromPath(filePath) {
   const parts = filePath.split("/");
@@ -63249,8 +63295,6 @@ function filterByNames(specs, specNames) {
   }
   return specs.filter((spec) => specNames.includes(spec.name));
 }
-var SPEED_2X = 2;
-var SPEED_4X = 4;
 var ISO_DATE_LENGTH = 10;
 function buildPrompt(safeConfig, specs) {
   return generateExplorerPrompt({
@@ -63282,12 +63326,29 @@ function toArtifacts(result, runPaths) {
 function emitStageEnd3(safeConfig, start) {
   safeConfig.onEvent?.({ type: "STAGE_END", agent: "explorer", durationMs: Date.now() - start });
 }
+var EMPTY_RUN_PATHS = { videoPath: "", videoPath2x: "", videoPath4x: "" };
+function collectWithoutRecording({
+  safeConfig,
+  prompt,
+  start
+}) {
+  return collectAgentOutput(prompt, safeConfig).map((result) => {
+    emitStageEnd3(safeConfig, start);
+    return toArtifacts(result, EMPTY_RUN_PATHS);
+  }).mapErr((error48) => {
+    emitStageEnd3(safeConfig, start);
+    return error48;
+  });
+}
 function collectAndFinalize({
   safeConfig,
   prompt,
   runPaths,
   start
 }) {
+  if (safeConfig.record === false) {
+    return collectWithoutRecording({ safeConfig, prompt, start });
+  }
   return startAndRun({
     videoPath: runPaths.videoPath,
     videoPath2x: runPaths.videoPath2x,
@@ -63343,71 +63404,19 @@ function runExplorer(config3) {
     (0, import_promises10.mkdir)(runPaths.screenshotsDir, { recursive: true }).catch(() => null)
   ).andThen(() => runPipeline({ safeConfig, runPaths, start }));
 }
-function applySpeedUpVariants({
-  result,
-  params,
-  toRecordingError
-}) {
-  const { findings, snapshots } = result;
-  const { videoPath, videoPath2x, videoPath4x, signal } = params;
-  if (signal?.aborted) {
-    return (0, import_neverthrow19.okAsync)({ findings, snapshots });
-  }
-  return speedUpVideo({ inputPath: videoPath, factor: SPEED_2X, outputPath: videoPath2x }).mapErr(toRecordingError).andThen(
-    () => speedUpVideo({ inputPath: videoPath, factor: SPEED_4X, outputPath: videoPath4x }).mapErr(toRecordingError).map(() => ({ findings, snapshots }))
-  );
-}
-function applyPostProcessing({
-  result,
-  params,
-  toRecordingError
-}) {
-  return applySpeedUpVariants({ result, params, toRecordingError });
-}
-function startAndRun(params) {
-  const { videoPath, signal, collectOutput } = params;
-  const toRecordingError = (cause) => ({
-    type: "RECORDING_FAILED",
-    cause
-  });
-  return startRecording(videoPath).mapErr(toRecordingError).andThen((handle) => {
-    const onAbort = () => {
-      void stopRecording(handle).unwrapOr(null);
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-    return runWithRecording(handle, collectOutput).map((result) => {
-      signal?.removeEventListener("abort", onAbort);
-      return result;
-    }).mapErr((error48) => {
-      signal?.removeEventListener("abort", onAbort);
-      return error48;
-    }).andThen((result) => applyPostProcessing({ result, params, toRecordingError }));
-  });
-}
-function runWithRecording(handle, collectOutput) {
-  const toRecordingError = (cause) => ({
-    type: "RECORDING_FAILED",
-    cause
-  });
-  return collectOutput().andThen(
-    ({ findings, snapshots }) => stopRecording(handle).mapErr(toRecordingError).map(() => ({ findings, snapshots }))
-  ).orElse(
-    (error48) => stopRecording(handle).mapErr(toRecordingError).andThen(() => (0, import_neverthrow19.errAsync)(error48)).orElse(() => (0, import_neverthrow19.errAsync)(error48))
-  );
-}
 
 // ../../packages/pipeline/dist/index.js
-var import_neverthrow33 = __toESM(require_index_cjs(), 1);
+var import_neverthrow34 = __toESM(require_index_cjs(), 1);
 
 // ../../agents/inspector/dist/index.js
-var import_neverthrow22 = __toESM(require_index_cjs(), 1);
-var import_promises12 = require("node:fs/promises");
 var import_neverthrow23 = __toESM(require_index_cjs(), 1);
+var import_promises12 = require("node:fs/promises");
 var import_neverthrow24 = __toESM(require_index_cjs(), 1);
 var import_neverthrow25 = __toESM(require_index_cjs(), 1);
 var import_neverthrow26 = __toESM(require_index_cjs(), 1);
-var import_sharp2 = __toESM(require("sharp"), 1);
 var import_neverthrow27 = __toESM(require_index_cjs(), 1);
+var import_sharp2 = __toESM(require("sharp"), 1);
+var import_neverthrow28 = __toESM(require_index_cjs(), 1);
 var import_promises13 = require("node:fs/promises");
 var import_node_path7 = __toESM(require("node:path"), 1);
 
@@ -66036,7 +66045,7 @@ var jsYaml = {
 };
 
 // ../../agents/inspector/dist/index.js
-var import_neverthrow28 = __toESM(require_index_cjs(), 1);
+var import_neverthrow29 = __toESM(require_index_cjs(), 1);
 var MS_PER_DAY = 864e5;
 function checkStaleness({ lastUpdated, thresholdDays, now }) {
   if (!lastUpdated) {
@@ -66113,7 +66122,7 @@ function mapRawFinding(item) {
 function parseJson(raw) {
   return JSON.parse(raw);
 }
-var safeJsonParse3 = (0, import_neverthrow25.fromThrowable)(parseJson);
+var safeJsonParse3 = (0, import_neverthrow26.fromThrowable)(parseJson);
 function parseClaudeResponse(raw) {
   const parseResult = safeJsonParse3(raw);
   if (parseResult.isErr()) {
@@ -66140,7 +66149,7 @@ async function downscaleBuffer(buffer) {
   return (0, import_sharp2.default)(buffer).resize({ width: targetWidth }).toBuffer();
 }
 function downscale(buffer) {
-  return (0, import_neverthrow26.fromAsyncThrowable)(
+  return (0, import_neverthrow27.fromAsyncThrowable)(
     downscaleBuffer,
     (cause) => ({ type: "CLAUDE_API_FAILED", cause })
   )(buffer);
@@ -66215,7 +66224,7 @@ async function fetchClaudeText({
   return block?.type === "text" ? block.text : "";
 }
 function callClaude(options) {
-  return (0, import_neverthrow24.fromAsyncThrowable)(
+  return (0, import_neverthrow25.fromAsyncThrowable)(
     fetchClaudeText,
     (cause) => ({ type: "CLAUDE_API_FAILED", cause })
   )(options);
@@ -66227,9 +66236,9 @@ function toFindings(text) {
   const cleaned = stripCodeFences(text);
   const findings = parseClaudeResponse(cleaned);
   if (!findings) {
-    return (0, import_neverthrow24.errAsync)({ type: "CLAUDE_RESPONSE_INVALID", raw: cleaned });
+    return (0, import_neverthrow25.errAsync)({ type: "CLAUDE_RESPONSE_INVALID", raw: cleaned });
   }
-  return (0, import_neverthrow24.okAsync)(findings);
+  return (0, import_neverthrow25.okAsync)(findings);
 }
 function buildResolveMessages(screenshotBase64, artboardNames) {
   return [
@@ -66266,12 +66275,12 @@ async function fetchResolveName({
 }
 function resolveArtboard(screenshot, artboardNames) {
   if (artboardNames.length === 0) {
-    return (0, import_neverthrow24.okAsync)(void 0);
+    return (0, import_neverthrow25.okAsync)(void 0);
   }
   const anthropic = new Anthropic();
   return downscale(screenshot).andThen((scaled) => {
     const screenshotBase64 = scaled.toString("base64");
-    return (0, import_neverthrow24.fromAsyncThrowable)(
+    return (0, import_neverthrow25.fromAsyncThrowable)(
       fetchResolveName,
       (cause) => ({ type: "CLAUDE_API_FAILED", cause })
     )({ anthropic, screenshotBase64, artboardNames }).map((name) => {
@@ -66334,7 +66343,7 @@ var SEVERITY_CONFIDENCE = {
   medium: CONFIDENCE_MEDIUM2,
   low: CONFIDENCE_LOW2
 };
-var safeJsonParse22 = (0, import_neverthrow27.fromThrowable)(JSON.parse);
+var safeJsonParse22 = (0, import_neverthrow28.fromThrowable)(JSON.parse);
 function buildFindCandidatesMessages(screenshotBase64, artboardNames) {
   return [
     {
@@ -66381,12 +66390,12 @@ async function fetchCandidateNames({
 }
 function findCandidates(screenshot, artboardNames) {
   if (artboardNames.length === 0) {
-    return (0, import_neverthrow27.okAsync)([]);
+    return (0, import_neverthrow28.okAsync)([]);
   }
   const anthropic = new Anthropic();
   return downscale(screenshot).andThen((scaled) => {
     const screenshotBase64 = scaled.toString("base64");
-    return (0, import_neverthrow27.fromAsyncThrowable)(
+    return (0, import_neverthrow28.fromAsyncThrowable)(
       fetchCandidateNames,
       (cause) => ({ type: "CLAUDE_API_FAILED", cause })
     )({ anthropic, screenshotBase64, artboardNames });
@@ -66473,14 +66482,14 @@ async function fetchDesignContextText({
 function toDesignContextFindings(text) {
   const findings = parseConservativeResponse(text);
   if (!findings) {
-    return (0, import_neverthrow27.errAsync)({ type: "CLAUDE_RESPONSE_INVALID", raw: text });
+    return (0, import_neverthrow28.errAsync)({ type: "CLAUDE_RESPONSE_INVALID", raw: text });
   }
-  return (0, import_neverthrow27.okAsync)(findings);
+  return (0, import_neverthrow28.okAsync)(findings);
 }
 async function downscaleAll(buffers) {
   return Promise.all(buffers.map(async (buf) => downscaleBuffer(buf)));
 }
-var downscaleAllBuffers = (0, import_neverthrow27.fromAsyncThrowable)(
+var downscaleAllBuffers = (0, import_neverthrow28.fromAsyncThrowable)(
   downscaleAll,
   (cause) => ({ type: "CLAUDE_API_FAILED", cause })
 );
@@ -66490,7 +66499,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_neverthrow27.fromAsyncThrowable)(
+      return (0, import_neverthrow28.fromAsyncThrowable)(
         fetchDesignContextText,
         (cause) => ({ type: "CLAUDE_API_FAILED", cause })
       )({ anthropic, screenshotBase64, artboardBase64s }).andThen(toDesignContextFindings);
@@ -66723,7 +66732,7 @@ async function initArtboardNames({ designStore, config: config3, state }) {
   return state.artboardNamesPromise;
 }
 function readScreenshot(screenshotPath, stepIndex) {
-  return import_neverthrow23.ResultAsync.fromThrowable(
+  return import_neverthrow24.ResultAsync.fromThrowable(
     import_promises12.readFile,
     (cause) => ({ type: "SCREENSHOT_READ_FAILED", stepIndex, cause })
   )(screenshotPath);
@@ -66799,7 +66808,7 @@ function buildInspector(state, context) {
       const { promise: promise2, resolve } = Promise.withResolvers();
       state.resolve = resolve;
       applyTryResolve(state);
-      return (0, import_neverthrow22.fromSafePromise)(promise2);
+      return (0, import_neverthrow23.fromSafePromise)(promise2);
     }
   };
 }
@@ -66823,10 +66832,10 @@ async function readAndParseSidecar(sidecarPath) {
   return parseMeta(raw);
 }
 function readSidecarFile(sidecarPath) {
-  return (0, import_neverthrow28.fromAsyncThrowable)(
+  return (0, import_neverthrow29.fromAsyncThrowable)(
     readAndParseSidecar,
     () => ({})
-  )(sidecarPath).orElse(() => (0, import_neverthrow28.okAsync)({}));
+  )(sidecarPath).orElse(() => (0, import_neverthrow29.okAsync)({}));
 }
 function isEnoent(error48) {
   return error48?.code === "ENOENT";
@@ -66835,13 +66844,13 @@ function wrapFsError(cause) {
   return { type: "FS_ERROR", cause };
 }
 function toFsError(fsError) {
-  return (0, import_neverthrow28.errAsync)(fsError);
+  return (0, import_neverthrow29.errAsync)(fsError);
 }
 function missingBuffer() {
-  return (0, import_neverthrow28.okAsync)(void 0);
+  return (0, import_neverthrow29.okAsync)(void 0);
 }
 function missingArtboard() {
-  return (0, import_neverthrow28.okAsync)(void 0);
+  return (0, import_neverthrow29.okAsync)(void 0);
 }
 var FsDesignStore = class {
   designsDirectory;
@@ -66849,12 +66858,12 @@ var FsDesignStore = class {
     this.designsDirectory = designsDirectory;
   }
   listArtboards() {
-    return (0, import_neverthrow28.fromAsyncThrowable)(
+    return (0, import_neverthrow29.fromAsyncThrowable)(
       import_promises13.readdir,
       wrapFsError
     )(this.designsDirectory).orElse((fsError) => {
       if (fsError.type === "FS_ERROR" && isEnoent(fsError.cause)) {
-        return (0, import_neverthrow28.okAsync)([]);
+        return (0, import_neverthrow29.okAsync)([]);
       }
       return toFsError(fsError);
     }).map(
@@ -66864,7 +66873,7 @@ var FsDesignStore = class {
   getArtboard(filename) {
     const pngPath = import_node_path7.default.join(this.designsDirectory, `${filename}.png`);
     const sidecarPath = import_node_path7.default.join(this.designsDirectory, `${filename}.meta.yaml`);
-    return (0, import_neverthrow28.fromAsyncThrowable)(
+    return (0, import_neverthrow29.fromAsyncThrowable)(
       import_promises13.readFile,
       wrapFsError
     )(pngPath).orElse((fsError) => {
@@ -66890,10 +66899,10 @@ function attemptRetry(options) {
   const { factory, config: config3, delayFunction, onRetry, attempt } = options;
   return factory().orElse((error48) => {
     if (attempt >= config3.maxAttempts) {
-      return (0, import_neverthrow31.errAsync)(error48);
+      return (0, import_neverthrow32.errAsync)(error48);
     }
     const delay = config3.baseDelayMs * Math.pow(2, attempt - 1);
-    return import_neverthrow31.ResultAsync.fromPromise(
+    return import_neverthrow32.ResultAsync.fromPromise(
       (onRetry?.({ attempt, maxAttempts: config3.maxAttempts, delayMs: delay, error: error48 }), delayFunction(delay)),
       () => error48
     ).andThen(
@@ -66913,7 +66922,7 @@ function withRetry(factory, options) {
 var CONSOLIDATOR_AGENT = "consolidator";
 function analyserFallback(artifacts, onEvent) {
   onEvent?.({ type: "AGENT_FAILED_NON_CRITICAL", agent: "analyser", attempts: RETRY_MAX_ATTEMPTS });
-  return (0, import_neverthrow30.okAsync)(artifacts.findings);
+  return (0, import_neverthrow31.okAsync)(artifacts.findings);
 }
 function runAnalyserWithRetry(params) {
   const { artifacts, config: config3, onEvent } = params;
@@ -66943,7 +66952,7 @@ function resolveVisualFindings({
   onEvent
 }) {
   if (config3.analyser === void 0 || config3.signal?.aborted) {
-    return (0, import_neverthrow30.okAsync)(artifacts.findings);
+    return (0, import_neverthrow31.okAsync)(artifacts.findings);
   }
   return runAnalyserWithRetry({ artifacts, config: config3, onEvent });
 }
@@ -66953,7 +66962,7 @@ function unmergedFallback(allFindings, onEvent) {
     agent: CONSOLIDATOR_AGENT,
     message: "Consolidation failed, returning unmerged findings"
   });
-  return (0, import_neverthrow30.okAsync)({ findings: allFindings, dismissed: [] });
+  return (0, import_neverthrow31.okAsync)({ findings: allFindings, dismissed: [] });
 }
 function mergeWithFallback(options) {
   const {
@@ -66980,7 +66989,7 @@ function consolidate(options) {
   const { artifacts, inspectorFindings, runId, dismissals, config: config3, consolidatorConfig, onEvent } = options;
   return resolveVisualFindings({ artifacts, config: config3, onEvent }).andThen((visualFindings) => {
     if (config3.signal?.aborted) {
-      return (0, import_neverthrow30.okAsync)({ findings: artifacts.findings, dismissed: [] });
+      return (0, import_neverthrow31.okAsync)({ findings: artifacts.findings, dismissed: [] });
     }
     return mergeWithFallback({
       artifacts,
@@ -66993,8 +67002,8 @@ function consolidate(options) {
     });
   });
 }
-var safeReadFile = (0, import_neverthrow32.fromThrowable)((filePath) => (0, import_node_fs3.readFileSync)(filePath, "utf8"));
-var safeParseJson2 = (0, import_neverthrow32.fromThrowable)(JSON.parse);
+var safeReadFile = (0, import_neverthrow33.fromThrowable)((filePath) => (0, import_node_fs3.readFileSync)(filePath, "utf8"));
+var safeParseJson2 = (0, import_neverthrow33.fromThrowable)(JSON.parse);
 function isEnoent2(error48) {
   if (!(error48 instanceof Error)) {
     return false;
@@ -67006,19 +67015,19 @@ function loadDismissals(filePath) {
   const readResult = safeReadFile(filePath);
   if (readResult.isErr()) {
     if (isEnoent2(readResult.error)) {
-      return (0, import_neverthrow32.ok)([]);
+      return (0, import_neverthrow33.ok)([]);
     }
-    return (0, import_neverthrow32.err)({ type: "DISMISSALS_LOAD_FAILED", cause: readResult.error });
+    return (0, import_neverthrow33.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_neverthrow32.err)({
+      return (0, import_neverthrow33.err)({
         type: "DISMISSALS_LOAD_FAILED",
         cause: "invalid shape: dismissed is not an array"
       });
     }
-    return (0, import_neverthrow32.ok)(store.dismissed);
+    return (0, import_neverthrow33.ok)(store.dismissed);
   });
 }
 function toInspectorStepEvent(event) {
@@ -67105,7 +67114,7 @@ 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_neverthrow33.errAsync)(error48)).orElse(() => (0, import_neverthrow33.errAsync)(error48))
+    (error48) => disableTouchIndicators(udid).mapErr(toSimulatorError).andThen(() => (0, import_neverthrow34.errAsync)(error48)).orElse(() => (0, import_neverthrow34.errAsync)(error48))
   );
 }
 function runExplorerWithRetry(options) {
@@ -67131,12 +67140,12 @@ async function drainAfterExplorer(options) {
   inspector?.close();
   const inspectorFindings = inspector ? await collectInspectorFindings({ inspector, onEvent, totalSteps: enqueuedCount.value }) : [];
   if (explorerResult.isErr()) {
-    return (0, import_neverthrow33.err)(explorerResult.error);
+    return (0, import_neverthrow34.err)(explorerResult.error);
   }
-  return (0, import_neverthrow33.ok)({ artifacts: explorerResult.value, inspectorFindings });
+  return (0, import_neverthrow34.ok)({ artifacts: explorerResult.value, inspectorFindings });
 }
 function runExplorerAndDrain(options) {
-  return new import_neverthrow33.ResultAsync(drainAfterExplorer(options));
+  return new import_neverthrow34.ResultAsync(drainAfterExplorer(options));
 }
 function createDefaultMcpServers(udid) {
   return {
@@ -67148,7 +67157,7 @@ function runAnalysis(artifacts, config3) {
 }
 var ISO_DATE_LENGTH2 = 10;
 var RUN_ID_PAD_LENGTH = 4;
-var safeReaddirSync = (0, import_neverthrow29.fromThrowable)((directory) => (0, import_node_fs2.readdirSync)(directory));
+var safeReaddirSync = (0, import_neverthrow30.fromThrowable)((directory) => (0, import_node_fs2.readdirSync)(directory));
 function nextRunId(outputDirectory, date5) {
   const entries = safeReaddirSync(`${outputDirectory}/${date5}`).unwrapOr([]);
   let max = 0;
@@ -67160,7 +67169,7 @@ function nextRunId(outputDirectory, date5) {
   }
   return String(max + 1).padStart(RUN_ID_PAD_LENGTH, "0");
 }
-var writeOutputFile = (0, import_neverthrow29.fromThrowable)(
+var writeOutputFile = (0, import_neverthrow30.fromThrowable)(
   (params) => {
     const { findingsPath, outputDirectory, json: json3 } = params;
     (0, import_node_fs2.mkdirSync)(outputDirectory, { recursive: true });
@@ -67173,15 +67182,15 @@ function validatePipelineConfig(config3) {
   const runId = config3.runId ?? nextRunId(config3.outputDir, date5);
   const runPathsResult = resolveRunPaths({ outputDirectory: config3.outputDir, runId, date: date5 });
   if (runPathsResult.isErr()) {
-    return (0, import_neverthrow29.err)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
+    return (0, import_neverthrow30.err)({ type: "RUN_PATHS_FAILED", cause: runPathsResult.error });
   }
   const dismissalsResult = loadDismissals(
     dismissalsPath(config3.outputDir, process.env.QA_DISMISSALS_PATH)
   );
   if (dismissalsResult.isErr()) {
-    return (0, import_neverthrow29.err)(dismissalsResult.error);
+    return (0, import_neverthrow30.err)(dismissalsResult.error);
   }
-  return (0, import_neverthrow29.ok)({ runId, date: date5, runPaths: runPathsResult.value, dismissals: dismissalsResult.value });
+  return (0, import_neverthrow30.ok)({ runId, date: date5, runPaths: runPathsResult.value, dismissals: dismissalsResult.value });
 }
 function buildExplorerConfig({
   config: config3,
@@ -67196,7 +67205,8 @@ function buildExplorerConfig({
     date: date5,
     onEvent,
     signal: config3.signal,
-    udid: config3.simulatorUdid ?? "booted"
+    udid: config3.simulatorUdid ?? "booted",
+    record: config3.explorer.record ?? config3.analyser !== void 0
   };
 }
 function buildOutput(consolidationResult, options) {
@@ -67217,11 +67227,11 @@ function buildOutput(consolidationResult, options) {
 function buildPipelineSetup(config3) {
   const validatedResult = validatePipelineConfig(config3);
   if (validatedResult.isErr()) {
-    return (0, import_neverthrow29.err)(validatedResult.error);
+    return (0, import_neverthrow30.err)(validatedResult.error);
   }
   const { runId, date: date5, runPaths, dismissals } = validatedResult.value;
   const { inspector, explorerOnEvent, enqueuedCount } = buildInspectorSetup(config3);
-  return (0, import_neverthrow29.ok)({
+  return (0, import_neverthrow30.ok)({
     runId,
     udid: config3.simulatorUdid ?? "booted",
     runPaths,
@@ -67265,19 +67275,19 @@ function executePipeline(setup, config3) {
 function runPipeline2(config3) {
   const setupResult = buildPipelineSetup(config3);
   if (setupResult.isErr()) {
-    return (0, import_neverthrow29.errAsync)(setupResult.error);
+    return (0, import_neverthrow30.errAsync)(setupResult.error);
   }
   return executePipeline(setupResult.value, config3);
 }
 
 // src/commands/analyse-command.ts
-var import_neverthrow34 = __toESM(require_index_cjs(), 1);
+var import_neverthrow35 = __toESM(require_index_cjs(), 1);
 
 // src/commands/item-events.ts
 function emitItemStart(identity, at) {
-  const { display, itemId, itemName } = identity;
+  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 });
+  display.onEvent({ type: "ITEM_STARTED", itemId, itemName, simulatorUdid, at });
 }
 function emitItemCompleted(input) {
   const { identity, startedAt, findingsCount } = input;
@@ -67346,7 +67356,7 @@ function buildArtifacts(videoPath) {
   return { videoPath, videoPath2x: "", videoPath4x: videoPath, findings: [], snapshots: [] };
 }
 async function checkVideoPathExists(videoPath) {
-  const safeAccess = (0, import_neverthrow34.fromAsyncThrowable)(import_promises16.access, () => ({ type: "FILE_NOT_FOUND" }));
+  const safeAccess = (0, import_neverthrow35.fromAsyncThrowable)(import_promises16.access, () => ({ type: "FILE_NOT_FOUND" }));
   const result = await safeAccess(videoPath);
   return result.isOk();
 }
@@ -67371,7 +67381,8 @@ async function runAnalysisAndExit(artifacts, apiKey) {
   const identity = {
     display: createSoloDisplay(),
     itemId: ITEM_ID,
-    itemName: ITEM_NAME
+    itemName: ITEM_NAME,
+    simulatorUdid: ""
   };
   const startedAt = Date.now();
   emitItemStart(identity, startedAt);
@@ -67411,7 +67422,7 @@ async function runAnalyseCommand(videoPath, config3) {
 }
 
 // src/core/completion-generator.ts
-var import_neverthrow35 = __toESM(require_index_cjs(), 1);
+var import_neverthrow36 = __toESM(require_index_cjs(), 1);
 function extractLongFlags(flags) {
   return flags.split(/[\s,]+/).filter((token) => token.startsWith("--"));
 }
@@ -67501,9 +67512,9 @@ complete -F _xqa_completion xqa`;
 }
 function generateCompletion(commands, shell) {
   if (shell !== "bash" && shell !== "zsh") {
-    return (0, import_neverthrow35.err)({ type: "UNSUPPORTED_SHELL", shell });
+    return (0, import_neverthrow36.err)({ type: "UNSUPPORTED_SHELL", shell });
   }
-  return (0, import_neverthrow35.ok)(shell === "zsh" ? generateZshCompletion(commands) : generateBashCompletion(commands));
+  return (0, import_neverthrow36.ok)(shell === "zsh" ? generateZshCompletion(commands) : generateBashCompletion(commands));
 }
 
 // src/commands/completion-command.ts
@@ -67561,16 +67572,16 @@ var FFMPEG_INSTALL_MESSAGE = "ffmpeg is not installed. Run:\n  brew install ffmp
 // src/core/last-path.ts
 var import_node_fs4 = require("node:fs");
 var import_node_path8 = __toESM(require("node:path"), 1);
-var import_neverthrow36 = __toESM(require_index_cjs(), 1);
+var import_neverthrow37 = __toESM(require_index_cjs(), 1);
 function resolveLastPath(argument, stateContent) {
   if (argument !== void 0) {
-    return (0, import_neverthrow36.ok)(argument);
+    return (0, import_neverthrow37.ok)(argument);
   }
   const trimmed = stateContent?.trim();
   if (trimmed) {
-    return (0, import_neverthrow36.ok)(trimmed);
+    return (0, import_neverthrow37.ok)(trimmed);
   }
-  return (0, import_neverthrow36.err)({ type: "NO_ARG_AND_NO_STATE" });
+  return (0, import_neverthrow37.err)({ type: "NO_ARG_AND_NO_STATE" });
 }
 function lastPathFilePath(xqaDirectoryectory) {
   return import_node_path8.default.join(xqaDirectoryectory, "last-findings-path");
@@ -67582,7 +67593,7 @@ function writeLastPath(xqaDirectory, findingsPath) {
 // src/shell/app-context.ts
 var import_promises17 = require("node:fs/promises");
 var import_node_path9 = __toESM(require("node:path"), 1);
-var import_neverthrow37 = __toESM(require_index_cjs(), 1);
+var import_neverthrow38 = __toESM(require_index_cjs(), 1);
 var HTML_COMMENT_PATTERN = /<!--[\s\S]*?-->/g;
 function isEnoentError(value) {
   return value !== null && typeof value === "object" && "code" in value && value.code === "ENOENT";
@@ -67592,9 +67603,9 @@ function toAppContextError(cause) {
 }
 function absentContext() {
   const absent = void 0;
-  return (0, import_neverthrow37.ok)(absent);
+  return (0, import_neverthrow38.ok)(absent);
 }
-var safeReadFile2 = import_neverthrow37.ResultAsync.fromThrowable(
+var safeReadFile2 = import_neverthrow38.ResultAsync.fromThrowable(
   async (filePath) => (0, import_promises17.readFile)(filePath, "utf8"),
   toAppContextError
 );
@@ -67608,7 +67619,7 @@ function readContextFile(xqaDirectory, filename) {
     if (isEnoentError(error48.cause)) {
       return absentContext();
     }
-    return (0, import_neverthrow37.err)(error48);
+    return (0, import_neverthrow38.err)(error48);
   });
 }
 function readAppContext(xqaDirectory) {
@@ -67620,7 +67631,7 @@ function readExploreContext(xqaDirectory) {
 
 // src/shell/ffmpeg-check.ts
 var import_node_child_process5 = require("node:child_process");
-var import_neverthrow38 = __toESM(require_index_cjs(), 1);
+var import_neverthrow39 = __toESM(require_index_cjs(), 1);
 async function whichFfmpeg() {
   const { promise: promise2, resolve, reject } = Promise.withResolvers();
   (0, import_node_child_process5.execFile)("which", ["ffmpeg"], (error48, stdout) => {
@@ -67632,7 +67643,7 @@ async function whichFfmpeg() {
   });
   return promise2;
 }
-var safeWhichFfmpeg = (0, import_neverthrow38.fromAsyncThrowable)(
+var safeWhichFfmpeg = (0, import_neverthrow39.fromAsyncThrowable)(
   whichFfmpeg,
   () => ({ type: "FFMPEG_NOT_FOUND" })
 );
@@ -67680,11 +67691,13 @@ function buildPipelineConfig({
   config: config3,
   xqaDirectory,
   explorer,
-  onEvent
+  onEvent,
+  simulatorUdid
 }) {
   const base = {
     outputDir: import_node_path10.default.join(xqaDirectory, "output"),
     runId: config3.QA_RUN_ID,
+    simulatorUdid,
     onEvent,
     signal: input.signal,
     inspector: { designsDirectory: import_node_path10.default.join(xqaDirectory, "designs") },
@@ -67705,7 +67718,9 @@ function buildSuccessMessage(output) {
 `;
 }
 var ITEM_ID2 = "explore";
-var ITEM_NAME2 = "explore";
+function buildItemName(simulatorUdid) {
+  return `${simulatorUdid} - explorer`;
+}
 function buildSuccessHandler({ input, xqaDirectory, identity, startedAt }) {
   return (output) => {
     emitItemCompleted({ identity, startedAt, findingsCount: output.findings.length });
@@ -67740,7 +67755,7 @@ ${cause}
   };
 }
 function runExplorePipeline(state, contexts) {
-  const { input, config: config3, xqaDirectory, onEvent, onSuccess, onError } = state;
+  const { input, config: config3, xqaDirectory, onEvent, onSuccess, onError, simulatorUdid } = state;
   const explorerConfig = buildExplorerConfig2({
     input,
     config: config3,
@@ -67748,14 +67763,22 @@ function runExplorePipeline(state, contexts) {
     initialState: contexts.exploreContext
   });
   void runPipeline2(
-    buildPipelineConfig({ input, config: config3, xqaDirectory, explorer: explorerConfig, onEvent })
+    buildPipelineConfig({
+      input,
+      config: config3,
+      xqaDirectory,
+      explorer: explorerConfig,
+      onEvent,
+      simulatorUdid
+    })
   ).match(onSuccess, onError);
 }
 function buildExploreRunState({
   input,
   options,
   identity,
-  startedAt
+  startedAt,
+  simulatorUdid
 }) {
   const { config: config3, xqaDirectory } = options;
   const onEvent = (event) => {
@@ -67763,17 +67786,32 @@ function buildExploreRunState({
   };
   const onSuccess = buildSuccessHandler({ input, xqaDirectory, identity, startedAt });
   const onError = buildErrorHandler(identity, startedAt);
-  return { input, config: config3, xqaDirectory, onEvent, onSuccess, onError };
+  return { input, config: config3, xqaDirectory, onEvent, onSuccess, onError, simulatorUdid };
 }
-function runPipelineAfterPreflight({ input, options }) {
+async function resolveSimulatorUdid() {
+  const result = await discoverBootedSimulators();
+  if (result.isErr()) {
+    process.stderr.write(`Failed to discover simulators: ${String(result.error.cause)}
+`);
+    return;
+  }
+  const first = result.value[0];
+  if (!first) {
+    process.stderr.write("No booted simulators found\n");
+    return;
+  }
+  return first.udid;
+}
+function runPipelineAfterPreflight({ input, options }, simulatorUdid) {
   const identity = {
     display: createSoloDisplay(input.verbose),
     itemId: ITEM_ID2,
-    itemName: ITEM_NAME2
+    itemName: buildItemName(simulatorUdid),
+    simulatorUdid
   };
   const startedAt = Date.now();
   emitItemStart(identity, startedAt);
-  const state = buildExploreRunState({ input, options, identity, startedAt });
+  const state = buildExploreRunState({ input, options, identity, startedAt, simulatorUdid });
   void readAppContext(options.xqaDirectory).andThen(
     (appContext) => readExploreContext(options.xqaDirectory).map((exploreContext) => ({
       appContext,
@@ -67789,7 +67827,12 @@ async function runExploreAfterPreflight(context) {
     process.exit(preflightExit);
     return;
   }
-  runPipelineAfterPreflight(context);
+  const simulatorUdid = await resolveSimulatorUdid();
+  if (simulatorUdid === void 0) {
+    process.exit(2);
+    return;
+  }
+  runPipelineAfterPreflight(context, simulatorUdid);
 }
 function runExploreCommand(input, options) {
   void runExploreAfterPreflight({ input, options });
@@ -67889,7 +67932,7 @@ function runInitCommand() {
 // src/commands/review-command.ts
 var import_node_fs7 = require("node:fs");
 var import_node_path14 = __toESM(require("node:path"), 1);
-var import_neverthrow40 = __toESM(require_index_cjs(), 1);
+var import_neverthrow41 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/@inquirer+core@10.3.2_@types+node@22.19.15/node_modules/@inquirer/core/dist/esm/lib/key.js
 var isUpKey = (key, keybindings = []) => (
@@ -70294,7 +70337,7 @@ var esm_default11 = createPrompt((config3, done) => {
 });
 
 // src/review-session.ts
-var import_neverthrow39 = __toESM(require_index_cjs(), 1);
+var import_neverthrow40 = __toESM(require_index_cjs(), 1);
 var CONFIDENCE_PERCENT = 100;
 var FLOW_COL_WIDTH = 35;
 var TRIGGER_COL_WIDTH = 16;
@@ -70447,15 +70490,15 @@ async function runInteractiveLoop(findings, existing) {
   }
   return { staged: state.staged, undoneKeys: state.undoneKeys };
 }
-var safeRunInteractiveLoop = (0, import_neverthrow39.fromAsyncThrowable)(
+var safeRunInteractiveLoop = (0, import_neverthrow40.fromAsyncThrowable)(
   runInteractiveLoop,
   (error48) => error48 instanceof Error && error48.name === "ExitPromptError" ? "exit-prompt" : "unexpected"
 );
 
 // src/commands/review-command.ts
-var safeReadFile3 = (0, import_neverthrow40.fromThrowable)((filePath) => (0, import_node_fs7.readFileSync)(filePath, "utf8"));
-var safeParseJson3 = (0, import_neverthrow40.fromThrowable)(JSON.parse);
-var safeWrite = (0, import_neverthrow40.fromThrowable)((filePath, content) => {
+var safeReadFile3 = (0, import_neverthrow41.fromThrowable)((filePath) => (0, import_node_fs7.readFileSync)(filePath, "utf8"));
+var safeParseJson3 = (0, import_neverthrow41.fromThrowable)(JSON.parse);
+var safeWrite = (0, import_neverthrow41.fromThrowable)((filePath, content) => {
   (0, import_node_fs7.writeFileSync)(filePath, content);
 });
 function readLastPath(xqaDirectory) {
@@ -70472,13 +70515,13 @@ function isPipelineOutput(data) {
 function readFindings(filePath) {
   const readResult = safeReadFile3(filePath);
   if (readResult.isErr()) {
-    return (0, import_neverthrow40.err)("not-found");
+    return (0, import_neverthrow41.err)("not-found");
   }
   return safeParseJson3(readResult.value).mapErr(() => "invalid").andThen((data) => {
     if (!isPipelineOutput(data)) {
-      return (0, import_neverthrow40.err)("invalid");
+      return (0, import_neverthrow41.err)("invalid");
     }
-    return (0, import_neverthrow40.ok)(data);
+    return (0, import_neverthrow41.ok)(data);
   });
 }
 function loadExistingDismissals(filePath) {
@@ -70551,7 +70594,7 @@ function resolveAndReadFindings(findingsPath, xqaDirectory) {
       "No findings path provided and no last path found. Run: xqa review <findings-path>\n"
     );
     process.exit(1);
-    return (0, import_neverthrow40.err)();
+    return (0, import_neverthrow41.err)();
   }
   const resolvedPath = resolvedPathResult.value;
   const findingsResult = readFindings(resolvedPath);
@@ -70564,9 +70607,9 @@ function resolveAndReadFindings(findingsPath, xqaDirectory) {
 `);
     }
     process.exit(1);
-    return (0, import_neverthrow40.err)();
+    return (0, import_neverthrow41.err)();
   }
-  return (0, import_neverthrow40.ok)({ resolvedPath, output: findingsResult.value });
+  return (0, import_neverthrow41.ok)({ resolvedPath, output: findingsResult.value });
 }
 async function runReviewLoop({
   findings,
@@ -70640,40 +70683,40 @@ function stripExtensions(filename) {
 // src/commands/spec-resolver.ts
 var import_node_fs8 = require("node:fs");
 var import_node_path16 = __toESM(require("node:path"), 1);
-var import_neverthrow42 = __toESM(require_index_cjs(), 1);
+var import_neverthrow43 = __toESM(require_index_cjs(), 1);
 
 // src/spec-frontmatter.ts
-var import_neverthrow41 = __toESM(require_index_cjs(), 1);
+var import_neverthrow42 = __toESM(require_index_cjs(), 1);
 var FRONTMATTER_OPEN_LEN = 4;
 var FRONTMATTER_MARKER_LEN = 3;
 function extractFrontmatterBlock(content) {
   const normalized = content.replaceAll("\r\n", "\n");
   if (!normalized.startsWith("---")) {
-    return (0, import_neverthrow41.err)({ type: "MISSING_FRONTMATTER" });
+    return (0, import_neverthrow42.err)({ type: "MISSING_FRONTMATTER" });
   }
   const end = normalized.indexOf("\n---", FRONTMATTER_MARKER_LEN);
   if (end === -1) {
-    return (0, import_neverthrow41.err)({ type: "MISSING_FRONTMATTER" });
+    return (0, import_neverthrow42.err)({ type: "MISSING_FRONTMATTER" });
   }
-  return (0, import_neverthrow41.ok)(normalized.slice(FRONTMATTER_OPEN_LEN, end));
+  return (0, import_neverthrow42.ok)(normalized.slice(FRONTMATTER_OPEN_LEN, end));
 }
 function parseTimeout(fields) {
   const raw = fields.get("timeout");
   if (raw === void 0) {
-    return (0, import_neverthrow41.ok)(raw);
+    return (0, import_neverthrow42.ok)(raw);
   }
   const parsed = Number(raw);
   if (Number.isNaN(parsed) || parsed <= 0) {
-    return (0, import_neverthrow41.err)({ type: "PARSE_ERROR", cause: `invalid timeout: ${raw}` });
+    return (0, import_neverthrow42.err)({ type: "PARSE_ERROR", cause: `invalid timeout: ${raw}` });
   }
-  return (0, import_neverthrow41.ok)(parsed);
+  return (0, import_neverthrow42.ok)(parsed);
 }
 function parseSpecFrontmatter(content) {
   return extractFrontmatterBlock(content).andThen((block) => {
     const fields = parseYamlFields(block);
     const feature = fields.get("feature");
     if (feature === void 0) {
-      return (0, import_neverthrow41.err)({ type: "MISSING_FIELD", field: "feature" });
+      return (0, import_neverthrow42.err)({ type: "MISSING_FIELD", field: "feature" });
     }
     return parseTimeout(fields).map((timeout) => ({ feature, timeout }));
   });
@@ -70695,12 +70738,12 @@ function parseYamlFields(block) {
 }
 
 // src/commands/spec-resolver.ts
-var safeReadFile4 = (0, import_neverthrow42.fromThrowable)((filePath) => (0, import_node_fs8.readFileSync)(filePath, "utf8"));
-var safeReaddir = (0, import_neverthrow42.fromThrowable)(
+var safeReadFile4 = (0, import_neverthrow43.fromThrowable)((filePath) => (0, import_node_fs8.readFileSync)(filePath, "utf8"));
+var safeReaddir = (0, import_neverthrow43.fromThrowable)(
   (directory) => (0, import_node_fs8.readdirSync)(directory, { recursive: true, encoding: "utf8" })
 );
 var CANCEL = "xqa:cancel";
-var safeSelect = import_neverthrow42.ResultAsync.fromThrowable(
+var safeSelect = import_neverthrow43.ResultAsync.fromThrowable(
   esm_default11,
   (error48) => error48 instanceof Error && error48.name === "ExitPromptError" ? "cancelled" : "failed"
 );
@@ -70819,7 +70862,8 @@ async function executeSpec(input, context) {
   const identity = {
     display: createSoloDisplay(input.verbose),
     itemId: "spec",
-    itemName: import_node_path17.default.basename(context.absolutePath, ".test.md")
+    itemName: import_node_path17.default.basename(context.absolutePath, ".test.md"),
+    simulatorUdid: ""
   };
   const startedAt = Date.now();
   emitItemStart(identity, startedAt);
@@ -70887,7 +70931,7 @@ function runUpdateCommand() {
 var import_node_path18 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 var import_dotenv = __toESM(require_main(), 1);
-var import_neverthrow43 = __toESM(require_index_cjs(), 1);
+var import_neverthrow44 = __toESM(require_index_cjs(), 1);
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports2 = {};
@@ -74948,10 +74992,10 @@ function loadConfig() {
     const messages = result.error.issues.map(
       (issue2) => `  - ${issue2.path.join(".")}: ${issue2.message}`
     );
-    return (0, import_neverthrow43.err)({ type: "INVALID_CONFIG", message: `Configuration error:
+    return (0, import_neverthrow44.err)({ type: "INVALID_CONFIG", message: `Configuration error:
 ${messages.join("\n")}` });
   }
-  return (0, import_neverthrow43.ok)(result.data);
+  return (0, import_neverthrow44.ok)(result.data);
 }
 
 // src/core/parse-timeout-seconds.ts
@@ -74984,7 +75028,7 @@ function parseVerboseOption(value) {
 
 // src/pid-lock.ts
 var import_node_fs9 = require("node:fs");
-var import_neverthrow44 = __toESM(require_index_cjs(), 1);
+var import_neverthrow45 = __toESM(require_index_cjs(), 1);
 var PID_FILE = "/tmp/xqa.pid";
 var SIGINT_EXIT_CODE = 130;
 var SIGTERM_EXIT_CODE = 143;
@@ -74993,7 +75037,7 @@ var HARD_TIMEOUT_MS = 1e4;
 var cleanup = () => {
   (0, import_node_fs9.rmSync)(PID_FILE, { force: true });
 };
-var checkProcessRunning = (0, import_neverthrow44.fromThrowable)(
+var checkProcessRunning = (0, import_neverthrow45.fromThrowable)(
   (pid) => {
     process.kill(pid, 0);
     return true;
@@ -75059,17 +75103,17 @@ function acquireLock() {
 // src/shell/xqa-directory.ts
 var import_node_fs10 = require("node:fs");
 var import_node_path19 = __toESM(require("node:path"), 1);
-var import_neverthrow45 = __toESM(require_index_cjs(), 1);
+var import_neverthrow46 = __toESM(require_index_cjs(), 1);
 function findXqaDirectory(startDirectory) {
   let current = startDirectory;
   for (; ; ) {
     const candidate = import_node_path19.default.join(current, ".xqa");
     if ((0, import_node_fs10.existsSync)(candidate)) {
-      return (0, import_neverthrow45.ok)(candidate);
+      return (0, import_neverthrow46.ok)(candidate);
     }
     const parent = import_node_path19.default.dirname(current);
     if (parent === current) {
-      return (0, import_neverthrow45.err)({ type: "XQA_NOT_INITIALIZED" });
+      return (0, import_neverthrow46.err)({ type: "XQA_NOT_INITIALIZED" });
     }
     current = parent;
   }
@@ -75079,7 +75123,7 @@ function findXqaDirectory(startDirectory) {
 var import_promises19 = __toESM(require("node:fs/promises"), 1);
 var import_node_path22 = __toESM(require("node:path"), 1);
 var import_fast_glob = __toESM(require_out4(), 1);
-var import_neverthrow50 = __toESM(require_index_cjs(), 1);
+var import_neverthrow51 = __toESM(require_index_cjs(), 1);
 
 // src/suite/core/run-id.ts
 var RUN_ID_PAD_LENGTH2 = 4;
@@ -75102,8 +75146,8 @@ function computeNextRunId(existingDirectories) {
 }
 
 // src/suite/core/suite-config-parser.ts
-var import_neverthrow46 = __toESM(require_index_cjs(), 1);
 var import_neverthrow47 = __toESM(require_index_cjs(), 1);
+var import_neverthrow48 = __toESM(require_index_cjs(), 1);
 var freestyleEntrySchema = external_exports2.object({
   prompt: external_exports2.string().optional(),
   timeoutSeconds: external_exports2.number().int().positive()
@@ -75122,7 +75166,7 @@ var suiteConfigSchema = external_exports2.object({
   specs: external_exports2.array(external_exports2.string()).nonempty(),
   freestyle: freestyleSchema
 });
-var safeJsonParse4 = (0, import_neverthrow46.fromThrowable)(
+var safeJsonParse4 = (0, import_neverthrow47.fromThrowable)(
   JSON.parse,
   (cause) => ({
     type: "INVALID_SUITE_CONFIG",
@@ -75133,9 +75177,9 @@ function parseSuiteConfig(raw) {
   return safeJsonParse4(raw).andThen((data) => {
     const parsed = suiteConfigSchema.safeParse(data);
     if (!parsed.success) {
-      return (0, import_neverthrow47.err)({ type: "INVALID_SUITE_CONFIG", cause: parsed.error });
+      return (0, import_neverthrow48.err)({ type: "INVALID_SUITE_CONFIG", cause: parsed.error });
     }
-    return (0, import_neverthrow47.ok)({ specs: parsed.data.specs, freestyle: parsed.data.freestyle });
+    return (0, import_neverthrow48.ok)({ specs: parsed.data.specs, freestyle: parsed.data.freestyle });
   });
 }
 
@@ -75201,7 +75245,7 @@ function buildFreestyleItems(entries) {
 // src/suite/shell/suite-findings-writer.ts
 var import_promises18 = __toESM(require("node:fs/promises"), 1);
 var import_node_path20 = __toESM(require("node:path"), 1);
-var import_neverthrow48 = __toESM(require_index_cjs(), 1);
+var import_neverthrow49 = __toESM(require_index_cjs(), 1);
 var INDENT_SPACES = 2;
 function writeSuiteFindings(findings, options) {
   const directory = import_node_path20.default.join(
@@ -75213,7 +75257,7 @@ function writeSuiteFindings(findings, options) {
   );
   const finalPath = import_node_path20.default.join(directory, "findings.json");
   const temporaryPath = `${finalPath}.tmp`;
-  const safeWriteAtomically = import_neverthrow48.ResultAsync.fromThrowable(
+  const safeWriteAtomically = import_neverthrow49.ResultAsync.fromThrowable(
     async () => {
       await import_promises18.default.mkdir(directory, { recursive: true });
       await import_promises18.default.writeFile(temporaryPath, JSON.stringify(findings, void 0, INDENT_SPACES));
@@ -75226,7 +75270,7 @@ function writeSuiteFindings(findings, options) {
 }
 
 // src/suite/shell/worker-pool.ts
-var import_neverthrow49 = __toESM(require_index_cjs(), 1);
+var import_neverthrow50 = __toESM(require_index_cjs(), 1);
 
 // src/suite/shell/item-result-builder.ts
 function getErrorMessage(cause) {
@@ -75454,7 +75498,7 @@ function runWorkerPool(config3) {
   const queue = setupQueue(config3);
   const results = [];
   const suiteStartMs = Date.now();
-  const safeRun = import_neverthrow49.ResultAsync.fromThrowable(
+  const safeRun = import_neverthrow50.ResultAsync.fromThrowable(
     async () => runAllWorkers({ config: config3, queue, results, suiteStartMs }),
     (cause) => ({ type: "WORKER_POOL_FAILED", cause })
   );
@@ -75541,14 +75585,14 @@ function makeExecuteItem(context) {
 
 // src/suite/commands/run-command.ts
 var ISO_DATE_LENGTH3 = 10;
-var safeReaddir2 = import_neverthrow50.ResultAsync.fromThrowable(
+var safeReaddir2 = import_neverthrow51.ResultAsync.fromThrowable(
   async (directoryPath) => {
     const entries = await import_promises19.default.readdir(directoryPath, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   },
   () => "READDIR_FAILED"
 );
-var safeReadFile5 = import_neverthrow50.ResultAsync.fromThrowable(
+var safeReadFile5 = import_neverthrow51.ResultAsync.fromThrowable(
   async (filePath) => import_promises19.default.readFile(filePath, "utf8"),
   () => "READ_FAILED"
 );
@@ -75730,7 +75774,7 @@ function resolveXqaDirectory() {
   return result.value;
 }
 var program2 = new Command();
-program2.name("xqa").description("AI-powered QA agent CLI").version(`${"1.6.1"}${false ? ` (dev build +${"6b23ee9"})` : ""}`);
+program2.name("xqa").description("AI-powered QA agent CLI").version(`${"1.8.0"}${false ? ` (dev build +${"d16dbac"})` : ""}`);
 program2.command("init").description("Initialize a new xqa project in the current directory").action(() => {
   runInitCommand();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/xqa",
-  "version": "1.6.1",
+  "version": "1.8.0",
   "type": "module",
   "engines": {
     "node": ">=22"
@@ -27,11 +27,11 @@
     "vitest": "^3.2.1",
     "zod": "^3.0.0",
     "@qa-agents/display": "0.0.0",
+    "@qa-agents/eslint-config": "0.0.0",
     "@qa-agents/explorer": "0.0.0",
     "@qa-agents/mobile-ios": "0.0.0",
     "@qa-agents/pipeline": "0.0.0",
     "@qa-agents/shared": "0.0.0",
-    "@qa-agents/eslint-config": "0.0.0",
     "@qa-agents/typescript-config": "0.0.0"
   },
   "dependencies": {