@volter/supercode-frontend-vscode 0.1.62 → 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
@@ -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

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. */
@@ -179,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[];

package/dist/view.js

@@ -174,6 +174,26 @@ export function toolTitles(toolName, argumentsText) {
     }
     if (name === 'todowrite' || name === 'update_plan')
         return both('Updating the plan', 'Updated the plan');
+    if (name === 'taskcreate') {
+        const subject = field('subject');
+        if (subject)
+            return both(`Adding a task: ${plain(subject)}`, `Added a task: ${plain(subject)}`);
+    }
+    if (name === 'taskupdate') {
+        const id = field('taskId'), status = field('status');
+        if (id) {
+            const task = `task #${plain(id)}`;
+            if (status === 'in_progress')
+                return both(`Starting ${task}`, `Started ${task}`);
+            if (status === 'completed')
+                return both(`Completing ${task}`, `Completed ${task}`);
+            if (status === 'deleted')
+                return both(`Removing ${task}`, `Removed ${task}`);
+            return both(`Updating ${task}`, `Updated ${task}`);
+        }
+    }
+    if (name === TASK_LIST_TOOL)
+        return both('Reading the task list', 'Read the task list');
     // Claude Code names an MCP tool `mcp__<server>__<tool>`; VS Code writes "Ran `tool` – server".
     const mcp = /^mcp__(.+?)__(.+)$/.exec(toolName);
     if (mcp)
@@ -181,6 +201,159 @@ export function toolTitles(toolName, argumentsText) {
     const subject = toolSubject(argumentsText);
     return subject ? both(`Running ${code(toolName)} · ${plain(subject)}`, `Ran ${code(toolName)} · ${plain(subject)}`) : both(`Running ${code(toolName)}`, `Ran ${code(toolName)}`);
 }
