@validate.qa/runner 1.0.38 → 1.0.40

package/dist/cli.js

@@ -270,7 +270,8 @@ var require_ai_provider = __commonJS({
       { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", provider: "anthropic", description: "Anthropic - fast & intelligent, 200k ctx", contextWindow: 2e5 },
       { id: "nvidia-nemotron-nano", label: "NVIDIA Nemotron Nano", provider: "nvidia", description: "NVIDIA NIM - Nemotron 30B Nano, reasoning model, 128k ctx", contextWindow: 128e3 },
       { id: "nvidia-kimi-k2.6", label: "NVIDIA Kimi K2.6", provider: "nvidia", description: "NVIDIA NIM - Moonshot Kimi K2.6, multimodal coding and agentic model, 256k ctx", contextWindow: 256e3 },
-      { id: "deepseek-v4-flash", label: "DeepSeek V4 Flash", provider: "deepseek", description: "DeepSeek - V4 Flash, OpenAI-compatible, 1M ctx", contextWindow: 1e6 }
+      { id: "deepseek-v4-flash", label: "DeepSeek V4 Flash", provider: "deepseek", description: "DeepSeek - V4 Flash, OpenAI-compatible, 1M ctx", contextWindow: 1e6 },
+      { id: "deepseek-v4-pro", label: "DeepSeek V4 Pro", provider: "deepseek", description: "DeepSeek - V4 Pro, higher-quality reasoning tier, OpenAI-compatible, 1M ctx", contextWindow: 1e6 }
     ];
     var PROVIDER_DEFAULT_MODEL = {
       openai: "gpt-4o",
@@ -330,7 +331,8 @@ var require_ai_provider = __commonJS({
       "claude-sonnet-4-6": { strong: "claude-sonnet-4-6", fast: "claude-sonnet-4-6", agent: "claude-sonnet-4-6" },
       "nvidia-nemotron-nano": { strong: "nvidia/nemotron-3-nano-30b-a3b", fast: "nvidia/nemotron-3-nano-30b-a3b", agent: "nvidia/nemotron-3-nano-30b-a3b" },
       "nvidia-kimi-k2.6": { strong: "moonshotai/kimi-k2.6", fast: "moonshotai/kimi-k2.6", agent: "moonshotai/kimi-k2.6" },
-      "deepseek-v4-flash": { strong: "deepseek-v4-flash", fast: "deepseek-v4-flash", agent: "deepseek-v4-flash" }
+      "deepseek-v4-flash": { strong: "deepseek-v4-flash", fast: "deepseek-v4-flash", agent: "deepseek-v4-flash" },
+      "deepseek-v4-pro": { strong: "deepseek-v4-pro", fast: "deepseek-v4-pro", agent: "deepseek-v4-pro" }
     };
     var _requestModelStorage = new async_hooks_1.AsyncLocalStorage();
     function withModelContext(modelId, fn) {
@@ -392,7 +394,7 @@ var require_ai_provider = __commonJS({
       if (modelId === "nvidia/nemotron-3-nano-30b-a3b") {
         return { chat_template_kwargs: { enable_thinking: false } };
       }
-      if (modelId === "deepseek-v4-flash") {
+      if (modelId === "deepseek-v4-flash" || modelId === "deepseek-v4-pro") {
         return { thinking: { type: "disabled" } };
       }
       return {};
@@ -3302,6 +3304,7 @@ var init_audit_pricing = __esm({
       "MiniMax-M2.7-highspeed": { input: 0.6, output: 2.4 },
       "MiniMax-M2": { input: 0.3, output: 1.2 },
       "deepseek-v4-flash": { input: 0.14, output: 0.28 },
+      "deepseek-v4-pro": { input: 0.42, output: 0.84 },
       // Whisper bills per-minute, not per-token (OpenAI + Groq)
       "whisper-1": null,
       "whisper-large-v3": null,
@@ -5879,6 +5882,34 @@ var require_ai_queue = __commonJS({
   }
 });
 
+// ../runner-core/dist/services/mobile/mobile-session-keepalive.js
+var require_mobile_session_keepalive = __commonJS({
+  "../runner-core/dist/services/mobile/mobile-session-keepalive.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.MOBILE_KEEPALIVE_INTERVAL_MS = void 0;
+    exports2.withMobileSessionKeepAlive = withMobileSessionKeepAlive;
+    exports2.MOBILE_KEEPALIVE_INTERVAL_MS = (() => {
+      const raw = Number(process.env.VALIDATEQA_MOBILE_KEEPALIVE_MS);
+      return Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 12e4;
+    })();
+    async function withMobileSessionKeepAlive(driver, fn, intervalMs = exports2.MOBILE_KEEPALIVE_INTERVAL_MS) {
+      if (intervalMs <= 0)
+        return fn();
+      const timer = setInterval(() => {
+        void driver.windowSize().catch(() => {
+        });
+      }, intervalMs);
+      timer.unref?.();
+      try {
+        return await fn();
+      } finally {
+        clearInterval(timer);
+      }
+    }
+  }
+});
+
 // ../runner-core/dist/services/mobile/mobile-observation.js
 var require_mobile_observation = __commonJS({
   "../runner-core/dist/services/mobile/mobile-observation.js"(exports2) {
@@ -6213,6 +6244,689 @@ var require_mobile_observation = __commonJS({
   }
 });
 
+// ../runner-core/dist/services/mobile/mobile-exploration-state.js
+var require_mobile_exploration_state = __commonJS({
+  "../runner-core/dist/services/mobile/mobile-exploration-state.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.MobileExplorationState = void 0;
+    exports2.isDestructiveActionLabel = isDestructiveActionLabel;
+    exports2.isDestructiveConfirmationInput = isDestructiveConfirmationInput;
+    exports2.stableMobileControlIdentity = stableMobileControlIdentity;
+    exports2.classifySafeMobileNavigationControl = classifySafeMobileNavigationControl;
+    exports2.deriveScreenId = deriveScreenId;
+    var mobile_observation_js_1 = require_mobile_observation();
+    var DEFAULT_STALE_THRESHOLD = 4;
+    var MAX_SCREEN_OBSERVATIONS = 50;
+    var EDITABLE_CONTROL_ROLE_RE = /(?:android\.widget\.(?:EditText|AutoCompleteTextView)|XCUIElementType(?:TextField|SecureTextField|SearchField|TextView)|textbox|searchbox|combobox|textarea|select)$/i;
+    var STATEFUL_CONTROL_ROLE_RE = /(?:Switch|CheckBox|Checkbox|RadioButton|radio|Slider|SeekBar|Stepper|PickerWheel|Toggle)$/i;
+    var UNSAFE_OR_COMMIT_LABEL_RE = /\b(?:submit|save|confirm|delete|remove|archive|reset|disconnect|deactivate|destroy|purge|pay|purchase|buy|checkout|place\s+order|send|post|publish|upload|import|export|sign\s*out|log\s*out|logout|accept|agree|subscribe|unsubscribe|follow|unfollow|enable|disable|book|reserve|cancel|continue|next|previous|done|apply|retry|close|dismiss|sign\s*in|log\s*in|register)\b/i;
+    var SAFE_MODAL_TRIGGER_LABEL_RE = /^(?:create|new|add|edit|invite|configure|manage|details|preview|share)$/i;
+    var MENU_TRIGGER_LABEL_RE = /^(?:more|menu|options|actions|filter|filters|sort|columns|customize)$/i;
+    var GENERIC_NAVIGATION_DESTINATION_LABEL_RE = /^(?:home|feed|dashboard|profile|settings|inbox|messages?|notifications?|projects?|about|privacy|terms|learn\s+more)$/i;
+    var SYSTEM_BACK_CONTROL_LABEL_RE = /^(?:back|go\s+back|navigate\s+up|navigation\s+up|up)$/i;
+    var SYSTEM_BACK_CONTROL_ID_RE = /^(?:action_bar_up|arrow_back|back_arrow|navigate_up|navigation_up|nav_up|toolbar_back|action_back|btn_back|button_back|back_button|back_btn|back_icon|icon_back)$/i;
+    var DESTRUCTIVE_ACTION_LABEL_RE = /\b(?:deactivate|delete\s+account|delete\s+profile|close\s+account|cancel\s+account|remove\s+account|delete\s+(?:my\s+)?(?:data|history|everything|account)|delete\s+(?:all|forever|permanently)|permanently\s+(?:delete|remove|erase|deactivate)|erase\s+(?:all|everything|account|data)|wipe\s+(?:account|data|everything|all|device)|purge\s+(?:account|data|everything|all)|destroy\s+(?:account|data)|factory\s+reset|reset\s+(?:all\s+data|everything))\b/i;
+    var DESTRUCTIVE_CONFIRMATION_INPUT_RE = /^(?:delete|delete\s+my\s+account|delete\s+account|delete\s+forever|permanently\s+delete|confirm\s+delete|erase|erase\s+all|wipe|deactivate|remove\s+account|close\s+account|yes,?\s*delete(?:\s+my\s+account)?)$/i;
+    function isDestructiveActionLabel(label) {
+      if (!label)
+        return false;
+      return DESTRUCTIVE_ACTION_LABEL_RE.test(normalizeControlIdentityPart(label));
+    }
+    function isDestructiveConfirmationInput(value) {
+      if (!value)
+        return false;
+      return DESTRUCTIVE_CONFIRMATION_INPUT_RE.test(value.trim());
+    }
+    function normalizeControlIdentityPart(value) {
+      return value.trim().replace(/\s+/g, " ").toLowerCase();
+    }
+    function semanticControlAlias(label) {
+      return `navigation-label:${normalizeControlIdentityPart(label)}`;
+    }
+    function localControlCoverageIdentity(screenId, identity) {
+      return `screen:${screenId}:${identity}`;
+    }
+    function storedMobileControlIdentity(candidate) {
+      return [
+        candidate.identity,
+        `kind:${candidate.kind}`,
+        `label:${normalizeControlIdentityPart(candidate.label)}`
+      ].join(":");
+    }
+    function isSystemBackNavigationControl(element, label) {
+      if (SYSTEM_BACK_CONTROL_LABEL_RE.test(normalizeControlIdentityPart(label)))
+        return true;
+      return [element.accessibilityId, element.resourceId].filter((value) => Boolean(value?.trim())).some((value) => {
+        const leaf = normalizeControlIdentityPart(value).split(/[/:.]/).filter(Boolean).at(-1) ?? "";
+        return SYSTEM_BACK_CONTROL_ID_RE.test(leaf);
+      });
+    }
+    function stableMobileControlIdentity(element) {
+      const role = normalizeControlIdentityPart(element.role || "control");
+      const accessibilityId = element.accessibilityId?.trim();
+      if (accessibilityId)
+        return `a11y:${role}:${normalizeControlIdentityPart(accessibilityId)}`;
+      const resourceId = element.resourceId?.trim();
+      if (resourceId)
+        return `resource:${role}:${normalizeControlIdentityPart(resourceId)}`;
+      const label = (0, mobile_observation_js_1.safeMobileElementLabel)(element)?.trim();
+      if (label)
+        return `semantic:${role}:${normalizeControlIdentityPart(label)}`;
+      return null;
+    }
+    function classifySafeMobileNavigationControl(element) {
+      if (!element.actionable || element.enabled === false)
+        return null;
+      const label = (0, mobile_observation_js_1.safeMobileElementLabel)(element)?.trim();
+      const safetyIdentity = [label, element.accessibilityId, element.resourceId].filter(Boolean).join(" ");
+      if (!label || UNSAFE_OR_COMMIT_LABEL_RE.test(safetyIdentity))
+        return null;
+      if (isSystemBackNavigationControl(element, label))
+        return null;
+      const role = element.role.trim();
+      if (EDITABLE_CONTROL_ROLE_RE.test(role) || STATEFUL_CONTROL_ROLE_RE.test(role))
+        return null;
+      const linkLike = /(?:Link$|^a$)/i.test(role);
+      let kind = null;
+      if (/(?:TabBarItem|\btab\b)/i.test(role))
+        kind = "tab";
+      else if (/menuitem/i.test(role))
+        kind = "menu-item";
+      else if (linkLike && element.navigationProvenance)
+        kind = "link";
+      else if (linkLike)
+        return null;
+      else if (element.hasPopup && element.hasPopup.toLowerCase() !== "false")
+        kind = "menu-trigger";
+      else if (element.expanded === false)
+        kind = "disclosure";
+      else if (MENU_TRIGGER_LABEL_RE.test(label))
+        kind = "menu-trigger";
+      else if (SAFE_MODAL_TRIGGER_LABEL_RE.test(label))
+        kind = "modal-trigger";
+      else if (element.navigationProvenance)
+        kind = "navigation-button";
+      else if (GENERIC_NAVIGATION_DESTINATION_LABEL_RE.test(label))
+        kind = "navigation-button";
+      if (!kind)
+        return null;
+      const identity = stableMobileControlIdentity(element);
+      return identity ? { identity, label, kind } : null;
+    }
+    function sharedMobileControlCoverageIdentity(element, candidate, semanticFamilyId) {
+      if (!element.navigationProvenance)
+        return void 0;
+      const durableId = element.accessibilityId?.trim() ? `a11y:${normalizeControlIdentityPart(element.accessibilityId)}` : element.resourceId?.trim() ? `resource:${normalizeControlIdentityPart(element.resourceId)}` : "";
+      if (!durableId && !semanticFamilyId)
+        return void 0;
+      return [
+        "shared-navigation",
+        element.navigationProvenance,
+        !durableId && semanticFamilyId ? `family:${semanticFamilyId}` : "",
+        candidate.kind,
+        durableId || "semantic-only",
+        normalizeControlIdentityPart(candidate.label)
+      ].filter(Boolean).join(":");
+    }
+    function mobileNavigationRegion(element, windowSize) {
+      if (!windowSize || windowSize.width <= 0 || windowSize.height <= 0)
+        return "unknown";
+      const centerX = (element.bounds.x + element.bounds.width / 2) / windowSize.width;
+      const centerY = (element.bounds.y + element.bounds.height / 2) / windowSize.height;
+      if (centerY >= 0.72)
+        return "bottom";
+      if (centerY <= 0.28)
+        return "top";
+      if (centerX <= 0.35)
+        return "left";
+      if (centerX >= 0.65)
+        return "right";
+      return "center";
+    }
+    function buildSemanticNavigationGroups(elements, windowSize) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const element of elements) {
+        if (!element.navigationProvenance)
+          continue;
+        const candidate = classifySafeMobileNavigationControl(element);
+        if (!candidate)
+          continue;
+        const groupKey = `${element.navigationProvenance}:${mobileNavigationRegion(element, windowSize)}`;
+        const labels = groups.get(groupKey) ?? /* @__PURE__ */ new Set();
+        labels.add(`${candidate.kind}:${normalizeControlIdentityPart(candidate.label)}`);
+        groups.set(groupKey, labels);
+      }
+      return new Map([...groups].filter(([, labels]) => labels.size >= 2));
+    }
+    function deriveScreenId(signal) {
+      const namespace = signal.activity?.trim() || signal.bundleId?.trim();
+      return namespace ? `${namespace}#${signal.screenHash}` : signal.screenHash;
+    }
+    function observedElementIdentity(element) {
+      return (0, mobile_observation_js_1.stableParsedMobileElementIdentity)(element);
+    }
+    function mergeObservedElements(previous, current) {
+      const merged = [...current];
+      const seen = new Set(current.map(observedElementIdentity));
+      for (const element of previous) {
+        const identity = observedElementIdentity(element);
+        if (seen.has(identity))
+          continue;
+        seen.add(identity);
+        merged.push(element);
+      }
+      return merged;
+    }
+    function sanitizeElementsForEvidence(elements) {
+      return elements.map((element) => {
+        const label = (0, mobile_observation_js_1.safeMobileElementLabel)(element);
+        return {
+          ...element,
+          ...label ? { label } : { label: void 0 },
+          text: void 0
+        };
+      });
+    }
+    var MobileExplorationState = class {
+      /** screenId -> ScreenState (the mobile analog of routeState). */
+      screens = /* @__PURE__ */ new Map();
+      /** Observed directed transitions between screens. */
+      transitions = [];
+      /** Transition-announced screens that do not yet have a live observation. */
+      frontier = /* @__PURE__ */ new Map();
+      /** Safe navigation controls observed on each screen, keyed by stable identity. */
+      safeControlsByScreen = /* @__PURE__ */ new Map();
+      /** Screen-scoped coverage keys plus explicitly proven shared-navigation keys. */
+      attemptedSafeControlCoverageIdentities = /* @__PURE__ */ new Set();
+      successfulSafeControlAttemptCount = 0;
+      /** Repeated id-less structural navigation families, grouped by region. */
+      semanticNavigationFamilies = /* @__PURE__ */ new Map();
+      nextSemanticNavigationFamilyId = 1;
+      /** The screen-id of the most recently observed screen. */
+      currentScreenId = null;
+      /** Latest iteration recorded (drives stale detection + firstSeen stamps). */
+      iteration = 0;
+      /** Stale detector: progress mark (#screens + #total elements) at last advance. */
+      lastProgressMark = 0;
+      /** Consecutive iterations observed with no progress. */
+      staleIterations = 0;
+      staleThreshold;
+      constructor(options = {}) {
+        this.staleThreshold = typeof options.staleThreshold === "number" && options.staleThreshold > 0 ? Math.floor(options.staleThreshold) : DEFAULT_STALE_THRESHOLD;
+      }
+      // -------------------------------------------------------------------------
+      // Observation recording
+      // -------------------------------------------------------------------------
+      /**
+       * Returns true when `signal` identifies a screen this run has never observed
+       * before. Pure read — does not mutate state.
+       */
+      isNewScreen(signal) {
+        return !this.screens.has(deriveScreenId(signal));
+      }
+      /**
+       * Record an observation of `screen` at `iteration`. Creates a `ScreenState`
+       * on first sight (stamping `firstSeenIteration`), otherwise refreshes the
+       * stored element set (latest-wins, mirroring the web reducer's PAGE_CAPTURED
+       * element refresh). A driver observation already contains the structural UI
+       * tree, elements, screenshot association, and screen identity, so it is
+       * captured evidence immediately; the model's capture_screen call only adds
+       * a friendly name/type. Returns the resolved screen-id.
+       */
+      recordObservation(signal, screen, iteration) {
+        this.iteration = iteration;
+        const screenId = deriveScreenId(signal);
+        const evidenceElements = sanitizeElementsForEvidence(screen.elements);
+        const existing = this.screens.get(screenId);
+        if (existing) {
+          this.screens.set(screenId, {
+            ...existing,
+            elements: mergeObservedElements(existing.elements, evidenceElements)
+          });
+        } else {
+          this.screens.set(screenId, {
+            screenId,
+            firstSeenIteration: iteration,
+            elements: evidenceElements,
+            visited: true
+          });
+        }
+        this.frontier.delete(screenId);
+        const controls = this.safeControlsByScreen.get(screenId) ?? /* @__PURE__ */ new Map();
+        const semanticNavigationGroups = buildSemanticNavigationGroups(evidenceElements, screen.windowSize);
+        const semanticNavigationFamilyIds = /* @__PURE__ */ new Map();
+        for (const [groupKey, labels] of semanticNavigationGroups) {
+          semanticNavigationFamilyIds.set(groupKey, this.resolveSemanticNavigationFamilyId(groupKey, labels));
+        }
+        for (const element of evidenceElements) {
+          const candidate = classifySafeMobileNavigationControl(element);
+          if (!candidate)
+            continue;
+          const storedIdentity = storedMobileControlIdentity(candidate);
+          const semanticGroupKey = element.navigationProvenance ? `${element.navigationProvenance}:${mobileNavigationRegion(element, screen.windowSize)}` : "";
+          controls.set(storedIdentity, {
+            ...candidate,
+            identity: storedIdentity,
+            sharedCoverageIdentity: sharedMobileControlCoverageIdentity(element, candidate, semanticNavigationFamilyIds.get(semanticGroupKey))
+          });
+        }
+        if (controls.size > 0)
+          this.safeControlsByScreen.set(screenId, controls);
+        this.currentScreenId = screenId;
+        this.updateStaleProgress();
+        return screenId;
+      }
+      /**
+       * Back-compatible acknowledgement from capture_screen. Observation already
+       * marks structural evidence visited; this call only resolves a rare pending
+       * transition frontier and preserves callers that annotate explicitly.
+       */
+      markVisited(screenId) {
+        const state2 = this.screens.get(screenId);
+        if (state2 && !state2.visited) {
+          this.screens.set(screenId, { ...state2, visited: true });
+        }
+        this.frontier.delete(screenId);
+      }
+      /**
+       * Record a confirmed tap against a safe navigation candidate. Callers invoke
+       * this only after the driver reports success; recovery-unknown, stale-ref, and
+       * failed actions must remain on the breadth frontier.
+       */
+      noteControlAttempt(screenId, element) {
+        if (!screenId)
+          return false;
+        const candidate = classifySafeMobileNavigationControl(element);
+        const controls = this.safeControlsByScreen.get(screenId) ?? /* @__PURE__ */ new Map();
+        if (candidate) {
+          const storedIdentity = storedMobileControlIdentity(candidate);
+          const existing = controls.get(storedIdentity);
+          controls.set(storedIdentity, {
+            ...candidate,
+            identity: storedIdentity,
+            sharedCoverageIdentity: existing?.sharedCoverageIdentity ?? sharedMobileControlCoverageIdentity(element, candidate)
+          });
+          this.safeControlsByScreen.set(screenId, controls);
+        }
+        const tappedLabel = (0, mobile_observation_js_1.safeMobileElementLabel)(element)?.trim();
+        if (!tappedLabel)
+          return false;
+        const before = this.attemptedSafeControlCoverageIdentities.size;
+        const alias = semanticControlAlias(tappedLabel);
+        for (const control of controls.values()) {
+          if (semanticControlAlias(control.label) === alias) {
+            this.attemptedSafeControlCoverageIdentities.add(localControlCoverageIdentity(screenId, control.identity));
+            if (control.sharedCoverageIdentity) {
+              this.attemptedSafeControlCoverageIdentities.add(control.sharedCoverageIdentity);
+            }
+          }
+        }
+        if (this.attemptedSafeControlCoverageIdentities.size > before) {
+          this.successfulSafeControlAttemptCount += 1;
+          this.staleIterations = 0;
+          return true;
+        }
+        return false;
+      }
+      /** Attach a human-friendly name / coarse type to a screen (capture_screen). */
+      annotateScreen(screenId, annotation) {
+        const state2 = this.screens.get(screenId);
+        if (!state2)
+          return;
+        this.screens.set(screenId, {
+          ...state2,
+          screenName: annotation.screenName ?? state2.screenName,
+          screenType: annotation.screenType ?? state2.screenType
+        });
+      }
+      /** Attach structurally observed authentication provenance to a screen. */
+      setScreenAuthEvidence(screenId, evidence) {
+        const state2 = this.screens.get(screenId);
+        if (!state2)
+          return;
+        this.screens.set(screenId, {
+          ...state2,
+          requiresAuth: evidence.requiresAuth,
+          authProvenance: evidence.authProvenance,
+          sessionState: { ...evidence.sessionState }
+        });
+      }
+      /** Append a free-form observation note to a screen (observations tool). */
+      addScreenObservation(screenId, note) {
+        const state2 = this.screens.get(screenId);
+        if (!state2)
+          return;
+        const normalized = note.trim();
+        if (!normalized)
+          return;
+        const current = state2.observations ?? [];
+        if (current.some((existing) => existing.trim().toLowerCase() === normalized.toLowerCase())) {
+          return;
+        }
+        const observations = [...current, normalized].slice(-MAX_SCREEN_OBSERVATIONS);
+        this.screens.set(screenId, { ...state2, observations });
+      }
+      /**
+       * Record a directed transition between two screens. Both endpoints are
+       * ensured to exist on the frontier if not yet observed (mirrors the web
+       * reducer adding both ends of a TRANSITION_RECORDED to the frontier). The
+       * `toScreenId` becomes the current screen when the transition starts from the
+       * current screen.
+      */
+      recordTransition(transition) {
+        let recordedTransition = transition;
+        if (!transition.viaControlIdentity && transition.viaRef) {
+          const sourceElement = this.screens.get(transition.fromScreenId)?.elements.find((element) => element.ref === transition.viaRef);
+          if (sourceElement) {
+            recordedTransition = {
+              ...transition,
+              viaControlIdentity: (0, mobile_observation_js_1.stableParsedMobileElementIdentity)(sourceElement)
+            };
+          }
+        }
+        const alreadyRecorded = this.transitions.some((existing) => existing.fromScreenId === recordedTransition.fromScreenId && existing.toScreenId === recordedTransition.toScreenId && existing.action === recordedTransition.action);
+        if (!alreadyRecorded) {
+          this.transitions.push(recordedTransition);
+        }
+        for (const endpointId of [transition.fromScreenId, transition.toScreenId]) {
+          if (!this.screens.has(endpointId) && !this.frontier.has(endpointId)) {
+            this.frontier.set(endpointId, {
+              screenId: endpointId,
+              source: "transition",
+              discoveredAtIteration: this.iteration
+            });
+          }
+        }
+        if (transition.fromScreenId === this.currentScreenId) {
+          this.currentScreenId = transition.toScreenId;
+        }
+      }
+      // -------------------------------------------------------------------------
+      // Selectors
+      // -------------------------------------------------------------------------
+      /** The current screen-id (most recently observed), or null before any observation. */
+      getCurrentScreenId() {
+        return this.currentScreenId;
+      }
+      /** ScreenState for `screenId`, if known. */
+      getScreen(screenId) {
+        return this.screens.get(screenId);
+      }
+      /** Number of distinct screens observed this run. */
+      getScreenCount() {
+        return this.screens.size;
+      }
+      /** Number of screens backed by a live structural driver observation. */
+      getVisitedScreenCount() {
+        let total = 0;
+        for (const state2 of this.screens.values()) {
+          if (state2.visited)
+            total += 1;
+        }
+        return total;
+      }
+      /** Total elements observed across all known screens (latest snapshot each). */
+      getTotalElementCount() {
+        let total = 0;
+        for (const state2 of this.screens.values()) {
+          total += state2.elements.length;
+        }
+        return total;
+      }
+      /**
+       * Frontier screen-ids ranked by recency (most recently discovered first),
+       * excluding any screen already visited. Mirrors the web `getRankedFrontier`
+       * intent (filter visited, rank by recency) — without URL prefix similarity,
+       * which has no mobile analog.
+       */
+      getFrontier() {
+        return [...this.frontier.values()].filter((item) => {
+          const state2 = this.screens.get(item.screenId);
+          return !state2 || !state2.visited;
+        }).sort((a, b) => b.discoveredAtIteration - a.discoveredAtIteration).map((item) => item.screenId);
+      }
+      /** Safe navigation candidates not yet attempted, deduped across shared chrome. */
+      getUnexploredSafeNavigationCandidates() {
+        const authenticatedProductObserved = [...this.screens.values()].some((screen) => screen.requiresAuth === true);
+        const candidates = [];
+        for (const [screenId, controls] of this.safeControlsByScreen) {
+          const origin = this.screens.get(screenId);
+          const originIsConfirmedPublicEntry = origin?.authProvenance === "public" || !origin?.authProvenance && origin?.requiresAuth !== true && /^(?:AUTH|LANDING)$/i.test(origin?.screenType ?? "");
+          if (authenticatedProductObserved && originIsConfirmedPublicEntry)
+            continue;
+          for (const control of controls.values()) {
+            const alias = semanticControlAlias(control.label);
+            const coverageIdentity = control.sharedCoverageIdentity ?? localControlCoverageIdentity(screenId, control.identity);
+            if (this.attemptedSafeControlCoverageIdentities.has(coverageIdentity) || this.attemptedSafeControlCoverageIdentities.has(localControlCoverageIdentity(screenId, control.identity)))
+              continue;
+            const existing = candidates.find((candidate) => candidate.identity === coverageIdentity || candidate.alias === alias && candidate.screenIds.has(screenId));
+            if (existing) {
+              existing.screenIds.add(screenId);
+            } else {
+              candidates.push({
+                identity: coverageIdentity,
+                label: control.label,
+                kind: control.kind,
+                alias,
+                screenIds: /* @__PURE__ */ new Set([screenId])
+              });
+            }
+          }
+        }
+        return candidates.map((candidate) => ({
+          identity: candidate.identity,
+          label: candidate.label,
+          kind: candidate.kind,
+          screenIds: [...candidate.screenIds]
+        })).sort((a, b) => {
+          const aCurrent = this.currentScreenId !== null && a.screenIds.includes(this.currentScreenId);
+          const bCurrent = this.currentScreenId !== null && b.screenIds.includes(this.currentScreenId);
+          if (aCurrent !== bCurrent)
+            return aCurrent ? -1 : 1;
+          return b.screenIds.length - a.screenIds.length;
+        });
+      }
+      /** Harness-owned survey completion floor, independent of model assertions. */
+      getSurveyBreadthCoverage() {
+        const unvisitedScreenIds = this.getFrontier();
+        const unexploredControls = this.getUnexploredSafeNavigationCandidates();
+        const complete = unvisitedScreenIds.length === 0 && unexploredControls.length === 0;
+        const missing = [];
+        if (unvisitedScreenIds.length > 0) {
+          missing.push(`${unvisitedScreenIds.length} uncaptured screen(s)`);
+        }
+        if (unexploredControls.length > 0) {
+          missing.push(`${unexploredControls.length} safe navigation control(s)`);
+        }
+        return {
+          required: true,
+          complete,
+          unvisitedScreenIds,
+          unexploredControls,
+          attemptedControlCount: this.successfulSafeControlAttemptCount,
+          ...missing.length > 0 ? { reason: `Missing ${missing.join(" and ")}.` } : {}
+        };
+      }
+      /**
+       * Monotonic structural progress token for adaptive survey leases. Frontier
+       * cardinality alone is insufficient: attempting control A can reveal control
+       * B and leave the remaining count unchanged even though real work happened.
+       */
+      getSurveyBreadthProgressMark() {
+        const discoveredControlIdentities = /* @__PURE__ */ new Set();
+        for (const [screenId, controls] of this.safeControlsByScreen) {
+          for (const control of controls.values()) {
+            discoveredControlIdentities.add(control.sharedCoverageIdentity ?? localControlCoverageIdentity(screenId, control.identity));
+          }
+        }
+        return [
+          `screens:${this.screens.size}`,
+          `attempts:${this.successfulSafeControlAttemptCount}`,
+          `controls:${discoveredControlIdentities.size}`,
+          `transitions:${this.transitions.length}`
+        ].join("|");
+      }
+      resolveSemanticNavigationFamilyId(groupKey, labels) {
+        const families = this.semanticNavigationFamilies.get(groupKey) ?? [];
+        let best;
+        let bestIntersection = 0;
+        for (const family of families) {
+          let intersection = 0;
+          for (const label of labels) {
+            if (family.labels.has(label))
+              intersection += 1;
+          }
+          const overlap = intersection / Math.min(labels.size, family.labels.size);
+          if (intersection >= 2 && overlap >= 0.6 && intersection > bestIntersection) {
+            best = family;
+            bestIntersection = intersection;
+          }
+        }
+        if (best) {
+          for (const label of labels)
+            best.labels.add(label);
+          return best.id;
+        }
+        const created = {
+          id: `semantic-nav-family-${this.nextSemanticNavigationFamilyId++}`,
+          labels: new Set(labels)
+        };
+        families.push(created);
+        this.semanticNavigationFamilies.set(groupKey, families);
+        return created.id;
+      }
+      /** Observed transitions (defensive copy). */
+      getTransitions() {
+        return [...this.transitions];
+      }
+      // -------------------------------------------------------------------------
+      // Stale-progress detection (ported semantics from the web stale guard)
+      // -------------------------------------------------------------------------
+      /**
+       * Progress mark: distinct screens weighted heavily, plus total elements seen.
+       * A run advances this mark whenever it finds a new screen OR new elements;
+       * the stale detector triggers when the mark stops advancing for
+       * `staleThreshold` consecutive iterations.
+       */
+      getProgressMark() {
+        return this.screens.size * 1e3 + this.transitions.length * 100 + this.successfulSafeControlAttemptCount * 10 + this.getTotalElementCount();
+      }
+      updateStaleProgress() {
+        const mark = this.getProgressMark();
+        if (mark > this.lastProgressMark) {
+          this.lastProgressMark = mark;
+          this.staleIterations = 0;
+        } else {
+          this.staleIterations += 1;
+        }
+      }
+      /** Consecutive no-progress iterations observed so far. */
+      getStaleIterations() {
+        return this.staleIterations;
+      }
+      /**
+       * True when the run has gone `staleThreshold` consecutive iterations with no
+       * new screen and no new element — the signal the explorer uses to nudge or
+       * finish (mirrors the web explorer's stale guard).
+       */
+      isStaleProgress() {
+        return this.staleIterations >= this.staleThreshold;
+      }
+      // -------------------------------------------------------------------------
+      // Planner evidence export
+      // -------------------------------------------------------------------------
+      /**
+       * Snapshot the screen-graph as a plain object (frozen mobile-types
+       * `MobileScreenGraph`). Defensive copies so callers cannot mutate internal
+       * state.
+       */
+      toScreenGraph() {
+        const screens = /* @__PURE__ */ new Map();
+        for (const [id, state2] of this.screens) {
+          screens.set(id, {
+            ...state2,
+            elements: [...state2.elements],
+            observations: state2.observations ? [...state2.observations] : void 0,
+            sessionState: state2.sessionState ? { ...state2.sessionState } : void 0
+          });
+        }
+        return {
+          screens,
+          transitions: this.transitions.map((t) => ({
+            fromScreenId: t.fromScreenId,
+            toScreenId: t.toScreenId,
+            viaRef: t.viaRef,
+            viaControlIdentity: t.viaControlIdentity,
+            action: t.action
+          }))
+        };
+      }
+      /**
+       * Build the planner evidence shape: one `CollectedPageData` per screen, with
+       * the screen-id carried in BOTH `route` (the on-the-wire positional field the
+       * server keys screenshots by) AND the explicit `screenId` field (per the
+       * Phase-0 `CollectedPageData.screenId` contract). `elements` are mapped from
+       * the screen's parsed actionable elements into the platform-neutral
+       * `CollectedPageElement[]` shape the server persists as SiteElements — without
+       * this, mobile screens land with zero elements (coverage always 0%, no element
+       * intelligence). `triggersNavigation` is derived from the durable source
+       * element identity captured when the transition happened (with ref-only
+       * fallback for legacy transitions). Insertion order matches first-seen order.
+       */
+      buildInMemoryScreenMap() {
+        const pages = [];
+        const ordered = [...this.screens.values()].sort((a, b) => a.firstSeenIteration - b.firstSeenIteration);
+        const navRefsByScreen = /* @__PURE__ */ new Map();
+        const navIdentitiesByScreen = /* @__PURE__ */ new Map();
+        for (const transition of this.transitions) {
+          if (transition.viaControlIdentity) {
+            const set = navIdentitiesByScreen.get(transition.fromScreenId) ?? /* @__PURE__ */ new Set();
+            set.add(transition.viaControlIdentity);
+            navIdentitiesByScreen.set(transition.fromScreenId, set);
+          } else if (transition.viaRef) {
+            const set = navRefsByScreen.get(transition.fromScreenId) ?? /* @__PURE__ */ new Set();
+            set.add(transition.viaRef);
+            navRefsByScreen.set(transition.fromScreenId, set);
+          }
+        }
+        for (const state2 of ordered) {
+          const page = {
+            route: state2.screenId,
+            screenId: state2.screenId,
+            pageType: state2.screenType ?? "UNKNOWN",
+            elements: (0, mobile_observation_js_1.buildCollectedElementsForScreen)(state2.elements, {
+              navigationRefs: navRefsByScreen.get(state2.screenId),
+              navigationIdentities: navIdentitiesByScreen.get(state2.screenId)
+            }),
+            requiresAuth: state2.requiresAuth ?? false
+          };
+          if (state2.sessionState) {
+            page.sessionState = { ...state2.sessionState };
+          }
+          if (state2.screenName) {
+            page.title = state2.screenName;
+          }
+          if (state2.observations && state2.observations.length > 0) {
+            page.observations = state2.observations.map((note) => ({
+              action: "observe",
+              outcome: note,
+              outcomeType: "SUCCESS"
+            }));
+          }
+          pages.push(page);
+        }
+        return pages;
+      }
+      /** Alias for `buildInMemoryScreenMap()` — name parity with the planner-evidence call site. */
+      toScreenMap() {
+        return this.buildInMemoryScreenMap();
+      }
+    };
+    exports2.MobileExplorationState = MobileExplorationState;
+  }
+});
+
 // ../runner-core/dist/services/mobile/mobile-keyboard.js
 var require_mobile_keyboard = __commonJS({
   "../runner-core/dist/services/mobile/mobile-keyboard.js"(exports2) {
@@ -63929,8 +64643,10 @@ var require_mobile_explorer = __commonJS({
     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_session_keepalive_js_1 = require_mobile_session_keepalive();
     var mobile_source_parser_js_1 = require_mobile_source_parser();
     var mobile_observation_js_1 = require_mobile_observation();
+    var mobile_exploration_state_js_1 = require_mobile_exploration_state();
     var mobile_boundary_js_1 = require_mobile_boundary();
     var mobile_keyboard_js_1 = require_mobile_keyboard();
     var mobile_auth_coverage_js_1 = require_mobile_auth_coverage();
@@ -64288,6 +65004,10 @@ var require_mobile_explorer = __commonJS({
         return void 0;
       return normalized;
     }
+    function destructiveActionRefusal(label, kind = "tap") {
+      const what = kind === "confirmation" ? `Typing "${label}" is a destructive confirmation` : `Tapping "${label}" is an irreversible, high-stakes destructive action`;
+      return `Refused: ${what} (account/data deletion, deactivation, wipe, or similar). Autonomous testing must never execute irreversible destruction on the account under test. Record it as an untested destructive flow in your summary and choose a non-destructive control instead.`;
+    }
     function hybridElementForEvidence(element, credentials) {
       const id = safeHybridIdentity(element.id, credentials);
       const name = safeHybridIdentity(element.name, credentials);
@@ -64910,7 +65630,7 @@ Max iterations: ${maxIterations}. You will be warned near the end.`;
 3. After each navigation, capture_screen the destination and record_transition. After completing a meaningful flow (login, search, create), ${enableRecordJourney ? "call record_journey with the steps and expected outcome." : "continue exploring."}
 4. Use mobile_relaunch for a clean, hermetic restart before testing a distinct flow that needs fresh state.
 5. mobile_swipe to scroll; mobile_back to return.
-6. Do NOT trigger irreversible side effects (real payments, sending messages/invites to others). Note them instead.
+6. Do NOT trigger irreversible or destructive side effects \u2014 real payments; sending messages/invites to others; and ESPECIALLY account/data deletion, deactivation, "delete account", factory reset, or any "type DELETE to confirm" gate. The runner hard-blocks destructive taps and confirmation keystrokes, so attempting them only wastes an iteration. Note such flows in your summary and explore elsewhere.
 7. Stay inside this app.${targetLine} If a tap opens an app store, settings, browser, or another app, do not explore it; return with mobile_back or mobile_relaunch.
 
 Max iterations: ${maxIterations}. You will be warned near the end.`;
@@ -65433,7 +66153,7 @@ ${statePacket}` }
           const requestMessageCount = messages.length;
           const requestMessages = messages.slice();
           const callStart = Date.now();
-          const response = await (0, ai_retry_js_1.resilientAICall)((signal, arm) => (0, ai_queue_js_1.queuedAICall)(() => {
+          const response = await (0, mobile_session_keepalive_js_1.withMobileSessionKeepAlive)(driver, () => (0, ai_retry_js_1.resilientAICall)((signal, arm) => (0, ai_queue_js_1.queuedAICall)(() => {
             arm();
             return aiClient.chat.completions.create({
               model: agentModel,
@@ -65446,7 +66166,7 @@ ${statePacket}` }
             label: `mobile-explore-iter-${iteration}`,
             deferTimeoutUntilArmed: true,
             onRetry: (attempt, reason, delayMs) => log2(`  \u26A0 mobile explore AI retry ${attempt} (${reason}) \u2014 waiting ${delayMs}ms`)
-          });
+          }));
           const iterDuration = Date.now() - callStart;
           if (!response?.choices?.[0]?.message) {
             throw new Error(`AI explore call returned no response (queue timeout or provider overload) at iteration ${iteration}`);
@@ -65775,6 +66495,11 @@ Exploration complete: ${summary}`);
             if (!driver.webTap) {
               return { ok: false, error: "This driver does not support hybrid WEBVIEW taps." };
             }
+            const hybridTapLabel = hybridElementForEvidence(hybrid, redactionCredentials).label ?? "";
+            if ((0, mobile_exploration_state_js_1.isDestructiveActionLabel)(hybridTapLabel)) {
+              log2(`   \u26A0 Refused destructive tap on "${hybridTapLabel}" (account/data-deletion class); noting instead.`);
+              return { ok: false, error: destructiveActionRefusal(hybridTapLabel) };
+            }
             const authSurfaceBeforeTap2 = currentAuthSurface();
             const fromScreenId2 = state2.getCurrentScreenId();
             const actionResult2 = await driver.webTap(hybrid.webviewContext, hybrid.css);
@@ -65805,6 +66530,11 @@ Exploration complete: ${summary}`);
           if (!resolved) {
             return { ok: false, error: `Unknown element ref "${String(toolArgs.ref)}". Call mobile_snapshot first; refs are only valid for the latest snapshot.` };
           }
+          const nativeTapLabel = resolved.element.label ?? resolved.element.text ?? resolved.element.accessibilityId ?? "";
+          if ((0, mobile_exploration_state_js_1.isDestructiveActionLabel)(nativeTapLabel)) {
+            log2(`   \u26A0 Refused destructive tap on "${nativeTapLabel}" (account/data-deletion class); noting instead.`);
+            return { ok: false, error: destructiveActionRefusal(nativeTapLabel) };
+          }
           const fromScreenId = state2.getCurrentScreenId();
           const boundaryBeforeAction = currentBoundary();
           const startedOutsideTarget = boundaryBeforeAction.kind !== "target" && boundaryBeforeAction.kind !== "unknown";
@@ -65845,6 +66575,10 @@ Exploration complete: ${summary}`);
         // ----- Type -----
         case "mobile_type": {
           const value = typeof toolArgs.value === "string" ? toolArgs.value : String(toolArgs.value ?? "");
+          if ((0, mobile_exploration_state_js_1.isDestructiveConfirmationInput)(value)) {
+            log2(`   \u26A0 Refused destructive confirmation input "${value}"; noting instead.`);
+            return { ok: false, error: destructiveActionRefusal(value, "confirmation") };
+          }
           const allowedLiteral = inbox ? inbox.state.email : "";
           for (const [key, secret] of Object.entries(credentials)) {
             if (!secret || secret.length < 4)
@@ -67511,6 +68245,7 @@ var require_discover_ai_planner = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.SCENARIO_SYSTEM_PROMPT = void 0;
+    exports2.getAIPlannerMaxTokens = getAIPlannerMaxTokens;
     exports2.getSnapshotConfidence = getSnapshotConfidence;
     exports2.compressSiteMap = compressSiteMap;
     exports2.formatEvidenceForPlanner = formatEvidenceForPlanner;
@@ -67522,10 +68257,25 @@ var require_discover_ai_planner = __commonJS({
     var ai_retry_js_1 = require_ai_retry();
     var strip_json_fences_js_1 = require_strip_json_fences();
     var scenario_plan_validator_js_1 = require_scenario_plan_validator();
-    var DEFAULT_AI_PLANNER_MAX_TOKENS = 8192;
-    var MINIMAX_AI_PLANNER_MAX_TOKENS = 16384;
+    var GENEROUS_AI_PLANNER_MAX_TOKENS = 65536;
+    var CONSERVATIVE_AI_PLANNER_MAX_TOKENS = 16384;
     function getAIPlannerMaxTokens(modelId) {
-      return (0, ai_provider_js_1.getProviderForModel)(modelId) === "minimax" ? MINIMAX_AI_PLANNER_MAX_TOKENS : DEFAULT_AI_PLANNER_MAX_TOKENS;
+      switch ((0, ai_provider_js_1.getProviderForModel)(modelId)) {
+        case "deepseek":
+        // V4 output ceiling = 384K — verified safe
+        case "minimax":
+          return GENEROUS_AI_PLANNER_MAX_TOKENS;
+        case "xai":
+        // grok-build-0.1 ceiling unproven (Grok-Fast/3 = 16K) — DON'T risk a 400
+        case "openai":
+        // gpt-4o max output = 16384 → more would 400
+        case "anthropic":
+        // OpenAI-compat proxy — keep conservative
+        case "nvidia":
+        // NIM output limits vary — keep conservative
+        default:
+          return CONSERVATIVE_AI_PLANNER_MAX_TOKENS;
+      }
     }
     var discover_planner_js_1 = require_discover_planner();
     function getSnapshotConfidence(sourceKind) {
@@ -68077,7 +68827,7 @@ Return ONLY one valid JSON object matching the schema below. Do NOT include <thi
 4. **Multi-page journeys** - only when transitions were actually observed
 5. **Bug reports** - for observed 500 errors, crashes, or broken features
 6. **Steps are human-readable** - "Fill the email field", not "page.getByLabel('Email').fill()"
-7. **Expected outcomes are plain-English success criteria** - describe the user-visible product result, not the controls touched along the way. Steps already cover buttons, inputs, links, fields, headings, tabs, dialogs, and menus. Expected outcomes should say what the user can now do or rely on (record saved, message sent, search results filtered, validation explained, dashboard accessible). Include durable routes or exact copy only when they are the real product outcome; do NOT list "heading visible", "button visible", "search input visible", or similar element inventory unless that exact control is the behavior under test.
+7. **Expected outcomes are plain-English success criteria** - describe the user-visible product result, not the controls touched along the way. Steps already cover buttons, inputs, links, fields, headings, tabs, dialogs, and menus. Expected outcomes should say what the user can now do or rely on (record saved, message sent, search results filtered, validation explained, dashboard accessible). Include durable routes or exact copy only when they are the real product outcome; do NOT list "heading visible", "button visible", "search input visible", or similar element inventory unless that exact control is the behavior under test.  **Outcome-strength self-check (applies to EVERY scenario type):** before emitting a scenario, ask \u2014 would every expectedOutcome still pass if the primary action did nothing and only the page and its existing chrome rendered? If yes, it is too weak. Add at least one evidence-backed post-condition that would FAIL in that no-op case: specific result content or value, a created or removed entity, a changed count or status, persisted state after reload, handled validation copy, or a concrete session signal. A route alone suffices only when navigation or redirect is itself the behavior under test; a newly revealed control suffices only when revealing that control is the behavior under test. Never invent copy to satisfy this check \u2014 Rule 1 still governs what you may assert.
 8. **Auth-aware** - mark scenarios that need login. Use process.env.TEST_USER_EMAIL / PASSWORD
 9. **No duplicates** - check existing test names before adding
 10. **All tests start from the landing page** - every generated test navigates to \`/\` first and uses the app's own navigation (clicking links/buttons) to reach the target page. Steps must reflect this: say "Navigate to landing page and click Sign In" not "Navigate to /auth/login". Deep-linking to internal routes causes hydration failures in SPAs. \`targetPages\` lists the pages involved in the flow.
@@ -68129,7 +68879,7 @@ Return ONLY one valid JSON object matching the schema below. Do NOT include <thi
     **YOUR responsibility:**
     - Scenario \`name\`, \`type\`, \`goal\`, \`prerequisites\`
     - \`steps\` written as user-language intent ("create a new conversation", "click the Submit button to log in"), naming observed UI labels where they help describe intent
-    - \`expectedOutcomes\` citing observed durable labels per Rule 12 (asserting on stable signals is encouraged)
+    - \`expectedOutcomes\` expressing the evidence-backed product post-condition per Rule 7 (and Rule 11 for happy paths, plus Rule 12's concrete session signal for authentication happy paths); citing observed durable labels when asserting on stable signals is encouraged
 
     **NOT your responsibility:**
     - Exact Playwright selectors (\`getByRole(...)\`, \`getByText(...)\`, \`page.locator(...)\`, etc.) \u2014 live-generate picks locators against the live snapshot
@@ -68150,7 +68900,7 @@ Return ONLY one valid JSON object matching the schema below. Do NOT include <thi
     - GOOD specificity: "create a new conversation by sending a message to a connection established earlier in this scenario"
     - BAD specificity: "click the button labeled exactly 'Send' in the bottom-right of the chat"
 
-    Citing observed labels in \`expectedOutcomes\` (per Rule 12) is fine \u2014 that's asserting on stable product signals, not implementation specifics.
+    Citing observed labels in \`expectedOutcomes\` is fine \u2014 that's asserting on stable product signals, not implementation specifics.
 
 ## Coverage Strategy
 - For every form: at least 1 HAPPY_PATH (submit valid data AND verify durable result per rule 11) + 1 EDGE_CASE (empty/invalid submission)
@@ -68736,6 +69486,24 @@ Each entry is exactly one of:
     }
     async function runAIPlanner(siteMap, evidence, context, options) {
       const logs2 = [];
+      const failurePlan = (kind, reason, legacyFallback2) => {
+        const noFallback = context.mode === "survey" && process.env.DISCOVERY_PLANNER_NO_FALLBACK === "true";
+        if (noFallback) {
+          logs2.push(`Planner ${kind} \u2014 NO-FALLBACK: failing survey cleanly instead of fabricating slug features (${reason})`);
+          return {
+            scenarios: [],
+            featureGroups: [],
+            reasoning: "",
+            logs: logs2,
+            coverageGaps: [],
+            plannerFailed: true,
+            plannerFailureKind: kind,
+            fallbackReason: reason
+          };
+        }
+        return { ...legacyFallback2(), fallbackReason: reason };
+      };
+      let extraPlannerCallUsed = false;
       const compressed = compressSiteMap(siteMap);
       const agentModel = options.modelOverride ? (0, ai_provider_js_1.resolveModelForTask)(options.modelOverride, "agent") : (0, ai_provider_js_1.getModel)("agent");
       const plannerMaxTokens = getAIPlannerMaxTokens(agentModel);
@@ -68771,7 +69539,7 @@ Each entry is exactly one of:
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         logs2.push(`AI planner failed after retries: ${message}`);
-        return { ...buildFallbackPlan(siteMap, evidence.recordedJourneys, context.mode, logs2, context.existingTestNames ?? [], context.focusAreas, context.testBudget), fallbackReason: (0, ai_retry_js_1.describeAIFailure)(err) };
+        return failurePlan("transport", (0, ai_retry_js_1.describeAIFailure)(err), () => buildFallbackPlan(siteMap, evidence.recordedJourneys, context.mode, logs2, context.existingTestNames ?? [], context.focusAreas, context.testBudget));
       }
       try {
         options.onAICall?.({
@@ -68790,20 +69558,104 @@ Each entry is exactly one of:
         });
       } catch {
       }
-      const raw = response?.choices?.[0]?.message?.content;
-      if (!raw) {
+      const choice = response?.choices?.[0];
+      const raw = choice?.message?.content;
+      const finishReason = (choice?.finish_reason ?? "").toString().toLowerCase();
+      const completionTokens = response.usage?.completion_tokens;
+      const TRUNCATION_FINISH = /* @__PURE__ */ new Set(["length", "max_tokens", "max_output_tokens", "token_limit"]);
+      const definitelyTruncated = TRUNCATION_FINISH.has(finishReason);
+      const atOrOverCap = completionTokens != null && completionTokens >= plannerMaxTokens;
+      const blocked = finishReason === "content_filter" || finishReason === "tool_calls";
+      const usage = response.usage;
+      logs2.push(`AI planner: ${usage?.prompt_tokens ?? "?"} input, ${usage?.completion_tokens ?? "?"} output tokens (finish=${finishReason || "?"})`);
+      const legacyFallback = () => buildFallbackPlan(siteMap, evidence.recordedJourneys, context.mode, logs2, context.existingTestNames ?? [], context.focusAreas, context.testBudget);
+      if (blocked) {
+        return failurePlan("blocked", "AI response was blocked (content_filter/tool_calls)", legacyFallback);
+      }
+      if (definitelyTruncated) {
+        return failurePlan("truncated", "AI planner output truncated at max_tokens (finish_reason=length)", legacyFallback);
+      }
+      const trimmed = raw?.trim();
+      if (!trimmed) {
         logs2.push("AI planner returned empty response");
-        return { ...buildFallbackPlan(siteMap, evidence.recordedJourneys, context.mode, logs2, context.existingTestNames ?? [], context.focusAreas, context.testBudget), fallbackReason: "AI returned an empty response" };
+        return atOrOverCap ? failurePlan("truncated", "AI planner output truncated at max_tokens (empty body at cap)", legacyFallback) : failurePlan("empty", "AI returned an empty response", legacyFallback);
       }
-      const usage = response.usage;
-      logs2.push(`AI planner: ${usage?.prompt_tokens ?? "?"} input, ${usage?.completion_tokens ?? "?"} output tokens`);
       let aiOutput;
       try {
-        aiOutput = JSON.parse((0, strip_json_fences_js_1.stripJsonFences)(raw));
+        aiOutput = JSON.parse((0, strip_json_fences_js_1.stripJsonFences)(trimmed));
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         logs2.push(`AI planner returned invalid JSON: ${message}`);
-        return { ...buildFallbackPlan(siteMap, evidence.recordedJourneys, context.mode, logs2, context.existingTestNames ?? [], context.focusAreas, context.testBudget), fallbackReason: "AI returned unreadable output" };
+        if (atOrOverCap) {
+          logs2.push("AI planner output at/over the token cap and unparseable \u2014 treating as truncated (skipping repair)");
+          return failurePlan("truncated", "AI planner output truncated at max_tokens (unparseable at cap)", legacyFallback);
+        }
+        const repairPrompt = `Your previous response was not valid JSON (parser error: ${message}). Return ONLY the corrected JSON object \u2014 no prose, no markdown fences \u2014 matching the exact schema of your previous attempt.`;
+        const repairStart = Date.now();
+        let repairResponse = null;
+        try {
+          extraPlannerCallUsed = true;
+          repairResponse = await (0, ai_retry_js_1.resilientAICall)((signal, arm) => (0, ai_queue_js_1.queuedAICall)(() => {
+            arm();
+            return aiClient.chat.completions.create({
+              model: agentModel,
+              messages: [
+                ...messages,
+                { role: "assistant", content: raw },
+                { role: "user", content: repairPrompt }
+              ],
+              max_tokens: plannerMaxTokens,
+              temperature: 0.3,
+              ...(0, ai_provider_js_1.getJsonObjectResponseFormat)(agentModel),
+              ...(0, ai_provider_js_1.getNoThinkingRequestOptions)(agentModel)
+            }, { signal });
+          }), {
+            label: "ai-planner-repair",
+            deferTimeoutUntilArmed: true,
+            onRetry: (attempt, reason, delay) => logs2.push(`AI planner repair call failed (${reason}) \u2014 retry ${attempt} in ${Math.round(delay / 1e3)}s`)
+          });
+        } catch (repairErr) {
+          const repairMessage = repairErr instanceof Error ? repairErr.message : String(repairErr);
+          logs2.push(`AI planner repair failed (${repairMessage})`);
+        }
+        if (repairResponse) {
+          try {
+            options.onAICall?.({
+              iteration: 1,
+              groupId: `ai-planner-${context.projectId.slice(0, 8)}`,
+              callType: "discoveryAIPlannerRepair",
+              model: agentModel,
+              provider: (0, ai_provider_js_1.getProviderForModel)(agentModel),
+              durationMs: Date.now() - repairStart,
+              promptTokens: repairResponse.usage?.prompt_tokens,
+              completionTokens: repairResponse.usage?.completion_tokens,
+              totalTokens: repairResponse.usage?.total_tokens,
+              assistantMessage: repairResponse.choices[0]?.message?.content,
+              requestMessageCount: messages.length + 2,
+              requestMessages: [
+                ...messages,
+                { role: "assistant", content: raw },
+                { role: "user", content: repairPrompt }
+              ]
+            });
+          } catch {
+          }
+          const repairedRaw = repairResponse.choices[0]?.message?.content?.trim();
+          if (repairedRaw) {
+            try {
+              aiOutput = JSON.parse((0, strip_json_fences_js_1.stripJsonFences)(repairedRaw));
+            } catch (repairParseErr) {
+              const repairMessage = repairParseErr instanceof Error ? repairParseErr.message : String(repairParseErr);
+              logs2.push(`AI planner repair returned invalid JSON (${repairMessage})`);
+              return failurePlan("malformed", "AI returned unreadable output", legacyFallback);
+            }
+          } else {
+            logs2.push("AI planner repair returned empty response");
+            return failurePlan("malformed", "AI returned unreadable output", legacyFallback);
+          }
+        } else {
+          return failurePlan("malformed", "AI returned unreadable output", legacyFallback);
+        }
       }
       let { scenarios, featureGroups, warnings, coverageGaps } = validateAIPlannerOutput(aiOutput, siteMap, context.existingTestNames, context.testBudget, evidence.recordedJourneys, context.mode, context.focusAreas);
       logs2.push(`AI planner: ${scenarios.length} scenarios, ${featureGroups.length} feature groups (${warnings.length} warnings, ${coverageGaps.length} coverage gaps)`);
@@ -68813,7 +69665,7 @@ Each entry is exactly one of:
       let topLevelWarning;
       const totalV1 = scenarios.length + coverageGaps.length;
       const rejectionRateV1 = totalV1 > 0 ? coverageGaps.length / totalV1 : 0;
-      if (rejectionRateV1 > 0.5 && totalV1 >= 3) {
+      if (rejectionRateV1 > 0.5 && totalV1 >= 3 && !extraPlannerCallUsed) {
         logs2.push(`AI planner: ${Math.round(rejectionRateV1 * 100)}% rejection rate (${coverageGaps.length}/${totalV1}) \u2014 running self-correction retry`);
         const retryContext = [
           `Your previous emission produced ${coverageGaps.length} coverage gaps out of ${totalV1} scenarios (${Math.round(rejectionRateV1 * 100)}% rejection rate).`,
@@ -68832,6 +69684,7 @@ Each entry is exactly one of:
         const retryStart = Date.now();
         let retryResponse = null;
         try {
+          extraPlannerCallUsed = true;
           retryResponse = await (0, ai_retry_js_1.resilientAICall)((signal, arm) => (0, ai_queue_js_1.queuedAICall)(() => {
             arm();
             return aiClient.chat.completions.create({
@@ -68931,6 +69784,22 @@ Each entry is exactly one of:
         };
       }
       if (context.mode === "survey" && featureGroups.length === 0 && siteMap.pages.length > 0) {
+        const hasGroupWorthyEvidence = siteMap.pages.some((p) => (p.forms?.length ?? 0) > 0 || (p.elements?.length ?? 0) > 0);
+        const noFallback = process.env.DISCOVERY_PLANNER_NO_FALLBACK === "true";
+        if (noFallback && !hasGroupWorthyEvidence) {
+          return {
+            scenarios,
+            featureGroups: [],
+            reasoning: aiOutput.reasoning ?? "",
+            logs: logs2,
+            coverageGaps,
+            warning: topLevelWarning,
+            fallbackUsed: false
+          };
+        }
+        if (noFallback) {
+          return failurePlan("empty_groups", "AI produced no feature groups despite discovered content", () => buildFallbackPlan(siteMap, evidence.recordedJourneys, context.mode, logs2, context.existingTestNames ?? [], context.focusAreas, context.testBudget));
+        }
         logs2.push("Survey AI returned 0 feature groups - falling back to deterministic grouping");
         const fallback = buildFallbackPlan(siteMap, evidence.recordedJourneys, context.mode, logs2, context.existingTestNames ?? [], context.focusAreas, context.testBudget);
         return {
@@ -70141,6 +71010,7 @@ var require_mobile_generator = __commonJS({
     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_session_keepalive_js_1 = require_mobile_session_keepalive();
     var mobile_source_parser_js_1 = require_mobile_source_parser();
     var mobile_source_parser_js_2 = require_mobile_source_parser();
     var mobile_observation_js_1 = require_mobile_observation();
@@ -70554,7 +71424,7 @@ var require_mobile_generator = __commonJS({
 - Re-snapshot before every assertion so the ref is fresh.
 - Assert the OUTCOME of the flow (the new screen / new content), not the control you just tapped.
 - Assert only DURABLE elements \u2014 screen chrome that exists on every visit (tab labels, headers, nav bars, the entity you just created). NEVER assert one-time / data-dependent UI: empty-state CTAs, first-run or onboarding prompts, or counters \u2014 they vanish as soon as the account has data, and the test then fails forever on a healthy app.
-- Do NOT trigger irreversible side effects (real payments, sending messages to others) \u2014 note them and assert what you safely can.
+- Do NOT trigger irreversible or destructive side effects \u2014 real payments; sending messages to others; and ESPECIALLY account/data deletion, deactivation, or any "type DELETE to confirm" gate (the runner hard-blocks destructive taps and confirmation keystrokes). Note them and assert what you safely can.
 - Stay inside this app.${targetLine} Do not open or use app stores, browsers, email apps, settings, or any other app. If an action leaves the target app, the runner will relaunch the target app and reject that action.
 - NEVER tap the phone's home screen / launcher (app icons, "Predicted app" chips, search bars, widgets). Those are NOT part of the app under test \u2014 tapping them is junk that poisons the test. If the app ever backgrounds or you find yourself on the launcher, use mobile_relaunch to cold-start the app; do NOT tap a launcher icon or app-prediction to get back in.
 - Do NOT re-do a sequence you already completed. If you filled a form then navigated away, do NOT come back and fill it again \u2014 the scenario needs ONE clean pass. Filling the login form, going back, and re-filling it is exactly the kind of wandering that produces a bloated, broken test.
@@ -71048,14 +71918,14 @@ ${statePacket}`, redactionCredentials) },
         const requestMessageCount = messages.length;
         const requestMessages = messages.slice();
         const callStart = Date.now();
-        const response = await (0, ai_retry_js_1.resilientAICall)((signal, arm) => (0, ai_queue_js_1.queuedAICall)(() => {
+        const response = await (0, mobile_session_keepalive_js_1.withMobileSessionKeepAlive)(driver, () => (0, ai_retry_js_1.resilientAICall)((signal, arm) => (0, ai_queue_js_1.queuedAICall)(() => {
           arm();
           return aiClient.chat.completions.create({ model: agentModel, messages, tools: GENERATE_TOOLS, tool_choice: "auto", max_tokens: 8e3 }, { signal });
         }), {
           label: `mobile-generate-${scenario.name.slice(0, 24)}-iter-${iteration}`,
           deferTimeoutUntilArmed: true,
           onRetry: (attempt, reason, delayMs) => log2(`  \u26A0 mobile generate AI retry ${attempt} (${reason}) \u2014 waiting ${delayMs}ms`)
-        });
+        }));
         const iterDuration = Date.now() - callStart;
         if (!response?.choices?.[0]?.message) {
           throw new Error(`AI generate call returned no response at iteration ${iteration}`);
@@ -71667,6 +72537,21 @@ ${statePacket}`, redactionCredentials) },
             };
           }
           const metadata = metadataForElement(element, screenName(), platform3);
+          const expectedNeedle = expected.trim().toLowerCase();
+          const identityValues = [element.accessibilityId, element.resourceId].map((value) => value?.trim().toLowerCase()).filter((value) => Boolean(value));
+          const visibleText = (element.text ?? "").trim().toLowerCase();
+          const isSelfLabelAssertion = expectedNeedle.length > 0 && identityValues.includes(expectedNeedle) && !visibleText.includes(expectedNeedle);
+          if (isSelfLabelAssertion) {
+            recordAction({ type: "ASSERT_VISIBLE", selector: (0, mobile_source_parser_js_2.preferredLocator)(element), metadata });
+            log2(`  assert_text DOWNGRADED to assert_visible (tautological self-label "${expected}"): ${metadata.targetLabel}`);
+            return {
+              ok: true,
+              asserted: "visible",
+              downgraded: true,
+              note: `"${expected}" is the element's own accessibility identity, not product copy it displays \u2014 recorded a visibility assertion instead. To prove the outcome, assert text the screen SHOWS (an error message, a status label, a field value), not the control's own name.`,
+              target: metadata.targetLabel
+            };
+          }
           if (hasStableId(element)) {
             recordAction({ type: "ASSERT_TEXT", value: expected, selector: (0, mobile_source_parser_js_2.preferredLocator)(element), metadata });
             log2(`  assert_text: ${metadata.targetLabel} ~ "${expected}"`);
@@ -72360,7 +73245,13 @@ ${statePacket}`, redactionCredentials) },
       const strengthReason = coldResetUnavailable ? `Cold app-data reset unavailable${coldResetReason ? ` (${coldResetReason})` : ""} \u2014 generation may not match cold-boot replay. ${strengthVerdict.reason}` : !verified && recording.assertCount === 0 ? "Mobile scenario finished unverified \u2014 the agent never proved the scenario outcome live, so the recording may not demonstrate the goal (e.g. a happy path that never completed). Review before promotion." : strengthVerdict.reason;
       const test = {
         name: compiled.name,
-        description: recording.finish?.description ?? compiled.description,
+        // Description priority: the model's live finish description, then the
+        // planner's scenario goal (always a meaningful sentence describing what the
+        // test proves), then the generic compiled placeholder. Without the goal
+        // fallback a scenario whose finish_generate omitted a description shipped
+        // with the contentless "<platform> native flow generated from a recorded
+        // mobile session." string — see mobile-test-generation.ts's compiled default.
+        description: recording.finish?.description?.trim() || scenario.goal?.trim() || compiled.description,
         framework: "APPIUM",
         appiumCode: compiled.appiumCode,
         steps: compiled.steps,
@@ -75037,6 +75928,118 @@ var require_har_stream = __commonJS({
   }
 });
 
+// ../runner-core/dist/services/api-auth-headers.js
+var require_api_auth_headers = __commonJS({
+  "../runner-core/dist/services/api-auth-headers.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.parseApiAuthHeaders = parseApiAuthHeaders;
+    exports2.resolveApiAuthHeaders = resolveApiAuthHeaders;
+    exports2.isAppOriginRequest = isAppOriginRequest;
+    exports2.buildOriginScopedApiFixtures = buildOriginScopedApiFixtures;
+    var HEADER_NAME_RE = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
+    function hasControlChar(v) {
+      for (let i = 0; i < v.length; i++) {
+        const code = v.charCodeAt(i);
+        if (code < 32 || code === 127)
+          return true;
+      }
+      return false;
+    }
+    function parseApiAuthHeaders(raw) {
+      if (!raw || typeof raw !== "string")
+        return void 0;
+      const trimmed = raw.trim();
+      if (!trimmed)
+        return void 0;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+          return void 0;
+        const headers = {};
+        for (const [k, v] of Object.entries(parsed)) {
+          if (typeof k === "string" && HEADER_NAME_RE.test(k) && typeof v === "string" && !hasControlChar(v)) {
+            headers[k] = v;
+          }
+        }
+        return Object.keys(headers).length > 0 ? headers : void 0;
+      } catch {
+        return void 0;
+      }
+    }
+    function resolveApiAuthHeaders(input) {
+      if (input.explicit)
+        return input.explicit;
+      if (!input.isApiTest)
+        return void 0;
+      return parseApiAuthHeaders(input.apiAuthHeadersVar);
+    }
+    function isAppOriginRequest(url, baseUrl) {
+      if (typeof url !== "string" || !baseUrl)
+        return false;
+      let appOrigin;
+      try {
+        appOrigin = new URL(baseUrl).origin;
+      } catch {
+        return false;
+      }
+      try {
+        return new URL(url, baseUrl).origin === appOrigin;
+      } catch {
+        return false;
+      }
+    }
+    function buildOriginScopedApiFixtures(headers, baseUrl) {
+      let appOrigin;
+      try {
+        appOrigin = baseUrl ? new URL(baseUrl).origin : null;
+      } catch {
+        appOrigin = null;
+      }
+      return `export * from '@playwright/test';
+import { test as base } from '@playwright/test';
+
+// Standing auth headers \u2014 attached ONLY to same-origin requests so the credential never leaks to
+// an off-origin host. Embedded at run time; this file lives in the ephemeral run dir.
+const STANDING_HEADERS = ${JSON.stringify(headers)};
+const APP_ORIGIN = ${JSON.stringify(appOrigin)};
+const BASE_URL = ${JSON.stringify(baseUrl)};
+const METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head', 'fetch'];
+
+function sameOrigin(url) {
+  if (!APP_ORIGIN || typeof url !== 'string') return false;
+  try { return new URL(url, BASE_URL).origin === APP_ORIGIN; } catch { return false; }
+}
+
+export const test = base.extend({
+  request: async ({ request }, use) => {
+    const scoped = new Proxy(request, {
+      get(target, prop) {
+        const value = target[prop];
+        // HTTP verbs: wrap to add standing headers on same-origin requests only.
+        if (typeof prop === 'string' && METHODS.indexOf(prop) !== -1) {
+          const orig = value.bind(target);
+          return (url, options) => {
+            options = options || {};
+            return sameOrigin(url)
+              ? orig(url, { ...options, headers: { ...STANDING_HEADERS, ...(options.headers || {}) } })
+              : orig(url, options);
+          };
+        }
+        // Every other METHOD must run with 'this' bound to the REAL context \u2014 an APIRequestContext
+        // uses internal slots/private fields a Proxy can't forward, so calling with 'this'=proxy
+        // would throw. Non-function props pass through untouched.
+        return typeof value === 'function' ? value.bind(target) : value;
+      },
+    });
+    await use(scoped);
+  },
+});
+`;
+    }
+  }
+});
+
 // ../runner-core/dist/services/playwright-native.js
 var require_playwright_native = __commonJS({
   "../runner-core/dist/services/playwright-native.js"(exports2) {
@@ -75079,7 +76082,7 @@ var require_playwright_native = __commonJS({
       };
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.scrubHarRequestBody = void 0;
+    exports2.scrubHarRequestBody = exports2.buildOriginScopedApiFixtures = exports2.isAppOriginRequest = exports2.resolveApiAuthHeaders = exports2.parseApiAuthHeaders = void 0;
     exports2.executeTestViaNativePlaywright = executeTestViaNativePlaywright2;
     exports2.parseJsonResults = parseJsonResults2;
     exports2.parseHarToApiSummary = parseHarToApiSummary;
@@ -75091,6 +76094,20 @@ var require_playwright_native = __commonJS({
     var spawn_with_tree_kill_js_1 = require_spawn_with_tree_kill();
     var api_call_redaction_js_1 = require_api_call_redaction();
     var har_stream_js_1 = require_har_stream();
+    var api_auth_headers_js_1 = require_api_auth_headers();
+    var api_auth_headers_js_2 = require_api_auth_headers();
+    Object.defineProperty(exports2, "parseApiAuthHeaders", { enumerable: true, get: function() {
+      return api_auth_headers_js_2.parseApiAuthHeaders;
+    } });
+    Object.defineProperty(exports2, "resolveApiAuthHeaders", { enumerable: true, get: function() {
+      return api_auth_headers_js_2.resolveApiAuthHeaders;
+    } });
+    Object.defineProperty(exports2, "isAppOriginRequest", { enumerable: true, get: function() {
+      return api_auth_headers_js_2.isAppOriginRequest;
+    } });
+    Object.defineProperty(exports2, "buildOriginScopedApiFixtures", { enumerable: true, get: function() {
+      return api_auth_headers_js_2.buildOriginScopedApiFixtures;
+    } });
     var api_call_redaction_js_2 = require_api_call_redaction();
     Object.defineProperty(exports2, "scrubHarRequestBody", { enumerable: true, get: function() {
       return api_call_redaction_js_2.scrubHarRequestBody;
@@ -75100,7 +76117,7 @@ var require_playwright_native = __commonJS({
     var RUNS_DIR = process.env.RUNS_DIR || (0, path_1.join)(PACKAGE_DIR, ".qa-runs");
     var PW_CLI = require.resolve("@playwright/test/cli");
     async function executeTestViaNativePlaywright2(options) {
-      const { playwrightCode, baseUrl, testName, testVariables, storageStatePath, validateContext, liveBrowserHandle, onLiveBrowserSnapshot } = options;
+      const { playwrightCode, baseUrl, testName, testVariables, storageStatePath, extraHttpHeaders, validateContext, liveBrowserHandle, onLiveBrowserSnapshot } = options;
       const logs2 = [];
       const screenshots = [];
       logs2.push(`\u{1F3AD} Native Playwright starting`);
@@ -75114,6 +76131,11 @@ var require_playwright_native = __commonJS({
         runDir = (0, path_1.join)(RUNS_DIR, (0, crypto_1.randomUUID)());
         await (0, promises_1.mkdir)(runDir, { recursive: true });
         const isApiTest2 = playwrightCode.includes("@api") || playwrightCode.includes("{ request }") && !playwrightCode.includes("{ page");
+        const resolvedExtraHeaders = (0, api_auth_headers_js_1.resolveApiAuthHeaders)({
+          explicit: extraHttpHeaders,
+          isApiTest: isApiTest2,
+          apiAuthHeadersVar: testVariables?.API_AUTH_HEADERS
+        });
         const cssDisableSetup = `
 const __qaLiveBrowserStateFile = process.env.VALIDATE_LIVE_BROWSER_STATE_PATH;
 let __qaLiveBrowserInterval: ReturnType<typeof setInterval> | null = null;
@@ -75307,8 +76329,17 @@ test.afterEach(async ({ page }, testInfo) => {
         if (!importMatch) {
           logs2.push("\u26A0 Could not find @playwright/test import - animation disabling NOT injected");
         }
-        const instrumentedCode = isApiTest2 ? playwrightCode : importMatch ? playwrightCode.replace(importMatch[0], importMatch[0] + cssDisableSetup) : playwrightCode;
+        const useScopedApiHeaders = isApiTest2 && !!resolvedExtraHeaders && !!importMatch && !!baseUrl;
+        let instrumentedCode;
+        if (isApiTest2) {
+          instrumentedCode = useScopedApiHeaders ? playwrightCode.replace(importMatch[0], importMatch[0].replace(/from\s+['"]@playwright\/test['"]/, "from './qa-api-fixtures'")) : playwrightCode;
+        } else {
+          instrumentedCode = importMatch ? playwrightCode.replace(importMatch[0], importMatch[0] + cssDisableSetup) : playwrightCode;
+        }
         await (0, promises_1.writeFile)((0, path_1.join)(runDir, "test.spec.ts"), instrumentedCode);
+        if (useScopedApiHeaders && resolvedExtraHeaders) {
+          await (0, promises_1.writeFile)((0, path_1.join)(runDir, "qa-api-fixtures.ts"), (0, api_auth_headers_js_1.buildOriginScopedApiFixtures)(resolvedExtraHeaders, baseUrl));
+        }
         const headless = process.env.PLAYWRIGHT_HEADLESS === "true" || process.env.NODE_ENV === "production" || IS_CLOUD2;
         logs2.push(`\u2699\uFE0F  Config: baseURL=${JSON.stringify(baseUrl)}, headless=${headless}${isApiTest2 ? ", API mode (no screenshot/video)" : ""}`);
         const absTestDir = runDir.replace(/\\/g, "/");
@@ -75322,6 +76353,7 @@ test.afterEach(async ({ page }, testInfo) => {
         const absHarPath = wantHar ? (0, path_1.join)(runDir, "session.har").replace(/\\/g, "/") : null;
         const recordHarLine = absHarPath ? `recordHar: { path: ${JSON.stringify(absHarPath)}, mode: 'full' },` : "";
         const storageStateLine = storageStatePath ? `storageState: ${JSON.stringify(storageStatePath.replace(/\\/g, "/"))},` : "";
+        const extraHeadersLine = resolvedExtraHeaders && !useScopedApiHeaders && Object.keys(resolvedExtraHeaders).length > 0 ? `extraHTTPHeaders: ${JSON.stringify(resolvedExtraHeaders)},` : "";
         const launchArgs = IS_CLOUD2 ? "args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-blink-features=AutomationControlled', '--disable-dev-shm-usage', '--disable-gpu', '--disable-software-rasterizer', '--no-zygote', '--disable-accelerated-2d-canvas', '--js-flags=--max-old-space-size=512']," : "args: ['--disable-blink-features=AutomationControlled'],";
         const config = `
 // Plain object export - no require('@playwright/test') needed.
@@ -75335,6 +76367,7 @@ module.exports = {
   use: {
     baseURL: ${JSON.stringify(baseUrl)},
     ${storageStateLine}
+    ${extraHeadersLine}
     browserName: 'chromium',
     headless: ${headless},
     screenshot: ${isApiTest2 ? "'off'" : "'on'"},
@@ -75376,6 +76409,7 @@ module.exports = {
           // code. Forwarded (not allowlisted) so it stays a per-run toggle; absent → inert.
           ...process.env.SHARED_AUTH_INJECT ? { SHARED_AUTH_INJECT: process.env.SHARED_AUTH_INJECT } : {}
         };
+        delete envWithIsolation.API_AUTH_HEADERS;
         logs2.push("\u{1F680} Spawning playwright test...");
         const stopLiveBrowserPolling = liveBrowserStatePath && liveBrowserHandle ? startLiveBrowserStatePolling(liveBrowserStatePath, liveBrowserHandle, onLiveBrowserSnapshot) : null;
         let playResult;
@@ -79227,6 +80261,34 @@ var require_anchor_harvester = __commonJS({
   }
 });
 
+// ../runner-core/dist/services/discovery-lint-flags.js
+var require_discovery_lint_flags = __commonJS({
+  "../runner-core/dist/services/discovery-lint-flags.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.structuralLocatorLintMode = structuralLocatorLintMode;
+    exports2.isPwMethodPreflightEnabled = isPwMethodPreflightEnabled;
+    exports2.isVqaLoginDedupeEnabled = isVqaLoginDedupeEnabled;
+    function strictOn(value) {
+      return value === "true" || value === "1";
+    }
+    function structuralLocatorLintMode() {
+      const v = (process.env.DISCOVERY_STRUCTURAL_LOCATOR_LINT || "").trim().toLowerCase();
+      if (v === "warn")
+        return "warn";
+      if (v === "true" || v === "1" || v === "enforce")
+        return "enforce";
+      return "off";
+    }
+    function isPwMethodPreflightEnabled() {
+      return strictOn(process.env.DISCOVERY_PW_METHOD_PREFLIGHT);
+    }
+    function isVqaLoginDedupeEnabled() {
+      return strictOn(process.env.DISCOVERY_VQALOGIN_DEDUPE);
+    }
+  }
+});
+
 // ../runner-core/dist/services/auth-recipe.js
 var require_auth_recipe = __commonJS({
   "../runner-core/dist/services/auth-recipe.js"(exports2) {
@@ -79249,9 +80311,11 @@ var require_auth_recipe = __commonJS({
     exports2.extractAuthRegion = extractAuthRegion;
     exports2.stripAuthRegions = stripAuthRegions;
     exports2.ensureExpectImported = ensureExpectImported;
+    exports2.ensureLoginCall = ensureLoginCall;
     exports2.upsertAuthBlock = upsertAuthBlock;
     exports2.buildHealAuthStamp = buildHealAuthStamp;
     var crypto_1 = require("crypto");
+    var discovery_lint_flags_js_1 = require_discovery_lint_flags();
     exports2.AUTH_MARKER_VERSION = "v1";
     var START_MARKER = `// >>> VALIDATE_QA_AUTH ${exports2.AUTH_MARKER_VERSION} \u2014 generated, do not edit >>>`;
     var END_MARKER = `// <<< VALIDATE_QA_AUTH ${exports2.AUTH_MARKER_VERSION} <<<`;
@@ -79515,10 +80579,13 @@ ${tail}`;
     var TEST_OPENER_RE = /test(?:\.(?:only|skip|fixme))?\s*\(\s*(['"`])(?:[^\\]|\\.)*?\1\s*,\s*(?:\{[\s\S]*?\}\s*,\s*)?async\s*\(\s*\{[^}]*\}[^)]*\)\s*=>\s*\{/;
     var LOGIN_CALL_RE = /await\s+__vqaLogin\s*\(\s*page\s*\)/;
     function ensureLoginCall(code) {
-      const matches = [...code.matchAll(new RegExp(TEST_OPENER_RE.source, "g"))];
-      if (matches.length === 0)
+      if (code.match(new RegExp(TEST_OPENER_RE.source, "g")) === null)
         return code;
       let result = code;
+      if ((0, discovery_lint_flags_js_1.isVqaLoginDedupeEnabled)()) {
+        result = result.replace(/^[ \t]*await[ \t]+__vqaLogin[ \t]*\([ \t]*page[ \t]*\)[ \t]*;?[ \t]*\r?\n/gm, "");
+      }
+      const matches = [...result.matchAll(new RegExp(TEST_OPENER_RE.source, "g"))];
       for (let i = matches.length - 1; i >= 0; i--) {
         const m = matches[i];
         if (m.index === void 0)
@@ -83410,7 +84477,7 @@ var require_discover_generator = __commonJS({
   "../runner-core/dist/services/discover-generator.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.MIN_BUG_DESCRIPTION_LENGTH = exports2.BLOCKED_MCP_TOOLS_SCENARIO_GEN = void 0;
+    exports2.MIN_BUG_DESCRIPTION_LENGTH = exports2.VALID_PLAYWRIGHT_GETBY_METHODS = exports2.BLOCKED_MCP_TOOLS_SCENARIO_GEN = void 0;
     exports2.filterMcpToolsForScenarioGen = filterMcpToolsForScenarioGen;
     exports2.detectScenarioSignals = detectScenarioSignals;
     exports2.scenarioStepsCoverAuth = scenarioStepsCoverAuth;
@@ -83433,6 +84500,7 @@ var require_discover_generator = __commonJS({
     exports2.upgradePositionalProvenLines = upgradePositionalProvenLines;
     exports2.synthesizeRefActionLines = synthesizeRefActionLines;
     exports2.renderSessionRecording = renderSessionRecording;
+    exports2.scanFragileStructuralLocators = scanFragileStructuralLocators;
     exports2.validateFinalActionFidelity = validateFinalActionFidelity;
     exports2.resolveSuspectedBugVerdict = resolveSuspectedBugVerdict;
     exports2.buildScenarioSystemPrompt = buildScenarioSystemPrompt;
@@ -83448,6 +84516,7 @@ var require_discover_generator = __commonJS({
     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 discover_ai_planner_js_1 = require_discover_ai_planner();
     var snapshot_parser_js_1 = require_snapshot_parser();
     var scrub_credentials_js_1 = require_scrub_credentials();
     var exploration_parser_js_1 = require_exploration_parser();
@@ -83460,6 +84529,7 @@ var require_discover_generator = __commonJS({
     var auth_recipe_js_1 = require_auth_recipe();
     var auth_replay_js_1 = require_auth_replay();
     var agentic_discovery_prompts_js_1 = require_agentic_discovery_prompts();
+    var discovery_lint_flags_js_1 = require_discovery_lint_flags();
     exports2.BLOCKED_MCP_TOOLS_SCENARIO_GEN = /* @__PURE__ */ new Set([
       "browser_install",
       "browser_close",
@@ -84184,6 +85254,15 @@ ${elementContext}${formContext}${observationContext}${interactionContext}${lowCo
       return assembled.join(separator);
     }
     var SENSITIVE_ENV_KEY_RE = /email|password|token|secret|api[_-]?key|access[_-]?key|username|user(name)?|bearer|session|cookie|\bpat\b|refresh|jwt/i;
+    exports2.VALID_PLAYWRIGHT_GETBY_METHODS = /* @__PURE__ */ new Set([
+      "getByRole",
+      "getByText",
+      "getByLabel",
+      "getByPlaceholder",
+      "getByTestId",
+      "getByAltText",
+      "getByTitle"
+    ]);
     var VALID_PLAYWRIGHT_MATCHERS = /* @__PURE__ */ new Set([
       // Locator assertions
       "toBeAttached",
@@ -84671,6 +85750,16 @@ ${testOpen}`;
             return false;
           }
         }
+        if ((0, discovery_lint_flags_js_1.isPwMethodPreflightEnabled)()) {
+          const getByCalls = codeForMatcherScan.match(/\.getBy[A-Za-z0-9_]*\s*\(/g) ?? [];
+          for (const call of getByCalls) {
+            const methodName = call.replace(/[\s(]+$/, "").slice(1);
+            if (!exports2.VALID_PLAYWRIGHT_GETBY_METHODS.has(methodName)) {
+              logs2?.push(`  \u2717 Rejected "${t.name}": invalid Playwright locator method "${methodName}" (not a real getBy* API \u2014 likely hallucinated)`);
+              return false;
+            }
+          }
+        }
         if (code.includes("// TODO")) {
           logs2?.push(`  \u26A0 "${t.name}" contains TODO comment \u2014 marking as unverified`);
           t.tags = t.tags.filter((tag) => tag !== "@verified");
@@ -85784,6 +86873,35 @@ ${testOpen}`;
       }
       return null;
     }
+    var STRUCTURAL_ACTION_RE = /\.(?:click|dblclick|tap|fill|type|pressSequentially|press|selectOption|hover|check|uncheck|setChecked|setInputFiles|dragTo|focus|clear)\s*\(/;
+    var POSITIONAL_PSEUDO_RE = /:(?:last-child|first-child|nth-child|nth-of-type|nth-last-child|nth-last-of-type)\b/i;
+    var TABLE_TOKEN_RE = /\b(?:tr|td|th|tbody|thead)\b/i;
+    var ROW_ANCHOR_RE = /getByRole\s*\(\s*['"`]row['"`]|getByTestId|data-testid|data-test\b|\[role\s*=\s*['"`]row['"`]\]/i;
+    var LOCATOR_ARG_RE = /\.locator\(\s*(['"`])((?:\\.|(?!\1)[\s\S])*?)\1/g;
+    function scanFragileStructuralLocators(code) {
+      const findings = [];
+      const scanCode = code.replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "));
+      for (const rawLine of scanCode.split("\n")) {
+        const line = rawLine.replace(/\/\/.*$/, "");
+        if (!STRUCTURAL_ACTION_RE.test(line))
+          continue;
+        if (ROW_ANCHOR_RE.test(line))
+          continue;
+        LOCATOR_ARG_RE.lastIndex = 0;
+        let m;
+        while ((m = LOCATOR_ARG_RE.exec(line)) !== null) {
+          const css = m[2];
+          if (POSITIONAL_PSEUDO_RE.test(css) && TABLE_TOKEN_RE.test(css)) {
+            findings.push({
+              line: rawLine.trim().slice(0, 200),
+              reason: `Positional table-row selector "${css.slice(0, 120)}" is not scoped to a row identity \u2014 it breaks when rows reorder, sort, filter, or a row is inserted. Scope through the row: page.getByRole('row', { name: '<a stable cell value in that row>' }).getByRole('button', { name: '<verb>' }).`
+            });
+            break;
+          }
+        }
+      }
+      return findings;
+    }
     function validateFinalActionFidelity(playwrightCode, actionLedger, credentials, opts) {
       const ledgerSigs = [];
       for (const entry of actionLedger) {
@@ -86223,6 +87341,7 @@ ${tailBlock}`;
         let actionRevisionAttempted = false;
         let ambiguityRevisionAttempted = false;
         let strengthRevisionAttempted = false;
+        let structuralRevisionAttempted = false;
         let lastRenderedLedgerEntryCount = 0;
         const successfulVerifications = [];
         const actionLedger = [];
@@ -86349,7 +87468,15 @@ Do NOT add steps you did not execute. Do NOT skip steps from the recording.${led
                 tools: openaiTools,
                 tool_choice: "auto",
                 temperature: 0.2,
-                max_tokens: 8192
+                // Shared provider-aware output ceiling (same helper the survey planner uses):
+                // generous where the provider's max output is verified large (deepseek/minimax
+                // 65536), conservative elsewhere (16384). The old flat 8192 truncated large
+                // finish_generate emissions mid-JSON — the loop re-prompted on the parse error
+                // (line ~4744) and, for a test that genuinely needs >8192 output tokens, could
+                // never finish before the hard stop → zero tests for that scenario. It's a
+                // ceiling, not a target (calls finish at finish_reason:'stop' well under it), so
+                // this adds no per-call cost.
+                max_tokens: (0, discover_ai_planner_js_1.getAIPlannerMaxTokens)(agentModel)
               }, { signal });
             }), {
               label: `scenario-gen-iter-${iteration}`,
@@ -86493,6 +87620,33 @@ Do NOT add steps you did not execute. Do NOT skip steps from the recording.${led
                   });
                   continue;
                 }
+                const structuralLintMode = (0, discovery_lint_flags_js_1.structuralLocatorLintMode)();
+                const structuralFindings = structuralLintMode !== "off" ? scanFragileStructuralLocators(validated[0].playwrightCode) : [];
+                if (structuralLintMode === "warn" && structuralFindings.length > 0) {
+                  logs2.push(`    Structural-locator gate [warn]: ${structuralFindings.length} positional table-row selector(s) \u2014 ${structuralFindings.map((f) => sanitizeLedgerText(f.line)).join(" | ").slice(0, 300)}`);
+                }
+                if (structuralLintMode === "enforce" && structuralFindings.length > 0 && !structuralRevisionAttempted) {
+                  structuralRevisionAttempted = true;
+                  const renderedLedger = actionLedger.length > 0 ? renderSessionRecording(actionLedger, credentials) : "";
+                  if (renderedLedger)
+                    lastRenderedLedgerEntryCount = actionLedger.length;
+                  logs2.push(`    Structural-locator gate: ${structuralFindings.length} positional table-row selector(s) found \u2014 requesting one revision (recording attached: ${renderedLedger ? "yes" : "no"})`);
+                  const structuralPayload = {
+                    acknowledged: false,
+                    valid: false,
+                    revisionRequired: true,
+                    reason: "fragile_structural_locator",
+                    instruction: "One or more locators below select a table row by POSITION (tr:last-child, tr:nth-child, td:nth-child) instead of by identity. Positional row selectors break the moment rows are reordered, sorted, filtered, or a row is inserted.\nFor EACH flagged locator:\n1. Scope through the row IDENTITY: page.getByRole('row', { name: '<a stable cell value in that row \u2014 an id, name, email>' }).getByRole('button', { name: '<verb>' }).\n2. If the row genuinely has no stable text, use a data-testid on the row if one exists.\n3. Keep every other line exactly as-is. Submit the COMPLETE corrected test and call finish_generate again.",
+                    offendingLocators: structuralFindings.map((f) => ({
+                      line: sanitizeLedgerText(f.line),
+                      reason: f.reason
+                    }))
+                  };
+                  if (renderedLedger)
+                    structuralPayload.sessionRecording = renderedLedger;
+                  toolResults.push({ role: "tool", tool_call_id: toolCall.id, content: JSON.stringify(structuralPayload) });
+                  continue;
+                }
                 const ambiguityGateEval = evaluateAmbiguityGate(validated[0].playwrightCode, ambiguityRevisionAttempted, iteration < MAX_SCENARIO_ITERATIONS);
                 const ambiguousLocators = ambiguityGateEval.findings;
                 if (ambiguityGateEval.fire) {
@@ -86589,12 +87743,16 @@ Do NOT assert that the button/tab/heading you interacted with is merely visible
                 const strengthSeverity = strengthVerdict?.severity ?? "none";
                 const hasResidualViolations = qualityCheck.offendingLines.length > 0;
                 const hasResidualActionDrift = actionCheck.offendingActions.length > 0;
+                const hasResidualStructural = structuralLintMode === "enforce" && structuralFindings.length > 0;
                 if (hasResidualViolations) {
                   logs2.push(`    Assertion quality gate: violations remain after revision \u2014 downgrading to @needs-review`);
                 }
                 if (hasResidualActionDrift) {
                   logs2.push(`    Action fidelity gate: ${actionCheck.offendingActions.length} action drift(s) remain after revision \u2014 downgrading to @needs-review`);
                 }
+                if (hasResidualStructural) {
+                  logs2.push(`    Structural-locator gate: ${structuralFindings.length} positional table-row selector(s) remain after revision \u2014 downgrading to @needs-review`);
+                }
                 let actualVerified = verified;
                 if (verified && verifyCallCount === 0) {
                   actualVerified = false;
@@ -86647,6 +87805,16 @@ Do NOT assert that the button/tab/heading you interacted with is merely visible
                     residual: ambiguousLocators.length,
                     lines: ambiguousLocators.map((a) => sanitizeLedgerText(a.line))
                   },
+                  // G2 — omitted entirely when off so the off-path healingContext is
+                  // byte-identical; present in warn (measure) + enforce (act) modes.
+                  ...structuralLintMode !== "off" ? {
+                    structuralGate: {
+                      mode: structuralLintMode,
+                      fired: structuralRevisionAttempted,
+                      residual: structuralFindings.length,
+                      lines: structuralFindings.map((f) => sanitizeLedgerText(f.line))
+                    }
+                  } : {},
                   // Durable marker the server promote-seam (failure-analyzer.checkTestStability)
                   // reads to decide ACTIVE vs QUARANTINED(@bug-found) vs hold-DRAFT. Omitted when
                   // the gate errored (fail-open) so a missing marker is treated as "promote".
@@ -86672,7 +87840,7 @@ Do NOT assert that the button/tab/heading you interacted with is merely visible
                   verified: actualVerified,
                   healingContext: { ...baseHealingContext, gateActivity }
                 };
-                if ((hasResidualViolations || hasResidualActionDrift || hasUncoveredOutcomes) && !result.tags.includes("@needs-review")) {
+                if ((hasResidualViolations || hasResidualActionDrift || hasUncoveredOutcomes || hasResidualStructural) && !result.tags.includes("@needs-review")) {
                   result.tags.push("@needs-review");
                 }
                 if (actualVerified) {
@@ -320906,675 +322074,6 @@ ${(0, inbox_tools_js_1.buildInboxAgentsGuidance)(inboxReg.email, inboxReg.passwo
   }
 });
 
-// ../runner-core/dist/services/mobile/mobile-exploration-state.js
-var require_mobile_exploration_state = __commonJS({
-  "../runner-core/dist/services/mobile/mobile-exploration-state.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.MobileExplorationState = void 0;
-    exports2.stableMobileControlIdentity = stableMobileControlIdentity;
-    exports2.classifySafeMobileNavigationControl = classifySafeMobileNavigationControl;
-    exports2.deriveScreenId = deriveScreenId;
-    var mobile_observation_js_1 = require_mobile_observation();
-    var DEFAULT_STALE_THRESHOLD = 4;
-    var MAX_SCREEN_OBSERVATIONS = 50;
-    var EDITABLE_CONTROL_ROLE_RE = /(?:android\.widget\.(?:EditText|AutoCompleteTextView)|XCUIElementType(?:TextField|SecureTextField|SearchField|TextView)|textbox|searchbox|combobox|textarea|select)$/i;
-    var STATEFUL_CONTROL_ROLE_RE = /(?:Switch|CheckBox|Checkbox|RadioButton|radio|Slider|SeekBar|Stepper|PickerWheel|Toggle)$/i;
-    var UNSAFE_OR_COMMIT_LABEL_RE = /\b(?:submit|save|confirm|delete|remove|archive|reset|disconnect|deactivate|destroy|purge|pay|purchase|buy|checkout|place\s+order|send|post|publish|upload|import|export|sign\s*out|log\s*out|logout|accept|agree|subscribe|unsubscribe|follow|unfollow|enable|disable|book|reserve|cancel|continue|next|previous|done|apply|retry|close|dismiss|sign\s*in|log\s*in|register)\b/i;
-    var SAFE_MODAL_TRIGGER_LABEL_RE = /^(?:create|new|add|edit|invite|configure|manage|details|preview|share)$/i;
-    var MENU_TRIGGER_LABEL_RE = /^(?:more|menu|options|actions|filter|filters|sort|columns|customize)$/i;
-    var GENERIC_NAVIGATION_DESTINATION_LABEL_RE = /^(?:home|feed|dashboard|profile|settings|inbox|messages?|notifications?|projects?|about|privacy|terms|learn\s+more)$/i;
-    var SYSTEM_BACK_CONTROL_LABEL_RE = /^(?:back|go\s+back|navigate\s+up|navigation\s+up|up)$/i;
-    var SYSTEM_BACK_CONTROL_ID_RE = /^(?:action_bar_up|arrow_back|back_arrow|navigate_up|navigation_up|nav_up|toolbar_back|action_back|btn_back|button_back|back_button|back_btn|back_icon|icon_back)$/i;
-    function normalizeControlIdentityPart(value) {
-      return value.trim().replace(/\s+/g, " ").toLowerCase();
-    }
-    function semanticControlAlias(label) {
-      return `navigation-label:${normalizeControlIdentityPart(label)}`;
-    }
-    function localControlCoverageIdentity(screenId, identity) {
-      return `screen:${screenId}:${identity}`;
-    }
-    function storedMobileControlIdentity(candidate) {
-      return [
-        candidate.identity,
-        `kind:${candidate.kind}`,
-        `label:${normalizeControlIdentityPart(candidate.label)}`
-      ].join(":");
-    }
-    function isSystemBackNavigationControl(element, label) {
-      if (SYSTEM_BACK_CONTROL_LABEL_RE.test(normalizeControlIdentityPart(label)))
-        return true;
-      return [element.accessibilityId, element.resourceId].filter((value) => Boolean(value?.trim())).some((value) => {
-        const leaf = normalizeControlIdentityPart(value).split(/[/:.]/).filter(Boolean).at(-1) ?? "";
-        return SYSTEM_BACK_CONTROL_ID_RE.test(leaf);
-      });
-    }
-    function stableMobileControlIdentity(element) {
-      const role = normalizeControlIdentityPart(element.role || "control");
-      const accessibilityId = element.accessibilityId?.trim();
-      if (accessibilityId)
-        return `a11y:${role}:${normalizeControlIdentityPart(accessibilityId)}`;
-      const resourceId = element.resourceId?.trim();
-      if (resourceId)
-        return `resource:${role}:${normalizeControlIdentityPart(resourceId)}`;
-      const label = (0, mobile_observation_js_1.safeMobileElementLabel)(element)?.trim();
-      if (label)
-        return `semantic:${role}:${normalizeControlIdentityPart(label)}`;
-      return null;
-    }
-    function classifySafeMobileNavigationControl(element) {
-      if (!element.actionable || element.enabled === false)
-        return null;
-      const label = (0, mobile_observation_js_1.safeMobileElementLabel)(element)?.trim();
-      const safetyIdentity = [label, element.accessibilityId, element.resourceId].filter(Boolean).join(" ");
-      if (!label || UNSAFE_OR_COMMIT_LABEL_RE.test(safetyIdentity))
-        return null;
-      if (isSystemBackNavigationControl(element, label))
-        return null;
-      const role = element.role.trim();
-      if (EDITABLE_CONTROL_ROLE_RE.test(role) || STATEFUL_CONTROL_ROLE_RE.test(role))
-        return null;
-      const linkLike = /(?:Link$|^a$)/i.test(role);
-      let kind = null;
-      if (/(?:TabBarItem|\btab\b)/i.test(role))
-        kind = "tab";
-      else if (/menuitem/i.test(role))
-        kind = "menu-item";
-      else if (linkLike && element.navigationProvenance)
-        kind = "link";
-      else if (linkLike)
-        return null;
-      else if (element.hasPopup && element.hasPopup.toLowerCase() !== "false")
-        kind = "menu-trigger";
-      else if (element.expanded === false)
-        kind = "disclosure";
-      else if (MENU_TRIGGER_LABEL_RE.test(label))
-        kind = "menu-trigger";
-      else if (SAFE_MODAL_TRIGGER_LABEL_RE.test(label))
-        kind = "modal-trigger";
-      else if (element.navigationProvenance)
-        kind = "navigation-button";
-      else if (GENERIC_NAVIGATION_DESTINATION_LABEL_RE.test(label))
-        kind = "navigation-button";
-      if (!kind)
-        return null;
-      const identity = stableMobileControlIdentity(element);
-      return identity ? { identity, label, kind } : null;
-    }
-    function sharedMobileControlCoverageIdentity(element, candidate, semanticFamilyId) {
-      if (!element.navigationProvenance)
-        return void 0;
-      const durableId = element.accessibilityId?.trim() ? `a11y:${normalizeControlIdentityPart(element.accessibilityId)}` : element.resourceId?.trim() ? `resource:${normalizeControlIdentityPart(element.resourceId)}` : "";
-      if (!durableId && !semanticFamilyId)
-        return void 0;
-      return [
-        "shared-navigation",
-        element.navigationProvenance,
-        !durableId && semanticFamilyId ? `family:${semanticFamilyId}` : "",
-        candidate.kind,
-        durableId || "semantic-only",
-        normalizeControlIdentityPart(candidate.label)
-      ].filter(Boolean).join(":");
-    }
-    function mobileNavigationRegion(element, windowSize) {
-      if (!windowSize || windowSize.width <= 0 || windowSize.height <= 0)
-        return "unknown";
-      const centerX = (element.bounds.x + element.bounds.width / 2) / windowSize.width;
-      const centerY = (element.bounds.y + element.bounds.height / 2) / windowSize.height;
-      if (centerY >= 0.72)
-        return "bottom";
-      if (centerY <= 0.28)
-        return "top";
-      if (centerX <= 0.35)
-        return "left";
-      if (centerX >= 0.65)
-        return "right";
-      return "center";
-    }
-    function buildSemanticNavigationGroups(elements, windowSize) {
-      const groups = /* @__PURE__ */ new Map();
-      for (const element of elements) {
-        if (!element.navigationProvenance)
-          continue;
-        const candidate = classifySafeMobileNavigationControl(element);
-        if (!candidate)
-          continue;
-        const groupKey = `${element.navigationProvenance}:${mobileNavigationRegion(element, windowSize)}`;
-        const labels = groups.get(groupKey) ?? /* @__PURE__ */ new Set();
-        labels.add(`${candidate.kind}:${normalizeControlIdentityPart(candidate.label)}`);
-        groups.set(groupKey, labels);
-      }
-      return new Map([...groups].filter(([, labels]) => labels.size >= 2));
-    }
-    function deriveScreenId(signal) {
-      const namespace = signal.activity?.trim() || signal.bundleId?.trim();
-      return namespace ? `${namespace}#${signal.screenHash}` : signal.screenHash;
-    }
-    function observedElementIdentity(element) {
-      return (0, mobile_observation_js_1.stableParsedMobileElementIdentity)(element);
-    }
-    function mergeObservedElements(previous, current) {
-      const merged = [...current];
-      const seen = new Set(current.map(observedElementIdentity));
-      for (const element of previous) {
-        const identity = observedElementIdentity(element);
-        if (seen.has(identity))
-          continue;
-        seen.add(identity);
-        merged.push(element);
-      }
-      return merged;
-    }
-    function sanitizeElementsForEvidence(elements) {
-      return elements.map((element) => {
-        const label = (0, mobile_observation_js_1.safeMobileElementLabel)(element);
-        return {
-          ...element,
-          ...label ? { label } : { label: void 0 },
-          text: void 0
-        };
-      });
-    }
-    var MobileExplorationState = class {
-      /** screenId -> ScreenState (the mobile analog of routeState). */
-      screens = /* @__PURE__ */ new Map();
-      /** Observed directed transitions between screens. */
-      transitions = [];
-      /** Transition-announced screens that do not yet have a live observation. */
-      frontier = /* @__PURE__ */ new Map();
-      /** Safe navigation controls observed on each screen, keyed by stable identity. */
-      safeControlsByScreen = /* @__PURE__ */ new Map();
-      /** Screen-scoped coverage keys plus explicitly proven shared-navigation keys. */
-      attemptedSafeControlCoverageIdentities = /* @__PURE__ */ new Set();
-      successfulSafeControlAttemptCount = 0;
-      /** Repeated id-less structural navigation families, grouped by region. */
-      semanticNavigationFamilies = /* @__PURE__ */ new Map();
-      nextSemanticNavigationFamilyId = 1;
-      /** The screen-id of the most recently observed screen. */
-      currentScreenId = null;
-      /** Latest iteration recorded (drives stale detection + firstSeen stamps). */
-      iteration = 0;
-      /** Stale detector: progress mark (#screens + #total elements) at last advance. */
-      lastProgressMark = 0;
-      /** Consecutive iterations observed with no progress. */
-      staleIterations = 0;
-      staleThreshold;
-      constructor(options = {}) {
-        this.staleThreshold = typeof options.staleThreshold === "number" && options.staleThreshold > 0 ? Math.floor(options.staleThreshold) : DEFAULT_STALE_THRESHOLD;
-      }
-      // -------------------------------------------------------------------------
-      // Observation recording
-      // -------------------------------------------------------------------------
-      /**
-       * Returns true when `signal` identifies a screen this run has never observed
-       * before. Pure read — does not mutate state.
-       */
-      isNewScreen(signal) {
-        return !this.screens.has(deriveScreenId(signal));
-      }
-      /**
-       * Record an observation of `screen` at `iteration`. Creates a `ScreenState`
-       * on first sight (stamping `firstSeenIteration`), otherwise refreshes the
-       * stored element set (latest-wins, mirroring the web reducer's PAGE_CAPTURED
-       * element refresh). A driver observation already contains the structural UI
-       * tree, elements, screenshot association, and screen identity, so it is
-       * captured evidence immediately; the model's capture_screen call only adds
-       * a friendly name/type. Returns the resolved screen-id.
-       */
-      recordObservation(signal, screen, iteration) {
-        this.iteration = iteration;
-        const screenId = deriveScreenId(signal);
-        const evidenceElements = sanitizeElementsForEvidence(screen.elements);
-        const existing = this.screens.get(screenId);
-        if (existing) {
-          this.screens.set(screenId, {
-            ...existing,
-            elements: mergeObservedElements(existing.elements, evidenceElements)
-          });
-        } else {
-          this.screens.set(screenId, {
-            screenId,
-            firstSeenIteration: iteration,
-            elements: evidenceElements,
-            visited: true
-          });
-        }
-        this.frontier.delete(screenId);
-        const controls = this.safeControlsByScreen.get(screenId) ?? /* @__PURE__ */ new Map();
-        const semanticNavigationGroups = buildSemanticNavigationGroups(evidenceElements, screen.windowSize);
-        const semanticNavigationFamilyIds = /* @__PURE__ */ new Map();
-        for (const [groupKey, labels] of semanticNavigationGroups) {
-          semanticNavigationFamilyIds.set(groupKey, this.resolveSemanticNavigationFamilyId(groupKey, labels));
-        }
-        for (const element of evidenceElements) {
-          const candidate = classifySafeMobileNavigationControl(element);
-          if (!candidate)
-            continue;
-          const storedIdentity = storedMobileControlIdentity(candidate);
-          const semanticGroupKey = element.navigationProvenance ? `${element.navigationProvenance}:${mobileNavigationRegion(element, screen.windowSize)}` : "";
-          controls.set(storedIdentity, {
-            ...candidate,
-            identity: storedIdentity,
-            sharedCoverageIdentity: sharedMobileControlCoverageIdentity(element, candidate, semanticNavigationFamilyIds.get(semanticGroupKey))
-          });
-        }
-        if (controls.size > 0)
-          this.safeControlsByScreen.set(screenId, controls);
-        this.currentScreenId = screenId;
-        this.updateStaleProgress();
-        return screenId;
-      }
-      /**
-       * Back-compatible acknowledgement from capture_screen. Observation already
-       * marks structural evidence visited; this call only resolves a rare pending
-       * transition frontier and preserves callers that annotate explicitly.
-       */
-      markVisited(screenId) {
-        const state2 = this.screens.get(screenId);
-        if (state2 && !state2.visited) {
-          this.screens.set(screenId, { ...state2, visited: true });
-        }
-        this.frontier.delete(screenId);
-      }
-      /**
-       * Record a confirmed tap against a safe navigation candidate. Callers invoke
-       * this only after the driver reports success; recovery-unknown, stale-ref, and
-       * failed actions must remain on the breadth frontier.
-       */
-      noteControlAttempt(screenId, element) {
-        if (!screenId)
-          return false;
-        const candidate = classifySafeMobileNavigationControl(element);
-        const controls = this.safeControlsByScreen.get(screenId) ?? /* @__PURE__ */ new Map();
-        if (candidate) {
-          const storedIdentity = storedMobileControlIdentity(candidate);
-          const existing = controls.get(storedIdentity);
-          controls.set(storedIdentity, {
-            ...candidate,
-            identity: storedIdentity,
-            sharedCoverageIdentity: existing?.sharedCoverageIdentity ?? sharedMobileControlCoverageIdentity(element, candidate)
-          });
-          this.safeControlsByScreen.set(screenId, controls);
-        }
-        const tappedLabel = (0, mobile_observation_js_1.safeMobileElementLabel)(element)?.trim();
-        if (!tappedLabel)
-          return false;
-        const before = this.attemptedSafeControlCoverageIdentities.size;
-        const alias = semanticControlAlias(tappedLabel);
-        for (const control of controls.values()) {
-          if (semanticControlAlias(control.label) === alias) {
-            this.attemptedSafeControlCoverageIdentities.add(localControlCoverageIdentity(screenId, control.identity));
-            if (control.sharedCoverageIdentity) {
-              this.attemptedSafeControlCoverageIdentities.add(control.sharedCoverageIdentity);
-            }
-          }
-        }
-        if (this.attemptedSafeControlCoverageIdentities.size > before) {
-          this.successfulSafeControlAttemptCount += 1;
-          this.staleIterations = 0;
-          return true;
-        }
-        return false;
-      }
-      /** Attach a human-friendly name / coarse type to a screen (capture_screen). */
-      annotateScreen(screenId, annotation) {
-        const state2 = this.screens.get(screenId);
-        if (!state2)
-          return;
-        this.screens.set(screenId, {
-          ...state2,
-          screenName: annotation.screenName ?? state2.screenName,
-          screenType: annotation.screenType ?? state2.screenType
-        });
-      }
-      /** Attach structurally observed authentication provenance to a screen. */
-      setScreenAuthEvidence(screenId, evidence) {
-        const state2 = this.screens.get(screenId);
-        if (!state2)
-          return;
-        this.screens.set(screenId, {
-          ...state2,
-          requiresAuth: evidence.requiresAuth,
-          authProvenance: evidence.authProvenance,
-          sessionState: { ...evidence.sessionState }
-        });
-      }
-      /** Append a free-form observation note to a screen (observations tool). */
-      addScreenObservation(screenId, note) {
-        const state2 = this.screens.get(screenId);
-        if (!state2)
-          return;
-        const normalized = note.trim();
-        if (!normalized)
-          return;
-        const current = state2.observations ?? [];
-        if (current.some((existing) => existing.trim().toLowerCase() === normalized.toLowerCase())) {
-          return;
-        }
-        const observations = [...current, normalized].slice(-MAX_SCREEN_OBSERVATIONS);
-        this.screens.set(screenId, { ...state2, observations });
-      }
-      /**
-       * Record a directed transition between two screens. Both endpoints are
-       * ensured to exist on the frontier if not yet observed (mirrors the web
-       * reducer adding both ends of a TRANSITION_RECORDED to the frontier). The
-       * `toScreenId` becomes the current screen when the transition starts from the
-       * current screen.
-      */
-      recordTransition(transition) {
-        let recordedTransition = transition;
-        if (!transition.viaControlIdentity && transition.viaRef) {
-          const sourceElement = this.screens.get(transition.fromScreenId)?.elements.find((element) => element.ref === transition.viaRef);
-          if (sourceElement) {
-            recordedTransition = {
-              ...transition,
-              viaControlIdentity: (0, mobile_observation_js_1.stableParsedMobileElementIdentity)(sourceElement)
-            };
-          }
-        }
-        const alreadyRecorded = this.transitions.some((existing) => existing.fromScreenId === recordedTransition.fromScreenId && existing.toScreenId === recordedTransition.toScreenId && existing.action === recordedTransition.action);
-        if (!alreadyRecorded) {
-          this.transitions.push(recordedTransition);
-        }
-        for (const endpointId of [transition.fromScreenId, transition.toScreenId]) {
-          if (!this.screens.has(endpointId) && !this.frontier.has(endpointId)) {
-            this.frontier.set(endpointId, {
-              screenId: endpointId,
-              source: "transition",
-              discoveredAtIteration: this.iteration
-            });
-          }
-        }
-        if (transition.fromScreenId === this.currentScreenId) {
-          this.currentScreenId = transition.toScreenId;
-        }
-      }
-      // -------------------------------------------------------------------------
-      // Selectors
-      // -------------------------------------------------------------------------
-      /** The current screen-id (most recently observed), or null before any observation. */
-      getCurrentScreenId() {
-        return this.currentScreenId;
-      }
-      /** ScreenState for `screenId`, if known. */
-      getScreen(screenId) {
-        return this.screens.get(screenId);
-      }
-      /** Number of distinct screens observed this run. */
-      getScreenCount() {
-        return this.screens.size;
-      }
-      /** Number of screens backed by a live structural driver observation. */
-      getVisitedScreenCount() {
-        let total = 0;
-        for (const state2 of this.screens.values()) {
-          if (state2.visited)
-            total += 1;
-        }
-        return total;
-      }
-      /** Total elements observed across all known screens (latest snapshot each). */
-      getTotalElementCount() {
-        let total = 0;
-        for (const state2 of this.screens.values()) {
-          total += state2.elements.length;
-        }
-        return total;
-      }
-      /**
-       * Frontier screen-ids ranked by recency (most recently discovered first),
-       * excluding any screen already visited. Mirrors the web `getRankedFrontier`
-       * intent (filter visited, rank by recency) — without URL prefix similarity,
-       * which has no mobile analog.
-       */
-      getFrontier() {
-        return [...this.frontier.values()].filter((item) => {
-          const state2 = this.screens.get(item.screenId);
-          return !state2 || !state2.visited;
-        }).sort((a, b) => b.discoveredAtIteration - a.discoveredAtIteration).map((item) => item.screenId);
-      }
-      /** Safe navigation candidates not yet attempted, deduped across shared chrome. */
-      getUnexploredSafeNavigationCandidates() {
-        const authenticatedProductObserved = [...this.screens.values()].some((screen) => screen.requiresAuth === true);
-        const candidates = [];
-        for (const [screenId, controls] of this.safeControlsByScreen) {
-          const origin = this.screens.get(screenId);
-          const originIsConfirmedPublicEntry = origin?.authProvenance === "public" || !origin?.authProvenance && origin?.requiresAuth !== true && /^(?:AUTH|LANDING)$/i.test(origin?.screenType ?? "");
-          if (authenticatedProductObserved && originIsConfirmedPublicEntry)
-            continue;
-          for (const control of controls.values()) {
-            const alias = semanticControlAlias(control.label);
-            const coverageIdentity = control.sharedCoverageIdentity ?? localControlCoverageIdentity(screenId, control.identity);
-            if (this.attemptedSafeControlCoverageIdentities.has(coverageIdentity) || this.attemptedSafeControlCoverageIdentities.has(localControlCoverageIdentity(screenId, control.identity)))
-              continue;
-            const existing = candidates.find((candidate) => candidate.identity === coverageIdentity || candidate.alias === alias && candidate.screenIds.has(screenId));
-            if (existing) {
-              existing.screenIds.add(screenId);
-            } else {
-              candidates.push({
-                identity: coverageIdentity,
-                label: control.label,
-                kind: control.kind,
-                alias,
-                screenIds: /* @__PURE__ */ new Set([screenId])
-              });
-            }
-          }
-        }
-        return candidates.map((candidate) => ({
-          identity: candidate.identity,
-          label: candidate.label,
-          kind: candidate.kind,
-          screenIds: [...candidate.screenIds]
-        })).sort((a, b) => {
-          const aCurrent = this.currentScreenId !== null && a.screenIds.includes(this.currentScreenId);
-          const bCurrent = this.currentScreenId !== null && b.screenIds.includes(this.currentScreenId);
-          if (aCurrent !== bCurrent)
-            return aCurrent ? -1 : 1;
-          return b.screenIds.length - a.screenIds.length;
-        });
-      }
-      /** Harness-owned survey completion floor, independent of model assertions. */
-      getSurveyBreadthCoverage() {
-        const unvisitedScreenIds = this.getFrontier();
-        const unexploredControls = this.getUnexploredSafeNavigationCandidates();
-        const complete = unvisitedScreenIds.length === 0 && unexploredControls.length === 0;
-        const missing = [];
-        if (unvisitedScreenIds.length > 0) {
-          missing.push(`${unvisitedScreenIds.length} uncaptured screen(s)`);
-        }
-        if (unexploredControls.length > 0) {
-          missing.push(`${unexploredControls.length} safe navigation control(s)`);
-        }
-        return {
-          required: true,
-          complete,
-          unvisitedScreenIds,
-          unexploredControls,
-          attemptedControlCount: this.successfulSafeControlAttemptCount,
-          ...missing.length > 0 ? { reason: `Missing ${missing.join(" and ")}.` } : {}
-        };
-      }
-      /**
-       * Monotonic structural progress token for adaptive survey leases. Frontier
-       * cardinality alone is insufficient: attempting control A can reveal control
-       * B and leave the remaining count unchanged even though real work happened.
-       */
-      getSurveyBreadthProgressMark() {
-        const discoveredControlIdentities = /* @__PURE__ */ new Set();
-        for (const [screenId, controls] of this.safeControlsByScreen) {
-          for (const control of controls.values()) {
-            discoveredControlIdentities.add(control.sharedCoverageIdentity ?? localControlCoverageIdentity(screenId, control.identity));
-          }
-        }
-        return [
-          `screens:${this.screens.size}`,
-          `attempts:${this.successfulSafeControlAttemptCount}`,
-          `controls:${discoveredControlIdentities.size}`,
-          `transitions:${this.transitions.length}`
-        ].join("|");
-      }
-      resolveSemanticNavigationFamilyId(groupKey, labels) {
-        const families = this.semanticNavigationFamilies.get(groupKey) ?? [];
-        let best;
-        let bestIntersection = 0;
-        for (const family of families) {
-          let intersection = 0;
-          for (const label of labels) {
-            if (family.labels.has(label))
-              intersection += 1;
-          }
-          const overlap = intersection / Math.min(labels.size, family.labels.size);
-          if (intersection >= 2 && overlap >= 0.6 && intersection > bestIntersection) {
-            best = family;
-            bestIntersection = intersection;
-          }
-        }
-        if (best) {
-          for (const label of labels)
-            best.labels.add(label);
-          return best.id;
-        }
-        const created = {
-          id: `semantic-nav-family-${this.nextSemanticNavigationFamilyId++}`,
-          labels: new Set(labels)
-        };
-        families.push(created);
-        this.semanticNavigationFamilies.set(groupKey, families);
-        return created.id;
-      }
-      /** Observed transitions (defensive copy). */
-      getTransitions() {
-        return [...this.transitions];
-      }
-      // -------------------------------------------------------------------------
-      // Stale-progress detection (ported semantics from the web stale guard)
-      // -------------------------------------------------------------------------
-      /**
-       * Progress mark: distinct screens weighted heavily, plus total elements seen.
-       * A run advances this mark whenever it finds a new screen OR new elements;
-       * the stale detector triggers when the mark stops advancing for
-       * `staleThreshold` consecutive iterations.
-       */
-      getProgressMark() {
-        return this.screens.size * 1e3 + this.transitions.length * 100 + this.successfulSafeControlAttemptCount * 10 + this.getTotalElementCount();
-      }
-      updateStaleProgress() {
-        const mark = this.getProgressMark();
-        if (mark > this.lastProgressMark) {
-          this.lastProgressMark = mark;
-          this.staleIterations = 0;
-        } else {
-          this.staleIterations += 1;
-        }
-      }
-      /** Consecutive no-progress iterations observed so far. */
-      getStaleIterations() {
-        return this.staleIterations;
-      }
-      /**
-       * True when the run has gone `staleThreshold` consecutive iterations with no
-       * new screen and no new element — the signal the explorer uses to nudge or
-       * finish (mirrors the web explorer's stale guard).
-       */
-      isStaleProgress() {
-        return this.staleIterations >= this.staleThreshold;
-      }
-      // -------------------------------------------------------------------------
-      // Planner evidence export
-      // -------------------------------------------------------------------------
-      /**
-       * Snapshot the screen-graph as a plain object (frozen mobile-types
-       * `MobileScreenGraph`). Defensive copies so callers cannot mutate internal
-       * state.
-       */
-      toScreenGraph() {
-        const screens = /* @__PURE__ */ new Map();
-        for (const [id, state2] of this.screens) {
-          screens.set(id, {
-            ...state2,
-            elements: [...state2.elements],
-            observations: state2.observations ? [...state2.observations] : void 0,
-            sessionState: state2.sessionState ? { ...state2.sessionState } : void 0
-          });
-        }
-        return {
-          screens,
-          transitions: this.transitions.map((t) => ({
-            fromScreenId: t.fromScreenId,
-            toScreenId: t.toScreenId,
-            viaRef: t.viaRef,
-            viaControlIdentity: t.viaControlIdentity,
-            action: t.action
-          }))
-        };
-      }
-      /**
-       * Build the planner evidence shape: one `CollectedPageData` per screen, with
-       * the screen-id carried in BOTH `route` (the on-the-wire positional field the
-       * server keys screenshots by) AND the explicit `screenId` field (per the
-       * Phase-0 `CollectedPageData.screenId` contract). `elements` are mapped from
-       * the screen's parsed actionable elements into the platform-neutral
-       * `CollectedPageElement[]` shape the server persists as SiteElements — without
-       * this, mobile screens land with zero elements (coverage always 0%, no element
-       * intelligence). `triggersNavigation` is derived from the durable source
-       * element identity captured when the transition happened (with ref-only
-       * fallback for legacy transitions). Insertion order matches first-seen order.
-       */
-      buildInMemoryScreenMap() {
-        const pages = [];
-        const ordered = [...this.screens.values()].sort((a, b) => a.firstSeenIteration - b.firstSeenIteration);
-        const navRefsByScreen = /* @__PURE__ */ new Map();
-        const navIdentitiesByScreen = /* @__PURE__ */ new Map();
-        for (const transition of this.transitions) {
-          if (transition.viaControlIdentity) {
-            const set = navIdentitiesByScreen.get(transition.fromScreenId) ?? /* @__PURE__ */ new Set();
-            set.add(transition.viaControlIdentity);
-            navIdentitiesByScreen.set(transition.fromScreenId, set);
-          } else if (transition.viaRef) {
-            const set = navRefsByScreen.get(transition.fromScreenId) ?? /* @__PURE__ */ new Set();
-            set.add(transition.viaRef);
-            navRefsByScreen.set(transition.fromScreenId, set);
-          }
-        }
-        for (const state2 of ordered) {
-          const page = {
-            route: state2.screenId,
-            screenId: state2.screenId,
-            pageType: state2.screenType ?? "UNKNOWN",
-            elements: (0, mobile_observation_js_1.buildCollectedElementsForScreen)(state2.elements, {
-              navigationRefs: navRefsByScreen.get(state2.screenId),
-              navigationIdentities: navIdentitiesByScreen.get(state2.screenId)
-            }),
-            requiresAuth: state2.requiresAuth ?? false
-          };
-          if (state2.sessionState) {
-            page.sessionState = { ...state2.sessionState };
-          }
-          if (state2.screenName) {
-            page.title = state2.screenName;
-          }
-          if (state2.observations && state2.observations.length > 0) {
-            page.observations = state2.observations.map((note) => ({
-              action: "observe",
-              outcome: note,
-              outcomeType: "SUCCESS"
-            }));
-          }
-          pages.push(page);
-        }
-        return pages;
-      }
-      /** Alias for `buildInMemoryScreenMap()` — name parity with the planner-evidence call site. */
-      toScreenMap() {
-        return this.buildInMemoryScreenMap();
-      }
-    };
-    exports2.MobileExplorationState = MobileExplorationState;
-  }
-});
-
 // ../runner-core/dist/services/mobile/mobile-discovery-agent.js
 var require_mobile_discovery_agent = __commonJS({
   "../runner-core/dist/services/mobile/mobile-discovery-agent.js"(exports2) {
@@ -321588,6 +322087,7 @@ var require_mobile_discovery_agent = __commonJS({
     var mobile_exploration_state_js_1 = require_mobile_exploration_state();
     var mobile_discovery_auth_js_1 = require_mobile_discovery_auth();
     var mobile_driver_errors_js_1 = require_mobile_driver_errors();
+    var mobile_session_keepalive_js_1 = require_mobile_session_keepalive();
     var shared_1 = (init_dist(), __toCommonJS(dist_exports));
     var discover_planner_js_1 = require_discover_planner();
     function checkpointErrorMessage(err) {
@@ -321870,7 +322370,7 @@ Explore complete: ${explore.exploreStats.pagesDiscovered} screens, ${explore.exp
           };
         }
         if (isSurvey && explore.authCoverage && !explore.authCoverage.complete) {
-          throw new Error("Mobile survey authentication coverage is incomplete; planning was skipped. " + (explore.authCoverage.reason ?? "No authenticated product screen was proven."));
+          log2("Mobile survey continuing to planning with incomplete authenticated coverage: " + (explore.authCoverage.reason ?? "No authenticated product screen was proven."));
         }
         if (isSurvey && explore.breadthCoverage && !explore.breadthCoverage.complete) {
           log2("Mobile survey continuing to planning with residual breadth gaps: " + (explore.breadthCoverage.reason ?? "Unvisited screens or safe navigation controls remain."));
@@ -321888,7 +322388,7 @@ Explore complete: ${explore.exploreStats.pagesDiscovered} screens, ${explore.exp
         const graph = state2.toScreenGraph();
         const screenMap = state2.buildInMemoryScreenMap();
         const testBudget = (0, discover_planner_js_1.computeTestBudget)(explore.exploreStats.pagesVisited, ctx.focusAreas);
-        const planResult = await runPlan({
+        const planResult = await (0, mobile_session_keepalive_js_1.withMobileSessionKeepAlive)(driver, () => runPlan({
           graph,
           mode,
           projectId: ctx.projectId,
@@ -321912,7 +322412,7 @@ Explore complete: ${explore.exploreStats.pagesDiscovered} screens, ${explore.exp
         }, {
           modelOverride: ctx.planModel ?? ctx.generateModel,
           onAICall
-        });
+        }));
         logs2.push(...planResult.logs);
         log2(`
 Plan: ${planResult.scenarios.length} scenarios, ${planResult.featureGroups.length} feature groups (budget: ${testBudget})`);
@@ -322131,6 +322631,9 @@ Fatal error: ${msg}`);
       if (explore.breadthCoverage && !explore.breadthCoverage.complete) {
         warnings.push("Discovery retained the captured mobile screen graph with residual navigation gaps: " + (explore.breadthCoverage.reason ?? "some observed controls could not be revisited."));
       }
+      if (explore.authCoverage && !explore.authCoverage.complete) {
+        warnings.push("Discovery retained the captured mobile screen graph with incomplete authenticated coverage: " + (explore.authCoverage.reason ?? "no authenticated product screen was proven."));
+      }
       if (explore.truncated) {
         const reasonLabel = explore.truncatedReason === "rate_limit" ? "AI rate-limit" : explore.truncatedReason === "timeout" ? "AI timeout" : "AI error";
         warnings.push(`Discovery may be incomplete: exploration aborted by ${reasonLabel}. Re-run after the limit clears for a complete screen graph.`);
@@ -322767,6 +323270,7 @@ Health: ${surveyHealth.totalIssues} issue(s) - ${surveyHealth.consoleErrors.leng
           if (surveyAuthRecipe) {
             logs2.push(`Auth-prologue: captured + verified login recipe ${surveyAuthRecipe.recipeHash} during survey \u2014 persisting for reuse on later runs`);
           }
+          const plannerFailedError = planResult.plannerFailed ? `Survey planning failed (${planResult.plannerFailureKind ?? "unknown"}): ${planResult.fallbackReason ?? "planner did not produce a usable plan"}. Explore evidence was saved; re-run the survey to retry planning.` : void 0;
           return {
             observedOrigins: mergeObservedOrigins(exploreResult.observedOrigins, loginObservedOrigins),
             resolvedAppOrigin: surveyAuthRecipe?.appOrigin ?? void 0,
@@ -322782,7 +323286,8 @@ Health: ${surveyHealth.totalIssues} issue(s) - ${surveyHealth.consoleErrors.leng
             exploreTruncatedReason: exploreResult.truncatedReason,
             fallbackUsed: planResult.fallbackUsed ?? false,
             fallbackReason: planResult.fallbackReason,
-            featureGroups,
+            error: plannerFailedError,
+            featureGroups: plannerFailedError ? void 0 : featureGroups,
             apiCalls: discoveryApiCalls.length > 0 ? discoveryApiCalls : void 0,
             healthObservations: surveyHealth,
             exploreFinalMessages: exploreResult.finalMessages,
@@ -336640,7 +337145,7 @@ var require_package4 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@validate.qa/runner",
-      version: "1.0.38",
+      version: "1.0.40",
       description: "validate local test runner - execute Playwright tests on your machine, connected to validate.qa cloud.",
       bin: {
         "validate-runner": "dist/cli.js"
@@ -339895,8 +340400,9 @@ async function activateTargetApp(sessionId, platform3, appId) {
   const args = platform3 === "IOS" ? [{ bundleId: appId }] : [{ appId }];
   await executeMobileScript(sessionId, "mobile: activateApp", args);
 }
+var APP_TERMINATE_TIMEOUT_MS = 5e3;
 async function terminateTargetApp(sessionId, platform3, appId) {
-  const args = platform3 === "IOS" ? [{ bundleId: appId }] : [{ appId }];
+  const args = platform3 === "IOS" ? [{ bundleId: appId, timeout: APP_TERMINATE_TIMEOUT_MS }] : [{ appId, timeout: APP_TERMINATE_TIMEOUT_MS }];
   await executeMobileScript(sessionId, "mobile: terminateApp", args);
 }
 async function freshLaunchTargetApp(sessionId, platform3, appId, log2) {
@@ -342907,7 +343413,11 @@ var MobileBridgeDriver = class {
   async relaunch() {
     await this.withSessionRecovery("app relaunch", async () => {
       const args = this.appLifecycleArgs();
-      await this.executeScript("mobile: terminateApp", [args]);
+      try {
+        await this.executeScript("mobile: terminateApp", [{ ...args, timeout: 5e3 }]);
+      } catch (err) {
+        if (isRecoverableAppiumSessionFailure(err)) throw err;
+      }
       await this.executeScript("mobile: activateApp", [args]);
       try {
         await waitForColdBootSettle(this.sessionPath);
@@ -345452,10 +345962,22 @@ ${finalVerifyResult.logs ?? ""}`;
               onPlanReady
             });
           } finally {
+            const TEARDOWN_STEP_TIMEOUT = /* @__PURE__ */ Symbol("vqa-teardown-timeout");
+            const timeboxed = async (step) => Promise.race([
+              step,
+              new Promise((resolve2) => {
+                const t = setTimeout(() => resolve2(TEARDOWN_STEP_TIMEOUT), 45e3);
+                t.unref?.();
+              })
+            ]);
             const activeCapture = capture;
             if (activeCapture) {
               try {
-                const apiCalls = await activeCapture.stop();
+                const stopped = await timeboxed(activeCapture.stop());
+                if (stopped === TEARDOWN_STEP_TIMEOUT) {
+                  throw new Error("capture stop timed out after 45s \u2014 continuing teardown without apiCalls");
+                }
+                const apiCalls = stopped;
                 const captureHealth = activeCapture.health();
                 if (discoveryResult) {
                   discoveryResult.apiCalls = apiCalls.length ? attachMobileDiscoveryNetworkContext(apiCalls, discoveryResult, session?.appId ?? mobileTarget.appId) : void 0;
@@ -345476,7 +345998,7 @@ ${finalVerifyResult.logs ?? ""}`;
             if (session) {
               detachMirrorSession(session.deviceId);
               try {
-                await session.stop();
+                await timeboxed(session.stop());
               } catch {
               }
             }