@volter/supercode-frontend-vscode 0.1.61 → 0.1.63

package/README.md

@@ -320,11 +320,56 @@ request), and each part declares its own fallback.
 | Proposal | What it buys | Without it |
 |---|---|---|
 | `defaultChatParticipant` | `isDefault` — Volter Harness answers the Chat view with no `@` mention | the ordinary `@supercode` participant; a mention is required |
-| `chatParticipantAdditions` | `ChatToolInvocationPart`, `ChatResponseConfirmationPart`, `ChatResponseWarningPart`, `codeblockUri`, `ChatResponseThinkingProgressPart` | progress lines, labeled Markdown results, typed replies, plain fenced diffs, blockquoted reasoning |
+| `chatParticipantAdditions` | `ChatToolInvocationPart` (with its terminal, todo-list and subagent data), `ChatResponseConfirmationPart`, `ChatResponseWarningPart`, `codeblockUri`, `ChatResponseThinkingProgressPart`, `ChatResponseHookPart`, `questionCarousel` | progress lines, labeled Markdown results, typed replies, plain fenced diffs, blockquoted reasoning, quoted hook lines, answer buttons |
 | `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 | static participant identity |
 | `chatProvider` | native fixed-model identity and provider icon | host new-chat configuration |
 
+### Parity with Code-OSS's own chat parts
+
+Every chat response part and tool-row kind the pinned Code-OSS (`4a7cd45`, `src/vscode-dts`) offers an extension,
+and what this frontend does with it. **Native**: the harness's event is drawn as VS Code draws its own.
+**Fallback**: drawn, but with a plainer part than VS Code's own (why given). **Not used**: no harness event this
+frontend receives carries what the part shows. **Gap**: the event exists and the native part is not built yet.
+This count is the measure of done; a change that moves a row says so here.
+
+| Part / tool data | Status | What draws it, or why not |
+|---|---|---|
+| `ChatResponseMarkdownPart` | native | the agent's text |
+| `ChatResponseProgressPart` | native | status lines; a finished subagent task as one line |
+| `ChatResponseWarningPart` | native | warnings, failed turns, usage limits |
+| `ChatResponseThinkingProgressPart` | native | the agent's reasoning (a subagent's is not shown, as VS Code shows none) |
+| `ChatResponseReferencePart` | native | each file a Codex diff names |
+| `ChatResponseCommandButtonPart` | native | approval answers; Stop for a background task |
+| `ChatToolInvocationPart` | native | every tool call, updated in place with its result |
+| ↳ terminal data | native | shell calls: command and output |
+| ↳ todo-list data | native | Claude Code's TodoWrite and its task tools (TaskCreate, TaskUpdate, TaskList), and supercode's own `update_plan`, shown in VS Code's todo list. Codex app-server's plan (`turn/plan/updated`, not a tool call) is still a status line: fallback |
+| ↳ subagent data, `subAgentInvocationId` | native | Claude Code's Agent/Task call is the subagent row; its own calls are grouped under it (`parent_tool_use_id`) |
+| ↳ simple input/output data | native | any other finished call |
+| ↳ MCP data | fallback | an MCP call's result arrives as text, so it is the simple input/output |
+| ↳ resources data | not used | no tool event lists resources as such |
+| `ChatResponseHookPart` | native | a blocked prompt, a blocked tool call, a hook that failed (Claude Code). The extension API cannot place a hook inside a subagent row |
+| `ChatResponseQuestionCarouselPart` | native | an elicitation of questions (`ask_user`, Claude Code's AskUserQuestion) on a turn this window runs; command buttons on a re-joined response, where the pinned host never delivers the carousel's answer |
+| `ChatResponseConfirmationPart` | native / fallback | approvals, where the host advertises in-turn approval cards; command buttons otherwise (a stock confirmation answers with a new request) |
+| `ChatResponseCodeblockUriPart` | fallback | a Codex diff: `codeblockUri` with a fenced diff, not an edit (see *Why `diff_updated` is not an edit part*) |
+| `ChatResponseTextEditPart`, `ChatResponseNotebookEditPart`, `ChatResponseWorkspaceEditPart`, `ChatResponseMultiDiffPart`, `ChatResponseExternalEditPart` | **gap (known)** | native file edits with Keep/Undo and the multi-file diff: the harness has already written the files, and no event carries the before/after the editor needs |
+| `ChatResponseAnchorPart` | not used | no event names a location inline in text |
+| `ChatResponseFileTreePart` | not used | no event lists a file tree |
+| `ChatResponseMarkdownWithVulnerabilitiesPart` | not used | no harness reports vulnerabilities |
+| `ChatResponseCodeCitationPart` | not used | no harness reports a licensed citation |
+| `ChatResponseMovePart` | not used | no event moves a range |
+| `ChatResponseExtensionsPart` | not used | no harness recommends extensions |
+| `ChatResponsePullRequestPart` | not used | no structured event announces a pull request |
+| `ChatResponseInfoPart` | not used | informational records are warnings or are dropped as telemetry |
+| `ChatResponseAutoModeResolutionPart` | not used | the harness's model is the one chosen; there is no automatic routing to report |
+| `ChatResponseProgressPart2`, `ChatResponseReferencePart2` | not used | no event carries a resolvable task or a reference status |
+| `ChatResponseVoiceProgressPart` (`chatParticipantPrivate`) | not used | voice is not a harness event |
+| `stream.usage` | gap | token counts are dropped from the transcript; VS Code's own context indicator could show them and does not yet |
+
+Count, by row: 14 native (the confirmation card only where the host advertises it), 2 fallback (and Codex's plan
+inside the todo-list row), 12 not used, 2 gaps — native edits (the known gap, five parts in one row) and
+`stream.usage`.
+
 The session participant uses the exact session type id (`supercode`). With
 `chatParticipantPrivate`, the extension registers its dynamic identity directly and keeps
 `canDelegate` disabled so the workbench does not pre-register a generic agent that masks the
@@ -357,7 +402,7 @@ 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 | the request turn in history; dropped live (VS Code already shows it) |
+| `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` or nothing |
 | `turn_started` / `turn_completed` / `turn_succeeded` | `submit_claimed`; `AgentEvent::TurnCompleted` | lifecycle only — the handler resolves, nothing renders |
 | `turn_interrupted` | `submit_claimed` | an italic notice |
 | `turn_failed` | `submit_claimed` | `ChatResponseWarningPart` → blockquote |
@@ -365,6 +410,9 @@ it needs and the fallback it degrades to. Each arm names the producer it reads.
 | `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 | a titled markdown block plus one **command button per answer** — stable API, no proposal |
 | `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 in the transcript: the turn lists them with a Stop each |
+| 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` | a progress line |
 | `background_output` | `AgentEvent::BackgroundOutput` | a fenced block, saying so when the runtime stopped retaining |
 | `scheduled_prompt_started` / `_deferred` / `_completed` | declared by `frontend_descriptor`'s `display.event_kinds` | a progress line |
