@volter/supercode-frontend-vscode 0.1.64 → 0.1.65

package/README.md

@@ -180,9 +180,10 @@ default is never stored as a choice (a pick equal to the default follows the def
 changes), and an Auto approve is never stored for a conversation that cannot answer. Conversations opened before 0.1.36 saved their picker's
 **Ask** when opened and keep it. Auto approve approves the requests the harness would ask you about, including requests to run
 outside its sandbox (Codex's approval requests are its sandbox escalations); the harness's deny
-rules still apply. A request it answers adds no line of its own: the call's row is the record (Code-OSS also says
-"Auto approved" on that row, which the extension API cannot); a card already shown gets its answer as a line beneath
-it, and an approval it could not answer has its card drawn again for the person to answer. A turn
+rules still apply. A request it answers adds no line of its own: the call's row is the record, as in Code-OSS's own
+agent host, whose Auto approve answers a harness's call with no reason on its row; a card already shown loses its
+buttons where the host can retire it (`chatConfirmationResolution`), else gets its answer as a line beneath it, and an
+approval it could not answer has its card drawn again for the person to answer. A turn
 re-joined after a page reload (the conversation's active response) is answered the same way. Unsupported modes are refused. Unanswerable
 harnesses show **Harness permissions**. Previously answered requests cannot affect another
 connection. Native command-button fallback limitations are documented below.
@@ -312,7 +313,9 @@ the frontend does not coerce them into JavaScript's object label.
 record this history path. The original Windows approval-row report remains
 unattributed, and native approval behavior is separate.
 
-The extension asks for five proposals. A host grants them through
+The extension asks for eight proposals. Three of them (`chatSessionResponses`, `chatSystemNotification`,
+`chatConfirmationResolution`) exist only in Volter's Code-OSS fork (volter-ai/code-oss, from `cb0c38b5`); a host
+without one drops its name as a proposal that does not exist. A host grants them through
 `product.json#extensionEnabledApiProposals` (a Code-OSS derivative that bundles this extension) or
 `--enable-proposed-api volter-ai-dev.supercode-frontend-vscode`. **Stock VS Code grants none, and
 everything below still works there** — the granted set is read back from the extension host at
@@ -326,13 +329,18 @@ request), and each part declares its own fallback.
 | `chatSessionsProvider` | the runtime's sessions in the Chat view's session picker, each reopening with its history | the participant still attaches; there is no session list |
 | `chatParticipantPrivate` | dynamic participant identity with the harness and provider icon; an interrupted turn's error at warning level | static participant identity; the interruption is an ordinary error |
 | `chatProvider` | native fixed-model identity and provider icon | host new-chat configuration |
+| `chatSessionResponses` | the `ChatResult` a re-joined response resolves with and a saved turn's `result.errorDetails` as the response's error; the question carousel on a re-joined response; a conversation that could not be opened anchored to the system-initiated request "Couldn't open session" (`ChatRequestTurn.systemInitiatedLabel`) | a re-joined or saved response's error as a warning part, `Answer…` buttons on a re-joined response, that conversation's error under the marker request |
+| `chatSystemNotification` | `ChatResponseSystemNotificationPart` for a harness notice, with its icon, live and saved | the notice as a plain line |
+| `chatConfirmationResolution` | `ChatResponseConfirmationPart.isUsed`: an approval card answered elsewhere loses its buttons | one plain line beneath the card says the answer |
 
 ### Parity with Code-OSS's own chat
 
-The measure is the event, not the API part: **does this event look as the pinned Code-OSS (`4a7cd45`, the fork
-this product ships) draws its own equivalent event?** Using a native part for something VS Code never draws is not
+The measure is the event, not the API part: **does this event look as Code-OSS draws its own equivalent
+event?** The citations are read from Volter's Code-OSS fork at the editor's `FORK.json` pin; the workbench archives
+this product ships are cut from earlier fork commits until they are re-cut at it: `4a7cd45` on macOS arm64, `4782d9a2`
+on Linux x64 and Windows x64. Using a native part for something VS Code never draws is not
 parity. Each row names what Code-OSS itself draws, with its source, and what this frontend draws on the product's
-host (all five proposals granted). **Native**: drawn as Code-OSS draws it. **Fallback**: drawn, but plainer than
+host (all eight proposals granted). **Native**: drawn as Code-OSS draws it. **Fallback**: drawn, but plainer than
 Code-OSS's own (why given). **Gap (API)**: Code-OSS's own drawing is not reachable through the extension API at the
 pin; the row names the fork change that would reach it. **Gap**: reachable, not built. This count is the measure of
 done; a change that moves a row says so here. Paths are under `src/vs/` unless they start with `src/vscode-dts`.
@@ -350,21 +358,24 @@ done; a change that moves a row says so here. Paths are under `src/vs/` unless t
 | A subagent and its calls | the subagent row with its calls grouped under it (`chatSubagentContentPart.ts`) | subagent tool data, `subAgentInvocationId` | native |
 | A hook that blocked or warned | the hook row (`chatHookContentPart.ts`) | `ChatResponseHookPart` | native; **gap (API)** inside a subagent: the part carries no subagent id |
 | An approval | the confirmation card, answered in the running turn (`chatConfirmationContentPart.ts`; the fork's `volter.chat.inTurnApprovalCapability`, `volterHarness/volterChat.ts`) | `ChatResponseConfirmationPart` where the host advertises in-turn cards (this product's host does); command buttons on a stock host, whose confirmation answers with a new request | native; fallback on a stock host |
