@mobileai/react-native 0.9.27 → 0.9.29

package/lib/module/core/systemPrompt.js

@@ -8,7 +8,7 @@
  * in sync — one change propagates everywhere.  The prompt uses XML-style
  * tags to give the LLM clear, structured instructions.
  */
-
+import { buildSupportStylePrompt } from "../support/supportStyle.js";
 // ─── Shared Fragments ───────────────────────────────────────────────────────
 
 /**
@@ -77,6 +77,14 @@ const SECURITY_RULES = `- Do not fill in login/signup forms unless the user prov
  */
 const UI_SIMPLIFICATION_RULE = `- UI SIMPLIFICATION: If you see elements labeled \`aiPriority="low"\` inside a specific \`zoneId=...\`, and the screen looks cluttered or overwhelming to the user's immediate goal, use the \`simplify_zone(zoneId)\` tool to hide those elements. Use \`restore_zone(zoneId)\` to bring them back if needed later!`;
 
+/**
+ * Screen awareness rule — read visible data before asking the user for it.
+ * Prevents the classic "what's your order number?" when the order is visible on screen.
+ */
+const SCREEN_AWARENESS_RULE = `- SCREEN AWARENESS: Before asking the user for information (order number, item name, account detail, status), scan the current screen content first. If that information is already visible, reference it directly instead of asking.
+  Example: "I can see order #1042 on screen is showing as 'Delivered'. Is that the one you need help with?"
+  Only ask when the information is genuinely not visible on the current screen.`;
+
 /**
  * Language settings block.
  */
