@volter/supercode-frontend-vscode 0.1.18 → 0.1.21

package/NOTICE.md

@@ -1,6 +1,6 @@
 # Third-party notice
 
-This optional frontend has **no runtime npm dependency**. It builds against `@types/vscode`
+This optional frontend needs **no runtime npm installation**. It builds against `@types/vscode`
 (Copyright (c) Microsoft Corporation, MIT) as an exact devDependency for types only; `vscode` itself
 is supplied by the editor at runtime and is never bundled or redistributed here.
 

package/README.md

@@ -34,65 +34,6 @@ Changed setup resources refresh
 Code-OSS's cached status history after an install. Hosts without these optional
 fields keep the existing runtime-attachment behavior.
 
-`starterPrompts?: {label: string; prompt: string}[]` is project data supplied by
-the host. An eligible new conversation exposes at most three short command links
-in the default participant's native welcome content, outside the transcript.
-The host's `fillInputCommand` receives the exact native session resource and full
-prompt and must return `{sessionResource, input}` after filling that existing
-widget, without submitting. A missing or mismatched receipt is an error.
-The untargeted partial-query command is not used. Links never send or write a turn.
-Presentation and clicks use the same `starterEligibility` calculation; runtime
-and host state changes update the welcome message, and a user turn clears it.
-Native Chat also hides its welcome surface immediately when a request is added.
-Eligibility requires a successful attachment, an idle runtime, no pending request,
-no saved/canonical non-system messages or truncated saved history, and no observed
-user turn. Accepted-input events (`user_message`, `turn_started`) and busy snapshots
-record turn evidence that survives re-attachment and replay eviction. Setup/status
-events can advance cursors without disqualifying a new conversation; system-only
-history also stays eligible. The checks run again after
-project data loads and before filling; a failed attachment never offers starters.
-`supercode.frontend.status(true)` includes each connection's `starterEligibility`:
-attachment state, turn state, pending count, saved-history presence/truncation/count
-and roles, canonical count/roles, sticky turn evidence, both cursors, replay count
-and kinds, active host ID, host busy state, connection identity check, and rejection
-reasons. `lastStarterAttempt` preserves the exact post-attachment guard snapshot
-and native binding from the latest click. These contain no message bodies or tokens.
-A rejected click names its failed conditions instead of a generic new/idle error.
-The pinned Chat session API exposes immutable history, without withdrawal or
-live enablement of a rendered command part. Starters therefore never enter history.
-`defaultChatParticipant.additionalWelcomeMessage` supplies trusted Markdown with
-only `supercode.frontend.fillStarter` allowed; labels are escaped and command
-arguments are encoded. Hosts without that proposal get no starter offer rather
-than permanent transcript buttons. Existing setup actions keep their native status
-presentation. No new workbench API or editor-side contribution is required.
-The pinned Code-OSS `f16dc165` has no `suggestedPrompts` field in either
-`vscode.proposed.defaultChatParticipant.d.ts` or the internal
-`IChatViewWelcomeContent`. `ChatViewWelcomePart` renders `additionalMessage` as
-Markdown; its optional `firstLinkToButton` converts only one anchor and the
-participant welcome never enables that option. The editor's native overlay can
-render standalone trusted command links as welcome buttons without a new extension
-API; other hosts keep Markdown links. The two introductory lines live together in
-this extension's `package.json`: `chatSessions.welcomeMessage` and
-`supercodeFrontendWelcome.starterIntroduction`. Hosts own their project prompt data.
-If `starterPromptsPending` is true, the project configuration is still loading.
-Empty-conversation resolution refreshes the host until that declaration arrives
-(cancellable, with a 30-second timeout), so native Chat does not cache an empty
-offer before the project adapter loads.
-
-W32/W37 passed starter filling and W37 passed healthy refresh with draft retention.
-W44 passed a real boost turn and exposed a presentation defect: transcript starter
-buttons remained after the turn even though the guard rejected them. W50 passed
-the native welcome fix at `29d8fac99`: all three pointer fills, one real HUD turn,
-first-turn disappearance, return-to-idle suppression, and no starters when reopening
-the earlier conversation with seven history entries. The shorter introductory copy
-is source-only; it needs a frontend build plus a workbench overlay copy.
-The accompanying native button and New Session repairs require a Code-OSS compile.
-W50 also found that the generic native New Session action
-bypasses this provider's creation command; its owning host must route that action
-through `chatSessions/newSession` rather than opening an unbound untitled resource.
-Signed-out/install transitions and failed-discovery/attachment recovery remain
-unverified live. A published frontend and rebuilt workbench are needed for npx users.
-
 A bundling host can expose a private lifecycle endpoint through
 `SUPERCODE_FRONTEND_HOST_URL` and `SUPERCODE_FRONTEND_HOST_CREDENTIAL_FILE`.
 The endpoint must be loopback HTTP and the credential follows the runtime credential-file