-| A harness's questions | the question carousel (`chatQuestionCarouselPart.ts`) | the carousel on a turn this window runs; `Answer…` buttons on a re-joined response | native; **gap (API)** on a re-joined response: its stream has a resolver map no answer reaches (`extHostChatSessions.ts`). Fork: route `$handleQuestionCarouselAnswer` to the session's active-response stream |
+| A harness's questions | the question carousel (`chatQuestionCarouselPart.ts`), in its turn's response | the carousel, on a turn this window runs and on a re-joined response (`chatSessionResponses`: `mainThreadChatSessions.ts` forwards the answer to the session's stream by its `resolveId`); `Answer…` buttons on a re-joined response on a host without it | native; fallback on a re-joined response without `chatSessionResponses` |
 | A request answered through its own card in this window | the card or carousel shows what was chosen (`chatConfirmationContentPart.ts`, `chatQuestionCarouselPart.ts`); the call's row carries on or ends denied | the same; a stock host's buttons stay, inert, and the status bar says what was sent | native |
-| A request answered any other way (another window, Auto approve turned on after its card showed, a typed reply) | the card retires itself with the answer | its card stays live; one plain line beneath it says the answer | **gap (API)**: an extension cannot retire a confirmation or carousel it pushed. Fork: let a pushed `ChatResponseConfirmationPart` or question carousel be resolved by the extension (marked used with the chosen answer) |
-| An approval answered automatically (Auto approve) | the call's row says "Auto approved …" (`chatToolPartUtilities.ts` `getApprovalMessageFromReason`, lines 58-80) | the call's row alone; an answer that fails or does not settle draws the approval's card again, as the one still waiting | **gap (API)**: `ChatToolInvocationPart` carries no confirmation reason. Fork: a proposed approval message (or reason) on `ChatToolInvocationPart`, passed through `extHostTypeConverters.ts` to the invocation's confirmed reason |
+| A request answered any other way (another window, Auto approve turned on after its card showed, a typed reply) | the request's card retires itself: the call's row carries on or ends denied (`agentHostSessionHandler.ts` `IChatToolInvocation.confirmWith`); a carousel answered elsewhere is marked used with its answers (`answeredExternally`) | an approval card loses its buttons (`chatConfirmationResolution`: the same `ChatResponseConfirmationPart` pushed with `isUsed`, which `chatModel.ts` matches by its `data`); the call's row carries the outcome. A question carousel stays live, with one plain line beneath it saying the answer | native for an approval card; **gap (API)** for a question carousel: an extension cannot mark a carousel it pushed answered. Fork: let the extension resolve a pushed carousel with the answers given elsewhere (`answeredExternally`) |
+| An approval answered automatically (Auto approve) | the call's row alone: Code-OSS's own agent host answers a harness's call under its Auto approve with `confirmed: NotNeeded` and no reason (`platform/agentHost/node/sessionPermissions.ts` `createToolReadyAction`, after `agentSideEffects.ts` strips the confirmation), so `getApprovalMessageFromReason` (`chatToolPartUtilities.ts`) has nothing to say. Only a client tool the workbench runs itself is "Auto approved by `autoApprove`" (`agentHostSessionHandler.ts` `getClientToolPreApproval`) | the call's row alone; an answer that fails or does not settle draws the approval's card again, as the one still waiting | native |
 | A request this window cannot answer (another client holds it) | no read-only confirmation: another client's call is its row, "Running {0} on another client…", with a cancel action (`stateToProgressAdapter.ts` `toolCallStateToInvocation`) | its title and summary as words, no controls; its answer as a line beneath it | fallback: the extension API cannot draw another client's call |
-| A turn that failed | the response's error (`agentHostSessionHandler.ts` `_getTurnErrorDetails`, `errorDetails`) | the request handler's `ChatResult.errorDetails` | native on a turn this window runs; **gap (API)** on a re-joined response and in history, which show VS Code's warning part with the error's words: the ext host ignores what `activeResponseCallback` returns (`extHostChatSessions.ts`) and `convertResponseTurn` drops `result.errorDetails`. Fork: let `activeResponseCallback` resolve a `ChatResult` whose `errorDetails` the main thread sets on the response (`response.setResult`, as `agentHostSessionHandler.ts` does), and pass `turn.result.errorDetails` through `convertResponseTurn` |
-| A turn interrupted from elsewhere | the response's warning-level, expected error (`_getTurnErrorDetails`, `executionInterrupted`) | `errorDetails` with `level: Warning`, `isExpectedError` | native on a turn this window runs; **gap (API)** elsewhere, as above |
+| A turn that failed | the response's error (`agentHostSessionHandler.ts` `_getTurnErrorDetails`, `errorDetails`) | the request handler's `ChatResult.errorDetails`; on a re-joined response the `ChatResult` its `activeResponseCallback` resolves with, and in history the saved turn's `result.errorDetails` (`chatSessionResponses`: `extHostChatSessions.ts` passes both on, and `chatServiceImpl.ts` sets the result on the response as it completes); on a host without it, VS Code's warning part with the error's words there | native; fallback on a re-joined response and in history without `chatSessionResponses` |
+| A turn interrupted from elsewhere | the response's warning-level, expected error (`_getTurnErrorDetails`, `executionInterrupted`) | `errorDetails` with `level: Warning`, `isExpectedError`, on the same paths | native; fallback without `chatSessionResponses`, as above |
 | A turn the person stopped | VS Code marks the response stopped | nothing more | native |
 | A request Chat cannot run (no sign-in, no runtime, a refused send) | the request's error | a thrown error, which the workbench writes as the response's error | native |
-| A transport or stream error while a turn may still run (`stream_error`, `transport_error`, `watch_error`, `runtime_disconnected`; a re-joined stream that fails; a conversation that cannot be recovered) | the response's error | VS Code's warning part with the error's words | fallback: the turn may still be running, so it is not ended with an error; a saved response cannot carry one (above) |
+| A transport or stream error while a turn may still run (`stream_error`, `transport_error`, `watch_error`, `runtime_disconnected`) | the response's error | VS Code's warning part with the error's words | fallback: the turn may still be running, so it is not ended with an error |
+| A re-joined stream that fails; a conversation that cannot be recovered | the response's error; a session that cannot be loaded is the system-initiated request "Couldn't open session" with that error (`agentHostSessionHandler.ts` `sessionLoadFailed`, `sessionLoadFailedLabel`) | the re-joined response's result carries the error; the conversation's marker request is the system-initiated "Couldn't open session" and its saved response's result carries the error (`chatSessionResponses`); VS Code's warning part under the marker request on a host without it | native; fallback without `chatSessionResponses` |
 | A harness warning (`cache_warning`, `warning`, a usage limit) | the warning part (`chatErrorContentPart.ts`, warning level) | `ChatResponseWarningPart` | native |
-| A harness record that is not the person's words (a background task's notification, live or saved; an interruption record) | a system notification row (`stateToProgressAdapter.ts` `systemNotificationToChatPart`; `claudeReplayMapper.ts` keeps `compact_boundary` and `notification`) | the notice's own words as a plain line, once per task (Claude Code reports a finished task both as `system/task_notification` and as the user-role record that wakes the agent; the saved transcript keeps only the latter, a `queued_command` attachment); not a progress part, which Code-OSS hides once any other part follows it (`chatProgressContentPart.ts`) | **gap (API)**: the extension API has no system-notification part. Fork: a proposed `ChatResponseSystemNotificationPart` converted to `{kind: 'systemNotification'}` in `extHostTypeConverters.ts` |
+| A harness record that is not the person's words (a background task's notification, live or saved; an interruption record) | a system notification row, its icon picked per notification kind with the completion check as default (`stateToProgressAdapter.ts` `systemNotificationToChatPart`; `claudeReplayMapper.ts` keeps `compact_boundary` and `notification`) | `ChatResponseSystemNotificationPart` with the notice's own words (`chatSystemNotification`, converted to `{kind: 'systemNotification'}` in `extHostTypeConverters.ts`), live and saved, once per task (Claude Code reports a finished task both as `system/task_notification` and as the user-role record that wakes the agent; the saved transcript keeps only the latter, a `queued_command` attachment). "Turn interrupted." and a background task that failed or was stopped carry `warning`, by analogy with the icon upstream gives an automatic-approval review that was interrupted: upstream draws neither as a notification of its own. A plain line on a host without it, never a progress part, which Code-OSS hides once any other part follows it (`chatProgressContentPart.ts`) | native; fallback without `chatSystemNotification` |
 | A status line (`status`) | the progress message, hidden once another part follows (`chatProgressContentPart.ts`) | `ChatResponseProgressPart` | native |
