@volter/supercode-frontend-vscode 0.1.48 → 0.1.50

package/dist/extension.js

@@ -267,17 +267,30 @@ function writePart(stream, part, state) {
             const toolName = part.toolName || state.toolNames.get(part.toolCallId) || 'tool';
             if (part.toolName)
                 state.toolNames.set(part.toolCallId, part.toolName);
+            // The titles a call started with stay its titles: a completion (which may not name its tool) never renames it.
+            const started = state.toolTitles.get(part.toolCallId);
+            const titles = started ?? { invocation: part.invocationMessage || `Running \`${toolName}\``, pastTense: part.pastTenseMessage || part.invocationMessage || `Ran \`${toolName}\`` };
+            if (!started)
+                state.toolTitles.set(part.toolCallId, titles);
+            if (part.commandLine)
+                state.toolCommands.set(part.toolCallId, part.commandLine);
+            const commandLine = state.toolCommands.get(part.toolCallId);
             const invocation = new vscode.ChatToolInvocationPart(toolName, part.toolCallId);
             invocation.enablePartialUpdate = true;
-            invocation.invocationMessage = part.invocationMessage || toolName;
+            invocation.invocationMessage = new vscode.MarkdownString(titles.invocation);
             invocation.isConfirmed = true;
             invocation.isComplete = part.isComplete;
-            invocation.pastTenseMessage = part.pastTenseMessage || toolName;
+            invocation.pastTenseMessage = new vscode.MarkdownString(titles.pastTense);
             if (part.isError !== undefined)
                 invocation.isError = part.isError;
             if (part.inputText !== undefined)
                 state.toolInputs.set(part.toolCallId, part.inputText);
-            if (part.isComplete) {
+            if (commandLine) {
+                // VS Code's own terminal block: the command, and its output once it has run.
+                invocation.toolSpecificData = { commandLine: { original: commandLine }, language: 'sh',
+                    ...(part.isComplete ? { output: { text: part.resultText ?? '' } } : {}) };
+            }
+            else if (part.isComplete) {
                 invocation.toolSpecificData = {
                     input: state.toolInputs.get(part.toolCallId) ?? '',
                     output: part.resultText ?? '',
@@ -494,14 +507,22 @@ export async function activate(context) {
             controlsChanged.fire();
         }
     }));
+    // What a new chat of `selection` runs with: its own picks over what the harness's configuration names (host state).
+    const draftEffective = (selection) => {
+        const configured = controls?.state.effectiveByHarness?.[selection.harness];
+        if (!configured)
+            return null;
+        const picked = selection.model ? controls?.state.modelsByHarness?.[selection.harness]?.find(model => model.id === selection.model) : undefined;
+        return { model: selection.model || configured.model, modelName: selection.model ? picked?.name ?? selection.model : configured.modelName, effort: selection.effort || configured.effort };
+    };
     const identity = () => {
         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);
+            return runtimeIdentity(selection.harness, selection.model, draftEffective(selection));
+        return runtimeIdentity(controls?.state.selection.harness ?? descriptor?.source_harness, controls?.state.selection.model || controls?.state.actualModel || descriptor?.model, controls?.state.effective);
     };
     const icon = () => {
         const provider = identity().provider;
@@ -524,16 +545,18 @@ export async function activate(context) {
                 if (!choices.some(model => model.id === selection.model))
                     choices.push({ id: selection.model, name: selection.model });
                 modelSelections.clear();
+                // Named by what the conversation actually runs with, never "default model" (host `effective`).
+                const effective = draft ? draftEffective(selection) : controls.state.effective;
                 return choices.map(model => {
                     const id = `${selection.harness}/${encodeURIComponent(model.id || '__default__')}`;
                     modelSelections.set(id, { ...selection, model: model.id });
-                    const provider = runtimeIdentity(selection.harness, selection.model).provider;
-                    const name = model.id ? model.name : runtimeIdentity(selection.harness, model.id).name;
+                    const provider = runtimeIdentity(selection.harness, selection.model, effective).provider;
+                    const name = runtimeIdentity(selection.harness, model.id, effective).name;
                     return { id, name, family: selection.harness, version: '1',
                         statusIcon: new vscode.ThemeIcon(provider === 'anthropic' ? 'claude' : provider === 'openai' ? 'openai' : provider === 'google' ? 'google-gemini' : 'sparkle'),
                         maxInputTokens: 0, maxOutputTokens: 0, capabilities: {},
                         targetChatSessionType: SESSION_SCHEME, isUserSelectable: true, isDefault: model.id === selection.model,
-                        tooltip: `${name} via ${harnessDisplayName(selection.harness)}${selection.effort ? ` · ${selection.effort} reasoning` : ''}. Model is fixed for this conversation. Use Model settings to choose model and reasoning for a new conversation.`,
+                        tooltip: `${name}. Model is fixed for this conversation. Use Model settings to choose model and reasoning for a new conversation.`,
                     };
                 });
             },
@@ -571,7 +594,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: runtimeIdentity(state.selection.harness, state.selection.model || state.actualModel).name }, log);
+            permissions: normalizePermissions(env.SUPERCODE_FRONTEND_PERMISSIONS, ['observe']), label: runtimeIdentity(state.selection.harness, state.selection.model || state.actualModel, state.effective).name }, log);
         if (!connection)
             throw new Error('Could not connect to the requested conversation.');
         return connection;