@@ -402,6 +450,36 @@ resolution sentence lands directly beneath them. An elicitation that carries a `
 `Answer…` button that asks for the value first; a request still pending while the session is idle
 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
+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:
+
+- *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}]`)
+  and `x-multi-select` (`sdk/interchange/question-tool.mjs`). Claude Code's AskUserQuestion takes the same
+  input (`questions[{question, header, options[{label, description}], multiSelect}]`, at most four of each)
+  and, with `--permission-prompt-tool stdio`, asks for it as a `can_use_tool` control request (Claude Code
+  enables the tool only when a permission prompt tool answers it — measured on 2.1.312). The runtime's
+  projection (`runtime-native-projection.mjs`) raises that request as an `elicitation` built by the same
+  `questionElicitation` the `ask_user` tool uses, not as an approval, so Auto approve never answers it and
+  every frontend that answers an elicitation answers this one.
+- *Chat shows the carousel.* An elicitation whose every property is such a question (a `title`, the question
+  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.
+- *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
+  answers every question with its words. For Claude Code the
+  hosted runtime (`runtime-hosted.mjs`) turns that into its permission reply
+  `{behavior:'allow', updatedInput:{questions, answers:{<question>: <answer>}}}`, multiple answers joined
+  with `, ` as AskUserQuestion's own output schema states; a decline is `{behavior:'deny', message}`.
+  `ask_user` already reads the same `content`.
+
 **A hosted harness runtime.** When the runtime is one Volter Harness HOSTS — a Claude Code, Codex, pi or
 opencode session it started through `harness.v1.runtimes.start` — an approval it raises is
 **answerable from this view** for every harness whose reply this runtime can translate
@@ -438,10 +516,17 @@ needs it; a reader does not, and a collapsed block is still a reader's problem.
 one to a person, so `role: 'system'` is dropped outright and the transcript starts where the
 conversation does.
 
-Saved user-role records marked `isMeta`, `isCompactSummary` or
-`promptSource: system` are also context. They create no person-message bubble;
-ordinary quoted text without those flags stays a person message. Claude's
-unmarked, exact `[Request interrupted by user]` record becomes a short turn
+Whose words a user-role record carries is one rule,
+`@volter/supercode-interchange/user-provenance`, vendored here unchanged. Live
+and replayed `user_message` events carry its answer as `source`
+(`person` | `harness`) with a `notice` where one is shown; saved history is
+read through the same rule. Records the harness wrote (`isMeta`,
+`isSynthetic` — the stream's image-coordinate note — `isCompactSummary`,
+`promptSource: system`, sidechain and tool-result records, file attachments)
+create no person-message bubble, live or restored; ordinary quoted text
+without those flags stays a person message. A task notification becomes a
+short background-task notice, and Claude's unmarked, exact interruption
+records (`[Request interrupted by user]`, `… for tool use]`) a short turn
 interruption notice. The native transcript remains authoritative and unchanged.
 [Source evidence and remaining qualification](../../docs/evidence/chat-native-notices-20261013.md).
 

package/dist/extension.js

@@ -11,7 +11,7 @@ import { readCredentialFile } from './credential.js';
 import { grantedProposals, PROPOSAL_EFFECTS, REQUESTED_PROPOSALS } from './proposals.js';
 import { observeActiveResponse, sessionStatus } from './native-session.js';
 import { RequestNotPendingError, VscodeFrontendSession } from './session.js';
-import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, HISTORY_MARKER_PROMPT, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
+import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, HISTORY_MARKER_PROMPT, PlanTracker, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
 const SESSION_SCHEME = 'supercode';
 /** The harnesses whose model and reasoning effort a new chat can set (the host passes them to the CLI). */
 const CONFIGURABLE_HARNESSES = ['claude-code', 'codex'];
@@ -204,6 +204,88 @@ class SupercodeFrontends {
     }
 }
 let nativeInTurnApprovalCards = false;