-| Input arriving from elsewhere while a turn runs | a request turn of its own (`agentHostSessionHandler.ts`, server-initiated turns) | **Additional input** and the words, inside the running response | **gap (API)**: an extension cannot add a request turn to an open session. Fork: let a session's provider append a request turn (end the active response and open the next with that prompt) |
-| A prompt the runtime's scheduler starts | a request turn of its own | a plain line, "Scheduled prompt: …" | **gap (API)**, as above |
+| Input arriving from elsewhere while a turn runs | the running turn's pending Steering message until the turn takes it in, then nothing: the turn keeps its response and no request turn opens (`agentHostSessionHandler.ts` `_applyRemotePendingMessages` → `syncPendingRequestsFromRemote`; `removePendingRequest` once taken in) | **Additional input** and the words, inside the running response, once the turn takes it in | **gap (runtime)**: the runtime announces no input waiting to be taken in (no frontend event carries it), and the runtime must echo a client-chosen input id on `user_message` and `turn_started`, and return it from `submit` and `steer` (`sdk/frontend/contract.json` carries no turn or input id, so which input started which turn is only a guess by text and order). Then a proposed API with which a session's provider sets and removes its pending Steering messages, mirroring those two calls |
+| A message sent from this window while a turn it follows runs (a re-joined response) | a pending Steering message, which the workbench dispatches to a streamed session's provider at once (`chatServiceImpl.ts`, mid-turn steering); the turn keeps its response | the request handler's own turn, which the runtime refuses while a turn runs | **gap (runtime)**: steering it into the running turn without drawing its runtime echo a second time needs to know which `user_message` is that echo: the runtime must echo a client-chosen input id on `user_message` and `turn_started`, and return it from `submit` and `steer` (`sdk/frontend/contract.json` carries no turn or input id, so which input started which turn is only a guess by text and order) |
+| A turn the runtime starts on its own (input that starts a turn while none runs, a turn after the previous one ended) | a request turn of its own (`agentHostSessionHandler.ts`, a changed active turn id: `startServerRequest`) | drawn inside the response of this window that follows the conversation, which follows to idle (a re-joined response), or only when the conversation reopens | **gap (runtime)**: opening it as a request turn of its own needs to know which input started it: the runtime must echo a client-chosen input id on `user_message` and `turn_started`, and return it from `submit` and `steer` (`sdk/frontend/contract.json` carries no turn or input id, so which input started which turn is only a guess by text and order) |
+| A prompt the runtime's scheduler starts | a system-initiated request turn: a notification row with its label (`chatListRenderer.ts` `renderSystemInitiatedRequest`) | a notice, "Scheduled prompt: …", inside the response this window follows, or nothing until the conversation reopens; the same in saved history. Nothing in this repository produces `scheduled_prompt_started` (it is declared by `agent-runtime-host.mjs` `displayKinds` and read by `frontend-transcript.mjs` and the browser client), so its payload is not known; the prompt is read from `prompt`, `name` or `message` | **gap (runtime)**: a producer, and the turn attribution above, so that its turn opens as its own system-initiated request without also drawing the runtime's `user_message` for it |
 | A Codex diff | file edits with Keep/Undo and the multi-file diff (`chatTextEditContentPart.ts`, `chatMultiDiffContentPart.ts`) | `codeblockUri` with a fenced diff, plus one reference per file | **gap (known)**: the harness has already written the files and no event carries the before/after the editor needs (see *Why `diff_updated` is not an edit part*) |
 | An MCP call | the MCP input/output row | the simple input/output row | fallback: its result arrives as text |
 | Token usage | the context-window indicator (`stream.usage`) | not shown | **gap** |
@@ -373,11 +384,16 @@ done; a change that moves a row says so here. Paths are under `src/vs/` unless t
 | History past its bound | left out without a word; a turn without its request gets "Message content could not be retrieved" (`claudeReplayMapper.ts` `missingPromptPlaceholder`) | the same | native |
 | A call waiting on approval in re-joined history | its row, with its card on the active response | the same | native |
 
