@jackwener/opencli 1.7.8 → 1.7.10

package/dist/src/commands/daemon.test.js

@@ -1,13 +1,18 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const { fetchDaemonStatusMock, requestDaemonShutdownMock, } = vi.hoisted(() => ({
+const { fetchDaemonStatusMock, requestDaemonShutdownMock, restartDaemonMock, } = vi.hoisted(() => ({
     fetchDaemonStatusMock: vi.fn(),
     requestDaemonShutdownMock: vi.fn(),
+    restartDaemonMock: vi.fn(),
 }));
 vi.mock('../browser/daemon-client.js', () => ({
     fetchDaemonStatus: fetchDaemonStatusMock,
     requestDaemonShutdown: requestDaemonShutdownMock,
 }));
-import { daemonStatus, daemonStop } from './daemon.js';
+vi.mock('../browser/daemon-lifecycle.js', () => ({
+    restartDaemon: restartDaemonMock,
+}));
+import { daemonRestart, daemonStatus, daemonStop } from './daemon.js';
+import { PKG_VERSION } from '../version.js';
 describe('daemonStatus', () => {
     let stdoutSpy;
     beforeEach(() => {
@@ -28,6 +33,7 @@ describe('daemonStatus', () => {
             ok: true,
             pid: 12345,
             uptime: 3661,
+            daemonVersion: PKG_VERSION,
             extensionConnected: true,
             extensionVersion: '1.6.8',
             pending: 0,
@@ -37,6 +43,7 @@ describe('daemonStatus', () => {
         await daemonStatus();
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('PID 12345'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining(`v${PKG_VERSION}`));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('1h 1m'));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('connected'));
         expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('v1.6.8'));
@@ -48,6 +55,7 @@ describe('daemonStatus', () => {
             ok: true,
             pid: 99,
             uptime: 120,
+            daemonVersion: PKG_VERSION,
             extensionConnected: false,
             pending: 0,
             memoryMB: 32,
@@ -61,6 +69,7 @@ describe('daemonStatus', () => {
             ok: true,
             pid: 99,
             uptime: 120,
+            daemonVersion: PKG_VERSION,
             extensionConnected: true,
             extensionVersion: undefined,
             pending: 0,
@@ -91,6 +100,7 @@ describe('daemonStop', () => {
             ok: true,
             pid: 12345,
             uptime: 100,
+            daemonVersion: PKG_VERSION,
             extensionConnected: true,
             pending: 0,
             memoryMB: 50,
@@ -106,6 +116,7 @@ describe('daemonStop', () => {
             ok: true,
             pid: 12345,
             uptime: 100,
+            daemonVersion: PKG_VERSION,
             extensionConnected: true,
             pending: 0,
             memoryMB: 50,
@@ -116,3 +127,93 @@ describe('daemonStop', () => {
         expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
     });
 });
+describe('daemonRestart', () => {
+    let stderrSpy;
+    beforeEach(() => {
+        stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        fetchDaemonStatusMock.mockReset();
+        requestDaemonShutdownMock.mockReset();
+        restartDaemonMock.mockReset();
+        process.exitCode = undefined;
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        process.exitCode = undefined;
+    });
+    it('restarts a running daemon and reports the new version', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            daemonVersion: '1.7.6',
+            extensionConnected: true,
+            profiles: [{ contextId: 'work', extensionConnected: true, pending: 0 }],
+            pending: 0,
+            memoryMB: 50,
+            port: 19825,
+        });
+        restartDaemonMock.mockResolvedValue({
+            previousStatus: { daemonVersion: '1.7.6' },
+            stopped: true,
+            spawned: true,
+            status: {
+                ok: true,
+                pid: 12346,
+                uptime: 1,
+                daemonVersion: PKG_VERSION,
+                extensionConnected: true,
+                profiles: [{ contextId: 'work', extensionConnected: true, pending: 0 }],
+                pending: 0,
+                memoryMB: 51,
+                port: 19825,
+            },
+        });
+        await daemonRestart();
+        expect(restartDaemonMock).toHaveBeenCalledTimes(1);
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('will disconnect 1 browser profile'));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon restarted on port 19825 (v${PKG_VERSION})`));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Extension connected; profiles connected: 1'));
+    });
+    it('starts a new daemon when none was running', async () => {
+        fetchDaemonStatusMock.mockResolvedValue(null);
+        restartDaemonMock.mockResolvedValue({
+            previousStatus: null,
+            stopped: true,
+            spawned: true,
+            status: {
+                ok: true,
+                pid: 12346,
+                uptime: 1,
+                daemonVersion: PKG_VERSION,
+                extensionConnected: false,
+                pending: 0,
+                memoryMB: 51,
+                port: 19825,
+            },
+        });
+        await daemonRestart();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining(`Daemon started on port 19825 (v${PKG_VERSION})`));
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('extension has not connected yet'));
+    });
+    it('reports failure when the daemon cannot stop', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            daemonVersion: '1.7.6',
+            extensionConnected: true,
+            pending: 0,
+            memoryMB: 50,
+            port: 19825,
+        });
+        restartDaemonMock.mockResolvedValue({
+            previousStatus: { daemonVersion: '1.7.6' },
+            status: { daemonVersion: '1.7.6' },
+            stopped: false,
+            spawned: false,
+        });
+        await daemonRestart();
+        expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon before restart'));
+        expect(process.exitCode).toBe(1);
+    });
+});

package/dist/src/completion-shared.js

@@ -15,8 +15,7 @@ export const BUILTIN_COMMANDS = [
     'tab',
     'doctor',
     'plugin',
-    'install',
-    'register',
+    'external',
     'completion',
 ];
 // ── Shell script generators ────────────────────────────────────────────────

package/dist/src/completion.test.js

@@ -12,8 +12,9 @@ describe('getCompletions', () => {
     it('includes top-level built-ins that are registered outside the site registry', () => {
         const completions = getCompletions([], 1);
         expect(completions).toContain('plugin');
-        expect(completions).toContain('install');
-        expect(completions).toContain('register');
+        expect(completions).toContain('external');
+        expect(completions).not.toContain('install');
+        expect(completions).not.toContain('register');
         expect(completions).not.toContain('setup');
     });
     it('still includes discovered site names', () => {

package/dist/src/daemon.js

@@ -25,19 +25,96 @@ import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { EXIT_CODES } from './errors.js';
 import { log } from './logger.js';
 import { PKG_VERSION } from './version.js';
+import { DEFAULT_CONTEXT_ID } from './browser/profile.js';
+import { recordExtensionVersion } from './update-check.js';
 const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
-// ─── State ───────────────────────────────────────────────────────────
-let extensionWs = null;
-let extensionVersion = null;
-let extensionCompatRange = null;
+const extensionProfiles = new Map();
 const pending = new Map();
 const LOG_BUFFER_SIZE = 200;
 const logBuffer = [];
+class DaemonCommandFailure extends Error {
+    errorCode;
+    errorHint;
+    status;
+    constructor(message, errorCode, errorHint, status = 400) {
+        super(message);
+        this.errorCode = errorCode;
+        this.errorHint = errorHint;
+        this.status = status;
+        this.name = 'DaemonCommandFailure';
+    }
+}
 function pushLog(entry) {
     logBuffer.push(entry);
     if (logBuffer.length > LOG_BUFFER_SIZE)
         logBuffer.shift();
 }
+function activeProfiles() {
+    return [...extensionProfiles.values()].filter((entry) => entry.ws.readyState === WebSocket.OPEN);
+}
+function resolveExtensionConnection(contextId) {
+    const requestedContextId = typeof contextId === 'string' && contextId.trim() ? contextId.trim() : undefined;
+    if (requestedContextId) {
+        const connection = extensionProfiles.get(requestedContextId);
+        if (connection?.ws.readyState === WebSocket.OPEN)
+            return { connection };
+        return {
+            errorCode: 'profile_disconnected',
+            error: `Browser profile "${requestedContextId}" is not connected.`,
+            errorHint: 'Open that Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.',
+        };
+    }
+    const connected = activeProfiles();
+    if (connected.length === 1)
+        return { connection: connected[0] };
+    if (connected.length > 1) {
+        return {
+            errorCode: 'profile_required',
+            error: 'Multiple Browser Bridge profiles are connected; choose one with --profile.',
+            errorHint: 'Run opencli profile list, then use opencli --profile <name> ... or opencli profile use <name>.',
+        };
+    }
+    return {
+        errorCode: 'extension_not_connected',
+        error: 'Extension not connected. Please install the opencli Browser Bridge extension.',
+    };
+}
+function registerExtensionConnection(ws, rawContextId) {
+    const contextId = typeof rawContextId === 'string' && rawContextId.trim()
+        ? rawContextId.trim()
+        : DEFAULT_CONTEXT_ID;
+    const previous = extensionProfiles.get(contextId);
+    if (previous && previous.ws !== ws) {
+        previous.ws.close();
+    }
+    const existing = [...extensionProfiles.entries()].find(([, entry]) => entry.ws === ws);
+    if (existing && existing[0] !== contextId)
+        extensionProfiles.delete(existing[0]);
+    const current = extensionProfiles.get(contextId);
+    const connection = {
+        contextId,
+        ws,
+        extensionVersion: current?.ws === ws ? current.extensionVersion : null,
+        extensionCompatRange: current?.ws === ws ? current.extensionCompatRange : null,
+        lastSeenAt: Date.now(),
+    };
+    extensionProfiles.set(contextId, connection);
+    return connection;
+}
+function unregisterExtensionConnection(ws) {
+    for (const [contextId, connection] of extensionProfiles.entries()) {
+        if (connection.ws !== ws)
+            continue;
+        extensionProfiles.delete(contextId);
+        for (const [id, p] of pending) {
+            if (p.contextId !== contextId)
+                continue;
+            clearTimeout(p.timer);
+            p.reject(new DaemonCommandFailure(`Browser profile "${contextId}" disconnected`, 'profile_disconnected', 'Open that Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.', 503));
+            pending.delete(id);
+        }
+    }
+}
 // ─── HTTP Server ─────────────────────────────────────────────────────
 const MAX_BODY = 1024 * 1024; // 1 MB — commands are tiny; this prevents OOM
 function readBody(req) {
@@ -118,14 +195,29 @@ async function handleRequest(req, res) {
     if (req.method === 'GET' && pathname === '/status') {
         const uptime = process.uptime();
         const mem = process.memoryUsage();
+        const params = new URL(url, `http://localhost:${PORT}`).searchParams;
+        const requestedContextId = params.get('contextId')?.trim() || undefined;
+        const route = resolveExtensionConnection(requestedContextId);
+        const profiles = activeProfiles().map((profile) => ({
+            contextId: profile.contextId,
+            extensionConnected: true,
+            extensionVersion: profile.extensionVersion ?? undefined,
+            extensionCompatRange: profile.extensionCompatRange ?? undefined,
+            pending: [...pending.values()].filter((entry) => entry.contextId === profile.contextId).length,
+            lastSeenAt: profile.lastSeenAt,
+        }));
         jsonResponse(res, 200, {
             ok: true,
             pid: process.pid,
             uptime,
             daemonVersion: PKG_VERSION,
-            extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
-            extensionVersion,
-            extensionCompatRange,
+            extensionConnected: !!route.connection,
+            extensionVersion: route.connection?.extensionVersion ?? undefined,
+            extensionCompatRange: route.connection?.extensionCompatRange ?? undefined,
+            contextId: route.connection?.contextId ?? requestedContextId,
+            profileRequired: route.errorCode === 'profile_required',
+            profileDisconnected: route.errorCode === 'profile_disconnected',
+            profiles,
             pending: pending.size,
             memoryMB: Math.round(mem.rss / 1024 / 1024 * 10) / 10,
             port: PORT,
@@ -158,8 +250,15 @@ async function handleRequest(req, res) {
                 jsonResponse(res, 400, { ok: false, error: 'Missing command id' });
                 return;
             }
-            if (!extensionWs || extensionWs.readyState !== WebSocket.OPEN) {
-                jsonResponse(res, 503, { id: body.id, ok: false, error: 'Extension not connected. Please install the opencli Browser Bridge extension.' });
+            const route = resolveExtensionConnection(typeof body.contextId === 'string' ? body.contextId : undefined);
+            if (!route.connection) {
+                jsonResponse(res, route.errorCode === 'profile_required' ? 409 : 503, {
+                    id: body.id,
+                    ok: false,
+                    errorCode: route.errorCode,
+                    error: route.error,
+                    ...(route.errorHint ? { errorHint: route.errorHint } : {}),
+                });
                 return;
             }
             const timeoutMs = typeof body.timeout === 'number' && body.timeout > 0
@@ -178,15 +277,18 @@ async function handleRequest(req, res) {
                     pending.delete(body.id);
                     reject(new Error(`Command timeout (${timeoutMs / 1000}s)`));
                 }, timeoutMs);
-                pending.set(body.id, { resolve, reject, timer });
-                extensionWs.send(JSON.stringify(body));
+                pending.set(body.id, { contextId: route.connection.contextId, resolve, reject, timer });
+                route.connection.ws.send(JSON.stringify(body));
             });
             jsonResponse(res, 200, result);
         }
         catch (err) {
-            jsonResponse(res, err instanceof Error && err.message.includes('timeout') ? 408 : 400, {
+            const commandFailure = err instanceof DaemonCommandFailure ? err : null;
+            jsonResponse(res, commandFailure?.status ?? (err instanceof Error && err.message.includes('timeout') ? 408 : 400), {
                 ok: false,
                 error: err instanceof Error ? err.message : 'Invalid request',
+                ...(commandFailure?.errorCode ? { errorCode: commandFailure.errorCode } : {}),
+                ...(commandFailure?.errorHint ? { errorHint: commandFailure.errorHint } : {}),
             });
         }
         return;
@@ -209,9 +311,6 @@ const wss = new WebSocketServer({
 });
 wss.on('connection', (ws) => {
     log.info('[daemon] Extension connected');
-    extensionWs = ws;
-    extensionVersion = null; // cleared until hello message arrives
-    extensionCompatRange = null;
     // ── Heartbeat: ping every 15s, close if 2 pongs missed ──
     let missedPongs = 0;
     const heartbeatInterval = setInterval(() => {
@@ -236,8 +335,13 @@ wss.on('connection', (ws) => {
             const msg = JSON.parse(data.toString());
             // Handle hello message from extension (version handshake)
             if (msg.type === 'hello') {
-                extensionVersion = typeof msg.version === 'string' ? msg.version : null;
-                extensionCompatRange = typeof msg.compatRange === 'string' ? msg.compatRange : null;
+                const connection = registerExtensionConnection(ws, msg.contextId);
+                connection.extensionVersion = typeof msg.version === 'string' ? msg.version : null;
+                connection.extensionCompatRange = typeof msg.compatRange === 'string' ? msg.compatRange : null;
+                connection.lastSeenAt = Date.now();
+                if (connection.extensionVersion)
+                    recordExtensionVersion(connection.extensionVersion);
+                log.info(`[daemon] Extension profile connected: ${connection.contextId}`);
                 return;
             }
             // Handle log messages from extension
@@ -266,31 +370,11 @@ wss.on('connection', (ws) => {
     ws.on('close', () => {
         log.info('[daemon] Extension disconnected');
         clearInterval(heartbeatInterval);
-        if (extensionWs === ws) {
-            extensionWs = null;
-            extensionVersion = null;
-            extensionCompatRange = null;
-            // Reject all pending requests since the extension is gone
-            for (const [id, p] of pending) {
-                clearTimeout(p.timer);
-                p.reject(new Error('Extension disconnected'));
-            }
-            pending.clear();
-        }
+        unregisterExtensionConnection(ws);
     });
     ws.on('error', () => {
         clearInterval(heartbeatInterval);
-        if (extensionWs === ws) {
-            extensionWs = null;
-            extensionVersion = null;
-            extensionCompatRange = null;
-            // Reject pending requests in case 'close' does not follow this 'error'
-            for (const [, p] of pending) {
-                clearTimeout(p.timer);
-                p.reject(new Error('Extension disconnected'));
-            }
-            pending.clear();
-        }
+        unregisterExtensionConnection(ws);
     });
 });
 // ─── Start ───────────────────────────────────────────────────────────
@@ -313,8 +397,8 @@ function shutdown() {
         p.reject(new Error('Daemon shutting down'));
     }
     pending.clear();
-    if (extensionWs)
-        extensionWs.close();
+    for (const profile of extensionProfiles.values())
+        profile.ws.close();
     httpServer.close();
     process.exit(EXIT_CODES.SUCCESS);
 }

package/dist/src/doctor.d.ts

@@ -3,6 +3,8 @@
  *
  * Simplified for the daemon-based architecture.
  */
+import type { BrowserSessionInfo } from './types.js';
+import type { BrowserProfileStatus } from './browser/daemon-client.js';
 export type DoctorOptions = {
     yes?: boolean;
     live?: boolean;
@@ -18,18 +20,15 @@ export type DoctorReport = {
     cliVersion?: string;
     daemonRunning: boolean;
     daemonFlaky?: boolean;
+    daemonStale?: boolean;
     daemonVersion?: string;
     extensionConnected: boolean;
     extensionFlaky?: boolean;
     extensionVersion?: string;
     latestExtensionVersion?: string;
     connectivity?: ConnectivityResult;
-    sessions?: Array<{
-        workspace: string;
-        windowId: number;
-        tabCount: number;
-        idleMsRemaining: number;
-    }>;
+    sessions?: BrowserSessionInfo[];
+    profiles?: BrowserProfileStatus[];
     issues: string[];
 };
 /**

package/dist/src/doctor.js

@@ -10,6 +10,8 @@ import { getDaemonHealth, listSessions } from './browser/daemon-client.js';
 import { getErrorMessage } from './errors.js';
 import { getRuntimeLabel } from './runtime-detect.js';
 import { getCachedLatestExtensionVersion } from './update-check.js';
+import { aliasForContextId, loadProfileConfig } from './browser/profile.js';
+import { formatDaemonVersion, isDaemonStale, staleDaemonIssue } from './browser/daemon-version.js';
 const DOCTOR_LIVE_TIMEOUT_SECONDS = 8;
 /** Parse a semver string into [major, minor, patch]. Returns null on invalid input. */
 function parseSemver(v) {
@@ -48,9 +50,14 @@ export async function checkConnectivity(opts) {
     try {
         const bridge = new BrowserBridge();
         const page = await bridge.connect({ timeout: opts?.timeout ?? DOCTOR_LIVE_TIMEOUT_SECONDS });
-        // Try a simple eval to verify end-to-end connectivity
-        await page.evaluate('1 + 1');
-        await bridge.close();
+        try {
+            // Try a simple eval to verify end-to-end connectivity.
+            await page.evaluate('1 + 1');
+            await page.closeWindow?.();
+        }
+        finally {
+            await bridge.close();
+        }
         return { ok: true, durationMs: Date.now() - start };
     }
     catch (err) {
@@ -84,9 +91,21 @@ export async function runBrowserDoctor(opts = {}) {
     const extensionConnected = health.state === 'ready';
     const daemonFlaky = !!(connectivity?.ok && !daemonRunning);
     const extensionFlaky = !!(connectivity?.ok && daemonRunning && !extensionConnected);
-    const sessions = opts.sessions && health.state === 'ready'
-        ? await listSessions()
-        : undefined;
+    const daemonStale = isDaemonStale(health.status, opts.cliVersion);
+    const profiles = health.status?.profiles;
+    let sessions;
+    if (opts.sessions) {
+        if (profiles && profiles.length > 0) {
+            const grouped = await Promise.all(profiles.map(async (profile) => {
+                const rows = await listSessions({ contextId: profile.contextId }).catch(() => []);
+                return rows.map((row) => ({ ...row, contextId: row.contextId ?? profile.contextId }));
+            }));
+            sessions = grouped.flat();
+        }
+        else if (health.state === 'ready') {
+            sessions = await listSessions();
+        }
+    }
     const extensionVersion = health.status?.extensionVersion;
     const issues = [];
     if (daemonFlaky) {
@@ -96,24 +115,25 @@ export async function runBrowserDoctor(opts = {}) {
     else if (!daemonRunning) {
         issues.push('Daemon is not running. It should start automatically when you run an opencli browser command.');
     }
+    if (daemonStale && opts.cliVersion) {
+        issues.push(staleDaemonIssue(health.status, opts.cliVersion));
+    }
     if (extensionFlaky) {
         issues.push('Extension connection is unstable. The live browser test succeeded, but the daemon reported the extension disconnected immediately afterward.\n' +
             'This usually means the Browser Bridge service worker is reconnecting slowly or Chrome suspended it.');
     }
     else if (daemonRunning && !extensionConnected) {
-        const daemonVersion = health.status?.daemonVersion;
-        const isStale = opts.cliVersion && (!daemonVersion || daemonVersion !== opts.cliVersion);
-        if (isStale) {
-            const reason = daemonVersion
-                ? `daemon v${daemonVersion} ≠ CLI v${opts.cliVersion}`
-                : `daemon predates version reporting, CLI is v${opts.cliVersion}`;
-            issues.push(`Stale daemon detected: ${reason}.\n` +
-                'The daemon was started by an older CLI version and may have missed the extension registration.\n' +
-                '  Quick fix: opencli daemon stop && opencli doctor');
+        if (health.state === 'profile-required') {
+            issues.push('Multiple Chrome profiles are connected to the daemon, but no default profile was selected.\n' +
+                '  Run opencli profile list, then opencli profile use <name>, or pass --profile <name>.');
+        }
+        else if (health.state === 'profile-disconnected') {
+            issues.push(`Selected browser profile is not connected: ${health.status?.contextId ?? 'unknown'}.\n` +
+                '  Open that Chrome profile and make sure the OpenCLI extension is enabled.');
         }
         else {
             issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
-                'If the extension is already installed, try: opencli daemon stop && opencli doctor\n' +
+                'If the extension is already installed, try: opencli daemon restart\n' +
                 'If the extension is not installed:\n' +
                 '  1. Download from https://github.com/jackwener/opencli/releases\n' +
                 '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
@@ -155,6 +175,7 @@ export async function runBrowserDoctor(opts = {}) {
         cliVersion: opts.cliVersion,
         daemonRunning,
         daemonFlaky,
+        daemonStale,
         daemonVersion: health.status?.daemonVersion,
         extensionConnected,
         extensionFlaky,
@@ -162,6 +183,7 @@ export async function runBrowserDoctor(opts = {}) {
         latestExtensionVersion,
         connectivity,
         sessions,
+        profiles,
         issues,
     };
 }
@@ -170,10 +192,16 @@ export function renderBrowserDoctorReport(report) {
     // Daemon status
     const daemonIcon = report.daemonFlaky
         ? styleText('yellow', '[WARN]')
-        : report.daemonRunning ? styleText('green', '[OK]') : styleText('red', '[MISSING]');
+        : report.daemonStale
+            ? styleText('yellow', '[WARN]')
+            : report.daemonRunning ? styleText('green', '[OK]') : styleText('red', '[MISSING]');
     const daemonLabel = report.daemonFlaky
         ? 'unstable (running during live check, then stopped)'
-        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` + (report.daemonVersion ? ` (v${report.daemonVersion})` : '') : 'not running';
+        : report.daemonRunning
+            ? `running on port ${DEFAULT_DAEMON_PORT} (${report.daemonStale
+                ? `${formatDaemonVersion(report)}, stale; CLI v${report.cliVersion ?? 'unknown'}`
+                : formatDaemonVersion(report)})`
+            : 'not running';
     lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
     // Extension status
     const extIcon = report.extensionFlaky || (report.extensionConnected && !report.extensionVersion)
@@ -191,6 +219,17 @@ export function renderBrowserDoctorReport(report) {
         ? 'unstable (connected during live check, then disconnected)'
         : report.extensionConnected ? 'connected' : 'not connected';
     lines.push(`${extIcon} Extension: ${extLabel}${extVersion}`);
+    if (report.profiles && report.profiles.length > 0) {
+        const config = loadProfileConfig();
+        lines.push('', styleText('bold', 'Profiles:'));
+        for (const profile of report.profiles) {
+            const alias = aliasForContextId(config, profile.contextId);
+            const aliasText = alias ? ` (${alias})` : '';
+            const defaultText = config.defaultContextId === profile.contextId ? ', default' : '';
+            const version = profile.extensionVersion ? `v${profile.extensionVersion}` : 'version unknown';
+            lines.push(styleText('dim', `  • ${profile.contextId}${aliasText}: connected ${version}${defaultText}`));
+        }
+    }
     // Connectivity
     if (report.connectivity) {
         const connIcon = report.connectivity.ok ? styleText('green', '[OK]') : styleText('red', '[FAIL]');
@@ -208,8 +247,27 @@ export function renderBrowserDoctorReport(report) {
             lines.push(styleText('dim', '  • no active automation sessions'));
         }
         else {
+            const byContext = new Map();
             for (const session of report.sessions) {
-                lines.push(styleText('dim', `  • ${session.workspace} → window ${session.windowId}, tabs=${session.tabCount}, idle=${Math.ceil(session.idleMsRemaining / 1000)}s`));
+                const contextId = typeof session.contextId === 'string' && session.contextId ? session.contextId : 'default';
+                const rows = byContext.get(contextId) ?? [];
+                rows.push(session);
+                byContext.set(contextId, rows);
+            }
+            for (const [contextId, rows] of byContext) {
+                if (byContext.size > 1)
+                    lines.push(styleText('dim', `  [profile: ${contextId}]`));
+                for (const session of rows) {
+                    const idle = session.idleMsRemaining == null
+                        ? 'none'
+                        : `${Math.ceil(session.idleMsRemaining / 1000)}s`;
+                    const target = session.preferredTabId != null
+                        ? `tab ${session.preferredTabId}`
+                        : `window ${session.windowId ?? 'unknown'}`;
+                    const mode = session.ownership ?? (session.owned === false ? 'borrowed' : 'owned');
+                    const surface = session.surface ? `, surface=${session.surface}` : '';
+                    lines.push(styleText('dim', `  • ${session.workspace ?? 'default'} → ${target}, mode=${mode}${surface}, tabs=${session.tabCount ?? 0}, idle=${idle}`));
+                }
             }
         }
     }