@piwitests/reporter 0.41.0 → 0.43.0

package/dist/cli/index.js

@@ -1924,43 +1924,43 @@ var Checker = class {
   constructor() {
     this.errors = [];
   }
-  fail(path16, message) {
-    if (this.errors.length < 20) this.errors.push(`${path16}: ${message}`);
+  fail(path19, message) {
+    if (this.errors.length < 20) this.errors.push(`${path19}: ${message}`);
   }
-  text(v, path16, max, nullable) {
+  text(v, path19, max, nullable) {
     if (v == null) {
-      if (!nullable) this.fail(path16, "is required");
+      if (!nullable) this.fail(path19, "is required");
       return null;
     }
     if (typeof v !== "string") {
-      this.fail(path16, "must be a string");
+      this.fail(path19, "must be a string");
       return null;
     }
-    if (v.length > max) this.fail(path16, `is longer than ${max} characters`);
+    if (v.length > max) this.fail(path19, `is longer than ${max} characters`);
     return v;
   }
-  number(v, path16) {
+  number(v, path19) {
     if (typeof v !== "number" || !Number.isFinite(v)) {
-      this.fail(path16, "must be a number");
+      this.fail(path19, "must be a number");
       return 0;
     }
     return v;
   }
 };
-function checkTarget(c, v, path16) {
+function checkTarget(c, v, path19) {
   if (v == null) return null;
   if (!isObject(v)) {
-    c.fail(path16, "must be an object");
+    c.fail(path19, "must be an object");
     return null;
   }
   const alternativesIn = v.alternatives ?? [];
   const alternatives = [];
-  if (!Array.isArray(alternativesIn)) c.fail(`${path16}.alternatives`, "must be a list");
+  if (!Array.isArray(alternativesIn)) c.fail(`${path19}.alternatives`, "must be a list");
   else if (alternativesIn.length > STEPS_LIMITS.alternatives)
-    c.fail(`${path16}.alternatives`, `holds more than ${STEPS_LIMITS.alternatives}`);
+    c.fail(`${path19}.alternatives`, `holds more than ${STEPS_LIMITS.alternatives}`);
   else {
     alternativesIn.forEach((alt, i) => {
-      const at = `${path16}.alternatives[${i}]`;
+      const at = `${path19}.alternatives[${i}]`;
       if (!isObject(alt)) return c.fail(at, "must be an object");
       const locator = c.text(alt.locator, `${at}.locator`, STEPS_LIMITS.textLength, false);
       const safe = locator ? safeLocator(locator) : null;
@@ -1974,67 +1974,67 @@ function checkTarget(c, v, path16) {
     });
   }
   return {
-    tagName: c.text(v.tagName, `${path16}.tagName`, 64, false) ?? "",
-    role: c.text(v.role, `${path16}.role`, 64, true),
-    accessibleName: c.text(v.accessibleName, `${path16}.accessibleName`, STEPS_LIMITS.textLength, true),
-    testId: c.text(v.testId, `${path16}.testId`, STEPS_LIMITS.textLength, true),
-    text: c.text(v.text, `${path16}.text`, STEPS_LIMITS.textLength, true),
+    tagName: c.text(v.tagName, `${path19}.tagName`, 64, false) ?? "",
+    role: c.text(v.role, `${path19}.role`, 64, true),
+    accessibleName: c.text(v.accessibleName, `${path19}.accessibleName`, STEPS_LIMITS.textLength, true),
+    testId: c.text(v.testId, `${path19}.testId`, STEPS_LIMITS.textLength, true),
+    text: c.text(v.text, `${path19}.text`, STEPS_LIMITS.textLength, true),
     alternatives
   };
 }
-function checkAssertion(c, v, path16) {
+function checkAssertion(c, v, path19) {
   if (!isObject(v)) {
-    c.fail(path16, "is required on an assert step");
+    c.fail(path19, "is required on an assert step");
     return void 0;
   }
   const matcher = v.matcher;
   if (!ASSERTION_MATCHERS.includes(matcher)) {
-    c.fail(`${path16}.matcher`, `must be one of ${ASSERTION_MATCHERS.join(", ")}`);
+    c.fail(`${path19}.matcher`, `must be one of ${ASSERTION_MATCHERS.join(", ")}`);
     return void 0;
   }
-  const expected = c.text(v.expected, `${path16}.expected`, STEPS_LIMITS.valueLength, !VALUE_MATCHERS.has(matcher));
+  const expected = c.text(v.expected, `${path19}.expected`, STEPS_LIMITS.valueLength, !VALUE_MATCHERS.has(matcher));
   return {
     matcher,
     expected: VALUE_MATCHERS.has(matcher) ? expected : null,
-    actual: c.text(v.actual, `${path16}.actual`, STEPS_LIMITS.valueLength, true),
+    actual: c.text(v.actual, `${path19}.actual`, STEPS_LIMITS.valueLength, true),
     negated: v.negated === true,
-    note: c.text(v.note, `${path16}.note`, STEPS_LIMITS.valueLength, true)
+    note: c.text(v.note, `${path19}.note`, STEPS_LIMITS.valueLength, true)
   };
 }
-function checkStep(c, v, path16) {
+function checkStep(c, v, path19) {
   if (!isObject(v)) {
-    c.fail(path16, "must be an object");
+    c.fail(path19, "must be an object");
     return null;
   }
   const action = v.action;
   if (!ACTIONS.has(action)) {
-    c.fail(`${path16}.action`, "is not a known action");
+    c.fail(`${path19}.action`, "is not a known action");
     return null;
   }
   const step = {
     action: action === "assertVisible" ? "assert" : action,
-    target: checkTarget(c, v.target, `${path16}.target`),
-    value: c.text(v.value, `${path16}.value`, STEPS_LIMITS.valueLength, true),
+    target: checkTarget(c, v.target, `${path19}.target`),
+    value: c.text(v.value, `${path19}.value`, STEPS_LIMITS.valueLength, true),
     redacted: v.redacted === true,
-    pageUrl: c.text(v.pageUrl, `${path16}.pageUrl`, STEPS_LIMITS.valueLength, false) ?? "",
-    timestamp: v.timestamp == null ? 0 : c.number(v.timestamp, `${path16}.timestamp`)
+    pageUrl: c.text(v.pageUrl, `${path19}.pageUrl`, STEPS_LIMITS.valueLength, false) ?? "",
+    timestamp: v.timestamp == null ? 0 : c.number(v.timestamp, `${path19}.timestamp`)
   };
   if (step.redacted) step.value = null;
   if (action === "hover" || action === "dblclick") {
     step.value = null;
-    if (!step.target) c.fail(`${path16}.target`, `is required on a ${action} step`);
+    if (!step.target) c.fail(`${path19}.target`, `is required on a ${action} step`);
   }
-  if (action === "setInputFiles" && !step.target) c.fail(`${path16}.target`, "is required on a setInputFiles step");
+  if (action === "setInputFiles" && !step.target) c.fail(`${path19}.target`, "is required on a setInputFiles step");
   if (action === "dragTo") {
     step.value = null;
-    if (!step.target) c.fail(`${path16}.target`, "is required on a dragTo step");
-    step.dropTarget = checkTarget(c, v.dropTarget, `${path16}.dropTarget`);
-    if (!step.dropTarget) c.fail(`${path16}.dropTarget`, "is required on a dragTo step");
+    if (!step.target) c.fail(`${path19}.target`, "is required on a dragTo step");
+    step.dropTarget = checkTarget(c, v.dropTarget, `${path19}.dropTarget`);
+    if (!step.dropTarget) c.fail(`${path19}.dropTarget`, "is required on a dragTo step");
   }
   if (action === "assertVisible") {
     step.assertion = { matcher: "toBeVisible", expected: null, actual: null, negated: false, note: null };
   } else if (action === "assert") {
-    step.assertion = checkAssertion(c, v.assertion, `${path16}.assertion`);
+    step.assertion = checkAssertion(c, v.assertion, `${path19}.assertion`);
   }
   return step;
 }
@@ -2378,8 +2378,1019 @@ ${USAGE3}`);
   return EXIT_OK3;
 }
 
-// src/cli/gate.ts
+// src/cli/flake.ts
+var import_node_child_process4 = require("child_process");
+var fs8 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path11 = __toESM(require("path"));
+
+// ../core/src/error-parse.ts
+var ANSI_RE = new RegExp("\\u001B\\[[0-9;]*m", "g");
+var CHAIN_LINK_METHODS = /* @__PURE__ */ new Set([
+  ...LOCATOR_BUILDER_METHODS,
+  "frameLocator",
+  "contentFrame",
+  "filter",
+  "first",
+  "last",
+  "nth",
+  "and",
+  "or",
+  "describe"
+]);
+var LEAF_METHODS = new Set(LOCATOR_BUILDER_METHODS);
+var SUBJECTS = "locator|page|frame|frameLocator|elementHandle|mouse|keyboard|touchscreen|browserContext|browser|apiRequestContext|request|response|route|download|dialog|fileChooser|expect|worker|jsHandle|clock|tracing|video";
+var CALL_RE = new RegExp(`\\b(${SUBJECTS})\\.(\\w+): `);
+
+// ../core/src/flake-plan.ts
+var FLAKE_PLAN_VERSION = 1;
+var FLAKE_BATCH_RUNS = 5;
+var FLAKE_SPAWN_OVERHEAD_MS = 3e3;
+function estimateFlakeSessionMs(arms, medianDurationMs) {
+  if (medianDurationMs == null) return null;
+  let total = 0;
+  for (const arm of arms) {
+    const twoTests = arm.conditions.some((c) => c.kind === "alongside" || c.kind === "after");
+    const batches = arm.stopAt == null ? 1 : Math.ceil(arm.runs / FLAKE_BATCH_RUNS);
+    total += arm.runs * medianDurationMs * (twoTests ? 2 : 1) + batches * FLAKE_SPAWN_OVERHEAD_MS;
+  }
+  return total;
+}
+
+// src/internal/config/desktop.ts
 var fs5 = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path8 = __toESM(require("path"));
+function defaultDesktopConfigPath() {
+  return path8.join(os.homedir(), ".piwi", "desktop.json");
+}
+function readDesktopConfig(filePath) {
+  try {
+    const parsed = JSON.parse(fs5.readFileSync(filePath, "utf8"));
+    const url = parsed?.url;
+    const token = parsed?.token;
+    if (typeof url !== "string" || !url) return null;
+    if (typeof token !== "string" || !token) return null;
+    return { url, token };
+  } catch {
+    return null;
+  }
+}
+
+// src/internal/config/env.ts
+var DEFAULTS = {
+  projectName: "default-project",
+  uploadTraces: true,
+  uploadReport: true,
+  liveFileUploads: true,
+  collectScmInfo: true,
+  collectCiInfo: true,
+  collectPerformanceMetrics: true,
+  captureLocators: true,
+  capturePageState: true,
+  // Off by default: the page inventory reads control and link names from every
+  // visited page, so it stays opt-in until a project turns it on.
+  capturePageInventory: false,
+  // Off by default: JavaScript coverage slows the page, so a scheduled job opts in.
+  captureCodeReach: false,
+  captureServerTraces: true,
+  sampleAriaOnPass: true,
+  uploadManifest: true,
+  defaultCapture: true,
+  streaming: true,
+  streamingBatchSize: 5,
+  streamingBatchDelay: 2e3,
+  maxStreamBufferBytes: 100 * 1024 * 1024,
+  submitTimeout: 15 * 60 * 1e3,
+  failOnFlakyTests: false,
+  username: null,
+  password: null,
+  apiKey: null,
+  verbose: false
+};
+var PIWI_ENV_KEYS = {
+  serverUrl: "PIWI_DASHBOARD_URL",
+  projectName: "PIWI_PROJECT_NAME",
+  verbose: "PIWI_VERBOSE",
+  apiKey: "PIWI_API_KEY",
+  username: "PIWI_USERNAME",
+  password: "PIWI_PASSWORD",
+  environment: "PIWI_ENVIRONMENT",
+  label: "PIWI_LABEL",
+  runLabel: "PIWI_RUN_LABEL",
+  keep: "PIWI_KEEP",
+  streaming: "PIWI_STREAMING",
+  streamingBatchSize: "PIWI_STREAMING_BATCH_SIZE",
+  streamingBatchDelay: "PIWI_STREAMING_BATCH_DELAY",
+  maxStreamBufferBytes: "PIWI_MAX_STREAM_BUFFER_BYTES",
+  submitTimeout: "PIWI_SUBMIT_TIMEOUT",
+  liveFileUploads: "PIWI_LIVE_FILE_UPLOADS",
+  failOnFlakyTests: "PIWI_FAIL_ON_FLAKY_TESTS",
+  uploadTraces: "PIWI_UPLOAD_TRACES",
+  uploadReport: "PIWI_UPLOAD_REPORT",
+  captureLocators: "PIWI_CAPTURE_LOCATORS",
+  capturePageState: "PIWI_CAPTURE_PAGE_STATE",
+  capturePageInventory: "PIWI_CAPTURE_PAGE_INVENTORY",
+  captureCodeReach: "PIWI_CAPTURE_CODE_REACH",
+  codeReachRoots: "PIWI_CODE_REACH_ROOTS",
+  captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
+  sampleAriaOnPass: "PIWI_SAMPLE_ARIA_ON_PASS",
+  uploadManifest: "PIWI_UPLOAD_MANIFEST",
+  defaultCapture: "PIWI_DEFAULT_CAPTURE",
+  inspectOnFailure: "PIWI_INSPECT_ON_FAIL",
+  pickLocatorOnFailure: "PIWI_PICK_LOCATOR_ON_FAIL",
+  outputFile: "PIWI_OUTPUT_FILE",
+  aiMode: "PIWI_AI",
+  aiDir: "PIWI_AI_DIR",
+  aiOnMiss: "PIWI_AI_ON_MISS",
+  aiMaxSteps: "PIWI_AI_MAX_FLOW_STEPS",
+  aiMaxSnapshotChars: "PIWI_AI_MAX_SNAPSHOT_CHARS",
+  aiOptionalProbeTimeout: "PIWI_AI_OPTIONAL_PROBE_TIMEOUT",
+  aiResponseWaitTimeout: "PIWI_AI_RESPONSE_WAIT_TIMEOUT",
+  aiScreenshotFallback: "PIWI_AI_SCREENSHOT_FALLBACK"
+};
+var PIWI_DESKTOP_CONFIG_ENV = "PIWI_DESKTOP_CONFIG";
+var PIWI_SHARD_ENV = "PIWI_SHARD";
+var PIWI_PROBE_ENV = {
+  flag: "PIWI_PROBE",
+  plan: "PIWI_PROBE_PLAN",
+  results: "PIWI_PROBE_RESULTS",
+  secret: "PIWI_PROBE_SECRET"
+};
+var PIWI_FLAKE_ENV = {
+  plan: "PIWI_FLAKE_PLAN",
+  results: "PIWI_FLAKE_RESULTS"
+};
+var ENV_FALLBACK_SPECS = [
+  { option: "serverUrl", env: PIWI_ENV_KEYS.serverUrl, kind: "string" },
+  { option: "projectName", env: PIWI_ENV_KEYS.projectName, kind: "string" },
+  { option: "apiKey", env: PIWI_ENV_KEYS.apiKey, kind: "string" },
+  { option: "username", env: PIWI_ENV_KEYS.username, kind: "string" },
+  { option: "password", env: PIWI_ENV_KEYS.password, kind: "string" },
+  { option: "environment", env: PIWI_ENV_KEYS.environment, kind: "string" },
+  { option: "label", env: PIWI_ENV_KEYS.label, kind: "string" },
+  { option: "runLabel", env: PIWI_ENV_KEYS.runLabel, kind: "string" },
+  { option: "keep", env: PIWI_ENV_KEYS.keep, kind: "bool" },
+  { option: "streaming", env: PIWI_ENV_KEYS.streaming, kind: "bool" },
+  { option: "streamingBatchSize", env: PIWI_ENV_KEYS.streamingBatchSize, kind: "number" },
+  { option: "streamingBatchDelay", env: PIWI_ENV_KEYS.streamingBatchDelay, kind: "number" },
+  { option: "maxStreamBufferBytes", env: PIWI_ENV_KEYS.maxStreamBufferBytes, kind: "number" },
+  { option: "submitTimeout", env: PIWI_ENV_KEYS.submitTimeout, kind: "number" },
+  { option: "liveFileUploads", env: PIWI_ENV_KEYS.liveFileUploads, kind: "bool" },
+  { option: "failOnFlakyTests", env: PIWI_ENV_KEYS.failOnFlakyTests, kind: "bool" },
+  { option: "uploadTraces", env: PIWI_ENV_KEYS.uploadTraces, kind: "bool" },
+  { option: "uploadReport", env: PIWI_ENV_KEYS.uploadReport, kind: "bool" },
+  { option: "captureLocators", env: PIWI_ENV_KEYS.captureLocators, kind: "bool" },
+  { option: "capturePageState", env: PIWI_ENV_KEYS.capturePageState, kind: "bool" },
+  { option: "capturePageInventory", env: PIWI_ENV_KEYS.capturePageInventory, kind: "bool" },
+  { option: "captureCodeReach", env: PIWI_ENV_KEYS.captureCodeReach, kind: "bool" },
+  { option: "captureServerTraces", env: PIWI_ENV_KEYS.captureServerTraces, kind: "bool" },
+  { option: "sampleAriaOnPass", env: PIWI_ENV_KEYS.sampleAriaOnPass, kind: "bool" },
+  { option: "uploadManifest", env: PIWI_ENV_KEYS.uploadManifest, kind: "bool" },
+  { option: "defaultCapture", env: PIWI_ENV_KEYS.defaultCapture, kind: "bool" },
+  { option: "inspectOnFailure", env: PIWI_ENV_KEYS.inspectOnFailure, kind: "bool" },
+  { option: "pickLocatorOnFailure", env: PIWI_ENV_KEYS.pickLocatorOnFailure, kind: "bool" },
+  { option: "outputFile", env: PIWI_ENV_KEYS.outputFile, kind: "string" }
+];
+
+// ../core/src/flake-verdict.ts
+var FLAKE_SIGNIFICANCE = 0.05;
+var FLAKE_REPRODUCED_RATE = 0.5;
+var FLAKE_VERIFY_MIN_RUNS = 5;
+function logFactorial(n) {
+  let sum = 0;
+  for (let i = 2; i <= n; i++) sum += Math.log(i);
+  return sum;
+}
+function logChoose(n, k) {
+  return logFactorial(n) - logFactorial(k) - logFactorial(n - k);
+}
+function assertCount(value, name) {
+  if (!Number.isInteger(value) || value < 0) throw new RangeError(`${name} must be a whole number from 0`);
+}
+function fisherExactGreater(armFailures, armRuns, controlFailures, controlRuns) {
+  assertCount(armFailures, "armFailures");
+  assertCount(armRuns, "armRuns");
+  assertCount(controlFailures, "controlFailures");
+  assertCount(controlRuns, "controlRuns");
+  if (armFailures > armRuns || controlFailures > controlRuns) throw new RangeError("failures cannot exceed runs");
+  const failures = armFailures + controlFailures;
+  const total = armRuns + controlRuns;
+  const denominator = logChoose(total, failures);
+  const highest = Math.min(armRuns, failures);
+  let p = 0;
+  for (let k = armFailures; k <= highest; k++) {
+    if (failures - k > controlRuns) continue;
+    p += Math.exp(logChoose(armRuns, k) + logChoose(controlRuns, failures - k) - denominator);
+  }
+  return Math.min(1, p);
+}
+function flakeArmVerdict(arm, control) {
+  const pValue = fisherExactGreater(arm.matchingFailures, arm.runs, control.matchingFailures, control.runs);
+  const rate = arm.runs > 0 ? arm.matchingFailures / arm.runs : 0;
+  const significant = pValue < FLAKE_SIGNIFICANCE;
+  const verdict = significant && rate >= FLAKE_REPRODUCED_RATE ? "reproduced" : significant ? "amplified" : "not-reproduced";
+  return { verdict, rate, pValue };
+}
+function flakeVerifyRuns(rate) {
+  if (!Number.isFinite(rate) || rate <= 0 || rate > 1) throw new RangeError("rate must be above 0 and at most 1");
+  if (rate === 1) return FLAKE_VERIFY_MIN_RUNS;
+  const exact = Math.log(FLAKE_SIGNIFICANCE) / Math.log(1 - rate);
+  return Math.max(FLAKE_VERIFY_MIN_RUNS, Math.ceil(Number(exact.toFixed(9))));
+}
+function flakeFixVerified(verify, reproducedRate) {
+  return verify.matchingFailures === 0 && verify.runs >= flakeVerifyRuns(reproducedRate);
+}
+
+// src/internal/flake/lab.ts
+var FAILED = /* @__PURE__ */ new Set(["failed", "timedOut"]);
+function overlaps(a, b) {
+  return a.startedAt < b.startedAt + b.duration && b.startedAt < a.startedAt + a.duration;
+}
+function workerCondition(conditions) {
+  for (const c of conditions) if (c.kind === "alongside" || c.kind === "after") return c;
+  return null;
+}
+function roundKept(line, all, conditions) {
+  const condition = workerCondition(conditions);
+  if (!condition) return true;
+  if (condition.kind === "alongside") return all.some((l) => l.role === "companion" && overlaps(l, line));
+  const before = all.filter((l) => l !== line && l.startedAt < line.startedAt).sort((a, b) => b.startedAt - a.startedAt)[0];
+  return before?.role === "companion";
+}
+function countArm(batches, arm) {
+  let seen = 0;
+  const kept = [];
+  for (const lines of batches) {
+    const targets = lines.filter((l) => l.role === "target" && l.status !== "skipped" && l.status !== "interrupted").sort((a, b) => a.startedAt - b.startedAt || a.repeatEachIndex - b.repeatEachIndex);
+    seen += targets.length;
+    kept.push(...targets.filter((l) => roundKept(l, lines, arm.conditions)));
+  }
+  const count = {
+    runs: 0,
+    matchingFailures: 0,
+    otherFailures: 0,
+    discardedRounds: seen - kept.length,
+    stoppedEarly: false,
+    otherSignatures: []
+  };
+  const others = /* @__PURE__ */ new Map();
+  for (const [i, line] of kept.entries()) {
+    count.runs++;
+    if (line.matchesHistory) count.matchingFailures++;
+    else if (FAILED.has(line.status)) {
+      count.otherFailures++;
+      const signature = line.errorSignature ?? line.status;
+      others.set(signature, (others.get(signature) ?? 0) + 1);
+    }
+    if (arm.stopAt != null && count.matchingFailures >= arm.stopAt) {
+      count.stoppedEarly = i < kept.length - 1;
+      break;
+    }
+  }
+  count.otherSignatures = [...others.entries()].sort((a, b) => b[1] - a[1]).map(([s]) => s);
+  return count;
+}
+function armDone(count, arm) {
+  return arm.stopAt != null && count.matchingFailures >= arm.stopAt || count.runs >= arm.runs;
+}
+function nextBatch(count, arm) {
+  const left = Math.max(0, arm.runs - count.runs);
+  return arm.stopAt == null ? left : Math.min(left, FLAKE_BATCH_RUNS);
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function grepFor(tests) {
+  return tests.map((t) => `(^| )${escapeRegex([...t.suite, t.title].join(" "))}( @\\S+)*$`).join("|");
+}
+function playwrightArgs(test, arm, repeat) {
+  const companion = workerCondition(arm.conditions);
+  const tests = companion ? [test, companion.test] : [test];
+  const files = [...new Set(tests.map((t) => t.file))];
+  const args = [...files, "--grep", grepFor(tests), `--repeat-each=${repeat}`, "--retries=0"];
+  const alongside = companion?.kind === "alongside";
+  args.push(`--workers=${alongside ? 2 : 1}`);
+  if (alongside && files.length === 1) args.push("--fully-parallel");
+  const project = arm.conditions.find((c) => c.kind === "project");
+  const name = project?.kind === "project" ? project.name : test.project;
+  if (name) args.push(`--project=${name}`);
+  return args;
+}
+function armVerdict(arm, control) {
+  return flakeArmVerdict(arm, control);
+}
+function verifyVerdict(arm, reproducedRate) {
+  if (arm.matchingFailures > 0) return "still-fails";
+  return flakeFixVerified(arm, reproducedRate) ? "verified" : "inconclusive";
+}
+var EXIT_REPRODUCED = 0;
+var EXIT_NOT_REPRODUCED = 1;
+var EXIT_ERROR4 = 2;
+var EXIT_BISECT_SKIP = 125;
+function exitCodeFor(verdict) {
+  return verdict === "reproduced" || verdict === "verified" ? EXIT_REPRODUCED : EXIT_NOT_REPRODUCED;
+}
+function bisectExitCode(verdict) {
+  if (verdict === "verified") return EXIT_REPRODUCED;
+  if (verdict === "still-fails") return EXIT_NOT_REPRODUCED;
+  return EXIT_BISECT_SKIP;
+}
+function parseDuration(text) {
+  const trimmed = text.trim().toLowerCase();
+  if (/^\d+(\.\d+)?$/.test(trimmed)) return Math.round(Number(trimmed) * 6e4);
+  const re = /(\d+(?:\.\d+)?)\s*(h|m|s)/g;
+  let total = 0;
+  let consumed = "";
+  for (const m of trimmed.matchAll(re)) {
+    total += Number(m[1]) * (m[2] === "h" ? 36e5 : m[2] === "m" ? 6e4 : 1e3);
+    consumed += m[0];
+  }
+  return consumed.replace(/\s/g, "") === trimmed.replace(/\s/g, "") && total > 0 ? Math.round(total) : null;
+}
+function formatDuration(ms) {
+  if (ms < 6e4) return `${Math.max(1, Math.round(ms / 1e3))} s`;
+  const minutes = Math.round(ms / 6e4);
+  if (minutes < 60) return `${minutes} min`;
+  return `${Math.floor(minutes / 60)} h ${minutes % 60} min`;
+}
+function withinBudget(startedAt, now, budgetMs) {
+  return now - startedAt < budgetMs;
+}
+
+// src/internal/support/connection.ts
+var fs6 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+
+// ../core/src/dotenv.ts
+function parseDotEnv(text) {
+  const out = {};
+  for (const raw of text.split(/\r?\n/)) {
+    const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/.exec(raw);
+    if (!m) continue;
+    let value = m[2];
+    const quote4 = value[0];
+    if ((quote4 === '"' || quote4 === "'") && value.length > 1 && value.endsWith(quote4)) {
+      value = value.slice(1, -1);
+      if (quote4 === '"') value = value.replace(/\\n/g, "\n").replace(/\\"/g, '"');
+    } else {
+      value = value.replace(/\s+#.*$/, "");
+    }
+    out[m[1]] = value;
+  }
+  return out;
+}
+function resolvePiwiConnection(sources) {
+  const own = {
+    serverUrl: sources.flags?.serverUrl || sources.env?.PIWI_DASHBOARD_URL,
+    apiKey: sources.flags?.apiKey || sources.env?.PIWI_API_KEY
+  };
+  const workspace = { serverUrl: sources.dotEnv?.PIWI_DASHBOARD_URL, apiKey: sources.dotEnv?.PIWI_API_KEY };
+  const project = sources.flags?.project || sources.env?.PIWI_PROJECT_NAME || sources.dotEnv?.PIWI_PROJECT_NAME || "";
+  const desktop = sources.desktop ?? null;
+  const trim = (url) => url.replace(/\/+$/, "");
+  const layer = own.serverUrl ? own : workspace.serverUrl ? workspace : null;
+  const serverUrl = layer ? trim(layer.serverUrl) : desktop ? trim(desktop.url) : "";
+  if (!serverUrl) return null;
+  const desktopKey = desktop && trim(desktop.url) === serverUrl ? desktop.token : null;
+  return { serverUrl, apiKey: layer?.apiKey || desktopKey || null, project };
+}
+
+// src/internal/support/connection.ts
+function resolveCliConnection(flags, env, dirs) {
+  let dotEnv = {};
+  for (const dir of dirs) {
+    try {
+      dotEnv = { ...parseDotEnv(fs6.readFileSync(path9.join(dir, ".env"), "utf-8")), ...dotEnv };
+    } catch {
+    }
+  }
+  return resolvePiwiConnection({
+    flags,
+    env,
+    dotEnv,
+    desktop: readDesktopConfig(env[PIWI_DESKTOP_CONFIG_ENV] || defaultDesktopConfigPath())
+  });
+}
+
+// src/internal/support/playwright-spawn.ts
+var import_node_child_process3 = require("child_process");
+var fs7 = __toESM(require("fs"));
+var import_node_module2 = require("module");
+var path10 = __toESM(require("path"));
+function resolvePlaywrightCli2(cwd = process.cwd()) {
+  const require2 = (0, import_node_module2.createRequire)(path10.join(cwd, "noop.js"));
+  for (const id of ["playwright/cli", "@playwright/test/cli", "playwright/lib/cli/cli"]) {
+    try {
+      return require2.resolve(id);
+    } catch {
+    }
+  }
+  return null;
+}
+function spawnPlaywright(playwrightArgs2, env, options = {}) {
+  const output = options.output ?? "inherit";
+  let fd = output === "inherit" ? null : fs7.openSync(output.file, "a");
+  const stdio = fd === null ? "inherit" : ["ignore", fd, fd];
+  const cli = resolvePlaywrightCli2();
+  const child = cli ? (0, import_node_child_process3.spawn)(process.execPath, [cli, "test", ...playwrightArgs2], { stdio, env }) : (0, import_node_child_process3.spawn)(process.platform === "win32" ? "npx.cmd" : "npx", ["playwright", "test", ...playwrightArgs2], {
+    stdio,
+    env
+  });
+  return new Promise((resolve8) => {
+    const done = (code) => {
+      if (fd !== null) fs7.closeSync(fd);
+      fd = null;
+      resolve8(code);
+    };
+    child.on("error", (err) => {
+      console.error(`${options.command ?? "piwi"}: could not start Playwright \u2014 ${err.message}`);
+      done(2);
+    });
+    child.on("exit", (code) => done(code ?? 2));
+  });
+}
+
+// src/cli/flake.ts
+var USAGE4 = `
+piwi flake \u2014 make a flaky test fail on demand, then prove the fix
+
+Usage:
+  npx @piwitests/reporter flake <test> [options]
+  npx @piwitests/reporter flake verify <test> [--runs <n>] [--bisect] [--json]
+
+<test> is a test case id (the number in its dashboard URL) or a spec file and
+line, tests/checkout.spec.ts:42, looked up in the project on the dashboard.
+
+It fetches the test's plan from the dashboard: a control arm and one arm per
+suspect of its flake profile, most likely first. It runs the control (10 runs),
+then each arm (up to 10 runs, stopping at 3 failures with the same error as in
+CI), one test at a time with retries off, in the checkout it runs in. It prints
+each arm against the control with its verdict and saves the experiment on the
+test's Flakiness tab. The capture fixtures must be in use (piwiFixtures).
+
+verify reruns the arm that last reproduced the test, and its control, until a
+matching failure appears or enough runs pass to say the fix holds.
+
+verify --bisect runs that arm alone at this checkout and saves nothing, for
+git bisect run: exit 0 (good) when enough runs pass, 1 (bad) on a failure with
+the same error as in CI, 125 (skip) when this commit cannot tell.
+
+Options:
+  --suspect <n>        Run only the arm of suspect n (its rank on the Flakiness tab)
+  --all                Also run every condition at once when none reproduces alone
+  --runs <n>           Runs of the control and of each arm (default 10; verify:
+                       the number that proves the fix at the rate it reproduced)
+  --budget <duration>  Start no new arm after this long: 15m (default), 90s, 1h
+  --no-upload          Keep the results off the dashboard; it still needs the plan
+                       from the dashboard, or from --plan when it cannot be reached
+  --plan <file>        Read the plan from a file (a saved flake-plan response, or
+                       the plan the plan_flake_experiment MCP tool returns) and run
+                       it without the dashboard; implies --no-upload
+  --bisect             verify only: one bisect step, as above; implies --no-upload
+  --source <where>     Where the lab runs, recorded on the experiment: cli, ci or
+                       desktop (default: ci when CI is set, else cli)
+  --json               Print the results as JSON instead of text
+  --server-url <url>   Dashboard URL (env PIWI_DASHBOARD_URL, .env, the desktop app)
+  --api-key <key>      Reporter API key (env PIWI_API_KEY, .env)
+  --project <name|id>  The Piwi project, for a file:line test (env PIWI_PROJECT_NAME)
+
+Exit codes: 0 an arm reproduced the failure (verify: the fix held),
+            1 nothing reproduced (verify: it still fails, or too few runs),
+            2 error; with --bisect, 0 good, 1 bad, 125 skip, 2 error.
+`.trim();
+var DEFAULT_BUDGET_MS = 15 * 6e4;
+var SOURCES = ["cli", "ci", "desktop"];
+var MAX_BATCHES = 12;
+var LOG_TAIL_LINES = 40;
+function parseFlakeArgs(argv) {
+  const args = {
+    verify: argv[0] === "verify",
+    test: null,
+    suspect: null,
+    all: false,
+    runs: null,
+    budgetMs: DEFAULT_BUDGET_MS,
+    upload: true,
+    planFile: null,
+    bisect: false,
+    source: null,
+    json: false,
+    help: false
+  };
+  const rest = args.verify ? argv.slice(1) : argv;
+  const value = (i, name) => {
+    const v = rest[i + 1];
+    if (v === void 0 || v.startsWith("--")) throw new Error(`${name} needs a value`);
+    return v;
+  };
+  const whole = (text, name, min, max) => {
+    const n = Number(text);
+    if (!Number.isInteger(n) || n < min || n > max)
+      throw new Error(`${name} must be a whole number from ${min} to ${max}`);
+    return n;
+  };
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        args.help = true;
+        break;
+      case "--suspect":
+        args.suspect = whole(value(i++, arg), arg, 1, 50);
+        break;
+      case "--all":
+        args.all = true;
+        break;
+      case "--runs":
+        args.runs = whole(value(i++, arg), arg, 1, 100);
+        break;
+      case "--budget": {
+        const ms = parseDuration(value(i++, arg));
+        if (ms == null) throw new Error("--budget must be a duration like 15m, 90s or 1h");
+        args.budgetMs = ms;
+        break;
+      }
+      case "--no-upload":
+        args.upload = false;
+        break;
+      case "--plan":
+        args.planFile = value(i++, arg);
+        args.upload = false;
+        break;
+      case "--bisect":
+        args.bisect = true;
+        args.upload = false;
+        break;
+      case "--source": {
+        const where = value(i++, arg);
+        if (!SOURCES.includes(where))
+          throw new Error(`--source must be one of ${SOURCES.join(", ")}`);
+        args.source = where;
+        break;
+      }
+      case "--json":
+        args.json = true;
+        break;
+      case "--server-url":
+        args.serverUrl = value(i++, arg);
+        break;
+      case "--api-key":
+        args.apiKey = value(i++, arg);
+        break;
+      case "--project":
+        args.project = value(i++, arg);
+        break;
+      default:
+        if (arg.startsWith("-")) throw new Error(`unknown option ${arg}`);
+        if (args.test !== null) throw new Error(`one test at a time (got "${args.test}" and "${arg}")`);
+        args.test = arg;
+    }
+  }
+  if (args.suspect !== null && args.all) throw new Error("--suspect and --all cannot be used together");
+  if (args.verify && (args.suspect !== null || args.all))
+    throw new Error("verify reruns one arm: drop --suspect and --all");
+  if (args.bisect && !args.verify) throw new Error("--bisect is a verify option: flake verify <test> --bisect");
+  return args;
+}
+function gitHead() {
+  try {
+    return (0, import_node_child_process4.execFileSync)("git", ["rev-parse", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function commitsDiffer(a, b) {
+  if (!a || !b) return false;
+  const [x, y] = [a.toLowerCase(), b.toLowerCase()];
+  return !x.startsWith(y) && !y.startsWith(x);
+}
+function short(sha) {
+  return sha ? sha.slice(0, 7) : "unknown";
+}
+function fraction(count) {
+  return `${count.matchingFailures}/${count.runs}`;
+}
+function formatP(p) {
+  return p < 1e-3 ? "< 0.001" : `= ${p.toFixed(3)}`;
+}
+var FlakeError = class extends Error {
+};
+async function getJson(http, url) {
+  const res = await fetch(`${http.serverUrl}${url}`, { headers: http.headers });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new FlakeError(body.message || `the dashboard returned ${res.status} for ${url.split("?")[0]}`);
+  }
+  return await res.json();
+}
+async function resolveTestCase(http, test, project, apiKey) {
+  if (/^\d+$/.test(test)) return Number(test);
+  const m = /^(.+):(\d+)$/.exec(test);
+  if (!m) throw new FlakeError(`"${test}" is neither a test case id nor file:line`);
+  const projectId = await resolveProjectId({ serverUrl: http.serverUrl, apiKey, project, key: "" });
+  const found = await getJson(
+    http,
+    `/api/projects/${projectId}/flake-lab/test?location=${encodeURIComponent(`${m[1].replace(/\\/g, "/")}:${m[2]}`)}`
+  );
+  return found.testCaseId;
+}
+function playwrightRunner(dir, log) {
+  return {
+    now: () => Date.now(),
+    async runBatch(plan, arm, repeat, batch) {
+      const planFile = path11.join(dir, `${arm.id}.plan.json`);
+      if (!fs8.existsSync(planFile)) {
+        fs8.writeFileSync(
+          planFile,
+          JSON.stringify({
+            version: FLAKE_PLAN_VERSION,
+            experimentId: plan.experimentId ?? `local-${process.pid}`,
+            test: plan.test,
+            arm: { id: arm.id, conditions: arm.conditions },
+            errorSignatures: plan.errorSignatures
+          })
+        );
+      }
+      const resultsFile = path11.join(dir, `${arm.id}.${batch}.jsonl`);
+      fs8.writeFileSync(resultsFile, "");
+      const env = {
+        ...process.env,
+        [PIWI_FLAKE_ENV.plan]: planFile,
+        [PIWI_FLAKE_ENV.results]: resultsFile
+      };
+      delete env[PIWI_PROBE_ENV.flag];
+      fs8.appendFileSync(log, `
+\u2500\u2500 ${arm.id} batch ${batch} \u2500\u2500
+`);
+      await spawnPlaywright(playwrightArgs(plan.test, arm, repeat), env, {
+        output: { file: log },
+        command: "piwi flake"
+      });
+      return readResults(resultsFile);
+    }
+  };
+}
+function readResults(file) {
+  const lines = [];
+  for (const line of fs8.readFileSync(file, "utf8").split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      lines.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return lines;
+}
+async function runArm(runner, plan, arm) {
+  const batches = [];
+  let count = countArm(batches, arm);
+  for (let batch = 1; batch <= MAX_BATCHES && !armDone(count, arm); batch++) {
+    const repeat = nextBatch(count, arm);
+    if (repeat <= 0) break;
+    const lines = await runner.runBatch(plan, arm, repeat, batch);
+    if (!lines.some((l) => l.role === "target")) {
+      throw new FlakeError(
+        `the ${arm.id} arm recorded no attempt of "${plan.displayTitle}" in ${plan.test.file}. Is the test in this checkout, and does its spec use the Piwi capture fixtures?`
+      );
+    }
+    batches.push(lines);
+    count = countArm(batches, arm);
+  }
+  return count;
+}
+async function runSession(runner, plan, args, onArm = () => {
+}) {
+  const started = runner.now();
+  const control = args.bisect ? { arm: plan.control, count: countArm([], plan.control), verdict: null, pValue: null, skipped: "bisect step" } : {
+    arm: plan.control,
+    count: await runArm(runner, plan, plan.control),
+    verdict: null,
+    pValue: null,
+    skipped: null
+  };
+  onArm(control, null);
+  const arms = args.suspect != null ? plan.arms.filter((a) => a.rank === args.suspect) : plan.arms;
+  const results = [];
+  const run = async (arm) => {
+    if (!withinBudget(started, runner.now(), args.budgetMs)) {
+      const result2 = { arm, count: countArm([], arm), verdict: null, pValue: null, skipped: "budget spent" };
+      results.push(result2);
+      onArm(result2, control.count);
+      return;
+    }
+    const count = await runArm(runner, plan, arm);
+    let verdict;
+    let pValue = null;
+    if (plan.kind === "verify") {
+      verdict = verifyVerdict(count, plan.verifies?.rate ?? 1);
+    } else {
+      const v = armVerdict(count, control.count);
+      verdict = v.verdict;
+      pValue = v.pValue;
+    }
+    const result = { arm, count, verdict, pValue, skipped: null };
+    results.push(result);
+    onArm(result, control.count);
+  };
+  for (const arm of arms) await run(arm);
+  if (args.all && plan.combined && !results.some((r) => r.verdict === "reproduced")) await run(plan.combined);
+  return { control, arms: results };
+}
+function sessionVerdict(kind, arms) {
+  if (kind === "verify") {
+    const v = arms.find((a) => a.arm.id === "verify");
+    return {
+      verdict: v?.verdict ?? "inconclusive",
+      reproducingArm: v ? "verify" : null
+    };
+  }
+  const reproduced = arms.find((a) => a.verdict === "reproduced");
+  if (reproduced) return { verdict: "reproduced", reproducingArm: reproduced.arm.id };
+  return {
+    verdict: arms.some((a) => a.verdict === "amplified") ? "amplified" : "not-reproduced",
+    reproducingArm: null
+  };
+}
+function pad(text, width) {
+  return text.length >= width ? `${text} ` : text + " ".repeat(width - text.length);
+}
+function clip(text, width) {
+  return text.length > width ? `${text.slice(0, width - 1)}\u2026` : text;
+}
+function armLine(result, stopAt) {
+  const { arm, count } = result;
+  const name = arm.id === "control" ? "control" : `${arm.rank != null ? `${arm.rank}  ` : "   "}${arm.label}`;
+  if (result.skipped) return `  ${pad(clip(name, 34), 35)}${result.skipped}`;
+  const notes = [];
+  if (count.stoppedEarly && stopAt != null) notes.push(`stopped at ${stopAt}`);
+  if (count.matchingFailures > 0) notes.push("same error as in CI");
+  if (count.otherFailures > 0)
+    notes.push(`${count.otherFailures} different error${count.otherFailures === 1 ? "" : "s"} (counted apart)`);
+  if (count.discardedRounds > 0) {
+    notes.push(`${count.discardedRounds} round${count.discardedRounds === 1 ? "" : "s"} left out`);
+  }
+  const verdict = result.verdict ? result.verdict.replace("-", " ") : "";
+  return `  ${pad(clip(name, 34), 35)}${pad(fraction(count), 7)}${pad(notes.join(" \xB7 "), 44)}${verdict}`.trimEnd();
+}
+function verdictSentence(report, arms, control) {
+  const c = fraction(control.count);
+  const against = control.skipped ? "" : ` (control ${c})`;
+  if (report.kind === "verify") {
+    const v = arms.find((a) => a.arm.id === "verify");
+    if (!v) return "Verdict: the verify arm did not run.";
+    const label = v.arm.label;
+    if (report.verdict === "verified") {
+      return `Verdict: fix verified: 0 matching failures in ${v.count.runs} runs under ${label}${against}`;
+    }
+    if (report.verdict === "still-fails") {
+      return `Verdict: still fails: ${fraction(v.count)} under ${label} failed as in CI${against}`;
+    }
+    return `Verdict: inconclusive: ${v.count.runs} clean runs under ${label}, too few to verify the fix`;
+  }
+  const r = arms.find((a) => a.arm.id === report.reproducingArm);
+  if (r) {
+    return `Verdict: reproduced by ${r.arm.label} (${fraction(r.count)} against ${c}, p ${formatP(r.pValue ?? 1)})`;
+  }
+  const amplified = arms.find((a) => a.verdict === "amplified");
+  if (amplified) {
+    return `Verdict: not reproduced; ${amplified.arm.label} made it fail more often (${fraction(amplified.count)} against ${c}, p ${formatP(amplified.pValue ?? 1)})`;
+  }
+  return `Verdict: not reproduced (control ${c})`;
+}
+function bisectStepWord(code) {
+  if (code === 0) return "good (the arm held at this commit)";
+  if (code === 1) return "bad (a failure with the same error as in CI)";
+  return "skip (too few clean runs to tell)";
+}
+function printHeader(plan, commit, estimate, budgetMs) {
+  const out = [];
+  out.push(
+    `piwi flake${plan.kind === "verify" ? " verify" : ""} \xB7 ${plan.displayTitle} \xB7 ${plan.failures} failures in ${plan.windowDays} days`
+  );
+  out.push("");
+  if (plan.kind === "verify" && plan.verifies) {
+    out.push(
+      `Rerunning ${plan.verifies.label}: it reproduced ${Math.round(plan.verifies.rate * 100)}% of runs on ${short(plan.verifies.commit)}`
+    );
+  } else if (plan.suspects.length === 0) {
+    out.push("Suspects from history: none. Nothing in its history separates its failures from its passes.");
+  } else {
+    out.push(`${pad("Suspects from history", 57)}condition`);
+    for (const s of plan.suspects) {
+      const counts = `${s.counts.failuresWith}/${s.counts.failures} failures \xB7 ${s.counts.passesWith}/${s.counts.passes} passes`;
+      out.push(
+        `  ${s.rank}  ${pad(clip(s.label, 40), 41)}${pad(counts, 30)}${s.skipped ? `none: ${s.skipped}` : s.conditionLabel}`
+      );
+      if (s.sharedRoutes?.length) out.push(`     both write ${s.sharedRoutes.join(", ")}`);
+    }
+  }
+  out.push("");
+  const estimateText = estimate != null ? `up to ${formatDuration(estimate)}` : "unknown (no passing run on record)";
+  out.push(`Estimate: ${estimateText} \xB7 budget ${formatDuration(budgetMs)}`);
+  out.push(`Lab \xB7 ${os2.hostname()} \xB7 HEAD ${short(commit)} \xB7 ${plan.test.project ?? "default project"} \xB7 retries off`);
+  if (commitsDiffer(commit, plan.failureCommit)) {
+    out.push(`warning: this checkout is ${short(commit)}; the latest failure ran on ${short(plan.failureCommit)}.`);
+  }
+  console.log(out.join("\n"));
+}
+async function loadPlan(args, commit) {
+  if (args.planFile) {
+    try {
+      const raw = JSON.parse(fs8.readFileSync(args.planFile, "utf8"));
+      const plan = "plan" in raw && raw.plan ? raw.plan : raw;
+      if (plan.version !== 1 || !plan.control || !Array.isArray(plan.arms)) throw new Error("not a flake-lab plan");
+      if (args.verify !== (plan.kind === "verify")) {
+        throw new Error(`it is a ${plan.kind} plan; run ${plan.kind === "verify" ? "flake verify" : "flake"} with it`);
+      }
+      return { plan: args.runs ? withRuns(plan, args.runs) : plan, http: null };
+    } catch (error) {
+      throw new FlakeError(`cannot read the plan ${args.planFile}: ${error.message}`);
+    }
+  }
+  if (!args.test) throw new FlakeError("name the test: a test case id or file:line");
+  const connection = resolveCliConnection(
+    { serverUrl: args.serverUrl, apiKey: args.apiKey, project: args.project },
+    process.env,
+    [process.cwd()]
+  );
+  if (!connection) {
+    throw new FlakeError(
+      "no dashboard to read the plan from: pass --server-url or set PIWI_DASHBOARD_URL (or run it offline with --plan <file>)"
+    );
+  }
+  const http = {
+    serverUrl: connection.serverUrl,
+    headers: connection.apiKey ? { "X-API-Key": connection.apiKey } : {}
+  };
+  try {
+    const testCaseId = await resolveTestCase(http, args.test, connection.project, connection.apiKey);
+    const params = new URLSearchParams({
+      kind: args.verify ? "verify" : "reproduce",
+      source: args.source ?? (process.env.CI ? "ci" : "cli"),
+      machine: os2.hostname(),
+      record: String(args.upload)
+    });
+    if (commit) params.set("commit", commit);
+    if (args.runs) params.set("runs", String(args.runs));
+    return { plan: await getJson(http, `/api/test-cases/${testCaseId}/flake-plan?${params}`), http };
+  } catch (error) {
+    if (error instanceof FlakeError) throw error;
+    throw new FlakeError(
+      `could not reach the dashboard at ${connection.serverUrl} (${error.message}). The plan comes from the dashboard; to run offline, pass --plan <file> with a plan saved earlier.`
+    );
+  }
+}
+function withRuns(plan, runs) {
+  const set = (arm) => ({ ...arm, runs });
+  return {
+    ...plan,
+    control: set(plan.control),
+    arms: plan.arms.map(set),
+    combined: plan.combined && set(plan.combined)
+  };
+}
+async function runFlake(argv, runner) {
+  let args;
+  try {
+    args = parseFlakeArgs(argv);
+  } catch (error) {
+    console.error(`piwi flake: ${error.message}
+`);
+    console.error(USAGE4);
+    return EXIT_ERROR4;
+  }
+  if (args.help) {
+    console.log(USAGE4);
+    return 0;
+  }
+  const commit = gitHead();
+  let plan;
+  let http;
+  try {
+    ({ plan, http } = await loadPlan(args, commit));
+  } catch (error) {
+    console.error(`piwi flake: ${error.message}`);
+    return EXIT_ERROR4;
+  }
+  if (args.suspect != null && !plan.arms.some((a) => a.rank === args.suspect)) {
+    console.error(`piwi flake: suspect ${args.suspect} has no arm (${plan.arms.length} arm(s) in the plan).`);
+    return EXIT_ERROR4;
+  }
+  if (plan.kind === "reproduce" && plan.arms.length === 0) {
+    if (!args.json) printHeader(plan, commit, null, args.budgetMs);
+    console.error("piwi flake: no suspect with a condition to test, so there is nothing to run.");
+    return 1;
+  }
+  const planned = [
+    ...args.bisect ? [] : [plan.control],
+    ...args.suspect != null ? plan.arms.filter((a) => a.rank === args.suspect) : plan.arms
+  ];
+  if (args.all && plan.combined) planned.push(plan.combined);
+  const estimate = estimateFlakeSessionMs(planned, plan.medianDurationMs);
+  if (!args.json) {
+    printHeader(plan, commit, estimate, args.budgetMs);
+  }
+  const dir = fs8.mkdtempSync(path11.join(os2.tmpdir(), "piwi-flake-"));
+  const log = path11.join(dir, "playwright.log");
+  let session;
+  try {
+    session = await runSession(runner ?? playwrightRunner(dir, log), plan, args, (result) => {
+      if (!args.json && !result.skipped?.startsWith("bisect")) console.log(armLine(result, result.arm.stopAt));
+    });
+  } catch (error) {
+    console.error(`piwi flake: ${error.message}`);
+    if (fs8.existsSync(log)) {
+      const tail = fs8.readFileSync(log, "utf8").trimEnd().split("\n").slice(-LOG_TAIL_LINES).join("\n");
+      console.error(`
+Playwright's output (${log}):
+${tail}`);
+    }
+    if (args.bisect) {
+      console.log("Bisect step: skip (this commit could not run the arm)");
+      return EXIT_BISECT_SKIP;
+    }
+    return EXIT_ERROR4;
+  }
+  const { verdict, reproducingArm } = sessionVerdict(plan.kind, session.arms);
+  const ran = [session.control, ...session.arms.filter((a) => !a.skipped)];
+  let uploaded = false;
+  if (args.upload && http && plan.experimentId) {
+    try {
+      const res = await fetch(`${http.serverUrl}/api/projects/${plan.projectId}/flake-lab/results`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...http.headers },
+        body: JSON.stringify({
+          experimentId: plan.experimentId,
+          commit,
+          playwrightProject: plan.test.project,
+          arms: ran.map((r) => ({
+            id: r.arm.id,
+            label: r.arm.label,
+            suspectId: r.arm.suspectId,
+            conditions: r.arm.conditions,
+            runs: r.count.runs,
+            matchingFailures: r.count.matchingFailures,
+            otherFailures: r.count.otherFailures,
+            discardedRounds: r.count.discardedRounds,
+            stoppedEarly: r.count.stoppedEarly
+          }))
+        })
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.message || `the dashboard returned ${res.status}`);
+      }
+      uploaded = true;
+    } catch (error) {
+      console.error(`piwi flake: could not save the results \u2014 ${error.message}`);
+    }
+  }
+  const code = args.bisect ? bisectExitCode(verdict) : exitCodeFor(verdict);
+  const verifyCommand = `npx @piwitests/reporter flake verify ${plan.testCaseId}`;
+  const report = {
+    kind: plan.kind,
+    testCaseId: plan.testCaseId,
+    test: plan.displayTitle,
+    experimentId: plan.experimentId,
+    commit,
+    failureCommit: plan.failureCommit,
+    commitsDiffer: commitsDiffer(commit, plan.failureCommit),
+    playwrightProject: plan.test.project,
+    estimateMs: estimate,
+    arms: [session.control, ...session.arms].map((r) => ({
+      id: r.arm.id,
+      label: r.arm.label,
+      suspectId: r.arm.suspectId,
+      rank: r.arm.rank,
+      ...r.count,
+      verdict: r.verdict,
+      pValue: r.pValue,
+      skipped: r.skipped
+    })),
+    verdict,
+    reproducingArm,
+    uploaded,
+    verifyCommand: plan.kind === "reproduce" && verdict === "reproduced" ? verifyCommand : null,
+    exitCode: code
+  };
+  fs8.rmSync(dir, { recursive: true, force: true });
+  if (args.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return code;
+  }
+  const lines = [verdictSentence(report, session.arms, session.control)];
+  if (args.bisect) lines.push(`Bisect step: ${bisectStepWord(code)}`);
+  if (uploaded)
+    lines.push(`Saved to the test's Flakiness tab.${report.verifyCommand ? ` After your fix: ${verifyCommand}` : ""}`);
+  else if (report.verifyCommand) lines.push(`Not saved (--no-upload). After your fix: ${verifyCommand}`);
+  console.log(lines.join("\n"));
+  return code;
+}
+
+// src/cli/gate.ts
+var fs9 = __toESM(require("fs"));
 
 // ../core/src/gate.ts
 function formatGateResult(result) {
@@ -2402,8 +3413,8 @@ function formatGateResult(result) {
 // src/cli/gate.ts
 var EXIT_OK4 = 0;
 var EXIT_VIOLATED = 1;
-var EXIT_ERROR4 = 2;
-var USAGE4 = `
+var EXIT_ERROR5 = 2;
+var USAGE5 = `
 piwi gate \u2014 fail a CI job on the dashboard's analysis of a run
 
 Usage:
@@ -2453,9 +3464,9 @@ function readCount(argv, name) {
   if (!Number.isFinite(n) || n < 0) throw new Error(`${name} expects a non-negative number, got "${raw}"`);
   return Math.floor(n);
 }
-function readRunIdFromFile(path16) {
+function readRunIdFromFile(path19) {
   try {
-    const parsed = JSON.parse(fs5.readFileSync(path16, "utf-8"));
+    const parsed = JSON.parse(fs9.readFileSync(path19, "utf-8"));
     const runId = Number(parsed.runId);
     return Number.isFinite(runId) && runId > 0 ? runId : null;
   } catch {
@@ -2510,7 +3521,7 @@ async function requestGate(args) {
 }
 async function runGate(argv, env = process.env) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE4);
+    console.log(USAGE5);
     return EXIT_OK4;
   }
   let args;
@@ -2519,15 +3530,15 @@ async function runGate(argv, env = process.env) {
   } catch (e) {
     console.error(`piwi gate: ${e.message}
 `);
-    console.error(USAGE4);
-    return EXIT_ERROR4;
+    console.error(USAGE5);
+    return EXIT_ERROR5;
   }
   let result;
   try {
     result = await requestGate(args);
   } catch (e) {
     console.error(`piwi gate: ${e.message}`);
-    return EXIT_ERROR4;
+    return EXIT_ERROR5;
   }
   if (argv.includes("--json")) {
     console.log(JSON.stringify(result, null, 2));
@@ -2538,9 +3549,9 @@ async function runGate(argv, env = process.env) {
 }
 
 // src/cli/init.ts
-var fs8 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
-var import_node_child_process3 = require("child_process");
+var fs12 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
+var import_node_child_process5 = require("child_process");
 
 // src/cli/report.ts
 var STATUS_MARK = {
@@ -2557,8 +3568,8 @@ function formatStep(result) {
 }
 
 // src/cli/detect.ts
-var fs6 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var CONFIG_NAMES = [
   "playwright.config.ts",
   "playwright.config.mts",
@@ -2576,9 +3587,9 @@ var LOCKFILES = [
 ];
 var REPORTER_PACKAGE = "@piwitests/reporter";
 function readPackageJson(root) {
-  const pkgPath = path8.join(root, "package.json");
+  const pkgPath = path12.join(root, "package.json");
   try {
-    return { pkg: JSON.parse(fs6.readFileSync(pkgPath, "utf-8")), pkgPath };
+    return { pkg: JSON.parse(fs10.readFileSync(pkgPath, "utf-8")), pkgPath };
   } catch {
     return { pkg: null, pkgPath: null };
   }
@@ -2587,14 +3598,14 @@ function detectPackageManager(root, pkg) {
   const declared = pkg?.packageManager?.split("@")[0];
   if (declared === "pnpm" || declared === "yarn" || declared === "bun" || declared === "npm") return declared;
   for (const [file, manager] of LOCKFILES) {
-    if (fs6.existsSync(path8.join(root, file))) return manager;
+    if (fs10.existsSync(path12.join(root, file))) return manager;
   }
   return "npm";
 }
 function findConfig(root) {
   for (const name of CONFIG_NAMES) {
-    const candidate = path8.join(root, name);
-    if (fs6.existsSync(candidate)) return candidate;
+    const candidate = path12.join(root, name);
+    if (fs10.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -2604,14 +3615,14 @@ function langOf(configPath) {
 }
 function suggestProjectName(root, pkg) {
   const fromPkg = pkg?.name?.replace(/^@[^/]+\//, "").trim();
-  return fromPkg || path8.basename(root) || "default-project";
+  return fromPkg || path12.basename(root) || "default-project";
 }
 function hasReporter(pkg) {
   if (!pkg) return false;
   return Boolean(pkg.dependencies?.[REPORTER_PACKAGE] || pkg.devDependencies?.[REPORTER_PACKAGE]);
 }
 function detectProject(root) {
-  const absRoot = path8.resolve(root);
+  const absRoot = path12.resolve(root);
   const { pkg, pkgPath } = readPackageJson(absRoot);
   const configPath = findConfig(absRoot);
   return {
@@ -2753,8 +3764,8 @@ function ensureGitignoreEntry(existing, entry = ".env") {
 }
 
 // src/cli/skills.ts
-var fs7 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var SETUP_SKILL = "setup-piwi";
 var WORKFLOW_SKILLS = [
   "investigate-failure",
@@ -2765,16 +3776,16 @@ var WORKFLOW_SKILLS = [
   "fix-a-reported-bug"
 ];
 var ALL_SKILLS = [SETUP_SKILL, ...WORKFLOW_SKILLS];
-var DEFAULT_SKILLS_DIR = path9.join(".claude", "skills");
+var DEFAULT_SKILLS_DIR = path13.join(".claude", "skills");
 function findTemplatesDir(fromDir) {
   let dir = fromDir;
   for (let i = 0; i < 6; i++) {
-    if (fs7.existsSync(path9.join(dir, "templates", "skills"))) return path9.join(dir, "templates");
-    const parent = path9.dirname(dir);
+    if (fs11.existsSync(path13.join(dir, "templates", "skills"))) return path13.join(dir, "templates");
+    const parent = path13.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path9.resolve(fromDir, "..", "..", "templates");
+  return path13.resolve(fromDir, "..", "..", "templates");
 }
 function readFrontMatter(markdown) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
@@ -2787,14 +3798,14 @@ function readFrontMatter(markdown) {
   return out;
 }
 function templatePath(templatesDir, slug) {
-  return path9.join(templatesDir, "skills", slug, "SKILL.md");
+  return path13.join(templatesDir, "skills", slug, "SKILL.md");
 }
 function listSkills(templatesDir, slugs = ALL_SKILLS) {
   const infos = [];
   for (const slug of slugs) {
     const file = templatePath(templatesDir, slug);
-    if (!fs7.existsSync(file)) continue;
-    const front = readFrontMatter(fs7.readFileSync(file, "utf-8"));
+    if (!fs11.existsSync(file)) continue;
+    const front = readFrontMatter(fs11.readFileSync(file, "utf-8"));
     infos.push({ slug, name: front.name ?? slug, description: front.description ?? "" });
   }
   return infos;
@@ -2804,16 +3815,16 @@ function installSkills(opts) {
   for (const slug of opts.slugs) {
     const step = `skill:${slug}`;
     const source = templatePath(opts.templatesDir, slug);
-    const relDest = path9.join(opts.skillsDir, slug, "SKILL.md");
-    const dest = path9.join(opts.root, relDest);
-    if (!fs7.existsSync(source)) {
+    const relDest = path13.join(opts.skillsDir, slug, "SKILL.md");
+    const dest = path13.join(opts.root, relDest);
+    if (!fs11.existsSync(source)) {
       results.push({ step, status: "error", detail: `no template found for "${slug}"` });
       continue;
     }
-    const contents = fs7.readFileSync(source, "utf-8");
-    const exists = fs7.existsSync(dest);
+    const contents = fs11.readFileSync(source, "utf-8");
+    const exists = fs11.existsSync(dest);
     if (exists && !opts.force) {
-      const identical = fs7.readFileSync(dest, "utf-8") === contents;
+      const identical = fs11.readFileSync(dest, "utf-8") === contents;
       results.push({
         step,
         file: relDest,
@@ -2823,14 +3834,14 @@ function installSkills(opts) {
       continue;
     }
     if (!opts.dryRun) {
-      fs7.mkdirSync(path9.dirname(dest), { recursive: true });
-      fs7.writeFileSync(dest, contents);
+      fs11.mkdirSync(path13.dirname(dest), { recursive: true });
+      fs11.writeFileSync(dest, contents);
     }
     results.push({ step, file: relDest, status: exists ? "updated" : "created", detail: "installed skill" });
   }
   return results;
 }
-var USAGE5 = `
+var USAGE6 = `
 piwi skills \u2014 install the Piwi agent skills into this project
 
 Usage:
@@ -2869,7 +3880,7 @@ function positionalSlugs(argv) {
 function runSkills(argv, templatesDir, cwd = process.cwd()) {
   const [sub, ...rest] = argv;
   if (sub === void 0 || sub === "-h" || sub === "--help") {
-    console.log(USAGE5);
+    console.log(USAGE6);
     return 0;
   }
   if (sub === "list") {
@@ -2890,12 +3901,12 @@ function runSkills(argv, templatesDir, cwd = process.cwd()) {
     if (unknown.length) {
       console.error(`piwi skills: unknown skill(s): ${unknown.join(", ")}
 `);
-      console.error(USAGE5);
+      console.error(USAGE6);
       return 2;
     }
     const results = installSkills({
       templatesDir,
-      root: path9.resolve(readOption5(rest, "--cwd") ?? cwd),
+      root: path13.resolve(readOption5(rest, "--cwd") ?? cwd),
       skillsDir: readOption5(rest, "--dir") ?? DEFAULT_SKILLS_DIR,
       slugs: requested.length ? requested : ALL_SKILLS,
       force: rest.includes("--force"),
@@ -2911,13 +3922,13 @@ function runSkills(argv, templatesDir, cwd = process.cwd()) {
   }
   console.error(`piwi skills: unknown command "${sub}"
 `);
-  console.error(USAGE5);
+  console.error(USAGE6);
   return 2;
 }
 
 // src/cli/init.ts
 var DEFAULT_SERVER_URL = "http://localhost:3000";
-var USAGE6 = `
+var USAGE7 = `
 piwi init \u2014 wire a Playwright project up to a Piwi Dashboard
 
 Usage:
@@ -2966,7 +3977,7 @@ function resolveSkillSlugs(raw) {
   return raw.split(",").map((slug) => slug.trim()).filter(Boolean);
 }
 function parseInitArgs(argv, env, cwd) {
-  const root = path10.resolve(readOption6(argv, "--cwd") ?? cwd);
+  const root = path14.resolve(readOption6(argv, "--cwd") ?? cwd);
   const detected = detectProject(root);
   return {
     root,
@@ -2985,7 +3996,7 @@ function parseInitArgs(argv, env, cwd) {
 }
 function readFileOr(file, fallback) {
   try {
-    return fs8.readFileSync(file, "utf-8");
+    return fs12.readFileSync(file, "utf-8");
   } catch {
     return fallback;
   }
@@ -3015,7 +4026,7 @@ function stepInstallReporter(project, opts) {
   if (opts.dryRun || !opts.install)
     return { step, status: "manual", detail: `Run \`${installCommand(project.packageManager)}\`` };
   const [command, args] = installArgv(project.packageManager);
-  const result = (0, import_node_child_process3.spawnSync)(command, args, { cwd: opts.root, stdio: "inherit" });
+  const result = (0, import_node_child_process5.spawnSync)(command, args, { cwd: opts.root, stdio: "inherit" });
   if (result.status === 0) return { step, status: "updated", detail: `Installed ${REPORTER_PACKAGE}` };
   return {
     step,
@@ -3031,19 +4042,19 @@ function stepConfig(project, opts) {
       status: "manual",
       detail: "No playwright.config found \u2014 create one, then re-run `npx @piwitests/reporter init`"
     };
-  const rel = path10.relative(project.root, project.configPath) || path10.basename(project.configPath);
+  const rel = path14.relative(project.root, project.configPath) || path14.basename(project.configPath);
   const edit = wrapPlaywrightConfig(readFileOr(project.configPath, ""), {
     serverUrl: opts.serverUrl,
     projectName: opts.projectName
   });
-  if (edit.status === "updated" && !opts.dryRun) fs8.writeFileSync(project.configPath, edit.text);
+  if (edit.status === "updated" && !opts.dryRun) fs12.writeFileSync(project.configPath, edit.text);
   return { step, file: rel, status: edit.status, detail: edit.detail };
 }
 function stepFixtures(project, opts) {
   const step = "fixtures";
-  const rel = path10.join("tests", project.configLang === "js" ? "fixtures.js" : "fixtures.ts");
-  const dest = path10.join(project.root, rel);
-  if (fs8.existsSync(dest)) {
+  const rel = path14.join("tests", project.configLang === "js" ? "fixtures.js" : "fixtures.ts");
+  const dest = path14.join(project.root, rel);
+  if (fs12.existsSync(dest)) {
     const current = readFileOr(dest, "");
     if (/piwiFixtures/.test(current))
       return { step, file: rel, status: "already", detail: "capture fixtures already set up" };
@@ -3055,8 +4066,8 @@ function stepFixtures(project, opts) {
     };
   }
   if (!opts.dryRun) {
-    fs8.mkdirSync(path10.dirname(dest), { recursive: true });
-    fs8.writeFileSync(dest, fixturesContents());
+    fs12.mkdirSync(path14.dirname(dest), { recursive: true });
+    fs12.writeFileSync(dest, fixturesContents());
   }
   return {
     step,
@@ -3067,12 +4078,12 @@ function stepFixtures(project, opts) {
 }
 function stepEnv(project, opts) {
   const results = [];
-  const examplePath = path10.join(project.root, ".env.example");
+  const examplePath = path14.join(project.root, ".env.example");
   const example = upsertEnvKeys(readFileOr(examplePath, ""), [
     ["PIWI_DASHBOARD_URL", opts.serverUrl],
     ["PIWI_API_KEY", ""]
   ]);
-  if (example.added.length && !opts.dryRun) fs8.writeFileSync(examplePath, example.text);
+  if (example.added.length && !opts.dryRun) fs12.writeFileSync(examplePath, example.text);
   results.push({
     step: "env",
     file: ".env.example",
@@ -3080,21 +4091,21 @@ function stepEnv(project, opts) {
     detail: example.added.length ? `Recorded ${example.added.join(", ")}` : "connection template already present"
   });
   if (opts.apiKey) {
-    const envPath = path10.join(project.root, ".env");
+    const envPath = path14.join(project.root, ".env");
     const env = upsertEnvKeys(readFileOr(envPath, ""), [
       ["PIWI_DASHBOARD_URL", opts.serverUrl],
       ["PIWI_API_KEY", opts.apiKey]
     ]);
-    if (env.added.length && !opts.dryRun) fs8.writeFileSync(envPath, env.text);
+    if (env.added.length && !opts.dryRun) fs12.writeFileSync(envPath, env.text);
     results.push({
       step: "env",
       file: ".env",
       status: env.added.length ? "updated" : "already",
       detail: env.added.length ? `Wrote ${env.added.join(", ")} (keep .env out of git)` : "already set"
     });
-    const gitignorePath = path10.join(project.root, ".gitignore");
+    const gitignorePath = path14.join(project.root, ".gitignore");
     const gitignore = ensureGitignoreEntry(readFileOr(gitignorePath, ""));
-    if (gitignore.added && !opts.dryRun) fs8.writeFileSync(gitignorePath, gitignore.text);
+    if (gitignore.added && !opts.dryRun) fs12.writeFileSync(gitignorePath, gitignore.text);
     results.push({
       step: "gitignore",
       file: ".gitignore",
@@ -3108,7 +4119,7 @@ function nextSteps(opts, steps) {
   const out = [];
   if (!opts.apiKey) {
     out.push(
-      "If your dashboard has authentication on, create an API key (Settings \u2192 Users \u2192 API keys), put it in .env as PIWI_API_KEY, and keep .env out of git."
+      "If your dashboard has authentication on, create an API key (Settings \u2192 Account \u2192 API keys), put it in .env as PIWI_API_KEY, and keep .env out of git."
     );
   }
   if (steps.some((s) => s.status === "manual")) {
@@ -3123,7 +4134,7 @@ function nextSteps(opts, steps) {
 }
 async function runInit(argv, env = process.env, cwd = process.cwd()) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE6);
+    console.log(USAGE7);
     return 0;
   }
   const opts = parseInitArgs(argv, env, cwd);
@@ -3156,7 +4167,7 @@ async function runInit(argv, env = process.env, cwd = process.cwd()) {
           project: {
             root: project.root,
             packageManager: project.packageManager,
-            configPath: project.configPath ? path10.relative(project.root, project.configPath) : null,
+            configPath: project.configPath ? path14.relative(project.root, project.configPath) : null,
             projectName: opts.projectName,
             serverUrl: opts.serverUrl
           },
@@ -3180,15 +4191,15 @@ Piwi setup${opts.dryRun ? " (dry run \u2014 nothing written)" : ""} for "${opts.
 }
 
 // src/cli/select.ts
-var fs10 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
-var import_node_child_process4 = require("child_process");
-var import_node_module3 = require("module");
+var fs14 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
+var import_node_child_process6 = require("child_process");
+var import_node_module4 = require("module");
 
 // src/cli/add-reporter.ts
-var fs9 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
-var import_node_module2 = require("module");
+var fs13 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var import_node_module3 = require("module");
 var REPORTER_PACKAGE2 = "@piwitests/reporter";
 var ADD_REPORTER_FLAG = "--add-reporter";
 var ADD_REPORTER_MIN = { major: 1, minor: 63 };
@@ -3215,14 +4226,14 @@ function decideAddReporter(configSource, playwrightVersion) {
     log: `piwi run: the Playwright config has no Piwi reporter and Playwright ${playwrightVersion ?? "unknown"} predates ${ADD_REPORTER_FLAG} (1.63) \u2014 results will not reach the dashboard`
   };
 }
-function resolveConfigPath(cwd, playwrightArgs) {
-  for (let i = 0; i < playwrightArgs.length; i++) {
-    const arg = playwrightArgs[i];
+function resolveConfigPath(cwd, playwrightArgs2) {
+  for (let i = 0; i < playwrightArgs2.length; i++) {
+    const arg = playwrightArgs2[i];
     if (arg === "--config" || arg === "-c") {
-      const next = playwrightArgs[i + 1];
-      if (next) return path11.resolve(cwd, next);
+      const next = playwrightArgs2[i + 1];
+      if (next) return path15.resolve(cwd, next);
     } else if (arg.startsWith("--config=")) {
-      return path11.resolve(cwd, arg.slice("--config=".length));
+      return path15.resolve(cwd, arg.slice("--config=".length));
     }
   }
   return detectProject(cwd).configPath;
@@ -3230,14 +4241,14 @@ function resolveConfigPath(cwd, playwrightArgs) {
 function readConfigSource(configPath) {
   if (!configPath) return null;
   try {
-    return fs9.readFileSync(configPath, "utf-8");
+    return fs13.readFileSync(configPath, "utf-8");
   } catch {
     return null;
   }
 }
 function readInstalledPlaywrightVersion(cwd) {
   try {
-    const require2 = (0, import_node_module2.createRequire)(path11.join(cwd, "noop.js"));
+    const require2 = (0, import_node_module3.createRequire)(path15.join(cwd, "noop.js"));
     for (const id of ["@playwright/test/package.json", "playwright/package.json"]) {
       try {
         return require2(id).version ?? null;
@@ -3248,15 +4259,15 @@ function readInstalledPlaywrightVersion(cwd) {
   }
   return null;
 }
-function computeAddReporterArgs(cwd, playwrightArgs) {
-  const source = readConfigSource(resolveConfigPath(cwd, playwrightArgs));
+function computeAddReporterArgs(cwd, playwrightArgs2) {
+  const source = readConfigSource(resolveConfigPath(cwd, playwrightArgs2));
   return decideAddReporter(source, readInstalledPlaywrightVersion(cwd));
 }
 
 // src/cli/select.ts
 var EXIT_OK5 = 0;
-var EXIT_ERROR5 = 2;
-var USAGE7 = `
+var EXIT_ERROR6 = 2;
+var USAGE8 = `
 piwi select / piwi run \u2014 run a saved selection of tests
 
 Usage:
@@ -3314,7 +4325,7 @@ function findKey(argv) {
   }
   return void 0;
 }
-function parseDuration(raw) {
+function parseDuration2(raw) {
   const match = raw.trim().match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
   if (!match) return null;
   const value = Number(match[1]);
@@ -3334,7 +4345,7 @@ function parseSelectArgs(argv, env) {
   const budgetRaw = readOption7(own, "--budget");
   let budgetMs = null;
   if (budgetRaw !== void 0) {
-    budgetMs = parseDuration(budgetRaw);
+    budgetMs = parseDuration2(budgetRaw);
     if (budgetMs === null) throw new Error(`--budget expects a duration like 5m or 90s, got "${budgetRaw}"`);
   }
   const shard = readOption7(own, "--shard") ?? null;
@@ -3357,51 +4368,52 @@ function parseSelectArgs(argv, env) {
     extra
   };
 }
-var CACHE_FILE = path12.join(".piwi", "selection-cache.json");
-function cacheKey(projectId, args) {
-  return `${projectId}:${args.key}:${args.format}:${args.budgetMs ?? 0}:${args.shard ?? ""}:${args.order ?? ""}`;
+var CACHE_FILE = path16.join(".piwi", "selection-cache.json");
+function cacheKey(args) {
+  return `${args.project.toLowerCase()}:${args.key}:${args.format}:${args.budgetMs ?? 0}:${args.shard ?? ""}:${args.order ?? ""}`;
 }
-function readCache(projectId, args) {
+function readCache(args) {
   try {
-    const store = JSON.parse(fs10.readFileSync(CACHE_FILE, "utf-8"));
-    return store[cacheKey(projectId, args)] ?? null;
+    const store = JSON.parse(fs14.readFileSync(CACHE_FILE, "utf-8"));
+    return store[cacheKey(args)] ?? null;
   } catch {
     return null;
   }
 }
-function writeCache(projectId, args, resolution) {
+function writeCache(args, resolution) {
   try {
     let store = {};
     try {
-      store = JSON.parse(fs10.readFileSync(CACHE_FILE, "utf-8"));
+      store = JSON.parse(fs14.readFileSync(CACHE_FILE, "utf-8"));
     } catch {
     }
-    store[cacheKey(projectId, args)] = resolution;
-    fs10.mkdirSync(path12.dirname(CACHE_FILE), { recursive: true });
-    fs10.writeFileSync(CACHE_FILE, JSON.stringify(store, null, 2));
+    store[cacheKey(args)] = resolution;
+    fs14.mkdirSync(path16.dirname(CACHE_FILE), { recursive: true });
+    fs14.writeFileSync(CACHE_FILE, JSON.stringify(store, null, 2));
   } catch {
   }
 }
-async function resolveWithCache(args, projectId) {
+async function resolveWithCache(args) {
   try {
+    const projectId = await resolveProjectId(args);
     const resolution = await fetchResolution(args, projectId);
-    writeCache(projectId, args, resolution);
+    writeCache(args, resolution);
     return { resolution, fromCache: false };
   } catch (e) {
     if (args.strict) throw e;
-    const cached = readCache(projectId, args);
+    const cached = readCache(args);
     if (cached) {
       console.error(`piwi: dashboard unreachable, using cached resolution \u2014 ${e.message}`);
       return { resolution: cached, fromCache: true };
     }
-    return null;
+    return { error: e };
   }
 }
 function printWarnings(resolution) {
   for (const w of resolution.warnings) console.error(`piwi: warning [${w.code}] ${w.message}`);
 }
 function gitChangedFiles(base) {
-  const out = (0, import_node_child_process4.execFileSync)("git", ["diff", "--name-only", base], {
+  const out = (0, import_node_child_process6.execFileSync)("git", ["diff", "--name-only", base], {
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "ignore"]
   });
@@ -3422,7 +4434,7 @@ async function runSelectImpact(args) {
     impact = await loadImpact(args, projectId);
   } catch (e) {
     console.error(`piwi select: ${e.message}`);
-    return EXIT_ERROR5;
+    return EXIT_ERROR6;
   }
   printWarnings(impact);
   console.error(
@@ -3437,7 +4449,7 @@ async function runSelectImpact(args) {
 }
 async function runSelect(argv, env = process.env) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE7);
+    console.log(USAGE8);
     return EXIT_OK5;
   }
   let args;
@@ -3446,13 +4458,13 @@ async function runSelect(argv, env = process.env) {
   } catch (e) {
     console.error(`piwi select: ${e.message}
 `);
-    console.error(USAGE7);
-    return EXIT_ERROR5;
+    console.error(USAGE8);
+    return EXIT_ERROR6;
   }
   if (args.key === IMPACT_KEY) {
     if (!args.base) {
       console.error("piwi select: impact needs a base ref \u2014 pass --base <ref> (e.g. --base origin/main)");
-      return EXIT_ERROR5;
+      return EXIT_ERROR6;
     }
     return runSelectImpact(args);
   }
@@ -3462,19 +4474,19 @@ async function runSelect(argv, env = process.env) {
     resolution = await fetchResolution(args, projectId);
   } catch (e) {
     console.error(`piwi select: ${e.message}`);
-    return EXIT_ERROR5;
+    return EXIT_ERROR6;
   }
   printWarnings(resolution);
   if (resolution.estimate.count === 0) {
     console.error(`piwi select: "${args.key}" resolved to 0 tests`);
-    return EXIT_ERROR5;
+    return EXIT_ERROR6;
   }
   if (args.json) console.log(JSON.stringify(resolution, null, 2));
   else console.log(resolution.materialization.args.join(" "));
   return EXIT_OK5;
 }
-function resolvePlaywrightCli2() {
-  const require2 = (0, import_node_module3.createRequire)(path12.join(process.cwd(), "noop.js"));
+function resolvePlaywrightCli3() {
+  const require2 = (0, import_node_module4.createRequire)(path16.join(process.cwd(), "noop.js"));
   for (const id of ["playwright/cli", "@playwright/test/cli", "playwright/lib/cli/cli"]) {
     try {
       return require2.resolve(id);
@@ -3483,24 +4495,27 @@ function resolvePlaywrightCli2() {
   }
   return null;
 }
-function spawnPlaywright(pkgRunner, playwrightArgs, env) {
-  const cli = resolvePlaywrightCli2();
-  const child = cli ? (0, import_node_child_process4.spawn)(process.execPath, [cli, "test", ...playwrightArgs], { stdio: "inherit", env }) : (0, import_node_child_process4.spawn)(process.platform === "win32" ? `${pkgRunner}.cmd` : pkgRunner, ["playwright", "test", ...playwrightArgs], {
+function spawnPlaywright2(pkgRunner, playwrightArgs2, env) {
+  const cli = resolvePlaywrightCli3();
+  const child = cli ? (0, import_node_child_process6.spawn)(process.execPath, [cli, "test", ...playwrightArgs2], { stdio: "inherit", env }) : (0, import_node_child_process6.spawn)(process.platform === "win32" ? `${pkgRunner}.cmd` : pkgRunner, ["playwright", "test", ...playwrightArgs2], {
     stdio: "inherit",
     env
   });
   return new Promise((resolve8) => {
     child.on("error", (err) => {
       console.error(`piwi run: could not start Playwright \u2014 ${err.message}`);
-      resolve8(EXIT_ERROR5);
+      resolve8(EXIT_ERROR6);
     });
-    child.on("exit", (code) => resolve8(code ?? EXIT_ERROR5));
+    child.on("exit", (code) => resolve8(code ?? EXIT_ERROR6));
   });
 }
-function spawnPlaywrightForRun(pkgRunner, playwrightArgs, env) {
-  const decision = computeAddReporterArgs(process.cwd(), playwrightArgs);
+function spawnPlaywrightForRun(pkgRunner, playwrightArgs2, env) {
+  const decision = computeAddReporterArgs(process.cwd(), playwrightArgs2);
   if (decision.log) console.error(decision.log);
-  return spawnPlaywright(pkgRunner, [...decision.args, ...playwrightArgs], env);
+  return spawnPlaywright2(pkgRunner, [...decision.args, ...playwrightArgs2], env);
+}
+function shardEnv(args) {
+  return args.shard ? { [PIWI_SHARD_ENV]: args.shard } : {};
 }
 async function runRunImpact(args, env) {
   let projectId;
@@ -3509,7 +4524,7 @@ async function runRunImpact(args, env) {
   } catch (e) {
     if (args.strict) {
       console.error(`piwi run: ${e.message}`);
-      return EXIT_ERROR5;
+      return EXIT_ERROR6;
     }
     console.error(`piwi run: ${e.message} \u2014 running the full suite`);
     return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
@@ -3520,7 +4535,7 @@ async function runRunImpact(args, env) {
   } catch (e) {
     if (args.strict) {
       console.error(`piwi run: ${e.message}`);
-      return EXIT_ERROR5;
+      return EXIT_ERROR6;
     }
     console.error(`piwi run: ${e.message} \u2014 running the full suite`);
     return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
@@ -3541,14 +4556,15 @@ async function runRunImpact(args, env) {
     PIWI_SELECTION: IMPACT_KEY,
     PIWI_SELECTION_VERSION: "0",
     PIWI_SELECTION_HASH: impact.resolvedHash,
-    PIWI_SELECTION_COUNT: String(impact.estimate.count)
+    PIWI_SELECTION_COUNT: String(impact.estimate.count),
+    ...shardEnv(args)
   };
   console.error(`piwi run: impact \u2192 ${impact.estimate.count} test(s)`);
   return spawnPlaywrightForRun(args.pkgRunner, [...impact.materialization.args, ...args.extra], runEnv);
 }
 async function runRun(argv, env = process.env) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE7);
+    console.log(USAGE8);
     return EXIT_OK5;
   }
   let args;
@@ -3557,54 +4573,44 @@ async function runRun(argv, env = process.env) {
   } catch (e) {
     console.error(`piwi run: ${e.message}
 `);
-    console.error(USAGE7);
-    return EXIT_ERROR5;
+    console.error(USAGE8);
+    return EXIT_ERROR6;
   }
   if (args.format === "json") {
     console.error("piwi run: --format json cannot be run; use args, grep or files");
-    return EXIT_ERROR5;
+    return EXIT_ERROR6;
   }
   if (args.key === IMPACT_KEY) {
     if (!args.base) {
       console.error("piwi run: impact needs a base ref \u2014 pass --base <ref> (e.g. --base origin/main)");
-      return EXIT_ERROR5;
+      return EXIT_ERROR6;
     }
     return runRunImpact(args, env);
   }
-  let projectId;
-  try {
-    projectId = await resolveProjectId(args);
-  } catch (e) {
-    if (args.strict) {
-      console.error(`piwi run: ${e.message}`);
-      return EXIT_ERROR5;
-    }
-    console.error(`piwi run: ${e.message} \u2014 running the full suite`);
-    return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
-  }
   let outcome;
   try {
-    outcome = await resolveWithCache(args, projectId);
+    outcome = await resolveWithCache(args);
   } catch (e) {
     console.error(`piwi run: ${e.message}`);
-    return EXIT_ERROR5;
+    return EXIT_ERROR6;
   }
-  if (!outcome) {
-    console.error("piwi run: dashboard unreachable and no cached resolution \u2014 running the full suite");
+  if ("error" in outcome) {
+    console.error(`piwi run: ${outcome.error.message} \u2014 no cached resolution, running the full suite`);
     return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
   }
   const { resolution } = outcome;
   printWarnings(resolution);
   if (resolution.estimate.count === 0) {
     console.error(`piwi run: "${args.key}" resolved to 0 tests`);
-    return EXIT_ERROR5;
+    return EXIT_ERROR6;
   }
   const runEnv = {
     ...env,
     PIWI_SELECTION: resolution.key ?? args.key,
     PIWI_SELECTION_VERSION: String(resolution.version ?? 0),
     PIWI_SELECTION_HASH: resolution.resolvedHash,
-    PIWI_SELECTION_COUNT: String(resolution.estimate.count)
+    PIWI_SELECTION_COUNT: String(resolution.estimate.count),
+    ...shardEnv(args)
   };
   console.error(
     `piwi run: ${args.key} \u2192 ${resolution.estimate.count} tests${resolution.materialization.format !== args.format ? ` (materialized as ${resolution.materialization.format})` : ""}`
@@ -3613,16 +4619,16 @@ async function runRun(argv, env = process.env) {
 }
 
 // src/cli/preflight.ts
-var fs12 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
-var import_node_child_process5 = require("child_process");
+var fs15 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
+var import_node_child_process7 = require("child_process");
 
 // ../core/src/diff-anchors.ts
 var RENAME_FROM = `rename from `;
 var RENAME_TO = "rename to ";
 var HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
-function stripPrefix(path16) {
-  const unquoted = path16.startsWith('"') && path16.endsWith('"') ? path16.slice(1, -1) : path16;
+function stripPrefix(path19) {
+  const unquoted = path19.startsWith('"') && path19.endsWith('"') ? path19.slice(1, -1) : path19;
   return unquoted.replace(/^[ab]\//, "");
 }
 function parseUnifiedDiff(text) {
@@ -3690,10 +4696,7 @@ function parseUnifiedDiff(text) {
   }
   return files.filter((f) => f.path);
 }
-var DEFAULT_TRANSLATION_GLOBS = [
-  "**/{locales,locale,i18n,lang,translations}/**",
-  "**/*.resx"
-];
+var DEFAULT_TRANSLATION_GLOBS = ["**/{locales,locale,i18n,lang,translations}/**", "**/*.resx"];
 var ANCHOR_ATTRIBUTES = [
   "id",
   "name",
@@ -3735,8 +4738,8 @@ function pathGlobToRegExp(glob) {
   });
   return new RegExp(`^(?:${parts.join("|")})$`);
 }
-function isTranslationFile(path16, globs = DEFAULT_TRANSLATION_GLOBS) {
-  const posix = path16.replace(/\\/g, "/");
+function isTranslationFile(path19, globs = DEFAULT_TRANSLATION_GLOBS) {
+  const posix = path19.replace(/\\/g, "/");
   if (!TRANSLATION_EXTENSIONS.test(posix)) return false;
   return globs.some((g) => pathGlobToRegExp(g).test(posix));
 }
@@ -3876,13 +4879,13 @@ function unquoteYaml(raw) {
 function decodeXml(text) {
   return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 }
-function parseTranslationFile(path16, content) {
+function parseTranslationFile(path19, content) {
   const lines = content.split(/\r?\n/);
   const out = [];
-  const ext = /\.([a-z]+)$/i.exec(path16)?.[1]?.toLowerCase();
+  const ext = /\.([a-z]+)$/i.exec(path19)?.[1]?.toLowerCase();
   if (ext === "json") {
     const stack = [];
-    const path17 = (key) => [...stack.map((f) => f.key), key].join(".");
+    const path20 = (key) => [...stack.map((f) => f.key), key].join(".");
     lines.forEach((text, i) => {
       const t = text.trim();
       const top = stack[stack.length - 1];
@@ -3891,14 +4894,14 @@ function parseTranslationFile(path16, content) {
         const key = JSON.parse(`"${pair[1]}"`);
         const rest = pair[2];
         const str = /^"((?:[^"\\]|\\.)*)"/.exec(rest);
-        if (str) out.push({ key: path17(key), value: JSON.parse(`"${str[1]}"`), line: i + 1 });
+        if (str) out.push({ key: path20(key), value: JSON.parse(`"${str[1]}"`), line: i + 1 });
         else if (/^[[{]\s*$/.test(rest)) stack.push({ key, array: rest.startsWith("["), next: 0 });
         return;
       }
       if (top?.array) {
         const str = /^"((?:[^"\\]|\\.)*)"\s*,?$/.exec(t);
         if (str) {
-          out.push({ key: path17(top.next++), value: JSON.parse(`"${str[1]}"`), line: i + 1 });
+          out.push({ key: path20(top.next++), value: JSON.parse(`"${str[1]}"`), line: i + 1 });
           return;
         }
         if (/^[[{]\s*$/.test(t)) {
@@ -3962,8 +4965,8 @@ function parseTranslationFile(path16, content) {
   }
   return out;
 }
-function translationLineToken(path16, text, line) {
-  const ext = /\.([a-z]+)$/i.exec(path16)?.[1]?.toLowerCase();
+function translationLineToken(path19, text, line) {
+  const ext = /\.([a-z]+)$/i.exec(path19)?.[1]?.toLowerCase();
   let key;
   let value;
   if (ext === "json") {
@@ -4000,9 +5003,9 @@ function translationLineToken(path16, text, line) {
   if (value === void 0 || !keepable(value)) return null;
   return { kind: "translation", group: `translation:${key ?? ""}`, value, key, line };
 }
-function lineTokens(path16, text, line, side, attributes, options) {
+function lineTokens(path19, text, line, side, attributes, options) {
   const spans = [];
-  const markup = MARKUP_FILE.test(path16);
+  const markup = MARKUP_FILE.test(path19);
   return [
     ...attributeTokens(text, attributes, line, spans),
     ...translationRefTokens(text, line, side, options.translations, spans),
@@ -4010,10 +5013,10 @@ function lineTokens(path16, text, line, side, attributes, options) {
     ...textTokens(text, line, markup)
   ];
 }
-function keysByLine(path16, side, options) {
-  const content = options.readFile?.(path16, side);
+function keysByLine(path19, side, options) {
+  const content = options.readFile?.(path19, side);
   if (content === void 0) return null;
-  return new Map(parseTranslationFile(path16, content).map((e) => [e.line, e.key]));
+  return new Map(parseTranslationFile(path19, content).map((e) => [e.line, e.key]));
 }
 function tokenId(t) {
   return `${t.group}\0${t.value}`;
@@ -4088,40 +5091,6 @@ function extractDiffAnchors(files, options = {}) {
   return anchors;
 }
 
-// ../core/src/dotenv.ts
-function parseDotEnv(text) {
-  const out = {};
-  for (const raw of text.split(/\r?\n/)) {
-    const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/.exec(raw);
-    if (!m) continue;
-    let value = m[2];
-    const quote4 = value[0];
-    if ((quote4 === '"' || quote4 === "'") && value.length > 1 && value.endsWith(quote4)) {
-      value = value.slice(1, -1);
-      if (quote4 === '"') value = value.replace(/\\n/g, "\n").replace(/\\"/g, '"');
-    } else {
-      value = value.replace(/\s+#.*$/, "");
-    }
-    out[m[1]] = value;
-  }
-  return out;
-}
-function resolvePiwiConnection(sources) {
-  const own = {
-    serverUrl: sources.flags?.serverUrl || sources.env?.PIWI_DASHBOARD_URL,
-    apiKey: sources.flags?.apiKey || sources.env?.PIWI_API_KEY
-  };
-  const workspace = { serverUrl: sources.dotEnv?.PIWI_DASHBOARD_URL, apiKey: sources.dotEnv?.PIWI_API_KEY };
-  const project = sources.flags?.project || sources.env?.PIWI_PROJECT_NAME || sources.dotEnv?.PIWI_PROJECT_NAME || "";
-  const desktop = sources.desktop ?? null;
-  const trim = (url) => url.replace(/\/+$/, "");
-  const layer = own.serverUrl ? own : workspace.serverUrl ? workspace : null;
-  const serverUrl = layer ? trim(layer.serverUrl) : desktop ? trim(desktop.url) : "";
-  if (!serverUrl) return null;
-  const desktopKey = desktop && trim(desktop.url) === serverUrl ? desktop.token : null;
-  return { serverUrl, apiKey: layer?.apiKey || desktopKey || null, project };
-}
-
 // ../core/src/locator-text-match.ts
 function normalizeWhiteSpace(text) {
   return text.replace(/[​­]/g, "").trim().replace(/\s+/g, " ");
@@ -4477,140 +5446,12 @@ function buildLiteralEdit(sourceLine, oldValue, newValue) {
   return null;
 }
 
-// src/internal/config/desktop.ts
-var fs11 = __toESM(require("fs"));
-var os = __toESM(require("os"));
-var path13 = __toESM(require("path"));
-function defaultDesktopConfigPath() {
-  return path13.join(os.homedir(), ".piwi", "desktop.json");
-}
-function readDesktopConfig(filePath) {
-  try {
-    const parsed = JSON.parse(fs11.readFileSync(filePath, "utf8"));
-    const url = parsed?.url;
-    const token = parsed?.token;
-    if (typeof url !== "string" || !url) return null;
-    if (typeof token !== "string" || !token) return null;
-    return { url, token };
-  } catch {
-    return null;
-  }
-}
-
-// src/internal/config/env.ts
-var DEFAULTS = {
-  projectName: "default-project",
-  uploadTraces: true,
-  uploadReport: true,
-  liveFileUploads: true,
-  collectScmInfo: true,
-  collectCiInfo: true,
-  collectPerformanceMetrics: true,
-  captureLocators: true,
-  capturePageState: true,
-  // Off by default: the page inventory reads control and link names from every
-  // visited page, so it stays opt-in until a project turns it on.
-  capturePageInventory: false,
-  // Off by default: JavaScript coverage slows the page, so a scheduled job opts in.
-  captureCodeReach: false,
-  captureServerTraces: true,
-  sampleAriaOnPass: true,
-  uploadManifest: true,
-  defaultCapture: true,
-  streaming: true,
-  streamingBatchSize: 5,
-  streamingBatchDelay: 2e3,
-  maxStreamBufferBytes: 100 * 1024 * 1024,
-  failOnFlakyTests: false,
-  username: null,
-  password: null,
-  apiKey: null,
-  verbose: false
-};
-var PIWI_ENV_KEYS = {
-  serverUrl: "PIWI_DASHBOARD_URL",
-  projectName: "PIWI_PROJECT_NAME",
-  verbose: "PIWI_VERBOSE",
-  apiKey: "PIWI_API_KEY",
-  username: "PIWI_USERNAME",
-  password: "PIWI_PASSWORD",
-  environment: "PIWI_ENVIRONMENT",
-  label: "PIWI_LABEL",
-  runLabel: "PIWI_RUN_LABEL",
-  keep: "PIWI_KEEP",
-  streaming: "PIWI_STREAMING",
-  streamingBatchSize: "PIWI_STREAMING_BATCH_SIZE",
-  streamingBatchDelay: "PIWI_STREAMING_BATCH_DELAY",
-  maxStreamBufferBytes: "PIWI_MAX_STREAM_BUFFER_BYTES",
-  liveFileUploads: "PIWI_LIVE_FILE_UPLOADS",
-  failOnFlakyTests: "PIWI_FAIL_ON_FLAKY_TESTS",
-  uploadTraces: "PIWI_UPLOAD_TRACES",
-  uploadReport: "PIWI_UPLOAD_REPORT",
-  captureLocators: "PIWI_CAPTURE_LOCATORS",
-  capturePageState: "PIWI_CAPTURE_PAGE_STATE",
-  capturePageInventory: "PIWI_CAPTURE_PAGE_INVENTORY",
-  captureCodeReach: "PIWI_CAPTURE_CODE_REACH",
-  codeReachRoots: "PIWI_CODE_REACH_ROOTS",
-  captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
-  sampleAriaOnPass: "PIWI_SAMPLE_ARIA_ON_PASS",
-  uploadManifest: "PIWI_UPLOAD_MANIFEST",
-  defaultCapture: "PIWI_DEFAULT_CAPTURE",
-  inspectOnFailure: "PIWI_INSPECT_ON_FAIL",
-  pickLocatorOnFailure: "PIWI_PICK_LOCATOR_ON_FAIL",
-  outputFile: "PIWI_OUTPUT_FILE",
-  aiMode: "PIWI_AI",
-  aiDir: "PIWI_AI_DIR",
-  aiOnMiss: "PIWI_AI_ON_MISS",
-  aiMaxSteps: "PIWI_AI_MAX_FLOW_STEPS",
-  aiMaxSnapshotChars: "PIWI_AI_MAX_SNAPSHOT_CHARS",
-  aiOptionalProbeTimeout: "PIWI_AI_OPTIONAL_PROBE_TIMEOUT",
-  aiResponseWaitTimeout: "PIWI_AI_RESPONSE_WAIT_TIMEOUT",
-  aiScreenshotFallback: "PIWI_AI_SCREENSHOT_FALLBACK"
-};
-var PIWI_DESKTOP_CONFIG_ENV = "PIWI_DESKTOP_CONFIG";
-var PIWI_PROBE_ENV = {
-  flag: "PIWI_PROBE",
-  plan: "PIWI_PROBE_PLAN",
-  results: "PIWI_PROBE_RESULTS",
-  secret: "PIWI_PROBE_SECRET"
-};
-var ENV_FALLBACK_SPECS = [
-  { option: "serverUrl", env: PIWI_ENV_KEYS.serverUrl, kind: "string" },
-  { option: "projectName", env: PIWI_ENV_KEYS.projectName, kind: "string" },
-  { option: "apiKey", env: PIWI_ENV_KEYS.apiKey, kind: "string" },
-  { option: "username", env: PIWI_ENV_KEYS.username, kind: "string" },
-  { option: "password", env: PIWI_ENV_KEYS.password, kind: "string" },
-  { option: "environment", env: PIWI_ENV_KEYS.environment, kind: "string" },
-  { option: "label", env: PIWI_ENV_KEYS.label, kind: "string" },
-  { option: "runLabel", env: PIWI_ENV_KEYS.runLabel, kind: "string" },
-  { option: "keep", env: PIWI_ENV_KEYS.keep, kind: "bool" },
-  { option: "streaming", env: PIWI_ENV_KEYS.streaming, kind: "bool" },
-  { option: "streamingBatchSize", env: PIWI_ENV_KEYS.streamingBatchSize, kind: "number" },
-  { option: "streamingBatchDelay", env: PIWI_ENV_KEYS.streamingBatchDelay, kind: "number" },
-  { option: "maxStreamBufferBytes", env: PIWI_ENV_KEYS.maxStreamBufferBytes, kind: "number" },
-  { option: "liveFileUploads", env: PIWI_ENV_KEYS.liveFileUploads, kind: "bool" },
-  { option: "failOnFlakyTests", env: PIWI_ENV_KEYS.failOnFlakyTests, kind: "bool" },
-  { option: "uploadTraces", env: PIWI_ENV_KEYS.uploadTraces, kind: "bool" },
-  { option: "uploadReport", env: PIWI_ENV_KEYS.uploadReport, kind: "bool" },
-  { option: "captureLocators", env: PIWI_ENV_KEYS.captureLocators, kind: "bool" },
-  { option: "capturePageState", env: PIWI_ENV_KEYS.capturePageState, kind: "bool" },
-  { option: "capturePageInventory", env: PIWI_ENV_KEYS.capturePageInventory, kind: "bool" },
-  { option: "captureCodeReach", env: PIWI_ENV_KEYS.captureCodeReach, kind: "bool" },
-  { option: "captureServerTraces", env: PIWI_ENV_KEYS.captureServerTraces, kind: "bool" },
-  { option: "sampleAriaOnPass", env: PIWI_ENV_KEYS.sampleAriaOnPass, kind: "bool" },
-  { option: "uploadManifest", env: PIWI_ENV_KEYS.uploadManifest, kind: "bool" },
-  { option: "defaultCapture", env: PIWI_ENV_KEYS.defaultCapture, kind: "bool" },
-  { option: "inspectOnFailure", env: PIWI_ENV_KEYS.inspectOnFailure, kind: "bool" },
-  { option: "pickLocatorOnFailure", env: PIWI_ENV_KEYS.pickLocatorOnFailure, kind: "bool" },
-  { option: "outputFile", env: PIWI_ENV_KEYS.outputFile, kind: "string" }
-];
-
 // src/cli/preflight.ts
 var EXIT_OK6 = 0;
 var EXIT_BREAKS = 1;
-var EXIT_ERROR6 = 2;
+var EXIT_ERROR7 = 2;
 var MAX_LISTED = 20;
-var USAGE8 = `
+var USAGE9 = `
 piwi preflight \u2014 the test locators a change breaks, before it runs
 
 Usage:
@@ -4689,16 +5530,16 @@ function parsePreflightArgs(argv) {
 }
 var CONFIG_NAMES2 = ["playwright.config.ts", "playwright.config.js", "playwright.config.mjs", "playwright.config.cjs"];
 function findPlaywrightRoot(from) {
-  let dir = path14.resolve(from);
+  let dir = path17.resolve(from);
   for (; ; ) {
-    if (CONFIG_NAMES2.some((name) => fs12.existsSync(path14.join(dir, name)))) return dir;
-    const parent = path14.dirname(dir);
+    if (CONFIG_NAMES2.some((name) => fs15.existsSync(path17.join(dir, name)))) return dir;
+    const parent = path17.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function git(cwd, args) {
-  return (0, import_node_child_process5.execFileSync)("git", args, {
+  return (0, import_node_child_process7.execFileSync)("git", args, {
     cwd,
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -4714,19 +5555,7 @@ function tryGit(cwd, args) {
 }
 var TEST_FILE = /(?:^|\/)[^/]+\.(?:spec|test)\.[cm]?[jt]sx?$/;
 function resolveConnection(args, env, dirs) {
-  let dotEnv = {};
-  for (const dir of dirs) {
-    try {
-      dotEnv = { ...parseDotEnv(fs12.readFileSync(path14.join(dir, ".env"), "utf-8")), ...dotEnv };
-    } catch {
-    }
-  }
-  return resolvePiwiConnection({
-    flags: { serverUrl: args.serverUrl, apiKey: args.apiKey, project: args.project },
-    env,
-    dotEnv,
-    desktop: readDesktopConfig(env[PIWI_DESKTOP_CONFIG_ENV] || defaultDesktopConfigPath())
-  });
+  return resolveCliConnection({ serverUrl: args.serverUrl, apiKey: args.apiKey, project: args.project }, env, dirs);
 }
 function translationLookup(repoRoot, base, locale) {
   const files = (tryGit(repoRoot, ["ls-files"]) ?? "").split("\n").filter((f) => f && isTranslationFile(f)).sort((a, b) => Number(prefersLocale(b, locale)) - Number(prefersLocale(a, locale)) || a.localeCompare(b));
@@ -4734,7 +5563,7 @@ function translationLookup(repoRoot, base, locale) {
   const build = (side) => {
     const map = /* @__PURE__ */ new Map();
     for (const file of files) {
-      const content = side === "new" ? readText(path14.join(repoRoot, file)) : tryGit(repoRoot, ["show", `${base}:${file}`]);
+      const content = side === "new" ? readText(path17.join(repoRoot, file)) : tryGit(repoRoot, ["show", `${base}:${file}`]);
       if (content === void 0) continue;
       for (const entry of parseTranslationFile(file, content)) {
         if (!map.has(entry.key)) map.set(entry.key, entry.value);
@@ -4753,34 +5582,34 @@ function prefersLocale(file, locale) {
 }
 function readText(file) {
   try {
-    return fs12.readFileSync(file, "utf-8");
+    return fs15.readFileSync(file, "utf-8");
   } catch {
     return void 0;
   }
 }
-var CACHE_FILE2 = path14.join(".piwi", "locator-index.json");
+var CACHE_FILE2 = path17.join(".piwi", "locator-index.json");
 function cacheKey2(connection, branch) {
   return `${connection.serverUrl}|${connection.project}|${branch ?? ""}`;
 }
 function readCache2(root, key) {
   try {
-    const store = JSON.parse(fs12.readFileSync(path14.join(root, CACHE_FILE2), "utf-8"));
+    const store = JSON.parse(fs15.readFileSync(path17.join(root, CACHE_FILE2), "utf-8"));
     return store[key] ?? null;
   } catch {
     return null;
   }
 }
 function writeCache2(root, key, index) {
-  const file = path14.join(root, CACHE_FILE2);
+  const file = path17.join(root, CACHE_FILE2);
   try {
     let store = {};
     try {
-      store = JSON.parse(fs12.readFileSync(file, "utf-8"));
+      store = JSON.parse(fs15.readFileSync(file, "utf-8"));
     } catch {
     }
     store[key] = { savedAt: (/* @__PURE__ */ new Date()).toISOString(), index };
-    fs12.mkdirSync(path14.dirname(file), { recursive: true });
-    fs12.writeFileSync(file, JSON.stringify(store));
+    fs15.mkdirSync(path17.dirname(file), { recursive: true });
+    fs15.writeFileSync(file, JSON.stringify(store));
   } catch {
   }
 }
@@ -4796,7 +5625,7 @@ function planSites(b, testRoot) {
   const sites = [...new Set(b.uses.flatMap((u) => u.callSites))];
   return sites.map((callSite) => {
     if (!b.rewrite || !b.replacements?.length) return { callSite, action: "none" };
-    const file = path14.resolve(testRoot, callSiteFile(callSite));
+    const file = path17.resolve(testRoot, callSiteFile(callSite));
     const lineNo = callSiteLine(callSite);
     const text = readText(file);
     if (text === void 0 || lineNo === null) return { callSite, action: "elsewhere" };
@@ -4839,7 +5668,7 @@ function applyEdits(breaks, replacementsOf) {
   }
   const edited = [];
   for (const [file, edits] of byFile) {
-    const text = fs12.readFileSync(file, "utf-8");
+    const text = fs15.readFileSync(file, "utf-8");
     const eol = text.includes("\r\n") ? "\r\n" : "\n";
     const lines = text.split(/\r?\n/);
     for (const e of edits) {
@@ -4849,7 +5678,7 @@ function applyEdits(breaks, replacementsOf) {
     }
     const next = lines.join(eol);
     if (next !== text) {
-      fs12.writeFileSync(file, next);
+      fs15.writeFileSync(file, next);
       edited.push(file);
     }
   }
@@ -4863,7 +5692,7 @@ function describeAnchor(a) {
   const extra = a.key ? ` (key ${a.key})` : a.attribute ? ` (${a.attribute})` : "";
   return `${what}${extra}`;
 }
-function pad(text, width) {
+function pad2(text, width) {
   return text.length >= width ? `${text}  ` : text + " ".repeat(width - text.length);
 }
 function renderPreflight(result, cwdToRoot = (f) => f) {
@@ -4884,14 +5713,14 @@ function renderPreflight(result, cwdToRoot = (f) => f) {
     let shown = 0;
     for (const [anchor, group] of byAnchor) {
       if (shown >= budget) break;
-      out.push(`  ${pad(`${anchor.file}:${anchor.line}`, 38)} ${describeAnchor(anchor)}`);
+      out.push(`  ${pad2(`${anchor.file}:${anchor.line}`, 38)} ${describeAnchor(anchor)}`);
       for (const b of group) {
         if (shown >= budget) break;
         shown++;
         const meta = `${b.actions.slice(0, 3).join(", ") || "used"} \xB7 ${plural(b.tests.length, "test")} \xB7 ${b.confidence}`;
-        out.push(`    ${pad(b.locator, 48)} ${meta}`);
+        out.push(`    ${pad2(b.locator, 48)} ${meta}`);
         for (const site of b.sites.slice(0, 5)) {
-          const where = pad(cwdToRoot(site.callSite.replace(/:\d+$/, "")), 34);
+          const where = pad2(cwdToRoot(site.callSite.replace(/:\d+$/, "")), 34);
           if (site.action === "edit") out.push(`      ${where} \u2192 ${b.rewrite}`);
           else if (site.action === "applied") out.push(`      ${where} already rewritten`);
           else if (site.action === "none") {
@@ -4920,7 +5749,7 @@ function renderPreflight(result, cwdToRoot = (f) => f) {
     out.push(`${plural(new Set(possible.map((b) => b.locator)).size, "locator")} it may break (a bare string matched)`);
     for (const b of possible.slice(0, Math.max(0, MAX_LISTED - likely.length))) {
       out.push(
-        `  ${pad(b.locator, 48)} ${plural(b.tests.length, "test")} \xB7 ${b.anchor.file}:${b.anchor.line} ${describeAnchor(b.anchor)}`
+        `  ${pad2(b.locator, 48)} ${plural(b.tests.length, "test")} \xB7 ${b.anchor.file}:${b.anchor.line} ${describeAnchor(b.anchor)}`
       );
       if (b.rewrite) out.push(`    if it does, edit by hand: ${b.rewrite}`);
     }
@@ -4943,7 +5772,7 @@ function renderPreflight(result, cwdToRoot = (f) => f) {
 }
 async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE8);
+    console.log(USAGE9);
     return EXIT_OK6;
   }
   let args;
@@ -4952,26 +5781,26 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
   } catch (e) {
     console.error(`piwi preflight: ${e.message}
 `);
-    console.error(USAGE8);
-    return EXIT_ERROR6;
+    console.error(USAGE9);
+    return EXIT_ERROR7;
   }
   const repoRoot = tryGit(cwd, ["rev-parse", "--show-toplevel"])?.trim();
   if (!repoRoot) {
     console.error("piwi preflight: not inside a git repository");
-    return EXIT_ERROR6;
+    return EXIT_ERROR7;
   }
-  const testRoot = path14.resolve(cwd, args.testRoot ?? findPlaywrightRoot(cwd) ?? cwd);
+  const testRoot = path17.resolve(cwd, args.testRoot ?? findPlaywrightRoot(cwd) ?? cwd);
   let files;
   try {
     files = parseUnifiedDiff(git(repoRoot, ["diff", "--unified=0", "--no-color", "--no-ext-diff", args.base, "--"]));
   } catch (e) {
     console.error(`piwi preflight: could not diff against ${args.base} \u2014 ${e.message.split("\n")[0]}`);
-    return EXIT_ERROR6;
+    return EXIT_ERROR7;
   }
   const connection = resolveConnection(args, env, [.../* @__PURE__ */ new Set([testRoot, cwd, repoRoot])]);
   if (!connection) {
     console.error("piwi preflight: no dashboard URL \u2014 pass --server-url, set PIWI_DASHBOARD_URL, or run piwi init");
-    return EXIT_ERROR6;
+    return EXIT_ERROR7;
   }
   const key = cacheKey2(connection, args.branch);
   let index;
@@ -4985,7 +5814,7 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
     const cached = readCache2(testRoot, key);
     if (!cached) {
       console.error(`piwi preflight: ${e.message}, and there is no cached index`);
-      return EXIT_ERROR6;
+      return EXIT_ERROR7;
     }
     console.error(
       `piwi preflight: dashboard unreachable, using the index cached ${cached.savedAt} \u2014 ${e.message}`
@@ -4997,7 +5826,7 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
     testIdAttributes: index.testIdAttributes ?? void 0,
     isTestFile: (file) => TEST_FILE.test(file),
     translations: translationLookup(repoRoot, args.base, args.locale),
-    readFile: (file, side) => side === "new" ? readText(path14.join(repoRoot, file)) : tryGit(repoRoot, ["show", `${args.base}:${file}`])
+    readFile: (file, side) => side === "new" ? readText(path17.join(repoRoot, file)) : tryGit(repoRoot, ["show", `${args.base}:${file}`])
   });
   const found = predictLocatorBreaks(anchors, index, { reach: await loadReach(connection, projectId, args.branch) });
   const replacementsOf = /* @__PURE__ */ new Map();
@@ -5042,8 +5871,8 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
   if (args.json) console.log(JSON.stringify(result, null, 2));
   else {
     const rel = (file) => {
-      const abs = path14.isAbsolute(file) ? file : path14.resolve(testRoot, file);
-      const r = path14.relative(cwd, abs).split(path14.sep).join("/");
+      const abs = path17.isAbsolute(file) ? file : path17.resolve(testRoot, file);
+      const r = path17.relative(cwd, abs).split(path17.sep).join("/");
       return r.startsWith("..") ? file : r || file;
     };
     console.log(renderPreflight(result, rel));
@@ -5070,14 +5899,12 @@ async function runPreflight(argv, env = process.env, cwd = process.cwd()) {
 }
 
 // src/cli/probe.ts
-var import_node_child_process6 = require("child_process");
-var import_node_module4 = require("module");
-var fs13 = __toESM(require("fs"));
-var os2 = __toESM(require("os"));
-var path15 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var os3 = __toESM(require("os"));
+var path18 = __toESM(require("path"));
 var EXIT_OK7 = 0;
-var EXIT_ERROR7 = 2;
-var USAGE9 = `
+var EXIT_ERROR8 = 2;
+var USAGE10 = `
 piwi probe \u2014 run the dashboard's probe plan and record what the suite noticed
 
 Usage:
@@ -5095,46 +5922,22 @@ function readOption9(argv, name) {
   const i = argv.indexOf(name);
   return i >= 0 && i + 1 < argv.length ? argv[i + 1] : void 0;
 }
-function escapeRegex(s) {
+function escapeRegex2(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function resolvePlaywrightCli3() {
-  const require2 = (0, import_node_module4.createRequire)(path15.join(process.cwd(), "noop.js"));
-  for (const id of ["playwright/cli", "@playwright/test/cli", "playwright/lib/cli/cli"]) {
-    try {
-      return require2.resolve(id);
-    } catch {
-    }
-  }
-  return null;
-}
-function spawnPlaywright2(playwrightArgs, env) {
-  const cli = resolvePlaywrightCli3();
-  const child = cli ? (0, import_node_child_process6.spawn)(process.execPath, [cli, "test", ...playwrightArgs], { stdio: "inherit", env }) : (0, import_node_child_process6.spawn)(process.platform === "win32" ? "npx.cmd" : "npx", ["playwright", "test", ...playwrightArgs], {
-    stdio: "inherit",
-    env
-  });
-  return new Promise((resolve8) => {
-    child.on("error", (err) => {
-      console.error(`piwi probe: could not start Playwright \u2014 ${err.message}`);
-      resolve8(EXIT_ERROR7);
-    });
-    child.on("exit", (code) => resolve8(code ?? EXIT_ERROR7));
-  });
-}
 async function runProbe(argv) {
   const sep5 = argv.indexOf("--");
   const own = sep5 < 0 ? argv : argv.slice(0, sep5);
-  const playwrightArgs = sep5 < 0 ? [] : argv.slice(sep5 + 1);
+  const playwrightArgs2 = sep5 < 0 ? [] : argv.slice(sep5 + 1);
   if (own.includes("-h") || own.includes("--help")) {
-    console.log(USAGE9);
+    console.log(USAGE10);
     return EXIT_OK7;
   }
   const env = process.env;
   const serverUrl = (readOption9(own, "--server-url") ?? env.PIWI_DASHBOARD_URL ?? "").replace(/\/$/, "");
   if (!serverUrl) {
     console.error("piwi probe: no dashboard URL \u2014 pass --server-url or set PIWI_DASHBOARD_URL");
-    return EXIT_ERROR7;
+    return EXIT_ERROR8;
   }
   const apiKey = readOption9(own, "--api-key") ?? env.PIWI_API_KEY ?? null;
   const project = readOption9(own, "--project") ?? env.PIWI_PROJECT_NAME ?? "";
@@ -5144,7 +5947,7 @@ async function runProbe(argv) {
     projectId = await resolveProjectId({ serverUrl, apiKey, project, key: "" });
   } catch (e) {
     console.error(`piwi probe: ${e.message}`);
-    return EXIT_ERROR7;
+    return EXIT_ERROR8;
   }
   const authHeaders3 = apiKey ? { "X-API-Key": apiKey } : {};
   const planUrl = `${serverUrl}/api/projects/${projectId}/probes/plan${budget ? `?budget=${encodeURIComponent(budget)}` : ""}`;
@@ -5155,22 +5958,22 @@ async function runProbe(argv) {
     plan = await res.json();
   } catch (e) {
     console.error(`piwi probe: could not fetch the probe plan \u2014 ${e.message}`);
-    return EXIT_ERROR7;
+    return EXIT_ERROR8;
   }
   if (!plan.items || plan.items.length === 0) {
     console.error("piwi probe: nothing to probe \u2014 the plan is empty.");
     return EXIT_OK7;
   }
   console.error(`piwi probe: ${plan.items.length} pair(s) to probe (budget ${plan.budget}).`);
-  const dir = fs13.mkdtempSync(path15.join(os2.tmpdir(), "piwi-probe-"));
-  const planFile = path15.join(dir, "plan.json");
-  const resultsFile = path15.join(dir, "results.jsonl");
-  const runOutputFile = path15.join(dir, "run.json");
-  fs13.writeFileSync(planFile, JSON.stringify(plan));
-  fs13.writeFileSync(resultsFile, "");
-  const grep = plan.items.map((i) => i.testTitle).filter(Boolean).map(escapeRegex).join("|");
-  const pwArgs = [...playwrightArgs];
-  if (grep && !playwrightArgs.includes("--grep") && !playwrightArgs.includes("-g")) pwArgs.push("--grep", grep);
+  const dir = fs16.mkdtempSync(path18.join(os3.tmpdir(), "piwi-probe-"));
+  const planFile = path18.join(dir, "plan.json");
+  const resultsFile = path18.join(dir, "results.jsonl");
+  const runOutputFile = path18.join(dir, "run.json");
+  fs16.writeFileSync(planFile, JSON.stringify(plan));
+  fs16.writeFileSync(resultsFile, "");
+  const grep = plan.items.map((i) => i.testTitle).filter(Boolean).map(escapeRegex2).join("|");
+  const pwArgs = [...playwrightArgs2];
+  if (grep && !playwrightArgs2.includes("--grep") && !playwrightArgs2.includes("-g")) pwArgs.push("--grep", grep);
   const childEnv = {
     ...env,
     [PIWI_PROBE_ENV.flag]: "1",
@@ -5180,8 +5983,8 @@ async function runProbe(argv) {
     // it write the run output here so the results POST can name the run.
     [PIWI_ENV_KEYS.outputFile]: runOutputFile
   };
-  await spawnPlaywright2(pwArgs, childEnv);
-  const lines = fs13.readFileSync(resultsFile, "utf8").split("\n").filter(Boolean);
+  await spawnPlaywright(pwArgs, childEnv, { command: "piwi probe" });
+  const lines = fs16.readFileSync(resultsFile, "utf8").split("\n").filter(Boolean);
   const results = [];
   for (const line of lines) {
     try {
@@ -5195,7 +5998,7 @@ async function runProbe(argv) {
   }
   let runId = null;
   try {
-    const out = JSON.parse(fs13.readFileSync(runOutputFile, "utf8"));
+    const out = JSON.parse(fs16.readFileSync(runOutputFile, "utf8"));
     if (typeof out.runId === "number") runId = out.runId;
   } catch {
   }
@@ -5214,19 +6017,19 @@ async function runProbe(argv) {
     );
   } catch (e) {
     console.error(`piwi probe: could not post probe results \u2014 ${e.message}`);
-    return EXIT_ERROR7;
+    return EXIT_ERROR8;
   }
   return EXIT_OK7;
 }
 
 // src/cli/quality-report.ts
-var fs14 = __toESM(require("fs"));
+var fs17 = __toESM(require("fs"));
 var EXIT_OK8 = 0;
 var EXIT_VERDICT = 1;
-var EXIT_ERROR8 = 2;
+var EXIT_ERROR9 = 2;
 var FORMATS = ["md", "json", "html", "pdf", "csv"];
 var DASHBOARDS = ["executive", "engineering", "overview"];
-var USAGE10 = `
+var USAGE11 = `
 piwi report \u2014 print a quality report from the dashboard
 
 Usage:
@@ -5329,7 +6132,7 @@ async function fetchReport(args, query) {
 }
 async function runQualityReport(argv) {
   if (argv.includes("-h") || argv.includes("--help")) {
-    console.log(USAGE10);
+    console.log(USAGE11);
     return EXIT_OK8;
   }
   try {
@@ -5340,7 +6143,7 @@ async function runQualityReport(argv) {
     }
     const res = await fetchReport(args, reportQuery(args, projectIds, args.format));
     const bytes = new Uint8Array(await res.arrayBuffer());
-    if (args.output) fs14.writeFileSync(args.output, bytes);
+    if (args.output) fs17.writeFileSync(args.output, bytes);
     else process.stdout.write(bytes);
     if (!args.failOn) return EXIT_OK8;
     const bundle = args.format === "json" ? JSON.parse(new TextDecoder().decode(bytes)) : await (await fetchReport(args, reportQuery(args, projectIds, "json"))).json();
@@ -5351,12 +6154,12 @@ async function runQualityReport(argv) {
     return EXIT_OK8;
   } catch (e) {
     console.error(`piwi report: ${e.message}`);
-    return EXIT_ERROR8;
+    return EXIT_ERROR9;
   }
 }
 
 // src/cli/index.ts
-var USAGE11 = `
+var USAGE12 = `
 piwi \u2014 companion commands for the Piwi Dashboard reporter
 
 Usage:
@@ -5370,6 +6173,7 @@ Commands:
   select    Print the Playwright args for a saved test selection
   run       Run a saved test selection with playwright test
   probe     Run the dashboard's probe plan and record what the suite noticed
+  flake     Make a flaky test fail on demand under its suspects' conditions, then verify the fix
   ai        Manage committed natural-language AI-step artifacts
   codegen   Turn a steps file (a Piwi Picker recording) into a Playwright spec
   preflight List the test locators your uncommitted change breaks, and fix them
@@ -5396,6 +6200,8 @@ async function main() {
       return runRun(rest);
     case "probe":
       return runProbe(rest);
+    case "flake":
+      return runFlake(rest);
     case "ai":
       return runAi(rest);
     case "codegen":
@@ -5407,12 +6213,12 @@ async function main() {
     case void 0:
     case "-h":
     case "--help":
-      console.log(USAGE11);
+      console.log(USAGE12);
       return 0;
     default:
       console.error(`piwi: unknown command "${command}"
 `);
-      console.error(USAGE11);
+      console.error(USAGE12);
       return 2;
   }
 }