-Count, by row (33): 22 native on this product's host, of which three (the questions, a failed turn, an interrupted
-turn) are native only on a turn this window runs and an API gap on a re-joined response, and one (hooks) is an API gap
-inside a subagent; 4 fallback; 5 API gaps (a request answered elsewhere, an automatic approval, harness records,
-input from elsewhere, a scheduled prompt); 1 known gap (native edits); 1 gap not built (`stream.usage`). The fork
-changes named above would close every API gap; none is made yet.
+Count, by row (36), on this product's host (Volter's Code-OSS fork at the editor's `FORK.json` pin, with all eight
+proposals granted; a stock host draws the fallbacks above): 26 native, of which hooks are an API gap inside a
+subagent and a request answered elsewhere an API gap for a question carousel; 4 fallback; 4 gaps that wait on the
+runtime's turn attribution (input from elsewhere while a turn runs, a message this window sends into a turn it
+follows, a turn the runtime starts on its own, a scheduled prompt, which also has no producer yet); 1 known gap
+(native edits); 1 gap not built (`stream.usage`). The rows marked native for a harness's questions on a re-joined
+response, harness records, a failed or interrupted turn on a re-joined or saved response, a conversation that cannot
+be recovered, and a card answered elsewhere rest on the fork's proposals `chatSessionResponses`,
+`chatSystemNotification` and `chatConfirmationResolution`; an automatic approval is native because Code-OSS's own
+agent host draws that call's row alone.
 
 Parts the extension API offers that no harness event this frontend receives carries, so not used:
 `ChatResponseAnchorPart`, `ChatResponseFileTreePart`, `ChatResponseMarkdownWithVulnerabilitiesPart`,
@@ -417,21 +433,21 @@ it needs and the fallback it degrades to. Each arm names the producer it reads.
 | Event kind | Producer | Rendered as |
 |---|---|---|
 | `text_delta` | `crates/runtime/src/event.rs` `AgentEvent::TextDelta` | `response.markdown` (streamed) |
-| `user_message` | `sdk/interchange/agent-runtime-host.mjs` accepted-turn projection; `runtime-native-projection.mjs` `claudeBlocks` for Claude's own user-role records (`source: harness`) | the request turn in history; dropped live (VS Code already shows it); a harness record shows its `notice` as a plain line, or nothing |
+| `user_message` | `sdk/interchange/agent-runtime-host.mjs` accepted-turn projection; `runtime-native-projection.mjs` `claudeBlocks` for Claude's own user-role records (`source: harness`) | the request turn in history; dropped live before `turn_started` (VS Code already shows it); after it, **Additional input** inside the response; a harness record shows its `notice` as a system notification row (`chatSystemNotification`) → a plain line, or nothing |
 | `turn_started` / `turn_completed` / `turn_succeeded` | `submit_claimed`; `AgentEvent::TurnCompleted` | lifecycle only — the handler resolves, nothing renders |
-| `turn_interrupted` | `submit_claimed` | the request handler's result: `errorDetails` at warning level; elsewhere `ChatResponseWarningPart` → its words |
-| `turn_failed` | `submit_claimed` | the request handler's result: `errorDetails`; elsewhere `ChatResponseWarningPart` → blockquote |
+| `turn_interrupted` | `submit_claimed` | the response's result: `errorDetails` at warning level (a re-joined or saved response needs `chatSessionResponses`); else `ChatResponseWarningPart` → its words |
+| `turn_failed` | `submit_claimed` | the response's result: `errorDetails` (a re-joined or saved response needs `chatSessionResponses`); else `ChatResponseWarningPart` → blockquote |
 | `tool_call_started` / `tool_call_completed` | `AgentEvent::ToolCallStarted` / `ToolCallCompleted` | one `ChatToolInvocationPart` per call, updated in place with its result (`enablePartialUpdate`) → a progress line plus a labeled Markdown result |
 | `diff_updated` | `crates/codex-frontend/src/codex_app_server_v0_144.rs` (stock Codex `turn/diff/updated`) | `codeblockUri` + a fenced `diff` block, plus one stable `reference` per file the diff names → the fenced block alone |
 | `request` | `sdk/interchange/frontend-request-bridge.mjs` request publication | `ChatResponseConfirmationPart` where the host advertises in-turn cards, the question carousel for questions; else a titled markdown block plus one **command button per answer**. Read-only (title and summary) for a request this window cannot answer |
-| `request_resolved` | `FrontendRequestBroker::respond` | nothing for a card answered through itself in this window; else one plain line beneath the card naming the answer |
+| `request_resolved` | `FrontendRequestBroker::respond` | nothing for a card answered through itself in this window; a native approval card answered elsewhere loses its buttons (`chatConfirmationResolution`); else one plain line beneath the card naming the answer |
 | `cache_warning` | `AgentEvent::CacheWarning` | `ChatResponseWarningPart` → blockquote |
 | `hook` | `runtime-native-projection.mjs` from Claude Code's failed `hook_response`, its blocked-prompt `informational` record, and a tool result in its own `PreToolUse:<tool> hook error:` words | `ChatResponseHookPart` ("Blocked by" / "Warning from" the hook) → blockquote |
 | `background_tasks` | `runtime-native-projection.mjs` from Claude Code's `background_tasks_changed` | nothing: a background command is its call's row, as in Code-OSS's own Claude host |
 | any event with `parent_id` | `runtime-native-projection.mjs` from Claude Code's `parent_tool_use_id` | a subagent's calls are grouped under its call; its own text, reasoning and input are not shown |
 | `usage` | `AgentEvent::Usage` | nothing (see `stream.usage` in the parity table) |
 | `background_output` | `sdk/interchange/agent-background.mjs` `status` | nothing: the status call's own row carries the output |