@@ -842,7 +865,10 @@ export async function activate(context) {
     const pickModelAndEffort = async (harness, current) => {
         const choices = controls?.state.modelsByHarness?.[harness] ?? [{ id: '', name: 'Harness default' }];
         const name = harnessDisplayName(harness);
-        const items = [...choices.map(model => ({ label: model.name, description: [model.id, model.description].filter(Boolean).join(' · ') || undefined, id: model.id, efforts: model.efforts })),
+        // The harness's own choice is named by what it resolves to (host `effectiveByHarness`).
+        const configured = controls?.state.effectiveByHarness?.[harness];
+        const items = [...choices.map(model => ({ label: model.id === '' && configured?.modelName ? `${model.name}: ${configured.modelName}` : model.name,
+                description: [model.id, model.description].filter(Boolean).join(' · ') || undefined, id: model.id, efforts: model.efforts })),
             { label: 'Enter an exact model ID…', description: undefined, id: '__custom__', efforts: choices.find(model => model.id === '')?.efforts }];
         const picked = await pickWithCurrent(items, `New chat · ${name} model`, 'Model availability depends on your harness account.', current?.model ?? '');
         if (!picked)
@@ -855,8 +881,8 @@ export async function activate(context) {
             model = typed.trim();
         }
         const levels = picked.efforts ?? ['low', 'medium', 'high'];
-        const efforts = [{ label: 'Harness default', id: '' }, ...levels.map(id => ({ label: id, id }))];
-        const effort = levels.length === 0 ? efforts[0] : await pickWithCurrent(efforts, `New chat · ${name} reasoning effort`, model ? `For ${model}` : 'For the harness default model', current?.effort ?? '');
+        const efforts = [{ label: configured?.effort && !model ? `Harness default: ${configured.effort}` : 'Harness default', id: '' }, ...levels.map(id => ({ label: id, id }))];
+        const effort = levels.length === 0 ? efforts[0] : await pickWithCurrent(efforts, `New chat · ${name} reasoning effort`, `For ${model || configured?.modelName || `${name}'s configured model`}`, current?.effort ?? '');
         if (!effort)
             return;
         return { model, effort: effort.id };
@@ -958,7 +984,9 @@ export async function activate(context) {
                 // whose built-in model picker deliberately omits Manage Models. Do not advertise
                 // 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' };
+                // The model picker names the model and effort and the permissions picker the approval mode; this item is only
+                // the way to choose them for a new chat.
+                const item = { id: 'settings', name: 'Change model…', description: 'Choose model and reasoning for a new chat.' };
                 groups.push({ id: 'modelSettings', name: 'Model', items: [item], selected: item,
                     commands: [{ command: 'supercode.frontend.configureModel', title: 'Choose model and reasoning for a new chat…', arguments: [selected.id] }] });
             }
@@ -990,6 +1018,7 @@ export async function activate(context) {
         resolve: (resource, token) => connectionFor(resource, false, token),
         attached: (connection) => attachedIds.has(connection.id),
         catalogue: () => controls?.state.sessions ?? [],
+        effective: (entry) => controls && entry.id === controls.state.activeSession ? controls.state.effective ?? null : draftEffective(entry.selection),
         bindings: boundId,
         watchApprovals: (connection, stream, token) => watchApprovals(connection, stream, token, () => approvalFor(connection.id)),
     };
@@ -1121,6 +1150,66 @@ export async function activate(context) {
         });
     }));
     context.subscriptions.push({ dispose: () => frontends.dispose() });
