@volter/supercode-frontend-vscode 0.1.58 → 0.1.60

package/dist/extension.js

@@ -108,8 +108,10 @@ class SupercodeFrontends {
         const { baseUrl, token } = options;
         const id = options.connectionId ?? options.clientId ?? `vscode-${randomUUID()}`;
         const existing = this.#connections.get(id);
-        if (existing)
-            return existing;
+        if (existing) {
+            await existing.controlling;
+            return this.#connections.get(id) === existing && existing.session.connection !== 'closed' ? existing : undefined;
+        }
         const permissions = normalizePermissions(options.permissions, ['observe']);
         const client = createFrontendClient({
             baseUrl,
@@ -121,9 +123,9 @@ class SupercodeFrontends {
         // The generated client opens SSE before the snapshot RPC; `attach` is
         // therefore the whole race-free attachment and `follow` only drains it.
         await session.attach();
-        // An interactive attachment holds the runtime's controller lease; without
-        // it the first submit comes back `lease_expired`.
-        await session.takeControlAndHold().catch((error) => {
+        // Taking control must not hold up observation of an attached snapshot.
+        // Actions share this acquisition; connect still awaits it before returning.
+        const controlling = session.takeControlAndHold().catch((error) => {
             log.warn(`Volter Harness could not take control of ${baseUrl}: ${String(error?.message ?? error)}`);
         });
         // The runtime's stream can end under a live attachment: an HTTP client's
@@ -135,14 +137,17 @@ class SupercodeFrontends {
         const stillWanted = () => connection !== undefined && this.#connections.get(id) === connection && session.connection !== 'closed';
         const following = (async () => {
             for (let attempt = 0;; attempt += 1) {
+                let failure;
                 try {
                     await session.follow();
                 }
                 catch (error) {
+                    failure = error;
                     log.warn(`Volter Harness event stream ended: ${String(error?.message ?? error)}`);
                 }
                 if (!stillWanted())
                     return;
+                session.reportFailure(failure ?? new Error('The conversation event stream ended before this attachment closed. Reconnecting to the runtime; its turn may still be running.'));
                 await new Promise((resolve) => setTimeout(resolve, Math.min(15_000, 500 * 2 ** Math.min(attempt, 5))));
                 if (!stillWanted())
                     return;
@@ -162,6 +167,7 @@ class SupercodeFrontends {
             baseUrl,
             session,
             following,
+            controlling,
         };
         session.onChange(() => this.#changed.fire());
         this.#connections.set(id, connection);
@@ -169,6 +175,9 @@ class SupercodeFrontends {
         this.setUnavailable(undefined);
         log.info(`Volter Harness attached: ${connection.label} (${baseUrl}) as ${permissions.join(',')}` +
             ` · ${session.history.length} history messages`);
+        await controlling;
+        if (this.#connections.get(id) !== connection || session.connection === 'closed')
+            return undefined;
         return connection;
     }
     async disconnect(id) {
@@ -383,13 +392,26 @@ export async function activate(context) {
         // protocol (an ACP agent) keeps asking until a host names it.
         return ['claude-code', 'codex'].includes(harness) && (!connection || canAnswer(connection)) ? 'autoApprove' : 'ask';
     };
-    // What governs a conversation's approvals: the person's choice, else the host's default.
-    const approvalFor = (id) => permissions.get(id) ?? defaultFor(id);
+    // Runtime YOLO is the host's recorded launch policy, never an approval-picker choice.
+    const yoloFor = (id) => {
+        const session = controls?.state.sessions.find(entry => entry.id === id);
+        return !attachedIds.has(id) && session?.runtimePolicy === 'yolo'
+            && ['claude-code', 'codex'].includes(session.selection.harness);
+    };
+    // A saved Ask choice cannot turn prompts back on in a runtime already launched with bypass flags.
+    const approvalFor = (id) => {
+        if (!yoloFor(id))
+            return permissions.get(id) ?? defaultFor(id);
+        const connection = frontends.get(id);
+        return !connection || canAnswer(connection) ? 'autoApprove' : 'ask';
+    };
     // A picker value becomes the person's choice only when it is one: it differs from the default the picker showed
     // (`shown`; null when the person already picked it), or replaces an earlier choice. Echoes of the displayed default
     // (the picker re-applied when a conversation opens) are not saved, and neither is an Auto approve the conversation
     // cannot answer: the picker offers it only where it can, so there it is a default shown before the harness was known.
     const choosePermission = (id, value, shown = defaultFor(id)) => {
+        if (yoloFor(id))
+            return;
         const connection = frontends.get(id);
         if (value === 'autoApprove' && connection && !canAnswer(connection))
             return;
@@ -405,6 +427,11 @@ export async function activate(context) {
     let focusedResource;
     let focusGeneration = 0;
     const activeDraft = () => pendingDraft?.resource && pendingDraft.resource.toString() === focusedResource?.toString() ? pendingDraft : undefined;
+    const draftChoiceRefusal = () => {
+        const draft = activeDraft();
+        return draft && (draft.choosing || !draft.choice || draft.choice.kind === 'cancelled')
+            ? 'Choose your coding agent before sending. Your draft is saved; send it after choosing.' : undefined;
+    };
     const draftSelection = () => {
         const choice = activeDraft()?.choice;
         return choice?.kind === 'agent' ? choice.selection : undefined;
@@ -624,9 +651,11 @@ export async function activate(context) {
             provideTokenCount: async () => 0,
         }));
     }
+    const newChatYolo = () => controls?.state.newChatRuntimePolicy === 'yolo'
+        && ['claude-code', 'codex'].includes(draftSelection()?.harness ?? controls.state.selection.harness);
     const currentOptions = (resource) => {
         const id = resource ? boundId(resource) : activeDraft() ? undefined : controls?.state.activeSession;
-        return { permissions: id ? approvalFor(id) : permission ?? newChatDefault() };
+        return { permissions: id ? yoloFor(id) ? 'yolo' : approvalFor(id) : newChatYolo() ? 'yolo' : permission ?? newChatDefault() };
     };
     const savedConnections = new Map();
     const saveManagedHistory = async (connection) => {
@@ -658,6 +687,12 @@ export async function activate(context) {
         return connection;
     };
     let setupHandoff;
+    let canceledSetupReveal;
+    const revealCanceledFor = (basis, connection) => Boolean(canceledSetupReveal
+        && canceledSetupReveal.id === basis.id && canceledSetupReveal.baseUrl === basis.baseUrl
+        && canceledSetupReveal.generation === basis.generation && canceledSetupReveal.focusResource === basis.focusResource
+        && canceledSetupReveal.live === basis.live && canceledSetupReveal.connection.deref() === connection
+        && connection.session.connection === 'connected');
     const setupHandoffComplete = () => {
         const id = controls?.state.activeSession;
         const connection = id ? frontends.get(id) : undefined;
@@ -725,6 +760,7 @@ export async function activate(context) {
             }
             else {
                 setupHandoff = undefined;
+                canceledSetupReveal = undefined;
                 controlsChanged.fire();
                 return { kind: 'setup', generation };
             }
@@ -745,8 +781,27 @@ export async function activate(context) {
                 if ((controls.state.setup && !controls.state.setup.ready) || controls.state.activeSession !== target.id
                     || controls.state.connection?.SUPERCODE_FRONTEND_URL !== target.baseUrl)
                     return;
-                if (!setupHandoffComplete())
-                    await revealManaged(target, { resource: target.focusResource });
+                if (!setupHandoffComplete()) {
+                    const connection = frontends.get(target.id);
+                    const basis = { ...target, live };
+                    if (!connection || revealCanceledFor(basis, connection))
+                        return;
+                    try {
+                        await revealManaged(target, { resource: target.focusResource });
+                        canceledSetupReveal = undefined;
+                    }
+                    catch (error) {
+                        // The native focus guard canceled this navigation. Repeating the same request cannot earn new focus;
+                        // attachment remains real and the reveal remains incomplete. A changed basis or explicit refresh retries.
+                        if (!(error instanceof vscode.CancellationError)
+                            && !(error instanceof Error && error.name === 'Canceled' && error.message === 'Canceled'))
+                            throw error;
+                        canceledSetupReveal = { ...basis, connection: new WeakRef(connection) };
+                        log.debug('Automatic Chat reveal canceled for the current conversation and focus.');
+                        controlsChanged.fire();
+                        return;
+                    }
+                }
                 if (setupHandoffComplete())
                     welcomeWasVisible = false;
             }
@@ -795,6 +850,41 @@ export async function activate(context) {
                 throw new vscode.CancellationError();
             if (action.command !== offered.command)
                 throw new Error('The sign-in command changed. Try again.');
+            if (kind === 'install') {
+                // A task observes native process exit without closing the terminal that
+                // holds its diagnostics. Each click gets its own panel and identity;
+                // cancellation terminates only the execution returned for this task.
+                const operation = randomUUID();
+                const task = new vscode.Task({ type: 'supercode-setup', operation }, vscode.workspace.getWorkspaceFolder(vscode.Uri.file(action.cwd)) ?? vscode.TaskScope.Workspace, `${action.name} · install`, 'supercode', new vscode.ProcessExecution(action.program, action.arguments, { cwd: action.cwd, env: action.env }));
+                task.presentationOptions = { reveal: vscode.TaskRevealKind.Always, panel: vscode.TaskPanelKind.New, clear: false, close: false };
+                const listeners = [];
+                let finished = false;
+                let resolveExit;
+                const exited = new Promise(resolve => { resolveExit = resolve; });
+                const finish = (code) => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    for (const listener of listeners)
+                        listener.dispose();
+                    resolveExit(code);
+                };
+                const owns = (execution) => execution.task.definition.type === 'supercode-setup'
+                    && execution.task.definition.operation === operation;
+                listeners.push(vscode.tasks.onDidEndTaskProcess(event => { if (owns(event.execution))
+                    finish(event.exitCode); }), vscode.tasks.onDidEndTask(event => { if (owns(event.execution))
+                    finish(undefined); }));
+                let execution;
+                try {
+                    execution = await vscode.tasks.executeTask(task);
+                }
+                catch (error) {
+                    finish(undefined);
+                    throw error;
+                }
+                return { exited, cancel: () => { if (!finished)
+                        execution.terminate(); } };
+            }
             const terminal = vscode.window.createTerminal({ name: `${action.name} · ${kind === 'login' ? 'sign in' : 'install'}`,
                 cwd: action.cwd, shellPath: action.program, shellArgs: action.arguments, env: action.env });
             const exited = new Promise(resolve => {
@@ -810,7 +900,10 @@ export async function activate(context) {
         },
     }) : undefined;
     const setupState = () => controls ? setupPresentation(controls.state, setupFlow?.operations ?? new Map(), setupFlow?.notice) : null;
-    context.subscriptions.push({ dispose: () => setupFlow?.dispose() }, vscode.commands.registerCommand('supercode.frontend.refreshSetup', refreshSetup), vscode.commands.registerCommand(SETUP_STATE, setupState), vscode.commands.registerCommand(SETUP_BEGIN, (harness) => {
+    context.subscriptions.push({ dispose: () => setupFlow?.dispose() }, vscode.commands.registerCommand('supercode.frontend.refreshSetup', () => {
+        canceledSetupReveal = undefined;
+        return refreshSetup();
+    }), vscode.commands.registerCommand(SETUP_STATE, setupState), vscode.commands.registerCommand(SETUP_BEGIN, (harness) => {
         if (!setupFlow)
             throw new Error('This host does not expose sign-in.');
         return setupFlow.begin(harness);
@@ -1014,7 +1107,7 @@ export async function activate(context) {
             if (draft && 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);
+                void refreshSetup().catch(error => log.warn(`Could not refresh Chat setup: ${String(error)}`)).finally(pollSetup);
             }
         }
     };
@@ -1028,12 +1121,16 @@ export async function activate(context) {
         if (busy)
             throw new Error(busy);
         const draft = activeDraft();
-        // the picker ends in a cancellation for a sign-in choice too: the draft's choice says which (sign-in is refused
-        // below, in the chat); a draft that went away is the real cancellation
-        await draft?.choosing?.catch(() => undefined);
-        if (draft && activeDraft() !== draft)
+        // Refuse before native materialization accepts the input. A pending picker
+        // must not hold an invisible send that starts when the choice later ends.
+        const choiceRefusal = draftChoiceRefusal();
+        if (choiceRefusal) {
+            void vscode.window.showInformationMessage(choiceRefusal);
             throw new vscode.CancellationError();
+        }
         await controls.refresh();
+        if (draft && activeDraft() !== draft)
+            throw new vscode.CancellationError();
         controlsChanged.fire();
         const choice = draft?.choice;
         const loginHarness = choice?.kind === 'signIn' ? choice.harness : undefined;
@@ -1051,7 +1148,8 @@ export async function activate(context) {
         // The picker shows the host's default until someone changes it; only a change is the person's choice.
         const selected = inputState.groups.find(group => group.id === 'permissions')?.selected?.id;
         const picked = selected === 'ask' || selected === 'autoApprove' ? selected : permission ?? newChatDefault();
-        choosePermission(connection.id, picked, permission !== undefined ? null : newChatDefault());
+        if (!yoloFor(connection.id))
+            choosePermission(connection.id, picked, permission !== undefined ? null : newChatDefault());
         permission = undefined;
         if (pendingDraft === draft) {
             pendingDraft = undefined;
@@ -1074,8 +1172,11 @@ export async function activate(context) {
                     // the default harness decides; only with none known does the new-chat default stand in for it
                     : controls?.state.selection.harness ? ['claude-code', 'codex'].includes(controls.state.selection.harness) : newChatDefault() === 'autoApprove');
             // An unbound input is a new chat, not the active conversation left behind it.
-            const selectedPermission = resource ? currentOptions(resource).permissions : permission ?? newChatDefault();
-            const permissionItems = [{ id: 'ask', name: canApprove ? 'Ask for approval' : 'Harness permissions', description: canApprove ? 'Show each approval requested by the harness.' : 'Approval controls are unavailable for this harness.' },
+            const isYolo = id ? yoloFor(id) : newChatYolo();
+            const selectedPermission = isYolo ? 'yolo' : resource ? currentOptions(resource).permissions : permission ?? newChatDefault();
+            const permissionItems = isYolo ? [{ id: 'yolo', name: 'YOLO', description: id
+                        ? 'This runtime runs without approval prompts. Change the project Chat runtime policy for its next start or resume.'
+                        : 'Project policy: start native Claude Code or Codex without approval prompts or the Codex sandbox.' }] : [{ id: 'ask', name: canApprove ? 'Ask for approval' : 'Harness permissions', description: canApprove ? 'Show each approval requested by the harness.' : 'Approval controls are unavailable for this harness.' },
                 ...((canApprove || (!active && resource && currentOptions(resource).permissions === 'autoApprove')) ? [{ id: 'autoApprove', name: 'Auto approve', description: 'Approve the requests the harness would ask you about, including requests to run outside its sandbox. Its deny rules still apply.' }] : [])];
             const groups = [{ id: 'permissions', name: 'Permissions', kind: 'permissions', items: permissionItems, selected: permissionItems.find(i => i.id === selectedPermission) ?? permissionItems[0] }];
             const selected = controls?.state.sessions.find(session => session.id === id);
@@ -1094,24 +1195,34 @@ export async function activate(context) {
         },
         setPermission: (resource, value) => {
             const id = boundId(resource);
+            if (value === 'yolo' && !id && newChatYolo())
+                return;
             if (controls && !id)
                 throw new Error('This conversation has no session binding.');
+            if (id && yoloFor(id))
+                return;
             if (id)
                 choosePermission(id, turnPermission(value));
             else
                 permission = turnPermission(value);
         },
-        // A send that makes no conversation (another turn runs, or the host or a sign-in refuses it) answers no item: the
-        // host then runs the request on the draft itself, and its handler says why in the chat. A rejection here reaches
-        // nobody (the host's acceptInput drops it), so every refusal goes that way (#1282 review).
+        // A send that makes no conversation keeps its refusal for the draft handler.
+        // Materialization can stop before that callback, so creation also shows the
+        // failure directly instead of relying on a rejected native callback (#1282).
         create: async (inputState) => {
+            const refusedKey = activeDraft()?.resource.toString() ?? inputState.sessionResource?.toString() ?? '';
             try {
                 return await createConversation(inputState);
             }
             catch (error) {
                 if (error instanceof vscode.CancellationError)
                     throw error;
-                refusedSends.set(activeDraft()?.resource.toString() ?? '', String(error?.message ?? error));
+                const reason = String(error?.message ?? error);
+                refusedSends.set(refusedKey, reason);
+                // Materialization can end before the native workbench calls a request
+                // handler. Surface the original launch error on this path as well.
+                log.error(`Chat creation failed: ${reason}`);
+                void vscode.window.showErrorMessage(`Chat could not start: ${reason}. No message was sent.`);
                 return undefined;
             }
         },
@@ -1125,6 +1236,10 @@ export async function activate(context) {
         finishIdentitySave: (connection) => finishIdentitySave(connection, true),
     };
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.activateSession', async (resource) => { await connectionFor(vscode.Uri.parse(resource)); }));
+    // A paired native host can explain Enter when its model/options precondition
+    // prevents the submit command from reaching session materialization at all.
+    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.sendRefusal', () => draftChoiceRefusal()
+        ?? (controls?.state.setup?.ready === false ? 'Finish setting up your coding agent before sending. Your draft is saved.' : undefined)));
     // A background task the chat named (sayTasks in runTurnInto), stopped through the harness's own control.
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.stopBackgroundTask', async (connectionId, taskId) => {
         const connection = frontends.get(connectionId);
@@ -1165,10 +1280,12 @@ export async function activate(context) {
         // with a new chat's draft open, a permission chosen is the draft's, never the conversation behind it
         if (supplied?.permissions) {
             const id = activeDraft() ? undefined : controls?.state.activeSession;
-            if (id)
-                choosePermission(id, turnPermission(supplied.permissions));
-            else
-                permission = turnPermission(supplied.permissions);
+            if (!(id ? yoloFor(id) : supplied.permissions === 'yolo' && newChatYolo())) {
+                if (id)
+                    choosePermission(id, turnPermission(supplied.permissions));
+                else
+                    permission = turnPermission(supplied.permissions);
+            }
             controlsChanged.fire();
             return currentOptions();
         }
@@ -1192,9 +1309,11 @@ export async function activate(context) {
             ?? controls.state.selection.harness;
         const agents = setupAgents(controls.state);
         const localChoices = agents.map(agent => ({ label: agent.name, id: agent.harness,
-            description: agent.harness === 'codex' ? (agent.signedIn ? 'Signed in with ChatGPT' : 'Sign in with ChatGPT…')
-                : agent.harness === 'claude-code' ? (agent.signedIn ? 'Signed in with Claude' : 'Sign in with Claude…')
-                    : controls.state.harnesses.find(h => h.id === agent.harness)?.description,
+            // An agent the host's account signs in (its launch carries that account's route) names that account.
+            description: agent.signedIn && agent.account ? `Signed in with ${agent.account}`
+                : agent.harness === 'codex' ? (agent.signedIn ? 'Signed in with ChatGPT' : 'Sign in with ChatGPT…')
+                    : agent.harness === 'claude-code' ? (agent.signedIn ? 'Signed in with Claude' : 'Sign in with Claude…')
+                        : controls.state.harnesses.find(h => h.id === agent.harness)?.description,
             login: controls.state.setup?.actions.some(a => a.harness === agent.harness) ?? false,
             autoStart: controls.state.harnesses.some(h => h.id === agent.harness && h.autoStart), configure: false }));
         const modelChoices = localChoices.filter(choice => !choice.login && CONFIGURABLE_HARNESSES.includes(choice.id))
@@ -1444,6 +1563,7 @@ export async function activate(context) {
         sayTasks();
         const unwatchTasks = connection.session.onChange(sayTasks);
         let completed = false;
+        let turnStarted = false;
         try {
             // A new harness transcript is created by input, so binding its identity
             // cannot be a prerequisite for that input. Retry the host save as native
@@ -1453,7 +1573,11 @@ export async function activate(context) {
                 // A turn the person stopped is marked stopped by VS Code itself; only an interruption from elsewhere is said.
                 if (event.kind === 'turn_interrupted' && token.isCancellationRequested)
                     return;
-                writeProjected(stream, projectEvent(event, projection), granted, state);
+                // Native submit publishes its initial user echo before `turn_started`.
+                // Subsequent input belongs in the response while this turn is visible.
+                if (event.kind === 'turn_started')
+                    turnStarted = true;
+                writeProjected(stream, projectEvent(event, { ...projection, liveUserMessages: turnStarted }), granted, state);
                 watch.sweep();
                 rememberIdentity(connection);
             }, { throwIfCancelled, onSubmitted: () => {
@@ -1726,15 +1850,26 @@ export async function activate(context) {
     vscode.commands.registerCommand('supercode.frontend.respond', async (answer) => { await answerRequest(answer); }), vscode.commands.registerCommand('supercode.frontend.respondInTurnApproval', (answer) => answerRequest(answer)), vscode.commands.registerCommand('supercode.frontend.status', async (inspect) => {
         if (controls)
             await controls.refresh();
+        const draft = activeDraft();
+        const focusedId = focusedResource ? boundId(focusedResource) : undefined;
+        const focusedSession = controls?.state.sessions.find(session => session.id === focusedId);
+        const selectionSource = draft ? 'draft' : focusedAttached ? 'attachment' : focusedSession ? 'conversation'
+            : focusedResource ? 'unavailable' : 'host';
+        const selection = draft ? draftSelection() : focusedAttached ? undefined : focusedSession?.selection
+            ?? (focusedResource ? undefined : controls?.state.selection);
         if (inspect === true)
             return {
                 setupState: setupState(),
                 connections: frontends.all.map(c => ({ ...frontends.info(c), permissions: [...c.session.permissions],
                     pendingRequests: [...c.session.pendingRequests.values()] })),
-                selection: controls?.state.selection, activeSession: controls?.state.activeSession,
+                selection, selectionSource, focusedSession: focusedId ?? null,
+                hostSelection: controls?.state.selection, activeSession: controls?.state.activeSession,
+                focusedSessionResource: focusedResource?.toString() ?? null, focusGeneration,
                 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(),
-                    revealed: setupHandoff ?? null },
+                    revealed: setupHandoff ?? null,
+                    lastCanceledReveal: canceledSetupReveal ? { id: canceledSetupReveal.id, baseUrl: canceledSetupReveal.baseUrl,
+                        generation: canceledSetupReveal.generation, focusResource: canceledSetupReveal.focusResource, live: canceledSetupReveal.live } : null },
                 sessions: controls?.state.sessions, permission: currentOptions().permissions, identity: identity(),
             };
         const rows = frontends.all.map((connection) => {
@@ -1886,25 +2021,40 @@ export async function activate(context) {
     // panel on "Loading…" — observed.
     const opening = setTimeout(() => void openResumedSession().catch(error => log.warn(`Could not reveal Chat: ${String(error)}`)), 500);
     context.subscriptions.push({ dispose: () => clearTimeout(opening) });
-    // Retry until host readiness has completed both attachment AND native reveal.
-    // A transient failure in either step leaves the handoff pending, even if ready=true.
+    // Retry attachment and reveal failures. A native navigation cancellation waits for changed focus/target/liveness
+    // or an explicit refresh; it neither earns a completed handoff nor repeats the same veto every three seconds.
     let setupTimer;
     let setupDisposed = false;
     const pollSetup = () => {
+        if (!controls || setupDisposed) {
+            clearTimeout(setupTimer);
+            setupTimer = undefined;
+            return;
+        }
         const choice = activeDraft()?.choice;
         const awaitingLogin = (choice?.kind === 'signIn' && choice.harness && !setupAgents(controls.state).some(h => h.harness === choice.harness && h.signedIn))
             || [...(setupFlow?.operations.values() ?? [])].some(operation => operation.phase === 'installing' || operation.phase === 'signing-in');
         if ([...(setupFlow?.operations.values() ?? [])].some(operation => operation.phase === 'installing' || operation.phase === 'signing-in'))
             return;
-        if (setupTimer || setupDisposed || !controls?.state.setup || (controls.state.setup.ready && setupHandoffComplete() && !awaitingLogin))
+        const connection = controls.state.activeSession ? frontends.get(controls.state.activeSession) : undefined;
+        const canceled = connection && revealCanceledFor({ id: connection.id,
+            baseUrl: controls.state.connection?.SUPERCODE_FRONTEND_URL ?? '', generation: focusGeneration,
+            focusResource: focusedResource?.toString() ?? null,
+            live: Boolean(connection.session.pendingRequests.size || connection.session.descriptor?.turn_state === 'busy') }, connection);
+        if (controls.state.setup?.ready && !awaitingLogin && (setupHandoffComplete() || canceled)) {
+            clearTimeout(setupTimer);
+            setupTimer = undefined;
+            return;
+        }
+        if (setupTimer || !controls.state.setup)
             return;
         setupTimer = setTimeout(() => {
             setupTimer = undefined;
-            void refreshSetup().catch(error => log.warn(`Could not refresh sign-in: ${String(error)}`)).finally(pollSetup);
+            void refreshSetup().catch(error => log.warn(`Could not refresh Chat setup: ${String(error)}`)).finally(pollSetup);
         }, 3000);
     };
     pollSetup();
-    context.subscriptions.push(controlsChanged.event(pollSetup));
+    context.subscriptions.push(controlsChanged.event(pollSetup), frontends.onDidChange(pollSetup));
     context.subscriptions.push({ dispose: () => { setupDisposed = true; clearTimeout(setupTimer); } });
     return {
         connect: async (options) => {
@@ -1943,7 +2093,7 @@ function oneRowPerToolCall(parts) {
                 rows[at] = {
                     ...first,
                     ...part,
-                    pastTenseMessage: first.invocationMessage ?? part.pastTenseMessage,
+                    pastTenseMessage: first.pastTenseMessage || part.pastTenseMessage,
                     invocationMessage: first.invocationMessage ?? part.invocationMessage,
                 };
                 continue;
@@ -2024,11 +2174,12 @@ function historyText(part) {
 }
 function registerSessions(context, frontends, participant, granted, handler, historyParticipant, controls) {
     const turns = vscode;
+    const failedResources = new Map();
     const items = () => {
         return (controls?.catalogue() ?? []).filter(entry => !frontends.get(entry.id)).map(entry => {
             return { resource: vscode.Uri.from({ scheme: SESSION_SCHEME, authority: entry.id, path: '/conversation' }), label: entry.title,
                 description: runtimeIdentity(entry.selection.harness, entry.selection.model, controls?.effective(entry)).name,
-                status: vscode.ChatSessionStatus.Completed, timing: { created: entry.created } };
+                status: failedResources.has(entry.id) ? vscode.ChatSessionStatus.Failed : vscode.ChatSessionStatus.Completed, timing: { created: entry.created } };
         });
     };
     const connectedRow = (connection) => ({
@@ -2127,13 +2278,38 @@ function registerSessions(context, frontends, participant, granted, handler, his
             if (token.isCancellationRequested)
                 throw new vscode.CancellationError();
             const boundHandler = (request, chatContext, stream, token) => handler(request, { ...chatContext, chatSessionContext: { chatSessionItem: { resource, label: 'Conversation' } } }, stream, token);
+            const failedContent = (error) => {
+                const message = opaqueText(String(error?.message ?? error), 2048);
+                if (failedResources.get(resource.authority) !== message) {
+                    failedResources.set(resource.authority, message);
+                    refreshItems();
+                }
+                return {
+                    history: [
+                        new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], 'supercode', []),
+                        new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(`**Conversation recovery failed**\n\n${message}`)], {}, 'supercode'),
+                    ],
+                    requestHandler: boundHandler,
+                };
+            };
             // Only a native untitled resource can create a conversation. Existing
             // resources must resolve their exact saved binding; there is no fallback.
-            const connection = controls ? (resource.path.startsWith('/untitled-') && !controls.bindings(resource) ? undefined : await controls.resolve(resource, token)) : frontends.get(resource.authority);
+            let connection;
+            try {
+                connection = controls ? (resource.path.startsWith('/untitled-') && !controls.bindings(resource) ? undefined : await controls.resolve(resource, token)) : frontends.get(resource.authority);
+            }
+            catch (error) {
+                if (token.isCancellationRequested || error instanceof vscode.CancellationError)
+                    throw error;
+                return failedContent(error);
+            }
+            failedResources.delete(resource.authority);
             if (token.isCancellationRequested)
                 throw new vscode.CancellationError();
             if (!connection) {
-                return { history: [], requestHandler: boundHandler };
+                const draft = resource.path.startsWith('/untitled-') && !controls?.bindings(resource);
+                return draft ? { history: [], requestHandler: boundHandler }
+                    : failedContent(frontends.unavailable ?? 'Could not attach to this saved conversation\'s runtime.');
             }
             connection.viewReady = false;
             connection.viewResource = resource.toString();
@@ -2146,7 +2322,8 @@ function registerSessions(context, frontends, participant, granted, handler, his
             // `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 = frontends.get(connection.id) === connection && await connection.session.attach().then(() => true).catch(() => {
+            const attached = frontends.get(connection.id) === connection && await connection.session.attach().then(() => true).catch(error => {
+                connection.session.reportFailure(error);
                 // An unreachable runtime replays what this window last saw.
                 return false;
             });
@@ -2160,7 +2337,10 @@ function registerSessions(context, frontends, participant, granted, handler, his
             // created. Keep it only as a fallback when no runtime user history is
             // available, rather than trying to align equal-looking prompt text.
             const runtimeHistory = connection.session.history;
-            const replay = connection.session.replay.filter(event => event.sequence > connection.session.historyCursor);
+            const replay = [
+                ...connection.session.historyEvents,
+                ...connection.session.replay.filter(event => event.sequence > connection.session.historyCursor),
+            ];
             const hasRuntimeHistory = runtimeHistory.length > 0 || replay.some(event => event.kind === 'user_message');
             const usingSavedHistory = !hasRuntimeHistory && Boolean(connection.persistedHistory?.length);
             const canonicalHistory = usingSavedHistory ? connection.persistedHistory : runtimeHistory;
@@ -2217,6 +2397,8 @@ function registerSessions(context, frontends, participant, granted, handler, his
             }
             if (usingSavedHistory && connection.historyTruncated)
                 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));
+            if (connection.session.historyEventsDropped > 0)
+                history.push(new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], authorId, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(`_${connection.session.historyEventsDropped} earlier runtime events are outside this display snapshot._`)], {}, authorId));
             for (const turn of projected) {
                 if (turn.role === 'user') {
                     history.push(new turns.ChatRequestTurn(turn.prompt ?? '', undefined, [], authorId, []));
@@ -2224,6 +2406,11 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 }
                 history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, authorId));
             }
+            if (connection.session.failure) {
+                // An explicit runtime marker pairs this notice without presenting
+                // it as a person's prompt. The native busy state stays unchanged.
+                history.push(new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], authorId, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(`**Conversation recovery failed**\n\n${opaqueText(connection.session.failure.message, 2048)}`)], {}, authorId));
+            }
             const renderedCursor = connection.session.cursor;
             const pendingAtCursor = [...connection.session.pendingRequests.values()];
             if (!live)
@@ -2252,6 +2439,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
                             await observeActiveResponse(connection.session, token, (event) => {
                                 writeProjected(stream, projectEvent(event, {
                                     connectionId: connection.id,
+                                    liveUserMessages: true,
                                     pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
                                     canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
                                 }), granted, state);
@@ -2259,6 +2447,11 @@ function registerSessions(context, frontends, participant, granted, handler, his
                                 controls?.rememberIdentity(connection);
                             }, () => { connection.viewReady = true; }, renderedCursor);
                         }
+                        catch (error) {
+                            if (token.isCancellationRequested || error instanceof vscode.CancellationError)
+                                throw error;
+                            stream.markdown(`\n\n**Conversation stream failed**\n\n${opaqueText(String(error?.message ?? error), 2048)}\n\n`);
+                        }
                         finally {
                             connection.viewReady = connection.session.descriptor?.turn_state !== 'busy' && !connection.session.pendingRequests.size;
                             watch?.dispose();

package/dist/host-controls.d.ts

@@ -27,6 +27,7 @@ export interface ManagedChatSession {
     title: string;
     created: number;
     defaultPermission?: 'ask' | 'autoApprove';
+    runtimePolicy?: 'default' | 'yolo';
 }
 /** Host-owned operations. The host revalidates commands before native terminal execution. */
 export interface ChatSetupAction {
@@ -75,6 +76,9 @@ export interface HostState {
     /** The mode a new chat's picker shows. A conversation's own default is its `ManagedChatSession.defaultPermission`;
      *  this is never applied to one that exists. `autoApprove` takes effect only where the runtime can answer approvals. */
     newChatPermission?: 'ask' | 'autoApprove';
+    /** Project policy for the next start/resume; an existing runtime uses its recorded session policy. */
+    newChatRuntimePolicy?: 'default' | 'yolo' | null;
+    runtimePolicyError?: string | null;
 }
 export interface HostSelectionResult extends HostState {
     connection: Record<string, string>;

package/dist/host-controls.js

@@ -70,9 +70,12 @@ export function runtimeIdentity(harness, model, effective) {
     const harnessName = harnessDisplayName(harness);
     const knownModel = effective?.model || (model && model !== harness ? model : '');
     const modelName = effective?.modelName || { sonnet: 'Claude Sonnet', opus: 'Claude Opus', haiku: 'Claude Haiku' }[knownModel] || knownModel;
+    // The provider of a display name ("Claude Opus 4.8"), whose mark is media/<provider>.svg (supercode-ui's catalogue);
+    // the catalogue's modelProvider reads model ids.
     const provider = /claude|sonnet|opus|haiku/i.test(modelName) || (!modelName && harness === 'claude-code') ? 'anthropic'
         : /^(gpt|o[134]|chatgpt)|\/gpt/i.test(modelName) || (!modelName && harness === 'codex') ? 'openai'
-            : /gemini/i.test(modelName) || (!modelName && harness === 'gemini') ? 'google' : undefined;
+            : /gemini/i.test(modelName) || (!modelName && harness === 'gemini') ? 'google'
+                : /grok/i.test(modelName) || (!modelName && harness === 'grok') ? 'xai' : undefined;
     const effort = effective?.effort ? ` · ${effective.effort}` : '';
     return { name: modelName ? `${modelName}${effort}` : `Model chosen by ${harnessName}`, provider };
 }

package/dist/native-session.d.ts

@@ -1,6 +1,6 @@
 import type { CancellationToken } from 'vscode';
 import type { FrontendEvent } from '../vendor/supercode-frontend/generated.mjs';
 import { type VscodeFrontendSession } from './session.js';
-export declare function sessionStatus(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests'>): 'NeedsInput' | 'InProgress' | 'Completed';
+export declare function sessionStatus(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests' | 'failure'>): 'NeedsInput' | 'Failed' | 'InProgress' | 'Completed';
 /** Follow a restored turn, including the interval between snapshot and callback. */
-export declare function observeActiveResponse(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests' | 'onEvent' | 'interrupt' | 'actions' | 'replay'>, token: CancellationToken, write: (event: FrontendEvent) => void, onSubscribed?: () => void, afterSequence?: number): Promise<void>;
+export declare function observeActiveResponse(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests' | 'onEvent' | 'onChange' | 'onFailure' | 'interrupt' | 'actions' | 'replay'>, token: CancellationToken, write: (event: FrontendEvent) => void, onSubscribed?: () => void, afterSequence?: number): Promise<void>;