yaver-feedback-react-native 0.9.2 → 0.9.3

package/dist/LoginScreen.d.ts

@@ -1,13 +1,9 @@
 import React from 'react';
 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;
 }
 /**
  * Full-screen in-SDK login. Mirrors the Yaver mobile app login UX: native

package/dist/LoginScreen.js

@@ -91,7 +91,7 @@ const iconStyles = react_native_1.StyleSheet.create({
  * Apple Sign-In on iOS, in-app browser OAuth for Google/GitHub/GitLab/
  * Microsoft (no codes, no leaving the app), and inline email/password.
  */
-const YaverLoginScreen = ({ onLoggedIn, onCancel, initialInviteCode, }) => {
+const YaverLoginScreen = ({ onLoggedIn, onCancel, }) => {
     const [busyProvider, setBusyProvider] = (0, react_1.useState)(null);
     const [showEmailForm, setShowEmailForm] = (0, react_1.useState)(false);
     const [isSignUp, setIsSignUp] = (0, react_1.useState)(false);
@@ -99,7 +99,6 @@ const YaverLoginScreen = ({ onLoggedIn, onCancel, initialInviteCode, }) => {
     const [email, setEmail] = (0, react_1.useState)('');
     const [password, setPassword] = (0, react_1.useState)('');
     const [confirmPassword, setConfirmPassword] = (0, react_1.useState)('');
-    const [inviteCode, setInviteCode] = (0, react_1.useState)((initialInviteCode ?? '').toUpperCase());
     const [emailBusy, setEmailBusy] = (0, react_1.useState)(false);
     const [emailError, setEmailError] = (0, react_1.useState)('');
     const finish = async (token) => {
@@ -107,8 +106,7 @@ const YaverLoginScreen = ({ onLoggedIn, onCancel, initialInviteCode, }) => {
         await (0, auth_1.saveToken)(token);
         if (user)
             await (0, auth_1.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 () => {
         setBusyProvider('apple');
@@ -218,8 +216,6 @@ const YaverLoginScreen = ({ onLoggedIn, onCancel, initialInviteCode, }) => {
                 <react_native_1.TextInput style={styles.input} placeholder="Email" placeholderTextColor="#666" value={email} onChangeText={setEmail} keyboardType="email-address" autoCapitalize="none" autoCorrect={false}/>
                 <react_native_1.TextInput style={styles.input} placeholder="Password" placeholderTextColor="#666" value={password} onChangeText={setPassword} secureTextEntry autoCapitalize="none"/>
                 {isSignUp && (<react_native_1.TextInput style={styles.input} placeholder="Confirm Password" placeholderTextColor="#666" value={confirmPassword} onChangeText={setConfirmPassword} secureTextEntry/>)}
-                {isSignUp && (<react_native_1.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 ? (<react_native_1.Text style={styles.errorText}>{emailError}</react_native_1.Text>) : null}
 
                 <react_native_1.Pressable style={({ pressed }) => [

package/dist/MachinePickerScreen.d.ts

@@ -8,9 +8,7 @@ export interface YaverMachinePickerProps {
     onCancel?: () => void;
 }
 /**
- * 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 +

package/dist/MachinePickerScreen.js

@@ -39,9 +39,7 @@ const react_native_1 = require("react-native");
 const auth_1 = require("./auth");
 const PairDeviceModal_1 = require("./PairDeviceModal");
 /**
- * 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 +
@@ -51,7 +49,7 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
     const [loading, setLoading] = (0, react_1.useState)(true);
     const [refreshing, setRefreshing] = (0, react_1.useState)(false);
     const [error, setError] = (0, react_1.useState)(null);
-    const [list, setList] = (0, react_1.useState)({ owned: [], shared: [] });
+    const [list, setList] = (0, react_1.useState)({ owned: [] });
     const [pairingDevice, setPairingDevice] = (0, react_1.useState)(null);
     const [reachability, setReachability] = (0, react_1.useState)({});
     const load = (0, react_1.useCallback)(async (silent = false) => {
@@ -63,7 +61,7 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
             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,
                     result: await (0, auth_1.probeDeviceReachability)(device),
@@ -78,8 +76,8 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
                     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) {
@@ -165,14 +163,8 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
             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 (<react_native_1.TouchableOpacity key={device.deviceId} style={[styles.deviceRow, selected && styles.deviceSelected]} onPress={() => handlePick(device)}>
         <react_native_1.View style={[styles.health, { backgroundColor: healthColor }]}/>
@@ -200,10 +192,6 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
                 <react_native_1.Text style={styles.sectionTitle}>Kendi makinelerim</react_native_1.Text>
                 {list.owned.map(renderDevice)}
               </react_native_1.View>)}
-            {list.shared.length > 0 && (<react_native_1.View style={styles.section}>
-                <react_native_1.Text style={styles.sectionTitle}>Paylaşılan (guest)</react_native_1.Text>
-                {list.shared.map(renderDevice)}
-              </react_native_1.View>)}
             {error && <react_native_1.Text style={styles.error}>{error}</react_native_1.Text>}
           </>)}
       </react_native_1.ScrollView>

package/dist/P2PClient.d.ts

@@ -13,6 +13,54 @@ export interface ReloadAck {
     nativeChangesDetected?: boolean;
     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
@@ -120,6 +168,17 @@ export declare class P2PClient {
      *  RunnerAuthModal.tsx and the Swift YaverRunnerAuthFlowPane. */
     submitRunnerBrowserAuthCode(sessionId: string, code: string): Promise<RunnerBrowserAuthSession>;
     getRunnerAuthStatus(): Promise<RunnerAuthStatusRow[]>;
+    /** Canonical runner + model catalogue used by Vibing routing controls. */
+    getAvailableRunners(): Promise<RunnerAuthStatusRow[]>;
+    /** Discovered runnable projects on the selected owner machine. Paths stay
+     * on that machine/transport; they are never registered in Yaver's backend. */
+    listDogfoodProjects(): Promise<Array<{
+        name: string;
+        path: string;
+        framework?: string;
+        frameworks?: string[];
+        surfaces?: string[];
+    }>>;
     getOpenCodeConfig(): Promise<OpenCodeConfigSummary | null>;
     saveOpenCodeConfig(patch: {
         defaultAgent?: string;
@@ -212,6 +271,35 @@ export declare class P2PClient {
      * Those are two different problems with two different fixes.
      */
     getDevServerStatus(): Promise<DevServerSnapshot | null>;
+    /**
+     * 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.
+     */
+    startDogfoodDevServer(input: {
+        framework: string;
+        workDir: string;
+        lane: 'browser' | 'hermes';
+    }): Promise<DogfoodDevServerStatus>;
+    /** Full status for Dogfood startup; unlike the compact feedback snapshot,
+     * this retains render URLs and structured startup failures. */
+    getDogfoodDevServerStatus(): Promise<DogfoodDevServerStatus | null>;
+    getDogfoodRemoteRuntimeCapabilities(workDir: string, framework: string): Promise<DogfoodRemoteRuntimeCapabilities>;
+    startDogfoodRemoteRuntime(workDir: string, framework: string, targetId: string): Promise<DogfoodRemoteRuntimeSession>;
+    stopDogfoodRemoteRuntime(sessionId: string): Promise<void>;
+    /** Stop the runtime this SDK host started. Full user auth, same as start. */
+    stopDogfoodDevServer(): Promise<void>;
+    /** Resolve an agent-reported /dev/ or /dev-web/ route without putting auth in the URL. */
+    resolveDogfoodUrl(path: string): string;
+    /**
+     * 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;
     /**
      * Trigger a reload with an EXPLICIT fast/full mode — no bundle fallback.
      *
@@ -222,8 +310,8 @@ export declare 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.
      */
     reloadWithMode(mode: ReloadWireMode, snapshot?: DevServerSnapshot | null): Promise<ReloadAck>;
     reloadApp(mode?: 'dev' | 'bundle', opts?: {
@@ -237,7 +325,7 @@ export declare 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.
@@ -246,6 +334,8 @@ export declare class P2PClient {
         projectName?: string;
         bundleId?: string;
         projectPath?: string;
+        runner?: string;
+        model?: string;
     }): Promise<{
         taskId: string;
     }>;
@@ -365,6 +455,29 @@ export declare class P2PClient {
         taskId: string;
         raw?: unknown;
     }>;
+    /** Existing task history, filtered by the agent to Vibing/feedback topics. */
+    listVibeThreads(input?: {
+        projectName?: string;
+        projectPath?: string;
+    }): Promise<Array<{
+        id: string;
+        title: string;
+        status: string;
+        createdAt?: string;
+        projectName?: string;
+        turnCount?: number;
+    }>>;
+    getVibeThread(taskId: string): Promise<{
+        id: string;
+        title: string;
+        status: string;
+        turns?: Array<{
+            role: 'user' | 'assistant';
+            content: string;
+            timestamp?: string;
+        }>;
+    }>;
+    deleteVibeThread(taskId: string): Promise<void>;
     /**
      * Subscribe to a task's live stdout/stderr stream. Returns an abort
      * function — call it to detach. The agent emits NDJSON lines on

package/dist/P2PClient.js

@@ -45,6 +45,17 @@ function unrefTimer(timer) {
         maybeNodeTimer.unref();
     }
 }
+async function dogfoodFetch(url, init, timeoutMs) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    unrefTimer(timer);
+    try {
+        return await fetch(url, { ...init, signal: ctrl.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 /**
  * Try to resolve `{projectName, bundleId}` for the running app so the
  * agent can map the reload request to a MobileProject in its scan
@@ -378,6 +389,29 @@ class P2PClient {
         const data = await resp.json().catch(() => ({}));
         return Array.isArray(data.runners) ? data.runners : [];
     }
+    /** Canonical runner + model catalogue used by Vibing routing controls. */
+    async getAvailableRunners() {
+        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(() => ({}));
+        return Array.isArray(data.runners) ? data.runners : [];
+    }
+    /** Discovered runnable projects on the selected owner machine. Paths stay
+     * on that machine/transport; they are never registered in Yaver's backend. */
+    async listDogfoodProjects() {
+        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(() => ({}));
+        return Array.isArray(data.projects) ? data.projects : [];
+    }
     async getOpenCodeConfig() {
         const resp = await fetch(`${this.baseUrl}/runner/opencode/config`, {
             headers: this.authHeaders(),
@@ -662,6 +696,200 @@ class P2PClient {
             return null;
         }
     }
+    /**
+     * 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) {
+        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(), 45000);
+        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(() => ({})));
+            if (!response.ok) {
+                const error = new Error(data.error || `Dogfood preview start failed with HTTP ${response.status}`);
+                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() {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 10000);
+        unrefTimer(timer);
+        try {
+            const response = await fetch(`${this.baseUrl}${endpoints_1.AGENT_ENDPOINTS.devStatus}`, {
+                headers: this.authHeaders(),
+                signal: ctrl.signal,
+            });
+            if (!response.ok)
+                return null;
+            return await response.json().catch(() => null);
+        }
+        catch {
+            return null;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async getDogfoodRemoteRuntimeCapabilities(workDir, framework) {
+        const query = `?workDir=${encodeURIComponent(workDir)}&framework=${encodeURIComponent(framework)}`;
+        const response = await dogfoodFetch(`${this.baseUrl}/remote-runtime/capabilities${query}`, {
+            headers: this.authHeaders(),
+        }, 20000);
+        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, framework, targetId) {
+        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' }),
+        }, 45000);
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok)
+            throw new Error(data?.error || `Remote-runtime start failed with HTTP ${response.status}`);
+        return data;
+    }
+    async stopDogfoodRemoteRuntime(sessionId) {
+        const response = await dogfoodFetch(`${this.baseUrl}/remote-runtime/sessions/${encodeURIComponent(sessionId)}`, {
+            method: 'DELETE', headers: this.authHeaders(),
+        }, 15000);
+        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() {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 15000);
+        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) {
+        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, onHealth) {
+        let disposed = false;
+        let xhr = null;
+        let retryTimer = 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) => {
+                if (disposed)
+                    return;
+                if (attempt >= 5) {
+                    onHealth?.({ kind: 'lost', message: `Dev-server logs stopped: ${reason}` });
+                    return;
+                }
+                const wait = Math.min(8000, 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.
      *
@@ -672,8 +900,8 @@ 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, snapshot) {
         if (mode === 'bundle')
@@ -785,7 +1013,7 @@ 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.
@@ -807,6 +1035,8 @@ class P2PClient {
                 projectPath: identity.projectPath ?? opts?.projectPath ?? '',
                 projectName: identity.projectName,
                 bundleId: identity.bundleId,
+                runner: opts?.runner,
+                model: opts?.model,
             }),
         });
         if (!response.ok) {
@@ -1047,6 +1277,46 @@ class P2PClient {
         }
         return { taskId: json.taskId, raw: json };
     }
+    /** Existing task history, filtered by the agent to Vibing/feedback topics. */
+    async listVibeThreads(input) {
+        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(() => ({})));
+        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) {
+        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(() => ({})));
+        return json.task || json;
+    }
+    async deleteVibeThread(taskId) {
+        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/dist/P2PDogfoodDriver.d.ts

@@ -0,0 +1,12 @@
+import type { P2PClient } from './P2PClient';
+import { type DogfoodDriver } from './DogfoodRuntime';
+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 declare function createP2PDogfoodDriver(client: P2PClient, options?: P2PDogfoodDriverOptions): DogfoodDriver;