yaver-feedback-react-native 0.9.0 → 0.9.2

package/app.plugin.js

@@ -387,14 +387,135 @@ function withYaverAndroidHotReload(config) {
     },
   ]);
 
-  // Patch MainApplication to register the package and use hot bundle
+  // Patch MainApplication to register the package and use hot bundle.
+  //
+  // MainApplication is Kotlin on React Native 0.73+ (every current Expo
+  // template) and Java before that. The two need genuinely different code —
+  // `new Foo()`, `final`, and `@Override` are all syntax errors in Kotlin —
+  // so branch on the language Expo reports rather than assuming.
   config = withMainApplication(config, (config) => {
-    let contents = config.modResults.contents;
-
-    if (contents.includes("YaverHotReload")) {
+    if (config.modResults.contents.includes("YaverHotReload")) {
       return config;
     }
+    config.modResults.contents =
+      config.modResults.language === "kt"
+        ? patchMainApplicationKotlin(config.modResults.contents)
+        : patchMainApplicationJava(config.modResults.contents);
+    return config;
+  });
+
+  return config;
+}
+
+/**
+ * Insert `snippet` immediately before the closing brace of the method whose
+ * signature contains `anchor`, by matching braces from the method's opening
+ * one.
+ *
+ * The boot guard has to run at the END of onCreate: it touches
+ * reactNativeHost, and reaching that before super.onCreate() and
+ * SoLoader.init() would initialise React before its native libraries are
+ * loaded. Returns the contents unchanged if the anchor isn't found — a
+ * missing safety net is survivable, a corrupted MainApplication is not.
+ */
+function insertAtEndOfMethod(contents, anchor, snippet) {
+  const anchorIdx = contents.indexOf(anchor);
+  if (anchorIdx === -1) return contents;
+  const open = contents.indexOf("{", anchorIdx);
+  if (open === -1) return contents;
+
+  let depth = 0;
+  for (let i = open; i < contents.length; i++) {
+    const ch = contents[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return contents.slice(0, i) + snippet + contents.slice(i);
+      }
+    }
+  }
+  return contents;
+}
 