+    // Auto approve holds for the conversation, not only while a response of this window is open. A harness also runs
+    // turns of its own (a background task reporting back, a Monitor's event): an approval those raise had no response to
+    // answer it or show its card, and the turn waited forever. With no turn of this window running, such an approval is
+    // answered here under the conversation's mode; under Ask it keeps waiting for the person, as before.
+    const answerOutsideTurns = () => {
+        for (const connection of frontends.all) {
+            if (attachedIds.has(connection.id) || runningTurns.get(connection.id)?.size || !canAnswer(connection))
+                continue;
+            if (approvalFor(connection.id) !== 'autoApprove')
+                continue;
+            const answered = answeredRequests.get(connection.id) ?? new Set();
+            answeredRequests.set(connection.id, answered);
+            for (const pending of connection.session.pendingRequests.values()) {
+                if (pending.kind !== 'approval' || answered.has(pending.id))
+                    continue;
+                const decisions = acceptedDecisions(pending);
+                if (decisions && !decisions.includes('allow'))
+                    continue;
+                answered.add(pending.id);
+                void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).catch(error => {
+                    answered.delete(pending.id);
+                    log.warn(`Auto approve could not answer request #${pending.id} outside a turn: ${String(error?.message ?? error)}`);
+                });
+            }
+        }
+    };
+    context.subscriptions.push(frontends.onDidChange(answerOutsideTurns));
+    // STOP ANSWERS WHAT THE AGENT IS WAITING ON FIRST. An agent blocked on an approval (or a question) does not hear an
+    // interrupt until that request is answered: Claude Code's permission prompt kept the turn alive, the request
+    // vanished from view on reload, and every later prompt queued behind it (2026-10-07). So a Stop denies each waiting
+    // approval and cancels each question, then interrupts.
+    const stopConnection = async (connection) => {
+        if (canAnswer(connection)) {
+            for (const pending of [...connection.session.pendingRequests.values()]) {
+                const answer = pending.kind === 'approval'
+                    ? { kind: 'approval', request_id: pending.id, decision: 'deny' }
+                    : { kind: pending.kind === 'elicitation' ? 'elicitation' : 'other', request_id: pending.id, action: 'cancel' };
+                await connection.session.respond(answer).catch(error => log.warn(`Stop could not answer request #${pending.id}: ${String(error?.message ?? error)}`));
+            }
+        }
+        await connection.session.interrupt();
+    };
+    // The same Stop for a turn no response of this window holds — one the harness started itself, after a background
+    // task or a Monitor's event — which the Chat's own Stop (it cancels a response) cannot reach.
+    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.stopTurn', async (connectionId) => {
+        const connection = connectionId ? frontends.get(connectionId) : managed();
+        if (!connection)
+            return { stopped: false, reason: 'no conversation' };
+        try {
+            await stopConnection(connection);
+            return { stopped: true, connectionId: connection.id };
+        }
+        catch (error) {
+            const reason = String(error?.message ?? error);
+            log.warn(`Stop could not interrupt: ${reason}`);
+            return { stopped: false, connectionId: connection.id, reason };
+        }
+    }));
+    const outsideTurns = setInterval(answerOutsideTurns, 2_000);
+    context.subscriptions.push({ dispose: () => clearInterval(outsideTurns) });
     // Auto-answers a conversation's approvals while a response is written into `stream`: read at every event
     // (`sweep`) and on every picker change for that conversation, so switching to Auto approve mid-turn answers
     // the approvals already waiting and the ones after them. Used by a turn this window runs and by a turn it
