@volter/supercode-frontend-vscode 0.1.62 → 0.1.64

package/dist/extension.js

@@ -11,7 +11,7 @@ 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, resolveParts, resolutionSentence, typedAnswer, } from './view.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,109 @@ class SupercodeFrontends {
     }
 }
 let nativeInTurnApprovalCards = 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));
+};
+/**
+ * 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
+ * takes the same door as a button's (`supercode.frontend.respond`).
+ */
+function askQuestions(stream, part, pending, cancelled) {
+    const questions = part.questions.map(field => new vscode.ChatQuestion(field.key, field.options.length === 0 ? vscode.ChatQuestionType.Text
+        : field.multiSelect ? vscode.ChatQuestionType.MultiSelect : vscode.ChatQuestionType.SingleSelect, field.title, {
+        ...(field.message ? { message: field.message } : {}),
+        ...(field.options.length ? {
+            options: field.options.map((option, index) => ({ id: `${field.key}-${index}`, label: option.description ? `${option.label} — ${option.description}` : option.label, value: option.label })),
+            allowFreeformInput: true,
+        } : {}),
+    }));
+    const respond = (response) => vscode.commands.executeCommand('supercode.frontend.respond', { connectionId: part.connectionId, requestId: part.requestId, response, label: 'Answer' });
+    void Promise.resolve(stream.questionCarousel(questions, true)).then(answers => {
+        // (the editor also resolves an unanswered carousel when its response ends: a request answered by another door
+        // by then is left alone)
+        // (and a stopped turn: Stop already cancels its requests)
+        if ((pending && !pending(part.requestId)) || cancelled?.())
+            return;
+        const content = {};
+        for (const field of part.questions) {
+            const answer = carouselAnswer(answers?.[field.key]);
+            if (answer !== undefined)
+                content[field.key] = answer;
+        }
+        // Skip, and a carousel submitted with nothing chosen, decline: a question is never answered with nothing.
+        if (Object.keys(content).length === 0)
+            return respond({ kind: 'elicitation', request_id: part.requestId, action: 'decline' });
+        return respond({ kind: 'elicitation', request_id: part.requestId, action: 'accept', content });
+    }, () => undefined);
+}
+/** One carousel answer as the elicitation's value: the text, the selected label (or the person's own words), or the
+ *  selected labels with any words of their own after them. */
+function carouselAnswer(value) {
+    if (typeof value === 'string')
+        return value.trim() || undefined;
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const answer = value;
+    const own = typeof answer.freeformValue === 'string' && answer.freeformValue.trim() ? answer.freeformValue.trim() : undefined;
+    if (Array.isArray(answer.selectedValues)) {
+        const picked = [...answer.selectedValues.filter((item) => typeof item === 'string'), ...(own ? [own] : [])];
+        return picked.length ? picked : undefined;
+    }
+    return typeof answer.selectedValue === 'string' && answer.selectedValue ? answer.selectedValue : own;
+}
+/** VS Code's own hook row: which hook, and what it said — a stop reason where it blocked, a warning otherwise. */
+function hookPart(part) {
+    return part.blocked
+        ? new vscode.ChatResponseHookPart(part.hookType, part.reason || 'The hook gave no reason.')
+        : new vscode.ChatResponseHookPart(part.hookType, undefined, part.reason || 'The hook gave no reason.');
+}
+/**
+ * What a tool row shows inside it, the way VS Code's own rows do, live and in history alike: a plan call is the todo
+ * list as the call left it; a subagent call is the subagent row, with its answer once it has one (none for a subagent
+ * started in the background, whose call returns only a launch notice); a shell call is the terminal block; any other
+ * finished call its input and output. A subagent's own calls are grouped under the call they were made inside.
+ */
+function setToolDetails(invocation, row) {
+    if (row.parentToolCallId)
+        invocation.subAgentInvocationId = row.parentToolCallId;
+    if (row.plan) {
+        invocation.toolSpecificData = { todoList: row.plan.map((item, index) => ({
+                id: index + 1,
+                title: item.title,
+                status: item.status === 'completed' ? vscode.ChatTodoStatus.Completed
+                    : item.status === 'in-progress' ? vscode.ChatTodoStatus.InProgress : vscode.ChatTodoStatus.NotStarted,
+            })) };
+    }
+    else if (row.subagent) {
+        invocation.toolSpecificData = new vscode.ChatSubagentToolInvocationData(row.subagent.description, row.subagent.agentName, row.subagent.prompt, row.isComplete && !row.background ? row.resultText ?? '' : undefined);
+    }
+    else if (row.commandLine) {
+        invocation.toolSpecificData = { commandLine: { original: row.commandLine }, language: 'sh',
+            ...(row.isComplete ? { output: { text: row.resultText ?? '' } } : {}) };
+    }
+    else if (row.isComplete) {
+        invocation.toolSpecificData = { input: row.inputText ?? '', output: row.resultText ?? '' };
+    }
+}
 function writeProjected(stream, projected, granted, state) {
     for (const candidate of projected) {
         const parts = resolveParts([candidate], granted);
@@ -219,7 +322,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)
                     }
                 }
             }
