the-android-mcp 3.2.0 → 3.4.0

package/dist/web-ui.js

@@ -19,9 +19,11 @@ exports.DEFAULT_WEB_UI_HOST = '127.0.0.1';
 exports.DEFAULT_WEB_UI_PORT = 50000;
 const UPDATE_HINT = 'npm install -g the-android-mcp@latest';
 const MAX_BODY_BYTES = 1024 * 1024;
-const MAX_EVENTS = 500;
-const WORKFLOW_DIR = path_1.default.join(os_1.default.homedir(), '.the-android-mcp');
-const WORKFLOW_FILE = path_1.default.join(WORKFLOW_DIR, 'web-ui-workflows.json');
+const MAX_EVENTS = 600;
+const MAX_JOBS = 300;
+const APP_STATE_DIR = path_1.default.join(os_1.default.homedir(), '.the-android-mcp');
+const WORKFLOW_FILE = path_1.default.join(APP_STATE_DIR, 'web-ui-workflows.json');
+const SESSION_EVENTS_FILE = path_1.default.join(APP_STATE_DIR, 'web-ui-session-events.ndjson');
 const SNAPSHOT_KINDS = [
     'radio',
     'display',
@@ -31,17 +33,41 @@ const SNAPSHOT_KINDS = [
 ];
 const serverStartedAt = Date.now();
 let eventSeq = 1;
+let jobSeq = 1;
 const eventHistory = [];
 const sseClients = new Set();
 const metrics = {};
 const snapshotCache = {};
 let workflows = loadWorkflows();
+const jobs = [];
+const lanes = {};
 function nowIso() {
     return new Date().toISOString();
 }
+function ensureAppStateDir() {
+    if (!fs_1.default.existsSync(APP_STATE_DIR)) {
+        fs_1.default.mkdirSync(APP_STATE_DIR, { recursive: true });
+    }
+}
+function appendSessionEvent(event) {
+    try {
+        ensureAppStateDir();
+        fs_1.default.appendFileSync(SESSION_EVENTS_FILE, `${JSON.stringify(event)}\n`, 'utf8');
+    }
+    catch {
+        // ignore event persistence failures
+    }
+}
 function isSnapshotKind(value) {
     return SNAPSHOT_KINDS.includes(value);
 }
+function isJobType(value) {
+    return (value === 'open_url' ||
+        value === 'snapshot_suite' ||
+        value === 'stress_run' ||
+        value === 'workflow_run' ||
+        value === 'device_profile');
+}
 function clampInt(value, fallback, min, max) {
     if (typeof value !== 'number' || !Number.isFinite(value)) {
         return fallback;
@@ -49,41 +75,6 @@ function clampInt(value, fallback, min, max) {
     const parsed = Math.trunc(value);
     return Math.max(min, Math.min(max, parsed));
 }
-function trackMetric(name, durationMs, ok, errorMessage) {
-    const entry = metrics[name] ?? {
-        name,
-        count: 0,
-        success: 0,
-        errors: 0,
-        totalDurationMs: 0,
-        lastDurationMs: 0,
-    };
-    entry.count += 1;
-    entry.totalDurationMs += durationMs;
-    entry.lastDurationMs = durationMs;
-    entry.lastAt = nowIso();
-    if (ok) {
-        entry.success += 1;
-    }
-    else {
-        entry.errors += 1;
-        entry.lastError = errorMessage;
-    }
-    metrics[name] = entry;
-}
-async function withMetric(name, fn) {
-    const startedAt = Date.now();
-    try {
-        const result = await fn();
-        trackMetric(name, Date.now() - startedAt, true);
-        return result;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        trackMetric(name, Date.now() - startedAt, false, message);
-        throw error;
-    }
-}
 function pushEvent(type, message, data) {
     const event = {
         id: eventSeq++,
@@ -96,6 +87,7 @@ function pushEvent(type, message, data) {
     if (eventHistory.length > MAX_EVENTS) {
         eventHistory.splice(0, eventHistory.length - MAX_EVENTS);
     }
+    appendSessionEvent(event);
     broadcastEvent(event);
     return event;
 }
@@ -126,6 +118,41 @@ function sendHtml(response, html) {
     response.setHeader('Content-Type', 'text/html; charset=utf-8');
     response.end(html);
 }
+function trackMetric(name, durationMs, ok, errorMessage) {
+    const entry = metrics[name] ?? {
+        name,
+        count: 0,
+        success: 0,
+        errors: 0,
+        totalDurationMs: 0,
+        lastDurationMs: 0,
+    };
+    entry.count += 1;
+    entry.totalDurationMs += durationMs;
+    entry.lastDurationMs = durationMs;
+    entry.lastAt = nowIso();
+    if (ok) {
+        entry.success += 1;
+    }
+    else {
+        entry.errors += 1;
+        entry.lastError = errorMessage;
+    }
+    metrics[name] = entry;
+}
+async function withMetric(name, fn) {
+    const startedAt = Date.now();
+    try {
+        const result = await fn();
+        trackMetric(name, Date.now() - startedAt, true);
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        trackMetric(name, Date.now() - startedAt, false, message);
+        throw error;
+    }
+}
 function compactStringSummary(value) {
     if (typeof value !== 'string') {
         return { type: typeof value };
@@ -133,7 +160,7 @@ function compactStringSummary(value) {
     return {
         length: value.length,
         lines: value.split('\n').length,
-        preview: value.slice(0, 200),
+        preview: value.slice(0, 220),
     };
 }
 function summarizeObjectShape(input) {
@@ -157,7 +184,7 @@ function summarizeObjectShape(input) {
             result[key] = { type: 'array', length: value.length };
             continue;
         }
-        if (typeof value === 'object' && value !== null) {
+        if (typeof value === 'object') {
             result[key] = { type: 'object', keys: Object.keys(value).length };
             continue;
         }
@@ -165,27 +192,49 @@ function summarizeObjectShape(input) {
     }
     return result;
 }
+function defaultWorkflows() {
+    const createdAt = nowIso();
+    return {
+        'smoke-web-flow': {
+            name: 'smoke-web-flow',
+            description: 'Open URLs and collect lightweight snapshots.',
+            updatedAt: createdAt,
+            steps: [
+                { type: 'open_url', url: 'https://www.wikipedia.org', waitForReadyMs: 900 },
+                { type: 'snapshot', snapshot: 'radio' },
+                { type: 'open_url', url: 'https://news.ycombinator.com', waitForReadyMs: 900 },
+                { type: 'snapshot', snapshot: 'display' },
+            ],
+        },
+        'diagnostic-suite': {
+            name: 'diagnostic-suite',
+            description: 'Run complete v3 snapshot suite.',
+            updatedAt: createdAt,
+            steps: [{ type: 'snapshot_suite', packageName: 'com.android.chrome' }],
+        },
+    };
+}
 function normalizeWorkflowStep(value) {
     if (!value || typeof value !== 'object') {
-        throw new Error('Invalid workflow step (must be object)');
+        throw new Error('Workflow step must be an object');
     }
     const step = value;
     const type = step.type;
     if (type !== 'open_url' && type !== 'snapshot' && type !== 'snapshot_suite' && type !== 'sleep_ms') {
-        throw new Error('Invalid workflow step type');
+        throw new Error('Unsupported workflow step type');
     }
     const normalized = { type };
     if (type === 'open_url') {
         if (typeof step.url !== 'string' || !/^https?:\/\//i.test(step.url)) {
-            throw new Error('Workflow open_url step requires valid url');
+            throw new Error('open_url step requires valid url');
         }
         normalized.url = step.url;
-        normalized.waitForReadyMs = clampInt(step.waitForReadyMs, 1200, 200, 10000);
+        normalized.waitForReadyMs = clampInt(step.waitForReadyMs, 1000, 200, 10000);
         return normalized;
     }
     if (type === 'snapshot') {
         if (typeof step.snapshot !== 'string' || !isSnapshotKind(step.snapshot)) {
-            throw new Error('Workflow snapshot step requires valid snapshot kind');
+            throw new Error('snapshot step requires valid snapshot kind');
         }
         normalized.snapshot = step.snapshot;
         if (typeof step.packageName === 'string') {
@@ -200,42 +249,12 @@ function normalizeWorkflowStep(value) {
         }
         return normalized;
     }
-    normalized.durationMs = clampInt(step.durationMs, 500, 50, 20000);
+    normalized.durationMs = clampInt(step.durationMs, 500, 50, 30000);
     return normalized;
 }
-function ensureWorkflowStore() {
-    if (!fs_1.default.existsSync(WORKFLOW_DIR)) {
-        fs_1.default.mkdirSync(WORKFLOW_DIR, { recursive: true });
-    }
-}
-function defaultWorkflows() {
-    const createdAt = nowIso();
-    const smoke = {
-        name: 'smoke-web-flow',
-        description: 'Open three URLs and capture radio/display quickly.',
-        updatedAt: createdAt,
-        steps: [
-            { type: 'open_url', url: 'https://www.wikipedia.org', waitForReadyMs: 1000 },
-            { type: 'snapshot', snapshot: 'radio' },
-            { type: 'open_url', url: 'https://news.ycombinator.com', waitForReadyMs: 1000 },
-            { type: 'snapshot', snapshot: 'display' },
-            { type: 'open_url', url: 'https://developer.android.com', waitForReadyMs: 1000 },
-        ],
-    };
-    const diagnostic = {
-        name: 'diagnostic-suite',
-        description: 'Capture full v3 snapshot suite for current device.',
-        updatedAt: createdAt,
-        steps: [{ type: 'snapshot_suite', packageName: 'com.android.chrome' }],
-    };
-    return {
-        [smoke.name]: smoke,
-        [diagnostic.name]: diagnostic,
-    };
-}
 function loadWorkflows() {
     try {
-        ensureWorkflowStore();
+        ensureAppStateDir();
         if (!fs_1.default.existsSync(WORKFLOW_FILE)) {
             const defaults = defaultWorkflows();
             fs_1.default.writeFileSync(WORKFLOW_FILE, JSON.stringify(defaults, null, 2), 'utf8');
@@ -243,7 +262,7 @@ function loadWorkflows() {
         }
         const raw = fs_1.default.readFileSync(WORKFLOW_FILE, 'utf8');
         const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== 'object') {
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
             return defaultWorkflows();
         }
         const result = {};
@@ -255,8 +274,19 @@ function loadWorkflows() {
             if (typeof item.name !== 'string' || item.name.trim().length === 0) {
                 continue;
             }
-            const stepsValue = Array.isArray(item.steps) ? item.steps : [];
-            const steps = stepsValue.map(step => normalizeWorkflowStep(step));
+            const stepsRaw = Array.isArray(item.steps) ? item.steps : [];
+            const steps = [];
+            for (const stepRaw of stepsRaw) {
+                try {
+                    steps.push(normalizeWorkflowStep(stepRaw));
+                }
+                catch {
+                    // skip invalid step
+                }
+            }
+            if (steps.length === 0) {
+                continue;
+            }
             result[name] = {
                 name,
                 description: typeof item.description === 'string' ? item.description : undefined,
@@ -264,29 +294,26 @@ function loadWorkflows() {
                 steps,
             };
         }
-        if (Object.keys(result).length === 0) {
-            return defaultWorkflows();
-        }
-        return result;
+        return Object.keys(result).length > 0 ? result : defaultWorkflows();
     }
     catch {
         return defaultWorkflows();
     }
 }
 function saveWorkflows() {
-    ensureWorkflowStore();
+    ensureAppStateDir();
     fs_1.default.writeFileSync(WORKFLOW_FILE, JSON.stringify(workflows, null, 2), 'utf8');
 }
 function workflowsList() {
     return Object.values(workflows).sort((a, b) => a.name.localeCompare(b.name));
 }
-async function sleepMs(durationMs) {
-    await new Promise(resolve => setTimeout(resolve, durationMs));
-}
 function extractDeviceId(body) {
     const value = body.deviceId;
     return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
 }
+async function sleepMs(durationMs) {
+    await new Promise(resolve => setTimeout(resolve, durationMs));
+}
 function captureSnapshot(kind, options) {
     const includeRaw = options.includeRaw === true;
     if (kind === 'radio') {
@@ -361,7 +388,7 @@ function captureSnapshot(kind, options) {
 }
 function diffSnapshot(prev, next) {
     if (!prev || typeof prev !== 'object' || !next || typeof next !== 'object') {
-        return { changedCount: 0, changed: [], note: 'No comparable snapshots' };
+        return { changedCount: 0, changed: [], note: 'No comparable snapshots available' };
     }
     const a = prev;
     const b = next;
@@ -370,23 +397,16 @@ function diffSnapshot(prev, next) {
     for (const key of keys) {
         const oldValue = a[key];
         const newValue = b[key];
-        if (typeof oldValue === 'string' || typeof newValue === 'string') {
-            const oldText = typeof oldValue === 'string' ? oldValue : JSON.stringify(oldValue);
-            const newText = typeof newValue === 'string' ? newValue : JSON.stringify(newValue);
-            if (oldText !== newText) {
-                changed.push({
-                    key,
-                    type: 'text',
-                    beforeLength: oldText.length,
-                    afterLength: newText.length,
-                });
-            }
-            continue;
-        }
         const oldJson = JSON.stringify(oldValue);
         const newJson = JSON.stringify(newValue);
         if (oldJson !== newJson) {
-            changed.push({ key, type: 'value', before: oldValue, after: newValue });
+            changed.push({
+                key,
+                beforeType: typeof oldValue,
+                afterType: typeof newValue,
+                beforeSize: oldJson ? oldJson.length : 0,
+                afterSize: newJson ? newJson.length : 0,
+            });
         }
     }
     return {
@@ -413,6 +433,114 @@ function getSnapshotSuite(deviceId, packageName) {
         },
     };
 }
+function computeHealthScore(profile) {
+    let score = 100;
+    const radio = profile.radio;
+    const location = profile.location;
+    const packages = profile.packages;
+    if (radio && radio.airplaneMode === '1') {
+        score -= 25;
+    }
+    if (location && location.mode === '0') {
+        score -= 20;
+    }
+    if (packages && typeof packages.disabled === 'number' && packages.disabled > 20) {
+        score -= 10;
+    }
+    return Math.max(0, Math.min(100, score));
+}
+function buildDeviceProfile(deviceId, packageName) {
+    const startedAt = Date.now();
+    const radio = (0, adb_js_1.captureAndroidRadioSnapshot)({
+        deviceId,
+        includeWifiDump: false,
+        includeTelephonyDump: false,
+        includeBluetoothDump: false,
+        includeIpState: true,
+        includeConnectivityDump: false,
+    });
+    const display = (0, adb_js_1.captureAndroidDisplaySnapshot)({
+        deviceId,
+        includeDisplayDump: false,
+        includeWindowDump: false,
+        includeSurfaceFlinger: false,
+    });
+    const location = (0, adb_js_1.captureAndroidLocationSnapshot)({
+        deviceId,
+        packageName,
+        includeLocationDump: false,
+        includeLocationAppOps: true,
+    });
+    const power = (0, adb_js_1.captureAndroidPowerIdleSnapshot)({
+        deviceId,
+        includePowerDump: false,
+        includeDeviceIdle: false,
+        includeBatteryStats: false,
+        includeThermal: false,
+    });
+    const packages = (0, adb_js_1.captureAndroidPackageInventorySnapshot)({
+        deviceId,
+        includeThirdParty: true,
+        includeSystem: true,
+        includeDisabled: true,
+        includePackagePaths: false,
+        includeFeatures: false,
+        packageListLines: 600,
+    });
+    const profile = {
+        capturedAt: nowIso(),
+        durationMs: Date.now() - startedAt,
+        deviceId: radio.deviceId,
+        radio: {
+            wifiEnabled: radio.wifiEnabled,
+            mobileDataEnabled: radio.mobileDataEnabled,
+            airplaneMode: radio.airplaneMode,
+            bluetoothEnabled: radio.bluetoothEnabled,
+        },
+        display: {
+            wmSize: display.wmSize,
+            wmDensity: display.wmDensity,
+            brightness: display.screenBrightness,
+            rotation: display.userRotation,
+        },
+        location: {
+            mode: location.locationMode,
+            mockLocation: location.mockLocation,
+            appOps: compactStringSummary(location.locationAppOps),
+        },
+        power: {
+            battery: compactStringSummary(power.battery),
+        },
+        packages: {
+            total: packages.packageCount,
+            thirdParty: packages.thirdPartyCount,
+            system: packages.systemCount,
+            disabled: packages.disabledCount,
+        },
+    };
+    profile.healthScore = computeHealthScore(profile);
+    return profile;
+}
+function buildProfilesForDevices(deviceIds, packageName) {
+    const startedAt = Date.now();
+    const profiles = [];
+    for (const deviceId of deviceIds) {
+        try {
+            const profile = buildDeviceProfile(deviceId, packageName);
+            profiles.push({ ok: true, deviceId, profile });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            profiles.push({ ok: false, deviceId, error: message });
+        }
+    }
+    return {
+        capturedAt: nowIso(),
+        durationMs: Date.now() - startedAt,
+        count: profiles.length,
+        profiles,
+    };
+}
 function runStressScenario(body) {
     const deviceId = extractDeviceId(body);
     const urlsValue = body.urls;
@@ -422,28 +550,28 @@ function runStressScenario(body) {
     const normalizedUrls = urls.length > 0
         ? urls
         : ['https://www.wikipedia.org', 'https://news.ycombinator.com', 'https://developer.android.com'];
-    const loops = clampInt(body.loops, 1, 1, 5);
-    const waitForReadyMs = clampInt(body.waitForReadyMs, 1000, 200, 6000);
+    const loops = clampInt(body.loops, 1, 1, 6);
+    const waitForReadyMs = clampInt(body.waitForReadyMs, 1000, 200, 7000);
     const includeSnapshotAfterEach = body.includeSnapshotAfterEach !== false;
     const startedAt = Date.now();
     const steps = [];
     for (let loop = 1; loop <= loops; loop += 1) {
-        for (const url of normalizedUrls) {
-            const actionStarted = Date.now();
-            const open = (0, adb_js_1.openUrlInChrome)(url, deviceId, {
+        for (const targetUrl of normalizedUrls) {
+            const openStarted = Date.now();
+            const open = (0, adb_js_1.openUrlInChrome)(targetUrl, deviceId, {
                 waitForReadyMs,
                 fallbackToDefault: true,
             });
-            const record = {
+            const step = {
                 kind: 'open_url',
                 loop,
-                url,
+                url: targetUrl,
                 strategy: open.strategy,
                 deviceId: open.deviceId,
-                durationMs: Date.now() - actionStarted,
+                durationMs: Date.now() - openStarted,
             };
             if (includeSnapshotAfterEach) {
-                const snapshotStarted = Date.now();
+                const snapStarted = Date.now();
                 const radio = (0, adb_js_1.captureAndroidRadioSnapshot)({ deviceId: open.deviceId, includeWifiDump: false });
                 const display = (0, adb_js_1.captureAndroidDisplaySnapshot)({
                     deviceId: open.deviceId,
@@ -451,8 +579,8 @@ function runStressScenario(body) {
                     includeWindowDump: false,
                     includeSurfaceFlinger: false,
                 });
-                record.snapshot = {
-                    durationMs: Date.now() - snapshotStarted,
+                step.snapshot = {
+                    durationMs: Date.now() - snapStarted,
                     radio: {
                         wifiEnabled: radio.wifiEnabled,
                         mobileDataEnabled: radio.mobileDataEnabled,
@@ -461,11 +589,11 @@ function runStressScenario(body) {
                     display: {
                         wmSize: display.wmSize,
                         wmDensity: display.wmDensity,
-                        screenBrightness: display.screenBrightness,
+                        brightness: display.screenBrightness,
                     },
                 };
             }
-            steps.push(record);
+            steps.push(step);
         }
     }
     return {
@@ -492,28 +620,27 @@ async function runWorkflow(name, options) {
         const stepStarted = Date.now();
         if (step.type === 'open_url') {
             const result = (0, adb_js_1.openUrlInChrome)(step.url || 'https://www.wikipedia.org', options.deviceId, {
-                waitForReadyMs: clampInt(step.waitForReadyMs, 1200, 200, 10000),
+                waitForReadyMs: clampInt(step.waitForReadyMs, 1000, 200, 10000),
                 fallbackToDefault: true,
             });
             outputs.push({
                 step: 'open_url',
                 url: step.url,
                 strategy: result.strategy,
-                deviceId: result.deviceId,
                 durationMs: Date.now() - stepStarted,
             });
             continue;
         }
         if (step.type === 'snapshot') {
-            const snapshotKind = step.snapshot || 'radio';
-            const snapshot = captureSnapshot(snapshotKind, {
+            const kind = step.snapshot || 'radio';
+            const snapshot = captureSnapshot(kind, {
                 deviceId: options.deviceId,
                 packageName: step.packageName || options.packageName,
                 includeRaw: step.includeRaw === true || options.includeRaw === true,
             });
             outputs.push({
                 step: 'snapshot',
-                snapshotKind,
+                snapshotKind: kind,
                 durationMs: Date.now() - stepStarted,
                 snapshot,
             });
@@ -528,12 +655,9 @@ async function runWorkflow(name, options) {
             });
             continue;
         }
-        const duration = clampInt(step.durationMs, 500, 50, 20000);
+        const duration = clampInt(step.durationMs, 500, 50, 30000);
         await sleepMs(duration);
-        outputs.push({
-            step: 'sleep_ms',
-            durationMs: duration,
-        });
+        outputs.push({ step: 'sleep_ms', durationMs: duration });
     }
     return {
         ok: true,
@@ -548,6 +672,245 @@ async function runWorkflow(name, options) {
         updateHint: UPDATE_HINT,
     };
 }
+function resolveLaneForDevice(deviceId) {
+    const laneId = deviceId ? `device:${deviceId}` : 'device:default';
+    if (!lanes[laneId]) {
+        lanes[laneId] = {
+            id: laneId,
+            deviceId,
+            active: false,
+            queue: [],
+            completed: 0,
+            failed: 0,
+            cancelled: 0,
+            updatedAt: nowIso(),
+        };
+    }
+    return lanes[laneId];
+}
+function createJob(type, input) {
+    const rawDeviceId = typeof input.deviceId === 'string' ? input.deviceId : undefined;
+    const lane = resolveLaneForDevice(rawDeviceId);
+    const job = {
+        id: jobSeq++,
+        type,
+        laneId: lane.id,
+        deviceId: lane.deviceId,
+        status: 'queued',
+        createdAt: nowIso(),
+        input,
+    };
+    jobs.unshift(job);
+    if (jobs.length > MAX_JOBS) {
+        jobs.splice(MAX_JOBS);
+    }
+    lane.queue.push(job.id);
+    lane.updatedAt = nowIso();
+    pushEvent('job-queued', 'Job queued', {
+        id: job.id,
+        type: job.type,
+        laneId: lane.id,
+        queueDepth: lane.queue.length,
+    });
+    void scheduleLanes();
+    return job;
+}
+function getJobById(id) {
+    return jobs.find(job => job.id === id);
+}
+function listJobSummaries() {
+    return jobs
+        .slice()
+        .sort((a, b) => b.id - a.id)
+        .map(job => ({
+        id: job.id,
+        type: job.type,
+        laneId: job.laneId,
+        deviceId: job.deviceId,
+        status: job.status,
+        createdAt: job.createdAt,
+        startedAt: job.startedAt,
+        finishedAt: job.finishedAt,
+        durationMs: job.durationMs,
+        error: job.error,
+    }));
+}
+function cancelQueuedJob(id) {
+    const job = getJobById(id);
+    if (!job || job.status !== 'queued') {
+        return false;
+    }
+    const lane = lanes[job.laneId];
+    if (!lane) {
+        return false;
+    }
+    const idx = lane.queue.indexOf(id);
+    if (idx >= 0) {
+        lane.queue.splice(idx, 1);
+    }
+    job.status = 'cancelled';
+    job.finishedAt = nowIso();
+    job.durationMs = 0;
+    lane.cancelled += 1;
+    lane.updatedAt = nowIso();
+    pushEvent('job-cancelled', 'Job cancelled', { id, laneId: lane.id });
+    return true;
+}
+function retryJob(id) {
+    const previous = getJobById(id);
+    if (!previous) {
+        return undefined;
+    }
+    if (previous.status !== 'failed' && previous.status !== 'completed' && previous.status !== 'cancelled') {
+        return undefined;
+    }
+    const cloneInput = JSON.parse(JSON.stringify(previous.input));
+    return createJob(previous.type, cloneInput);
+}
+async function executeJob(job) {
+    if (job.type === 'open_url') {
+        const urlValue = typeof job.input.url === 'string' ? job.input.url : '';
+        if (!urlValue || !/^https?:\/\//i.test(urlValue)) {
+            throw new Error('open_url job requires valid url');
+        }
+        const waitForReadyMs = clampInt(job.input.waitForReadyMs, 1000, 200, 10000);
+        return (0, adb_js_1.openUrlInChrome)(urlValue, job.deviceId, {
+            waitForReadyMs,
+            fallbackToDefault: true,
+        });
+    }
+    if (job.type === 'snapshot_suite') {
+        return getSnapshotSuite(job.deviceId, typeof job.input.packageName === 'string' ? job.input.packageName : undefined);
+    }
+    if (job.type === 'stress_run') {
+        const input = { ...job.input };
+        if (!input.deviceId && job.deviceId) {
+            input.deviceId = job.deviceId;
+        }
+        return runStressScenario(input);
+    }
+    if (job.type === 'workflow_run') {
+        const workflowName = typeof job.input.name === 'string' ? job.input.name : '';
+        if (!workflowName) {
+            throw new Error('workflow_run job requires name');
+        }
+        return await runWorkflow(workflowName, {
+            deviceId: job.deviceId,
+            packageName: typeof job.input.packageName === 'string' ? job.input.packageName : undefined,
+            includeRaw: job.input.includeRaw === true,
+        });
+    }
+    return buildDeviceProfile(job.deviceId, typeof job.input.packageName === 'string' ? job.input.packageName : undefined);
+}
+async function processLane(lane) {
+    if (lane.active) {
+        return;
+    }
+    lane.active = true;
+    lane.updatedAt = nowIso();
+    while (lane.queue.length > 0) {
+        const jobId = lane.queue.shift();
+        if (!jobId) {
+            continue;
+        }
+        const job = getJobById(jobId);
+        if (!job || job.status !== 'queued') {
+            continue;
+        }
+        job.status = 'running';
+        job.startedAt = nowIso();
+        lane.updatedAt = nowIso();
+        pushEvent('job-running', 'Job started', {
+            id: job.id,
+            type: job.type,
+            laneId: lane.id,
+        });
+        const startedAtMs = Date.now();
+        try {
+            const result = await executeJob(job);
+            job.result = result;
+            job.status = 'completed';
+            job.finishedAt = nowIso();
+            job.durationMs = Date.now() - startedAtMs;
+            lane.completed += 1;
+            lane.updatedAt = nowIso();
+            pushEvent('job-completed', 'Job completed', {
+                id: job.id,
+                type: job.type,
+                laneId: lane.id,
+                durationMs: job.durationMs,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            job.status = 'failed';
+            job.error = message;
+            job.finishedAt = nowIso();
+            job.durationMs = Date.now() - startedAtMs;
+            lane.failed += 1;
+            lane.updatedAt = nowIso();
+            pushEvent('job-failed', 'Job failed', {
+                id: job.id,
+                type: job.type,
+                laneId: lane.id,
+                error: message,
+            });
+        }
+    }
+    lane.active = false;
+    lane.updatedAt = nowIso();
+}
+let laneSchedulerRunning = false;
+async function scheduleLanes() {
+    if (laneSchedulerRunning) {
+        return;
+    }
+    laneSchedulerRunning = true;
+    const promises = [];
+    for (const lane of Object.values(lanes)) {
+        if (lane.queue.length > 0 && !lane.active) {
+            promises.push(processLane(lane));
+        }
+    }
+    await Promise.all(promises);
+    laneSchedulerRunning = false;
+    const hasPending = Object.values(lanes).some(lane => lane.queue.length > 0 && !lane.active);
+    if (hasPending) {
+        void scheduleLanes();
+    }
+}
+function lanesSummary() {
+    return Object.values(lanes)
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .map(lane => ({
+        id: lane.id,
+        deviceId: lane.deviceId,
+        active: lane.active,
+        queueDepth: lane.queue.length,
+        completed: lane.completed,
+        failed: lane.failed,
+        cancelled: lane.cancelled,
+        updatedAt: lane.updatedAt,
+    }));
+}
+function resetSession(options) {
+    eventHistory.splice(0, eventHistory.length);
+    for (const key of Object.keys(metrics)) {
+        delete metrics[key];
+    }
+    for (const key of Object.keys(snapshotCache)) {
+        delete snapshotCache[key];
+    }
+    jobs.splice(0, jobs.length);
+    for (const key of Object.keys(lanes)) {
+        delete lanes[key];
+    }
+    if (!options.keepWorkflows) {
+        workflows = defaultWorkflows();
+        saveWorkflows();
+    }
+    pushEvent('session-reset', 'Session state reset', { keepWorkflows: options.keepWorkflows !== false });
+}
 async function readJsonBody(request) {
     return await new Promise((resolve, reject) => {
         const chunks = [];
@@ -639,23 +1002,43 @@ function buildStatePayload(host, port) {
         connectedDeviceCount: devices.length,
         eventCount: eventHistory.length,
         workflowCount: Object.keys(workflows).length,
+        laneCount: Object.keys(lanes).length,
+        queueDepth: Object.values(lanes).reduce((sum, lane) => sum + lane.queue.length, 0),
+        jobCount: jobs.length,
         snapshotKinds: SNAPSHOT_KINDS,
     };
 }
 function buildMetricsPayload() {
-    const items = Object.values(metrics)
+    const entries = Object.values(metrics)
         .sort((a, b) => b.count - a.count)
-        .map(item => ({
-        ...item,
-        avgDurationMs: item.count > 0 ? Math.round((item.totalDurationMs / item.count) * 100) / 100 : 0,
-        successRate: item.count > 0 ? Math.round((item.success / item.count) * 10000) / 100 : 0,
+        .map(entry => ({
+        ...entry,
+        avgDurationMs: entry.count > 0 ? Math.round((entry.totalDurationMs / entry.count) * 100) / 100 : 0,
+        successRate: entry.count > 0 ? Math.round((entry.success / entry.count) * 10000) / 100 : 0,
     }));
     return {
         generatedAt: nowIso(),
         uptimeMs: Date.now() - serverStartedAt,
-        totalActions: items.reduce((sum, item) => sum + item.count, 0),
-        errors: items.reduce((sum, item) => sum + item.errors, 0),
-        entries: items,
+        totalActions: entries.reduce((sum, item) => sum + item.count, 0),
+        errors: entries.reduce((sum, item) => sum + item.errors, 0),
+        entries,
+    };
+}
+function buildSessionExport() {
+    return {
+        exportedAt: nowIso(),
+        state: {
+            uptimeMs: Date.now() - serverStartedAt,
+            workflowCount: Object.keys(workflows).length,
+            jobCount: jobs.length,
+            laneCount: Object.keys(lanes).length,
+            eventCount: eventHistory.length,
+        },
+        workflows,
+        lanes: lanesSummary(),
+        jobs,
+        metrics: buildMetricsPayload(),
+        events: eventHistory,
     };
 }
 async function handleApi(request, response, context) {
@@ -691,34 +1074,186 @@ async function handleApi(request, response, context) {
         });
         return;
     }
-    if (method === 'GET' && pathname === '/api/history') {
-        await withMetric('history', () => {
-            const limitRaw = Number(url.searchParams.get('limit') ?? '120');
-            const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(500, Math.trunc(limitRaw))) : 120;
+    if (method === 'GET' && pathname === '/api/lanes') {
+        await withMetric('lanes-list', () => {
             sendJson(response, 200, {
-                count: Math.min(limit, eventHistory.length),
-                events: eventHistory.slice(-limit),
+                lanes: lanesSummary(),
+                count: Object.keys(lanes).length,
+            });
+        });
+        return;
+    }
+    if (method === 'GET' && pathname === '/api/jobs') {
+        await withMetric('jobs-list', () => {
+            sendJson(response, 200, {
+                jobs: listJobSummaries(),
+                queueDepth: Object.values(lanes).reduce((sum, lane) => sum + lane.queue.length, 0),
+            });
+        });
+        return;
+    }
+    if (method === 'POST' && pathname === '/api/jobs') {
+        await withMetric('jobs-create', async () => {
+            const body = await readJsonBody(request);
+            const typeValue = typeof body.type === 'string' ? body.type : '';
+            if (!isJobType(typeValue)) {
+                sendJson(response, 400, { error: 'type must be one of open_url, snapshot_suite, stress_run, workflow_run, device_profile' });
+                return;
+            }
+            const input = body.input && typeof body.input === 'object' && !Array.isArray(body.input)
+                ? body.input
+                : {};
+            const job = createJob(typeValue, input);
+            sendJson(response, 200, {
+                ok: true,
+                job,
+            });
+        });
+        return;
+    }
+    if (method === 'POST' && pathname === '/api/jobs/bulk') {
+        await withMetric('jobs-bulk', async () => {
+            const body = await readJsonBody(request);
+            const itemsRaw = Array.isArray(body.jobs) ? body.jobs : [];
+            if (itemsRaw.length === 0) {
+                sendJson(response, 400, { error: 'jobs array is required' });
+                return;
+            }
+            const created = [];
+            for (const itemRaw of itemsRaw) {
+                if (!itemRaw || typeof itemRaw !== 'object') {
+                    continue;
+                }
+                const item = itemRaw;
+                const typeValue = typeof item.type === 'string' ? item.type : '';
+                if (!isJobType(typeValue)) {
+                    continue;
+                }
+                const input = item.input && typeof item.input === 'object' && !Array.isArray(item.input)
+                    ? item.input
+                    : {};
+                created.push(createJob(typeValue, input));
+            }
+            sendJson(response, 200, {
+                ok: true,
+                createdCount: created.length,
+                jobs: created,
+            });
+        });
+        return;
+    }
+    if (method === 'GET' && /^\/api\/jobs\/\d+$/.test(pathname)) {
+        await withMetric('jobs-get', () => {
+            const id = Number(pathname.slice('/api/jobs/'.length));
+            const job = getJobById(id);
+            if (!job) {
+                sendJson(response, 404, { error: `job ${id} not found` });
+                return;
+            }
+            sendJson(response, 200, { ok: true, job });
+        });
+        return;
+    }
+    if (method === 'POST' && /^\/api\/jobs\/\d+\/cancel$/.test(pathname)) {
+        await withMetric('jobs-cancel', () => {
+            const id = Number(pathname.split('/')[3]);
+            const ok = cancelQueuedJob(id);
+            if (!ok) {
+                sendJson(response, 400, { error: `job ${id} cannot be cancelled` });
+                return;
+            }
+            sendJson(response, 200, { ok: true, id });
+        });
+        return;
+    }
+    if (method === 'POST' && /^\/api\/jobs\/\d+\/retry$/.test(pathname)) {
+        await withMetric('jobs-retry', () => {
+            const id = Number(pathname.split('/')[3]);
+            const retried = retryJob(id);
+            if (!retried) {
+                sendJson(response, 400, { error: `job ${id} cannot be retried` });
+                return;
+            }
+            sendJson(response, 200, {
+                ok: true,
+                previousJobId: id,
+                newJob: retried,
+            });
+        });
+        return;
+    }
+    if (method === 'GET' && pathname === '/api/workflows') {
+        await withMetric('workflows-list', () => {
+            sendJson(response, 200, {
+                workflows: workflowsList(),
+                count: Object.keys(workflows).length,
+            });
+        });
+        return;
+    }
+    if (method === 'GET' && pathname === '/api/workflows/export') {
+        await withMetric('workflows-export', () => {
+            sendJson(response, 200, {
+                exportedAt: nowIso(),
+                workflows,
+            });
+        });
+        return;
+    }
+    if (method === 'POST' && pathname === '/api/workflows/import') {
+        await withMetric('workflows-import', async () => {
+            const body = await readJsonBody(request);
+            const replace = body.replace === true;
+            const payload = body.workflows;
+            const imported = replace ? {} : { ...workflows };
+            const consumeWorkflow = (value) => {
+                if (!value || typeof value !== 'object') {
+                    return;
+                }
+                const item = value;
+                const name = typeof item.name === 'string' ? item.name.trim() : '';
+                if (!name) {
+                    return;
+                }
+                const stepsRaw = Array.isArray(item.steps) ? item.steps : [];
+                const steps = [];
+                for (const stepRaw of stepsRaw) {
+                    steps.push(normalizeWorkflowStep(stepRaw));
+                }
+                if (steps.length === 0) {
+                    return;
+                }
+                imported[name] = {
+                    name,
+                    description: typeof item.description === 'string' ? item.description : undefined,
+                    updatedAt: nowIso(),
+                    steps,
+                };
+            };
+            if (Array.isArray(payload)) {
+                for (const value of payload) {
+                    consumeWorkflow(value);
+                }
+            }
+            else if (payload && typeof payload === 'object') {
+                for (const value of Object.values(payload)) {
+                    consumeWorkflow(value);
+                }
+            }
+            else {
+                sendJson(response, 400, { error: 'workflows must be array or object' });
+                return;
+            }
+            workflows = imported;
+            saveWorkflows();
+            pushEvent('workflow-import', 'Workflows imported', {
+                count: Object.keys(workflows).length,
+                replace,
             });
-        });
-        return;
-    }
-    if (method === 'GET' && pathname === '/api/events') {
-        await withMetric('events', () => {
-            setupSse(request, response);
-        });
-        return;
-    }
-    if (method === 'GET' && pathname === '/api/metrics') {
-        await withMetric('metrics', () => {
-            sendJson(response, 200, buildMetricsPayload());
-        });
-        return;
-    }
-    if (method === 'GET' && pathname === '/api/workflows') {
-        await withMetric('workflows-list', () => {
             sendJson(response, 200, {
-                workflows: workflowsList(),
+                ok: true,
                 count: Object.keys(workflows).length,
+                workflows: workflowsList(),
             });
         });
         return;
@@ -738,13 +1273,12 @@ async function handleApi(request, response, context) {
                 return;
             }
             const steps = stepsRaw.map(step => normalizeWorkflowStep(step));
-            const workflow = {
+            workflows[name] = {
                 name,
                 description,
                 updatedAt: nowIso(),
                 steps,
             };
-            workflows[name] = workflow;
             saveWorkflows();
             pushEvent('workflow-saved', 'Workflow saved', {
                 name,
@@ -752,7 +1286,7 @@ async function handleApi(request, response, context) {
             });
             sendJson(response, 200, {
                 ok: true,
-                workflow,
+                workflow: workflows[name],
             });
         });
         return;
@@ -804,11 +1338,9 @@ async function handleApi(request, response, context) {
                 sendJson(response, 400, { error: 'url must be valid http/https URL' });
                 return;
             }
-            const deviceId = extractDeviceId(body);
-            const waitForReadyMs = clampInt(body.waitForReadyMs, 1200, 200, 10000);
             const startedAt = Date.now();
-            const result = (0, adb_js_1.openUrlInChrome)(targetUrl, deviceId, {
-                waitForReadyMs,
+            const result = (0, adb_js_1.openUrlInChrome)(targetUrl, extractDeviceId(body), {
+                waitForReadyMs: clampInt(body.waitForReadyMs, 1000, 200, 10000),
                 fallbackToDefault: true,
             });
             pushEvent('open-url', 'Opened URL on device', {
@@ -826,6 +1358,44 @@ async function handleApi(request, response, context) {
         });
         return;
     }
+    if (method === 'POST' && pathname === '/api/device/profile') {
+        await withMetric('device-profile', async () => {
+            const body = await readJsonBody(request);
+            const profile = buildDeviceProfile(extractDeviceId(body), typeof body.packageName === 'string' ? body.packageName : undefined);
+            pushEvent('device-profile', 'Device profile captured', {
+                deviceId: profile.deviceId,
+                durationMs: profile.durationMs,
+                healthScore: profile.healthScore,
+            });
+            sendJson(response, 200, {
+                ok: true,
+                profile,
+                updateHint: UPDATE_HINT,
+            });
+        });
+        return;
+    }
+    if (method === 'POST' && pathname === '/api/device/profiles') {
+        await withMetric('device-profiles', async () => {
+            const body = await readJsonBody(request);
+            const packageName = typeof body.packageName === 'string' ? body.packageName : undefined;
+            const devicesRaw = Array.isArray(body.deviceIds) ? body.deviceIds : [];
+            const requested = devicesRaw.filter((value) => typeof value === 'string' && value.trim().length > 0);
+            const fallback = (0, adb_js_1.getConnectedDevices)().map(device => device.id);
+            const targetDevices = requested.length > 0 ? requested : fallback;
+            const profiles = buildProfilesForDevices(targetDevices, packageName);
+            pushEvent('device-profiles', 'Multi-device profiles captured', {
+                count: profiles.count,
+                durationMs: profiles.durationMs,
+            });
+            sendJson(response, 200, {
+                ok: true,
+                ...profiles,
+                updateHint: UPDATE_HINT,
+            });
+        });
+        return;
+    }
     if (method === 'POST' && pathname === '/api/snapshot-suite') {
         await withMetric('snapshot-suite', async () => {
             const body = await readJsonBody(request);
@@ -849,23 +1419,23 @@ async function handleApi(request, response, context) {
                 sendJson(response, 400, { error: 'kind must be one of snapshot kinds' });
                 return;
             }
-            const prev = snapshotCache[kindValue];
+            const previous = snapshotCache[kindValue];
             const fresh = captureSnapshot(kindValue, {
                 deviceId: extractDeviceId(body),
                 packageName: typeof body.packageName === 'string' ? body.packageName : undefined,
                 includeRaw: true,
             });
-            const currentRaw = fresh.raw ?? null;
-            snapshotCache[kindValue] = currentRaw ?? snapshotCache[kindValue];
-            const diff = diffSnapshot(prev, currentRaw);
-            pushEvent('snapshot-diff', 'Captured snapshot diff', {
+            const currentRaw = fresh.raw;
+            snapshotCache[kindValue] = currentRaw;
+            const diff = diffSnapshot(previous, currentRaw);
+            pushEvent('snapshot-diff', 'Snapshot diff captured', {
                 kind: kindValue,
                 changedCount: diff.changedCount,
             });
             sendJson(response, 200, {
                 ok: true,
                 kind: kindValue,
-                hadPrevious: Boolean(prev),
+                hadPrevious: Boolean(previous),
                 diff,
                 currentSummary: fresh.summary,
                 updateHint: UPDATE_HINT,
@@ -886,7 +1456,7 @@ async function handleApi(request, response, context) {
                 packageName: typeof body.packageName === 'string' ? body.packageName : undefined,
                 includeRaw: body.includeRaw === true,
             });
-            pushEvent('snapshot', 'Captured snapshot', {
+            pushEvent('snapshot', 'Snapshot captured', {
                 kind: kindValue,
                 deviceId: result.deviceId,
             });
@@ -902,7 +1472,7 @@ async function handleApi(request, response, context) {
         await withMetric('stress-run', async () => {
             const body = await readJsonBody(request);
             const result = runStressScenario(body);
-            pushEvent('stress-run', 'Completed stress run', {
+            pushEvent('stress-run', 'Stress run completed', {
                 totalSteps: result.totalSteps,
                 durationMs: result.durationMs,
             });
@@ -910,6 +1480,47 @@ async function handleApi(request, response, context) {
         });
         return;
     }
+    if (method === 'GET' && pathname === '/api/history') {
+        await withMetric('history', () => {
+            const limitRaw = Number(url.searchParams.get('limit') ?? '120');
+            const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(600, Math.trunc(limitRaw))) : 120;
+            sendJson(response, 200, {
+                count: Math.min(limit, eventHistory.length),
+                events: eventHistory.slice(-limit),
+            });
+        });
+        return;
+    }
+    if (method === 'GET' && pathname === '/api/events') {
+        await withMetric('events', () => {
+            setupSse(request, response);
+        });
+        return;
+    }
+    if (method === 'GET' && pathname === '/api/metrics') {
+        await withMetric('metrics', () => {
+            sendJson(response, 200, buildMetricsPayload());
+        });
+        return;
+    }
+    if (method === 'GET' && pathname === '/api/session/export') {
+        await withMetric('session-export', () => {
+            sendJson(response, 200, buildSessionExport());
+        });
+        return;
+    }
+    if (method === 'POST' && pathname === '/api/session/reset') {
+        await withMetric('session-reset', async () => {
+            const body = await readJsonBody(request);
+            const keepWorkflows = body.keepWorkflows !== false;
+            resetSession({ keepWorkflows });
+            sendJson(response, 200, {
+                ok: true,
+                keepWorkflows,
+            });
+        });
+        return;
+    }
     sendJson(response, 404, { error: 'Not found' });
 }
 const INDEX_HTML = String.raw `<!doctype html>
@@ -917,7 +1528,7 @@ const INDEX_HTML = String.raw `<!doctype html>
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width,initial-scale=1" />
-    <title>the-android-mcp web ui v3.2</title>
+    <title>the-android-mcp web ui v3.4</title>
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Manrope:wght@400;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
@@ -948,7 +1559,7 @@ const INDEX_HTML = String.raw `<!doctype html>
           linear-gradient(155deg, var(--bg0), var(--bg1) 44%, var(--bg2));
         padding: 16px;
       }
-      .app { max-width: 1450px; margin: 0 auto; display: grid; gap: 12px; }
+      .app { max-width: 1560px; margin: 0 auto; display: grid; gap: 12px; }
       .hero {
         border: 1px solid var(--line);
         border-radius: 18px;
@@ -978,7 +1589,7 @@ const INDEX_HTML = String.raw `<!doctype html>
       .grid {
         display: grid;
         gap: 10px;
-        grid-template-columns: 1.1fr 1fr 1fr;
+        grid-template-columns: 1fr 1fr 1fr;
       }
       .card {
         border: 1px solid var(--line);
@@ -1000,13 +1611,13 @@ const INDEX_HTML = String.raw `<!doctype html>
         padding: 9px;
         font: inherit;
       }
-      textarea { min-height: 94px; resize: vertical; }
+      textarea { min-height: 86px; resize: vertical; }
       button { cursor: pointer; font-weight: 700; transition: transform 120ms ease, filter 120ms ease; }
       button:hover { transform: translateY(-1px); filter: brightness(1.08); }
       .p { background: linear-gradient(130deg, #0d7666, #155f75); }
       .s { background: linear-gradient(130deg, #1d3348, #192b3c); }
       .w { background: linear-gradient(130deg, #7a5917, #61401f); }
-      .events, .metrics {
+      .events, .metrics, .jobs, .lanes {
         max-height: 300px;
         overflow: auto;
         border: 1px solid #2f4a61;
@@ -1014,7 +1625,7 @@ const INDEX_HTML = String.raw `<!doctype html>
         padding: 8px;
         background: #0b141d;
       }
-      .event, .metric {
+      .item {
         border: 1px solid #2e4a61;
         border-radius: 8px;
         padding: 6px;
@@ -1038,7 +1649,7 @@ const INDEX_HTML = String.raw `<!doctype html>
       pre {
         margin: 0;
         padding: 10px;
-        max-height: 450px;
+        max-height: 460px;
         overflow: auto;
         color: #c6e4ff;
         font: 12px/1.45 'JetBrains Mono', monospace;
@@ -1058,15 +1669,17 @@ const INDEX_HTML = String.raw `<!doctype html>
           <span class="pill" id="version-pill">v3</span>
           <span class="pill" id="device-pill">device: n/a</span>
           <span class="pill" id="workflow-pill">workflows: 0</span>
+          <span class="pill" id="lane-pill">lanes: 0</span>
+          <span class="pill" id="queue-pill">queue: 0</span>
           <span class="pill">port: 50000</span>
         </div>
-        <h1 style="margin:0;font-size:1.45rem;">the-android-mcp v3.2 command center</h1>
-        <p class="muted">Live backend integration, workflow engine, snapshot diff, stress automation, and streaming events.</p>
+        <h1 style="margin:0;font-size:1.45rem;">the-android-mcp v3.4 command center</h1>
+        <p class="muted">Multi-lane backend orchestration, workflow import/export, profile matrix, snapshot diff, and live job controls.</p>
       </section>
 
       <section class="grid">
         <article class="card stack">
-          <h2>Device + URL actions</h2>
+          <h2>Device operations</h2>
           <select id="device-select"></select>
           <input id="url-input" type="url" value="https://www.wikipedia.org" />
           <div class="split">
@@ -1079,11 +1692,15 @@ const INDEX_HTML = String.raw `<!doctype html>
             <button class="s quick-url" data-url="https://developer.android.com">Android Docs</button>
             <button class="s quick-url" data-url="https://www.youtube.com">YouTube</button>
           </div>
+          <div class="split">
+            <button class="s" id="profile-btn">Device profile</button>
+            <button class="s" id="profiles-btn">Profiles all</button>
+          </div>
           <p class="muted">Update hint: <code>npm install -g the-android-mcp@latest</code></p>
         </article>
 
         <article class="card stack">
-          <h2>Snapshot + diff</h2>
+          <h2>Snapshot + stress</h2>
           <select id="snapshot-kind">
             <option value="radio">radio</option>
             <option value="display">display</option>
@@ -1095,48 +1712,74 @@ const INDEX_HTML = String.raw `<!doctype html>
             <button class="s" id="snapshot-btn">Capture</button>
             <button class="w" id="snapshot-diff-btn">Capture diff</button>
           </div>
-          <p class="muted">Diff compares latest capture with previous capture of same type.</p>
-        </article>
-
-        <article class="card stack">
-          <h2>Stress run</h2>
           <textarea id="stress-urls">https://www.wikipedia.org
 https://news.ycombinator.com
 https://developer.android.com</textarea>
           <div class="split">
-            <input id="stress-loops" type="number" min="1" max="5" value="1" />
-            <input id="stress-wait" type="number" min="200" max="6000" value="1000" />
+            <input id="stress-loops" type="number" min="1" max="6" value="1" />
+            <input id="stress-wait" type="number" min="200" max="7000" value="1000" />
           </div>
           <button class="w" id="stress-btn">Run stress</button>
-          <p class="muted">Config: loops / wait-ms</p>
         </article>
 
         <article class="card stack">
           <h2>Workflow engine</h2>
           <select id="workflow-select"></select>
-          <input id="workflow-name" placeholder="workflow name" value="" />
+          <input id="workflow-name" placeholder="workflow name" />
           <textarea id="workflow-steps">[
-  {"type":"open_url","url":"https://www.wikipedia.org","waitForReadyMs":1000},
+  {"type":"open_url","url":"https://www.wikipedia.org","waitForReadyMs":900},
   {"type":"snapshot","snapshot":"radio"},
-  {"type":"open_url","url":"https://developer.android.com","waitForReadyMs":1000},
   {"type":"snapshot_suite","packageName":"com.android.chrome"}
 ]</textarea>
           <div class="split">
             <button class="p" id="workflow-save-btn">Save</button>
             <button class="p" id="workflow-run-btn">Run</button>
           </div>
-          <button class="s" id="workflow-delete-btn">Delete selected</button>
+          <div class="split">
+            <button class="s" id="workflow-delete-btn">Delete</button>
+            <button class="s" id="workflow-export-btn">Export</button>
+          </div>
+          <button class="s" id="workflow-import-btn">Import from editor</button>
         </article>
 
         <article class="card stack">
-          <h2>Live events</h2>
+          <h2>Job orchestrator</h2>
+          <select id="job-type">
+            <option value="open_url">open_url</option>
+            <option value="snapshot_suite">snapshot_suite</option>
+            <option value="stress_run">stress_run</option>
+            <option value="workflow_run">workflow_run</option>
+            <option value="device_profile">device_profile</option>
+          </select>
+          <input id="job-url" type="url" value="https://developer.android.com" />
+          <select id="job-workflow"></select>
+          <div class="split">
+            <button class="p" id="job-enqueue-btn">Enqueue job</button>
+            <button class="s" id="job-refresh-btn">Refresh jobs</button>
+          </div>
+          <textarea id="bulk-jobs">[
+  {"type":"open_url","input":{"url":"https://www.wikipedia.org","waitForReadyMs":800}},
+  {"type":"open_url","input":{"url":"https://news.ycombinator.com","waitForReadyMs":800}},
+  {"type":"snapshot_suite","input":{"packageName":"com.android.chrome"}}
+]</textarea>
+          <button class="w" id="job-bulk-btn">Enqueue bulk JSON</button>
+          <div id="jobs" class="jobs"></div>
+        </article>
+
+        <article class="card stack">
+          <h2>Lanes + events</h2>
+          <div id="lanes" class="lanes"></div>
           <div id="events" class="events"></div>
         </article>
 
         <article class="card stack">
-          <h2>Backend metrics</h2>
+          <h2>Metrics + session</h2>
           <div id="metrics" class="metrics"></div>
-          <button class="s" id="refresh-state-btn">Refresh state</button>
+          <div class="split">
+            <button class="s" id="refresh-state-btn">Refresh state</button>
+            <button class="s" id="export-session-btn">Export session</button>
+          </div>
+          <button class="w" id="reset-session-btn">Reset session (keep workflows)</button>
         </article>
 
         <article class="card" style="grid-column: 1 / -1;">
@@ -1161,12 +1804,16 @@ https://developer.android.com</textarea>
       const $versionPill = document.getElementById('version-pill');
       const $devicePill = document.getElementById('device-pill');
       const $workflowPill = document.getElementById('workflow-pill');
+      const $lanePill = document.getElementById('lane-pill');
+      const $queuePill = document.getElementById('queue-pill');
       const $deviceSelect = document.getElementById('device-select');
       const $urlInput = document.getElementById('url-input');
       const $message = document.getElementById('message');
       const $output = document.getElementById('output');
       const $events = document.getElementById('events');
       const $metrics = document.getElementById('metrics');
+      const $jobs = document.getElementById('jobs');
+      const $lanes = document.getElementById('lanes');
       const $snapshotKind = document.getElementById('snapshot-kind');
       const $stressUrls = document.getElementById('stress-urls');
       const $stressLoops = document.getElementById('stress-loops');
@@ -1174,6 +1821,10 @@ https://developer.android.com</textarea>
       const $workflowSelect = document.getElementById('workflow-select');
       const $workflowName = document.getElementById('workflow-name');
       const $workflowSteps = document.getElementById('workflow-steps');
+      const $jobType = document.getElementById('job-type');
+      const $jobUrl = document.getElementById('job-url');
+      const $jobWorkflow = document.getElementById('job-workflow');
+      const $bulkJobs = document.getElementById('bulk-jobs');
 
       function setMessage(text, isError) {
         $message.textContent = text;
@@ -1190,23 +1841,13 @@ https://developer.android.com</textarea>
           return;
         }
         const item = document.createElement('div');
-        item.className = 'event';
-        const meta = document.createElement('div');
-        meta.className = 'meta';
-        meta.textContent = '[' + (event.at || new Date().toISOString()) + '] ' + event.type;
-        const message = document.createElement('div');
-        message.textContent = event.message || '';
-        item.appendChild(meta);
-        item.appendChild(message);
-        if (event.data) {
-          const data = document.createElement('div');
-          data.style.color = '#a5c6db';
-          data.style.marginTop = '4px';
-          data.textContent = JSON.stringify(event.data);
-          item.appendChild(data);
-        }
+        item.className = 'item';
+        item.innerHTML =
+          '<div class="meta">[' + (event.at || new Date().toISOString()) + '] ' + event.type + '</div>' +
+          '<div>' + (event.message || '') + '</div>' +
+          (event.data ? '<div style="color:#a5c6db;margin-top:4px;">' + JSON.stringify(event.data) + '</div>' : '');
         $events.prepend(item);
-        while ($events.children.length > 100) {
+        while ($events.children.length > 120) {
           $events.removeChild($events.lastChild);
         }
       }
@@ -1214,9 +1855,9 @@ https://developer.android.com</textarea>
       function renderMetrics(payload) {
         const entries = Array.isArray(payload.entries) ? payload.entries : [];
         $metrics.innerHTML = '';
-        for (const entry of entries.slice(0, 20)) {
+        for (const entry of entries.slice(0, 25)) {
           const item = document.createElement('div');
-          item.className = 'metric';
+          item.className = 'item';
           item.innerHTML =
             '<div class="meta">' + entry.name + '</div>' +
             '<div>count=' + entry.count + ' success=' + entry.success + ' errors=' + entry.errors + '</div>' +
@@ -1228,6 +1869,77 @@ https://developer.android.com</textarea>
         }
       }
 
+      function renderLanes(payload) {
+        const lanes = Array.isArray(payload.lanes) ? payload.lanes : [];
+        $lanes.innerHTML = '';
+        for (const lane of lanes.slice(0, 30)) {
+          const item = document.createElement('div');
+          item.className = 'item';
+          item.innerHTML =
+            '<div class="meta">' + lane.id + (lane.active ? ' [active]' : '') + '</div>' +
+            '<div>queue=' + lane.queueDepth + ' completed=' + lane.completed + ' failed=' + lane.failed + ' cancelled=' + lane.cancelled + '</div>' +
+            '<div>device=' + (lane.deviceId || 'default') + '</div>';
+          $lanes.appendChild(item);
+        }
+        if (!lanes.length) {
+          $lanes.textContent = 'No lanes yet.';
+        }
+      }
+
+      function renderJobs(payload) {
+        const jobs = Array.isArray(payload.jobs) ? payload.jobs : [];
+        $jobs.innerHTML = '';
+        for (const job of jobs.slice(0, 40)) {
+          const item = document.createElement('div');
+          item.className = 'item';
+          item.innerHTML =
+            '<div class="meta">#' + job.id + ' ' + job.type + ' [' + job.status + ']</div>' +
+            '<div>lane=' + (job.laneId || '-') + ' duration=' + (job.durationMs || 0) + 'ms</div>' +
+            (job.error ? '<div style="color:#ff8f8f;">' + job.error + '</div>' : '');
+
+          if (job.status === 'queued') {
+            const cancelBtn = document.createElement('button');
+            cancelBtn.className = 'w';
+            cancelBtn.textContent = 'Cancel';
+            cancelBtn.style.marginTop = '6px';
+            cancelBtn.addEventListener('click', async function () {
+              try {
+                const result = await api('/api/jobs/' + job.id + '/cancel', 'POST', {});
+                renderOutput(result);
+                await refreshJobsAndLanes();
+                setMessage('Job cancelled', false);
+              } catch (error) {
+                setMessage(String(error), true);
+              }
+            });
+            item.appendChild(cancelBtn);
+          }
+
+          if (job.status === 'failed' || job.status === 'completed' || job.status === 'cancelled') {
+            const retryBtn = document.createElement('button');
+            retryBtn.className = 's';
+            retryBtn.textContent = 'Retry';
+            retryBtn.style.marginTop = '6px';
+            retryBtn.addEventListener('click', async function () {
+              try {
+                const result = await api('/api/jobs/' + job.id + '/retry', 'POST', {});
+                renderOutput(result);
+                await refreshJobsAndLanes();
+                setMessage('Job retried', false);
+              } catch (error) {
+                setMessage(String(error), true);
+              }
+            });
+            item.appendChild(retryBtn);
+          }
+
+          $jobs.appendChild(item);
+        }
+        if (!jobs.length) {
+          $jobs.textContent = 'No jobs yet.';
+        }
+      }
+
       async function api(path, method, body) {
         const response = await fetch(path, {
           method: method || 'GET',
@@ -1245,14 +1957,43 @@ https://developer.android.com</textarea>
         return state.deviceId || undefined;
       }
 
-      async function refreshState() {
+      function selectedWorkflowName() {
+        const value = ($workflowSelect.value || '').trim();
+        return value || undefined;
+      }
+
+      function stressConfig() {
+        return {
+          urls: $stressUrls.value
+            .split('\n')
+            .map(function (line) { return line.trim(); })
+            .filter(function (line) { return line.length > 0; }),
+          loops: Number($stressLoops.value || '1'),
+          waitForReadyMs: Number($stressWait.value || '1000'),
+          includeSnapshotAfterEach: true,
+        };
+      }
+
+      async function refreshJobsAndLanes() {
+        const jobsPayload = await api('/api/jobs');
+        renderJobs(jobsPayload);
+
+        const lanesPayload = await api('/api/lanes');
+        renderLanes(lanesPayload);
+      }
+
+      async function refreshCore() {
         const statePayload = await api('/api/state');
         $status.textContent = statePayload.connectedDeviceCount > 0 ? 'online' : 'no-device';
         $versionPill.textContent = 'v' + statePayload.version;
         $workflowPill.textContent = 'workflows: ' + statePayload.workflowCount;
+        $lanePill.textContent = 'lanes: ' + statePayload.laneCount;
+        $queuePill.textContent = 'queue: ' + statePayload.queueDepth;
 
         const devicesPayload = await api('/api/devices');
         const devices = Array.isArray(devicesPayload.devices) ? devicesPayload.devices : [];
+        const previousDevice = state.deviceId;
+
         $deviceSelect.innerHTML = '';
         for (const device of devices) {
           const option = document.createElement('option');
@@ -1260,7 +2001,13 @@ https://developer.android.com</textarea>
           option.textContent = device.id + ' (' + (device.model || 'unknown') + ')';
           $deviceSelect.appendChild(option);
         }
-        state.deviceId = devices[0] ? devices[0].id : undefined;
+
+        if (previousDevice && devices.some(function (d) { return d.id === previousDevice; })) {
+          state.deviceId = previousDevice;
+        } else {
+          state.deviceId = devices[0] ? devices[0].id : undefined;
+        }
+
         if (state.deviceId) {
           $deviceSelect.value = state.deviceId;
           $devicePill.textContent = 'device: ' + state.deviceId;
@@ -1269,23 +2016,40 @@ https://developer.android.com</textarea>
         }
 
         const workflowsPayload = await api('/api/workflows');
-        state.workflows = Array.isArray(workflowsPayload.workflows) ? workflowsPayload.workflows : [];
-        $workflowSelect.innerHTML = '';
-        for (const workflow of state.workflows) {
-          const option = document.createElement('option');
-          option.value = workflow.name;
-          option.textContent = workflow.name;
-          $workflowSelect.appendChild(option);
-        }
-        if (state.workflows.length > 0) {
-          const selected = state.workflows[0];
-          $workflowSelect.value = selected.name;
-          $workflowName.value = selected.name;
-          $workflowSteps.value = JSON.stringify(selected.steps || [], null, 2);
+        const workflows = Array.isArray(workflowsPayload.workflows) ? workflowsPayload.workflows : [];
+        state.workflows = workflows;
+
+        const fillWorkflowSelect = function (selectElement) {
+          const prev = (selectElement.value || '').trim();
+          selectElement.innerHTML = '';
+          for (const wf of workflows) {
+            const option = document.createElement('option');
+            option.value = wf.name;
+            option.textContent = wf.name;
+            selectElement.appendChild(option);
+          }
+          if (prev && workflows.some(function (w) { return w.name === prev; })) {
+            selectElement.value = prev;
+          } else if (workflows[0]) {
+            selectElement.value = workflows[0].name;
+          }
+        };
+
+        fillWorkflowSelect($workflowSelect);
+        fillWorkflowSelect($jobWorkflow);
+
+        if ($workflowSelect.value) {
+          const selected = workflows.find(function (w) { return w.name === $workflowSelect.value; });
+          if (selected) {
+            $workflowName.value = selected.name;
+            $workflowSteps.value = JSON.stringify(selected.steps || [], null, 2);
+          }
         }
 
         const metricsPayload = await api('/api/metrics');
         renderMetrics(metricsPayload);
+
+        await refreshJobsAndLanes();
       }
 
       function connectEvents() {
@@ -1293,7 +2057,7 @@ https://developer.android.com</textarea>
         es.onmessage = function (event) {
           try {
             addEvent(JSON.parse(event.data));
-          } catch (err) {
+          } catch (error) {
             // ignore
           }
         };
@@ -1303,13 +2067,23 @@ https://developer.android.com</textarea>
         setMessage('Opening URL: ' + url, false);
         const result = await api('/api/open-url', 'POST', {
           deviceId: selectedDeviceId(),
-          url: url,
-          waitForReadyMs: 1000,
+          url,
+          waitForReadyMs: 900,
         });
         renderOutput(result);
         setMessage('URL opened', false);
       }
 
+      async function runSuite() {
+        setMessage('Running suite', false);
+        const result = await api('/api/snapshot-suite', 'POST', {
+          deviceId: selectedDeviceId(),
+          packageName: 'com.android.chrome',
+        });
+        renderOutput(result);
+        setMessage('Suite completed', false);
+      }
+
       async function captureSnapshot() {
         const kind = $snapshotKind.value;
         setMessage('Capturing snapshot: ' + kind, false);
@@ -1328,40 +2102,43 @@ https://developer.android.com</textarea>
         const result = await api('/api/snapshot/diff', 'POST', {
           deviceId: selectedDeviceId(),
           packageName: 'com.android.chrome',
-          kind: kind,
+          kind,
         });
         renderOutput(result);
-        setMessage('Snapshot diff done', false);
+        setMessage('Snapshot diff completed', false);
       }
 
-      async function runSuite() {
-        setMessage('Running full suite', false);
-        const result = await api('/api/snapshot-suite', 'POST', {
+      async function captureDeviceProfile() {
+        setMessage('Capturing device profile', false);
+        const result = await api('/api/device/profile', 'POST', {
           deviceId: selectedDeviceId(),
           packageName: 'com.android.chrome',
         });
         renderOutput(result);
-        setMessage('Suite done', false);
+        setMessage('Device profile completed', false);
       }
 
-      async function runStress() {
-        setMessage('Running stress', false);
-        const urls = $stressUrls.value
-          .split('\n')
-          .map(function (line) { return line.trim(); })
-          .filter(function (line) { return line.length > 0; });
-        const loops = Number($stressLoops.value || '1');
-        const waitForReadyMs = Number($stressWait.value || '1000');
+      async function captureAllProfiles() {
+        setMessage('Capturing profiles for all devices', false);
+        const result = await api('/api/device/profiles', 'POST', {
+          packageName: 'com.android.chrome',
+        });
+        renderOutput(result);
+        setMessage('Profiles matrix completed', false);
+      }
 
+      async function runStress() {
+        setMessage('Running stress run', false);
+        const cfg = stressConfig();
         const result = await api('/api/stress-run', 'POST', {
           deviceId: selectedDeviceId(),
-          urls,
-          loops,
-          waitForReadyMs,
+          urls: cfg.urls,
+          loops: cfg.loops,
+          waitForReadyMs: cfg.waitForReadyMs,
           includeSnapshotAfterEach: true,
         });
         renderOutput(result);
-        setMessage('Stress run done', false);
+        setMessage('Stress run completed', false);
       }
 
       async function saveWorkflow() {
@@ -1373,19 +2150,16 @@ https://developer.android.com</textarea>
         try {
           steps = JSON.parse($workflowSteps.value || '[]');
         } catch (error) {
-          throw new Error('workflow steps must be valid JSON array');
+          throw new Error('workflow steps must be valid JSON');
         }
-        const result = await api('/api/workflows', 'POST', {
-          name,
-          steps,
-        });
+        const result = await api('/api/workflows', 'POST', { name, steps });
         renderOutput(result);
         setMessage('Workflow saved', false);
-        await refreshState();
+        await refreshCore();
       }
 
       async function runWorkflow() {
-        const name = ($workflowSelect.value || '').trim();
+        const name = selectedWorkflowName();
         if (!name) {
           throw new Error('select workflow first');
         }
@@ -1396,18 +2170,113 @@ https://developer.android.com</textarea>
           includeRaw: false,
         });
         renderOutput(result);
-        setMessage('Workflow done', false);
+        setMessage('Workflow executed', false);
       }
 
       async function deleteWorkflow() {
-        const name = ($workflowSelect.value || '').trim();
+        const name = selectedWorkflowName();
         if (!name) {
           throw new Error('select workflow first');
         }
         const result = await api('/api/workflows/' + encodeURIComponent(name), 'DELETE');
         renderOutput(result);
         setMessage('Workflow deleted', false);
-        await refreshState();
+        await refreshCore();
+      }
+
+      async function exportWorkflows() {
+        const result = await api('/api/workflows/export');
+        $workflowSteps.value = JSON.stringify(result.workflows || {}, null, 2);
+        renderOutput(result);
+        setMessage('Workflows exported to editor', false);
+      }
+
+      async function importWorkflows() {
+        let parsed;
+        try {
+          parsed = JSON.parse($workflowSteps.value || '{}');
+        } catch (error) {
+          throw new Error('workflow editor must contain valid JSON');
+        }
+        const result = await api('/api/workflows/import', 'POST', {
+          workflows: parsed,
+          replace: false,
+        });
+        renderOutput(result);
+        setMessage('Workflows imported', false);
+        await refreshCore();
+      }
+
+      async function enqueueSingleJob() {
+        const type = ($jobType.value || '').trim();
+        const input = { deviceId: selectedDeviceId() };
+
+        if (type === 'open_url') {
+          input.url = $jobUrl.value || 'https://developer.android.com';
+          input.waitForReadyMs = 900;
+        } else if (type === 'snapshot_suite') {
+          input.packageName = 'com.android.chrome';
+        } else if (type === 'stress_run') {
+          const cfg = stressConfig();
+          input.urls = cfg.urls;
+          input.loops = cfg.loops;
+          input.waitForReadyMs = cfg.waitForReadyMs;
+          input.includeSnapshotAfterEach = true;
+        } else if (type === 'workflow_run') {
+          const workflowName = ($jobWorkflow.value || '').trim();
+          if (!workflowName) {
+            throw new Error('select workflow for workflow_run job');
+          }
+          input.name = workflowName;
+          input.packageName = 'com.android.chrome';
+        } else if (type === 'device_profile') {
+          input.packageName = 'com.android.chrome';
+        }
+
+        const result = await api('/api/jobs', 'POST', { type, input });
+        renderOutput(result);
+        setMessage('Job enqueued', false);
+        await refreshJobsAndLanes();
+      }
+
+      async function enqueueBulkJobs() {
+        let parsed;
+        try {
+          parsed = JSON.parse($bulkJobs.value || '[]');
+        } catch (error) {
+          throw new Error('bulk jobs must be valid JSON array');
+        }
+
+        if (!Array.isArray(parsed)) {
+          throw new Error('bulk jobs must be array');
+        }
+
+        for (const item of parsed) {
+          if (!item.input || typeof item.input !== 'object' || Array.isArray(item.input)) {
+            item.input = {};
+          }
+          if (!item.input.deviceId) {
+            item.input.deviceId = selectedDeviceId();
+          }
+        }
+
+        const result = await api('/api/jobs/bulk', 'POST', { jobs: parsed });
+        renderOutput(result);
+        setMessage('Bulk jobs enqueued', false);
+        await refreshJobsAndLanes();
+      }
+
+      async function exportSession() {
+        const result = await api('/api/session/export');
+        renderOutput(result);
+        setMessage('Session exported to output', false);
+      }
+
+      async function resetSession() {
+        const result = await api('/api/session/reset', 'POST', { keepWorkflows: true });
+        renderOutput(result);
+        setMessage('Session reset complete', false);
+        await refreshCore();
       }
 
       document.getElementById('open-url-btn').addEventListener('click', async function () {
@@ -1422,6 +2291,12 @@ https://developer.android.com</textarea>
       document.getElementById('snapshot-diff-btn').addEventListener('click', async function () {
         try { await captureSnapshotDiff(); } catch (error) { setMessage(String(error), true); }
       });
+      document.getElementById('profile-btn').addEventListener('click', async function () {
+        try { await captureDeviceProfile(); } catch (error) { setMessage(String(error), true); }
+      });
+      document.getElementById('profiles-btn').addEventListener('click', async function () {
+        try { await captureAllProfiles(); } catch (error) { setMessage(String(error), true); }
+      });
       document.getElementById('stress-btn').addEventListener('click', async function () {
         try { await runStress(); } catch (error) { setMessage(String(error), true); }
       });
@@ -1434,20 +2309,36 @@ https://developer.android.com</textarea>
       document.getElementById('workflow-delete-btn').addEventListener('click', async function () {
         try { await deleteWorkflow(); } catch (error) { setMessage(String(error), true); }
       });
+      document.getElementById('workflow-export-btn').addEventListener('click', async function () {
+        try { await exportWorkflows(); } catch (error) { setMessage(String(error), true); }
+      });
+      document.getElementById('workflow-import-btn').addEventListener('click', async function () {
+        try { await importWorkflows(); } catch (error) { setMessage(String(error), true); }
+      });
+      document.getElementById('job-enqueue-btn').addEventListener('click', async function () {
+        try { await enqueueSingleJob(); } catch (error) { setMessage(String(error), true); }
+      });
+      document.getElementById('job-bulk-btn').addEventListener('click', async function () {
+        try { await enqueueBulkJobs(); } catch (error) { setMessage(String(error), true); }
+      });
+      document.getElementById('job-refresh-btn').addEventListener('click', async function () {
+        try { await refreshJobsAndLanes(); setMessage('Jobs and lanes refreshed', false); } catch (error) { setMessage(String(error), true); }
+      });
       document.getElementById('refresh-state-btn').addEventListener('click', async function () {
-        try {
-          await refreshState();
-          setMessage('State refreshed', false);
-        } catch (error) {
-          setMessage(String(error), true);
-        }
+        try { await refreshCore(); setMessage('State refreshed', false); } catch (error) { setMessage(String(error), true); }
+      });
+      document.getElementById('export-session-btn').addEventListener('click', async function () {
+        try { await exportSession(); } catch (error) { setMessage(String(error), true); }
+      });
+      document.getElementById('reset-session-btn').addEventListener('click', async function () {
+        try { await resetSession(); } catch (error) { setMessage(String(error), true); }
       });
       document.getElementById('clear-output-btn').addEventListener('click', function () {
         renderOutput({});
       });
 
       $deviceSelect.addEventListener('change', function () {
-        state.deviceId = $deviceSelect.value;
+        state.deviceId = $deviceSelect.value || undefined;
         $devicePill.textContent = 'device: ' + (state.deviceId || 'none');
       });
 
@@ -1466,17 +2357,98 @@ https://developer.android.com</textarea>
       }
 
       $workflowSelect.addEventListener('change', function () {
-        const selected = state.workflows.find(function (item) { return item.name === $workflowSelect.value; });
+        const selected = state.workflows.find(function (w) { return w.name === $workflowSelect.value; });
         if (selected) {
           $workflowName.value = selected.name;
           $workflowSteps.value = JSON.stringify(selected.steps || [], null, 2);
         }
       });
 
+      function connectEvents() {
+        const es = new EventSource('/api/events');
+        es.onmessage = function (event) {
+          try {
+            addEvent(JSON.parse(event.data));
+          } catch {
+            // ignore
+          }
+        };
+      }
+
+      async function refreshCore() {
+        const statePayload = await api('/api/state');
+        $status.textContent = statePayload.connectedDeviceCount > 0 ? 'online' : 'no-device';
+        $versionPill.textContent = 'v' + statePayload.version;
+        $workflowPill.textContent = 'workflows: ' + statePayload.workflowCount;
+        $lanePill.textContent = 'lanes: ' + statePayload.laneCount;
+        $queuePill.textContent = 'queue: ' + statePayload.queueDepth;
+
+        const devicesPayload = await api('/api/devices');
+        const devices = Array.isArray(devicesPayload.devices) ? devicesPayload.devices : [];
+        const previousDevice = state.deviceId;
+
+        $deviceSelect.innerHTML = '';
+        for (const device of devices) {
+          const option = document.createElement('option');
+          option.value = device.id;
+          option.textContent = device.id + ' (' + (device.model || 'unknown') + ')';
+          $deviceSelect.appendChild(option);
+        }
+
+        if (previousDevice && devices.some(function (d) { return d.id === previousDevice; })) {
+          state.deviceId = previousDevice;
+        } else {
+          state.deviceId = devices[0] ? devices[0].id : undefined;
+        }
+
+        if (state.deviceId) {
+          $deviceSelect.value = state.deviceId;
+          $devicePill.textContent = 'device: ' + state.deviceId;
+        } else {
+          $devicePill.textContent = 'device: none';
+        }
+
+        const workflowsPayload = await api('/api/workflows');
+        const workflows = Array.isArray(workflowsPayload.workflows) ? workflowsPayload.workflows : [];
+        state.workflows = workflows;
+
+        const fillSelect = function (selectElement) {
+          const prev = (selectElement.value || '').trim();
+          selectElement.innerHTML = '';
+          for (const workflow of workflows) {
+            const option = document.createElement('option');
+            option.value = workflow.name;
+            option.textContent = workflow.name;
+            selectElement.appendChild(option);
+          }
+          if (prev && workflows.some(function (w) { return w.name === prev; })) {
+            selectElement.value = prev;
+          } else if (workflows[0]) {
+            selectElement.value = workflows[0].name;
+          }
+        };
+
+        fillSelect($workflowSelect);
+        fillSelect($jobWorkflow);
+
+        if ($workflowSelect.value) {
+          const selected = workflows.find(function (w) { return w.name === $workflowSelect.value; });
+          if (selected) {
+            $workflowName.value = selected.name;
+            $workflowSteps.value = JSON.stringify(selected.steps || [], null, 2);
+          }
+        }
+
+        const metricsPayload = await api('/api/metrics');
+        renderMetrics(metricsPayload);
+
+        await refreshJobsAndLanes();
+      }
+
       async function init() {
         try {
-          await refreshState();
-          const history = await api('/api/history?limit=30');
+          await refreshCore();
+          const history = await api('/api/history?limit=45');
           const events = Array.isArray(history.events) ? history.events : [];
           for (let i = events.length - 1; i >= 0; i -= 1) {
             addEvent(events[i]);
@@ -1484,12 +2456,14 @@ https://developer.android.com</textarea>
           connectEvents();
           renderOutput({ ok: true, message: 'UI ready', updateHint: '${UPDATE_HINT}' });
           setMessage('Ready.', false);
+
           setInterval(async function () {
             try {
               const metricsPayload = await api('/api/metrics');
               renderMetrics(metricsPayload);
+              await refreshJobsAndLanes();
             } catch (error) {
-              setMessage('Metrics refresh failed', true);
+              setMessage('Background refresh failed', true);
             }
           }, 5000);
         } catch (error) {