@mindexec/cli 0.2.15 → 0.2.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

package/remote-hub.js

@@ -5,12 +5,14 @@ import crypto from 'crypto';
 const DEFAULT_REMOTE_HUB_PORT = 5197;
 const DEFAULT_REMOTE_HUB_HOST = '127.0.0.1';
 const DEFAULT_HEARTBEAT_MS = 5000;
+const DEFAULT_AGENT_TASK_TIMEOUT_MS = 120000;
 const MAX_LINE_CHARS = 4 * 1024 * 1024;
 const MAX_THUMBNAIL_BASE64_CHARS = 3 * 1024 * 1024;
 const MAX_STREAM_BASE64_CHARS = 3 * 1024 * 1024;
 const MAX_AGENT_TASK_CHARS = 4000;
 const MAX_AGENT_TASK_RESULT_CHARS = 3000;
 const RECENT_TASK_LIMIT = 12;
+const RECENT_TASK_BATCH_LIMIT = 16;
 const REMOTE_PROTOCOL_VERSION = 1;
 const MAX_SYNTHETIC_DEVICES = 1000;
 const SYNTHETIC_FRAME_DATA_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
@@ -79,6 +81,7 @@ function createDeviceCounters(overrides = {}) {
         tasksQueued: 0,
         taskResultsReceived: 0,
         taskResultsFailed: 0,
+        taskResultsTimedOut: 0,
         ...overrides
     };
 }
@@ -152,6 +155,31 @@ function serializeDevice(device) {
     };
 }
 
