@volter/supercode-frontend-vscode 0.1.63 → 0.1.65

package/dist/extension.js

@@ -10,8 +10,8 @@ import { createFrontendClient } from './client.js';
 import { readCredentialFile } from './credential.js';
 import { grantedProposals, PROPOSAL_EFFECTS, REQUESTED_PROPOSALS } from './proposals.js';
 import { observeActiveResponse, sessionStatus } from './native-session.js';
-import { RequestNotPendingError, VscodeFrontendSession } from './session.js';
-import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, HISTORY_MARKER_PROMPT, PlanTracker, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
+import { RequestNotPendingError, TURN_TERMINAL_KINDS, VscodeFrontendSession } from './session.js';
+import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, HISTORY_MARKER_PROMPT, PlanTracker, resolveParts, resolutionSentence, turnOutcome, typedAnswer, } from './view.js';
 const SESSION_SCHEME = 'supercode';
 /** The harnesses whose model and reasoning effort a new chat can set (the host passes them to the CLI). */
 const CONFIGURABLE_HARNESSES = ['claude-code', 'codex'];
@@ -204,6 +204,43 @@ class SupercodeFrontends {
     }
 }
 let nativeInTurnApprovalCards = false;
+/** The host draws a harness notice as its system notification row (`chatSystemNotification`). */
+let systemNotifications = false;
+/** The host retires a confirmation the extension marks answered (`chatConfirmationResolution`). */
+let confirmationResolution = false;
+/** The output channel, for records that are not conversation (`unshown` parts). */
+let outputLog;
+/** Each such record once, however often a history is rebuilt from the same events. */
+const loggedRecords = new Set();
+const logRecord = (value) => {
+    if (loggedRecords.has(value))
+        return;
+    loggedRecords.add(value);
+    if (loggedRecords.size > 1000)
+        loggedRecords.delete(loggedRecords.values().next().value);
+    outputLog?.warn(value);
+};
+/** The requests each response stream drew a card for, so a resolution is said only beneath a card it drew. */
+const drawnRequests = new WeakMap();
+/** Requests answered through their own card in this window (`answerRequest`): such a card shows its answer itself. */
+const answeredByCard = new Set();
+const cardKey = (connectionId, requestId) => JSON.stringify([connectionId, requestId]);
+const drew = (stream, requestId) => {
+    const drawn = drawnRequests.get(stream) ?? new Set();
+    drawnRequests.set(stream, drawn.add(requestId));
+};
+/** The confirmation cards each response stream drew natively, so one answered elsewhere can be retired. */
+const drawnCards = new WeakMap();
+/** Retires a native card drawn in `stream`, as one answered through itself is; false where the host cannot. */
+function retireCard(stream, requestId) {
+    const card = confirmationResolution ? drawnCards.get(stream)?.get(requestId) : undefined;
+    if (!card)
+        return false;
+    const retired = new vscode.ChatResponseConfirmationPart(card.title, card.message, card.data, card.buttons);
+    retired.isUsed = true;
+    stream.push(retired);
+    return true;
+}
 /**
  * A harness's questions as VS Code's own carousel, inside the running turn; the person's answers are the
  * elicitation's `{action:'accept', content:{<key>: label | [labels] | text}}`, and Skip is a decline. The answer
@@ -301,7 +338,7 @@ function writeProjected(stream, projected, granted, state) {
                         writePart(stream, fallback, state);
                     }
                     catch {
-                        stream.markdown(opaqueText(fallback));
+                        // (a stream that refuses even the stable part has closed; a part's JSON is never conversation)
                     }
                 }
             }
@@ -316,6 +353,12 @@ function writePart(stream, part, state) {
         case 'progress':
             stream.progress(part.value);
             return;
+        case 'notice':
+            if (systemNotifications)
+                stream.push(new vscode.ChatResponseSystemNotificationPart(part.value, part.icon ? new vscode.ThemeIcon(part.icon) : undefined));
+            else
+                stream.markdown(`\n\n${part.value}\n\n`);
+            return;
         case 'warning':
             stream.warning(part.value);
             return;
@@ -330,6 +373,7 @@ function writePart(stream, part, state) {
             stream.push(hookPart(part));
             return;
         case 'questions':
+            drew(stream, part.requestId);
             if (state.carousel)
                 askQuestions(stream, part, state.pending, state.cancelled);
             else
@@ -345,13 +389,26 @@ function writePart(stream, part, state) {
                 stream.markdown(`\`${part.path}\``);
             return;
         }
+        case 'resolution':
+            if (!drawnRequests.get(stream)?.has(part.requestId) || answeredByCard.has(cardKey(part.connectionId, part.requestId)))
+                return;
+            // A native card answered elsewhere retires itself, as Code-OSS's does; the call's row carries the outcome.
+            if (retireCard(stream, part.requestId))
+                return;
+            stream.markdown(`\n\n${part.value}\n\n`);
+            return;
+        case 'unshown':
+            logRecord(part.value);
+            return;
         case 'answers':
-            if (part.approval && part.answers.length > 0 && state.quiet?.(part.answers[0].requestId))
+            if (part.approval && part.answers.length > 0 && state.quiet?.(part.requestId))
                 return;
+            drew(stream, part.requestId);
             if (part.approval && nativeInTurnApprovalCards && part.answers.length > 0) {
-                stream.confirmation(part.title, part.message, {
-                    kind: 'supercode.inTurnApproval', version: 1, answers: part.answers,
-                }, part.answers.map(answer => answer.label));
+                const card = { title: part.title, message: part.message, data: { kind: 'supercode.inTurnApproval', version: 1, answers: part.answers }, buttons: part.answers.map(answer => answer.label) };
+                stream.confirmation(card.title, card.message, card.data, card.buttons);
+                const cards = drawnCards.get(stream) ?? new Map();
+                drawnCards.set(stream, cards.set(part.requestId, card));
                 return;
             }
             // Stable API on purpose: a command button runs INSIDE the live turn,
@@ -434,12 +491,15 @@ function unavailableMarkdown(reason) {
 }
 export async function activate(context) {
     const log = vscode.window.createOutputChannel('Volter Harness', { log: true });
+    outputLog = log;
     context.subscriptions.push(log);
     // The HOST decides which proposals this extension got; its own manifest only
     // asks. `context.extension.packageJSON` is the filtered extension
     // description, so this is the grant, not the request.
     const granted = grantedProposals(context.extension.packageJSON);
     log.info(`Volter Harness: proposals requested ${REQUESTED_PROPOSALS.join(', ')}; granted ${granted.size ? [...granted].join(', ') : 'none (stable chat parts only)'}`);
+    systemNotifications = granted.has('chatSystemNotification');
+    confirmationResolution = granted.has('chatConfirmationResolution');
     // Explicit workbench support is required: stock confirmation clicks send
     // a new prompt. A missing capability keeps the stable in-turn buttons.
     if (granted.has('chatParticipantAdditions')) {
@@ -770,7 +830,6 @@ export async function activate(context) {
         if (state.activeSession !== connection.id)
             throw new Error('The conversation changed before its history could be saved.');
         connection.persistedHistory = state.history;
-        connection.historyTruncated = state.historyTruncated;
         savedConnections.set(connection.id, connection);
     };
     const connectManaged = async (state = controls.state) => {
@@ -1087,7 +1146,6 @@ export async function activate(context) {
                 throw new Error('The host did not restore the requested conversation.');
             const connection = await connectManaged(state);
             connection.persistedHistory = state.history;
-            connection.historyTruncated = state.historyTruncated;
             savedConnections.set(id, connection);
             if (active !== connection)
                 controlsChanged.fire();
@@ -1347,22 +1405,6 @@ export async function activate(context) {
     // prevents the submit command from reaching session materialization at all.
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.sendRefusal', () => draftChoiceRefusal()
         ?? (controls?.state.setup?.ready === false ? 'Finish setting up your coding agent before sending. Your draft is saved.' : undefined)));
-    // A background task the chat named (sayTasks in runTurnInto), stopped through the harness's own control.
-    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.stopBackgroundTask', async (connectionId, taskId) => {
-        const connection = frontends.get(connectionId);
-        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) => {
@@ -1547,8 +1589,8 @@ export async function activate(context) {
         // never both answer the same request (the second answer would be refused and noted as a failure).
         const answered = answeredRequests.get(connection.id) ?? new Set();
         answeredRequests.set(connection.id, answered);
-        // Requests whose card was not shown because this watch was going to answer them.
-        const unshown = new Set();
+        // Requests whose card an automatic answer that failed or did not settle has drawn again: once each.
+        const redrawn = new Set();
         const answers = (requestId) => {
             if (approval() !== 'autoApprove' || token.isCancellationRequested || !canAnswer(connection))
                 return false;
@@ -1559,7 +1601,6 @@ export async function activate(context) {
             const decisions = acceptedDecisions(pending);
             if (decisions && !decisions.includes('allow'))
                 return false;
-            unshown.add(requestId);
             return true;
         };
         const sweep = () => {
@@ -1572,45 +1613,41 @@ export async function activate(context) {
                 if (decisions && !decisions.includes('allow'))
                     continue;
                 answered.add(pending.id);
-                // Its card is already in the stream (the event that raised it was written first), so say it was answered.
                 const payload = pending.payload && typeof pending.payload === 'object' && !Array.isArray(pending.payload) ? pending.payload : {};
                 const named = [payload.title, payload.tool, payload.tool_name].find((value) => typeof value === 'string');
-                // The answer can settle after the turn's response has closed, when writing to it throws: the note is then dropped.
-                const note = (text) => { try {
-                    stream.markdown(text);
-                }
-                catch {
-                    log.info(text.trim());
-                } };
                 const label = opaqueText(named ?? `request #${pending.id}`, 200);
-                // A card this watch hid is shown when its automatic answer fails or does not settle: a typed reply cannot
-                // reach a running turn, its buttons can. With the response closed, the person is told an approval waits.
+                // An automatic answer that fails or does not settle leaves the approval waiting: its card is drawn (again,
+                // when it was already shown) as the one that still needs an answer, once: the settle timer and a later
+                // failure of the same answer draw it one time between them. With the response closed, writing to it throws,
+                // and the person is told an approval waits.
                 const showCard = () => {
-                    if (!unshown.delete(pending.id) || !connection.session.pendingRequests.has(pending.id))
+                    if (redrawn.has(pending.id) || !connection.session.pendingRequests.has(pending.id))
                         return;
+                    redrawn.add(pending.id);
                     try {
-                        writeProjected(stream, projectPendingRequests([pending], {
+                        const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map() };
+                        for (const part of resolveParts(projectPendingRequests([pending], {
                             connectionId: connection.id,
-                            canRespond: connection.session.descriptor?.actions.respond !== false,
-                        }), granted, { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map() });
+                            canRespond: canAnswer(connection),
+                        }), granted))
+                            writePart(stream, part, state);
                     }
                     catch {
                         void vscode.window.showWarningMessage(`${connection.label}: ${label} is waiting for approval. Open its chat to answer it.`);
                     }
                 };
+                // An approval answered automatically adds no line of its own: Code-OSS's own agent host draws a call its Auto
+                // approve answered as its plain row (`sessionPermissions.ts` `createToolReadyAction`, `confirmed: NotNeeded`).
+                // A card it answered after the card was shown gets its resolution.
                 const unsettled = setTimeout(() => {
-                    note(`\nAuto approve has had no answer for ${label} for ${AUTO_ANSWER_SETTLE_MS / 1000} s. Use the approval buttons to answer.\n`);
+                    log.warn(`Auto approve has had no answer for ${label} for ${AUTO_ANSWER_SETTLE_MS / 1000} s.`);
                     showCard();
                 }, AUTO_ANSWER_SETTLE_MS);
                 void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).then(() => {
                     clearTimeout(unsettled);
-                    // A card that was never shown needs no note: its resolution line says it was allowed.
-                    if (unshown.has(pending.id))
-                        return;
-                    note(`\n_auto-approved: ${label}_\n`);
                 }, error => {
                     clearTimeout(unsettled);
-                    note(`\nApproval failed: ${String(error.message || error)}. Use the approval buttons to answer.\n`);
+                    log.warn(`Auto approve could not answer ${label}: ${String(error.message || error)}`);
                     showCard();
                 });
             }
@@ -1640,8 +1677,10 @@ export async function activate(context) {
         const projection = {
             connectionId: connection.id,
             pendingRequest: (requestId) => connection.session.pendingRequests.get(requestId) ?? connection.session.resolvedRequests.get(requestId),
-            canRespond: connection.session.descriptor?.actions.respond !== false,
+            // (as history: a control appears only where the runtime offers `respond` and this attachment may approve)
+            canRespond: canAnswer(connection),
             plan: connection.plan ??= new PlanTracker(),
+            notices: new Set(),
         };
         const cancellation = token.onCancellationRequested(() => {
             void stopConnection(connection).catch(() => {
@@ -1651,27 +1690,8 @@ export async function activate(context) {
         });
         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);
+        // How the turn ended when it did not succeed: the response's own error, as VS Code's agent host ends one.
+        let outcome;
         let completed = false;
         let turnStarted = false;
         try {
@@ -1680,14 +1700,18 @@ export async function activate(context) {
             // events arrive; no save refusal submits input again or aborts its turn.
             throwIfCancelled();
             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.
+                // A turn the person stopped is marked stopped by VS Code itself; any other end is this response's result.
                 if (event.kind === 'turn_interrupted' && token.isCancellationRequested)
                     return;
                 // Native submit publishes its initial user echo before `turn_started`.
                 // Subsequent input belongs in the response while this turn is visible.
                 if (event.kind === 'turn_started')
                     turnStarted = true;
-                writeProjected(stream, projectEvent(event, { ...projection, liveUserMessages: turnStarted }), granted, state);
+                const ended = turnOutcome(event);
+                if (ended)
+                    outcome = ended;
+                else
+                    writeProjected(stream, projectEvent(event, { ...projection, liveUserMessages: turnStarted }), granted, state);
                 watch.sweep();
                 rememberIdentity(connection);
             }, { throwIfCancelled, onSubmitted: () => {
@@ -1696,7 +1720,6 @@ export async function activate(context) {
             completed = true;
         }
         finally {
-            unwatchTasks();
             watch.dispose();
             cancellation.dispose();
             await finishIdentitySave(connection);
@@ -1707,7 +1730,14 @@ export async function activate(context) {
         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 details = completed && ran && !token.isCancellationRequested ? `${opaqueText(ran, 120)}${effort ? ` · ${opaqueText(effort, 24)}` : ''}` : undefined;
+        // (an interruption is the expected, warning-level error: `isExpectedError` and `level` are
+        // `chatParticipantPrivate`'s, which the ext host checks for `isExpectedError`, so a host without it gets the message)
+        const errorDetails = outcome && (outcome.interrupted && granted.has('chatParticipantPrivate')
+            ? { message: outcome.message, isExpectedError: true, level: 1 /* ChatErrorLevel.Warning */ }
+            : { message: outcome.message });
+        // The model the turn ran on, in VS Code's own response footer rather than as a line of the conversation.
+        return { ...(details ? { details } : {}), ...(errorDetails ? { errorDetails } : {}) };
     };
     const handler = async (request, chatContext, stream, token) => {
         await applying;
@@ -1720,9 +1750,10 @@ export async function activate(context) {
             // thrown as is: the workbench writes a handler's error into the chat
             throw new Error(`${refusal} Nothing was sent; send it again in a new chat.`);
         }
+        // A request the handler cannot run is refused as VS Code refuses one: the request's own error (thrown, which
+        // the workbench writes as the response's errorDetails), not an answer in the transcript.
         if (controls?.state.setup && !controls.state.setup.ready) {
-            stream.markdown('Sign in before sending a message. Use **New Chat: Choose Agent** to get started.');
-            return {};
+            throw new Error('Sign in before sending a message. Use **New Chat: Choose Agent** to get started.');
         }
         const connection = requestedResource
             ? await connectionFor(requestedResource)
@@ -1734,10 +1765,8 @@ export async function activate(context) {
                 throw new Error('This conversation has fixed model settings. Start a new chat to choose different settings; no message was sent.');
             }
         }