-| `scheduled_prompt_started` / `_deferred` / `_completed` | declared by `agent-runtime-host.mjs` `displayKinds`; no producer here | started: a plain line, "Scheduled prompt: …"; deferred and completed: lifecycle only |
+| `scheduled_prompt_started` / `_deferred` / `_completed` | declared by `agent-runtime-host.mjs` `displayKinds`; no producer here | started: a notice, "Scheduled prompt: …"; deferred and completed: lifecycle only |
 | `scheduler_error` | same | `ChatResponseWarningPart` with its words → blockquote |
 | `reasoning` / `thinking` | no producer in this repository; read because `sdk/interchange/frontend-transcript.mjs` reads them | `ChatResponseThinkingProgressPart` → blockquote |
 | `stream_error` / `transport_error` / `watch_error` / `runtime_disconnected` | `crates/opencode-frontend/src/server.rs`; `crates/interchange/src/watch.rs`; synthesized by a frontend (`sdk/interchange/frontend-app.mjs`); `stream_error` has no producer here | `ChatResponseWarningPart` with its words → blockquote |
@@ -467,11 +483,13 @@ status bar says what was sent. An elicitation that carries a `requested_schema`
 can also be answered by typing.
 
 **A harness's questions are VS Code's question carousel.** Why the carousel once swallowed its answer, read
-from the pinned Code-OSS (`4a7cd45`): `questionCarousel` resolves through the resolver map of the stream it
+from Code-OSS at `4a7cd45`, the fork commit the macOS arm64 archive is still cut from (Linux and Windows: `4782d9a2`): `questionCarousel` resolves through the resolver map of the stream it
 was called on, and `$handleQuestionCarouselAnswer` reads only the participant's map
 (`extHostChatAgents2.ts`). A session's *re-joined* response (`activeResponseCallback`) gets a stream with a
-map of its own (`extHostChatSessions.ts`) that no answer ever reaches. So the carousel is used only on a
-turn this window's request handler is running; a re-joined response keeps the buttons above. The design:
+map of its own (`extHostChatSessions.ts`) that no answer reached at that pin. The fork's `chatSessionResponses`
+routes a carousel answer to a session's stream by its `resolveId` (`mainThreadChatSessions.ts` →
+`$handleQuestionCarouselAnswer`), so on the product's host the carousel is used on a re-joined response too;
+a host without it keeps the buttons above on a re-joined response. The design:
 
 - *The question reaches Chat as a request.* Supercode's own `ask_user` already asks through an `elicitation`
   whose `requested_schema.properties.qN` carry `title`, `description`, `x-options` (`[{label, description}]`)
@@ -486,7 +504,8 @@ turn this window's request handler is running; a re-joined response keeps the bu
   alone as `x-question`, and `x-options`) is one `ChatQuestion` per property: single or multi select with
   free text allowed, or text when it has no options; Skip is allowed. Any other form (an MCP server's own
   schema, with its `enum`, `format` or `required`) keeps the `Answer…` door, which honours them. Without the
-  carousel (no `chatParticipantAdditions`, or a re-joined response) it is the `Answer…` button.
+  carousel (no `chatParticipantAdditions`, or a re-joined response on a host without `chatSessionResponses`) it is
+  the `Answer…` button.
 - *The answer reaches the harness in its own format.* The carousel's answers become the elicitation's
   `{action:'accept', content:{qN: label | [labels] | text}}`, or `decline` when skipped or submitted with
   nothing chosen; a stopped turn sends nothing (Stop cancels its requests). A reply typed into Chat instead

package/dist/extension.js

@@ -10,7 +10,7 @@ import { createFrontendClient } from './client.js';
 import { readCredentialFile } from './credential.js';
 import { grantedProposals, PROPOSAL_EFFECTS, REQUESTED_PROPOSALS } from './proposals.js';
 import { observeActiveResponse, sessionStatus } from './native-session.js';
-import { RequestNotPendingError, VscodeFrontendSession } from './session.js';
+import { RequestNotPendingError, TURN_TERMINAL_KINDS, VscodeFrontendSession } from './session.js';
 import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, HISTORY_MARKER_PROMPT, PlanTracker, resolveParts, resolutionSentence, turnOutcome, typedAnswer, } from './view.js';
 const SESSION_SCHEME = 'supercode';
 /** The harnesses whose model and reasoning effort a new chat can set (the host passes them to the CLI). */
@@ -204,6 +204,10 @@ class SupercodeFrontends {
     }
 }
 let nativeInTurnApprovalCards = false;
+/** The host draws a harness notice as its system notification row (`chatSystemNotification`). */
+let systemNotifications = false;
+/** The host retires a confirmation the extension marks answered (`chatConfirmationResolution`). */
+let confirmationResolution = false;
 /** The output channel, for records that are not conversation (`unshown` parts). */
 let outputLog;
 /** Each such record once, however often a history is rebuilt from the same events. */
@@ -225,6 +229,18 @@ const drew = (stream, requestId) => {
     const drawn = drawnRequests.get(stream) ?? new Set();
     drawnRequests.set(stream, drawn.add(requestId));
 };
