@volter/supercode-frontend-vscode 0.1.63 → 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, PlanTracker, 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,27 @@ 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
@@ -301,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)
                     }
                 }
             }
@@ -330,6 +351,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,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,
@@ -434,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
@@ -770,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) => {
@@ -1087,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();
@@ -1347,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) => {
@@ -1547,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;
@@ -1559,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 = () => {
@@ -1572,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(), 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 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();
                 });
             }
@@ -1640,8 +1648,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 +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 {
@@ -1680,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: () => {
@@ -1696,7 +1691,6 @@ export async function activate(context) {
             completed = true;
         }
         finally {
-            unwatchTasks();
             watch.dispose();
             cancellation.dispose();
             await finishIdentitySave(connection);
@@ -1707,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;
@@ -1720,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)
@@ -1734,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.
@@ -1769,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]) {
@@ -1891,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' };
         }
@@ -2223,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 = () => {
@@ -2251,6 +2259,12 @@ function historyParts(parts) {
             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);
@@ -2258,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`).
@@ -2285,6 +2304,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) {
@@ -2402,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,
                 };
@@ -2470,8 +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.
+            // 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 +2509,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;
@@ -2511,24 +2540,24 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 if (last?.role === 'assistant') {
                     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));
+                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()];
@@ -2560,6 +2589,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
                                     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);
@@ -2570,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;

package/dist/host-controls.d.ts

@@ -52,7 +52,6 @@ export interface ChatSetupState {
 }
 export interface HostState {
     history?: ChatMessage[];
-    historyTruncated?: boolean;
     activeSession: string | null;
     openSessionCommand?: string;
     /** Automatic ready-session reveal checks the observed native focus through its queued commit. */

package/dist/proposals.js

@@ -27,8 +27,8 @@ export const PROPOSAL_EFFECTS = Object.freeze({
         without: 'the ordinary `@supercode` participant answers; a mention is required',
     },
     chatParticipantPrivate: {
-        grants: 'the dynamic-participant and participant-detection APIs a bundling host can use to route without a mention',
-        without: 'nothing is lost in this package: it registers no dynamic participant and no detection provider',
+        grants: 'the dynamic-participant identity, and an interrupted turn ending with a warning-level, expected error',
+        without: 'a static participant identity; an interrupted turn ends with an ordinary error',
     },
     chatParticipantAdditions: {
         grants: 'tool-invocation, confirmation, warning and codeblock-uri response parts',

package/dist/session.d.ts

@@ -16,9 +16,6 @@ export interface VscodeRuntimeClient {
     steer(prompt: string): Promise<{
         queued: boolean;
     }>;
-    stopTask(taskId: string): Promise<{
-        stopped: boolean;
-    }>;
     interrupt(): Promise<{
         interrupted: boolean;
     }>;
@@ -66,12 +63,6 @@ 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
@@ -87,7 +78,6 @@ export declare class VscodeFrontendSession {
     history: ChatMessage[];
     historyCursor: number;
     historyEvents: FrontendEvent[];
-    historyEventsDropped: number;
     cursor: number;
     /**
      * Every event this attachment has seen, in order — NOT just the last
@@ -99,15 +89,8 @@ 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
-     * could only say "request #1" — it would have lost the very thing it needs to
-     * name. Bounded, because a long session resolves a lot of them.
+     * Requests this attachment has seen resolved, so a resolution can still name what it answered once the pending
+     * entry is gone. Bounded, because a long session resolves a lot of them.
      */
     resolvedRequests: Map<number, FrontendRequest>;
     connection: 'disconnected' | 'connected' | 'closed';
@@ -158,8 +141,6 @@ export declare class VscodeFrontendSession {
     submit(prompt: string, throwIfCancelled?: () => void): 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

@@ -48,7 +48,6 @@ export class VscodeFrontendSession {
     history = [];
     historyCursor = 0;
     historyEvents = [];
-    historyEventsDropped = 0;
     cursor = 0;
     /**
      * Every event this attachment has seen, in order — NOT just the last
@@ -60,15 +59,8 @@ 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
-     * could only say "request #1" — it would have lost the very thing it needs to
-     * name. Bounded, because a long session resolves a lot of them.
+     * Requests this attachment has seen resolved, so a resolution can still name what it answered once the pending
+     * entry is gone. Bounded, because a long session resolves a lot of them.
      */
     resolvedRequests = new Map();
     connection = 'disconnected';
@@ -130,23 +122,12 @@ export class VscodeFrontendSession {
             descriptor: structuredClone(snapshot.descriptor),
             pendingRequests: new Map((authoritative ? snapshot.pending_requests : [...this.pendingRequests.values()])
                 .map(request => [request.id, structuredClone(request)])),
-            backgroundTasks: structuredClone(this.backgroundTasks),
             cursor: authoritative ? recovery.captureCursor : Math.max(this.cursor, snapshot.history_cursor),
         };
         // Validate and project the whole attachment before any observable field
         // moves or a live listener is registered.
         if (authoritative) {
             // Snapshot state is authoritative at capture, before any later events.
-            // Background listings have no separate snapshot field; retain their
-            // latest original event without replaying historical request state.
-            for (const event of recovery.replay) {
-                const payload = (event.payload ?? {});
-                if (event.kind === 'background_tasks' && Array.isArray(payload.tasks)) {
-                    staged.backgroundTasks = payload.tasks
-                        .filter(task => task && typeof task.id === 'string')
-                        .map(task => ({ id: task.id, kind: String(task.kind ?? 'task'), description: String(task.description ?? '') }));
-                }
-            }
             for (const event of recovery.later)
                 this.projectEvent(staged, event);
         }
@@ -197,10 +178,8 @@ export class VscodeFrontendSession {
         this.history = structuredClone(snapshot.history);
         this.historyCursor = snapshot.history_cursor;
         this.historyEvents = structuredClone(snapshot.history_events ?? []);
-        this.historyEventsDropped = snapshot.history_events_dropped ?? 0;
         this.appendTranscript(structuredClone(recovery.replay));
         this.pendingRequests = staged.pendingRequests;
-        this.backgroundTasks = staged.backgroundTasks;
         const previousCursor = this.cursor;
         this.cursor = staged.cursor;
         this.connection = 'connected';
@@ -392,18 +371,12 @@ 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) {
                 this.resolvedRequests.set(payload.request_id, resolved);
-                while (this.resolvedRequests.size > 50) {
+                while (this.resolvedRequests.size > 50)
                     this.resolvedRequests.delete(this.resolvedRequests.keys().next().value);
-                }
             }
             state.pendingRequests.delete(payload.request_id);
         }
@@ -480,11 +453,6 @@ 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))