@veolab/discoverylab 1.3.2 → 1.3.3

package/dist/chunk-7EDIUVIO.js

@@ -0,0 +1,4304 @@
+import {
+  APP_VERSION
+} from "./chunk-6EGBXRDK.js";
+import {
+  DATA_DIR,
+  PROJECTS_DIR
+} from "./chunk-VVIOB362.js";
+
+// src/core/integrations/esvp-local-runtime.ts
+import { execFile as execFile2 } from "child_process";
+import { createHash as createHash3 } from "crypto";
+import { mkdir as mkdir2, readFile as readFile2, readdir, stat, writeFile as writeFile2 } from "fs/promises";
+import { basename, extname, join as join4, resolve, sep } from "path";
+import { promisify as promisify3 } from "util";
+
+// src/core/integrations/esvp-local-device.ts
+import { execFile } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+import { promisify as promisify2 } from "util";
+
+// src/core/android/adb.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var ADB_COMMAND_CACHE_SUCCESS_TTL_MS = 5 * 60 * 1e3;
+var ADB_COMMAND_CACHE_FAILURE_TTL_MS = 5 * 1e3;
+var adbCommandCache = null;
+function quoteCommand(cmd) {
+  return cmd.includes(" ") ? `"${cmd}"` : cmd;
+}
+function shellQuoteArg(value) {
+  const str = String(value ?? "");
+  if (!str) return "''";
+  return `'${str.replace(/'/g, `'"'"'`)}'`;
+}
+function findAndroidSdkPath() {
+  const envPaths = [
+    process.env.ANDROID_HOME,
+    process.env.ANDROID_SDK_ROOT,
+    process.env.ANDROID_SDK
+  ].filter((value) => typeof value === "string" && value.trim().length > 0);
+  for (const envPath of envPaths) {
+    if (existsSync(join(envPath, "platform-tools", "adb"))) {
+      return envPath;
+    }
+  }
+  const home = homedir();
+  const commonPaths = [
+    join(home, "Library", "Android", "sdk"),
+    join(home, "Android", "Sdk"),
+    "/opt/android-sdk",
+    "/usr/local/android-sdk"
+  ];
+  for (const sdkPath of commonPaths) {
+    if (existsSync(join(sdkPath, "platform-tools", "adb"))) {
+      return sdkPath;
+    }
+  }
+  return null;
+}
+function getAdbPath() {
+  const sdkPath = findAndroidSdkPath();
+  if (!sdkPath) return null;
+  const adbPath = join(sdkPath, "platform-tools", "adb");
+  return existsSync(adbPath) ? adbPath : null;
+}
+function getEmulatorPath() {
+  const sdkPath = findAndroidSdkPath();
+  if (!sdkPath) return null;
+  const emulatorPath = join(sdkPath, "emulator", "emulator");
+  return existsSync(emulatorPath) ? emulatorPath : null;
+}
+function getAdbCommand(options) {
+  const forceRefresh = options?.forceRefresh === true;
+  const now = Date.now();
+  if (!forceRefresh && adbCommandCache) {
+    const ttlMs = adbCommandCache.value ? ADB_COMMAND_CACHE_SUCCESS_TTL_MS : ADB_COMMAND_CACHE_FAILURE_TTL_MS;
+    if (now - adbCommandCache.checkedAt < ttlMs) {
+      return adbCommandCache.value;
+    }
+  }
+  const candidates = [
+    getAdbPath(),
+    "/opt/homebrew/bin/adb",
+    "/usr/local/bin/adb",
+    "adb"
+  ].filter((value, index, arr) => Boolean(value) && arr.indexOf(value) === index);
+  for (const candidate of candidates) {
+    try {
+      if (candidate === "adb") {
+        execSync("which adb", { stdio: "pipe", timeout: 2e3 });
+      } else if (!existsSync(candidate)) {
+        continue;
+      }
+      adbCommandCache = { value: candidate, checkedAt: Date.now() };
+      return candidate;
+    } catch {
+    }
+  }
+  adbCommandCache = { value: null, checkedAt: Date.now() };
+  return null;
+}
+function normalizeAndroidDeviceToken(value) {
+  return value.trim().replace(/^android:/i, "").replace(/\s+/g, "_").toLowerCase();
+}
+function listConnectedAndroidDevices(adbCommand = getAdbCommand()) {
+  if (!adbCommand) return [];
+  try {
+    const adbOutput = execSync(`${quoteCommand(adbCommand)} devices -l`, {
+      encoding: "utf8",
+      timeout: 4e3
+    });
+    const lines = adbOutput.split("\n").slice(1);
+    const devices = [];
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      const parts = line.split(/\s+/);
+      const serial = parts[0];
+      const state = parts[1];
+      if (!serial || !state) continue;
+      const modelMatch = line.match(/model:(\S+)/);
+      const deviceMatch = line.match(/device:(\S+)/);
+      const deviceInfo = {
+        serial,
+        state,
+        model: modelMatch?.[1],
+        device: deviceMatch?.[1]
+      };
+      if (serial.startsWith("emulator-") && state === "device") {
+        try {
+          const avdNameOutput = execSync(
+            `${quoteCommand(adbCommand)} -s ${shellQuoteArg(serial)} emu avd name`,
+            {
+              encoding: "utf8",
+              timeout: 1500
+            }
+          );
+          const avdName = avdNameOutput.split("\n").map((value) => value.trim()).find((value) => value && value !== "OK");
+          if (avdName) {
+            deviceInfo.avdName = avdName;
+          }
+        } catch {
+        }
+      }
+      devices.push(deviceInfo);
+    }
+    return devices;
+  } catch {
+    return [];
+  }
+}
+function resolveAndroidDeviceSerial(deviceId, adbCommand = getAdbCommand()) {
+  const connectedDevices = listConnectedAndroidDevices(adbCommand);
+  const onlineDevices = connectedDevices.filter((device) => device.state === "device");
+  if (onlineDevices.length === 0) return null;
+  const requested = typeof deviceId === "string" ? deviceId.trim() : "";
+  if (!requested) {
+    return onlineDevices[0]?.serial || null;
+  }
+  const requestedToken = normalizeAndroidDeviceToken(requested);
+  for (const device of onlineDevices) {
+    const candidates = [device.serial, device.avdName, device.model, device.device].filter((value) => Boolean(value)).map((value) => normalizeAndroidDeviceToken(value));
+    if (candidates.includes(requestedToken)) {
+      return device.serial;
+    }
+  }
+  return null;
+}
+
+// src/core/testing/maestro.ts
+import { exec, execSync as execSync2, spawn } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { createHash } from "crypto";
+import { EventEmitter } from "events";
+var execAsync = promisify(exec);
+var MAESTRO_COMMAND_CACHE_SUCCESS_TTL_MS = 5 * 60 * 1e3;
+var MAESTRO_COMMAND_CACHE_FAILURE_TTL_MS = 5 * 1e3;
+var MAESTRO_DEVICE_CACHE_TTL_MS = 4 * 1e3;
+var maestroCommandCache = null;
+var maestroCommandResolveInFlight = null;
+var maestroDeviceListCache = null;
+var maestroDeviceListInFlight = null;
+function quoteCommand2(cmd) {
+  return cmd.includes(" ") ? `"${cmd}"` : cmd;
+}
+function shellQuoteArg2(value) {
+  const str = String(value ?? "");
+  if (!str) return "''";
+  return `'${str.replace(/'/g, `'"'"'`)}'`;
+}
+function getAdbCommandOrThrow() {
+  const adbCommand = getAdbCommand();
+  if (!adbCommand) {
+    throw new Error("ADB not found. Set ANDROID_HOME/ANDROID_SDK_ROOT or add adb to PATH.");
+  }
+  return adbCommand;
+}
+function getMaestroCommandCandidates() {
+  const candidates = [];
+  const maestroHomePath = path.join(os.homedir(), ".maestro", "bin", "maestro");
+  if (fs.existsSync(maestroHomePath)) {
+    candidates.push(maestroHomePath);
+  }
+  const brewPaths = ["/opt/homebrew/bin/maestro", "/usr/local/bin/maestro"];
+  for (const brewPath of brewPaths) {
+    if (fs.existsSync(brewPath)) {
+      candidates.push(brewPath);
+    }
+  }
+  candidates.push("maestro");
+  return candidates;
+}
+function getMaestroCommandCacheTtlMs(value) {
+  return value ? MAESTRO_COMMAND_CACHE_SUCCESS_TTL_MS : MAESTRO_COMMAND_CACHE_FAILURE_TTL_MS;
+}
+async function resolveMaestroCommand(options) {
+  const forceRefresh = options?.forceRefresh === true;
+  const now = Date.now();
+  if (!forceRefresh && maestroCommandCache) {
+    const ttlMs = getMaestroCommandCacheTtlMs(maestroCommandCache.value);
+    if (now - maestroCommandCache.checkedAt < ttlMs) {
+      return maestroCommandCache.value;
+    }
+  }
+  if (!forceRefresh && maestroCommandResolveInFlight) {
+    return maestroCommandResolveInFlight;
+  }
+  maestroCommandResolveInFlight = (async () => {
+    for (const candidate of getMaestroCommandCandidates()) {
+      try {
+        const cmd = quoteCommand2(candidate);
+        await execAsync(`${cmd} --version`);
+        maestroCommandCache = { value: candidate, checkedAt: Date.now() };
+        return candidate;
+      } catch {
+      }
+    }
+    maestroCommandCache = { value: null, checkedAt: Date.now() };
+    return null;
+  })();
+  try {
+    return await maestroCommandResolveInFlight;
+  } finally {
+    maestroCommandResolveInFlight = null;
+  }
+}
+var PENDING_SESSION_FILE = path.join(PROJECTS_DIR, ".maestro-pending-session.json");
+async function isMaestroInstalled() {
+  try {
+    return !!await resolveMaestroCommand();
+  } catch {
+    return false;
+  }
+}
+async function isIdbInstalled() {
+  try {
+    await execAsync("idb --version", { timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function tapViaIdb(deviceId, x, y) {
+  try {
+    await execAsync(`idb ui tap ${Math.round(x)} ${Math.round(y)} --udid ${deviceId}`, {
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    console.error("[idb tap failed]", error instanceof Error ? error.message : error);
+    return false;
+  }
+}
+async function killZombieMaestroProcesses() {
+  try {
+    await execAsync('pkill -f "maestro test" || true', { timeout: 3e3 });
+    await execAsync('pkill -f "maestro record" || true', { timeout: 3e3 });
+    console.log("[MaestroCleanup] Killed zombie maestro processes");
+  } catch {
+  }
+}
+async function getMaestroVersion() {
+  try {
+    const command = await resolveMaestroCommand();
+    if (!command) return null;
+    const cmd = quoteCommand2(command);
+    const { stdout } = await execAsync(`${cmd} --version`);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function listMaestroDevices(options) {
+  const forceRefresh = options?.forceRefresh === true;
+  const ttlMs = Math.max(0, Number(options?.ttlMs ?? MAESTRO_DEVICE_CACHE_TTL_MS));
+  const now = Date.now();
+  if (!forceRefresh && maestroDeviceListCache && now - maestroDeviceListCache.fetchedAt < ttlMs) {
+    return maestroDeviceListCache.devices;
+  }
+  if (!forceRefresh && maestroDeviceListInFlight) {
+    return maestroDeviceListInFlight;
+  }
+  maestroDeviceListInFlight = (async () => {
+    const devices = [];
+    try {
+      const { stdout: iosOutput } = await execAsync("xcrun simctl list devices -j");
+      const iosData = JSON.parse(iosOutput);
+      for (const [runtime, deviceList] of Object.entries(iosData.devices || {})) {
+        if (!Array.isArray(deviceList)) continue;
+        for (const device of deviceList) {
+          if (device.state === "Booted") {
+            devices.push({
+              id: device.udid,
+              name: device.name,
+              platform: "ios",
+              status: "connected"
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    try {
+      const adbCommand = getAdbCommand();
+      if (adbCommand) {
+        const { stdout: androidOutput } = await execAsync(`${quoteCommand2(adbCommand)} devices -l`);
+        const lines = androidOutput.split("\n").slice(1);
+        for (const line of lines) {
+          const match = line.match(/^(\S+)\s+device\s+(.*)$/);
+          if (match) {
+            const [, id, info] = match;
+            const modelMatch = info.match(/model:(\S+)/);
+            devices.push({
+              id,
+              name: modelMatch ? modelMatch[1] : id,
+              platform: "android",
+              status: "connected"
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    maestroDeviceListCache = { devices, fetchedAt: Date.now() };
+    return devices;
+  })();
+  try {
+    return await maestroDeviceListInFlight;
+  } finally {
+    maestroDeviceListInFlight = null;
+  }
+}
+function generateMaestroFlow(flow) {
+  const lines = [];
+  lines.push(`appId: ${flow.appId}`);
+  lines.push("");
+  if (flow.name) {
+    lines.push(`name: ${flow.name}`);
+    lines.push("");
+  }
+  if (flow.env && Object.keys(flow.env).length > 0) {
+    lines.push("env:");
+    for (const [key, value] of Object.entries(flow.env)) {
+      lines.push(`  ${key}: "${value}"`);
+    }
+    lines.push("");
+  }
+  if (flow.onFlowStart && flow.onFlowStart.length > 0) {
+    lines.push("onFlowStart:");
+    for (const step of flow.onFlowStart) {
+      lines.push(formatFlowStep(step, 2));
+    }
+    lines.push("");
+  }
+  if (flow.onFlowComplete && flow.onFlowComplete.length > 0) {
+    lines.push("onFlowComplete:");
+    for (const step of flow.onFlowComplete) {
+      lines.push(formatFlowStep(step, 2));
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  for (const step of flow.steps) {
+    lines.push(formatFlowStep(step, 0));
+  }
+  return lines.join("\n");
+}
+function formatFlowStep(step, indent) {
+  const prefix = " ".repeat(indent);
+  const { action, params } = step;
+  if (!params || Object.keys(params).length === 0) {
+    return `${prefix}- ${action}`;
+  }
+  if (Object.keys(params).length === 1) {
+    const [key, value] = Object.entries(params)[0];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      return `${prefix}- ${action}:
+${prefix}    ${key}: ${formatValue(value)}`;
+    }
+  }
+  const lines = [`${prefix}- ${action}:`];
+  for (const [key, value] of Object.entries(params)) {
+    lines.push(`${prefix}    ${key}: ${formatValue(value)}`);
+  }
+  return lines.join("\n");
+}
+function formatValue(value) {
+  if (typeof value === "string") {
+    return value.includes("\n") || value.includes(":") ? `"${value}"` : value;
+  }
+  return String(value);
+}
+var MaestroActions = {
+  // App lifecycle
+  launchApp: (appId) => ({ action: "launchApp", params: appId ? { appId } : void 0 }),
+  stopApp: (appId) => ({ action: "stopApp", params: appId ? { appId } : void 0 }),
+  clearState: (appId) => ({ action: "clearState", params: appId ? { appId } : void 0 }),
+  clearKeychain: () => ({ action: "clearKeychain" }),
+  // Navigation
+  tapOn: (text) => ({ action: "tapOn", params: { text } }),
+  tapOnId: (id) => ({ action: "tapOn", params: { id } }),
+  tapOnPoint: (x, y) => ({ action: "tapOn", params: { point: `${x},${y}` } }),
+  doubleTapOn: (text) => ({ action: "doubleTapOn", params: { text } }),
+  longPressOn: (text) => ({ action: "longPressOn", params: { text } }),
+  // Input
+  inputText: (text) => ({ action: "inputText", params: { text } }),
+  inputRandomText: () => ({ action: "inputRandomText" }),
+  inputRandomNumber: () => ({ action: "inputRandomNumber" }),
+  inputRandomEmail: () => ({ action: "inputRandomEmail" }),
+  eraseText: (chars) => ({ action: "eraseText", params: chars ? { charactersToErase: chars } : void 0 }),
+  // Gestures
+  scroll: () => ({ action: "scroll" }),
+  scrollDown: () => ({ action: "scrollUntilVisible", params: { direction: "DOWN" } }),
+  scrollUp: () => ({ action: "scrollUntilVisible", params: { direction: "UP" } }),
+  swipeLeft: () => ({ action: "swipe", params: { direction: "LEFT" } }),
+  swipeRight: () => ({ action: "swipe", params: { direction: "RIGHT" } }),
+  swipeDown: () => ({ action: "swipe", params: { direction: "DOWN" } }),
+  swipeUp: () => ({ action: "swipe", params: { direction: "UP" } }),
+  // Assertions
+  assertVisible: (text) => ({ action: "assertVisible", params: { text } }),
+  assertNotVisible: (text) => ({ action: "assertNotVisible", params: { text } }),
+  assertTrue: (condition) => ({ action: "assertTrue", params: { condition } }),
+  // Wait
+  waitForAnimationToEnd: (timeout) => ({
+    action: "waitForAnimationToEnd",
+    params: timeout ? { timeout } : void 0
+  }),
+  wait: (ms) => ({ action: "extendedWaitUntil", params: { timeout: ms } }),
+  // Screenshots
+  takeScreenshot: (path2) => ({ action: "takeScreenshot", params: { path: path2 } }),
+  // Keyboard
+  hideKeyboard: () => ({ action: "hideKeyboard" }),
+  pressKey: (key) => ({ action: "pressKey", params: { key } }),
+  back: () => ({ action: "back" }),
+  // Conditional
+  runFlow: (flowPath) => ({ action: "runFlow", params: { file: flowPath } }),
+  runScript: (script) => ({ action: "runScript", params: { script } }),
+  // Device
+  openLink: (url) => ({ action: "openLink", params: { link: url } }),
+  setLocation: (lat, lon) => ({ action: "setLocation", params: { latitude: lat, longitude: lon } }),
+  travel: (steps) => ({ action: "travel", params: { points: steps } })
+};
+async function runMaestroTest(options) {
+  const installed = await isMaestroInstalled();
+  if (!installed) {
+    return {
+      success: false,
+      error: 'Maestro CLI is not installed. Install with: curl -Ls "https://get.maestro.mobile.dev" | bash'
+    };
+  }
+  const {
+    flowPath,
+    appId,
+    device,
+    env = {},
+    timeout = 3e5,
+    // 5 minutes default
+    captureVideo = false,
+    captureScreenshots = false,
+    outputDir = path.join(PROJECTS_DIR, "maestro-output", Date.now().toString())
+  } = options;
+  const command = await resolveMaestroCommand();
+  if (!command) {
+    return {
+      success: false,
+      error: 'Maestro CLI is not installed or not runnable. Install with: curl -Ls "https://get.maestro.mobile.dev" | bash'
+    };
+  }
+  if (!fs.existsSync(flowPath)) {
+    return { success: false, error: `Flow file not found: ${flowPath}` };
+  }
+  await fs.promises.mkdir(outputDir, { recursive: true });
+  const startTime = Date.now();
+  const args = ["test", flowPath];
+  const maestroCmd = quoteCommand2(command);
+  if (device) {
+    args.push("--device", device);
+  }
+  for (const [key, value] of Object.entries(env)) {
+    args.push("-e", `${key}=${value}`);
+  }
+  args.push("--format", "junit");
+  args.push("--output", path.join(outputDir, "report.xml"));
+  try {
+    const shellArgs = args.map(shellQuoteArg2).join(" ");
+    const { stdout, stderr } = await execAsync(`${maestroCmd} ${shellArgs}`, {
+      timeout,
+      env: { ...process.env, ...env }
+    });
+    const duration = Date.now() - startTime;
+    const screenshots = [];
+    const videoPath = captureVideo ? path.join(outputDir, "recording.mp4") : void 0;
+    if (captureScreenshots) {
+      const files = await fs.promises.readdir(outputDir);
+      for (const file of files) {
+        if (file.endsWith(".png")) {
+          screenshots.push(path.join(outputDir, file));
+        }
+      }
+    }
+    return {
+      success: true,
+      duration,
+      flowPath,
+      output: stdout + stderr,
+      screenshots,
+      video: videoPath
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const message = error instanceof Error ? error.message : String(error);
+    const errLike = error;
+    const stdout = typeof errLike?.stdout === "string" ? errLike.stdout : Buffer.isBuffer(errLike?.stdout) ? errLike.stdout.toString("utf8") : "";
+    const stderr = typeof errLike?.stderr === "string" ? errLike.stderr : Buffer.isBuffer(errLike?.stderr) ? errLike.stderr.toString("utf8") : "";
+    const detailedOutput = [stderr?.trim(), stdout?.trim(), message].filter(Boolean).join("\n\n").slice(-16e3);
+    return {
+      success: false,
+      error: stderr?.trim() || message,
+      duration,
+      flowPath,
+      output: detailedOutput || message
+    };
+  }
+}
+async function runMaestroWithCapture(options, onProgress) {
+  const {
+    flowPath,
+    device,
+    outputDir = path.join(PROJECTS_DIR, "maestro-output", Date.now().toString())
+  } = options;
+  await fs.promises.mkdir(outputDir, { recursive: true });
+  const videoPath = path.join(outputDir, "recording.mp4");
+  let recordingProcess = null;
+  try {
+    onProgress?.("Starting screen recording...");
+    if (device) {
+      const devices = await listMaestroDevices();
+      const targetDevice = devices.find((d) => d.id === device || d.name === device);
+      if (targetDevice?.platform === "ios") {
+        recordingProcess = spawn("xcrun", ["simctl", "io", device, "recordVideo", videoPath]);
+      } else if (targetDevice?.platform === "android") {
+        const adbCommand = getAdbCommandOrThrow();
+        recordingProcess = spawn(adbCommand, ["-s", device, "shell", "screenrecord", "/sdcard/recording.mp4"]);
+      }
+    }
+    onProgress?.("Running Maestro test...");
+    const result = await runMaestroTest({ ...options, outputDir });
+    onProgress?.("Stopping screen recording...");
+    if (recordingProcess) {
+      recordingProcess.kill("SIGINT");
+      await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+      const devices = await listMaestroDevices();
+      const targetDevice = devices.find((d) => d.id === device || d.name === device);
+      if (targetDevice?.platform === "android") {
+        const adbCommand = getAdbCommandOrThrow();
+        await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(device)} pull /sdcard/recording.mp4 "${videoPath}"`);
+        await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(device)} shell rm /sdcard/recording.mp4`);
+      }
+    }
+    return {
+      ...result,
+      video: fs.existsSync(videoPath) ? videoPath : void 0
+    };
+  } catch (error) {
+    if (recordingProcess) {
+      recordingProcess.kill("SIGKILL");
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      flowPath
+    };
+  }
+}
+async function startMaestroStudio(appId) {
+  const installed = await isMaestroInstalled();
+  if (!installed) {
+    return {
+      success: false,
+      error: "Maestro CLI is not installed"
+    };
+  }
+  try {
+    const args = ["studio"];
+    if (appId) {
+      args.push(appId);
+    }
+    const maestroCmd = await resolveMaestroCommand();
+    if (!maestroCmd) {
+      return { success: false, error: "Maestro CLI is not installed or not runnable" };
+    }
+    spawn(maestroCmd, args, {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createLoginFlow(appId, usernameField, passwordField, loginButton, successIndicator) {
+  return {
+    appId,
+    name: "Login Flow",
+    steps: [
+      MaestroActions.launchApp(appId),
+      MaestroActions.waitForAnimationToEnd(),
+      MaestroActions.tapOn(usernameField),
+      MaestroActions.inputText("${USERNAME}"),
+      MaestroActions.tapOn(passwordField),
+      MaestroActions.inputText("${PASSWORD}"),
+      MaestroActions.hideKeyboard(),
+      MaestroActions.tapOn(loginButton),
+      MaestroActions.waitForAnimationToEnd(5e3),
+      MaestroActions.assertVisible(successIndicator)
+    ]
+  };
+}
+function createOnboardingFlow(appId, screens) {
+  const steps = [
+    MaestroActions.launchApp(appId),
+    MaestroActions.waitForAnimationToEnd()
+  ];
+  for (const screen of screens) {
+    if (screen.waitFor) {
+      steps.push(MaestroActions.assertVisible(screen.waitFor));
+    }
+    steps.push(MaestroActions.tapOn(screen.nextButton));
+    steps.push(MaestroActions.waitForAnimationToEnd());
+  }
+  return {
+    appId,
+    name: "Onboarding Flow",
+    steps
+  };
+}
+function createNavigationTestFlow(appId, tabs) {
+  const steps = [
+    MaestroActions.launchApp(appId),
+    MaestroActions.waitForAnimationToEnd()
+  ];
+  for (const tab of tabs) {
+    steps.push(MaestroActions.tapOn(tab));
+    steps.push(MaestroActions.waitForAnimationToEnd());
+    steps.push(MaestroActions.takeScreenshot(`${tab.replace(/\s+/g, "_")}.png`));
+  }
+  return {
+    appId,
+    name: "Navigation Test",
+    steps
+  };
+}
+function parseMaestroActionsFromYaml(yamlContent) {
+  const actions = [];
+  const lines = yamlContent.split("\n");
+  let currentAction = null;
+  let actionIndex = 0;
+  const nextId = () => `action_${String(++actionIndex).padStart(3, "0")}`;
+  const stripInlineComment = (value) => {
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    for (let index = 0; index < value.length; index += 1) {
+      const char = value[index];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"' && !inSingle) {
+        inDouble = !inDouble;
+        continue;
+      }
+      if (char === "'" && !inDouble) {
+        inSingle = !inSingle;
+        continue;
+      }
+      if (char === "#" && !inSingle && !inDouble) {
+        return value.slice(0, index).trimEnd();
+      }
+    }
+    return value;
+  };
+  const cleanValue = (value) => stripInlineComment(value).trim().replace(/^["']|["']$/g, "");
+  const pushAction = (action) => {
+    actions.push({
+      id: action.id || nextId(),
+      type: action.type || "tap",
+      timestamp: action.timestamp || Date.now(),
+      description: action.description || action.type || "Action",
+      x: action.x,
+      y: action.y,
+      endX: action.endX,
+      endY: action.endY,
+      text: action.text,
+      direction: action.direction,
+      seconds: action.seconds,
+      appId: action.appId,
+      duration: action.duration,
+      screenshotPath: action.screenshotPath
+    });
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed === "" || trimmed === "---") {
+      continue;
+    }
+    if (trimmed.startsWith("appId:")) {
+      continue;
+    }
+    if (trimmed.startsWith("- tapOn:")) {
+      const inlineValue = cleanValue(trimmed.replace("- tapOn:", ""));
+      if (inlineValue) {
+        pushAction({
+          type: "tap",
+          description: `Tap on "${inlineValue}"`,
+          text: inlineValue
+        });
+        continue;
+      }
+      currentAction = { type: "tap", description: "Tap" };
+    } else if (trimmed.startsWith("- tap:")) {
+      currentAction = { type: "tap", description: "Tap" };
+    } else if (trimmed.startsWith("- swipe:")) {
+      currentAction = { type: "swipe", description: "Swipe" };
+    } else if (trimmed.startsWith("- scroll:")) {
+      currentAction = { type: "scroll", description: "Scroll" };
+    } else if (trimmed.startsWith("- scrollUntilVisible:")) {
+      currentAction = { type: "scroll", description: "Scroll" };
+    } else if (trimmed.startsWith("- inputText:")) {
+      const text = cleanValue(trimmed.replace("- inputText:", ""));
+      pushAction({
+        type: "input",
+        description: `Input: ${text.slice(0, 20)}${text.length > 20 ? "..." : ""}`,
+        text
+      });
+      continue;
+    } else if (trimmed.startsWith("- launchApp:")) {
+      const appId = cleanValue(trimmed.replace("- launchApp:", ""));
+      pushAction({
+        type: "launch",
+        description: `Launch: ${appId}`,
+        text: appId,
+        appId
+      });
+      continue;
+    } else if (trimmed === "- launchApp") {
+      pushAction({
+        type: "launch",
+        description: "Launch app"
+      });
+      continue;
+    } else if (trimmed.startsWith("- assertVisible:")) {
+      const inlineValue = cleanValue(trimmed.replace("- assertVisible:", ""));
+      if (inlineValue) {
+        pushAction({
+          type: "assert",
+          description: `Assert visible "${inlineValue}"`,
+          text: inlineValue
+        });
+        continue;
+      }
+      currentAction = { type: "assert", description: "Assert visible" };
+    } else if (trimmed.startsWith("- extendedWaitUntil:")) {
+      currentAction = { type: "wait", description: "Wait" };
+    } else if (trimmed.startsWith("- pressKey:")) {
+      const key = cleanValue(trimmed.replace("- pressKey:", "")).toLowerCase();
+      if (key === "back") {
+        pushAction({ type: "back", description: "Back button" });
+      } else if (key === "home") {
+        pushAction({ type: "home", description: "Home button" });
+      } else {
+        pushAction({
+          type: "pressKey",
+          description: `Press: ${key}`,
+          text: key
+        });
+      }
+      continue;
+    } else if (trimmed.startsWith("- back")) {
+      pushAction({ type: "back", description: "Back button" });
+      continue;
+    }
+    if (currentAction && trimmed.startsWith("point:")) {
+      const point = cleanValue(trimmed.replace("point:", ""));
+      const [x, y] = point.split(",").map((n) => parseInt(n.trim()));
+      if (!isNaN(x) && !isNaN(y)) {
+        currentAction.x = x;
+        currentAction.y = y;
+        currentAction.description = `Tap at (${x}, ${y})`;
+        pushAction(currentAction);
+        currentAction = null;
+        continue;
+      }
+    }
+    if (currentAction && trimmed.startsWith("text:")) {
+      const text = cleanValue(trimmed.replace("text:", ""));
+      currentAction.text = text;
+      if (currentAction.type === "assert") {
+        currentAction.description = `Assert visible "${text}"`;
+      } else {
+        currentAction.description = `Tap on "${text}"`;
+      }
+      pushAction(currentAction);
+      currentAction = null;
+      continue;
+    }
+    if (currentAction && trimmed.startsWith("id:")) {
+      const id = cleanValue(trimmed.replace("id:", ""));
+      currentAction.text = id;
+      currentAction.description = `Tap on id: ${id}`;
+      pushAction(currentAction);
+      currentAction = null;
+      continue;
+    }
+    if (currentAction && (currentAction.type === "swipe" || currentAction.type === "scroll") && trimmed.startsWith("direction:")) {
+      const direction = cleanValue(trimmed.replace("direction:", "")).toLowerCase();
+      currentAction.direction = direction;
+      currentAction.description = currentAction.type === "swipe" ? `Swipe ${direction}` : `Scroll ${direction}`;
+      pushAction(currentAction);
+      currentAction = null;
+      continue;
+    }
+    if (currentAction && currentAction.type === "wait" && trimmed.startsWith("timeout:")) {
+      const timeoutMs = parseInt(cleanValue(trimmed.replace("timeout:", "")), 10);
+      const seconds = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.max(1, Math.round(timeoutMs / 1e3)) : 3;
+      currentAction.seconds = seconds;
+      currentAction.description = `Wait ${seconds}s`;
+      pushAction(currentAction);
+      currentAction = null;
+      continue;
+    }
+    if (currentAction && currentAction.type === "swipe") {
+      if (trimmed.startsWith("start:")) {
+        const point = cleanValue(trimmed.replace("start:", ""));
+        const [x, y] = point.split(",").map((n) => parseInt(n.trim()));
+        if (!isNaN(x) && !isNaN(y)) {
+          currentAction.x = x;
+          currentAction.y = y;
+        }
+      } else if (trimmed.startsWith("end:")) {
+        const point = cleanValue(trimmed.replace("end:", ""));
+        const [x, y] = point.split(",").map((n) => parseInt(n.trim()));
+        if (!isNaN(x) && !isNaN(y)) {
+          currentAction.endX = x;
+          currentAction.endY = y;
+          currentAction.description = `Swipe from (${currentAction.x}, ${currentAction.y}) to (${x}, ${y})`;
+          pushAction(currentAction);
+          currentAction = null;
+        }
+      }
+    }
+  }
+  return actions;
+}
+var MaestroRecorder = class extends EventEmitter {
+  session = null;
+  adbProcess = null;
+  videoProcess = null;
+  maestroRecordProcess = null;
+  // Native maestro record process
+  actionCounter = 0;
+  screenshotInterval = null;
+  useNativeMaestroRecord = true;
+  // Use native maestro record for better accuracy
+  legacyCaptureStarted = false;
+  lastMaestroRecordErrorLine = null;
+  baseScreenshotIntervalMs = 2e3;
+  maxScreenshotIntervalMs = 12e3;
+  currentScreenshotIntervalMs = this.baseScreenshotIntervalMs;
+  nextScreenshotAt = 0;
+  lastScreenshotHash = null;
+  unchangedScreenshotCount = 0;
+  screenshotBackoffThreshold = 3;
+  constructor() {
+    super();
+    this.loadPendingSession();
+  }
+  /**
+   * Check if maestro is available in system PATH
+   */
+  isMaestroInPath() {
+    try {
+      execSync2("which maestro", { encoding: "utf-8", timeout: 2e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  canRunMaestro(cmd) {
+    try {
+      execSync2(`"${cmd}" --version`, { encoding: "utf-8", timeout: 3e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  startLegacyCapture(deviceId, platform) {
+    if (platform === "android") {
+      if (!this.adbProcess) {
+        this.startAndroidEventCapture(deviceId);
+      }
+    } else {
+      this.startIOSEventCapture(deviceId);
+    }
+    this.legacyCaptureStarted = true;
+  }
+  fallbackToLegacyCapture(reason) {
+    if (!this.session || this.session.status !== "recording") return;
+    if (this.legacyCaptureStarted) return;
+    console.log(`[MaestroRecorder] Native record stopped (${reason}). Falling back to manual capture.`);
+    this.session.captureMode = "manual";
+    const stderrSuffix = this.lastMaestroRecordErrorLine ? ` | ${this.lastMaestroRecordErrorLine}` : "";
+    this.session.captureModeReason = `maestro record falhou (${reason})${stderrSuffix}`;
+    this.startLegacyCapture(this.session.deviceId, this.session.platform);
+  }
+  /**
+   * Save session state to disk for recovery after server restart
+   */
+  savePendingSession() {
+    if (!this.session) return;
+    try {
+      fs.writeFileSync(PENDING_SESSION_FILE, JSON.stringify(this.session, null, 2));
+    } catch (error) {
+      console.error("[MaestroRecorder] Failed to save pending session:", error);
+    }
+  }
+  /**
+   * Load pending session from disk (after server restart)
+   */
+  loadPendingSession() {
+    try {
+      if (fs.existsSync(PENDING_SESSION_FILE)) {
+        const data = fs.readFileSync(PENDING_SESSION_FILE, "utf8");
+        const savedSession = JSON.parse(data);
+        if (savedSession.status === "recording") {
+          console.log("[MaestroRecorder] Restoring pending session from disk:", savedSession.id);
+          this.session = savedSession;
+          this.actionCounter = savedSession.actions.length;
+        }
+      }
+    } catch (error) {
+      console.error("[MaestroRecorder] Failed to load pending session:", error);
+      try {
+        fs.unlinkSync(PENDING_SESSION_FILE);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Clear pending session file (after successful stop)
+   */
+  clearPendingSession() {
+    try {
+      if (fs.existsSync(PENDING_SESSION_FILE)) {
+        fs.unlinkSync(PENDING_SESSION_FILE);
+      }
+    } catch (error) {
+      console.error("[MaestroRecorder] Failed to clear pending session:", error);
+    }
+  }
+  /**
+   * Persist session metadata to session.json (available during recording)
+   */
+  async writeSessionMetadata() {
+    if (!this.session) return;
+    try {
+      const metadataPath = path.join(this.session.screenshotsDir, "..", "session.json");
+      await fs.promises.writeFile(metadataPath, JSON.stringify(this.session, null, 2));
+    } catch (error) {
+      console.error("[MaestroRecorder] Failed to write session metadata:", error);
+    }
+  }
+  /**
+   * Start recording a mobile session
+   */
+  async startRecording(name, deviceId, deviceName, platform, appId, options = {}) {
+    if (this.session?.status === "recording") {
+      const hasActiveProcesses = !!(this.videoProcess || this.maestroRecordProcess || this.adbProcess);
+      if (hasActiveProcesses) {
+        throw new Error("Recording already in progress");
+      }
+      console.log("[MaestroRecorder] Stale recording session detected. Clearing before starting a new one.");
+      this.session = null;
+      if (this.screenshotInterval) {
+        clearInterval(this.screenshotInterval);
+        this.screenshotInterval = null;
+      }
+      this.clearPendingSession();
+    }
+    const sessionId = `maestro_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const baseDir = path.join(PROJECTS_DIR, "maestro-recordings", sessionId);
+    const screenshotsDir = path.join(baseDir, "screenshots");
+    await fs.promises.mkdir(screenshotsDir, { recursive: true });
+    this.session = {
+      id: sessionId,
+      name,
+      startedAt: Date.now(),
+      appId,
+      deviceId,
+      deviceName,
+      platform,
+      actions: [],
+      screenshotsDir,
+      status: "recording"
+    };
+    this.actionCounter = 0;
+    try {
+      const adbCommand = platform === "android" ? getAdbCommandOrThrow() : null;
+      const flowPath = path.join(baseDir, "test.yaml");
+      this.session.flowPath = flowPath;
+      const videoPath = path.join(baseDir, "recording.mp4");
+      this.session.videoPath = videoPath;
+      const maestroHomePath = path.join(os.homedir(), ".maestro", "bin", "maestro");
+      const maestroPath = fs.existsSync(maestroHomePath) ? maestroHomePath : "maestro";
+      const maestroExists = fs.existsSync(maestroHomePath) || this.isMaestroInPath();
+      const maestroRunnable = maestroExists && this.canRunMaestro(maestroPath);
+      const preferNativeRecord = options.preferNativeRecord !== false;
+      const useNativeRecord = preferNativeRecord && this.useNativeMaestroRecord && maestroRunnable;
+      if (!maestroRunnable && this.useNativeMaestroRecord) {
+        console.log("[MaestroRecorder] \u26A0\uFE0F Maestro CLI not available or not runnable. Falling back to screenshot-based capture.");
+        console.log('[MaestroRecorder] Ensure Java is installed or reinstall Maestro: curl -Ls "https://get.maestro.mobile.dev" | bash');
+        this.session.captureModeReason = "Maestro CLI indispon\xEDvel/n\xE3o execut\xE1vel (verifique Java e reinstale o Maestro).";
+      }
+      if (!preferNativeRecord) {
+        console.log("[MaestroRecorder] Native record disabled for this session (manual capture mode).");
+        this.session.captureModeReason = "Native Maestro record desabilitado para esta sess\xE3o.";
+      }
+      let nativeRecordStarted = false;
+      this.legacyCaptureStarted = false;
+      if (useNativeRecord) {
+        console.log("[MaestroRecorder] Starting native maestro record...");
+        this.lastMaestroRecordErrorLine = null;
+        try {
+          const recordArgs = ["record", flowPath, "--device", deviceId];
+          this.maestroRecordProcess = spawn(maestroPath, recordArgs, {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env }
+          });
+          nativeRecordStarted = true;
+          this.maestroRecordProcess.stdout?.on("data", (data) => {
+            console.log("[MaestroRecord]", data.toString().trim());
+          });
+          this.maestroRecordProcess.stderr?.on("data", (data) => {
+            const text = data.toString().trim();
+            console.log("[MaestroRecord ERROR]", text);
+            const lastLine = text.split("\n").map((line) => line.trim()).filter(Boolean).pop();
+            if (lastLine) {
+              this.lastMaestroRecordErrorLine = lastLine;
+            }
+          });
+          this.maestroRecordProcess.on("error", (err) => {
+            console.log("[MaestroRecord] Spawn error:", err.message);
+            this.fallbackToLegacyCapture("spawn error");
+            this.maestroRecordProcess = null;
+          });
+          this.maestroRecordProcess.on("close", (code) => {
+            console.log(`[MaestroRecord] Process exited with code ${code}`);
+            this.fallbackToLegacyCapture(`exit code ${code}`);
+            this.maestroRecordProcess = null;
+          });
+        } catch (err) {
+          console.log("[MaestroRecorder] Failed to start native record, using legacy capture");
+          this.maestroRecordProcess = null;
+          nativeRecordStarted = false;
+          this.session.captureModeReason = err instanceof Error ? `Falha ao iniciar maestro record: ${err.message}` : "Falha ao iniciar maestro record";
+        }
+      }
+      this.session.captureMode = nativeRecordStarted ? "native" : "manual";
+      if (nativeRecordStarted) {
+        this.session.captureModeReason = void 0;
+      }
+      if (!nativeRecordStarted && this.session.flowPath) {
+        try {
+          const initialYaml = this.generateFlowYaml();
+          await fs.promises.writeFile(this.session.flowPath, initialYaml);
+        } catch (error) {
+          console.error("[MaestroRecorder] Failed to write initial flow YAML:", error);
+        }
+      }
+      await this.writeSessionMetadata();
+      if (nativeRecordStarted) {
+        if (platform === "ios") {
+          this.videoProcess = spawn("xcrun", ["simctl", "io", deviceId, "recordVideo", videoPath]);
+        } else {
+          const tempVideoPath = "/sdcard/maestro-recording.mp4";
+          this.videoProcess = spawn(adbCommand, ["-s", deviceId, "shell", "screenrecord", "--time-limit", "180", tempVideoPath]);
+        }
+      } else {
+        if (useNativeRecord) {
+          console.log("[MaestroRecorder] Native record failed to start, using legacy capture");
+        }
+        if (platform === "android") {
+          const tempVideoPath = "/sdcard/maestro-recording.mp4";
+          this.videoProcess = spawn(adbCommand, ["-s", deviceId, "shell", "screenrecord", "--time-limit", "180", tempVideoPath]);
+          this.startLegacyCapture(deviceId, platform);
+        } else {
+          this.videoProcess = spawn("xcrun", ["simctl", "io", deviceId, "recordVideo", videoPath]);
+          this.startLegacyCapture(deviceId, platform);
+        }
+      }
+      this.currentScreenshotIntervalMs = this.baseScreenshotIntervalMs;
+      this.nextScreenshotAt = 0;
+      this.lastScreenshotHash = null;
+      this.unchangedScreenshotCount = 0;
+      this.screenshotInterval = setInterval(() => {
+        this.captureScreenshot(void 0, { reason: "periodic" });
+      }, 2e3);
+      this.savePendingSession();
+      this.emit("status", "recording");
+      return this.session;
+    } catch (error) {
+      this.session.status = "error";
+      this.clearPendingSession();
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  /**
+   * Capture Android touch events via ADB
+   */
+  startAndroidEventCapture(deviceId) {
+    const adbCommand = getAdbCommand();
+    if (!adbCommand) {
+      console.error("[MaestroRecorder] ADB not found. Android event capture is unavailable.");
+      return;
+    }
+    exec(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(deviceId)} shell wm size`, (err, stdout) => {
+      if (err) return;
+      const match = stdout.match(/(\d+)x(\d+)/);
+      const screenWidth = match ? parseInt(match[1]) : 1080;
+      const screenHeight = match ? parseInt(match[2]) : 1920;
+      this.adbProcess = spawn(adbCommand, ["-s", deviceId, "shell", "getevent", "-lt"]);
+      let touchStartTime = 0;
+      let touchStartX = 0;
+      let touchStartY = 0;
+      let currentX = 0;
+      let currentY = 0;
+      let isTracking = false;
+      this.adbProcess.stdout?.on("data", (data) => {
+        const lines = data.toString().split("\n");
+        for (const line of lines) {
+          if (line.includes("ABS_MT_POSITION_X")) {
+            const match2 = line.match(/ABS_MT_POSITION_X\s+([0-9a-f]+)/i);
+            if (match2) {
+              currentX = Math.round(parseInt(match2[1], 16) / 32767 * screenWidth);
+            }
+          }
+          if (line.includes("ABS_MT_POSITION_Y")) {
+            const match2 = line.match(/ABS_MT_POSITION_Y\s+([0-9a-f]+)/i);
+            if (match2) {
+              currentY = Math.round(parseInt(match2[1], 16) / 32767 * screenHeight);
+            }
+          }
+          if (line.includes("BTN_TOUCH") && line.includes("DOWN")) {
+            touchStartTime = Date.now();
+            touchStartX = currentX;
+            touchStartY = currentY;
+            isTracking = true;
+          }
+          if (line.includes("BTN_TOUCH") && line.includes("UP") && isTracking) {
+            const duration = Date.now() - touchStartTime;
+            const deltaX = Math.abs(currentX - touchStartX);
+            const deltaY = Math.abs(currentY - touchStartY);
+            if (deltaX > 50 || deltaY > 50) {
+              this.recordAction({
+                type: "swipe",
+                x: touchStartX,
+                y: touchStartY,
+                endX: currentX,
+                endY: currentY,
+                duration,
+                description: `Swipe from (${touchStartX}, ${touchStartY}) to (${currentX}, ${currentY})`
+              });
+            } else if (duration > 500) {
+              this.recordAction({
+                type: "longPress",
+                x: touchStartX,
+                y: touchStartY,
+                duration,
+                description: `Long press at (${touchStartX}, ${touchStartY})`
+              });
+            } else {
+              this.recordAction({
+                type: "tap",
+                x: touchStartX,
+                y: touchStartY,
+                description: `Tap at (${touchStartX}, ${touchStartY})`
+              });
+            }
+            isTracking = false;
+          }
+          if (line.includes("KEY_BACK") && line.includes("DOWN")) {
+            this.recordAction({
+              type: "back",
+              description: "Press back button"
+            });
+          }
+          if (line.includes("KEY_HOME") && line.includes("DOWN")) {
+            this.recordAction({
+              type: "home",
+              description: "Press home button"
+            });
+          }
+        }
+      });
+    });
+  }
+  /**
+   * Capture iOS events (limited - mainly screenshots)
+   */
+  startIOSEventCapture(deviceId) {
+    console.log("[MaestroRecorder] iOS event capture started (screenshot-based)");
+  }
+  /**
+   * Record an action
+   */
+  async recordAction(actionData) {
+    if (!this.session || this.session.status !== "recording") return;
+    this.actionCounter++;
+    const actionId = `action_${this.actionCounter.toString().padStart(3, "0")}`;
+    const screenshotPath = await this.captureScreenshot(actionId, { force: true, reason: "action" });
+    const action = {
+      id: actionId,
+      type: actionData.type || "tap",
+      timestamp: Date.now(),
+      x: actionData.x,
+      y: actionData.y,
+      endX: actionData.endX,
+      endY: actionData.endY,
+      text: actionData.text,
+      direction: actionData.direction,
+      seconds: actionData.seconds,
+      appId: actionData.appId,
+      duration: actionData.duration,
+      description: actionData.description || actionData.type || "Action",
+      screenshotPath
+    };
+    this.session.actions.push(action);
+    this.emit("action", action);
+    console.log("[MaestroRecorder] Action captured:", action.type, action.description);
+    if (action.type === "launch") {
+      const launchAppId = action.appId || action.text;
+      if (launchAppId && !this.session.appId) {
+        this.session.appId = launchAppId;
+      }
+    }
+    const shouldWriteFlow = this.session.captureMode !== "native" || !this.maestroRecordProcess;
+    if (shouldWriteFlow && this.session.flowPath) {
+      try {
+        const flowYaml = this.generateFlowYaml();
+        await fs.promises.writeFile(this.session.flowPath, flowYaml);
+      } catch (error) {
+        console.error("[MaestroRecorder] Failed to update flow YAML during recording:", error);
+      }
+    }
+    await this.writeSessionMetadata();
+    this.savePendingSession();
+  }
+  /**
+   * Capture a screenshot
+   */
+  async captureScreenshot(name, options = {}) {
+    if (!this.session) return void 0;
+    const now = Date.now();
+    if (!options.force && now < this.nextScreenshotAt) {
+      return void 0;
+    }
+    const screenshotName = name ? `${name}.png` : `screenshot_${Date.now()}.png`;
+    const screenshotPath = path.join(this.session.screenshotsDir, screenshotName);
+    try {
+      if (this.session.platform === "android") {
+        const adbCommand = getAdbCommandOrThrow();
+        await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(this.session.deviceId)} exec-out screencap -p > "${screenshotPath}"`);
+      } else {
+        await execAsync(`xcrun simctl io ${this.session.deviceId} screenshot "${screenshotPath}"`);
+      }
+      const screenshotBuffer = await fs.promises.readFile(screenshotPath);
+      const screenshotHash = createHash("sha1").update(screenshotBuffer).digest("hex");
+      if (!options.force && this.lastScreenshotHash === screenshotHash) {
+        this.unchangedScreenshotCount += 1;
+        await fs.promises.unlink(screenshotPath);
+        if (this.unchangedScreenshotCount >= this.screenshotBackoffThreshold) {
+          this.currentScreenshotIntervalMs = Math.min(
+            this.currentScreenshotIntervalMs * 2,
+            this.maxScreenshotIntervalMs
+          );
+        }
+        this.nextScreenshotAt = now + this.currentScreenshotIntervalMs;
+        return void 0;
+      }
+      this.lastScreenshotHash = screenshotHash;
+      this.unchangedScreenshotCount = 0;
+      this.currentScreenshotIntervalMs = this.baseScreenshotIntervalMs;
+      this.nextScreenshotAt = now + this.currentScreenshotIntervalMs;
+      this.emit("screenshot", screenshotPath);
+      return screenshotPath;
+    } catch (error) {
+      console.error("Screenshot failed:", error);
+      return void 0;
+    }
+  }
+  /**
+   * Add a manual action (for iOS or user-initiated)
+   */
+  addManualAction(type, description, params) {
+    return this.recordAction({
+      type,
+      description,
+      ...params
+    });
+  }
+  /**
+   * Stop recording and generate outputs
+   */
+  async stopRecording() {
+    if (!this.session) throw new Error("No recording session");
+    this.session.status = "stopped";
+    this.session.endedAt = Date.now();
+    await killZombieMaestroProcesses();
+    if (this.adbProcess) {
+      this.adbProcess.kill();
+      this.adbProcess = null;
+    }
+    if (this.screenshotInterval) {
+      clearInterval(this.screenshotInterval);
+      this.screenshotInterval = null;
+    }
+    if (this.maestroRecordProcess) {
+      console.log("[MaestroRecorder] Stopping native maestro record...");
+      this.maestroRecordProcess.kill("SIGINT");
+      await new Promise((resolve2) => {
+        const timeout = setTimeout(() => {
+          console.log("[MaestroRecorder] Timeout waiting for maestro record, forcing kill");
+          this.maestroRecordProcess?.kill("SIGKILL");
+          resolve2();
+        }, 5e3);
+        this.maestroRecordProcess?.on("close", () => {
+          clearTimeout(timeout);
+          resolve2();
+        });
+      });
+      this.maestroRecordProcess = null;
+      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+      const recordedActions = this.session.actions;
+      let parsedActions = [];
+      if (this.session.flowPath && fs.existsSync(this.session.flowPath)) {
+        console.log("[MaestroRecorder] Reading generated YAML from:", this.session.flowPath);
+        try {
+          const yamlContent = await fs.promises.readFile(this.session.flowPath, "utf-8");
+          parsedActions = this.parseActionsFromYaml(yamlContent);
+          console.log(`[MaestroRecorder] Parsed ${parsedActions.length} actions from YAML`);
+          this.session.actions = this.mergeParsedActionsWithRecorded(parsedActions, recordedActions);
+        } catch (e) {
+          console.error("[MaestroRecorder] Failed to read/parse YAML:", e);
+        }
+      } else {
+        console.log("[MaestroRecorder] No YAML file found at:", this.session.flowPath);
+      }
+      const flowPath = this.session.flowPath || path.join(this.session.screenshotsDir, "..", "test.yaml");
+      if ((parsedActions.length === 0 || !fs.existsSync(flowPath)) && recordedActions.length > 0) {
+        const flowYaml = this.generateFlowYaml();
+        await fs.promises.writeFile(flowPath, flowYaml);
+        this.session.flowPath = flowPath;
+        this.session.actions = recordedActions;
+        console.log("[MaestroRecorder] Fallback YAML generated from recorded actions");
+      }
+    }
+    if (this.videoProcess) {
+      this.videoProcess.kill("SIGINT");
+      await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+      if (this.session.platform === "android" && this.session.videoPath) {
+        try {
+          const adbCommand = getAdbCommandOrThrow();
+          await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(this.session.deviceId)} pull /sdcard/maestro-recording.mp4 "${this.session.videoPath}"`);
+          await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(this.session.deviceId)} shell rm /sdcard/maestro-recording.mp4`);
+        } catch (e) {
+          console.error("Failed to pull video:", e);
+        }
+      }
+      this.videoProcess = null;
+    }
+    if (!this.session.flowPath || !fs.existsSync(this.session.flowPath)) {
+      if (this.session.actions.length > 0) {
+        const flowYaml = this.generateFlowYaml();
+        const fallbackFlowPath = path.join(this.session.screenshotsDir, "..", "test.yaml");
+        await fs.promises.writeFile(fallbackFlowPath, flowYaml);
+        this.session.flowPath = fallbackFlowPath;
+        console.log("[MaestroRecorder] Generated flow YAML from recorded actions");
+      }
+    }
+    if (this.session.actions.length === 0 && this.session.flowPath && fs.existsSync(this.session.flowPath)) {
+      try {
+        const fallbackYaml = await fs.promises.readFile(this.session.flowPath, "utf-8");
+        const parsedActions = parseMaestroActionsFromYaml(fallbackYaml);
+        if (parsedActions.length > 0) {
+          this.session.actions = parsedActions;
+          console.log(`[MaestroRecorder] Rehydrated ${parsedActions.length} actions from YAML for manual capture`);
+        }
+      } catch (error) {
+        console.error("[MaestroRecorder] Failed to rehydrate actions from YAML:", error);
+      }
+    }
+    const metadataPath = path.join(this.session.screenshotsDir, "..", "session.json");
+    await fs.promises.writeFile(metadataPath, JSON.stringify(this.session, null, 2));
+    this.clearPendingSession();
+    this.emit("status", "stopped");
+    this.emit("stopped", this.session);
+    const result = this.session;
+    this.session = null;
+    return result;
+  }
+  /**
+   * Parse actions from Maestro YAML content
+   */
+  parseActionsFromYaml(yamlContent) {
+    const parsedActions = parseMaestroActionsFromYaml(yamlContent);
+    const appIdMatch = yamlContent.match(/^\s*appId:\s*([^\n#]+)/m);
+    const parsedAppId = appIdMatch?.[1]?.trim().replace(/^["']|["']$/g, "") || "";
+    if (this.session && parsedAppId && !this.session.appId) {
+      this.session.appId = parsedAppId;
+    }
+    return parsedActions;
+  }
+  mergeParsedActionsWithRecorded(parsedActions, recordedActions) {
+    if (parsedActions.length === 0) return recordedActions;
+    if (recordedActions.length === 0) return parsedActions;
+    const recordedWithScreens = recordedActions.filter((action) => action.screenshotPath);
+    if (recordedWithScreens.length === 0) return parsedActions;
+    const shouldMapScreenshot = (action) => action.type === "tap" || action.type === "swipe" || action.type === "scroll" || action.type === "longPress" || action.type === "back" || action.type === "home" || action.type === "assert" || action.type === "wait";
+    let recordedIndex = 0;
+    return parsedActions.map((action) => {
+      if (!shouldMapScreenshot(action) || recordedIndex >= recordedWithScreens.length) {
+        return action;
+      }
+      const recorded = recordedWithScreens[recordedIndex++];
+      return {
+        ...recorded,
+        ...action,
+        id: recorded.id || action.id,
+        screenshotPath: recorded.screenshotPath,
+        x: action.x ?? recorded.x,
+        y: action.y ?? recorded.y,
+        endX: action.endX ?? recorded.endX,
+        endY: action.endY ?? recorded.endY,
+        text: action.text ?? recorded.text,
+        direction: action.direction ?? recorded.direction,
+        seconds: action.seconds ?? recorded.seconds,
+        appId: action.appId ?? recorded.appId,
+        duration: action.duration ?? recorded.duration,
+        timestamp: recorded.timestamp || action.timestamp,
+        description: action.description || recorded.description,
+        type: action.type
+      };
+    });
+  }
+  /**
+   * Generate Maestro YAML from recorded actions
+   */
+  generateFlowYaml() {
+    if (!this.session) return "";
+    const escapeYaml = (value) => value.replace(/"/g, '\\"');
+    const lines = [
+      `# Maestro Flow: ${this.session.name}`,
+      `# Recorded: ${new Date(this.session.startedAt).toISOString()}`,
+      `# Generated by DiscoveryLab`,
+      ``
+    ];
+    if (this.session.appId) {
+      lines.push(`appId: ${this.session.appId}`);
+      lines.push(``);
+    }
+    lines.push(`---`);
+    lines.push(``);
+    for (const action of this.session.actions) {
+      lines.push(`# ${action.description}`);
+      switch (action.type) {
+        case "tap":
+          if (action.text) {
+            lines.push(`- tapOn:`);
+            lines.push(`    text: "${escapeYaml(action.text)}"`);
+          } else if (action.x !== void 0 && action.y !== void 0) {
+            lines.push(`- tapOn:`);
+            lines.push(`    point: "${action.x},${action.y}"`);
+          }
+          break;
+        case "swipe":
+          if (action.x !== void 0 && action.y !== void 0 && action.endX !== void 0 && action.endY !== void 0) {
+            lines.push(`- swipe:`);
+            lines.push(`    start: "${action.x},${action.y}"`);
+            lines.push(`    end: "${action.endX},${action.endY}"`);
+            if (action.duration) {
+              lines.push(`    duration: ${action.duration}`);
+            }
+          } else if (action.direction) {
+            lines.push(`- swipe:`);
+            lines.push(`    direction: "${action.direction.toUpperCase()}"`);
+          }
+          break;
+        case "longPress":
+          if (action.x !== void 0 && action.y !== void 0) {
+            lines.push(`- longPressOn:`);
+            lines.push(`    point: "${action.x},${action.y}"`);
+          }
+          break;
+        case "input":
+          if (action.text) {
+            lines.push(`- inputText: "${escapeYaml(action.text)}"`);
+          }
+          break;
+        case "back":
+          lines.push(`- pressKey: back`);
+          break;
+        case "home":
+          lines.push(`- pressKey: home`);
+          break;
+        case "scroll":
+          if (action.direction && action.direction.toLowerCase() === "down") {
+            lines.push(`- scrollUntilVisible:`);
+            lines.push(`    element: ".*"`);
+            lines.push(`    direction: "DOWN"`);
+          } else {
+            lines.push(`- scroll`);
+          }
+          break;
+        case "launch": {
+          const launchAppId = action.appId || action.text;
+          if (launchAppId) {
+            lines.push(`- launchApp: "${escapeYaml(launchAppId)}"`);
+            if (!this.session.appId) {
+              this.session.appId = launchAppId;
+            }
+          } else {
+            lines.push(`- launchApp`);
+          }
+          break;
+        }
+        case "assert":
+          if (action.text) {
+            lines.push(`- assertVisible:`);
+            lines.push(`    text: "${escapeYaml(action.text)}"`);
+          }
+          break;
+        case "wait": {
+          const seconds = action.seconds && action.seconds > 0 ? Math.round(action.seconds) : 3;
+          lines.push(`- extendedWaitUntil:`);
+          lines.push(`    visible: ".*"`);
+          lines.push(`    timeout: ${seconds * 1e3}`);
+          break;
+        }
+        default:
+          lines.push(`# Unknown action: ${action.type}`);
+      }
+      lines.push(``);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get current session
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Check if recording is active
+   */
+  isRecording() {
+    return this.session?.status === "recording";
+  }
+};
+var maestroRecorderInstance = null;
+function getMaestroRecorder() {
+  if (!maestroRecorderInstance) {
+    maestroRecorderInstance = new MaestroRecorder();
+  }
+  return maestroRecorderInstance;
+}
+
+// src/core/integrations/esvp-local-device.ts
+var execFileAsync = promisify2(execFile);
+async function listDevicesForExecutor(executor) {
+  if (executor === "fake") return [];
+  const devices = await listMaestroDevices();
+  if (executor === "adb") {
+    return devices.filter((device) => device.platform === "android");
+  }
+  return devices.filter((device) => device.platform === "ios");
+}
+async function resolveDefaultDeviceId(executor) {
+  const devices = await listDevicesForExecutor(executor);
+  return devices[0]?.id || null;
+}
+async function runDeviceActionFlow(input) {
+  const appId = resolveFlowAppId(input.actions, input.meta, input.preflightConfig);
+  if (!appId) {
+    throw new Error("ESVP local requires an appId in session meta/preflight or a launch action before running device-backed actions.");
+  }
+  const flowDir = join3(input.runDir, "maestro");
+  const checkpointsDir = join3(input.runDir, "checkpoints");
+  await mkdir(flowDir, { recursive: true });
+  await mkdir(checkpointsDir, { recursive: true });
+  const flowPath = join3(flowDir, `session-${Date.now()}.yaml`);
+  const checkpointSpecs = [];
+  const steps = [];
+  steps.push(...buildPreflightSteps(input.preflightConfig, appId));
+  for (const [index, action] of input.actions.entries()) {
+    steps.push(...translateActionToMaestroSteps(action, appId));
+    if (action.checkpointAfter) {
+      const label = action.checkpointLabel || `${action.name}:${index + 1}`;
+      const relativePath = `checkpoints/${String(index + 1).padStart(3, "0")}-${slugify(label)}.png`;
+      const absPath = join3(input.runDir, relativePath);
+      steps.push(MaestroActions.takeScreenshot(absPath));
+      checkpointSpecs.push({
+        actionIndex: index,
+        label,
+        relativePath,
+        absPath
+      });
+    }
+  }
+  const flow = {
+    appId,
+    name: `ESVP ${input.sessionId}`,
+    steps
+  };
+  await writeFile(flowPath, generateMaestroFlow(flow), "utf8");
+  const result = await runMaestroTest({
+    flowPath,
+    device: input.deviceId,
+    outputDir: join3(flowDir, `output-${Date.now()}`),
+    timeout: 3e5
+  });
+  const checkpoints = [];
+  for (const spec of checkpointSpecs) {
+    if (!existsSync3(spec.absPath)) break;
+    const contents = await readFile(spec.absPath);
+    checkpoints.push({
+      ...spec,
+      sha256: createHash2("sha256").update(contents).digest("hex"),
+      bytes: contents.length
+    });
+  }
+  return {
+    success: result.success,
+    error: result.success ? null : result.error || result.output || "Maestro run failed",
+    output: typeof result.output === "string" ? result.output : result.error || null,
+    flowPath,
+    checkpoints,
+    executedActionCount: result.success ? input.actions.length : Math.min(input.actions.length, checkpoints.length),
+    appId
+  };
+}
+async function configureDeviceNetwork(executor, context, profile = {}) {
+  if (executor === "fake") {
+    context.networkProfile = profile;
+    return {
+      supported: true,
+      applied: true,
+      applied_features: ["simulated"],
+      unsupported_features: [],
+      warnings: [],
+      capabilities: networkCapabilitiesForExecutor(executor),
+      profile
+    };
+  }
+  if (executor === "adb") {
+    const applied2 = [];
+    const unsupported = [];
+    const warnings2 = [];
+    if (profile.connectivity === "offline") {
+      await setAndroidConnectivity(context, "offline");
+      applied2.push("offline");
+    } else if (profile.connectivity === "online" || profile.connectivity === "reset") {
+      await setAndroidConnectivity(context, "online");
+      applied2.push(String(profile.connectivity));
+    }
+    if (profile.proxy?.host && Number.isFinite(profile.proxy?.port) && profile.proxy.port > 0) {
+      await setAndroidHttpProxy(context, profile.proxy);
+      applied2.push("proxy");
+    } else if (profile.proxy === null && profile.connectivity === "reset") {
+      await clearAndroidHttpProxy(context);
+      applied2.push("proxy_cleared");
+    }
+    if (profile.faults?.delay_ms != null) unsupported.push("faults.delay_ms");
+    if (profile.faults?.timeout === true) unsupported.push("faults.timeout");
+    if (profile.faults?.offline_partial === true) unsupported.push("faults.offline_partial");
+    if (profile.faults?.status_code != null) unsupported.push("faults.status_code");
+    if (profile.faults?.body_patch != null) unsupported.push("faults.body_patch");
+    if (profile.capture?.enabled === true && profile.capture?.mode !== "esvp-managed-proxy") {
+      warnings2.push("capture.enabled was recorded, but external proxy traces still need to be attached via /network/trace");
+    }
+    context.networkProfile = profile;
+    return {
+      supported: true,
+      applied: applied2.length > 0,
+      applied_features: applied2,
+      unsupported_features: unsupported,
+      warnings: warnings2,
+      capabilities: networkCapabilitiesForExecutor(executor),
+      profile
+    };
+  }
+  const applied = [];
+  const warnings = [];
+  if (profile.proxy?.host && Number.isFinite(profile.proxy?.port) && profile.proxy.port > 0) {
+    await setMacHostHttpProxy(context, profile.proxy);
+    applied.push("proxy");
+    warnings.push("proxy was applied via macOS networksetup on the host, which temporarily affects host traffic during the session");
+  } else if (profile.proxy === null) {
+    await clearMacHostHttpProxy(context);
+    applied.push("proxy_cleared");
+  }
+  context.networkProfile = profile;
+  return {
+    supported: true,
+    applied: applied.length > 0,
+    applied_features: applied,
+    unsupported_features: [],
+    warnings,
+    capabilities: networkCapabilitiesForExecutor(executor),
+    profile
+  };
+}
+async function clearDeviceNetwork(executor, context) {
+  if (executor === "adb") {
+    await clearAndroidHttpProxy(context);
+    await setAndroidConnectivity(context, "online");
+  } else if (executor === "ios-sim" || executor === "maestro-ios") {
+    await clearMacHostHttpProxy(context);
+  }
+  context.networkProfile = null;
+  return {
+    supported: true,
+    cleared: true,
+    capabilities: networkCapabilitiesForExecutor(executor),
+    warnings: []
+  };
+}
+async function captureDeviceCheckpoint(input) {
+  await mkdir(dirname2(input.targetPath), { recursive: true });
+  if (input.executor === "adb") {
+    const adbCommand = getAdbCommand();
+    if (!adbCommand) {
+      return { success: false, error: "ADB not found. Set ANDROID_HOME/ANDROID_SDK_ROOT or add adb to PATH." };
+    }
+    const tempPath = "/sdcard/esvp-checkpoint.png";
+    try {
+      await execFileAsync(adbCommand, ["-s", input.deviceId, "shell", "screencap", "-p", tempPath], { timeout: 1e4 });
+      await execFileAsync(adbCommand, ["-s", input.deviceId, "pull", tempPath, input.targetPath], { timeout: 1e4 });
+      await execFileAsync(adbCommand, ["-s", input.deviceId, "shell", "rm", tempPath], { timeout: 5e3 }).catch(() => void 0);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  try {
+    await execFileAsync("xcrun", ["simctl", "io", input.deviceId, "screenshot", input.targetPath], { timeout: 1e4 });
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function collectExecutorDebugArtifact(input) {
+  if (input.executor === "adb" && input.context.deviceId) {
+    const adbCommand = getAdbCommand();
+    if (adbCommand) {
+      try {
+        const { stdout, stderr } = await execFileAsync(adbCommand, ["-s", input.context.deviceId, "logcat", "-d"], {
+          timeout: 1e4,
+          maxBuffer: 4 * 1024 * 1024
+        });
+        const content = [stdout, stderr].filter(Boolean).join("\n").trim();
+        if (content) {
+          return {
+            kind: "logcat",
+            content,
+            extension: "log"
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  const output = typeof input.context.lastRunOutput === "string" ? input.context.lastRunOutput.trim() : "";
+  if (!output) return null;
+  return {
+    kind: "debug_asset",
+    content: output,
+    extension: "txt"
+  };
+}
+function networkCapabilitiesForExecutor(executor) {
+  if (executor === "adb") {
+    return {
+      proxy: true,
+      connectivity: true,
+      delay: false,
+      loss: false,
+      timeout: false,
+      offline_partial: false,
+      status_code: false,
+      body_patch: false,
+      trace_attach: true,
+      capture: true
+    };
+  }
+  if (executor === "ios-sim" || executor === "maestro-ios") {
+    return {
+      proxy: true,
+      connectivity: false,
+      delay: false,
+      loss: false,
+      timeout: false,
+      offline_partial: false,
+      status_code: false,
+      body_patch: false,
+      trace_attach: true,
+      capture: true
+    };
+  }
+  return {
+    proxy: true,
+    connectivity: true,
+    delay: true,
+    loss: false,
+    timeout: true,
+    offline_partial: true,
+    status_code: true,
+    body_patch: true,
+    trace_attach: true,
+    capture: true
+  };
+}
+function buildPreflightSteps(config, appId) {
+  if (!config || typeof config !== "object") return [];
+  const steps = [];
+  const rules = Array.isArray(config.rules) ? config.rules : [];
+  for (const rule of rules) {
+    const kind = String(rule?.kind || "").trim().toLowerCase();
+    if (kind === "clear_data") {
+      steps.push(MaestroActions.clearState(String(config.appId || appId)));
+      continue;
+    }
+    if (kind === "wait_for_stable") {
+      steps.push(MaestroActions.waitForAnimationToEnd(1e3));
+      continue;
+    }
+  }
+  return steps;
+}
+function resolveFlowAppId(actions, meta, preflightConfig) {
+  const fromMeta = typeof meta?.appId === "string" ? meta.appId.trim() : typeof meta?.app_id === "string" ? String(meta.app_id).trim() : "";
+  if (fromMeta) return fromMeta;
+  const fromPreflight = typeof preflightConfig?.appId === "string" ? preflightConfig.appId.trim() : "";
+  if (fromPreflight) return fromPreflight;
+  for (const action of actions) {
+    if (action.name !== "launch") continue;
+    const appId = typeof action.args?.appId === "string" ? action.args.appId.trim() : "";
+    if (appId) return appId;
+  }
+  return "";
+}
+function translateActionToMaestroSteps(action, appId) {
+  const args = action.args || {};
+  switch (action.name) {
+    case "launch": {
+      const launchAppId = typeof args.appId === "string" && args.appId.trim() ? args.appId.trim() : appId;
+      return [MaestroActions.launchApp(launchAppId)];
+    }
+    case "tap": {
+      if (typeof args.selector === "string" && args.selector.trim()) {
+        return [MaestroActions.tapOn(args.selector.trim())];
+      }
+      if (typeof args.text === "string" && args.text.trim()) {
+        return [MaestroActions.tapOn(args.text.trim())];
+      }
+      if (typeof args.x === "number" && typeof args.y === "number") {
+        return [MaestroActions.tapOnPoint(Math.round(args.x), Math.round(args.y))];
+      }
+      throw new Error("ESVP tap action requires selector/text or x/y.");
+    }
+    case "type": {
+      const text = typeof args.text === "string" ? args.text : "";
+      if (!text) throw new Error("ESVP type action requires args.text.");
+      return [MaestroActions.inputText(text)];
+    }
+    case "back":
+      return [MaestroActions.back()];
+    case "home":
+      return [MaestroActions.pressKey("HOME")];
+    case "keyevent": {
+      const key = typeof args.key === "string" ? args.key : "";
+      if (!key) throw new Error("ESVP keyevent action requires args.key.");
+      return [MaestroActions.pressKey(key)];
+    }
+    case "wait": {
+      const ms = Number(args.ms);
+      return [MaestroActions.wait(Number.isFinite(ms) ? Math.max(0, Math.round(ms)) : 1e3)];
+    }
+    case "swipe": {
+      const direction = resolveSwipeDirection(args);
+      switch (direction) {
+        case "left":
+          return [MaestroActions.swipeLeft()];
+        case "right":
+          return [MaestroActions.swipeRight()];
+        case "up":
+          return [MaestroActions.swipeUp()];
+        case "down":
+          return [MaestroActions.swipeDown()];
+        default:
+          throw new Error("ESVP swipe action requires a direction or coordinates that can be resolved to a direction.");
+      }
+    }
+    default:
+      throw new Error(`ESVP action "${action.name}" is not supported by the local AppLab executor.`);
+  }
+}
+function resolveSwipeDirection(args) {
+  if (typeof args.direction === "string" && args.direction.trim()) {
+    const normalized = args.direction.trim().toLowerCase();
+    if (normalized === "left" || normalized === "right" || normalized === "up" || normalized === "down") {
+      return normalized;
+    }
+  }
+  if (typeof args.x1 === "number" && typeof args.y1 === "number" && typeof args.x2 === "number" && typeof args.y2 === "number") {
+    const deltaX = args.x2 - args.x1;
+    const deltaY = args.y2 - args.y1;
+    if (Math.abs(deltaX) >= Math.abs(deltaY)) {
+      return deltaX >= 0 ? "right" : "left";
+    }
+    return deltaY >= 0 ? "down" : "up";
+  }
+  return null;
+}
+async function setAndroidHttpProxy(context, proxy) {
+  const adbCommand = getAdbCommand();
+  if (!adbCommand) {
+    throw new Error("ADB not found. Set ANDROID_HOME/ANDROID_SDK_ROOT or add adb to PATH.");
+  }
+  if (!context.deviceId) {
+    throw new Error("Android proxy configuration requires a deviceId.");
+  }
+  const host = String(proxy.host || "").trim();
+  const port = Number(proxy.port);
+  if (!host || !Number.isFinite(port) || port <= 0) {
+    throw new Error("Invalid Android proxy host/port.");
+  }
+  const endpoint = `${host}:${Math.round(port)}`;
+  await execFileAsync(adbCommand, ["-s", context.deviceId, "shell", "settings", "put", "global", "http_proxy", endpoint], { timeout: 7e3 });
+  await execFileAsync(adbCommand, ["-s", context.deviceId, "shell", "settings", "put", "global", "global_http_proxy_host", host], { timeout: 7e3 });
+  await execFileAsync(adbCommand, ["-s", context.deviceId, "shell", "settings", "put", "global", "global_http_proxy_port", String(Math.round(port))], { timeout: 7e3 });
+  const bypass = Array.isArray(proxy.bypass) ? proxy.bypass.filter(Boolean).join(",") : "";
+  if (bypass) {
+    await execFileAsync(adbCommand, ["-s", context.deviceId, "shell", "settings", "put", "global", "global_http_proxy_exclusion_list", bypass], { timeout: 7e3 });
+  }
+}
+async function clearAndroidHttpProxy(context) {
+  const adbCommand = getAdbCommand();
+  if (!adbCommand || !context.deviceId) return;
+  const commands = [
+    ["-s", context.deviceId, "shell", "settings", "put", "global", "http_proxy", ":0"],
+    ["-s", context.deviceId, "shell", "settings", "delete", "global", "global_http_proxy_host"],
+    ["-s", context.deviceId, "shell", "settings", "delete", "global", "global_http_proxy_port"],
+    ["-s", context.deviceId, "shell", "settings", "delete", "global", "global_http_proxy_exclusion_list"]
+  ];
+  for (const command of commands) {
+    await execFileAsync(adbCommand, command, { timeout: 7e3 }).catch(() => void 0);
+  }
+}
+async function setAndroidConnectivity(context, mode) {
+  const adbCommand = getAdbCommand();
+  if (!adbCommand || !context.deviceId) return;
+  if (mode === "offline") {
+    await execFileAsync(adbCommand, ["-s", context.deviceId, "shell", "svc", "wifi", "disable"], { timeout: 7e3 }).catch(() => void 0);
+    await execFileAsync(adbCommand, ["-s", context.deviceId, "shell", "svc", "data", "disable"], { timeout: 7e3 }).catch(() => void 0);
+    return;
+  }
+  await execFileAsync(adbCommand, ["-s", context.deviceId, "shell", "svc", "wifi", "enable"], { timeout: 7e3 }).catch(() => void 0);
+  await execFileAsync(adbCommand, ["-s", context.deviceId, "shell", "svc", "data", "enable"], { timeout: 7e3 }).catch(() => void 0);
+}
+async function setMacHostHttpProxy(context, proxy) {
+  const host = String(proxy.host || "").trim();
+  const port = Number(proxy.port);
+  if (!host || !Number.isFinite(port) || port <= 0) {
+    throw new Error("Invalid macOS proxy host/port.");
+  }
+  const iface = await detectActiveNetworkInterface();
+  const saved = await saveCurrentProxySettings(iface);
+  context._macosProxyBackup = saved;
+  context._macosProxyInterface = iface;
+  const portStr = String(Math.round(port));
+  await execFileAsync("networksetup", ["-setwebproxy", iface, host, portStr], { timeout: 5e3 });
+  await execFileAsync("networksetup", ["-setsecurewebproxy", iface, host, portStr], { timeout: 5e3 });
+  const { stdout } = await execFileAsync("networksetup", ["-getwebproxy", iface], { timeout: 5e3 });
+  const verify = String(stdout || "");
+  if (!verify.includes("Enabled: Yes") || !verify.includes(host)) {
+    throw new Error(`Failed to verify host proxy on macOS network service ${iface}.`);
+  }
+}
+async function clearMacHostHttpProxy(context) {
+  const iface = context._macosProxyInterface;
+  const saved = context._macosProxyBackup;
+  if (!iface) return;
+  if (saved?.http?.enabled) {
+    await execFileAsync("networksetup", ["-setwebproxy", iface, saved.http.server || "", saved.http.port || "0"], { timeout: 5e3 }).catch(() => void 0);
+  } else {
+    await execFileAsync("networksetup", ["-setwebproxystate", iface, "off"], { timeout: 5e3 }).catch(() => void 0);
+  }
+  if (saved?.https?.enabled) {
+    await execFileAsync("networksetup", ["-setsecurewebproxy", iface, saved.https.server || "", saved.https.port || "0"], { timeout: 5e3 }).catch(() => void 0);
+  } else {
+    await execFileAsync("networksetup", ["-setsecurewebproxystate", iface, "off"], { timeout: 5e3 }).catch(() => void 0);
+  }
+  delete context._macosProxyBackup;
+  delete context._macosProxyInterface;
+}
+async function detectActiveNetworkInterface() {
+  const { stdout } = await execFileAsync("networksetup", ["-listallnetworkservices"], { timeout: 5e3 });
+  const services = String(stdout || "").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("*") && !line.startsWith("An asterisk"));
+  const preferred = ["Wi-Fi", "Ethernet", "USB 10/100/1000 LAN", "Thunderbolt Ethernet"];
+  for (const service of [...preferred, ...services.filter((candidate) => !preferred.includes(candidate))]) {
+    if (!services.includes(service)) continue;
+    try {
+      const { stdout: info } = await execFileAsync("networksetup", ["-getinfo", service], { timeout: 5e3 });
+      if (/IP address:\s*\d+\.\d+/.test(String(info || ""))) {
+        return service;
+      }
+    } catch {
+    }
+  }
+  throw new Error("No active macOS network service was found via networksetup.");
+}
+async function saveCurrentProxySettings(iface) {
+  const parseProxyOutput = (stdout) => {
+    const lines = String(stdout || "").split("\n");
+    const get = (key) => {
+      const line = lines.find((candidate) => candidate.toLowerCase().startsWith(`${key.toLowerCase()}:`));
+      return line ? line.split(":").slice(1).join(":").trim() : "";
+    };
+    return {
+      enabled: get("Enabled") === "Yes",
+      server: get("Server") || "",
+      port: get("Port") || "0"
+    };
+  };
+  const { stdout: httpOut } = await execFileAsync("networksetup", ["-getwebproxy", iface], { timeout: 5e3 });
+  const { stdout: httpsOut } = await execFileAsync("networksetup", ["-getsecurewebproxy", iface], { timeout: 5e3 });
+  return {
+    http: parseProxyOutput(String(httpOut || "")),
+    https: parseProxyOutput(String(httpsOut || ""))
+  };
+}
+function slugify(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "checkpoint";
+}
+
+// src/core/integrations/esvp-managed-proxy.ts
+import http from "http";
+import net from "net";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function randomId(prefix) {
+  return `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
+}
+var ESVPManagedProxyManager = class {
+  bindHost;
+  defaultAdvertiseHost;
+  proxies = /* @__PURE__ */ new Map();
+  defaultBodyCaptureBytes;
+  constructor(options = {}) {
+    this.bindHost = String(options.bindHost || "127.0.0.1");
+    this.defaultAdvertiseHost = normalizeOptionalString(options.advertiseHost);
+    this.defaultBodyCaptureBytes = clampInt(options.maxBodyCaptureBytes, 2048, 131072, 16384);
+  }
+  shouldManageProfile(profile = {}) {
+    const captureMode = String(profile.capture?.mode || "").trim().toLowerCase();
+    return captureMode === "esvp-managed-proxy" || captureMode === "esvp-proxy" || (profile.capture?.enabled === true || hasAdvancedFaults(profile)) && !hasExplicitProxy(profile);
+  }
+  async configureSessionProxy(input) {
+    const existing = this.proxies.get(input.sessionId) || null;
+    if (existing) {
+      existing.profile = input.profile || {};
+      return {
+        managed: true,
+        proxy: existing.publicState(),
+        capabilities: managedProxyCapabilities(),
+        effectiveProfile: {
+          ...input.profile || {},
+          proxy: {
+            ...normalizeProxyShape(input.profile?.proxy),
+            host: existing.advertiseHost,
+            port: existing.port,
+            protocol: "http"
+          },
+          capture: {
+            ...input.profile?.capture || {},
+            enabled: true,
+            mode: "esvp-managed-proxy"
+          }
+        }
+      };
+    }
+    const proxy = new ManagedSessionProxy({
+      sessionId: input.sessionId,
+      profile: input.profile || {},
+      bindHost: normalizeOptionalString(input.profile?.proxy?.bind_host) || this.bindHost,
+      advertiseHost: normalizeOptionalString(input.profile?.proxy?.advertise_host) || inferAdvertiseHost(input.profile, input.session) || this.defaultAdvertiseHost || inferSessionAdvertiseHost(input.session) || "127.0.0.1",
+      maxBodyCaptureBytes: this.defaultBodyCaptureBytes
+    });
+    await proxy.start();
+    this.proxies.set(input.sessionId, proxy);
+    return {
+      managed: true,
+      proxy: proxy.publicState(),
+      capabilities: managedProxyCapabilities(),
+      effectiveProfile: {
+        ...input.profile || {},
+        proxy: {
+          ...normalizeProxyShape(input.profile?.proxy),
+          host: proxy.advertiseHost,
+          port: proxy.port,
+          protocol: "http"
+        },
+        capture: {
+          ...input.profile?.capture || {},
+          enabled: true,
+          mode: "esvp-managed-proxy"
+        }
+      }
+    };
+  }
+  getSessionProxy(sessionId) {
+    return this.proxies.get(sessionId)?.publicState() || null;
+  }
+  async releaseSessionProxy(sessionId, options = {}) {
+    const proxy = this.proxies.get(sessionId);
+    if (!proxy) {
+      return {
+        managed: false,
+        traces: [],
+        proxy: null
+      };
+    }
+    this.proxies.delete(sessionId);
+    const traces = proxy.snapshotTraceEntries({
+      reason: options.reason || "released"
+    });
+    await proxy.stop();
+    return {
+      managed: true,
+      traces,
+      proxy: proxy.publicState({ active: false })
+    };
+  }
+};
+var ManagedSessionProxy = class {
+  id = randomId("proxy");
+  sessionId;
+  profile;
+  bindHost;
+  advertiseHost;
+  maxBodyCaptureBytes;
+  entries = [];
+  server = null;
+  startedAt = null;
+  port = null;
+  seq = 0;
+  constructor(options) {
+    this.sessionId = String(options.sessionId);
+    this.profile = options.profile || {};
+    this.bindHost = String(options.bindHost || "127.0.0.1");
+    this.advertiseHost = String(options.advertiseHost || this.bindHost);
+    this.maxBodyCaptureBytes = clampInt(options.maxBodyCaptureBytes, 2048, 131072, 16384);
+  }
+  async start() {
+    if (this.server) return;
+    this.server = http.createServer();
+    this.server.on("request", (req, res) => {
+      void this.handleHttpRequest(req, res).catch((error) => {
+        if (!res.headersSent) {
+          res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+        }
+        res.end(`ESVP proxy error: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    });
+    this.server.on("connect", (req, clientSocket, head) => {
+      void this.handleConnect(req, clientSocket, head).catch(() => {
+        try {
+          clientSocket.destroy();
+        } catch {
+        }
+      });
+    });
+    await new Promise((resolveListen, rejectListen) => {
+      const onError = (error) => {
+        this.server?.off("listening", onListening);
+        rejectListen(error);
+      };
+      const onListening = () => {
+        this.server?.off("error", onError);
+        resolveListen();
+      };
+      this.server?.once("error", onError);
+      this.server?.once("listening", onListening);
+      this.server?.listen(0, this.bindHost);
+    });
+    const address = this.server.address();
+    this.port = typeof address === "object" && address && "port" in address ? Number(address.port) : null;
+    this.startedAt = nowIso();
+    this.server.unref();
+  }
+  async stop() {
+    if (!this.server) return;
+    const server = this.server;
+    this.server = null;
+    await new Promise((resolveClose) => {
+      server.close(() => resolveClose());
+    });
+  }
+  publicState(options = {}) {
+    return {
+      id: this.id,
+      active: options.active === false ? false : Boolean(this.server),
+      bind_host: this.bindHost,
+      host: this.advertiseHost,
+      port: this.port,
+      url: this.port ? `http://${this.advertiseHost}:${this.port}` : null,
+      started_at: this.startedAt,
+      entry_count: this.entries.length,
+      capture_mode: "esvp-managed-proxy"
+    };
+  }
+  snapshotTraceEntries(options = {}) {
+    if (!this.entries.length) return [];
+    return [
+      {
+        trace_kind: "http_trace",
+        label: options.reason ? `managed-proxy-${slugify2(options.reason)}` : "managed-proxy",
+        format: "json",
+        source: "esvp-managed-proxy",
+        payload: {
+          session_id: this.sessionId,
+          proxy_id: this.id,
+          generated_at: nowIso(),
+          entries: this.entries.map((entry) => JSON.parse(JSON.stringify(entry)))
+        },
+        artifactMeta: {
+          capture_mode: "esvp-managed-proxy",
+          proxy_id: this.id,
+          entry_count: this.entries.length
+        }
+      }
+    ];
+  }
+  async handleHttpRequest(clientReq, clientRes) {
+    const entry = this.createBaseEntry({
+      kind: "request",
+      method: clientReq.method || "GET",
+      url: inferProxyRequestUrl(clientReq)
+    });
+    const body = await readStreamBuffer(clientReq, this.maxBodyCaptureBytes);
+    entry.request = {
+      url: entry.url,
+      method: entry.method,
+      headers: redactHeaders(clientReq.headers),
+      startedAt: entry.startedAt,
+      bodyPreview: previewBody(body),
+      bodyBytes: body.length
+    };
+    const fault = await maybeApplyFaults({
+      profile: this.profile,
+      entry,
+      respondHttp: async ({ statusCode, headers, bodyText, delayMs = 0 }) => {
+        if (delayMs > 0) await sleep(delayMs);
+        clientRes.writeHead(statusCode, headers);
+        clientRes.end(bodyText);
+      },
+      abortHttp: async ({ delayMs = 0, errorText = "ESVP_PROXY_ABORT" }) => {
+        if (delayMs > 0) await sleep(delayMs);
+        clientReq.destroy(new Error(errorText));
+        clientRes.destroy(new Error(errorText));
+      }
+    });
+    if (fault.handled) {
+      entry.finishedAt = Date.now();
+      entry.durationMs = Math.max(0, entry.finishedAt - entry.startedAt);
+      this.entries.push(entry);
+      return;
+    }
+    const targetUrl = new URL(entry.url);
+    const upstreamReq = http.request(
+      {
+        protocol: targetUrl.protocol,
+        hostname: targetUrl.hostname,
+        port: targetUrl.port || 80,
+        method: entry.method,
+        path: `${targetUrl.pathname}${targetUrl.search}`,
+        headers: filterHopByHopHeaders(clientReq.headers)
+      },
+      async (upstreamRes) => {
+        const responseBody = await readStreamBuffer(upstreamRes, this.maxBodyCaptureBytes);
+        entry.status = upstreamRes.statusCode || null;
+        entry.ok = typeof upstreamRes.statusCode === "number" ? upstreamRes.statusCode < 400 : null;
+        entry.response = {
+          status: upstreamRes.statusCode || null,
+          headers: redactHeaders(upstreamRes.headers),
+          durationMs: Math.max(0, Date.now() - entry.startedAt),
+          size: responseBody.length,
+          contentType: headerValue(upstreamRes.headers["content-type"]),
+          bodyPreview: previewBody(responseBody)
+        };
+        entry.finishedAt = Date.now();
+        entry.durationMs = Math.max(0, entry.finishedAt - entry.startedAt);
+        clientRes.writeHead(upstreamRes.statusCode || 502, filterHopByHopHeaders(upstreamRes.headers));
+        clientRes.end(responseBody);
+        this.entries.push(entry);
+      }
+    );
+    upstreamReq.on("error", (error) => {
+      entry.finishedAt = Date.now();
+      entry.durationMs = Math.max(0, entry.finishedAt - entry.startedAt);
+      entry.failureText = error instanceof Error ? error.message : String(error);
+      entry.response = {
+        error: entry.failureText
+      };
+      if (!clientRes.headersSent) {
+        clientRes.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+      }
+      clientRes.end(`ESVP upstream error: ${entry.failureText}`);
+      this.entries.push(entry);
+    });
+    if (body.length) upstreamReq.write(body);
+    upstreamReq.end();
+  }
+  async handleConnect(req, clientSocket, head) {
+    const authority = String(req.url || "");
+    const [hostname, portRaw] = authority.split(":");
+    const port = Number(portRaw || 443);
+    const entry = this.createBaseEntry({
+      kind: "connect",
+      method: "CONNECT",
+      url: `https://${authority}`
+    });
+    entry.request = {
+      url: entry.url,
+      method: "CONNECT",
+      headers: redactHeaders(req.headers),
+      startedAt: entry.startedAt
+    };
+    const fault = await maybeApplyFaults({
+      profile: this.profile,
+      entry,
+      respondConnect: async ({ delayMs = 0, statusCode = 502, message = "Bad Gateway" }) => {
+        if (delayMs > 0) await sleep(delayMs);
+        clientSocket.write(`HTTP/1.1 ${statusCode} ${message}\r
+Connection: close\r
+\r
+`);
+        clientSocket.destroy();
+      },
+      abortConnect: async ({ delayMs = 0 }) => {
+        if (delayMs > 0) await sleep(delayMs);
+        clientSocket.destroy();
+      }
+    });
+    if (fault.handled) {
+      entry.finishedAt = Date.now();
+      entry.durationMs = Math.max(0, entry.finishedAt - entry.startedAt);
+      this.entries.push(entry);
+      return;
+    }
+    const upstreamSocket = net.connect(port, hostname, () => {
+      clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+      if (head && head.length > 0) {
+        upstreamSocket.write(head);
+      }
+      upstreamSocket.pipe(clientSocket);
+      clientSocket.pipe(upstreamSocket);
+      entry.status = 200;
+      entry.ok = true;
+      entry.response = {
+        status: 200
+      };
+    });
+    const finalize = (error = null) => {
+      if (entry.finishedAt) return;
+      entry.finishedAt = Date.now();
+      entry.durationMs = Math.max(0, entry.finishedAt - entry.startedAt);
+      if (error) {
+        entry.failureText = error instanceof Error ? error.message : String(error);
+        entry.response = {
+          ...entry.response || {},
+          error: entry.failureText
+        };
+      }
+      this.entries.push(entry);
+    };
+    upstreamSocket.on("error", (error) => {
+      finalize(error);
+      try {
+        clientSocket.destroy(error);
+      } catch {
+      }
+    });
+    clientSocket.on("error", (error) => finalize(error));
+    upstreamSocket.on("close", () => finalize());
+    clientSocket.on("close", () => finalize());
+  }
+  createBaseEntry(input) {
+    this.seq += 1;
+    return {
+      id: `${this.id}-${String(this.seq).padStart(4, "0")}`,
+      kind: input.kind,
+      resourceType: input.kind === "connect" ? "connect_tunnel" : "request",
+      method: String(input.method || "GET").toUpperCase(),
+      url: input.url,
+      startedAt: Date.now(),
+      sessionId: this.sessionId,
+      proxyId: this.id
+    };
+  }
+};
+async function maybeApplyFaults(input) {
+  const faults = input.profile?.faults || {};
+  const delayMs = clampInt(faults.delay_ms, 0, 6e4, 0);
+  if (faults.offline_partial === true && shouldFailOfflinePartial(input.entry)) {
+    input.entry.failureText = "ESVP_PROXY_OFFLINE_PARTIAL";
+    if (input.entry.method === "CONNECT") {
+      await input.abortConnect?.({ delayMs });
+    } else {
+      await input.abortHttp?.({ delayMs, errorText: "ESVP_PROXY_OFFLINE_PARTIAL" });
+    }
+    return { handled: true };
+  }
+  if (faults.timeout === true) {
+    input.entry.failureText = "ESVP_PROXY_TIMEOUT";
+    if (input.entry.method === "CONNECT") {
+      await input.abortConnect?.({ delayMs: Math.max(delayMs, 15e3) });
+    } else {
+      await input.abortHttp?.({ delayMs: Math.max(delayMs, 15e3), errorText: "ESVP_PROXY_TIMEOUT" });
+    }
+    return { handled: true };
+  }
+  if (input.entry.method !== "CONNECT" && Number.isFinite(faults.status_code) && faults.status_code > 0) {
+    const statusCode = Math.max(100, Math.min(599, Number(faults.status_code)));
+    const bodyText = faults.body_patch != null ? typeof faults.body_patch === "string" ? faults.body_patch : JSON.stringify(faults.body_patch, null, 2) : "";
+    input.entry.status = statusCode;
+    input.entry.ok = statusCode < 400;
+    input.entry.response = {
+      status: statusCode,
+      headers: {
+        "content-type": typeof faults.body_patch === "object" ? "application/json; charset=utf-8" : "text/plain; charset=utf-8",
+        "x-esvp-fault": "status_code"
+      },
+      durationMs: delayMs,
+      size: Buffer.byteLength(bodyText),
+      bodyPreview: previewBody(Buffer.from(bodyText, "utf8"))
+    };
+    await input.respondHttp?.({
+      statusCode,
+      delayMs,
+      headers: input.entry.response.headers,
+      bodyText
+    });
+    return { handled: true };
+  }
+  if (delayMs > 0) {
+    await sleep(delayMs);
+  }
+  return { handled: false };
+}
+function shouldFailOfflinePartial(entry) {
+  const idNum = Number(String(entry.id || "").split("-").pop());
+  return Number.isFinite(idNum) ? idNum % 2 === 0 : false;
+}
+function inferProxyRequestUrl(req) {
+  const raw = String(req.url || "");
+  if (/^https?:\/\//i.test(raw)) return raw;
+  const host = headerValue(req.headers.host) || "127.0.0.1";
+  return `http://${host}${raw.startsWith("/") ? raw : `/${raw}`}`;
+}
+function filterHopByHopHeaders(headers = {}) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers || {})) {
+    const lower = String(key).toLowerCase();
+    if (lower === "proxy-connection" || lower === "connection" || lower === "keep-alive" || lower === "transfer-encoding" || lower === "te" || lower === "trailer" || lower === "upgrade" || lower === "proxy-authorization") {
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function redactHeaders(headers = {}) {
+  const output = {};
+  for (const [key, value] of Object.entries(headers || {})) {
+    const lower = String(key).toLowerCase();
+    if (lower === "authorization" || lower === "proxy-authorization" || lower === "cookie" || lower === "set-cookie") {
+      output[key] = "[redacted]";
+      continue;
+    }
+    output[key] = Array.isArray(value) ? value.join(", ") : value != null ? String(value) : null;
+  }
+  return output;
+}
+function headerValue(value) {
+  if (Array.isArray(value)) return value[0] || null;
+  return value != null ? String(value) : null;
+}
+async function readStreamBuffer(stream, limitBytes) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of stream) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    total += buffer.length;
+    if (total <= limitBytes) {
+      chunks.push(buffer);
+    }
+  }
+  return Buffer.concat(chunks);
+}
+function previewBody(buffer) {
+  if (!buffer || buffer.length === 0) return null;
+  return buffer.toString("utf8").slice(0, 1024);
+}
+function hasExplicitProxy(profile = {}) {
+  return Boolean(profile?.proxy?.host) && Number.isFinite(profile?.proxy?.port) && Number(profile.proxy.port) > 0;
+}
+function hasAdvancedFaults(profile = {}) {
+  const faults = profile?.faults || {};
+  return Boolean(
+    faults.delay_ms != null || faults.timeout === true || faults.offline_partial === true || faults.status_code != null || faults.body_patch != null
+  );
+}
+function normalizeProxyShape(proxy = null) {
+  if (!proxy || typeof proxy !== "object") {
+    return {
+      host: null,
+      port: null,
+      protocol: "http",
+      bypass: []
+    };
+  }
+  return {
+    host: normalizeOptionalString(proxy.host),
+    port: Number.isFinite(proxy.port) ? Number(proxy.port) : null,
+    protocol: normalizeOptionalString(proxy.protocol) || "http",
+    bypass: Array.isArray(proxy.bypass) ? proxy.bypass.map((value) => String(value)) : []
+  };
+}
+function inferAdvertiseHost(profile = {}, session) {
+  return normalizeOptionalString(profile?.proxy?.advertise_host) || inferSessionAdvertiseHost(session);
+}
+function inferSessionAdvertiseHost(session) {
+  const deviceId = String(session?.context?.deviceId || "");
+  if (deviceId.startsWith("emulator-")) return "10.0.2.2";
+  return null;
+}
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+function clampInt(value, min, max, fallback) {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return fallback;
+  return Math.max(min, Math.min(max, Math.round(num)));
+}
+function slugify2(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "trace";
+}
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function managedProxyCapabilities() {
+  return {
+    proxy: true,
+    connectivity: false,
+    delay: true,
+    loss: false,
+    timeout: true,
+    offline_partial: true,
+    status_code: true,
+    body_patch: true,
+    trace_attach: true,
+    capture: true,
+    mode: "esvp-managed-proxy"
+  };
+}
+
+// src/core/integrations/esvp-local-runtime.ts
+var execFileAsync2 = promisify3(execFile2);
+var LOCAL_ESVP_SERVER_URL = "applab://local-esvp";
+var LOCAL_RUNTIME_ROOT = join4(DATA_DIR, "esvp-local");
+var LOCAL_RUNS_ROOT = join4(LOCAL_RUNTIME_ROOT, "runs");
+var runtimePromise = null;
+var cleanupRegistered = false;
+async function getAppLabESVPLocalRuntime() {
+  if (!runtimePromise) {
+    runtimePromise = (async () => {
+      const runtime = new AppLabESVPLocalRuntime();
+      await runtime.init();
+      runtime.registerCleanupHooks();
+      return runtime;
+    })().catch((error) => {
+      runtimePromise = null;
+      throw error;
+    });
+  }
+  return runtimePromise;
+}
+var AppLabESVPLocalRuntime = class {
+  rootDir = LOCAL_RUNS_ROOT;
+  sessions = /* @__PURE__ */ new Map();
+  managedProxyManager = new ESVPManagedProxyManager();
+  async init() {
+    await mkdir2(this.rootDir, { recursive: true });
+    await this.loadPersistedSessions();
+  }
+  registerCleanupHooks() {
+    if (cleanupRegistered) return;
+    cleanupRegistered = true;
+    const cleanup = async () => {
+      await this.cleanupTransientSystemState().catch(() => void 0);
+    };
+    process.once("beforeExit", () => {
+      void cleanup();
+    });
+    process.once("SIGINT", () => {
+      void cleanup().finally(() => process.exit(0));
+    });
+    process.once("SIGTERM", () => {
+      void cleanup().finally(() => process.exit(0));
+    });
+  }
+  async getHealth() {
+    return {
+      ok: true,
+      service: "applab-esvp-local",
+      version: APP_VERSION,
+      auth: { enabled: false },
+      limits: {
+        max_body_bytes: 10 * 1024 * 1024
+      },
+      managed_proxy: {
+        bind_host: "127.0.0.1",
+        advertise_host: null
+      }
+    };
+  }
+  listSessions() {
+    return [...this.sessions.values()].map((session) => this.publicSession(session)).sort((a, b) => String(b.created_at || "").localeCompare(String(a.created_at || "")));
+  }
+  async createSession(input) {
+    const executorName = normalizeExecutor(input.executor);
+    const sessionId = input.sessionId || randomId2("sess");
+    if (this.sessions.has(sessionId)) {
+      throw new Error(`session_id already exists: ${sessionId}`);
+    }
+    const runDir = resolve(this.rootDir, sessionId);
+    await mkdir2(runDir, { recursive: true });
+    const resolvedDeviceId = input.deviceId || await resolveDefaultDeviceId(executorName);
+    const meta = sanitizeMeta({
+      ...input.meta || {},
+      ...input.crash_clip ? { crash_clip: input.crash_clip } : {}
+    });
+    const transcript = [
+      {
+        t: 0,
+        type: "session_started",
+        session_id: sessionId,
+        target: targetForExecutor(executorName),
+        meta: {
+          executor: executorName,
+          ...meta,
+          ...resolvedDeviceId ? { deviceId: resolvedDeviceId } : {}
+        }
+      }
+    ];
+    const session = {
+      id: sessionId,
+      executorName,
+      context: {
+        deviceId: resolvedDeviceId || null,
+        target: targetForExecutor(executorName),
+        runDir,
+        appId: resolveMetaAppId(meta),
+        preflightConfig: null,
+        networkProfile: null,
+        lastRunOutput: null,
+        lastFlowPath: null,
+        lastRunFailed: false
+      },
+      createdAt: nowIso2(),
+      updatedAt: nowIso2(),
+      status: "running",
+      error: null,
+      recovered: false,
+      meta,
+      runDir,
+      transcriptPath: resolve(runDir, "transcript.jsonl"),
+      transcriptPathRelative: relativeRunsPath(this.rootDir, runDir, "transcript.jsonl"),
+      manifestPath: resolve(runDir, "session.json"),
+      manifestPathRelative: relativeRunsPath(this.rootDir, runDir, "session.json"),
+      transcript,
+      actionCount: 0,
+      checkpointCount: 0,
+      artifactCount: 0,
+      network: createInitialNetworkState(executorName)
+    };
+    this.sessions.set(sessionId, session);
+    await this.persistSessionState(session);
+    return this.publicSession(session);
+  }
+  getSession(sessionId) {
+    return this.publicSession(this.requireSession(sessionId));
+  }
+  getTranscript(sessionId) {
+    const session = this.requireSession(sessionId);
+    return {
+      session_id: session.id,
+      status: session.status,
+      transcript_path: session.transcriptPathRelative,
+      events: session.transcript
+    };
+  }
+  listArtifacts(sessionId) {
+    const session = this.requireSession(sessionId);
+    return session.transcript.filter((event) => event.type === "artifact").map((event) => ({
+      t: event.t,
+      kind: event.kind,
+      path: event.path,
+      sha256: event.sha256,
+      bytes: event.bytes,
+      meta: event.meta || null,
+      abs_path: resolve(session.runDir, event.path)
+    }));
+  }
+  async getArtifactContent(sessionId, artifactPath) {
+    const resolved = this.resolveSessionArtifactPath(sessionId, artifactPath);
+    const ext = extname(resolved.absPath).toLowerCase();
+    const data = await readFile2(resolved.absPath);
+    if (ext === ".json" || ext === ".har" || ext.endsWith(".json")) {
+      try {
+        return JSON.parse(data.toString("utf8"));
+      } catch {
+        return data.toString("utf8");
+      }
+    }
+    if (ext === ".txt" || ext === ".log" || ext === ".jsonl" || ext === ".xml" || ext === ".yaml" || ext === ".yml") {
+      return data.toString("utf8");
+    }
+    return {
+      encoding: "base64",
+      bytes: data.length,
+      content_base64: data.toString("base64"),
+      path: resolved.path
+    };
+  }
+  async runPreflight(sessionId, preflightConfig) {
+    const session = this.requireMutableSession(sessionId);
+    if (!preflightConfig || typeof preflightConfig !== "object") {
+      throw new Error("Invalid preflight config");
+    }
+    session.context.preflightConfig = sanitizeMeta(preflightConfig);
+    const appId = typeof preflightConfig.appId === "string" ? preflightConfig.appId.trim() : "";
+    if (appId) {
+      session.context.appId = appId;
+      session.meta = {
+        ...session.meta,
+        appId,
+        app_id: appId
+      };
+    }
+    const results = Array.isArray(preflightConfig.rules) ? preflightConfig.rules.map((rule) => ({
+      kind: String(rule?.kind || "unknown"),
+      status: "applied",
+      optional: rule?.optional === true
+    })) : [];
+    const event = {
+      t: lastEventTime(session.transcript) + 1,
+      type: "preflight",
+      policy: preflightConfig.policy || "default",
+      appId: appId || session.context.appId || null,
+      results
+    };
+    appendSessionEvents(session, [event]);
+    await this.persistSessionState(session);
+    return {
+      session: this.publicSession(session),
+      appended_events: [event],
+      results
+    };
+  }
+  async runActions(sessionId, actions, options = {}) {
+    const session = this.requireMutableSession(sessionId);
+    if (!Array.isArray(actions) || actions.length === 0) {
+      throw new Error("actions must be a non-empty array");
+    }
+    const normalizedActions = actions.map((action) => ({
+      name: String(action?.name || ""),
+      args: action?.args && typeof action.args === "object" ? action.args : {},
+      checkpointAfter: typeof action?.checkpointAfter === "boolean" ? action.checkpointAfter : options.checkpointAfterEach === true,
+      checkpointLabel: typeof action?.checkpointLabel === "string" ? action.checkpointLabel : void 0
+    }));
+    if (session.executorName === "fake") {
+      return this.runFakeActions(session, normalizedActions, options);
+    }
+    const deviceId = session.context.deviceId || await resolveDefaultDeviceId(session.executorName);
+    if (!deviceId) {
+      throw new Error(`No connected device was found for executor ${session.executorName}.`);
+    }
+    session.context.deviceId = deviceId;
+    const result = await runDeviceActionFlow({
+      executor: session.executorName,
+      deviceId,
+      runDir: session.runDir,
+      sessionId: session.id,
+      meta: session.meta,
+      preflightConfig: session.context.preflightConfig || null,
+      actions: normalizedActions
+    });
+    session.context.lastRunOutput = result.output;
+    session.context.lastFlowPath = result.flowPath;
+    session.context.lastRunFailed = !result.success;
+    session.context.appId = result.appId;
+    session.meta = {
+      ...session.meta,
+      ...result.appId ? { appId: result.appId, app_id: result.appId } : {}
+    };
+    const appended = [];
+    let eventClock = lastEventTime(session.transcript);
+    for (let index = 0; index < result.executedActionCount; index += 1) {
+      const action = normalizedActions[index];
+      eventClock += 1;
+      const actionEvent = {
+        t: eventClock,
+        type: "action",
+        name: action.name,
+        args: sanitizeMeta(action.args || {})
+      };
+      appended.push(actionEvent);
+      const checkpoint = result.checkpoints.find((candidate) => candidate.actionIndex === index) || null;
+      if (checkpoint) {
+        const artifactEvent = await this.persistBinaryArtifact(session, {
+          t: eventClock + 1,
+          kind: "screenshot",
+          path: checkpoint.relativePath,
+          absPath: checkpoint.absPath,
+          bytes: checkpoint.bytes,
+          sha256: checkpoint.sha256,
+          meta: {
+            label: checkpoint.label,
+            source: "applab-esvp-local"
+          }
+        });
+        eventClock += 1;
+        appended.push(artifactEvent);
+        const checkpointEvent = {
+          t: eventClock + 1,
+          type: "checkpoint",
+          label: checkpoint.label,
+          screen_hash: checkpoint.sha256,
+          ui_hash: checkpoint.sha256,
+          state_hash: null
+        };
+        eventClock += 1;
+        appended.push(checkpointEvent);
+      }
+    }
+    appendSessionEvents(session, appended);
+    if (!result.success) {
+      const debugArtifact = await collectExecutorDebugArtifact({
+        executor: session.executorName,
+        context: session.context
+      });
+      const failureEvents = [];
+      if (debugArtifact) {
+        const artifact = await this.persistTextArtifact(session, {
+          t: lastEventTime(session.transcript) + 1,
+          kind: debugArtifact.kind,
+          path: `logs/${String(Date.now())}-${debugArtifact.kind}.${debugArtifact.extension}`,
+          content: debugArtifact.content,
+          meta: {
+            source: "applab-esvp-local"
+          }
+        });
+        failureEvents.push(artifact);
+      }
+      session.status = "failed";
+      session.error = result.error || "ESVP local device run failed";
+      const finishEvent = {
+        t: lastEventTime(session.transcript) + failureEvents.length + 1,
+        type: "session_finished",
+        status: "failed",
+        error: session.error
+      };
+      appendSessionEvents(session, [...failureEvents, finishEvent]);
+      await this.persistSessionState(session);
+      return {
+        session: this.publicSession(session),
+        appended_events: [...appended, ...failureEvents, finishEvent],
+        failed: true
+      };
+    }
+    if (options.finish === true) {
+      const finishResult = await this.finishSessionInternal(session, options);
+      return {
+        session: this.publicSession(session),
+        appended_events: [...appended, ...finishResult.events],
+        failed: false
+      };
+    }
+    await this.persistSessionState(session);
+    return {
+      session: this.publicSession(session),
+      appended_events: appended,
+      failed: false
+    };
+  }
+  async finishSession(sessionId, options = {}) {
+    const session = this.requireSession(sessionId);
+    if (session.status === "finished" || session.status === "failed") {
+      return this.publicSession(session);
+    }
+    this.assertSessionMutable(session);
+    await this.finishSessionInternal(session, options);
+    return this.publicSession(session);
+  }
+  async captureCheckpoint(sessionId, label) {
+    const session = this.requireMutableSession(sessionId);
+    const checkpointLabel = normalizeCheckpointLabelInput(label) || `checkpoint:${session.checkpointCount + 1}`;
+    if (session.executorName === "fake") {
+      const hash = createHash3("sha256").update(`${session.id}:${checkpointLabel}:${session.checkpointCount + 1}`).digest("hex");
+      const event = {
+        t: lastEventTime(session.transcript) + 1,
+        type: "checkpoint",
+        label: checkpointLabel,
+        screen_hash: hash,
+        ui_hash: hash,
+        state_hash: null
+      };
+      appendSessionEvents(session, [event]);
+      await this.persistSessionState(session);
+      return event;
+    }
+    const deviceId = session.context.deviceId || await resolveDefaultDeviceId(session.executorName);
+    if (!deviceId) {
+      throw new Error(`No connected device was found for executor ${session.executorName}.`);
+    }
+    session.context.deviceId = deviceId;
+    const relativePath = `checkpoints/${String(session.checkpointCount + 1).padStart(3, "0")}-${slugify3(checkpointLabel)}.png`;
+    const absPath = join4(session.runDir, relativePath);
+    const capture = await captureDeviceCheckpoint({
+      executor: session.executorName,
+      deviceId,
+      targetPath: absPath
+    });
+    if (!capture.success) {
+      throw new Error(capture.error || "Failed to capture local ESVP checkpoint screenshot");
+    }
+    const contents = await readFile2(absPath);
+    const sha256 = createHash3("sha256").update(contents).digest("hex");
+    const t = lastEventTime(session.transcript) + 1;
+    const artifactEvent = await this.persistBinaryArtifact(session, {
+      t,
+      kind: "screenshot",
+      path: relativePath,
+      absPath,
+      bytes: contents.length,
+      sha256,
+      meta: {
+        label: checkpointLabel,
+        source: "applab-esvp-local"
+      }
+    });
+    const checkpointEvent = {
+      t: t + 1,
+      type: "checkpoint",
+      label: checkpointLabel,
+      screen_hash: sha256,
+      ui_hash: sha256,
+      state_hash: null
+    };
+    appendSessionEvents(session, [artifactEvent, checkpointEvent]);
+    await this.persistSessionState(session);
+    return checkpointEvent;
+  }
+  getSessionNetwork(sessionId) {
+    const session = this.requireSession(sessionId);
+    return {
+      session: this.publicSession(session),
+      network: this.buildPublicNetwork(session)
+    };
+  }
+  async configureSessionNetwork(sessionId, input = {}) {
+    const session = this.requireMutableSession(sessionId);
+    const profile = normalizeNetworkProfileInput(input);
+    const previousProxyArtifacts = await this.releaseManagedProxyArtifacts(session, {
+      reason: "reconfigure"
+    });
+    const managedProxyResult = await this.prepareManagedProxy(session, profile);
+    const effectiveProfile = managedProxyResult?.effectiveProfile || profile;
+    const result = await configureDeviceNetwork(session.executorName, session.context, effectiveProfile);
+    const actionEvent = {
+      t: lastEventTime(session.transcript) + 1,
+      type: "action",
+      name: "network.configure",
+      args: profile
+    };
+    const artifactEvent = await this.persistJsonArtifact(session, {
+      t: actionEvent.t + 1 + previousProxyArtifacts.length,
+      kind: "network_profile",
+      path: buildNetworkArtifactPath(session, "network_profile", {
+        label: profile.label || "network-profile",
+        format: "json"
+      }),
+      payload: {
+        profile,
+        effective_profile: effectiveProfile,
+        managed_proxy: managedProxyResult?.proxy || null,
+        result
+      },
+      meta: {
+        label: profile.label || "network-profile",
+        profile_name: profile.profile || null
+      }
+    });
+    appendSessionEvents(session, [actionEvent, ...previousProxyArtifacts, artifactEvent]);
+    session.network = {
+      ...session.network,
+      supported: true,
+      capabilities: mergeNetworkCapabilities(result.capabilities, managedProxyResult?.capabilities, session.network?.capabilities),
+      active_profile: profile,
+      effective_profile: effectiveProfile,
+      managed_proxy: managedProxyResult?.proxy || null,
+      configured_at: nowIso2(),
+      last_result: sanitizeNetworkResult({
+        ...result,
+        managed_proxy: managedProxyResult?.proxy || null
+      }),
+      last_error: result?.error || null
+    };
+    await this.persistSessionState(session);
+    return {
+      session: this.publicSession(session),
+      network: this.buildPublicNetwork(session),
+      applied: result,
+      profile_artifact: summarizeArtifactEvent(artifactEvent)
+    };
+  }
+  async clearSessionNetwork(sessionId, input = {}) {
+    const session = this.requireMutableSession(sessionId);
+    const result = await clearDeviceNetwork(session.executorName, session.context);
+    const proxyArtifacts = await this.releaseManagedProxyArtifacts(session, {
+      reason: "network-clear"
+    });
+    const actionEvent = {
+      t: lastEventTime(session.transcript) + 1,
+      type: "action",
+      name: "network.clear",
+      args: sanitizeMeta(input || {})
+    };
+    const artifactEvent = await this.persistJsonArtifact(session, {
+      t: actionEvent.t + 1 + proxyArtifacts.length,
+      kind: "network_profile",
+      path: buildNetworkArtifactPath(session, "network_profile", {
+        label: "network-clear",
+        format: "json"
+      }),
+      payload: {
+        cleared: true,
+        result
+      },
+      meta: {
+        cleared: true
+      }
+    });
+    appendSessionEvents(session, [actionEvent, ...proxyArtifacts, artifactEvent]);
+    session.network = {
+      ...session.network,
+      active_profile: null,
+      effective_profile: null,
+      managed_proxy: null,
+      cleared_at: nowIso2(),
+      last_result: sanitizeNetworkResult(result),
+      last_error: null
+    };
+    await this.persistSessionState(session);
+    return {
+      session: this.publicSession(session),
+      network: this.buildPublicNetwork(session),
+      cleared: result,
+      profile_artifact: summarizeArtifactEvent(artifactEvent)
+    };
+  }
+  async attachSessionNetworkTrace(sessionId, input = {}) {
+    const session = this.requireSession(sessionId);
+    const trace = normalizeNetworkTraceInput(input);
+    const artifactEvent = await this.persistArtifactPayload(session, {
+      t: hasFinished(session.transcript) ? lastEventTimeBeforeFinish(session.transcript) : lastEventTime(session.transcript) + 1,
+      kind: "network_trace",
+      path: buildNetworkArtifactPath(session, "network_trace", {
+        label: trace.label || trace.trace_kind,
+        format: trace.format,
+        traceKind: trace.trace_kind
+      }),
+      payload: trace.payload,
+      format: trace.format,
+      meta: {
+        ...trace.label ? { label: trace.label } : {},
+        trace_kind: trace.trace_kind,
+        source: trace.source,
+        request_id: trace.request_id,
+        url: trace.url,
+        method: trace.method,
+        status_code: trace.status_code
+      }
+    });
+    if (hasFinished(session.transcript)) {
+      insertEventsBeforeSessionFinished(session.transcript, [artifactEvent]);
+      recountEvents(session, [artifactEvent]);
+      session.updatedAt = nowIso2();
+    } else {
+      appendSessionEvents(session, [artifactEvent]);
+    }
+    const traceKinds = new Set(session.network?.trace_kinds || []);
+    traceKinds.add(trace.trace_kind);
+    session.network = {
+      ...session.network,
+      trace_count: Number(session.network?.trace_count || 0) + 1,
+      trace_kinds: [...traceKinds]
+    };
+    await this.persistSessionState(session);
+    return {
+      session: this.publicSession(session),
+      network: this.buildPublicNetwork(session),
+      attached_trace: summarizeArtifactEvent(artifactEvent)
+    };
+  }
+  validateSessionReplay(sessionId) {
+    const session = this.requireSession(sessionId);
+    if (!hasFinished(session.transcript)) {
+      return {
+        ok: false,
+        supported: false,
+        reason: "session must be finished before replay validation",
+        session: this.publicSession(session)
+      };
+    }
+    const extracted = extractReplayActionsFromTranscript(session.transcript);
+    if (!extracted.actions.length) {
+      return {
+        ok: false,
+        supported: false,
+        reason: "transcript does not contain replayable actions",
+        session: this.publicSession(session)
+      };
+    }
+    return {
+      ok: true,
+      supported: true,
+      reason: null,
+      session: this.publicSession(session),
+      extraction: extracted
+    };
+  }
+  analyzeReplayConsistency(sessionId) {
+    const session = this.requireSession(sessionId);
+    const transcript = session.transcript || [];
+    const actions = transcript.filter((event) => event.type === "action");
+    const checkpoints = transcript.filter((event) => event.type === "checkpoint");
+    const artifacts = transcript.filter((event) => event.type === "artifact");
+    const failure = transcript.find((event) => event.type === "session_finished" && event.status === "failed") || null;
+    const tapActions = actions.filter((action) => action.name === "tap");
+    const selectorTapCount = tapActions.filter((action) => action.args && typeof action.args.selector === "string").length;
+    const coordinateTapCount = tapActions.filter((action) => action.args && typeof action.args.x === "number" && typeof action.args.y === "number").length;
+    const waitCount = actions.filter((action) => action.name === "wait").length;
+    const waitForCount = actions.filter((action) => action.name === "waitFor").length;
+    const artifactsByKind = artifacts.reduce((acc, event) => {
+      acc[event.kind] = (acc[event.kind] || 0) + 1;
+      return acc;
+    }, {});
+    const recommendations = [];
+    let score = 100;
+    if (actions.length === 0) {
+      score -= 40;
+      recommendations.push("record actions in the transcript to strengthen replay quality");
+    }
+    if (checkpoints.length === 0) {
+      score -= 25;
+      recommendations.push("add regular checkpoints for replay comparison");
+    }
+    if (coordinateTapCount > 0) {
+      score -= Math.min(20, coordinateTapCount * 4);
+      recommendations.push("prefer selectors instead of fixed coordinates");
+    }
+    if (waitCount > waitForCount && waitCount >= 2) {
+      score -= Math.min(15, waitCount * 2);
+      recommendations.push("replace fixed waits with waitFor(selector) style waits when possible");
+    }
+    if (!artifactsByKind.screenshot) {
+      score -= 10;
+      recommendations.push("capture screenshots at critical checkpoints");
+    }
+    if (failure && session.executorName === "adb" && !artifactsByKind.logcat) {
+      score -= 15;
+      recommendations.push("capture logcat on Android failures");
+    }
+    if (failure && (session.executorName === "ios-sim" || session.executorName === "maestro-ios") && !artifactsByKind.debug_asset) {
+      score -= 10;
+      recommendations.push("persist Maestro debug output on iOS failures");
+    }
+    score = Math.max(0, Math.min(100, score));
+    const verdict = score >= 85 ? "strong" : score >= 65 ? "moderate" : "weak";
+    return {
+      session: this.publicSession(session),
+      replay_consistency: {
+        version: 1,
+        objective: "replay_consistency",
+        score,
+        verdict,
+        deterministic_validation: this.validateSessionReplay(sessionId),
+        metrics: {
+          action_count: actions.length,
+          checkpoint_count: checkpoints.length,
+          artifact_count: artifacts.length,
+          tap_selector_count: selectorTapCount,
+          tap_coordinate_count: coordinateTapCount,
+          wait_count: waitCount,
+          wait_for_count: waitForCount,
+          artifacts_by_kind: artifactsByKind
+        },
+        recommendations: [...new Set(recommendations)]
+      }
+    };
+  }
+  async replaySessionToNewSession(sessionId, options = {}) {
+    const original = this.requireSession(sessionId);
+    if (!hasFinished(original.transcript)) {
+      throw new Error("finish the original session before replaying it");
+    }
+    const extracted = extractReplayActionsFromTranscript(original.transcript);
+    if (!extracted.actions.length) {
+      throw new Error("transcript does not contain replayable actions");
+    }
+    const replayExecutor = normalizeExecutor(options.executor || original.executorName || "fake");
+    const replaySession = await this.createSession({
+      executor: replayExecutor,
+      deviceId: options.deviceId || original.context.deviceId || void 0,
+      meta: {
+        source: "replay-run",
+        replay_of: original.id,
+        ...resolveMetaAppId(original.meta) ? { appId: resolveMetaAppId(original.meta), app_id: resolveMetaAppId(original.meta) } : {},
+        ...options.meta ? sanitizeMeta(options.meta) : {}
+      }
+    });
+    const replaySessionId = String(replaySession.id || "");
+    if (!replaySessionId) {
+      throw new Error("Failed to create replay session");
+    }
+    if (original.context.preflightConfig) {
+      await this.runPreflight(replaySessionId, original.context.preflightConfig).catch(() => void 0);
+    }
+    const run = await this.runActions(replaySessionId, extracted.actions, {
+      finish: true,
+      captureLogcat: options.captureLogcat !== false,
+      checkpointAfterEach: false
+    });
+    const replayTranscriptPayload = this.getTranscript(replaySessionId);
+    const comparison = compareCheckpointSequences({
+      expectedTranscript: original.transcript,
+      actualTranscript: replayTranscriptPayload.events,
+      strategy: comparisonStrategyForExecutors(original.executorName, replayExecutor)
+    });
+    return {
+      original_session: this.publicSession(original),
+      replay_session: this.getSession(replaySessionId),
+      extraction: extracted,
+      run_summary: {
+        failed: run.failed,
+        appended_events: Array.isArray(run.appended_events) ? run.appended_events.length : 0,
+        session: run.session
+      },
+      checkpoint_comparison: comparison
+    };
+  }
+  async cleanupTransientSystemState() {
+    for (const session of this.sessions.values()) {
+      if (session.status !== "running") continue;
+      await clearDeviceNetwork(session.executorName, session.context).catch(() => void 0);
+      await this.managedProxyManager.releaseSessionProxy(session.id, { reason: "process-exit" }).catch(() => void 0);
+    }
+  }
+  async runFakeActions(session, actions, options) {
+    const appended = [];
+    for (const action of actions) {
+      const actionEvent = {
+        t: lastEventTime(session.transcript) + appended.length + 1,
+        type: "action",
+        name: action.name,
+        args: sanitizeMeta(action.args || {})
+      };
+      appended.push(actionEvent);
+      if (action.checkpointAfter) {
+        const hash = createHash3("sha256").update(`${session.id}:${action.name}:${JSON.stringify(action.args || {})}:${action.checkpointLabel || ""}`).digest("hex");
+        appended.push({
+          t: actionEvent.t + 1,
+          type: "checkpoint",
+          label: action.checkpointLabel || null,
+          screen_hash: hash,
+          ui_hash: hash,
+          state_hash: hash
+        });
+      }
+    }
+    appendSessionEvents(session, appended);
+    if (options.finish === true) {
+      const finishResult = await this.finishSessionInternal(session, {});
+      return {
+        session: this.publicSession(session),
+        appended_events: [...appended, ...finishResult.events],
+        failed: false
+      };
+    }
+    await this.persistSessionState(session);
+    return {
+      session: this.publicSession(session),
+      appended_events: appended,
+      failed: false
+    };
+  }
+  buildPublicNetwork(session) {
+    return {
+      ...session.network || {},
+      capabilities: session.network?.capabilities || networkCapabilitiesForExecutor(session.executorName)
+    };
+  }
+  publicSession(session) {
+    const lastEvent = session.transcript[session.transcript.length - 1];
+    return {
+      id: session.id,
+      executor: session.executorName,
+      status: session.status,
+      error: session.error,
+      recovered: session.recovered === true,
+      mutable: session.status === "running",
+      created_at: session.createdAt,
+      updated_at: session.updatedAt,
+      target: session.context?.target || null,
+      device_id: session.context?.deviceId || null,
+      meta: session.meta || {},
+      run_dir: session.runDir,
+      transcript_path: session.transcriptPath,
+      transcript_path_relative: session.transcriptPathRelative,
+      manifest_path: session.manifestPath,
+      manifest_path_relative: session.manifestPathRelative,
+      action_count: session.actionCount,
+      checkpoint_count: session.checkpointCount,
+      artifact_count: session.artifactCount,
+      event_count: session.transcript.length,
+      last_event_type: lastEvent?.type || null,
+      last_event_t: lastEvent?.t ?? 0,
+      network: this.buildPublicNetwork(session)
+    };
+  }
+  requireSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`session not found: ${sessionId}`);
+    }
+    return session;
+  }
+  requireMutableSession(sessionId) {
+    const session = this.requireSession(sessionId);
+    this.assertSessionMutable(session);
+    return session;
+  }
+  assertSessionMutable(session) {
+    if (session.status !== "running") {
+      throw new Error(`session ${session.id} is not running (status=${session.status})`);
+    }
+  }
+  async finishSessionInternal(session, options = {}) {
+    const finishEvents = [];
+    const proxyArtifacts = await this.releaseManagedProxyArtifacts(session, {
+      reason: "session-finish"
+    });
+    if (proxyArtifacts.length) {
+      appendSessionEvents(session, proxyArtifacts);
+      finishEvents.push(...proxyArtifacts);
+    }
+    if (options.captureLogcat !== false) {
+      const debugArtifact = await collectExecutorDebugArtifact({
+        executor: session.executorName,
+        context: session.context
+      });
+      if (debugArtifact) {
+        const artifact = await this.persistTextArtifact(session, {
+          t: lastEventTime(session.transcript) + 1,
+          kind: debugArtifact.kind,
+          path: `logs/${String(Date.now())}-${debugArtifact.kind}.${debugArtifact.extension}`,
+          content: debugArtifact.content,
+          meta: {
+            source: "applab-esvp-local"
+          }
+        });
+        appendSessionEvents(session, [artifact]);
+        finishEvents.push(artifact);
+      }
+    }
+    session.status = "finished";
+    session.error = null;
+    session.network = {
+      ...session.network,
+      managed_proxy: null
+    };
+    const sessionFinishedEvent = {
+      t: lastEventTime(session.transcript) + 1,
+      type: "session_finished",
+      status: "ok"
+    };
+    appendSessionEvents(session, [sessionFinishedEvent]);
+    finishEvents.push(sessionFinishedEvent);
+    await this.persistSessionState(session);
+    return {
+      session: this.publicSession(session),
+      events: finishEvents
+    };
+  }
+  async persistSessionState(session) {
+    await writeTranscriptFile(session.transcriptPath, session.transcript);
+    const manifest = {
+      session: this.publicSession(session),
+      meta: session.meta || {},
+      persisted_at: nowIso2(),
+      context: {
+        deviceId: session.context.deviceId || null,
+        appId: session.context.appId || null,
+        preflightConfig: session.context.preflightConfig || null
+      }
+    };
+    await writeFile2(session.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  }
+  async prepareManagedProxy(session, profile) {
+    if (!this.managedProxyManager.shouldManageProfile(profile)) {
+      return null;
+    }
+    return this.managedProxyManager.configureSessionProxy({
+      sessionId: session.id,
+      session,
+      profile
+    });
+  }
+  async releaseManagedProxyArtifacts(session, options = {}) {
+    const release = await this.managedProxyManager.releaseSessionProxy(session.id, options);
+    if (!release.managed || !Array.isArray(release.traces) || release.traces.length === 0) {
+      return [];
+    }
+    const events = [];
+    for (const trace of release.traces) {
+      const artifactEvent = await this.persistArtifactPayload(session, {
+        t: hasFinished(session.transcript) ? lastEventTimeBeforeFinish(session.transcript) : lastEventTime(session.transcript) + 1 + events.length,
+        kind: "network_trace",
+        path: buildNetworkArtifactPath(session, "network_trace", {
+          label: trace.label || trace.trace_kind,
+          format: trace.format,
+          traceKind: trace.trace_kind
+        }),
+        payload: trace.payload,
+        format: trace.format,
+        meta: {
+          ...trace.artifactMeta || {},
+          source: trace.source || "esvp-managed-proxy",
+          trace_kind: trace.trace_kind || "http_trace"
+        }
+      });
+      events.push(artifactEvent);
+    }
+    if (events.length) {
+      const traceKinds = new Set(session.network?.trace_kinds || []);
+      for (const trace of release.traces) {
+        if (trace.trace_kind) traceKinds.add(String(trace.trace_kind));
+      }
+      session.network = {
+        ...session.network,
+        trace_count: Number(session.network?.trace_count || 0) + events.length,
+        trace_kinds: [...traceKinds],
+        managed_proxy: null
+      };
+    }
+    return events;
+  }
+  async loadPersistedSessions() {
+    const entries = await readdir(this.rootDir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const runDir = resolve(this.rootDir, entry.name);
+      const transcriptPath = resolve(runDir, "transcript.jsonl");
+      const transcriptInfo = await stat(transcriptPath).catch(() => null);
+      if (!transcriptInfo?.isFile()) continue;
+      try {
+        const transcript = await readTranscriptFile(transcriptPath);
+        const manifest = await readJsonFile(resolve(runDir, "session.json"));
+        const session = this.recoverSessionFromDisk({
+          runDir,
+          transcriptPath,
+          transcript,
+          manifest,
+          transcriptInfo
+        });
+        this.sessions.set(session.id, session);
+      } catch {
+      }
+    }
+  }
+  recoverSessionFromDisk(input) {
+    const firstEvent = input.transcript.find((event) => event.type === "session_started") || {};
+    const finishEvent = [...input.transcript].reverse().find((event) => event.type === "session_finished") || null;
+    const manifestSession = input.manifest?.session || {};
+    const executorName = normalizeExecutor(
+      manifestSession.executor || firstEvent?.meta?.executor || firstEvent?.meta?.executor_name || "fake"
+    );
+    const id = String(manifestSession.id || firstEvent.session_id || basename(input.runDir));
+    const target = manifestSession.target || firstEvent.target || targetForExecutor(executorName) || null;
+    const deviceId = manifestSession.device_id || firstEvent?.meta?.deviceId || firstEvent?.meta?.device_id || null;
+    const meta = sanitizeMeta(manifestSession.meta || input.manifest?.meta || firstEvent?.meta || {});
+    const status = finishEvent ? finishEvent.status === "failed" ? "failed" : "finished" : "running";
+    const error = status === "failed" ? finishEvent?.error || manifestSession.error || "session failed" : null;
+    return {
+      id,
+      executorName,
+      context: {
+        deviceId: deviceId || null,
+        target,
+        runDir: input.runDir,
+        appId: resolveMetaAppId(meta),
+        preflightConfig: input.manifest?.context?.preflightConfig || null,
+        networkProfile: null,
+        lastRunOutput: null,
+        lastFlowPath: null,
+        lastRunFailed: status === "failed"
+      },
+      createdAt: manifestSession.created_at || input.transcriptInfo.birthtime?.toISOString?.() || input.transcriptInfo.mtime?.toISOString?.() || nowIso2(),
+      updatedAt: manifestSession.updated_at || input.transcriptInfo.mtime?.toISOString?.() || nowIso2(),
+      status,
+      error,
+      recovered: true,
+      meta,
+      runDir: input.runDir,
+      transcriptPath: input.transcriptPath,
+      transcriptPathRelative: relativeRunsPath(this.rootDir, input.runDir, "transcript.jsonl"),
+      manifestPath: resolve(input.runDir, "session.json"),
+      manifestPathRelative: relativeRunsPath(this.rootDir, input.runDir, "session.json"),
+      transcript: input.transcript,
+      actionCount: input.transcript.filter((event) => event.type === "action").length,
+      checkpointCount: input.transcript.filter((event) => event.type === "checkpoint").length,
+      artifactCount: input.transcript.filter((event) => event.type === "artifact").length,
+      network: recoverNetworkState({
+        transcript: input.transcript,
+        manifestNetwork: manifestSession.network,
+        capabilities: networkCapabilitiesForExecutor(executorName)
+      })
+    };
+  }
+  resolveSessionArtifactPath(sessionId, artifactPath) {
+    const session = this.requireSession(sessionId);
+    const normalized = normalizeArtifactRelativePath(artifactPath);
+    const absPath = resolve(session.runDir, normalized);
+    const root = session.runDir.endsWith(sep) ? session.runDir : `${session.runDir}${sep}`;
+    if (!absPath.startsWith(root)) {
+      throw new Error("artifact path is outside the session run_dir");
+    }
+    return {
+      sessionId: session.id,
+      runDir: session.runDir,
+      path: normalized,
+      absPath
+    };
+  }
+  async persistBinaryArtifact(session, input) {
+    return {
+      t: input.t,
+      type: "artifact",
+      kind: input.kind,
+      path: input.path,
+      sha256: input.sha256,
+      bytes: input.bytes,
+      meta: input.meta || null
+    };
+  }
+  async persistTextArtifact(session, input) {
+    const absPath = resolve(session.runDir, input.path);
+    await mkdir2(dirnameSafe(absPath), { recursive: true });
+    const payload = Buffer.from(String(input.content), "utf8");
+    await writeFile2(absPath, payload);
+    const sha256 = createHash3("sha256").update(payload).digest("hex");
+    return {
+      t: input.t,
+      type: "artifact",
+      kind: input.kind,
+      path: input.path,
+      sha256,
+      bytes: payload.length,
+      meta: input.meta || null
+    };
+  }
+  async persistJsonArtifact(session, input) {
+    return this.persistArtifactPayload(session, {
+      ...input,
+      format: "json"
+    });
+  }
+  async persistArtifactPayload(session, input) {
+    const absPath = resolve(session.runDir, input.path);
+    await mkdir2(dirnameSafe(absPath), { recursive: true });
+    const content = serializeArtifactPayload(input.payload, input.format);
+    await writeFile2(absPath, content);
+    const sha256 = createHash3("sha256").update(content).digest("hex");
+    return {
+      t: input.t,
+      type: "artifact",
+      kind: input.kind,
+      path: input.path,
+      sha256,
+      bytes: content.length,
+      meta: input.meta || null
+    };
+  }
+};
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function randomId2(prefix) {
+  return `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function normalizeExecutor(value) {
+  const raw = String(value || "fake").trim();
+  if (raw === "fake" || raw === "adb" || raw === "ios-sim" || raw === "maestro-ios") {
+    return raw;
+  }
+  throw new Error(`Unknown ESVP executor: ${value}`);
+}
+function targetForExecutor(executor) {
+  if (executor === "adb") return "android";
+  if (executor === "ios-sim" || executor === "maestro-ios") return "ios";
+  return "fake";
+}
+function resolveMetaAppId(meta) {
+  if (!meta) return null;
+  if (typeof meta.appId === "string" && meta.appId.trim()) return meta.appId.trim();
+  if (typeof meta.app_id === "string" && meta.app_id.trim()) return meta.app_id.trim();
+  return null;
+}
+async function readJsonFile(filePath) {
+  const text = await readFile2(filePath, "utf8").catch(() => null);
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function writeTranscriptFile(filePath, transcript) {
+  const lines = transcript.map((event) => JSON.stringify(event)).join("\n");
+  await writeFile2(filePath, `${lines}${lines ? "\n" : ""}`, "utf8");
+}
+async function readTranscriptFile(filePath) {
+  const text = await readFile2(filePath, "utf8");
+  return text.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+function createInitialNetworkState(executor) {
+  return {
+    supported: true,
+    capabilities: networkCapabilitiesForExecutor(executor),
+    active_profile: null,
+    effective_profile: null,
+    managed_proxy: null,
+    configured_at: null,
+    cleared_at: null,
+    last_result: null,
+    last_error: null,
+    trace_count: 0,
+    trace_kinds: []
+  };
+}
+function recoverNetworkState(input) {
+  if (input.manifestNetwork && typeof input.manifestNetwork === "object") {
+    const managedProxyWasPersisted = Boolean(
+      input.manifestNetwork.managed_proxy || input.manifestNetwork.managedProxy || String(input.manifestNetwork.effective_profile?.capture?.mode || "").trim().toLowerCase() === "esvp-managed-proxy"
+    );
+    const activeProfile = input.manifestNetwork.active_profile || input.manifestNetwork.activeProfile || null;
+    return {
+      ...input.manifestNetwork,
+      capabilities: input.manifestNetwork.capabilities || input.capabilities || null,
+      ...managedProxyWasPersisted ? {
+        effective_profile: activeProfile,
+        effectiveProfile: activeProfile,
+        managed_proxy: null,
+        managedProxy: null,
+        last_error: typeof input.manifestNetwork.last_error === "string" && input.manifestNetwork.last_error || "managed proxy was released when the previous App Lab process exited",
+        lastError: typeof input.manifestNetwork.lastError === "string" && input.manifestNetwork.lastError || "managed proxy was released when the previous App Lab process exited"
+      } : {}
+    };
+  }
+  const networkArtifacts = (input.transcript || []).filter((event) => event.type === "artifact" && String(event.kind || "").startsWith("network_"));
+  const traceKinds = /* @__PURE__ */ new Set();
+  for (const event of networkArtifacts) {
+    if (event.kind === "network_trace" && event.meta?.trace_kind) {
+      traceKinds.add(String(event.meta.trace_kind));
+    }
+  }
+  return {
+    supported: networkArtifacts.length > 0 || Boolean(input.capabilities),
+    capabilities: input.capabilities || null,
+    active_profile: null,
+    effective_profile: null,
+    managed_proxy: null,
+    configured_at: null,
+    cleared_at: null,
+    last_result: null,
+    last_error: null,
+    trace_count: networkArtifacts.filter((event) => event.kind === "network_trace").length,
+    trace_kinds: [...traceKinds]
+  };
+}
+function summarizeArtifactEvent(event) {
+  return {
+    kind: event.kind,
+    path: event.path,
+    meta: event.meta || null
+  };
+}
+function recountEvents(session, events) {
+  for (const event of events) {
+    if (event.type === "action") session.actionCount += 1;
+    if (event.type === "checkpoint") session.checkpointCount += 1;
+    if (event.type === "artifact") session.artifactCount += 1;
+  }
+}
+function appendSessionEvents(session, events) {
+  if (!Array.isArray(events) || events.length === 0) return;
+  session.transcript.push(...events);
+  recountEvents(session, events);
+  session.updatedAt = nowIso2();
+}
+function extractReplayActionsFromTranscript(transcript) {
+  const actions = [];
+  const skipped_actions = [];
+  let pendingReplayActionIndex = -1;
+  for (const event of transcript || []) {
+    if (!event || typeof event !== "object") continue;
+    if (event.type === "action") {
+      const name = String(event.name || "");
+      if (!isReplayableTranscriptAction(name)) {
+        skipped_actions.push({
+          name,
+          reason: "non_replayable_action"
+        });
+        pendingReplayActionIndex = -1;
+        continue;
+      }
+      actions.push({
+        name,
+        args: sanitizeReplayActionArgs(event.args),
+        checkpointAfter: false
+      });
+      pendingReplayActionIndex = actions.length - 1;
+      continue;
+    }
+    if (event.type === "checkpoint" && pendingReplayActionIndex >= 0) {
+      const action = actions[pendingReplayActionIndex];
+      action.checkpointAfter = true;
+      if (event.label) action.checkpointLabel = event.label;
+      pendingReplayActionIndex = -1;
+      continue;
+    }
+    if (event.type === "session_finished") {
+      break;
+    }
+  }
+  return {
+    action_count: actions.length,
+    skipped_action_count: skipped_actions.length,
+    actions,
+    skipped_actions
+  };
+}
+function sanitizeReplayActionArgs(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (String(key).startsWith("_")) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function isReplayableTranscriptAction(name) {
+  if (!name) return false;
+  if (String(name).startsWith("monitor.")) return false;
+  if (String(name).startsWith("network.")) return false;
+  return true;
+}
+function comparisonStrategyForExecutors(originalExecutor, replayExecutor) {
+  if (originalExecutor === "adb" || replayExecutor === "adb") {
+    return "adb_ui_primary";
+  }
+  if (originalExecutor === "maestro-ios" || replayExecutor === "maestro-ios" || originalExecutor === "ios-sim" || replayExecutor === "ios-sim") {
+    return "ios_step_parity";
+  }
+  return "strict_visual";
+}
+function compareCheckpointSequences(input) {
+  const expected = (input.expectedTranscript || []).filter((event) => event.type === "checkpoint");
+  const actual = (input.actualTranscript || []).filter((event) => event.type === "checkpoint");
+  const maxLen = Math.max(expected.length, actual.length);
+  const comparisons = [];
+  let matchedMain = 0;
+  let matchedLabel = 0;
+  let matchedUi = 0;
+  let matchedScreen = 0;
+  let matchedState = 0;
+  const strategy = input.strategy || "strict_visual";
+  for (let index = 0; index < maxLen; index += 1) {
+    const exp = expected[index] || null;
+    const act = actual[index] || null;
+    const row = {
+      index,
+      expected: exp ? {
+        t: exp.t ?? null,
+        label: exp.label || null,
+        ui_hash: exp.ui_hash,
+        screen_hash: exp.screen_hash,
+        state_hash: exp.state_hash || null
+      } : null,
+      actual: act ? {
+        t: act.t ?? null,
+        label: act.label || null,
+        ui_hash: act.ui_hash,
+        screen_hash: act.screen_hash,
+        state_hash: act.state_hash || null
+      } : null,
+      ui_hash_match: Boolean(exp && act && exp.ui_hash === act.ui_hash),
+      screen_hash_match: Boolean(exp && act && exp.screen_hash === act.screen_hash),
+      state_hash_match: Boolean(exp && act && exp.state_hash && act.state_hash && exp.state_hash === act.state_hash),
+      label_match: Boolean(exp && act && exp.label && act.label && normalizeCheckpointLabel(exp.label) === normalizeCheckpointLabel(act.label))
+    };
+    row.strict_match = Boolean(row.ui_hash_match && row.screen_hash_match);
+    row.main_match = strategy === "adb_ui_primary" ? Boolean(row.ui_hash_match) : strategy === "ios_step_parity" ? Boolean(row.label_match || row.strict_match) : Boolean(row.strict_match);
+    if (row.label_match) matchedLabel += 1;
+    if (row.ui_hash_match) matchedUi += 1;
+    if (row.screen_hash_match) matchedScreen += 1;
+    if (row.state_hash_match) matchedState += 1;
+    if (row.main_match) matchedMain += 1;
+    comparisons.push(row);
+  }
+  const expectedCount = expected.length;
+  const mainRate = expectedCount > 0 ? matchedMain / expectedCount : 0;
+  const verdict = expectedCount === 0 ? "no_checkpoints" : mainRate >= 0.8 ? "pass" : mainRate >= 0.5 ? "partial" : "fail";
+  return {
+    strategy,
+    expected_checkpoint_count: expected.length,
+    actual_checkpoint_count: actual.length,
+    matched_main_count: matchedMain,
+    matched_label_count: matchedLabel,
+    matched_ui_count: matchedUi,
+    matched_screen_count: matchedScreen,
+    matched_state_count: matchedState,
+    main_match_rate: Number(mainRate.toFixed(3)),
+    label_match_rate: Number((expectedCount > 0 ? matchedLabel / expectedCount : 0).toFixed(3)),
+    ui_match_rate: Number((expectedCount > 0 ? matchedUi / expectedCount : 0).toFixed(3)),
+    screen_match_rate: Number((expectedCount > 0 ? matchedScreen / expectedCount : 0).toFixed(3)),
+    state_match_rate: Number((expectedCount > 0 ? matchedState / expectedCount : 0).toFixed(3)),
+    strict_match_rate: Number((expectedCount > 0 ? comparisons.filter((row) => row.strict_match).length / expectedCount : 0).toFixed(3)),
+    verdict,
+    divergences: comparisons.filter((row) => !row.main_match).slice(0, 20),
+    comparisons: comparisons.slice(0, 50)
+  };
+}
+function normalizeCheckpointLabel(label) {
+  return String(label || "").trim().toLowerCase();
+}
+function normalizeCheckpointLabelInput(label) {
+  const normalized = String(label || "").trim();
+  return normalized || null;
+}
+function hasFinished(transcript) {
+  return transcript.some((event) => event.type === "session_finished");
+}
+function lastEventTime(transcript) {
+  return transcript.length ? Number(transcript[transcript.length - 1].t || 0) : 0;
+}
+function lastEventTimeBeforeFinish(transcript) {
+  const finishIdx = transcript.findIndex((event) => event.type === "session_finished");
+  if (finishIdx <= 0) return 0;
+  return Number(transcript[finishIdx - 1]?.t || 0);
+}
+function insertEventsBeforeSessionFinished(transcript, events) {
+  if (!Array.isArray(events) || events.length === 0) return;
+  const finishIdx = transcript.findIndex((event) => event.type === "session_finished");
+  if (finishIdx < 0) {
+    transcript.push(...events);
+    return;
+  }
+  transcript.splice(finishIdx, 0, ...events);
+}
+function relativeRunsPath(rootDir, runDir, filename) {
+  if (!runDir.startsWith(rootDir)) return resolve(runDir, filename);
+  return `runs/${runDir.slice(rootDir.length + 1)}/${filename}`;
+}
+function normalizeArtifactRelativePath(input) {
+  const raw = String(input || "").trim();
+  if (!raw) throw new Error("artifact path is empty");
+  const segments = raw.replace(/^\/+/, "").split("/").filter(Boolean);
+  const normalized = segments.join("/");
+  if (!normalized) throw new Error("invalid artifact path");
+  if (segments.some((segment) => segment === "..")) {
+    throw new Error("invalid artifact path");
+  }
+  return normalized;
+}
+function normalizeNetworkProfileInput(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("network profile must be an object");
+  }
+  const proxyInput = input.proxy && typeof input.proxy === "object" ? input.proxy : null;
+  const faultsInput = input.faults && typeof input.faults === "object" ? input.faults : null;
+  const captureInput = input.capture && typeof input.capture === "object" ? input.capture : null;
+  return {
+    profile: input.profile ? String(input.profile) : null,
+    label: input.label ? String(input.label) : null,
+    connectivity: normalizeNetworkConnectivity(input.connectivity),
+    proxy: proxyInput ? {
+      host: proxyInput.host ? String(proxyInput.host) : null,
+      port: proxyInput.port != null ? Number(proxyInput.port) : null,
+      protocol: proxyInput.protocol ? String(proxyInput.protocol) : "http",
+      bypass: Array.isArray(proxyInput.bypass) ? proxyInput.bypass.map((value) => String(value)) : [],
+      bind_host: proxyInput.bind_host ? String(proxyInput.bind_host) : proxyInput.bindHost ? String(proxyInput.bindHost) : null,
+      advertise_host: proxyInput.advertise_host ? String(proxyInput.advertise_host) : proxyInput.advertiseHost ? String(proxyInput.advertiseHost) : null
+    } : null,
+    faults: faultsInput ? {
+      delay_ms: numberOrNull(faultsInput.delay_ms ?? faultsInput.delayMs),
+      timeout: faultsInput.timeout === true,
+      offline_partial: faultsInput.offline_partial === true || faultsInput.offlinePartial === true,
+      status_code: numberOrNull(faultsInput.status_code ?? faultsInput.statusCode),
+      body_patch: faultsInput.body_patch ?? faultsInput.bodyPatch ?? null
+    } : null,
+    capture: captureInput ? {
+      enabled: captureInput.enabled !== false,
+      mode: captureInput.mode ? String(captureInput.mode) : null
+    } : null
+  };
+}
+function normalizeNetworkConnectivity(value) {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return null;
+  if (raw === "offline" || raw === "online" || raw === "reset") return raw;
+  throw new Error(`invalid network connectivity: ${value}`);
+}
+function normalizeNetworkTraceInput(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("network trace must be an object");
+  }
+  const traceKind = String(input.trace_kind || input.kind || "http_trace").trim();
+  if (!traceKind) throw new Error("network trace.trace_kind is required");
+  const payload = input.payload ?? input.trace ?? input.content;
+  if (payload == null) throw new Error("network trace.payload is required");
+  return {
+    trace_kind: traceKind,
+    label: input.label ? String(input.label) : null,
+    format: inferNetworkTraceFormat(input.format, payload, traceKind),
+    payload,
+    source: input.source ? String(input.source) : null,
+    request_id: input.request_id ? String(input.request_id) : null,
+    url: input.url ? String(input.url) : null,
+    method: input.method ? String(input.method) : null,
+    status_code: input.status_code != null ? Number(input.status_code) : null
+  };
+}
+function inferNetworkTraceFormat(explicitFormat, payload, traceKind) {
+  if (explicitFormat) return String(explicitFormat);
+  if (traceKind === "har") return "har";
+  if (typeof payload === "string") return "text";
+  return "json";
+}
+function buildNetworkArtifactPath(session, kind, options = {}) {
+  const existingCount = (session.transcript || []).filter((event) => event.type === "artifact" && String(event.kind || "").startsWith("network_")).length;
+  const seq = String(existingCount + 1).padStart(3, "0");
+  const safeBase = slugify3(options.label || options.traceKind || kind);
+  const ext = networkArtifactExt(kind, options.format, options.traceKind);
+  return `network/${seq}-${kind}-${safeBase}${ext}`;
+}
+function networkArtifactExt(kind, format, traceKind) {
+  if (kind === "network_trace" && traceKind === "har") return ".har.json";
+  if (format === "json" || format === "har") return ".json";
+  if (format === "txt" || format === "text") return ".txt";
+  return ".json";
+}
+function serializeArtifactPayload(payload, format) {
+  if (Buffer.isBuffer(payload)) return payload;
+  if (format === "json" || format === "har" || !format) {
+    return Buffer.from(`${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  }
+  return Buffer.from(String(payload), "utf8");
+}
+function sanitizeMeta(meta) {
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return {};
+  return JSON.parse(JSON.stringify(meta));
+}
+function sanitizeNetworkResult(result) {
+  if (!result || typeof result !== "object") return result ?? null;
+  return JSON.parse(JSON.stringify(result));
+}
+function numberOrNull(value) {
+  if (value == null || value === "") return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+function slugify3(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "artifact";
+}
+function mergeNetworkCapabilities(...caps) {
+  const normalized = caps.filter((value) => Boolean(value && typeof value === "object"));
+  if (!normalized.length) return null;
+  return Object.assign({}, ...normalized);
+}
+function dirnameSafe(pathLike) {
+  const index = pathLike.lastIndexOf("/");
+  return index >= 0 ? pathLike.slice(0, index) : ".";
+}
+
+// src/core/integrations/esvp-local.ts
+async function resolveESVPConnection(serverUrl) {
+  assertLocalOnlyESVPConfig(serverUrl);
+  await getAppLabESVPLocalRuntime();
+  return {
+    mode: "local",
+    serverUrl: LOCAL_ESVP_SERVER_URL
+  };
+}
+function assertLocalOnlyESVPConfig(serverUrl) {
+  const explicit = normalizeOptionalUrl(serverUrl);
+  if (explicit && explicit !== LOCAL_ESVP_SERVER_URL) {
+    throw new Error(
+      "App Lab agora embute o runtime ESVP local no pr\xF3prio processo. Remova o --server/serverUrl informado e use o modo local padr\xE3o."
+    );
+  }
+  const envUrl = normalizeOptionalUrl(process.env.ESVP_BASE_URL);
+  if (envUrl && envUrl !== LOCAL_ESVP_SERVER_URL) {
+    throw new Error(
+      "ESVP_BASE_URL n\xE3o \xE9 mais suportado no App Lab local. Remova essa vari\xE1vel para usar o runtime ESVP embutido."
+    );
+  }
+}
+function normalizeOptionalUrl(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().replace(/\/+$/, "");
+  return normalized || null;
+}
+
+// src/core/integrations/esvp.ts
+async function getRuntime(serverUrl) {
+  await resolveESVPConnection(serverUrl);
+  return getAppLabESVPLocalRuntime();
+}
+function normalizeActionList(actions) {
+  return actions.map((action) => {
+    const normalized = {
+      name: String(action?.name || ""),
+      args: action?.args && typeof action.args === "object" ? action.args : {}
+    };
+    if (typeof action?.checkpointAfter === "boolean") {
+      normalized.checkpointAfter = action.checkpointAfter;
+    }
+    if (typeof action?.checkpointLabel === "string") {
+      normalized.checkpointLabel = action.checkpointLabel;
+    }
+    return normalized;
+  });
+}
+async function listDevicesEnvelope(executor) {
+  return {
+    devices: await listDevicesForExecutor(executor)
+  };
+}
+function getESVPBaseUrl(serverUrl) {
+  assertLocalOnlyESVPConfig(serverUrl);
+  return LOCAL_ESVP_SERVER_URL;
+}
+async function resolveESVPBaseUrl(serverUrl) {
+  const connection = await resolveESVPConnection(serverUrl);
+  return connection.serverUrl;
+}
+async function getESVPConnection(serverUrl) {
+  return resolveESVPConnection(serverUrl);
+}
+async function getESVPHealth(serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.getHealth();
+}
+async function listESVPSessions(serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return {
+    sessions: runtime.listSessions()
+  };
+}
+async function createESVPSession(input, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return {
+    session: await runtime.createSession(input)
+  };
+}
+async function getESVPSession(sessionId, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return {
+    session: runtime.getSession(sessionId)
+  };
+}
+async function getESVPTranscript(sessionId, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.getTranscript(sessionId);
+}
+async function listESVPArtifacts(sessionId, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return {
+    artifacts: runtime.listArtifacts(sessionId)
+  };
+}
+async function runESVPActions(sessionId, input, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.runActions(sessionId, normalizeActionList(input.actions), {
+    finish: input.finish === true,
+    captureLogcat: input.captureLogcat === true,
+    checkpointAfterEach: input.checkpointAfterEach === true
+  });
+}
+async function finishESVPSession(sessionId, input = {}, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return {
+    session: await runtime.finishSession(sessionId, input)
+  };
+}
+async function runESVPPreflight(sessionId, config, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.runPreflight(sessionId, config);
+}
+async function inspectESVPSession(sessionId, input = {}, serverUrl) {
+  const [session, transcript, artifacts] = await Promise.all([
+    getESVPSession(sessionId, serverUrl),
+    input.includeTranscript === true ? getESVPTranscript(sessionId, serverUrl) : Promise.resolve(null),
+    input.includeArtifacts === true ? listESVPArtifacts(sessionId, serverUrl) : Promise.resolve(null)
+  ]);
+  return {
+    session: session?.session || session,
+    transcript: transcript?.events || null,
+    artifacts: artifacts?.artifacts || null
+  };
+}
+async function getESVPArtifactContent(sessionId, artifactPath, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.getArtifactContent(sessionId, artifactPath);
+}
+async function getESVPSessionNetwork(sessionId, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.getSessionNetwork(sessionId);
+}
+async function replayESVPSession(sessionId, input = {}, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.replaySessionToNewSession(sessionId, input);
+}
+async function getESVPReplayConsistency(sessionId, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.analyzeReplayConsistency(sessionId);
+}
+async function validateESVPReplay(sessionId, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  const result = runtime.validateSessionReplay(sessionId);
+  return {
+    http_status: result?.supported === false || result?.ok === false ? 409 : 200,
+    ...result
+  };
+}
+async function captureESVPCheckpoint(sessionId, input = {}, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.captureCheckpoint(sessionId, input.label);
+}
+async function configureESVPNetwork(sessionId, input, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.configureSessionNetwork(sessionId, input);
+}
+async function clearESVPNetwork(sessionId, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.clearSessionNetwork(sessionId, {});
+}
+async function attachESVPNetworkTrace(sessionId, input, serverUrl) {
+  const runtime = await getRuntime(serverUrl);
+  return runtime.attachSessionNetworkTrace(sessionId, input);
+}
+async function listESVPDevices(platform = "all", serverUrl) {
+  await getRuntime(serverUrl);
+  if (platform === "adb") {
+    return listDevicesEnvelope("adb");
+  }
+  if (platform === "ios-sim") {
+    return listDevicesEnvelope("ios-sim");
+  }
+  if (platform === "maestro-ios") {
+    return listDevicesEnvelope("maestro-ios");
+  }
+  const [adb, iosSim, maestroIos] = await Promise.all([
+    listDevicesEnvelope("adb").catch((error) => ({ error: error instanceof Error ? error.message : String(error), devices: [] })),
+    listDevicesEnvelope("ios-sim").catch((error) => ({ error: error instanceof Error ? error.message : String(error), devices: [] })),
+    listDevicesEnvelope("maestro-ios").catch((error) => ({ error: error instanceof Error ? error.message : String(error), devices: [] }))
+  ]);
+  return {
+    adb,
+    iosSim,
+    maestroIos
+  };
+}
+
+export {
+  findAndroidSdkPath,
+  getEmulatorPath,
+  getAdbCommand,
+  listConnectedAndroidDevices,
+  resolveAndroidDeviceSerial,
+  isMaestroInstalled,
+  isIdbInstalled,
+  tapViaIdb,
+  killZombieMaestroProcesses,
+  getMaestroVersion,
+  listMaestroDevices,
+  generateMaestroFlow,
+  runMaestroTest,
+  runMaestroWithCapture,
+  startMaestroStudio,
+  createLoginFlow,
+  createOnboardingFlow,
+  createNavigationTestFlow,
+  parseMaestroActionsFromYaml,
+  getMaestroRecorder,
+  LOCAL_ESVP_SERVER_URL,
+  getESVPBaseUrl,
+  resolveESVPBaseUrl,
+  getESVPConnection,
+  getESVPHealth,
+  listESVPSessions,
+  createESVPSession,
+  getESVPSession,
+  getESVPTranscript,
+  listESVPArtifacts,
+  runESVPActions,
+  finishESVPSession,
+  runESVPPreflight,
+  inspectESVPSession,
+  getESVPArtifactContent,
+  getESVPSessionNetwork,
+  replayESVPSession,
+  getESVPReplayConsistency,
+  validateESVPReplay,
+  captureESVPCheckpoint,
+  configureESVPNetwork,
+  clearESVPNetwork,
+  attachESVPNetworkTrace,
+  listESVPDevices
+};