manager.ts

import * as vscode from 'vscode';
import * as fs from 'fs';
import * as path from 'path';
import { randomUUID } from 'crypto';
import { AgentClient } from './client';
import {
    AgentConfig,
    AgentSnapshot,
    DEFAULT_MAX_ASSET_BYTES,
    ExecutionRecord,
    SessionEvent,
    SessionManifest,
    SourceLocation,
    object,
    sessionLabel,
} from './protocol';
import { AssetStore, AssetStorageStats, exportedAssetName, readAsset } from './assets';
import {
    NotebookOutputState,
    prepareNotebookStream,
    updateNotebookOutputs,
} from './notebookOutput';
import { ExecutionCellIndex } from './cellIndex';
import type { StreamSnapshot, StreamText } from './streamText';
import { OutputQueue } from './outputQueue';
import {
    defaultStorage,
    discoverSessions,
    hasSessionEndpoint,
    launchAgent,
    newIdentity,
    prepareNodeRuntime,
} from './launcher';
import { NodeRuntime, resolveNodeRuntime } from './nodeExecutable';
import { backendDescriptor, prepareBackendRuntime } from './backendRegistry';
import { discoverArf, probeArfSession, ArfSession } from './arf';
import { resolveArfExecutable } from './arfExecutable';
import { prepareSupervisor } from './supervisor';
import { Transcript, TranscriptCell } from './transcript';
import {
    DISPLAY_MIME,
    InteractiveSerializer,
    persistentCellMetadata,
    persistentNotebookMetadata,
    restoredCellMetadata,
} from './notebook';
import { setInteractiveExecutor } from './executionTarget';
import * as session from '../session';
import * as util from '../util';
import type { ListViewNavigation } from '../listViewer';
import { escapeXml } from './plotSvg';
import { ensureWorkspaceViewer } from '../extension';
import { queryTablePage } from './tableQuery';
import { tableColumnAlignment, tableDisplayValue, tableSnapshotSummary } from './tableFormatting';
import { HistoryPage, searchHistory } from './history';
import { readExecutionRecordsAsync, readPreviousJournalAsync } from './journal';
import { sessionAge, sessionPresentation } from './sessionPresentation';
import { runningSessions, stopSession } from './sessionLifecycle';
import { InteractiveInputFeatures } from './inputFeatures';

interface InteractiveView {
    client: AgentClient;
    target: session.Session;
    model: Transcript;
    history: Transcript[];
    notebook: vscode.NotebookDocument;
    controller: vscode.NotebookController;
    controllers: vscode.NotebookController[];
    inputUri?: vscode.Uri;
    executions: Map<
        string,
        { task: vscode.NotebookCellExecution; started: boolean; startTime?: number }
    >;
    chain: Promise<void>;
    outputQueue: OutputQueue;
    outputState?: NotebookOutputState;
    cellIndex?: ExecutionCellIndex<vscode.NotebookCell>;
    reconnectTimer?: NodeJS.Timeout;
    disposed: boolean;
    prompts: Set<number>;
    base: string;
    hidden: Set<string>;
    restarting?: boolean;
}

interface SessionChoice extends vscode.QuickPickItem {
    manifest?: SessionManifest;
    arf?: ArfSession;
    create?: boolean;
    terminal?: boolean;
}
interface SavedConnection {
    id: string;
    notebookUri?: string;
}