+/** A hook's row as words, as VS Code titles its own (`chatHookContentPart.ts`): "Blocked by …" or "Warning from …". */
+export function hookSentence(hookEvent, blocked, reason) {
+    return `${blocked ? 'Blocked by' : 'Warning from'} the ${hookEvent} hook${reason ? `: ${reason}` : ''}`;
+}
+/** The hook events VS Code's own Chat names (`ChatHookType`), which are Claude Code's. */
+export const HOOK_TYPES = ['SessionStart', 'SessionEnd', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'PreCompact',
+    'SubagentStart', 'SubagentStop', 'Stop', 'ErrorOccurred'];
+/** Claude Code's TaskList tool, lower-cased as this view compares tool names. */
+const TASK_LIST_TOOL = 'tasklist'; // process-read: a Claude Code tool name, not the Windows command
+/** 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 function planItems(toolName, argumentsText) {
+    const name = toolName.toLowerCase();
+    if (name !== 'todowrite' && name !== 'update_plan')
+        return undefined;
+    const list = argumentFields(argumentsText)[name === 'todowrite' ? 'todos' : 'plan'];
+    if (!Array.isArray(list))
+        return undefined;
+    const items = list.flatMap((item) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            return [];
+        const fields = item;
+        const title = planTitle(name === 'todowrite' ? fields.content : fields.step);
+        return title ? [{ title, status: planStatus(fields.status) }] : [];
+    });
+    return items.length > 0 ? items : undefined;
+}
+function argumentFields(argumentsText) {
+    try {
+        const parsed = JSON.parse(argumentsText);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch { /* not JSON: no fields */ }
+    return {};
+}
+const planTitle = (value) => typeof value === 'string' ? clamp(stripControls(value.trim()), VSCODE_CHAT_LIMITS.titleCharacters) : '';
+/** Claude Code's task statuses (`pending`, `in_progress`, `completed`) as VS Code's own todo statuses. */
+const planStatus = (value) => value === 'completed' ? 'completed' : value === 'in_progress' ? 'in-progress' : 'not-started';
+/**
+ * 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 class PlanTracker {
+    #tasks = [];
+    #calls = new Map();
+    /** A call that started: the list as it leaves it, or undefined when it is not a task call (or changes nothing). */
+    started(toolName, argumentsText, toolCallId) {
+        const name = toolName.toLowerCase();
+        if (!['taskcreate', 'taskupdate', TASK_LIST_TOOL].includes(name))
+            return undefined;
+        const fields = argumentFields(argumentsText);
+        if (name === TASK_LIST_TOOL) {
+            this.#calls.set(toolCallId, { name });
+            return undefined;
+        }
+        if (name === 'taskcreate') {
+            const title = planTitle(fields.subject);
+            if (!title)
+                return undefined;
+            const created = { title, status: 'not-started' };
+            this.#tasks.push(created);
+            this.#calls.set(toolCallId, { name, created });
+            return this.items();
+        }
+        const id = typeof fields.taskId === 'string' ? fields.taskId : undefined;
+        const index = id === undefined ? -1 : this.#tasks.findIndex(task => task.id === id);
+        if (index < 0)
+            return undefined;
+        const task = this.#tasks[index];
+        const deleted = fields.status === 'deleted';
+        this.#calls.set(toolCallId, { name, before: { task: { ...task }, at: index, deleted } });
+        if (deleted)
+            this.#tasks.splice(index, 1);
+        else {
+            const title = planTitle(fields.subject);
+            // (changed in place, so a create still waiting for its id keeps its entry)
+            Object.assign(task, title ? { title } : {}, typeof fields.status === 'string' ? { status: planStatus(fields.status) } : {});
+        }
+        return this.items();
+    }
+    /** 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, output, isError) {
+        const call = this.#calls.get(toolCallId);
+        if (!call)
+            return undefined;
+        this.#calls.delete(toolCallId);
+        if (call.name === 'taskcreate' && call.created) {
+            const id = isError ? undefined : /^Task #(\S+) created successfully: /.exec(output)?.[1];
+            if (id !== undefined)
+                call.created.id = id;
+            // (a task Claude Code did not create is not on its list)
+            else
+                this.#tasks = this.#tasks.filter(task => task !== call.created);
+            return this.items();
+        }
+        if (call.name === 'taskupdate') {
+            const before = call.before;
+            if ((isError || !/^Updated task #/.test(output)) && before) {
+                if (before.deleted)
+                    this.#tasks.splice(Math.min(before.at, this.#tasks.length), 0, before.task);
+                else {
+                    const task = this.#tasks.find(other => other.id === before.task.id);
+                    if (task)
+                        Object.assign(task, { title: before.task.title, status: before.task.status });
+                }
+            }
+            return this.items();
+        }
+        if (isError)
+            return undefined;
+        if (output.trim() === 'No tasks found') {
+            this.#tasks = [];
+            return [];
+        }
+        const listed = output.split('\n').flatMap(line => {
+            const match = /^#(\S+) \[(\w+)\] (.*?)(?: \[blocked by [^\]]*\])?$/.exec(line);
+            const title = match ? planTitle(match[3]) : '';
+            return match && title ? [{ id: match[1], title, status: planStatus(match[2]) }] : [];
+        });
+        if (listed.length === 0)
+            return undefined;
+        this.#tasks = listed;
+        return this.items();
+    }
+    items() {
+        return this.#tasks.map(({ title, status }) => ({ title, status }));
+    }
+}
+/** 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 function subagentCall(toolName, argumentsText) {
+    if (!['task', 'agent'].includes(toolName.toLowerCase()))
+        return undefined;
+    const fields = argumentFields(argumentsText);
+    const field = (name, limit) => {
+        const value = fields[name];
+        return typeof value === 'string' && value.trim() ? clamp(stripControls(value.trim()), limit) : undefined;
+    };
+    const description = field('description', VSCODE_CHAT_LIMITS.titleCharacters);
+    const agentName = field('subagent_type', VSCODE_CHAT_LIMITS.titleCharacters);
+    const prompt = field('prompt', VSCODE_CHAT_LIMITS.partCharacters);
+    return { ...(description ? { description } : {}), ...(agentName ? { agentName } : {}), ...(prompt ? { prompt } : {}) };
+}
 /** The command line of a shell tool call, read from its own arguments; undefined for any other tool. */
 export function shellCommand(toolName, argumentsText) {
     if (!['bash', 'shell', 'exec_command', 'local_shell', 'powershell'].includes(toolName.toLowerCase()))
@@ -366,6 +539,52 @@ export function acceptedDecisions(request) {
     const decisions = declared.filter((entry) => typeof entry === 'string');
     return decisions.length > 0 ? decisions : 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 function requestQuestions(request) {
+    if (request.kind !== 'elicitation')
+        return undefined;
+    const payload = request.payload;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return undefined;
+    const schema = payload.requested_schema;
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema))
+        return undefined;
+    const properties = schema.properties;
+    if (!properties || typeof properties !== 'object' || Array.isArray(properties))
+        return undefined;
+    const fields = [];
+    for (const [key, value] of Object.entries(properties)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return undefined;
+        const property = value;
+        const title = typeof property.title === 'string' ? clamp(stripControls(property.title.trim()), VSCODE_CHAT_LIMITS.titleCharacters) : '';
+        if (!title)
+            return undefined;
+        const listed = property['x-options'];
+        if (typeof property['x-question'] !== 'string' || !Array.isArray(listed))
+            return undefined;
+        const options = listed.flatMap(option => {
+            if (!option || typeof option !== 'object' || Array.isArray(option) || typeof option.label !== 'string' || !option.label.trim())
+                return [];
+            const label = clamp(stripControls(option.label.trim()), VSCODE_CHAT_LIMITS.titleCharacters);
+            const description = typeof option.description === 'string' && option.description.trim()
+                ? clamp(stripControls(option.description.trim()), VSCODE_CHAT_LIMITS.titleCharacters) : undefined;
+            return [{ label, ...(description ? { description } : {}) }];
+        });
+        // The question alone (`x-question`) where the elicitation states it: its `description` repeats the options for
+        // a frontend that cannot show them, and the carousel shows them itself.
+        const asked = clamp(stripControls(property['x-question'].trim()), VSCODE_CHAT_LIMITS.partCharacters);
+        const message = asked && asked !== title ? asked : undefined;
+        fields.push({ key, title, ...(message ? { message } : {}), options, multiSelect: property['x-multi-select'] === true });
+    }
+    return fields.length > 0 ? fields : undefined;
+}
 /** True when this request asks for content a button click cannot carry. */
 export function requestNeedsTypedReply(request) {
     if (request.kind === 'approval')
@@ -447,6 +666,9 @@ export function projectEvent(event, context) {
         // The harness's own user-role records (runtime-native-projection.mjs
         // `claudeBlocks`) arrive stamped `source: 'harness'`: a notice or nothing.
         case 'user_message': {
+            // (a subagent's own input, `parent_id`: what it was asked is on its row)
+            if (text(payload.parent_id))
+                return [];
             const notice = notPersonNotice(payload);
             if (notice !== undefined)
                 return notice ? [stable({ part: 'markdown', value: `\n\n${notice}\n\n` })] : [];
@@ -470,6 +692,10 @@ export function projectEvent(event, context) {
             return [];
         // crates/runtime/src/event.rs `AgentEvent::TextDelta`.
         case 'text_delta':
+            // A subagent's own words (`parent_id`): VS Code's own subagent row shows its calls and its answer, not its
+            // running text, which would otherwise read as the agent's reply.
+            if (text(payload.parent_id))
+                return [];
             return [stable({ part: 'markdown', value: text(payload.text) })];
         // crates/runtime/src/event.rs `AgentEvent::ToolCallStarted`.
         case 'tool_call_started': {
@@ -479,6 +705,9 @@ export function projectEvent(event, context) {
             const inputText = clamp(stripControls(parseArguments(rawArguments)), VSCODE_CHAT_LIMITS.partCharacters);
             const titles = toolTitles(toolName, rawArguments);
             const commandLine = shellCommand(toolName, rawArguments);
+            const plan = planItems(toolName, rawArguments) ?? context.plan?.started(toolName, rawArguments, toolCallId);
+            const subagent = subagentCall(toolName, rawArguments);
+            const parentToolCallId = text(payload.parent_id);
             return [{
                     emit: {
                         part: 'tool',
@@ -489,6 +718,9 @@ export function projectEvent(event, context) {
                         inputText,
                         isComplete: false,
                         ...(commandLine ? { commandLine } : {}),
+                        ...(plan ? { plan } : {}),
+                        ...(subagent ? { subagent } : {}),
+                        ...(parentToolCallId ? { parentToolCallId } : {}),
                     },
                     needs: 'chatParticipantAdditions',
                     fallback: [{ part: 'progress', value: titles.invocation }],
@@ -506,6 +738,9 @@ export function projectEvent(event, context) {
             // The titles stay the ones the call started with (the writer keeps them per call); a completion that names its
             // tool without having started on this stream is titled by that name.
             const titles = toolName ? toolTitles(toolName, text(payload.arguments)) : undefined;
+            const parentToolCallId = text(payload.parent_id);
+            const plan = context.plan?.completed(toolCallId, text(payload.output), isError);
+            const background = payload.background === true;
             return [{
                     emit: {
                         part: 'tool',
@@ -516,6 +751,9 @@ export function projectEvent(event, context) {
                         isError,
                         isComplete: true,
                         resultText: output,
+                        ...(plan ? { plan } : {}),
+                        ...(parentToolCallId ? { parentToolCallId } : {}),
+                        ...(background ? { background } : {}),
                     },
                     needs: 'chatParticipantAdditions',
                     fallback: [{
@@ -564,9 +802,11 @@ export function projectEvent(event, context) {
             const summary = requestSummary(request);
             const answers = requestAnswers(request, context.connectionId);
             const subject = requestSubject(request);
+            const asked = requestQuestions(request);
             const title = request.kind === 'approval'
                 ? subject ? `Allow ${stripControls(subject)}?` : 'Approval required'
-                : subject ? `Approve ${subject}` : `Assistant request #${request.id}`;
+                : asked ? asked.length === 1 ? asked[0].title : `${asked.length} questions`
+                    : subject ? `Approve ${subject}` : `Assistant request #${request.id}`;
             // The host capability decides whether these original answers can use
             // a native in-turn confirmation card. Stock confirmation clicks start a
             // new chat request, so stable command buttons remain the fallback.
@@ -576,13 +816,22 @@ export function projectEvent(event, context) {
                         value: `\n\n**${title}**\n\n${summary}\n\n_This runtime answers its own requests; Volter Harness is observing._\n\n`,
                     })];
             }
-            return [stable({
-                    part: 'answers',
-                    approval: request.kind === 'approval',
-                    title: clamp(title, VSCODE_CHAT_LIMITS.titleCharacters),
-                    message: summary,
-                    answers,
-                })];
+            const buttons = {
+                part: 'answers',
+                approval: request.kind === 'approval',
+                title: clamp(title, VSCODE_CHAT_LIMITS.titleCharacters),
+                message: summary,
+                answers,
+            };
+            // A harness's questions: VS Code's own carousel, answered inside the running turn.
+            if (asked) {
+                return [{
+                        emit: { part: 'questions', connectionId: context.connectionId, requestId: request.id, questions: asked, fallback: buttons },
+                        needs: 'chatParticipantAdditions',
+                        fallback: [buttons],
+                    }];
+            }
+            return [stable(buttons)];
         }
         // crates/harness/src/server.rs `FrontendRequestBroker::respond`.
         case 'request_resolved': {
@@ -604,10 +853,29 @@ export function projectEvent(event, context) {
                     fallback: [{ part: 'markdown', value: `> ⚠ ${message}` }],
                 }];
         }
+        // A harness hook that blocked or warned (`runtime-native-projection.mjs`, from Claude Code's own hook records).
+        // VS Code's own hook row, for the hook events it names; its words otherwise. In the pinned host `push` of this part
+        // checks no proposal and `hookProgress` checks `chatParticipantAdditions`; `chatHooks` gates nothing this frontend
+        // uses. It is keyed to `chatParticipantAdditions` with the other proposed parts, so a host without it gets words.
+        case 'hook': {
+            const hookType = HOOK_TYPES.find(type => type === text(payload.hook_event));
+            const reason = clamp(stripControls(text(payload.reason)), VSCODE_CHAT_LIMITS.partCharacters);
+            const blocked = payload.blocked === true;
+            const said = hookSentence(text(payload.hook_event, 'harness'), blocked, reason);
+            return [{
+                    emit: hookType ? { part: 'hook', hookType, blocked, reason } : { part: 'warning', value: said },
+                    needs: 'chatParticipantAdditions',
+                    fallback: [{ part: 'markdown', value: `> ⚠ ${said}` }],
+                }];
+        }
         // crates/runtime/src/event.rs `AgentEvent::Usage`.
         // Token counts are not conversation: VS Code's own chat keeps them out of the transcript.
         case 'usage':
             return [];
+        // The harness's background tasks are the session's state (`session.ts` lists them while a turn runs, each with
+        // its Stop), not conversation.
+        case 'background_tasks':
+            return [];
         // crates/runtime/src/event.rs `AgentEvent::BackgroundOutput`.
         case 'background_output': {
             const chunk = fence(clamp(stripControls(text(payload.chunk)), VSCODE_CHAT_LIMITS.partCharacters));
@@ -665,6 +933,15 @@ export function projectEvent(event, context) {
         case 'native_event':
             return [];
         case 'status':
+            // A subagent's task finishing (`call_id` names the subagent call): its answer belongs to that call's row (or to
+            // the agent's reply, for a subagent started in the background), so the notice is its first line, and the task's
+            // output file where it names one (a background shell's notice names the same call).
+            if (text(payload.call_id)) {
+                const lines = stripControls(text(payload.message)).split('\n');
+                const output = lines.find(line => line.startsWith('Output: ') && line.length > 8);
+                const line = [clamp((lines[0] ?? '').trim(), VSCODE_CHAT_LIMITS.titleCharacters), output].filter(Boolean).join('\n');
+                return line ? [stable({ part: 'progress', value: clamp(line, VSCODE_CHAT_LIMITS.partCharacters) })] : [];
+            }
             return [stable({ part: 'progress', value: clamp(stripControls(text(payload.message)), VSCODE_CHAT_LIMITS.partCharacters) })];
         case 'warning':
             return [stable({ part: 'warning', value: clamp(stripControls(text(payload.message)), VSCODE_CHAT_LIMITS.partCharacters) })];
@@ -672,6 +949,9 @@ export function projectEvent(event, context) {
         // sdk/interchange/frontend-transcript.mjs reads a donor that emits them.
         case 'reasoning':
         case 'thinking': {
+            // (a subagent's own reasoning, `parent_id`, as its running text above)
+            if (text(payload.parent_id))
+                return [];
             const body = clamp(stripControls(text(payload.text ?? payload.summary, opaqueText(event.payload))), VSCODE_CHAT_LIMITS.partCharacters);
             return [{
                     emit: { part: 'thinking', value: body },
@@ -776,7 +1056,8 @@ export function projectReplayTurns(events, granted, context, history = []) {
             if (typeof request?.id === 'number' && allowed.has(request.id))
                 continue;
         }
-        if (event.kind === 'user_message') {
+        // (a subagent's own input is no turn of the conversation; `projectEvent` draws nothing for it)
+        if (event.kind === 'user_message' && !text(payloadOf(event).parent_id)) {
             streamedText = undefined;
             const payload = payloadOf(event);
             const shown = notPersonNotice(payload);
@@ -840,7 +1121,7 @@ export function projectReplayTurns(events, granted, context, history = []) {
  * The attach snapshot's canonical history as chat turns. Bounded: when older
  * turns are omitted the view says so, the way the browser observer does.
  */
-export function projectHistory(history, granted, pendingToolNames = new Set()) {
+export function projectHistory(history, granted, pendingToolNames = new Set(), plan = new PlanTracker()) {
     const turns = [];
     // Keep results inside the native invocation, as the live stream does. A
     // separate Markdown result bypasses the editor's collapsed tool-step group.
@@ -923,6 +1204,8 @@ export function projectHistory(history, granted, pendingToolNames = new Set()) {
             for (const call of message.tool_calls ?? []) {
                 const titles = toolTitles(call.function.name, call.function.arguments);
                 const commandLine = shellCommand(call.function.name, call.function.arguments);
+                const items = planItems(call.function.name, call.function.arguments) ?? plan.started(call.function.name, call.function.arguments, call.id);
+                const subagent = subagentCall(call.function.name, call.function.arguments);
                 const row = {
                     part: 'tool',
                     toolName: call.function.name,
@@ -930,6 +1213,8 @@ export function projectHistory(history, granted, pendingToolNames = new Set()) {
                     invocationMessage: titles.invocation,
                     pastTenseMessage: titles.pastTense,
                     ...(commandLine ? { commandLine } : {}),
+                    ...(items ? { plan: items } : {}),
+                    ...(subagent ? { subagent } : {}),
                     inputText: clamp(stripControls(parseArguments(call.function.arguments)), VSCODE_CHAT_LIMITS.partCharacters),
                     isComplete: true,
                 };
@@ -967,6 +1252,9 @@ export function projectHistory(history, granted, pendingToolNames = new Set()) {
                 // establish failure; do not guess from arbitrary result prose.
                 if (body === '[no tool result recorded — turn interrupted]' || (Array.isArray(message.content) && message.content.some(part => part && typeof part === 'object' && !Array.isArray(part) && part.is_error === true)))
                     row.isError = true;
+                const items = plan.completed(message.tool_call_id, body, row.isError === true);
+                if (items)
+                    row.plan = items;
                 toolRows.delete(message.tool_call_id);
             }
             else {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.62",
+  "version": "0.1.63",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "repository": {