@volter/supercode-frontend-vscode 0.1.28 → 0.1.30

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,24 @@ 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;
+    let focusGeneration = 0;
+    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) {
+            focusGeneration++;
+            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 +361,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 +378,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);
@@ -386,11 +409,20 @@ export async function activate(context) {
         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)
+    const savedConnections = new Map();
+    const saveManagedHistory = async (connection) => {
+        const state = await controls.open(connection.id);
+        if (state.activeSession !== connection.id)
+            throw new Error('The conversation changed before its history could be saved.');
+        connection.persistedHistory = state.history;
+        connection.historyTruncated = state.historyTruncated;
+        savedConnections.set(connection.id, connection);
+    };
+    const connectManaged = async (state = controls.state) => {
+        const env = state.connection;
+        if (!env || !state.activeSession)
             throw new Error('The requested conversation has no runtime connection.');
-        const id = controls.state.activeSession;
+        const id = state.activeSession;
         const existing = frontends.get(id);
         if (existing && existing.baseUrl === env.SUPERCODE_FRONTEND_URL && existing.session.connection !== 'closed') {
             if (existing.session.connection !== 'connected')
@@ -401,7 +433,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(state.selection.harness, state.selection.model || state.actualModel).name }, log);
         if (!connection)
             throw new Error('Could not connect to the requested conversation.');
         return connection;
@@ -438,23 +470,33 @@ export async function activate(context) {
     };
     let refreshingSetup;
     const refreshSetup = () => {
-        refreshingSetup ??= (async () => {
+        if (refreshingSetup)
+            return refreshingSetup;
+        const pending = applying.then(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();
-            if (controls.state.setup?.ready) {
+            const state = controls.state;
+            controlsChanged.fire();
+            const preserveDraft = focusedResource?.path.startsWith('/untitled-');
+            if (state.setup?.ready) {
                 setupRevealed = false;
-                await connectManaged();
+                await connectManaged(state);
                 controlsChanged.fire();
-                if (!setupHandoffComplete())
+                if (!preserveDraft && !setupHandoffComplete())
                     await revealManaged();
             }
             else {
                 setupHandoff = undefined;
                 controlsChanged.fire();
-                await revealSetup();
+                if (!preserveDraft)
+                    await revealSetup();
             }
-        })().finally(() => { refreshingSetup = undefined; });
+        });
+        applying = pending.then(() => undefined, () => undefined);
+        refreshingSetup = pending.finally(() => { refreshingSetup = undefined; });
         return refreshingSetup;
     };
     const setupTerminals = new Map();
@@ -487,7 +529,8 @@ export async function activate(context) {
         setupTerminals.set(key, terminal);
         terminal.show();
     }));
