@volter/supercode-frontend-vscode 0.1.47 → 0.1.49

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,28 @@ 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 effectiveNow = () => {
+        if (focusedAttached)
+            return null;
+        const selection = draftSelection();
+        return selection ? draftEffective(selection) : controls?.state.effective ?? null;
+    };
     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 +551,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 +600,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 +871,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 +887,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 +990,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,10 +1024,27 @@ 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)),
     };
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.activateSession', async (resource) => { await connectionFor(vscode.Uri.parse(resource)); }));
+    // 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);
+        const task = connection?.session.backgroundTasks.find(candidate => candidate.id === taskId);
+        if (!connection || !task) {
+            void vscode.window.showInformationMessage('That background task is no longer running.');
+            return;
+        }
+        try {
+            const stopped = await connection.session.stopTask(taskId);
+            void vscode.window.showInformationMessage(stopped ? `Stopped ${task.description || taskId}.` : `The harness did not stop ${task.description || taskId}.`);
+        }
+        catch (error) {
+            void vscode.window.showErrorMessage(`Could not stop ${task.description || taskId}: ${String(error?.message ?? error)}`);
+        }
+    }));
     // The host's native focus event is authoritative even when a cached model
     // skips content resolution. Untitled/non-harness focus never starts a runtime.
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.focusSession', (resource) => {
@@ -1105,6 +1156,59 @@ 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' };
+        await stopConnection(connection).catch(error => log.warn(`Stop could not interrupt: ${String(error?.message ?? error)}`));
+        return { stopped: true, connectionId: connection.id };
+    }));
+    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
@@ -1159,7 +1263,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.`);
@@ -1196,29 +1300,54 @@ 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.
             });
         });
         const watch = watchApprovals(connection, stream, token, approval);
         state.quiet = watch.answers;
+        // The harness's own background tasks (a Monitor, a background shell): each event one reports is a turn of its own,
+        // which this message waits behind, and nothing here would show it. Said once per change of the set, each with a
+        // way to stop it.
+        let saidTasks = '';
+        const sayTasks = () => {
+            const tasks = connection.session.backgroundTasks;
+            const key = tasks.map(task => task.id).join(',');
+            if (key === saidTasks)
+                return;
+            saidTasks = key;
+            if (!tasks.length) {
+                stream.markdown('\n\n_No background task is running any more._\n\n');
+                return;
+            }
+            stream.markdown(`\n\n_${tasks.length === 1 ? 'A background task is' : `${tasks.length} background tasks are`} still running in this session. The harness answers each of its events as a turn of its own, so this message can wait behind them:_\n\n`);
+            for (const task of tasks) {
+                stream.button({ command: 'supercode.frontend.stopBackgroundTask', title: `Stop ${opaqueText(task.description || task.id, 80)}`, arguments: [connection.id, task.id] });
+            }
+        };
+        sayTasks();
+        const unwatchTasks = connection.session.onChange(sayTasks);
         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();
             });
             completed = true;
         }
         finally {
+            unwatchTasks();
             watch.dispose();
             cancellation.dispose();
             if (controls && !attachedIds.has(connection.id)) {
@@ -1227,13 +1356,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;
@@ -1268,21 +1398,23 @@ export async function activate(context) {
         // 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 = [];
@@ -1296,8 +1428,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]) {
@@ -1728,13 +1861,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);
@@ -1794,7 +1930,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;
@@ -1936,7 +2072,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,9 +96,13 @@ 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;
 };
+/** The approval mode as the Chat names it. */
+export declare function permissionName(value: 'ask' | 'autoApprove'): string;
 /** Native pickers need a nonempty id; the host uses an empty model for its default. */
 export declare function modelSelection(value: string): string;

package/dist/host-controls.js

@@ -64,14 +64,19 @@ 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 };
 }
+/** The approval mode as the Chat names it. */
+export function permissionName(value) { return value === 'autoApprove' ? 'Auto approve' : 'Ask for approval'; }
 /** 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.d.ts

@@ -15,6 +15,9 @@ export interface VscodeRuntimeClient {
     steer(prompt: string): Promise<{
         queued: boolean;
     }>;
+    stopTask(taskId: string): Promise<{
+        stopped: boolean;
+    }>;
     interrupt(): Promise<{
         interrupted: boolean;
     }>;
@@ -62,6 +65,12 @@ export declare const TURN_TERMINAL_KINDS: readonly ["turn_succeeded", "turn_fail
  * the view reports.
  */
 export declare const LEASE_ERROR_NAMES: readonly string[];
+/** One of the harness's own background tasks (a Monitor, a background shell), as it last listed them. */
+export interface BackgroundTask {
+    id: string;
+    kind: string;
+    description: string;
+}
 /**
  * One attachment to one already-running Volter Harness SDK runtime: cursor-safe
  * event projection, permission narrowing, and the semantic actions the runtime
@@ -86,6 +95,11 @@ export declare class VscodeFrontendSession {
      */
     replay: FrontendEvent[];
     pendingRequests: Map<number, FrontendRequest>;
+    /**
+     * The harness's own background tasks as it last listed them (`background_tasks`). Each event one reports starts a
+     * turn of its own, so while any runs the session can be busy with turns no one here submitted.
+     */
+    backgroundTasks: BackgroundTask[];
     /**
      * Requests this attachment has seen resolved. `request_resolved` deletes the
      * pending entry while it is being projected, so without this the resolution
@@ -136,6 +150,8 @@ export declare class VscodeFrontendSession {
     submit(prompt: string): Promise<void>;
     steer(prompt: string): Promise<void>;
     interrupt(): Promise<void>;
+    /** Stop one of the harness's own background tasks, by the id it listed it with. */
+    stopTask(taskId: string): Promise<boolean>;
     respond(response: FrontendResponse): Promise<void>;
     detach(): Promise<void>;
     close(): Promise<void>;

package/dist/session.js

@@ -56,6 +56,11 @@ export class VscodeFrontendSession {
      */
     replay = [];
     pendingRequests = new Map();
+    /**
+     * The harness's own background tasks as it last listed them (`background_tasks`). Each event one reports starts a
+     * turn of its own, so while any runs the session can be busy with turns no one here submitted.
+     */
+    backgroundTasks = [];
     /**
      * Requests this attachment has seen resolved. `request_resolved` deletes the
      * pending entry while it is being projected, so without this the resolution
@@ -105,6 +110,7 @@ export class VscodeFrontendSession {
         const staged = {
             descriptor: structuredClone(snapshot.descriptor),
             pendingRequests: new Map([...this.pendingRequests].map(([id, request]) => [id, structuredClone(request)])),
+            backgroundTasks: structuredClone(this.backgroundTasks),
             cursor: Math.max(this.cursor, snapshot.history_cursor),
         };
         // Validate and project the whole attachment before any observable field
@@ -122,13 +128,36 @@ 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') {
+            const BOUNDARIES = new Set(['turn_succeeded', 'turn_completed', '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;
         this.appendTranscript(structuredClone(snapshot.replay));
         this.pendingRequests = staged.pendingRequests;
+        this.backgroundTasks = staged.backgroundTasks;
         this.cursor = staged.cursor;
         this.connection = 'connected';
         this.attachedAtMs ??= Date.now();
@@ -263,6 +292,11 @@ export class VscodeFrontendSession {
             if (request && typeof request.id === 'number')
                 state.pendingRequests.set(request.id, structuredClone(request));
         }
+        if (event.kind === 'background_tasks' && Array.isArray(payload.tasks)) {
+            state.backgroundTasks = payload.tasks
+                .filter(task => task && typeof task.id === 'string')
+                .map(task => ({ id: task.id, kind: String(task.kind ?? 'task'), description: String(task.description ?? '') }));
+        }
         if (event.kind === 'request_resolved' && typeof payload.request_id === 'number') {
             const resolved = state.pendingRequests.get(payload.request_id);
             if (resolved) {
@@ -337,6 +371,11 @@ export class VscodeFrontendSession {
         this.require('interrupt');
         await this.withControl(() => this.client.interrupt());
     }
+    /** Stop one of the harness's own background tasks, by the id it listed it with. */
+    async stopTask(taskId) {
+        const result = await this.withControl(() => this.client.stopTask(taskId));
+        return result?.stopped === true;
+    }
     async respond(response) {
         this.require('respond');
         if (!this.pendingRequests.has(response.request_id))

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,101 @@ export function toolSubject(argumentsText) {
     }
     return undefined;
 }
+const code = (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(description, 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 ${url}`, `Fetched ${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: ${description}`, `Ran a subagent: ${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])} – ${mcp[1]}`, `Ran ${code(mcp[2])} – ${mcp[1]}`);
+    const subject = toolSubject(argumentsText);
+    return subject ? both(`Running ${code(toolName)} · ${subject}`, `Ran ${code(toolName)} · ${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 +397,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 +423,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 +508,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 +525,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 +538,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 +656,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 +680,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 +784,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 +813,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.47",
+  "version": "0.1.49",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",
@@ -190,7 +190,7 @@
   },
   "supercodeFrontendContract": {
     "name": "@volter/supercode-frontend",
-    "version": "0.2.8",
+    "version": "0.2.9",
     "mode": "generated-artifact"
   },
   "license": "MIT OR Apache-2.0"

package/vendor/supercode-frontend/contract.json

@@ -251,6 +251,8 @@
     "Reply": {"kind": "object", "fields": {"reply": {"type": "string"}}},
     "Interrupted": {"kind": "object", "fields": {"interrupted": {"type": "boolean"}}},
     "Queued": {"kind": "object", "fields": {"queued": {"type": "boolean"}}},
+    "TaskParams": {"kind": "object", "fields": {"task_id": {"type": "string"}}},
+    "Stopped": {"kind": "object", "fields": {"stopped": {"type": "boolean"}}},
     "Closed": {"kind": "object", "fields": {"closed": {"type": "boolean"}}}
   },
   "methods": [
@@ -260,6 +262,7 @@
     {"id": "submit", "wire": "frontend.v2.submit", "sdk_action": "input", "params": "MultimodalPromptParams", "result": "Reply", "compatibility": "completion_waiting_alias", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "interrupt", "wire": "frontend.v2.interrupt", "sdk_action": "interrupt", "params": "Empty", "result": "Interrupted", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "steer", "wire": "frontend.v2.steer", "sdk_action": "steer", "params": "PromptParams", "result": "Queued", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "stop_task", "wire": "frontend.v2.stop_task", "sdk_action": "stop_task", "params": "TaskParams", "result": "Stopped", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "respond", "wire": "frontend.v2.respond", "sdk_action": "respond", "params": "RespondParams", "result": "Accepted", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "invoke", "wire": "frontend.v2.invoke", "sdk_action": "input", "params": "InvokeParams", "result": "FrontendOperationResult", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "lease", "wire": "frontend.v2.lease", "sdk_action": "events", "params": "Empty", "result": "RuntimeLeaseSnapshot", "transports": ["local", "http", "websocket", "acp"]},

package/vendor/supercode-frontend/generated-client.d.mts

@@ -1,5 +1,5 @@
 // @generated by sdk/frontend/generate.mjs from contract.json. Do not edit.
-import type { Accepted, Closed, FrontendAttachSnapshot, FrontendOperationInvocation, FrontendOperationResult, FrontendResponse, FrontendRuntimeDescriptor, FrontendWireMethod, Interrupted, Queued, Reply, RuntimeLeaseSnapshot } from './generated.mjs';
+import type { Accepted, Closed, FrontendAttachSnapshot, FrontendOperationInvocation, FrontendOperationResult, FrontendResponse, FrontendRuntimeDescriptor, FrontendWireMethod, Interrupted, Queued, Reply, RuntimeLeaseSnapshot, Stopped } from './generated.mjs';
 export abstract class GeneratedFrontendClient<Options = unknown> {
   abstract rpc(method: FrontendWireMethod, params?: Record<string, unknown>, options?: Options): Promise<unknown>;
   describe(options?: Options): Promise<FrontendRuntimeDescriptor>;
@@ -8,6 +8,7 @@ export abstract class GeneratedFrontendClient<Options = unknown> {
   submit(prompt: string, options?: Options & {imageUrls?: string[]}): Promise<Reply>;
   interrupt(options?: Options): Promise<Interrupted>;
   steer(prompt: string, options?: Options): Promise<Queued>;
+  stopTask(taskId: string, options?: Options): Promise<Stopped>;
   respond(response: FrontendResponse, options?: Options): Promise<Accepted>;
   invoke(operation: FrontendOperationInvocation, options?: Options): Promise<FrontendOperationResult>;
   lease(options?: Options): Promise<RuntimeLeaseSnapshot>;

package/vendor/supercode-frontend/generated-client.mjs

@@ -9,6 +9,7 @@ export class GeneratedFrontendClient {
   submit(prompt, { imageUrls, ...options } = {}) { return this.rpc(FRONTEND_METHODS.submit, { prompt, ...(imageUrls?.length ? {image_urls:imageUrls} : {}) }, options); }
   interrupt(options) { return this.rpc(FRONTEND_METHODS.interrupt, {}, options); }
   steer(prompt, options) { return this.rpc(FRONTEND_METHODS.steer, { prompt }, options); }
+  stopTask(taskId, options) { return this.rpc(FRONTEND_METHODS.stop_task, { task_id: taskId }, options); }
   respond(response, options) { return this.rpc(FRONTEND_METHODS.respond, { response }, options); }
   invoke(operation, options) { return this.rpc(FRONTEND_METHODS.invoke, { operation }, options); }
   lease(options) { return this.rpc(FRONTEND_METHODS.lease, {}, options); }

package/vendor/supercode-frontend/generated.d.mts

@@ -139,8 +139,14 @@ export interface Interrupted {
 export interface Queued {
   queued: boolean;
 }
+export interface TaskParams {
+  task_id: string;
+}
+export interface Stopped {
+  stopped: boolean;
+}
 export interface Closed {
   closed: boolean;
 }
-export type FrontendMethodId = 'describe' | 'attach' | 'send_input' | 'submit' | 'interrupt' | 'steer' | 'respond' | 'invoke' | 'lease' | 'acquire_control' | 'take_control' | 'heartbeat' | 'detach' | 'close';
-export type FrontendWireMethod = 'frontend.v2.describe' | 'frontend.v2.attach' | 'frontend.v2.send_input' | 'frontend.v2.submit' | 'frontend.v2.interrupt' | 'frontend.v2.steer' | 'frontend.v2.respond' | 'frontend.v2.invoke' | 'frontend.v2.lease' | 'frontend.v2.acquire_control' | 'frontend.v2.take_control' | 'frontend.v2.heartbeat' | 'frontend.v2.detach' | 'frontend.v2.close';
+export type FrontendMethodId = 'describe' | 'attach' | 'send_input' | 'submit' | 'interrupt' | 'steer' | 'stop_task' | 'respond' | 'invoke' | 'lease' | 'acquire_control' | 'take_control' | 'heartbeat' | 'detach' | 'close';
+export type FrontendWireMethod = 'frontend.v2.describe' | 'frontend.v2.attach' | 'frontend.v2.send_input' | 'frontend.v2.submit' | 'frontend.v2.interrupt' | 'frontend.v2.steer' | 'frontend.v2.stop_task' | 'frontend.v2.respond' | 'frontend.v2.invoke' | 'frontend.v2.lease' | 'frontend.v2.acquire_control' | 'frontend.v2.take_control' | 'frontend.v2.heartbeat' | 'frontend.v2.detach' | 'frontend.v2.close';

package/vendor/supercode-frontend/generated.mjs

@@ -7,6 +7,7 @@ export const FRONTEND_METHODS = Object.freeze({
   "submit": "frontend.v2.submit",
   "interrupt": "frontend.v2.interrupt",
   "steer": "frontend.v2.steer",
+  "stop_task": "frontend.v2.stop_task",
   "respond": "frontend.v2.respond",
   "invoke": "frontend.v2.invoke",
   "lease": "frontend.v2.lease",

package/vendor/supercode-frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-frontend",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "type": "module",
   "description": "Generated language-neutral attachment client for Volter Harness SDK runtimes",
   "exports": {