yaver-feedback-react-native 0.9.2 → 0.9.4

package/src/LoginScreen.tsx

@@ -113,11 +113,9 @@ const iconStyles = StyleSheet.create({
 
 export interface YaverLoginScreenProps {
   /** Invoked once a session token is issued and the user is loaded. */
-  onLoggedIn: (token: string, opts?: { inviteCode?: string }) => void;
+  onLoggedIn: (token: string) => void;
   /** Optional cancel button shown in header. */
   onCancel?: () => void;
-  /** Optional prefilled guest invite code from config / deep link. */
-  initialInviteCode?: string;
 }
 
 /**
@@ -128,7 +126,6 @@ export interface YaverLoginScreenProps {
 export const YaverLoginScreen: React.FC<YaverLoginScreenProps> = ({
   onLoggedIn,
   onCancel,
-  initialInviteCode,
 }) => {
   const [busyProvider, setBusyProvider] = useState<OAuthProvider | 'apple' | null>(null);
   const [showEmailForm, setShowEmailForm] = useState(false);
@@ -137,7 +134,6 @@ export const YaverLoginScreen: React.FC<YaverLoginScreenProps> = ({
   const [email, setEmail] = useState('');
   const [password, setPassword] = useState('');
   const [confirmPassword, setConfirmPassword] = useState('');
-  const [inviteCode, setInviteCode] = useState((initialInviteCode ?? '').toUpperCase());
   const [emailBusy, setEmailBusy] = useState(false);
   const [emailError, setEmailError] = useState('');
 
@@ -145,8 +141,7 @@ export const YaverLoginScreen: React.FC<YaverLoginScreenProps> = ({
     const user = await validateToken(token);
     await saveToken(token);
     if (user) await saveUser(user);
-    const cleanedInviteCode = inviteCode.toUpperCase().replace(/[^A-Z0-9]/g, '').slice(0, 6);
-    onLoggedIn(token, cleanedInviteCode ? { inviteCode: cleanedInviteCode } : undefined);
+    onLoggedIn(token);
   };
 
   const handleApple = async () => {
@@ -330,21 +325,6 @@ export const YaverLoginScreen: React.FC<YaverLoginScreenProps> = ({
                     secureTextEntry
                   />
                 )}
-                {isSignUp && (
-                  <TextInput
-                    style={styles.input}
-                    placeholder="Invite Code (optional)"
-                    placeholderTextColor="#666"
-                    value={inviteCode}
-                    onChangeText={(value) =>
-                      setInviteCode(value.toUpperCase().replace(/[^A-Z0-9]/g, '').slice(0, 6))
-                    }
-                    autoCapitalize="characters"
-                    autoCorrect={false}
-                    maxLength={6}
-                  />
-                )}
-
                 {emailError ? (
                   <Text style={styles.errorText}>{emailError}</Text>
                 ) : null}

package/src/MachinePickerScreen.tsx

@@ -28,9 +28,7 @@ export interface YaverMachinePickerProps {
 }
 
 /**
- * List of remote dev machines the signed-in user can reach. Split into
- *   - Owned machines (user is the host)
- *   - Shared machines (host invited them as a guest)
+ * List of remote dev machines owned by the signed-in user.
  *
  * Tapping a device persists it to AsyncStorage and invokes `onPick`. The
  * SDK then uses that device's deviceId for agent discovery (LAN probe +
@@ -45,7 +43,7 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
   const [loading, setLoading] = useState(true);
   const [refreshing, setRefreshing] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const [list, setList] = useState<DeviceList>({ owned: [], shared: [] });
+  const [list, setList] = useState<DeviceList>({ owned: [] });
   const [pairingDevice, setPairingDevice] = useState<RemoteDevice | null>(null);
   const [reachability, setReachability] = useState<Record<string, DeviceReachability | undefined>>({});
 
@@ -57,7 +55,7 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
       setList(result);
       setReachability({});
       void (async () => {
-        const devices = [...result.owned, ...result.shared];
+        const devices = result.owned;
         const settled = await Promise.allSettled(
           devices.map(async (device) => ({
             deviceId: device.deviceId,
@@ -74,10 +72,8 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
           return next;
         });
       })();
-      if (result.owned.length === 0 && result.shared.length === 0) {
-        setError(
-          'No machines found yet. If you do not have your own computer, redeem a host invite code first. Otherwise run `yaver auth` + `yaver serve` on your machine.',
-        );
+      if (result.owned.length === 0) {
+        setError('No machines found yet. Run `yaver auth` + `yaver serve` on your machine.');
       }
     } catch (err) {
       setError(err instanceof Error ? err.message : String(err));
@@ -158,13 +154,8 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
     } else if (device.runnerDown) {
       statusLine = 'Runner down — restart the coding agent on the Mac';
     } else {
-      // Happy-path subtitle: platform + optional host/share hint.
+      // Happy-path subtitle.
       statusLine = device.platform;
-      if (device.isGuest && device.hostEmail) {
-        statusLine = `${statusLine} • ${device.hostEmail}`;
-      } else if (device.accessScope === 'shared-scoped') {
-        statusLine = `${statusLine} • paylaşılan`;
-      }
     }
     return (
       <TouchableOpacity
@@ -216,12 +207,6 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
                 {list.owned.map(renderDevice)}
               </View>
             )}
-            {list.shared.length > 0 && (
-              <View style={styles.section}>
-                <Text style={styles.sectionTitle}>Paylaşılan (guest)</Text>
-                {list.shared.map(renderDevice)}
-              </View>
-            )}
             {error && <Text style={styles.error}>{error}</Text>}
           </>
         )}

package/src/P2PClient.ts

@@ -23,6 +23,17 @@ function unrefTimer(timer: ReturnType<typeof setTimeout>): void {
   }
 }
 
+async function dogfoodFetch(url: string, init: RequestInit, timeoutMs: number): Promise<Response> {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  unrefTimer(timer);
+  try {
+    return await fetch(url, { ...init, signal: ctrl.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 export interface FeedbackEvent {
   type: string;
   timestamp: string;
@@ -38,6 +49,56 @@ export interface ReloadAck {
   changeClass?: string;
 }
 
+export interface DogfoodDevServerStatus {
+  running?: boolean;
+  serving?: boolean;
+  starting?: boolean;
+  building?: boolean;
+  framework?: string;
+  workDir?: string;
+  bundleUrl?: string;
+  previewUrl?: string;
+  error?: string;
+  capabilityGap?: unknown;
+}
+
+export interface DogfoodDevEvent {
+  type: string;
+  framework?: string;
+  logLine?: string;
+  message?: string;
+  phase?: string;
+  pct?: number;
+  currentFile?: string;
+  snapshot?: { recentLogs?: string[]; [key: string]: unknown };
+  [key: string]: unknown;
+}
+
+export interface DogfoodRemoteRuntimeTarget {
+  id: string;
+  label: string;
+  enabled: boolean;
+  reason?: string;
+  platform?: string;
+  surface?: string;
+  displaySurface?: string;
+}
+
+export interface DogfoodRemoteRuntimeCapabilities {
+  remoteRuntimeEligible?: boolean;
+  targets: DogfoodRemoteRuntimeTarget[];
+}
+
+export interface DogfoodRemoteRuntimeSession {
+  id: string;
+  status: string;
+  targetId?: string;
+  targetLabel?: string;
+  transportMode?: string;
+  note?: string;
+  [key: string]: unknown;
+}
+
 /**
  * Try to resolve `{projectName, bundleId}` for the running app so the
  * agent can map the reload request to a MobileProject in its scan
@@ -409,6 +470,37 @@ export class P2PClient {
     return Array.isArray(data.runners) ? (data.runners as RunnerAuthStatusRow[]) : [];
   }
 
+  /** Canonical runner + model catalogue used by Vibing routing controls. */
+  async getAvailableRunners(): Promise<RunnerAuthStatusRow[]> {
+    const resp = await fetch(`${this.baseUrl}/agent/runners`, {
+      headers: this.authHeaders(),
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      throw new Error(`getAvailableRunners HTTP ${resp.status}: ${text}`);
+    }
+    const data = await resp.json().catch(() => ({} as Record<string, unknown>));
+    return Array.isArray(data.runners) ? (data.runners as RunnerAuthStatusRow[]) : [];
+  }
+
+  /** Discovered runnable projects on the selected owner machine. Paths stay
+   * on that machine/transport; they are never registered in Yaver's backend. */
+  async listDogfoodProjects(): Promise<Array<{
+    name: string;
+    path: string;
+    framework?: string;
+    frameworks?: string[];
+    surfaces?: string[];
+  }>> {
+    const resp = await fetch(`${this.baseUrl}/projects`, { headers: this.authHeaders() });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => '');
+      throw new Error(`listDogfoodProjects HTTP ${resp.status}: ${body}`);
+    }
+    const data = await resp.json().catch(() => ({} as Record<string, unknown>));
+    return Array.isArray(data.projects) ? data.projects : [];
+  }
+
   async getOpenCodeConfig(): Promise<OpenCodeConfigSummary | null> {
     const resp = await fetch(`${this.baseUrl}/runner/opencode/config`, {
       headers: this.authHeaders(),
@@ -727,6 +819,205 @@ export class P2PClient {
     }
   }
 
+  /**
+   * Start the ordinary Projects runtime for an embedded Dogfood host.
+   * Requires a full signed-in-user token because /dev/start can spawn tools;
+   * a narrow feedback SDK token intentionally cannot use it.
+   */
+  async startDogfoodDevServer(input: {
+    framework: string;
+    workDir: string;
+    lane: 'browser' | 'hermes';
+  }): Promise<DogfoodDevServerStatus> {
+    if (input.lane === 'hermes') {
+      const ack = await this.reloadApp('bundle', { projectPath: input.workDir });
+      return { running: ack.ok, framework: input.framework, workDir: input.workDir };
+    }
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 45_000);
+    unrefTimer(timer);
+    try {
+      const response = await fetch(`${this.baseUrl}/dev/start`, {
+        method: 'POST',
+        headers: this.authHeaders({ 'Content-Type': 'application/json' }),
+        body: JSON.stringify({
+          framework: input.framework,
+          workDir: input.workDir,
+          platform: 'web',
+          caller: 'sdk',
+        }),
+        signal: ctrl.signal,
+      });
+      const data = (await response.json().catch(() => ({}))) as DogfoodDevServerStatus & {
+        code?: string; remedy?: string; retryable?: boolean;
+      };
+      if (!response.ok) {
+        const error = new Error(data.error || `Dogfood preview start failed with HTTP ${response.status}`) as Error & {
+          code?: string; remedy?: string; retryable?: boolean; capabilityGap?: unknown;
+        };
+        error.code = data.code || `DOGFOOD_DEV_START_HTTP_${response.status}`;
+        error.remedy = data.remedy || 'Fix the named dev-server failure, then retry Dogfood.';
+        error.retryable = data.retryable !== false;
+        error.capabilityGap = data.capabilityGap;
+        throw error;
+      }
+      return data;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  /** Full status for Dogfood startup; unlike the compact feedback snapshot,
+   * this retains render URLs and structured startup failures. */
+  async getDogfoodDevServerStatus(): Promise<DogfoodDevServerStatus | null> {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 10_000);
+    unrefTimer(timer);
+    try {
+      const response = await fetch(`${this.baseUrl}${AGENT_ENDPOINTS.devStatus}`, {
+        headers: this.authHeaders(),
+        signal: ctrl.signal,
+      });
+      if (!response.ok) return null;
+      return await response.json().catch(() => null) as DogfoodDevServerStatus | null;
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  async getDogfoodRemoteRuntimeCapabilities(
+    workDir: string,
+    framework: string,
+  ): Promise<DogfoodRemoteRuntimeCapabilities> {
+    const query = `?workDir=${encodeURIComponent(workDir)}&framework=${encodeURIComponent(framework)}`;
+    const response = await dogfoodFetch(`${this.baseUrl}/remote-runtime/capabilities${query}`, {
+      headers: this.authHeaders(),
+    }, 20_000);
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(data?.error || `Remote-runtime capabilities failed with HTTP ${response.status}`);
+    return { ...data, targets: Array.isArray(data?.targets) ? data.targets : [] };
+  }
+
+  async startDogfoodRemoteRuntime(
+    workDir: string,
+    framework: string,
+    targetId: string,
+  ): Promise<DogfoodRemoteRuntimeSession> {
+    const response = await dogfoodFetch(`${this.baseUrl}/remote-runtime/sessions`, {
+      method: 'POST',
+      headers: this.authHeaders({ 'Content-Type': 'application/json' }),
+      body: JSON.stringify({ workDir, framework, targetId, surface: 'sdk' }),
+    }, 45_000);
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(data?.error || `Remote-runtime start failed with HTTP ${response.status}`);
+    return data as DogfoodRemoteRuntimeSession;
+  }
+
+  async stopDogfoodRemoteRuntime(sessionId: string): Promise<void> {
+    const response = await dogfoodFetch(`${this.baseUrl}/remote-runtime/sessions/${encodeURIComponent(sessionId)}`, {
+      method: 'DELETE', headers: this.authHeaders(),
+    }, 15_000);
+    if (!response.ok) throw new Error(`Remote-runtime stop failed with HTTP ${response.status}`);
+  }
+
+  /** Stop the runtime this SDK host started. Full user auth, same as start. */
+  async stopDogfoodDevServer(): Promise<void> {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 15_000);
+    unrefTimer(timer);
+    try {
+      const response = await fetch(`${this.baseUrl}/dev/stop`, {
+        method: 'POST', headers: this.authHeaders(), signal: ctrl.signal,
+      });
+      if (!response.ok) throw new Error(`Dogfood preview stop failed with HTTP ${response.status}`);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  /** Resolve an agent-reported /dev/ or /dev-web/ route without putting auth in the URL. */
+  resolveDogfoodUrl(path: string): string {
+    return new URL(path, `${this.baseUrl.replace(/\/+$/, '')}/`).toString();
+  }
+
+  /**
+   * React-Native-safe /dev/events stream. XHR is intentional: Hermes fetch
+   * exposes no streaming response body. Reconnects are bounded and every
+   * reconnect/loss is surfaced to the host console.
+   */
+  subscribeDogfoodDevEvents(
+    onEvent: (event: DogfoodDevEvent) => void,
+    onHealth?: (health: { kind: 'reattaching' | 'lost'; message: string } | null) => void,
+  ): () => void {
+    let disposed = false;
+    let xhr: XMLHttpRequest | null = null;
+    let retryTimer: ReturnType<typeof setTimeout> | null = null;
+    let attempt = 0;
+
+    const open = () => {
+      if (disposed) return;
+      const request = new XMLHttpRequest();
+      xhr = request;
+      let parsed = 0;
+      let carry = '';
+      const consume = () => {
+        const text = request.responseText || '';
+        if (text.length <= parsed) return;
+        carry += text.slice(parsed);
+        parsed = text.length;
+        const normalized = carry.replace(/\r\n/g, '\n');
+        const frames = normalized.split('\n\n');
+        carry = frames.pop() || '';
+        for (const frame of frames) {
+          const data = frame.split('\n')
+            .filter((line) => line.startsWith('data:'))
+            .map((line) => line.slice(5).replace(/^ /, ''))
+            .join('\n');
+          if (!data) continue;
+          try {
+            attempt = 0;
+            onHealth?.(null);
+            onEvent(JSON.parse(data));
+          } catch { /* comments and non-JSON keepalives are valid SSE */ }
+        }
+      };
+      const reconnect = (reason: string) => {
+        if (disposed) return;
+        if (attempt >= 5) {
+          onHealth?.({ kind: 'lost', message: `Dev-server logs stopped: ${reason}` });
+          return;
+        }
+        const wait = Math.min(8_000, 500 * (2 ** attempt));
+        attempt += 1;
+        onHealth?.({ kind: 'reattaching', message: `Dev-server logs interrupted; reconnecting (${attempt}/5): ${reason}` });
+        retryTimer = setTimeout(open, wait);
+        unrefTimer(retryTimer);
+      };
+      request.open('GET', `${this.baseUrl}/dev/events`, true);
+      for (const [key, value] of Object.entries(this.authHeaders({ Accept: 'text/event-stream' }))) {
+        try { request.setRequestHeader(key, value); } catch { /* restricted RN header */ }
+      }
+      request.onprogress = consume;
+      request.onload = () => { consume(); reconnect(`HTTP ${request.status || 0}`); };
+      request.onerror = () => reconnect('connection failed');
+      request.onabort = () => reconnect('connection aborted');
+      request.ontimeout = () => reconnect('connection timed out');
+      try {
+        request.send();
+      } catch (error) {
+        reconnect(error instanceof Error ? error.message : 'connection could not start');
+      }
+    };
+    open();
+    return () => {
+      disposed = true;
+      if (retryTimer) clearTimeout(retryTimer);
+      try { xhr?.abort(); } catch { /* idempotent */ }
+    };
+  }
+
   /**
    * Trigger a reload with an EXPLICIT fast/full mode — no bundle fallback.
    *
@@ -737,8 +1028,8 @@ export class P2PClient {
    * 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.
+   * registered under `authSDK` in desktop/agent/httpserver.go and is already
+   * in the `reload` SDK-token scope list — nothing widens.
    */
   async reloadWithMode(
     mode: ReloadWireMode,
@@ -864,14 +1155,14 @@ export class P2PClient {
    * the project context plus the user's prompt. Returns the task id the
    * caller can poll via `/tasks/{id}` if needed.
    *
-   * Requires an owner/CLI/paired token — the `/vibing*` routes do not
+   * Requires an owner/CLI token — the `/vibing*` routes do not
    * currently accept SDK-minted tokens. Power users typically drive
    * vibing from Claude Code / the Yaver mobile app; this method is a
    * convenience for the SDK's one-tap bug-report-to-vibing path.
    */
   async vibing(
     prompt: string,
-    opts?: { projectName?: string; bundleId?: string; projectPath?: string },
+    opts?: { projectName?: string; bundleId?: string; projectPath?: string; runner?: string; model?: string },
   ): Promise<{ taskId: string }> {
     // Resolve app identity exactly the same way we do for
     // reloadApp — bundle ID from expo-constants or native config.
@@ -889,6 +1180,8 @@ export class P2PClient {
         projectPath: identity.projectPath ?? opts?.projectPath ?? '',
         projectName: identity.projectName,
         bundleId: identity.bundleId,
+        runner: opts?.runner,
+        model: opts?.model,
       }),
     });
     if (!response.ok) {
@@ -1189,6 +1482,56 @@ export class P2PClient {
     return { taskId: json.taskId, raw: json };
   }
 
+  /** Existing task history, filtered by the agent to Vibing/feedback topics. */
+  async listVibeThreads(input?: { projectName?: string; projectPath?: string }): Promise<Array<{
+    id: string;
+    title: string;
+    status: string;
+    createdAt?: string;
+    projectName?: string;
+    turnCount?: number;
+  }>> {
+    const params = new URLSearchParams();
+    if (input?.projectName) params.set('projectName', input.projectName);
+    if (input?.projectPath) params.set('projectPath', input.projectPath);
+    const query = params.toString();
+    const resp = await fetch(`${this.baseUrl}/vibing/tasks${query ? `?${query}` : ''}`, {
+      headers: this.authHeaders(),
+    });
+    if (!resp.ok) throw new Error(`listVibeThreads HTTP ${resp.status}`);
+    const json = (await resp.json().catch(() => ({}))) as { tasks?: Array<any> };
+    return (json.tasks || []).map((task) => ({
+      id: String(task.id),
+      title: String(task.title || 'New topic'),
+      status: String(task.status || 'completed'),
+      createdAt: task.createdAt,
+      projectName: task.projectName,
+      turnCount: task.turnCount,
+    }));
+  }
+
+  async getVibeThread(taskId: string): Promise<{
+    id: string;
+    title: string;
+    status: string;
+    turns?: Array<{ role: 'user' | 'assistant'; content: string; timestamp?: string }>;
+  }> {
+    const resp = await fetch(`${this.baseUrl}/vibing/task/${encodeURIComponent(taskId)}`, {
+      headers: this.authHeaders(),
+    });
+    if (!resp.ok) throw new Error(`getVibeThread HTTP ${resp.status}`);
+    const json = (await resp.json().catch(() => ({}))) as { task?: any };
+    return json.task || json as any;
+  }
+
+  async deleteVibeThread(taskId: string): Promise<void> {
+    const resp = await fetch(`${this.baseUrl}/vibing/task/${encodeURIComponent(taskId)}`, {
+      method: 'DELETE',
+      headers: this.authHeaders(),
+    });
+    if (!resp.ok) throw new Error(`deleteVibeThread HTTP ${resp.status}`);
+  }
+
   /**
    * Subscribe to a task's live stdout/stderr stream. Returns an abort
    * function — call it to detach. The agent emits NDJSON lines on

package/src/P2PDogfoodDriver.ts

@@ -0,0 +1,132 @@
+import type { P2PClient } from './P2PClient';
+import {
+  DogfoodRuntimeError,
+  runtimeLogLinesFromDevEvent,
+  type DogfoodDriver,
+} from './DogfoodRuntime';
+
+const delay = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+function reportedPreview(status: { previewUrl?: string; bundleUrl?: string }): string {
+  return String(status.previewUrl || status.bundleUrl || '').trim();
+}
+
+export interface P2PDogfoodDriverOptions {
+  startupTimeoutMs?: number;
+  pollIntervalMs?: number;
+}
+
+/**
+ * Ready-to-use driver for app owners who authenticate with Yaver's normal
+ * account flow. Their UI owns the trigger and preview surface; this adapter
+ * owns the existing Projects endpoints and raw build log stream.
+ */
+export function createP2PDogfoodDriver(
+  client: P2PClient,
+  options: P2PDogfoodDriverOptions = {},
+): DogfoodDriver {
+  const startupTimeoutMs = Math.max(1, options.startupTimeoutMs ?? 155_000);
+  const pollIntervalMs = Math.max(1, options.pollIntervalMs ?? 600);
+  return {
+    async prepare(context) {
+      const close = client.subscribeDogfoodDevEvents(
+        (event) => runtimeLogLinesFromDevEvent(event).forEach((line) => context.log(line)),
+        (health) => {
+          if (health) context.log({ text: `[logs] ${health.message}`, at: Date.now(), stream: 'system' });
+        },
+      );
+      context.registerCleanup(close, 'transient');
+    },
+    async start(context) {
+      const { project } = context;
+      if (project.lane === 'webrtc') {
+        context.setPhase('starting', `Finding a native runtime for ${project.name}…`);
+        const capabilities = await client.getDogfoodRemoteRuntimeCapabilities(project.workDir, project.framework);
+        const nativeTargets = capabilities.targets.filter((target) => target.enabled && target.id !== 'browser-window');
+        const target = project.nativeTargetId
+          ? nativeTargets.find((candidate) => candidate.id === project.nativeTargetId)
+          : nativeTargets[0];
+        if (!target) {
+          throw new DogfoodRuntimeError({
+            code: 'DOGFOOD_NATIVE_RUNTIME_UNAVAILABLE',
+            error: project.nativeTargetId
+              ? `Native runtime ${project.nativeTargetId} is not available.`
+              : 'No native simulator, emulator, or device runtime is available.',
+            remedy: 'Start or install a native runtime on the selected machine, then retry WebRTC; Browser lane remains available.',
+            retryable: true,
+          });
+        }
+        context.setPhase('starting', `Starting ${target.label} over WebRTC…`);
+        const session = await client.startDogfoodRemoteRuntime(project.workDir, project.framework, target.id);
+        context.registerCleanup(() => client.stopDogfoodRemoteRuntime(session.id), 'session');
+        return {
+          lane: 'webrtc',
+          sessionId: session.id,
+          metadata: { target, session, framework: project.framework, workDir: project.workDir },
+        };
+      }
+      context.setPhase(project.lane === 'hermes' ? 'compiling' : 'starting',
+        project.lane === 'hermes' ? `Compiling ${project.name} with Hermes…` : `Starting ${project.name} in the browser…`);
+      const status = await client.startDogfoodDevServer({
+        framework: project.framework,
+        workDir: project.workDir,
+        lane: project.lane,
+      });
+      // Browser Dogfood owns a long-lived dev server. Hermes is a one-shot
+      // build + delivery to the Yaver container; calling /dev/stop when that
+      // guest exits can kill an unrelated browser preview on the same box.
+      if (project.lane === 'browser') {
+        context.registerCleanup(() => client.stopDogfoodDevServer(), 'session');
+      }
+      if (status.error) {
+        throw new DogfoodRuntimeError({
+          code: 'DOGFOOD_DEV_SERVER_FAILED', error: status.error,
+          remedy: 'Fix the named project/runtime error, then retry Dogfood.', retryable: true,
+        });
+      }
+      let latest = status;
+      let reported = reportedPreview(latest);
+      if (project.lane === 'browser' && !reported) {
+        context.setPhase('compiling', `Compiling ${project.name} for the browser…`);
+        const deadline = Date.now() + startupTimeoutMs;
+        while (context.isCurrent() && Date.now() < deadline) {
+          await delay(pollIntervalMs);
+          const polled = await client.getDogfoodDevServerStatus();
+          if (!polled) continue;
+          latest = polled;
+          if (latest.error && !latest.building) {
+            throw new DogfoodRuntimeError({
+              code: 'DOGFOOD_DEV_SERVER_FAILED', error: latest.error,
+              remedy: 'Fix the named project/runtime error, then retry Dogfood.', retryable: true,
+            });
+          }
+          reported = reportedPreview(latest);
+          if (reported && (latest.running || latest.serving)) break;
+        }
+        if (!context.isCurrent()) {
+          throw new DogfoodRuntimeError({
+            code: 'DOGFOOD_ATTEMPT_REPLACED', error: 'A newer Dogfood attempt replaced this compile.',
+            remedy: 'Wait for the newer attempt.', retryable: true,
+          });
+        }
+        if (!reported) {
+          throw new DogfoodRuntimeError({
+            code: 'DOGFOOD_NO_RENDER_URL',
+            error: `The dev server did not report a browser preview URL within ${Math.ceil(startupTimeoutMs / 1000)} seconds.`,
+            remedy: 'Read the live npm/compiler output above, fix the named failure, then retry. Flutter uses `-d web-server`; Expo/RN needs react-native-web.',
+            retryable: true,
+          });
+        }
+      }
+      return {
+        lane: project.lane,
+        url: reported ? client.resolveDogfoodUrl(reported) : undefined,
+        metadata: {
+          framework: latest.framework || project.framework,
+          workDir: latest.workDir || project.workDir,
+          ...(project.lane === 'hermes' ? { delivered: latest.running === true } : {}),
+        },
+      };
+    },
+  };
+}

package/src/PairDeviceModal.tsx

@@ -28,9 +28,8 @@ import { getConvexSiteUrl, getToken } from './auth';
  *      report `needsAuth=false` in /devices/list.
  *
  * This avoids making the user bounce to the Yaver mobile app just to
- * adopt a machine. Works for owners and shared-scope guests since the
- * pair endpoint accepts any valid Convex session that matches the
- * expected account type.
+ * adopt one of their own machines. The pair endpoint verifies the signed-in
+ * account as the machine owner.
  */
 export interface PairDeviceModalProps {
   device: RemoteDevice | null;