+function serializeTaskBatch(batch) {
+    if (!batch) {
+        return null;
+    }
+
+    return {
+        batchId: batch.batchId,
+        title: batch.title,
+        instructionPreview: batch.instructionPreview,
+        approvalLevel: batch.approvalLevel,
+        status: batch.status,
+        requestedAt: batch.requestedAt,
+        updatedAt: batch.updatedAt,
+        total: batch.total,
+        queued: batch.queued,
+        pending: batch.pending,
+        completed: batch.completed,
+        failed: batch.failed,
+        timedOut: batch.timedOut,
+        results: Array.isArray(batch.results)
+            ? batch.results.map(item => ({ ...item }))
+            : []
+    };
+}
+
 function writeJsonLine(socket, payload) {
     if (!socket || socket.destroyed) {
         return false;
@@ -172,11 +200,17 @@ export function createRemoteHub(options = {}) {
     const host = safeString(env.REMOTE_HUB_HOST || DEFAULT_REMOTE_HUB_HOST, 128);
     const requestedPort = normalizePort(env.REMOTE_HUB_PORT || DEFAULT_REMOTE_HUB_PORT);
     const heartbeatMs = clampNumber(env.REMOTE_HUB_HEARTBEAT_MS, 1000, 60000, DEFAULT_HEARTBEAT_MS);
+    const taskTimeoutMs = clampNumber(
+        options.taskTimeoutMs ?? env.REMOTE_HUB_TASK_TIMEOUT_MS,
+        50,
+        30 * 60 * 1000,
+        DEFAULT_AGENT_TASK_TIMEOUT_MS);
     const pairToken = safeString(
         env.REMOTE_HUB_PAIR_TOKEN || env.MINDEXEC_REMOTE_PAIR_TOKEN || crypto.randomBytes(6).toString('hex'),
         256);
 
     const devices = new Map();
+    const taskBatches = new Map();
     const sockets = new Map();
     const allSockets = new Set();
     let server = null;
@@ -194,6 +228,7 @@ export function createRemoteHub(options = {}) {
             protocol: 'tcp-jsonl',
             protocolVersion: REMOTE_PROTOCOL_VERSION,
             heartbeatMs,
+            taskTimeoutMs,
             agentPackage: '@mindexec/remote',
             agentEndpoint: `${host}:${boundPort || requestedPort}`,
             pairToken: includeSecrets ? pairToken : undefined,
@@ -221,6 +256,17 @@ export function createRemoteHub(options = {}) {
             });
     }
 
+    function listTaskBatches() {
+        return [...taskBatches.values()]
+            .map(serializeTaskBatch)
+            .filter(Boolean)
+            .sort((left, right) => String(right.requestedAt || '').localeCompare(String(left.requestedAt || '')));
+    }
+
+    function getLatestTaskBatch() {
+        return listTaskBatches()[0] || null;
+    }
+
     function emitRemoteEvent(type, device = null, extra = {}) {
         emitEvent(type, {
             ...extra,
@@ -307,6 +353,7 @@ export function createRemoteHub(options = {}) {
         }
 
         existing.lastDisconnectReason = 'replaced-by-new-session';
+        failAllPendingTasks(existing, 'replaced-by-new-session');
         writeJsonLine(existing.socket, {
             type: 'disconnect',
             reason: 'replaced-by-new-session',
@@ -427,6 +474,7 @@ export function createRemoteHub(options = {}) {
                 latestTask,
                 recentTasks: latestTask ? [latestTask] : [],
                 pendingTaskCommands: new Map(),
+                pendingTaskTimers: new Map(),
                 counters: createDeviceCounters({
                     messagesReceived: 1,
                     statusReceived: 1,
@@ -532,6 +580,7 @@ export function createRemoteHub(options = {}) {
             latestTask: null,
             recentTasks: [],
             pendingTaskCommands: new Map(),
+            pendingTaskTimers: new Map(),
             synthetic: false,
             counters: createDeviceCounters({ messagesReceived: 1 })
         };
@@ -573,6 +622,7 @@ export function createRemoteHub(options = {}) {
             device.activeLiveStream.stoppedAt = device.disconnectedAt;
             device.activeLiveStream.stopReason = reason;
         }
+        failAllPendingTasks(device, 'device-disconnected');
         logWarn('remote', `device disconnected ${device.deviceName} (${deviceId}): ${reason}`);
         emitRemoteEvent('RemoteDeviceDisconnected', device, { reason });
     }
@@ -601,6 +651,241 @@ export function createRemoteHub(options = {}) {
         return task;
     }
 
+    function trimTaskBatches() {
+        const ordered = [...taskBatches.values()]
+            .sort((left, right) => String(right.requestedAt || '').localeCompare(String(left.requestedAt || '')));
+        for (const batch of ordered.slice(RECENT_TASK_BATCH_LIMIT)) {
+            taskBatches.delete(batch.batchId);
+        }
+    }
+
+    function beginTaskBatch(deviceIds, options = {}) {
+        const targets = [...new Set((deviceIds || [])
+            .map(deviceId => safeString(deviceId, 128))
+            .filter(Boolean))]
+            .slice(0, 500);
+        const now = new Date().toISOString();
+        const instruction = safeText(options.instruction, MAX_AGENT_TASK_CHARS);
+        const batchId = safeString(options.batchId, 128) || crypto.randomUUID();
+        const title = safeString(options.title, 120)
+            || safeString(instruction.split(/\r?\n/)[0], 120)
+            || 'Remote task batch';
+        const batch = {
+            batchId,
+            title,
+            instructionPreview: safeText(instruction, 320),
+            approvalLevel: normalizeApprovalLevel(options.approvalLevel),
+            status: targets.length > 0 ? 'running' : 'failed',
+            requestedAt: now,
+            updatedAt: now,
+            total: targets.length,
+            queued: 0,
+            pending: 0,
+            completed: 0,
+            failed: targets.length > 0 ? 0 : 1,
+            timedOut: 0,
+            results: targets.map(deviceId => ({
+                deviceId,
+                ok: false,
+                status: 'targeted',
+                error: '',
+                commandId: '',
+                taskId: '',
+                approvalLevel: normalizeApprovalLevel(options.approvalLevel),
+                updatedAt: now
+            }))
+        };
+
+        taskBatches.set(batchId, batch);
+        trimTaskBatches();
+        return batch;
+    }
+
+    function getTaskBatchItem(batch, deviceId) {
+        if (!batch) {
+            return null;
+        }
+
+        const id = safeString(deviceId, 128);
+        if (!id) {
+            return null;
+        }
+
+        let item = batch.results.find(result => result.deviceId === id);
+        if (!item) {
+            item = {
+                deviceId: id,
+                ok: false,
+                status: 'targeted',
+                error: '',
+                commandId: '',
+                taskId: '',
+                approvalLevel: batch.approvalLevel,
+                updatedAt: new Date().toISOString()
+            };
+            batch.results.push(item);
+            batch.total = batch.results.length;
+        }
+
+        return item;
+    }
+
+    function recalculateTaskBatch(batch) {
+        if (!batch) {
+            return null;
+        }
+
+        const results = Array.isArray(batch.results) ? batch.results : [];
+        batch.total = results.length;
+        batch.queued = results.filter(item => item.ok === true).length;
+        batch.completed = results.filter(item => item.status === 'completed').length;
+        batch.failed = results.filter(item => item.status === 'failed' || (item.ok === false && !!item.error)).length;
+        batch.timedOut = results.filter(item => item.error === 'task-timeout').length;
+        batch.pending = results.filter(item =>
+            item.ok === true
+            && item.status !== 'completed'
+            && item.status !== 'failed').length;
+        batch.updatedAt = new Date().toISOString();
+
+        if (batch.total === 0) {
+            batch.status = 'failed';
+        } else if (batch.completed + batch.failed >= batch.total) {
+            batch.status = batch.failed > 0 ? 'completed-with-failures' : 'completed';
+        } else if (batch.queued > 0) {
+            batch.status = 'running';
+        } else {
+            batch.status = 'failed';
+        }
+
+        return batch;
+    }
+
+    function syncTaskBatchFromTask(device, task) {
+        const batchId = safeString(task?.batchId, 128);
+        if (!batchId) {
+            return null;
+        }
+
+        const batch = taskBatches.get(batchId);
+        if (!batch) {
+            return null;
+        }
+
+        const item = getTaskBatchItem(batch, device?.deviceId);
+        if (!item) {
+            return null;
+        }
+
+        item.ok = true;
+        item.status = safeString(task.status, 40) || 'queued';
+        item.error = safeString(task.error, 500);
+        item.commandId = safeString(task.commandId, 128);
+        item.taskId = safeString(task.taskId, 128);
+        item.approvalLevel = normalizeApprovalLevel(task.approvalLevel || batch.approvalLevel);
+        item.updatedAt = task.updatedAt || task.completedAt || task.sentAt || new Date().toISOString();
+        return recalculateTaskBatch(batch);
+    }
+
+    function syncTaskBatchDispatchFailure(batchId, deviceId, error, extra = {}) {
+        const batch = taskBatches.get(safeString(batchId, 128));
+        if (!batch) {
+            return null;
+        }
+
+        const item = getTaskBatchItem(batch, deviceId);
+        if (!item) {
+            return null;
+        }
+
+        item.ok = false;
+        item.status = 'failed';
+        item.error = safeString(error, 500) || 'task-dispatch-failed';
+        item.commandId = safeString(extra.commandId, 128);
+        item.taskId = safeString(extra.taskId, 128);
+        item.approvalLevel = normalizeApprovalLevel(extra.approvalLevel || batch.approvalLevel);
+        item.updatedAt = new Date().toISOString();
+        return recalculateTaskBatch(batch);
+    }
+
+    function clearTaskTimeout(device, commandId) {
+        const key = safeString(commandId, 128);
+        if (!device?.pendingTaskTimers || !key) {
+            return;
+        }
+
+        const timer = device.pendingTaskTimers.get(key);
+        if (timer) {
+            clearTimeout(timer);
+        }
+        device.pendingTaskTimers.delete(key);
+    }
+
+    function failPendingTask(device, commandId, error = 'task-timeout') {
+        const key = safeString(commandId, 128);
+        if (!device?.pendingTaskCommands || !key) {
+            return null;
+        }
+
+        const task = device.pendingTaskCommands.get(key);
+        if (!task) {
+            clearTaskTimeout(device, key);
+            return null;
+        }
+
+        const now = new Date().toISOString();
+        clearTaskTimeout(device, key);
+        task.status = 'failed';
+        task.updatedAt = now;
+        task.completedAt = now;
+        task.error = safeString(error, 500) || 'task-timeout';
+        task.resultSummary = task.error;
+        task.resultKind = task.resultKind || 'agent-task';
+        device.latestTask = task;
+        device.pendingTaskCommands.delete(key);
+        device.counters.taskResultsReceived += 1;
+        device.counters.taskResultsFailed += 1;
+        if (task.error === 'task-timeout') {
+            device.counters.taskResultsTimedOut += 1;
+        }
+        syncTaskBatchFromTask(device, task);
+        emitRemoteEvent('RemoteTaskResult', device, {
+            commandId: key,
+            taskId: task.taskId,
+            status: task.status,
+            error: task.error
+        });
+        return task;
+    }
+
+    function failAllPendingTasks(device, error = 'device-disconnected') {
+        if (!device?.pendingTaskCommands) {
+            return 0;
+        }
+
+        const commandIds = [...device.pendingTaskCommands.keys()];
+        let failed = 0;
+        for (const commandId of commandIds) {
+            if (failPendingTask(device, commandId, error)) {
+                failed += 1;
+            }
+        }
+        return failed;
+    }
+
+    function scheduleTaskTimeout(device, task) {
+        const commandId = safeString(task?.commandId, 128);
+        if (!device?.pendingTaskTimers || !commandId) {
+            return;
+        }
+
+        clearTaskTimeout(device, commandId);
+        const timer = setTimeout(() => {
+            failPendingTask(device, commandId, 'task-timeout');
+        }, taskTimeoutMs);
+        timer.unref?.();
+        device.pendingTaskTimers.set(commandId, timer);
+    }
+
     function summarizeTaskResult(result) {
         if (result && typeof result === 'object') {
             return safeText(
@@ -634,6 +919,7 @@ export function createRemoteHub(options = {}) {
         const status = error
             ? 'failed'
             : safeString(result?.status, 40) || 'completed';
+        clearTaskTimeout(device, commandId);
         task.status = status;
         task.updatedAt = now;
         task.completedAt = safeString(result?.completedAt, 80) || now;
@@ -648,6 +934,7 @@ export function createRemoteHub(options = {}) {
         if (error) {
             device.counters.taskResultsFailed += 1;
         }
+        syncTaskBatchFromTask(device, task);
 
         return task;
     }
@@ -903,6 +1190,7 @@ export function createRemoteHub(options = {}) {
 
     async function close() {
         for (const device of devices.values()) {
+            failAllPendingTasks(device, 'hub-shutdown');
             if (device.socket && !device.socket.destroyed) {
                 writeJsonLine(device.socket, { type: 'disconnect', reason: 'hub-shutdown' });
                 device.socket.destroy();
@@ -958,6 +1246,7 @@ export function createRemoteHub(options = {}) {
                 device.activeLiveStream.stoppedAt = device.disconnectedAt;
                 device.activeLiveStream.stopReason = reason;
             }
+            failAllPendingTasks(device, 'device-disconnected');
             emitRemoteEvent('RemoteDeviceDisconnected', device, { reason, synthetic: true });
             return true;
         }
@@ -1020,6 +1309,10 @@ export function createRemoteHub(options = {}) {
 
     function requestAgentTask(deviceId, options = {}) {
         const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+
         if (device?.synthetic === true && device.connected) {
             const instruction = safeText(options.instruction, MAX_AGENT_TASK_CHARS);
             if (!instruction) {
@@ -1038,6 +1331,7 @@ export function createRemoteHub(options = {}) {
                 || safeString(instruction.split(/\r?\n/)[0], 120)
                 || 'Remote task';
             const task = {
+                batchId: safeString(options.batchId, 128),
                 taskId,
                 commandId,
                 title,
@@ -1068,6 +1362,7 @@ export function createRemoteHub(options = {}) {
             device.lastSeenAt = now;
             rememberDeviceTask(device, task);
             device.pendingTaskCommands.delete(commandId);
+            syncTaskBatchFromTask(device, task);
             emitRemoteEvent('RemoteTaskQueued', device, {
                 commandId,
                 taskId,
@@ -1106,6 +1401,7 @@ export function createRemoteHub(options = {}) {
             || safeString(instruction.split(/\r?\n/)[0], 120)
             || 'Remote task';
         const task = {
+            batchId: safeString(options.batchId, 128),
             taskId,
             commandId,
             title,
@@ -1145,6 +1441,8 @@ export function createRemoteHub(options = {}) {
         device.counters.commandsSent += 1;
         device.counters.tasksQueued += 1;
         rememberDeviceTask(device, task);
+        syncTaskBatchFromTask(device, task);
+        scheduleTaskTimeout(device, task);
         emitRemoteEvent('RemoteTaskQueued', device, {
             commandId,
             taskId,
@@ -1154,6 +1452,55 @@ export function createRemoteHub(options = {}) {
         return { ok: true, commandId, taskId, approvalLevel };
     }
 
+    function requestAgentTaskBatch(deviceIds, options = {}) {
+        const targets = [...new Set((deviceIds || [])
+            .map(deviceId => safeString(deviceId, 128))
+            .filter(Boolean))]
+            .slice(0, 500);
+
+        if (targets.length === 0) {
+            return {
+                ok: false,
+                error: 'no-target-devices',
+                total: 0,
+                queued: 0,
+                approvalLevel: normalizeApprovalLevel(options.approvalLevel),
+                results: []
+            };
+        }
+
+        const batch = beginTaskBatch(targets, options);
+        const results = targets.map(deviceId => {
+            const result = requestAgentTask(deviceId, {
+                ...options,
+                batchId: batch.batchId
+            });
+
+            if (result.ok !== true) {
+                syncTaskBatchDispatchFailure(batch.batchId, deviceId, result.error, result);
+            }
+
+            return {
+                deviceId,
+                ...result
+            };
+        });
+
+        const queued = results.filter(result => result.ok === true).length;
+        const updatedBatch = taskBatches.get(batch.batchId) || batch;
+        recalculateTaskBatch(updatedBatch);
+        return {
+            ok: queued > 0,
+            batchId: batch.batchId,
+            total: targets.length,
+            queued,
+            approvalLevel: batch.approvalLevel,
+            results,
+            batch: serializeTaskBatch(updatedBatch),
+            error: queued > 0 ? undefined : 'no-task-queued'
+        };
+    }
+
     function requestThumbnail(deviceId, options = {}) {
         return sendCommand(deviceId, {
             command: 'thumbnail.capture',
@@ -1329,9 +1676,12 @@ export function createRemoteHub(options = {}) {
         close,
         getStatus,
         listDevices,
+        listTaskBatches,
+        getLatestTaskBatch,
         disconnectDevice,
         sendCommand,
         requestAgentTask,
+        requestAgentTaskBatch,
         requestThumbnail,
         startLiveStream,
         stopLiveStream,

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

@@ -412,7 +412,7 @@ function wait(ms = 0) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-function buildMonitorNode(devices, hubStatus) {
+function buildMonitorNode(devices, hubStatus, latestTaskBatch = null) {
     const connected = devices.filter(device => device.Connected).length;
     const endpoint = hubStatus.agentEndpoint || '127.0.0.1:5197';
     const pairToken = hubStatus.pairToken || 'render-smoke-token';
@@ -433,6 +433,7 @@ function buildMonitorNode(devices, hubStatus) {
             RemoteFleetConnectedDeviceCount: String(connected),
             RemoteFleetCanvasPagination: 'none',
             RemoteFleetDevicesJson: JSON.stringify(devices),
+            RemoteFleetLatestTaskBatchJson: latestTaskBatch ? JSON.stringify(latestTaskBatch) : '',
             RemoteFleetLastError: ''
         }
     };
@@ -531,6 +532,31 @@ try {
     const aiCount = devices.filter(device => device.Connected && device.AiAssistEnabled).length;
     const focusedDevice = devices.find(device => device.Connected);
     assert.ok(focusedDevice);
+    focusedDevice.LatestTaskId = 'render-smoke-timeout-task';
+    focusedDevice.LatestTaskCommandId = 'render-smoke-timeout-command';
+    focusedDevice.LatestTaskTitle = 'Timed out smoke task';
+    focusedDevice.LatestTaskInstructionPreview = 'This synthetic task timed out before the agent replied.';
+    focusedDevice.LatestTaskStatus = 'failed';
+    focusedDevice.LatestTaskApprovalLevel = 'task-only';
+    focusedDevice.LatestTaskUpdatedAt = new Date().toISOString();
+    focusedDevice.LatestTaskError = 'task-timeout';
+    focusedDevice.LatestTaskResultSummary = '';
+    const latestTaskBatch = {
+        batchId: 'render-smoke-batch',
+        title: 'Render smoke batch',
+        instructionPreview: 'Render smoke batch instruction preview.',
+        approvalLevel: 'ai-assist',
+        status: 'running',
+        requestedAt: new Date(Date.now() - 2500).toISOString(),
+        updatedAt: new Date().toISOString(),
+        total: 210,
+        queued: 210,
+        pending: 1,
+        completed: 208,
+        failed: 1,
+        timedOut: 1,
+        results: []
+    };
 
     const { manager, document } = await loadCss3DManager();
     assert.equal(typeof manager?.renderRemoteFleetMonitorForTest, 'function');
@@ -564,7 +590,7 @@ try {
     bodyView.dataset.remoteFleetFocusDeviceId = focusedDevice.DeviceId;
     document.body.appendChild(bodyView);
 
-    manager.renderRemoteFleetMonitorForTest(bodyView, buildMonitorNode(devices, hub.getStatus({ includeSecrets: true })));
+    manager.renderRemoteFleetMonitorForTest(bodyView, buildMonitorNode(devices, hub.getStatus({ includeSecrets: true }), latestTaskBatch));
 
     let cards = bodyView.querySelectorAll('article[data-device-id]');
     assert.equal(cards.length, SYNTHETIC_COUNT);
@@ -577,6 +603,12 @@ try {
     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(bodyView.textContent.includes('Task timed out waiting for the agent response.'));
+    const batchSummary = bodyView.querySelector('[data-remote-fleet-task-batch="true"]');
+    assert.ok(batchSummary);
+    assert.ok(batchSummary.textContent.includes('Render smoke batch'));
+    assert.ok(batchSummary.textContent.includes('208/210 done'));
+    assert.ok(batchSummary.textContent.includes('1 timed out'));
     assert.ok(devices.some(device => /^synthetic-response-/.test(device.LatestTaskResultResponseId)));
 
     const searchInput = bodyView.querySelector('[data-remote-fleet-search="true"]');
@@ -630,6 +662,7 @@ try {
     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('Task timed out waiting for the agent response.'));
     assert.ok(deviceBody.textContent.includes(focusedDevice.DeviceId));
 
     console.log(`RemoteFleet render smoke OK (${SYNTHETIC_COUNT} synthetic devices, ${connectedCount} connected, ${aiCount} AI-ready)`);

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

@@ -77,13 +77,20 @@ try {
         .filter(device => device.connected && device.capabilities?.taskDispatch)
         .slice(0, 200);
     assert.ok(connectedTargets.length >= 100);
-    const taskResults = connectedTargets.map(device =>
-        hub.requestAgentTask(device.deviceId, {
-            instruction: 'Synthetic scale task: report current status to the manager.',
-            title: 'Scale task'
-        }));
-    assert.equal(taskResults.every(result => result.ok === true), true);
-    assert.equal(taskResults.length, connectedTargets.length);
+    const scaleBatch = hub.requestAgentTaskBatch(connectedTargets.map(device => device.deviceId), {
+        instruction: 'Synthetic scale task: report current status to the manager.',
+        title: 'Scale task batch'
+    });
+    assert.equal(scaleBatch.ok, true);
+    assert.equal(scaleBatch.total, connectedTargets.length);
+    assert.equal(scaleBatch.queued, connectedTargets.length);
+    assert.equal(scaleBatch.results.every(result => result.ok === true), true);
+    assert.equal(scaleBatch.batch?.completed, connectedTargets.length);
+    assert.equal(scaleBatch.batch?.failed, 0);
+    assert.equal(scaleBatch.batch?.status, 'completed');
+    const latestBatch = hub.getLatestTaskBatch();
+    assert.equal(latestBatch?.batchId, scaleBatch.batchId);
+    assert.equal(latestBatch?.completed, connectedTargets.length);
 
     const aiTarget = hub.listDevices().find(device =>
         device.connected && device.capabilities?.taskDispatch && device.capabilities?.aiAssist);

package/scripts/remote-hub-smoke.mjs

@@ -30,7 +30,8 @@ const hub = createRemoteHub({
         MINDEXEC_REMOTE_HUB: '1',
         REMOTE_HUB_HOST: '127.0.0.1',
         REMOTE_HUB_PORT: '0',
-        REMOTE_HUB_PAIR_TOKEN: 'smoke-token'
+        REMOTE_HUB_PAIR_TOKEN: 'smoke-token',
+        REMOTE_HUB_TASK_TIMEOUT_MS: '120'
     }
 });
 
@@ -230,6 +231,63 @@ try {
     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);
+
     socket.destroy();
     await waitFor(() => hub.listDevices()[0]?.connected === false);
     console.log('RemoteHub smoke OK');

package/server.js

@@ -6969,6 +6969,8 @@ app.get('/api/remote/devices', (req, res) => {
         total: devices.length,
         pagination: 'none',
         canvasDeviceListMode: 'all-devices',
+        latestTaskBatch: remoteHub.getLatestTaskBatch(),
+        recentTaskBatches: remoteHub.listTaskBatches(),
         devices
     });
 });
@@ -7040,23 +7042,20 @@ app.post('/api/remote/tasks', (req, res) => {
         ? requestedDeviceIds
         : (allConnected ? devices.filter(device => device.connected).map(device => device.deviceId) : []);
     const uniqueTargetIds = [...new Set(targetIds)].slice(0, 500);
-    const results = uniqueTargetIds.map(deviceId => ({
-        deviceId,
-        ...remoteHub.requestAgentTask(deviceId, {
-            instruction: req.body?.instruction,
-            title: req.body?.title,
-            approvalLevel: req.body?.approvalLevel,
-            model: req.body?.model
-        })
-    }));
-    const queued = results.filter(result => result.ok === true).length;
+    const result = remoteHub.requestAgentTaskBatch(uniqueTargetIds, {
+        instruction: req.body?.instruction,
+        title: req.body?.title,
+        approvalLevel: req.body?.approvalLevel,
+        model: req.body?.model,
+        batchId: req.body?.batchId
+    });
     res.json({
-        ok: queued > 0,
+        ...result,
+        ok: result.ok === true,
         total: uniqueTargetIds.length,
-        queued,
+        queued: result.queued || 0,
         approvalLevel: req.body?.approvalLevel === 'ai-assist' ? 'ai-assist' : 'task-only',
-        results,
-        error: queued > 0 ? undefined : (uniqueTargetIds.length === 0 ? 'no-target-devices' : 'no-task-queued')
+        error: result.ok === true ? undefined : (uniqueTargetIds.length === 0 ? 'no-target-devices' : (result.error || 'no-task-queued'))
     });
 });
 

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

@@ -11975,6 +11975,22 @@
         }
     }
 
+    function parseRemoteFleetLatestTaskBatch(nodeModel) {
+        const raw = getRemoteFleetMetadataValue(nodeModel, 'RemoteFleetLatestTaskBatchJson', '');
+        if (!raw.trim()) {
+            return null;
+        }
+
+        try {
+            const parsed = JSON.parse(raw);
+            return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+                ? parsed
+                : null;
+        } catch {
+            return null;
+        }
+    }
+
     function parseRemoteFleetPinnedDevice(nodeModel) {
         const raw = getRemoteFleetMetadataValue(nodeModel, 'RemoteFleetPinnedDeviceJson', '{}');
         if (!raw.trim()) {
@@ -12204,6 +12220,22 @@
         return getRemoteFleetDeviceField(device, 'thumbnailEnabled', 'ThumbnailEnabled', false) === true;
     }
 
+    function formatRemoteFleetTaskError(error) {
+        const value = String(error || '').trim();
+        switch (value) {
+            case 'task-timeout':
+                return 'Task timed out waiting for the agent response.';
+            case 'device-disconnected':
+                return 'Agent disconnected before returning a task result.';
+            case 'replaced-by-new-session':
+                return 'Agent reconnected before returning a task result.';
+            case 'hub-shutdown':
+                return 'RemoteHub shut down before the task completed.';
+            default:
+                return value;
+        }
+    }
+
     function getRemoteFleetGroupInfo(device, groupMode) {
         const mode = String(groupMode || 'none');
         const connected = isRemoteFleetDeviceConnected(device);
@@ -12601,7 +12633,7 @@
                 : 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';
+            taskSummary.textContent = formatRemoteFleetTaskError(latestTaskError) || latestTaskResult || latestTaskTitle || 'Task queued';
             taskSummary.title = taskSummary.textContent;
             taskSummary.style.cssText = 'color:#334155;font-size:11px;font-weight:750;line-height:1.3;overflow:hidden;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;letter-spacing:0;';
             taskBox.appendChild(taskLine);
@@ -12852,6 +12884,7 @@
         const aiAssistState = bodyView.dataset.remoteFleetAiAssist === 'true';
         const autoMonitorState = bodyView.dataset.remoteFleetAutoMonitor !== 'false';
         const focusState = bodyView.dataset.remoteFleetFocusDeviceId || '';
+        const latestTaskBatch = parseRemoteFleetLatestTaskBatch(nodeModel);
         const sortedDevices = [...parseRemoteFleetDevices(nodeModel)]
             .sort((left, right) => compareRemoteFleetDevices(left, right, sortState));
         const devices = groupState === 'none'
@@ -13159,6 +13192,64 @@
         `;
         bodyView.appendChild(taskFeedback);
 
+        if (latestTaskBatch) {
+            const batchTotal = Number(latestTaskBatch.total ?? latestTaskBatch.Total ?? 0);
+            const batchQueued = Number(latestTaskBatch.queued ?? latestTaskBatch.Queued ?? 0);
+            const batchPending = Number(latestTaskBatch.pending ?? latestTaskBatch.Pending ?? 0);
+            const batchCompleted = Number(latestTaskBatch.completed ?? latestTaskBatch.Completed ?? 0);
+            const batchFailed = Number(latestTaskBatch.failed ?? latestTaskBatch.Failed ?? 0);
+            const batchTimedOut = Number(latestTaskBatch.timedOut ?? latestTaskBatch.TimedOut ?? 0);
+            const batchStatus = String(latestTaskBatch.status ?? latestTaskBatch.Status ?? '').trim();
+            const batchTitle = String(latestTaskBatch.title ?? latestTaskBatch.Title ?? 'Remote task batch').trim();
+            const batchUpdatedAt = String(latestTaskBatch.updatedAt ?? latestTaskBatch.UpdatedAt ?? latestTaskBatch.requestedAt ?? latestTaskBatch.RequestedAt ?? '').trim();
+            const doneCount = Math.max(0, batchCompleted + batchFailed);
+            const progress = batchTotal > 0 ? Math.max(0, Math.min(100, Math.round(doneCount * 100 / batchTotal))) : 0;
+            const batchTone = batchFailed > 0
+                ? 'error'
+                : batchPending > 0
+                    ? 'pending'
+                    : 'done';
+            const batchBox = document.createElement('div');
+            batchBox.dataset.remoteFleetTaskBatch = 'true';
+            batchBox.style.cssText = `
+                flex: 0 0 auto;
+                display: grid;
+                grid-template-columns: minmax(0, 1fr) auto;
+                gap: 8px 12px;
+                align-items: center;
+                padding: 8px 10px;
+                border-radius: 8px;
+                background: ${batchTone === 'error' ? 'rgba(248, 113, 113, 0.11)' : batchTone === 'done' ? 'rgba(16, 185, 129, 0.10)' : 'rgba(37, 99, 235, 0.08)'};
+                border: 1px solid ${batchTone === 'error' ? 'rgba(248, 113, 113, 0.24)' : batchTone === 'done' ? 'rgba(16, 185, 129, 0.20)' : 'rgba(37, 99, 235, 0.16)'};
+                min-width: 0;
+            `;
+            const batchMain = document.createElement('div');
+            batchMain.style.cssText = 'min-width:0;display:flex;flex-direction:column;gap:5px;';
+            const batchLabel = document.createElement('div');
+            batchLabel.textContent = `${batchTitle} - ${batchStatus || 'running'}${batchUpdatedAt ? ` - ${formatRemoteFleetAge(batchUpdatedAt)}` : ''}`;
+            batchLabel.title = batchLabel.textContent;
+            batchLabel.style.cssText = `color:${batchTone === 'error' ? '#991b1b' : batchTone === 'done' ? '#047857' : '#1d4ed8'};font-size:11px;font-weight:950;line-height:1.2;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;letter-spacing:0;`;
+            const progressTrack = document.createElement('div');
+            progressTrack.style.cssText = 'position:relative;height:7px;border-radius:999px;background:rgba(148,163,184,0.22);overflow:hidden;';
+            const progressBar = document.createElement('div');
+            progressBar.style.cssText = `
+                width: ${progress}%;
+                height: 100%;
+                border-radius: inherit;
+                background: ${batchTone === 'error' ? '#ef4444' : batchTone === 'done' ? '#10b981' : '#2563eb'};
+            `;
+            progressTrack.appendChild(progressBar);
+            batchMain.appendChild(batchLabel);
+            batchMain.appendChild(progressTrack);
+            const batchStats = document.createElement('div');
+            batchStats.textContent = `${batchCompleted}/${batchTotal || batchQueued || 0} done - ${batchPending} pending - ${batchFailed} failed${batchTimedOut > 0 ? ` - ${batchTimedOut} timed out` : ''}`;
+            batchStats.title = batchStats.textContent;
+            batchStats.style.cssText = 'color:#334155;font-size:10px;font-weight:900;line-height:1.25;white-space:nowrap;letter-spacing:0;';
+            batchBox.appendChild(batchMain);
+            batchBox.appendChild(batchStats);
+            bodyView.appendChild(batchBox);
+        }
+
         if (focusedDevice) {
             const focusedId = getRemoteFleetDeviceId(focusedDevice);
             const focusedName = getRemoteFleetDeviceName(focusedDevice);
@@ -13641,7 +13732,7 @@
                         letter-spacing: 0;
                     `;
                     const taskSummary = document.createElement('div');
-                    taskSummary.textContent = latestTaskError || latestTaskResult || latestTaskTitle || 'Task queued';
+                    taskSummary.textContent = formatRemoteFleetTaskError(latestTaskError) || latestTaskResult || latestTaskTitle || 'Task queued';
                     taskSummary.title = taskSummary.textContent;
                     taskSummary.style.cssText = `
                         color: #334155;

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-SDDoFz4/uzWopUhjgpkiIgiLuIxFbjw0fze0ljEluiQ=",
+    "hash": "sha256-x+zuHEgludyG90VHm7vAvh24gxrcXgpLsHEMSmn3EZA=",
     "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.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.gc38fmee62.dll": "MindExecution.Plugins.Concept.dll",
-      "MindExecution.Plugins.Directory.hr2p0grenr.dll": "MindExecution.Plugins.Directory.dll",
-      "MindExecution.Plugins.PlanMaster.ivqd47y3cx.dll": "MindExecution.Plugins.PlanMaster.dll",
-      "MindExecution.Plugins.YouTube.tpgm4p80hh.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.2r4r7zx1ek.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.stbecd1tk9.dll": "MindExecution.Web.dll",
+      "MindExecution.Core.ckgjbdvvxl.dll": "MindExecution.Core.dll",
+      "MindExecution.Kernel.lm7kgq8l8h.dll": "MindExecution.Kernel.dll",
+      "MindExecution.Plugins.Admin.k085kt3dls.dll": "MindExecution.Plugins.Admin.dll",
+      "MindExecution.Plugins.Business.dsz9uwkxih.dll": "MindExecution.Plugins.Business.dll",
+      "MindExecution.Plugins.Concept.6gcazss69r.dll": "MindExecution.Plugins.Concept.dll",
+      "MindExecution.Plugins.Directory.ufbriq6js4.dll": "MindExecution.Plugins.Directory.dll",
+      "MindExecution.Plugins.PlanMaster.zqc0kv9n5d.dll": "MindExecution.Plugins.PlanMaster.dll",
+      "MindExecution.Plugins.YouTube.5ojg8vbf9w.dll": "MindExecution.Plugins.YouTube.dll",
+      "MindExecution.Shared.ahf7j9dymw.dll": "MindExecution.Shared.dll",
+      "MindExecution.Web.6i9vy7xy1k.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.q469sducjw.dll": "sha256-tqgvXepOZPfdkyxH1BK3KlhL8azJjoV+iV/BismieCc=",
-      "MindExecution.Kernel.lqglgq2jmo.dll": "sha256-AyAPsZpAwsH/HeC6cWVzRH50hBjGAoamzGup6clWJTg=",
-      "MindExecution.Plugins.Concept.gc38fmee62.dll": "sha256-EFZnHpuHNJzdkWPTkGXV7EYsZIkpMMOAHf6R5FBGzQ0=",
-      "MindExecution.Plugins.PlanMaster.ivqd47y3cx.dll": "sha256-slYqPeIeQ3yugnSA4ABLJ1eGGd7opYVqd11waq+hJBo=",
-      "MindExecution.Shared.2r4r7zx1ek.dll": "sha256-znMYyuG18GNFULfWrkwczymEkg1ZtSPHpHXKkw13h2A=",
-      "MindExecution.Web.stbecd1tk9.dll": "sha256-oJwTIFv6bY3dnlzZQafAf01epgSK3gOAbo2XK7nLaQA="
+      "MindExecution.Core.ckgjbdvvxl.dll": "sha256-ZDas50sgMQGCNt0UC1ZErP+uv7PQ7z/skK7zCwnmU2I=",
+      "MindExecution.Kernel.lm7kgq8l8h.dll": "sha256-ndscepu8d8g/nrJmBP8VrkIOTIkSA57t5shOq/rp/ys=",
+      "MindExecution.Plugins.Concept.6gcazss69r.dll": "sha256-hpCyKxiQxk50zHE8iOWtoIiBapBG83wfaos3jZzeaYg=",
+      "MindExecution.Plugins.PlanMaster.zqc0kv9n5d.dll": "sha256-iwATrRDt3Wwr/DKLxUl7GzqwKdhMLZNBKYVJPAkrhdM=",
+      "MindExecution.Shared.ahf7j9dymw.dll": "sha256-HlFaI9iZybI0VDe6KpsgRqLb3GTfUVXoU3KMlx0gQ0o=",
+      "MindExecution.Web.6i9vy7xy1k.dll": "sha256-IlDxFyeBhZWgici5UD0RtmqRNwynyD6n9Q0IJ8f4eBE="
     },
     "lazyAssembly": {
-      "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.tpgm4p80hh.dll": "sha256-3/nB2+iWQdfNdzktROztp/oVkSJbxu64mmWRShW2QMo="
+      "MindExecution.Plugins.Admin.k085kt3dls.dll": "sha256-LLDLGzE3yaP+rL+8CMZGWBmGQZBfrRWgUMijX/fxTxw=",
+      "MindExecution.Plugins.Business.dsz9uwkxih.dll": "sha256-bfvFu7Pq58deN7TnwfhsUZdvWhS4RpA0LdO77UsBnY8=",
+      "MindExecution.Plugins.Directory.ufbriq6js4.dll": "sha256-qoxaegrVr9oaXJgQqU7t7CrCf0EYgsd22BcWXg/+91I=",
+      "MindExecution.Plugins.YouTube.5ojg8vbf9w.dll": "sha256-a+S4Xha/L7um0foEwb8E0p8VqEw21M6ETzjrEUpIYTk="
     }
   },
   "cacheBootResources": true,

package/wwwroot/index.html

@@ -558,7 +558,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-            const scriptVersion = '20260612-remote-dispatch-feedback-v474';
+            const scriptVersion = '20260612-remote-task-batch-v476';
             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":  "0KR50DAc",
+    "version":  "wUCVSTgn",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-E87osNoVqhikMqj3XaJ+fZpNqyY0377QlQIjHfzZPhc=",
+                       "hash":  "sha256-MaP05yuNb/XsfihViUh/bL9svf11oMZGMZiAWnpm/Gk=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {
@@ -410,44 +410,44 @@
                        "url":  "_framework/MimeMapping.og9ys58ylm.dll"
                    },
                    {
-                       "hash":  "sha256-tqgvXepOZPfdkyxH1BK3KlhL8azJjoV+iV/BismieCc=",
-                       "url":  "_framework/MindExecution.Core.q469sducjw.dll"
+                       "hash":  "sha256-ZDas50sgMQGCNt0UC1ZErP+uv7PQ7z/skK7zCwnmU2I=",
+                       "url":  "_framework/MindExecution.Core.ckgjbdvvxl.dll"
                    },
                    {
-                       "hash":  "sha256-AyAPsZpAwsH/HeC6cWVzRH50hBjGAoamzGup6clWJTg=",
-                       "url":  "_framework/MindExecution.Kernel.lqglgq2jmo.dll"
+                       "hash":  "sha256-ndscepu8d8g/nrJmBP8VrkIOTIkSA57t5shOq/rp/ys=",
+                       "url":  "_framework/MindExecution.Kernel.lm7kgq8l8h.dll"
                    },
                    {
-                       "hash":  "sha256-ctRNgHtUfPq0pCvAeG0DCzZPBRTgLtQC2c4pjGFM+Go=",
-                       "url":  "_framework/MindExecution.Plugins.Admin.2jqptn6ylw.dll"
+                       "hash":  "sha256-LLDLGzE3yaP+rL+8CMZGWBmGQZBfrRWgUMijX/fxTxw=",
+                       "url":  "_framework/MindExecution.Plugins.Admin.k085kt3dls.dll"
                    },
                    {
-                       "hash":  "sha256-ZL74Jut/WgaNdDBWZzhC6ECsjBdm+0cB1P5fx4ACugM=",
-                       "url":  "_framework/MindExecution.Plugins.Business.8hzwity3fl.dll"
+                       "hash":  "sha256-bfvFu7Pq58deN7TnwfhsUZdvWhS4RpA0LdO77UsBnY8=",
+                       "url":  "_framework/MindExecution.Plugins.Business.dsz9uwkxih.dll"
                    },
                    {
-                       "hash":  "sha256-EFZnHpuHNJzdkWPTkGXV7EYsZIkpMMOAHf6R5FBGzQ0=",
-                       "url":  "_framework/MindExecution.Plugins.Concept.gc38fmee62.dll"
+                       "hash":  "sha256-hpCyKxiQxk50zHE8iOWtoIiBapBG83wfaos3jZzeaYg=",
+                       "url":  "_framework/MindExecution.Plugins.Concept.6gcazss69r.dll"
                    },
                    {
-                       "hash":  "sha256-PUrdpFqGptJ5kxYaarWNwB2NmZ1TphHnFHlnyQL48DI=",
-                       "url":  "_framework/MindExecution.Plugins.Directory.hr2p0grenr.dll"
+                       "hash":  "sha256-qoxaegrVr9oaXJgQqU7t7CrCf0EYgsd22BcWXg/+91I=",
+                       "url":  "_framework/MindExecution.Plugins.Directory.ufbriq6js4.dll"
                    },
                    {
-                       "hash":  "sha256-slYqPeIeQ3yugnSA4ABLJ1eGGd7opYVqd11waq+hJBo=",
-                       "url":  "_framework/MindExecution.Plugins.PlanMaster.ivqd47y3cx.dll"
+                       "hash":  "sha256-iwATrRDt3Wwr/DKLxUl7GzqwKdhMLZNBKYVJPAkrhdM=",
+                       "url":  "_framework/MindExecution.Plugins.PlanMaster.zqc0kv9n5d.dll"
                    },
                    {
-                       "hash":  "sha256-3/nB2+iWQdfNdzktROztp/oVkSJbxu64mmWRShW2QMo=",
-                       "url":  "_framework/MindExecution.Plugins.YouTube.tpgm4p80hh.dll"
+                       "hash":  "sha256-a+S4Xha/L7um0foEwb8E0p8VqEw21M6ETzjrEUpIYTk=",
+                       "url":  "_framework/MindExecution.Plugins.YouTube.5ojg8vbf9w.dll"
                    },
                    {
-                       "hash":  "sha256-znMYyuG18GNFULfWrkwczymEkg1ZtSPHpHXKkw13h2A=",
-                       "url":  "_framework/MindExecution.Shared.2r4r7zx1ek.dll"
+                       "hash":  "sha256-HlFaI9iZybI0VDe6KpsgRqLb3GTfUVXoU3KMlx0gQ0o=",
+                       "url":  "_framework/MindExecution.Shared.ahf7j9dymw.dll"
                    },
                    {
-                       "hash":  "sha256-oJwTIFv6bY3dnlzZQafAf01epgSK3gOAbo2XK7nLaQA=",
-                       "url":  "_framework/MindExecution.Web.stbecd1tk9.dll"
+                       "hash":  "sha256-IlDxFyeBhZWgici5UD0RtmqRNwynyD6n9Q0IJ8f4eBE=",
+                       "url":  "_framework/MindExecution.Web.6i9vy7xy1k.dll"
                    },
                    {
                        "hash":  "sha256-IsZJ91/OW+fHzNqIgEc7Y072ns8z9dGritiSyvR9Wgc=",
@@ -770,7 +770,7 @@
                        "url":  "_framework/Websocket.Client.vapounvmnl.dll"
                    },
                    {
-                       "hash":  "sha256-y6Kp7jPu3NDwDsVpfK/DXAaN7ZSNGvq3LDKrIhURBio=",
+                       "hash":  "sha256-fGH3vBiA9K4LY1+siDEi6C1uyYfJgDAywmyOxn+xGY8=",
                        "url":  "_framework/blazor.boot.json"
                    },
                    {
@@ -834,7 +834,7 @@
                        "url":  "image-manifest.json"
                    },
                    {
-                       "hash":  "sha256-kK0fdbwqbRSdpNq5r4LyomSjE6FQ2lhjrXkQVBWacL8=",
+                       "hash":  "sha256-2i4bXinqysl6fMxtRowvbfVpJyKIfPSm3wdbCBcX5i4=",
                        "url":  "index.html"
                    },
                    {

package/wwwroot/service-worker.js

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