@validate.qa/runner 1.0.23 → 1.0.25

package/dist/cli.js

@@ -245,8 +245,8 @@ var require_ai_provider = __commonJS({
     exports2.resetAIClient = resetAIClient;
     exports2.getServerProxiedAIClient = getServerProxiedAIClient;
     exports2.getServerProxiedClientForModel = getServerProxiedClientForModel;
-    exports2.getMobileAIClient = getMobileAIClient;
-    exports2.getMobileClientForModel = getMobileClientForModel;
+    exports2.getMobileAIClient = getMobileAIClient2;
+    exports2.getMobileClientForModel = getMobileClientForModel2;
     var openai_1 = __importDefault(require("openai"));
     var async_hooks_1 = require("async_hooks");
     var ai_retry_js_1 = require_ai_retry();
@@ -643,14 +643,14 @@ var require_ai_provider = __commonJS({
     function getServerProxiedClientForModel(_modelId) {
       return getServerProxiedAIClient();
     }
-    function getMobileAIClient() {
+    function getMobileAIClient2() {
       if ((process.env.SERVER_URL ?? "").trim().length > 0)
         return getServerProxiedAIClient();
       if (isMobileAiUnitTestMode())
         return getAIClient();
       throw new Error("Mobile AI requires the platform server URL (SERVER_URL). Customer runners do not provision provider API keys \u2014 the platform proxies every mobile AI completion through /api/runner/ai/execute, which lives on the shared server with the keys. If you reached this from `validate-runner start`, the credentials file is missing `serverUrl` or the install is broken; re-run `npx @validate.qa/runner login`. If you are calling the runner-core library directly, pass `options.aiClient` in tests or set VALIDATEQA_TEST_MODE=1 to opt into the local-provider fallback.");
     }
-    function getMobileClientForModel(modelId) {
+    function getMobileClientForModel2(modelId) {
       if ((process.env.SERVER_URL ?? "").trim().length > 0)
         return getServerProxiedClientForModel(modelId);
       if (isMobileAiUnitTestMode())
@@ -681,6 +681,8 @@ var require_mobile_source_parser = __commonJS({
     exports2.buildLocatorBundle = buildLocatorBundle;
     exports2.preferredLocator = preferredLocator;
     exports2.parseMobileSource = parseMobileSource2;
+    exports2.resolveLocatorAgainstScreenDetailed = resolveLocatorAgainstScreenDetailed;
+    exports2.resolveLocatorAgainstScreen = resolveLocatorAgainstScreen;
     var IOS_ACTIONABLE_ROLE_SUFFIXES = [
       "Button",
       "TextField",
@@ -1084,6 +1086,106 @@ var require_mobile_source_parser = __commonJS({
         windowSize: null
       };
     }
+    var XPATH_IDENTITY_TEXT_ATTRS = /* @__PURE__ */ new Set([
+      "text",
+      "content-desc",
+      "label",
+      "name",
+      "value"
+    ]);
+    function elementValuesForXpathAttr(el, attr) {
+      if (attr === "resource-id")
+        return [el.resourceId];
+      if (attr === "class")
+        return [el.role];
+      if (XPATH_IDENTITY_TEXT_ATTRS.has(attr))
+        return [el.text, el.accessibilityId, el.label];
+      return [];
+    }
+    function elementCarriesIdentityText(el, value) {
+      return el.text === value || el.accessibilityId === value || el.label === value;
+    }
+    function parseXpathClauses(xpath) {
+      const clauses = [];
+      const seen = /* @__PURE__ */ new Set();
+      const push = (attr, value, matchKind) => {
+        const key = `${attr}\0${value}\0${matchKind}`;
+        if (seen.has(key))
+          return;
+        seen.add(key);
+        clauses.push({ attr, value, matchKind });
+      };
+      const fnRe = /\b(contains|starts-with)\s*\(\s*@([A-Za-z_][\w.:-]*)\s*,\s*("([^"]*)"|'([^']*)')\s*\)/gi;
+      let m;
+      while ((m = fnRe.exec(xpath)) !== null) {
+        const kind = m[1].toLowerCase() === "contains" ? "contains" : "starts-with";
+        const value = m[4] ?? m[5] ?? "";
+        push(m[2], value, kind);
+      }
+      const eqRe = /@([A-Za-z_][\w.:-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+      while ((m = eqRe.exec(xpath)) !== null) {
+        const value = m[3] ?? m[4] ?? "";
+        push(m[1], value, "exact");
+      }
+      return clauses;
+    }
+    function elementMatchesClause(el, clause) {
+      const values = elementValuesForXpathAttr(el, clause.attr);
+      return values.some((v) => {
+        if (v === void 0)
+          return false;
+        if (clause.matchKind === "contains")
+          return v.includes(clause.value);
+        if (clause.matchKind === "starts-with")
+          return v.startsWith(clause.value);
+        return v === clause.value;
+      });
+    }
+    function matchXpath(xpath, elements) {
+      const clauses = parseXpathClauses(xpath);
+      if (clauses.length === 0)
+        return { elements: [], exact: false };
+      const matched = elements.filter((el) => clauses.some((c) => elementMatchesClause(el, c)));
+      const exact = clauses.every((c) => c.matchKind === "exact");
+      return { elements: matched, exact };
+    }
+    function resolveLocatorAgainstScreenDetailed(candidate, screen) {
+      const elements = screen.elements;
+      const accId = candidate.accessibilityId?.trim();
+      if (accId) {
+        const matches = elements.filter((el) => el.accessibilityId === accId);
+        if (matches.length > 0)
+          return { elements: matches, strategy: "accessibilityId", exact: true };
+      }
+      const resId = candidate.resourceId?.trim();
+      if (resId) {
+        const matches = elements.filter((el) => el.resourceId === resId);
+        if (matches.length > 0)
+          return { elements: matches, strategy: "resourceId", exact: true };
+      }
+      const text = candidate.text?.trim();
+      if (text) {
+        const matches = elements.filter((el) => elementCarriesIdentityText(el, text));
+        if (matches.length > 0)
+          return { elements: matches, strategy: "text", exact: true };
+      }
+      const xpath = candidate.xpath?.trim();
+      if (xpath) {
+        const res = matchXpath(xpath, elements);
+        if (res.elements.length > 0)
+          return { elements: res.elements, strategy: "xpath", exact: res.exact };
+      }
+      const className = candidate.className?.trim();
+      if (className) {
+        const matches = elements.filter((el) => el.role === className);
+        if (matches.length > 0)
+          return { elements: matches, strategy: "className", exact: true };
+      }
+      return { elements: [], strategy: "none", exact: false };
+    }
+    function resolveLocatorAgainstScreen(candidate, screen) {
+      return resolveLocatorAgainstScreenDetailed(candidate, screen).elements;
+    }
   }
 });
 
@@ -62139,7 +62241,7 @@ Rules:
 - Register ONCE per run. If signup says the account ALREADY exists, log in with that email + the \`${opts.passwordKey}\` password instead of registering again.
 - Only call the verification tools AFTER submitting the signup form; pass the app as \`senderMatch\` (the inbox is shared).`;
     }
-    function buildSystemPrompt(mode, platform3, enableRecordJourney, maxIterations, appBrief, targetAppId, existingScreens) {
+    function buildSystemPrompt(mode, platform3, enableRecordJourney, maxIterations, appBrief, targetAppId, existingScreens, incremental) {
       const platformLabel = platform3 === "IOS" ? "iOS" : "Android";
       const targetLine = targetAppId ? ` Target app package/bundle: ${targetAppId}.` : "";
       const surveyBody = `You are a mobile QA exploration agent driving a real ${platformLabel} app on a connected device. Your goal: MAP every reachable screen so downstream agents know what to test. You are NOT testing \u2014 you are building a complete screen map.
@@ -62149,13 +62251,12 @@ Rules:
 - Every element is addressed by a ref like e1, e2. **Refs are ONLY valid for the most recent mobile_snapshot.** Re-snapshot after every action that changes the screen, then use the NEW refs.
 - mobile_tap/mobile_type/mobile_clear take a ref. The loop resolves the ref to coordinates for you \u2014 you never pass coordinates.
 
-## Strategy
-1. mobile_snapshot the launch screen.
-2. capture_screen to record it (name + type). Then record_transition when you move between screens.
-3. Systematically open every navigation target: tabs, list rows (open ONE per list \u2014 they share a template), menus, drawers.
-4. Use mobile_swipe up/down to reveal off-screen content and scroll long screens.
-5. mobile_back to return; mobile_relaunch only for a clean restart between episodes.
-6. When no new screens remain, call finish_exploration.
+## Strategy \u2014 three phases, in order
+**Phase 1 \u2014 Logged-out entry (be quick, ~15% of budget).** mobile_snapshot the launch screen, capture_screen it, and capture each distinct pre-login screen ONCE (landing, theme/language picker, sign-up, sign-in, forgot-password). Do NOT exhaustively try onboarding variants (every theme, every language) \u2014 one capture per screen type is enough. Then LOG IN using the provided credentials and verify you are actually signed in.
+**Phase 2 \u2014 Logged-in breadth first (~35% of budget).** Once signed in, find the primary navigation (bottom tab bar, drawer, or menu) and visit EVERY top-level destination ONCE, capturing each screen, BEFORE drilling into any of them. A survey that maps one tab deeply but never opens the other tabs has failed \u2014 breadth across all tabs/drawer entries is mandatory.
+**Phase 3 \u2014 Depth (remaining budget).** Return to each captured tab and explore its sub-screens: open ONE list row per list (rows share a template), open menus/sheets/dialogs, capture detail screens, and mobile_swipe up/down to reveal off-screen content. record_transition whenever you move between screens.
+
+Rules that apply throughout: capture_screen every new screen (name + type \u2014 use type "onboarding"/"landing" for pre-login screens, "auth" for sign-in/sign-up); record_transition on every move; mobile_back to return; mobile_relaunch only for a clean restart between episodes. When no new screens remain, call finish_exploration.
 
 ## Boundaries (survey = map, do not mutate)
 - Do NOT submit forms, save, delete, purchase, or send anything. You MAY open modals/menus to catalog them, then dismiss.
@@ -62185,7 +62286,7 @@ Max iterations: ${maxIterations}. You will be warned near the end.`;
 ## Application Brief
 ${appBrief}
 Use this to prioritize which screens and flows to cover.` : "";
-      const existingScreensBlock = mode === "survey" && existingScreens && existingScreens.length > 0 ? `
+      const existingScreensBlock = mode === "survey" && incremental && existingScreens && existingScreens.length > 0 ? `
 
 ## ALREADY DISCOVERED SCREENS (skip these; find new)
 These screens were mapped in a previous survey. Do NOT re-map them \u2014 use your budget to find NEW screens and flows not listed here. If you land on one of these, move on to something new.
@@ -62380,7 +62481,7 @@ ${existingScreens.slice(0, 100).map((s) => `- ${s.screenId}${s.name ? ` "${s.nam
       const browserCreds = ctx.variableContext.allTestVariables ?? ctx.variableContext.publicTestVariables;
       const { secrets: credentialSecrets } = (0, credential_tools_js_1.partitionTestVariables)(browserCreds);
       const hasCredentials = Object.keys(credentialSecrets).length > 0;
-      const systemPrompt = buildSystemPrompt(mode, platform3, enableRecordJourney, maxIterations, ctx.appBrief, targetAppId, existingScreens) + buildMobileCredentialPromptBlock(credentialSecrets) + (registerMode && inboxState ? buildMobileInboxPromptBlock({
+      const systemPrompt = buildSystemPrompt(mode, platform3, enableRecordJourney, maxIterations, ctx.appBrief, targetAppId, existingScreens, ctx.incremental) + buildMobileCredentialPromptBlock(credentialSecrets) + (registerMode && inboxState ? buildMobileInboxPromptBlock({
         email: inboxState.email,
         passwordKey: inboxState.passwordKey ?? "TEST_USER_PASSWORD",
         context: mode
@@ -65645,6 +65746,7 @@ Return ONLY one valid JSON object matching the schema below. Do NOT include <thi
 7. Feature descriptions MUST reference actual element labels / accessibility-ids from the evidence
 8. Do NOT create standalone features for generic error / empty screens (network-error, permission-denied). If a feature screen is broken or crashes, keep it in its intended feature and note the failure in the description.
 9. COVER EVERY SCREEN: every explored screen except generic error / permission screens MUST appear in exactly one feature group's routes. Do not leave screens ungrouped \u2014 a screen the explorer reached is part of SOME feature. Attach an ambiguous screen to its most closely related feature and note the ambiguity in that feature's description. Sign-in / sign-up / forgot-password screens form an "Authentication" group even when they were only reached via links from other screens.
+10. LOGGED-OUT vs LOGGED-IN SEPARATION: screens shown BEFORE the user is signed in (splash, landing/welcome, theme or language pickers, walkthroughs, sign-up, sign-in, forgot-password, demo/preview screens) must NEVER share a feature group with the signed-in app. Put sign-in / sign-up / forgot-password in "Authentication" (rule 4) and the remaining pre-login screens in an "Onboarding" group. Features named after signed-in areas (feeds, dashboards, tabs, settings) must contain ONLY screens reached after authentication. A pre-login flow is a linear sequence, not a navigation destination \u2014 do not let it swallow the app's main features.
 
 ## Output JSON Schema
 {
@@ -66028,7 +66130,8 @@ ${constraints.join("\n")}`);
       const orderedScreens = targetAppScreens(graph, appId).filter((state2) => state2.screenType?.toLowerCase() !== "error").sort((a, b) => a.firstSeenIteration - b.firstSeenIteration);
       const includedScreenIds = new Set(orderedScreens.map((state2) => state2.screenId));
       for (const state2 of orderedScreens) {
-        const groupName = state2.screenType?.toLowerCase() === "auth" ? "Authentication" : screenDisplayName(state2);
+        const screenTypeLower = state2.screenType?.toLowerCase();
+        const groupName = screenTypeLower === "auth" ? "Authentication" : screenTypeLower === "onboarding" || screenTypeLower === "landing" || screenTypeLower === "splash" ? "Onboarding" : screenDisplayName(state2);
         const group = groups.get(groupName) ?? {
           name: groupName,
           description: `Native mobile screens related to ${groupName}.`,
@@ -67136,6 +67239,24 @@ ${statePacket}` },
         return true;
       return false;
     }
+    var BARE_CONTAINER_CLASS_RE = /(webview|framelayout|linearlayout|relativelayout|viewgroup|scrollview|recyclerview|listview|XCUIElementTypeWebView|XCUIElementTypeApplication|XCUIElementTypeWindow|XCUIElementTypeOther|XCUIElementTypeScrollView)$/i;
+    function isBareContainerTap(action) {
+      if (action.type !== "TAP")
+        return false;
+      const bundle = action.metadata.locatorBundle;
+      if (!bundle)
+        return false;
+      const hasIdentity = Boolean(bundle.text?.trim() || bundle.contentDesc?.trim() || bundle.accessibilityId?.trim() || action.metadata.targetLabel?.trim());
+      if (hasIdentity)
+        return false;
+      const resourceId = bundle.resourceId?.trim() ?? "";
+      const localName = resourceId.includes("/") ? resourceId.slice(resourceId.indexOf("/") + 1) : resourceId;
+      const containerishId = localName !== "" && (localName === "webview" || ALWAYS_PRESENT_CONTAINER_ID_NAMES.has(localName));
+      const containerishClass = BARE_CONTAINER_CLASS_RE.test(bundle.className ?? "");
+      if (containerishId)
+        return true;
+      return containerishClass && (resourceId === "" || containerishId);
+    }
     function appendHybridFloor(actions, recording, platform3) {
       const anchor = pickLandingAnchor(recording.lastSnapshot);
       if (!anchor)
@@ -67176,10 +67297,15 @@ ${statePacket}` },
     }
     function assembleTest(args) {
       const { scenario, recording, ctx, platform: platform3, appDataCleared, log: log2 } = args;
-      const actions = collapseRetryCycles(recording.actions);
+      let actions = collapseRetryCycles(recording.actions);
       if (actions.length < recording.actions.length) {
         log2(`  collapsed ${recording.actions.length - actions.length} retry-cycle step(s) out of the recorded trace (${recording.actions.length} \u2192 ${actions.length}).`);
       }
+      const beforeContainerDrop = actions.length;
+      actions = actions.filter((a) => !isBareContainerTap(a));
+      if (actions.length < beforeContainerDrop) {
+        log2(`  dropped ${beforeContainerDrop - actions.length} bare-container tap step(s) (no identity \u2014 un-replayable ambient taps).`);
+      }
       const floorAppended = appendHybridFloor(actions, recording, platform3);
       if (floorAppended) {
         log2("  appended hybrid durable-outcome floor (landing-screen ASSERT_VISIBLE).");
@@ -67367,6 +67493,1155 @@ Mobile generate phase complete: ${tests.length}/${scenarios.length} test(s) gene
   }
 });
 
+// ../runner-core/dist/services/mobile/mobile-heal-postprocess.js
+var require_mobile_heal_postprocess = __commonJS({
+  "../runner-core/dist/services/mobile/mobile-heal-postprocess.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.redactMobileSecretsFromText = redactMobileSecretsFromText;
+    exports2.detectMobileStepSecretLeak = detectMobileStepSecretLeak;
+    exports2.computeMobileHealOutcome = computeMobileHealOutcome2;
+    var REDACT_KEY_RE = /email|username|user|phone|password|secret|token|api[_-]?key|access[_-]?key|\bpass\b|credential|bearer|\bpat\b|session|cookie|jwt|otp|pin/i;
+    var DETECT_KEY_RE = /password|secret|token|api[_]?key|\bpass\b|credential|bearer|\bpat\b/i;
+    var MIN_REDACT_LEN = 4;
+    var MIN_DETECT_LEN = 6;
+    var TOKEN_SOURCES = [
+      "eyJ[A-Za-z0-9_-]{6,}\\.[A-Za-z0-9_-]{6,}\\.[A-Za-z0-9_-]{4,}",
+      // JWT (three base64url segments)
+      "Bearer\\s+[A-Za-z0-9._~+/=-]{12,}",
+      // Authorization: Bearer <token>
+      "sk-[A-Za-z0-9]{16,}"
+      // OpenAI-style secret key
+    ];
+    var EMAIL_RE = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+    function escapeRegExp(value) {
+      return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function collectSecretVars(testVariables, minLen, keyRe) {
+      if (!testVariables)
+        return [];
+      const out = [];
+      for (const [key, value] of Object.entries(testVariables)) {
+        if (typeof value === "string" && value.length >= minLen && keyRe.test(key)) {
+          out.push({ key, value });
+        }
+      }
+      return out.sort((a, b) => b.value.length - a.value.length);
+    }
+    function redactMobileSecretsFromText(text, testVariables) {
+      if (!text)
+        return text;
+      let out = text;
+      for (const { key, value } of collectSecretVars(testVariables, MIN_REDACT_LEN, REDACT_KEY_RE)) {
+        out = out.replace(new RegExp(escapeRegExp(value), "g"), `{{${key}}}`);
+      }
+      for (const source of TOKEN_SOURCES) {
+        out = out.replace(new RegExp(source, "g"), "[REDACTED]");
+      }
+      out = out.replace(EMAIL_RE, "[EMAIL]");
+      return out;
+    }
+    function detectMobileStepSecretLeak(steps, testVariables) {
+      if (!Array.isArray(steps) || steps.length === 0)
+        return null;
+      const serialized = JSON.stringify(steps);
+      if (typeof serialized !== "string")
+        return null;
+      for (const { key, value } of collectSecretVars(testVariables, MIN_DETECT_LEN, DETECT_KEY_RE)) {
+        if (serialized.includes(value))
+          return `literal value of ${key}`;
+      }
+      for (const source of TOKEN_SOURCES) {
+        if (new RegExp(source).test(serialized))
+          return "embedded token/bearer/JWT";
+      }
+      return null;
+    }
+    var NEEDS_REVIEW_VERDICTS = /* @__PURE__ */ new Set([
+      "prereq_unmet",
+      "state_stale",
+      "test_invalid",
+      "unhealable_dynamic"
+    ]);
+    function computeMobileHealOutcome2(args) {
+      const { heal } = args;
+      const hasFix = Array.isArray(heal.healedSteps) && heal.healedSteps.length > 0;
+      const secretLeak = heal.passed && hasFix ? detectMobileStepSecretLeak(heal.healedSteps, args.testVariables) : null;
+      const isConfigIssue = heal.verdict === "config_issue";
+      const isAppBug = heal.verdict === "app_bug";
+      const extraTags = new Set((heal.extraTags ?? []).filter((t) => typeof t === "string" && t.length > 0));
+      if (secretLeak)
+        extraTags.add("@needs-review");
+      if (!heal.passed && NEEDS_REVIEW_VERDICTS.has(heal.verdict))
+        extraTags.add("@needs-review");
+      let status;
+      if (secretLeak)
+        status = "FAILED";
+      else if (heal.passed)
+        status = "PASSED";
+      else if (isConfigIssue)
+        status = "ERROR";
+      else
+        status = "FAILED";
+      let error2;
+      if (status === "PASSED") {
+        error2 = void 0;
+      } else if (secretLeak) {
+        error2 = `HEAL_SECRET_LEAK: healed steps contained a literal secret (${secretLeak}); patch dropped, tagged @needs-review`;
+      } else if (isConfigIssue) {
+        error2 = `CONFIG_ISSUE: ${heal.healReason ?? args.finalError ?? args.reproduceError ?? "environment/rate-limit blocker"}`;
+      } else if (isAppBug) {
+        error2 = `APP_BUG: ${heal.healReason ?? args.finalError ?? args.reproduceError ?? "application defect found during heal"}`;
+      } else {
+        error2 = args.finalError ?? heal.healReason ?? args.reproduceError ?? void 0;
+      }
+      return {
+        status,
+        error: error2,
+        extraTags: extraTags.size > 0 ? [...extraTags] : void 0,
+        removeTags: heal.removeTags,
+        shouldPatch: heal.passed === true && hasFix && !secretLeak,
+        secretLeak
+      };
+    }
+  }
+});
+
+// ../runner-core/dist/services/selector-registry-context.js
+var require_selector_registry_context = __commonJS({
+  "../runner-core/dist/services/selector-registry-context.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.normalizeSelectorRegistryEntries = normalizeSelectorRegistryEntries;
+    exports2.formatSelectorRegistryContextForPrompt = formatSelectorRegistryContextForPrompt;
+    exports2.collectRegistryCandidates = collectRegistryCandidates;
+    exports2.buildRegistryCandidateBlock = buildRegistryCandidateBlock;
+    exports2.planRegistryFallbackFix = planRegistryFallbackFix;
+    exports2.substituteSelectorInCode = substituteSelectorInCode;
+    exports2.parseMobileLocatorExpression = parseMobileLocatorExpression;
+    exports2.collectMobileRegistryCandidates = collectMobileRegistryCandidates;
+    exports2.mobileCandidateToTarget = mobileCandidateToTarget;
+    function isRecord(value) {
+      return value !== null && typeof value === "object" && !Array.isArray(value);
+    }
+    function asString(value, fallback = "") {
+      return typeof value === "string" ? value : fallback;
+    }
+    function asNumber(value, fallback = 0) {
+      return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+    }
+    function asStringArray(value) {
+      return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+    }
+    function truncateForSelectorPrompt(value, maxLength = 180) {
+      const normalized = (value ?? "").replace(/\s+/g, " ").trim();
+      if (normalized.length <= maxLength)
+        return normalized;
+      return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
+    }
+    function inlineCode(value, maxLength = 180) {
+      return `\`${truncateForSelectorPrompt(value, maxLength).replace(/`/g, "'")}\``;
+    }
+    function normalizeRef(value) {
+      if (!isRecord(value))
+        return null;
+      const expression = asString(value.expression).trim();
+      if (!expression)
+        return null;
+      return {
+        route: asString(value.route, "*"),
+        usage: asString(value.usage, "locator"),
+        source: asString(value.source, "generated"),
+        expression,
+        occurrenceIndex: asNumber(value.occurrenceIndex, 0)
+      };
+    }
+    function normalizeSibling(value) {
+      if (!isRecord(value))
+        return null;
+      const testCaseId = asString(value.testCaseId).trim();
+      const expression = asString(value.expression).trim();
+      if (!testCaseId || !expression)
+        return null;
+      return {
+        testCaseId,
+        name: asString(value.name, testCaseId),
+        suite: typeof value.suite === "string" ? value.suite : null,
+        lastPassedAt: typeof value.lastPassedAt === "string" ? value.lastPassedAt : null,
+        expression,
+        usage: asString(value.usage, "locator"),
+        route: asString(value.route, "*"),
+        source: asString(value.source, "generated")
+      };
+    }
+    function normalizeEntry(value) {
+      if (!isRecord(value))
+        return null;
+      const id = asString(value.id).trim();
+      const expression = asString(value.expression).trim();
+      if (!id || !expression)
+        return null;
+      return {
+        id,
+        key: asString(value.key, id),
+        route: asString(value.route, "*"),
+        scope: asString(value.scope, "page"),
+        status: asString(value.status, "ACTIVE"),
+        stability: asNumber(value.stability, 1),
+        label: asString(value.label),
+        locatorKind: asString(value.locatorKind),
+        locatorRole: typeof value.locatorRole === "string" ? value.locatorRole : null,
+        locatorName: typeof value.locatorName === "string" ? value.locatorName : null,
+        locatorTestId: typeof value.locatorTestId === "string" ? value.locatorTestId : null,
+        expression,
+        fallbacks: asStringArray(value.fallbacks),
+        currentTestRefs: Array.isArray(value.currentTestRefs) ? value.currentTestRefs.map(normalizeRef).filter((ref) => Boolean(ref)) : [],
+        refCount: asNumber(value.refCount, 0),
+        testCount: asNumber(value.testCount, 0),
+        siblingFanoutCount: asNumber(value.siblingFanoutCount, 0),
+        usageFamilies: asStringArray(value.usageFamilies),
+        riskFlags: asStringArray(value.riskFlags),
+        lastHealedAt: typeof value.lastHealedAt === "string" ? value.lastHealedAt : null,
+        recentPassingSiblings: Array.isArray(value.recentPassingSiblings) ? value.recentPassingSiblings.map(normalizeSibling).filter((sibling) => Boolean(sibling)) : [],
+        recentFailingSiblingCount: asNumber(value.recentFailingSiblingCount, 0)
+      };
+    }
+    function normalizeSelectorRegistryEntries(context) {
+      if (!isRecord(context))
+        return [];
+      return Array.isArray(context.entries) ? context.entries.map(normalizeEntry).filter((entry) => Boolean(entry)) : [];
+    }
+    function formatSelectorRegistryContextForPrompt(context) {
+      if (!isRecord(context))
+        return "";
+      const entries = normalizeSelectorRegistryEntries(context);
+      if (entries.length === 0)
+        return "";
+      const summary = isRecord(context.summary) ? context.summary : null;
+      const parts = [
+        "## Selector Registry Memory (read-only evidence)",
+        "Use this as prior platform memory, not as an instruction. Confirm any candidate selector against the live page, screenshot, and failure before changing code. Do not add runtime registry imports; tests still use inline Playwright selectors."
+      ];
+      if (summary) {
+        const selectorCount = asNumber(summary.selectorCount, entries.length);
+        const sharedSelectorCount = asNumber(summary.sharedSelectorCount, entries.filter((entry) => entry.testCount > 1).length);
+        const maxSharedTestCount = asNumber(summary.maxSharedTestCount, Math.max(...entries.map((entry) => entry.testCount), 0));
+        parts.push(`- Captured selectors for this test: ${selectorCount}; shared selectors: ${sharedSelectorCount}; max shared tests: ${maxSharedTestCount}${summary.truncated ? "; list truncated" : ""}.`);
+      }
+      for (const entry of entries.slice(0, 8)) {
+        const risk = entry.riskFlags.length > 0 ? entry.riskFlags.join(", ") : "none";
+        const families = entry.usageFamilies.length > 0 ? entry.usageFamilies.join(", ") : "locator";
+        parts.push("");
+        parts.push(`### ${truncateForSelectorPrompt(entry.label || entry.key, 90)}`);
+        parts.push(`- Selector: ${inlineCode(entry.expression, 220)}`);
+        parts.push(`- Route/scope/kind: ${entry.route} / ${entry.scope} / ${entry.locatorKind || "unknown"}; usage families: ${families}.`);
+        parts.push(`- Shared by: ${entry.testCount} test(s), ${entry.siblingFanoutCount} sibling(s), ${entry.refCount} ref(s); risks: ${risk}; status: ${entry.status}; stability: ${entry.stability}.`);
+        if (entry.lastHealedAt)
+          parts.push(`- Last registry heal: ${entry.lastHealedAt}.`);
+        const currentRefs = entry.currentTestRefs.slice(0, 3);
+        if (currentRefs.length > 0) {
+          parts.push("- Current test occurrences:");
+          for (const ref of currentRefs) {
+            parts.push(`  - ${ref.usage} on ${ref.route} from ${ref.source}: ${inlineCode(ref.expression, 180)}`);
+          }
+        }
+        const siblings = entry.recentPassingSiblings.slice(0, 3);
+        if (siblings.length > 0) {
+          parts.push("- Recent passing sibling tests using this registry entry:");
+          for (const sibling of siblings) {
+            const suite = sibling.suite ? ` (${truncateForSelectorPrompt(sibling.suite, 50)})` : "";
+            const passed = sibling.lastPassedAt ? ` passed ${sibling.lastPassedAt}` : "";
+            parts.push(`  - ${truncateForSelectorPrompt(sibling.name, 80)}${suite}${passed}: ${inlineCode(sibling.expression, 180)}`);
+          }
+        }
+        if (entry.recentFailingSiblingCount && entry.recentFailingSiblingCount > 0) {
+          parts.push(`- Other recent failing siblings on this entry: ${entry.recentFailingSiblingCount}.`);
+        }
+        const fallbacks = (entry.fallbacks ?? []).slice(0, 3);
+        if (fallbacks.length > 0) {
+          parts.push(`- Registry fallbacks: ${fallbacks.map((fallback) => inlineCode(fallback, 120)).join(", ")}.`);
+        }
+      }
+      return `${parts.join("\n")}
+`;
+    }
+    function selectorKey(expression) {
+      return expression.trim().replace(/^page\s*\.\s*/, "").replace(/\s+/g, " ").replace(/"/g, "'").trim();
+    }
+    function collectRegistryCandidates(context) {
+      const entries = normalizeSelectorRegistryEntries(context).slice(0, 8);
+      const seen = /* @__PURE__ */ new Set();
+      const ranked = [[], [], []];
+      for (const entry of entries) {
+        const entryLabel = entry.label || entry.key;
+        for (const sibling of entry.recentPassingSiblings) {
+          const key = selectorKey(sibling.expression);
+          if (seen.has(key))
+            continue;
+          seen.add(key);
+          ranked[0].push({ expression: sibling.expression, source: "passing-sibling", entryLabel, siblingName: sibling.name });
+        }
+        const entryKey = selectorKey(entry.expression);
+        if (!seen.has(entryKey)) {
+          seen.add(entryKey);
+          ranked[1].push({ expression: entry.expression, source: "registry-entry", entryLabel });
+        }
+        for (const fallback of entry.fallbacks ?? []) {
+          const key = selectorKey(fallback);
+          if (seen.has(key))
+            continue;
+          seen.add(key);
+          ranked[2].push({ expression: fallback, source: "fallback", entryLabel });
+        }
+      }
+      return ranked.flat();
+    }
+    function buildRegistryCandidateBlock(context, excludeExpressions) {
+      const exclude = new Set(excludeExpressions.map(selectorKey));
+      const candidates = collectRegistryCandidates(context).filter((candidate) => !exclude.has(selectorKey(candidate.expression))).slice(0, 6);
+      if (candidates.length === 0)
+        return "";
+      const lines = [
+        "## Untried Selector Candidates (from registry memory)",
+        "Ranked alternatives for elements this test uses, from the platform selector registry. Verify each against the screenshot and error before adopting \u2014 do not adopt blindly."
+      ];
+      for (const candidate of candidates) {
+        const provenance = candidate.source === "passing-sibling" ? `proven in passing sibling "${truncateForSelectorPrompt(candidate.siblingName, 80)}"` : candidate.source === "registry-entry" ? `registry entry for "${truncateForSelectorPrompt(candidate.entryLabel, 80)}"` : `registry fallback for "${truncateForSelectorPrompt(candidate.entryLabel, 80)}"`;
+        lines.push(`- ${inlineCode(candidate.expression, 180)} \u2014 ${provenance}`);
+      }
+      return lines.join("\n");
+    }
+    function findExpressionInCode(code, expression) {
+      const trimmed = expression.trim();
+      if (trimmed && code.includes(trimmed))
+        return trimmed;
+      const withoutPage = trimmed.replace(/^page\s*\.\s*/, "");
+      if (withoutPage !== trimmed && withoutPage && code.includes(withoutPage))
+        return withoutPage;
+      const withPage = `page.${withoutPage}`;
+      if (withPage !== trimmed && code.includes(withPage))
+        return withPage;
+      return null;
+    }
+    function extractFailureFocus(error2) {
+      const focus = error2.split(/\r?\n/).filter((line) => /^\s*>/.test(line) || /waiting for|locator resolved to/i.test(line) || /^\s*locator:/i.test(line));
+      return focus.length > 0 ? focus.join("\n") : error2;
+    }
+    function planRegistryFallbackFix(args) {
+      const { code, error: error2, context } = args;
+      if (!error2 || !code)
+        return null;
+      const entries = normalizeSelectorRegistryEntries(context).slice(0, 8);
+      if (entries.length === 0)
+        return null;
+      const errorKey = selectorKey(extractFailureFocus(error2));
+      for (const entry of entries) {
+        const failingExpressions = [entry.expression, ...entry.currentTestRefs.map((ref) => ref.expression)];
+        const failingSeen = /* @__PURE__ */ new Set();
+        for (const failing of failingExpressions) {
+          const failingKey = selectorKey(failing);
+          if (!failingKey || failingSeen.has(failingKey))
+            continue;
+          failingSeen.add(failingKey);
+          if (!errorKey.includes(failingKey))
+            continue;
+          const matchedInCode = findExpressionInCode(code, failing);
+          if (!matchedInCode)
+            continue;
+          const entryLabel = entry.label || entry.key;
+          const candidateSeen = /* @__PURE__ */ new Set([failingKey]);
+          const candidates = [];
+          for (const fallback of entry.fallbacks ?? []) {
+            const key = selectorKey(fallback);
+            if (!key || candidateSeen.has(key) || code.includes(fallback.trim()))
+              continue;
+            candidateSeen.add(key);
+            candidates.push({ expression: fallback, source: "fallback", entryLabel });
+          }
+          for (const sibling of entry.recentPassingSiblings) {
+            const key = selectorKey(sibling.expression);
+            if (!key || candidateSeen.has(key) || code.includes(sibling.expression.trim()))
+              continue;
+            candidateSeen.add(key);
+            candidates.push({ expression: sibling.expression, source: "passing-sibling", entryLabel, siblingName: sibling.name });
+          }
+          if (candidates.length === 0)
+            continue;
+          return { matchedInCode, entryLabel, candidates };
+        }
+      }
+      return null;
+    }
+    function substituteSelectorInCode(code, matchedInCode, replacement) {
+      const target = matchedInCode.trim();
+      let normalized = replacement.trim();
+      const targetHasPage = /^page\s*\.\s*/.test(target);
+      const replacementHasPage = /^page\s*\.\s*/.test(normalized);
+      if (targetHasPage && !replacementHasPage)
+        normalized = `page.${normalized}`;
+      if (!targetHasPage && replacementHasPage)
+        normalized = normalized.replace(/^page\s*\.\s*/, "");
+      return code.split(target).join(normalized);
+    }
+    var MOBILE_LOCATOR_RE = /^mobile\.(accessibilityId|resourceId|text|contentDesc|xpath|className|locator)\(\s*'((?:\\.|[^'])*)'\s*\)$/;
+    function unescapeMobileLocatorValue(value) {
+      return value.replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+    }
+    function parseMobileLocatorExpression(expression) {
+      const match = MOBILE_LOCATOR_RE.exec(expression.trim());
+      if (!match)
+        return null;
+      return { kind: match[1], value: unescapeMobileLocatorValue(match[2]).trim() };
+    }
+    function mobileIdentityKey(parts) {
+      return `${parts.kind}\0${parts.value}`;
+    }
+    function collectMobileFallbackExpressions(entry, primary) {
+      const seen = /* @__PURE__ */ new Set([mobileIdentityKey(primary)]);
+      const fallbacks = [];
+      const consider = (expression) => {
+        const parsed = parseMobileLocatorExpression(expression);
+        if (!parsed)
+          return;
+        const key = mobileIdentityKey(parsed);
+        if (seen.has(key))
+          return;
+        seen.add(key);
+        fallbacks.push(expression.trim());
+      };
+      for (const fallback of entry.fallbacks ?? [])
+        consider(fallback);
+      for (const sibling of entry.recentPassingSiblings)
+        consider(sibling.expression);
+      return fallbacks;
+    }
+    function collectMobileRegistryCandidates(context) {
+      const entries = normalizeSelectorRegistryEntries(context).slice(0, 8);
+      const seen = /* @__PURE__ */ new Set();
+      const candidates = [];
+      for (const entry of entries) {
+        const primary = parseMobileLocatorExpression(entry.expression);
+        if (!primary)
+          continue;
+        const identityKey = mobileIdentityKey(primary);
+        if (seen.has(identityKey))
+          continue;
+        seen.add(identityKey);
+        candidates.push({
+          kind: primary.kind,
+          value: primary.value,
+          fallbacks: collectMobileFallbackExpressions(entry, primary)
+        });
+      }
+      return candidates;
+    }
+    function mobileCandidateToTarget(candidate) {
+      const { kind, value } = candidate;
+      switch (kind) {
+        case "resourceId":
+          return { locatorBundle: { resourceId: value } };
+        case "accessibilityId":
+          return { locatorBundle: { accessibilityId: value } };
+        case "text":
+          return { locatorBundle: { text: value } };
+        case "contentDesc":
+          return { locatorBundle: { contentDesc: value } };
+        case "xpath":
+          return { locatorBundle: { xpath: value } };
+        case "className":
+          return { locatorBundle: { className: value } };
+        default:
+          return {};
+      }
+    }
+  }
+});
+
+// ../runner-core/dist/services/mobile/mobile-heal-loop.js
+var require_mobile_heal_loop = __commonJS({
+  "../runner-core/dist/services/mobile/mobile-heal-loop.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.MOBILE_LIVE_HEAL_SYSTEM_PROMPT = exports2.MOBILE_SCRIPT_HEAL_SYSTEM_PROMPT = void 0;
+    exports2.executeMobileScriptDrivenHeal = executeMobileScriptDrivenHeal;
+    exports2.executeMobileTestWithHealing = executeMobileTestWithHealing2;
+    exports2.executeMobileLiveHeal = executeMobileLiveHeal2;
+    var ai_provider_js_1 = require_ai_provider();
+    var ai_queue_js_1 = require_ai_queue();
+    var ai_retry_js_1 = require_ai_retry();
+    var mobile_source_parser_js_1 = require_mobile_source_parser();
+    var mobile_heal_postprocess_js_1 = require_mobile_heal_postprocess();
+    var mobile_observation_js_1 = require_mobile_observation();
+    var selector_registry_context_js_1 = require_selector_registry_context();
+    exports2.MOBILE_SCRIPT_HEAL_SYSTEM_PROMPT = `You are a QA engineer fixing a failing Appium (mobile UI automation) test. You receive: the test STEPS as JSON, the failure ERROR + step-level results, and the PAGE-SOURCE accessibility tree captured at the moment of failure (this tree is your 'screenshot'), plus optional known-good selector candidates from a registry.
+## You MUST try to fix the steps
+Reason over steps + error + tree + registry and return working healed steps. Do NOT return needs_device unless you have genuinely exhausted that reasoning (and NEVER before your final attempt).
+## Analyze
+1. ERROR: which step failed, on what locator/assertion? "element not found"/"no such element" almost always means a WRONG LOCATOR on a screen that DOES exist \u2014 pick a stronger IDENTITY locator that is actually present in the captured tree: a resource-id, an accessibility-id/content-desc, or an EXACT @text= predicate (never a loose contains()). Do NOT declare a feature absent from one failed locator.
+2. STEP RESULTS: which steps passed before the failure.
+3. TREE: does the current screen match what the failed step expects?
+4. ENTRY-SCREEN DRIFT ("unexpected screen"/"screen drift"): the app started on a DIFFERENT screen than recorded; the fix is usually a MISSING NAVIGATION step (e.g. tap "Get Started" before the recorded first step). Author it from the tree if you can (verdict fix); if a single static tree is insufficient, return needs_device.
+## Response \u2014 STRICT JSON, exactly one verdict:
+{"verdict":"fix","steps":[<FULL healed MobileTestStep array, all steps, your changes applied, order/metadata preserved>],"reason":"what changed and why","confidence":0.0-1.0}
+{"verdict":"app_bug","reason":"app crashed/blank/5xx (NOT rate-limit)"}
+{"verdict":"config_issue","reason":"429/rate limit/lockout/quota"}
+{"verdict":"needs_device","reason":"cannot fix from a static tree; need live re-observation"}
+{"verdict":"prereq_unmet","reason":"required entity/state absent for the account"}
+{"verdict":"state_stale","reason":"leftover data blocks a baseline assertion"}
+{"verdict":"test_invalid","reason":"scenario cannot be made to pass"}
+For a fix, return the COMPLETE steps array (not a diff).`;
+    var DEFAULT_SCRIPT_MAX_ATTEMPTS = 6;
+    var RECOVERABLE_MAX = 3;
+    var BONUS_ATTEMPTS_CEIL = 4;
+    var DEFAULT_BONUS_ATTEMPTS = 2;
+    var MAX_LOG_CHARS = 4096;
+    var OBSERVATION_MAX_ELEMENTS = 120;
+    var REGISTRY_PREFLIGHT_MAX_CANDIDATES = 2;
+    var MOBILE_HEAL_VERDICTS = [
+      "fix",
+      "app_bug",
+      "config_issue",
+      "needs_device",
+      "prereq_unmet",
+      "state_stale",
+      "test_invalid",
+      "unhealable_dynamic"
+    ];
+    var TERMINAL_VERDICTS = /* @__PURE__ */ new Set([
+      "app_bug",
+      "config_issue",
+      "prereq_unmet",
+      "state_stale",
+      "test_invalid",
+      "unhealable_dynamic"
+    ]);
+    function isRecord(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    function envInt2(key) {
+      const raw = process.env[key];
+      if (raw === void 0)
+        return void 0;
+      const parsed = Number.parseInt(raw, 10);
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+    }
+    function tailLimit(text, max) {
+      return text.length <= max ? text : text.slice(text.length - max);
+    }
+    function isMobileHealVerdict(value) {
+      return MOBILE_HEAL_VERDICTS.includes(value);
+    }
+    function isLocatorNotFound(error2) {
+      return /not found|no such element/i.test(error2 ?? "");
+    }
+    function isDrift(error2) {
+      return /unexpected screen|screen drift/i.test(error2 ?? "");
+    }
+    function stripCodeFences(text) {
+      const trimmed = text.trim();
+      const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/m.exec(trimmed);
+      return fenced ? fenced[1].trim() : trimmed;
+    }
+    function extractBracesSubstring(text) {
+      const first = text.indexOf("{");
+      const last = text.lastIndexOf("}");
+      if (first === -1 || last === -1 || last <= first)
+        return null;
+      return text.slice(first, last + 1);
+    }
+    function safeJsonParse(text) {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return void 0;
+      }
+    }
+    function coerceSteps(value) {
+      if (!Array.isArray(value) || value.length === 0)
+        return void 0;
+      const allValid = value.every((step) => isRecord(step) && typeof step.action === "string" && typeof step.order === "number");
+      return allValid ? value : void 0;
+    }
+    function parseHealVerdict(content) {
+      const cleaned = stripCodeFences(content);
+      let obj = safeJsonParse(cleaned);
+      if (!isRecord(obj)) {
+        const sub = extractBracesSubstring(cleaned);
+        obj = sub ? safeJsonParse(sub) : void 0;
+      }
+      if (!isRecord(obj))
+        return null;
+      const rawVerdict = obj.verdict;
+      if (typeof rawVerdict !== "string" || !isMobileHealVerdict(rawVerdict))
+        return null;
+      return {
+        verdict: rawVerdict,
+        steps: coerceSteps(obj.steps),
+        reason: typeof obj.reason === "string" ? obj.reason : void 0,
+        confidence: typeof obj.confidence === "number" ? obj.confidence : void 0
+      };
+    }
+    function partsToCandidate(parts) {
+      switch (parts.kind) {
+        case "accessibilityId":
+          return { accessibilityId: parts.value };
+        case "resourceId":
+          return { resourceId: parts.value };
+        case "text":
+        case "contentDesc":
+          return { text: parts.value };
+        case "xpath":
+          return { xpath: parts.value };
+        case "className":
+          return { className: parts.value };
+        default:
+          return {};
+      }
+    }
+    function hasIdentitySignal(candidate) {
+      return Boolean(candidate.accessibilityId || candidate.resourceId || candidate.text || candidate.xpath);
+    }
+    function stepToLocatorCandidate(step) {
+      const primary = step.target?.primary;
+      if (primary) {
+        const parsed = (0, selector_registry_context_js_1.parseMobileLocatorExpression)(primary);
+        if (parsed) {
+          const candidate = partsToCandidate(parsed);
+          if (hasIdentitySignal(candidate))
+            return candidate;
+        }
+      }
+      const bundle = step.target?.locatorBundle;
+      if (bundle) {
+        const candidate = {};
+        if (bundle.accessibilityId)
+          candidate.accessibilityId = bundle.accessibilityId;
+        if (bundle.resourceId)
+          candidate.resourceId = bundle.resourceId;
+        if (bundle.text)
+          candidate.text = bundle.text;
+        else if (bundle.contentDesc)
+          candidate.text = bundle.contentDesc;
+        if (bundle.xpath)
+          candidate.xpath = bundle.xpath;
+        if (hasIdentitySignal(candidate))
+          return candidate;
+      }
+      return null;
+    }
+    function stepIdentityExpressions(step) {
+      const out = [];
+      const primary = step.target?.primary;
+      if (primary)
+        out.push(primary);
+      const bundle = step.target?.locatorBundle;
+      if (bundle) {
+        if (bundle.resourceId)
+          out.push(`mobile.resourceId('${bundle.resourceId}')`);
+        if (bundle.accessibilityId)
+          out.push(`mobile.accessibilityId('${bundle.accessibilityId}')`);
+        if (bundle.text)
+          out.push(`mobile.text('${bundle.text}')`);
+        if (bundle.contentDesc)
+          out.push(`mobile.contentDesc('${bundle.contentDesc}')`);
+        if (bundle.xpath)
+          out.push(`mobile.xpath('${bundle.xpath}')`);
+      }
+      return out;
+    }
+    function stepTargetChanged(base2, healed) {
+      return JSON.stringify(base2?.target) !== JSON.stringify(healed.target);
+    }
+    function findMissingChangedLocators(baseSteps, healedSteps, screen) {
+      const missing = [];
+      healedSteps.forEach((healed, index) => {
+        if (!stepTargetChanged(baseSteps[index], healed))
+          return;
+        const candidate = stepToLocatorCandidate(healed);
+        if (!candidate)
+          return;
+        if ((0, mobile_source_parser_js_1.resolveLocatorAgainstScreen)(candidate, screen).length === 0) {
+          missing.push({
+            label: healed.target?.primary ?? JSON.stringify(candidate),
+            expressions: stepIdentityExpressions(healed)
+          });
+        }
+      });
+      return missing;
+    }
+    function changedStepExpressions(baseSteps, healedSteps) {
+      const out = [];
+      healedSteps.forEach((healed, index) => {
+        if (stepTargetChanged(baseSteps[index], healed))
+          out.push(...stepIdentityExpressions(healed));
+      });
+      return out;
+    }
+    function pushUnique(target, additions) {
+      for (const value of additions) {
+        if (value && !target.includes(value))
+          target.push(value);
+      }
+    }
+    function buildUserContent(args) {
+      const parts = [];
+      const safeError = (0, mobile_heal_postprocess_js_1.redactMobileSecretsFromText)(args.activeError ?? void 0, args.testVariables);
+      const safeLogs = (0, mobile_heal_postprocess_js_1.redactMobileSecretsFromText)(args.trimmedLogs, args.testVariables);
+      parts.push("## Failing test steps (JSON)");
+      parts.push("```json\n" + JSON.stringify(args.baseSteps, null, 2) + "\n```");
+      parts.push("## Steps (numbered)");
+      parts.push(args.baseSteps.map((step, index) => {
+        const locator = step.target?.primary ? ` -> ${step.target.primary}` : "";
+        return `${index + 1}. [${step.action}] ${step.description ?? ""}${locator}`;
+      }).join("\n"));
+      parts.push("## Failure");
+      parts.push(`Error: ${safeError ?? "(none reported)"}`);
+      if (safeLogs)
+        parts.push("Logs (tail):\n" + safeLogs);
+      if (args.activeFailingSource) {
+        const safeSource = (0, mobile_heal_postprocess_js_1.redactMobileSecretsFromText)(args.activeFailingSource, args.testVariables) ?? args.activeFailingSource;
+        const screen = (0, mobile_source_parser_js_1.parseMobileSource)(safeSource, args.platform);
+        parts.push("## Captured screen (accessibility tree at moment of failure)");
+        parts.push((0, mobile_observation_js_1.renderMobileObservation)(screen, { maxElements: OBSERVATION_MAX_ELEMENTS }));
+      }
+      if (args.attempt === 1) {
+        const registryBlock = (0, selector_registry_context_js_1.formatSelectorRegistryContextForPrompt)(args.registryContext);
+        if (registryBlock)
+          parts.push(registryBlock);
+      } else {
+        const candidateBlock = (0, selector_registry_context_js_1.buildRegistryCandidateBlock)(args.registryContext, [...args.triedLocators]);
+        if (candidateBlock)
+          parts.push(candidateBlock);
+        if (args.triedLocators.length > 0) {
+          parts.push("## Locators already tried (do NOT repeat):\n" + args.triedLocators.map((locator) => `- ${locator}`).join("\n"));
+        }
+        const safeLastError = (0, mobile_heal_postprocess_js_1.redactMobileSecretsFromText)(args.lastError, args.testVariables);
+        if (safeLastError)
+          parts.push(`## Previous fix failed with:
+${safeLastError}`);
+      }
+      if (args.directive)
+        parts.push(`## Directive
+${args.directive}`);
+      return parts.join("\n\n");
+    }
+    function findFailingStepIndex(steps, error2) {
+      const withTarget = steps.map((step, index) => ({ step, index })).filter((entry) => Boolean(entry.step.target?.primary));
+      if (withTarget.length === 0)
+        return -1;
+      if (error2) {
+        for (let k = withTarget.length - 1; k >= 0; k -= 1) {
+          const primary = withTarget[k].step.target?.primary;
+          if (primary && error2.includes(primary))
+            return withTarget[k].index;
+        }
+      }
+      return withTarget[withTarget.length - 1].index;
+    }
+    function substituteStepTarget(steps, index, candidate, bundlePartial) {
+      const existing = steps[index].target;
+      const newBundle = {
+        xpath: existing?.locatorBundle?.xpath ?? "",
+        className: existing?.locatorBundle?.className ?? "",
+        ...existing?.locatorBundle,
+        ...bundlePartial
+      };
+      const escaped = candidate.value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+      const newTarget = {
+        primary: `mobile.${candidate.kind}('${escaped}')`,
+        fallbacks: existing?.fallbacks ?? [],
+        screenName: existing?.screenName ?? "",
+        locatorBundle: newBundle,
+        platformLocators: existing?.platformLocators
+      };
+      return steps.map((step, i) => i === index ? { ...step, target: newTarget } : step);
+    }
+    async function tryRegistryPreflight(steps, target, ctx, options) {
+      const runNativeTest = options.runNativeTest;
+      if (!runNativeTest || !options.selectorRegistryContext || !ctx.error)
+        return null;
+      const candidates = (0, selector_registry_context_js_1.collectMobileRegistryCandidates)(options.selectorRegistryContext);
+      const failingIndex = findFailingStepIndex(steps, ctx.error);
+      if (failingIndex < 0)
+        return null;
+      let tried = 0;
+      for (const candidate of candidates) {
+        if (tried >= REGISTRY_PREFLIGHT_MAX_CANDIDATES)
+          break;
+        const mapped = (0, selector_registry_context_js_1.mobileCandidateToTarget)(candidate);
+        if (!mapped.locatorBundle || Object.keys(mapped.locatorBundle).length === 0)
+          continue;
+        tried += 1;
+        const healedSteps = substituteStepTarget(steps, failingIndex, candidate, mapped.locatorBundle);
+        const verify = await runNativeTest({ steps: healedSteps, target, testVariables: ctx.testVariables });
+        if (verify.passed) {
+          return {
+            passed: true,
+            verdict: "fix",
+            healedSteps,
+            healReason: "registry-fallback",
+            stepResults: verify.stepResults,
+            logs: verify.logs
+          };
+        }
+      }
+      return null;
+    }
+    async function executeMobileScriptDrivenHeal(steps, target, ctx, options) {
+      const aiClient = options.aiClient ?? (options.model ? (0, ai_provider_js_1.getMobileClientForModel)(options.model) : (0, ai_provider_js_1.getMobileAIClient)());
+      const model = options.model ? (0, ai_provider_js_1.resolveModelForTask)(options.model, "strong") : (0, ai_provider_js_1.getModel)("strong");
+      const base2 = options.maxScriptAttempts ?? envInt2("MOBILE_HEAL_SCRIPT_MAX_ATTEMPTS") ?? DEFAULT_SCRIPT_MAX_ATTEMPTS;
+      const bonusMax = Math.min(options.bonusAttempts ?? DEFAULT_BONUS_ATTEMPTS, BONUS_ATTEMPTS_CEIL);
+      const registryPresent = options.selectorRegistryContext != null;
+      const platform3 = target.platform;
+      const trimmedLogs = tailLimit(ctx.logs ?? "", MAX_LOG_CHARS);
+      let attemptCap = base2;
+      let recoverableUsed = 0;
+      let bonusUsed = 0;
+      let attempt = 0;
+      let baseSteps = steps;
+      let activeError = ctx.error;
+      let activeFailingSource = ctx.failingSource;
+      let lastError;
+      let lastHealedSteps;
+      let lastHealReason;
+      let lastConfidence;
+      let lastVerdict;
+      let pendingDirective = null;
+      const triedLocators = [];
+      let sameErrorCount = 0;
+      let lastErrorSignature = null;
+      const markRecoverableTurn = () => {
+        if (recoverableUsed < RECOVERABLE_MAX) {
+          attemptCap += 1;
+          recoverableUsed += 1;
+        }
+      };
+      const noteError = (error2) => {
+        const signature = (error2 ?? "").slice(0, 150);
+        if (signature && signature === lastErrorSignature) {
+          sameErrorCount += 1;
+        } else {
+          sameErrorCount = error2 ? 1 : 0;
+          lastErrorSignature = signature;
+        }
+      };
+      for (; ; ) {
+        if (attempt >= attemptCap) {
+          const untriedRegistry = registryPresent && (0, selector_registry_context_js_1.buildRegistryCandidateBlock)(options.selectorRegistryContext, triedLocators) !== "";
+          const canBonus = bonusUsed < bonusMax && lastHealedSteps !== void 0 && sameErrorCount < 2 && untriedRegistry;
+          if (canBonus) {
+            attemptCap += 1;
+            bonusUsed += 1;
+          } else {
+            break;
+          }
+        }
+        attempt += 1;
+        const userContent = buildUserContent({
+          attempt,
+          baseSteps,
+          activeError,
+          trimmedLogs,
+          activeFailingSource,
+          platform: platform3,
+          registryContext: options.selectorRegistryContext ?? null,
+          triedLocators,
+          lastError,
+          directive: pendingDirective,
+          testVariables: ctx.testVariables
+        });
+        pendingDirective = null;
+        const messages = [
+          { role: "system", content: exports2.MOBILE_SCRIPT_HEAL_SYSTEM_PROMPT },
+          { role: "user", content: userContent }
+        ];
+        let content;
+        try {
+          const response = await (0, ai_retry_js_1.resilientAICall)((signal, arm) => (0, ai_queue_js_1.queuedAICall)(() => {
+            arm();
+            return aiClient.chat.completions.create({ model, messages, max_tokens: 8e3, temperature: 0.1 }, { signal });
+          }), { label: `mobile-heal-attempt-${attempt}`, deferTimeoutUntilArmed: true });
+          content = response?.choices?.[0]?.message?.content ?? "";
+        } catch {
+          markRecoverableTurn();
+          pendingDirective = "The previous attempt did not reach the model. Re-analyze and return one valid JSON verdict.";
+          continue;
+        }
+        const parsed = parseHealVerdict(content);
+        if (!parsed) {
+          markRecoverableTurn();
+          pendingDirective = "Your last response was not valid JSON matching the verdict schema. Return exactly one JSON verdict object.";
+          continue;
+        }
+        if (TERMINAL_VERDICTS.has(parsed.verdict)) {
+          return { passed: false, verdict: parsed.verdict, healReason: parsed.reason, attemptsUsed: attempt };
+        }
+        if (parsed.verdict === "needs_device") {
+          const isFinalAttempt = attempt >= attemptCap && recoverableUsed >= RECOVERABLE_MAX;
+          if (!isFinalAttempt) {
+            markRecoverableTurn();
+            pendingDirective = "You returned needs_device but MUST try a step/locator fix first \u2014 this is not your final attempt. Re-analyze the captured tree and return a concrete fix.";
+            continue;
+          }
+          return {
+            passed: false,
+            verdict: "needs_device",
+            healedSteps: lastHealedSteps,
+            healReason: parsed.reason,
+            attemptsUsed: attempt,
+            verifiedFallbackAvailable: lastHealedSteps !== void 0
+          };
+        }
+        const healedSteps = parsed.steps;
+        if (!healedSteps) {
+          markRecoverableTurn();
+          pendingDirective = 'You returned verdict "fix" but no usable steps array. Return the COMPLETE healed MobileTestStep array.';
+          continue;
+        }
+        if (activeFailingSource && isLocatorNotFound(activeError) && !isDrift(activeError)) {
+          const screen = (0, mobile_source_parser_js_1.parseMobileSource)(activeFailingSource, platform3);
+          const missing = findMissingChangedLocators(baseSteps, healedSteps, screen);
+          if (missing.length > 0) {
+            for (const entry of missing)
+              pushUnique(triedLocators, entry.expressions);
+            markRecoverableTurn();
+            lastVerdict = "fix";
+            pendingDirective = `Your proposed locator ${missing[0].label} does NOT exist in the captured screen tree. Pick an identity locator (resource-id, accessibility-id, or exact @text=) that is PRESENT in the tree.`;
+            continue;
+          }
+        }
+        if (!options.runNativeTest) {
+          lastHealedSteps = healedSteps;
+          lastHealReason = parsed.reason;
+          lastConfidence = parsed.confidence;
+          lastVerdict = "fix";
+          pushUnique(triedLocators, changedStepExpressions(baseSteps, healedSteps));
+          baseSteps = healedSteps;
+          pendingDirective = "The proposed fix could not be device-verified here. If it is not clearly correct, revise it.";
+          continue;
+        }
+        const verify = await options.runNativeTest({ steps: healedSteps, target, testVariables: ctx.testVariables });
+        if (verify.passed) {
+          return {
+            passed: true,
+            verdict: "fix",
+            healedSteps,
+            healReason: parsed.reason,
+            confidence: parsed.confidence,
+            attemptsUsed: attempt
+          };
+        }
+        lastError = verify.error ?? lastError;
+        lastHealedSteps = healedSteps;
+        lastHealReason = parsed.reason;
+        lastConfidence = parsed.confidence;
+        lastVerdict = "fix";
+        noteError(verify.error);
+        pushUnique(triedLocators, changedStepExpressions(baseSteps, healedSteps));
+        if (verify.failingSource)
+          activeFailingSource = verify.failingSource;
+        activeError = verify.error ?? activeError;
+        baseSteps = healedSteps;
+      }
+      return {
+        passed: false,
+        verdict: lastVerdict ?? "fix",
+        healedSteps: lastHealedSteps,
+        healReason: lastHealReason,
+        confidence: lastConfidence,
+        attemptsUsed: attempt,
+        lastError,
+        verifiedFallbackAvailable: lastHealedSteps !== void 0 ? false : void 0
+      };
+    }
+    async function executeMobileTestWithHealing2(steps, target, ctx, options) {
+      const preflight = await tryRegistryPreflight(steps, target, ctx, options);
+      if (preflight)
+        return preflight;
+      const script = await executeMobileScriptDrivenHeal(steps, target, ctx, options);
+      const shouldEscalate = script.verdict === "needs_device" || !script.passed;
+      if (shouldEscalate && options.runLiveHeal) {
+        return options.runLiveHeal({
+          steps: script.healedSteps ?? steps,
+          target,
+          testVariables: ctx.testVariables,
+          options
+        });
+      }
+      return {
+        passed: script.passed,
+        healedSteps: script.healedSteps,
+        healedAppiumCode: script.healedAppiumCode,
+        healReason: script.healReason,
+        verdict: script.verdict,
+        confidence: script.confidence,
+        extraTags: script.extraTags,
+        removeTags: script.removeTags
+      };
+    }
+    var DEFAULT_PHASE2_MAX_PASSES = 6;
+    exports2.MOBILE_LIVE_HEAL_SYSTEM_PROMPT = `You are a QA engineer fixing a failing Appium (mobile UI automation) test with LIVE device access (Phase 2). You receive: the failing test STEPS as JSON, the PRIOR failure error, and the LIVE current screen accessibility tree observed on-device RIGHT NOW. Unlike a frozen failure snapshot, this LIVE tree is the REAL screen the app is on this instant.
+## Key insight \u2014 ENTRY-SCREEN DRIFT
+The recorded flow may have expected a DIFFERENT starting screen than the one shown. When the LIVE screen is an earlier/other screen (e.g. an onboarding or "Get Started" screen), the fix is almost always a MISSING NAVIGATION step: AUTHOR the leading step(s) (e.g. a tap on "Get Started") that reach the recorded first screen, then keep the recorded steps. This is exactly what a static failing-source cannot reveal but a LIVE screen can.
+## Analyze
+1. Compare the recorded first step's expected screen to the LIVE tree.
+2. If they differ, PREPEND the missing navigation step(s), authored from IDENTITY locators (resource-id, accessibility-id, or EXACT @text=) that are PRESENT in the LIVE tree \u2014 never a loose contains().
+3. If a locator is simply wrong, swap it for a stronger identity locator present in the LIVE tree.
+4. If you cannot yet SEE the screen you need, use "observe" to advance ONE step, then you will be re-shown the new live screen.
+## Response \u2014 STRICT JSON, exactly one verdict:
+{"verdict":"fix","steps":[<FULL healed MobileTestStep array, all steps incl. any prepended navigation, order/metadata coherent>],"reason":"what changed and why","confidence":0.0-1.0}
+{"verdict":"observe","action":{"type":"tap","target":"mobile.text('Get Started')"}}
+{"verdict":"observe","action":{"type":"back"}}
+{"verdict":"observe","action":{"type":"relaunch"}}
+{"verdict":"observe","action":{"type":"reset"}}   \u2190 clears app data + cold-relaunches: use when the app is in the WRONG STATE for the recorded flow (e.g. signed in when the test expects the cleared first-launch screens, stale onboarding, poisoned local state)
+{"verdict":"app_bug","reason":"app crashed/blank/5xx (NOT rate-limit)"}
+{"verdict":"config_issue","reason":"429/rate limit/lockout/quota"}
+{"verdict":"needs_device","reason":"cannot resolve even with live access"}
+{"verdict":"prereq_unmet","reason":"required entity/state absent for the account"}
+{"verdict":"state_stale","reason":"leftover data blocks a baseline assertion"}
+{"verdict":"test_invalid","reason":"scenario cannot be made to pass"}
+{"verdict":"unhealable_dynamic","reason":"assertion targets non-durable dynamic content"}
+For a fix, return the COMPLETE steps array (not a diff). Use "observe" only to reveal a screen you cannot yet see; prefer "fix" as soon as the LIVE tree is enough. "observe" with type "tap" REQUIRES a target locator expression; "back"/"relaunch" take no target.`;
+    function parseLiveObserveAction(content) {
+      const cleaned = stripCodeFences(content);
+      let obj = safeJsonParse(cleaned);
+      if (!isRecord(obj)) {
+        const sub = extractBracesSubstring(cleaned);
+        obj = sub ? safeJsonParse(sub) : void 0;
+      }
+      if (!isRecord(obj) || obj.verdict !== "observe")
+        return null;
+      const action = obj.action;
+      if (!isRecord(action))
+        return null;
+      const type = action.type;
+      if (type !== "tap" && type !== "back" && type !== "relaunch" && type !== "reset")
+        return null;
+      const target = typeof action.target === "string" ? action.target : void 0;
+      return { type, target };
+    }
+    async function applyLiveObserveAction(driver, action, screen) {
+      if (action.type === "back") {
+        await driver.back();
+        return;
+      }
+      if (action.type === "relaunch") {
+        await driver.relaunch();
+        return;
+      }
+      if (action.type === "reset") {
+        const cleared = await driver.resetAppState();
+        if (!cleared)
+          await driver.relaunch();
+        return;
+      }
+      if (!action.target)
+        return;
+      const parts = (0, selector_registry_context_js_1.parseMobileLocatorExpression)(action.target);
+      if (!parts)
+        return;
+      const candidate = partsToCandidate(parts);
+      if (!hasIdentitySignal(candidate))
+        return;
+      const first = (0, mobile_source_parser_js_1.resolveLocatorAgainstScreen)(candidate, screen)[0];
+      if (first)
+        await driver.tap(first.bounds);
+    }
+    function buildLiveUserContent(args) {
+      const parts = [];
+      parts.push("## Failing test steps (JSON)");
+      parts.push("```json\n" + JSON.stringify(args.steps, null, 2) + "\n```");
+      parts.push("## Prior failure");
+      parts.push(`Error: ${args.priorError ?? "(none reported)"}`);
+      parts.push("## LIVE current screen (accessibility tree observed on-device NOW)");
+      parts.push(args.observation);
+      return parts.join("\n\n");
+    }
+    async function executeMobileLiveHeal2(args) {
+      const { target, testVariables, options } = args;
+      const liveDriver = options.liveDriver;
+      if (!liveDriver) {
+        return { passed: false, verdict: "needs_device", healReason: "no live driver available" };
+      }
+      const runNativeTest = options.runNativeTest;
+      if (!runNativeTest) {
+        return { passed: false, verdict: "needs_device", healReason: "no native verify seam available" };
+      }
+      const aiClient = options.aiClient ?? (options.model ? (0, ai_provider_js_1.getMobileClientForModel)(options.model) : (0, ai_provider_js_1.getMobileAIClient)());
+      const model = options.model ? (0, ai_provider_js_1.resolveModelForTask)(options.model, "agent") : (0, ai_provider_js_1.getModel)("agent");
+      const maxPasses = envInt2("MOBILE_HEAL_PHASE2_MAX_PASSES") ?? DEFAULT_PHASE2_MAX_PASSES;
+      let baseSteps = args.steps;
+      let priorError = args.priorError ?? null;
+      let bestSteps;
+      let bestStepResults;
+      for (let pass = 1; pass <= maxPasses; pass += 1) {
+        const snap = await liveDriver.snapshot();
+        const screen = (0, mobile_source_parser_js_1.parseMobileSource)(snap.xml, target.platform);
+        const safeScreen = (0, mobile_source_parser_js_1.parseMobileSource)((0, mobile_heal_postprocess_js_1.redactMobileSecretsFromText)(snap.xml, testVariables) ?? snap.xml, target.platform);
+        const observation = (0, mobile_observation_js_1.renderMobileObservation)(safeScreen, { maxElements: OBSERVATION_MAX_ELEMENTS });
+        const messages = [
+          { role: "system", content: exports2.MOBILE_LIVE_HEAL_SYSTEM_PROMPT },
+          {
+            role: "user",
+            content: buildLiveUserContent({
+              steps: baseSteps,
+              priorError: (0, mobile_heal_postprocess_js_1.redactMobileSecretsFromText)(priorError ?? void 0, testVariables) ?? null,
+              observation
+            })
+          }
+        ];
+        let content;
+        try {
+          const response = await (0, ai_retry_js_1.resilientAICall)((signal, arm) => (0, ai_queue_js_1.queuedAICall)(() => {
+            arm();
+            return aiClient.chat.completions.create({ model, messages, max_tokens: 8e3, temperature: 0.1 }, { signal });
+          }), { label: `mobile-live-heal-pass-${pass}`, deferTimeoutUntilArmed: true });
+          content = response?.choices?.[0]?.message?.content ?? "";
+        } catch {
+          continue;
+        }
+        const observe = parseLiveObserveAction(content);
+        if (observe) {
+          await applyLiveObserveAction(liveDriver, observe, screen);
+          continue;
+        }
+        const parsed = parseHealVerdict(content);
+        if (!parsed)
+          continue;
+        if (TERMINAL_VERDICTS.has(parsed.verdict)) {
+          return { passed: false, verdict: parsed.verdict, healReason: parsed.reason, healedSteps: bestSteps };
+        }
+        if (parsed.verdict !== "fix" || !parsed.steps)
+          continue;
+        const healedSteps = parsed.steps;
+        const verify = await runNativeTest({ steps: healedSteps, target, testVariables });
+        if (verify.passed) {
+          return {
+            passed: true,
+            verdict: "fix",
+            healedSteps,
+            healReason: parsed.reason,
+            confidence: parsed.confidence,
+            stepResults: verify.stepResults
+          };
+        }
+        baseSteps = healedSteps;
+        bestSteps = healedSteps;
+        bestStepResults = verify.stepResults;
+        priorError = verify.error ?? priorError;
+      }
+      return {
+        passed: false,
+        verdict: "needs_device",
+        healedSteps: bestSteps,
+        healReason: "live heal exhausted",
+        stepResults: bestStepResults
+      };
+    }
+  }
+});
+
 // ../runner-core/dist/services/browser-config.js
 var require_browser_config = __commonJS({
   "../runner-core/dist/services/browser-config.js"(exports2) {
@@ -293115,282 +294390,6 @@ var require_preflight_syntax = __commonJS({
   }
 });
 
-// ../runner-core/dist/services/selector-registry-context.js
-var require_selector_registry_context = __commonJS({
-  "../runner-core/dist/services/selector-registry-context.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.normalizeSelectorRegistryEntries = normalizeSelectorRegistryEntries;
-    exports2.formatSelectorRegistryContextForPrompt = formatSelectorRegistryContextForPrompt;
-    exports2.collectRegistryCandidates = collectRegistryCandidates;
-    exports2.buildRegistryCandidateBlock = buildRegistryCandidateBlock;
-    exports2.planRegistryFallbackFix = planRegistryFallbackFix;
-    exports2.substituteSelectorInCode = substituteSelectorInCode;
-    function isRecord(value) {
-      return value !== null && typeof value === "object" && !Array.isArray(value);
-    }
-    function asString(value, fallback = "") {
-      return typeof value === "string" ? value : fallback;
-    }
-    function asNumber(value, fallback = 0) {
-      return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-    }
-    function asStringArray(value) {
-      return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-    }
-    function truncateForSelectorPrompt(value, maxLength = 180) {
-      const normalized = (value ?? "").replace(/\s+/g, " ").trim();
-      if (normalized.length <= maxLength)
-        return normalized;
-      return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
-    }
-    function inlineCode(value, maxLength = 180) {
-      return `\`${truncateForSelectorPrompt(value, maxLength).replace(/`/g, "'")}\``;
-    }
-    function normalizeRef(value) {
-      if (!isRecord(value))
-        return null;
-      const expression = asString(value.expression).trim();
-      if (!expression)
-        return null;
-      return {
-        route: asString(value.route, "*"),
-        usage: asString(value.usage, "locator"),
-        source: asString(value.source, "generated"),
-        expression,
-        occurrenceIndex: asNumber(value.occurrenceIndex, 0)
-      };
-    }
-    function normalizeSibling(value) {
-      if (!isRecord(value))
-        return null;
-      const testCaseId = asString(value.testCaseId).trim();
-      const expression = asString(value.expression).trim();
-      if (!testCaseId || !expression)
-        return null;
-      return {
-        testCaseId,
-        name: asString(value.name, testCaseId),
-        suite: typeof value.suite === "string" ? value.suite : null,
-        lastPassedAt: typeof value.lastPassedAt === "string" ? value.lastPassedAt : null,
-        expression,
-        usage: asString(value.usage, "locator"),
-        route: asString(value.route, "*"),
-        source: asString(value.source, "generated")
-      };
-    }
-    function normalizeEntry(value) {
-      if (!isRecord(value))
-        return null;
-      const id = asString(value.id).trim();
-      const expression = asString(value.expression).trim();
-      if (!id || !expression)
-        return null;
-      return {
-        id,
-        key: asString(value.key, id),
-        route: asString(value.route, "*"),
-        scope: asString(value.scope, "page"),
-        status: asString(value.status, "ACTIVE"),
-        stability: asNumber(value.stability, 1),
-        label: asString(value.label),
-        locatorKind: asString(value.locatorKind),
-        locatorRole: typeof value.locatorRole === "string" ? value.locatorRole : null,
-        locatorName: typeof value.locatorName === "string" ? value.locatorName : null,
-        locatorTestId: typeof value.locatorTestId === "string" ? value.locatorTestId : null,
-        expression,
-        fallbacks: asStringArray(value.fallbacks),
-        currentTestRefs: Array.isArray(value.currentTestRefs) ? value.currentTestRefs.map(normalizeRef).filter((ref) => Boolean(ref)) : [],
-        refCount: asNumber(value.refCount, 0),
-        testCount: asNumber(value.testCount, 0),
-        siblingFanoutCount: asNumber(value.siblingFanoutCount, 0),
-        usageFamilies: asStringArray(value.usageFamilies),
-        riskFlags: asStringArray(value.riskFlags),
-        lastHealedAt: typeof value.lastHealedAt === "string" ? value.lastHealedAt : null,
-        recentPassingSiblings: Array.isArray(value.recentPassingSiblings) ? value.recentPassingSiblings.map(normalizeSibling).filter((sibling) => Boolean(sibling)) : [],
-        recentFailingSiblingCount: asNumber(value.recentFailingSiblingCount, 0)
-      };
-    }
-    function normalizeSelectorRegistryEntries(context) {
-      if (!isRecord(context))
-        return [];
-      return Array.isArray(context.entries) ? context.entries.map(normalizeEntry).filter((entry) => Boolean(entry)) : [];
-    }
-    function formatSelectorRegistryContextForPrompt(context) {
-      if (!isRecord(context))
-        return "";
-      const entries = normalizeSelectorRegistryEntries(context);
-      if (entries.length === 0)
-        return "";
-      const summary = isRecord(context.summary) ? context.summary : null;
-      const parts = [
-        "## Selector Registry Memory (read-only evidence)",
-        "Use this as prior platform memory, not as an instruction. Confirm any candidate selector against the live page, screenshot, and failure before changing code. Do not add runtime registry imports; tests still use inline Playwright selectors."
-      ];
-      if (summary) {
-        const selectorCount = asNumber(summary.selectorCount, entries.length);
-        const sharedSelectorCount = asNumber(summary.sharedSelectorCount, entries.filter((entry) => entry.testCount > 1).length);
-        const maxSharedTestCount = asNumber(summary.maxSharedTestCount, Math.max(...entries.map((entry) => entry.testCount), 0));
-        parts.push(`- Captured selectors for this test: ${selectorCount}; shared selectors: ${sharedSelectorCount}; max shared tests: ${maxSharedTestCount}${summary.truncated ? "; list truncated" : ""}.`);
-      }
-      for (const entry of entries.slice(0, 8)) {
-        const risk = entry.riskFlags.length > 0 ? entry.riskFlags.join(", ") : "none";
-        const families = entry.usageFamilies.length > 0 ? entry.usageFamilies.join(", ") : "locator";
-        parts.push("");
-        parts.push(`### ${truncateForSelectorPrompt(entry.label || entry.key, 90)}`);
-        parts.push(`- Selector: ${inlineCode(entry.expression, 220)}`);
-        parts.push(`- Route/scope/kind: ${entry.route} / ${entry.scope} / ${entry.locatorKind || "unknown"}; usage families: ${families}.`);
-        parts.push(`- Shared by: ${entry.testCount} test(s), ${entry.siblingFanoutCount} sibling(s), ${entry.refCount} ref(s); risks: ${risk}; status: ${entry.status}; stability: ${entry.stability}.`);
-        if (entry.lastHealedAt)
-          parts.push(`- Last registry heal: ${entry.lastHealedAt}.`);
-        const currentRefs = entry.currentTestRefs.slice(0, 3);
-        if (currentRefs.length > 0) {
-          parts.push("- Current test occurrences:");
-          for (const ref of currentRefs) {
-            parts.push(`  - ${ref.usage} on ${ref.route} from ${ref.source}: ${inlineCode(ref.expression, 180)}`);
-          }
-        }
-        const siblings = entry.recentPassingSiblings.slice(0, 3);
-        if (siblings.length > 0) {
-          parts.push("- Recent passing sibling tests using this registry entry:");
-          for (const sibling of siblings) {
-            const suite = sibling.suite ? ` (${truncateForSelectorPrompt(sibling.suite, 50)})` : "";
-            const passed = sibling.lastPassedAt ? ` passed ${sibling.lastPassedAt}` : "";
-            parts.push(`  - ${truncateForSelectorPrompt(sibling.name, 80)}${suite}${passed}: ${inlineCode(sibling.expression, 180)}`);
-          }
-        }
-        if (entry.recentFailingSiblingCount && entry.recentFailingSiblingCount > 0) {
-          parts.push(`- Other recent failing siblings on this entry: ${entry.recentFailingSiblingCount}.`);
-        }
-        const fallbacks = (entry.fallbacks ?? []).slice(0, 3);
-        if (fallbacks.length > 0) {
-          parts.push(`- Registry fallbacks: ${fallbacks.map((fallback) => inlineCode(fallback, 120)).join(", ")}.`);
-        }
-      }
-      return `${parts.join("\n")}
-`;
-    }
-    function selectorKey(expression) {
-      return expression.trim().replace(/^page\s*\.\s*/, "").replace(/\s+/g, " ").replace(/"/g, "'").trim();
-    }
-    function collectRegistryCandidates(context) {
-      const entries = normalizeSelectorRegistryEntries(context).slice(0, 8);
-      const seen = /* @__PURE__ */ new Set();
-      const ranked = [[], [], []];
-      for (const entry of entries) {
-        const entryLabel = entry.label || entry.key;
-        for (const sibling of entry.recentPassingSiblings) {
-          const key = selectorKey(sibling.expression);
-          if (seen.has(key))
-            continue;
-          seen.add(key);
-          ranked[0].push({ expression: sibling.expression, source: "passing-sibling", entryLabel, siblingName: sibling.name });
-        }
-        const entryKey = selectorKey(entry.expression);
-        if (!seen.has(entryKey)) {
-          seen.add(entryKey);
-          ranked[1].push({ expression: entry.expression, source: "registry-entry", entryLabel });
-        }
-        for (const fallback of entry.fallbacks ?? []) {
-          const key = selectorKey(fallback);
-          if (seen.has(key))
-            continue;
-          seen.add(key);
-          ranked[2].push({ expression: fallback, source: "fallback", entryLabel });
-        }
-      }
-      return ranked.flat();
-    }
-    function buildRegistryCandidateBlock(context, excludeExpressions) {
-      const exclude = new Set(excludeExpressions.map(selectorKey));
-      const candidates = collectRegistryCandidates(context).filter((candidate) => !exclude.has(selectorKey(candidate.expression))).slice(0, 6);
-      if (candidates.length === 0)
-        return "";
-      const lines = [
-        "## Untried Selector Candidates (from registry memory)",
-        "Ranked alternatives for elements this test uses, from the platform selector registry. Verify each against the screenshot and error before adopting \u2014 do not adopt blindly."
-      ];
-      for (const candidate of candidates) {
-        const provenance = candidate.source === "passing-sibling" ? `proven in passing sibling "${truncateForSelectorPrompt(candidate.siblingName, 80)}"` : candidate.source === "registry-entry" ? `registry entry for "${truncateForSelectorPrompt(candidate.entryLabel, 80)}"` : `registry fallback for "${truncateForSelectorPrompt(candidate.entryLabel, 80)}"`;
-        lines.push(`- ${inlineCode(candidate.expression, 180)} \u2014 ${provenance}`);
-      }
-      return lines.join("\n");
-    }
-    function findExpressionInCode(code, expression) {
-      const trimmed = expression.trim();
-      if (trimmed && code.includes(trimmed))
-        return trimmed;
-      const withoutPage = trimmed.replace(/^page\s*\.\s*/, "");
-      if (withoutPage !== trimmed && withoutPage && code.includes(withoutPage))
-        return withoutPage;
-      const withPage = `page.${withoutPage}`;
-      if (withPage !== trimmed && code.includes(withPage))
-        return withPage;
-      return null;
-    }
-    function extractFailureFocus(error2) {
-      const focus = error2.split(/\r?\n/).filter((line) => /^\s*>/.test(line) || /waiting for|locator resolved to/i.test(line) || /^\s*locator:/i.test(line));
-      return focus.length > 0 ? focus.join("\n") : error2;
-    }
-    function planRegistryFallbackFix(args) {
-      const { code, error: error2, context } = args;
-      if (!error2 || !code)
-        return null;
-      const entries = normalizeSelectorRegistryEntries(context).slice(0, 8);
-      if (entries.length === 0)
-        return null;
-      const errorKey = selectorKey(extractFailureFocus(error2));
-      for (const entry of entries) {
-        const failingExpressions = [entry.expression, ...entry.currentTestRefs.map((ref) => ref.expression)];
-        const failingSeen = /* @__PURE__ */ new Set();
-        for (const failing of failingExpressions) {
-          const failingKey = selectorKey(failing);
-          if (!failingKey || failingSeen.has(failingKey))
-            continue;
-          failingSeen.add(failingKey);
-          if (!errorKey.includes(failingKey))
-            continue;
-          const matchedInCode = findExpressionInCode(code, failing);
-          if (!matchedInCode)
-            continue;
-          const entryLabel = entry.label || entry.key;
-          const candidateSeen = /* @__PURE__ */ new Set([failingKey]);
-          const candidates = [];
-          for (const fallback of entry.fallbacks ?? []) {
-            const key = selectorKey(fallback);
-            if (!key || candidateSeen.has(key) || code.includes(fallback.trim()))
-              continue;
-            candidateSeen.add(key);
-            candidates.push({ expression: fallback, source: "fallback", entryLabel });
-          }
-          for (const sibling of entry.recentPassingSiblings) {
-            const key = selectorKey(sibling.expression);
-            if (!key || candidateSeen.has(key) || code.includes(sibling.expression.trim()))
-              continue;
-            candidateSeen.add(key);
-            candidates.push({ expression: sibling.expression, source: "passing-sibling", entryLabel, siblingName: sibling.name });
-          }
-          if (candidates.length === 0)
-            continue;
-          return { matchedInCode, entryLabel, candidates };
-        }
-      }
-      return null;
-    }
-    function substituteSelectorInCode(code, matchedInCode, replacement) {
-      const target = matchedInCode.trim();
-      let normalized = replacement.trim();
-      const targetHasPage = /^page\s*\.\s*/.test(target);
-      const replacementHasPage = /^page\s*\.\s*/.test(normalized);
-      if (targetHasPage && !replacementHasPage)
-        normalized = `page.${normalized}`;
-      if (!targetHasPage && replacementHasPage)
-        normalized = normalized.replace(/^page\s*\.\s*/, "");
-      return code.split(target).join(normalized);
-    }
-  }
-});
-
 // ../runner-core/dist/services/heal-selector-ledger.js
 var require_heal_selector_ledger = __commonJS({
   "../runner-core/dist/services/heal-selector-ledger.js"(exports2) {
@@ -313796,7 +314795,7 @@ var require_mobile_discovery_agent = __commonJS({
         log2(exploreAppDataCleared ? "App data cleared \u2014 exploring from a deterministic cold (logged-out) state." : "App data reset unavailable (platform/device policy) \u2014 exploring the app in its current state.");
         const state2 = new mobile_exploration_state_js_1.MobileExplorationState();
         const maxIterations = getMobileExploreBudget(mode, ctx.incremental);
-        const existingScreens = compactExistingScreens(ctx.existingSiteMap);
+        const existingScreens = isSurvey && ctx.incremental ? compactExistingScreens(ctx.existingSiteMap) : void 0;
         const explore = await runExplore({
           ctx,
           driver,
@@ -328144,8 +329143,9 @@ var require_dist2 = __commonJS({
       for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.buildRepoMapContractMd = exports2.buildRepoMemorySystemRules = exports2.buildRepoMemoryKickoff = exports2.buildRepoMemoryContractMd = exports2.runRepoAnalysisOnRunner = exports2.IMPORT_SCHEMA_VERSION = exports2.validateImportResultFile = exports2.validateImportedTest = exports2.buildImportSystemRules = exports2.buildImportKickoff = exports2.buildImportContractMd = exports2.MAX_ARCHIVE_BYTES = exports2.isUnsafeEntryName = exports2.extractZipSafely = exports2.downloadArchiveCapped = exports2.detectArchiveKind = exports2.acquireRepoForImport = exports2.runFrameworkImportOnRunner = exports2.getAgenticEngine = exports2.resolveRefFromSnapshot = exports2.replayAuthRecipeIntoBrowser = exports2.runRegisterCaptureRun = exports2.runLoginCaptureRun = exports2.AUTH_MARKER_VERSION = exports2.buildHealAuthStamp = exports2.extractAuthRegion = exports2.upsertAuthBlock = exports2.buildAuthRecipe = exports2.commandToReplayStep = exports2.buildReplayPlan = exports2.absoluteRoute = exports2.renderReplaySettleArrow = exports2.renderReplayClickArrow = exports2.renderAuthFn = exports2.canonicalizeRoute = exports2.executeGrokPerBatchHeal = exports2.executeGrokPerTestHeal = exports2.headerVal = exports2.classifyAuthType = exports2.isTextExcerptable = exports2.isStaticAssetByExt = exports2.isApiCall = exports2.buildApiCallSummary = exports2.runMobileGeneratePhase = exports2.runMobileAIPlanner = exports2.buildMobileSiteMap = exports2.formatMobileEvidenceForPlanner = exports2.MOBILE_SCENARIO_SYSTEM_PROMPT = exports2.MOBILE_SURVEY_SYSTEM_PROMPT = exports2.runMobileExplorePhase = void 0;
-    exports2.UNSUPPORTED_RENDERER_PREFIX = exports2.UnsupportedRendererError = exports2.buildCanvasModeAuthoringAddendum = exports2.buildUnsupportedRendererMessage = exports2.modelSupportsVision = exports2.decideCanvasStrategy = exports2.decideAppRenderType = exports2.detectCanvasApp = exports2.detectRateLimitBlock = exports2.isSafeCanonicalRedirect = exports2.resolveBaseUrlPreflight = exports2.checkBaseUrlRedirect = exports2.stripJsonFences = exports2.scrubCredentials = exports2.withAIRetry = exports2.snapshotMatchingChildren = exports2.findNewChromiumChildPid = exports2.killProcessTree = exports2.gracefulCloseWithTreeKill = exports2.liveBrowserRegistry = exports2.REPO_SWITCH_REMOVED_FRACTION = exports2.MAX_MANIFEST_FILES = exports2.toDiffSummary = exports2.isLikelyTestFile = exports2.sanitizeRepoRelPath = exports2.sha256Hex = exports2.hashFiles = exports2.enumerateTestFiles = exports2.buildNextManifest = exports2.detectRepoSwitch = exports2.classifyImportDiff = exports2.parseImportManifest = exports2.REPO_ANALYSIS_SCHEMA_VERSION = exports2.validateSourceEndpoints = exports2.validateAuthoredTest = exports2.validateRepoMapFile = exports2.validateRepoMemoryFile = exports2.buildTestingStandardsSection = exports2.buildRepoAuthorSystemRules = exports2.buildRepoAuthorKickoff = exports2.buildRepoAuthorContractMd = exports2.buildRepoMapSystemRules = exports2.buildRepoMapKickoff = void 0;
+    exports2.buildImportSystemRules = exports2.buildImportKickoff = exports2.buildImportContractMd = exports2.MAX_ARCHIVE_BYTES = exports2.isUnsafeEntryName = exports2.extractZipSafely = exports2.downloadArchiveCapped = exports2.detectArchiveKind = exports2.acquireRepoForImport = exports2.runFrameworkImportOnRunner = exports2.getAgenticEngine = exports2.resolveRefFromSnapshot = exports2.replayAuthRecipeIntoBrowser = exports2.runRegisterCaptureRun = exports2.runLoginCaptureRun = exports2.AUTH_MARKER_VERSION = exports2.buildHealAuthStamp = exports2.extractAuthRegion = exports2.upsertAuthBlock = exports2.buildAuthRecipe = exports2.commandToReplayStep = exports2.buildReplayPlan = exports2.absoluteRoute = exports2.renderReplaySettleArrow = exports2.renderReplayClickArrow = exports2.renderAuthFn = exports2.canonicalizeRoute = exports2.executeGrokPerBatchHeal = exports2.executeGrokPerTestHeal = exports2.headerVal = exports2.classifyAuthType = exports2.isTextExcerptable = exports2.isStaticAssetByExt = exports2.isApiCall = exports2.buildApiCallSummary = exports2.computeMobileHealOutcome = exports2.detectMobileStepSecretLeak = exports2.redactMobileSecretsFromText = exports2.MOBILE_LIVE_HEAL_SYSTEM_PROMPT = exports2.MOBILE_SCRIPT_HEAL_SYSTEM_PROMPT = exports2.executeMobileLiveHeal = exports2.executeMobileTestWithHealing = exports2.executeMobileScriptDrivenHeal = exports2.runMobileGeneratePhase = exports2.runMobileAIPlanner = exports2.buildMobileSiteMap = exports2.formatMobileEvidenceForPlanner = exports2.MOBILE_SCENARIO_SYSTEM_PROMPT = exports2.MOBILE_SURVEY_SYSTEM_PROMPT = exports2.runMobileExplorePhase = void 0;
+    exports2.UnsupportedRendererError = exports2.buildCanvasModeAuthoringAddendum = exports2.buildUnsupportedRendererMessage = exports2.modelSupportsVision = exports2.decideCanvasStrategy = exports2.decideAppRenderType = exports2.detectCanvasApp = exports2.detectRateLimitBlock = exports2.isSafeCanonicalRedirect = exports2.resolveBaseUrlPreflight = exports2.checkBaseUrlRedirect = exports2.stripJsonFences = exports2.scrubCredentials = exports2.withAIRetry = exports2.snapshotMatchingChildren = exports2.findNewChromiumChildPid = exports2.killProcessTree = exports2.gracefulCloseWithTreeKill = exports2.liveBrowserRegistry = exports2.REPO_SWITCH_REMOVED_FRACTION = exports2.MAX_MANIFEST_FILES = exports2.toDiffSummary = exports2.isLikelyTestFile = exports2.sanitizeRepoRelPath = exports2.sha256Hex = exports2.hashFiles = exports2.enumerateTestFiles = exports2.buildNextManifest = exports2.detectRepoSwitch = exports2.classifyImportDiff = exports2.parseImportManifest = exports2.REPO_ANALYSIS_SCHEMA_VERSION = exports2.validateSourceEndpoints = exports2.validateAuthoredTest = exports2.validateRepoMapFile = exports2.validateRepoMemoryFile = exports2.buildTestingStandardsSection = exports2.buildRepoAuthorSystemRules = exports2.buildRepoAuthorKickoff = exports2.buildRepoAuthorContractMd = exports2.buildRepoMapSystemRules = exports2.buildRepoMapKickoff = exports2.buildRepoMapContractMd = exports2.buildRepoMemorySystemRules = exports2.buildRepoMemoryKickoff = exports2.buildRepoMemoryContractMd = exports2.runRepoAnalysisOnRunner = exports2.IMPORT_SCHEMA_VERSION = exports2.validateImportResultFile = exports2.validateImportedTest = void 0;
+    exports2.UNSUPPORTED_RENDERER_PREFIX = void 0;
     __exportStar(require_ai_provider(), exports2);
     __exportStar(require_mobile_types(), exports2);
     __exportStar(require_mobile_source_parser(), exports2);
@@ -328174,6 +329174,32 @@ var require_dist2 = __commonJS({
     Object.defineProperty(exports2, "runMobileGeneratePhase", { enumerable: true, get: function() {
       return mobile_generator_js_1.runMobileGeneratePhase;
     } });
+    var mobile_heal_loop_js_1 = require_mobile_heal_loop();
+    Object.defineProperty(exports2, "executeMobileScriptDrivenHeal", { enumerable: true, get: function() {
+      return mobile_heal_loop_js_1.executeMobileScriptDrivenHeal;
+    } });
+    Object.defineProperty(exports2, "executeMobileTestWithHealing", { enumerable: true, get: function() {
+      return mobile_heal_loop_js_1.executeMobileTestWithHealing;
+    } });
+    Object.defineProperty(exports2, "executeMobileLiveHeal", { enumerable: true, get: function() {
+      return mobile_heal_loop_js_1.executeMobileLiveHeal;
+    } });
+    Object.defineProperty(exports2, "MOBILE_SCRIPT_HEAL_SYSTEM_PROMPT", { enumerable: true, get: function() {
+      return mobile_heal_loop_js_1.MOBILE_SCRIPT_HEAL_SYSTEM_PROMPT;
+    } });
+    Object.defineProperty(exports2, "MOBILE_LIVE_HEAL_SYSTEM_PROMPT", { enumerable: true, get: function() {
+      return mobile_heal_loop_js_1.MOBILE_LIVE_HEAL_SYSTEM_PROMPT;
+    } });
+    var mobile_heal_postprocess_js_1 = require_mobile_heal_postprocess();
+    Object.defineProperty(exports2, "redactMobileSecretsFromText", { enumerable: true, get: function() {
+      return mobile_heal_postprocess_js_1.redactMobileSecretsFromText;
+    } });
+    Object.defineProperty(exports2, "detectMobileStepSecretLeak", { enumerable: true, get: function() {
+      return mobile_heal_postprocess_js_1.detectMobileStepSecretLeak;
+    } });
+    Object.defineProperty(exports2, "computeMobileHealOutcome", { enumerable: true, get: function() {
+      return mobile_heal_postprocess_js_1.computeMobileHealOutcome;
+    } });
     __exportStar(require_browser_config(), exports2);
     __exportStar(require_mcp(), exports2);
     var api_call_redaction_js_1 = require_api_call_redaction();
@@ -328483,7 +329509,7 @@ var require_package4 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@validate.qa/runner",
-      version: "1.0.23",
+      version: "1.0.25",
       description: "validate local test runner - execute Playwright tests on your machine, connected to validate.qa cloud.",
       bin: {
         "validate-runner": "dist/cli.js"
@@ -330552,6 +331578,14 @@ async function takeScreenshot(sessionId) {
     return null;
   }
 }
+async function captureFailingSource(sessionId) {
+  try {
+    const result = await wdRequest(`/session/${sessionId}/source`);
+    return typeof result?.value === "string" ? result.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function mobileRecordingEnabled() {
   const value = process.env.VALIDATEQA_MOBILE_RUN_VIDEO;
   return value !== "0" && value !== "false";
@@ -330681,9 +331715,12 @@ function identityTextXpath(value) {
   const lit = xpathLiteral(value);
   return `//*[@text=${lit} or @content-desc=${lit} or @label=${lit} or @name=${lit} or @value=${lit}]`;
 }
+function isIdentityXpath(value) {
+  return value.includes("@") && !/(?:contains|starts-with)\s*\(/i.test(value);
+}
 function isIdentityStrategy(strategy) {
   if (strategy.using === "accessibility id" || strategy.using === "id") return true;
-  if (strategy.using === "xpath") return strategy.value.includes("@");
+  if (strategy.using === "xpath") return isIdentityXpath(strategy.value);
   return false;
 }
 function buildIdentityLocatorStrategies(target, platform3) {
@@ -330697,7 +331734,7 @@ function buildIdentityLocatorStrategies(target, platform3) {
       const trimmed = value?.trim();
       if (trimmed) strategies.push({ using: "xpath", value: identityTextXpath(trimmed) });
     }
-    if (bundle.xpath && bundle.xpath.includes("@")) strategies.push({ using: "xpath", value: bundle.xpath });
+    if (bundle.xpath && isIdentityXpath(bundle.xpath)) strategies.push({ using: "xpath", value: bundle.xpath });
   }
   if (!(platform3 && hasPlatformLocator(target, platform3))) {
     for (const value of [target.primary, ...target.fallbacks ?? []]) {
@@ -331044,6 +332081,7 @@ async function executeMobileTest(options) {
   let recordingStarted = false;
   let recordingStopped = false;
   let video;
+  let failingSource;
   const stopCapture = async () => {
     if (!capture || captureStopped) return apiCalls;
     captureStopped = true;
@@ -331067,6 +332105,10 @@ async function executeMobileTest(options) {
     }
     return video;
   };
+  const recordFirstFailingSource = async () => {
+    if (failingSource != null || !sessionId) return;
+    failingSource = await captureFailingSource(sessionId);
+  };
   try {
     log2("Checking Appium server health...");
     const health = await checkAppiumHealth();
@@ -331188,9 +332230,18 @@ async function executeMobileTest(options) {
     let entryDrift = false;
     const runPlatform = options.target.platform;
     const isCrossPlatform = options.target.authoringPlatform != null && options.target.authoringPlatform !== runPlatform;
-    const entryStep = runSteps.find(
+    const CONTAINER_ONLY_ID_RE = /(?:^|[:/])id\/(webview|content|decor|decor_content_parent|action_bar_root|statusBarBackground|navigationBarBackground)$|^(?:main-content|root|app|app-root|__next|react-root|application)$/i;
+    const isContainerOnlyEntryTarget = (target) => {
+      const primary = target?.primary?.trim() ?? "";
+      if (primary === "") return false;
+      const m = primary.match(/^mobile\.(?:resourceId|accessibilityId)\('([^']+)'\)$/);
+      const value = m ? m[1] : primary;
+      return CONTAINER_ONLY_ID_RE.test(value);
+    };
+    const identityBearingSteps = runSteps.filter(
       (s) => s.action !== "launchApp" && stepAppliesToPlatform(s, runPlatform) && buildIdentityLocatorStrategies(s.target, runPlatform).length > 0
     );
+    const entryStep = identityBearingSteps.find((s) => !isContainerOnlyEntryTarget(s.target)) ?? identityBearingSteps[0];
     if (entryStep) {
       try {
         const entryTimeout = recordedFromClearedState ? Math.max(DEFAULT_STEP_TIMEOUT_MS, COLD_BOOT_ENTRY_TIMEOUT_MS) : DEFAULT_STEP_TIMEOUT_MS;
@@ -331200,6 +332251,7 @@ async function executeMobileTest(options) {
         entryDrift = true;
         const driftMsg = `App started on an unexpected screen \u2014 the recorded flow's first element ("${entryStep.target?.primary ?? entryStep.description}") is not present, so the replay was aborted before it could blind-tap stale coordinates (screen drift; the app may be on onboarding or a different screen than when the test was recorded).`;
         log2(`  \u2717 Entry-screen drift: ${driftMsg}`);
+        await recordFirstFailingSource();
         stepResults.push({ stepOrder: entryStep.order, status: "failed", duration: 0, error: driftMsg });
         const driftShot = await takeScreenshot(sessionId).catch(() => null);
         screenshots.push(driftShot ?? "");
@@ -331276,6 +332328,9 @@ async function executeMobileTest(options) {
       }
       const screenshot = await takeScreenshot(sessionId).catch(() => null);
       screenshots.push(screenshot ?? "");
+      if (status === "failed") {
+        await recordFirstFailingSource();
+      }
       stepResults.push({
         stepOrder: step.order,
         status,
@@ -331313,7 +332368,8 @@ async function executeMobileTest(options) {
       duration: Date.now() - startTime,
       deviceId: selectedDevice?.id,
       deviceName: selectedDevice?.name,
-      environmental: environmental ?? void 0
+      environmental: environmental ?? void 0,
+      failingSource
     };
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -331334,7 +332390,8 @@ async function executeMobileTest(options) {
       // A throw before/around the step loop is a setup/environment problem
       // (no device booted, app not installed, session could not be created,
       // Appium unreachable) — never a genuine test assertion failure.
-      environmental: errorMsg
+      environmental: errorMsg,
+      failingSource
     };
   } finally {
     await stopCapture();
@@ -333303,6 +334360,9 @@ function budgetResultPayload(result, maxBytes = RESULT_BODY_BUDGET_BYTES, videoS
   if ((bytes > maxBytes || oversizedVideo) && payload.video != null) {
     drop(["video", "videoMimeType"], "video");
   }
+  if (bytes > maxBytes && payload.failingSource != null) {
+    drop(["failingSource"], "failingSource");
+  }
   if (bytes > maxBytes && Array.isArray(payload.screenshots) && payload.screenshots.length > 0) {
     const shots = [...payload.screenshots];
     const bySizeDesc = shots.map((shot, i) => ({ i, len: typeof shot === "string" ? shot.length : 0 })).sort((a, b) => b.len - a.len);
@@ -333354,6 +334414,7 @@ ${tail}` };
 // src/runner.ts
 init_dist();
 var import_runner_core12 = __toESM(require_dist2());
+var import_runner_core13 = __toESM(require_dist2());
 function fingerprintTest(test) {
   const code = test.framework === "APPIUM" ? [test.appiumCode ?? "", JSON.stringify(test.steps ?? [])].join("\n--steps--\n") : test.playwrightCode ?? "";
   return (0, import_node_crypto2.createHash)("sha256").update(test.name).update("\n--suite--\n").update(test.suiteName ?? "").update("\n--type--\n").update(test.testType ?? "").update("\n--framework--\n").update(test.framework ?? "").update("\n--code--\n").update(code).digest("hex").slice(0, 24);
@@ -333591,6 +334652,33 @@ async function postHealResult(serverUrl, headers, runId, healedCode, testCaseId,
   }
   throw new Error(`Failed to post heal result after ${MAX_ATTEMPTS} attempts: ${lastError?.message}`);
 }
+async function postMobileHealResult(serverUrl, headers, runId, body) {
+  const MAX_ATTEMPTS = 3;
+  let lastError;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      const res = await fetch(`${serverUrl}/api/runner/runs/${runId}/mobile-heal-result`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(6e4)
+      });
+      if (res.ok) return;
+      lastError = new Error(`HTTP ${res.status}`);
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+    }
+    if (attempt < MAX_ATTEMPTS) {
+      const delay = Math.pow(2, attempt) * 1e3;
+      console.warn(`[runner] postMobileHealResult attempt ${attempt} failed (${lastError.message}), retrying in ${delay}ms...`);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw new Error(`Failed to post mobile heal result after ${MAX_ATTEMPTS} attempts: ${lastError?.message}`);
+}
+function narrowMobileLaunchMode(mode) {
+  return mode === "LAUNCH_APP" || mode === "DEEP_LINK" || mode === "RESUME" ? mode : void 0;
+}
 async function postBatchHealResult(serverUrl, headers, runId, body) {
   const res = await fetch(`${serverUrl}/api/runner/runs/${runId}/batch-heal-result`, {
     method: "POST",
@@ -335499,6 +336587,218 @@ ${finalVerifyResult.logs ?? ""}`;
         log.fail("ERROR - No mobile steps");
         return;
       }
+      if (runMode === "heal" && run2.mobileAiHeal === true) {
+        if (getBridgeState().hasActiveSession) {
+          await postResult(opts.serverUrl, headers, run2.runId, {
+            status: "ERROR",
+            error: "CONFIG_ISSUE: the shared mobile device is busy with an active recording session; the AI heal will retry once it ends.",
+            duration: Date.now() - startTime
+          });
+          log.warn("Skipped mobile AI heal (device busy with a recording)");
+          return;
+        }
+        const healTarget = {
+          appId: target.appId,
+          platform: target.platform,
+          platformVersion: target.platformVersion,
+          recordedDeviceId: target.recordedDeviceId,
+          assignedDeviceId,
+          launchMode: target.launchMode,
+          deeplink: target.deeplink,
+          authoringPlatform: mobilePlatformFromMedium(run2.authoringMedium) ?? void 0
+        };
+        const nativeVerify = { last: null };
+        const runNativeTest = async ({ steps, target: t, testVariables }) => {
+          const res = await executeMobileTest({
+            steps,
+            target: {
+              appId: t.appId,
+              platform: t.platform,
+              platformVersion: t.platformVersion,
+              recordedDeviceId: t.recordedDeviceId,
+              assignedDeviceId: t.assignedDeviceId,
+              launchMode: narrowMobileLaunchMode(t.launchMode),
+              deeplink: t.deeplink,
+              authoringPlatform: t.authoringPlatform
+            },
+            testVariables
+          });
+          nativeVerify.last = res;
+          return {
+            passed: res.passed,
+            error: res.error,
+            stepResults: res.stepResults.map((s) => ({ stepOrder: s.stepOrder, status: s.status, error: s.error })),
+            failingSource: res.failingSource,
+            logs: res.logs
+          };
+        };
+        setExecutorBusy(true);
+        try {
+          log.info("\u{1FA7A} Mobile AI heal \u2014 reproducing the failure on device...");
+          const reproduce = await runNativeTest({ steps: mobileSteps, target: healTarget, testVariables: run2.testVariables });
+          if (reproduce.passed) {
+            const recovered = nativeVerify.last;
+            await postResult(opts.serverUrl, headers, run2.runId, {
+              status: "PASSED",
+              stepResults: recovered?.stepResults,
+              screenshots: recovered?.screenshots,
+              video: recovered?.video,
+              videoMimeType: recovered?.videoMimeType,
+              apiCalls: recovered?.apiCalls,
+              logs: recovered?.logs,
+              duration: Date.now() - startTime
+            });
+            try {
+              await postMobileHealResult(opts.serverUrl, headers, run2.runId, {
+                healedSteps: mobileSteps,
+                healedAppiumCode: "",
+                healReason: "recovered on reproduce",
+                verdict: "fix",
+                recovered: true,
+                priorStepsHash: run2.priorStepsHash
+              });
+              log.ok("\u{1FA7A} Reproduce PASSED \u2014 test recovered (flaky); promotion posted");
+            } catch (patchErr) {
+              log.warn(`Failed to post recovered heal result: ${patchErr instanceof Error ? patchErr.message : String(patchErr)}`);
+            }
+            return;
+          }
+          const reproduceError = reproduce.error;
+          const modelOverride = run2.healerModel ?? void 0;
+          const healerOptions = {
+            aiClient: modelOverride ? (0, import_runner_core13.getMobileClientForModel)(modelOverride) : (0, import_runner_core13.getMobileAIClient)(),
+            ...modelOverride ? { model: modelOverride } : {},
+            runNativeTest,
+            selectorRegistryContext: run2.selectorRegistryContext ?? null,
+            runLiveHeal: async (a) => {
+              let liveSession = null;
+              try {
+                liveSession = await createMobileDiscoverySession({
+                  appId: target.appId,
+                  platform: target.platform,
+                  platformVersion: target.platformVersion,
+                  recordedDeviceId: target.recordedDeviceId,
+                  assignedDeviceId,
+                  launchMode: target.launchMode,
+                  deeplink: target.deeplink
+                });
+                attachMirrorSession(liveSession.sessionId, target.platform, liveSession.deviceId);
+                const bridgeDriver = new MobileBridgeDriver({
+                  sessionId: liveSession.sessionId,
+                  platform: target.platform,
+                  appId: liveSession.appId,
+                  allowAppReset: shouldResetMobileAppData(target.platform, liveSession.deviceId)
+                });
+                const liveDriver = {
+                  snapshot: async () => {
+                    const snap = await bridgeDriver.snapshot();
+                    return { xml: snap.xml, screenshot: snap.screenshot, windowSize: snap.windowSize };
+                  },
+                  tap: async (bounds) => {
+                    await bridgeDriver.tap(bounds);
+                  },
+                  type: async (value, bounds) => {
+                    await bridgeDriver.type(value, bounds);
+                  },
+                  clear: async (bounds) => {
+                    await bridgeDriver.clear(bounds);
+                  },
+                  swipe: async (direction, distance) => {
+                    await bridgeDriver.swipe(direction, distance);
+                  },
+                  back: async () => {
+                    await bridgeDriver.back();
+                  },
+                  home: async () => {
+                    await bridgeDriver.home();
+                  },
+                  relaunch: async () => {
+                    await bridgeDriver.relaunch();
+                  },
+                  resetAppState: async () => bridgeDriver.resetAppState()
+                };
+                return await (0, import_runner_core13.executeMobileLiveHeal)({
+                  steps: a.steps,
+                  target: a.target,
+                  testVariables: a.testVariables,
+                  priorError: reproduceError,
+                  options: { ...a.options ?? healerOptions, liveDriver }
+                });
+              } finally {
+                if (liveSession) {
+                  detachMirrorSession(liveSession.deviceId);
+                  try {
+                    await liveSession.stop();
+                  } catch {
+                  }
+                }
+              }
+            }
+          };
+          log.info("\u{1FA7A} Mobile AI heal \u2014 Phase 1 (script) \u2192 Phase 2 (live device, lazy)...");
+          const heal = await (0, import_runner_core13.executeMobileTestWithHealing)(
+            mobileSteps,
+            healTarget,
+            { error: reproduceError, logs: reproduce.logs, failingSource: reproduce.failingSource, testVariables: run2.testVariables },
+            healerOptions
+          );
+          const finalRes = nativeVerify.last;
+          const outcome = (0, import_runner_core13.computeMobileHealOutcome)({
+            heal,
+            finalError: finalRes?.error ?? null,
+            reproduceError,
+            testVariables: run2.testVariables
+          });
+          await postResult(opts.serverUrl, headers, run2.runId, {
+            status: outcome.status,
+            stepResults: finalRes?.stepResults,
+            screenshots: finalRes?.screenshots,
+            video: finalRes?.video,
+            videoMimeType: finalRes?.videoMimeType,
+            apiCalls: finalRes?.apiCalls,
+            logs: finalRes?.logs,
+            error: outcome.error,
+            healReason: heal.healReason,
+            // NB: the loop's numeric `confidence` (0-1) is intentionally NOT posted
+            // here — RunnerResultPayload.confidence is the web healer's categorical
+            // 'high'|'medium'|'low'. The numeric value rides /mobile-heal-result via
+            // the healReason instead. Mapping the two would be lossy and misleading.
+            // extraTags carries @needs-review for the non-fix verdicts (applied by
+            // the server's mobileAiHeal /result tag hook); PASSED heals apply tags
+            // via /mobile-heal-result instead.
+            extraTags: outcome.extraTags,
+            removeTags: outcome.removeTags,
+            duration: Date.now() - startTime,
+            failingSource: finalRes?.failingSource
+          });
+          if (outcome.shouldPatch && heal.healedSteps && heal.healedSteps.length > 0) {
+            const healedAppiumCode = heal.healedAppiumCode ?? buildAppiumCode(run2.testName ?? run2.testCaseId ?? "Healed mobile test", run2.target ?? null, heal.healedSteps);
+            try {
+              await postMobileHealResult(opts.serverUrl, headers, run2.runId, {
+                healedSteps: heal.healedSteps,
+                healedAppiumCode,
+                healReason: heal.healReason ?? "",
+                verdict: heal.verdict,
+                extraTags: heal.extraTags,
+                removeTags: heal.removeTags,
+                priorStepsHash: run2.priorStepsHash
+              });
+              log.ok(`\u{1FA7A} Mobile heal patch posted for test ${run2.testCaseId ?? "(unknown)"} (verdict: ${heal.verdict})`);
+            } catch (patchErr) {
+              log.warn(`Failed to post mobile heal patch: ${patchErr instanceof Error ? patchErr.message : String(patchErr)}`);
+            }
+          } else if (outcome.secretLeak) {
+            log.warn(`\u{1FA7A} Mobile heal patch DROPPED \u2014 healed steps contained a secret (${outcome.secretLeak}); tagged @needs-review`);
+          }
+          const duration3 = Date.now() - startTime;
+          log[outcome.status === "PASSED" ? "ok" : "fail"](
+            `\u{1FA7A} Mobile AI heal ${outcome.status} (verdict: ${heal.verdict}, ${duration3}ms)${outcome.error ? ` - ${outcome.error}` : ""}`
+          );
+        } finally {
+          setExecutorBusy(false);
+        }
+        return;
+      }
       const maxRetries = typeof run2.retryCount === "number" && Number.isFinite(run2.retryCount) ? Math.max(0, Math.min(2, Math.floor(run2.retryCount))) : 0;
       setExecutorBusy(true);
       let result2 = null;
@@ -335568,7 +336868,10 @@ ${result2.logs}`);
         apiCalls: result2.apiCalls,
         logs: result2.logs,
         error: reportedError,
-        duration: duration2
+        duration: duration2,
+        // Point-of-failure page-source XML (mobile) for the AI healer. Budget-
+        // droppable (see result-payload-budget.ts); the verdict is never dropped.
+        failingSource: result2.failingSource
       });
       log[result2.passed ? "ok" : "fail"](
         `\u{1F4F1} ${status}  (${duration2}ms)${reportedError ? ` - ${reportedError}` : ""}`