+/** The confirmation cards each response stream drew natively, so one answered elsewhere can be retired. */
+const drawnCards = new WeakMap();
+/** Retires a native card drawn in `stream`, as one answered through itself is; false where the host cannot. */
+function retireCard(stream, requestId) {
+    const card = confirmationResolution ? drawnCards.get(stream)?.get(requestId) : undefined;
+    if (!card)
+        return false;
+    const retired = new vscode.ChatResponseConfirmationPart(card.title, card.message, card.data, card.buttons);
+    retired.isUsed = true;
+    stream.push(retired);
+    return true;
+}
 /**
  * A harness's questions as VS Code's own carousel, inside the running turn; the person's answers are the
  * elicitation's `{action:'accept', content:{<key>: label | [labels] | text}}`, and Skip is a decline. The answer
@@ -337,6 +353,12 @@ function writePart(stream, part, state) {
         case 'progress':
             stream.progress(part.value);
             return;
+        case 'notice':
+            if (systemNotifications)
+                stream.push(new vscode.ChatResponseSystemNotificationPart(part.value, part.icon ? new vscode.ThemeIcon(part.icon) : undefined));
+            else
+                stream.markdown(`\n\n${part.value}\n\n`);
+            return;
         case 'warning':
             stream.warning(part.value);
             return;
@@ -370,6 +392,9 @@ function writePart(stream, part, state) {
         case 'resolution':
             if (!drawnRequests.get(stream)?.has(part.requestId) || answeredByCard.has(cardKey(part.connectionId, part.requestId)))
                 return;
+            // A native card answered elsewhere retires itself, as Code-OSS's does; the call's row carries the outcome.
+            if (retireCard(stream, part.requestId))
+                return;
             stream.markdown(`\n\n${part.value}\n\n`);
             return;
         case 'unshown':
@@ -380,9 +405,10 @@ function writePart(stream, part, state) {
                 return;
             drew(stream, part.requestId);
             if (part.approval && nativeInTurnApprovalCards && part.answers.length > 0) {
-                stream.confirmation(part.title, part.message, {
-                    kind: 'supercode.inTurnApproval', version: 1, answers: part.answers,
-                }, part.answers.map(answer => answer.label));
+                const card = { title: part.title, message: part.message, data: { kind: 'supercode.inTurnApproval', version: 1, answers: part.answers }, buttons: part.answers.map(answer => answer.label) };
+                stream.confirmation(card.title, card.message, card.data, card.buttons);
+                const cards = drawnCards.get(stream) ?? new Map();
+                drawnCards.set(stream, cards.set(part.requestId, card));
                 return;
             }
             // Stable API on purpose: a command button runs INSIDE the live turn,
@@ -472,6 +498,8 @@ export async function activate(context) {
     // description, so this is the grant, not the request.
     const granted = grantedProposals(context.extension.packageJSON);
     log.info(`Volter Harness: proposals requested ${REQUESTED_PROPOSALS.join(', ')}; granted ${granted.size ? [...granted].join(', ') : 'none (stable chat parts only)'}`);
+    systemNotifications = granted.has('chatSystemNotification');
+    confirmationResolution = granted.has('chatConfirmationResolution');
     // Explicit workbench support is required: stock confirmation clicks send
     // a new prompt. A missing capability keeps the stable in-turn buttons.
     if (granted.has('chatParticipantAdditions')) {
@@ -1608,8 +1636,9 @@ export async function activate(context) {
                         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.
+                // An approval answered automatically adds no line of its own: Code-OSS's own agent host draws a call its Auto
+                // approve answered as its plain row (`sessionPermissions.ts` `createToolReadyAction`, `confirmed: NotNeeded`).
+                // A card it answered after the card was shown gets its resolution.
                 const unsettled = setTimeout(() => {
                     log.warn(`Auto approve has had no answer for ${label} for ${AUTO_ANSWER_SETTLE_MS / 1000} s.`);
                     showCard();
@@ -2259,6 +2288,12 @@ function historyParts(parts, granted) {
             out.push(hookPart(part));
             continue;
         }
+        // A harness notice is Code-OSS's system notification row in history too, where the host has it.
+        if (part.part === 'notice' && granted.has('chatSystemNotification')) {
+            flush();
+            out.push(new vscode.ChatResponseSystemNotificationPart(part.value, part.icon ? new vscode.ThemeIcon(part.icon) : undefined));
+            continue;
+        }
         // A warning and the agent's reasoning are VS Code's own parts in history too, where the host granted them.
         if ((part.part === 'warning' || part.part === 'thinking') && granted.has('chatParticipantAdditions')) {
             flush();
@@ -2272,10 +2307,29 @@ function historyParts(parts, granted) {
     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);
+/** How a turn that did not succeed ends its response, as VS Code's agent host ends one (`_getTurnErrorDetails`). */
+function outcomeErrorDetails(outcome, granted) {
+    // (an interruption is the expected, warning-level error: `isExpectedError` and `level` are
+    // `chatParticipantPrivate`'s, which the ext host checks for `isExpectedError`, so a host without it gets the message)
+    return outcome.interrupted && granted.has('chatParticipantPrivate')
+        ? { message: outcome.message, isExpectedError: true, level: 1 /* ChatErrorLevel.Warning */ }
+        : { message: outcome.message };
+}
+/** A conversation that failed, as a history response shows it: the response's own error where the host keeps a saved
+ *  response's result (`chatSessionResponses`), as Code-OSS shows a session that could not be loaded; else VS Code's
+ *  warning part where the host granted it, else the words alone. */
+function failureResponse(message, granted) {
+    if (granted.has('chatSessionResponses'))
+        return { parts: [], result: { errorDetails: { message } } };
+    return { parts: [granted.has('chatParticipantAdditions') ? new vscode.ChatResponseWarningPart(message) : new vscode.ChatResponseMarkdownPart(message)], result: {} };
+}
+/** The request a failure's response answers: the marker turn, which Code-OSS anchors as the system-initiated request
+ *  "Couldn't open session" (`agentHostSessionHandler.ts` `sessionLoadFailedLabel`) where the host keeps that label. */
+function failureRequest(turns, participant, granted) {
+    const request = new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], participant, []);
+    if (granted.has('chatSessionResponses'))
+        request.systemInitiatedLabel = "Couldn't open session";
+    return request;
 }
 /**
  * One text part as the markdown a HISTORY turn carries (tool calls are drawn
@@ -2285,6 +2339,7 @@ function historyText(part) {
     switch (part.part) {
         case 'markdown':
         case 'progress':
+        case 'notice':
             return part.value;
         case 'warning':
             return `> ⚠ ${part.value}`;
@@ -2424,10 +2479,11 @@ function registerSessions(context, frontends, participant, granted, handler, his
                     failedResources.set(resource.authority, message);
                     refreshItems();
                 }
+                const failure = failureResponse(message, granted);
                 return {
                     history: [
-                        new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], 'supercode', []),
-                        new turns.ChatResponseTurn([failurePart(message, granted)], {}, 'supercode'),
+                        failureRequest(turns, 'supercode', granted),
+                        new turns.ChatResponseTurn(failure.parts, failure.result, 'supercode'),
                     ],
                     requestHandler: boundHandler,
                 };
@@ -2518,6 +2574,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
             if (!live)
                 void controls?.finishIdentitySave(connection);
             const activeParts = [];
+            let heldFailure;
             if (live) {
                 // Standalone requests have no user turn. Give their live response
                 // an explicit runtime marker instead of reopening an old answer.
@@ -2538,6 +2595,8 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 // responses can be stale; their command buttons are disabled.
                 const last = projected.at(-1);
                 if (last?.role === 'assistant') {
+                    // (a failure that ended that turn stays held for the live response, as it was in history)
+                    heldFailure = last.errorEvent;
                     activeParts.push(...(projected.pop()?.parts ?? []).map(part => part.part === 'answers' || part.part === 'questions'
                         ? { part: 'markdown', value: `**${(part.part === 'questions' ? part.fallback : part).title}**\n\n${(part.part === 'questions' ? part.fallback : part).message}` }
                         // (its card is words here, so its answer is said beneath it)
@@ -2552,12 +2611,14 @@ function registerSessions(context, frontends, participant, granted, handler, his
                     history.push(new turns.ChatRequestTurn(turn.prompt ?? '', undefined, [], authorId, []));
                     continue;
                 }
-                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? []), granted), {}, authorId));
+                // (a turn that failed keeps its error as the saved response's own, where the host shows one)
+                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? []), granted), turn.error ? { errorDetails: outcomeErrorDetails(turn.error, granted) } : {}, authorId));
             }
             if (connection.session.failure) {
                 // An explicit runtime marker pairs this notice without presenting
                 // it as a person's prompt. The native busy state stays unchanged.
-                history.push(new turns.ChatRequestTurn(HISTORY_MARKER_PROMPT, undefined, [], authorId, []), new turns.ChatResponseTurn([failurePart(opaqueText(connection.session.failure.message, 2048), granted)], {}, authorId));
+                const failure = failureResponse(opaqueText(connection.session.failure.message, 2048), granted);
+                history.push(failureRequest(turns, authorId, granted), new turns.ChatResponseTurn(failure.parts, failure.result, authorId));
             }
             const renderedCursor = connection.session.cursor;
             const pendingAtCursor = [...connection.session.pendingRequests.values()];
@@ -2574,8 +2635,31 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         // answered here under the conversation's mode (t_39dac582): Auto approve answers the cards
                         // already waiting and later ones; Ask leaves them for the person, as before.
                         const watch = controls && !controls.attached(connection) ? controls.watchApprovals(connection, stream, token) : undefined;
+                        // Where the host keeps a re-joined response's result and answers its questions (`chatSessionResponses`),
+                        // how the turn it ends on did not succeed is that result, as on a turn this window runs, and its
+                        // questions are the carousel. It follows to idle, as it always did, so an earlier turn's failure it
+                        // passes is still drawn, as its warning part.
+                        const results = granted.has('chatSessionResponses');
+                        let failure = results ? heldFailure : undefined;
+                        let result;
+                        // Draws the held failure where it stood, once anything follows it, as history draws one.
+                        let release = () => { };
                         try {
-                            const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map(), quiet: watch?.answers };
+                            const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map(), quiet: watch?.answers,
+                                ...(results ? { carousel: true, pending: (requestId) => connection.session.pendingRequests.has(requestId), cancelled: () => token.isCancellationRequested } : {}) };
+                            const project = (event) => projectEvent(event, {
+                                connectionId: connection.id,
+                                liveUserMessages: true,
+                                plan,
+                                notices,
+                                pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
+                                canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
+                            });
+                            release = () => {
+                                if (failure)
+                                    writeProjected(stream, project(failure), granted, state);
+                                failure = undefined;
+                            };
                             for (const part of oneRowPerToolCall(activeParts))
                                 writePart(stream, part, state);
                             writeProjected(stream, projectPendingRequests(pendingAtCursor.filter(request => connection.session.pendingRequests.has(request.id)), {
@@ -2585,25 +2669,45 @@ function registerSessions(context, frontends, participant, granted, handler, his
                             watch?.sweep();
                             controls?.rememberIdentity(connection);
                             await observeActiveResponse(connection.session, token, (event) => {
-                                writeProjected(stream, projectEvent(event, {
-                                    connectionId: connection.id,
-                                    liveUserMessages: true,
-                                    plan,
-                                    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);
+                                // (a failure the next turn follows is that turn's past: drawn where it stood as soon as the next
+                                // turn starts or anything is drawn after it, so neither a later Stop nor a disconnect makes it
+                                // this response's error)
+                                const terminal = TURN_TERMINAL_KINDS.includes(event.kind);
+                                if (event.kind === 'turn_started' || terminal)
+                                    release();
+                                if (results && terminal) {
+                                    failure = turnOutcome(event) && !token.isCancellationRequested ? event : undefined;
+                                }
+                                else {
+                                    const projected = project(event);
+                                    if (resolveParts(projected, granted).some(part => part.part !== 'unshown'))
+                                        release();
+                                    writeProjected(stream, projected, granted, state);
+                                }
                                 watch?.sweep();
                                 controls?.rememberIdentity(connection);
                             }, () => { connection.viewReady = true; }, renderedCursor);
+                            const outcome = failure && turnOutcome(failure);
+                            if (outcome)
+                                result = { errorDetails: outcomeErrorDetails(outcome, granted) };
                         }
                         catch (error) {
                             if (token.isCancellationRequested || error instanceof vscode.CancellationError)
                                 throw error;
-                            // 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.
+                            // The response's own error is what VS Code shows; a host that does not keep a re-joined
+                            // response's result gets the warning part.
                             const message = opaqueText(String(error?.message ?? error), 2048);
-                            if (granted.has('chatParticipantAdditions'))
+                            // (a failure held when the connection drops is drawn; the drop is the result)
+                            if (results) {
+                                try {
+                                    release();
+                                }
+                                catch {
+                                    // (a stream that refuses a part has closed)
+                                }
+                                result = { errorDetails: { message } };
+                            }
+                            else if (granted.has('chatParticipantAdditions'))
                                 stream.warning(message);
                             else
                                 stream.markdown(`\n\n${message}\n\n`);
@@ -2613,6 +2717,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
                             watch?.dispose();
                             await controls?.finishIdentitySave(connection);
                         }
+                        return result;
                     }
                     : undefined,
             };

package/dist/proposals.d.ts

@@ -13,7 +13,7 @@
  * unconditionally, so a `typeof vscode.ChatResponseConfirmationPart` probe
  * cannot answer this question — only the description can.
  */
