yaver-feedback-react-native 0.9.2 → 0.9.3

package/dist/__tests__/DogfoodRuntime.test.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DogfoodRuntime_1 = require("../DogfoodRuntime");
+const expo = {
+    name: 'Example', workDir: '/workspace/example', framework: 'expo', lane: 'browser',
+};
+describe('DogfoodController', () => {
+    test('does no work before the explicit trigger', () => {
+        const driver = { start: jest.fn(async () => ({ lane: 'browser' })) };
+        const controller = new DogfoodRuntime_1.DogfoodController(expo, driver);
+        expect(driver.start).not.toHaveBeenCalled();
+        expect(controller.snapshot().phase).toBe('idle');
+    });
+    test('preserves raw npm output and hands a live session to the host', async () => {
+        const stop = jest.fn();
+        const closeLogs = jest.fn();
+        const controller = new DogfoodRuntime_1.DogfoodController(expo, {
+            async start(ctx) {
+                ctx.registerCleanup(stop, 'session');
+                ctx.registerCleanup(closeLogs, 'transient');
+                ctx.log('$ npm install --legacy-peer-deps');
+                ctx.log('npm warn deprecated example@1.0.0');
+                return { lane: 'browser', sessionId: 's1', url: 'http://agent/dev/' };
+            },
+        });
+        await controller.trigger();
+        expect(controller.snapshot().logs.map((line) => line.text)).toEqual([
+            '$ npm install --legacy-peer-deps',
+            'npm warn deprecated example@1.0.0',
+        ]);
+        expect(await controller.handoff()).toMatchObject({ sessionId: 's1' });
+        expect(closeLogs).toHaveBeenCalledTimes(1);
+        expect(stop).not.toHaveBeenCalled();
+    });
+    test('cleans a partial session before exposing a structured failure', async () => {
+        const stop = jest.fn();
+        const controller = new DogfoodRuntime_1.DogfoodController(expo, {
+            async start(ctx) {
+                ctx.registerCleanup(stop);
+                throw new DogfoodRuntime_1.DogfoodRuntimeError({
+                    code: 'DOGFOOD_RENDER_FAILED', error: 'Metro exited', remedy: 'Fix Metro and retry.', retryable: true,
+                });
+            },
+        });
+        await expect(controller.trigger()).rejects.toThrow('Metro exited');
+        expect(stop).toHaveBeenCalledTimes(1);
+        expect(controller.snapshot()).toMatchObject({ phase: 'failed', failure: { code: 'DOGFOOD_RENDER_FAILED' } });
+    });
+    test('an obsolete attempt cannot clean up the replacement attempt', async () => {
+        let releaseFirst;
+        const firstGate = new Promise((resolve) => { releaseFirst = resolve; });
+        let firstStarted;
+        const firstStartedGate = new Promise((resolve) => { firstStarted = resolve; });
+        const stopFirst = jest.fn();
+        const stopSecond = jest.fn();
+        let starts = 0;
+        const controller = new DogfoodRuntime_1.DogfoodController(expo, {
+            async start(ctx) {
+                starts += 1;
+                if (starts === 1) {
+                    ctx.registerCleanup(stopFirst);
+                    firstStarted();
+                    await firstGate;
+                    return { lane: 'browser', sessionId: 'old' };
+                }
+                ctx.registerCleanup(stopSecond);
+                return { lane: 'browser', sessionId: 'new' };
+            },
+        });
+        const old = controller.trigger();
+        await firstStartedGate;
+        await controller.stop();
+        await expect(controller.trigger()).resolves.toMatchObject({ sessionId: 'new' });
+        releaseFirst();
+        await expect(old).rejects.toMatchObject({ failure: { code: 'DOGFOOD_ATTEMPT_REPLACED' } });
+        expect(stopFirst).toHaveBeenCalledTimes(1);
+        expect(stopSecond).not.toHaveBeenCalled();
+        await controller.stop();
+        expect(stopSecond).toHaveBeenCalledTimes(1);
+    });
+});
+describe('Dogfood lanes and console events', () => {
+    test('Flutter is first-class on browser but cannot be mislabeled Hermes', () => {
+        expect((0, DogfoodRuntime_1.validateDogfoodProject)({ ...expo, framework: 'flutter', lane: 'browser' })).toBeNull();
+        expect((0, DogfoodRuntime_1.validateDogfoodProject)({ ...expo, framework: 'flutter', lane: 'hermes' })?.code)
+            .toBe('DOGFOOD_HERMES_FRAMEWORK_UNSUPPORTED');
+    });
+    test('uses one three-lane matrix with browser default for React Native and Flutter', () => {
+        const rn = (0, DogfoodRuntime_1.dogfoodLaneOptions)('expo', { nativeRuntimeAvailable: true });
+        expect((0, DogfoodRuntime_1.defaultDogfoodLane)('expo')).toBe('browser');
+        expect(rn.map((option) => [option.lane, option.supported])).toEqual([
+            ['browser', true], ['hermes', true], ['webrtc', true],
+        ]);
+        const flutter = (0, DogfoodRuntime_1.dogfoodLaneOptions)('flutter', { nativeRuntimeAvailable: true });
+        expect((0, DogfoodRuntime_1.defaultDogfoodLane)('flutter')).toBe('browser');
+        expect(flutter.find((option) => option.lane === 'hermes')?.supported).toBe(false);
+    });
+    test('keeps Yaver self-development on the same RN three-lane contract', () => {
+        const options = (0, DogfoodRuntime_1.dogfoodLaneOptions)('expo', { nativeRuntimeAvailable: true, selfDevelopment: true });
+        expect(options).toHaveLength(3);
+        expect(options.find((option) => option.lane === 'hermes')).toMatchObject({ supported: true });
+        expect(options.find((option) => option.lane === 'webrtc')).toMatchObject({ supported: true });
+    });
+    test('native-only projects use WebRTC rather than fake browser or Hermes lanes', () => {
+        const swift = (0, DogfoodRuntime_1.dogfoodLaneOptions)('swift', { nativeRuntimeAvailable: true });
+        expect(swift.map((option) => [option.lane, option.supported])).toEqual([
+            ['browser', false], ['hermes', false], ['webrtc', true],
+        ]);
+    });
+    test('reads raw and replayed package-manager logs from /dev/events', () => {
+        expect((0, DogfoodRuntime_1.dogfoodLogLinesFromDevEvent)({ type: 'log', logLine: '$ npm ci\u001b[0m' }))
+            .toEqual(['$ npm ci\u001b[0m']);
+        expect((0, DogfoodRuntime_1.dogfoodLogLinesFromDevEvent)({ type: 'snapshot', snapshot: { recentLogs: ['npm warn x', 'Metro ready'] } }))
+            .toEqual(['npm warn x', 'Metro ready']);
+    });
+});