-    const connectionFor = async (resource) => {
+    const restoring = new Map();
+    const connectionFor = async (resource, activate = true) => {
         if (!controls) {
             const connection = frontends.get(resource.authority);
             if (!connection)
@@ -495,7 +538,7 @@ export async function activate(context) {
             return connection;
         }
         const attached = attachedIds.has(resource.authority) ? frontends.get(resource.authority) : undefined;
-        if (focusedAttached !== attached) {
+        if (activate && focusedAttached !== attached) {
             focusedAttached = attached;
             controlsChanged.fire();
         }
@@ -504,43 +547,124 @@ export async function activate(context) {
         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 = managed();
-        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.');
+        // Content refresh is not a focus change. Replaying a previously connected
+        // conversation must not retire the runtime the person just selected.
+        if (!activate) {
+            const saved = frontends.get(id) ?? savedConnections.get(id);
+            if (saved)
+                return saved;
+        }
+        const existing = restoring.get(id);
+        // Coalesce adjacent requests only. A later A after a queued B must still
+        // activate A last, rather than borrowing an earlier A's completion.
+        if (existing?.completion === applying)
+            return existing.pending;
+        const pending = applying.then(async () => {
+            const active = managed();
+            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.');
+            if (active && active.id !== id) {
+                // Capture the exact saved transcript while its runtime still belongs
+                // to the host. Subsequent background content reads need no activation.
+                await saveManagedHistory(active);
+            }
+            let state;
+            try {
+                state = await controls.open(id);
+            }
+            catch (error) {
+                log.error(`Could not restore conversation ${id}: ${String(error)}`);
+                throw error;
+            }
+            if (state.activeSession !== id)
+                throw new Error('The host did not restore the requested conversation.');
+            const connection = await connectManaged(state);
+            connection.persistedHistory = state.history;
+            connection.historyTruncated = state.historyTruncated;
+            savedConnections.set(id, connection);
+            if (active !== connection)
+                controlsChanged.fire();
+            return connection;
+        });
+        const completion = pending.then(() => undefined, () => undefined);
+        restoring.set(id, { pending, completion });
+        applying = completion;
         try {
-            await controls.open(id);
+            return await pending;
         }
-        catch (error) {
-            log.error(`Could not restore conversation ${id}: ${String(error)}`);
-            throw error;
+        finally {
+            if (restoring.get(id)?.pending === pending)
+                restoring.delete(id);
         }
-        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) {
+    async function applySelection(selection) {
         if (!controls)
             throw new Error('This host does not expose harness or model configuration.');
         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.');
-        await controls.select(selection);
-        await connectManaged();
+        if (active)
+            await saveManagedHistory(active);
+        const state = await controls.select(selection);
+        const connection = await connectManaged(state);
         controlsChanged.fire();
-        if (openChat)
-            await revealManaged();
+        return connection;
     }
-    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;
+        focusGeneration++;
+        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 +685,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,19 +705,50 @@ 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 connection = frontends.get(controls.state.activeSession);
+            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.then(() => undefined, () => undefined);
+            const connection = await pending;
             savePermission(connection.id, turnPermission(inputState.groups.find(group => group.id === 'permissions')?.selected?.id));
+            if (pendingDraft === draft) {
+                pendingDraft = undefined;
+                controlsChanged.fire();
+            }
             return connection;
         },
-        resolve: connectionFor,
+        resolve: (resource) => connectionFor(resource, false),
         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' }));
+        const resource = vscode.Uri.from({ scheme: SESSION_SCHEME, authority: id, path: '/conversation' });
+        focusSession(resource);
+        const generation = focusGeneration;
+        await connectionFor(resource);
+        if (generation !== focusGeneration)
+            return;
         await revealManaged();
     }));
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.configure', async (supplied) => {
@@ -607,7 +762,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 +787,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 +817,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 +961,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 +976,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() };
@@ -839,7 +998,28 @@ export async function activate(context) {
                     p.iconPath = icon();
             };
             context.subscriptions.push({ dispose: () => sessionParticipant.dispose() }, controlsChanged.event(updateIdentity), frontends.onDidChange(updateIdentity));
-            registerSessions(context, frontends, sessionParticipant, granted, handler, controls ? providerControls : undefined);
+            // Replayed turns outlive the active composer participant. Keep their
+            // author tied to the saved harness, including passive background loads.
+            const historyParticipants = new Map();
+            const historyParticipant = (connection) => {
+                if (!granted.has('chatParticipantPrivate'))
+                    return sessionParticipant.id;
+                const harness = connection.session.descriptor?.source_harness
+                    ?? controls?.state.sessions.find(entry => entry.id === connection.id)?.selection.harness;
+                if (!harness)
+                    return sessionParticipant.id;
+                let author = historyParticipants.get(harness);
+                if (!author) {
+                    const name = harnessDisplayName(harness);
+                    author = vscode.chat.createDynamicChatParticipant(`${SESSION_SCHEME}.history.${encodeURIComponent(harness)}`, { name: name.replace(/[^a-zA-Z0-9]/g, ''), fullName: name, publisherName: 'Volter' }, handler);
+                    const provider = runtimeIdentity(harness, '').provider;
+                    author.iconPath = provider ? vscode.Uri.joinPath(context.extensionUri, 'media', `${provider}.svg`) : new vscode.ThemeIcon('hubot');
+                    historyParticipants.set(harness, author);
+                    context.subscriptions.push(author);
+                }
+                return author.id;
+            };
+            registerSessions(context, frontends, sessionParticipant, granted, handler, historyParticipant, controls ? providerControls : undefined);
         }
         catch (error) {
             log.warn(`Volter Harness chat sessions were not registered: ${String(error?.message ?? error)}`);
@@ -1067,9 +1247,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);
     };
@@ -1206,7 +1389,7 @@ function applyTiming(item, connection) {
         lastRequestEnded: connection.session.lastTurnEndedMs ?? undefined,
     };
 }
