@volter/supercode-frontend-vscode 0.1.62 → 0.1.64

package/dist/view.js

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