@mindexec/cli 0.2.11 → 0.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -20,9 +20,10 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs",
     "test:remote": "node scripts/remote-hub-smoke.mjs",
     "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
+    "test:remote:render": "node scripts/remote-fleet-render-smoke.mjs",
     "pack:dry": "npm pack --dry-run",
     "setup:grammars": "node scripts/setup-tree-sitter-grammars.mjs",
     "postinstall": "npm run setup:grammars"

package/remote-hub.js

@@ -377,6 +377,8 @@ export function createRemoteHub(options = {}) {
                     completedAt: taskStatus === 'completed' || taskStatus === 'failed' ? seenAt : '',
                     error: taskStatus === 'failed' ? 'Synthetic task failure sample.' : '',
                     resultKind: 'synthetic-agent-task',
+                    resultModel: hasAiAssist ? 'synthetic-ai' : '',
+                    resultResponseId: hasAiAssist ? `synthetic-response-${ordinal}` : '',
                     resultSummary: taskStatus === 'failed'
                         ? 'Synthetic task reported a sample issue.'
                         : 'Synthetic task completed for scale validation.'
@@ -638,6 +640,8 @@ export function createRemoteHub(options = {}) {
         task.error = error;
         task.resultSummary = error || summarizeTaskResult(result);
         task.resultKind = safeString(result?.kind || result?.mode || 'agent-task', 80);
+        task.resultModel = safeString(result?.model || result?.aiModel || '', 120);
+        task.resultResponseId = safeString(result?.responseId || result?.id || '', 160);
         device.latestTask = task;
         device.pendingTaskCommands.delete(commandId);
         device.counters.taskResultsReceived += 1;
@@ -1046,6 +1050,12 @@ export function createRemoteHub(options = {}) {
                 completedAt: now,
                 error: '',
                 resultKind: approvalLevel === 'ai-assist' ? 'synthetic-ai-assist' : 'synthetic-agent-task',
+                resultModel: approvalLevel === 'ai-assist'
+                    ? safeString(options.model, 120) || 'synthetic-ai'
+                    : '',
+                resultResponseId: approvalLevel === 'ai-assist'
+                    ? `synthetic-response-${taskId}`
+                    : '',
                 resultSummary: approvalLevel === 'ai-assist'
                     ? `Synthetic AI assist completed for ${device.deviceName}.`
                     : `Synthetic task accepted by ${device.deviceName}.`
@@ -1108,6 +1118,8 @@ export function createRemoteHub(options = {}) {
             completedAt: '',
             error: '',
             resultKind: '',
+            resultModel: '',
+            resultResponseId: '',
             resultSummary: ''
         };
 

package/scripts/remote-fleet-render-smoke.mjs

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { createRemoteHub } from '../remote-hub.js';
+
+const SYNTHETIC_COUNT = Number(process.env.REMOTE_FLEET_RENDER_SMOKE_COUNT || 250);
+
+function dataAttributeToDatasetKey(name) {
+    return String(name || '').replace(/^data-/, '').replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+class MiniStyle {
+    constructor() {
+        this._cssText = '';
+    }
+
+    get cssText() {
+        return this._cssText;
+    }
+
+    set cssText(value) {
+        this._cssText = String(value || '');
+        const displayMatch = /(?:^|;)\s*display\s*:\s*([^;]+)/i.exec(this._cssText);
+        if (displayMatch) {
+            this.display = displayMatch[1].trim();
+        }
+    }
+
+    setProperty(name, value) {
+        this[String(name)] = String(value);
+    }
+}
+
+class MiniClassList {
+    constructor(owner) {
+        this.owner = owner;
+        this.tokens = new Set();
+    }
+
+    add(...tokens) {
+        tokens.forEach(token => {
+            const value = String(token || '').trim();
+            if (value) {
+                this.tokens.add(value);
+            }
+        });
+        this.sync();
+    }
+
+    remove(...tokens) {
+        tokens.forEach(token => this.tokens.delete(String(token || '').trim()));
+        this.sync();
+    }
+
+    contains(token) {
+        return this.tokens.has(String(token || '').trim());
+    }
+
+    toggle(token, force) {
+        const value = String(token || '').trim();
+        if (!value) return false;
+        const shouldAdd = force === undefined ? !this.tokens.has(value) : !!force;
+        if (shouldAdd) {
+            this.tokens.add(value);
+        } else {
+            this.tokens.delete(value);
+        }
+        this.sync();
+        return shouldAdd;
+    }
+
+    sync() {
+        this.owner.className = [...this.tokens].join(' ');
+    }
+}
+
+class MiniElement {
+    constructor(tagName, ownerDocument) {
+        this.tagName = String(tagName || '').toUpperCase();
+        this.nodeName = this.tagName;
+        this.ownerDocument = ownerDocument;
+        this.parentElement = null;
+        this.children = [];
+        this.attributes = {};
+        this.dataset = {};
+        this.style = new MiniStyle();
+        this.classList = new MiniClassList(this);
+        this.className = '';
+        this._textContent = '';
+        this._listeners = new Map();
+        this.value = '';
+        this.checked = false;
+        this.disabled = false;
+    }
+
+    get textContent() {
+        return `${this._textContent}${this.children.map(child => child.textContent).join('')}`;
+    }
+
+    set textContent(value) {
+        this.children.forEach(child => {
+            child.parentElement = null;
+        });
+        this.children = [];
+        this._textContent = String(value ?? '');
+    }
+
+    get innerHTML() {
+        return '';
+    }
+
+    set innerHTML(_value) {
+        this.children.forEach(child => {
+            child.parentElement = null;
+        });
+        this.children = [];
+        this._textContent = '';
+    }
+
+    appendChild(child) {
+        if (!child) return child;
+        if (child.parentElement) {
+            child.parentElement.children = child.parentElement.children.filter(item => item !== child);
+        }
+        child.parentElement = this;
+        this.children.push(child);
+        return child;
+    }
+
+    remove() {
+        if (!this.parentElement) return;
+        this.parentElement.children = this.parentElement.children.filter(child => child !== this);
+        this.parentElement = null;
+    }
+
+    setAttribute(name, value) {
+        const key = String(name || '');
+        const text = String(value ?? '');
+        this.attributes[key] = text;
+        if (key === 'id') {
+            this.id = text;
+        } else if (key === 'class') {
+            this.className = text;
+            this.classList.tokens = new Set(text.split(/\s+/).filter(Boolean));
+        } else if (key.startsWith('data-')) {
+            this.dataset[dataAttributeToDatasetKey(key)] = text;
+        } else if (key === 'aria-label') {
+            this.ariaLabel = text;
+        }
+    }
+
+    getAttribute(name) {
+        const key = String(name || '');
+        if (key.startsWith('data-')) {
+            return this.dataset[dataAttributeToDatasetKey(key)];
+        }
+        return this.attributes[key];
+    }
+
+    addEventListener(type, listener) {
+        const key = String(type || '');
+        if (!this._listeners.has(key)) {
+            this._listeners.set(key, []);
+        }
+        this._listeners.get(key).push(listener);
+    }
+
+    dispatchEvent(event) {
+        const payload = typeof event === 'string' ? { type: event } : { ...(event || {}) };
+        payload.type = payload.type || 'event';
+        payload.target = payload.target || this;
+        payload.currentTarget = this;
+        payload.preventDefault = payload.preventDefault || (() => {});
+        payload.stopPropagation = payload.stopPropagation || (() => {});
+        for (const listener of this._listeners.get(payload.type) || []) {
+            listener(payload);
+        }
+        return true;
+    }
+
+    querySelector(selector) {
+        return this.querySelectorAll(selector)[0] || null;
+    }
+
+    querySelectorAll(selector) {
+        const matches = [];
+        const visit = element => {
+            for (const child of element.children) {
+                if (matchesSelector(child, selector)) {
+                    matches.push(child);
+                }
+                visit(child);
+            }
+        };
+        visit(this);
+        return matches;
+    }
+
+    closest(selector) {
+        let current = this;
+        while (current) {
+            if (matchesSelector(current, selector)) {
+                return current;
+            }
+            current = current.parentElement;
+        }
+        return null;
+    }
+
+    contains(node) {
+        let current = node;
+        while (current) {
+            if (current === this) return true;
+            current = current.parentElement;
+        }
+        return false;
+    }
+}
+
+class MiniDocument {
+    constructor() {
+        this.body = new MiniElement('body', this);
+        this.head = new MiniElement('head', this);
+    }
+
+    createElement(tagName) {
+        return new MiniElement(tagName, this);
+    }
+
+    getElementById(id) {
+        const target = String(id || '');
+        return [this.head, this.body]
+            .flatMap(root => root.querySelectorAll('*'))
+            .find(element => element.id === target) || null;
+    }
+
+    querySelector(selector) {
+        return this.body.querySelector(selector) || this.head.querySelector(selector);
+    }
+
+    querySelectorAll(selector) {
+        return [
+            ...this.head.querySelectorAll(selector),
+            ...this.body.querySelectorAll(selector)
+        ];
+    }
+}
+
+function matchesSelector(element, selector) {
+    const text = String(selector || '').trim();
+    if (!text || !element) return false;
+    if (text === '*') return true;
+
+    const tagMatch = /^[a-zA-Z][\w-]*/.exec(text);
+    if (tagMatch && element.tagName.toLowerCase() !== tagMatch[0].toLowerCase()) {
+        return false;
+    }
+
+    for (const classMatch of text.matchAll(/\.([\w-]+)/g)) {
+        if (!element.classList.contains(classMatch[1])) {
+            return false;
+        }
+    }
+
+    for (const attrMatch of text.matchAll(/\[([^\]=]+)(?:="([^"]*)")?\]/g)) {
+        const attrName = attrMatch[1];
+        const expected = attrMatch[2];
+        const actual = attrName.startsWith('data-')
+            ? element.dataset[dataAttributeToDatasetKey(attrName)]
+            : element.getAttribute(attrName);
+        if (actual === undefined || actual === null) {
+            return false;
+        }
+        if (expected !== undefined && String(actual) !== expected) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+function readStatusNumber(status, key) {
+    const value = status?.[key];
+    return Number.isFinite(Number(value)) ? Number(value) : null;
+}
+
+function readLoad1(status) {
+    const value = status?.loadavg;
+    return Array.isArray(value) && Number.isFinite(Number(value[0])) ? Number(value[0]) : null;
+}
+
+function projectDevice(device) {
+    const status = device.status || {};
+    const capabilities = device.capabilities || {};
+    const thumbnail = device.latestThumbnail || {};
+    const liveFrame = device.latestLiveFrame || {};
+    const liveStream = device.activeLiveStream || {};
+    const latestTask = device.latestTask || {};
+    const platform = String(status.platform || device.platform || 'unknown');
+
+    return {
+        DeviceId: String(device.deviceId || ''),
+        SessionId: String(device.sessionId || ''),
+        Name: String(device.deviceName || device.hostname || device.deviceId || 'device'),
+        Hostname: String(device.hostname || ''),
+        Platform: platform,
+        Release: String(status.release || ''),
+        Arch: String(device.arch || ''),
+        AgentVersion: String(device.agentVersion || ''),
+        Connected: device.connected === true,
+        ConnectedAt: String(device.connectedAt || ''),
+        DisconnectedAt: String(device.disconnectedAt || ''),
+        LastSeenAt: String(device.lastSeenAt || ''),
+        LastStatusAt: String(device.lastStatusAt || ''),
+        LastDisconnectReason: String(device.lastDisconnectReason || ''),
+        RemoteAddress: String(device.remoteAddress || ''),
+        RemotePort: Number(device.remotePort || 0),
+        UptimeSec: readStatusNumber(status, 'uptimeSec'),
+        UsedMemRatio: readStatusNumber(status, 'usedMemRatio'),
+        Load1: readLoad1(status),
+        StatusEnabled: capabilities.status === true,
+        ThumbnailEnabled: capabilities.thumbnail === true,
+        LiveStreamEnabled: capabilities.liveStream === true,
+        ControlEnabled: capabilities.control === true,
+        ComputerAgentEnabled: capabilities.computerAgent === true || capabilities.taskDispatch === true,
+        AiAssistEnabled: capabilities.aiAssist === true,
+        AiModel: String(capabilities.aiModel || ''),
+        AiProvider: String(capabilities.aiProvider || ''),
+        ThumbnailStreamId: String(thumbnail.streamId || ''),
+        ThumbnailFrameSeq: Number(thumbnail.frameSeq || 0),
+        ThumbnailWidth: Number(thumbnail.width || 0),
+        ThumbnailHeight: Number(thumbnail.height || 0),
+        ThumbnailMimeType: String(thumbnail.mimeType || thumbnail.format || ''),
+        ThumbnailCapturedAt: String(thumbnail.capturedAt || ''),
+        ThumbnailReceivedAt: String(thumbnail.receivedAt || ''),
+        ThumbnailDataUrl: String(thumbnail.dataUrl || ''),
+        LiveStreamActive: liveStream.active === true,
+        LiveStreamId: String(liveStream.streamId || ''),
+        LiveStreamMode: String(liveStream.mode || ''),
+        LiveStreamFps: Number(liveStream.fps || 0),
+        LiveStreamStartedAt: String(liveStream.startedAt || ''),
+        LiveStreamStoppedAt: String(liveStream.stoppedAt || ''),
+        LiveStreamLastFrameAt: String(liveStream.lastFrameAt || ''),
+        LiveStreamFrameSeq: Number(liveStream.lastFrameSeq || 0),
+        LiveFrameStreamId: String(liveFrame.streamId || ''),
+        LiveFrameSeq: Number(liveFrame.frameSeq || 0),
+        LiveFrameWidth: Number(liveFrame.width || 0),
+        LiveFrameHeight: Number(liveFrame.height || 0),
+        LiveFrameMimeType: String(liveFrame.mimeType || liveFrame.format || ''),
+        LiveFrameCapturedAt: String(liveFrame.capturedAt || ''),
+        LiveFrameReceivedAt: String(liveFrame.receivedAt || ''),
+        LiveFrameDataUrl: String(liveFrame.dataUrl || ''),
+        LatestTaskId: String(latestTask.taskId || ''),
+        LatestTaskCommandId: String(latestTask.commandId || ''),
+        LatestTaskTitle: String(latestTask.title || ''),
+        LatestTaskInstructionPreview: String(latestTask.instructionPreview || ''),
+        LatestTaskStatus: String(latestTask.status || ''),
+        LatestTaskApprovalLevel: String(latestTask.approvalLevel || ''),
+        LatestTaskUpdatedAt: String(latestTask.updatedAt || latestTask.completedAt || latestTask.sentAt || ''),
+        LatestTaskError: String(latestTask.error || ''),
+        LatestTaskResultModel: String(latestTask.resultModel || ''),
+        LatestTaskResultResponseId: String(latestTask.resultResponseId || ''),
+        LatestTaskResultSummary: String(latestTask.resultSummary || '')
+    };
+}
+
+async function loadCss3DManager() {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const managerPath = path.resolve(__dirname, '../../MindExecution.Shared/wwwroot/js/mind-map-css3d-manager.js');
+    const source = await fs.readFile(managerPath, 'utf8');
+    const document = new MiniDocument();
+    const context = {
+        console,
+        document,
+        navigator: {
+            clipboard: {
+                writeText: async () => {}
+            }
+        },
+        setInterval: () => 0,
+        clearInterval: () => {},
+        setTimeout,
+        clearTimeout,
+        Date,
+        Math,
+        Number,
+        String,
+        Boolean,
+        Array,
+        Object,
+        JSON,
+        RegExp,
+        Map,
+        Set,
+        WeakMap,
+        THREE: createThreeStub(),
+        URL,
+        Promise
+    };
+    context.window = context;
+    context.self = context;
+
+    vm.runInNewContext(source, context, { filename: managerPath });
+    return { manager: context.window.MindMapCss3DManager, document };
+}
+
+function buildMonitorNode(devices, hubStatus) {
+    const connected = devices.filter(device => device.Connected).length;
+    const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
+    const pairToken = hubStatus.pairToken || 'render-smoke-token';
+    return {
+        id: 'remote-fleet-render-smoke',
+        contentType: 'memo',
+        metadata: {
+            SemanticType: 'RemoteFleetMonitor',
+            RemoteFleetSchemaVersion: 'remote-fleet@1',
+            RemoteFleetViewMode: 'all-devices',
+            RemoteFleetLastRefreshAtUtc: new Date().toISOString(),
+            RemoteFleetHubStatus: 'online',
+            RemoteFleetHubEndpoint: endpoint,
+            RemoteFleetAgentPackage: '@mindexec/remote',
+            RemoteFleetPairTokenPreview: '<pair-token>',
+            RemoteFleetConnectCommand: `npx @mindexec/remote connect --manager ${endpoint} --pair ${pairToken}`,
+            RemoteFleetDeviceCount: String(devices.length),
+            RemoteFleetConnectedDeviceCount: String(connected),
+            RemoteFleetCanvasPagination: 'none',
+            RemoteFleetDevicesJson: JSON.stringify(devices),
+            RemoteFleetLastError: ''
+        }
+    };
+}
+
+function buildDeviceNode(device, hubStatus) {
+    const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
+    return {
+        id: 'remote-device-render-smoke',
+        contentType: 'memo',
+        metadata: {
+            SemanticType: 'RemoteFleetDevice',
+            RemoteFleetSchemaVersion: 'remote-device@1',
+            RemoteFleetViewMode: 'pinned-device',
+            RemoteFleetLastRefreshAtUtc: new Date().toISOString(),
+            RemoteFleetHubStatus: 'online',
+            RemoteFleetHubEndpoint: endpoint,
+            RemoteFleetAgentPackage: '@mindexec/remote',
+            RemoteFleetPinnedDeviceId: device.DeviceId,
+            RemoteFleetPinnedDeviceJson: JSON.stringify(device),
+            RemoteFleetLastError: ''
+        }
+    };
+}
+
+function createThreeStub() {
+    class Vector3 {
+        constructor(x = 0, y = 0, z = 0) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
+
+        set(x = 0, y = 0, z = 0) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            return this;
+        }
+    }
+
+    class Matrix4 {
+        multiplyMatrices() { return this; }
+    }
+
+    class Frustum {
+        setFromProjectionMatrix() { return this; }
+        intersectsBox() { return true; }
+    }
+
+    class Quaternion {}
+
+    class Box3 {
+        setFromCenterAndSize() { return this; }
+    }
+
+    return { Box3, Frustum, Matrix4, Quaternion, Vector3 };
+}
+
+const hub = createRemoteHub({
+    env: {
+        MINDEXEC_REMOTE_HUB: '1',
+        REMOTE_HUB_HOST: '127.0.0.1',
+        REMOTE_HUB_PORT: '0',
+        REMOTE_HUB_PAIR_TOKEN: 'render-smoke-token'
+    }
+});
+
+try {
+    await hub.start();
+    const seeded = hub.seedSyntheticFleet({
+        count: SYNTHETIC_COUNT,
+        connectedRatio: 0.84,
+        thumbnailRatio: 0.72,
+        aiAssistRatio: 0.42,
+        liveCount: 0
+    });
+    assert.equal(seeded.ok, true);
+    assert.equal(seeded.seeded, SYNTHETIC_COUNT);
+
+    const seededAiTarget = hub.listDevices().find(device =>
+        device.connected && device.capabilities?.taskDispatch && device.capabilities?.aiAssist);
+    assert.ok(seededAiTarget);
+    const renderAiTask = hub.requestAgentTask(seededAiTarget.deviceId, {
+        instruction: 'Synthetic render smoke AI task: report model metadata to the canvas.',
+        title: 'Render smoke AI task',
+        approvalLevel: 'ai-assist',
+        model: 'synthetic-render-ai'
+    });
+    assert.equal(renderAiTask.ok, true);
+
+    const rawDevices = hub.listDevices();
+    const devices = rawDevices.map(projectDevice);
+    const connectedCount = devices.filter(device => device.Connected).length;
+    const offlineCount = devices.length - connectedCount;
+    const aiCount = devices.filter(device => device.Connected && device.AiAssistEnabled).length;
+    const focusedDevice = devices.find(device => device.Connected);
+    assert.ok(focusedDevice);
+
+    const { manager, document } = await loadCss3DManager();
+    assert.equal(typeof manager?.renderRemoteFleetMonitorForTest, 'function');
+    assert.equal(typeof manager?.renderRemoteFleetDeviceForTest, 'function');
+
+    const bodyView = document.createElement('div');
+    bodyView.dataset.remoteFleetAutoMonitor = 'false';
+    bodyView.dataset.remoteFleetFocusDeviceId = focusedDevice.DeviceId;
+    document.body.appendChild(bodyView);
+
+    manager.renderRemoteFleetMonitorForTest(bodyView, buildMonitorNode(devices, hub.getStatus({ includeSecrets: true })));
+
+    let cards = bodyView.querySelectorAll('article[data-device-id]');
+    assert.equal(cards.length, SYNTHETIC_COUNT);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${SYNTHETIC_COUNT}/${SYNTHETIC_COUNT}`);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="pin-device"]').length, SYNTHETIC_COUNT);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="task-device"]').length, connectedCount);
+    assert.equal(bodyView.querySelectorAll('[data-remote-fleet-action="thumbnail-device"]').length, devices.filter(device => device.Connected && device.ThumbnailEnabled).length);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-live-panel="true"]')?.dataset.deviceId, focusedDevice.DeviceId);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-action="task-visible"]')?.disabled, false);
+    assert.ok(bodyView.textContent.includes('all devices, no paging'));
+    assert.ok(bodyView.querySelector('code')?.textContent.includes('npx @mindexec/remote connect'));
+    assert.ok(bodyView.textContent.includes('synthetic-render-ai'));
+    assert.ok(devices.some(device => /^synthetic-response-/.test(device.LatestTaskResultResponseId)));
+
+    const searchInput = bodyView.querySelector('[data-remote-fleet-search="true"]');
+    searchInput.value = 'synthetic pc 0001';
+    searchInput.dispatchEvent({ type: 'input' });
+    cards = bodyView.querySelectorAll('article[data-device-id]');
+    assert.equal(cards.filter(card => card.style.display !== 'none').length, 1);
+    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `1/${SYNTHETIC_COUNT}`);
+
+    const selects = bodyView.querySelectorAll('select');
+    assert.equal(selects.length, 4);
+    const [filterSelect, , groupSelect] = selects;
+    searchInput.value = '';
+    searchInput.dispatchEvent({ type: 'input' });
+    filterSelect.value = 'offline';
+    filterSelect.dispatchEvent({ type: 'change' });
+    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${offlineCount}/${SYNTHETIC_COUNT}`);
+
+    filterSelect.value = 'ai';
+    filterSelect.dispatchEvent({ type: 'change' });
+    assert.equal(bodyView.querySelector('[data-remote-fleet-match-count="true"]')?.textContent, `${aiCount}/${SYNTHETIC_COUNT}`);
+
+    filterSelect.value = 'all';
+    filterSelect.dispatchEvent({ type: 'change' });
+    groupSelect.value = 'status';
+    groupSelect.dispatchEvent({ type: 'change' });
+    assert.equal(bodyView.dataset.remoteFleetGroup, 'status');
+    assert.ok(bodyView.querySelectorAll('[data-remote-fleet-group-header="true"]').length >= 2);
+    assert.equal(bodyView.querySelectorAll('article[data-device-id]').length, SYNTHETIC_COUNT);
+
+    const deviceBody = document.createElement('div');
+    document.body.appendChild(deviceBody);
+    manager.renderRemoteFleetDeviceForTest(deviceBody, buildDeviceNode(focusedDevice, hub.getStatus()));
+    assert.ok(deviceBody.textContent.includes(focusedDevice.Name));
+    assert.ok(deviceBody.querySelector('[data-remote-fleet-action="refresh-device"]'));
+    assert.ok(deviceBody.querySelector('[data-remote-fleet-action="task-device"]'));
+    assert.ok(deviceBody.textContent.includes(focusedDevice.DeviceId));
+
+    console.log(`RemoteFleet render smoke OK (${SYNTHETIC_COUNT} synthetic devices, ${connectedCount} connected, ${aiCount} AI-ready)`);
+} finally {
+    await hub.close();
+}

package/scripts/remote-hub-scale-smoke.mjs

@@ -95,8 +95,10 @@ try {
     });
     assert.equal(aiResult.ok, true);
     assert.equal(aiResult.approvalLevel, 'ai-assist');
-    assert.equal(hub.listDevices().find(device => device.deviceId === aiTarget.deviceId)
-        ?.latestTask?.approvalLevel, 'ai-assist');
+    const updatedAiTarget = hub.listDevices().find(device => device.deviceId === aiTarget.deviceId);
+    assert.equal(updatedAiTarget?.latestTask?.approvalLevel, 'ai-assist');
+    assert.equal(updatedAiTarget?.latestTask?.resultModel, 'synthetic-ai');
+    assert.match(updatedAiTarget?.latestTask?.resultResponseId || '', /^synthetic-response-/);
 
     const cleared = hub.clearSyntheticFleet();
     assert.equal(cleared.ok, true);

package/scripts/remote-hub-smoke.mjs

@@ -210,6 +210,8 @@ try {
             taskId: aiTaskCommand.taskId,
             status: 'completed',
             summary: 'Smoke AI task accepted.',
+            model: 'smoke-ai-model',
+            responseId: 'smoke-ai-response',
             completedAt: new Date().toISOString()
         }
     });
@@ -223,6 +225,8 @@ try {
             : 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);
 

package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-manager.js

@@ -12292,6 +12292,8 @@
             isRemoteFleetLiveActive(device) ? 'live active remote-fast' : '',
             getRemoteFleetDeviceField(device, 'latestTaskTitle', 'LatestTaskTitle', ''),
             getRemoteFleetDeviceField(device, 'latestTaskStatus', 'LatestTaskStatus', ''),
+            getRemoteFleetDeviceField(device, 'latestTaskResultModel', 'LatestTaskResultModel', ''),
+            getRemoteFleetDeviceField(device, 'latestTaskResultResponseId', 'LatestTaskResultResponseId', ''),
             getRemoteFleetDeviceField(device, 'latestTaskResultSummary', 'LatestTaskResultSummary', ''),
             getRemoteFleetDeviceField(device, 'latestTaskError', 'LatestTaskError', '')
         ].join(' ').toLowerCase();