@@ -1175,7 +1264,7 @@ export async function activate(context) {
                         writeProjected(stream, projectPendingRequests([pending], {
                             connectionId: connection.id,
                             canRespond: connection.session.descriptor?.actions.respond !== false,
-                        }), granted, { toolInputs: new Map(), toolNames: new Map() });
+                        }), granted, { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map() });
                     }
                     catch {
                         void vscode.window.showWarningMessage(`${connection.label}: ${label} is waiting for approval. Open its chat to answer it.`);
@@ -1212,14 +1301,14 @@ export async function activate(context) {
         if (approval() === 'autoApprove' && !canAnswer(connection)) {
             throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
         }
-        const state = { toolInputs: new Map(), toolNames: new Map() };
+        const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map() };
         const projection = {
             connectionId: connection.id,
             pendingRequest: (requestId) => connection.session.pendingRequests.get(requestId) ?? connection.session.resolvedRequests.get(requestId),
             canRespond: connection.session.descriptor?.actions.respond !== false,
         };
         const cancellation = token.onCancellationRequested(() => {
-            void connection.session.interrupt().catch(() => {
+            void stopConnection(connection).catch(() => {
                 // The runtime may already be idle; interrupting twice is not an error
                 // this view reports.
             });
@@ -1250,6 +1339,9 @@ export async function activate(context) {
         let completed = false;
         try {
             await connection.session.runTurn(prompt, (event) => {
+                // 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);
                 watch.sweep();
             });
@@ -1265,13 +1357,14 @@ export async function activate(context) {
                 await controls.refresh().catch(error => log.warn(`Could not refresh chat identity: ${String(error)}`));
                 controlsChanged.fire();
             }
-            // The model the turn ran on: what the harness's own replies name (the host watches them), else what the
-            // runtime reports; and the effort it was given.
-            const ran = (controls?.state.activeSession === connection.id ? controls.state.actualModel : undefined) || connection.session.descriptor?.model;
-            const effort = controls?.state.sessions.find(session => session.id === connection.id)?.selection.effort;
-            if (completed && ran && !token.isCancellationRequested)
-                stream.markdown(`\n\n_Ran on ${opaqueText(ran, 120)}${effort ? ` · ${opaqueText(effort, 24)} effort` : ''}_`);
         }
+        // The model the turn ran on: what the harness's own replies name (the host watches them), else what the
+        // runtime reports; and the effort it ran at (host `effective`).
+        const active = controls?.state.activeSession === connection.id;
+        const effective = active ? controls?.state.effective : undefined;
+        const ran = effective?.modelName || (active ? controls?.state.actualModel : undefined) || connection.session.descriptor?.model;
+        const effort = effective?.effort || controls?.state.sessions.find(session => session.id === connection.id)?.selection.effort;
+        return completed && ran && !token.isCancellationRequested ? `${opaqueText(ran, 120)}${effort ? ` · ${opaqueText(effort, 24)}` : ''}` : undefined;
     };
     const handler = async (request, chatContext, stream, token) => {
         await applying;
@@ -1302,25 +1395,24 @@ export async function activate(context) {
             stream.markdown(unavailableMarkdown(frontends.unavailable));
             return {};
         }
-        // While a request is pending, a typed message is its answer — this is the
-        // path for the answers no button can carry (`allow for session`, `cancel`,
-        // and an elicitation's free-text content).
         const pending = pendingRequestOf(connection);
+        // A message is never taken as an approval: one sent while an approval waits would otherwise allow the tool and
+        // never reach the agent. It is refused, with what to do, like a send during any running turn.
+        if (pending?.kind === 'approval') {
+            throw new Error(`${busyRefusal(connection, 'sending another message') ?? 'The current chat is waiting for your answer.'} Nothing was sent.`);
+        }
         if (pending) {
+            // A question that needs typed content: the message is its answer, and its resolution line says so.
             try {
-                const answer = typedAnswer(pending, request.prompt);
-                await connection.session.respond(answer);
-                stream.markdown(`_answered request #${pending.id}: ${opaqueText(answer, 256)}_`);
+                await connection.session.respond(typedAnswer(pending, request.prompt));
             }
             catch (error) {
-                stream.markdown(`Could not answer request #${pending.id}: ${opaqueText(String(error.message), 512)}`);
+                throw new Error(`Could not answer the question: ${opaqueText(String(error.message), 512)}`);
             }
             return {};
         }
-        if (request.prompt.trim().length === 0) {
-            stream.markdown('_nothing to submit_');
+        if (request.prompt.trim().length === 0)
             return {};
-        }
         const native = controls ? undefined : turnPermission(request.permissionLevel);
         const approval = () => native ?? approvalFor(connection.id);
         const attached = [];
@@ -1334,8 +1426,9 @@ export async function activate(context) {
             attached.push({ name: uri.toString(), text: document.getText(location?.range) });
         }
         const prompt = withTextContext(request.prompt, attached);
-        await runTurnInto(connection, prompt, stream, token, approval);
-        return {};
+        const details = await runTurnInto(connection, prompt, stream, token, approval);
+        // The model the turn ran on, in VS Code's own response footer rather than as a line of the conversation.
+        return details ? { details } : {};
     };
     const participants = [];
     for (const id of granted.has('defaultChatParticipant') ? [PARTICIPANT_ID, DEFAULT_PARTICIPANT_ID] : [PARTICIPANT_ID]) {
@@ -1766,13 +1859,16 @@ function historyParts(parts) {
             flush();
             const toolName = part.toolName || 'tool';
             const invocation = new vscode.ChatToolInvocationPart(toolName, part.toolCallId);
-            invocation.invocationMessage = part.invocationMessage || toolName;
-            invocation.pastTenseMessage = part.pastTenseMessage || part.invocationMessage || toolName;
+            invocation.invocationMessage = new vscode.MarkdownString(part.invocationMessage || `Ran \`${toolName}\``);
+            invocation.pastTenseMessage = new vscode.MarkdownString(part.pastTenseMessage || part.invocationMessage || `Ran \`${toolName}\``);
             invocation.isConfirmed = true;
             invocation.isComplete = part.isComplete;
             if (part.isError !== undefined)
                 invocation.isError = part.isError;
-            if (part.isComplete) {
+            if (part.commandLine) {
+                invocation.toolSpecificData = { commandLine: { original: part.commandLine }, language: 'sh', output: { text: part.resultText ?? '' } };
+            }
+            else if (part.isComplete) {
                 invocation.toolSpecificData = { input: part.inputText ?? '', output: part.resultText ?? '' };
             }
             out.push(invocation);
@@ -1832,7 +1928,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
     const items = () => {
         return (controls?.catalogue() ?? []).filter(entry => !frontends.get(entry.id)).map(entry => {
             const item = controller.createChatSessionItem(vscode.Uri.from({ scheme: SESSION_SCHEME, authority: entry.id, path: '/conversation' }), entry.title);
-            item.description = runtimeIdentity(entry.selection.harness, entry.selection.model).name;
+            item.description = runtimeIdentity(entry.selection.harness, entry.selection.model, controls?.effective(entry)).name;
             item.status = vscode.ChatSessionStatus.Completed;
             item.timing = { created: entry.created };
             return item;
@@ -1974,7 +2070,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         // already waiting and later ones; Ask leaves them for the person, as before.
                         const watch = controls && !controls.attached(connection) ? controls.watchApprovals(connection, stream, token) : undefined;
                         try {
-                            const state = { toolInputs: new Map(), toolNames: new Map(), quiet: watch?.answers };
+                            const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), quiet: watch?.answers };
                             writeProjected(stream, projectPendingRequests(connection.session.pendingRequests.values(), {
                                 connectionId: connection.id,
                                 canRespond: connection.session.descriptor?.actions.respond !== false,

package/dist/host-controls.d.ts

@@ -5,6 +5,12 @@ export interface ChatSelection {
     model: string;
     effort: string;
 }
+/** `modelName`: how to name `model` ("Claude Opus 5.5"); `effort` is '' when the model takes none. */
+export interface EffectiveChat {
+    model: string;
+    modelName: string;
+    effort: string;
+}
 /** `efforts`: the reasoning efforts a model takes, as the host read them from the harness (absent from older hosts). */
 export interface ChatChoice {
     id: string;
@@ -51,6 +57,11 @@ export interface HostState {
     modelsByHarness?: Record<string, ChatChoice[]>;
     busy: boolean;
     actualModel?: string | null;
+    /** The model and effort this conversation actually runs with, read from the harness's own configuration when the
+     *  selection names none (and from the runtime once a turn has run). Absent from older hosts. */
+    effective?: EffectiveChat | null;
+    /** The same for a new chat of each startable harness. */
+    effectiveByHarness?: Record<string, EffectiveChat | null>;
     configurable: boolean;
     setup?: ChatSetupState;
     /** The mode a new chat's picker shows. A conversation's own default is its `ManagedChatSession.defaultPermission`;
@@ -85,7 +96,9 @@ export declare class ChatHostControls {
 /** A picked approval mode, never inferred from connection privileges (those only keep a host default at ask). */
 export declare function turnPermission(value: string | undefined): 'ask' | 'autoApprove';
 export declare function harnessDisplayName(harness: string | null | undefined): string;
-export declare function runtimeIdentity(harness: string | null | undefined, model: string | null | undefined): {
+/** The Chat's name for a runtime: the model and effort it actually runs with (`effective`, from the host) and its
+ *  harness. It never says "default model": a harness whose model nobody reports is said to choose its own. */
+export declare function runtimeIdentity(harness: string | null | undefined, model: string | null | undefined, effective?: EffectiveChat | null): {
     name: string;
     provider: string | undefined;
 };

package/dist/host-controls.js

@@ -64,14 +64,17 @@ export function turnPermission(value) {
 export function harnessDisplayName(harness) {
     return { 'claude-code': 'Claude Code', codex: 'Codex', gemini: 'Gemini CLI', opencode: 'OpenCode', pi: 'Pi', goose: 'Goose' }[harness || ''] || harness || 'Assistant';
 }
-export function runtimeIdentity(harness, model) {
+/** The Chat's name for a runtime: the model and effort it actually runs with (`effective`, from the host) and its
+ *  harness. It never says "default model": a harness whose model nobody reports is said to choose its own. */
+export function runtimeIdentity(harness, model, effective) {
     const harnessName = harnessDisplayName(harness);
-    const knownModel = model && model !== harness ? model : '';
-    const modelName = { sonnet: 'Claude Sonnet', opus: 'Claude Opus', haiku: 'Claude Haiku' }[knownModel] || knownModel;
+    const knownModel = effective?.model || (model && model !== harness ? model : '');
+    const modelName = effective?.modelName || { sonnet: 'Claude Sonnet', opus: 'Claude Opus', haiku: 'Claude Haiku' }[knownModel] || knownModel;
     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;
-    return { name: modelName ? `${modelName} · ${harnessName}` : `${harnessName} · default model`, provider };
+    const effort = effective?.effort ? ` · ${effective.effort}` : '';
+    return { name: modelName ? `${modelName}${effort}` : `Model chosen by ${harnessName}`, provider };
 }
 /** Native pickers need a nonempty id; the host uses an empty model for its default. */
 export function modelSelection(value) { return value === "__default__" ? "" : value; }

package/dist/session.js

@@ -128,8 +128,31 @@ export class VscodeFrontendSession {
         // none no matter what its replay still carries.
         // Hosted Codex also receives standalone MCP elicitations. Its host retains
         // request/resolved pairs without the native broker's turn compaction.
-        if (staged.descriptor?.turn_state !== 'busy' && staged.descriptor?.source_harness !== 'codex')
-            staged.pendingRequests.clear();
+        // BUT A HARNESS ALSO RUNS TURNS OF ITS OWN (a background task reporting back, a Monitor's event): the runtime then
+        // reads idle while the agent loop is blocked on an approval it raised. Clearing that one left the agent waiting
+        // forever with nothing to answer it (2026-10-07). Compaction happens only at a turn boundary, so a request raised
+        // AFTER the replay's last boundary and not resolved since is still open, idle or not; only older ones are dropped.
+        if (staged.descriptor?.turn_state !== 'busy' && staged.descriptor?.source_harness !== 'codex') {
+            // A turn's END, not `turn_completed`: that one is a model round-trip and fires mid-turn.
+            const BOUNDARIES = new Set(['turn_succeeded', 'turn_failed', 'turn_interrupted']);
+            let lastBoundary = -1;
+            const raisedAt = new Map();
+            for (const event of snapshot.replay) {
+                if (BOUNDARIES.has(event.kind))
+                    lastBoundary = Math.max(lastBoundary, event.sequence);
+                const payload = (event.payload ?? {});
+                const request = event.kind === 'request' ? payload.request : undefined;
+                if (request && typeof request.id === 'number')
+                    raisedAt.set(request.id, event.sequence);
+            }
+            for (const id of [...staged.pendingRequests.keys()]) {
+                const at = raisedAt.get(id);
+                // A request known from before this attachment, with no boundary since, is still the open one it was.
+                const open = at !== undefined ? at > lastBoundary : lastBoundary < 0 && this.pendingRequests.has(id);
+                if (!open)
+                    staged.pendingRequests.delete(id);
+            }
+        }
         this.descriptor = staged.descriptor;
         this.history = structuredClone(snapshot.history);
         this.historyCursor = snapshot.history_cursor;

package/dist/view.d.ts

@@ -60,6 +60,8 @@ export type ChatPart = {
     isError?: boolean;
     isComplete: boolean;
     resultText?: string;
+    /** A shell call's command line: the row is then VS Code's own terminal block, command and output. */
+    commandLine?: string;
 } | {
     part: 'answers';
     approval: boolean;
@@ -93,6 +95,18 @@ export declare function diffPaths(diff: string): string[];
  * wasted row; `write_file · hello.txt` says what it did.
  */
 export declare function toolSubject(argumentsText: string): string | undefined;
+/**
+ * A tool row's titles the way VS Code's own agent writes them: what the call does, in the present while it runs
+ * ("Reading `view.ts`") and the past once done ("Read `view.ts`"), read from the call's own arguments. Shell calls
+ * use the description the harness gave them (Claude Code's `Bash.description`) when there is one. A tool this does
+ * not know is "Ran `name`", with its subject when the arguments name one.
+ */
+export declare function toolTitles(toolName: string, argumentsText: string): {
+    invocation: string;
+    pastTense: string;
+};
+/** The command line of a shell tool call, read from its own arguments; undefined for any other tool. */
+export declare function shellCommand(toolName: string, argumentsText: string): string | undefined;
 /** The summary line this view shows for a request payload. */
 export declare function requestSummary(request: FrontendRequest): string;
 /** The answers this view offers for a request, one button each. */
@@ -164,6 +178,14 @@ export interface ProjectedTurn {
  * supercode's own agent loop, and a hosted harness has none. So a resumed
  * Claude Code session's turns are here or nowhere.
  */
+/**
+ * A "user" message no person typed: Claude Code's `<task-notification>` (a background task reporting back) or the
+ * editor's automatic tripwire nudge. Neither is shown as the person's words. A task notification is said as one
+ * short line ("Background task completed: <its summary>"); a nudge is not shown. Undefined for a person's message.
+ */
+export declare function automaticPrompt(body: string): {
+    notice?: string;
+} | undefined;
 export declare function projectReplayTurns(events: readonly FrontendEvent[], granted: ReadonlySet<string>, context: ProjectionContext): ProjectedTurn[];
 /**
  * The attach snapshot's canonical history as chat turns. Bounded: when older

package/dist/view.js

@@ -98,6 +98,103 @@ export function toolSubject(argumentsText) {
     }
     return undefined;
 }
+const code = (value) => `\`${value.replace(/`/g, "'")}\``;
+/** Free text in a title, which the Chat renders as Markdown: its own `*`, `_`, `[` and the like stay characters. */
+const plain = (value) => value.replace(/[\\`*_{}[\]()<>#+!|~]/g, '\\$&');
+const basename = (path) => path.split(/[\\/]/).filter(Boolean).pop() ?? path;
+/**
+ * A tool row's titles the way VS Code's own agent writes them: what the call does, in the present while it runs
+ * ("Reading `view.ts`") and the past once done ("Read `view.ts`"), read from the call's own arguments. Shell calls
+ * use the description the harness gave them (Claude Code's `Bash.description`) when there is one. A tool this does
+ * not know is "Ran `name`", with its subject when the arguments name one.
+ */
+export function toolTitles(toolName, argumentsText) {
+    let fields = {};
+    try {
+        const parsed = JSON.parse(argumentsText);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            fields = parsed;
+    }
+    catch { /* not JSON: titled by name */ }
+    const field = (...names) => {
+        for (const name of names) {
+            const value = fields[name];
+            if (typeof value === 'string' && value.trim())
+                return clamp(stripControls(value.trim()), 120);
+            if (Array.isArray(value) && value.every(part => typeof part === 'string') && value.length)
+                return clamp(stripControls(value.join(' ')), 120);
+        }
+        return '';
+    };
+    const both = (present, past) => ({ invocation: clamp(present, VSCODE_CHAT_LIMITS.titleCharacters), pastTense: clamp(past, VSCODE_CHAT_LIMITS.titleCharacters) });
+    const file = field('file_path', 'path', 'file', 'notebook_path');
+    const name = toolName.toLowerCase();
+    if (['bash', 'shell', 'exec_command', 'local_shell', 'powershell'].includes(name)) {
+        const description = field('description');
+        if (description)
+            return both(plain(description), plain(description));
+        const command = field('command', 'cmd');
+        return command ? both(`Running ${code(command)}`, `Ran ${code(command)}`) : both(`Running a command`, `Ran a command`);
+    }
+    if (name === 'read' && file) {
+        const offset = typeof fields.offset === 'number' ? fields.offset : undefined;
+        const limit = typeof fields.limit === 'number' ? fields.limit : undefined;
+        const lines = offset !== undefined && limit !== undefined ? `, lines ${offset} to ${offset + limit - 1}` : '';
+        return both(`Reading ${code(basename(file))}${lines}`, `Read ${code(basename(file))}${lines}`);
+    }
+    if (name === 'write' && file)
+        return both(`Writing ${code(basename(file))}`, `Wrote ${code(basename(file))}`);
+    if (['edit', 'multiedit', 'notebookedit', 'apply_patch'].includes(name))
+        return file ? both(`Editing ${code(basename(file))}`, `Edited ${code(basename(file))}`) : both('Editing files', 'Edited files');
+    if (name === 'grep') {
+        const pattern = field('pattern');
+        if (pattern)
+            return both(`Searching for ${code(pattern)}`, `Searched for ${code(pattern)}`);
+    }
+    if (name === 'glob') {
+        const pattern = field('pattern');
+        if (pattern)
+            return both(`Finding files matching ${code(pattern)}`, `Found files matching ${code(pattern)}`);
+    }
+    if (name === 'webfetch') {
+        const url = field('url');
+        if (url)
+            return both(`Fetching ${plain(url)}`, `Fetched ${plain(url)}`);
+    }
+    if (name === 'websearch' || name === 'web_search') {
+        const query = field('query');
+        if (query)
+            return both(`Searching the web for ${code(query)}`, `Searched the web for ${code(query)}`);
+    }
+    if (['task', 'agent'].includes(name)) {
+        const description = field('description');
+        if (description)
+            return both(`Running a subagent: ${plain(description)}`, `Ran a subagent: ${plain(description)}`);
+    }
+    if (name === 'todowrite' || name === 'update_plan')
+        return both('Updating the plan', 'Updated the plan');
+    // Claude Code names an MCP tool `mcp__<server>__<tool>`; VS Code writes "Ran `tool` – server".
+    const mcp = /^mcp__(.+?)__(.+)$/.exec(toolName);
+    if (mcp)
+        return both(`Running ${code(mcp[2])} – ${plain(mcp[1])}`, `Ran ${code(mcp[2])} – ${plain(mcp[1])}`);
+    const subject = toolSubject(argumentsText);
+    return subject ? both(`Running ${code(toolName)} · ${plain(subject)}`, `Ran ${code(toolName)} · ${plain(subject)}`) : both(`Running ${code(toolName)}`, `Ran ${code(toolName)}`);
+}
+/** The command line of a shell tool call, read from its own arguments; undefined for any other tool. */
+export function shellCommand(toolName, argumentsText) {
+    if (!['bash', 'shell', 'exec_command', 'local_shell', 'powershell'].includes(toolName.toLowerCase()))
+        return undefined;
+    try {
+        const fields = JSON.parse(argumentsText);
+        const command = fields?.command ?? fields?.cmd;
+        if (typeof command === 'string' && command.trim())
+            return stripControls(command);
+        if (Array.isArray(command) && command.every(part => typeof part === 'string') && command.length)
+            return stripControls(command.join(' '));
+    }
+    catch { /* not JSON */ }
+    return undefined;
+}
 /** The summary line this view shows for a request payload. */
 export function requestSummary(request) {
     const payload = request.payload;
@@ -302,21 +399,21 @@ export function projectEvent(event, context) {
             const toolCallId = text(payload.id, `event-${event.sequence}`);
             const rawArguments = text(payload.arguments);
             const inputText = clamp(stripControls(parseArguments(rawArguments)), VSCODE_CHAT_LIMITS.partCharacters);
-            const subject = toolSubject(rawArguments);
+            const titles = toolTitles(toolName, rawArguments);
+            const commandLine = shellCommand(toolName, rawArguments);
             return [{
                     emit: {
                         part: 'tool',
                         toolName,
                         toolCallId,
-                        invocationMessage: clamp(subject ? `${toolName} · ${subject}` : toolName, VSCODE_CHAT_LIMITS.titleCharacters),
+                        invocationMessage: titles.invocation,
+                        pastTenseMessage: titles.pastTense,
                         inputText,
                         isComplete: false,
+                        ...(commandLine ? { commandLine } : {}),
                     },
                     needs: 'chatParticipantAdditions',
-                    fallback: [{
-                            part: 'progress',
-                            value: clamp(subject ? `${toolName} · ${subject}` : toolName, VSCODE_CHAT_LIMITS.titleCharacters),
-                        }],
+                    fallback: [{ part: 'progress', value: titles.invocation }],
                 }];
         }
         // crates/runtime/src/event.rs `AgentEvent::ToolCallCompleted`.
@@ -328,13 +425,16 @@ export function projectEvent(event, context) {
             const toolCallId = text(payload.id, `event-${event.sequence}`);
             const output = clamp(stripControls(text(payload.output)), VSCODE_CHAT_LIMITS.partCharacters);
             const isError = payload.is_error === true;
+            // The titles stay the ones the call started with (the writer keeps them per call); a completion that names its
+            // tool without having started on this stream is titled by that name.
+            const titles = toolName ? toolTitles(toolName, text(payload.arguments)) : undefined;
             return [{
                     emit: {
                         part: 'tool',
                         toolName,
                         toolCallId,
-                        invocationMessage: clamp(toolName, VSCODE_CHAT_LIMITS.titleCharacters),
-                        pastTenseMessage: clamp(toolName, VSCODE_CHAT_LIMITS.titleCharacters),
+                        invocationMessage: titles?.invocation ?? '',
+                        pastTenseMessage: titles?.pastTense ?? '',
                         isError,
                         isComplete: true,
                         resultText: output,
@@ -410,6 +510,10 @@ export function projectEvent(event, context) {
         case 'request_resolved': {
             const requestId = typeof payload.request_id === 'number' ? payload.request_id : Number.NaN;
             const response = payload.response;
+            // An allowed approval says nothing more, as in VS Code's own chat: its tool row carries on and is the record.
+            // A denial, and an answer to any other request, is said once.
+            if (response?.kind === 'approval' && response.decision !== 'deny')
+                return [];
             const sentence = resolutionSentence(response, context.pendingRequest?.(requestId), requestId);
             return [stable({ part: 'markdown', value: `\n\n_${sentence}_\n\n` })];
         }
@@ -423,11 +527,9 @@ export function projectEvent(event, context) {
                 }];
         }
         // crates/runtime/src/event.rs `AgentEvent::Usage`.
+        // Token counts are not conversation: VS Code's own chat keeps them out of the transcript.
         case 'usage':
-            return [stable({
-                    part: 'progress',
-                    value: `prompt ${text(payload.prompt_tokens, '?')} · completion ${text(payload.completion_tokens, '?')} · total ${text(payload.total_tokens, '?')} tokens`,
-                })];
+            return [];
         // crates/runtime/src/event.rs `AgentEvent::BackgroundOutput`.
         case 'background_output': {
             const chunk = fence(clamp(stripControls(text(payload.chunk)), VSCODE_CHAT_LIMITS.partCharacters));
@@ -438,8 +540,9 @@ export function projectEvent(event, context) {
                 })];
         }
         // crates/harness/src/server.rs `submit_claimed`.
+        // The live writer drops it when the person stopped the turn (VS Code marks a stopped response itself).
         case 'turn_interrupted':
-            return [stable({ part: 'markdown', value: '\n\n_turn interrupted_\n\n' })];
+            return [stable({ part: 'warning', value: 'The turn was interrupted.' })];
         // crates/harness/src/server.rs `submit_claimed` emits `turn_failed`. The
         // other four are the error kinds the donor-neutral reader in
         // crates/frontend-model/src/transcript.rs treats identically:
@@ -555,6 +658,23 @@ function messageText(message) {
  * supercode's own agent loop, and a hosted harness has none. So a resumed
  * Claude Code session's turns are here or nowhere.
  */
+/**
+ * A "user" message no person typed: Claude Code's `<task-notification>` (a background task reporting back) or the
+ * editor's automatic tripwire nudge. Neither is shown as the person's words. A task notification is said as one
+ * short line ("Background task completed: <its summary>"); a nudge is not shown. Undefined for a person's message.
+ */
+export function automaticPrompt(body) {
+    const trimmed = body.trimStart();
+    if (trimmed.startsWith('<task-notification>')) {
+        const tag = (name) => clamp(stripControls(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`).exec(trimmed)?.[1]?.trim() ?? ''), 200);
+        const summary = tag('summary');
+        const status = tag('status');
+        return { notice: `_Background task${status ? ` ${status}` : ''}${summary ? `: ${summary}` : ''}_` };
+    }
+    if (trimmed.startsWith('[Volter editor tripwire'))
+        return {};
+    return undefined;
+}
 export function projectReplayTurns(events, granted, context) {
     const turns = [];
     let streamedText;
@@ -562,6 +682,20 @@ export function projectReplayTurns(events, granted, context) {
         if (event.kind === 'user_message') {
             streamedText = undefined;
             const payload = payloadOf(event);
+            const automatic = automaticPrompt(text(payload.text));
+            if (automatic) {
+                if (!automatic.notice)
+                    continue;
+                if (turns.length === 0)
+                    turns.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+                const last = turns[turns.length - 1];
+                const notice = { part: 'markdown', value: `\n\n${automatic.notice}\n\n` };
+                if (last.role === 'assistant' && last.parts)
+                    last.parts.push(notice);
+                else
+                    turns.push({ role: 'assistant', parts: [notice] });
+                continue;
+            }
             turns.push({ role: 'user', prompt: clamp(stripControls(text(payload.text)), VSCODE_CHAT_LIMITS.partCharacters) });
             continue;
         }
@@ -652,6 +786,12 @@ export function projectHistory(history, granted, pendingToolNames = new Set()) {
                     pushAssistant([{ part: 'markdown', value: clamp(stripControls(text), VSCODE_CHAT_LIMITS.partCharacters) }]);
                 continue;
             }
+            const automatic = automaticPrompt(body);
+            if (automatic) {
+                if (automatic.notice)
+                    pushAssistant([{ part: 'markdown', value: `\n\n${automatic.notice}\n\n` }]);
+                continue;
+            }
             toolRows.clear();
             turns.push({ role: 'user', prompt: clamp(stripControls(body), VSCODE_CHAT_LIMITS.partCharacters) });
             continue;
@@ -675,14 +815,15 @@ export function projectHistory(history, granted, pendingToolNames = new Set()) {
                 pushAssistant([{ part: 'markdown', value: clamp(stripControls(body), VSCODE_CHAT_LIMITS.partCharacters) }]);
             }
             for (const call of message.tool_calls ?? []) {
-                const subject = toolSubject(call.function.arguments);
-                const label = clamp(stripControls(subject ? `${call.function.name} · ${subject}` : call.function.name), VSCODE_CHAT_LIMITS.titleCharacters);
+                const titles = toolTitles(call.function.name, call.function.arguments);
+                const commandLine = shellCommand(call.function.name, call.function.arguments);
                 const row = {
                     part: 'tool',
                     toolName: call.function.name,
                     toolCallId: call.id,
-                    invocationMessage: label,
-                    pastTenseMessage: label,
+                    invocationMessage: titles.invocation,
+                    pastTenseMessage: titles.pastTense,
+                    ...(commandLine ? { commandLine } : {}),
                     inputText: clamp(stripControls(parseArguments(call.function.arguments)), VSCODE_CHAT_LIMITS.partCharacters),
                     isComplete: true,
                 };

package/package.json

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