@mindexec/cli 0.2.478 → 0.2.480

package/scripts/remote-hub-smoke.mjs

@@ -1,699 +1,699 @@
-#!/usr/bin/env node
-
-import net from 'net';
-import assert from 'assert/strict';
-import { createRemoteHub } from '../remote-hub.js';
-
-function writeJsonLine(socket, payload) {
-    socket.write(`${JSON.stringify(payload)}\n`);
-}
-
-function writeBinaryFrame(socket, header, payload) {
-    const framePayload = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
-    socket.write(`${JSON.stringify({
-        ...header,
-        type: 'frame.binary',
-        byteLength: framePayload.length
-    })}\n`);
-    socket.write(framePayload);
-}
-
-function wait(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-const defaultHub = createRemoteHub({
-    env: {
-        MINDEXEC_REMOTE_HUB: '0'
-    }
-});
-assert.equal(defaultHub.getStatus().port, 5198, 'MindExecution RemoteHub must not reuse the LiveDesk 5197 port');
-
-async function waitFor(predicate, timeoutMs = 3000) {
-    const startedAt = Date.now();
-    while (Date.now() - startedAt < timeoutMs) {
-        const value = predicate();
-        if (value) {
-            return value;
-        }
-        await wait(25);
-    }
-
-    throw new Error('Timed out waiting for RemoteHub smoke condition.');
-}
-
-const hub = createRemoteHub({
-    env: {
-        MINDEXEC_REMOTE_HUB: '1',
-        REMOTE_HUB_HOST: '127.0.0.1',
-        REMOTE_HUB_PORT: '0',
-        REMOTE_HUB_PAIR_TOKEN: 'smoke-token',
-        REMOTE_HUB_TASK_TIMEOUT_MS: '120'
-    }
-});
-const smokePngFrame = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC', 'base64');
-
-try {
-    await hub.start();
-    const status = hub.getStatus({ includeSecrets: true });
-    assert.equal(status.started, true);
-    assert.equal(status.canvasPagination, 'none');
-
-    const socket = net.createConnection({ host: '127.0.0.1', port: status.port });
-    socket.setEncoding('utf8');
-    await new Promise((resolve, reject) => {
-        socket.once('connect', resolve);
-        socket.once('error', reject);
-    });
-    socket.on('error', () => { });
-
-    writeJsonLine(socket, {
-        type: 'hello',
-        pairToken: 'smoke-token',
-        deviceId: 'smoke-device',
-        deviceName: 'Smoke Device',
-        hostname: 'smoke-host',
-        platform: process.platform,
-        arch: process.arch,
-        pid: process.pid,
-        agentVersion: '0.0.0-smoke',
-        capabilities: {
-            status: true,
-            thumbnail: false,
-            control: true,
-            liveStream: true,
-            computerAgent: true,
-            taskDispatch: true,
-            aiAssist: true,
-            aiModel: 'fake-ai'
-        }
-    });
-    writeJsonLine(socket, {
-        type: 'status',
-        status: {
-            uptimeSec: 1,
-            totalMem: 2,
-            freeMem: 1
-        }
-    });
-
-    const devices = await waitFor(() => {
-        const current = hub.listDevices();
-        return current.length === 1 && current[0].status?.uptimeSec === 1 ? current : null;
-    });
-
-    assert.equal(devices[0].deviceId, 'smoke-device');
-    assert.equal(devices[0].connected, true);
-    assert.equal(hub.getStatus().deviceCount, 1);
-
-    const inputCommand = hub.sendInputControl('smoke-device', {
-        type: 'noop'
-    });
-    assert.equal(inputCommand.ok, true);
-    writeJsonLine(socket, {
-        type: 'command.result',
-        commandId: inputCommand.commandId,
-        result: {
-            input: true,
-            handled: true
-        }
-    });
-    const inputDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current[0]?.counters?.commandResultsReceived === 1 ? current[0] : null;
-    });
-    assert.equal(inputDevice.counters.commandsSent, 1);
-
-    const thumbnailCommand = hub.requestThumbnail('smoke-device', {
-        streamId: 'smoke-thumb',
-        maxWidth: 320,
-        maxHeight: 180,
-        quality: 50
-    });
-    assert.equal(thumbnailCommand.ok, true);
-
-    writeJsonLine(socket, {
-        type: 'thumbnail.frame',
-        commandId: thumbnailCommand.commandId,
-        streamId: 'smoke-thumb',
-        frameSeq: 1,
-        width: 2,
-        height: 1,
-        mimeType: 'image/png',
-        capturedAt: new Date().toISOString(),
-        data: 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC'
-    });
-
-    const thumbnailDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current[0]?.latestThumbnail?.frameSeq === 1 ? current[0] : null;
-    });
-    assert.equal(thumbnailDevice.latestThumbnail.streamId, 'smoke-thumb');
-    assert.equal(thumbnailDevice.counters.thumbnailFramesReceived, 1);
-    const serializedFirstThumbnail = hub.getDeviceThumbnail('smoke-device', { includeDataUrl: false });
-    const serializedFirstThumbnailUrl = new URL(serializedFirstThumbnail.framePath, 'http://127.0.0.1');
-
-    const binaryThumbnailCommand = hub.requestThumbnail('smoke-device', {
-        streamId: 'smoke-thumb-binary',
-        maxWidth: 320,
-        maxHeight: 180,
-        quality: 50
-    });
-    assert.equal(binaryThumbnailCommand.ok, true);
-    writeBinaryFrame(socket, {
-        frameKind: 'thumbnail',
-        commandId: binaryThumbnailCommand.commandId,
-        streamId: 'smoke-thumb-binary',
-        frameSeq: 4,
-        width: 2,
-        height: 1,
-        mimeType: 'image/png',
-        capturedAt: new Date().toISOString()
-    }, smokePngFrame);
-
-    const binaryThumbnailDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current[0]?.latestThumbnail?.frameSeq === 4 ? current[0] : null;
-    });
-    assert.equal(binaryThumbnailDevice.latestThumbnail.streamId, 'smoke-thumb-binary');
-    assert.equal(binaryThumbnailDevice.latestThumbnail.transport, 'binary');
-    assert.equal(binaryThumbnailDevice.latestThumbnail.byteLength, smokePngFrame.length);
-    assert.equal(typeof binaryThumbnailDevice.latestThumbnail.contentHash, 'string');
-    assert.equal(binaryThumbnailDevice.latestThumbnail.contentHash.length, 16);
-    assert.equal(binaryThumbnailDevice.latestThumbnail.sameContentStreak, 1);
-    assert.equal(binaryThumbnailDevice.counters.thumbnailFramesReceived, 2);
-    const serializedBinaryThumbnail = hub.getDeviceThumbnail('smoke-device', { includeDataUrl: false });
-    assert.equal(serializedBinaryThumbnail.streamId, 'smoke-thumb-binary');
-    assert.equal(serializedBinaryThumbnail.frameSeq, 4);
-    assert.equal(serializedBinaryThumbnail.contentHash, binaryThumbnailDevice.latestThumbnail.contentHash);
-    assert.ok(serializedBinaryThumbnail.framePath.includes('/api/remote/devices/smoke-device/thumbnail?'));
-    assert.ok(!('dataUrl' in serializedBinaryThumbnail));
-    assert.ok(!('payload' in serializedBinaryThumbnail));
-    assert.ok(!('accessToken' in serializedBinaryThumbnail));
-    const serializedThumbnailUrl = new URL(serializedBinaryThumbnail.framePath, 'http://127.0.0.1');
-    const thumbnailPayload = hub.getFramePayload('smoke-device', 'thumbnail', {
-        token: serializedThumbnailUrl.searchParams.get('token'),
-        frameSeq: serializedThumbnailUrl.searchParams.get('seq'),
-        requireToken: true
-    });
-    assert.equal(thumbnailPayload?.mimeType, 'image/png');
-    assert.equal(thumbnailPayload?.byteLength, smokePngFrame.length);
-    assert.equal(Buffer.compare(thumbnailPayload.payload, smokePngFrame), 0);
-    const retainedThumbnailPayload = hub.getFramePayload('smoke-device', 'thumbnail', {
-        token: serializedFirstThumbnailUrl.searchParams.get('token'),
-        frameSeq: serializedFirstThumbnailUrl.searchParams.get('seq'),
-        requireToken: true
-    });
-    assert.equal(retainedThumbnailPayload?.frame?.frameSeq, 1);
-    assert.equal(retainedThumbnailPayload?.byteLength, smokePngFrame.length);
-    assert.equal(Buffer.compare(retainedThumbnailPayload.payload, smokePngFrame), 0);
-    assert.equal(hub.getFramePayload('smoke-device', 'thumbnail', {
-        token: 'wrong-token',
-        frameSeq: 4,
-        requireToken: true
-    }), null);
-
-    const liveCommand = hub.startLiveStream('smoke-device', {
-        streamId: 'smoke-live',
-        fps: 5,
-        maxWidth: 320,
-        maxHeight: 180,
-        quality: 50
-    });
-    assert.equal(liveCommand.ok, true);
-    assert.equal(liveCommand.frameMode, 'remote-fast');
-    writeJsonLine(socket, {
-        type: 'stream.open',
-        commandId: liveCommand.commandId,
-        streamId: 'smoke-live',
-        mode: 'remote-fast',
-        frameMode: 'remote-fast',
-        frameProfile: 'jpeg-binary-v1',
-        encoding: 'image',
-        codec: 'png',
-        compression: 'image/png',
-        transferProtocol: 'mindexec.remote.frame.v2',
-        transferProtocolVersion: 2,
-        handshake: 'smartview-request-open-frame',
-        fps: 5,
-        openedAt: new Date().toISOString()
-    });
-    writeJsonLine(socket, {
-        type: 'stream.frame',
-        commandId: liveCommand.commandId,
-        streamId: 'smoke-live',
-        frameSeq: 2,
-        width: 2,
-        height: 1,
-        mimeType: 'image/png',
-        mode: 'remote-fast',
-        frameMode: 'remote-fast',
-        frameProfile: 'jpeg-binary-v1',
-        encoding: 'image',
-        codec: 'png',
-        compression: 'image/png',
-        transferProtocol: 'mindexec.remote.frame.v2',
-        transferProtocolVersion: 2,
-        handshake: 'smartview-request-open-frame',
-        fps: 5,
-        capturedAt: new Date().toISOString(),
-        data: 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC'
-    });
-
-    const liveDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current[0]?.latestLiveFrame?.streamId === 'smoke-live' ? current[0] : null;
-    });
-    assert.equal(liveDevice.activeLiveStream.active, true);
-    assert.equal(liveDevice.activeLiveStream.open, true);
-    assert.equal(liveDevice.activeLiveStream.handshake, 'smartview-request-open-frame');
-    assert.equal(liveDevice.latestLiveFrame.mode, 'remote-fast');
-    assert.equal(liveDevice.latestLiveFrame.frameMode, 'remote-fast');
-    assert.equal(liveDevice.latestLiveFrame.compression, 'image/png');
-    assert.equal(liveDevice.counters.liveFramesReceived, 1);
-    const serializedFirstLiveFrame = hub.getDeviceLiveFrame('smoke-device', { includeDataUrl: false });
-    const serializedFirstLiveUrl = new URL(serializedFirstLiveFrame.framePath, 'http://127.0.0.1');
-
-    writeBinaryFrame(socket, {
-        frameKind: 'stream',
-        commandId: liveCommand.commandId,
-        streamId: 'smoke-live',
-        frameSeq: 5,
-        width: 2,
-        height: 1,
-        mimeType: 'image/png',
-        mode: 'remote-fast',
-        frameMode: 'remote-fast',
-        frameProfile: 'jpeg-binary-v1',
-        encoding: 'image',
-        codec: 'png',
-        compression: 'image/png',
-        transferProtocol: 'mindexec.remote.frame.v2',
-        transferProtocolVersion: 2,
-        handshake: 'smartview-request-open-frame',
-        fps: 5,
-        capturedAt: new Date().toISOString()
-    }, smokePngFrame);
-
-    const binaryLiveDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current[0]?.latestLiveFrame?.frameSeq === 5 ? current[0] : null;
-    });
-    assert.equal(binaryLiveDevice.latestLiveFrame.streamId, 'smoke-live');
-    assert.equal(binaryLiveDevice.latestLiveFrame.transport, 'binary');
-    assert.equal(binaryLiveDevice.latestLiveFrame.byteLength, smokePngFrame.length);
-    assert.equal(typeof binaryLiveDevice.latestLiveFrame.contentHash, 'string');
-    assert.equal(binaryLiveDevice.latestLiveFrame.contentHash.length, 16);
-    assert.equal(binaryLiveDevice.latestLiveFrame.sameContentStreak, 1);
-    assert.equal(binaryLiveDevice.counters.liveFramesReceived, 2);
-    const serializedBinaryLiveFrame = hub.getDeviceLiveFrame('smoke-device', { includeDataUrl: false });
-    assert.equal(serializedBinaryLiveFrame.streamId, 'smoke-live');
-    assert.equal(serializedBinaryLiveFrame.frameSeq, 5);
-    assert.equal(serializedBinaryLiveFrame.frameMode, 'remote-fast');
-    assert.equal(serializedBinaryLiveFrame.compression, 'image/png');
-    assert.equal(serializedBinaryLiveFrame.contentHash, binaryLiveDevice.latestLiveFrame.contentHash);
-    assert.ok(serializedBinaryLiveFrame.framePath.includes('/api/remote/devices/smoke-device/live/frame?'));
-    assert.ok(!('dataUrl' in serializedBinaryLiveFrame));
-    assert.ok(!('payload' in serializedBinaryLiveFrame));
-    assert.ok(!('accessToken' in serializedBinaryLiveFrame));
-    const serializedLiveUrl = new URL(serializedBinaryLiveFrame.framePath, 'http://127.0.0.1');
-    const livePayload = hub.getFramePayload('smoke-device', 'live', {
-        token: serializedLiveUrl.searchParams.get('token'),
-        frameSeq: serializedLiveUrl.searchParams.get('seq'),
-        requireToken: true
-    });
-    assert.equal(livePayload?.mimeType, 'image/png');
-    assert.equal(livePayload?.byteLength, smokePngFrame.length);
-    assert.equal(Buffer.compare(livePayload.payload, smokePngFrame), 0);
-    const retainedLivePayload = hub.getFramePayload('smoke-device', 'live', {
-        token: serializedFirstLiveUrl.searchParams.get('token'),
-        frameSeq: serializedFirstLiveUrl.searchParams.get('seq'),
-        requireToken: true
-    });
-    assert.equal(retainedLivePayload?.frame?.frameSeq, 2);
-    assert.equal(retainedLivePayload?.byteLength, smokePngFrame.length);
-    assert.equal(Buffer.compare(retainedLivePayload.payload, smokePngFrame), 0);
-    assert.equal(hub.getFramePayload('smoke-device', 'live', {
-        token: serializedLiveUrl.searchParams.get('token'),
-        frameSeq: 4,
-        requireToken: true
-    }), null);
-
-    const staleFrameBefore = liveDevice.counters.liveFramesDropped;
-    writeJsonLine(socket, {
-        type: 'stream.frame',
-        streamId: 'stale-live',
-        frameSeq: 3,
-        width: 2,
-        height: 1,
-        mimeType: 'image/png',
-        capturedAt: new Date().toISOString(),
-        data: 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC'
-    });
-    const staleDropDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current[0]?.counters?.liveFramesDropped > staleFrameBefore ? current[0] : null;
-    });
-    assert.equal(staleDropDevice.latestLiveFrame.streamId, 'smoke-live');
-
-    const stopLiveCommand = hub.stopLiveStream('smoke-device', {
-        streamId: 'smoke-live'
-    });
-    assert.equal(stopLiveCommand.ok, true);
-    assert.equal(hub.listDevices()[0].activeLiveStream.active, false);
-
-    const taskCommand = hub.requestAgentTask('smoke-device', {
-        instruction: 'Summarize current desktop status for the manager.',
-        title: 'Smoke task'
-    });
-    assert.equal(taskCommand.ok, true);
-    writeJsonLine(socket, {
-        type: 'command.result',
-        commandId: taskCommand.commandId,
-        result: {
-            kind: 'agent.task',
-            taskId: taskCommand.taskId,
-            status: 'completed',
-            summary: 'Smoke task accepted.',
-            completedAt: new Date().toISOString()
-        }
-    });
-
-    const taskDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current[0]?.latestTask?.taskId === taskCommand.taskId
-            && current[0]?.latestTask?.status === 'completed'
-            ? current[0]
-            : null;
-    });
-    assert.equal(taskDevice.latestTask.resultSummary, 'Smoke task accepted.');
-    assert.equal(taskDevice.counters.tasksQueued, 1);
-    assert.equal(taskDevice.counters.taskResultsReceived, 1);
-
-    const aiTaskCommand = hub.requestAgentTask('smoke-device', {
-        instruction: 'Use AI assist to summarize the smoke test state.',
-        title: 'Smoke AI task',
-        approvalLevel: 'ai-assist'
-    });
-    assert.equal(aiTaskCommand.ok, true);
-    assert.equal(aiTaskCommand.approvalLevel, 'ai-assist');
-    writeJsonLine(socket, {
-        type: 'command.result',
-        commandId: aiTaskCommand.commandId,
-        result: {
-            kind: 'agent.task',
-            mode: 'ai-assist',
-            taskId: aiTaskCommand.taskId,
-            status: 'completed',
-            summary: 'Smoke AI task accepted.',
-            model: 'smoke-ai-model',
-            responseId: 'smoke-ai-response',
-            completedAt: new Date().toISOString()
-        }
-    });
-
-    const aiTaskDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current[0]?.latestTask?.taskId === aiTaskCommand.taskId
-            && current[0]?.latestTask?.approvalLevel === 'ai-assist'
-            && current[0]?.latestTask?.status === 'completed'
-            ? current[0]
-            : null;
-    });
-    assert.equal(aiTaskDevice.latestTask.resultSummary, 'Smoke AI task accepted.');
-    assert.equal(aiTaskDevice.latestTask.resultModel, 'smoke-ai-model');
-    assert.equal(aiTaskDevice.latestTask.resultResponseId, 'smoke-ai-response');
-    assert.equal(aiTaskDevice.counters.tasksQueued, 2);
-    assert.equal(aiTaskDevice.counters.taskResultsReceived, 2);
-
-    const batchTask = hub.requestAgentTaskBatch(['smoke-device', 'missing-smoke-device'], {
-        instruction: 'Dispatch a smoke batch to one connected and one missing device.',
-        title: 'Smoke batch'
-    });
-    assert.equal(batchTask.ok, true);
-    assert.equal(batchTask.total, 2);
-    assert.equal(batchTask.queued, 1);
-    assert.ok(batchTask.batchId);
-    assert.equal(batchTask.batch?.pending, 1);
-    assert.equal(batchTask.batch?.failed, 1);
-    assert.equal(batchTask.batch?.status, 'running');
-    const acceptedBatchItem = batchTask.results.find(result => result.deviceId === 'smoke-device');
-    assert.ok(acceptedBatchItem?.commandId);
-    writeJsonLine(socket, {
-        type: 'command.result',
-        commandId: acceptedBatchItem.commandId,
-        result: {
-            kind: 'agent.task',
-            taskId: acceptedBatchItem.taskId,
-            status: 'completed',
-            summary: 'Smoke batch item accepted.',
-            completedAt: new Date().toISOString()
-        }
-    });
-
-    const completedBatch = await waitFor(() => {
-        const latest = hub.getLatestTaskBatch();
-        return latest?.batchId === batchTask.batchId
-            && latest.completed === 1
-            && latest.failed === 1
-            ? latest
-            : null;
-    });
-    assert.equal(completedBatch.pending, 0);
-    assert.equal(completedBatch.status, 'completed-with-failures');
-    assert.equal(completedBatch.results.length, 2);
-    assert.equal(completedBatch.results.find(result => result.deviceId === 'missing-smoke-device')?.error, 'device-not-found');
-
-    const timeoutTaskCommand = hub.requestAgentTask('smoke-device', {
-        instruction: 'This task intentionally receives no agent response.',
-        title: 'Timeout task'
-    });
-    assert.equal(timeoutTaskCommand.ok, true);
-    const timeoutTaskDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current[0]?.latestTask?.taskId === timeoutTaskCommand.taskId
-            && current[0]?.latestTask?.status === 'failed'
-            ? current[0]
-            : null;
-    }, 1000);
-    assert.equal(timeoutTaskDevice.latestTask.error, 'task-timeout');
-    assert.equal(timeoutTaskDevice.latestTask.resultSummary, 'task-timeout');
-    assert.equal(timeoutTaskDevice.counters.tasksQueued, 4);
-    assert.equal(timeoutTaskDevice.counters.taskResultsReceived, 4);
-    assert.equal(timeoutTaskDevice.counters.taskResultsFailed, 1);
-    assert.equal(timeoutTaskDevice.counters.taskResultsTimedOut, 1);
-    writeJsonLine(socket, {
-        type: 'command.result',
-        commandId: timeoutTaskCommand.commandId,
-        result: {
-            kind: 'agent.task',
-            taskId: timeoutTaskCommand.taskId,
-            status: 'completed',
-            summary: 'This late timeout result must be ignored.',
-            completedAt: new Date().toISOString()
-        }
-    });
-    await wait(100);
-    const lateTimeoutDevice = hub.listDevices()[0];
-    assert.equal(lateTimeoutDevice.latestTask.taskId, timeoutTaskCommand.taskId);
-    assert.equal(lateTimeoutDevice.latestTask.status, 'failed');
-    assert.equal(lateTimeoutDevice.latestTask.error, 'task-timeout');
-    assert.equal(lateTimeoutDevice.latestTask.resultSummary, 'task-timeout');
-    assert.equal(lateTimeoutDevice.counters.taskResultsReceived, 4);
-
-    const timeoutBatch = hub.requestAgentTaskBatch(['smoke-device'], {
-        instruction: 'This batch item intentionally times out before a late result arrives.',
-        title: 'Timeout batch'
-    });
-    assert.equal(timeoutBatch.ok, true);
-    assert.equal(timeoutBatch.total, 1);
-    assert.equal(timeoutBatch.queued, 1);
-    assert.equal(timeoutBatch.batch?.pending, 1);
-    const timeoutBatchItem = timeoutBatch.results.find(result => result.deviceId === 'smoke-device');
-    assert.ok(timeoutBatchItem?.commandId);
-    assert.ok(timeoutBatchItem?.taskId);
-
-    const timedOutBatch = await waitFor(() => {
-        const latest = hub.getLatestTaskBatch();
-        return latest?.batchId === timeoutBatch.batchId
-            && latest.timedOut === 1
-            && latest.pending === 0
-            ? latest
-            : null;
-    }, 1000);
-    assert.equal(timedOutBatch.status, 'completed-with-failures');
-    assert.equal(timedOutBatch.failed, 1);
-    assert.equal(timedOutBatch.results[0]?.status, 'failed');
-    assert.equal(timedOutBatch.results[0]?.error, 'task-timeout');
-
-    writeJsonLine(socket, {
-        type: 'command.result',
-        commandId: timeoutBatchItem.commandId,
-        result: {
-            kind: 'agent.task',
-            taskId: timeoutBatchItem.taskId,
-            status: 'completed',
-            summary: 'This late batch timeout result must be ignored.',
-            completedAt: new Date().toISOString()
-        }
-    });
-    await wait(100);
-    const lateTimedOutBatch = hub.getLatestTaskBatch();
-    const lateTimedOutDevice = hub.listDevices()[0];
-    assert.equal(lateTimedOutBatch.batchId, timeoutBatch.batchId);
-    assert.equal(lateTimedOutBatch.status, 'completed-with-failures');
-    assert.equal(lateTimedOutBatch.completed, 0);
-    assert.equal(lateTimedOutBatch.failed, 1);
-    assert.equal(lateTimedOutBatch.timedOut, 1);
-    assert.equal(lateTimedOutBatch.results[0]?.status, 'failed');
-    assert.equal(lateTimedOutBatch.results[0]?.error, 'task-timeout');
-    assert.equal(lateTimedOutDevice.latestTask.taskId, timeoutBatchItem.taskId);
-    assert.equal(lateTimedOutDevice.latestTask.status, 'failed');
-    assert.equal(lateTimedOutDevice.latestTask.error, 'task-timeout');
-    assert.equal(lateTimedOutDevice.latestTask.resultSummary, 'task-timeout');
-    assert.equal(lateTimedOutDevice.counters.taskResultsReceived, 5);
-    assert.equal(lateTimedOutDevice.counters.taskResultsFailed, 2);
-    assert.equal(lateTimedOutDevice.counters.taskResultsTimedOut, 2);
-
-    const staleSessionTask = hub.requestAgentTask('smoke-device', {
-        instruction: 'This old session task must not survive reconnect.',
-        title: 'Reconnect stale task'
-    });
-    assert.equal(staleSessionTask.ok, true);
-    const oldSessionId = lateTimedOutDevice.sessionId;
-
-    const duplicateSocket = net.createConnection({ host: '127.0.0.1', port: status.port });
-    duplicateSocket.setEncoding('utf8');
-    const duplicateMessages = [];
-    let duplicateBuffer = '';
-    await new Promise((resolve, reject) => {
-        duplicateSocket.once('connect', resolve);
-        duplicateSocket.once('error', reject);
-    });
-    duplicateSocket.on('error', () => { });
-    duplicateSocket.on('data', chunk => {
-        duplicateBuffer += chunk;
-        let lineBreakIndex = duplicateBuffer.indexOf('\n');
-        while (lineBreakIndex >= 0) {
-            const line = duplicateBuffer.slice(0, lineBreakIndex).trim();
-            duplicateBuffer = duplicateBuffer.slice(lineBreakIndex + 1);
-            if (line) {
-                duplicateMessages.push(JSON.parse(line));
-            }
-            lineBreakIndex = duplicateBuffer.indexOf('\n');
-        }
-    });
-    writeJsonLine(duplicateSocket, {
-        type: 'hello',
-        pairToken: 'smoke-token',
-        deviceId: 'smoke-device',
-        deviceName: 'Smoke Device Duplicate',
-        hostname: 'smoke-host-duplicate',
-        platform: process.platform,
-        arch: process.arch,
-        pid: process.pid,
-        agentVersion: '0.0.0-smoke-duplicate',
-        capabilities: {
-            status: true,
-            thumbnail: false,
-            control: false,
-            liveStream: true,
-            computerAgent: true,
-            taskDispatch: true,
-            aiAssist: false
-        }
-    });
-
-    const duplicateDisconnect = await waitFor(() => (
-        duplicateMessages.find(message => message?.type === 'disconnect')
-    ), 1000);
-    assert.equal(duplicateDisconnect.reason, 'duplicate-device-active');
-    assert.equal(duplicateDisconnect.activeSessionId, oldSessionId);
-    assert.equal(duplicateDisconnect.retryAfterMs >= 30000, true);
-    await wait(100);
-    const duplicateRejectedDevice = hub.listDevices()[0];
-    assert.equal(duplicateRejectedDevice.sessionId, oldSessionId);
-    assert.equal(duplicateRejectedDevice.deviceName, 'Smoke Device');
-    assert.equal(duplicateRejectedDevice.connected, true);
-    assert.equal(duplicateRejectedDevice.counters.duplicateConnectionsRejected, 1);
-    assert.equal(duplicateRejectedDevice.latestTask.taskId, staleSessionTask.taskId);
-    duplicateSocket.destroy();
-
-    socket.destroy();
-    const disconnectedDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current.length === 1
-            && current[0]?.sessionId === oldSessionId
-            && current[0]?.connected === false
-            ? current[0]
-            : null;
-    });
-    assert.equal(disconnectedDevice.latestTask.status, 'failed');
-    assert.equal(
-        ['device-disconnected', 'task-timeout'].includes(disconnectedDevice.latestTask.error),
-        true);
-
-    const replacementSocket = net.createConnection({ host: '127.0.0.1', port: status.port });
-    replacementSocket.setEncoding('utf8');
-    await new Promise((resolve, reject) => {
-        replacementSocket.once('connect', resolve);
-        replacementSocket.once('error', reject);
-    });
-    replacementSocket.on('error', () => { });
-    writeJsonLine(replacementSocket, {
-        type: 'hello',
-        pairToken: 'smoke-token',
-        deviceId: 'smoke-device',
-        deviceName: 'Smoke Device Reconnected',
-        hostname: 'smoke-host-reconnected',
-        platform: process.platform,
-        arch: process.arch,
-        pid: process.pid,
-        agentVersion: '0.0.0-smoke-reconnected',
-        capabilities: {
-            status: true,
-            thumbnail: false,
-            control: false,
-            liveStream: true,
-            computerAgent: true,
-            taskDispatch: true,
-            aiAssist: true,
-            aiModel: 'fake-ai'
-        }
-    });
-    writeJsonLine(replacementSocket, {
-        type: 'status',
-        status: {
-            uptimeSec: 2,
-            totalMem: 4,
-            freeMem: 3
-        }
-    });
-
-    const reconnectedDevice = await waitFor(() => {
-        const current = hub.listDevices();
-        return current.length === 1
-            && current[0]?.deviceName === 'Smoke Device Reconnected'
-            && current[0]?.status?.uptimeSec === 2
-            ? current[0]
-            : null;
-    });
-    assert.notEqual(reconnectedDevice.sessionId, oldSessionId);
-    assert.equal(reconnectedDevice.connected, true);
-    assert.equal(reconnectedDevice.latestTask, null);
-    assert.equal(reconnectedDevice.counters.taskResultsReceived, 0);
-
-    await wait(100);
-    const staleSessionIgnoredDevice = hub.listDevices()[0];
-    assert.equal(staleSessionIgnoredDevice.sessionId, reconnectedDevice.sessionId);
-    assert.equal(staleSessionIgnoredDevice.deviceName, 'Smoke Device Reconnected');
-    assert.equal(staleSessionIgnoredDevice.status.uptimeSec, 2);
-    assert.equal(staleSessionIgnoredDevice.latestTask, null);
-    assert.equal(staleSessionIgnoredDevice.counters.taskResultsReceived, 0);
-
-    replacementSocket.destroy();
-    await waitFor(() => hub.listDevices()[0]?.connected === false);
-    console.log('RemoteHub smoke OK');
-} finally {
-    await hub.close();
-}
+#!/usr/bin/env node
+
+import net from 'net';
+import assert from 'assert/strict';
+import { createRemoteHub } from '../remote-hub.js';
+
+function writeJsonLine(socket, payload) {
+    socket.write(`${JSON.stringify(payload)}\n`);
+}
+
+function writeBinaryFrame(socket, header, payload) {
+    const framePayload = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+    socket.write(`${JSON.stringify({
+        ...header,
+        type: 'frame.binary',
+        byteLength: framePayload.length
+    })}\n`);
+    socket.write(framePayload);
+}
+
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+const defaultHub = createRemoteHub({
+    env: {
+        MINDEXEC_REMOTE_HUB: '0'
+    }
+});
+assert.equal(defaultHub.getStatus().port, 5198, 'MindExecution RemoteHub must not reuse the LiveDesk 5197 port');
+
+async function waitFor(predicate, timeoutMs = 3000) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const value = predicate();
+        if (value) {
+            return value;
+        }
+        await wait(25);
+    }
+
+    throw new Error('Timed out waiting for RemoteHub smoke condition.');
+}
+
+const hub = createRemoteHub({
+    env: {
+        MINDEXEC_REMOTE_HUB: '1',
+        REMOTE_HUB_HOST: '127.0.0.1',
+        REMOTE_HUB_PORT: '0',
+        REMOTE_HUB_PAIR_TOKEN: 'smoke-token',
+        REMOTE_HUB_TASK_TIMEOUT_MS: '120'
+    }
+});
+const smokePngFrame = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC', 'base64');
+
+try {
+    await hub.start();
+    const status = hub.getStatus({ includeSecrets: true });
+    assert.equal(status.started, true);
+    assert.equal(status.canvasPagination, 'none');
+
+    const socket = net.createConnection({ host: '127.0.0.1', port: status.port });
+    socket.setEncoding('utf8');
+    await new Promise((resolve, reject) => {
+        socket.once('connect', resolve);
+        socket.once('error', reject);
+    });
+    socket.on('error', () => { });
+
+    writeJsonLine(socket, {
+        type: 'hello',
+        pairToken: 'smoke-token',
+        deviceId: 'smoke-device',
+        deviceName: 'Smoke Device',
+        hostname: 'smoke-host',
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        agentVersion: '0.0.0-smoke',
+        capabilities: {
+            status: true,
+            thumbnail: false,
+            control: true,
+            liveStream: true,
+            computerAgent: true,
+            taskDispatch: true,
+            aiAssist: true,
+            aiModel: 'fake-ai'
+        }
+    });
+    writeJsonLine(socket, {
+        type: 'status',
+        status: {
+            uptimeSec: 1,
+            totalMem: 2,
+            freeMem: 1
+        }
+    });
+
+    const devices = await waitFor(() => {
+        const current = hub.listDevices();
+        return current.length === 1 && current[0].status?.uptimeSec === 1 ? current : null;
+    });
+
+    assert.equal(devices[0].deviceId, 'smoke-device');
+    assert.equal(devices[0].connected, true);
+    assert.equal(hub.getStatus().deviceCount, 1);
+
+    const inputCommand = hub.sendInputControl('smoke-device', {
+        type: 'noop'
+    });
+    assert.equal(inputCommand.ok, true);
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: inputCommand.commandId,
+        result: {
+            input: true,
+            handled: true
+        }
+    });
+    const inputDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.counters?.commandResultsReceived === 1 ? current[0] : null;
+    });
+    assert.equal(inputDevice.counters.commandsSent, 1);
+
+    const thumbnailCommand = hub.requestThumbnail('smoke-device', {
+        streamId: 'smoke-thumb',
+        maxWidth: 320,
+        maxHeight: 180,
+        quality: 50
+    });
+    assert.equal(thumbnailCommand.ok, true);
+
+    writeJsonLine(socket, {
+        type: 'thumbnail.frame',
+        commandId: thumbnailCommand.commandId,
+        streamId: 'smoke-thumb',
+        frameSeq: 1,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        capturedAt: new Date().toISOString(),
+        data: 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC'
+    });
+
+    const thumbnailDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestThumbnail?.frameSeq === 1 ? current[0] : null;
+    });
+    assert.equal(thumbnailDevice.latestThumbnail.streamId, 'smoke-thumb');
+    assert.equal(thumbnailDevice.counters.thumbnailFramesReceived, 1);
+    const serializedFirstThumbnail = hub.getDeviceThumbnail('smoke-device', { includeDataUrl: false });
+    const serializedFirstThumbnailUrl = new URL(serializedFirstThumbnail.framePath, 'http://127.0.0.1');
+
+    const binaryThumbnailCommand = hub.requestThumbnail('smoke-device', {
+        streamId: 'smoke-thumb-binary',
+        maxWidth: 320,
+        maxHeight: 180,
+        quality: 50
+    });
+    assert.equal(binaryThumbnailCommand.ok, true);
+    writeBinaryFrame(socket, {
+        frameKind: 'thumbnail',
+        commandId: binaryThumbnailCommand.commandId,
+        streamId: 'smoke-thumb-binary',
+        frameSeq: 4,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        capturedAt: new Date().toISOString()
+    }, smokePngFrame);
+
+    const binaryThumbnailDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestThumbnail?.frameSeq === 4 ? current[0] : null;
+    });
+    assert.equal(binaryThumbnailDevice.latestThumbnail.streamId, 'smoke-thumb-binary');
+    assert.equal(binaryThumbnailDevice.latestThumbnail.transport, 'binary');
+    assert.equal(binaryThumbnailDevice.latestThumbnail.byteLength, smokePngFrame.length);
+    assert.equal(typeof binaryThumbnailDevice.latestThumbnail.contentHash, 'string');
+    assert.equal(binaryThumbnailDevice.latestThumbnail.contentHash.length, 16);
+    assert.equal(binaryThumbnailDevice.latestThumbnail.sameContentStreak, 1);
+    assert.equal(binaryThumbnailDevice.counters.thumbnailFramesReceived, 2);
+    const serializedBinaryThumbnail = hub.getDeviceThumbnail('smoke-device', { includeDataUrl: false });
+    assert.equal(serializedBinaryThumbnail.streamId, 'smoke-thumb-binary');
+    assert.equal(serializedBinaryThumbnail.frameSeq, 4);
+    assert.equal(serializedBinaryThumbnail.contentHash, binaryThumbnailDevice.latestThumbnail.contentHash);
+    assert.ok(serializedBinaryThumbnail.framePath.includes('/api/remote/devices/smoke-device/thumbnail?'));
+    assert.ok(!('dataUrl' in serializedBinaryThumbnail));
+    assert.ok(!('payload' in serializedBinaryThumbnail));
+    assert.ok(!('accessToken' in serializedBinaryThumbnail));
+    const serializedThumbnailUrl = new URL(serializedBinaryThumbnail.framePath, 'http://127.0.0.1');
+    const thumbnailPayload = hub.getFramePayload('smoke-device', 'thumbnail', {
+        token: serializedThumbnailUrl.searchParams.get('token'),
+        frameSeq: serializedThumbnailUrl.searchParams.get('seq'),
+        requireToken: true
+    });
+    assert.equal(thumbnailPayload?.mimeType, 'image/png');
+    assert.equal(thumbnailPayload?.byteLength, smokePngFrame.length);
+    assert.equal(Buffer.compare(thumbnailPayload.payload, smokePngFrame), 0);
+    const retainedThumbnailPayload = hub.getFramePayload('smoke-device', 'thumbnail', {
+        token: serializedFirstThumbnailUrl.searchParams.get('token'),
+        frameSeq: serializedFirstThumbnailUrl.searchParams.get('seq'),
+        requireToken: true
+    });
+    assert.equal(retainedThumbnailPayload?.frame?.frameSeq, 1);
+    assert.equal(retainedThumbnailPayload?.byteLength, smokePngFrame.length);
+    assert.equal(Buffer.compare(retainedThumbnailPayload.payload, smokePngFrame), 0);
+    assert.equal(hub.getFramePayload('smoke-device', 'thumbnail', {
+        token: 'wrong-token',
+        frameSeq: 4,
+        requireToken: true
+    }), null);
+
+    const liveCommand = hub.startLiveStream('smoke-device', {
+        streamId: 'smoke-live',
+        fps: 5,
+        maxWidth: 320,
+        maxHeight: 180,
+        quality: 50
+    });
+    assert.equal(liveCommand.ok, true);
+    assert.equal(liveCommand.frameMode, 'remote-fast');
+    writeJsonLine(socket, {
+        type: 'stream.open',
+        commandId: liveCommand.commandId,
+        streamId: 'smoke-live',
+        mode: 'remote-fast',
+        frameMode: 'remote-fast',
+        frameProfile: 'jpeg-binary-v1',
+        encoding: 'image',
+        codec: 'png',
+        compression: 'image/png',
+        transferProtocol: 'mindexec.remote.frame.v2',
+        transferProtocolVersion: 2,
+        handshake: 'smartview-request-open-frame',
+        fps: 5,
+        openedAt: new Date().toISOString()
+    });
+    writeJsonLine(socket, {
+        type: 'stream.frame',
+        commandId: liveCommand.commandId,
+        streamId: 'smoke-live',
+        frameSeq: 2,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        mode: 'remote-fast',
+        frameMode: 'remote-fast',
+        frameProfile: 'jpeg-binary-v1',
+        encoding: 'image',
+        codec: 'png',
+        compression: 'image/png',
+        transferProtocol: 'mindexec.remote.frame.v2',
+        transferProtocolVersion: 2,
+        handshake: 'smartview-request-open-frame',
+        fps: 5,
+        capturedAt: new Date().toISOString(),
+        data: 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC'
+    });
+
+    const liveDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestLiveFrame?.streamId === 'smoke-live' ? current[0] : null;
+    });
+    assert.equal(liveDevice.activeLiveStream.active, true);
+    assert.equal(liveDevice.activeLiveStream.open, true);
+    assert.equal(liveDevice.activeLiveStream.handshake, 'smartview-request-open-frame');
+    assert.equal(liveDevice.latestLiveFrame.mode, 'remote-fast');
+    assert.equal(liveDevice.latestLiveFrame.frameMode, 'remote-fast');
+    assert.equal(liveDevice.latestLiveFrame.compression, 'image/png');
+    assert.equal(liveDevice.counters.liveFramesReceived, 1);
+    const serializedFirstLiveFrame = hub.getDeviceLiveFrame('smoke-device', { includeDataUrl: false });
+    const serializedFirstLiveUrl = new URL(serializedFirstLiveFrame.framePath, 'http://127.0.0.1');
+
+    writeBinaryFrame(socket, {
+        frameKind: 'stream',
+        commandId: liveCommand.commandId,
+        streamId: 'smoke-live',
+        frameSeq: 5,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        mode: 'remote-fast',
+        frameMode: 'remote-fast',
+        frameProfile: 'jpeg-binary-v1',
+        encoding: 'image',
+        codec: 'png',
+        compression: 'image/png',
+        transferProtocol: 'mindexec.remote.frame.v2',
+        transferProtocolVersion: 2,
+        handshake: 'smartview-request-open-frame',
+        fps: 5,
+        capturedAt: new Date().toISOString()
+    }, smokePngFrame);
+
+    const binaryLiveDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestLiveFrame?.frameSeq === 5 ? current[0] : null;
+    });
+    assert.equal(binaryLiveDevice.latestLiveFrame.streamId, 'smoke-live');
+    assert.equal(binaryLiveDevice.latestLiveFrame.transport, 'binary');
+    assert.equal(binaryLiveDevice.latestLiveFrame.byteLength, smokePngFrame.length);
+    assert.equal(typeof binaryLiveDevice.latestLiveFrame.contentHash, 'string');
+    assert.equal(binaryLiveDevice.latestLiveFrame.contentHash.length, 16);
+    assert.equal(binaryLiveDevice.latestLiveFrame.sameContentStreak, 1);
+    assert.equal(binaryLiveDevice.counters.liveFramesReceived, 2);
+    const serializedBinaryLiveFrame = hub.getDeviceLiveFrame('smoke-device', { includeDataUrl: false });
+    assert.equal(serializedBinaryLiveFrame.streamId, 'smoke-live');
+    assert.equal(serializedBinaryLiveFrame.frameSeq, 5);
+    assert.equal(serializedBinaryLiveFrame.frameMode, 'remote-fast');
+    assert.equal(serializedBinaryLiveFrame.compression, 'image/png');
+    assert.equal(serializedBinaryLiveFrame.contentHash, binaryLiveDevice.latestLiveFrame.contentHash);
+    assert.ok(serializedBinaryLiveFrame.framePath.includes('/api/remote/devices/smoke-device/live/frame?'));
+    assert.ok(!('dataUrl' in serializedBinaryLiveFrame));
+    assert.ok(!('payload' in serializedBinaryLiveFrame));
+    assert.ok(!('accessToken' in serializedBinaryLiveFrame));
+    const serializedLiveUrl = new URL(serializedBinaryLiveFrame.framePath, 'http://127.0.0.1');
+    const livePayload = hub.getFramePayload('smoke-device', 'live', {
+        token: serializedLiveUrl.searchParams.get('token'),
+        frameSeq: serializedLiveUrl.searchParams.get('seq'),
+        requireToken: true
+    });
+    assert.equal(livePayload?.mimeType, 'image/png');
+    assert.equal(livePayload?.byteLength, smokePngFrame.length);
+    assert.equal(Buffer.compare(livePayload.payload, smokePngFrame), 0);
+    const retainedLivePayload = hub.getFramePayload('smoke-device', 'live', {
+        token: serializedFirstLiveUrl.searchParams.get('token'),
+        frameSeq: serializedFirstLiveUrl.searchParams.get('seq'),
+        requireToken: true
+    });
+    assert.equal(retainedLivePayload?.frame?.frameSeq, 2);
+    assert.equal(retainedLivePayload?.byteLength, smokePngFrame.length);
+    assert.equal(Buffer.compare(retainedLivePayload.payload, smokePngFrame), 0);
+    assert.equal(hub.getFramePayload('smoke-device', 'live', {
+        token: serializedLiveUrl.searchParams.get('token'),
+        frameSeq: 4,
+        requireToken: true
+    }), null);
+
+    const staleFrameBefore = liveDevice.counters.liveFramesDropped;
+    writeJsonLine(socket, {
+        type: 'stream.frame',
+        streamId: 'stale-live',
+        frameSeq: 3,
+        width: 2,
+        height: 1,
+        mimeType: 'image/png',
+        capturedAt: new Date().toISOString(),
+        data: 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC'
+    });
+    const staleDropDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.counters?.liveFramesDropped > staleFrameBefore ? current[0] : null;
+    });
+    assert.equal(staleDropDevice.latestLiveFrame.streamId, 'smoke-live');
+
+    const stopLiveCommand = hub.stopLiveStream('smoke-device', {
+        streamId: 'smoke-live'
+    });
+    assert.equal(stopLiveCommand.ok, true);
+    assert.equal(hub.listDevices()[0].activeLiveStream.active, false);
+
+    const taskCommand = hub.requestAgentTask('smoke-device', {
+        instruction: 'Summarize current desktop status for the manager.',
+        title: 'Smoke task'
+    });
+    assert.equal(taskCommand.ok, true);
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: taskCommand.commandId,
+        result: {
+            kind: 'agent.task',
+            taskId: taskCommand.taskId,
+            status: 'completed',
+            summary: 'Smoke task accepted.',
+            completedAt: new Date().toISOString()
+        }
+    });
+
+    const taskDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestTask?.taskId === taskCommand.taskId
+            && current[0]?.latestTask?.status === 'completed'
+            ? current[0]
+            : null;
+    });
+    assert.equal(taskDevice.latestTask.resultSummary, 'Smoke task accepted.');
+    assert.equal(taskDevice.counters.tasksQueued, 1);
+    assert.equal(taskDevice.counters.taskResultsReceived, 1);
+
+    const aiTaskCommand = hub.requestAgentTask('smoke-device', {
+        instruction: 'Use AI assist to summarize the smoke test state.',
+        title: 'Smoke AI task',
+        approvalLevel: 'ai-assist'
+    });
+    assert.equal(aiTaskCommand.ok, true);
+    assert.equal(aiTaskCommand.approvalLevel, 'ai-assist');
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: aiTaskCommand.commandId,
+        result: {
+            kind: 'agent.task',
+            mode: 'ai-assist',
+            taskId: aiTaskCommand.taskId,
+            status: 'completed',
+            summary: 'Smoke AI task accepted.',
+            model: 'smoke-ai-model',
+            responseId: 'smoke-ai-response',
+            completedAt: new Date().toISOString()
+        }
+    });
+
+    const aiTaskDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestTask?.taskId === aiTaskCommand.taskId
+            && current[0]?.latestTask?.approvalLevel === 'ai-assist'
+            && current[0]?.latestTask?.status === 'completed'
+            ? current[0]
+            : null;
+    });
+    assert.equal(aiTaskDevice.latestTask.resultSummary, 'Smoke AI task accepted.');
+    assert.equal(aiTaskDevice.latestTask.resultModel, 'smoke-ai-model');
+    assert.equal(aiTaskDevice.latestTask.resultResponseId, 'smoke-ai-response');
+    assert.equal(aiTaskDevice.counters.tasksQueued, 2);
+    assert.equal(aiTaskDevice.counters.taskResultsReceived, 2);
+
+    const batchTask = hub.requestAgentTaskBatch(['smoke-device', 'missing-smoke-device'], {
+        instruction: 'Dispatch a smoke batch to one connected and one missing device.',
+        title: 'Smoke batch'
+    });
+    assert.equal(batchTask.ok, true);
+    assert.equal(batchTask.total, 2);
+    assert.equal(batchTask.queued, 1);
+    assert.ok(batchTask.batchId);
+    assert.equal(batchTask.batch?.pending, 1);
+    assert.equal(batchTask.batch?.failed, 1);
+    assert.equal(batchTask.batch?.status, 'running');
+    const acceptedBatchItem = batchTask.results.find(result => result.deviceId === 'smoke-device');
+    assert.ok(acceptedBatchItem?.commandId);
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: acceptedBatchItem.commandId,
+        result: {
+            kind: 'agent.task',
+            taskId: acceptedBatchItem.taskId,
+            status: 'completed',
+            summary: 'Smoke batch item accepted.',
+            completedAt: new Date().toISOString()
+        }
+    });
+
+    const completedBatch = await waitFor(() => {
+        const latest = hub.getLatestTaskBatch();
+        return latest?.batchId === batchTask.batchId
+            && latest.completed === 1
+            && latest.failed === 1
+            ? latest
+            : null;
+    });
+    assert.equal(completedBatch.pending, 0);
+    assert.equal(completedBatch.status, 'completed-with-failures');
+    assert.equal(completedBatch.results.length, 2);
+    assert.equal(completedBatch.results.find(result => result.deviceId === 'missing-smoke-device')?.error, 'device-not-found');
+
+    const timeoutTaskCommand = hub.requestAgentTask('smoke-device', {
+        instruction: 'This task intentionally receives no agent response.',
+        title: 'Timeout task'
+    });
+    assert.equal(timeoutTaskCommand.ok, true);
+    const timeoutTaskDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.latestTask?.taskId === timeoutTaskCommand.taskId
+            && current[0]?.latestTask?.status === 'failed'
+            ? current[0]
+            : null;
+    }, 1000);
+    assert.equal(timeoutTaskDevice.latestTask.error, 'task-timeout');
+    assert.equal(timeoutTaskDevice.latestTask.resultSummary, 'task-timeout');
+    assert.equal(timeoutTaskDevice.counters.tasksQueued, 4);
+    assert.equal(timeoutTaskDevice.counters.taskResultsReceived, 4);
+    assert.equal(timeoutTaskDevice.counters.taskResultsFailed, 1);
+    assert.equal(timeoutTaskDevice.counters.taskResultsTimedOut, 1);
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: timeoutTaskCommand.commandId,
+        result: {
+            kind: 'agent.task',
+            taskId: timeoutTaskCommand.taskId,
+            status: 'completed',
+            summary: 'This late timeout result must be ignored.',
+            completedAt: new Date().toISOString()
+        }
+    });
+    await wait(100);
+    const lateTimeoutDevice = hub.listDevices()[0];
+    assert.equal(lateTimeoutDevice.latestTask.taskId, timeoutTaskCommand.taskId);
+    assert.equal(lateTimeoutDevice.latestTask.status, 'failed');
+    assert.equal(lateTimeoutDevice.latestTask.error, 'task-timeout');
+    assert.equal(lateTimeoutDevice.latestTask.resultSummary, 'task-timeout');
+    assert.equal(lateTimeoutDevice.counters.taskResultsReceived, 4);
+
+    const timeoutBatch = hub.requestAgentTaskBatch(['smoke-device'], {
+        instruction: 'This batch item intentionally times out before a late result arrives.',
+        title: 'Timeout batch'
+    });
+    assert.equal(timeoutBatch.ok, true);
+    assert.equal(timeoutBatch.total, 1);
+    assert.equal(timeoutBatch.queued, 1);
+    assert.equal(timeoutBatch.batch?.pending, 1);
+    const timeoutBatchItem = timeoutBatch.results.find(result => result.deviceId === 'smoke-device');
+    assert.ok(timeoutBatchItem?.commandId);
+    assert.ok(timeoutBatchItem?.taskId);
+
+    const timedOutBatch = await waitFor(() => {
+        const latest = hub.getLatestTaskBatch();
+        return latest?.batchId === timeoutBatch.batchId
+            && latest.timedOut === 1
+            && latest.pending === 0
+            ? latest
+            : null;
+    }, 1000);
+    assert.equal(timedOutBatch.status, 'completed-with-failures');
+    assert.equal(timedOutBatch.failed, 1);
+    assert.equal(timedOutBatch.results[0]?.status, 'failed');
+    assert.equal(timedOutBatch.results[0]?.error, 'task-timeout');
+
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: timeoutBatchItem.commandId,
+        result: {
+            kind: 'agent.task',
+            taskId: timeoutBatchItem.taskId,
+            status: 'completed',
+            summary: 'This late batch timeout result must be ignored.',
+            completedAt: new Date().toISOString()
+        }
+    });
+    await wait(100);
+    const lateTimedOutBatch = hub.getLatestTaskBatch();
+    const lateTimedOutDevice = hub.listDevices()[0];
+    assert.equal(lateTimedOutBatch.batchId, timeoutBatch.batchId);
+    assert.equal(lateTimedOutBatch.status, 'completed-with-failures');
+    assert.equal(lateTimedOutBatch.completed, 0);
+    assert.equal(lateTimedOutBatch.failed, 1);
+    assert.equal(lateTimedOutBatch.timedOut, 1);
+    assert.equal(lateTimedOutBatch.results[0]?.status, 'failed');
+    assert.equal(lateTimedOutBatch.results[0]?.error, 'task-timeout');
+    assert.equal(lateTimedOutDevice.latestTask.taskId, timeoutBatchItem.taskId);
+    assert.equal(lateTimedOutDevice.latestTask.status, 'failed');
+    assert.equal(lateTimedOutDevice.latestTask.error, 'task-timeout');
+    assert.equal(lateTimedOutDevice.latestTask.resultSummary, 'task-timeout');
+    assert.equal(lateTimedOutDevice.counters.taskResultsReceived, 5);
+    assert.equal(lateTimedOutDevice.counters.taskResultsFailed, 2);
+    assert.equal(lateTimedOutDevice.counters.taskResultsTimedOut, 2);
+
+    const staleSessionTask = hub.requestAgentTask('smoke-device', {
+        instruction: 'This old session task must not survive reconnect.',
+        title: 'Reconnect stale task'
+    });
+    assert.equal(staleSessionTask.ok, true);
+    const oldSessionId = lateTimedOutDevice.sessionId;
+
+    const duplicateSocket = net.createConnection({ host: '127.0.0.1', port: status.port });
+    duplicateSocket.setEncoding('utf8');
+    const duplicateMessages = [];
+    let duplicateBuffer = '';
+    await new Promise((resolve, reject) => {
+        duplicateSocket.once('connect', resolve);
+        duplicateSocket.once('error', reject);
+    });
+    duplicateSocket.on('error', () => { });
+    duplicateSocket.on('data', chunk => {
+        duplicateBuffer += chunk;
+        let lineBreakIndex = duplicateBuffer.indexOf('\n');
+        while (lineBreakIndex >= 0) {
+            const line = duplicateBuffer.slice(0, lineBreakIndex).trim();
+            duplicateBuffer = duplicateBuffer.slice(lineBreakIndex + 1);
+            if (line) {
+                duplicateMessages.push(JSON.parse(line));
+            }
+            lineBreakIndex = duplicateBuffer.indexOf('\n');
+        }
+    });
+    writeJsonLine(duplicateSocket, {
+        type: 'hello',
+        pairToken: 'smoke-token',
+        deviceId: 'smoke-device',
+        deviceName: 'Smoke Device Duplicate',
+        hostname: 'smoke-host-duplicate',
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        agentVersion: '0.0.0-smoke-duplicate',
+        capabilities: {
+            status: true,
+            thumbnail: false,
+            control: false,
+            liveStream: true,
+            computerAgent: true,
+            taskDispatch: true,
+            aiAssist: false
+        }
+    });
+
+    const duplicateDisconnect = await waitFor(() => (
+        duplicateMessages.find(message => message?.type === 'disconnect')
+    ), 1000);
+    assert.equal(duplicateDisconnect.reason, 'duplicate-device-active');
+    assert.equal(duplicateDisconnect.activeSessionId, oldSessionId);
+    assert.equal(duplicateDisconnect.retryAfterMs >= 30000, true);
+    await wait(100);
+    const duplicateRejectedDevice = hub.listDevices()[0];
+    assert.equal(duplicateRejectedDevice.sessionId, oldSessionId);
+    assert.equal(duplicateRejectedDevice.deviceName, 'Smoke Device');
+    assert.equal(duplicateRejectedDevice.connected, true);
+    assert.equal(duplicateRejectedDevice.counters.duplicateConnectionsRejected, 1);
+    assert.equal(duplicateRejectedDevice.latestTask.taskId, staleSessionTask.taskId);
+    duplicateSocket.destroy();
+
+    socket.destroy();
+    const disconnectedDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current.length === 1
+            && current[0]?.sessionId === oldSessionId
+            && current[0]?.connected === false
+            ? current[0]
+            : null;
+    });
+    assert.equal(disconnectedDevice.latestTask.status, 'failed');
+    assert.equal(
+        ['device-disconnected', 'task-timeout'].includes(disconnectedDevice.latestTask.error),
+        true);
+
+    const replacementSocket = net.createConnection({ host: '127.0.0.1', port: status.port });
+    replacementSocket.setEncoding('utf8');
+    await new Promise((resolve, reject) => {
+        replacementSocket.once('connect', resolve);
+        replacementSocket.once('error', reject);
+    });
+    replacementSocket.on('error', () => { });
+    writeJsonLine(replacementSocket, {
+        type: 'hello',
+        pairToken: 'smoke-token',
+        deviceId: 'smoke-device',
+        deviceName: 'Smoke Device Reconnected',
+        hostname: 'smoke-host-reconnected',
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        agentVersion: '0.0.0-smoke-reconnected',
+        capabilities: {
+            status: true,
+            thumbnail: false,
+            control: false,
+            liveStream: true,
+            computerAgent: true,
+            taskDispatch: true,
+            aiAssist: true,
+            aiModel: 'fake-ai'
+        }
+    });
+    writeJsonLine(replacementSocket, {
+        type: 'status',
+        status: {
+            uptimeSec: 2,
+            totalMem: 4,
+            freeMem: 3
+        }
+    });
+
+    const reconnectedDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current.length === 1
+            && current[0]?.deviceName === 'Smoke Device Reconnected'
+            && current[0]?.status?.uptimeSec === 2
+            ? current[0]
+            : null;
+    });
+    assert.notEqual(reconnectedDevice.sessionId, oldSessionId);
+    assert.equal(reconnectedDevice.connected, true);
+    assert.equal(reconnectedDevice.latestTask, null);
+    assert.equal(reconnectedDevice.counters.taskResultsReceived, 0);
+
+    await wait(100);
+    const staleSessionIgnoredDevice = hub.listDevices()[0];
+    assert.equal(staleSessionIgnoredDevice.sessionId, reconnectedDevice.sessionId);
+    assert.equal(staleSessionIgnoredDevice.deviceName, 'Smoke Device Reconnected');
+    assert.equal(staleSessionIgnoredDevice.status.uptimeSec, 2);
+    assert.equal(staleSessionIgnoredDevice.latestTask, null);
+    assert.equal(staleSessionIgnoredDevice.counters.taskResultsReceived, 0);
+
+    replacementSocket.destroy();
+    await waitFor(() => hub.listDevices()[0]?.connected === false);
+    console.log('RemoteHub smoke OK');
+} finally {
+    await hub.close();
+}