-function registerSessions(context, frontends, participant, granted, handler, controls) {
+function registerSessions(context, frontends, participant, granted, handler, historyParticipant, controls) {
     const turns = vscode;
     const items = () => {
         return (controls?.catalogue() ?? []).filter(entry => !frontends.get(entry.id)).map(entry => {
@@ -1260,11 +1443,15 @@ function registerSessions(context, frontends, participant, granted, handler, con
         }));
     }
     context.subscriptions.push(vscode.chat.registerChatSessionContentProvider(SESSION_SCHEME, {
-        provideChatSessionContent: async (resource, _token, { inputState }) => {
+        provideChatSessionContent: async (resource, token, { inputState }) => {
+            if (token.isCancellationRequested)
+                throw new vscode.CancellationError();
             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.
             const connection = controls ? (resource.path.startsWith('/untitled-') && !controls.bindings(resource) ? undefined : await controls.resolve(resource)) : frontends.get(resource.authority);
+            if (token.isCancellationRequested)
+                throw new vscode.CancellationError();
             if (!connection) {
                 return { history: [], requestHandler: boundHandler };
             }
@@ -1277,13 +1464,14 @@ function registerSessions(context, frontends, participant, granted, handler, con
             // `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.
-            const attached = await connection.session.attach().then(() => true).catch(() => {
+            const attached = frontends.get(connection.id) === connection && await connection.session.attach().then(() => true).catch(() => {
                 // An unreachable runtime replays what this window last saw.
                 return false;
             });
             // The attach snapshot IS the session's history: the runtime's own
             // canonical transcript, replayed as turns.
             const history = [];
+            const authorId = historyParticipant(connection);
             // 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
@@ -1309,13 +1497,13 @@ function registerSessions(context, frontends, participant, granted, handler, con
                     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));
+                history.push(new turns.ChatRequestTurn('[Earlier conversation history]', undefined, [], authorId, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart('_Showing the latest 120 saved messages. Earlier context remains in the harness session._')], {}, authorId));
             for (const turn of projected) {
                 if (turn.role === 'user') {
-                    history.push(new turns.ChatRequestTurn(turn.prompt ?? '', undefined, [], participant.id, []));
+                    history.push(new turns.ChatRequestTurn(turn.prompt ?? '', undefined, [], authorId, []));
                     continue;
                 }
-                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, participant.id));
+                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, authorId));
             }
             const busy = connection.session.descriptor?.turn_state === 'busy';
             return {

package/dist/host-controls.d.ts

@@ -55,6 +55,7 @@ export declare class ChatHostControls {
     readonly baseUrl: string;
     private readonly credential;
     state: HostState;
+    private updating;
     private constructor();
     static fromEnvironment(env?: NodeJS.ProcessEnv): Promise<ChatHostControls | undefined>;
     refresh(): Promise<void>;
@@ -67,6 +68,9 @@ export declare class ChatHostControls {
         arguments: string[];
         env?: Record<string, string>;
     }>;
+    /** Publish complete host replies in request order; a late refresh must not
+     * overwrite the connection returned by a newer lifecycle operation. */
+    private update;
     private request;
 }
 /** Approval policy is captured for one turn, never inferred from connection privileges. */

package/dist/host-controls.js

@@ -3,6 +3,7 @@ export class ChatHostControls {
     baseUrl;
     credential;
     state;
+    updating = Promise.resolve();
     constructor(baseUrl, credential, state) {
         this.baseUrl = baseUrl;
         this.credential = credential;
@@ -19,21 +20,28 @@ export class ChatHostControls {
         host.state = await host.request('/state');
         return host;
     }
-    async refresh() { this.state = await this.request('/state'); }
+    async refresh() { await this.update('/state'); }
     async select(selection) {
-        const result = await this.request('/select', selection);
-        this.state = result;
-        return result;
+        return this.update('/select', selection);
     }
-    async remember(id, nativeId) { this.state = await this.request('/remember', { id, nativeId }); }
+    async remember(id, nativeId) { await this.update('/remember', { id, nativeId }); }
     async open(id) {
-        const result = await this.request('/open', { id });
-        this.state = result;
-        return result;
+        return this.update('/open', { id });
     }
     async setup(kind, harness) {
         return this.request('/setup', { kind, harness });
     }
+    /** Publish complete host replies in request order; a late refresh must not
+     * overwrite the connection returned by a newer lifecycle operation. */
+    update(path, selection) {
+        const pending = this.updating.then(async () => {
+            const result = await this.request(path, selection);
+            this.state = result;
+            return result;
+        });
+        this.updating = pending.then(() => undefined, () => undefined);
+        return pending;
+    }
     async request(path, selection) {
         const response = await fetch(this.baseUrl + path, {
             method: selection ? 'POST' : 'GET', headers: { Authorization: `Bearer ${this.credential}`, 'Content-Type': 'application/json' },

package/package.json

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