+/**
+ * A harness's questions as VS Code's own carousel, inside the running turn; the person's answers are the
+ * elicitation's `{action:'accept', content:{<key>: label | [labels] | text}}`, and Skip is a decline. The answer
+ * takes the same door as a button's (`supercode.frontend.respond`).
+ */
+function askQuestions(stream, part, pending, cancelled) {
+    const questions = part.questions.map(field => new vscode.ChatQuestion(field.key, field.options.length === 0 ? vscode.ChatQuestionType.Text
+        : field.multiSelect ? vscode.ChatQuestionType.MultiSelect : vscode.ChatQuestionType.SingleSelect, field.title, {
+        ...(field.message ? { message: field.message } : {}),
+        ...(field.options.length ? {
+            options: field.options.map((option, index) => ({ id: `${field.key}-${index}`, label: option.description ? `${option.label} — ${option.description}` : option.label, value: option.label })),
+            allowFreeformInput: true,
+        } : {}),
+    }));
+    const respond = (response) => vscode.commands.executeCommand('supercode.frontend.respond', { connectionId: part.connectionId, requestId: part.requestId, response, label: 'Answer' });
+    void Promise.resolve(stream.questionCarousel(questions, true)).then(answers => {
+        // (the editor also resolves an unanswered carousel when its response ends: a request answered by another door
+        // by then is left alone)
+        // (and a stopped turn: Stop already cancels its requests)
+        if ((pending && !pending(part.requestId)) || cancelled?.())
+            return;
+        const content = {};
+        for (const field of part.questions) {
+            const answer = carouselAnswer(answers?.[field.key]);
+            if (answer !== undefined)
+                content[field.key] = answer;
+        }
+        // Skip, and a carousel submitted with nothing chosen, decline: a question is never answered with nothing.
+        if (Object.keys(content).length === 0)
+            return respond({ kind: 'elicitation', request_id: part.requestId, action: 'decline' });
+        return respond({ kind: 'elicitation', request_id: part.requestId, action: 'accept', content });
+    }, () => undefined);
+}
+/** One carousel answer as the elicitation's value: the text, the selected label (or the person's own words), or the
+ *  selected labels with any words of their own after them. */
+function carouselAnswer(value) {
+    if (typeof value === 'string')
+        return value.trim() || undefined;
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const answer = value;
+    const own = typeof answer.freeformValue === 'string' && answer.freeformValue.trim() ? answer.freeformValue.trim() : undefined;
+    if (Array.isArray(answer.selectedValues)) {
+        const picked = [...answer.selectedValues.filter((item) => typeof item === 'string'), ...(own ? [own] : [])];
+        return picked.length ? picked : undefined;
+    }
+    return typeof answer.selectedValue === 'string' && answer.selectedValue ? answer.selectedValue : own;
+}
+/** VS Code's own hook row: which hook, and what it said — a stop reason where it blocked, a warning otherwise. */
+function hookPart(part) {
+    return part.blocked
+        ? new vscode.ChatResponseHookPart(part.hookType, part.reason || 'The hook gave no reason.')
+        : new vscode.ChatResponseHookPart(part.hookType, undefined, part.reason || 'The hook gave no reason.');
+}
+/**
+ * What a tool row shows inside it, the way VS Code's own rows do, live and in history alike: a plan call is the todo
+ * list as the call left it; a subagent call is the subagent row, with its answer once it has one (none for a subagent
+ * started in the background, whose call returns only a launch notice); a shell call is the terminal block; any other
+ * finished call its input and output. A subagent's own calls are grouped under the call they were made inside.
+ */
+function setToolDetails(invocation, row) {
+    if (row.parentToolCallId)
+        invocation.subAgentInvocationId = row.parentToolCallId;
+    if (row.plan) {
+        invocation.toolSpecificData = { todoList: row.plan.map((item, index) => ({
+                id: index + 1,
+                title: item.title,
+                status: item.status === 'completed' ? vscode.ChatTodoStatus.Completed
+                    : item.status === 'in-progress' ? vscode.ChatTodoStatus.InProgress : vscode.ChatTodoStatus.NotStarted,
+            })) };
+    }
+    else if (row.subagent) {
+        invocation.toolSpecificData = new vscode.ChatSubagentToolInvocationData(row.subagent.description, row.subagent.agentName, row.subagent.prompt, row.isComplete && !row.background ? row.resultText ?? '' : undefined);
+    }
+    else if (row.commandLine) {
+        invocation.toolSpecificData = { commandLine: { original: row.commandLine }, language: 'sh',
+            ...(row.isComplete ? { output: { text: row.resultText ?? '' } } : {}) };
+    }
+    else if (row.isComplete) {
+        invocation.toolSpecificData = { input: row.inputText ?? '', output: row.resultText ?? '' };
+    }
+}
 function writeProjected(stream, projected, granted, state) {
     for (const candidate of projected) {
         const parts = resolveParts([candidate], granted);
@@ -244,6 +326,15 @@ function writePart(stream, part, state) {
         case 'thinking':
             stream.push(new vscode.ChatResponseThinkingProgressPart(part.value));
             return;
+        case 'hook':
+            stream.push(hookPart(part));
+            return;
+        case 'questions':
+            if (state.carousel)
+                askQuestions(stream, part, state.pending, state.cancelled);
+            else
+                writePart(stream, part.fallback, state);
+            return;
         case 'reference': {
             // Only a path the runtime's own payload named, resolved against the
             // workspace this window already has. Nothing is created or fabricated.
@@ -299,17 +390,22 @@ function writePart(stream, part, state) {
                 invocation.isError = part.isError;
             if (part.inputText !== undefined)
                 state.toolInputs.set(part.toolCallId, part.inputText);
-            if (commandLine) {
-                // VS Code's own terminal block: the command, and its output once it has run.
-                invocation.toolSpecificData = { commandLine: { original: commandLine }, language: 'sh',
-                    ...(part.isComplete ? { output: { text: part.resultText ?? '' } } : {}) };
-            }
-            else if (part.isComplete) {
-                invocation.toolSpecificData = {
-                    input: state.toolInputs.get(part.toolCallId) ?? '',
-                    output: part.resultText ?? '',
-                };
+            if (part.plan || part.subagent || part.parentToolCallId || part.background) {
+                const kept = state.toolKinds.get(part.toolCallId) ?? {};
+                state.toolKinds.set(part.toolCallId, {
+                    ...kept,
+                    ...(part.plan ? { plan: part.plan } : {}),
+                    ...(part.subagent ? { subagent: part.subagent } : {}),
+                    ...(part.parentToolCallId ? { parentToolCallId: part.parentToolCallId } : {}),
+                    ...(part.background ? { background: true } : {}),
+                });
             }
+            setToolDetails(invocation, {
+                ...part,
+                ...state.toolKinds.get(part.toolCallId),
+                commandLine,
+                inputText: state.toolInputs.get(part.toolCallId),
+            });
             stream.push(invocation);
             return;
         }
@@ -1496,7 +1592,7 @@ export async function activate(context) {
                         writeProjected(stream, projectPendingRequests([pending], {
                             connectionId: connection.id,
                             canRespond: connection.session.descriptor?.actions.respond !== false,
-                        }), granted, { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map() });
+                        }), granted, { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map() });
                     }
                     catch {
                         void vscode.window.showWarningMessage(`${connection.label}: ${label} is waiting for approval. Open its chat to answer it.`);
@@ -1538,11 +1634,14 @@ export async function activate(context) {
         if (approval() === 'autoApprove' && !canAnswer(connection)) {
             throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
         }
-        const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map() };
+        const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map(),
+            carousel: true, pending: (requestId) => connection.session.pendingRequests.has(requestId),
+            cancelled: () => token.isCancellationRequested };
         const projection = {
             connectionId: connection.id,
             pendingRequest: (requestId) => connection.session.pendingRequests.get(requestId) ?? connection.session.resolvedRequests.get(requestId),
             canRespond: connection.session.descriptor?.actions.respond !== false,
+            plan: connection.plan ??= new PlanTracker(),
         };
         const cancellation = token.onCancellationRequested(() => {
             void stopConnection(connection).catch(() => {
@@ -2143,15 +2242,15 @@ function historyParts(parts) {
             invocation.isComplete = part.isComplete;
             if (part.isError !== undefined)
                 invocation.isError = part.isError;
-            if (part.commandLine) {
-                invocation.toolSpecificData = { commandLine: { original: part.commandLine }, language: 'sh', output: { text: part.resultText ?? '' } };
-            }
-            else if (part.isComplete) {
-                invocation.toolSpecificData = { input: part.inputText ?? '', output: part.resultText ?? '' };
-            }
+            setToolDetails(invocation, part);
             out.push(invocation);
             continue;
         }
+        if (part.part === 'hook') {
+            flush();
+            out.push(hookPart(part));
+            continue;
+        }
         const value = historyText(part);
         if (value)
             text.push(value);
@@ -2172,6 +2271,9 @@ function historyText(part) {
             return `> ⚠ ${part.value}`;
         case 'thinking':
             return `> ${part.value}`;
+        case 'hook':
+            // Drawn as VS Code's own hook row by `historyParts`.
+            return '';
         case 'codeblock':
             return part.value;
         case 'reference':
@@ -2181,6 +2283,8 @@ function historyText(part) {
             return '';
         case 'answers':
             return `**${part.title}**\n\n${part.message}`;
+        case 'questions':
+            return `**${part.fallback.title}**\n\n${part.fallback.message}`;
     }
 }
 function registerSessions(context, frontends, participant, granted, handler, historyParticipant, controls) {
@@ -2366,6 +2470,8 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         pendingToolNames.add(name);
                 }
             }
+            // The task list is replayed with the history it was built in, and live turns carry on from it.
+            const plan = new PlanTracker();
             const projected = projectReplayTurns(replay.filter(event => {
                 if (event.kind !== 'request')
                     return true;
@@ -2375,7 +2481,9 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 connectionId: connection.id,
                 pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
                 canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
-            }, projectHistory(canonicalHistory, granted, pendingToolNames));
+                plan,
+            }, projectHistory(canonicalHistory, granted, pendingToolNames, plan));
+            connection.plan = plan;
             const live = connection.session.descriptor?.turn_state === 'busy' || connection.session.pendingRequests.size > 0;
             controls?.rememberIdentity(connection);
             if (!live)
@@ -2401,8 +2509,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') {
-                    activeParts.push(...(projected.pop()?.parts ?? []).map(part => part.part === 'answers'
-                        ? { part: 'markdown', value: `**${part.title}**\n\n${part.message}` }
+                    activeParts.push(...(projected.pop()?.parts ?? []).map(part => part.part === 'answers' || part.part === 'questions'
+                        ? { part: 'markdown', value: `**${(part.part === 'questions' ? part.fallback : part).title}**\n\n${(part.part === 'questions' ? part.fallback : part).message}` }
                         : part));
                 }
             }
@@ -2438,7 +2546,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         // already waiting and later ones; Ask leaves them for the person, as before.
                         const watch = controls && !controls.attached(connection) ? controls.watchApprovals(connection, stream, token) : undefined;
                         try {
-                            const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), quiet: watch?.answers };
+                            const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), toolKinds: new Map(), quiet: watch?.answers };
                             for (const part of oneRowPerToolCall(activeParts))
                                 writePart(stream, part, state);
                             writeProjected(stream, projectPendingRequests(pendingAtCursor.filter(request => connection.session.pendingRequests.has(request.id)), {
@@ -2451,6 +2559,7 @@ function registerSessions(context, frontends, participant, granted, handler, his
                                 writeProjected(stream, projectEvent(event, {
                                     connectionId: connection.id,
                                     liveUserMessages: true,
+                                    plan,
                                     pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
                                     canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
                                 }), granted, state);

package/dist/view.d.ts

@@ -50,6 +50,13 @@ export type ChatPart = {
     uri: string;
     value: string;
     language: string;
+}
+/** A harness hook that blocked or warned: which event it ran on, and what it said. */
+ | {
+    part: 'hook';
+    hookType: HookType;
+    blocked: boolean;
+    reason: string;
 } | {
     part: 'tool';
     toolName: string;
@@ -62,13 +69,45 @@ export type ChatPart = {
     resultText?: string;
     /** A shell call's command line: the row is then VS Code's own terminal block, command and output. */
     commandLine?: string;
+    /** The plan as this call left it (`planItems`, `PlanTracker`): the row is then VS Code's own todo list. */
+    plan?: PlanItem[];
+    /** A subagent call's own fields (`subagentCall`): the row is then VS Code's own subagent row. */
+    subagent?: SubagentCall;
+    /** The subagent call this call was made inside (Claude Code's `parent_tool_use_id`): VS Code groups it there. */
+    parentToolCallId?: string;
+    /** The call started its subagent in the background: its result is a launch notice, not the subagent's answer. */
+    background?: boolean;
 } | {
     part: 'answers';
     approval: boolean;
     title: string;
     message: string;
     answers: ChatAnswer[];
+}
+/** A harness's questions (`requestQuestions`): VS Code's question carousel on a turn this window runs, its
+ *  `answers` part anywhere else. */
+ | {
+    part: 'questions';
+    connectionId: string;
+    requestId: number;
+    questions: QuestionField[];
+    fallback: Extract<ChatPart, {
+        part: 'answers';
+    }>;
 };
+/** One question of an elicitation that asks questions (`requestQuestions`), as VS Code's carousel asks it. */
+export interface QuestionField {
+    /** The elicitation's property, which the answer's `content` is keyed by. */
+    key: string;
+    title: string;
+    message?: string;
+    /** Each option's label (also its answer) and what it means. None: a free-text question. */
+    options: {
+        label: string;
+        description?: string;
+    }[];
+    multiSelect: boolean;
+}
 /**
  * One rendered part plus the API proposal it needs and what this view renders
  * instead when the host did not grant it. README.md's proposal table is this
@@ -105,6 +144,49 @@ export declare function toolTitles(toolName: string, argumentsText: string): {
     invocation: string;
     pastTense: string;
 };
+/** A hook's row as words, as VS Code titles its own (`chatHookContentPart.ts`): "Blocked by …" or "Warning from …". */
+export declare function hookSentence(hookEvent: string, blocked: boolean, reason: string): string;
+/** The hook events VS Code's own Chat names (`ChatHookType`), which are Claude Code's. */
+export declare const HOOK_TYPES: readonly ["SessionStart", "SessionEnd", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PreCompact", "SubagentStart", "SubagentStop", "Stop", "ErrorOccurred"];
+export type HookType = (typeof HOOK_TYPES)[number];
+/** One item of an agent's plan, as VS Code's own todo list holds it. */
+export interface PlanItem {
+    title: string;
+    status: 'not-started' | 'in-progress' | 'completed';
+}
+/** A plan call's items (Claude Code's TodoWrite `todos` of `content`; the `update_plan` tool's `plan` of `step`, as
+ *  supercode's own and Codex's take it), each its text and status, read from its own arguments; undefined for any
+ *  other tool, or arguments holding none. Both carry the whole list, so they need no state. */
+export declare function planItems(toolName: string, argumentsText: string): PlanItem[] | undefined;
+/**
+ * The task list Claude Code keeps with its task tools, which it offers in place of TodoWrite (TaskCreate, TaskUpdate,
+ * TaskList; Claude Code 2.1.312 enables them by default and TodoWrite only when its tasks are turned off). Each call
+ * changes ONE task, while VS Code's own todo list shows the WHOLE list, so this keeps the list for one conversation as
+ * the calls go by and gives each call's row the list as that call left it.
+ *
+ * Read from the calls' own arguments, and from Claude Code's own result text where only the result has it (measured
+ * on 2.1.312, its `mapToolResultToToolResultBlockParam`): TaskCreate's `Task #<id> created successfully: <subject>`,
+ * TaskUpdate's `Updated task #<id> <fields>`, and TaskList's lines `#<id> [<status>] <subject>…`. A result in other
+ * words changes nothing here; the row is then an ordinary one.
+ */
+export declare class PlanTracker {
+    #private;
+    /** A call that started: the list as it leaves it, or undefined when it is not a task call (or changes nothing). */
+    started(toolName: string, argumentsText: string, toolCallId: string): PlanItem[] | undefined;
+    /** A call that completed: the list as it now stands (a failed call's change undone; TaskList's result is the
+     *  list), so a finished row never shows an older list than the calls before it left. */
+    completed(toolCallId: string, output: string, isError: boolean): PlanItem[] | undefined;
+    private items;
+}
+/** What a subagent call says of its subagent, as VS Code's own subagent row shows it. */
+export interface SubagentCall {
+    description?: string;
+    agentName?: string;
+    prompt?: string;
+}
+/** A subagent call's description, kind and prompt (Claude Code's Task and Agent tools: `description`,
+ *  `subagent_type`, `prompt`), read from its own arguments; undefined for any other tool. */
+export declare function subagentCall(toolName: string, argumentsText: string): SubagentCall | undefined;
 /** The command line of a shell tool call, read from its own arguments; undefined for any other tool. */
 export declare function shellCommand(toolName: string, argumentsText: string): string | undefined;
 /** The information this view shows for a request payload. */
@@ -118,6 +200,14 @@ export declare function requestAnswers(request: FrontendRequest, connectionId: s
 export declare function typedAnswer(request: FrontendRequest, reply: string): FrontendResponse;
 /** The decisions a runtime said its harness accepts, when it said so. */
 export declare function acceptedDecisions(request: FrontendRequest): string[] | undefined;
+/**
+ * An elicitation that asks questions, the shape supercode's `ask_user` asks with and a hosted Claude Code's
+ * AskUserQuestion is raised as (`question-tool.mjs` `questionElicitation`): every property of its
+ * `requested_schema` is one question, with a `title`, the question alone (`x-question`) and its `x-options`
+ * (`[{label, description}]`, with `x-multi-select`; none for free text). Any other form (an MCP server's schema with
+ * its own `enum`, `format` or `required`) is undefined here and keeps the `Answer…` door, which honours them.
+ */
+export declare function requestQuestions(request: FrontendRequest): QuestionField[] | undefined;
 /** True when this request asks for content a button click cannot carry. */
 export declare function requestNeedsTypedReply(request: FrontendRequest): boolean;
 /**
@@ -147,6 +237,8 @@ export interface ProjectionContext {
      * buttons are absent rather than dead.
      */
     canRespond?: boolean;
+    /** The conversation's task list as its task tools change it; without one, those calls are ordinary rows. */
+    plan?: PlanTracker;
 }
 /** Pending requests belong to the live runtime, even when saved transcript
  * history predates them. Rehydrate their controls before waiting for new events. */
@@ -172,14 +264,6 @@ export interface ProjectedTurn {
     /** Rendered parts for an assistant turn. */
     parts?: ChatPart[];
 }
-/**
- * A "user" message no person typed: Claude Code's `<task-notification>` (a background task reporting back) or the
- * editor's automatic tripwire nudge or Claude's unmarked interruption record. None is shown as the person's words.
- * A task notification and interruption are short notices; a nudge is not shown. Undefined for a person's message.
- */
-export declare function automaticPrompt(body: string): {
-    notice?: string;
-} | undefined;
 export declare function projectReplayTurns(events: readonly FrontendEvent[], granted: ReadonlySet<string>, context: ProjectionContext, history?: readonly ProjectedTurn[]): ProjectedTurn[];
 /**
  * The attach snapshot's canonical history as chat turns. Bounded: when older
@@ -187,4 +271,4 @@ export declare function projectReplayTurns(events: readonly FrontendEvent[], gra
  */
 export declare function projectHistory(history: readonly (ChatMessage & {
     metadata?: Record<string, string>;
-})[], granted: ReadonlySet<string>, pendingToolNames?: ReadonlySet<string>): ProjectedTurn[];
+})[], granted: ReadonlySet<string>, pendingToolNames?: ReadonlySet<string>, plan?: PlanTracker): ProjectedTurn[];