package/dist/chat-setup.d.ts

@@ -1,6 +1,4 @@
-/** Native Chat presentation; the host supplies inventory, terminal actions and project data. */
+/** Native Chat presentation; the host supplies inventory and terminal actions. */
 import * as vscode from 'vscode';
-import type { ChatSetupState, ChatStarterPrompt } from './host-controls.js';
+import type { ChatSetupState } from './host-controls.js';
 export declare function setupParts(setup: ChatSetupState): Array<vscode.ChatResponseMarkdownPart | vscode.ChatResponseCommandButtonPart>;
-/** Welcome content is owned by the empty-state renderer, never transcript history. */
-export declare function starterWelcome(prompts: readonly ChatStarterPrompt[], session: string, resource: string, introduction: string): vscode.MarkdownString;

package/dist/chat-setup.js

@@ -1,4 +1,4 @@
-/** Native Chat presentation; the host supplies inventory, terminal actions and project data. */
+/** Native Chat presentation; the host supplies inventory and terminal actions. */
 import * as vscode from 'vscode';
 export function setupParts(setup) {
     const parts = [
@@ -16,14 +16,3 @@ export function setupParts(setup) {
     parts.push(new vscode.ChatResponseCommandButtonPart({ title: 'Check again', command: 'supercode.frontend.refreshSetup' }));
     return parts;
 }
-/** Welcome content is owned by the empty-state renderer, never transcript history. */
-export function starterWelcome(prompts, session, resource, introduction) {
-    const message = new vscode.MarkdownString().appendText(introduction).appendMarkdown('\n\n');
-    message.isTrusted = { enabledCommands: ['supercode.frontend.fillStarter'] };
-    for (const [index, starter] of prompts.slice(0, 3).entries()) {
-        const args = encodeURIComponent(JSON.stringify([session, index, resource]));
-        message.appendMarkdown('[').appendText(starter.label)
-            .appendMarkdown(`](command:supercode.frontend.fillStarter?${args})\n\n`);
-    }
-    return message;
-}

package/dist/extension.js

@@ -2,7 +2,7 @@ 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 { setupParts, starterWelcome } from './chat-setup.js';
+import { setupParts } from './chat-setup.js';
 import * as vscode from 'vscode';
 import { createFrontendClient } from './client.js';
 import { readCredentialFile } from './credential.js';
@@ -33,44 +33,6 @@ const ENV = Object.freeze({
      */
     unavailable: 'SUPERCODE_FRONTEND_UNAVAILABLE',
 });
-/** Transport progress includes setup events; it is not a user-turn count. */
-function conversationEligibility(connection) {
-    const session = connection.session;
-    const inputs = {
-        attachmentState: session.connection,
-        turnState: session.descriptor?.turn_state ?? null,
-        pendingRequestCount: session.pendingRequests.size,
-        historyTruncated: connection.historyTruncated ?? false,
-        persistedHistoryLoaded: connection.persistedHistory !== undefined,
-        persistedHistoryCount: connection.persistedHistory?.length ?? 0,
-        persistedHistoryRoles: connection.persistedHistory?.map(message => message.role) ?? [],
-        canonicalHistoryCount: session.history.length,
-        canonicalHistoryRoles: session.history.map(message => message.role),
-        hasUserTurn: session.hasUserTurn,
-        historyCursor: session.historyCursor,
-        eventCursor: session.cursor,
-        replayLength: session.replay.length,
-        replayKinds: [...new Set(session.replay.map(event => event.kind))],
-        nativeEventKinds: [...new Set(session.replay.filter(event => event.kind === 'native_event')
-                .map(event => event.payload?.kind).filter(kind => typeof kind === 'string'))],
-    };
-    const reasons = [];
-    if (inputs.attachmentState !== 'connected')
-        reasons.push(`attachmentState=${inputs.attachmentState}`);
-    if (inputs.turnState !== 'idle')
-        reasons.push(`turnState=${inputs.turnState}`);
-    if (inputs.pendingRequestCount)
-        reasons.push(`pendingRequestCount=${inputs.pendingRequestCount}`);
-    if (inputs.historyTruncated)
-        reasons.push('saved history is truncated');
-    if (inputs.persistedHistoryRoles.some(role => role !== 'system'))
-        reasons.push('saved history contains a turn');
-    if (inputs.canonicalHistoryRoles.some(role => role !== 'system'))
-        reasons.push('canonical history contains a turn');
-    if (inputs.hasUserTurn)
-        reasons.push('a user turn has been observed');
-    return { ...inputs, eligible: reasons.length === 0, reasons };
-}
 function normalizePermissions(value, fallback) {
     const raw = Array.isArray(value)
         ? value.map(String)
@@ -363,24 +325,6 @@ export async function activate(context) {
     const boundId = (resource) => resolveSessionBinding(resource, controls?.state.sessions ?? [], resourceBindings);
     let applying = Promise.resolve();
     const frontends = new SupercodeFrontends();
-    const starterEligibility = (connection) => {
-        const conversation = conversationEligibility(connection);
-        const activeSession = controls?.state.activeSession ?? null;
-        const hostBusy = Boolean(controls?.state.busy);
-        const connectionMatches = frontends.get(connection.id) === connection;
-        const reasons = [...conversation.reasons];
-        if (!controls)
-            reasons.push('host controls unavailable');
-        if (activeSession !== connection.id)
-            reasons.push(`activeSession=${activeSession}; expected ${connection.id}`);
-        if (hostBusy)
-            reasons.push('hostBusy=true');
-        if (!connectionMatches)
-            reasons.push('connection was replaced');
-        return { ...conversation, controlsAvailable: Boolean(controls), connectionId: connection.id, activeSession, hostBusy, connectionMatches,
-            eligible: reasons.length === 0, reasons };
-    };
-    const lastStarterAttempts = new Map();
     // Runtimes attached by address ("Set Runtime Token", "Attach to Runtime")
     // beside a host's managed conversation. The host's catalogue does not know
     // them, so they open as what they are: attachments, shown as their runtime
@@ -389,28 +333,6 @@ export async function activate(context) {
     const managed = () => frontends.all.find((connection) => !attachedIds.has(connection.id));
     // The attached runtime the person is looking at: the Chat names its harness, not the host's.
     let focusedAttached;
-    const welcomeParticipants = new Set();
-    const welcomeValues = new WeakMap();
-    const starterResources = new Map();
-    const updateStarterWelcome = () => {
-        if (!granted.has('defaultChatParticipant'))
-            return;
-        const connection = managed();
-        const prompts = controls?.state.starterPrompts ?? [];
-        // This is the click guard's exact state, including host activity and connection
-        // identity. A later idle state must not revive an offer after a user turn.
-        const message = connection && !focusedAttached && !controls?.state.starterPromptsPending
-            && prompts.length && starterEligibility(connection).eligible
-            ? starterWelcome(prompts, connection.id, starterResources.get(connection.id) ?? sessionResource(connection).toString(), context.extension.packageJSON.supercodeFrontendWelcome.starterIntroduction)
-            : new vscode.MarkdownString('');
-        for (const participant of welcomeParticipants) {
-            if (welcomeValues.get(participant) === message.value)
-                continue;
-            participant.additionalWelcomeMessage = message;
-            welcomeValues.set(participant, message.value);
-        }
-    };
-    context.subscriptions.push(frontends.onDidChange(updateStarterWelcome), controlsChanged.event(updateStarterWelcome));
     let approvalAvailable = false;
     context.subscriptions.push(frontends.onDidChange(() => {
         const active = managed();
@@ -573,36 +495,6 @@ export async function activate(context) {
         setupTerminals.set(key, terminal);
         terminal.show();
     }));
-    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.fillStarter', async (session, index, nativeResource) => {
-        if (!controls || !Number.isInteger(index) || index < 0 || index > 2)
-            throw new Error('Invalid starter selection.');
-        const connection = frontends.get(session);
-        if (!connection)
-            throw new Error(`Starter prompt unavailable: connection ${session} is absent.`);
-        const resource = nativeResource ? vscode.Uri.parse(nativeResource)
-            : vscode.Uri.from({ scheme: SESSION_SCHEME, authority: session, path: '/conversation' });
-        if (boundId(resource) !== session)
-            throw new Error('The starter has no matching conversation binding.');
-        await connection.session.attach();
-        const guard = starterEligibility(connection);
-        lastStarterAttempts.set(session, { at: new Date().toISOString(), resource: resource.toString(),
-            boundSession: boundId(resource), guard });
-        while (lastStarterAttempts.size > 50)
-            lastStarterAttempts.delete(lastStarterAttempts.keys().next().value);
-        if (!guard.eligible)
-            throw new Error(`Starter prompt unavailable: ${guard.reasons.join('; ')}.`);
-        const prompt = controls.state.starterPrompts?.[index]?.prompt;
-        if (!prompt)
-            throw new Error('This starter is no longer available.');
-        if (!controls.state.fillInputCommand)
-            throw new Error('This host does not support filling a conversation draft.');
-        // The host addresses the existing native widget, never the default participant or last focus.
-        const receipt = await vscode.commands.executeCommand(controls.state.fillInputCommand, resource.toString(), prompt);
-        if (!receipt || receipt.sessionResource !== resource.toString() || receipt.input !== prompt) {
-            throw new Error('Chat did not confirm the requested draft.');
-        }
-        return receipt;
-    }));
     const connectionFor = async (resource) => {
         if (!controls) {
             const connection = frontends.get(resource.authority);
@@ -705,24 +597,6 @@ export async function activate(context) {
         catalogue: () => controls?.state.sessions ?? [],
         bindings: boundId,
         setup: () => controls?.state.setup,
-        prepareStarters: async (session, resource, token) => {
-            // Project configuration can arrive after the runtime connects. Wait for
-            // its real answer before publishing the conversation's welcome actions.
-            const deadline = Date.now() + 30_000;
-            await controls?.refresh();
-            while (controls?.state.starterPromptsPending) {
-                if (token.isCancellationRequested)
-                    throw new vscode.CancellationError();
-                if (Date.now() >= deadline)
-                    throw new Error('Project configuration is still loading. Reopen Chat once the project is ready.');
-                await new Promise(resolve => setTimeout(resolve, 250));
-                await controls.refresh();
-            }
-            if (token.isCancellationRequested)
-                throw new vscode.CancellationError();
-            starterResources.set(session, resource);
-            controlsChanged.fire();
-        },
     };
     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) => {
@@ -748,16 +622,25 @@ export async function activate(context) {
             return;
         }
         await controls.refresh();
-        // The host supplies startable agents, including installation/authentication checks.
-        // An absent choice is not permission to guess a harness or start another runtime.
-        const choices = controls.state.harnesses;
+        // Sign-in choices stay visible alongside agents that can be explicitly started.
+        const login = controls.state.setup?.actions.filter(action => action.kind === 'login') ?? [];
+        const choices = [
+            ...login.map(action => ({ label: action.name, id: action.harness, description: 'Sign in…', login: true, autoStart: false })),
+            ...controls.state.harnesses.filter(h => !login.some(action => action.harness === h.id))
+                .map(h => ({ label: h.name, id: h.id, description: h.description, login: false, autoStart: h.autoStart === true })),
+        ];
         if (!choices.length) {
             await revealSetup();
             return;
         }
-        const harness = choices.length === 1 ? choices[0] : await vscode.window.showQuickPick(choices.map(h => ({ label: h.name, id: h.id })), { title: 'New chat · Agent', placeHolder: 'Choose your coding agent. Model and reasoning use its defaults.' });
+        // A sole sign-in option still requires a deliberate click before opening its terminal.
+        const harness = choices.length === 1 && choices[0].autoStart ? choices[0] : await vscode.window.showQuickPick(choices, { title: 'New chat · Agent', placeHolder: 'Choose your coding agent. Model and reasoning use its defaults.' });
         if (!harness)
             return;
+        if (harness.login) {
+            await vscode.commands.executeCommand('supercode.frontend.setup', 'login', harness.id);
+            return;
+        }
         await enqueueSelection({ harness: harness.id, model: '', effort: '' });
     }));
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.configureModel', async (resource, sessionId) => {
@@ -874,9 +757,14 @@ export async function activate(context) {
         // 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)}_`);
+            try {
+                const answer = typedAnswer(pending, request.prompt);
+                await connection.session.respond(answer);
+                stream.markdown(`_answered request #${pending.id}: ${opaqueText(answer, 256)}_`);
+            }
+            catch (error) {
+                stream.markdown(`Could not answer request #${pending.id}: ${opaqueText(String(error.message), 512)}`);
+            }
             return {};
         }
         if (request.prompt.trim().length === 0) {
@@ -904,8 +792,6 @@ export async function activate(context) {
             const participant = vscode.chat.createChatParticipant(id, handler);
             participant.iconPath = icon();
             participants.push(participant);
-            welcomeParticipants.add(participant);
-            updateStarterWelcome();
             context.subscriptions.push(participant);
         }
         catch (error) {
@@ -928,8 +814,6 @@ export async function activate(context) {
                     ? 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();
-                welcomeParticipants.add(participant);
-                updateStarterWelcome();
                 return participant;
             };
             let sessionParticipant = makeParticipant();
@@ -938,7 +822,6 @@ export async function activate(context) {
                 if (participantKey() === previousIdentity)
                     return;
                 previousIdentity = participantKey();
-                welcomeParticipants.delete(sessionParticipant);
                 sessionParticipant.dispose();
                 sessionParticipant = makeParticipant();
                 for (const p of participants)
@@ -971,17 +854,13 @@ export async function activate(context) {
             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 {
+            if (answer.promptForContent) {
+                const content = await requestContent(request);
+                if (content === undefined)
+                    return;
+                response = { ...response, content };
+            }
             await connection.session.respond(response);
             void vscode.window.setStatusBarMessage(`Volter Harness: ${resolutionSentence(response, request, answer.requestId)}`, 4000);
         }
@@ -1042,8 +921,7 @@ export async function activate(context) {
         if (inspect === true)
             return {
                 connections: frontends.all.map(c => ({ ...frontends.info(c), permissions: [...c.session.permissions],
-                    pendingRequests: [...c.session.pendingRequests.values()], starterEligibility: starterEligibility(c),
-                    lastStarterAttempt: lastStarterAttempts.get(c.id) ?? null })),
+                    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)),
                 setupHandoff: { hostReady: controls?.state.setup?.ready ?? null, complete: setupHandoffComplete(),
@@ -1463,12 +1341,6 @@ function registerSessions(context, frontends, participant, granted, handler, con
                 }
                 history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, participant.id));
             }
-            // The public API cannot withdraw a rendered history command part. Keep
-            // starters in the default participant's native welcome content instead:
-            // Chat hides that whole surface as soon as the first request is added.
-            if (attached && history.length === 0 && !controls?.attached(connection) && controls) {
-                await controls.prepareStarters(connection.id, resource.toString(), _token);
-            }
             const busy = connection.session.descriptor?.turn_state === 'busy';
             return {
                 title: connection.label,
@@ -1495,3 +1367,133 @@ function registerSessions(context, frontends, participant, granted, handler, con
         },
     }, participant, { supportsInterruptions: true }));
 }
+/** Collect each question through the existing Chat answer button, preserving ids and secrets. */
+async function requestContent(request) {
+    const payload = request.payload;
+    if (Array.isArray(payload?.questions)) {
+        const answers = Object.create(null);
+        for (const value of payload.questions) {
+            if (!value || typeof value !== 'object' || Array.isArray(value) || typeof value.id !== 'string')
+                continue;
+            const question = value;
+            const options = Array.isArray(question.options) ? question.options.flatMap(option => {
+                if (!option || typeof option !== 'object' || Array.isArray(option) || typeof option.label !== 'string')
+                    return [];
+                return [{ label: option.label, description: typeof option.description === 'string' ? option.description : undefined, custom: false }];
+            }) : [];
+            let answer;
+            if (options.length) {
+                if (question.isOther === true)
+                    options.push({ label: 'Write an answer…', description: undefined, custom: true });
+                const chosen = await vscode.window.showQuickPick(options, { title: String(question.header ?? 'Codex question'), placeHolder: String(question.question ?? ''), ignoreFocusOut: true });
+                if (!chosen)
+                    return undefined;
+                if (!chosen.custom)
+                    answer = chosen.label;
+            }
+            if (answer === undefined) {
+                answer = await vscode.window.showInputBox({ title: String(question.header ?? 'Codex question'), prompt: String(question.question ?? ''), password: question.isSecret === true, ignoreFocusOut: true });
+            }
+            if (answer === undefined)
+                return undefined;
+            answers[value.id] = answer;
+        }
+        return answers;
+    }
+    const schema = payload?.requested_schema;
+    if (schema === undefined || schema === null) {
+        return vscode.window.showInputBox({ title: 'Runtime request', prompt: 'Enter your answer.', ignoreFocusOut: true });
+    }
+    const showSchema = async () => {
+        const document = await vscode.workspace.openTextDocument({ language: 'json', content: JSON.stringify(schema, null, 2) });
+        await vscode.window.showTextDocument(document, { preview: true, preserveFocus: true });
+    };
+    const structuredInput = async () => {
+        await showSchema();
+        const typed = await vscode.window.showInputBox({ title: 'Runtime request', prompt: 'Enter your answer as JSON.', ignoreFocusOut: true,
+            validateInput: value => { try {
+                JSON.parse(value);
+                return undefined;
+            }
+            catch {
+                return 'Enter valid JSON';
+            } } });
+        return typed === undefined ? undefined : JSON.parse(typed);
+    };
+    const form = objectValue(schema);
+    const properties = objectValue(form?.properties);
+    if (!properties)
+        return structuredInput();
+    const content = Object.create(null);
+    const required = Array.isArray(form?.required) ? form.required : [];
+    for (const [name, spec] of Object.entries(properties)) {
+        const field = objectValue(spec) ?? {};
+        const title = typeof field.title === 'string' ? field.title : name;
+        const description = typeof field.description === 'string' ? field.description : undefined;
+        if (!required.includes(name)) {
+            const choice = await vscode.window.showQuickPick(['Provide a value', 'Omit this field'], { title: `${title} (optional)`, ignoreFocusOut: true });
+            if (!choice)
+                return undefined;
+            if (choice === 'Omit this field')
+                continue;
+        }
+        const multiple = field.type === 'array';
+        const options = fieldChoices(multiple ? objectValue(field.items) ?? {} : field);
+        if (options.length) {
+            if (multiple) {
+                const selected = await vscode.window.showQuickPick(options, { title, placeHolder: description, canPickMany: true, ignoreFocusOut: true });
+                if (!selected)
+                    return undefined;
+                content[name] = selected.map(choice => choice.value);
+            }
+            else {
+                const selected = await vscode.window.showQuickPick(options, { title, placeHolder: description, ignoreFocusOut: true });
+                if (!selected)
+                    return undefined;
+                content[name] = selected.value;
+            }
+        }
+        else {
+            const parse = (value) => {
+                if (field.type === 'number' || field.type === 'integer') {
+                    if (!value.trim() || !Number.isFinite(Number(value)))
+                        throw new Error('Enter a number');
+                    return Number(value);
+                }
+                if (field.type === 'array' || field.type === 'object')
+                    return JSON.parse(value);
+                return value;
+            };
+            const typed = await vscode.window.showInputBox({ title, prompt: description, ignoreFocusOut: true,
+                validateInput: value => { try {
+                    parse(value);
+                    return undefined;
+                }
+                catch {
+                    return field.type === 'number' || field.type === 'integer' ? 'Enter a number' : 'Enter valid JSON';
+                } } });
+            if (typed === undefined)
+                return undefined;
+            content[name] = parse(typed);
+        }
+    }
+    return content;
+}
+function objectValue(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function fieldChoices(field) {
+    if (Array.isArray(field.enum))
+        return field.enum.map((value, index) => ({ value,
+            label: Array.isArray(field.enumNames) && typeof field.enumNames[index] === 'string' ? field.enumNames[index] : String(value) }));
+    const variants = Array.isArray(field.oneOf) ? field.oneOf : field.anyOf;
+    if (Array.isArray(variants))
+        return variants.flatMap(value => {
+            const option = objectValue(value);
+            return option && Object.hasOwn(option, 'const') ? [{ value: option.const,
+                    label: typeof option.title === 'string' ? option.title : String(option.const) }] : [];
+        });
+    if (field.type === 'boolean')
+        return [{ label: 'True', value: true }, { label: 'False', value: false }];
+    return [];
+}

package/dist/host-controls.d.ts

@@ -9,10 +9,7 @@ export interface ChatChoice {
     id: string;
     name: string;
     description?: string;
-}
-export interface ChatStarterPrompt {
-    label: string;
-    prompt: string;
+    autoStart?: boolean;
 }
 export interface ManagedChatSession {
     id: string;
@@ -39,8 +36,6 @@ export interface HostState {
     historyTruncated?: boolean;
     activeSession: string | null;
     openSessionCommand?: string;
-    /** Fill the composer of an exact native session; returns {sessionResource, input}. */
-    fillInputCommand?: string;
     /** The native renderer supports a leading response with no visible user request. */
     responseOnlyHistory?: boolean;
     sessions: ManagedChatSession[];
@@ -54,9 +49,6 @@ export interface HostState {
     actualModel?: string | null;
     configurable: boolean;
     setup?: ChatSetupState;
-    starterPrompts?: ChatStarterPrompt[];
-    /** The host's project configuration has not finished loading yet. */
-    starterPromptsPending?: boolean;
 }
 export interface HostSelectionResult extends HostState {
     connection: Record<string, string>;

package/dist/session.d.ts

@@ -77,8 +77,6 @@ export declare class VscodeFrontendSession {
     history: ChatMessage[];
     historyCursor: number;
     cursor: number;
-    /** Semantic evidence, retained even when replay is evicted or re-attached. */
-    hasUserTurn: boolean;
     /**
      * Every event this attachment has seen, in order — NOT just the last
      * snapshot's. A re-attach asks `afterSequence: cursor`, so its `replay` is

package/dist/session.js

@@ -44,8 +44,6 @@ export class VscodeFrontendSession {
     history = [];
     historyCursor = 0;
     cursor = 0;
-    /** Semantic evidence, retained even when replay is evicted or re-attached. */
-    hasUserTurn = false;
     /**
      * Every event this attachment has seen, in order — NOT just the last
      * snapshot's. A re-attach asks `afterSequence: cursor`, so its `replay` is
@@ -105,8 +103,6 @@ export class VscodeFrontendSession {
             descriptor: structuredClone(snapshot.descriptor),
             pendingRequests: new Map([...this.pendingRequests].map(([id, request]) => [id, structuredClone(request)])),
             cursor: Math.max(this.cursor, snapshot.history_cursor),
-            hasUserTurn: this.hasUserTurn || snapshot.descriptor.turn_state === 'busy'
-                || snapshot.history.some(message => message.role !== 'system'),
         };
         // Validate and project the whole attachment before any observable field
         // moves or a live listener is registered.
@@ -121,7 +117,9 @@ export class VscodeFrontendSession {
         // dead id. An approval can only be outstanding while a turn is running,
         // because `decide_approval` blocks the agent loop, so an idle runtime has
         // none no matter what its replay still carries.
-        if (staged.descriptor?.turn_state !== 'busy')
+        // Hosted Codex also receives standalone MCP elicitations. Its host retains
+        // request/resolved pairs without the native broker's turn compaction.
+        if (staged.descriptor?.turn_state !== 'busy' && staged.descriptor?.source_harness !== 'codex')
             staged.pendingRequests.clear();
         this.descriptor = staged.descriptor;
         this.history = structuredClone(snapshot.history);
@@ -129,7 +127,6 @@ export class VscodeFrontendSession {
         this.appendTranscript(structuredClone(snapshot.replay));
         this.pendingRequests = staged.pendingRequests;
         this.cursor = staged.cursor;
-        this.hasUserTurn = staged.hasUserTurn;
         this.connection = 'connected';
         this.attachedAtMs ??= Date.now();
         if (!this.#subscribed) {
@@ -257,11 +254,6 @@ export class VscodeFrontendSession {
             throw new EventSequenceGapError(state.cursor + 1, event.sequence);
         }
         state.cursor = event.sequence;
-        // Hosted runtimes publish user_message + turn_started when accepting input.
-        // Native init/status notifications also consume sequence numbers, but are
-        // not user turns. Keep this independent of the bounded replay buffer.
-        if (BUSY_KINDS.has(event.kind))
-            state.hasUserTurn = true;
         const payload = (event.payload ?? {});
         if (event.kind === 'request' && payload.type === 'request') {
             const request = payload.request;
@@ -278,6 +270,11 @@ export class VscodeFrontendSession {
             }
             state.pendingRequests.delete(payload.request_id);
         }
+        if (event.kind === 'runtime_disconnected') {
+            state.pendingRequests.clear();
+            if (state.descriptor)
+                state.descriptor = { ...state.descriptor, connection_state: 'shutting_down', turn_state: 'idle', actions: { ...state.descriptor.actions, submit: false, steer: false, interrupt: false, respond: false } };
+        }
         if (state === this) {
             if (BUSY_KINDS.has(event.kind))
                 this.lastTurnStartedMs = Date.now();

package/dist/view.js

@@ -111,8 +111,10 @@ export function requestSummary(request) {
         // naming a runtime uses and falls back to bounded JSON.
         for (const field of ['subject', 'message', 'tool', 'tool_name', 'summary', 'prompt', 'reason']) {
             const value = fields[field];
-            if (typeof value === 'string')
-                return clamp(stripControls(value), VSCODE_CHAT_LIMITS.partCharacters);
+            if (typeof value === 'string') {
+                const url = typeof fields.url === 'string' ? `\n\n${fields.url}` : '';
+                return clamp(stripControls(value + url), VSCODE_CHAT_LIMITS.partCharacters);
+            }
         }
     }
     return opaqueText(payload);
@@ -121,6 +123,18 @@ export function requestSummary(request) {
 export function requestAnswers(request, connectionId) {
     const base = { connectionId, requestId: request.id };
     if (request.kind === 'approval') {
+        const options = request.payload && typeof request.payload === 'object' && !Array.isArray(request.payload)
+            ? request.payload.options : undefined;
+        if (Array.isArray(options)) {
+            return options.flatMap(option => {
+                if (!option || typeof option !== 'object' || Array.isArray(option) || typeof option.id !== 'string' || typeof option.label !== 'string')
+                    return [];
+                const response = ['allow', 'allow_for_session', 'deny'].includes(option.id)
+                    ? { kind: 'approval', request_id: request.id, decision: option.id }
+                    : { kind: 'other', request_id: request.id, action: 'accept', content: { option_id: option.id } };
+                return [{ ...base, label: option.label, response }];
+            });
+        }
         const all = [
             { ...base, label: 'Allow', response: { kind: 'approval', request_id: request.id, decision: 'allow' } },
             {
@@ -161,6 +175,9 @@ export function requestAnswers(request, connectionId) {
 export function typedAnswer(request, reply) {
     const normalized = reply.trim().toLowerCase();
     if (request.kind === 'approval') {
+        if (['cancel', 'allow_always', 'execpolicy'].includes(normalized) || /^network_\d+$/.test(normalized)) {
+            return { kind: 'other', request_id: request.id, action: 'accept', content: { option_id: normalized } };
+        }
         if (['allow for session', 'allow_for_session', 'session'].includes(normalized)) {
             return { kind: 'approval', request_id: request.id, decision: 'allow_for_session' };
         }
@@ -194,6 +211,8 @@ export function requestNeedsTypedReply(request) {
     const payload = request.payload;
     if (!payload || typeof payload !== 'object' || Array.isArray(payload))
         return false;
+    if (Array.isArray(payload.questions))
+        return true;
     const schema = payload.requested_schema;
     return schema !== undefined && schema !== null;
 }
@@ -211,6 +230,12 @@ export function resolutionSentence(response, request, requestId) {
         const verb = { allow: 'Allowed', allow_for_session: 'Allowed for session', deny: 'Denied' }[response.decision];
         return `${verb ?? 'Resolved'}${suffix}`;
     }
+    if (response.kind === 'other' && response.content && typeof response.content === 'object' && !Array.isArray(response.content) && typeof response.content.option_id === 'string') {
+        const options = request?.payload && typeof request.payload === 'object' && !Array.isArray(request.payload) ? request.payload.options : undefined;
+        const option = Array.isArray(options) ? options.find(value => value && typeof value === 'object' && !Array.isArray(value) && value.id === response.content.option_id) : undefined;
+        if (option && typeof option === 'object' && !Array.isArray(option) && typeof option.label === 'string')
+            return `Selected “${option.label}” for${suffix}`;
+    }
     const verb = { accept: 'Accepted', decline: 'Declined', cancel: 'Cancelled' }[response.action];
     const content = typeof response.content === 'string' && response.content.length > 0
         ? ` — ${clamp(stripControls(response.content), 160)}`
@@ -419,7 +444,7 @@ export function projectEvent(event, context) {
             //     runtime is left blocked. A preferred path that silently swallows
             //     the answer is worse than a plain one that works.
             // A command button runs inside the live turn and carries its own answer,
-            // so all three approval decisions are offered. It cannot be withdrawn
+            // so the runtime's offered answers remain usable. It cannot be withdrawn
             // once pushed (`chatCommandContentPart` enables on `!isStale` and has no
             // used-state), so `supercode.frontend.respond` refuses a request that is
             // no longer pending and SAYS so instead of sending a stale answer.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.18",
+  "version": "0.1.21",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",
@@ -23,7 +23,7 @@
     "media"
   ],
   "scripts": {
-    "build": "node scripts/sync-sdk.mjs && node scripts/fetch-icon.mjs && tsc -p tsconfig.build.json",
+    "build": "node -e \"require('node:fs').rmSync('dist', {recursive:true, force:true})\" && node scripts/sync-sdk.mjs && node scripts/fetch-icon.mjs && tsc -p tsconfig.build.json",
     "extension": "npm run build && node scripts/pack-extension.mjs",
     "prepack": "npm run build"
   },
@@ -196,9 +196,6 @@
     "@types/vscode": "1.138.0",
     "typescript": "5.6.3"
   },
-  "supercodeFrontendWelcome": {
-    "starterIntroduction": "Choose an idea to edit before sending:"
-  },
   "supercodeFrontendContract": {
     "name": "@volter/supercode-frontend",
     "version": "0.2.7",