@volter/supercode-frontend-vscode 0.1.61 → 0.1.63

package/dist/view.js

@@ -1,3 +1,4 @@
+import { userProvenance } from '../vendor/supercode-interchange/user-provenance.mjs';
 /**
  * The bounded projection this presentation package renders. Mirrors
  * `@volter/supercode-frontend-browser`'s rule: the view is size-bounded
@@ -173,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)
@@ -180,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()))
@@ -365,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')
@@ -439,18 +659,21 @@ export function projectPendingRequests(requests, context) {
 export function projectEvent(event, context) {
     const payload = payloadOf(event);
     switch (event.kind) {
-        // crates/harness/src/server.rs `submit_claimed` — the runtime's echo of the
-        // initial prompt, before `turn_started`. VS Code renders that request turn.
-        // A rejoined turn has no submitting handler; later runtime input is visible
+        // runtime-hosted.mjs `#submitClaimed` — the runtime's echo of the initial
+        // prompt, before `turn_started`. VS Code renders that request turn. A
+        // rejoined turn has no submitting handler; later runtime input is visible
         // within its live response and remains a user turn in canonical history.
+        // 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` })] : [];
             if (context.liveUserMessages) {
                 const body = text(payload.text);
-                const automatic = automaticPrompt(body);
-                if (automatic)
-                    return automatic.notice
-                        ? [stable({ part: 'markdown', value: `\n\n${automatic.notice}\n\n` })]
-                        : [];
                 const prefix = '\n\n**Additional input**\n\n';
                 const suffix = '\n\n';
                 const value = clamp(stripControls(body), VSCODE_CHAT_LIMITS.partCharacters - prefix.length - suffix.length);
@@ -469,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': {
@@ -478,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',
@@ -488,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 }],
@@ -505,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',
@@ -515,6 +751,9 @@ export function projectEvent(event, context) {
                         isError,
                         isComplete: true,
                         resultText: output,
+                        ...(plan ? { plan } : {}),
+                        ...(parentToolCallId ? { parentToolCallId } : {}),
+                        ...(background ? { background } : {}),
                     },
                     needs: 'chatParticipantAdditions',
                     fallback: [{
@@ -563,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.
@@ -575,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': {
@@ -603,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));
@@ -664,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) })];
@@ -671,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 },
@@ -730,47 +1011,65 @@ function messageText(message) {
         .join('\n');
 }
 /**
- * A "user" message no person typed: Claude Code's `<task-notification>` (a background task reporting back) or the
- * editor's automatic tripwire nudge or Claude's unmarked interruption record. None is shown as the person's words.
- * A task notification and interruption are short notices; a nudge is not shown. Undefined for a person's message.
+ * 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
+ * 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.
  */
-export function automaticPrompt(body) {
-    const trimmed = body.trimStart();
-    if (trimmed.startsWith('<task-notification>')) {
-        const tag = (name) => clamp(stripControls(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`).exec(trimmed)?.[1]?.trim() ?? ''), 200);
-        const summary = tag('summary');
-        const status = tag('status');
-        return { notice: `_Background task${status ? ` ${status}` : ''}${summary ? `: ${summary}` : ''}_` };
-    }
-    if (trimmed.startsWith('[Volter editor tripwire'))
-        return {};
-    // Claude persists this reserved notice as an unmarked user-role record.
-    if (trimmed.trimEnd() === '[Request interrupted by user]')
-        return { notice: '_Turn interrupted._' };
+function notPersonNotice(payload) {
+    if (payload.source === 'harness')
+        return noticeMarkdown(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}_` : '';
+}
+function editorNudge(body) {
+    return body.trimStart().startsWith('[Volter editor tripwire');
+}
 export function projectReplayTurns(events, granted, context, history = []) {
     // Join canonical history with its sequenced tail. Retained request/decision
     // events can be re-sequenced past history_cursor with no originating turn.
     // 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() }));
+    // 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();
+    for (const event of events) {
+        if (event.kind !== 'request_resolved')
+            continue;
+        const payload = payloadOf(event);
+        const response = payload.response;
+        if (typeof payload.request_id === 'number' && response?.kind === 'approval' && response.decision !== 'deny')
+            allowed.add(payload.request_id);
+    }
     let replayTurn = false;
     let streamedText;
     for (const event of events) {
-        if (event.kind === 'user_message') {
+        if (event.kind === 'request') {
+            const request = (payloadOf(event).request ?? payloadOf(event));
+            if (typeof request?.id === 'number' && allowed.has(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 automatic = automaticPrompt(text(payload.text));
-            if (automatic) {
-                if (!automatic.notice)
+            const shown = notPersonNotice(payload);
+            if (shown !== undefined) {
+                if (!shown)
                     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${automatic.notice}\n\n` };
+                const notice = { part: 'markdown', value: `\n\n${shown}\n\n` };
                 if (last.role === 'assistant' && last.parts)
                     last.parts.push(notice);
                 else
@@ -822,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.
@@ -870,17 +1169,16 @@ export function projectHistory(history, granted, pendingToolNames = new Set()) {
                     pushAssistant([{ part: 'markdown', value: clamp(stripControls(text), VSCODE_CHAT_LIMITS.partCharacters) }]);
                 continue;
             }
-            const automatic = automaticPrompt(body);
-            if (automatic) {
-                if (automatic.notice)
-                    pushAssistant([{ part: 'markdown', value: `\n\n${automatic.notice}\n\n` }]);
+            // The codec preserves the harness's provenance; the one rule reads it.
+            // Image-coordinate notes, compact summaries, task notifications and the
+            // 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);
+                if (notice)
+                    pushAssistant([{ part: 'markdown', value: `\n\n${notice}\n\n` }]);
                 continue;
             }
-            // The codec preserves the harness's provenance. Image-coordinate notes,
-            // compact summaries and injected context are not the person's words.
-            if (message.metadata?.isMeta === 'true' || message.metadata?.isCompactSummary === 'true' ||
-                message.metadata?.promptSource === 'system')
-                continue;
             toolRows.clear();
             turns.push({ role: 'user', prompt: clamp(stripControls(body), VSCODE_CHAT_LIMITS.partCharacters) });
             continue;
@@ -906,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,
@@ -913,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,
                 };
@@ -950,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.61",
+  "version": "0.1.63",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "repository": {
@@ -22,6 +22,7 @@
     "LICENSE-APACHE",
     "dist",
     "vendor/supercode-frontend",
+    "vendor/supercode-interchange",
     "scripts/pack-extension.mjs",
     "README.md",
     "NOTICE.md",

package/vendor/supercode-interchange/user-provenance.d.mts

@@ -0,0 +1,19 @@
+// Generated from sdk/interchange/user-provenance.mjs by scripts/user-provenance-copies.mjs (the pre-commit hook
+// runs it): edit that rule, not this file.
+export type UserSource = "person" | "harness";
+export interface UserProvenance {
+	source: UserSource;
+	/** The short line shown in place of a harness record, where one is shown. */
+	notice?: string;
+}
+export const CLAUDE_INTERRUPTION_TEXTS: readonly string[];
+export function isClaudeInterruption(text: unknown): boolean;
+export function userProvenance(
+	metadata: Readonly<Record<string, string>> | null | undefined,
+	text?: string,
+): UserProvenance;
+export function isHarnessAuthoredUser(
+	metadata: Readonly<Record<string, string>> | null | undefined,
+	text?: string,
+): boolean;
+export function claudeRecordProvenance(record: unknown): Record<string, string>;