+/** Kotlin MainApplication (React Native 0.73+). */
+function patchMainApplicationKotlin(contents) {
+  // Imports. Kotlin takes no semicolons.
+  contents = contents.replace(
+    "import com.facebook.react.ReactApplication",
+    "import com.facebook.react.ReactApplication\nimport io.yaver.feedback.YaverHotReloadModule\nimport io.yaver.feedback.YaverHotReloadPackage"
+  );
+
+  // Register the package. Anchor on `return packages` rather than on
+  // `packages.add(` — the template's only occurrence of that is inside a
+  // commented-out example line.
+  contents = contents.replace(
+    /(\n([ \t]*)return packages\n)/,
+    "\n$2packages.add(YaverHotReloadPackage())\n$1"
+  );
+
+  // Load a hot-pushed bundle when one is present. Inserted before
+  // getJSMainModuleName, which every Expo template defines.
+  if (!contents.includes("getJSBundleFile")) {
+    contents = contents.replace(
+      /(\n([ \t]*)override fun getJSMainModuleName\(\))/,
+      `
+$2override fun getJSBundleFile(): String? {
+$2  // Yaver Feedback SDK: load hot-reloaded bundle if available
+$2  val hotBundle = YaverHotReloadModule.getSavedBundleFile(application.applicationContext)
+$2  return hotBundle?.absolutePath ?: super.getJSBundleFile()
+$2}
+$1`
+    );
+  }
+
+  // Crash-revert safety net: clear the boot-attempt counter once the React
+  // context initialises (bundle loaded successfully), AND via a 10-s fallback
+  // in case that listener never fires (e.g. an infinite loop in the root
+  // component). If neither fires, YaverHotReloadModule.getSavedBundleFile()
+  // reverts to the APK-bundled bundle after 3 failed cold starts. Parity with
+  // YaverHotReload.swift on iOS.
+  if (!contents.includes("yaverHotReloadBootListener")) {
+    contents = insertAtEndOfMethod(
+      contents,
+      "override fun onCreate()",
+      `
+    // Yaver Feedback SDK hot-reload crash-revert safety net
+    val yaverHotReloadCtx: android.content.Context = applicationContext
+    android.os.Handler(android.os.Looper.getMainLooper()).postDelayed(
+      { YaverHotReloadModule.markBootSuccessful(yaverHotReloadCtx) },
+      10000
+    )
+    try {
+      // Anonymous object, not a lambda: SAM conversion needs a Java interface
+      // or a Kotlin \`fun interface\`, and as of RN 0.81
+      // com.facebook.react.ReactInstanceEventListener is a plain Kotlin
+      // interface (ReactInstanceEventListener.kt). A lambda there fails
+      // :app:compileReleaseKotlin with "Argument type mismatch: actual type is
+      // 'Function0<Unit>'" — i.e. the host app cannot build a release AAB at
+      // all. The Java path below already did this correctly.
+      reactNativeHost.reactInstanceManager.addReactInstanceEventListener(
+        object : com.facebook.react.ReactInstanceEventListener {
+          override fun onReactContextInitialized(
+            context: com.facebook.react.bridge.ReactContext
+          ) {
+            YaverHotReloadModule.markBootSuccessful(yaverHotReloadCtx)
+          }
+        }
+      )
+    } catch (yaverHotReloadBootListener: Throwable) {
+      // Bridgeless / New Architecture does not expose reactInstanceManager;
+      // the 10-s fallback above still covers us.
+    }
+`
+    );
+  }
+
+  return contents;
+}
+
+/** Java MainApplication (React Native < 0.73). */
+function patchMainApplicationJava(contents) {
     // Add import
     contents = contents.replace(
       "import com.facebook.react.ReactApplication",
@@ -468,11 +589,7 @@ function withYaverAndroidHotReload(config) {
         contents.slice(0, insertionPoint) + bootGuard + contents.slice(insertionPoint);
     }
 
-    config.modResults.contents = contents;
-    return config;
-  });
-
-  return config;
+  return contents;
 }
 
 function withYaverFeedback(config, props) {

package/dist/BlackBox.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlackBox = void 0;
 const react_native_1 = require("react-native");
 const YaverFeedback_1 = require("./YaverFeedback");
+function unrefTimer(timer) {
+    const maybeNodeTimer = timer;
+    if (typeof maybeNodeTimer.unref === 'function') {
+        maybeNodeTimer.unref();
+    }
+}
 class BlackBox {
     /**
      * Start the black box stream. Call after `YaverFeedback.init()`.
@@ -18,7 +24,7 @@ class BlackBox {
         }
         BlackBox.baseUrl = feedbackConfig.agentUrl.replace(/\/$/, '');
         BlackBox.authToken = feedbackConfig.authToken ?? null;
-        BlackBox.relayPassword = feedbackConfig.relayPassword ?? '';
+        BlackBox.relayPassword = YaverFeedback_1.YaverFeedback.getRelayPassword();
         BlackBox.deviceId = config?.deviceId ?? BlackBox.generateDeviceId();
         BlackBox.appName = config?.appName ?? '';
         BlackBox.flushInterval = config?.flushInterval ?? 2000;
@@ -29,6 +35,7 @@ class BlackBox {
         if (BlackBox.flushTimer)
             clearInterval(BlackBox.flushTimer);
         BlackBox.flushTimer = setInterval(() => BlackBox.flush(), BlackBox.flushInterval);
+        unrefTimer(BlackBox.flushTimer);
         // Log the session start
         BlackBox.push({
             type: 'lifecycle',
@@ -343,6 +350,7 @@ class BlackBox {
             if (BlackBox.started)
                 BlackBox.connectSSE();
         }, 5000);
+        unrefTimer(BlackBox.sseReconnectTimer);
     }
     // ─── Internal ────────────────────────────────────────────────────
     static push(event) {

package/dist/DeployPanel.js

@@ -151,6 +151,45 @@ const DeployPanel = ({ onClose }) => {
         </react_native_1.Text>
       </react_native_1.Pressable>);
     };
+    // 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_1.YaverFeedback.getConfig();
+        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_1.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.';
+                react_native_1.Alert.alert('App Store screenshots', msg);
+            }
+            catch (e) {
+                react_native_1.Alert.alert('App Store screenshots', e?.message ?? 'Capture failed.');
+            }
+        }, 500);
+    };
+    const storeShotsEnabled = (YaverFeedback_1.YaverFeedback.getConfig()?.storeShots?.routes?.length ?? 0) > 0;
     const triggerDeploy = async (machine) => {
         if (!options)
             return;
@@ -233,6 +272,13 @@ const DeployPanel = ({ onClose }) => {
           <react_native_1.ActivityIndicator color="rgba(255,255,255,0.6)"/>
         </react_native_1.View>) : error ? (<react_native_1.Text style={styles.error}>{error}</react_native_1.Text>) : options ? (<react_native_1.ScrollView style={styles.list}>{options.devices.map(machineRow)}</react_native_1.ScrollView>) : null}
 
+      {storeShotsEnabled && (<react_native_1.Pressable onPress={runStoreShots} disabled={shipping} style={({ pressed }) => [styles.shotsBtn, pressed && styles.rowPressed]}>
+          <react_native_1.Text style={styles.shotsBtnText}>📸 App Store screenshots</react_native_1.Text>
+          <react_native_1.Text style={styles.shotsBtnSub}>
+            capture this app on-device + upload to App Store Connect
+          </react_native_1.Text>
+        </react_native_1.Pressable>)}
+
       {status && (<react_native_1.Text style={[
                 styles.status,
                 statusTone === 'success' && styles.statusSuccess,
@@ -339,6 +385,25 @@ const styles = react_native_1.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/dist/Discovery.js

@@ -34,6 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YaverDiscovery = void 0;
+function unrefTimer(timer) {
+    const maybeNodeTimer = timer;
+    if (typeof maybeNodeTimer.unref === 'function') {
+        maybeNodeTimer.unref();
+    }
+}
 function getAsyncStorage() {
     try {
         const mod = require('@react-native-async-storage/async-storage');
@@ -333,14 +339,15 @@ class YaverDiscovery {
     static async probe(url) {
         const base = url.replace(/\/$/, '');
         const start = Date.now();
+        let timeoutId = 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;
@@ -359,6 +366,10 @@ class YaverDiscovery {
         catch {
             return null;
         }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
     }
     static async connect(url) {
         const result = await YaverDiscovery.probe(url);

package/dist/FeedbackModal.js

@@ -39,11 +39,13 @@ const react_native_1 = require("react-native");
 const YaverFeedback_1 = require("./YaverFeedback");
 const capture_1 = require("./capture");
 const upload_1 = require("./upload");
+const P2PClient_1 = require("./P2PClient");
 const AuthOverlay_1 = require("./AuthOverlay");
 const QuickActionIcon_1 = require("./QuickActionIcon");
 const VibeChatScreen_1 = require("./VibeChatScreen");
 const DeployPanel_1 = require("./DeployPanel");
 const auth_1 = require("./auth");
+const reloadActions_1 = require("./reloadActions");
 const preferences_1 = require("./preferences");
 const PRIMARY_RUNNER_IDS = ['claude', 'codex', 'opencode'];
 function normalizeRunnerStatusRows(rows) {
@@ -136,6 +138,11 @@ const FeedbackModal = () => {
     // is our guaranteed UI for bringing the icon back — we surface a
     // small "Show quick icon" row when this is true.
     const [quickIconHidden, setQuickIconHidden] = (0, react_1.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] = (0, react_1.useState)(null);
+    // Which reload action is in flight, so only that button spins.
+    const [reloadingId, setReloadingId] = (0, react_1.useState)(null);
     const [runnerAuthModal, setRunnerAuthModal] = (0, react_1.useState)(null);
     // Vibing-input mode: same expand-on-tap pattern as email login.
     // Tap "Vibing" once → the button reveals an input + Send; that lets
@@ -163,6 +170,28 @@ const FeedbackModal = () => {
     const [preferredModel, setPreferredModelState] = (0, react_1.useState)('');
     const [showOpenCodeConfig, setShowOpenCodeConfig] = (0, react_1.useState)(false);
     const mountedRef = (0, react_1.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 = (0, react_1.useCallback)(async () => {
+        try {
+            const client = YaverFeedback_1.YaverFeedback.getP2PClient();
+            if (!client) {
+                setDevSnapshot(null);
+                return;
+            }
+            setDevSnapshot(await client.getDevServerStatus());
+        }
+        catch {
+            setDevSnapshot(null);
+        }
+    }, []);
     const loadSelectedMachine = (0, react_1.useCallback)(async () => {
         const cfg = YaverFeedback_1.YaverFeedback.getConfig();
         if (!cfg?.authToken) {
@@ -384,12 +413,18 @@ const FeedbackModal = () => {
     (0, react_1.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]);
     (0, react_1.useEffect)(() => {
         if (!visible) {
             setKeyboardInset(0);
@@ -473,7 +508,81 @@ const FeedbackModal = () => {
             await fn(fresh);
         }
     }, []);
-    // ─── 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 = (0, reloadActions_1.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 = (0, react_1.useCallback)(async (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_1.YaverFeedback.getSelectedRemoteDevice();
+            if (!selected) {
+                YaverFeedback_1.YaverFeedback.showMachinePicker();
+                throw new Error('No machine selected. Pick a machine and try again.');
+            }
+            if (selected.needsAuth) {
+                YaverFeedback_1.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) {
+            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 = (0, react_1.useCallback)(async () => {
         setAction('hot-reloading');
         setError(null);
@@ -579,19 +688,36 @@ const FeedbackModal = () => {
         try {
             const { Dimensions } = require('react-native');
             const { width, height } = Dimensions.get('window');
+            const cfg = YaverFeedback_1.YaverFeedback.getConfig();
+            const identity = (0, P2PClient_1.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 = {
                 platform: react_native_1.Platform.OS,
                 osVersion: String(react_native_1.Platform.Version),
                 model: react_native_1.Platform.OS === 'ios' ? 'iOS Device' : 'Android Device',
                 screenWidth: width,
                 screenHeight: height,
+                appName: identity.appName,
             };
             const capturedErrors = YaverFeedback_1.YaverFeedback.getCapturedErrors();
             const bundle = {
                 metadata: {
                     timestamp: new Date().toISOString(),
-                    device: deviceInfo,
-                    app: {},
+                    deviceInfo,
+                    app: identity.app,
+                    project: identity.project,
                     userNote: '[Screenshot + Fix]',
                 },
                 screenshots: [path],
@@ -926,8 +1052,27 @@ const FeedbackModal = () => {
                 </react_native_1.View>
               </react_native_1.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) => (<react_native_1.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}/>
+                  <react_native_1.Text style={styles.reloadHint}>
+                    {reloadAction.enabled
+                    ? reloadAction.hint
+                    : reloadAction.disabledReason}
+                  </react_native_1.Text>
+                </react_native_1.View>))}
 
               {/* 3. Vibing — expands to an input box on first tap
                  so the user says WHAT they want to vibe on, just
@@ -1004,6 +1149,15 @@ const ActionRow = ({ label, tint, onPress, disabled, busy, }) => (<react_native_
     {busy ? (<react_native_1.ActivityIndicator color={tint} size="small"/>) : (<react_native_1.Text style={[styles.actionText, { color: tint }]}>{label}</react_native_1.Text>)}
   </react_native_1.Pressable>);
 const styles = react_native_1.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)',

package/dist/P2PClient.d.ts

@@ -1,4 +1,5 @@
-import { CapabilitySnapshot, FeedbackBundle, IncidentEvent, OpenCodeConfigSummary, OperationState, RunnerBrowserAuthSession, RunnerAuthStatusRow, TestSession, VoiceCapability } from './types';
+import { AppInfo, CapabilitySnapshot, FeedbackBundle, FeedbackProjectRef, IncidentEvent, OpenCodeConfigSummary, OperationState, RunnerBrowserAuthSession, RunnerAuthStatusRow, TestSession, VoiceCapability } from './types';
+import type { DevServerSnapshot, ReloadWireMode } from './reloadActions';
 export interface FeedbackEvent {
     type: string;
     timestamp: string;
@@ -28,6 +29,45 @@ export declare function resolveAppIdentity(opts?: {
     bundleId?: string;
     projectPath?: string;
 };
+/**
+ * Build the app-identity half of a feedback report's metadata.
+ *
+ * `resolveAppIdentity()` has always fed /vibing/execute and /dev/reload-app,
+ * so the agent could route a "vibe on THIS app" request to the right repo —
+ * but nothing fed /feedback. Reports arrived with no identity at all, so the
+ * agent's fix router fell through to its own working directory and edited
+ * whichever repo it happened to be sitting in. This closes that gap by
+ * reusing the same resolver for the feedback path.
+ *
+ * Precedence, most to least trustworthy:
+ *   1. What the host app declared (`FeedbackConfig.projectName`/`bundleId`).
+ *      An app knows its own identity; nothing should override it.
+ *   2. The guest project Yaver's host shell pinned, when running as a Hermes
+ *      guest. Ambient lookups describe Yaver there, not the guest.
+ *   3. Ambient expo-constants / native modules — correct for a standalone
+ *      build, which is the common case.
+ *
+ * Every lookup is best-effort: a bare RN app with no expo-constants still
+ * produces a report, just one the agent resolves by its own means.
+ */
+export declare function resolveReportIdentity(opts?: {
+    projectName?: string;
+    bundleId?: string;
+    surface?: FeedbackProjectRef['surface'];
+    surfaces?: FeedbackProjectRef['surfaces'];
+    stack?: string;
+    stacks?: string[];
+    testSurfaces?: string[];
+    feedbackSdk?: string;
+    feedbackTransport?: string;
+    voiceCapabilities?: string[];
+    sttProvider?: string;
+    ttsProvider?: string;
+}): {
+    appName?: string;
+    app: AppInfo;
+    project?: FeedbackProjectRef;
+};
 /**
  * Lightweight P2P HTTP client for communicating with a Yaver agent.
  *
@@ -163,6 +203,29 @@ export declare class P2PClient {
      * via the BlackBox command channel.
      * @param mode - "dev" for hot reload, "bundle" for native bundle rebuild
      */
+    /**
+     * Read the dev server's state so the overlay can decide WHICH reload
+     * actions to offer, and disable the rest with a reason.
+     *
+     * Returns null when the machine cannot be reached at all — which the
+     * caller must render as "not connected", never as "no dev server".
+     * Those are two different problems with two different fixes.
+     */
+    getDevServerStatus(): Promise<DevServerSnapshot | null>;
+    /**
+     * Trigger a reload with an EXPLICIT fast/full mode — no bundle fallback.
+     *
+     * `reloadApp('dev')` silently falls through to a bundle rebuild when the
+     * dev server is down, which is right for a one-button UX and wrong the
+     * moment the user picks between two named actions: someone who pressed
+     * "Full Reload" must not get a 60-second bundle rebuild without being
+     * told. So this method reports the failure instead, with a named cause.
+     *
+     * Auth: the SAME bearer used for the feedback POST. `/dev/reload` is
+     * registered under `authSDKOrGuest` in desktop/agent/httpserver.go and is
+     * already in the `guest-reload` SDK-token scope list — nothing widens.
+     */
+    reloadWithMode(mode: ReloadWireMode, snapshot?: DevServerSnapshot | null): Promise<ReloadAck>;
     reloadApp(mode?: 'dev' | 'bundle', opts?: {
         projectName?: string;
         bundleId?: string;