@volter/supercode-frontend-vscode 0.1.63 → 0.1.65

package/dist/view.js

@@ -137,6 +137,11 @@ export function toolTitles(toolName, argumentsText) {
         const command = field('command', 'cmd');
         return command ? both(`Running ${code(command)}`, `Ran ${code(command)}`) : both(`Running a command`, `Ran a command`);
     }
+    // Code-OSS's own Claude host's words for the shell's output and stop rows (`claudeToolDisplay.ts`).
+    if (name === 'bashoutput')
+        return both('Reading shell output', 'Read shell output');
+    if (name === 'killbash')
+        return both('Kill shell command', 'Kill shell command');
     if (name === 'read' && file) {
         const offset = typeof fields.offset === 'number' ? fields.offset : undefined;
         const limit = typeof fields.limit === 'number' ? fields.limit : undefined;
@@ -354,9 +359,18 @@ export function subagentCall(toolName, argumentsText) {
     const prompt = field('prompt', VSCODE_CHAT_LIMITS.partCharacters);
     return { ...(description ? { description } : {}), ...(agentName ? { agentName } : {}), ...(prompt ? { prompt } : {}) };
 }
-/** The command line of a shell tool call, read from its own arguments; undefined for any other tool. */
+/**
+ * The command line of a shell tool call, read from its own arguments; undefined for any other tool. Claude Code's
+ * BashOutput and KillBash are terminal rows too, as Code-OSS's own Claude host draws them (`claudeToolDisplay.ts`
+ * `TOOL_ROWS`): their command line is their `command`, else their input (`getClaudeToolInputString`).
+ */
 export function shellCommand(toolName, argumentsText) {
-    if (!['bash', 'shell', 'exec_command', 'local_shell', 'powershell'].includes(toolName.toLowerCase()))
+    const name = toolName.toLowerCase();
+    if (name === 'bashoutput' || name === 'killbash') {
+        const command = argumentFields(argumentsText).command;
+        return stripControls(typeof command === 'string' && command.trim() ? command : parseArguments(argumentsText)) || undefined;
+    }
+    if (!['bash', 'shell', 'exec_command', 'local_shell', 'powershell'].includes(name))
         return undefined;
     try {
         const fields = JSON.parse(argumentsText);
@@ -644,6 +658,24 @@ export function requestSubject(request) {
         return clamp(stripControls(subject), 120);
     return undefined;
 }
+/** The words an error event states (`message`, else `error` or `reason`), bounded; '' when it states none. */
+function errorMessage(payload) {
+    const said = [payload.message, payload.error, payload.reason].find((value) => typeof value === 'string' && value.trim() !== '');
+    return said ? clamp(stripControls(said.trim()), VSCODE_CHAT_LIMITS.partCharacters) : '';
+}
+/**
+ * How a turn that did not succeed ends the response its request handler runs, as VS Code's own agent host ends one
+ * (`agentHostSessionHandler.ts` `_getTurnErrorDetails`): a failed turn is the response's error, an interrupted one its
+ * warning-level, expected error. Undefined for any other event.
+ */
+export function turnOutcome(event) {
+    const payload = payloadOf(event);
+    if (event.kind === 'turn_interrupted')
+        return { message: errorMessage(payload) || 'Turn interrupted.', interrupted: true };
+    if (event.kind === 'turn_failed')
+        return { message: errorMessage(payload) || 'Turn failed.', interrupted: false };
+    return undefined;
+}
 /** Pending requests belong to the live runtime, even when saved transcript
  * history predates them. Rehydrate their controls before waiting for new events. */
 export function projectPendingRequests(requests, context) {
@@ -669,9 +701,11 @@ export function projectEvent(event, context) {
             // (a subagent's own input, `parent_id`: what it was asked is on its row)
             if (text(payload.parent_id))
                 return [];
+            // A harness record (a background task's notification, an interruption) is Code-OSS's system notification row
+            // (`noticeLine`).
             const notice = notPersonNotice(payload);
             if (notice !== undefined)
-                return notice ? [stable({ part: 'markdown', value: `\n\n${notice}\n\n` })] : [];
+                return notice && firstNotice(context, notifiedCall(payload)) ? [stable(noticeLine(notice))] : [];
             if (context.liveUserMessages) {
                 const body = text(payload.text);
                 const prefix = '\n\n**Additional input**\n\n';
@@ -793,11 +827,9 @@ export function projectEvent(event, context) {
         // crates/harness/src/server.rs `FrontendRequestBroker::publish`.
         case 'request': {
             const request = (payload.request ?? payload);
+            // (a request with no id cannot be answered, so it is a malformed record, not conversation)
             if (!request || typeof request.id !== 'number') {
-                return [stable({
-                        part: 'markdown',
-                        value: `**supercode** · malformed request event\n\n${fence(opaqueText(event.payload), 'json')}`,
-                    })];
+                return [stable({ part: 'unshown', value: `malformed request event #${event.sequence}: ${opaqueText(event.payload)}` })];
             }
             const summary = requestSummary(request);
             const answers = requestAnswers(request, context.connectionId);
@@ -810,19 +842,22 @@ export function projectEvent(event, context) {
             // The host capability decides whether these original answers can use
             // a native in-turn confirmation card. Stock confirmation clicks start a
             // new chat request, so stable command buttons remain the fallback.
-            if (context.canRespond === false || (request.payload && typeof request.payload === 'object' && !Array.isArray(request.payload) && request.payload.observe_only === true)) {
-                return [stable({
-                        part: 'markdown',
-                        value: `\n\n**${title}**\n\n${summary}\n\n_This runtime answers its own requests; Volter Harness is observing._\n\n`,
-                    })];
-            }
             const buttons = {
                 part: 'answers',
+                connectionId: context.connectionId,
+                requestId: request.id,
                 approval: request.kind === 'approval',
                 title: clamp(title, VSCODE_CHAT_LIMITS.titleCharacters),
                 message: summary,
                 answers,
             };
+            // A request this window cannot answer (another client, the runtime's owner, answers it) is still drawn: its
+            // title and summary, without controls. Code-OSS has no read-only confirmation; it draws another client's call
+            // as its row, "Running {0} on another client…", with a cancel action (`stateToProgressAdapter.ts`
+            // `toolCallStateToInvocation`), which the extension API cannot draw.
+            if (context.canRespond === false || (request.payload && typeof request.payload === 'object' && !Array.isArray(request.payload) && request.payload.observe_only === true)) {
+                return [stable({ ...buttons, answers: [] })];
+            }
             // A harness's questions: VS Code's own carousel, answered inside the running turn.
             if (asked) {
                 return [{
@@ -833,16 +868,15 @@ export function projectEvent(event, context) {
             }
             return [stable(buttons)];
         }
-        // crates/harness/src/server.rs `FrontendRequestBroker::respond`.
+        // crates/harness/src/server.rs `FrontendRequestBroker::respond`. A card answered through itself shows what was
+        // chosen (`chatConfirmationContentPart`, `chatQuestionCarouselPart`). One answered any other way (another window,
+        // Auto approve, a typed reply) cannot be retired through the extension API, so its answer is said beneath it, once,
+        // as one plain line; the writer decides which (`resolution`).
         case 'request_resolved': {
             const requestId = typeof payload.request_id === 'number' ? payload.request_id : Number.NaN;
             const response = payload.response;
-            // An allowed approval says nothing more, as in VS Code's own chat: its tool row carries on and is the record.
-            // A denial, and an answer to any other request, is said once.
-            if (response?.kind === 'approval' && response.decision !== 'deny')
-                return [];
-            const sentence = resolutionSentence(response, context.pendingRequest?.(requestId), requestId);
-            return [stable({ part: 'markdown', value: `\n\n_${sentence}_\n\n` })];
+            const value = plain(resolutionSentence(response, context.pendingRequest?.(requestId), requestId));
+            return [stable({ part: 'resolution', connectionId: context.connectionId, requestId, value })];
         }
         // crates/runtime/src/event.rs `AgentEvent::CacheWarning`.
         case 'cache_warning': {
@@ -872,23 +906,25 @@ export function projectEvent(event, context) {
         // Token counts are not conversation: VS Code's own chat keeps them out of the transcript.
         case 'usage':
             return [];
-        // The harness's background tasks are the session's state (`session.ts` lists them while a turn runs, each with
-        // its Stop), not conversation.
+        // A harness's listing of its background tasks is not conversation: Code-OSS's own Claude host draws a background
+        // command as its call's terminal row, and BashOutput and KillBash as rows of their own (`claudeToolDisplay.ts`).
+        // Current Claude Code stops a task with TaskStop, an ordinary row there and here.
         case 'background_tasks':
             return [];
-        // crates/runtime/src/event.rs `AgentEvent::BackgroundOutput`.
-        case 'background_output': {
-            const chunk = fence(clamp(stripControls(text(payload.chunk)), VSCODE_CHAT_LIMITS.partCharacters));
-            const truncated = payload.truncated === true ? '\n\n_the runtime stopped retaining this job’s output_' : '';
-            return [stable({
-                    part: 'markdown',
-                    value: `\n\n**background job ${text(payload.job_id)}**\n\n${chunk}${truncated}\n\n`,
-                })];
+        // sdk/interchange/agent-background.mjs `status`: the output a `background_status` call drained, which that call's
+        // own result also carries (`output`, `output_truncated`). It is that row's output, as a VS Code background
+        // terminal's output is its own row's, and nothing more in the transcript.
+        case 'background_output':
+            return [];
+        // crates/harness/src/server.rs `submit_claimed`. VS Code's own agent host draws an interrupted turn as its
+        // response's warning-level error (`agentHostSessionHandler.ts` `_getTurnErrorDetails`, `executionInterrupted`):
+        // the handler's turn returns it as its result (`turnOutcome`), and so do a re-joined response and a saved one
+        // where the host keeps their result (`chatSessionResponses`); elsewhere they show its warning part. The live
+        // writer drops it when the person stopped the turn (VS Code marks a stopped response itself).
+        case 'turn_interrupted': {
+            const value = turnOutcome(event).message;
+            return [{ emit: { part: 'warning', value }, needs: 'chatParticipantAdditions', fallback: [{ part: 'markdown', value }] }];
         }
-        // crates/harness/src/server.rs `submit_claimed`.
-        // The live writer drops it when the person stopped the turn (VS Code marks a stopped response itself).
-        case 'turn_interrupted':
-            return [stable({ part: 'warning', value: 'The turn was interrupted.' })];
         // crates/harness/src/server.rs `submit_claimed` emits `turn_failed`. The
         // other four are the error kinds the donor-neutral reader in
         // sdk/interchange/frontend-transcript.mjs treats identically:
@@ -897,31 +933,41 @@ export function projectEvent(event, context) {
         // `runtime_disconnected`, which a frontend synthesizes for itself
         // (sdk/interchange/frontend-app.mjs). `stream_error` has no producer in this
         // repository and is read only because that reader reads it.
+        //
+        // A failed turn is VS Code's own request error (`ChatResult.errorDetails`) on the turn the handler runs
+        // (`turnOutcome`), and on a re-joined or saved response where the host keeps their result (`chatSessionResponses`);
+        // elsewhere it is the warning part. The error's own words, as VS Code's agent host shows a turn's error, never
+        // the event kind's name.
         case 'turn_failed':
         case 'stream_error':
         case 'transport_error':
         case 'watch_error':
         case 'runtime_disconnected': {
-            const message = typeof payload.message === 'string' ? payload.message : opaqueText(event.payload);
-            const value = `${event.kind.replaceAll('_', ' ')}: ${clamp(stripControls(message), VSCODE_CHAT_LIMITS.partCharacters)}`;
+            const value = turnOutcome(event)?.message ?? errorMessage(payload);
+            if (!value)
+                return [];
             return [{
                     emit: { part: 'warning', value },
                     needs: 'chatParticipantAdditions',
                     fallback: [{ part: 'markdown', value: `> ⚠ ${value}` }],
                 }];
         }
-        // Declared by the runtime descriptor's `display.event_kinds`
-        // (crates/harness/src/server.rs `frontend_descriptor`); read here the way
-        // sdk/interchange/frontend-transcript.mjs reads them.
-        case 'scheduled_prompt_started':
+        // Declared by the runtime descriptor's `display.event_kinds` (`agent-runtime-host.mjs` `displayKinds`); nothing
+        // in this repository produces them, so their payload is read for the words it states and never shown as JSON.
+        // A scheduled prompt is a turn the runtime starts itself: its start is a labelled line naming the prompt, its
+        // deferral and completion are lifecycle like `turn_started` / `turn_completed`, and an error is a warning.
+        case 'scheduled_prompt_started': {
+            const value = clamp(stripControls(text(payload.prompt ?? payload.name ?? payload.message)), VSCODE_CHAT_LIMITS.titleCharacters);
+            // (labelled, so the runtime's prompt is not read as the agent's words)
+            return value ? [stable(noticeLine(`Scheduled prompt: ${value}`))] : [];
+        }
         case 'scheduled_prompt_deferred':
         case 'scheduled_prompt_completed':
-            return [stable({
-                    part: 'progress',
-                    value: `${event.kind.replaceAll('_', ' ')} · ${opaqueText(event.payload, 256)}`,
-                })];
+            return [];
         case 'scheduler_error': {
-            const value = `scheduler error: ${opaqueText(event.payload, 256)}`;
+            const value = errorMessage(payload);
+            if (!value)
+                return [];
             return [{
                     emit: { part: 'warning', value },
                     needs: 'chatParticipantAdditions',
@@ -933,18 +979,23 @@ export function projectEvent(event, context) {
         case 'native_event':
             return [];
         case 'status':
-            // A subagent's task finishing (`call_id` names the subagent call): its answer belongs to that call's row (or to
-            // the agent's reply, for a subagent started in the background), so the notice is its first line, and the task's
-            // output file where it names one (a background shell's notice names the same call).
+            // A background task's notification (`call_id` names the call that started it): a harness record, drawn as the
+            // `user_message` notices are (`noticeLine`), since a progress part would be hidden by whatever follows. Its
+            // answer belongs to that call's row (or to the agent's reply, for a subagent started in the background), so the
+            // notice is its first line, and the task's output file where it names one.
             if (text(payload.call_id)) {
+                if (!firstNotice(context, text(payload.call_id)))
+                    return [];
                 const lines = stripControls(text(payload.message)).split('\n');
                 const output = lines.find(line => line.startsWith('Output: ') && line.length > 8);
-                const line = [clamp((lines[0] ?? '').trim(), VSCODE_CHAT_LIMITS.titleCharacters), output].filter(Boolean).join('\n');
-                return line ? [stable({ part: 'progress', value: clamp(line, VSCODE_CHAT_LIMITS.partCharacters) })] : [];
+                const line = [clamp((lines[0] ?? '').trim(), VSCODE_CHAT_LIMITS.titleCharacters), output].filter(Boolean).join('\n\n');
+                return line ? [stable(noticeLine(clamp(line, VSCODE_CHAT_LIMITS.partCharacters)))] : [];
             }
             return [stable({ part: 'progress', value: clamp(stripControls(text(payload.message)), VSCODE_CHAT_LIMITS.partCharacters) })];
-        case 'warning':
-            return [stable({ part: 'warning', value: clamp(stripControls(text(payload.message)), VSCODE_CHAT_LIMITS.partCharacters) })];
+        case 'warning': {
+            const value = clamp(stripControls(text(payload.message)), VSCODE_CHAT_LIMITS.partCharacters);
+            return [{ emit: { part: 'warning', value }, needs: 'chatParticipantAdditions', fallback: [{ part: 'markdown', value: `> ⚠ ${value}` }] }];
+        }
         // Not in this runtime's declared set; read the way
         // sdk/interchange/frontend-transcript.mjs reads a donor that emits them.
         case 'reasoning':
@@ -959,17 +1010,11 @@ export function projectEvent(event, context) {
                     fallback: [{ part: 'markdown', value: `\n\n> ${body.replaceAll('\n', '\n> ')}\n\n` }],
                 }];
         }
-        // The contract says every kind but `request` is opaque JSON by design, so a
-        // kind this version does not know is rendered bounded, never dropped.
+        // A kind this version does not know is a protocol record, not conversation, like `native_event` above: VS Code's
+        // own chat shows none (its agent host drops a record it does not map). It goes to the output channel; the
+        // runtime's history keeps it.
         default:
-            // The surrounding blank lines are load-bearing: a fenced block that the
-            // next streamed delta lands against on the same line never closes, and
-            // it swallows everything after it — observed doing exactly that to an
-            // approval request.
-            return [stable({
-                    part: 'markdown',
-                    value: `\n\n_supercode event \`${clamp(event.kind, VSCODE_CHAT_LIMITS.titleCharacters)}\` is not displayable by this frontend version_\n\n${fence(opaqueText(event.payload), 'json')}\n\n`,
-                })];
+            return [stable({ part: 'unshown', value: `event kind ${clamp(event.kind, VSCODE_CHAT_LIMITS.titleCharacters)} #${event.sequence} is not displayed: ${opaqueText(event.payload)}` })];
     }
 }
 /** Replace every part whose proposal the host did not grant with its fallback. */
@@ -984,10 +1029,11 @@ export function resolveParts(parts, granted) {
     return resolved;
 }
 /**
- * The prompt of the marker turn that carries runtime history with no user turn
- * of its own. It names itself; nothing here is presented as a person's words.
+ * The prompt of the marker turn that carries runtime history with no user turn of its own: VS Code's own words for a
+ * turn whose request is not in the transcript (`claudeReplayMapper.ts` `missingPromptPlaceholder`), so nothing is
+ * presented as a person's words.
  */
-export const HISTORY_MARKER_PROMPT = '⟨supercode runtime history⟩';
+export const HISTORY_MARKER_PROMPT = 'Message content could not be retrieved';
 function messageText(message) {
     const content = message.content;
     if (typeof content === 'string')
@@ -1012,21 +1058,55 @@ function messageText(message) {
 }
 /**
  * What a `user_message` shows when no person typed it: undefined for the person's words, '' to show nothing, else a
- * short notice. The harness's own records carry `source: 'harness'` (and a `notice` where one is shown) from the one
+ * short notice, plain text drawn as a notice row (`noticeLine`). The harness's own records carry `source: 'harness'` (and a `notice` where one is shown) from the one
  * provenance rule the runtime applies (`@volter/supercode-interchange/user-provenance`). The editor's automatic
  * tripwire nudge travels through the person's input door, so the editor's frame is what names it.
  */
 function notPersonNotice(payload) {
     if (payload.source === 'harness')
-        return noticeMarkdown(text(payload.notice));
+        return noticeText(text(payload.notice));
     if (editorNudge(text(payload.text)))
         return '';
     return undefined;
 }
-/** The rule's plain notice as this view's italic line; '' for none. */
-function noticeMarkdown(notice) {
-    const value = clamp(stripControls(notice ?? ''), VSCODE_CHAT_LIMITS.partCharacters - 2);
-    return value ? `_${value}_` : '';
+/**
+ * A notice as a row of the transcript: its own words, plain, as Code-OSS's system notification row
+ * (`stateToProgressAdapter.ts` `systemNotificationToChatPart`). Not a progress part: Code-OSS hides a progress message
+ * as soon as any other part follows it (`chatProgressContentPart.ts`), so the notice would never be seen.
+ */
+function noticeLine(notice) {
+    const icon = noticeIcon(notice);
+    return { part: 'notice', value: plain(notice), ...(icon ? { icon } : {}) };
+}
+/**
+ * The icon of a notice that reports no completion. Code-OSS's agent host picks one per notification kind
+ * (`stateToProgressAdapter.ts` `systemNotificationToChatPart`), with the completion check as its default; `warning` here
+ * follows, by analogy, the one it gives an automatic-approval review that was interrupted. None for the others.
+ */
+function noticeIcon(notice) {
+    // (by analogy: upstream draws no harness interruption or failed background task as a notification of its own)
+    if (notice === 'Turn interrupted.')
+        return 'warning';
+    if (/^Background task (failed|killed|stopped|cancell?ed|error)\b/i.test(notice))
+        return 'warning';
+    return undefined;
+}
+/** The call a background task's notification record names (`<tool-use-id>`), for `firstNotice`. */
+function notifiedCall(payload) {
+    return /<tool-use-id>([^<]+)<\/tool-use-id>/.exec(text(payload.text))?.[1]?.trim() ?? '';
+}
+/** Whether this is the first notification of `call`'s task in this stream (always, for one that names no call). */
+function firstNotice(context, call) {
+    if (!call || !context.notices)
+        return true;
+    if (context.notices.has(call))
+        return false;
+    context.notices.add(call);
+    return true;
+}
+/** The rule's plain notice, bounded; '' for none. */
+function noticeText(notice) {
+    return clamp(stripControls(notice ?? ''), VSCODE_CHAT_LIMITS.titleCharacters);
 }
 function editorNudge(body) {
     return body.trimStart().startsWith('[Volter editor tripwire');
@@ -1037,6 +1117,18 @@ export function projectReplayTurns(events, granted, context, history = []) {
     // Before the replay supplies a prompt, give its parts their own runtime
     // history turn rather than attributing old approvals to the latest answer.
     const turns = history.map(turn => ({ ...turn, parts: turn.parts?.slice() }));
+    // A reopened chat names what each answer answered from the replay's own requests first: the session's maps hold
+    // only what is pending now and the latest few resolved.
+    const requests = new Map();
+    for (const event of events) {
+        if (event.kind !== 'request')
+            continue;
+        const request = (payloadOf(event).request ?? payloadOf(event));
+        if (typeof request?.id === 'number')
+            requests.set(request.id, request);
+    }
+    const known = context.pendingRequest;
+    context = { ...context, notices: context.notices ?? new Set(), pendingRequest: (id) => requests.get(id) ?? known?.(id) };
     // An approval the replay shows allowed is not drawn again: live, its card is hidden (Auto approve) or answered,
     // and its allowed resolution says nothing more, so the tool row is the record (`request_resolved` above).
     const allowed = new Set();
@@ -1050,28 +1142,43 @@ export function projectReplayTurns(events, granted, context, history = []) {
     }
     let replayTurn = false;
     let streamedText;
+    // A saved failure is its response's error only while nothing follows it: the next turn's start, or anything drawn
+    // after it in that response, turns it back into its warning part where it stood, so an error never shows after a
+    // later turn's content and a second failure never replaces the first. A re-joined response follows the same rule.
+    const append = (turn, ...parts) => {
+        const failed = turn.errorEvent;
+        if (failed) {
+            turn.error = undefined;
+            turn.errorEvent = undefined;
+            turn.parts.push(...resolveParts(projectEvent(failed, context), granted));
+        }
+        turn.parts.push(...parts);
+    };
     for (const event of events) {
         if (event.kind === 'request') {
             const request = (payloadOf(event).request ?? payloadOf(event));
             if (typeof request?.id === 'number' && allowed.has(request.id))
                 continue;
         }
+        // (nor is its answer, which would answer a card that is not there)
+        if (event.kind === 'request_resolved' && allowed.has(payloadOf(event).request_id))
+            continue;
         // (a subagent's own input is no turn of the conversation; `projectEvent` draws nothing for it)
         if (event.kind === 'user_message' && !text(payloadOf(event).parent_id)) {
             streamedText = undefined;
             const payload = payloadOf(event);
             const shown = notPersonNotice(payload);
             if (shown !== undefined) {
-                if (!shown)
+                if (!shown || !firstNotice(context, notifiedCall(payload)))
                     continue;
                 if (!replayTurn) {
                     turns.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
                     replayTurn = true;
                 }
                 const last = turns[turns.length - 1];
-                const notice = { part: 'markdown', value: `\n\n${shown}\n\n` };
+                const notice = noticeLine(shown);
                 if (last.role === 'assistant' && last.parts)
-                    last.parts.push(notice);
+                    append(last, notice);
                 else
                     turns.push({ role: 'assistant', parts: [notice] });
                 continue;
@@ -1080,7 +1187,38 @@ export function projectReplayTurns(events, granted, context, history = []) {
             replayTurn = true;
             continue;
         }
-        const parts = resolveParts(projectEvent(event, context), granted);
+        // A turn that failed or was interrupted is its saved response's own error, where the host shows one.
+        const outcome = granted.has('chatSessionResponses') ? turnOutcome(event) : undefined;
+        if (outcome) {
+            streamedText = undefined;
+            if (!replayTurn) {
+                turns.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+                replayTurn = true;
+            }
+            const last = turns[turns.length - 1];
+            if (last.role === 'assistant') {
+                append(last);
+                last.error = outcome;
+                last.errorEvent = event;
+            }
+            else {
+                turns.push({ role: 'assistant', parts: [], error: outcome, errorEvent: event });
+            }
+            continue;
+        }
+        // (the next turn's start ends the last failure's hold, as on a re-joined response)
+        if (event.kind === 'turn_started') {
+            const last = turns[turns.length - 1];
+            if (last?.role === 'assistant' && last.errorEvent)
+                append(last);
+        }
+        // (a record that is not conversation is no part of a turn: it goes to `unshown`, wherever it falls)
+        const parts = resolveParts(projectEvent(event, context), granted).filter(part => {
+            if (part.part !== 'unshown')
+                return true;
+            context.unshown?.(part.value);
+            return false;
+        });
         if (parts.length === 0)
             continue;
         if (event.kind === 'text_delta' && parts[0]?.part === 'markdown') {
@@ -1099,23 +1237,24 @@ export function projectReplayTurns(events, granted, context, history = []) {
         }
         const last = turns[turns.length - 1];
         if (last.role === 'assistant' && last.parts)
-            last.parts.push(...parts);
+            append(last, ...parts);
         else
             turns.push({ role: 'assistant', parts });
     }
-    if (turns.length > VSCODE_CHAT_LIMITS.historyTurns) {
-        const omitted = turns.length - VSCODE_CHAT_LIMITS.historyTurns;
-        const kept = turns.slice(-VSCODE_CHAT_LIMITS.historyTurns);
-        kept.unshift({
-            role: 'assistant',
-            parts: [{
-                    part: 'markdown',
-                    value: `_${omitted} earlier turns are omitted by this view’s bound; the runtime’s own history is unchanged and authoritative._`,
-                }],
-        });
-        return kept;
-    }
-    return turns;
+    return boundTurns(turns);
+}
+/**
+ * The latest `historyTurns` turns. The earlier ones are left out without a word, as VS Code's own agent host shows a
+ * transcript its harness truncated; a response the cut leaves without its request gets the marker request, as that
+ * host gives one its missing-prompt placeholder (`claudeReplayMapper.ts` `missingPromptPlaceholder`).
+ */
+function boundTurns(turns) {
+    if (turns.length <= VSCODE_CHAT_LIMITS.historyTurns)
+        return turns;
+    const kept = turns.slice(-VSCODE_CHAT_LIMITS.historyTurns);
+    if (kept[0]?.role === 'assistant')
+        kept.unshift({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+    return kept;
 }
 /**
  * The attach snapshot's canonical history as chat turns. Bounded: when older
@@ -1174,9 +1313,9 @@ export function projectHistory(history, granted, pendingToolNames = new Set(), p
             // interruption record are not the person's words.
             const provenance = userProvenance(message.metadata, body);
             if (provenance.source === 'harness' || editorNudge(body)) {
-                const notice = noticeMarkdown(provenance.notice);
+                const notice = noticeText(provenance.notice);
                 if (notice)
-                    pushAssistant([{ part: 'markdown', value: `\n\n${notice}\n\n` }]);
+                    pushAssistant([noticeLine(notice)]);
                 continue;
             }
             toolRows.clear();
@@ -1236,13 +1375,10 @@ export function projectHistory(history, granted, pendingToolNames = new Set(), p
         // interruption. Only the final matching tool is affected, never old history.
         const pending = message === history.at(-1) && pendingToolNames.has(message.name ?? '')
             && body === '[no tool result recorded — turn interrupted]';
-        if (pending) {
-            // The pinned editor serializes history tool parts as complete even if
-            // isComplete=false. Keep this explicit marker for matched AND orphan
-            // results; the active response separately restores the approval controls.
-            pushAssistant([{ part: 'markdown', value: '**Awaiting approval** — no tool result yet.' }]);
+        // Its call's row stays without a result, and the active response restores the approval it waits on, which is
+        // where VS Code shows a call waiting for confirmation: on its own card, not in words in the transcript.
+        if (pending)
             continue;
-        }
         if (granted.has('chatParticipantAdditions')) {
             const row = message.tool_call_id ? toolRows.get(message.tool_call_id) : undefined;
             const output = clamp(stripControls(body), VSCODE_CHAT_LIMITS.partCharacters);
@@ -1278,16 +1414,5 @@ export function projectHistory(history, granted, pendingToolNames = new Set(), p
                 value: `**Tool result${message.name ? ` · ${message.name}` : ''}**\n\n${fence(clamp(stripControls(body), VSCODE_CHAT_LIMITS.partCharacters))}`,
             }]);
     }
-    if (turns.length <= VSCODE_CHAT_LIMITS.historyTurns)
-        return turns;
-    const omitted = turns.length - VSCODE_CHAT_LIMITS.historyTurns;
-    const kept = turns.slice(-VSCODE_CHAT_LIMITS.historyTurns);
-    kept.unshift({
-        role: 'assistant',
-        parts: [{
-                part: 'markdown',
-                value: `_${omitted} earlier turns are omitted by this view’s bound; the runtime’s own history is unchanged and authoritative._`,
-            }],
-    });
-    return kept;
+    return boundTurns(turns);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "repository": {
@@ -53,7 +53,10 @@
     "chatParticipantPrivate",
     "chatParticipantAdditions",
     "chatSessionsProvider",
-    "chatProvider"
+    "chatProvider",
+    "chatSessionResponses",
+    "chatSystemNotification",
+    "chatConfirmationResolution"
   ],
   "contributes": {
     "taskDefinitions": [