@@ -12470,6 +12472,8 @@
         const latestTaskApproval = String(getRemoteFleetDeviceField(device, 'latestTaskApprovalLevel', 'LatestTaskApprovalLevel', ''));
         const latestTaskUpdatedAt = String(getRemoteFleetDeviceField(device, 'latestTaskUpdatedAt', 'LatestTaskUpdatedAt', ''));
         const latestTaskError = String(getRemoteFleetDeviceField(device, 'latestTaskError', 'LatestTaskError', ''));
+        const latestTaskResultModel = String(getRemoteFleetDeviceField(device, 'latestTaskResultModel', 'LatestTaskResultModel', ''));
+        const latestTaskResultResponseId = String(getRemoteFleetDeviceField(device, 'latestTaskResultResponseId', 'LatestTaskResultResponseId', ''));
         const latestTaskResult = String(getRemoteFleetDeviceField(device, 'latestTaskResultSummary', 'LatestTaskResultSummary', ''));
 
         const header = document.createElement('div');
@@ -12587,7 +12591,10 @@
             `;
             const taskLine = document.createElement('div');
             const taskModeLabel = latestTaskApproval === 'ai-assist' ? 'AI' : 'Task';
-            taskLine.textContent = `${taskModeLabel} ${latestTaskStatus || 'task'}${latestTaskUpdatedAt ? ` - ${formatRemoteFleetAge(latestTaskUpdatedAt)}` : ''}`;
+            taskLine.textContent = `${taskModeLabel} ${latestTaskStatus || 'task'}${latestTaskUpdatedAt ? ` - ${formatRemoteFleetAge(latestTaskUpdatedAt)}` : ''}${latestTaskResultModel ? ` - ${latestTaskResultModel}` : ''}`;
+            taskLine.title = latestTaskResultResponseId
+                ? `${taskLine.textContent} (${latestTaskResultResponseId})`
+                : taskLine.textContent;
             taskLine.style.cssText = `color:${taskTone === 'error' ? '#991b1b' : taskTone === 'done' ? '#047857' : '#1d4ed8'};font-size:10px;font-weight:900;line-height:1.2;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;letter-spacing:0;`;
             const taskSummary = document.createElement('div');
             taskSummary.textContent = latestTaskError || latestTaskResult || latestTaskTitle || 'Task queued';
@@ -13376,6 +13383,8 @@
                 const latestTaskApproval = String(device?.latestTaskApprovalLevel || device?.LatestTaskApprovalLevel || '');
                 const latestTaskUpdatedAt = String(device?.latestTaskUpdatedAt || device?.LatestTaskUpdatedAt || '');
                 const latestTaskError = String(device?.latestTaskError || device?.LatestTaskError || '');
+                const latestTaskResultModel = String(device?.latestTaskResultModel || device?.LatestTaskResultModel || '');
+                const latestTaskResultResponseId = String(device?.latestTaskResultResponseId || device?.LatestTaskResultResponseId || '');
                 const latestTaskResult = String(device?.latestTaskResultSummary || device?.LatestTaskResultSummary || '');
                 const groupInfo = getRemoteFleetGroupInfo(device, groupState);
                 if (groupState !== 'none' && groupInfo.key && groupInfo.key !== lastGroupKey) {
@@ -13613,7 +13622,10 @@
                     `;
                     const taskLine = document.createElement('div');
                     const taskModeLabel = latestTaskApproval === 'ai-assist' ? 'AI' : 'Task';
