yaver-feedback-react-native 0.9.0 → 0.9.2

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { BlackBoxConfig } from './BlackBox';
 /**
  * Remote browser-style sign-in session for a coding-agent CLI on the
  * connected yaver host. Mirrors runnerBrowserAuthSession on the agent
@@ -121,9 +122,32 @@ export interface CapabilitySnapshot {
     };
     targets: Record<string, CapabilityTargetReadiness>;
 }
+/**
+ * Opt-in config for the overlay's "App Store screenshots" action and the
+ * `capture_store_shots` remote command. When set, the SDK can walk the
+ * app's routes on-device, screenshot each, and upload them to the agent
+ * (which runs the App Store Connect backend).
+ */
+export interface StoreShotsConfig {
+    /** Ordered routes to visit + screenshot (e.g. ['/(tabs)/home', ...]). */
+    routes: string[];
+    /** Navigation handle: a react-navigation ref or expo-router `router`. */
+    navigationRef?: any;
+    /** Also set metadata + attempt submit-for-review after upload. */
+    submit?: boolean;
+    /** Optional per-route screenshot names (defaults to NN_<route>). */
+    screens?: string[];
+}
 export interface FeedbackConfig {
     /** URL of the Yaver agent (e.g. "http://192.168.1.10:18080"). If omitted, auto-discovery is used. */
     agentUrl?: string;
+    /**
+     * Enables the overlay's "App Store screenshots" action + the
+     * `capture_store_shots` remote command. The host supplies the route
+     * list (and a navigation ref) once; the SDK captures the real running
+     * app — no simulator needed.
+     */
+    storeShots?: StoreShotsConfig;
     /**
      * Auth token for the Yaver agent. Optional in 0.5+: if omitted, the SDK
      * will hydrate one from AsyncStorage or show its in-app login screen
@@ -163,6 +187,39 @@ export interface FeedbackConfig {
      * If omitted with convexUrl, connects to the first online device.
      */
     preferredDeviceId?: string;
+    /**
+     * Identity of the app this SDK instance reports for. Both fields are
+     * resolved automatically from expo-constants / native modules when
+     * omitted, so most apps never set them.
+     *
+     * Set them when the ambient answer would be wrong — above all when the
+     * app's JS is pushed into Yaver's container as a Hermes guest. There the
+     * runtime IS Yaver: `expo-constants` and `SettingsManager` describe the
+     * host (`Yaver` / `io.yaver.mobile`), not the guest, so auto-resolution
+     * would file every report against Yaver's own repo and the fix task would
+     * edit the SDK instead of the app. Declaring identity here is the only
+     * answer that holds in both a standalone build and a guest bundle.
+     *
+     * `bundleId` is the key that actually routes: the agent matches it against
+     * each project's pbxproj / build.gradle / app.json. `projectName` is a
+     * fallback for platforms with no bundle id.
+     */
+    projectName?: string;
+    bundleId?: string;
+    /** Primary Yaver product surface for this app/package. */
+    surface?: YaverSurface;
+    /** All product surfaces this app/package owns. */
+    surfaces?: YaverSurface[];
+    /** Canonical development stack labels, e.g. react-native-expo, yaver-xml. */
+    stack?: string;
+    stacks?: string[];
+    /** Yaver preview/runtime targets that can exercise this app. */
+    testSurfaces?: string[];
+    feedbackSdk?: string;
+    feedbackTransport?: string;
+    voiceCapabilities?: string[];
+    sttProvider?: string;
+    ttsProvider?: string;
     /** How feedback collection is triggered */
     trigger?: 'shake' | 'floating-button' | 'manual';
     /**
@@ -203,6 +260,22 @@ export interface FeedbackConfig {
      * Calling `BlackBox.start()` manually is still safe — it's idempotent.
      */
     autoStartBlackBox?: boolean;
+    /**
+     * Config handed to BlackBox when the SDK auto-starts it.
+     *
+     * Without this there was no way to configure the flight recorder at all.
+     * The obvious move — and the one the README's own snippet makes — is:
+     *
+     *     YaverFeedback.init({ trigger: 'shake' });
+     *     BlackBox.start({ appName: 'my-app' });
+     *
+     * but that start() early-returns, because a zero-config init has no
+     * agentUrl yet (discovery resolves it asynchronously). The auto-start then
+     * fires ~500ms later once the agent and token exist and calls `start()`
+     * with NO arguments — so the host's config is silently dropped and appName
+     * is ''. Pass it here instead and the auto-start will honour it.
+     */
+    blackBox?: BlackBoxConfig;
     /**
      * Small tap-to-open icon that floats above the app so the user
      * doesn't have to shake every time they want to open feedback.
@@ -291,6 +364,26 @@ export interface FeedbackConfig {
      * Bugsnag, or any other error tracking tool.
      */
     maxCapturedErrors?: number;
+    /**
+     * Crash-aware reporting/fixing. Defaults to disabled.
+     *
+     * - enabled: records fatal errors into the SDK error buffer and enables
+     *   explicit `YaverFeedback.reportCrash(error)`.
+     * - installGlobalHandler: opt-in only. Wraps React Native's global ErrorUtils
+     *   handler without suppressing the existing handler. Leave false when Sentry,
+     *   Crashlytics, Bugsnag, or another crash tool owns the global handler.
+     * - autoFix: after uploading a crash report, ask the connected Yaver agent to
+     *   create a fix task. The normal BlackBox command stream can then deliver a
+     *   reload/reload_bundle command after the agent rebuilds.
+     * - captureScreenshot: attach a best-effort screenshot to the crash report.
+     */
+    crashReporting?: {
+        enabled?: boolean;
+        installGlobalHandler?: boolean;
+        autoFix?: boolean;
+        captureScreenshot?: boolean;
+        metadata?: Record<string, unknown>;
+    };
     /**
      * Which platforms the Build button targets.
      * - 'ios' — build iOS only
@@ -403,9 +496,36 @@ export interface CapturedError {
 }
 export interface FeedbackMetadata {
     timestamp: string;
-    device: DeviceInfo;
+    /**
+     * Wire key is `deviceInfo`, matching the Flutter + web SDKs and the
+     * agent's `FeedbackReport.DeviceInfo` (`json:"deviceInfo"`). This was
+     * `device` until 0.9.2 — a key the agent never read, so the whole block
+     * (platform, model, and the app name the fix router needs) was silently
+     * dropped on every React Native report. The agent still accepts the old
+     * key so builds already in the field keep working.
+     */
+    deviceInfo: DeviceInfo;
     app: AppInfo;
+    /**
+     * Which of the host's projects this report is about. The agent resolves
+     * a feedback→fix task's working directory from this; without it the task
+     * falls back to whatever directory the agent happens to be sitting in.
+     * Populated automatically by `resolveReportIdentity()`.
+     */
+    project?: FeedbackProjectRef;
     userNote?: string;
+    reportKind?: 'feedback' | 'auto-report' | 'crash';
+    crash?: {
+        message: string;
+        isFatal: boolean;
+        source: 'manual' | 'global-handler';
+        autoFixRequested?: boolean;
+    };
+    twin?: {
+        sessionId?: string;
+        surface?: string;
+        artifactDir?: string;
+    };
 }
 export interface DeviceInfo {
     platform: string;
@@ -413,12 +533,49 @@ export interface DeviceInfo {
     model: string;
     screenWidth: number;
     screenHeight: number;
+    /** Host app name. First key the agent's fix router checks. */
+    appName?: string;
 }
 export interface AppInfo {
     bundleId?: string;
     version?: string;
     buildNumber?: string;
 }
+/**
+ * Identifies the host project a report belongs to. Mirrors the web SDK's
+ * `FeedbackProjectRef` and the agent's `FeedbackProject`.
+ */
+export interface FeedbackProjectRef {
+    appName?: string;
+    projectName?: string;
+    /**
+     * Bundle identifier / applicationId. The only unambiguous key: an app's
+     * display name ("Talos") does not match the agent's registry name for it
+     * ("talos / mobile"), and one repo can hold several mobile projects that
+     * all share a name prefix. The agent matches this against the project's
+     * pbxproj, build.gradle, and app.json.
+     */
+    bundleId?: string;
+    /**
+     * Deliberately never set by this SDK. The agent ignores client-supplied
+     * paths for feedback reports (an untrusted guest could otherwise point the
+     * fix task's CWD at ~/.ssh) and resolves the path server-side. Present only
+     * so the type matches the wire format the agent parses.
+     */
+    projectPath?: string;
+    surface?: YaverSurface;
+    surfaces?: YaverSurface[];
+    stack?: string;
+    stacks?: string[];
+    testSurfaces?: string[];
+    feedbackSdk?: string;
+    feedbackTransport?: string;
+    voiceCapabilities?: string[];
+    sttProvider?: string;
+    ttsProvider?: string;
+    releaseChannel?: 'production' | 'candidate' | 'development';
+}
+export type YaverSurface = 'web' | 'mobile' | 'backend' | 'watch' | 'tv' | 'car' | 'vision' | 'desktop' | 'cli';
 export interface TimelineEvent {
     type: 'screenshot' | 'audio' | 'video';
     path: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "yaver-feedback-react-native",
-  "version": "0.9.0",
-  "description": "Visual feedback SDK for Yaver \u2014 bug reports, screen recording, voice vibe coding, and local-first developer workflows",
+  "version": "0.9.2",
+  "description": "Visual feedback SDK for Yaver — bug reports, screen recording, voice vibe coding, and local-first developer workflows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [

package/src/BlackBox.ts

@@ -66,6 +66,13 @@ export interface BlackBoxCommand {
 /** Callback type for handling agent commands. */
 export type CommandHandler = (cmd: BlackBoxCommand) => void;
 
+function unrefTimer(timer: ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>): void {
+  const maybeNodeTimer = timer as unknown as { unref?: () => void };
+  if (typeof maybeNodeTimer.unref === 'function') {
+    maybeNodeTimer.unref();
+  }
+}
+
 export class BlackBox {
   private static baseUrl: string | null = null;
   private static authToken: string | null = null;
@@ -109,7 +116,7 @@ export class BlackBox {
 
     BlackBox.baseUrl = feedbackConfig.agentUrl.replace(/\/$/, '');
     BlackBox.authToken = feedbackConfig.authToken ?? null;
-    BlackBox.relayPassword = (feedbackConfig as { relayPassword?: string }).relayPassword ?? '';
+    BlackBox.relayPassword = YaverFeedback.getRelayPassword();
     BlackBox.deviceId = config?.deviceId ?? BlackBox.generateDeviceId();
     BlackBox.appName = config?.appName ?? '';
     BlackBox.flushInterval = config?.flushInterval ?? 2000;
@@ -120,6 +127,7 @@ export class BlackBox {
     // Start periodic flush
     if (BlackBox.flushTimer) clearInterval(BlackBox.flushTimer);
     BlackBox.flushTimer = setInterval(() => BlackBox.flush(), BlackBox.flushInterval);
+    unrefTimer(BlackBox.flushTimer);
 
     // Log the session start
     BlackBox.push({
@@ -471,6 +479,7 @@ export class BlackBox {
       BlackBox.sseReconnectTimer = null;
       if (BlackBox.started) BlackBox.connectSSE();
     }, 5000);
+    unrefTimer(BlackBox.sseReconnectTimer);
   }
 
   // ─── Internal ────────────────────────────────────────────────────

package/src/DeployPanel.tsx

@@ -1,6 +1,7 @@
 import React, { useCallback, useEffect, useState } from 'react';
 import {
   ActivityIndicator,
+  Alert,
   Pressable,
   ScrollView,
   StyleSheet,
@@ -184,6 +185,47 @@ export const DeployPanel: React.FC<DeployPanelProps> = ({ onClose }) => {
     );
   };
 
+  // First-class App Store screenshots: walk the app's routes on THIS
+  // device, screenshot each, upload to the agent (which runs the ASC
+  // backend). Closes the overlay first so the captures are clean (no
+  // modal in frame), then reports via an alert.
+  const runStoreShots = () => {
+    const cfg = YaverFeedback.getConfig() as { storeShots?: any } | null;
+    const ss = cfg?.storeShots;
+    if (!ss?.routes?.length) {
+      setStatus('Set config.storeShots.routes (and a navigationRef) to enable.');
+      setStatusTone('error');
+      return;
+    }
+    const app = resolveAppSlug();
+    onClose();
+    // Defer so the overlay is fully dismissed before the first capture.
+    setTimeout(async () => {
+      try {
+        const res = await YaverFeedback.captureStoreScreenshots({
+          app,
+          routes: ss.routes,
+          navigationRef: ss.navigationRef,
+          screens: ss.screens,
+          submit: ss.submit,
+        });
+        const msg = res.ok
+          ? res.submitted
+            ? 'Submitted for App Store review 🎉'
+            : res.staged
+              ? `Uploaded ${res.uploaded} screenshots — staged. One tap left in App Store Connect.`
+              : `Uploaded ${res.uploaded} App Store screenshots.`
+          : res.message || 'Capture failed.';
+        Alert.alert('App Store screenshots', msg);
+      } catch (e: any) {
+        Alert.alert('App Store screenshots', e?.message ?? 'Capture failed.');
+      }
+    }, 500);
+  };
+
+  const storeShotsEnabled =
+    ((YaverFeedback.getConfig() as { storeShots?: any } | null)?.storeShots?.routes?.length ?? 0) > 0;
+
   const triggerDeploy = async (machine: string) => {
     if (!options) return;
     setShipping(true);
@@ -277,6 +319,19 @@ export const DeployPanel: React.FC<DeployPanelProps> = ({ onClose }) => {
         <ScrollView style={styles.list}>{options.devices.map(machineRow)}</ScrollView>
       ) : null}
 
+      {storeShotsEnabled && (
+        <Pressable
+          onPress={runStoreShots}
+          disabled={shipping}
+          style={({ pressed }) => [styles.shotsBtn, pressed && styles.rowPressed]}
+        >
+          <Text style={styles.shotsBtnText}>📸 App Store screenshots</Text>
+          <Text style={styles.shotsBtnSub}>
+            capture this app on-device + upload to App Store Connect
+          </Text>
+        </Pressable>
+      )}
+
       {status && (
         <Text
           style={[
@@ -388,6 +443,25 @@ const styles = StyleSheet.create({
   rowMetaWarning: {
     color: 'rgb(255,178,115)',
   },
+  shotsBtn: {
+    marginTop: 12,
+    paddingVertical: 12,
+    paddingHorizontal: 14,
+    borderRadius: 10,
+    backgroundColor: 'rgba(124,109,255,0.16)',
+    borderWidth: 1,
+    borderColor: 'rgba(124,109,255,0.4)',
+  },
+  shotsBtnText: {
+    color: '#fff',
+    fontSize: 14,
+    fontWeight: '600',
+  },
+  shotsBtnSub: {
+    color: 'rgba(255,255,255,0.55)',
+    fontSize: 12,
+    marginTop: 2,
+  },
   status: {
     color: 'rgba(255,255,255,0.55)',
     fontSize: 12,

package/src/Discovery.ts

@@ -7,6 +7,14 @@ type AsyncStorageLike = {
   setItem: (key: string, value: string) => Promise<void>;
   removeItem: (key: string) => Promise<void>;
 };
+
+function unrefTimer(timer: ReturnType<typeof setTimeout>): void {
+  const maybeNodeTimer = timer as unknown as { unref?: () => void };
+  if (typeof maybeNodeTimer.unref === 'function') {
+    maybeNodeTimer.unref();
+  }
+}
+
 function getAsyncStorage(): AsyncStorageLike | null {
   try {
     const mod = require('@react-native-async-storage/async-storage');
@@ -362,14 +370,15 @@ export class YaverDiscovery {
   static async probe(url: string): Promise<DiscoveryResult | null> {
     const base = url.replace(/\/$/, '');
     const start = Date.now();
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
     try {
       const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+      timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+      unrefTimer(timeoutId);
       const response = await fetch(`${base}/health`, {
         method: 'GET',
         signal: controller.signal,
       });
-      clearTimeout(timeoutId);
       if (!response.ok) return null;
       const latency = Date.now() - start;
       let hostname = 'Unknown';
@@ -384,6 +393,8 @@ export class YaverDiscovery {
       return { url: base, hostname, version, latency };
     } catch {
       return null;
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
     }
   }
 

package/src/FeedbackModal.tsx

@@ -25,6 +25,7 @@ import {
   // stopVideoRecording,
 } from './capture';
 import { uploadFeedback } from './upload';
+import { resolveReportIdentity } from './P2PClient';
 import {
   DeviceInfo,
   FeedbackBundle,
@@ -37,6 +38,8 @@ import { QuickActionIcon } from './QuickActionIcon';
 import { VibeChatScreen } from './VibeChatScreen';
 import { DeployPanel } from './DeployPanel';
 import { listReachableDevices, RemoteDevice } from './auth';
+import { reloadActions } from './reloadActions';
+import type { DevServerSnapshot, ReloadAction } from './reloadActions';
 import {
   QUICK_ICON_COLOR_PRESETS,
   QuickIconColorPreset,
@@ -195,6 +198,11 @@ export const FeedbackModal: React.FC = () => {
   // is our guaranteed UI for bringing the icon back — we surface a
   // small "Show quick icon" row when this is true.
   const [quickIconHidden, setQuickIconHidden] = useState(false);
+  // Dev-server snapshot behind the reload buttons. `null` means "we have not
+  // been able to ask" — rendered as "not connected", never as "no dev server".
+  const [devSnapshot, setDevSnapshot] = useState<DevServerSnapshot | null>(null);
+  // Which reload action is in flight, so only that button spins.
+  const [reloadingId, setReloadingId] = useState<string | null>(null);
   const [runnerAuthModal, setRunnerAuthModal] = useState<string | null>(null);
   // Vibing-input mode: same expand-on-tap pattern as email login.
   // Tap "Vibing" once → the button reveals an input + Send; that lets
@@ -226,6 +234,28 @@ export const FeedbackModal: React.FC = () => {
   const [showOpenCodeConfig, setShowOpenCodeConfig] = useState(false);
   const mountedRef = useRef(true);
 
+  /**
+   * Ask the machine what its dev server is doing, so the reload actions can
+   * be enabled/disabled against reality rather than against a guess.
+   *
+   * Best-effort and deliberately null-on-failure: null means "we could not
+   * ask", which the seam renders as "not connected to a machine yet" — a
+   * different sentence from "no dev server is running", because they have
+   * different fixes.
+   */
+  const refreshDevSnapshot = useCallback(async () => {
+    try {
+      const client = YaverFeedback.getP2PClient();
+      if (!client) {
+        setDevSnapshot(null);
+        return;
+      }
+      setDevSnapshot(await client.getDevServerStatus());
+    } catch {
+      setDevSnapshot(null);
+    }
+  }, []);
+
   const loadSelectedMachine = useCallback(async () => {
     const cfg = YaverFeedback.getConfig();
     if (!cfg?.authToken) {
@@ -448,12 +478,18 @@ export const FeedbackModal: React.FC = () => {
 
   useEffect(() => {
     if (!visible) return;
+    // Poll the dev server alongside the machine + runners. A reload button
+    // whose enabled state was decided once, when the sheet opened, goes
+    // stale the moment the user starts Metro from another surface — and a
+    // stale "no dev server is running" reads as the product being broken.
+    void refreshDevSnapshot();
     const interval = setInterval(() => {
       void loadSelectedMachine();
       void loadRunnerStatuses();
+      void refreshDevSnapshot();
     }, 5000);
     return () => clearInterval(interval);
-  }, [loadRunnerStatuses, loadSelectedMachine, visible]);
+  }, [loadRunnerStatuses, loadSelectedMachine, refreshDevSnapshot, visible]);
 
   useEffect(() => {
     if (!visible) {
@@ -542,7 +578,87 @@ export const FeedbackModal: React.FC = () => {
     [],
   );
 
-  // ─── 1. Hot reload ─────────────────────────────────────────────────
+  // ─── 1. Reload ─────────────────────────────────────────────────────
+  //
+  // Three actions now, not one: Hot Reload (mode=fast), Full Reload
+  // (mode=full — Flutter's hot RESTART), and Rebuild Bundle
+  // (/dev/reload-app, the only one that works with Metro down).
+  //
+  // WHICH of them render, and which are disabled with what reason, is
+  // decided by the pure `reloadActions()` seam — never inline here, so the
+  // same policy holds on web, Flutter, Unity, Swift and Kotlin. In
+  // particular: a production build (`__DEV__ === false`) gets NONE of them.
+
+  const availableReloadActions = reloadActions(devSnapshot, {
+    // __DEV__ is React Native's own build flag. A release bundle sets it
+    // false, so a shipped app renders no reload UI at all — which is the
+    // point, and is what reloadActions.test.ts pins.
+    isDevBuild: typeof __DEV__ !== 'undefined' && __DEV__ === true,
+    connected: devSnapshot !== null,
+    machineLabel: machineCard.device?.name || undefined,
+    includeRebuild: true,
+  });
+
+  const handleReloadAction = useCallback(
+    async (reloadAction: ReloadAction) => {
+      if (!reloadAction.enabled) {
+        // Pressing a disabled action must SAY why. A row that does nothing
+        // is the same defect as a spinner that never resolves.
+        setToast(reloadAction.disabledReason || 'Reload is unavailable right now.');
+        setError(reloadAction.disabledReason || null);
+        return;
+      }
+      setReloadingId(reloadAction.id);
+      setAction('hot-reloading');
+      setError(null);
+      setProgress(0);
+      setToast(`${reloadAction.label}…`);
+      try {
+        await loadSelectedMachine();
+        const selected = await YaverFeedback.getSelectedRemoteDevice();
+        if (!selected) {
+          YaverFeedback.showMachinePicker();
+          throw new Error('No machine selected. Pick a machine and try again.');
+        }
+        if (selected.needsAuth) {
+          YaverFeedback.showMachinePicker();
+          throw new Error('Selected machine needs pairing again.');
+        }
+        if (!selected.isOnline) {
+          throw new Error('Selected machine is offline. Start `yaver serve` on it first.');
+        }
+
+        let ackMessage = `${reloadAction.label} requested.`;
+        await runWithReconnect(async (client) => {
+          const ack = await client.reloadWithMode(reloadAction.mode, devSnapshot);
+          ackMessage = ack.message;
+          setToast(ack.message);
+          setProgress(0.2);
+        });
+        setToast(ackMessage);
+        if (reloadAction.mode === 'bundle') closeSoon(2500);
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        setError(message);
+        setToast(
+          message.toLowerCase().indexOf('session expired') >= 0
+            ? 'Session expired. Sign in again.'
+            : message,
+        );
+        await loadSelectedMachine();
+        setProgress(null);
+      } finally {
+        if (mountedRef.current) {
+          setAction('idle');
+          setReloadingId(null);
+          void refreshDevSnapshot();
+        }
+      }
+    },
+    [closeSoon, devSnapshot, loadSelectedMachine, refreshDevSnapshot, runWithReconnect],
+  );
+
+  /** Kept for the legacy one-tap path (BlackBox command, chat Reload button). */
   const handleHotReload = useCallback(async () => {
     setAction('hot-reloading');
     setError(null);
@@ -661,19 +777,36 @@ export const FeedbackModal: React.FC = () => {
     try {
       const { Dimensions } = require('react-native');
       const { width, height } = Dimensions.get('window');
+      const cfg = YaverFeedback.getConfig();
+      const identity = resolveReportIdentity({
+        projectName: cfg?.projectName,
+        bundleId: cfg?.bundleId,
+        surface: cfg?.surface,
+        surfaces: cfg?.surfaces,
+        stack: cfg?.stack,
+        stacks: cfg?.stacks,
+        testSurfaces: cfg?.testSurfaces,
+        feedbackSdk: cfg?.feedbackSdk,
+        feedbackTransport: cfg?.feedbackTransport,
+        voiceCapabilities: cfg?.voiceCapabilities,
+        sttProvider: cfg?.sttProvider,
+        ttsProvider: cfg?.ttsProvider,
+      });
       const deviceInfo: DeviceInfo = {
         platform: Platform.OS,
         osVersion: String(Platform.Version),
         model: Platform.OS === 'ios' ? 'iOS Device' : 'Android Device',
         screenWidth: width,
         screenHeight: height,
+        appName: identity.appName,
       };
       const capturedErrors = YaverFeedback.getCapturedErrors();
       const bundle: FeedbackBundle = {
         metadata: {
           timestamp: new Date().toISOString(),
-          device: deviceInfo,
-          app: {},
+          deviceInfo,
+          app: identity.app,
+          project: identity.project,
           userNote: '[Screenshot + Fix]',
         },
         screenshots: [path],
@@ -1115,16 +1248,36 @@ export const FeedbackModal: React.FC = () => {
                 </View>
               </View>
 
-              {/* 1. Hot Reload — the common path */}
-              <ActionRow
-                label={
-                  action === 'hot-reloading' ? 'Reloading…' : 'Hot Reload'
-                }
-                tint="#fbbf24"
-                onPress={handleHotReload}
-                disabled={busy}
-                busy={action === 'hot-reloading'}
-              />
+              {/* 1. Reload — Hot / Full / Rebuild Bundle.
+                   Rendered from the shared decision seam, so a production
+                   build (__DEV__ false) renders nothing here at all, and a
+                   blocked action shows greyed WITH its reason underneath
+                   rather than vanishing. */}
+              {availableReloadActions.map((reloadAction) => (
+                <View key={reloadAction.id} style={styles.reloadRow}>
+                  <ActionRow
+                    label={
+                      reloadingId === reloadAction.id
+                        ? `${reloadAction.label}…`
+                        : reloadAction.label
+                    }
+                    tint={reloadAction.id === 'rebuild' ? '#38bdf8' : '#fbbf24'}
+                    onPress={() => {
+                      void handleReloadAction(reloadAction);
+                    }}
+                    // Never `disabled` at the Pressable level for a blocked
+                    // action: we WANT the tap so we can say why. Only a
+                    // genuinely busy modal blocks the press.
+                    disabled={busy && reloadingId !== reloadAction.id}
+                    busy={reloadingId === reloadAction.id}
+                  />
+                  <Text style={styles.reloadHint}>
+                    {reloadAction.enabled
+                      ? reloadAction.hint
+                      : reloadAction.disabledReason}
+                  </Text>
+                </View>
+              ))}
 
               {/* 3. Vibing — expands to an input box on first tap
                    so the user says WHAT they want to vibe on, just
@@ -1293,6 +1446,15 @@ const ActionRow: React.FC<ActionRowProps> = ({
 );
 
 const styles = StyleSheet.create({
+  reloadRow: {
+    gap: 4,
+  },
+  reloadHint: {
+    color: '#8b8b93',
+    fontSize: 11,
+    lineHeight: 15,
+    paddingHorizontal: 4,
+  },
   vibeInputRow: {
     backgroundColor: 'rgba(129,140,248,0.08)',
     borderColor: 'rgba(129,140,248,0.4)',