-        if (!connection) {
-            stream.markdown(unavailableMarkdown(frontends.unavailable));
-            return {};
-        }
+        if (!connection)
+            throw new Error(unavailableMarkdown(frontends.unavailable));
         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.
@@ -1769,9 +1798,7 @@ export async function activate(context) {
             attached.push({ name: uri.toString(), text: document.getText(location?.range) });
         }
         const prompt = withTextContext(request.prompt, attached);
-        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 } : {};
+        return runTurnInto(connection, prompt, stream, token, approval);
     };
     const participants = [];
     for (const id of granted.has('defaultChatParticipant') ? [PARTICIPANT_ID, DEFAULT_PARTICIPANT_ID] : [PARTICIPANT_ID]) {
@@ -1891,7 +1918,17 @@ export async function activate(context) {
                     return { status: 'cancelled' };
                 response = { ...response, content };
             }
-            await connection.session.respond(response);
+            const key = cardKey(connection.id, answer.requestId);
+            answeredByCard.add(key);
+            if (answeredByCard.size > 500)
+                answeredByCard.delete(answeredByCard.values().next().value);
+            try {
+                await connection.session.respond(response);
+            }
+            catch (error) {
+                answeredByCard.delete(key);
+                throw error;
+            }
             void vscode.window.setStatusBarMessage(`Volter Harness: ${resolutionSentence(response, request, answer.requestId)}`, 4000);
             return { status: 'responded' };
         }