-export declare const REQUESTED_PROPOSALS: readonly ["defaultChatParticipant", "chatParticipantPrivate", "chatParticipantAdditions", "chatSessionsProvider", "chatProvider"];
+export declare const REQUESTED_PROPOSALS: readonly ["defaultChatParticipant", "chatParticipantPrivate", "chatParticipantAdditions", "chatSessionsProvider", "chatProvider", "chatSessionResponses", "chatSystemNotification", "chatConfirmationResolution"];
 export type ProposalName = (typeof REQUESTED_PROPOSALS)[number];
 /** What each requested proposal buys, and what this frontend does without it. */
 export declare const PROPOSAL_EFFECTS: Readonly<Record<ProposalName, {

package/dist/proposals.js

@@ -19,6 +19,10 @@ export const REQUESTED_PROPOSALS = Object.freeze([
     'chatParticipantAdditions',
     'chatSessionsProvider',
     'chatProvider',
+    // Volter's Code-OSS fork (volter-ai/code-oss); a host without them drops the names ("DOES NOT EXIST").
+    'chatSessionResponses',
+    'chatSystemNotification',
+    'chatConfirmationResolution',
 ]);
 /** What each requested proposal buys, and what this frontend does without it. */
 export const PROPOSAL_EFFECTS = Object.freeze({
@@ -39,6 +43,18 @@ export const PROPOSAL_EFFECTS = Object.freeze({
         grants: 'the runtime’s sessions in the Chat view’s session picker, each reopening with its history',
         without: 'the participant still attaches; there is no session list',
     },
+    chatSessionResponses: {
+        grants: 'a re-joined or saved response ending with its error; questions on a re-joined response as the carousel; a conversation that could not be opened anchored as Code-OSS anchors one',
+        without: 'a re-joined or saved response’s error as a warning part; questions there as buttons; that conversation’s error under the marker request',
+    },
+    chatSystemNotification: {
+        grants: 'a harness notice (a background task finishing, an interruption record) as the system notification row',
+        without: 'the notice as a plain line',
+    },
+    chatConfirmationResolution: {
+        grants: 'an approval card answered elsewhere losing its buttons',
+        without: 'the card stays and one plain line beneath it says the answer',
+    },
 });
 /** Read the proposals the HOST granted this extension, never the ones it asked for. */
 export function grantedProposals(packageJSON) {

package/dist/view.d.ts

@@ -34,6 +34,14 @@ export type ChatPart = {
 } | {
     part: 'progress';
     value: string;
+}
+/** A record of the harness that is neither the agent's words nor the person's (a background task finishing, an
+ *  interruption record, a scheduled prompt's start): Code-OSS's system notification row where the host has it
+ *  (`chatSystemNotification`), with `icon` where it reports no completion, else a plain line. Markdown-safe text. */
+ | {
+    part: 'notice';
+    value: string;
+    icon?: string;
 } | {
     part: 'warning';
     value: string;
@@ -300,6 +308,14 @@ export interface ProjectedTurn {
     prompt?: string;
     /** Rendered parts for an assistant turn. */
     parts?: ChatPart[];
+    /** How an assistant turn ended when it did not succeed, kept as the saved response's own error where the host
+     *  shows one (`chatSessionResponses`); otherwise it is a warning part among `parts`. */
+    error?: {
+        message: string;
+        interrupted: boolean;
+    };
+    /** The record `error` came from, drawn as its warning part where anything follows it. */
+    errorEvent?: FrontendEvent;
 }
 export declare function projectReplayTurns(events: readonly FrontendEvent[], granted: ReadonlySet<string>, context: ProjectionContext, history?: readonly ProjectedTurn[]): ProjectedTurn[];
 /**

package/dist/view.js

@@ -701,8 +701,8 @@ 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,
-            // which the extension API does not carry: here it is its own words as a line that stays (`noticeLine`).
+            // 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 && firstNotice(context, notifiedCall(payload)) ? [stable(noticeLine(notice))] : [];
@@ -918,9 +918,9 @@ export function projectEvent(event, context) {
             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 a re-joined response or history, which have
-        // no result to carry it, shows its warning part. The live writer drops it when the person stopped the turn
-        // (VS Code marks a stopped response itself).
+        // 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 }] }];
@@ -935,8 +935,9 @@ export function projectEvent(event, context) {
         // 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`); a re-joined response and history carry no result, so there 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.
+        // (`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':
@@ -1057,7 +1058,7 @@ 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, plain text drawn as a status line. 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.
  */
@@ -1069,11 +1070,26 @@ function notPersonNotice(payload) {
     return undefined;
 }
 /**
- * A notice as a line of the transcript: its own words, plain. Not a progress part: Code-OSS hides a progress message
+ * 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) {
-    return { part: 'markdown', value: `\n\n${plain(notice)}\n\n` };
+    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) {
@@ -1126,6 +1142,18 @@ 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));
@@ -1150,7 +1178,7 @@ export function projectReplayTurns(events, granted, context, history = []) {
                 const last = turns[turns.length - 1];
                 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;
@@ -1159,6 +1187,31 @@ export function projectReplayTurns(events, granted, context, history = []) {
             replayTurn = true;
             continue;
         }
+        // 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')
@@ -1184,7 +1237,7 @@ 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 });
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.64",
+  "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": [