@@ -244,6 +347,16 @@ function writePart(stream, part, state) {
         case 'thinking':
             stream.push(new vscode.ChatResponseThinkingProgressPart(part.value));
             return;
+        case 'hook':
+            stream.push(hookPart(part));
+            return;
+        case 'questions':
+            drew(stream, part.requestId);
+            if (state.carousel)
+                askQuestions(stream, part, state.pending, state.cancelled);
+            else
+                writePart(stream, part.fallback, state);
+            return;
         case 'reference': {
             // Only a path the runtime's own payload named, resolved against the
             // workspace this window already has. Nothing is created or fabricated.
@@ -254,9 +367,18 @@ 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;
+            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,
@@ -299,17 +421,22 @@ function writePart(stream, part, state) {
                 invocation.isError = part.isError;
             if (part.inputText !== undefined)
                 state.toolInputs.set(part.toolCallId, part.inputText);
-            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 ?? '',
-                };
+            if (part.plan || part.subagent || part.parentToolCallId || part.background) {
+                const kept = state.toolKinds.get(part.toolCallId) ?? {};
+                state.toolKinds.set(part.toolCallId, {
+                    ...kept,
+                    ...(part.plan ? { plan: part.plan } : {}),
+                    ...(part.subagent ? { subagent: part.subagent } : {}),
+                    ...(part.parentToolCallId ? { parentToolCallId: part.parentToolCallId } : {}),
+                    ...(part.background ? { background: true } : {}),
+                });
             }
+            setToolDetails(invocation, {
+                ...part,
+                ...state.toolKinds.get(part.toolCallId),
+                commandLine,
+                inputText: state.toolInputs.get(part.toolCallId),
+            });
             stream.push(invocation);
             return;
         }
@@ -338,6 +465,7 @@ 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
@@ -674,7 +802,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) => {
@@ -991,7 +1118,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();
@@ -1251,22 +1377,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) => {
@@ -1451,8 +1561,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;
@@ -1463,7 +1573,6 @@ export async function activate(context) {
             const decisions = acceptedDecisions(pending);
             if (decisions && !decisions.includes('allow'))
                 return false;
-            unshown.add(requestId);
             return true;
         };
         const sweep = () => {
@@ -1476,45 +1585,40 @@ 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() });
+                            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 says "Auto approved" on the call's row,
+                // which the extension API cannot), and a card it answered after the card was shown gets its resolution line.
                 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();
                 });
             }
