@volter/supercode-frontend-vscode 0.1.11

package/dist/extension.js

@@ -0,0 +1,1131 @@
+import { resolveSessionBinding } from './bindings.js';
+import { withTextContext } from './context.js';
+import { randomUUID } from 'node:crypto';
+import { ChatHostControls, runtimeIdentity, harnessDisplayName, turnPermission } from './host-controls.js';
+import * as vscode from 'vscode';
+import { createFrontendClient } from './client.js';
+import { readCredentialFile } from './credential.js';
+import { grantedProposals, PROPOSAL_EFFECTS, REQUESTED_PROPOSALS } from './proposals.js';
+import { observeActiveResponse, sessionStatus } from './native-session.js';
+import { RequestNotPendingError, VscodeFrontendSession } from './session.js';
+import { fence, acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
+const SESSION_SCHEME = 'supercode';
+const PARTICIPANT_ID = 'supercode.chat';
+const DEFAULT_PARTICIPANT_ID = 'supercode.chat.default';
+/** `package.json` gates the `isDefault` participant on this key. */
+const DEFAULT_PARTICIPANT_CONTEXT_KEY = 'supercodeChatDefaultParticipant';
+/** `chatViewsWelcome` shows the empty state until this is true. */
+const ATTACHED_CONTEXT_KEY = 'supercodeAttached';
+const PERMISSIONS = ['observe', 'interact', 'approve', 'terminate'];
+/** The environment a runtime uses to hand this frontend a live connection. */
+const ENV = Object.freeze({
+    url: 'SUPERCODE_FRONTEND_URL',
+    clientId: 'SUPERCODE_FRONTEND_CLIENT_ID',
+    credentialFile: 'SUPERCODE_FRONTEND_CREDENTIAL_FILE',
+    permissions: 'SUPERCODE_FRONTEND_PERMISSIONS',
+    /**
+     * Why there is no runtime to attach to, in the host's OWN words — "Install
+     * Claude Code and ensure `claude` is on PATH", "sign in with `codex login`".
+     * A host that could not start one knows exactly why and what to type; this
+     * frontend does not, and a chat panel that looks identical to the working
+     * case is how a person ends up typing into nothing.
+     */
+    unavailable: 'SUPERCODE_FRONTEND_UNAVAILABLE',
+});
+function normalizePermissions(value, fallback) {
+    const raw = Array.isArray(value)
+        ? value.map(String)
+        : typeof value === 'string'
+            ? value.split(',')
+            : [];
+    const permissions = raw
+        .map((entry) => entry.trim())
+        .filter((entry) => PERMISSIONS.includes(entry));
+    if (!permissions.includes('observe'))
+        permissions.unshift('observe');
+    return value === undefined || value === null ? fallback : permissions;
+}
+/** The one session item that stands for "there is no runtime, and here is why". */
+const UNAVAILABLE_PATH = '/unavailable';
+/**
+ * The prompt of the turn that carries a status this frontend is reporting.
+ * It names itself; nothing here is presented as a person's words.
+ */
+const STATUS_MARKER_PROMPT = '⟨supercode⟩';
+function unavailableResource() {
+    return vscode.Uri.from({ scheme: SESSION_SCHEME, authority: 'supercode', path: UNAVAILABLE_PATH });
+}
+function sessionResource(connection) {
+    const sessionId = 'conversation';
+    return vscode.Uri.from({ scheme: SESSION_SCHEME, authority: connection.id, path: `/${encodeURIComponent(sessionId)}` });
+}
+/**
+ * Every attachment this window holds. It owns no agent, no model and no
+ * session file: one generated client per runtime and nothing else.
+ */
+class SupercodeFrontends {
+    #connections = new Map();
+    #changed = new vscode.EventEmitter();
+    onDidChange = this.#changed.event;
+    /**
+     * Why there is no runtime, in the host's own words. Held here because it is
+     * shown the same way an attached runtime is — as a session in the picker
+     * whose content is that sentence — so a person reading the panel learns
+     * what to do instead of typing into nothing.
+     */
+    unavailable;
+    setUnavailable(reason) {
+        this.unavailable = reason?.trim() || undefined;
+        this.#changed.fire();
+    }
+    get all() {
+        return [...this.#connections.values()];
+    }
+    get(id) {
+        if (id)
+            return this.#connections.get(id);
+        return this.#connections.values().next().value;
+    }
+    info(connection) {
+        return {
+            id: connection.id,
+            baseUrl: connection.baseUrl,
+            label: connection.label,
+            sessionId: connection.session.descriptor?.session_id ?? null,
+            model: connection.session.descriptor?.model ?? null,
+            turnState: connection.session.descriptor?.turn_state ?? null,
+        };
+    }
+    async connect(options, log) {
+        // `{unavailable}` and no runtime: the host is telling this frontend why
+        // there is nothing to attach to. Record it and show it; do not attach.
+        if (!options.baseUrl || !options.token) {
+            if (options.unavailable) {
+                this.setUnavailable(options.unavailable);
+                log.info(`Volter Harness has no runtime: ${options.unavailable}`);
+                return undefined;
+            }
+            throw new TypeError('connect needs a baseUrl and token, or an `unavailable` reason');
+        }
+        const { baseUrl, token } = options;
+        const id = options.connectionId ?? options.clientId ?? `vscode-${randomUUID()}`;
+        const existing = this.#connections.get(id);
+        if (existing)
+            return existing;
+        const permissions = normalizePermissions(options.permissions, ['observe']);
+        const client = createFrontendClient({
+            baseUrl,
+            token,
+            clientId: options.clientId ?? id,
+            permissions,
+        });
+        const session = new VscodeFrontendSession(id, baseUrl, client, permissions);
+        // The generated client opens SSE before the snapshot RPC; `attach` is
+        // therefore the whole race-free attachment and `follow` only drains it.
+        await session.attach();
+        // An interactive attachment holds the runtime's controller lease; without
+        // it the first submit comes back `lease_expired`.
+        await session.takeControlAndHold().catch((error) => {
+            log.warn(`Volter Harness could not take control of ${baseUrl}: ${String(error?.message ?? error)}`);
+        });
+        // The runtime's stream can end under a live attachment: an HTTP client's
+        // body timeout ended an idle one at 300 s (the runtime sent no keep-alive),
+        // and the view went on showing a turn it would never see finish, with the
+        // next prompt queued behind it. While this connection is still the
+        // registered one, it re-attaches from its cursor and follows again.
+        let connection;
+        const stillWanted = () => connection !== undefined && this.#connections.get(id) === connection && session.connection !== 'closed';
+        const following = (async () => {
+            for (let attempt = 0;; attempt += 1) {
+                try {
+                    await session.follow();
+                }
+                catch (error) {
+                    log.warn(`Volter Harness event stream ended: ${String(error?.message ?? error)}`);
+                }
+                if (!stillWanted())
+                    return;
+                await new Promise((resolve) => setTimeout(resolve, Math.min(15_000, 500 * 2 ** Math.min(attempt, 5))));
+                if (!stillWanted())
+                    return;
+                try {
+                    await session.attach();
+                    attempt = -1;
+                    log.info(`Volter Harness re-attached to ${baseUrl} at event ${session.cursor}`);
+                }
+                catch (error) {
+                    log.warn(`Volter Harness could not re-attach to ${baseUrl}: ${String(error?.message ?? error)}`);
+                }
+            }
+        })();
+        connection = {
+            id,
+            label: options.label ?? session.descriptor?.session_id ?? baseUrl,
+            baseUrl,
+            session,
+            following,
+        };
+        session.onChange(() => this.#changed.fire());
+        this.#connections.set(id, connection);
+        this.#changed.fire();
+        this.setUnavailable(undefined);
+        log.info(`Volter Harness attached: ${connection.label} (${baseUrl}) as ${permissions.join(',')}` +
+            ` · ${session.history.length} history messages`);
+        return connection;
+    }
+    async disconnect(id) {
+        const targets = id ? [this.#connections.get(id)].filter(Boolean) : this.all;
+        for (const connection of targets) {
+            try {
+                if (connection.session.actions().detach)
+                    await connection.session.detach();
+            }
+            catch {
+                // Detaching is best effort; dropping the client never closes a runtime.
+            }
+            connection.session.dispose();
+            this.#connections.delete(connection.id);
+        }
+        this.#changed.fire();
+    }
+    dispose() {
+        for (const connection of this.all)
+            connection.session.dispose();
+        this.#connections.clear();
+        this.#changed.dispose();
+    }
+}
+function writeProjected(stream, projected, granted, state) {
+    for (const candidate of projected) {
+        const parts = resolveParts([candidate], granted);
+        for (const part of parts) {
+            try {
+                writePart(stream, part, state);
+            }
+            catch {
+                // A host that advertised the proposal but refuses the call still gets
+                // the stable rendering rather than a dropped event.
+                for (const fallback of candidate.fallback ?? []) {
+                    try {
+                        writePart(stream, fallback, state);
+                    }
+                    catch {
+                        stream.markdown(opaqueText(fallback));
+                    }
+                }
+            }
+        }
+    }
+}
+function writePart(stream, part, state) {
+    switch (part.part) {
+        case 'markdown':
+            stream.markdown(part.value);
+            return;
+        case 'progress':
+            stream.progress(part.value);
+            return;
+        case 'warning':
+            stream.warning(part.value);
+            return;
+        case 'codeblock':
+            stream.codeblockUri(vscode.Uri.parse(part.uri));
+            stream.markdown(part.value);
+            return;
+        case 'thinking':
+            stream.push(new vscode.ChatResponseThinkingProgressPart(part.value));
+            return;
+        case 'reference': {
+            // Only a path the runtime's own payload named, resolved against the
+            // workspace this window already has. Nothing is created or fabricated.
+            const folder = vscode.workspace.workspaceFolders?.[0];
+            if (folder)
+                stream.reference(vscode.Uri.joinPath(folder.uri, part.path));
+            else
+                stream.markdown(`\`${part.path}\``);
+            return;
+        }
+        case 'answers':
+            // Stable API on purpose: a command button runs INSIDE the live turn,
+            // which is when a supercode approval is raised. See `view.ts`.
+            stream.markdown(`\n\n**${part.title}**\n\n${part.message}\n\n`);
+            for (const answer of part.answers) {
+                stream.button({
+                    title: answer.label,
+                    command: 'supercode.frontend.respond',
+                    arguments: [answer],
+                });
+            }
+            return;
+        case 'tool': {
+            const toolName = part.toolName || state.toolNames.get(part.toolCallId) || 'tool';
+            if (part.toolName)
+                state.toolNames.set(part.toolCallId, part.toolName);
+            const invocation = new vscode.ChatToolInvocationPart(toolName, part.toolCallId);
+            invocation.enablePartialUpdate = true;
+            invocation.invocationMessage = part.invocationMessage || toolName;
+            invocation.isConfirmed = true;
+            invocation.isComplete = part.isComplete;
+            invocation.pastTenseMessage = part.pastTenseMessage || toolName;
+            if (part.isError !== undefined)
+                invocation.isError = part.isError;
+            if (part.inputText !== undefined)
+                state.toolInputs.set(part.toolCallId, part.inputText);
+            if (part.isComplete) {
+                invocation.toolSpecificData = {
+                    input: state.toolInputs.get(part.toolCallId) ?? '',
+                    output: part.resultText ?? '',
+                };
+            }
+            stream.push(invocation);
+            return;
+        }
+    }
+}
+function pendingRequestOf(connection) {
+    return connection.session.pendingRequests.values().next().value;
+}
+/**
+ * What the person reads when there is no runtime. A HOST-SUPPLIED reason is
+ * printed verbatim, because the host is the only thing that knows which
+ * harness it tried to start and what the person must type; this package would
+ * only be guessing. Without one it falls back to its own configuration
+ * pointer.
+ */
+function unavailableMarkdown(reason) {
+    if (reason) {
+        return ['**Volter Harness has no runtime attached.**', '', reason, ''].join('\n');
+    }
+    return [
+        '**Volter Harness is not attached to a runtime.**',
+        '',
+        `Set \`supercode.frontend.baseUrl\`, then run **Volter Harness: Set Runtime Token** — or start the editor from a runtime that exports \`${ENV.url}\`.`,
+        '',
+    ].join('\n');
+}
+export async function activate(context) {
+    const log = vscode.window.createOutputChannel('Volter Harness', { log: true });
+    context.subscriptions.push(log);
+    // The HOST decides which proposals this extension got; its own manifest only
+    // asks. `context.extension.packageJSON` is the filtered extension
+    // description, so this is the grant, not the request.
+    const granted = grantedProposals(context.extension.packageJSON);
+    log.info(`Volter Harness: proposals requested ${REQUESTED_PROPOSALS.join(', ')}; granted ${granted.size ? [...granted].join(', ') : 'none (stable chat parts only)'}`);
+    const controls = await ChatHostControls.fromEnvironment();
+    const controlsChanged = new vscode.EventEmitter();
+    context.subscriptions.push(controlsChanged);
+    let permission = 'ask';
+    const permissions = new Map(context.workspaceState.get('supercode.sessionPermissions', []));
+    const savePermission = (id, value) => {
+        permissions.set(id, value);
+        void Promise.resolve(context.workspaceState.update('supercode.sessionPermissions', [...permissions])).catch(error => log.error(`Could not persist conversation permissions: ${String(error)}`));
+    };
+    const resourceBindings = new Map(context.workspaceState.get('supercode.sessionBindings', []));
+    const boundId = (resource) => resolveSessionBinding(resource, controls?.state.sessions ?? [], resourceBindings);
+    let applying = Promise.resolve();
+    const frontends = new SupercodeFrontends();
+    let approvalAvailable = false;
+    context.subscriptions.push(frontends.onDidChange(() => {
+        const active = frontends.get(undefined);
+        const available = Boolean(active?.session.descriptor?.actions.respond && active.session.permissions.has('approve'));
+        if (available !== approvalAvailable) {
+            approvalAvailable = available;
+            controlsChanged.fire();
+        }
+    }));
+    const identity = () => {
+        const descriptor = frontends.get(undefined)?.session.descriptor;
+        return runtimeIdentity(controls?.state.selection.harness ?? descriptor?.source_harness, controls?.state.selection.model || controls?.state.actualModel || descriptor?.model);
+    };
+    const icon = () => {
+        const provider = identity().provider;
+        return provider ? vscode.Uri.joinPath(context.extensionUri, 'media', `${provider}.svg`) : new vscode.ThemeIcon('hubot');
+    };
+    const nativeModels = Boolean(controls && granted.has('chatProvider'));
+    const modelSelections = new Map();
+    if (nativeModels && controls) {
+        context.subscriptions.push(vscode.lm.registerLanguageModelChatProvider('supercode-runtime', {
+            onDidChangeLanguageModelChatInformation: controlsChanged.event,
+            provideLanguageModelChatInformation: () => {
+                const { selection, models } = controls.state;
+                // A running harness does not advertise hot model changes. Configuration
+                // belongs to the explicit new-conversation flow.
+                const choices = models.filter(model => model.id === selection.model);
+                if (!choices.some(model => model.id === selection.model))
+                    choices.push({ id: selection.model, name: selection.model });
+                modelSelections.clear();
+                return choices.map(model => {
+                    const id = `${selection.harness}/${encodeURIComponent(model.id || '__default__')}`;
+                    modelSelections.set(id, { ...selection, model: model.id });
+                    const provider = runtimeIdentity(selection.harness, selection.model).provider;
+                    return { id, name: model.name, family: selection.harness, version: '1',
+                        statusIcon: new vscode.ThemeIcon(provider === 'anthropic' ? 'claude' : provider === 'openai' ? 'openai' : provider === 'google' ? 'google-gemini' : 'sparkle'),
+                        maxInputTokens: 0, maxOutputTokens: 0, capabilities: {},
+                        targetChatSessionType: SESSION_SCHEME, isUserSelectable: true, isDefault: model.id === selection.model,
+                        tooltip: `${model.name} via ${harnessDisplayName(selection.harness)}${selection.effort ? ` · ${selection.effort} reasoning` : ''}. Model is fixed for this conversation. Use New Chat to choose another model.`,
+                    };
+                });
+            },
+            // Like the workbench's AgentHostLanguageModelProvider, these are session
+            // model descriptors. The participant owns the conversation and tools.
+            provideLanguageModelChatResponse: async () => { throw new Error('Use these models through their Volter Harness chat session. Direct model requests are not supported.'); },
+            provideTokenCount: async () => 0,
+        }));
+    }
+    const currentOptions = (resource) => {
+        const id = resource ? boundId(resource) : controls?.state.activeSession;
+        return { permissions: id ? permissions.get(id) ?? 'ask' : permission };
+    };
+    const connectManaged = async () => {
+        const env = controls.state.connection;
+        if (!env || !controls.state.activeSession)
+            throw new Error('The requested conversation has no runtime connection.');
+        const id = controls.state.activeSession;
+        const existing = frontends.get(id);
+        if (existing && existing.baseUrl === env.SUPERCODE_FRONTEND_URL)
+            return existing;
+        await frontends.disconnect();
+        const connection = await frontends.connect({ connectionId: id, baseUrl: env.SUPERCODE_FRONTEND_URL,
+            token: await readCredentialFile(env.SUPERCODE_FRONTEND_CREDENTIAL_FILE), clientId: env.SUPERCODE_FRONTEND_CLIENT_ID,
+            permissions: normalizePermissions(env.SUPERCODE_FRONTEND_PERMISSIONS, ['observe']), label: identity().name }, log);
+        if (!connection)
+            throw new Error('Could not connect to the requested conversation.');
+        return connection;
+    };
+    const revealManaged = async () => {
+        const id = controls?.state.activeSession;
+        if (!id || !controls?.state.openSessionCommand)
+            throw new Error('The host cannot reveal this conversation.');
+        await vscode.commands.executeCommand(controls.state.openSessionCommand, vscode.Uri.from({ scheme: SESSION_SCHEME, authority: id, path: '/conversation' }).toString());
+    };
+    const connectionFor = async (resource) => {
+        if (!controls) {
+            const connection = frontends.get(resource.authority);
+            if (!connection)
+                throw new Error('This conversation is no longer connected.');
+            return connection;
+        }
+        const id = boundId(resource);
+        if (!id)
+            throw new Error('This chat has no backend session binding. Start a new chat; no message was sent.');
+        const active = frontends.get(undefined);
+        if (active && active.id !== id && (active.session.descriptor?.turn_state === 'busy' || active.session.pendingRequests.size))
+            throw new Error('Finish or cancel the active turn before opening another conversation.');
+        try {
+            await controls.open(id);
+        }
+        catch (error) {
+            log.error(`Could not restore conversation ${id}: ${String(error)}`);
+            throw error;
+        }
+        const history = controls.state.history;
+        const historyTruncated = controls.state.historyTruncated;
+        const connection = await connectManaged();
+        connection.persistedHistory = history;
+        connection.historyTruncated = historyTruncated;
+        // Resolving an already-focused session must not republish its catalogue
+        // while the native widget is still opening that same resource.
+        if (active !== connection)
+            controlsChanged.fire();
+        return connection;
+    };
+    async function applySelection(selection, openChat = true) {
+        if (!controls)
+            throw new Error('This host does not expose harness or model configuration.');
+        const active = frontends.get(undefined);
+        if (active?.session.descriptor?.turn_state === 'busy' || active?.session.pendingRequests.size)
+            throw new Error('Finish or cancel the current turn before starting a new chat.');
+        await controls.select(selection);
+        await connectManaged();
+        controlsChanged.fire();
+        if (openChat)
+            await revealManaged();
+    }
+    const enqueueSelection = (selection, openChat = true) => {
+        const pending = applying.then(() => applySelection(selection, openChat));
+        applying = pending.catch(() => undefined);
+        return pending;
+    };
+    // Publish capability-honest input groups only after the handoff descriptor is available.
+    if (controls?.state.connection)
+        await connectManaged().catch(error => log.warn(`Could not attach before registering chat input: ${String(error)}`));
+    const providerControls = {
+        changed: controlsChanged.event,
+        currentOptions,
+        options: (resource) => {
+            const id = resource ? boundId(resource) : undefined;
+            const active = resource ? (id ? frontends.get(id) : undefined) : frontends.get(undefined);
+            const canApprove = active?.session.descriptor?.actions.respond && active.session.permissions.has('approve');
+            const permissionItems = [{ id: 'ask', name: canApprove ? 'Ask for approval' : 'Harness permissions', description: canApprove ? 'Show each approval requested by the harness.' : 'Approval controls are unavailable for this harness.' },
+                ...((canApprove || (!active && resource && currentOptions(resource).permissions === 'autoApprove')) ? [{ id: 'autoApprove', name: 'Auto approve', description: 'Allow tool approval requests for this chat. Harness sandbox rules still apply.' }] : [])];
+            const groups = [{ id: 'permissions', name: 'Permissions', kind: 'permissions', items: permissionItems, selected: permissionItems.find(i => i.id === (resource ? currentOptions(resource).permissions : 'ask')) }];
+            return groups;
+        },
+        setPermission: (resource, value) => {
+            const id = boundId(resource);
+            if (controls && !id)
+                throw new Error('This conversation has no session binding.');
+            if (id)
+                savePermission(id, turnPermission(value));
+            else
+                permission = turnPermission(value);
+        },
+        create: async (inputState) => {
+            if (!controls)
+                throw new Error('The host does not expose conversation creation.');
+            await enqueueSelection({ ...controls.state.selection }, false);
+            const connection = frontends.get(controls.state.activeSession);
+            savePermission(connection.id, turnPermission(inputState.groups.find(group => group.id === 'permissions')?.selected?.id));
+            return connection;
+        },
+        resolve: connectionFor,
+        catalogue: () => controls?.state.sessions ?? [],
+        bindings: boundId,
+    };
+    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.activateSession', async (resource) => { await connectionFor(vscode.Uri.parse(resource)); }));
+    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.openSession', async (id) => {
+        await connectionFor(vscode.Uri.from({ scheme: SESSION_SCHEME, authority: id, path: '/conversation' }));
+        await revealManaged();
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.configure', async (supplied) => {
+        if (supplied?.permissions) {
+            const id = controls?.state.activeSession;
+            if (id)
+                savePermission(id, turnPermission(supplied.permissions));
+            else
+                permission = turnPermission(supplied.permissions);
+            controlsChanged.fire();
+            return currentOptions();
+        }
+        if (supplied && typeof supplied.harness === 'string') {
+            await enqueueSelection(supplied);
+            return currentOptions();
+        }
+        if (!controls) {
+            void vscode.window.showInformationMessage('This host does not expose chat configuration.');
+            return;
+        }
+        const selection = { ...controls.state.selection };
+        const harness = await vscode.window.showQuickPick(controls.state.harnesses.map(h => ({ label: h.name, id: h.id })), { title: 'New chat · Harness', placeHolder: 'Choose the harness for a new conversation. Existing chats keep their harness and history.' });
+        if (!harness)
+            return;
+        if (harness.id !== selection.harness) {
+            selection.harness = harness.id;
+            selection.model = '';
+            selection.effort = '';
+        }
+        if (['claude-code', 'codex'].includes(selection.harness)) {
+            const choices = controls.state.modelsByHarness?.[selection.harness] ?? [{ id: '', name: 'Harness default' }];
+            const picked = await vscode.window.showQuickPick([...choices.map(model => ({ label: model.name, id: model.id })), { label: 'Enter an exact model ID…', id: '__custom__' }], { title: 'New chat · Model', placeHolder: 'Model availability depends on your harness account.' });
+            if (!picked)
+                return;
+            if (picked.id === '__custom__') {
+                const model = await vscode.window.showInputBox({ title: 'New chat · Exact model', prompt: 'Model ID or CLI alias supported by this harness account.', value: selection.model });
+                if (model === undefined)
+                    return;
+                selection.model = model.trim();
+            }
+            else
+                selection.model = picked.id;
+            const effort = await vscode.window.showQuickPick([{ label: 'Harness default', id: '' }, ...['low', 'medium', 'high'].map(id => ({ label: id, id }))], { title: 'New chat · Reasoning effort' });
+            if (!effort)
+                return;
+            selection.effort = effort.id;
+        }
+        await enqueueSelection(selection);
+    }));
+    context.subscriptions.push({ dispose: () => frontends.dispose() });
+    context.subscriptions.push(frontends.onDidChange(() => {
+        void vscode.commands.executeCommand('setContext', ATTACHED_CONTEXT_KEY, frontends.all.length > 0);
+    }));
+    // From the connections, not `false`: one made earlier in activation (the editor host
+    // attaches before this line) already fired its change, and `false` here outlived it.
+    await vscode.commands.executeCommand('setContext', ATTACHED_CONTEXT_KEY, frontends.all.length > 0);
+    const runTurnInto = async (connection, prompt, stream, token, approval) => {
+        if (approval === 'autoApprove' && (!connection.session.descriptor?.actions.respond || !connection.session.permissions.has('approve'))) {
+            throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
+        }
+        const answered = new Set();
+        const state = { toolInputs: new Map(), toolNames: new Map() };
+        const projection = {
+            connectionId: connection.id,
+            pendingRequest: (requestId) => connection.session.pendingRequests.get(requestId) ?? connection.session.resolvedRequests.get(requestId),
+            canRespond: connection.session.descriptor?.actions.respond !== false,
+        };
+        const cancellation = token.onCancellationRequested(() => {
+            void connection.session.interrupt().catch(() => {
+                // The runtime may already be idle; interrupting twice is not an error
+                // this view reports.
+            });
+        });
+        try {
+            await connection.session.runTurn(prompt, (event) => {
+                writeProjected(stream, projectEvent(event, projection), granted, state);
+                if (approval === 'autoApprove' && !token.isCancellationRequested) {
+                    for (const pending of connection.session.pendingRequests.values()) {
+                        if (pending.kind !== 'approval' || answered.has(pending.id))
+                            continue;
+                        const decisions = acceptedDecisions(pending);
+                        if (decisions && !decisions.includes('allow'))
+                            continue;
+                        answered.add(pending.id);
+                        void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).catch(error => {
+                            stream.markdown(`\nApproval failed: ${String(error.message || error)}. Use the approval buttons to answer.\n`);
+                        });
+                    }
+                }
+            });
+        }
+        finally {
+            cancellation.dispose();
+            if (controls) {
+                if (connection.session.descriptor?.session_id)
+                    await controls.remember(connection.id, connection.session.descriptor.session_id).catch(error => log.warn(`Could not save conversation identity: ${String(error)}`));
+                await controls.refresh().catch(error => log.warn(`Could not refresh chat identity: ${String(error)}`));
+                controlsChanged.fire();
+            }
+        }
+    };
+    const handler = async (request, chatContext, stream, token) => {
+        await applying;
+        const requestedResource = chatContext.chatSessionContext?.chatSessionItem?.resource;
+        const connection = requestedResource
+            ? await connectionFor(requestedResource)
+            : controls ? undefined : frontends.get(undefined);
+        if (controls && connection && request.model?.vendor === 'supercode-runtime') {
+            const selection = controls.state.sessions.find(s => s.id === connection.id).selection;
+            const expected = `${selection.harness}/${encodeURIComponent(selection.model || '__default__')}`;
+            if (request.model.id !== expected || (typeof request.modelConfiguration?.reasoningEffort === 'string' && request.modelConfiguration.reasoningEffort !== selection.effort)) {
+                throw new Error('This conversation has fixed model settings. Start a new chat to choose different settings; no message was sent.');
+            }
+        }
+        if (!connection) {
+            stream.markdown(unavailableMarkdown(frontends.unavailable));
+            return {};
+        }
+        // While a request is pending, a typed message is its answer — this is the
+        // path for the answers no button can carry (`allow for session`, `cancel`,
+        // and an elicitation's free-text content).
+        const pending = pendingRequestOf(connection);
+        if (pending) {
+            const answer = typedAnswer(pending, request.prompt);
+            await connection.session.respond(answer);
+            stream.markdown(`_answered request #${pending.id}: ${opaqueText(answer, 256)}_`);
+            return {};
+        }
+        if (request.prompt.trim().length === 0) {
+            stream.markdown('_nothing to submit_');
+            return {};
+        }
+        const approval = turnPermission(controls ? permissions.get(connection.id) ?? 'ask' : request.permissionLevel);
+        const attached = [];
+        for (const reference of request.references) {
+            const value = reference.value;
+            const location = value instanceof vscode.Location ? value : undefined;
+            const uri = location?.uri ?? (value instanceof vscode.Uri ? value : undefined);
+            if (!uri || !['file', 'vscode-remote', 'untitled'].includes(uri.scheme))
+                throw new Error('This harness integration supports text files and selections only. Remove unsupported context before sending.');
+            const document = await vscode.workspace.openTextDocument(uri);
+            attached.push({ name: uri.toString(), text: document.getText(location?.range) });
+        }
+        const prompt = withTextContext(request.prompt, attached);
+        await runTurnInto(connection, prompt, stream, token, approval);
+        return {};
+    };
+    const participants = [];
+    for (const id of granted.has('defaultChatParticipant') ? [PARTICIPANT_ID, DEFAULT_PARTICIPANT_ID] : [PARTICIPANT_ID]) {
+        try {
+            const participant = vscode.chat.createChatParticipant(id, handler);
+            participant.iconPath = icon();
+            participants.push(participant);
+            context.subscriptions.push(participant);
+        }
+        catch (error) {
+            log.warn(`Volter Harness chat participant ${id} was not registered: ${String(error?.message ?? error)}`);
+        }
+    }
+    // The runtime's sessions in the Chat view's own picker. Without the
+    // `chatSessionsProvider` grant the participant alone still works.
+    if (granted.has('chatSessionsProvider')) {
+        try {
+            // Requests route to the session type. Register its dynamic identity here;
+            // canDelegate is disabled to avoid a generic workbench-owned registration.
+            // A participant names the harness; the native model picker names the model.
+            // Keep the author stable when a model changes during request dispatch.
+            const participantName = () => harnessDisplayName(controls?.state.selection.harness ?? frontends.get(undefined)?.session.descriptor?.source_harness);
+            const participantKey = () => `${participantName()}/${identity().provider ?? ''}`;
+            const makeParticipant = () => {
+                const current = { name: participantName() };
+                const participant = granted.has('chatParticipantPrivate')
+                    ? vscode.chat.createDynamicChatParticipant(SESSION_SCHEME, { name: current.name.replace(/[^a-zA-Z0-9]/g, ''), fullName: current.name, publisherName: 'Volter', description: 'Ask a question or describe a task' }, handler)
+                    : vscode.chat.createChatParticipant(SESSION_SCHEME, handler);
+                participant.iconPath = icon();
+                return participant;
+            };
+            let sessionParticipant = makeParticipant();
+            let previousIdentity = participantKey();
+            const updateIdentity = () => {
+                if (participantKey() === previousIdentity)
+                    return;
+                previousIdentity = participantKey();
+                sessionParticipant.dispose();
+                sessionParticipant = makeParticipant();
+                for (const p of participants)
+                    p.iconPath = icon();
+            };
+            context.subscriptions.push({ dispose: () => sessionParticipant.dispose() }, controlsChanged.event(updateIdentity), frontends.onDidChange(updateIdentity));
+            registerSessions(context, frontends, sessionParticipant, granted, handler, controls ? providerControls : undefined);
+        }
+        catch (error) {
+            log.warn(`Volter Harness chat sessions were not registered: ${String(error?.message ?? error)}`);
+        }
+    }
+    /**
+     * The one door an answer takes, whether it came from the inline question or
+     * from a fallback command button. A button cannot be withdrawn once pushed,
+     * so a click on an already-resolved request must be a no-op that SAYS so —
+     * never a stale `respond`, and never a silent nothing.
+     */
+    async function answerRequest(answer) {
+        if (!answer || typeof answer.requestId !== 'number')
+            return;
+        const connection = frontends.get(answer.connectionId);
+        if (!connection) {
+            void vscode.window.showWarningMessage('Volter Harness is no longer attached to that runtime.');
+            return;
+        }
+        const request = connection.session.pendingRequests.get(answer.requestId);
+        if (!request) {
+            void vscode.window.showInformationMessage(`Volter Harness: request #${answer.requestId} is already resolved.`);
+            return;
+        }
+        let response = answer.response;
+        if (answer.promptForContent) {
+            const content = await vscode.window.showInputBox({
+                title: 'Volter Harness runtime request',
+                prompt: 'The runtime asked for a value; a button cannot carry one.',
+                ignoreFocusOut: true,
+            });
+            if (content === undefined)
+                return;
+            response = { ...response, content };
+        }
+        try {
+            await connection.session.respond(response);
+            void vscode.window.setStatusBarMessage(`Volter Harness: ${resolutionSentence(response, request, answer.requestId)}`, 4000);
+        }
+        catch (error) {
+            if (error instanceof RequestNotPendingError) {
+                void vscode.window.showInformationMessage(`Volter Harness: request #${answer.requestId} is already resolved.`);
+                return;
+            }
+            void vscode.window.showErrorMessage(`Volter Harness could not answer request #${answer.requestId}: ${String(error?.message ?? error)}`);
+        }
+    }
+    const secretKey = (baseUrl) => `supercode.frontend.token:${baseUrl}`;
+    // The runtime's credential FILE is one-shot, and an extension host reloads.
+    // Remembering which runtime this window was handed lets the next activation
+    // reconnect from SecretStorage instead of losing the attachment.
+    const HANDED_OVER_KEY = 'supercode.frontend.handedOverBaseUrl';
+    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.setToken', async () => {
+        const settings = vscode.workspace.getConfiguration('supercode.frontend');
+        const baseUrl = await vscode.window.showInputBox({
+            title: 'Volter Harness runtime',
+            prompt: 'Base URL of the already-running Volter Harness SDK runtime',
+            value: settings.get('baseUrl') ?? 'http://127.0.0.1:0',
+            ignoreFocusOut: true,
+        });
+        if (!baseUrl)
+            return;
+        const token = await vscode.window.showInputBox({
+            title: 'Volter Harness runtime token',
+            prompt: 'Scoped runtime credential — stored in SecretStorage, sent only in Authorization',
+            password: true,
+            ignoreFocusOut: true,
+        });
+        if (!token)
+            return;
+        await settings.update('baseUrl', baseUrl, vscode.ConfigurationTarget.Global);
+        await context.secrets.store(secretKey(baseUrl), token);
+        await connectFromSettings();
+    }), vscode.commands.registerCommand('supercode.frontend.connect', () => connectFromSettings()), 
+    // The create command the core's own `chatSessions/newSession` menu invokes
+    // for this session type (`chatSessions.contribution.ts`
+    // `_resolveCreateSubMenuCommandId`). It opens a chat on the supercode
+    // session type through the editor's own action; nothing here is a second
+    // way to reach the runtime.
+    vscode.commands.registerCommand('supercode.frontend.newSession', async (position) => {
+        if (controls) {
+            await vscode.commands.executeCommand('supercode.frontend.configure');
+            return;
+        }
+        const where = position === 'editor' ? 'editor' : 'sidebar';
+        await vscode.commands.executeCommand(`workbench.action.chat.openNewChatSessionInPlace.${SESSION_SCHEME}`, where);
+    }), vscode.commands.registerCommand('supercode.frontend.disconnect', () => frontends.disconnect()), 
+    // The one door an answer button uses. It answers the runtime's pending
+    // request through `frontend.v2.respond` and narrates itself, because a
+    // click whose effect is invisible is a click nobody can trust.
+    vscode.commands.registerCommand('supercode.frontend.respond', (answer) => answerRequest(answer)), vscode.commands.registerCommand('supercode.frontend.status', async (inspect) => {
+        if (controls)
+            await controls.refresh();
+        if (inspect === true)
+            return { connections: frontends.all.map(c => ({ ...frontends.info(c), permissions: [...c.session.permissions], pendingRequests: [...c.session.pendingRequests.values()] })), selection: controls?.state.selection, activeSession: controls?.state.activeSession, busy: Boolean(controls?.state.busy || frontends.all.some(c => c.session.descriptor?.turn_state === 'busy' || c.session.pendingRequests.size)), sessions: controls?.state.sessions, permission: currentOptions().permissions, identity: identity() };
+        const rows = frontends.all.map((connection) => {
+            const info = frontends.info(connection);
+            return `${info.label} · ${info.baseUrl} · ${info.model ?? 'unknown model'} · ${info.turnState ?? 'unattached'}`;
+        });
+        const proposals = [...granted];
+        await vscode.window.showInformationMessage(rows.length ? rows.join('\n') : 'Volter Harness is not attached to a runtime.', {
+            modal: true,
+            detail: proposals.length
+                ? proposals.map((name) => `${name}: ${PROPOSAL_EFFECTS[name].grants}`).join('\n')
+                : REQUESTED_PROPOSALS.map((name) => `${name} not granted: ${PROPOSAL_EFFECTS[name].without}`).join('\n'),
+        });
+    }));
+    async function connectFromSettings() {
+        const settings = vscode.workspace.getConfiguration('supercode.frontend');
+        const baseUrl = settings.get('baseUrl')?.trim() || context.globalState.get(HANDED_OVER_KEY);
+        if (!baseUrl)
+            return;
+        const token = await context.secrets.get(secretKey(baseUrl));
+        if (!token) {
+            log.info('Volter Harness: a base URL is configured but no token is stored; run Volter Harness: Set Runtime Token.');
+            return;
+        }
+        await frontends
+            .connect({ baseUrl, token, permissions: normalizePermissions(settings.get('permissions'), ['observe']) }, log)
+            .catch((error) => {
+            log.error(`Volter Harness could not attach to ${baseUrl}: ${String(error?.message ?? error)}`);
+        });
+    }
+    /**
+     * The handover path: a runtime (or a product that launched this editor's
+     * server) exports the endpoint and a scoped credential FILE, mirroring what
+     * `crates/cli/src/frontend_client.rs` already does for the pi frontend. No
+     * pasted token, no secret in argv or a setting.
+     */
+    async function connectFromEnvironment() {
+        const env = controls?.state.connection ?? process.env;
+        const baseUrl = env[ENV.url]?.trim();
+        const credentialFile = env[ENV.credentialFile]?.trim();
+        // A host that could not start a runtime says so here, and that sentence is
+        // what the person reads instead of an empty chat that looks like a working
+        // one.
+        const unavailable = process.env[ENV.unavailable]?.trim();
+        if (unavailable)
+            frontends.setUnavailable(unavailable);
+        if (!baseUrl || !credentialFile)
+            return false;
+        try {
+            const token = await readCredentialFile(credentialFile);
+            // The file is read, never consumed: an extension host reloads and must be
+            // able to reconnect. SecretStorage is a convenience for the settings
+            // path, not a durable home in every host — see `credential.ts`.
+            await context.secrets.store(secretKey(baseUrl), token);
+            await context.globalState.update(HANDED_OVER_KEY, baseUrl);
+            await frontends.connect({
+                baseUrl,
+                token,
+                clientId: env[ENV.clientId]?.trim() || undefined,
+                connectionId: controls?.state.activeSession ?? undefined,
+                permissions: normalizePermissions(env[ENV.permissions], ['observe', 'interact', 'approve']),
+                label: identity().name,
+            }, log);
+            return true;
+        }
+        catch (error) {
+            log.error(`Volter Harness could not use ${ENV.credentialFile}: ${String(error?.message ?? error)}`);
+            return false;
+        }
+    }
+    /**
+     * A RESUMED runtime arrives with the person's conversation already in it —
+     * vgai reopens a project on `claude --resume <id>`. Opening the panel beside
+     * that conversation instead of on it is the same defect as not showing it at
+     * all: the history exists and nobody sees it. So an attachment that brings
+     * history opens its own session, once, on the surface the person is looking
+     * at. A runtime with no history is left alone; there is nothing to show and
+     * stealing the panel would be rude.
+     */
+    async function openResumedSession() {
+        if (!granted.has('chatSessionsProvider'))
+            return;
+        if (controls) {
+            try {
+                await revealManaged();
+            }
+            catch (error) {
+                log.error(`Could not open the saved conversation: ${String(error)}`);
+            }
+            return;
+        }
+        const connection = frontends.all.find((entry) => Boolean(controls) || entry.session.history.length > 0 ||
+            entry.session.replay.some((event) => event.kind === 'user_message'));
+        if (!connection)
+            return;
+        try {
+            // The editor's own action for this session type. `vscode.openWith` on
+            // the session resource opens a LOCAL chat instead — observed — because
+            // nothing routes a `supercode:` uri to the session provider's editor.
+            await vscode.commands.executeCommand(`workbench.action.chat.openNewChatSessionInPlace.${SESSION_SCHEME}`, 'sidebar');
+            log.info(`Volter Harness opened the resumed session ${connection.label} on its history`);
+        }
+        catch (error) {
+            log.warn(`Volter Harness could not open the resumed session: ${String(error?.message ?? error)}`);
+        }
+    }
+    // Precedence: a host's own `connect()` wins, then the runtime's environment
+    // handover, then the configured base URL plus its stored secret.
+    await vscode.commands.executeCommand('setContext', DEFAULT_PARTICIPANT_CONTEXT_KEY, granted.has('defaultChatParticipant'));
+    if (!(await connectFromEnvironment()))
+        await connectFromSettings();
+    // NOT awaited: this opens an editor, and activation must return before the
+    // workbench will run one. Awaiting it here left activation hanging and the
+    // panel on "Loading…" — observed.
+    const opening = setTimeout(() => void openResumedSession(), 500);
+    context.subscriptions.push({ dispose: () => clearTimeout(opening) });
+    return {
+        connect: async (options) => {
+            const connection = await frontends.connect(options, log);
+            return connection ? frontends.info(connection) : undefined;
+        },
+        disconnect: (connectionId) => frontends.disconnect(connectionId),
+        get connections() {
+            return frontends.all.map((connection) => frontends.info(connection));
+        },
+        get grantedProposals() {
+            return [...granted];
+        },
+        onDidChangeConnections: frontends.onDidChange,
+    };
+}
+export function deactivate() {
+    // Every disposable is owned by the extension context.
+}
+/**
+ * One rendered part as the markdown a HISTORY turn carries. A replayed turn is
+ * built from `ChatResponseMarkdownPart`s only — the live part types belong to a
+ * running stream — so a tool row becomes its own one-line summary rather than
+ * the JSON of the object that would have drawn it.
+ */
+function historyText(part) {
+    switch (part.part) {
+        case 'markdown':
+        case 'progress':
+            return part.value;
+        case 'warning':
+            return `> ⚠ ${part.value}`;
+        case 'thinking':
+            return `> ${part.value}`;
+        case 'codeblock':
+            return part.value;
+        case 'reference':
+            return `\`${part.path}\``;
+        case 'tool': {
+            // No `<details>` here: a HISTORY turn's markdown is rendered without raw
+            // HTML, so the tags show up as text — observed. A replayed tool is one
+            // line plus its output, fenced.
+            const summary = part.pastTenseMessage ?? part.invocationMessage ?? part.toolName;
+            if (!summary)
+                return '';
+            const verb = part.isError ? 'Tool failed:' : 'Tool call:';
+            const result = part.resultText ? `\n\n${fence(part.resultText)}` : '';
+            return `${verb} \`${summary}\`${result}`;
+        }
+        case 'answers':
+            return `**${part.title}**\n\n${part.message}`;
+    }
+}
+/**
+ * The editor's session list ALWAYS reads `timing.created` and renders the epoch
+ * ("57 yrs ago") when a provider supplies none — measured in
+ * `agentSessionsViewer`, which has no path that omits the time. `frontend.v2`
+ * carries no session timestamp of its own, so the true times this frontend
+ * knows are its own: when this window attached, and the turn boundaries it
+ * watched. Those are what the item gets.
+ */
+function applyTiming(item, connection) {
+    const created = connection.session.attachedAtMs;
+    if (created === null)
+        return;
+    item.timing = {
+        created,
+        lastRequestStarted: connection.session.lastTurnStartedMs ?? undefined,
+        lastRequestEnded: connection.session.lastTurnEndedMs ?? undefined,
+    };
+}
+function registerSessions(context, frontends, participant, granted, handler, controls) {
+    const turns = vscode;
+    /**
+     * The session list is the door that actually SHOWS a reason on screen.
+     * `chatViewsWelcome` cannot: `ChatViewPane.shouldShowWelcome()` in
+     * `src/vs/workbench/contrib/chat/browser/widgetHosts/viewPane/chatViewPane.ts`
+     * begins `const shouldShow = !hasCoreAgent && …`, so the whole welcome
+     * control is suppressed whenever ANY core agent is registered for the Chat
+     * location — which a Code-OSS derivative with an agent host always has. The
+     * `when` clause is never even consulted there.
+     */
+    const unavailableItem = () => {
+        if (!frontends.unavailable || frontends.all.length > 0)
+            return undefined;
+        const item = controller.createChatSessionItem(unavailableResource(), 'Volter Harness · no runtime');
+        item.description = frontends.unavailable.split('\n')[0];
+        item.status = vscode.ChatSessionStatus.Failed;
+        return item;
+    };
+    const items = () => {
+        const unavailable = unavailableItem();
+        if (unavailable)
+            return [unavailable];
+        return (controls?.catalogue() ?? []).filter(entry => !frontends.get(entry.id)).map(entry => {
+            const item = controller.createChatSessionItem(vscode.Uri.from({ scheme: SESSION_SCHEME, authority: entry.id, path: '/conversation' }), entry.title);
+            item.description = runtimeIdentity(entry.selection.harness, entry.selection.model).name;
+            item.status = vscode.ChatSessionStatus.Completed;
+            item.timing = { created: entry.created };
+            return item;
+        });
+    };
+    const connectedItem = (connection) => {
+        const item = controller.createChatSessionItem(sessionResource(connection), connection.label);
+        item.description = connection.label;
+        applyTiming(item, connection);
+        item.status = vscode.ChatSessionStatus[sessionStatus(connection.session)];
+        return item;
+    };
+    const refreshItems = () => controller.items.replace(items().concat(frontends.all.map(connectedItem)));
+    const controller = vscode.chat.createChatSessionItemController(SESSION_SCHEME, async () => { refreshItems(); });
+    context.subscriptions.push(controller, frontends.onDidChange(refreshItems));
+    if (controls) {
+        const states = new Set();
+        controller.getChatSessionInputState = (resource, { previousInputState }) => {
+            const previous = previousInputState?.groups.find(group => group.id === 'permissions')?.selected?.id;
+            // Saved conversation preferences survive extension-host reloads. Native input state
+            // owns live changes; a blank conversation always starts with its own Ask default.
+            const groups = controls.options(resource).map(group => ({ ...group,
+                selected: group.items.find(item => item.id === (resource ? group.selected?.id : previous ?? group.selected?.id)) ?? group.selected,
+            }));
+            const state = controller.createChatSessionInputState(groups);
+            states.add(state);
+            const changed = state.onDidChange(() => {
+                const target = state.sessionResource ?? resource;
+                if (target)
+                    controls.setPermission(target, state.groups.find(group => group.id === 'permissions')?.selected?.id);
+            });
+            const disposed = state.onDidDispose(() => { states.delete(state); changed.dispose(); disposed.dispose(); });
+            return state;
+        };
+        controller.newChatSessionItemHandler = async ({ inputState }, token) => {
+            if (token.isCancellationRequested)
+                throw new vscode.CancellationError();
+            return connectedItem(await controls.create(inputState));
+        };
+        context.subscriptions.push(controls.changed(() => {
+            refreshItems();
+            for (const state of states) {
+                if (state.sessionResource)
+                    state.groups = controls.options(state.sessionResource);
+            }
+        }));
+    }
+    context.subscriptions.push(vscode.chat.registerChatSessionContentProvider(SESSION_SCHEME, {
+        provideChatSessionContent: async (resource, _token, { inputState }) => {
+            const boundHandler = (request, chatContext, stream, token) => handler(request, { ...chatContext, chatSessionContext: { chatSessionItem: { resource, label: 'Conversation' } } }, stream, token);
+            if (resource.path === UNAVAILABLE_PATH) {
+                // As HISTORY, not `activeResponseCallback`: the editor only invokes
+                // that callback for a session it believes is mid-response, and this
+                // one is not running anything. A history turn renders the moment
+                // the session opens, with no request behind it and nothing to wait
+                // for — which is the whole point, since the person has not typed.
+                return {
+                    title: 'Volter Harness · no runtime',
+                    history: [
+                        new turns.ChatRequestTurn(STATUS_MARKER_PROMPT, undefined, [], participant.id, []),
+                        new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(unavailableMarkdown(frontends.unavailable))], {}, participant.id),
+                    ],
+                    requestHandler: boundHandler,
+                };
+            }
+            // Only a native untitled resource can create a conversation. Existing
+            // resources must resolve their exact saved binding; there is no fallback.
+            const connection = controls ? (resource.path.startsWith('/untitled-') && !controls.bindings(resource) ? undefined : await controls.resolve(resource)) : frontends.get(resource.authority);
+            if (!connection) {
+                return { history: [], requestHandler: boundHandler };
+            }
+            if (controls) {
+                controls.setPermission(resource, inputState.groups.find(group => group.id === 'permissions')?.selected?.id);
+                inputState.groups = controls.options(resource);
+            }
+            // Re-take the attachment snapshot: the runtime republishes its
+            // canonical history at every turn boundary (`submit_claimed` writes
+            // `state.history`), so the copy taken when this window attached is
+            // stale as soon as a turn runs. The generated client reuses the
+            // already-open event stream, so this is a snapshot, not a reconnect.
+            await connection.session.attach().catch(() => {
+                // An unreachable runtime replays what this window last saw.
+            });
+            // The attach snapshot IS the session's history: the runtime's own
+            // canonical transcript, replayed as turns.
+            const history = [];
+            // A hosted harness runtime has no canonical ChatMessage history —
+            // `HostedHarnessRuntime::attach` returns an empty one and puts the
+            // conversation in `replay`. Read whichever the runtime actually
+            // filled, or a resumed session opens blank beside the person's own
+            // conversation.
+            const canonicalHistory = connection.persistedHistory?.length ? connection.persistedHistory : connection.session.history;
+            const pendingToolNames = new Set();
+            if (connection.session.descriptor?.turn_state === 'busy') {
+                for (const request of connection.session.pendingRequests.values()) {
+                    const payload = request.payload;
+                    if (request.kind !== 'approval' || !payload || typeof payload !== 'object' || Array.isArray(payload))
+                        continue;
+                    const name = payload.tool ?? payload.tool_name;
+                    if (typeof name === 'string')
+                        pendingToolNames.add(name);
+                }
+            }
+            const projected = canonicalHistory.length > 0
+                ? projectHistory(canonicalHistory, granted, pendingToolNames)
+                : projectReplayTurns(connection.session.replay, granted, {
+                    connectionId: connection.id,
+                    pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
+                    canRespond: connection.session.descriptor?.actions.respond !== false,
+                });
+            if (connection.historyTruncated)
+                history.push(new turns.ChatRequestTurn('[Earlier conversation history]', undefined, [], participant.id, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart('_Showing the latest 120 saved messages. Earlier context remains in the harness session._')], {}, participant.id));
+            for (const turn of projected) {
+                if (turn.role === 'user') {
+                    history.push(new turns.ChatRequestTurn(turn.prompt ?? '', undefined, [], participant.id, []));
+                    continue;
+                }
+                const markdown = (turn.parts ?? [])
+                    .map(historyText)
+                    .filter(Boolean)
+                    .join('\n\n');
+                history.push(new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(markdown)], {}, participant.id));
+            }
+            const busy = connection.session.descriptor?.turn_state === 'busy';
+            return {
+                title: connection.label,
+                options: controls?.currentOptions(resource),
+                history,
+                requestHandler: boundHandler,
+                activeResponseCallback: busy
+                    ? async (stream, token) => {
+                        const state = { toolInputs: new Map(), toolNames: new Map() };
+                        writeProjected(stream, projectPendingRequests(connection.session.pendingRequests.values(), {
+                            connectionId: connection.id,
+                            canRespond: connection.session.descriptor?.actions.respond !== false,
+                        }), granted, state);
+                        await observeActiveResponse(connection.session, token, (event) => {
+                            writeProjected(stream, projectEvent(event, {
+                                connectionId: connection.id,
+                                pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
+                                canRespond: connection.session.descriptor?.actions.respond !== false,
+                            }), granted, state);
+                        });
+                    }
+                    : undefined,
+            };
+        },
+    }, participant, { supportsInterruptions: true }));
+}