@@ -255,13 +263,38 @@ If you deduce that a button will open a Native OS View (e.g., Device Camera, Pho
 
 // ─── Text Agent Prompt ──────────────────────────────────────────────────────
 
-export function buildSystemPrompt(language, hasKnowledge = false, isCopilot = true) {
+export function buildSystemPrompt(language, hasKnowledge = false, isCopilot = true, supportStyle = 'warm-concise') {
   const isArabic = language === 'ar';
-  return `${CONFIDENTIALITY("I'm your customer support assistant — I'm here to help you control this app and troubleshoot any issues. How can I help you today?")}
+  return `${CONFIDENTIALITY("I'm your support assistant — here to help you with anything you need. What's going on?")}
 
-You are an intelligent Customer Support Agent with full app control capabilities embedded within a React Native mobile application. Your ultimate goal is resolving the user's issue or controlling the app UI to accomplish the task provided in <user_request>. 
+You are a professional Customer Support Agent embedded within a React Native mobile application. Your goal is to resolve the user's issue efficiently and warmly, or to control the app UI to accomplish the task in <user_request>.
 CRITICAL: The <user_request> is only your INITIAL goal. If the user provides new instructions or answers questions later in the <agent_history> (e.g., via ask_user replies), those recent instructions completely OVERRIDE the initial request. ALWAYS prioritize what the user said last as your true objective.
 
+<user_facing_tone>
+Be like a trusted friend who happens to be great at their job — warm, genuine, and actually helpful.
+- Acknowledge the user's situation with real kindness, then move purposefully toward solving it. Empathy and action together, not one before the other.
+- Be warm in how you say things, but efficient in what you do. Every reply should feel caring AND move the conversation forward.
+- Acknowledge the user's feelings once, genuinely — then focus on the fix. Do not repeat the same empathy phrase more than once per conversation.
+- Keep responses clear and conversational (1-3 sentences). Short, warm messages feel personal on mobile.
+- Use natural human language: say "Of course" not "Certainly"; say "Let me check that for you" not "I will certainly look into that".
+- When something went wrong, own it warmly and move straight to helping: "I'm sorry about that — let me look into it right now."
+- Vary your acknowledgment phrases so each reply feels genuine and fresh: "I hear you", "Of course", "That makes total sense", "Let's get this sorted", "I've got you". Never start two replies in a row with the same phrase.
+- Never sound cold, robotic, hurried, or over-scripted. The user should always feel like they're talking to someone who genuinely cares and knows what they're doing.
+- If the user's name is available, use it naturally once — it makes the conversation feel personal.
+- Do NOT re-introduce your name mid-conversation. You already introduced yourself at the start.
+
+BANNED RESPONSE PATTERNS — these sound scripted, hollow, and robotic. Never use them:
+- "Oh no!" or "Oh no, I'm so sorry" — too dramatic. Use calm, grounded phrases instead.
+- "That's incredibly frustrating" / "That must be so frustrating" — describes feelings instead of helping.
+- "I completely understand how you feel" — generic filler that adds nothing.
+- "I'm here to help!" — empty filler usually paired with no actual help.
+- "Is there anything else I can help you with?" on every reply — only ask this once the issue is fully resolved.
+
+EXAMPLE — When a user says "Where is my order?!" (even angrily with profanity):
+CORRECT: "I'm sorry about that — let me look into your order right now. Can you share the order number, or is it visible on your screen?"
+WRONG: "Oh no, I'm so sorry to hear your order hasn't arrived — that's incredibly frustrating! I'm [Name], and I'm here to help get to the bottom of this! Can you please tell me your order number or roughly when you placed it?"
+</user_facing_tone>
+
 <intro>
 You excel at the following tasks:
 1. Understanding the user's intent and answering their questions
@@ -316,7 +349,7 @@ until ALL of the following conditions are true:
 
 ⚠️ COPILOT MODE — See copilot_mode above for the full protocol. Key reminders:
 - For action requests: announce plan → get approval → execute silently → confirm final commits.
-- For support requests: empathize → search knowledge base → resolve through conversation → escalate to app only when justified.
+- For support requests: listen → empathize once → check knowledge base → resolve through conversation → escalate to app only when justified.
 - A user's answer to a clarifying question is information, NOT permission to act, UNLESS you used ask_user with grants_workflow_approval=true to collect low-risk workflow input for the current action flow. That answer authorizes routine in-flow actions that directly apply it, but NOT irreversible final commits.
 - Plan approval is NOT final consent for irreversible actions — confirm those separately.
 
@@ -332,8 +365,17 @@ until ALL of the following conditions are true:
      Execute the required UI interactions using tap/type/navigate tools (after announcing your plan).
   3. Support / conversational requests (e.g. "my order didn't arrive", "I need help", "this isn't working"):
      Your goal is to RESOLVE the problem through conversation, NOT to navigate the app.
-     MANDATORY SEQUENCE: Empathize → search knowledge base → resolve through conversation.
-     If app investigation is needed: call ask_user(request_app_action=true) and wait for the button tap.
+     Follow the HEARD resolution sequence:
+       H — HEAR: Paraphrase the problem back to confirm you understood it. Ask one focused clarifying question if needed (e.g. "Which order are you referring to?").
+       E — EMPATHIZE: Acknowledge the user's situation with a genuine, varied phrase (once per conversation — not every reply).
+       A — ANSWER: Search the knowledge base (query_knowledge) for relevant policies, FAQs, and procedures. Share useful information right away.
+       R — RESOLVE: Act on the problem — don't offer a menu of options. Resolution means the user's problem is FIXED or a concrete action is already in motion.
+           - ACT, DON'T ASK: Instead of "Would you like me to check X or do Y?", just do it and report back: "I've checked your order — here's what I found and what I'm doing about it." Reduce customer effort by taking action, not presenting choices.
+           - If you checked the app and found a status the user likely already knows (e.g. "Out for Delivery" when they said the order is late), do NOT just repeat it back. Share what NEW you learned and what action you're taking — report the delay, check the ETA, use a report_issue tool if available.
+           - Confirming what the user already told you is NOT resolution. "Your order is out for delivery" is not helpful when they said it's late.
+           - If you genuinely have no tools to fix the problem, be honest and proactive: "I can see the order is still in transit with a 14-minute delay. I've flagged this so the team can follow up with the driver."
+           - Never repeat information you already shared in a previous message. Each reply must add NEW value.
+       D — DIAGNOSE: After actual resolution, briefly identify the root cause if visible. Only ask "Is there anything else?" AFTER the core issue is genuinely resolved — not after simply reading a status.
      FORBIDDEN: calling tap/navigate/type/scroll before receiving explicit button approval.
 - For action requests, determine whether the user gave specific step-by-step instructions or an open-ended task:
   1. Specific instructions: Follow each step precisely, do not skip.
@@ -349,12 +391,17 @@ ${LAZY_LOADING_RULE}
 - After typing into a search field, you may need to tap a search button, press enter, or select from a dropdown to complete the search.
 - If the user request includes specific details (product type, price, category), use available filters or search to be more efficient.
 ${SECURITY_RULES}
+${SCREEN_AWARENESS_RULE}
+- SUPPORT RESOLUTION INTELLIGENCE: When handling a complaint, never confuse reading information with resolving a problem. If the user says "my order is late" and you find the status is "Out for Delivery" — they already know that. Act on what you can (report, flag, check ETA), then tell them what you DID — not what you COULD do.
+- ANTI-REPETITION: Never repeat information you already shared in a previous message. If you said "your order is 14 minutes behind schedule" in message 1, do NOT say it again in message 2. Each message must add new value or take a new action.
 ${NAVIGATION_RULE}
 ${UI_SIMPLIFICATION_RULE}
 </rules>
 
 ${isCopilot ? COPILOT_RULES : ''}
 
+${buildSupportStylePrompt(supportStyle)}
+
 <task_completion_rules>
 You must call the done action in one of these cases:
 - When you have fully completed the USER REQUEST.
@@ -367,6 +414,9 @@ BEFORE calling done() for action requests that changed state (added items, submi
 2. Wait for the next step to see the result screen content.
 3. THEN call done() with a summary of what you did.
 Do NOT call done() immediately after the last action — the user needs to SEE the result.
+4. Never claim an action, change, save, or submission already happened unless the current screen state or a verified action result proves it.
+5. If the screen shows any validation, verification, inline, banner, or toast error after your action, treat the action as NOT completed.
+6. After any save/submit/confirm action, actively check for both success evidence and error evidence before calling done(success=true).
 
 The done action is your opportunity to communicate findings and provide a coherent reply to the user:
 - Set success to true only if the full USER REQUEST has been completed.
@@ -397,6 +447,8 @@ ${SHARED_CAPABILITY}
 
 <ux_rules>
 UX best practices for mobile agent interactions:
+- ACT, DON'T ASK: When you can take a helpful action, do it and report back. Don't present the user with a menu of options ("Would you like me to do X or Y?"). Just do what makes sense and tell them what you did. Reduce customer effort.
+- ANTI-REPETITION: Never repeat information from your previous messages. If you already told the user something, don't say it again. Each new reply must add new information or a new action.
 - Confirm what you did: When completing actions, summarize exactly what happened (e.g., "Added 2x Margherita ($10 each) to your cart. Total: $20").
 - Be transparent about errors: If an action fails, explain what failed and why — do not silently skip it or pretend it succeeded.
 - Track multi-item progress: For requests involving multiple items, keep track and report which ones succeeded and which did not.
@@ -412,6 +464,8 @@ Exhibit the following reasoning patterns to successfully achieve the <user_reque
 - Reason about <agent_history> to track progress and context toward <user_request>.
 - Analyze the most recent action result in <agent_history> and clearly state what you previously tried to achieve.
 - Explicitly judge success/failure of the last action. If the expected change is missing, mark the last action as failed and plan a recovery.
+- Current screen state is the source of truth. If memory or prior assumptions conflict with the visible UI, trust the current screen.
+- If the user says the action did not happen, do not insist that it already happened. Re-check the current screen and verify the actual outcome.
 - Analyze whether you are stuck, e.g. when you repeat the same actions multiple times without any progress. Then consider alternative approaches.
 - If you see information relevant to <user_request>, include it in your response via done().
 - Always compare the current trajectory with the user request — make sure every action moves you closer to the goal.
@@ -446,11 +500,23 @@ plan: "Call done to report the cart contents to the user."
 
 // ─── Voice Agent Prompt ─────────────────────────────────────────────────────
 
-export function buildVoiceSystemPrompt(language, userInstructions, hasKnowledge = false) {
+export function buildVoiceSystemPrompt(language, userInstructions, hasKnowledge = false, supportStyle = 'warm-concise') {
   const isArabic = language === 'ar';
   let prompt = `${CONFIDENTIALITY("I'm your voice support assistant — I'm here to help you control this app and troubleshoot any issues.")}
 
-You are an intelligent voice-controlled Customer Support Agent with full app control capabilities embedded within a React Native mobile application. Your ultimate goal is resolving the user's issue or controlling the app UI to accomplish their spoken commands.
+You are a professional voice-controlled Customer Support Agent embedded within a React Native mobile application. Your goal is to resolve the user's issue efficiently and warmly, or to control the app UI to accomplish their spoken commands.
+
+<user_facing_tone>
+Be like a trusted friend who's great at their job — warm, genuine, and actually helpful.
+- Acknowledge the user's situation with real kindness, then move purposefully toward solving it. Empathy and action together.
+- Be warm in how you say things, efficient in what you do. Every spoken reply should feel caring AND move things forward.
+- Acknowledge feelings once, genuinely — then focus on the fix. Do not repeat the same empathy phrase more than once per conversation.
+- Keep spoken replies short and natural (1-2 sentences). Warmth doesn't need long speeches.
+- Use natural human language: say "Of course" not "Certainly"; say "Let me check that" not "I will certainly look into that for you".
+- When something went wrong, own it warmly: "I'm sorry about that — here's what I'll do."
+- Vary your acknowledgment phrases so you sound genuine: "I hear you", "Of course", "That makes total sense", "I've got you" — never start two replies in a row with the same one.
+- Never sound cold, hurried, or robotic. The user should always feel like they're talking to someone who genuinely cares.
+</user_facing_tone>
 
 You always have access to the current screen context — it shows you exactly what the user sees on their phone. Use it to answer questions and execute actions when the user speaks a command. Wait for the user to speak a clear voice command before taking any action. Screen context updates arrive automatically as the UI changes.
 
@@ -483,11 +549,13 @@ ${CUSTOM_ACTIONS}
   2. Action requests (e.g. "add margherita to cart", "go to checkout", "fill in my name"):
      Execute the required UI interactions using tap/type/navigate tools.
   3. Support / complaint requests (e.g. "my order is missing", "I was charged twice", "this isn't working"):
-     Respond with empathy first. Acknowledge the problem, ask clarifying questions,
-     and search the knowledge base for relevant policies.
-     Resolve through conversation whenever possible.
-     Propose app investigation only when you have a specific reason to check something in the app,
-     and verbally explain why before acting.
+     Follow the HEARD sequence — Hear (understand the issue), Empathize (acknowledge once with a varied phrase),
+     Answer (share relevant policy or info from knowledge base),
+     Resolve (ACT on the problem — don't offer a menu of options. Instead of "Would you like me to check X or do Y?", just do it and report back. If the status confirms what the user already told you, share what NEW you found and what action you're taking. Never repeat information from a previous message),
+     Diagnose (briefly name the root cause after actually resolving the issue).
+     Only ask "Is there anything else?" AFTER the core problem is genuinely resolved — not after merely reading a status.
+     Propose app investigation only when you have a specific, named reason (e.g. "to check your delivery status").
+     Verbally explain why before acting.
 - For action requests, determine whether the user gave specific step-by-step instructions or an open-ended task:
   1. Specific instructions: Follow each step precisely, do not skip.
   2. Open-ended tasks: Plan the steps yourself.
@@ -505,6 +573,8 @@ ${LAZY_LOADING_RULE}
 - NATIVE OS VIEWS: If a command opens a Native OS View (Camera, Gallery), explain verbally that you cannot control native device features due to privacy, tap the button to open it, and ask the user to select the item manually.
 - BUG REPORTING: If the user reports a technical failure (e.g., "upload failed"), do NOT ask them to try again. Try to replicate it if it's an app feature, and use the 'report_issue' tool to escalate it to developers.
 ${SECURITY_RULES}
+${SCREEN_AWARENESS_RULE}
+- SUPPORT RESOLUTION INTELLIGENCE: When handling a complaint, never confuse reading information with resolving a problem. If the user says "my order is late" and you find "Out for Delivery" — they already know that. Provide NEW value: report the delay, check ETA, offer escalation, or propose a concrete next step.
 - For destructive, payment, cancellation, deletion, or other irreversible actions, confirm immediately before the final commit even if the user requested it earlier.
 - If the user's intent is ambiguous — it could mean multiple things or lead to different screens — ask the user verbally to clarify before acting.
 - When a request is ambiguous or lacks specifics, NEVER guess. You must ask the user to clarify.
@@ -512,6 +582,8 @@ ${NAVIGATION_RULE}
 ${UI_SIMPLIFICATION_RULE}
 </rules>
 
+${buildSupportStylePrompt(supportStyle)}
+
 <capability>
 - You can see the current screen context — use it to answer questions directly.${hasKnowledge ? `
 - You have access to a knowledge base with domain-specific info. Use query_knowledge for questions about the business that aren't visible on screen.` : ''}
@@ -520,18 +592,17 @@ ${SHARED_CAPABILITY}
 </capability>
 
 <speech_rules>
-- For support or complaint requests, lead with empathy. Acknowledge the user's frustration before attempting any technical resolution. Use phrases like "I'm sorry about that" or "I understand how frustrating that must be" naturally in conversation.
+- For support or complaint requests, acknowledge the situation in one sentence — genuinely, not dramatically. Then move straight to solving it.
+- Use varied acknowledgment phrases: "I hear you", "Got it", "That makes sense", "On it." Never repeat the same one twice in a row.
 - Resolve through conversation first. Search the knowledge base for policies and answers before proposing any app navigation.
-- Keep spoken output to 1-2 short sentences.
-- Speak naturally — no markdown, no headers, no bullet points.
-- Only speak confirmations and answers. Do not narrate your reasoning.
-- Confirm what you did: summarize the action result briefly (e.g., "Added to cart" or "Navigated to Settings").
-- Be transparent about errors: If an action fails, explain what failed and why.
-- Track multi-item progress: For requests involving multiple items, keep track and report which ones succeeded and which did not.
-- Stay on the user's screen: For information requests, read from the current screen. Only navigate away if the needed information is on another screen.
-- When a request is ambiguous or lacks specifics, NEVER guess. You must ask the user to clarify.
-- Suggest next steps: After completing an action, briefly suggest what the user might want to do next.
-- Be concise: Users are on mobile — avoid long speech.
+- Keep spoken output concise — 1-2 short sentences per turn. Speak naturally, like a calm human teammate.
+- No markdown, no headers, no bullet points. Spoken language only.
+- Only speak confirmations and answers. Do not narrate your reasoning aloud.
+- Confirm what you did briefly (e.g., "Added to cart" or "Navigated to Settings").
+- Be transparent about errors: explain what failed and what you'll do next.
+- Track multi-item progress: report which succeeded and which did not.
+- When a request is ambiguous or lacks specifics, ask the user to clarify — never guess.
+- Suggest next steps briefly after completing an action.
 </speech_rules>
 
 ${LANGUAGE_SETTINGS(isArabic)}`;

package/lib/module/providers/GeminiProvider.js

@@ -356,9 +356,15 @@ export class GeminiProvider {
         }
       }
     }
-    if (errorCode === 'proxy_blocked') {
-      logger.error('GeminiProvider', 'Proxy blocked: Credit limit reached or budget exhausted.');
-      return 'The AI assistant is temporarily unavailable. Please try again later.';
+    if (errorCode === 'budget_exhausted' || errorCode === 'proxy_blocked') {
+      logger.error('GeminiProvider', 'Proxy blocked: project has run out of hosted proxy credits.');
+      return 'This project has run out of AI credits. Add more credits in the MobileAI dashboard to continue.';
+    }
+    if (errorCode === 'hosted_proxy_disabled') {
+      return 'The MobileAI hosted proxy is not enabled for this project yet.';
+    }
+    if (errorCode === 'invalid_auth_key') {
+      return 'This MobileAI key is invalid. Use the publishable key from your dashboard project settings.';
     }
 
     // Map status codes to friendly descriptions

package/lib/module/services/telemetry/TelemetryService.js

@@ -63,6 +63,7 @@ function generateSessionId() {
   return `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
 }
 import { getDeviceId } from "./device.js";
+import { humanizeScreenName } from "../../utils/humanizeScreenName.js";
 
 // ─── Service ───────────────────────────────────────────────────
 
@@ -73,6 +74,7 @@ export class TelemetryService {
   flushTimer = null;
   isFlushing = false;
   appStateSubscription = null;
+  wireframesSent = new Set();
   get screen() {
     return this.currentScreen;
   }
@@ -199,9 +201,13 @@ export class TelemetryService {
   }
 
   /** Update current screen (called by AIAgent on navigation) */
-  setScreen(screenName) {
+  setScreen(rawScreenName) {
+    const screenName = humanizeScreenName(rawScreenName);
+
+    // If it's a layout component or catch-all, skip it
+    if (!screenName) return;
     if (this.currentScreen !== screenName) {
-      const prevScreen = this.currentScreen;
+      const prevScreen = this.currentScreen === 'Unknown' ? undefined : this.currentScreen;
       this.currentScreen = screenName;
       this.screenFlow.push(screenName);
       this.track('screen_view', {
@@ -211,6 +217,19 @@ export class TelemetryService {
     }
   }
 
+  /**
+   * Track a wireframe snapshot.
+   * Deduped per session (only one wireframe per screen over a session).
+   */
+  trackWireframe(snapshot) {
+    if (!this.isEnabled()) return;
+
+    // Only send once per screen per session
+    if (this.wireframesSent.has(snapshot.screen)) return;
+    this.wireframesSent.add(snapshot.screen);
+    this.track('wireframe_snapshot', snapshot);
+  }
+
   // ─── Flush ──────────────────────────────────────────────────
 
   /** Send queued events to the cloud API */

package/lib/module/services/telemetry/TouchAutoCapture.js

@@ -16,6 +16,9 @@
 
 // React Native imports not needed — we use Fiber internals directly
 
+import { chooseBestAnalyticsTarget, getAnalyticsElementKind } from "./analyticsLabeling.js";
+import { getChild, getDisplayName, getParent, getProps, getSibling, getType } from "../../core/FiberAdapter.js";
+
 // ─── Rage Click Detection ──────────────────────────────────────────
 //
 // Industry-standard approach (FullStory, PostHog, LogRocket):
@@ -31,6 +34,158 @@ const MAX_TAP_BUFFER = 8;
 
 // Labels that are naturally tapped multiple times in sequence (wizards, onboarding, etc.)
 const NAVIGATION_LABELS = new Set(['next', 'continue', 'skip', 'back', 'done', 'ok', 'cancel', 'previous', 'dismiss', 'close', 'got it', 'confirm', 'proceed', 'التالي', 'متابعة', 'تخطي', 'رجوع', 'تم', 'إلغاء', 'إغلاق', 'حسناً']);
+const INTERACTIVE_PROP_KEYS = new Set(['onPress', 'onPressIn', 'onPressOut', 'onLongPress', 'onValueChange', 'onChangeText', 'onChange', 'onBlur', 'onFocus', 'onSubmitEditing', 'onScrollToTop', 'onDateChange', 'onValueChangeComplete', 'onSlidingComplete', 'onRefresh', 'onEndEditing', 'onSelect', 'onCheckedChange']);
+const INTERACTIVE_ROLES = new Set(['button', 'link', 'menuitem', 'tab', 'checkbox', 'switch', 'radio', 'slider', 'search', 'text', 'textbox']);
+const RN_INTERNAL_NAMES = new Set(['View', 'RCTView', 'Pressable', 'TouchableOpacity', 'TouchableHighlight', 'ScrollView', 'RCTScrollView', 'FlatList', 'SectionList', 'SafeAreaView', 'RNCSafeAreaView', 'KeyboardAvoidingView', 'Modal', 'StatusBar', 'Text', 'RCTText', 'AnimatedComponent', 'AnimatedComponentWrapper', 'Animated']);
+function isInteractiveNode(props, typeName) {
+  if (!props || typeof props !== 'object') return false;
+  for (const key of Object.keys(props)) {
+    if (INTERACTIVE_PROP_KEYS.has(key) && typeof props[key] === 'function') {
+      return true;
+    }
+  }
+  const role = props.accessibilityRole;
+  if (typeof role === 'string' && INTERACTIVE_ROLES.has(role.toLowerCase())) {
+    return true;
+  }
+  if (!typeName) return false;
+  const normalizedType = typeName.toLowerCase();
+  return normalizedType.includes('pressable') || normalizedType.includes('touchable') || normalizedType.includes('button') || normalizedType.includes('textfield') || normalizedType.includes('textinput') || normalizedType.includes('switch') || normalizedType.includes('checkbox') || normalizedType.includes('slider') || normalizedType.includes('picker') || normalizedType.includes('datepicker');
+}
+function getComponentName(fiber) {
+  const type = getType(fiber);
+  if (!type) return null;
+  if (typeof type === 'string') return type;
+  const displayName = getDisplayName(fiber);
+  if (displayName) return displayName;
+  if (type.name) return type.name;
+  if (type.render?.displayName) return type.render.displayName;
+  if (type.render?.name) return type.render.name;
+  return null;
+}
+function getZoneId(fiber, maxDepth = 8) {
+  let current = fiber;
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    const name = getComponentName(current);
+    const props = getProps(current);
+    if (name === 'AIZone' && typeof props.id === 'string' && props.id.trim().length > 0) {
+      return props.id.trim();
+    }
+    current = getParent(current);
+    depth++;
+  }
+  return null;
+}
+function getAncestorPath(fiber, maxDepth = 6) {
+  const labels = [];
+  const seen = new Set();
+  let current = getParent(fiber);
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    const name = getComponentName(current);
+    const props = getProps(current);
+    const candidate = name === 'AIZone' && typeof props.id === 'string' && props.id.trim() ? props.id.trim() : name;
+    if (candidate && !RN_INTERNAL_NAMES.has(candidate) && !seen.has(candidate)) {
+      labels.push(candidate);
+      seen.add(candidate);
+    }
+    current = getParent(current);
+    depth++;
+  }
+  return labels;
+}
+function getLabelForFiberNode(fiber) {
+  const props = getProps(fiber);
+  return chooseBestAnalyticsTarget([{
+    text: props.accessibilityLabel,
+    source: 'accessibility'
+  }, {
+    text: props.title,
+    source: 'title'
+  }, {
+    text: props.placeholder,
+    source: 'placeholder'
+  }, {
+    text: props.testID,
+    source: 'test-id'
+  }, {
+    text: typeof props.children === 'string' ? props.children : Array.isArray(props.children) ? findTextInChildren(props.children) : props.children && typeof props.children === 'object' ? findTextInChildren([props.children]) : null,
+    source: 'deep-text'
+  }], getAnalyticsElementKind(props.accessibilityRole || getComponentName(fiber))).label;
+}
+function getSiblingLabels(fiber, maxLabels = 6) {
+  const parent = getParent(fiber);
+  if (!parent) return [];
+  const labels = [];
+  const seen = new Set();
+  let sibling = getChild(parent);
+  while (sibling) {
+    if (sibling !== fiber) {
+      const siblingProps = getProps(sibling);
+      const siblingName = getComponentName(sibling) || undefined;
+      if (isInteractiveNode(siblingProps, siblingName)) {
+        const label = getLabelForFiberNode(sibling);
+        if (label && !seen.has(label.toLowerCase())) {
+          labels.push(label);
+          seen.add(label.toLowerCase());
+          if (labels.length >= maxLabels) break;
+        }
+      }
+    }
+    sibling = getSibling(sibling);
+  }
+  return labels;
+}
+function addCandidatesFromProps(candidates, props, isInteractiveContext = false) {
+  if (!props) return;
+  const candidateSources = [{
+    source: 'accessibility',
+    text: props.accessibilityLabel
+  }, {
+    source: 'title',
+    text: props.title
+  }, {
+    source: 'placeholder',
+    text: props.placeholder
+  }, {
+    source: 'test-id',
+    text: props.testID
+  }];
+  for (const item of candidateSources) {
+    if (!item.text) continue;
+    candidates.push({
+      text: item.text,
+      source: item.source,
+      isInteractiveContext
+    });
+  }
+  if (typeof props.children === 'string' && props.children.trim()) {
+    candidates.push({
+      text: props.children.trim(),
+      source: 'deep-text',
+      isInteractiveContext
+    });
+  } else if (Array.isArray(props.children)) {
+    const text = findTextInChildren(props.children);
+    if (text) {
+      candidates.push({
+        text,
+        source: 'deep-text',
+        isInteractiveContext
+      });
+    }
+  } else if (props.children && typeof props.children === 'object') {
+    const text = findTextInChildren([props.children]);
+    if (text) {
+      candidates.push({
+        text,
+        source: 'deep-text',
+        isInteractiveContext
+      });
+    }
+  }
+}
 function isNavigationLabel(label) {
   return NAVIGATION_LABELS.has(label.toLowerCase().trim());
 }
@@ -43,7 +198,10 @@ function isNavigationLabel(label) {
  * 2. Taps must be on the SAME screen (screen change = not rage, it's navigation)
  * 3. Navigation labels ("Next", "Skip", etc.) are excluded
  */
-export function checkRageClick(label, telemetry) {
+export function checkRageClick(target, telemetry) {
+  const label = target.label;
+  if (!label) return;
+
   // Skip navigation-style labels — sequential tapping is by design
   if (isNavigationLabel(label)) return;
   const now = Date.now();
@@ -61,9 +219,19 @@ export function checkRageClick(label, telemetry) {
   const matching = recentTaps.filter(t => t.label === label && t.screen === currentScreen && now - t.ts < RAGE_WINDOW_MS);
   if (matching.length >= RAGE_THRESHOLD) {
     telemetry.track('rage_click', {
+      canonical_type: 'rage_click_detected',
       label,
+      element_label: label,
+      element_kind: target.elementKind,
+      label_confidence: target.labelConfidence,
+      zone_id: target.zoneId,
+      ancestor_path: target.ancestorPath,
+      sibling_labels: target.siblingLabels,
+      component_name: target.componentName,
       count: matching.length,
-      screen: currentScreen
+      screen: currentScreen,
+      x: target.x,
+      y: target.y
     });
     // Reset buffer after emitting to avoid duplicate rage events
     recentTaps.length = 0;
@@ -76,61 +244,90 @@ export function checkRageClick(label, telemetry) {
  * @param event - The GestureResponderEvent from onStartShouldSetResponderCapture
  * @returns A descriptive label string for the tapped element
  */
-export function extractTouchLabel(event) {
-  // Try accessible properties first (most reliable)
+export function extractTouchTargetMetadata(event) {
   const target = event?.nativeEvent?.target;
-  if (!target) return 'Unknown Element';
-
-  // React Native internal: _targetInst (synthetic event Fiber ref)
-  // We can walk the Fiber tree from the target to find text
+  if (!target) {
+    return {
+      label: null,
+      elementKind: 'unknown',
+      labelConfidence: 'low'
+    };
+  }
   try {
-    // Strategy 1: Fiber from the SyntheticEvent (works in dev and production RN >= 0.60)
-    // Strategy 2: Walk up the Fiber tree from the touched element via DevTools hook
     let fiber = event?._targetInst || getFiberFromNativeTag(target);
     if (fiber) {
-      // Walk up looking for text content or accessibility labels
       let current = fiber;
       let depth = 0;
-      const MAX_DEPTH = 10;
+      const MAX_DEPTH = 12;
+      let foundInteractive = false;
+      const candidates = [];
+      let detectedKind = getAnalyticsElementKind(null);
+      let interactiveFiber = null;
       while (current && depth < MAX_DEPTH) {
-        // Check for accessibilityLabel
-        if (current.memoizedProps?.accessibilityLabel) {
-          return current.memoizedProps.accessibilityLabel;
+        const props = current.memoizedProps;
+        const typeName = current.type?.name || current.type?.displayName;
+        const nodeInteractive = isInteractiveNode(props, typeName);
+        if (nodeInteractive) {
+          foundInteractive = true;
+          interactiveFiber = current;
         }
-
-        // Check for testID
-        if (current.memoizedProps?.testID) {
-          return current.memoizedProps.testID;
-        }
-
-        // Check for title (Button component)
-        if (current.memoizedProps?.title) {
-          return current.memoizedProps.title;
-        }
-
-        // Check for placeholder (TextInput)
-        if (current.memoizedProps?.placeholder) {
-          return `Input: ${current.memoizedProps.placeholder}`;
+        // 1. Detect Component Type Context
+        if (detectedKind === 'unknown') {
+          if (props?.accessibilityRole) {
+            detectedKind = getAnalyticsElementKind(props.accessibilityRole);
+          } else if (props?.onValueChange && typeof props?.value === 'boolean') {
+            detectedKind = 'toggle';
+          } else if (props?.onChangeText) {
+            detectedKind = 'text_input';
+          } else if (props?.onPress) {
+            detectedKind = 'button';
+          } else if (typeName) {
+            detectedKind = getAnalyticsElementKind(typeName);
+          }
         }
-
-        // Check if this is a Text node with children string
-        if (typeof current.memoizedProps?.children === 'string' && current.memoizedProps.children.trim()) {
-          return current.memoizedProps.children.trim();
+        if (!props) {
+          break;
         }
+        addCandidatesFromProps(candidates, props, nodeInteractive);
 
-        // Check for nested text in children array
-        if (Array.isArray(current.memoizedProps?.children)) {
-          const textChild = findTextInChildren(current.memoizedProps.children);
-          if (textChild) return textChild;
+        // Stop at the nearest interactive node. If this node does not provide a
+        // usable label, still allow a child text fallback from descendants.
+        if (foundInteractive) {
+          break;
         }
         current = current.return;
         depth++;
       }
+      if (!foundInteractive) {
+        return {
+          label: null,
+          elementKind: detectedKind,
+          labelConfidence: 'low'
+        };
+      }
+
+      // Prioritize nearest interactive context when available.
+      const resolved = chooseBestAnalyticsTarget(candidates, detectedKind);
+      const sourceFiber = interactiveFiber || fiber;
+      return {
+        ...resolved,
+        zoneId: getZoneId(sourceFiber),
+        ancestorPath: getAncestorPath(sourceFiber),
+        siblingLabels: getSiblingLabels(sourceFiber),
+        componentName: getComponentName(sourceFiber)
+      };
     }
   } catch {
     // Fiber access failed — fall back gracefully
   }
-  return 'Unknown Element';
+  return {
+    label: null,
+    elementKind: 'unknown',
+    labelConfidence: 'low'
+  };
+}
+export function extractTouchLabel(event) {
+  return extractTouchTargetMetadata(event).label ?? 'Unknown Element';
 }
 
 /**