@volter/supercode-frontend-vscode 0.1.28 → 0.1.29

package/README.md

@@ -73,12 +73,29 @@ picker includes the official choice on supported hosts; with no choices it retur
 to setup. Model
 and reasoning are sent as empty values, leaving both at the harness's own defaults,
 even if the previous conversation used explicit settings. Cancelling the agent
-picker creates nothing.
+picker starts no backend conversation.
+
+The native blank chat opens before the picker appears. First send waits for the
+choice and the host's new connection through Code-OSS's session-creation handler;
+the composer keeps the draft until the request is accepted. There is no later
+conversation swap that can hide a message sent while the agent starts. This follows
+the pinned workbench's [first-send materialization](https://github.com/volter-ai/code-oss/blob/f16dc165c0dffe701a7bbf59aefb1c662b206cee/src/vs/workbench/contrib/chat/common/chatService/chatServiceImpl.ts#L1272)
+and [draft acceptance](https://github.com/volter-ai/code-oss/blob/f16dc165c0dffe701a7bbf59aefb1c662b206cee/src/vs/workbench/contrib/chat/browser/widget/chatWidget.ts#L3493)
+paths. A failed startup leaves the draft available to retry.
+
+The pending agent/model choice belongs to that blank chat's untitled resource
+and is retired when another conversation opens. Cancelling or opening sign-in
+does not choose an agent. Readiness polling and **Check again** still discover
+agents while a draft is open, updating the welcome and model catalogue without
+replacing its widget or input. First send refreshes readiness; after a native
+sign-in choice it uses that agent once ready, otherwise it keeps the draft with
+a visible sign-in error.
 
 The composer's native **Model settings** control offers **Choose model and reasoning
 for a new chat…** for Claude Code and Codex. This optional path retains the model
 list, exact model ID entry and reasoning choices. Only completing the choices
-starts a separate conversation; cancelling either leaves the current one intact.
+configures the new blank chat; its backend starts on first send. Cancelling a
+choice starts no backend and leaves the blank chat available.
 A conversation's harness, model and reasoning remain fixed: this integration does
 not advertise hot swapping. The built-in model picker still displays the selected
 model and provider icon; nondelegating session providers cannot add its Manage
@@ -93,7 +110,12 @@ The host publishes durable conversation IDs and their exact harness history iden
 reported native session ID to discovered history. Unknown or missing bindings fail explicitly,
 never falling back to the currently active runtime. The host may provide an `openSessionCommand`
 to reveal an exact resource through its native widget service. Cached native widgets should
-notify `supercode.frontend.activateSession` when focused. The frontend owns no processes.
+notify `supercode.frontend.focusSession` on every native focused-resource change,
+including untitled resources and leaving harness Chat (`undefined` when there is
+no focused session). This retires abandoned draft choices even when returning to
+the same cached conversation. Managed resources then notify
+`supercode.frontend.activateSession` to restore their exact backend. The frontend
+owns no processes.
 
 The permission group offers **Ask for approval** and, on an answerable interactive attachment,
 **Auto approve**. Policies are scoped by conversation and captured for each turn; automatic

package/dist/extension.js

@@ -321,6 +321,21 @@ export async function activate(context) {
     const resourceBindings = new Map(context.workspaceState.get('supercode.sessionBindings', []));
     const boundId = (resource) => resolveSessionBinding(resource, controls?.state.sessions ?? [], resourceBindings);
     let applying = Promise.resolve();
+    let pendingDraft;
+    let focusedResource;
+    const activeDraft = () => pendingDraft?.resource && pendingDraft.resource.toString() === focusedResource?.toString() ? pendingDraft : undefined;
+    const draftSelection = () => {
+        const choice = activeDraft()?.choice;
+        return choice?.kind === 'agent' ? choice.selection : undefined;
+    };
+    const focusSession = (resource) => {
+        const changed = focusedResource?.toString() !== resource?.toString();
+        focusedResource = resource;
+        if (pendingDraft?.resource && pendingDraft.resource.toString() !== resource?.toString())
+            pendingDraft = undefined;
+        if (changed)
+            controlsChanged.fire();
+    };
     const frontends = new SupercodeFrontends();
     // Runtimes attached by address ("Set Runtime Token", "Attach to Runtime")
     // beside a host's managed conversation. The host's catalogue does not know
@@ -343,6 +358,9 @@ export async function activate(context) {
         if (focusedAttached)
             return runtimeIdentity(focusedAttached.session.descriptor?.source_harness, focusedAttached.session.descriptor?.model);
         const descriptor = managed()?.session.descriptor;
+        const selection = draftSelection();
+        if (selection)
+            return runtimeIdentity(selection.harness, selection.model);
         return runtimeIdentity(controls?.state.selection.harness ?? descriptor?.source_harness, controls?.state.selection.model || controls?.state.actualModel || descriptor?.model);
     };
     const icon = () => {
@@ -357,7 +375,9 @@ export async function activate(context) {
             provideLanguageModelChatInformation: () => {
                 if (controls.state.setup && !controls.state.setup.ready)
                     return [];
-                const { selection, models } = controls.state;
+                const draft = draftSelection();
+                const selection = draft ?? controls.state.selection;
+                const models = draft ? controls.state.modelsByHarness?.[selection.harness] ?? [] : controls.state.models;
                 // 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);
@@ -401,7 +421,7 @@ export async function activate(context) {
             await frontends.disconnect(connection.id);
         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);
+            permissions: normalizePermissions(env.SUPERCODE_FRONTEND_PERMISSIONS, ['observe']), label: runtimeIdentity(controls.state.selection.harness, controls.state.selection.model || controls.state.actualModel).name }, log);
         if (!connection)
             throw new Error('Could not connect to the requested conversation.');
         return connection;
@@ -441,18 +461,23 @@ export async function activate(context) {
         refreshingSetup ??= (async () => {
             if (!controls)
                 return;
+            // Discover and publish readiness even while a blank chat holds a draft.
+            // Only the automatic reveal is suppressed; discovery must never stall.
             await controls.refresh();
+            controlsChanged.fire();
+            const preserveDraft = focusedResource?.path.startsWith('/untitled-');
             if (controls.state.setup?.ready) {
                 setupRevealed = false;
                 await connectManaged();
                 controlsChanged.fire();
-                if (!setupHandoffComplete())
+                if (!preserveDraft && !setupHandoffComplete())
                     await revealManaged();
             }
             else {
                 setupHandoff = undefined;
                 controlsChanged.fire();
-                await revealSetup();
+                if (!preserveDraft)
+                    await revealSetup();
             }
         })().finally(() => { refreshingSetup = undefined; });
         return refreshingSetup;
@@ -488,6 +513,7 @@ export async function activate(context) {
         terminal.show();
     }));
     const connectionFor = async (resource) => {
+        focusSession(resource);
         if (!controls) {
             const connection = frontends.get(resource.authority);
             if (!connection)
@@ -525,7 +551,7 @@ export async function activate(context) {
             controlsChanged.fire();
         return connection;
     };
-    async function applySelection(selection, openChat = true) {
+    async function applySelection(selection) {
         if (!controls)
             throw new Error('This host does not expose harness or model configuration.');
         const active = managed();
@@ -534,13 +560,61 @@ export async function activate(context) {
         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;
+    const openNewChat = async () => {
+        if (!controls || !granted.has('chatSessionsProvider'))
+            throw new Error('This host does not expose native conversation creation.');
+        const active = managed();
+        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.');
+        // Code-OSS materializes this untitled session on first send, awaiting our
+        // newChatSessionItemHandler before accepting/clearing the draft. Never boot
+        // beside the old widget and reveal another resource after it accepts input.
+        if (!controls.state.openSessionCommand)
+            throw new Error('The host cannot reveal a new conversation.');
+        // Use Code-OSS's untitled URI format and its existing native widget bridge.
+        // Blank sessions resolve content lazily, so a content-provider callback
+        // cannot be used to discover which resource owns the pending selection.
+        const draft = { resource: vscode.Uri.from({ scheme: SESSION_SCHEME, path: `/untitled-${randomUUID()}` }) };
+        pendingDraft = draft;
+        focusedResource = draft.resource;
+        focusedAttached = undefined;
+        controlsChanged.fire();
+        await vscode.commands.executeCommand(controls.state.openSessionCommand, draft.resource.toString());
+        if (pendingDraft !== draft)
+            throw new vscode.CancellationError();
+        return draft;
+    };
+    const chooseNewChat = async (pick) => {
+        if (pendingDraft?.choosing)
+            throw new Error('Finish choosing an agent before starting another chat.');
+        // Open before the picker: a send can beat its result across the extension-
+        // host boundary. Materialization awaits this exact draft's choice too.
+        const draft = await openNewChat();
+        const picking = (async () => {
+            const choice = await pick();
+            if (activeDraft() !== draft)
+                throw new vscode.CancellationError();
+            draft.choice = choice;
+            controlsChanged.fire();
+            if (choice.kind !== 'agent')
+                throw new vscode.CancellationError();
+        })();
+        draft.choosing = picking;
+        try {
+            await picking;
+        }
+        catch (error) {
+            if (!(error instanceof vscode.CancellationError))
+                throw error;
+        }
+        finally {
+            if (draft.choosing === picking)
+                draft.choosing = undefined;
+            if (draft.choice?.kind === 'signIn') {
+                void refreshSetup().catch(error => log.warn(`Could not refresh sign-in: ${String(error)}`)).finally(pollSetup);
+            }
+        }
     };
     // Publish capability-honest input groups only after the handoff descriptor is available.
     if (controls?.state.connection)
@@ -561,7 +635,7 @@ export async function activate(context) {
             if (selected && ['claude-code', 'codex'].includes(selected.selection.harness)) {
                 // Native session-option commands remain reachable for nondelegating providers,
                 // whose built-in model picker deliberately omits Manage Models. Do not advertise
-                // hot swapping: the command opens a separate conversation after both choices.
+                // hot swapping: the command configures a separate native blank chat.
                 // A locked selected item hides the entire native dropdown, including commands.
                 const item = { id: 'settings', name: 'Model settings' };
                 groups.push({ id: 'modelSettings', name: 'Model', items: [item], selected: item,
@@ -581,17 +655,45 @@ export async function activate(context) {
         create: async (inputState) => {
             if (!controls)
                 throw new Error('The host does not expose conversation creation.');
-            await enqueueSelection({ harness: controls.state.selection.harness, model: '', effort: '' }, false);
+            const draft = activeDraft();
+            await draft?.choosing;
+            if (draft && activeDraft() !== draft)
+                throw new vscode.CancellationError();
+            await controls.refresh();
+            controlsChanged.fire();
+            const choice = draft?.choice;
+            const loginHarness = choice?.kind === 'signIn' ? choice.harness : undefined;
+            if (loginHarness && !controls.state.harnesses.some(h => h.id === loginHarness && h.autoStart)) {
+                throw new Error(`Finish signing in with ${harnessDisplayName(loginHarness)} before sending. Your draft is kept.`);
+            }
+            if (choice?.kind !== 'agent' && controls.state.setup && !controls.state.setup.ready) {
+                throw new Error('Sign in before sending. Your draft is kept; use Check again after signing in.');
+            }
+            const selection = choice?.kind === 'agent' ? choice.selection
+                : { harness: loginHarness ?? controls.state.selection.harness, model: '', effort: '' };
+            const pending = applying.then(() => applySelection(selection));
+            applying = pending.catch(() => undefined);
+            await pending;
             const connection = frontends.get(controls.state.activeSession);
             savePermission(connection.id, turnPermission(inputState.groups.find(group => group.id === 'permissions')?.selected?.id));
+            if (pendingDraft === draft) {
+                pendingDraft = undefined;
+                controlsChanged.fire();
+            }
             return connection;
         },
         resolve: connectionFor,
+        focus: focusSession,
         attached: (connection) => attachedIds.has(connection.id),
         catalogue: () => controls?.state.sessions ?? [],
         bindings: boundId,
     };
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.activateSession', async (resource) => { await connectionFor(vscode.Uri.parse(resource)); }));
+    // The host's native focus event is authoritative even when a cached model
+    // skips content resolution. Untitled/non-harness focus never starts a runtime.
+    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.focusSession', (resource) => {
+        focusSession(resource ? vscode.Uri.parse(resource) : undefined);
+    }));
     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();
@@ -607,7 +709,7 @@ export async function activate(context) {
             return currentOptions();
         }
         if (supplied && typeof supplied.harness === 'string') {
-            await enqueueSelection(supplied);
+            await chooseNewChat(async () => ({ kind: 'agent', selection: supplied }));
             return currentOptions();
         }
         if (!controls) {
@@ -632,18 +734,20 @@ export async function activate(context) {
         }
         // A sole sign-in option still requires a deliberate click before opening its terminal.
         // The official choice must not disable the existing sole-local-agent shortcut.
-        const harness = localChoices.length === 1 && localChoices[0].autoStart ? localChoices[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.id === CHATGPT_SIGN_IN) {
-            await vscode.commands.executeCommand(CHATGPT_SIGN_IN);
-            return;
-        }
-        if (harness.login) {
-            await vscode.commands.executeCommand('supercode.frontend.setup', 'login', harness.id);
-            return;
-        }
-        await enqueueSelection({ harness: harness.id, model: '', effort: '' });
+        await chooseNewChat(async () => {
+            const harness = localChoices.length === 1 && localChoices[0].autoStart ? localChoices[0] : await vscode.window.showQuickPick(choices, { title: 'New chat · Agent', placeHolder: 'Choose your coding agent. Model and reasoning use its defaults.' });
+            if (!harness)
+                return { kind: 'cancelled' };
+            if (harness.id === CHATGPT_SIGN_IN) {
+                await vscode.commands.executeCommand(CHATGPT_SIGN_IN);
+                return { kind: 'signIn' };
+            }
+            if (harness.login) {
+                await vscode.commands.executeCommand('supercode.frontend.setup', 'login', harness.id);
+                return { kind: 'signIn', harness: harness.id };
+            }
+            return { kind: 'agent', selection: { harness: harness.id, model: '', effort: '' } };
+        });
     }));
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.configureModel', async (resource, sessionId) => {
         if (!controls || focusedAttached)
@@ -660,25 +764,25 @@ export async function activate(context) {
         const selection = { ...selected.selection };
         if (!['claude-code', 'codex'].includes(selection.harness))
             throw new Error('This harness uses its own model defaults; configuration is not advertised.');
-        if (['claude-code', 'codex'].includes(selection.harness)) {
+        await chooseNewChat(async () => {
             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;
+                return { kind: 'cancelled' };
             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;
+                    return { kind: 'cancelled' };
                 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;
+                return { kind: 'cancelled' };
             selection.effort = effort.id;
-        }
-        await enqueueSelection(selection);
+            return { kind: 'agent', selection };
+        });
     }));
     context.subscriptions.push({ dispose: () => frontends.dispose() });
     const runTurnInto = async (connection, prompt, stream, token, approval) => {
@@ -804,8 +908,10 @@ export async function activate(context) {
         if (welcomeValue === welcome?.value)
             return;
         welcomeValue = welcome?.value;
+        // Metadata updates merge across RPC; undefined can leave the previous
+        // sign-in message behind. An explicit empty value clears it in place.
         for (const participant of participants)
-            participant.additionalWelcomeMessage = welcome;
+            participant.additionalWelcomeMessage = welcome ?? new vscode.MarkdownString('');
     };
     updateWelcome();
     context.subscriptions.push(controlsChanged.event(updateWelcome), frontends.onDidChange(updateWelcome));
@@ -817,7 +923,7 @@ export async function activate(context) {
             // 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(focusedAttached?.session.descriptor?.source_harness ?? controls?.state.selection.harness ?? managed()?.session.descriptor?.source_harness);
+            const participantName = () => harnessDisplayName(focusedAttached?.session.descriptor?.source_harness ?? draftSelection()?.harness ?? controls?.state.selection.harness ?? managed()?.session.descriptor?.source_harness);
             const participantKey = () => `${participantName()}/${identity().provider ?? ''}`;
             const makeParticipant = () => {
                 const current = { name: participantName() };
@@ -1067,9 +1173,12 @@ export async function activate(context) {
     let setupTimer;
     let setupDisposed = false;
     const pollSetup = () => {
-        if (setupDisposed || !controls?.state.setup || (controls.state.setup.ready && setupHandoffComplete()))
+        const choice = activeDraft()?.choice;
+        const awaitingLogin = choice?.kind === 'signIn' && choice.harness && !controls?.state.harnesses.some(h => h.id === choice.harness && h.autoStart);
+        if (setupTimer || setupDisposed || !controls?.state.setup || (controls.state.setup.ready && setupHandoffComplete() && !awaitingLogin))
             return;
         setupTimer = setTimeout(() => {
+            setupTimer = undefined;
             void refreshSetup().catch(error => log.warn(`Could not refresh sign-in: ${String(error)}`)).finally(pollSetup);
         }, 3000);
     };
@@ -1261,6 +1370,7 @@ function registerSessions(context, frontends, participant, granted, handler, con
     }
     context.subscriptions.push(vscode.chat.registerChatSessionContentProvider(SESSION_SCHEME, {
         provideChatSessionContent: async (resource, _token, { inputState }) => {
+            controls?.focus(resource);
             const boundHandler = (request, chatContext, stream, token) => handler(request, { ...chatContext, chatSessionContext: { chatSessionItem: { resource, label: 'Conversation' } } }, stream, token);
             // Only a native untitled resource can create a conversation. Existing
             // resources must resolve their exact saved binding; there is no fallback.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",