-                    taskLine.textContent = `${taskModeLabel} ${latestTaskStatus || 'task'}${latestTaskUpdatedAt ? ` - ${formatRemoteFleetAge(latestTaskUpdatedAt)}` : ''}`;
+                    taskLine.textContent = `${taskModeLabel} ${latestTaskStatus || 'task'}${latestTaskUpdatedAt ? ` - ${formatRemoteFleetAge(latestTaskUpdatedAt)}` : ''}${latestTaskResultModel ? ` - ${latestTaskResultModel}` : ''}`;
+                    taskLine.title = latestTaskResultResponseId
+                        ? `${taskLine.textContent} (${latestTaskResultResponseId})`
+                        : taskLine.textContent;
                     taskLine.style.cssText = `
                         color: ${taskTone === 'error' ? '#991b1b' : taskTone === 'done' ? '#047857' : '#1d4ed8'};
                         font-size: 10px;
@@ -18079,6 +18091,8 @@
         syncVideoNodeVisibilityPlayback: syncVideoNodeVisibilityPlayback,
         syncEditingOverlay: syncEditingOverlay,
         syncTextOverlays: syncTextOverlays,
+        renderRemoteFleetMonitorForTest: renderRemoteFleetMonitor,
+        renderRemoteFleetDeviceForTest: renderRemoteFleetDevice,
         renderBusinessAutomationEdges: renderBusinessAutomationEdges,
         scheduleBusinessAutomationEdgeRender: scheduleBusinessAutomationEdgeRender,
         hideBusinessAutomationFloatingTooltipForNode: hideBusinessAutomationFloatingTooltipForNode,

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-AfctgIeogWni4PMiafMrW/TiX1otsT+MSNhvCPr7EjA=",
+    "hash": "sha256-0k5T2HJtoTcXNrqcYPQNVAHSTuKIGNo59QRDVoAnHl4=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -123,16 +123,16 @@
       "System.m05i39uvk9.dll": "System.dll",
       "netstandard.0xet7jg7ky.dll": "netstandard.dll",
       "System.Private.CoreLib.rkafq04oma.dll": "System.Private.CoreLib.dll",
-      "MindExecution.Core.pnw79cgqjx.dll": "MindExecution.Core.dll",
-      "MindExecution.Kernel.dt3w864bqn.dll": "MindExecution.Kernel.dll",
-      "MindExecution.Plugins.Admin.z93cu32xru.dll": "MindExecution.Plugins.Admin.dll",
-      "MindExecution.Plugins.Business.b6da8sg85t.dll": "MindExecution.Plugins.Business.dll",
-      "MindExecution.Plugins.Concept.sj3ujw4e72.dll": "MindExecution.Plugins.Concept.dll",
-      "MindExecution.Plugins.Directory.rjod6rdmly.dll": "MindExecution.Plugins.Directory.dll",
-      "MindExecution.Plugins.PlanMaster.ec8ccog2o3.dll": "MindExecution.Plugins.PlanMaster.dll",
-      "MindExecution.Plugins.YouTube.mk7a07org5.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.mc9gi9kvqg.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.n70z8m41l3.dll": "MindExecution.Web.dll",
+      "MindExecution.Core.q469sducjw.dll": "MindExecution.Core.dll",
+      "MindExecution.Kernel.lqglgq2jmo.dll": "MindExecution.Kernel.dll",
+      "MindExecution.Plugins.Admin.2jqptn6ylw.dll": "MindExecution.Plugins.Admin.dll",
+      "MindExecution.Plugins.Business.8hzwity3fl.dll": "MindExecution.Plugins.Business.dll",
+      "MindExecution.Plugins.Concept.4jfcx4yb6n.dll": "MindExecution.Plugins.Concept.dll",
+      "MindExecution.Plugins.Directory.hr2p0grenr.dll": "MindExecution.Plugins.Directory.dll",
+      "MindExecution.Plugins.PlanMaster.gnc7ediozd.dll": "MindExecution.Plugins.PlanMaster.dll",
+      "MindExecution.Plugins.YouTube.nb68y61g8l.dll": "MindExecution.Plugins.YouTube.dll",
+      "MindExecution.Shared.fut0ze7fxs.dll": "MindExecution.Shared.dll",
+      "MindExecution.Web.gzr3k0ca14.dll": "MindExecution.Web.dll",
       "dotnet.js": "dotnet.js",
       "dotnet.native.xsn1d6x2kd.js": "dotnet.native.js",
       "dotnet.native.vz0adxojrz.wasm": "dotnet.native.wasm",
@@ -278,18 +278,18 @@
       "System.Xml.XDocument.c539ki6cuq.dll": "sha256-MPTRJkptrL9nGa2tl4kF46+wErNUYRPCGblX3ANoKoY=",
       "System.m05i39uvk9.dll": "sha256-5jDfIdbYAigw7/Q/lMzt5W/+cayGbW9ko9FvuaN1GsQ=",
       "netstandard.0xet7jg7ky.dll": "sha256-xENDv620uJ8fHwLJ2bdhrTHz4QPjvqXOztnk2a4wr0c=",
-      "MindExecution.Core.pnw79cgqjx.dll": "sha256-64VJ+VCnq+r7lgfYzm99hPX3yo5u2QCC4guGqsrVTus=",
-      "MindExecution.Kernel.dt3w864bqn.dll": "sha256-r0Q9mY7CB+L/3j7KlKlNiyLBlXcwBkPRtjGh0RBZOFs=",
-      "MindExecution.Plugins.Concept.sj3ujw4e72.dll": "sha256-eKBzfvFolc9FJhorB30L48rhIU4Ue/8vt1QO2wvOT0w=",
-      "MindExecution.Plugins.PlanMaster.ec8ccog2o3.dll": "sha256-PiE9Rs3TkNAWvj38n/uaLil6xi2eRYeFUTQhDsdiuA4=",
-      "MindExecution.Shared.mc9gi9kvqg.dll": "sha256-qlYWbNOfw5WCQm9YXBQj3DT2pPJcHtDxdeQ/99jrpTs=",
-      "MindExecution.Web.n70z8m41l3.dll": "sha256-04vr/dzHUHxf++L+m7zQsKAtV3khH9yNrcl4CouSppw="
+      "MindExecution.Core.q469sducjw.dll": "sha256-tqgvXepOZPfdkyxH1BK3KlhL8azJjoV+iV/BismieCc=",
+      "MindExecution.Kernel.lqglgq2jmo.dll": "sha256-AyAPsZpAwsH/HeC6cWVzRH50hBjGAoamzGup6clWJTg=",
+      "MindExecution.Plugins.Concept.4jfcx4yb6n.dll": "sha256-YPWPQZNVfc6RXAiQjyj/WFnsRDCdJNDJymWZb88v93Q=",
+      "MindExecution.Plugins.PlanMaster.gnc7ediozd.dll": "sha256-zH2yvZLPWKNI6dutFs8Dt3WctekhA9G4R2NpOgNgFWs=",
+      "MindExecution.Shared.fut0ze7fxs.dll": "sha256-F8IWkvkVKPcwPF/L7AY48/QBX6Bbh5H3mWr7bO8/+cE=",
+      "MindExecution.Web.gzr3k0ca14.dll": "sha256-bIRn+xBPamwTWtFM/BGSzGH6FN2PngGLx2Qc7ewoARc="
     },
     "lazyAssembly": {
-      "MindExecution.Plugins.Admin.z93cu32xru.dll": "sha256-aToPZeovhBXkB0URHkzYdYDAmg1+HxsvojgiefL4pkY=",
-      "MindExecution.Plugins.Business.b6da8sg85t.dll": "sha256-M1macJ1ZqfBCrj/1WPw2JQxnFtFX31HxydBxQKa3Cgw=",
-      "MindExecution.Plugins.Directory.rjod6rdmly.dll": "sha256-hx8N04/7sIYB8PdHSyVTLhPfPb7ZkmqM1RPBB1J0iuw=",
-      "MindExecution.Plugins.YouTube.mk7a07org5.dll": "sha256-1gBQNQ4XkMp71HDUpy2X4q/IG5lrrMhuhwPdASIp0TA="
+      "MindExecution.Plugins.Admin.2jqptn6ylw.dll": "sha256-ctRNgHtUfPq0pCvAeG0DCzZPBRTgLtQC2c4pjGFM+Go=",
+      "MindExecution.Plugins.Business.8hzwity3fl.dll": "sha256-ZL74Jut/WgaNdDBWZzhC6ECsjBdm+0cB1P5fx4ACugM=",
+      "MindExecution.Plugins.Directory.hr2p0grenr.dll": "sha256-PUrdpFqGptJ5kxYaarWNwB2NmZ1TphHnFHlnyQL48DI=",
+      "MindExecution.Plugins.YouTube.nb68y61g8l.dll": "sha256-/eNjC7gKzfLxjrGniD+Bv2L+4ZlxzV4ocXSe12owKDs="
     }
   },
   "cacheBootResources": true,

package/wwwroot/index.html

@@ -558,7 +558,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-            const scriptVersion = '20260612-remote-device-pin-v470';
+            const scriptVersion = '20260612-remote-ai-result-metadata-v472';
             const scriptUrl = (script) => `${base}${script}?v=${scriptVersion}`;
             console.log(`[Script Loader] Shared JS version: ${scriptVersion}`);
             const criticalScripts = [

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "x1hfM46o",
+    "version":  "+m3+ATnr",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-LSO5/TRH4+1bNtJc7X09UZHrFfaIF1SkX012PLDVndg=",
+                       "hash":  "sha256-TRPlxHfTd5M/XAy1bnnYRmTFqExG/OMAo4jSJSVcZjk=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {
@@ -410,44 +410,44 @@
                        "url":  "_framework/MimeMapping.og9ys58ylm.dll"
                    },
                    {
-                       "hash":  "sha256-64VJ+VCnq+r7lgfYzm99hPX3yo5u2QCC4guGqsrVTus=",
-                       "url":  "_framework/MindExecution.Core.pnw79cgqjx.dll"
+                       "hash":  "sha256-tqgvXepOZPfdkyxH1BK3KlhL8azJjoV+iV/BismieCc=",
+                       "url":  "_framework/MindExecution.Core.q469sducjw.dll"
                    },
                    {
-                       "hash":  "sha256-r0Q9mY7CB+L/3j7KlKlNiyLBlXcwBkPRtjGh0RBZOFs=",
-                       "url":  "_framework/MindExecution.Kernel.dt3w864bqn.dll"
+                       "hash":  "sha256-AyAPsZpAwsH/HeC6cWVzRH50hBjGAoamzGup6clWJTg=",
+                       "url":  "_framework/MindExecution.Kernel.lqglgq2jmo.dll"
                    },
                    {
-                       "hash":  "sha256-aToPZeovhBXkB0URHkzYdYDAmg1+HxsvojgiefL4pkY=",
-                       "url":  "_framework/MindExecution.Plugins.Admin.z93cu32xru.dll"
+                       "hash":  "sha256-ctRNgHtUfPq0pCvAeG0DCzZPBRTgLtQC2c4pjGFM+Go=",
+                       "url":  "_framework/MindExecution.Plugins.Admin.2jqptn6ylw.dll"
                    },
                    {
-                       "hash":  "sha256-M1macJ1ZqfBCrj/1WPw2JQxnFtFX31HxydBxQKa3Cgw=",
-                       "url":  "_framework/MindExecution.Plugins.Business.b6da8sg85t.dll"
+                       "hash":  "sha256-ZL74Jut/WgaNdDBWZzhC6ECsjBdm+0cB1P5fx4ACugM=",
+                       "url":  "_framework/MindExecution.Plugins.Business.8hzwity3fl.dll"
                    },
                    {
-                       "hash":  "sha256-eKBzfvFolc9FJhorB30L48rhIU4Ue/8vt1QO2wvOT0w=",
-                       "url":  "_framework/MindExecution.Plugins.Concept.sj3ujw4e72.dll"
+                       "hash":  "sha256-YPWPQZNVfc6RXAiQjyj/WFnsRDCdJNDJymWZb88v93Q=",
+                       "url":  "_framework/MindExecution.Plugins.Concept.4jfcx4yb6n.dll"
                    },
                    {
-                       "hash":  "sha256-hx8N04/7sIYB8PdHSyVTLhPfPb7ZkmqM1RPBB1J0iuw=",
-                       "url":  "_framework/MindExecution.Plugins.Directory.rjod6rdmly.dll"
+                       "hash":  "sha256-PUrdpFqGptJ5kxYaarWNwB2NmZ1TphHnFHlnyQL48DI=",
+                       "url":  "_framework/MindExecution.Plugins.Directory.hr2p0grenr.dll"
                    },
                    {
-                       "hash":  "sha256-PiE9Rs3TkNAWvj38n/uaLil6xi2eRYeFUTQhDsdiuA4=",
-                       "url":  "_framework/MindExecution.Plugins.PlanMaster.ec8ccog2o3.dll"
+                       "hash":  "sha256-zH2yvZLPWKNI6dutFs8Dt3WctekhA9G4R2NpOgNgFWs=",
+                       "url":  "_framework/MindExecution.Plugins.PlanMaster.gnc7ediozd.dll"
                    },
                    {
-                       "hash":  "sha256-1gBQNQ4XkMp71HDUpy2X4q/IG5lrrMhuhwPdASIp0TA=",
-                       "url":  "_framework/MindExecution.Plugins.YouTube.mk7a07org5.dll"
+                       "hash":  "sha256-/eNjC7gKzfLxjrGniD+Bv2L+4ZlxzV4ocXSe12owKDs=",
+                       "url":  "_framework/MindExecution.Plugins.YouTube.nb68y61g8l.dll"
                    },
                    {
-                       "hash":  "sha256-qlYWbNOfw5WCQm9YXBQj3DT2pPJcHtDxdeQ/99jrpTs=",
-                       "url":  "_framework/MindExecution.Shared.mc9gi9kvqg.dll"
+                       "hash":  "sha256-F8IWkvkVKPcwPF/L7AY48/QBX6Bbh5H3mWr7bO8/+cE=",
+                       "url":  "_framework/MindExecution.Shared.fut0ze7fxs.dll"
                    },
                    {
-                       "hash":  "sha256-04vr/dzHUHxf++L+m7zQsKAtV3khH9yNrcl4CouSppw=",
-                       "url":  "_framework/MindExecution.Web.n70z8m41l3.dll"
+                       "hash":  "sha256-bIRn+xBPamwTWtFM/BGSzGH6FN2PngGLx2Qc7ewoARc=",
+                       "url":  "_framework/MindExecution.Web.gzr3k0ca14.dll"
                    },
                    {
                        "hash":  "sha256-IsZJ91/OW+fHzNqIgEc7Y072ns8z9dGritiSyvR9Wgc=",
@@ -770,7 +770,7 @@
                        "url":  "_framework/Websocket.Client.vapounvmnl.dll"
                    },
                    {
-                       "hash":  "sha256-T6ZFGjsJ+b+J0Je7Wr8VCbBYyPPOsuCXwkoNQny1pak=",
+                       "hash":  "sha256-WXFIc3YdM6GgUBzkhMFzph+q2JHFQ5Tl3qtMOd09268=",
                        "url":  "_framework/blazor.boot.json"
                    },
                    {
@@ -834,7 +834,7 @@
                        "url":  "image-manifest.json"
                    },
                    {
-                       "hash":  "sha256-JxMVTLs/BdFFsgJ34YMkq3lh37rBZLnvhbj3f+MxRYo=",
+                       "hash":  "sha256-o+XpLh2krvIrD5ft3X1+naDQ0KDO4W8xARptLooMC6Q=",
                        "url":  "index.html"
                    },
                    {

package/wwwroot/service-worker.js

@@ -1,4 +1,4 @@
-/* Manifest version: x1hfM46o */
+/* Manifest version: +m3+ATnr */
 // Hosted deployments should prefer the network over stale offline caches.
 // This service worker immediately clears old Blazor offline caches and unregisters itself.