package/dist/__tests__/P2PDogfoodDriver.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/P2PDogfoodDriver.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DogfoodRuntime_1 = require("../DogfoodRuntime");
+const P2PDogfoodDriver_1 = require("../P2PDogfoodDriver");
+describe('createP2PDogfoodDriver', () => {
+    it('keeps the browser lane compiling until the ordinary Projects status reports a URL', async () => {
+        const stop = jest.fn(async () => { });
+        const status = jest.fn()
+            .mockResolvedValueOnce({ building: true, framework: 'flutter' })
+            .mockResolvedValueOnce({ running: true, serving: true, framework: 'flutter', bundleUrl: '/dev/' });
+        const client = {
+            subscribeDogfoodDevEvents: (onEvent) => {
+                onEvent({ type: 'log', logLine: '$ flutter run -d web-server' });
+                return jest.fn();
+            },
+            startDogfoodDevServer: jest.fn(async () => ({ starting: true, framework: 'flutter' })),
+            getDogfoodDevServerStatus: status,
+            stopDogfoodDevServer: stop,
+            resolveDogfoodUrl: (path) => `http://agent.test${path}`,
+        };
+        const snapshots = [];
+        const controller = new DogfoodRuntime_1.DogfoodController({ name: 'Flutter app', framework: 'flutter', workDir: '/workspace/app', lane: 'browser' }, (0, P2PDogfoodDriver_1.createP2PDogfoodDriver)(client, { pollIntervalMs: 1, startupTimeoutMs: 100 }), { onChange: (snapshot) => snapshots.push(snapshot.logs.map((line) => line.text)) });
+        const result = await controller.trigger();
+        expect(result.url).toBe('http://agent.test/dev/');
+        expect(status).toHaveBeenCalledTimes(2);
+        expect(snapshots.flat()).toContain('$ flutter run -d web-server');
+        expect(stop).not.toHaveBeenCalled();
+        await controller.stop();
+        expect(stop).toHaveBeenCalledTimes(1);
+    });
+    it('starts and cleans up an available native WebRTC runtime', async () => {
+        const closeRuntime = jest.fn(async () => { });
+        const client = {
+            subscribeDogfoodDevEvents: () => jest.fn(),
+            getDogfoodRemoteRuntimeCapabilities: jest.fn(async () => ({
+                targets: [
+                    { id: 'browser-window', label: 'Browser', enabled: true },
+                    { id: 'ios-simulator', label: 'iPhone simulator', enabled: true },
+                ],
+            })),
+            startDogfoodRemoteRuntime: jest.fn(async () => ({
+                id: 'runtime-1', status: 'starting', targetId: 'ios-simulator',
+            })),
+            stopDogfoodRemoteRuntime: closeRuntime,
+        };
+        const controller = new DogfoodRuntime_1.DogfoodController({ name: 'Native app', framework: 'flutter', workDir: '/workspace/app', lane: 'webrtc' }, (0, P2PDogfoodDriver_1.createP2PDogfoodDriver)(client));
+        await expect(controller.trigger()).resolves.toMatchObject({ lane: 'webrtc', sessionId: 'runtime-1' });
+        expect(closeRuntime).not.toHaveBeenCalled();
+        await controller.stop();
+        expect(closeRuntime).toHaveBeenCalledWith('runtime-1');
+    });
+    it('delivers Hermes without stopping an unrelated dev server on exit', async () => {
+        const stop = jest.fn(async () => { });
+        const client = {
+            subscribeDogfoodDevEvents: () => jest.fn(),
+            startDogfoodDevServer: jest.fn(async () => ({ running: true, framework: 'expo', workDir: '/workspace/app' })),
+            stopDogfoodDevServer: stop,
+        };
+        const controller = new DogfoodRuntime_1.DogfoodController({ name: 'RN app', framework: 'expo', workDir: '/workspace/app', lane: 'hermes' }, (0, P2PDogfoodDriver_1.createP2PDogfoodDriver)(client));
+        await expect(controller.trigger()).resolves.toMatchObject({ lane: 'hermes', metadata: { delivered: true } });
+        await controller.stop();
+        expect(stop).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/ReportIdentity.test.d.ts

@@ -1 +1,25 @@
-export {};
+declare const mockReactNative: {
+    Platform: {
+        OS: string;
+    };
+    NativeModules: {};
+};
+declare const mockExpoModule: {
+    default: Record<string, unknown>;
+};
+/** Mirrors mobile/app.json in the Talos repo — the SDK's first external consumer. */
+declare const EXPO_CONFIG: {
+    name: string;
+    slug: string;
+    version: string;
+    ios: {
+        bundleIdentifier: string;
+        buildNumber: string;
+    };
+    android: {
+        package: string;
+        versionCode: number;
+    };
+};
+declare function mockExpoConstants(expoConfig: unknown, extra?: Record<string, unknown>): void;
+declare function loadResolve(): typeof import('../P2PClient').resolveReportIdentity;

package/dist/__tests__/ReportIdentity.test.js

@@ -1,14 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 // resolveAppIdentity() has always fed /vibing/execute and /dev/reload-app so
 // the agent could route "vibe on THIS app" to the right repo, but nothing fed
 // /feedback — reports carried no identity at all, so the agent's fix router
 // had nothing to resolve and fell back to whatever directory it was sitting
 // in. resolveReportIdentity() closes that gap for the feedback path.
-jest.mock('react-native', () => ({
+const mockReactNative = {
     Platform: { OS: 'ios' },
     NativeModules: {},
-}));
+};
+const mockExpoModule = { default: {} };
+jest.mock('react-native', () => mockReactNative);
+jest.mock('expo-constants', () => mockExpoModule, { virtual: true });
 /** Mirrors mobile/app.json in the Talos repo — the SDK's first external consumer. */
 const EXPO_CONFIG = {
     name: 'Talos',
@@ -18,15 +20,30 @@ const EXPO_CONFIG = {
     android: { package: 'works.talos.mobile', versionCode: 423 },
 };
 function mockExpoConstants(expoConfig, extra = {}) {
-    jest.doMock('expo-constants', () => ({ default: { expoConfig, ...extra } }), { virtual: true });
+    mockExpoModule.default = { expoConfig, ...extra };
+}
+function loadResolve() {
+    let resolve;
+    jest.isolateModules(() => {
+        jest.doMock('react-native', () => mockReactNative);
+        jest.doMock('expo-constants', () => mockExpoModule, { virtual: true });
+        resolve = require('../P2PClient').resolveReportIdentity;
+    });
+    return resolve;
 }
 beforeEach(() => {
+    // P2PClient is imported by many suites with different virtual RN/Expo
+    // modules. Re-evaluate it against this suite's mutable modules every time;
+    // an order-dependent green test is not an identity-routing guard.
     jest.resetModules();
+    mockReactNative.Platform.OS = 'ios';
+    mockReactNative.NativeModules = {};
+    mockExpoModule.default = {};
 });
 describe('resolveReportIdentity', () => {
     it('resolves app name and bundle id from the Expo config', () => {
         mockExpoConstants(EXPO_CONFIG);
-        const { resolveReportIdentity: resolve } = require('../P2PClient');
+        const resolve = loadResolve();
         const identity = resolve();
         // The agent's fix router reads DeviceInfo.AppName first.
         expect(identity.appName).toBe('Talos');
@@ -39,7 +56,7 @@ describe('resolveReportIdentity', () => {
     });
     it('never reports a project path', () => {
         mockExpoConstants(EXPO_CONFIG);
-        const { resolveReportIdentity: resolve } = require('../P2PClient');
+        const resolve = loadResolve();
         // The agent ignores client-supplied paths on feedback reports (an
         // untrusted guest could otherwise aim the fix task's CWD at ~/.ssh).
         // Sending one would be misleading at best.
@@ -47,7 +64,7 @@ describe('resolveReportIdentity', () => {
     });
     it('prefers the native runtime version over the manifest version', () => {
         mockExpoConstants(EXPO_CONFIG, { nativeAppVersion: '1.9.158', nativeBuildVersion: '428' });
-        const { resolveReportIdentity: resolve } = require('../P2PClient');
+        const resolve = loadResolve();
         const identity = resolve();
         // A stale manifest shouldn't misreport which build is actually running.
         expect(identity.app.version).toBe('1.9.158');
@@ -55,7 +72,7 @@ describe('resolveReportIdentity', () => {
     });
     it('falls back to the manifest version when no native version is exposed', () => {
         mockExpoConstants(EXPO_CONFIG);
-        const { resolveReportIdentity: resolve } = require('../P2PClient');
+        const resolve = loadResolve();
         const identity = resolve();
         expect(identity.app.version).toBe('1.9.157');
         expect(identity.app.buildNumber).toBe('427');
@@ -71,16 +88,13 @@ describe('resolveReportIdentity', () => {
             android: { package: 'io.yaver.mobile' },
         };
         function mockContainer(yaverInfo) {
-            jest.doMock('react-native', () => ({
-                Platform: { OS: 'ios' },
-                NativeModules: { YaverInfo: { isYaver: true, ...yaverInfo } },
-            }));
+            mockReactNative.NativeModules = { YaverInfo: { isYaver: true, ...yaverInfo } };
             // The host's manifest — what expo-constants answers for a guest bundle.
             mockExpoConstants(YAVER_CONFIG);
         }
         it("never reports the host's bundle id as the guest's", () => {
             mockContainer({ inheritedGuestProjectName: 'talos / mobile' });
-            const { resolveReportIdentity: resolve } = require('../P2PClient');
+            const resolve = loadResolve();
             const identity = resolve();
             // The agent routes on bundle id FIRST. Leaking io.yaver.mobile here
             // would resolve to yaver.io and the project name would never be read.
@@ -91,14 +105,14 @@ describe('resolveReportIdentity', () => {
         });
         it('reports the guest project Yaver pinned', () => {
             mockContainer({ inheritedGuestProjectName: 'talos / mobile' });
-            const { resolveReportIdentity: resolve } = require('../P2PClient');
+            const resolve = loadResolve();
             const identity = resolve();
             expect(identity.appName).toBe('talos / mobile');
             expect(identity.project?.projectName).toBe('talos / mobile');
         });
         it("lets the app's own declaration win over the pinned project", () => {
             mockContainer({ inheritedGuestProjectName: 'something-else' });
-            const { resolveReportIdentity: resolve } = require('../P2PClient');
+            const resolve = loadResolve();
             // A bundle knows its own identity; nothing ambient should override it.
             const identity = resolve({ projectName: 'Talos', bundleId: 'works.talos.mobile' });
             expect(identity.appName).toBe('Talos');
@@ -106,7 +120,7 @@ describe('resolveReportIdentity', () => {
         });
         it('reports nothing rather than something wrong when no project is pinned', () => {
             mockContainer({});
-            const { resolveReportIdentity: resolve } = require('../P2PClient');
+            const resolve = loadResolve();
             // Better for the agent to reject/fall back than to confidently edit
             // the wrong repo.
             const identity = resolve();
@@ -117,14 +131,14 @@ describe('resolveReportIdentity', () => {
     });
     it('lets an explicit declaration override the ambient identity', () => {
         mockExpoConstants(EXPO_CONFIG);
-        const { resolveReportIdentity: resolve } = require('../P2PClient');
+        const resolve = loadResolve();
         const identity = resolve({ projectName: 'Override', bundleId: 'com.override.app' });
         expect(identity.appName).toBe('Override');
         expect(identity.project?.bundleId).toBe('com.override.app');
     });
     it('passes declared surfaces stacks and voice metadata through', () => {
         mockExpoConstants(EXPO_CONFIG);
-        const { resolveReportIdentity: resolve } = require('../P2PClient');
+        const resolve = loadResolve();
         const identity = resolve({
             projectName: 'Omni',
             bundleId: 'io.example.omni',
@@ -156,10 +170,8 @@ describe('resolveReportIdentity', () => {
     it('omits the project block when nothing identifies the app', () => {
         // Bare RN with no expo-constants and no native modules. The report must
         // still upload — the agent just resolves it by its own means.
-        jest.doMock('expo-constants', () => {
-            throw new Error('not installed');
-        }, { virtual: true });
-        const { resolveReportIdentity: resolve } = require('../P2PClient');
+        mockExpoModule.default = {};
+        const resolve = loadResolve();
         const identity = resolve();
         expect(identity.project).toBeUndefined();
         expect(identity.appName).toBeUndefined();

package/dist/__tests__/YaverFeedback.test.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
 const YaverFeedback_1 = require("../YaverFeedback");
 // Mock react-native: DeviceEventEmitter for event dispatch + Platform so
 // ShakeDetector.start() can branch on iOS without hitting a real RN runtime.
@@ -33,13 +34,10 @@ jest.mock('../auth', () => ({
                 needsAuth: false,
                 runnerDown: false,
                 lastHeartbeat: Date.now(),
-                isGuest: false,
-                accessScope: 'owner',
                 quicHost: '127.0.0.1',
                 quicPort: 18080,
             },
         ],
-        shared: [],
     })),
     DEFAULT_CONVEX_SITE_URL: 'https://example.convex.site',
 }));
@@ -51,6 +49,18 @@ beforeEach(() => {
     jest.clearAllMocks();
 });
 describe('YaverFeedback', () => {
+    describe('Dogfood onboarding', () => {
+        it('starts with Yaver OAuth when the host has no session', () => {
+            YaverFeedback_1.YaverFeedback.init({ enabled: true });
+            YaverFeedback_1.YaverFeedback.beginDogfoodOnboarding({ appId: 'io.example.app', label: 'Example' });
+            expect(react_native_1.DeviceEventEmitter.emit).toHaveBeenCalledWith('yaverFeedback:startLogin');
+        });
+        it('asks for a machine after an existing OAuth session', () => {
+            YaverFeedback_1.YaverFeedback.init({ enabled: true, authToken: 'owner-token' });
+            YaverFeedback_1.YaverFeedback.beginDogfoodOnboarding({ appId: 'io.example.app', label: 'Example' });
+            expect(react_native_1.DeviceEventEmitter.emit).toHaveBeenCalledWith('yaverFeedback:startMachinePicker');
+        });
+    });
     describe('init()', () => {
         it('sets config correctly with defaults', () => {
             YaverFeedback_1.YaverFeedback.init({

package/dist/__tests__/deviceDogfood.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/deviceDogfood.test.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const buffer_1 = require("buffer");
+const crypto_1 = require("crypto");
+const deviceDogfood_1 = require("../deviceDogfood");
+class MemorySecureStore {
+    constructor() {
+        this.values = new Map();
+    }
+    async getItemAsync(key) { return this.values.get(key) ?? null; }
+    async setItemAsync(key, value) { this.values.set(key, value); }
+    async deleteItemAsync(key) { this.values.delete(key); }
+}
+function response(body, status = 200) {
+    return new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
+}
+describe('YaverDeviceDogfood', () => {
+    beforeAll(() => {
+        if (!globalThis.crypto)
+            globalThis.crypto = crypto_1.webcrypto;
+    });
+    afterEach(() => { jest.restoreAllMocks(); });
+    test('keeps identity stable and proves possession rather than trusting the UUID', async () => {
+        const store = new MemorySecureStore();
+        const client = new deviceDogfood_1.YaverDeviceDogfood({ appId: 'io.example.test', secureStore: store, backendUrl: 'https://dogfood.test' });
+        const first = await client.enrollmentInfo();
+        const second = await client.enrollmentInfo();
+        expect(second).toEqual(first);
+        let proof;
+        jest.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/dogfood/enroll/start'))
+                return response({ status: 'pending', challenge: 'server-nonce' });
+            if (url.endsWith('/dogfood/enroll/prove')) {
+                proof = JSON.parse(String(init?.body));
+                return response({ status: 'pending', proofVerified: true });
+            }
+            throw new Error(`unexpected URL ${url}`);
+        });
+        await client.enroll('ios');
+        const message = new TextEncoder().encode(`yaver-dogfood-enroll-v1\nio.example.test\n${first.installationId}\nserver-nonce`);
+        expect(tweetnacl_1.default.sign.detached.verify(message, new Uint8Array(buffer_1.Buffer.from(proof.signature, 'base64')), new Uint8Array(buffer_1.Buffer.from(first.publicKey, 'base64')))).toBe(true);
+        const attacker = tweetnacl_1.default.sign.keyPair();
+        expect(tweetnacl_1.default.sign.detached.verify(message, new Uint8Array(buffer_1.Buffer.from(proof.signature, 'base64')), attacker.publicKey)).toBe(false);
+    });
+    test('re-register rotates key and installation while preserving only the logical slot', async () => {
+        const store = new MemorySecureStore();
+        const client = new deviceDogfood_1.YaverDeviceDogfood({ appId: 'io.example.test', secureStore: store, backendUrl: 'https://dogfood.test' });
+        const before = await client.enrollmentInfo();
+        jest.spyOn(globalThis, 'fetch').mockImplementation(async (input) => {
+            if (String(input).endsWith('/dogfood/enroll/start'))
+                return response({ status: 'pending', challenge: 'rotate-nonce' });
+            return response({ status: 'pending', proofVerified: true });
+        });
+        await client.reRegister('ios');
+        const after = await client.enrollmentInfo();
+        expect(after.registrationSlot).toBe(before.registrationSlot);
+        expect(after.installationId).not.toBe(before.installationId);
+        expect(after.publicKey).not.toBe(before.publicKey);
+    });
+    test('exchanges an approved key proof for a short-lived scoped session', async () => {
+        const client = new deviceDogfood_1.YaverDeviceDogfood({ appId: 'io.example.test', secureStore: new MemorySecureStore(), backendUrl: 'https://dogfood.test' });
+        const identity = await client.enrollmentInfo();
+        let sessionProof;
+        jest.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
+            const url = String(input);
+            if (url.includes('/dogfood/enroll/status'))
+                return response({ status: 'active' });
+            if (url.endsWith('/dogfood/session/challenge'))
+                return response({ challenge: 'session-nonce' });
+            if (url.endsWith('/dogfood/session')) {
+                sessionProof = JSON.parse(String(init?.body));
+                return response({ token: 'short-token', expiresAt: 123, scopes: ['feedback', 'blackbox'], projectSlug: 'example' });
+            }
+            throw new Error(`unexpected URL ${url}`);
+        });
+        const session = await client.session();
+        expect(session).toMatchObject({ active: true, token: 'short-token', scopes: ['feedback', 'blackbox'] });
+        const message = new TextEncoder().encode(`yaver-dogfood-session-v1\nio.example.test\n${identity.installationId}\nsession-nonce`);
+        expect(tweetnacl_1.default.sign.detached.verify(message, new Uint8Array(buffer_1.Buffer.from(sessionProof.signature, 'base64')), new Uint8Array(buffer_1.Buffer.from(identity.publicKey, 'base64')))).toBe(true);
+    });
+});

package/dist/__tests__/dogfoodPolicy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/dogfoodPolicy.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dogfoodPolicy_1 = require("../dogfoodPolicy");
+describe('resolveSDKDogfood', () => {
+    it('fails closed unless Dogfood is explicitly enabled', () => {
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ accountIds: ['acct-1'], currentAccountId: 'acct-1' })).toMatchObject({
+            active: false,
+            code: 'SDK_DOGFOOD_DISABLED',
+        });
+    });
+    it('requires an exact approved app-account ID', () => {
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, accountIds: ['acct-1'], currentAccountId: '' }).code)
+            .toBe('SDK_DOGFOOD_ACCOUNT_REQUIRED');
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, accountIds: ['acct-1'], currentAccountId: 'acct-10' }).code)
+            .toBe('SDK_DOGFOOD_ACCOUNT_NOT_ALLOWED');
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, accountIds: ['acct-1'], currentAccountId: 'acct-1' })).toMatchObject({
+            active: true,
+            code: 'SDK_DOGFOOD_ACTIVE',
+            accountId: 'acct-1',
+        });
+    });
+    it('supports a key-enrolled installation without an app account', () => {
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, appId: 'io.example', installationStatus: 'active' }).code)
+            .toBe('SDK_DOGFOOD_INSTALLATION_REQUIRED');
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, appId: 'io.example', installationId: 'install-1', installationStatus: 'pending' }).code)
+            .toBe('SDK_DOGFOOD_INSTALLATION_NOT_ACTIVE');
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, appId: 'io.example', installationId: 'install-1', installationStatus: 'active' })).toMatchObject({
+            active: true,
+            code: 'SDK_DOGFOOD_ACTIVE',
+            accountId: 'install-1',
+        });
+    });
+});

package/dist/_core/ansi.d.ts

@@ -0,0 +1,117 @@
+/**
+ * ansi.ts — ANSI/terminal-stream tokenizer shared by every Yaver surface.
+ *
+ * WHY THIS EXISTS (2026-08-09): the opencode runner's raw stdout is an ANSI
+ * VT stream (`\x1b[0m`, `$` prompts, `> build · <model>` banners, git diff
+ * +/- lines, 256-color + truecolor SGR codes, box-drawing TUIs). The
+ * dashboard and the mobile app both flattened it to plain text with
+ * stripAnsi — losing every colour the console has — while the xterm Terminal
+ * view kept the bytes. One shared tokenizer gives BOTH chat surfaces the
+ * console look from the SAME code path, so the two renderers can never drift
+ * (AGENTS.md: "one shared classifier, no copies"). The web and mobile
+ * renderers consume these tokens and paint them with their own primitives
+ * (spans / nested Text).
+ *
+ * This file is platform-neutral: no DOM, no RN. It lives in
+ * shared/client-core and is mirrored into mobile/src/_core via
+ * scripts/sync-client-core.sh (CI checks drift).
+ *
+ * Scope: the SGR family (\x1b[<params>m) plus the most common cursor/erase
+ * sequences (move, clear-line, clear-screen), which are dropped with a
+ * line-split marker so a TUI re-render reads as one block. OSC hyperlinks
+ * (\x1b]8;;url\x1b\\ ... \x1b]8;;\x1b\\) are extracted and carried on the
+ * token. Everything else is stripped.
+ */
+export interface AnsiToken {
+    /** Plain text content of this run (escape sequences removed). */
+    text: string;
+    /** Optional OSC-8 hyperlink URL attached to the run. */
+    href?: string;
+    fg?: AnsiColor;
+    bg?: AnsiColor;
+    bold?: boolean;
+    dim?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+}
+export interface AnsiColor {
+    kind: "named" | "rgb" | "palette";
+    /** named: 0-15 (standard + bright). palette: 0-255 (xterm-256). */
+    index?: number;
+    /** rgb: [r,g,b]. */
+    rgb?: [number, number, number];
+}
+/** The 16 standard ANSI colours as RGB (bright variants at 8-15). */
+export declare const ANSI_16_RGB: ReadonlyArray<readonly [number, number, number]>;
+/** Map an xterm-256 palette index to RGB. */
+export declare function paletteRgb(index: number): [number, number, number];
+export interface TokenizeOptions {
+    /** Keep cursor/erase sequences as line breaks instead of dropping them
+     *  silently (default true: a TUI repaint becomes a blank line). */
+    keepEraseLines?: boolean;
+}
+/**
+ * Tokenize an ANSI/VT stream into styled runs. Pure, deterministic,
+ * dependency-free — unit-tested in ansi.test.ts.
+ */
+export declare function tokenizeAnsi(input: string, opts?: TokenizeOptions): AnsiToken[];
+/** Convenience: flatten tokens to plain text (strip all styling). */
+export declare function ansiToPlain(input: string): string;
+/** Split a token stream into lines, preserving per-token styling. */
+export interface AnsiLine {
+    tokens: AnsiToken[];
+}
+export declare function tokenStreamToLines(tokens: AnsiToken[]): AnsiLine[];
+/**
+ * Structural console-line classification (opencode console look, 2026-08-09).
+ *
+ * The opencode runner's raw stream is full of shapes a plain-text render
+ * flattens: `> build · <model>` banner lines, `$ command` prompt lines, git
+ * patch output (`diff --git`, `+added`, `-removed`, `@@ hunk @@`), and
+ * tool/status prefixes. The terminal view renders these with xterm's own
+ * palette; the CHAT views on web + mobile used to strip every trace of them.
+ * One shared classifier lets both chat renderers paint the same console
+ * grammar from the same code path — a line is a hint, the renderer decides
+ * the exact colour, and the two surfaces can never drift.
+ *
+ * Pure, deterministic, unit-tested in ansi.test.ts.
+ */
+export type AnsiLineHint = "plain" | "banner" | "prompt" | "diff-header" | "diff-file" | "diff-hunk" | "diff-add" | "diff-del" | "tool-call";
+export declare function classifyAnsiLine(plain: string): AnsiLineHint;
+/**
+ * One-stop helper: tokenize a raw stream and return per-line hints aligned
+ * with the token lines, so a renderer can paint both colour runs and line
+ * grammar from a single pass.
+ */
+export interface AnsiStyledLine {
+    hint: AnsiLineHint;
+    plain: string;
+    tokens: AnsiToken[];
+}
+export declare function styleAnsiLines(input: string): AnsiStyledLine[];
+/**
+ * Summarize a raw runner console for a small screen (phone / compact web
+ * pane). The full raw stream is megabytes of tool noise a human shouldn't
+ * have to read to find the answer; this is a DETERMINISTIC reducer — no LLM,
+ * no config:
+ *
+ *   - `$ cmd` prompt echoes, runner-config banners (workdir/model/…), git
+ *     diff hunks and punctuation-only TUI redraw edges are dropped.
+ *   - 3+ consecutive identical lines collapse to one.
+ *   - A line/byte budget bounds the render (a RUNNING task gets a tight
+ *     budget — the user is watching the runner, not reading it; a finished
+ *     task's tail gets a bigger one so the answer stays readable).
+ *   - A trailing marker says how many lines were collapsed.
+ *
+ * Classification runs on ANSI-stripped text so escapes-prefixed lines still
+ * match; the KEPT lines keep their escapes intact for AnsiConsoleText to
+ * paint. Budgets default to mobile-sized; pass larger ones for web.
+ */
+export interface SummarizeConsoleOptions {
+    /** Max lines to keep. Default: 40 running / 200 finished. */
+    budgetLines?: number;
+    /** Max characters to keep. Default: 6 KiB running / 24 KiB finished. */
+    budgetChars?: number;
+}
+export declare function summarizeRawConsole(raw: string, running: boolean, opts?: SummarizeConsoleOptions): string;