export class InteractiveManager
    implements vscode.Disposable, vscode.TreeDataProvider<SessionManifest>
{
    private views = new Map<string, InteractiveView>();
    private opening = new Map<string, Promise<void>>();
    private presentationRefresh = new Set<InteractiveView>();
    private active?: InteractiveView;
    private routing = false;
    private targetSelection?: Promise<InteractiveView | 'createTerminal' | undefined>;
    private manifests: SessionManifest[] = [];
    private changes = new vscode.EventEmitter<SessionManifest | undefined>();
    readonly onDidChangeTreeData = this.changes.event;
    private disposables: vscode.Disposable[] = [];
    private output = vscode.window.createOutputChannel('R Interactive');
    private messages = vscode.notebooks.createRendererMessaging('r-interactive-renderer');
    private serializer = new InteractiveSerializer();
    private root: string;
    private closed = false;
    private clientId: string;
    private savedConnections: Map<string, SavedConnection>;
    private outputViews: Map<
        string,
        { tableView?: string; listView?: string; selectedPlot?: string }
    >;
    private executionTimings: Map<string, { startTime: number; endTime: number }>;
    private timingWrites: OutputQueue;
    // Display events replace their data object. Weak keys release superseded
    // snapshots, while console/status updates can reuse encoded plot assets.
    private renderedPlots = new WeakMap<
        Record<string, unknown>,
        {
            context: string;
            output: vscode.NotebookCellOutput;
            data: Record<string, unknown>;
        }
    >();
    private status = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 20);

    constructor(private context: vscode.ExtensionContext) {
        // A restart replaces the transcript, invalidating pending formatting edits.
        this.disposables.push(
            new InteractiveInputFeatures(
                (editor) =>
                    [...this.views.values()].find(
                        (view) =>
                            !view.disposed &&
                            view.inputUri?.toString() === editor.document.uri.toString(),
                    )?.model,
            ),
        );
        this.root = util.config().get<string>('interactive.storagePath') || defaultStorage();
        this.clientId = randomUUID();
        // Native Interactive tabs restore their URI, but discard notebook metadata.
        // Keep that association outside the notebook, including while R is unreachable.
        const saved =
            context.workspaceState.get<SavedConnection[]>('r.interactive.connections') ??
            context.workspaceState
                .get<string[]>('r.interactive.sessions', [])
                .map((id) => ({ id }));
        this.savedConnections = new Map(saved.map((connection) => [connection.id, connection]));
        this.outputViews = new Map(context.workspaceState.get('r.interactive.outputViews', []));
        this.executionTimings = new Map(
            context.workspaceState.get('r.interactive.executionTimings', []),
        );
        this.timingWrites = new OutputQueue(
            async () => {
                // Snapshot when the write starts, coalescing completions that
                // arrived while the preceding storage update was in flight.
                await context.workspaceState.update('r.interactive.executionTimings', [
                    ...this.executionTimings,
                ]);
            },
            (error) => {
                if (this.closed) {
                    console.error('R Interactive: could not save execution timings', error);
                } else {
                    this.report(error);
                }
            },
        );
        const command = (name: string, handler: (...args: unknown[]) => unknown): void => {
            this.disposables.push(
                vscode.commands.registerCommand(name, (...args: unknown[]) =>
                    Promise.resolve()
                        .then(() => handler(...args))
                        .catch((error: unknown) => this.report(error)),
                ),
            );
        };
        command('r.interactive.new', async () => {
            const view = await this.create();
            if (view) {
                if (view.inputUri) {
                    // Reuse the native editor created beside the previous input.
                    // showNotebookDocument would open a second tab in the old group.
                    await vscode.commands.executeCommand(
                        'interactive.open',
                        { preserveFocus: false },
                        view.notebook.uri,
                    );
                    await vscode.commands.executeCommand('interactive.input.focus');
                } else {
                    const editor = vscode.window.visibleNotebookEditors.find(
                        (item) => item.notebook === view.notebook,
                    );
                    await vscode.window.showNotebookDocument(view.notebook, {
                        preserveFocus: false,
                        viewColumn: editor?.viewColumn,
                    });
                }
            }
        });
        command('r.interactive.connect', () => this.pick());
        command('r.interactive.open', (value) =>
            value ? this.open(value as SessionManifest) : this.pick(),
        );
        command('r.interactive.refresh', () => this.refresh());
        command('r.interactive.interrupt', (value) =>
            this.forView(value, (view) => view.client.request('interrupt')),
        );
        command('r.interactive.input', (value) =>
            this.forView(value, (view) => this.resumeInput(view)),
        );
        command('r.interactive.detach', (value) =>
            this.forView(value, (view) => this.detach(view)),
        );
        command('r.interactive.stop', (value) => this.forView(value, (view) => this.stop(view)));
        command('r.interactive.stopSelected', (value, selection) =>
            this.stopMultiple(false, value, selection),
        );
        command('r.interactive.stopAll', () => this.stopMultiple(true));
        command('r.interactive.restart', (value) =>
            this.forView(value, (view) => this.restart(view)),
        );
        command('r.interactive.sessionActions', (value) =>
            this.forView(value, (view) => this.sessionActions(view)),
        );
        command('r.interactive.takeControl', (value) =>
            this.forView(value, async (view) => {
                view.client.control = await view.client.request<boolean>('claim', { force: true });
                this.updateStatus();
                this.changes.fire(undefined);
            }),
        );
        command('r.interactive.rename', (value, label) =>
            this.forView(value, (view) =>
                this.rename(view, typeof label === 'string' ? label : undefined),
            ),
        );
        command('r.interactive.history', (value) =>
            this.forView(value, (view) => this.history(view)),
        );
        command('r.interactive.plots', (value) => this.forView(value, (view) => this.plots(view)));
        command('r.interactive.cancelQueued', (value) =>
            this.forView(value, (view) => this.cancelQueued(view)),
        );
        command('r.interactive.reuseCell', (value) =>
            this.forView(value, async (view) => {
                const cell = value as vscode.NotebookCell;
                // Native Interactive toolbars do not expose notebookCellType, so
                // their actions also appear on lifecycle notices.
                if (cell.kind !== vscode.NotebookCellKind.Code) {
                    void vscode.window.showInformationMessage(
                        'Select an R code cell to insert into the Interactive input.',
                    );
                    return;
                }
                await this.insertCode(view, cell.document.getText());
            }),
        );
        command('r.interactive.copyCell', (value) =>
            vscode.env.clipboard.writeText((value as vscode.NotebookCell).document.getText()),
        );
        command('r.interactive.source', (value) => {
            const cell = value as vscode.NotebookCell;
            if (cell.kind !== vscode.NotebookCellKind.Code) {
                void vscode.window.showInformationMessage(
                    'Session notices have no source location.',
                );
                return;
            }
            return this.source(cell.metadata.rSource as SourceLocation | undefined);
        });
        command('r.interactive.info', (value) =>
            this.forView(value, (view) => {
                this.output.appendLine(
                    sessionPresentation(
                        view.client.manifest,
                        view.client.connected,
                        view.client.control,
                        view.restarting,
                        view.target.workingDir,
                    ).tooltip,
                );
                this.output.show(true);
            }),
        );
        command('r.interactive.useTerminal', () => {
            this.routing = false;
        });
        command('r.interactive.bindDocument', () => {
            const document = vscode.window.activeTextEditor?.document;
            if (document && this.active) {
                session.bindSessionDocument(document.uri, this.active.target);
            }
        });
        command('r.interactive.export', (value) =>
            this.forView(value, (view) => this.exportHistory(view)),
        );
        command('r.interactive.clear', (value) =>
            this.forView(value, (view) => this.clearCompleted(view)),
        );
        command('r.interactive.cleanAssets', (value) =>
            this.forView(value, async (view) => {
                if (!view.client.manifest.capabilities.assetStorage) {
                    throw new Error(
                        'Asset cleanup requires a session started with the current extension build',
                    );
                }
                const stats = await view.client.request<AssetStorageStats>('assetStorage', {
                    compact: true,
                });
                void vscode.window.showInformationMessage(
                    `R Interactive: reclaimed ${(stats.reclaimedBytes / 1024 / 1024).toFixed(1)} MiB. Retained assets use ${(stats.usedBytes / 1024 / 1024).toFixed(1)} MiB of ${(stats.limitBytes / 1024 / 1024 / 1024).toFixed(2)} GiB.`,
                );
            }),
        );
        this.status.name = 'R Interactive session';
        this.status.command = 'r.interactive.connect';
        this.disposables.push(this.status);
        const ageTimer = setInterval(() => {
            this.changes.fire(undefined);
            this.updateStatus();
        }, 60000);
        ageTimer.unref();
        this.disposables.push({ dispose: () => clearInterval(ageTimer) });
        this.disposables.push(
            vscode.window.createTreeView('rInteractiveSessions', {
                treeDataProvider: this,
                canSelectMany: true,
            }),
            vscode.workspace.registerNotebookSerializer('r-interactive', this.serializer, {
                transientOutputs: false,
            }),
            this.messages.onDidReceiveMessage((event) => {
                void this.rendererMessage(event.editor, event.message as Record<string, unknown>);
            }),
            vscode.window.onDidChangeActiveNotebookEditor((editor) => {
                const view = [...this.views.values()].find(
                    (item) => item.notebook === editor?.notebook,
                );
                void vscode.commands.executeCommand('setContext', 'r.interactive.notebook', !!view);
                if (view) {
                    void this.activate(view);
                }
            }),
            vscode.window.onDidChangeActiveTextEditor((editor) => {
                const target = editor && session.boundSessionForDocument(editor.document.uri);
                const view =
                    target && [...this.views.values()].find((item) => item.target === target);
                if (view) {
                    void this.activate(view);
                } else {
                    this.updateStatus();
                }
            }),
            vscode.workspace.onDidCloseNotebookDocument((document) => {
                const view = [...this.views.values()].find((item) => item.notebook === document);
                if (view) {
                    this.disposeView(view);
                }
            }),
            vscode.workspace.onDidChangeNotebookDocument((event) => {
                if (
                    event.contentChanges.length ||
                    event.cellChanges.some((change) => change.metadata !== undefined)
                ) {
                    for (const view of this.views.values()) {
                        if (view.notebook === event.notebook) {
                            view.cellIndex?.invalidate();
                            for (const change of event.contentChanges) {
                                for (const cell of change.removedCells) {
                                    const id = cell.metadata.rExecutionId as string | undefined;
                                    const generation = cell.metadata.rGeneration as
                                        | string
                                        | undefined;
                                    const model = generation
                                        ? [view.model, ...view.history].find(
                                              (model) => model.generation === generation,
                                          )
                                        : view.model;
                                    for (const output of (id && model?.cells.get(id)?.outputs) ||
                                        []) {
                                        if (output.stream) {
                                            view.outputState?.forget(output.stream);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }),
            vscode.workspace.onDidChangeConfiguration((event) => {
                if (event.affectsConfiguration('r.interactive.tableView')) {
                    for (const view of this.views.values()) {
                        view.chain = view.chain
                            .then(() => {
                                for (const cell of this.transcriptCells(view)) {
                                    if (
                                        cell.outputs.some((output) => output.data.kind === 'table')
                                    ) {
                                        view.outputQueue.schedule(cell.record.id);
                                    }
                                }
                            })
                            .catch((error) => this.report(error));
                    }
                }
                if (!event.affectsConfiguration('r.interactive.maxAssetSizeMiB')) {
                    return;
                }
                const limitBytes = this.retentionLimits().maxAssetBytes;
                for (const view of this.views.values()) {
                    if (
                        view.client.connected &&
                        view.client.control &&
                        view.client.manifest.capabilities.assetStorage
                    ) {
                        void view.client
                            .request('assetStorage', { limitBytes })
                            .catch((error) => this.report(error));
                    }
                }
            }),
        );
        setInteractiveExecutor(async (code, resource, source, offerTarget) => {
            const mode = util.config(resource).get<string>('interactive.executionTarget', 'auto');
            if (mode === 'terminal' || (!this.routing && mode !== 'interactive' && !offerTarget)) {
                return false;
            }
            try {
                const bound = resource && session.boundSessionForDocument(resource);
                let view =
                    this.routing || mode === 'interactive'
                        ? bound
                            ? [...this.views.values()].find((item) => item.target === bound)
                            : this.active
                        : undefined;
                if (view?.restarting) {
                    throw new Error(
                        'R is restarting. Wait for the restart notice before running code.',
                    );
                }
                if (
                    !view ||
                    view.disposed ||
                    !view.client.connected ||
                    ['exited', 'stopping'].includes(view.client.manifest.status)
                ) {
                    // Share one chooser when several Run Selection commands arrive during startup.
                    const pending = (this.targetSelection ??= this.chooseExecutionTarget(resource));
                    let chosen: Awaited<typeof pending>;
                    try {
                        chosen = await pending;
                    } finally {
                        if (this.targetSelection === pending) {
                            this.targetSelection = undefined;
                        }
                    }
                    if (!chosen) {
                        return 'cancelled';
                    }
                    if (chosen === 'createTerminal') {
                        this.routing = false;
                        return chosen;
                    }
                    view = chosen;
                    if (bound && resource) {
                        session.bindSessionDocument(resource, view.target);
                    }
                }
                await this.submit(view, code, source);
                return 'executed';
            } catch (error) {
                this.report(error);
                return 'cancelled';
            }
        });
        this.refresh();
        if (util.config().get<boolean>('interactive.restore', true)) {
            void this.restoreConnections();
        }
    }

    private async restoreConnections(): Promise<void> {
        for (const id of this.savedConnections.keys()) {
            if (this.closed) {
                return;
            }
            const manifest = this.manifests.find((item) => item.id === id);
            if (manifest) {
                try {
                    await this.open(manifest);
                } catch (error) {
                    if (!this.closed) {
                        this.output.appendLine(`Restore ${manifest.label}: ${String(error)}`);
                    }
                }
            }
        }
        // Restoring background tabs must not leave their workspace selected over
        // the visible Interactive input or a source file with an explicit binding.
        const document = vscode.window.activeTextEditor?.document;
        const target = document && session.boundSessionForDocument(document.uri);
        const focused = [...this.views.values()].find((view) =>
            target
                ? view.target === target
                : view.notebook === vscode.window.activeNotebookEditor?.notebook,
        );
        if (focused) {
            await this.activate(focused);
        }
    }

    private saveConnections(): Thenable<void> {
        return this.context.workspaceState.update('r.interactive.connections', [
            ...this.savedConnections.values(),
        ]);
    }

    private report(error: unknown): void {
        const message = error instanceof Error ? error.message : String(error);
        this.output.appendLine(message);
        void vscode.window.showErrorMessage(`R Interactive: ${message}`);
    }

    private async forView(
        value: unknown,
        action: (view: InteractiveView) => unknown,
    ): Promise<unknown> {
        let view = this.active;
        if (value && typeof value === 'object') {
            const target = value as Partial<SessionManifest> & {
                notebook?: vscode.NotebookDocument;
                notebookUri?: vscode.Uri;
                uri?: vscode.Uri;
                notebookEditor?: { notebookUri?: vscode.Uri };
            };
            if (typeof target.id === 'string' && typeof target.generation === 'string') {
                const key = `${target.id}:${target.generation}`;
                if (!this.views.has(key)) {
                    await this.open(target as SessionManifest);
                }
                view = this.views.get(key);
            } else {
                // Native notebook/Interactive toolbars serialize their editor under notebookEditor.
                const uri =
                    value instanceof vscode.Uri
                        ? value
                        : (target.notebookEditor?.notebookUri ??
                          target.notebook?.uri ??
                          target.notebookUri ??
                          target.uri);
                view =
                    uri &&
                    [...this.views.values()].find(
                        (item) => item.notebook.uri.toString() === uri.toString(),
                    );
            }
            if (!view) {
                throw new Error('This notebook is not connected to an R Interactive session');
            }
        }
        if (!view || view.disposed) {
            return;
        }
        return action(view);
    }

    private updateStatus(): void {
        for (const view of this.views.values()) {
            const unavailable = view.restarting
                ? 'R is restarting. The workspace will refresh when it is ready.'
                : ['exited', 'stopping'].includes(view.client.manifest.status)
                  ? 'R session stopped. Restart it to inspect a new workspace.'
                  : !view.client.connected
                    ? 'R session disconnected. Reconnecting to its workspace…'
                    : view.client.manifest.status === 'starting'
                      ? 'R is starting…'
                      : undefined;
            if (
                view.target.label !== view.client.manifest.label ||
                view.target.workspaceUnavailable !== unavailable
            ) {
                view.target.label = view.client.manifest.label;
                view.target.workspaceUnavailable = unavailable;
                session.updateSessionWorkspace(view.target, view.target.workspaceData);
            }
            const { label, description, detail } = sessionPresentation(
                view.client.manifest,
                view.client.connected,
                view.client.control,
                view.restarting,
                view.target.workingDir,
            );
            let changed = false;
            for (const controller of view.controllers) {
                if (controller.label !== label) {
                    controller.label = label;
                    changed = true;
                }
                if (controller.description !== description) {
                    controller.description = description;
                    changed = true;
                }
                if (controller.detail !== detail) {
                    controller.detail = detail;
                    changed = true;
                }
            }
            if (changed && !this.presentationRefresh.has(view)) {
                this.presentationRefresh.add(view);
                // VS Code's native toolbar/picker watches affinity, not kernel property
                // changes. Reassert the existing affinity without changing selection.
                // Property setters send a batched microtask: refresh on the next turn
                // so the workbench receives the new label/details before this event.
                setImmediate(() => {
                    this.presentationRefresh.delete(view);
                    if (!view.disposed && !view.notebook.isClosed) {
                        view.controller.updateNotebookAffinity(
                            view.notebook,
                            vscode.NotebookControllerAffinity.Preferred,
                        );
                    }
                });
            }
        }
        const document = vscode.window.activeTextEditor?.document;
        const target = document && session.boundSessionForDocument(document.uri);
        const view =
            (target && [...this.views.values()].find((item) => item.target === target)) ||
            this.active;
        if (!view || view.disposed) {
            this.status.hide();
            return;
        }
        const manifest = view.client.manifest;
        const queued = [...view.model.cells.values()].filter(
            (cell) => cell.record.state === 'queued',
        ).length;
        const state = view.restarting
            ? 'Restarting'
            : !view.client.connected
              ? 'Disconnected'
              : manifest.status === 'input'
                ? 'Waiting for input'
                : manifest.status;
        const icon = !view.client.connected
            ? 'debug-disconnect'
            : manifest.status === 'busy'
              ? 'sync~spin'
              : manifest.status === 'input'
                ? 'question'
                : 'terminal';
        this.status.text = `$(${icon}) R: ${manifest.label} · ${state}${queued ? ` · ${queued} queued` : ''}${view.client.connected && !view.client.control ? ' · observing' : ''}`;
        this.status.tooltip = `${
            sessionPresentation(
                manifest,
                view.client.connected,
                view.client.control,
                view.restarting,
                view.target.workingDir,
            ).tooltip
        }\nSelect to ${manifest.status === 'input' ? 'reply to R input' : 'switch sessions'}`;
        this.status.command =
            manifest.status === 'input'
                ? {
                      command: 'r.interactive.input',
                      title: 'Reply to R input',
                      arguments: [manifest],
                  }
                : 'r.interactive.connect';
        this.status.show();
    }

    private async rename(view: InteractiveView, supplied?: string): Promise<void> {
        if (!view.client.manifest.capabilities.rename) {
            throw new Error('Renaming requires a session started with the current extension build');
        }
        const label =
            supplied ??
            (await vscode.window.showInputBox({
                title: 'Rename R session',
                value: view.client.manifest.label,
                validateInput: (value) => {
                    try {
                        sessionLabel(value);
                        return undefined;
                    } catch (error) {
                        return String(error);
                    }
                },
            }));
        if (label === undefined) {
            return;
        }
        view.client.manifest.label = await view.client.request<string>('rename', { label });
        this.refresh();
    }

    private async sessionActions(view: InteractiveView): Promise<void> {
        const actions = [
            { label: '$(plug) Switch Session…', command: 'r.interactive.connect' },
            { label: '$(add) New Session…', command: 'r.interactive.new' },
            { label: 'Session', kind: vscode.QuickPickItemKind.Separator },
            { label: '$(edit) Rename…', command: 'r.interactive.rename' },
            { label: '$(info) Session Details', command: 'r.interactive.info' },
            { label: 'Execution', kind: vscode.QuickPickItemKind.Separator },
            { label: '$(close-all) Cancel Queued Cells', command: 'r.interactive.cancelQueued' },
            { label: '$(comment) Reply to R Input…', command: 'r.interactive.input' },
            { label: '$(key) Take Control', command: 'r.interactive.takeControl' },
            { label: 'Output', kind: vscode.QuickPickItemKind.Separator },
            { label: '$(graph) Browse Plots…', command: 'r.interactive.plots' },
            { label: '$(export) Export History…', command: 'r.interactive.export' },
            { label: '$(discard) Clean Up Assets', command: 'r.interactive.cleanAssets' },
            { label: 'Lifecycle', kind: vscode.QuickPickItemKind.Separator },
            {
                label: '$(debug-disconnect) Disconnect',
                description: 'Keep R running',
                command: 'r.interactive.detach',
            },
            {
                label: '$(debug-stop) Stop Session',
                description: 'End R and discard its in-memory objects',
                command: 'r.interactive.stop',
            },
        ];
        const selected = await vscode.window.showQuickPick(actions, {
            title: `Session: ${view.client.manifest.label}`,
            placeHolder: 'Choose a session action',
            matchOnDescription: true,
        });
        // Keep the original notebook as the target even if focus changes while the picker is open.
        if (selected?.command && !view.disposed) {
            await vscode.commands.executeCommand(selected.command, view.notebook.uri);
        }
    }

    private async cancelQueued(view: InteractiveView): Promise<void> {
        if (view.client.manifest.capabilities.cancelQueued) {
            await view.client.request('cancelQueued');
        } else {
            for (const cell of view.model.cells.values()) {
                if (cell.record.state === 'queued') {
                    await view.client.request('cancel', { id: cell.record.id });
                }
            }
        }
    }

    private async clearCompleted(view: InteractiveView): Promise<void> {
        view.chain = view.chain.then(async () => {
            if (view.disposed) {
                return;
            }
            await view.outputQueue.pause();
            try {
                const edits: vscode.NotebookEdit[] = [];
                for (const cell of view.notebook.getCells().slice().reverse()) {
                    const id = cell.metadata.rExecutionId as string | undefined;
                    const record = id && this.transcriptCell(view, id)?.record;
                    if (
                        record &&
                        !view.executions.has(record.id) &&
                        !['queued', 'running', 'unknown'].includes(record.state)
                    ) {
                        view.hidden.add(record.id);
                        const adjacent = edits.at(-1);
                        if (adjacent?.range.start === cell.index + 1) {
                            edits[edits.length - 1] = vscode.NotebookEdit.deleteCells(
                                new vscode.NotebookRange(cell.index, adjacent.range.end),
                            );
                        } else {
                            edits.push(
                                vscode.NotebookEdit.deleteCells(
                                    new vscode.NotebookRange(cell.index, cell.index + 1),
                                ),
                            );
                        }
                    }
                }
                const edit = new vscode.WorkspaceEdit();
                edit.set(view.notebook.uri, edits);
                await vscode.workspace.applyEdit(edit);
            } finally {
                view.outputQueue.resume();
            }
        });
        await view.chain;
    }

    private async insertCode(view: InteractiveView, code: string): Promise<void> {
        if (view.inputUri) {
            await vscode.commands.executeCommand(
                'interactive.open',
                { preserveFocus: false },
                view.notebook.uri,
            );
        } else {
            await vscode.window.showNotebookDocument(view.notebook, { preserveFocus: false });
        }
        const edit = new vscode.WorkspaceEdit();
        if (view.inputUri) {
            const document = await vscode.workspace.openTextDocument(view.inputUri);
            const current = document.getText();
            edit.insert(
                document.uri,
                document.positionAt(current.length),
                `${current && !current.endsWith('\n') ? '\n' : ''}${code}`,
            );
        } else {
            edit.set(view.notebook.uri, [
                vscode.NotebookEdit.insertCells(view.notebook.cellCount, [
                    new vscode.NotebookCellData(vscode.NotebookCellKind.Code, code, 'r'),
                ]),
            ]);
        }
        await vscode.workspace.applyEdit(edit);
        if (view.inputUri) {
            await vscode.commands.executeCommand('interactive.input.focus');
        }
    }

    private async source(source?: SourceLocation): Promise<void> {
        if (!source) {
            void vscode.window.showInformationMessage(
                'This code was entered directly in the Interactive window.',
            );
            return;
        }
        const document = await vscode.workspace.openTextDocument(vscode.Uri.parse(source.uri));
        const line = Math.min(source.line, document.lineCount - 1);
        await vscode.window.showTextDocument(document, {
            selection: new vscode.Range(line, 0, line, 0),
        });
    }

    private history(view: InteractiveView): void {
        type Item = vscode.QuickPickItem & { record: ExecutionRecord };
        const picker = vscode.window.createQuickPick<Item>();
        const older = {
            iconPath: new vscode.ThemeIcon('history'),
            tooltip: 'Load older matching commands',
        };
        const copy = { iconPath: new vscode.ThemeIcon('copy'), tooltip: 'Copy code' };
        const run = {
            iconPath: new vscode.ThemeIcon('play'),
            tooltip: 'Run again in this session',
        };
        const source = { iconPath: new vscode.ThemeIcon('go-to-file'), tooltip: 'Go to source' };
        picker.title = `R history: ${view.client.manifest.label}`;
        picker.placeholder = 'Search code; Enter inserts it into the input for editing';
        picker.matchOnDescription = true;
        picker.matchOnDetail = true;
        let version = 0,
            closed = false,
            timer: NodeJS.Timeout | undefined;
        const load = async (more = false, request = ++version): Promise<void> => {
            picker.busy = true;
            try {
                const before = more ? picker.items.at(-1)?.record.order : undefined;
                // Orders restart at one for each R process. Use a transcript-wide order for
                // history pagination after restart, including admission records outside replay.
                const records = async (): Promise<ExecutionRecord[]> =>
                    view.history.length
                        ? (
                              await Promise.all(
                                  [...view.history, view.model].map((model) =>
                                      readExecutionRecordsAsync(
                                          path.join(
                                              this.root,
                                              view.client.manifest.id,
                                              model.generation,
                                          ),
                                      ),
                                  ),
                              )
                          )
                              .flat()
                              .map((record, index) => ({ ...record, order: index + 1 }))
                        : this.transcriptCells(view).map((cell) => cell.record);
                const page =
                    !view.history.length &&
                    view.client.connected &&
                    view.client.manifest.capabilities.history
                        ? await view.client.request<HistoryPage>('history', {
                              query: picker.value,
                              before,
                          })
                        : searchHistory(await records(), picker.value, before);
                if (closed || request !== version) {
                    return;
                }
                const items = page.executions.map((record) => ({
                    record,
                    alwaysShow: true,
                    label: `#${record.order} ${record.code.split('\n')[0].slice(0, 100)}`,
                    description: `${record.state} · ${new Date(record.accepted).toLocaleString()}`,
                    detail: record.code.slice(0, 600),
                    buttons: record.source ? [copy, run, source] : [copy, run],
                }));
                picker.items = more ? [...picker.items, ...items] : items;
                picker.buttons = page.more ? [older] : [];
            } catch (error) {
                if (!closed && request === version) {
                    picker.placeholder = String(error);
                }
            } finally {
                if (!closed && request === version) {
                    picker.busy = false;
                }
            }
        };
        const listeners: vscode.Disposable[] = [
            picker.onDidChangeValue(() => {
                clearTimeout(timer);
                const request = ++version;
                timer = setTimeout(() => {
                    void load(false, request);
                }, 150);
            }),
            picker.onDidTriggerButton(() => {
                void load(true);
            }),
            picker.onDidAccept(() => {
                const item = picker.selectedItems[0];
                if (item) {
                    picker.hide();
                    void this.insertCode(view, item.record.code).catch((error) =>
                        this.report(error),
                    );
                }
            }),
            picker.onDidTriggerItemButton((event) => {
                const record = event.item.record;
                if (event.button === copy) {
                    void vscode.env.clipboard.writeText(record.code);
                } else {
                    picker.hide();
                    void (
                        event.button === run
                            ? this.submit(view, record.code, record.source)
                            : this.source(record.source)
                    ).catch((error) => this.report(error));
                }
            }),
            picker.onDidHide(() => {
                closed = true;
                clearTimeout(timer);
                listeners.forEach((listener) => {
                    listener.dispose();
                });
                picker.dispose();
            }),
        ];
        picker.show();
        void load();
    }

    private async plots(view: InteractiveView): Promise<void> {
        const items = this.transcriptCells(view)
            .reverse()
            .flatMap((cell) =>
                cell.outputs
                    .filter(
                        (output) =>
                            output.type === 'display' &&
                            ['plot', 'image'].includes(String(output.data.kind)),
                    )
                    .map((output, index) => ({
                        label: `#${cell.record.order} · Plot ${index + 1}`,
                        description: cell.record.code.split('\n')[0].slice(0, 120),
                        detail: new Date(cell.record.accepted).toLocaleString(),
                        data: output.data,
                    })),
            );
        if (!items.length) {
            void vscode.window.showInformationMessage(
                'This session has no plots in its restored history.',
            );
            return;
        }
        const selected = await vscode.window.showQuickPick(items, {
            title: `Plots: ${view.client.manifest.label}`,
            matchOnDescription: true,
        });
        if (selected) {
            await this.openOutput(view, selected.data);
        }
    }

    private async openOutput(view: InteractiveView, data: Record<string, unknown>): Promise<void> {
        let url =
            data.svg || data.asset
                ? view.base +
                  String(data.svg ?? data.asset)
                      .split('/')
                      .map(encodeURIComponent)
                      .join('/')
                : typeof data.url === 'string'
                  ? data.url
                  : '';
        if (/^https?:\/\/(localhost|127\.0\.0\.1)(:|\/)/.test(url)) {
            url = (await vscode.env.asExternalUri(vscode.Uri.parse(url))).toString(true);
        }
        if (data.kind === 'image' && !url) {
            url = `data:${String(data.mime)};base64,${String(data.data)}`;
        }
        const html = data.kind === 'mime' && data.mime === 'text/html';
        if (!url && !html) {
            return;
        }
        const kind = ['plot', 'image'].includes(String(data.kind)) ? 'Plot' : 'Viewer';
        const panel = vscode.window.createWebviewPanel(
            'rInteractiveOutput',
            `${kind}: ${view.client.manifest.label}`,
            vscode.ViewColumn.Beside,
            { enableScripts: true },
        );
        panel.webview.html = `<!doctype html><html><body style="margin:0">${
            ['plot', 'image'].includes(String(data.kind))
                ? `<img alt="R plot" src="${escapeXml(url)}" style="display:block;max-width:100%;height:auto;margin:auto">`
                : `<iframe sandbox="allow-scripts allow-forms allow-downloads" ${html ? `srcdoc="${escapeXml(String(data.text))}"` : `src="${escapeXml(url)}"`} style="position:fixed;inset:0;width:100%;height:100%;border:0"></iframe>`
        }</body></html>`;
    }

    private defaultExportUri(view: InteractiveView, suffix: string): vscode.Uri {
        const name =
            view.client.manifest.label
                // eslint-disable-next-line no-control-regex -- export names must exclude control characters
                .replace(/[<>:"/\\|?*\x00-\x1f]/g, '-')
                .replace(/[. ]+$/, '') || 'R';
        return vscode.Uri.file(path.join(view.target.workingDir, `${name}-${suffix}`));
    }

    refresh(): void {
        try {
            this.manifests = discoverSessions(this.root).filter(hasSessionEndpoint);
        } catch (error) {
            this.manifests = [];
            this.report(error);
        }
        const manifests = new Map(
            this.manifests.map((manifest) => [`${manifest.id}:${manifest.generation}`, manifest]),
        );
        for (const view of this.views.values()) {
            const manifest = view.client.manifest;
            manifests.set(`${manifest.id}:${manifest.generation}`, manifest);
        }
        this.manifests = [...manifests.values()];
        this.changes.fire(undefined);
        this.updateStatus();
    }
    getChildren(): SessionManifest[] {
        return this.manifests;
    }
    getTreeItem(manifest: SessionManifest): vscode.TreeItem {
        const view = this.views.get(`${manifest.id}:${manifest.generation}`);
        manifest = view?.client.manifest ?? manifest;
        const presentation = sessionPresentation(
            manifest,
            view?.client.connected,
            view?.client.control ?? false,
            view?.restarting,
            view?.target.workingDir,
        );
        const item = new vscode.TreeItem(manifest.label);
        item.id = `${manifest.id}:${manifest.generation}`;
        item.description = `${presentation.state} · ${manifest.provider}`;
        const age = sessionAge(manifest);
        if (age) {
            item.description += ` · ${age}`;
        }
        item.contextValue = 'rInteractiveSession';
        if (view?.client.connected && !view.client.control) {
            item.description += ' · observing';
        }
        item.tooltip = presentation.tooltip;
        item.iconPath = new vscode.ThemeIcon(
            manifest.status === 'busy'
                ? 'sync~spin'
                : manifest.status === 'exited'
                  ? 'circle-outline'
                  : 'terminal',
        );
        item.command = {
            command: 'r.interactive.open',
            title: 'Open R Interactive',
            arguments: [manifest],
        };
        return item;
    }

    private async create(
        adopt?: ArfSession,
        resource = vscode.window.activeTextEditor?.document.uri,
    ): Promise<InteractiveView | undefined> {
        if (!vscode.workspace.isTrusted) {
            throw new Error('Trust this workspace before starting or controlling R');
        }
        const directory =
            adopt?.cwd ??
            vscode.workspace.getWorkspaceFolder(resource ?? vscode.Uri.file(this.root))?.uri
                .fsPath ??
            vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ??
            process.env.HOME ??
            process.cwd();
        const rPath = await util.getRpath(false, resource);
        if (!rPath) {
            throw new Error('Configure an R executable before starting Interactive');
        }
        const arfCommand = this.arfCommand(resource);
        let arfPath = adopt ? undefined : resolveArfExecutable(arfCommand, directory);
        const provider = adopt
            ? 'arf-existing'
            : await vscode.window.showQuickPick(
                  arfPath
                      ? [{ label: 'arf', detail: arfPath, value: 'arf' as const }]
                      : [
                            {
                                label: '$(gear) Configure arf…',
                                description: 'Required for Interactive · executable unavailable',
                                detail: `Install arf on this host and set its path. Ordinary R terminals remain available. Checked: ${arfCommand}`,
                                value: 'configure' as const,
                            },
                        ],
                  { title: 'R Interactive session provider' },
              );
        if (!provider) {
            return;
        }
        const kind = typeof provider === 'string' ? provider : provider.value;
        if (kind === 'configure') {
            await this.configureArf();
            return;
        }
        const label = await vscode.window.showInputBox({
            title: 'Session name',
            value: adopt ? `arf ${adopt.pid}` : path.basename(directory),
        });
        if (!label) {
            return;
        }
        if (
            kind === 'arf' &&
            !(arfPath = this.checkArfExecutable(arfPath ?? arfCommand, directory))
        ) {
            return;
        }
        const supervision = util.config(resource).get<string>('interactive.supervision', 'auto');
        prepareSupervisor(supervision, directory);
        const node = await this.nodeRuntime(directory, resource);
        return vscode.window.withProgress(
            {
                location: vscode.ProgressLocation.Notification,
                title: 'Starting persistent R Interactive',
            },
            async (progress) => {
                progress.report({ message: 'Preparing the private R runtime' });
                if (
                    kind === 'arf' &&
                    !(arfPath = this.checkArfExecutable(arfPath ?? arfCommand, directory))
                ) {
                    return;
                }
                const identity = newIdentity();
                let config: AgentConfig = {
                    ...identity,
                    label,
                    directory,
                    storage: path.join(this.root, identity.id),
                    rPath,
                    provider: kind,
                    arfPath,
                    arfEndpoint: adopt?.socket_path,
                    supervision,
                    plotBackend: util
                        .config()
                        .get<AgentConfig['plotBackend']>('interactive.plotBackend', 'auto'),
                    historyLimit: util.config().get<number>('interactive.historyLimit', 100),
                    ...this.retentionLimits(),
                };
                const runtime = await prepareBackendRuntime(config, {
                    extensionPath: this.context.extensionPath,
                    root: this.root,
                    log: (text) => this.output.append(text),
                });
                config = runtime.config;
                progress.report({ message: 'Launching the independent session agent' });
                const manifest = await launchAgent(config, runtime.agent, node, (text) =>
                    this.output.appendLine(text),
                );
                this.refresh();
                await this.open(manifest);
                return this.views.get(`${manifest.id}:${manifest.generation}`);
            },
        );
    }

    private retentionLimits(): Required<
        Pick<AgentConfig, 'maxOutputBytes' | 'maxAssetBytes' | 'maxJournalBytes'>
    > {
        const settings = util.config();
        const mib = 1024 * 1024;
        // Settings use MiB; the agent and its saved configuration use whole bytes.
        return {
            maxOutputBytes: Math.floor(
                settings.get<number>('interactive.maxOutputSizeMiB', 4) * mib,
            ),
            maxAssetBytes: Math.floor(
                settings.get<number>('interactive.maxAssetSizeMiB', DEFAULT_MAX_ASSET_BYTES / mib) *
                    mib,
            ),
            maxJournalBytes: Math.floor(
                settings.get<number>('interactive.maxJournalSizeMiB', 128) * mib,
            ),
        };
    }

    private arfCommand(resource?: vscode.Uri): string {
        return (
            util
                .substituteVariables(
                    util.config(resource).get<string>('interactive.arfPath', 'arf'),
                    resource,
                )
                .trim() || 'arf'
        );
    }

    private nodeRuntime(
        directory: string,
        resource = vscode.Uri.file(directory),
    ): Promise<NodeRuntime> {
        const command = util.substituteVariables(
            util.config(resource).get<string>('interactive.nodePath', ''),
            resource,
        );
        return prepareNodeRuntime(directory, resolveNodeRuntime(command, directory));
    }

    private async configureArf(): Promise<void> {
        await vscode.commands.executeCommand(
            'workbench.action.openSettings',
            'r.interactive.arfPath',
        );
    }

    private checkArfExecutable(
        command: string,
        directory: string,
        restarting = false,
    ): string | undefined {
        const executable = resolveArfExecutable(command, directory);
        if (executable) {
            return executable;
        }
        // A nonmodal setup notification must not keep the view in Restarting or
        // hold the source execution target chooser until the user dismisses it.
        void Promise.resolve(
            vscode.window.showWarningMessage(
                `Cannot ${restarting ? 'restart' : 'start'} Headless arf: “${command}” was not found or is not executable on this host. ` +
                    'Install arf or set r.interactive.arfPath to its executable. Plain R sessions do not require arf.' +
                    (restarting ? ' The current R session has not been stopped.' : ''),
                'Configure arf',
            ),
        )
            .then(async (action) => {
                if (action === 'Configure arf') {
                    await this.configureArf();
                }
            })
            .catch((error) => this.report(error));
    }

    private async sessionChoices(): Promise<SessionChoice[]> {
        this.refresh();
        const live = await runningSessions(this.manifests.filter(hasSessionEndpoint));
        const terminals: ArfSession[] = [];
        const arfCandidates = discoverArf().filter(
            (arf) => fs.existsSync(arf.socket_path) && !live.some((item) => item.rPid === arf.pid),
        );
        for (let i = 0; i < arfCandidates.length; i += 8) {
            const batch = await Promise.all(
                arfCandidates.slice(i, i + 8).map((arf) => probeArfSession(arf)),
            );
            for (const arf of batch) {
                if (arf) {
                    terminals.push(arf);
                }
            }
        }
        return [
            ...live.map((manifest) => ({
                label: manifest.label,
                description: this.sessionChoiceDescription(manifest),
                detail: `${manifest.directory} · ${manifest.id.slice(0, 8)}`,
                manifest,
            })),
            ...terminals.map((arf) => ({
                label: `arf ${arf.pid}`,
                description: `${arf.r_version ?? ''} · ${arf.cwd ?? ''}`,
                arf,
            })),
            { label: '$(add) New persistent R session', create: true },
        ];
    }

    private async chooseExecutionTarget(
        resource?: vscode.Uri,
    ): Promise<InteractiveView | 'createTerminal' | undefined> {
        const choices = this.sessionChoices().then(
            (items) =>
                [
                    {
                        label: '$(add) New R Interactive window',
                        description: 'Start a persistent R session',
                        create: true,
                    },
                    ...(util.config(resource).get<string>('interactive.executionTarget') ===
                    'interactive'
                        ? []
                        : [
                              {
                                  label: '$(terminal) Create R terminal',
                                  description: 'Run R in the Terminal pane',
                                  terminal: true,
                              },
                          ]),
                    ...items.filter((item) => !item.create),
                ] as SessionChoice[],
        );
        const selected = await vscode.window.showQuickPick(choices, {
            title: 'Run R code',
            placeHolder: 'Choose where to run the selected code',
            matchOnDescription: true,
            matchOnDetail: true,
        });
        if (selected?.terminal) {
            return 'createTerminal';
        }
        if (selected?.create || selected?.arf) {
            return this.create(selected.arf, resource);
        }
        if (selected?.manifest) {
            await this.open(selected.manifest);
            return this.views.get(`${selected.manifest.id}:${selected.manifest.generation}`);
        }
    }

    private sessionChoiceDescription(manifest: SessionManifest): string {
        const age = sessionAge(manifest);
        return `${manifest.status} · ${manifest.provider} · PID ${manifest.rPid ?? 'starting'}${age ? ` · ${age}` : ''}`;
    }

    private async pick(): Promise<void> {
        // Passing a promise keeps the picker responsive while local agents are checked.
        const selected = await vscode.window.showQuickPick(this.sessionChoices(), {
            title: 'Connect to a persistent R session',
            placeHolder: 'Select a running session or create a new one',
            matchOnDescription: true,
            matchOnDetail: true,
        });
        if (selected?.manifest) {
            await this.open(selected.manifest);
        } else if (selected?.arf) {
            await this.create(selected.arf);
        } else if (selected?.create) {
            await this.create();
        }
    }

    async open(manifest: SessionManifest): Promise<void> {
        const key = `${manifest.id}:${manifest.generation}`;
        const pending = this.opening.get(key);
        if (pending) {
            return pending;
        }
        const opening = this.openView(manifest);
        this.opening.set(key, opening);
        try {
            await opening;
        } finally {
            this.opening.delete(key);
        }
    }

    private async openView(manifest: SessionManifest): Promise<void> {
        if (!vscode.workspace.isTrusted) {
            throw new Error('Trust this workspace before connecting to R');
        }
        const key = `${manifest.id}:${manifest.generation}`;
        const previous = this.views.get(key);
        if (
            previous &&
            !previous.notebook.isClosed &&
            (previous.client.connected || previous.restarting)
        ) {
            if (previous.notebook.notebookType === 'interactive') {
                await vscode.commands.executeCommand(
                    'interactive.open',
                    { preserveFocus: true },
                    previous.notebook.uri,
                );
            } else {
                const editor = vscode.window.visibleNotebookEditors.find(
                    (item) => item.notebook === previous.notebook,
                );
                await vscode.window.showNotebookDocument(previous.notebook, {
                    preserveFocus: true,
                    viewColumn: editor?.viewColumn,
                });
            }
            await this.activate(previous);
            return;
        }
        if (previous) {
            this.disposeView(previous, false);
        }
        const client = new AgentClient(manifest, this.clientId);
        const created: vscode.Disposable[] = [{ dispose: () => client.close() }];
        try {
            try {
                await client.connect();
            } catch (error) {
                if (
                    ['ENOENT', 'ECONNREFUSED'].includes((error as NodeJS.ErrnoException).code ?? '')
                ) {
                    this.refresh();
                    throw new Error(
                        `Session “${manifest.label}” is no longer available. Refresh the session list or start a new session. Its saved history has not been removed.`,
                        { cause: error },
                    );
                }
                throw error;
            }
            if (this.closed) {
                throw new Error('Interactive manager was closed during connection');
            }
            const makeController = (type: string): vscode.NotebookController => {
                const controller = vscode.notebooks.createNotebookController(
                    `r-${manifest.id}-${manifest.generation}-${type}`,
                    type,
                    `R: ${manifest.label}`,
                );
                controller.supportedLanguages = ['r'];
                controller.supportsExecutionOrder = true;
                controller.executeHandler = (cells) => {
                    if (cells.some((cell) => cell.notebook !== view.notebook)) {
                        this.report(
                            new Error(
                                'This kernel belongs to another Interactive window. Connect this notebook to its original session before running it.',
                            ),
                        );
                        return;
                    }
                    return this.executeCells(view, cells).catch((error) => this.report(error));
                };
                controller.interruptHandler = () =>
                    view.client.request<void>('interrupt').catch((error) => this.report(error));
                created.push(controller);
                return controller;
            };
            const native = makeController('interactive');
            const fallback = makeController('r-interactive');
            let notebook: vscode.NotebookDocument;
            let inputUri: vscode.Uri | undefined;
            let notebookEditor: vscode.NotebookEditor | undefined;
            let controller = native;
            const rememberedUri = this.savedConnections.get(manifest.id)?.notebookUri;
            // Native Interactive reuses numbered URIs after tabs close. A saved URI
            // can consequently belong to a different, newer session.
            const occupied = (uri: string): boolean =>
                [...this.views.values()].some(
                    (view) =>
                        !view.disposed &&
                        view.client.manifest.id !== manifest.id &&
                        view.notebook.uri.toString() === uri,
                ) ||
                vscode.workspace.notebookDocuments.some(
                    (document) =>
                        document.uri.toString() === uri &&
                        document.metadata.rSessionId &&
                        document.metadata.rSessionId !== manifest.id,
                );
            const savedUri = rememberedUri && !occupied(rememberedUri) ? rememberedUri : undefined;
            const existing = vscode.workspace.notebookDocuments.find(
                (document) =>
                    document.metadata.rSessionId === manifest.id ||
                    (!document.metadata.rSessionId && document.uri.toString() === savedUri),
            );
            try {
                if (existing?.notebookType === 'r-interactive') {
                    throw new Error('Restoring an R Interactive notebook');
                }
                const result = await vscode.commands.executeCommand<{
                    notebookUri: vscode.Uri;
                    inputUri: vscode.Uri;
                    notebookEditor?: vscode.NotebookEditor;
                }>(
                    'interactive.open',
                    { viewColumn: vscode.ViewColumn.Beside, preserveFocus: true },
                    existing?.uri ?? (savedUri ? vscode.Uri.parse(savedUri) : undefined),
                    `${this.context.extension.id}/${native.id}`,
                    `R: ${manifest.label}`,
                );
                if (!result?.notebookUri || !result.inputUri) {
                    throw new Error('Interactive Window returned no document');
                }
                notebook = await vscode.workspace.openNotebookDocument(result.notebookUri);
                inputUri = result.inputUri;
                notebookEditor = result.notebookEditor;
            } catch (error) {
                this.output.appendLine(`Using notebook fallback: ${String(error)}`);
                controller = fallback;
                notebook =
                    existing?.notebookType === 'r-interactive'
                        ? existing
                        : await vscode.workspace.openNotebookDocument(
                              'r-interactive',
                              new vscode.NotebookData([]),
                          );
                fallback.updateNotebookAffinity(
                    notebook,
                    vscode.NotebookControllerAffinity.Preferred,
                );
                notebookEditor = await vscode.window.showNotebookDocument(notebook, {
                    preserveFocus: true,
                });
            }
            if (this.closed) {
                throw new Error('Interactive manager was closed during connection');
            }
            const history = await this.readHistory(manifest);
            if (this.closed || notebook.isClosed) {
                throw new Error('Interactive window closed while reading its history');
            }
            const target = this.registerTarget(client);
            session.bindSessionDocument(
                vscode.Uri.from({ scheme: 'vscode-notebook-cell', path: notebook.uri.path }),
                target,
            );
            const view: InteractiveView = {
                client,
                target,
                model: new Transcript(manifest.generation),
                history,
                notebook,
                controller,
                controllers: [native, fallback],
                inputUri,
                executions: new Map(),
                chain: Promise.resolve(),
                outputQueue: new OutputQueue(
                    (id) => this.render(view, id),
                    (error) => this.report(error),
                ),
                disposed: false,
                prompts: new Set(),
                base: '',
                hidden: new Set(),
            };
            this.views.set(key, view);
            controller.updateNotebookAffinity(
                notebook,
                vscode.NotebookControllerAffinity.Preferred,
            );
            // A restored native tab may still have the previous generation's kernel selected.
            if (notebookEditor) {
                await vscode.commands.executeCommand('notebook.selectKernel', {
                    id: controller.id,
                    extension: this.context.extension.id,
                    notebookEditor,
                });
            }
            if (inputUri) {
                session.bindSessionDocument(inputUri, target);
                await vscode.languages.setTextDocumentLanguage(
                    await vscode.workspace.openTextDocument(inputUri),
                    'r',
                );
            }
            const restoring =
                notebook === existing || (!!savedUri && notebook.uri.toString() === savedUri);
            if (!restoring && inputUri) {
                // A recycled native input model may still contain the previous tab's draft.
                const input = await vscode.workspace.openTextDocument(inputUri);
                if (input.getText()) {
                    const edit = new vscode.WorkspaceEdit();
                    edit.replace(
                        inputUri,
                        new vscode.Range(
                            input.positionAt(0),
                            input.positionAt(input.getText().length),
                        ),
                        '',
                    );
                    await vscode.workspace.applyEdit(edit);
                }
            }
            await this.restore(view, await client.snapshot(), restoring);
            if (this.closed || view.disposed) {
                throw new Error('Interactive manager was closed during connection');
            }
            this.listen(view, client);
            if (!(await client.subscribe(view.model.seq))) {
                await this.restore(view, await client.snapshot());
                await client.subscribe(view.model.seq);
            }
            await this.activate(view);
            for (const [id, connection] of this.savedConnections) {
                if (id !== manifest.id && connection.notebookUri === notebook.uri.toString()) {
                    this.savedConnections.set(id, { id });
                }
            }
            this.savedConnections.set(manifest.id, {
                id: manifest.id,
                notebookUri: notebook.uri.toString(),
            });
            await this.saveConnections();
        } catch (error) {
            const view = this.views.get(key);
            if (view) {
                this.disposeView(view, false);
            } else {
                created.forEach((item) => {
                    item.dispose();
                });
            }
            throw error;
        }
    }

    private registerTarget(client: AgentClient): session.Session {
        const manifest = client.manifest;
        const target = session.registerSessionTransport(
            `${manifest.id}:${manifest.generation}`,
            manifest.host,
            manifest.directory,
            (data) =>
                client.request(
                    'inspect',
                    { method: data.method, params: data.params ?? {} },
                    data.method === 'hover' || data.method === 'completion' ? 250 : 6000,
                ),
        );
        target.pid = String(manifest.rPid ?? '');
        target.rVer = manifest.rVersion ?? '';
        target.processExited = manifest.status === 'exited';
        target.rPath = manifest.rPath;
        target.libraryPaths = manifest.libraryPaths;
        target.label = manifest.label;
        target.execute = async (code) => {
            const view = [...this.views.values()].find((item) => item.target === target);
            if (!view || view.disposed) {
                throw new Error('This Interactive session is no longer attached.');
            }
            await this.submit(view, code);
        };
        return target;
    }

    private listen(view: InteractiveView, client: AgentClient): void {
        client.on('event', (event: SessionEvent) => {
            if (view.client !== client) {
                return;
            }
            view.chain = view.chain
                .then(() => this.event(view, event))
                .catch((error) => this.report(error));
        });
        client.on('activity', () => {
            if (view.client === client) {
                this.updateStatus();
                this.changes.fire(undefined);
            }
        });
        client.on('disconnect', () => {
            if (view.client !== client || view.restarting) {
                return;
            }
            this.updateStatus();
            this.changes.fire(undefined);
            this.reconnect(view, 1000);
        });
    }

    private async readHistory(manifest: SessionManifest): Promise<Transcript[]> {
        const storage = path.join(this.root, manifest.id);
        const file = path.join(storage, 'config.json');
        if (!fs.existsSync(file)) {
            return [];
        }
        const config = JSON.parse(await fs.promises.readFile(file, 'utf8')) as AgentConfig;
        return Promise.all(
            (config.previousGenerations ?? [])
                .filter((generation) => generation !== manifest.generation)
                .map(async (generation) => {
                    const model = new Transcript(generation);
                    model.restore({
                        manifest: { ...manifest, generation },
                        ...(await readPreviousJournalAsync(
                            storage,
                            generation,
                            config.historyLimit,
                        )),
                    });
                    return model;
                }),
        );
    }

    private transcriptCells(view: InteractiveView): TranscriptCell[] {
        return [...view.history, view.model].flatMap((model) => [...model.cells.values()]);
    }

    private async restore(
        view: InteractiveView,
        snapshot: AgentSnapshot,
        preserveDrafts = true,
    ): Promise<void> {
        // Wait only for the current notebook write. A reconnected R process may
        // keep streaming indefinitely; suspend pending writes during restore.
        await view.outputQueue.pause();
        try {
            await this.restoreSnapshot(view, snapshot, preserveDrafts);
        } finally {
            view.outputQueue.resume();
        }
    }

    private async restoreSnapshot(
        view: InteractiveView,
        snapshot: AgentSnapshot,
        preserveDrafts: boolean,
    ): Promise<void> {
        const previousCells = preserveDrafts ? view.notebook.getCells() : [];
        for (const { task } of view.executions.values()) {
            task.end(undefined);
        }
        view.executions.clear();
        view.outputState?.reset();
        view.cellIndex?.invalidate();
        for (const cell of view.notebook.getCells()) {
            session.unbindSessionDocument(cell.document.uri);
        }
        view.client.manifest = snapshot.manifest;
        view.target.pid = String(snapshot.manifest.rPid ?? '');
        view.target.rVer = snapshot.manifest.rVersion ?? '';
        view.target.processExited = snapshot.manifest.status === 'exited';
        view.target.rPath = snapshot.manifest.rPath;
        view.target.libraryPaths = snapshot.manifest.libraryPaths;
        view.base = snapshot.manifest.assetBase
            ? (
                  await vscode.env.asExternalUri(vscode.Uri.parse(snapshot.manifest.assetBase))
              ).toString(true)
            : '';
        view.model.restore(snapshot);
        const metadata = new Map(
            previousCells.map((cell) => [cell, restoredCellMetadata(cell.metadata)]),
        );
        const edited = new Map(
            previousCells.map((cell) => [
                metadata.get(cell)!.rExecutionId as string,
                cell.document.getText(),
            ]),
        );
        const previousNotice = previousCells.find(
            (cell) => metadata.get(cell)!.rSessionNotice === snapshot.manifest.generation,
        );
        if (snapshot.workspace) {
            view.target.workspaceData = snapshot.workspace as unknown as session.WorkspaceData;
        }
        const cells: vscode.NotebookCellData[] = [];
        for (const model of [...view.history, view.model]) {
            for (const cell of model.cells.values()) {
                if (!view.hidden.has(cell.record.id)) {
                    const data = await this.cellData(view, cell);
                    data.value = edited.get(cell.record.id) ?? data.value;
                    cells.push(data);
                }
            }
            if (model !== view.model) {
                cells.push(this.noticeData(view, 'restarted', model.generation));
            }
        }
        if (snapshot.manifest.status === 'exited') {
            cells.push(this.noticeData(view, 'stopped'));
        } else if (previousNotice) {
            const notice = new vscode.NotebookCellData(
                vscode.NotebookCellKind.Markup,
                previousNotice.document.getText(),
                'markdown',
            );
            notice.metadata = persistentCellMetadata(metadata.get(previousNotice)!, 'markdown');
            cells.push(notice);
        }
        // Group drafts by their next retained execution or notice, then merge
        // once. Identity lookups avoid source matching and repeated array edits.
        const executions = new Map(cells.map((cell) => [cell.metadata?.rExecutionId, cell]));
        const notices = new Map(cells.map((cell) => [cell.metadata?.rSessionNotice, cell]));
        const draftsBefore = new Map<vscode.NotebookCellData, vscode.NotebookCellData[]>();
        let pendingDrafts: vscode.NotebookCellData[] = [];
        let draftCount = 0;
        for (const cell of previousCells) {
            const data = metadata.get(cell)!;
            if (cell.kind === vscode.NotebookCellKind.Code && !data.rExecutionId) {
                pendingDrafts.push(
                    new vscode.NotebookCellData(
                        cell.kind,
                        cell.document.getText(),
                        cell.document.languageId,
                    ),
                );
                draftCount++;
            } else {
                const anchor = data.rExecutionId
                    ? executions.get(data.rExecutionId)
                    : data.rSessionNotice
                      ? notices.get(data.rSessionNotice)
                      : undefined;
                if (anchor && pendingDrafts.length) {
                    draftsBefore.set(anchor, pendingDrafts);
                    pendingDrafts = [];
                }
            }
        }
        const restoredCells = cells
            .flatMap((cell) => [...(draftsBefore.get(cell) ?? []), cell])
            .concat(pendingDrafts);
        if (view.notebook.notebookType === 'r-interactive' && !draftCount) {
            restoredCells.push(new vscode.NotebookCellData(vscode.NotebookCellKind.Code, '', 'r'));
        }
        const edit = new vscode.WorkspaceEdit();
        edit.set(view.notebook.uri, [
            vscode.NotebookEdit.replaceCells(
                new vscode.NotebookRange(0, view.notebook.cellCount),
                restoredCells,
            ),
            vscode.NotebookEdit.updateNotebookMetadata(
                persistentNotebookMetadata(
                    view.notebook.metadata,
                    snapshot.manifest.id,
                    snapshot.manifest.generation,
                ),
            ),
        ]);
        await vscode.workspace.applyEdit(edit);
        for (const cell of view.notebook.getCells()) {
            session.bindSessionDocument(cell.document.uri, view.target);
        }
        if (snapshot.input && view.client.control) {
            void this.prompt(view, snapshot.input);
        }
    }

    private async activate(view: InteractiveView): Promise<void> {
        if (view.disposed) {
            return;
        }
        this.active = view;
        this.routing = true;
        ensureWorkspaceViewer();
        this.updateStatus();
        // Select synchronously before any command round trips; the latest focus wins.
        const activated = session.activateSession(view.target);
        await vscode.commands.executeCommand('setContext', 'r.WorkspaceViewer:show', true);
        await activated;
        await vscode.commands.executeCommand('setContext', 'r.interactive.active', true);
        await vscode.commands.executeCommand(
            'setContext',
            'r.interactive.notebook',
            vscode.window.activeNotebookEditor?.notebook === view.notebook,
        );
        this.updateStatus();
    }

    private cell(view: InteractiveView, id: string): vscode.NotebookCell | undefined {
        view.cellIndex ??= new ExecutionCellIndex();
        return view.cellIndex.get(id, () => view.notebook.getCells());
    }

    private transcriptCell(view: InteractiveView, id: string): TranscriptCell | undefined {
        return (
            view.model.cells.get(id) ??
            view.history.map((model) => model.cells.get(id)).find((cell) => cell !== undefined)
        );
    }

    private async submit(
        view: InteractiveView,
        code: string,
        source?: SourceLocation,
    ): Promise<void> {
        if (!code.trim()) {
            return;
        }
        if (view.restarting) {
            throw new Error('R is restarting. Wait for the restart notice before running code.');
        }
        if (!view.client.control) {
            throw new Error(
                'This window is observing R. Run R: Take Control of Interactive Session first.',
            );
        }
        const data = new vscode.NotebookCellData(vscode.NotebookCellKind.Code, code, 'r');
        const id = randomUUID();
        data.metadata = persistentCellMetadata({ rExecutionId: id, rSource: source }, 'r');
        const edit = new vscode.WorkspaceEdit();
        edit.set(view.notebook.uri, [
            vscode.NotebookEdit.insertCells(view.notebook.cellCount, [data]),
        ]);
        await vscode.workspace.applyEdit(edit);
        const cell = this.cell(view, id);
        if (cell) {
            await this.executeCells(view, [cell]);
        }
    }

    private async executeCells(
        view: InteractiveView,
        cells: readonly vscode.NotebookCell[],
    ): Promise<void> {
        if (!view || view.disposed) {
            return;
        }
        if (view.restarting) {
            throw new Error('R is restarting. Wait for the restart notice before running code.');
        }
        if (['exited', 'stopping'].includes(view.client.manifest.status)) {
            throw new Error(
                'This R session has stopped. Restart it or choose another session to run code.',
            );
        }
        if (!view.client.control) {
            throw new Error(
                'This window is observing R. Run R: Take Control of Interactive Session first.',
            );
        }
        for (const cell of cells) {
            const code = cell.document.getText();
            if (!code.trim()) {
                continue;
            }
            // Re-running creates a new execution identity, even if the same cell is selected.
            const previousId = cell.metadata.rExecutionId as string | undefined;
            if (previousId && this.transcriptCell(view, previousId)) {
                await this.submit(view, code, cell.metadata.rSource as SourceLocation | undefined);
                continue;
            }
            const id = previousId && !view.model.cells.has(previousId) ? previousId : randomUUID();
            const source = cell.metadata.rSource as SourceLocation | undefined;
            const edit = new vscode.WorkspaceEdit();
            edit.set(view.notebook.uri, [
                vscode.NotebookEdit.updateCellMetadata(
                    cell.index,
                    persistentCellMetadata({ ...cell.metadata, rExecutionId: id }, 'r'),
                ),
            ]);
            await vscode.workspace.applyEdit(edit);
            session.bindSessionDocument(cell.document.uri, view.target);
            const task = view.controller.createNotebookCellExecution(cell);
            view.executions.set(id, { task, started: false });
            try {
                await view.client.request('submit', { submission: { id, code, source } });
            } catch (error) {
                // Query by the same ID; never resubmit code after an ambiguous transport failure.
                this.output.appendLine(`Submission ${id}: ${String(error)}`);
                if (view.executions.get(id)?.task === task) {
                    task.end(undefined);
                    view.executions.delete(id);
                }
                throw error;
            }
        }
    }

    private async event(view: InteractiveView, event: SessionEvent): Promise<void> {
        if (
            view.disposed ||
            event.generation !== view.model.generation ||
            event.seq <= view.model.seq
        ) {
            return;
        }
        const changed = view.model.apply(event);
        this.updateStatus();
        if (event.type === 'state') {
            view.client.manifest.status = event.data.status as SessionManifest['status'];
            view.target.processExited = event.data.status === 'exited';
            view.client.manifest.rPid =
                typeof event.data.rPid === 'number' ? event.data.rPid : undefined;
            view.client.manifest.rVersion =
                typeof event.data.rVersion === 'string' ? event.data.rVersion : undefined;
            view.client.manifest.ended =
                typeof event.data.ended === 'number' ? event.data.ended : undefined;
            if (event.data.capabilities) {
                view.client.manifest.capabilities = object(event.data.capabilities) as Record<
                    string,
                    boolean
                >;
            }
            if (typeof event.data.rPath === 'string') {
                view.client.manifest.rPath = event.data.rPath;
                view.target.rPath = event.data.rPath;
            }
            if (Array.isArray(event.data.libraryPaths)) {
                view.client.manifest.libraryPaths = event.data.libraryPaths.map(String);
                view.target.libraryPaths = view.client.manifest.libraryPaths;
            }
            if (typeof event.data.runtimeSessionId === 'string') {
                view.client.manifest.runtimeSessionId = event.data.runtimeSessionId;
            }
            view.target.pid = typeof event.data.rPid === 'number' ? String(event.data.rPid) : '';
            view.target.rVer = typeof event.data.rVersion === 'string' ? event.data.rVersion : '';
            this.refresh();
            if (event.data.status === 'exited' && !view.restarting) {
                await this.sessionNotice(view, 'stopped');
                for (const cell of this.transcriptCells(view)) {
                    if (cell.outputs.some((output) => output.type === 'display')) {
                        view.outputQueue.schedule(cell.record.id);
                    }
                }
            }
        } else if (event.type === 'session' && typeof event.data.label === 'string') {
            view.client.manifest.label = event.data.label;
            this.refresh();
        } else if (event.type === 'workspace') {
            session.updateSessionWorkspace(
                view.target,
                event.data as unknown as session.WorkspaceData,
            );
        } else if (event.type === 'workspaceInvalidated') {
            session.invalidateWorkspaceChildren(view.target);
        } else if (event.type === 'input' && view.client.control) {
            void this.prompt(view, event.data);
        } else if (event.type === 'clientRequest' && view.client.control) {
            void this.clientRequest(view, event.data);
        } else if (event.type === 'viewer' && event.data.method === 'dataview') {
            const params = object(event.data.params ?? {});
            const title =
                typeof params.title === 'string'
                    ? params.title
                    : Array.isArray(params.title) &&
                        params.title.every((line: unknown) => typeof line === 'string')
                      ? params.title.join(',')
                      : undefined;
            const viewer =
                util.config().get<Record<string, string>>('session.viewers.viewColumn')?.view ??
                'Two';
            if (
                viewer !== 'Disable' &&
                typeof params.source === 'string' &&
                params.source &&
                typeof params.type === 'string' &&
                params.type &&
                title &&
                (params.file === undefined ||
                    params.file === null ||
                    typeof params.file === 'string') &&
                (params.view_id === undefined ||
                    params.view_id === null ||
                    typeof params.view_id === 'string')
            ) {
                await session.showDataView(
                    params.source,
                    params.type,
                    title,
                    params.file ?? '',
                    viewer,
                    params.view_id || undefined,
                    params.navigation as ListViewNavigation | undefined,
                    view.target.sessionId,
                    typeof params.state_generation === 'number'
                        ? params.state_generation
                        : undefined,
                );
            }
        } else if (event.type === 'notification') {
            const params = object(event.data.params ?? {});
            if (event.data.method === 'help') {
                await session.showHelpNotification(params);
            }
            if (event.data.method === 'rstudioapi/send_to_console') {
                if (params.execute) {
                    await this.submit(view, String(params.code));
                } else if (view.inputUri) {
                    const document = await vscode.workspace.openTextDocument(view.inputUri);
                    const edit = new vscode.WorkspaceEdit();
                    edit.insert(
                        document.uri,
                        document.positionAt(document.getText().length),
                        String(params.code),
                    );
                    await vscode.workspace.applyEdit(edit);
                }
            }
        } else if (event.type === 'agentError' || event.type === 'agentWarning') {
            this.output.appendLine(String(event.data.message));
        }
        if (!changed || view.hidden.has(changed)) {
            return;
        }
        if (!this.cell(view, changed)) {
            const data = await this.cellData(view, view.model.cells.get(changed)!);
            const edit = new vscode.WorkspaceEdit();
            edit.set(view.notebook.uri, [
                vscode.NotebookEdit.insertCells(view.notebook.cellCount, [data]),
            ]);
            await vscode.workspace.applyEdit(edit);
        }
        if (event.type === 'started') {
            let execution = view.executions.get(changed);
            if (!execution) {
                try {
                    execution = {
                        task: view.controller.createNotebookCellExecution(
                            this.cell(view, changed)!,
                        ),
                        started: false,
                    };
                    view.executions.set(changed, execution);
                } catch {
                    /* Restored/observed execution can still display its retained state. */
                }
            }
            if (execution) {
                execution.task.executionOrder = Number(event.data.order);
                if (!execution.started) {
                    execution.startTime = event.time;
                    execution.task.start(event.time);
                    execution.started = true;
                }
            }
        }
        view.outputQueue.schedule(changed, event.type === 'finished' || event.type === 'uncertain');
    }

    private async cellData(
        view: InteractiveView,
        cell: TranscriptCell,
        portable = false,
    ): Promise<vscode.NotebookCellData> {
        const data = new vscode.NotebookCellData(
            vscode.NotebookCellKind.Code,
            cell.record.code,
            'r',
        );
        data.metadata = persistentCellMetadata(
            {
                rExecutionId: cell.record.id,
                rGeneration: cell.generation,
                rSource: cell.record.source,
                rState: cell.record.state,
                execution_count: cell.record.order,
            },
            'r',
        );
        data.executionSummary = {
            executionOrder: cell.record.order,
            success:
                cell.record.state === 'success'
                    ? true
                    : cell.record.state === 'error'
                      ? false
                      : undefined,
            timing:
                this.executionTimings.get(
                    `${view.client.manifest.id}:${cell.generation}:${cell.record.id}`,
                ) ??
                (cell.record.started && cell.record.ended
                    ? { startTime: cell.record.started, endTime: cell.record.ended }
                    : undefined),
        };
        data.outputs = await this.outputs(view, cell, portable);
        return data;
    }

    private async outputs(
        view: InteractiveView,
        cell: TranscriptCell,
        portable = false,
        streamSnapshots?: ReadonlyMap<StreamText, StreamSnapshot>,
    ): Promise<vscode.NotebookCellOutput[]> {
        const outputs: vscode.NotebookCellOutput[] = [];
        const plots: { output: vscode.NotebookCellOutput; data: Record<string, unknown> }[] = [];
        const plotContext = JSON.stringify([
            view.base,
            cell.generation,
            view.model.generation,
            view.client.connected,
            !['exited', 'stopping'].includes(view.client.manifest.status),
        ]);
        for (const [index, output] of cell.outputs.entries()) {
            const data = output.data;
            const stream = output.stream && streamSnapshots?.get(output.stream);
            const cachedPlot = !portable && this.renderedPlots.get(data);
            if (cachedPlot && cachedPlot.context === plotContext) {
                plots.push(cachedPlot);
                outputs.push(cachedPlot.output);
                continue;
            }
            let items: vscode.NotebookCellOutputItem[];
            if (output.type === 'stream') {
                items = [
                    data.channel === 'stderr'
                        ? vscode.NotebookCellOutputItem.stderr(stream ? '' : String(data.text))
                        : vscode.NotebookCellOutputItem.stdout(stream ? '' : String(data.text)),
                ];
            } else if (output.type === 'condition') {
                if (data.kind === 'error') {
                    const message = String(data.message);
                    // VS Code renders a nonempty stack in place of the message.
                    // Include the heading so nested calls cannot hide the cause.
                    const trace = Array.isArray(data.trace) ? data.trace.join('\n') : '';
                    const stack = `R error: ${message}${trace ? `\n${trace}` : ''}`;
                    items = [
                        vscode.NotebookCellOutputItem.error({ name: 'R error', message, stack }),
                    ];
                } else {
                    items = [
                        vscode.NotebookCellOutputItem.stderr(
                            `${String(data.kind)}: ${String(data.message)}\n`,
                        ),
                    ];
                }
            } else if (output.type === 'truncated') {
                items = [vscode.NotebookCellOutputItem.text(String(data.message))];
            } else if (data.kind === 'mime' && data.mime !== 'text/html') {
                items = [vscode.NotebookCellOutputItem.text(String(data.text), String(data.mime))];
            } else {
                const display: Record<string, unknown> = {
                    ...data,
                    generation: cell.generation,
                    archived: cell.generation !== view.model.generation,
                    connected: view.client.connected,
                    running: !['exited', 'stopping'].includes(view.client.manifest.status),
                };
                const preference = this.outputViews.get(
                    `${view.client.manifest.id}:${cell.generation}:${String(data.displayId)}`,
                );
                if (data.kind === 'list') {
                    display.listView = preference?.listView ?? 'list';
                }
                if (data.kind === 'table') {
                    display.tableView =
                        preference?.tableView ??
                        util.config().get('interactive.tableView', 'table');
                }
                if (data.svg || data.asset) {
                    display.url =
                        view.base +
                        String(data.svg ?? data.asset)
                            .split('/')
                            .map(encodeURIComponent)
                            .join('/');
                } else if (
                    typeof data.url === 'string' &&
                    /^https?:\/\/(localhost|127\.0\.0\.1)(:|\/)/.test(data.url)
                ) {
                    display.url = (
                        await vscode.env.asExternalUri(vscode.Uri.parse(data.url))
                    ).toString(true);
                }
                if (data.kind === 'mime' && data.mime === 'text/html') {
                    display.kind = 'htmlText';
                }
                items = [
                    vscode.NotebookCellOutputItem.json(display, DISPLAY_MIME),
                    vscode.NotebookCellOutputItem.text(
                        typeof data.printedText === 'string'
                            ? data.printedText
                            : data.kind === 'table'
                              ? `${String(data.totalRows)} rows\n${JSON.stringify(data.rows, null, 2)}`
                              : data.kind === 'list'
                                ? JSON.stringify(data.children, null, 2)
                                : `R ${String(data.kind)} output`,
                    ),
                ];
                if (typeof data.svg === 'string') {
                    try {
                        const svg = portable
                            ? readAsset(
                                  path.join(this.root, view.client.manifest.id, 'assets'),
                                  data.svg,
                              ).toString('base64')
                            : await view.client.request<string>('asset', { id: data.svg });
                        display.svgData = svg;
                        items[0] = vscode.NotebookCellOutputItem.json(display, DISPLAY_MIME);
                        items.push(
                            new vscode.NotebookCellOutputItem(
                                Buffer.from(svg, 'base64'),
                                'image/svg+xml',
                            ),
                        );
                    } catch (error) {
                        if (portable) {
                            throw error;
                        }
                        // The live renderer can load a larger SVG directly from its asset URL.
                    }
                }
                if (data.kind === 'image') {
                    const bytes =
                        typeof data.asset === 'string'
                            ? readAsset(
                                  path.join(this.root, view.client.manifest.id, 'assets'),
                                  data.asset,
                              )
                            : Buffer.from(String(data.data), 'base64');
                    display.kind = 'plot';
                    display.imageData = bytes.toString('base64');
                    display.resizable = false;
                    items[0] = vscode.NotebookCellOutputItem.json(display, DISPLAY_MIME);
                    items.push(new vscode.NotebookCellOutputItem(bytes, String(data.mime)));
                }
                if (data.kind === 'plot' || data.kind === 'image') {
                    const plotOutput = new vscode.NotebookCellOutput(items, {
                        rDisplayId: data.displayId,
                    });
                    const rendered = { output: plotOutput, data: display, context: plotContext };
                    if (!portable) {
                        this.renderedPlots.set(data, rendered);
                    }
                    plots.push(rendered);
                    outputs.push(plotOutput);
                    continue;
                }
            }
            const notebookOutput = new vscode.NotebookCellOutput(items, {
                rDisplayId: data.displayId,
                ...(output.type === 'stream'
                    ? { rStreamId: `${cell.generation}:${cell.record.id}:${index}` }
                    : {}),
            });
            if (stream) {
                prepareNotebookStream(notebookOutput, stream);
            }
            outputs.push(notebookOutput);
        }
        if (plots.length > 1) {
            const first = plots[0];
            const key = `${view.client.manifest.id}:${cell.generation}:${String(first.data.displayId)}`;
            const gallery = {
                kind: 'plot',
                displayId: first.data.displayId,
                generation: cell.generation,
                connected: view.client.connected,
                archived: cell.generation !== view.model.generation,
                running: !['exited', 'stopping'].includes(view.client.manifest.status),
                pages: plots.map((plot) => plot.data),
                selectedPlot: this.outputViews.get(key)?.selectedPlot,
            };
            // Keep the gallery at the first plot's position. Other output retains
            // its order, and the journal keeps each page as an independent asset.
            const grouped = new vscode.NotebookCellOutput(
                [
                    vscode.NotebookCellOutputItem.json(gallery, DISPLAY_MIME),
                    vscode.NotebookCellOutputItem.text(`${plots.length} R plot pages`),
                    ...first.output.items.filter((item) => item.mime.startsWith('image/')),
                ],
                first.output.metadata,
            );
            const plotOutputs = new Set(plots.map((plot) => plot.output));
            return outputs.flatMap((output) =>
                output === first.output ? [grouped] : plotOutputs.has(output) ? [] : [output],
            );
        }
        return outputs;
    }

    private async render(view: InteractiveView, id: string): Promise<void> {
        try {
            await this.renderOutputs(view, id);
        } finally {
            // OutputQueue reports delivery failures separately. Completion
            // still reflects R's result and must release the execution handle.
            const execution = view.executions.get(id),
                record = view.model.cells.get(id)?.record;
            if (
                !view.disposed &&
                !view.outputQueue.has(id) &&
                execution &&
                record &&
                !['queued', 'running'].includes(record.state)
            ) {
                // The live timer includes output delivery. End it when the last
                // notebook update completes, rather than backdating it to R's
                // earlier completion event. Keep the journal's R timing intact.
                const endTime = Math.max(execution.startTime ?? 0, Date.now());
                execution.task.end(
                    record.state === 'success'
                        ? true
                        : record.state === 'error'
                          ? false
                          : undefined,
                    endTime,
                );
                view.executions.delete(id);
                if (execution.startTime !== undefined) {
                    const key = `${view.client.manifest.id}:${view.model.generation}:${id}`;
                    this.executionTimings.delete(key);
                    this.executionTimings.set(key, { startTime: execution.startTime, endTime });
                    while (this.executionTimings.size > 1000) {
                        this.executionTimings.delete(
                            this.executionTimings.keys().next().value as string,
                        );
                    }
                    this.timingWrites.schedule('executionTimings', true);
                }
            }
        }
    }

    private async renderOutputs(view: InteractiveView, id: string): Promise<void> {
        if (view.disposed || view.notebook.isClosed) {
            return;
        }
        const data = this.transcriptCell(view, id);
        if (!data || !this.cell(view, id)) {
            return;
        }
        // Admission can precede R's start event by an arbitrary queue/startup delay.
        // Keep VS Code's execution pending; output mutation requires start().
        if (
            data.record.state === 'queued' ||
            (view.executions.get(id)?.started === false && !data.outputs.length)
        ) {
            return;
        }
        // Rendering may await asset reads while the transcript receives newer
        // events. Snapshot mutable streams and defer obsolete output writes.
        const streamSnapshots = new Map(
            data.outputs.flatMap((output) =>
                output.stream ? [[output.stream, output.stream.snapshot()] as const] : [],
            ),
        );
        const snapshot = {
            ...data,
            outputs: data.outputs.map((output) => {
                const stream = output.stream && streamSnapshots.get(output.stream);
                return {
                    ...output,
                    data: stream
                        ? {
                              channel: output.data.channel,
                              get text() {
                                  return stream.text();
                              },
                          }
                        : output.data,
                };
            }),
        };
        const outputs = await this.outputs(view, snapshot, false, streamSnapshots);
        // Asset reads can outlive detach or reconnection. Re-read the live handle.
        if (view.disposed || view.notebook.isClosed || view.outputQueue.has(id)) {
            return;
        }
        const cell = this.cell(view, id);
        if (!cell) {
            return;
        }
        const execution = view.executions.get(id);
        view.outputState ??= new NotebookOutputState();
        if (execution) {
            // A dispatch failure may have diagnostics but no R start event.
            if (!execution.started) {
                execution.startTime = snapshot.record.started ?? Date.now();
                execution.task.start(execution.startTime);
                execution.started = true;
            }
            await updateNotebookOutputs(
                execution.task,
                cell.outputs,
                outputs,
                view.outputState,
                () => cell.outputs,
            );
        } else {
            // Updating a late plot must preserve the cell URI, edited code, selection, and diagnostics.
            const summary = cell.executionSummary;
            const update = view.controller.createNotebookCellExecution(cell);
            update.executionOrder = summary?.executionOrder;
            update.start(summary?.timing?.startTime);
            try {
                await updateNotebookOutputs(
                    update,
                    cell.outputs,
                    outputs,
                    view.outputState,
                    () => cell.outputs,
                );
            } finally {
                update.end(summary?.success, summary?.timing?.endTime);
            }
        }
    }

    private async prompt(view: InteractiveView, input: Record<string, unknown>): Promise<void> {
        const client = view.client;
        const id = Number(input.inputId);
        if (view.prompts.has(id) || view.disposed) {
            return;
        }
        view.prompts.add(id);
        const value = await vscode.window.showInputBox({
            title: `${view.client.manifest.label}: R input`,
            prompt: typeof input.prompt === 'string' ? input.prompt : 'Input',
            ignoreFocusOut: true,
        });
        if (view.client !== client) {
            return;
        }
        view.prompts.delete(id);
        if (value !== undefined && view.client === client && !view.restarting) {
            try {
                await view.client.request('input', { id, executionId: input.executionId, value });
            } catch (error) {
                this.report(error);
            }
        }
    }

    private async resumeInput(view: InteractiveView): Promise<void> {
        const snapshot = await view.client.snapshot(1);
        if (snapshot.input) {
            await this.prompt(view, snapshot.input);
        }
    }

    private async clientRequest(
        view: InteractiveView,
        data: Record<string, unknown>,
    ): Promise<void> {
        const client = view.client;
        const params = object(data.params ?? {});
        try {
            const result = await session.handleEditorRequest(String(data.method), params);
            await client.request('clientReply', { id: data.id, result });
        } catch (error) {
            await client
                .request('clientReply', { id: data.id, error: String(error) })
                .catch(() => undefined);
        }
    }

    private async rendererMessage(
        editor: vscode.NotebookEditor,
        message: Record<string, unknown>,
    ): Promise<void> {
        const view = [...this.views.values()].find((item) => item.notebook === editor.notebook);
        if (!view) {
            return;
        }
        const cells = this.transcriptCells(view).filter((cell) =>
            message.generation
                ? cell.generation === message.generation
                : cell.generation === view.model.generation,
        );
        const owner = cells.find((cell) =>
            cell.outputs.some(
                (item) => item.type === 'display' && item.data.displayId === message.displayId,
            ),
        );
        const output = owner?.outputs.find(
            (item) => item.type === 'display' && item.data.displayId === message.displayId,
        );
        if (!owner || !output) {
            return;
        }
        const data = output.data;
        try {
            if (
                (message.action === 'tableView' &&
                    data.kind === 'table' &&
                    ['table', 'text'].includes(String(message.mode))) ||
                (message.action === 'listView' &&
                    data.kind === 'list' &&
                    ['list', 'text'].includes(String(message.mode))) ||
                (message.action === 'plotPage' &&
                    ['plot', 'image'].includes(String(data.kind)) &&
                    owner?.outputs.some(
                        (item) =>
                            item.type === 'display' &&
                            ['plot', 'image'].includes(String(item.data.kind)) &&
                            item.data.displayId === message.selectedPlot,
                    ))
            ) {
                const key = `${view.client.manifest.id}:${owner.generation}:${String(data.displayId)}`;
                const preference =
                    message.action === 'tableView'
                        ? { tableView: String(message.mode) }
                        : message.action === 'listView'
                          ? { listView: String(message.mode) }
                          : { selectedPlot: String(message.selectedPlot) };
                this.outputViews.delete(key);
                this.outputViews.set(key, preference);
                while (this.outputViews.size > 1000) {
                    this.outputViews.delete(this.outputViews.keys().next().value as string);
                }
                await this.context.workspaceState.update('r.interactive.outputViews', [
                    ...this.outputViews,
                ]);
                return;
            }
            if (
                [
                    'table',
                    'page',
                    'list',
                    'listPage',
                    'listNavigate',
                    'listItem',
                    'resize',
                ].includes(String(message.action)) &&
                ['exited', 'stopping'].includes(view.client.manifest.status)
            ) {
                throw new Error(
                    'R has stopped. Start a new session and run the code again to use live controls.',
                );
            }
            if (
                [
                    'table',
                    'page',
                    'list',
                    'listPage',
                    'listNavigate',
                    'listItem',
                    'resize',
                ].includes(String(message.action)) &&
                (view.restarting || owner?.generation !== view.model.generation)
            ) {
                throw new Error(
                    'This output belongs to a previous R process. Run its code again to use live controls.',
                );
            }
            let result: unknown;
            switch (message.action) {
                case 'table':
                    if (data.kind !== 'table') {
                        return;
                    }
                    await session.showDataView(
                        'table',
                        'json',
                        `${view.client.manifest.label}: ${data.fullViewId ? 'full table' : 'table'}`,
                        '',
                        'Beside',
                        String(data.fullViewId ?? data.viewId),
                        undefined,
                        view.target?.sessionId ?? null,
                    );
                    break;
                case 'page': {
                    if (data.kind !== 'table') {
                        return;
                    }
                    result = await queryTablePage(data, message, (request) =>
                        view.client.request('inspect', request),
                    );
                    break;
                }
                case 'list':
                case 'listPage':
                case 'listNavigate':
                case 'listItem': {
                    if (data.kind !== 'list') {
                        return;
                    }
                    const listPath = message.path ?? [];
                    if (
                        !Array.isArray(listPath) ||
                        !listPath.every((index) => Number.isSafeInteger(index) && index > 0)
                    ) {
                        throw new Error('Invalid list path');
                    }
                    const params = { view_id: data.viewId, path: listPath };
                    if (message.action === 'listPage') {
                        if (!Number.isSafeInteger(message.start) || Number(message.start) < 1) {
                            throw new Error('Invalid list page');
                        }
                        result = await view.client.request('inspect', {
                            method: 'workspace_children',
                            params: { ...params, start: message.start },
                        });
                    } else {
                        if (
                            message.action === 'listItem' &&
                            (!Number.isSafeInteger(message.index) || Number(message.index) < 1)
                        ) {
                            throw new Error('Invalid list index');
                        }
                        const navigation = await view.client.request<ListViewNavigation | boolean>(
                            'inspect',
                            {
                                method:
                                    message.action === 'listItem'
                                        ? 'listview_view'
                                        : 'listview_navigate',
                                params: { ...params, index: message.index },
                            },
                        );
                        if (!navigation) {
                            throw new Error(
                                'Unable to open this item. Check the R session and try again.',
                            );
                        }
                        if (
                            typeof navigation === 'object' &&
                            Array.isArray(navigation.breadcrumbs)
                        ) {
                            if (message.action === 'list') {
                                await session.showDataView(
                                    'list',
                                    'json',
                                    `${view.client.manifest.label}: ${navigation.title}`,
                                    '',
                                    'Beside',
                                    String(data.viewId),
                                    navigation,
                                    view.target.sessionId,
                                );
                            } else {
                                result = { navigation };
                            }
                        }
                    }
                    break;
                }
                case 'resize':
                    if (data.kind !== 'plot') {
                        return;
                    }
                    await view.client.request('resize', {
                        device: data.device,
                        plot: data.plot,
                        width: message.width,
                        height: message.height,
                    });
                    break;
                case 'saveAs': {
                    if (!['plot', 'image'].includes(String(data.kind))) {
                        return;
                    }
                    const formats = [
                        ...(data.kind === 'plot' || data.mime === 'image/svg+xml'
                            ? [
                                  {
                                      label: 'SVG (.svg)',
                                      description: 'Scalable vector image',
                                      format: 'svg',
                                  },
                              ]
                            : []),
                        ...(message.pngReady === true
                            ? [{ label: 'PNG (.png)', description: 'Raster image', format: 'png' }]
                            : []),
                    ];
                    result = (
                        await vscode.window.showQuickPick(formats, {
                            title: 'Save R plot as',
                            placeHolder: 'Choose an image format',
                        })
                    )?.format;
                    break;
                }
                case 'save':
                case 'savePng': {
                    if (!['plot', 'image'].includes(String(data.kind))) {
                        return;
                    }
                    const png = message.action === 'savePng';
                    if (!png && data.kind === 'image' && data.mime !== 'image/svg+xml') {
                        return;
                    }
                    const pages =
                        owner?.outputs.filter(
                            (item) =>
                                item.type === 'display' &&
                                ['plot', 'image'].includes(String(item.data.kind)),
                        ) ?? [];
                    const pageSuffix = pages.length > 1 ? `-${pages.indexOf(output) + 1}` : '';
                    const file = await vscode.window.showSaveDialog({
                        defaultUri: this.defaultExportUri(
                            view,
                            `plot-${owner?.record.order ?? 1}${pageSuffix}.${png ? 'png' : 'svg'}`,
                        ),
                        filters: png ? { PNG: ['png'] } : { SVG: ['svg'] },
                    });
                    if (!file) {
                        return;
                    }
                    let bytes: Buffer;
                    if (png) {
                        if (
                            typeof message.image !== 'string' ||
                            !/^data:image\/png;base64,[A-Za-z0-9+/=]+$/.test(message.image) ||
                            message.image.length > 32 * 1024 * 1024
                        ) {
                            throw new Error('Invalid PNG export');
                        }
                        bytes = Buffer.from(
                            message.image.slice('data:image/png;base64,'.length),
                            'base64',
                        );
                    } else if (data.svg || data.asset) {
                        bytes = readAsset(
                            path.join(this.root, view.client.manifest.id, 'assets'),
                            String(data.svg ?? data.asset),
                        );
                    } else {
                        bytes = Buffer.from(String(data.data), 'base64');
                    }
                    await vscode.workspace.fs.writeFile(file, bytes);
                    break;
                }
                case 'plot':
                case 'open': {
                    await this.openOutput(view, data);
                    break;
                }
            }
            await this.messages.postMessage(
                {
                    outputId: message.outputId,
                    action: message.action,
                    requestId: message.requestId,
                    result,
                },
                editor,
            );
        } catch (error) {
            await this.messages.postMessage(
                {
                    outputId: message.outputId,
                    action: message.action,
                    requestId: message.requestId,
                    error: String(error),
                },
                editor,
            );
        }
    }

    private reconnect(view: InteractiveView, delay: number): void {
        if (view.disposed || this.closed || view.restarting) {
            return;
        }
        clearTimeout(view.reconnectTimer);
        view.reconnectTimer = setTimeout(() => {
            view.chain = view.chain.then(async () => {
                if (view.disposed || view.restarting) {
                    return;
                }
                try {
                    const latest = discoverSessions(this.root).find(
                        (item) => item.id === view.client.manifest.id,
                    );
                    if (latest && latest.generation !== view.model.generation) {
                        this.output.appendLine(
                            `${latest.label}: a new R generation is available. Reconnect from Interactive Sessions.`,
                        );
                        return;
                    }
                    if (latest) {
                        view.client.manifest = latest;
                    }
                    await view.client.connect();
                    if (view.client.manifest.assetBase) {
                        view.base = (
                            await vscode.env.asExternalUri(
                                vscode.Uri.parse(view.client.manifest.assetBase),
                            )
                        ).toString(true);
                    }
                    if (!(await view.client.subscribe(view.model.seq))) {
                        await this.restore(view, await view.client.snapshot());
                        await view.client.subscribe(view.model.seq);
                    }
                    if (this.active === view) {
                        await this.activate(view);
                    }
                } catch {
                    this.reconnect(view, Math.min(delay * 2, 30000));
                }
            });
        }, delay);
    }

    private async detach(view: InteractiveView): Promise<void> {
        try {
            if (view.client.connected) {
                await view.client.request('detach');
            }
        } finally {
            this.disposeView(view);
        }
    }

    private async stop(view: InteractiveView): Promise<void> {
        const answer = await vscode.window.showWarningMessage(
            `Stop R session “${view.client.manifest.label}”? Its in-memory objects will be lost.`,
            { modal: true },
            'Stop Session',
        );
        if (answer === 'Stop Session') {
            await view.client.request('stop');
        }
    }

    private async stopMultiple(all: boolean, value?: unknown, selection?: unknown): Promise<void> {
        if (!vscode.workspace.isTrusted) {
            throw new Error('Trust this workspace before stopping R sessions');
        }
        const isManifest = (item: unknown): item is SessionManifest =>
            !!item &&
            typeof item === 'object' &&
            typeof (item as SessionManifest).id === 'string' &&
            typeof (item as SessionManifest).generation === 'string';
        // Tree actions can supply both the focused item and its selection; palette commands supply neither.
        const selected =
            !all && isManifest(value)
                ? Array.isArray(selection) && selection.length
                    ? selection.filter(isManifest)
                    : [value]
                : undefined;
        this.refresh();
        let targets = selected ?? (await runningSessions(this.manifests));
        if (!all && !selected && targets.length) {
            const choices = targets.map((manifest) => ({
                label: manifest.label,
                description: this.sessionChoiceDescription(manifest),
                detail: `${manifest.directory} · ${manifest.host} · ${manifest.id.slice(0, 8)}`,
                manifest,
            }));
            const picked = await vscode.window.showQuickPick(choices, {
                canPickMany: true,
                matchOnDescription: true,
                matchOnDetail: true,
                title: 'Stop Selected Interactive Sessions',
                placeHolder: 'Select the R sessions to stop',
            });
            if (!picked?.length) {
                return;
            }
            targets = picked.map((item) => item.manifest);
        }
        // Freeze identities before confirmation: a restart or a newly created session must never become a target.
        targets = [
            ...new Map(
                targets
                    .filter((manifest) => !['exited', 'stopping'].includes(manifest.status))
                    .map((manifest) => [`${manifest.id}:${manifest.generation}`, { ...manifest }]),
            ).values(),
        ];
        if (!targets.length) {
            void vscode.window.showInformationMessage('No running R Interactive sessions to stop.');
            return;
        }
        const label = targets.length === 1 ? 'Stop Session' : `Stop ${targets.length} Sessions`;
        const detail = [
            'Their in-memory objects will be lost. Transcripts and saved output will be retained.',
            targets
                .map(
                    (manifest) =>
                        `${manifest.label} — PID ${manifest.rPid ?? 'starting'} · ${manifest.id.slice(0, 8)}\n${manifest.directory}`,
                )
                .join('\n\n'),
            ...(targets.some(
                (manifest) =>
                    manifest.ownership === 'adopted' ||
                    (!manifest.ownership && manifest.provider === 'arf-existing'),
            )
                ? ['Stopping an attached arf session also ends its R process.']
                : []),
            'Sessions controlled by another VS Code window will be skipped. Take Control of those sessions before retrying.',
        ].join('\n\n');
        const confirmed = await vscode.window.showWarningMessage(
            `Stop ${targets.length} R Interactive session${targets.length === 1 ? '' : 's'}?`,
            { modal: true, detail },
            label,
        );
        if (confirmed !== label || this.closed) {
            return;
        }
        const stopped = new Set<string>();
        const failures: string[] = [];
        await vscode.window.withProgress(
            {
                location: vscode.ProgressLocation.Notification,
                title: 'Stopping R Interactive sessions',
            },
            async (progress) => {
                for (let i = 0; i < targets.length; i += 4) {
                    const results = await Promise.allSettled(
                        targets.slice(i, i + 4).map(async (manifest) => {
                            if (
                                this.views.get(`${manifest.id}:${manifest.generation}`)?.restarting
                            ) {
                                throw new Error('Session is restarting; retry when it is ready.');
                            }
                            await stopSession(manifest, this.clientId);
                        }),
                    );
                    results.forEach((result, index) => {
                        const manifest = targets[i + index];
                        if (result.status === 'fulfilled') {
                            stopped.add(`${manifest.id}:${manifest.generation}`);
                        } else {
                            failures.push(
                                `${manifest.label} (PID ${manifest.rPid ?? 'starting'}): ${String(result.reason)}`,
                            );
                        }
                    });
                    progress.report({
                        increment: (results.length / targets.length) * 100,
                        message: `${i + results.length} of ${targets.length} checked`,
                    });
                }
            },
        );
        this.refresh();
        // An unopened session's agent shuts down when the temporary client closes.
        // Its socket can still exist during refresh; do not leave an unusable tree link.
        this.manifests = this.manifests.filter((manifest) => {
            const key = `${manifest.id}:${manifest.generation}`;
            return !stopped.has(key) || this.views.has(key);
        });
        this.changes.fire(undefined);
        const summary = `Stopped ${stopped.size} of ${targets.length} R Interactive sessions.`;
        if (failures.length) {
            this.output.appendLine(`${summary}\n${failures.join('\n')}`);
            const details = 'Show Details';
            if (
                (await vscode.window.showWarningMessage(
                    `${summary} ${failures.length} could not be stopped.`,
                    details,
                )) === details
            ) {
                this.output.show(true);
            }
        } else {
            void vscode.window.showInformationMessage(summary);
        }
    }

    private noticeData(
        view: InteractiveView,
        state: 'stopped' | 'restarting' | 'restarted' | 'restartFailed',
        generation = view.model.generation,
    ): vscode.NotebookCellData {
        const messages = {
            stopped: [
                'R session stopped',
                'This R process has ended. The transcript is retained. Restart the session or choose another execution target to continue.',
            ],
            restarting: [
                'Restarting R session…',
                'The R process is being replaced. Your transcript and input stay in this window.',
            ],
            restarted: [
                'R session restarted',
                'Continue here in a fresh R process. Previous code and output are retained above; objects from the previous process are no longer available.',
            ],
            restartFailed: [
                'R session restart did not complete',
                'The previous transcript is retained. Check the R Interactive output channel and session list before trying again.',
            ],
        };
        const [title, body] = messages[state];
        // appendText escapes spaces as NBSP; use it only for the untrusted session name.
        const markdown = new vscode.MarkdownString()
            .appendMarkdown(`**${title}**\n\n`)
            .appendText(view.client.manifest.label)
            .appendMarkdown(` — ${body}`);
        const data = new vscode.NotebookCellData(
            vscode.NotebookCellKind.Markup,
            markdown.value,
            'markdown',
        );
        data.metadata = persistentCellMetadata(
            { rSessionNotice: generation, rNoticeKind: state },
            'markdown',
        );
        return data;
    }

    private async sessionNotice(
        view: InteractiveView,
        state: Parameters<InteractiveManager['noticeData']>[1],
        generation = view.model.generation,
    ): Promise<void> {
        if (view.notebook.isClosed) {
            return;
        }
        const previous = view.notebook
            .getCells()
            .find((cell) => cell.metadata.rSessionNotice === generation);
        const data = this.noticeData(view, state, generation);
        const edit = new vscode.WorkspaceEdit();
        edit.set(view.notebook.uri, [
            previous
                ? vscode.NotebookEdit.replaceCells(
                      new vscode.NotebookRange(previous.index, previous.index + 1),
                      [data],
                  )
                : vscode.NotebookEdit.insertCells(view.notebook.cellCount, [data]),
        ]);
        await vscode.workspace.applyEdit(edit);
    }

    private queueNotice(
        view: InteractiveView,
        state: Parameters<InteractiveManager['noticeData']>[1],
        generation = view.model.generation,
    ): Promise<void> {
        view.chain = view.chain.then(() => this.sessionNotice(view, state, generation));
        return view.chain;
    }

    private async restart(view: InteractiveView): Promise<void> {
        if (view.restarting) {
            return;
        }
        if (
            !(
                view.client.manifest.capabilities.restart ??
                view.client.manifest.provider !== 'arf-existing'
            )
        ) {
            throw new Error(
                'Restart adopted arf from its original terminal or session manager, then reconnect to the new process',
            );
        }
        view.restarting = true;
        this.updateStatus();
        const generation = view.model.generation;
        let announced = false;
        try {
            const answer = await vscode.window.showWarningMessage(
                `Restart R session “${view.client.manifest.label}”? Its in-memory objects will be lost. Code, output, and input will stay in this Interactive window.`,
                { modal: true },
                'Restart Session',
            );
            if (answer !== 'Restart Session' || view.disposed) {
                return;
            }
            const storage = path.join(this.root, view.client.manifest.id);
            let config = JSON.parse(
                fs.readFileSync(path.join(storage, 'config.json'), 'utf8'),
            ) as AgentConfig;
            // Re-evaluate auto and honor repaired settings; the saved config records
            // the actual supervisor of the old process, not the current preference.
            config.supervision = util
                .config(vscode.Uri.file(config.directory))
                .get<string>('interactive.supervision', 'auto');
            prepareSupervisor(config.supervision, config.directory);
            const node = await this.nodeRuntime(config.directory);
            const backend = backendDescriptor(config);
            if (
                backend.kind === 'sess' &&
                backend.options.frontend === 'arf' &&
                backend.options.ownership === 'managed'
            ) {
                // Preserve the original binary across PATH changes after a reload, but
                // allow a repaired setting to replace a removed/moved executable.
                const command =
                    resolveArfExecutable(
                        typeof backend.options.arfPath === 'string'
                            ? backend.options.arfPath
                            : 'arf',
                        config.directory,
                    ) ?? this.arfCommand(vscode.Uri.file(config.directory));
                const arfPath = this.checkArfExecutable(command, config.directory, true);
                if (!arfPath) {
                    return;
                }
                backend.options = { ...backend.options, arfPath };
            }
            config.backend = backend;
            const runtime = await prepareBackendRuntime(config, {
                extensionPath: this.context.extensionPath,
                root: this.root,
                log: (text) => this.output.append(text),
            });
            config = runtime.config;
            Object.assign(config, this.retentionLimits());
            config.previousGenerations = [
                ...view.history.map((model) => model.generation),
                generation,
            ];
            config.generation = randomUUID();
            if (view.disposed) {
                return;
            }
            if (
                backend.kind === 'sess' &&
                backend.options.frontend === 'arf' &&
                backend.options.ownership === 'managed' &&
                !this.checkArfExecutable(
                    typeof runtime.config.backend?.options.arfPath === 'string'
                        ? runtime.config.backend.options.arfPath
                        : 'arf',
                    config.directory,
                    true,
                )
            ) {
                return;
            }
            prepareSupervisor(config.supervision, config.directory);
            clearTimeout(view.reconnectTimer);
            announced = true;
            await this.queueNotice(view, 'restarting');
            if (view.client.connected) {
                await view.client.request('stop');
                // Wait for the old runtime to publish its final state before its successor.
                for (let i = 0; i < 100; i++) {
                    const state = await view.client.request<{ status: string }>('heartbeat');
                    if (state.status === 'exited') {
                        break;
                    }
                    if (i === 99) {
                        throw new Error('The previous R process has not exited');
                    }
                    await new Promise((resolve) => setTimeout(resolve, 100));
                }
                await view.client.request('shutdown');
            } else if (view.client.manifest.status !== 'exited') {
                throw new Error('Reconnect to the R session before restarting it.');
            }
            await view.chain;
            await view.outputQueue.flush();
            for (const { task } of view.executions.values()) {
                task.end(undefined);
            }
            view.executions.clear();
            view.client.close();
            const manifest = await launchAgent(config, runtime.agent, node, (text) =>
                this.output.appendLine(text),
            );
            if (view.disposed) {
                return;
            }
            this.views.delete(`${manifest.id}:${generation}`);
            view.history.push(view.model);
            view.model = new Transcript(manifest.generation);
            view.client = new AgentClient(manifest, this.clientId);
            this.views.set(`${manifest.id}:${manifest.generation}`, view);
            const target = this.registerTarget(view.client);
            session.replaceSessionTransport(view.target, target);
            view.target = target;
            this.listen(view, view.client);
            await view.client.connect();
            const deadline = Date.now() + 30000;
            while (
                (await view.client.request<{ status: string }>('heartbeat')).status === 'starting'
            ) {
                if (Date.now() >= deadline) {
                    throw new Error('The replacement R process has not become ready');
                }
                await new Promise((resolve) => setTimeout(resolve, 100));
            }
            const snapshot = await view.client.snapshot();
            view.client.manifest = snapshot.manifest;
            target.pid = String(snapshot.manifest.rPid ?? '');
            target.rVer = snapshot.manifest.rVersion ?? '';
            target.processExited = snapshot.manifest.status === 'exited';
            target.rPath = snapshot.manifest.rPath;
            target.libraryPaths = snapshot.manifest.libraryPaths;
            view.prompts.clear();
            if (snapshot.workspace) {
                target.workspaceData = snapshot.workspace as unknown as session.WorkspaceData;
            }
            view.base = snapshot.manifest.assetBase
                ? (
                      await vscode.env.asExternalUri(vscode.Uri.parse(snapshot.manifest.assetBase))
                  ).toString(true)
                : '';
            view.model.restore(snapshot);
            const edit = new vscode.WorkspaceEdit();
            edit.set(view.notebook.uri, [
                vscode.NotebookEdit.updateNotebookMetadata(
                    persistentNotebookMetadata(
                        view.notebook.metadata,
                        manifest.id,
                        manifest.generation,
                    ),
                ),
            ]);
            await vscode.workspace.applyEdit(edit);
            await this.queueNotice(view, 'restarted', generation);
            if (view.model.cells.size) {
                const cells = await Promise.all(
                    [...view.model.cells.values()].map((cell) => this.cellData(view, cell)),
                );
                const insert = new vscode.WorkspaceEdit();
                insert.set(view.notebook.uri, [
                    vscode.NotebookEdit.insertCells(view.notebook.cellCount, cells),
                ]);
                await vscode.workspace.applyEdit(insert);
                for (const cell of view.notebook.getCells()) {
                    session.bindSessionDocument(cell.document.uri, target);
                }
            }
            // Refresh asset URLs and disable process-specific controls without replacing old cells.
            for (const cell of this.transcriptCells(view)) {
                if (cell.outputs.some((output) => output.type === 'display')) {
                    view.outputQueue.schedule(cell.record.id);
                }
            }
            await view.outputQueue.flush();
            if (snapshot.manifest.status === 'exited') {
                throw new Error('The replacement R process exited during startup');
            }
            if (!(await view.client.subscribe(view.model.seq))) {
                await this.restore(view, await view.client.snapshot());
                await view.client.subscribe(view.model.seq);
            }
            if (this.active === view) {
                await this.activate(view);
            }
        } catch (error) {
            if (announced) {
                await this.queueNotice(view, 'restartFailed', generation);
            }
            throw error;
        } finally {
            view.restarting = false;
            this.refresh();
            if (!view.client.connected && view.client.manifest.status !== 'exited') {
                this.reconnect(view, 1000);
            }
        }
    }

    private async exportHistory(view: InteractiveView): Promise<void> {
        // macOS uses only the first save-dialog filter and otherwise appends .rnb
        // even when the user types another supported suffix. Choose the format first.
        const selected = await vscode.window.showQuickPick(
            [
                {
                    label: 'R Interactive notebook (.rnb)',
                    description: 'Reopen cells and retained output in VS Code',
                    format: 'rnb',
                },
                {
                    label: 'Jupyter notebook (.ipynb)',
                    description: 'Portable notebook with standard output formats',
                    format: 'ipynb',
                },
                { label: 'R script (.R)', description: 'Code and session boundaries', format: 'R' },
                {
                    label: 'HTML report (.html)',
                    description: 'Share output and interactive widgets in a browser',
                    format: 'html',
                },
            ],
            {
                title: `Export history: ${view.client.manifest.label}`,
                placeHolder: 'Choose an export format',
            },
        );
        if (!selected) {
            return;
        }
        const file = await vscode.window.showSaveDialog({
            defaultUri: this.defaultExportUri(view, `history.${selected.format}`),
            filters: { [selected.label]: [selected.format] },
        });
        if (!file) {
            return;
        }
        const entries = [...view.history, view.model].flatMap<TranscriptCell | string>((model) => [
            ...model.cells.values(),
            ...(model === view.model ? [] : [model.generation]),
        ]);
        const cells = entries.filter((entry): entry is TranscriptCell => typeof entry !== 'string');
        if (selected.format === 'R') {
            await vscode.workspace.fs.writeFile(
                file,
                Buffer.from(
                    entries
                        .map((entry) =>
                            typeof entry === 'string'
                                ? '# R session restarted — fresh R process; previous objects are unavailable.'
                                : `# %% ${entry.record.order}: ${entry.record.state}\n${entry.record.code}`,
                        )
                        .join('\n\n'),
                ),
            );
            return;
        }
        if (selected.format === 'html') {
            const sections: string[] = [];
            const assetFolder = `${file.fsPath}.assets`;
            const assets = new AssetStore(path.join(this.root, view.client.manifest.id, 'assets'));
            assets.exportTo(
                assetFolder,
                cells.flatMap((cell) =>
                    cell.outputs.flatMap((output) =>
                        [output.data.svg, output.data.asset].filter(
                            (id): id is string => typeof id === 'string',
                        ),
                    ),
                ),
            );
            for (const cell of entries) {
                if (typeof cell === 'string') {
                    sections.push(
                        '<p><strong>R session restarted</strong> — fresh R process; previous objects are unavailable.</p>',
                    );
                    continue;
                }
                sections.push(`<section><pre><code>${escapeXml(cell.record.code)}</code></pre>`);
                for (const output of cell.outputs) {
                    const data = output.data;
                    if (data.svg || data.asset) {
                        const url = `${encodeURIComponent(path.basename(assetFolder))}/${exportedAssetName(String(data.svg ?? data.asset))}`;
                        sections.push(
                            data.svg || data.kind === 'image'
                                ? `<img src="${escapeXml(url)}" style="max-width:100%">`
                                : `<iframe sandbox="allow-scripts" src="${escapeXml(url)}" style="width:100%;height:500px;border:0"></iframe>`,
                        );
                    } else if (data.kind === 'table') {
                        const preference = this.outputViews.get(
                            `${view.client.manifest.id}:${cell.generation}:${String(data.displayId)}`,
                        );
                        if (
                            (preference?.tableView ??
                                util.config().get('interactive.tableView', 'table')) === 'text' &&
                            typeof data.printedText === 'string'
                        ) {
                            sections.push(`<pre>${escapeXml(data.printedText)}</pre>`);
                            continue;
                        }
                        const columns = data.columns as {
                            field: string;
                            headerName: string;
                            type?: unknown;
                        }[];
                        const rows = data.rows as Record<string, unknown>[];
                        sections.push(
                            `<table><tr>${columns.map((column) => `<th style="text-align:${tableColumnAlignment(data, column)}">${escapeXml(column.headerName)}</th>`).join('')}</tr>${rows.map((row, rowIndex) => `<tr>${columns.map((column) => `<td style="text-align:${tableColumnAlignment(data, column)}">${escapeXml(tableDisplayValue(data, row, column.field, rowIndex))}</td>`).join('')}</tr>`).join('')}</table><p>${tableSnapshotSummary(data) || `${String(data.totalRows)} rows (preview)`}</p>`,
                        );
                    } else if (data.kind === 'list') {
                        sections.push(
                            `<pre>${escapeXml(data.printedText ?? JSON.stringify(data.children, null, 2))}</pre>`,
                        );
                    } else if (data.kind === 'mime' && data.mime === 'text/html') {
                        sections.push(
                            `<iframe sandbox="allow-scripts" srcdoc="${escapeXml(String(data.text))}" style="width:100%;height:500px;border:0"></iframe>`,
                        );
                    } else {
                        sections.push(
                            `<pre>${escapeXml(data.text ?? data.message ?? JSON.stringify(data, null, 2))}</pre>`,
                        );
                    }
                }
                sections.push('</section>');
            }
            await vscode.workspace.fs.writeFile(
                file,
                Buffer.from(
                    `<!doctype html><meta charset="utf-8"><title>R Interactive</title><style>body{max-width:1100px;margin:30px auto;font:14px system-ui}pre{white-space:pre-wrap;background:#f5f5f5;padding:16px}section{margin-bottom:32px}</style>${sections.join('\n')}`,
                ),
            );
            return;
        }
        const exported: vscode.NotebookCellData[] = [];
        for (const model of [...view.history, view.model]) {
            for (const cell of model.cells.values()) {
                exported.push(await this.cellData(view, cell, true));
            }
            if (model !== view.model) {
                exported.push(this.noticeData(view, 'restarted', model.generation));
            }
        }
        const notebook = new vscode.NotebookData(exported);
        notebook.metadata = {
            rSessionId: view.client.manifest.id,
            rGeneration: view.client.manifest.generation,
        };
        await vscode.workspace.fs.writeFile(
            file,
            selected.format === 'ipynb'
                ? this.serializer.exportIpynb(notebook)
                : this.serializer.serializeNotebook(notebook),
        );
    }

    private disposeView(view: InteractiveView, forget = true): void {
        if (view.disposed) {
            return;
        }
        view.disposed = true;
        view.outputQueue.dispose();
        clearTimeout(view.reconnectTimer);
        view.client.close();
        for (const { task } of view.executions.values()) {
            task.end(undefined);
        }
        view.executions.clear();
        for (const controller of view.controllers) {
            controller.dispose();
        }
        session.unregisterSessionTransport(view.target);
        this.views.delete(`${view.client.manifest.id}:${view.client.manifest.generation}`);
        if (this.active === view) {
            this.active = undefined;
            this.routing = false;
            this.status.hide();
            void vscode.commands.executeCommand('setContext', 'r.interactive.active', false);
            void vscode.commands.executeCommand(
                'setContext',
                'r.WorkspaceViewer:show',
                util.config().get<boolean>('sessionWatcher', false),
            );
        }
        if (!this.closed && forget) {
            this.savedConnections.delete(view.client.manifest.id);
            void this.saveConnections();
        }
    }

    dispose(): void {
        this.closed = true;
        // Already scheduled timing writes may drain after the views close.
        setInteractiveExecutor(undefined);
        for (const view of this.views.values()) {
            this.disposeView(view);
        }
        for (const disposable of this.disposables) {
            disposable.dispose();
        }
        this.changes.dispose();
        this.output.dispose();
    }
}