@@ -2223,7 +2260,7 @@ function oneRowPerToolCall(parts) {
  * between tools is markdown, consecutive text joined into one part. A turn
  * looks the same however late the Chat was opened.
  */
-function historyParts(parts) {
+function historyParts(parts, granted) {
     const out = [];
     let text = [];
     const flush = () => {
@@ -2251,6 +2288,18 @@ function historyParts(parts) {
             out.push(hookPart(part));
             continue;
         }
+        // A harness notice is Code-OSS's system notification row in history too, where the host has it.
+        if (part.part === 'notice' && granted.has('chatSystemNotification')) {
+            flush();
+            out.push(new vscode.ChatResponseSystemNotificationPart(part.value, part.icon ? new vscode.ThemeIcon(part.icon) : undefined));
+            continue;
+        }
+        // A warning and the agent's reasoning are VS Code's own parts in history too, where the host granted them.
+        if ((part.part === 'warning' || part.part === 'thinking') && granted.has('chatParticipantAdditions')) {
+            flush();
+            out.push(part.part === 'warning' ? new vscode.ChatResponseWarningPart(part.value) : new vscode.ChatResponseThinkingProgressPart(part.value));
+            continue;
+        }
         const value = historyText(part);
         if (value)
             text.push(value);
@@ -2258,6 +2307,30 @@ function historyParts(parts) {
     flush();
     return out.length ? out : [new vscode.ChatResponseMarkdownPart('')];
 }
+/** How a turn that did not succeed ends its response, as VS Code's agent host ends one (`_getTurnErrorDetails`). */
+function outcomeErrorDetails(outcome, granted) {
+    // (an interruption is the expected, warning-level error: `isExpectedError` and `level` are
+    // `chatParticipantPrivate`'s, which the ext host checks for `isExpectedError`, so a host without it gets the message)
+    return outcome.interrupted && granted.has('chatParticipantPrivate')
+        ? { message: outcome.message, isExpectedError: true, level: 1 /* ChatErrorLevel.Warning */ }
+        : { message: outcome.message };
+}
+/** A conversation that failed, as a history response shows it: the response's own error where the host keeps a saved
+ *  response's result (`chatSessionResponses`), as Code-OSS shows a session that could not be loaded; else VS Code's
+ *  warning part where the host granted it, else the words alone. */
+function failureResponse(message, granted) {
+    if (granted.has('chatSessionResponses'))
+        return { parts: [], result: { errorDetails: { message } } };
+    return { parts: [granted.has('chatParticipantAdditions') ? new vscode.ChatResponseWarningPart(message) : new vscode.ChatResponseMarkdownPart(message)], result: {} };
+}
+/** The request a failure's response answers: the marker turn, which Code-OSS anchors as the system-initiated request
+ *  "Couldn't open session" (`agentHostSessionHandler.ts` `sessionLoadFailedLabel`) where the host keeps that label. */
+function failureRequest(turns, participant, granted) {
+    const request = new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], participant, []);
+    if (granted.has('chatSessionResponses'))
+        request.systemInitiatedLabel = "Couldn't open session";
+    return request;
+}
 /**
  * One text part as the markdown a HISTORY turn carries (tool calls are drawn
  * as tool rows by `historyParts`).
@@ -2266,6 +2339,7 @@ function historyText(part) {
     switch (part.part) {
         case 'markdown':
         case 'progress':
+        case 'notice':
             return part.value;
         case 'warning':
             return `> ⚠ ${part.value}`;
@@ -2285,6 +2359,12 @@ function historyText(part) {
             return `**${part.title}**\n\n${part.message}`;
         case 'questions':
             return `**${part.fallback.title}**\n\n${part.fallback.message}`;
+        case 'resolution':
+            // (a saved card is words, which nothing retires, so its answer is said beneath it)
+            return part.value;
+        case 'unshown':
+            // (`projectReplayTurns` hands these to `unshown`; none reaches a history turn)
+            return '';
     }
 }
 function registerSessions(context, frontends, participant, granted, handler, historyParticipant, controls) {
@@ -2399,10 +2479,11 @@ function registerSessions(context, frontends, participant, granted, handler, his
                     failedResources.set(resource.authority, message);
                     refreshItems();
                 }
+                const failure = failureResponse(message, granted);
                 return {
                     history: [
-                        new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], 'supercode', []),
-                        new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(`**Conversation recovery failed**\n\n${message}`)], {}, 'supercode'),
+                        failureRequest(turns, 'supercode', granted),
+                        new turns.ChatResponseTurn(failure.parts, failure.result, 'supercode'),
                     ],
                     requestHandler: boundHandler,
                 };
@@ -2470,8 +2551,10 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         pendingToolNames.add(name);
                 }
             }
-            // The task list is replayed with the history it was built in, and live turns carry on from it.
+            // The task list is replayed with the history it was built in, and live turns carry on from it; so is the
+            // set of background tasks whose finishing has been drawn.
             const plan = new PlanTracker();
+            const notices = new Set();
             const projected = projectReplayTurns(replay.filter(event => {
                 if (event.kind !== 'request')
                     return true;
@@ -2482,6 +2565,8 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
                 canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
                 plan,
+                notices,
+                unshown: logRecord,
             }, projectHistory(canonicalHistory, granted, pendingToolNames, plan));
             connection.plan = plan;
             const live = connection.session.descriptor?.turn_state === 'busy' || connection.session.pendingRequests.size > 0;
@@ -2489,6 +2574,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
             if (!live)
                 void controls?.finishIdentitySave(connection);
             const activeParts = [];
+            let heldFailure;
             if (live) {
                 // Standalone requests have no user turn. Give their live response
                 // an explicit runtime marker instead of reopening an old answer.
@@ -2509,26 +2595,30 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 // responses can be stale; their command buttons are disabled.
                 const last = projected.at(-1);
                 if (last?.role === 'assistant') {
+                    // (a failure that ended that turn stays held for the live response, as it was in history)
+                    heldFailure = last.errorEvent;
                     activeParts.push(...(projected.pop()?.parts ?? []).map(part => part.part === 'answers' || part.part === 'questions'
                         ? { part: 'markdown', value: `**${(part.part === 'questions' ? part.fallback : part).title}**\n\n${(part.part === 'questions' ? part.fallback : part).message}` }
-                        : part));
+                        // (its card is words here, so its answer is said beneath it)
+                        : part.part === 'resolution' ? { part: 'markdown', value: `\n\n${part.value}\n\n` }
+                            : part));
                 }
             }
-            if (usingSavedHistory && connection.historyTruncated)
-                history.push(new turns.ChatRequestTurn('[Earlier conversation history]', undefined, [], authorId, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart('_Showing the latest 120 saved messages. Earlier context remains in the harness session._')], {}, authorId));
-            if (connection.session.historyEventsDropped > 0)
-                history.push(new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], authorId, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(`_${connection.session.historyEventsDropped} earlier runtime events are outside this display snapshot._`)], {}, authorId));
+            // (saved history and retained events past their bounds are left out without a word, as VS Code's own agent
+            // host shows a transcript its harness truncated)
             for (const turn of projected) {
                 if (turn.role === 'user') {
                     history.push(new turns.ChatRequestTurn(turn.prompt ?? '', undefined, [], authorId, []));
                     continue;
                 }
-                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, authorId));
+                // (a turn that failed keeps its error as the saved response's own, where the host shows one)
+                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? []), granted), turn.error ? { errorDetails: outcomeErrorDetails(turn.error, granted) } : {}, authorId));
             }
             if (connection.session.failure) {
                 // An explicit runtime marker pairs this notice without presenting
                 // it as a person's prompt. The native busy state stays unchanged.
-                history.push(new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], authorId, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(`**Conversation recovery failed**\n\n${opaqueText(connection.session.failure.message, 2048)}`)], {}, authorId));
+                const failure = failureResponse(opaqueText(connection.session.failure.message, 2048), granted);
+                history.push(failureRequest(turns, authorId, granted), new turns.ChatResponseTurn(failure.parts, failure.result, authorId));
             }
             const renderedCursor = connection.session.cursor;
             const pendingAtCursor = [...connection.session.pendingRequests.values()];
@@ -2545,8 +2635,31 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         // answered here under the conversation's mode (t_39dac582): Auto approve answers the cards
                         // 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;
+                        // Where the host keeps a re-joined response's result and answers its questions (`chatSessionResponses`),
+                        // how the turn it ends on did not succeed is that result, as on a turn this window runs, and its
+                        // questions are the carousel. It follows to idle, as it always did, so an earlier turn's failure it
+                        // passes is still drawn, as its warning part.
+                        const results = granted.has('chatSessionResponses');
+                        let failure = results ? heldFailure : undefined;
+                        let result;
+                        // Draws the held failure where it stood, once anything follows it, as history draws one.
+                        let release = () => { };
                         try {
-                            const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map(), quiet: watch?.answers };
+                            const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map(), quiet: watch?.answers,
+                                ...(results ? { carousel: true, pending: (requestId) => connection.session.pendingRequests.has(requestId), cancelled: () => token.isCancellationRequested } : {}) };
+                            const project = (event) => projectEvent(event, {
+                                connectionId: connection.id,
+                                liveUserMessages: true,
+                                plan,
+                                notices,
+                                pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
+                                canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
+                            });
+                            release = () => {
+                                if (failure)
+                                    writeProjected(stream, project(failure), granted, state);
+                                failure = undefined;
+                            };
                             for (const part of oneRowPerToolCall(activeParts))
                                 writePart(stream, part, state);
                             writeProjected(stream, projectPendingRequests(pendingAtCursor.filter(request => connection.session.pendingRequests.has(request.id)), {
@@ -2556,27 +2669,55 @@ function registerSessions(context, frontends, participant, granted, handler, his
                             watch?.sweep();
                             controls?.rememberIdentity(connection);
                             await observeActiveResponse(connection.session, token, (event) => {
-                                writeProjected(stream, projectEvent(event, {
-                                    connectionId: connection.id,
-                                    liveUserMessages: true,
-                                    plan,
-                                    pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
-                                    canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
-                                }), granted, state);
+                                // (a failure the next turn follows is that turn's past: drawn where it stood as soon as the next
+                                // turn starts or anything is drawn after it, so neither a later Stop nor a disconnect makes it
+                                // this response's error)
+                                const terminal = TURN_TERMINAL_KINDS.includes(event.kind);
+                                if (event.kind === 'turn_started' || terminal)
+                                    release();
+                                if (results && terminal) {
+                                    failure = turnOutcome(event) && !token.isCancellationRequested ? event : undefined;
+                                }
+                                else {
+                                    const projected = project(event);
+                                    if (resolveParts(projected, granted).some(part => part.part !== 'unshown'))
+                                        release();
+                                    writeProjected(stream, projected, granted, state);
+                                }
                                 watch?.sweep();
                                 controls?.rememberIdentity(connection);
                             }, () => { connection.viewReady = true; }, renderedCursor);
+                            const outcome = failure && turnOutcome(failure);
+                            if (outcome)
+                                result = { errorDetails: outcomeErrorDetails(outcome, granted) };
                         }
                         catch (error) {
                             if (token.isCancellationRequested || error instanceof vscode.CancellationError)
                                 throw error;
-                            stream.markdown(`\n\n**Conversation stream failed**\n\n${opaqueText(String(error?.message ?? error), 2048)}\n\n`);
+                            // The response's own error is what VS Code shows; a host that does not keep a re-joined
+                            // response's result gets the warning part.
+                            const message = opaqueText(String(error?.message ?? error), 2048);
+                            // (a failure held when the connection drops is drawn; the drop is the result)
+                            if (results) {
+                                try {
+                                    release();
+                                }
+                                catch {
+                                    // (a stream that refuses a part has closed)
+                                }
+                                result = { errorDetails: { message } };
+                            }
+                            else if (granted.has('chatParticipantAdditions'))
+                                stream.warning(message);
+                            else
+                                stream.markdown(`\n\n${message}\n\n`);
                         }
                         finally {
                             connection.viewReady = connection.session.descriptor?.turn_state !== 'busy' && !connection.session.pendingRequests.size;
                             watch?.dispose();
                             await controls?.finishIdentitySave(connection);
                         }
+                        return result;
                     }
                     : undefined,
             };