@@ -1538,11 +1642,16 @@ 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(), toolTitles: new Map(), toolCommands: new Map() };
+        const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map(),
+            carousel: true, pending: (requestId) => connection.session.pendingRequests.has(requestId),
+            cancelled: () => token.isCancellationRequested };
         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(() => {
@@ -1552,27 +1661,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 {
@@ -1581,14 +1671,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: () => {
@@ -1597,7 +1691,6 @@ export async function activate(context) {
             completed = true;
         }
         finally {
-            unwatchTasks();
             watch.dispose();
             cancellation.dispose();
             await finishIdentitySave(connection);
@@ -1608,7 +1701,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;
@@ -1621,9 +1721,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)
@@ -1635,10 +1736,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.
@@ -1670,9 +1769,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]) {
@@ -1792,7 +1889,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' };
         }
@@ -2124,7 +2231,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 = () => {
@@ -2143,15 +2250,21 @@ function historyParts(parts) {
             invocation.isComplete = part.isComplete;
             if (part.isError !== undefined)
                 invocation.isError = part.isError;
-            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 ?? '' };
-            }
+            setToolDetails(invocation, part);
             out.push(invocation);
             continue;
         }
+        if (part.part === 'hook') {
+            flush();
+            out.push(hookPart(part));
+            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);
@@ -2159,6 +2272,11 @@ function historyParts(parts) {
     flush();
     return out.length ? out : [new vscode.ChatResponseMarkdownPart('')];
 }
+/** A conversation that failed, as a history response shows it: VS Code's warning part where the host granted it (the
+ *  extension API does not carry a history response's own error), else the words alone. */
+function failurePart(message, granted) {
+    return granted.has('chatParticipantAdditions') ? new vscode.ChatResponseWarningPart(message) : new vscode.ChatResponseMarkdownPart(message);
+}
 /**
  * One text part as the markdown a HISTORY turn carries (tool calls are drawn
  * as tool rows by `historyParts`).
@@ -2172,6 +2290,9 @@ function historyText(part) {
             return `> ⚠ ${part.value}`;
         case 'thinking':
             return `> ${part.value}`;
+        case 'hook':
+            // Drawn as VS Code's own hook row by `historyParts`.
+            return '';
         case 'codeblock':
             return part.value;
         case 'reference':
@@ -2181,6 +2302,14 @@ function historyText(part) {
             return '';
         case 'answers':
             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) {
@@ -2298,7 +2427,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 return {
                     history: [
                         new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], 'supercode', []),
-                        new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(`**Conversation recovery failed**\n\n${message}`)], {}, 'supercode'),
+                        new turns.ChatResponseTurn([failurePart(message, granted)], {}, 'supercode'),
                     ],
                     requestHandler: boundHandler,
                 };
@@ -2366,6 +2495,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; 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;
@@ -2375,7 +2508,11 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 connectionId: connection.id,
                 pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
                 canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
-            }, projectHistory(canonicalHistory, granted, pendingToolNames));
+                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;
             controls?.rememberIdentity(connection);
             if (!live)
@@ -2401,26 +2538,26 @@ 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') {
-                    activeParts.push(...(projected.pop()?.parts ?? []).map(part => part.part === 'answers'
-                        ? { part: 'markdown', value: `**${part.title}**\n\n${part.message}` }
-                        : part));
+                    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}` }
+                        // (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));
+                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? []), 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));
+                history.push(new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], authorId, []), new turns.ChatResponseTurn([failurePart(opaqueText(connection.session.failure.message, 2048), granted)], {}, authorId));
             }
             const renderedCursor = connection.session.cursor;
             const pendingAtCursor = [...connection.session.pendingRequests.values()];
@@ -2438,7 +2575,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(), toolTitles: new Map(), toolCommands: 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 };
                             for (const part of oneRowPerToolCall(activeParts))
                                 writePart(stream, part, state);
                             writeProjected(stream, projectPendingRequests(pendingAtCursor.filter(request => connection.session.pendingRequests.has(request.id)), {
@@ -2451,6 +2588,8 @@ function registerSessions(context, frontends, participant, granted, handler, his
                                 writeProjected(stream, 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')),
                                 }), granted, state);
@@ -2461,7 +2600,13 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         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, and a re-joined response cannot set one (the
+                            // ext host ignores what `activeResponseCallback` returns), so it is the warning part.
+                            const message = opaqueText(String(error?.message ?? error), 2048);
+                            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;