@volter/supercode-frontend-vscode 0.1.11

package/dist/view.js

@@ -0,0 +1,717 @@
+/**
+ * The bounded projection this presentation package renders. Mirrors
+ * `@volter/supercode-frontend-browser`'s rule: the view is size-bounded
+ * and says so when it omits something; the runtime's own history is unchanged
+ * and remains authoritative.
+ */
+export const VSCODE_CHAT_LIMITS = Object.freeze({
+    partCharacters: 64 * 1024,
+    titleCharacters: 256,
+    opaqueCharacters: 2 * 1024,
+    historyTurns: 500,
+});
+const stable = (emit) => ({ emit });
+function clamp(text, limit) {
+    const characters = [...text];
+    return characters.length <= limit ? text : `${characters.slice(0, limit - 1).join('')}…`;
+}
+const CONTROL_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f\u009b]/gu;
+function stripControls(text) {
+    return text.replace(CONTROL_CHARACTERS, '');
+}
+/** Markdown-safe rendering of an arbitrary JSON payload, bounded. */
+export function opaqueText(value, limit = VSCODE_CHAT_LIMITS.opaqueCharacters) {
+    let rendered;
+    if (typeof value === 'string')
+        rendered = value;
+    else {
+        try {
+            rendered = JSON.stringify(value) ?? String(value);
+        }
+        catch {
+            rendered = '<unavailable>';
+        }
+    }
+    return clamp(stripControls(rendered), limit);
+}
+/** A fenced block that its own content cannot break out of. */
+export function fence(body, language = '') {
+    const longest = [...body.matchAll(/`{3,}/g)].reduce((max, match) => Math.max(max, match[0].length), 2);
+    const ticks = '`'.repeat(Math.max(3, longest + 1));
+    return `${ticks}${language}\n${body}\n${ticks}`;
+}
+/**
+ * The files a unified diff says it touched, read from its own `+++ b/<path>`
+ * headers. Nothing else is derived from the diff: this frontend never rebuilds
+ * edits from it (see the `diff_updated` arm).
+ */
+export function diffPaths(diff) {
+    const paths = [];
+    for (const line of diff.split('\n')) {
+        const match = /^\+\+\+ (?:b\/)?(.+?)(?:\t.*)?$/.exec(line);
+        const value = match?.[1]?.trim();
+        if (value && value !== '/dev/null' && !paths.includes(value))
+            paths.push(value);
+    }
+    return paths;
+}
+function payloadOf(event) {
+    return event.payload && typeof event.payload === 'object' && !Array.isArray(event.payload)
+        ? event.payload
+        : {};
+}
+function text(value, fallback = '') {
+    if (typeof value === 'string')
+        return value;
+    if (value === undefined || value === null)
+        return fallback;
+    return opaqueText(value);
+}
+function parseArguments(value) {
+    try {
+        return JSON.stringify(JSON.parse(value), null, 2);
+    }
+    catch {
+        return value;
+    }
+}
+/**
+ * The one-line subject a tool call is about, read from its own arguments.
+ * The editor renders `invocationMessage` verbatim, so a bare tool name is a
+ * wasted row; `write_file · hello.txt` says what it did.
+ */
+export function toolSubject(argumentsText) {
+    let parsed;
+    try {
+        parsed = JSON.parse(argumentsText);
+    }
+    catch {
+        return undefined;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return undefined;
+    const fields = parsed;
+    for (const field of ['path', 'file', 'file_path', 'command', 'pattern', 'query', 'url', 'job_id']) {
+        const value = fields[field];
+        if (typeof value === 'string' && value.length > 0)
+            return clamp(stripControls(value), 120);
+    }
+    return undefined;
+}
+/** The summary line this view shows for a request payload. */
+export function requestSummary(request) {
+    const payload = request.payload;
+    if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+        const fields = payload;
+        // `decide_approval` in crates/harness/src/server.rs publishes
+        // `{tool, subject, raw_args}` and `ask_elicitation` publishes
+        // `{message, requested_schema}`; the contract's own conformance fixture
+        // (sdk/frontend/test/fixtures/conformance.json) carries `{tool_name,
+        // arguments}`. The payload is opaque by design, so this reads whichever
+        // naming a runtime uses and falls back to bounded JSON.
+        for (const field of ['subject', 'message', 'tool', 'tool_name', 'summary', 'prompt', 'reason']) {
+            const value = fields[field];
+            if (typeof value === 'string')
+                return clamp(stripControls(value), VSCODE_CHAT_LIMITS.partCharacters);
+        }
+    }
+    return opaqueText(payload);
+}
+/** The answers this view offers for a request, one button each. */
+export function requestAnswers(request, connectionId) {
+    const base = { connectionId, requestId: request.id };
+    if (request.kind === 'approval') {
+        const all = [
+            { ...base, label: 'Allow', response: { kind: 'approval', request_id: request.id, decision: 'allow' } },
+            {
+                ...base,
+                label: 'Allow for session',
+                response: { kind: 'approval', request_id: request.id, decision: 'allow_for_session' },
+            },
+            { ...base, label: 'Deny', response: { kind: 'approval', request_id: request.id, decision: 'deny' } },
+        ];
+        // A runtime may state which decisions its own harness protocol can carry
+        // (`hosted_answerable_decisions` in crates/harness/src/runtime/hosted.rs —
+        // Claude Code's permission-prompt-tool has allow and deny and no
+        // always-allow BEHAVIOR at all). Offer exactly those rather than a button
+        // the runtime would refuse.
+        const accepted = acceptedDecisions(request);
+        if (accepted) {
+            return all.filter((answer) => answer.response.kind === 'approval' && accepted.includes(answer.response.decision));
+        }
+        return all;
+    }
+    const kind = request.kind === 'elicitation' ? 'elicitation' : 'other';
+    const needsContent = requestNeedsTypedReply(request);
+    return [
+        {
+            ...base,
+            label: needsContent ? 'Answer…' : 'Accept',
+            response: { kind, request_id: request.id, action: 'accept' },
+            promptForContent: needsContent,
+        },
+        { ...base, label: 'Decline', response: { kind, request_id: request.id, action: 'decline' } },
+        { ...base, label: 'Cancel', response: { kind, request_id: request.id, action: 'cancel' } },
+    ];
+}
+/**
+ * The typed-reply path, for a request that is still pending when the turn is
+ * NOT running: the person types the answer as the next message.
+ */
+export function typedAnswer(request, reply) {
+    const normalized = reply.trim().toLowerCase();
+    if (request.kind === 'approval') {
+        if (['allow for session', 'allow_for_session', 'session'].includes(normalized)) {
+            return { kind: 'approval', request_id: request.id, decision: 'allow_for_session' };
+        }
+        if (['deny', 'no', 'reject'].includes(normalized)) {
+            return { kind: 'approval', request_id: request.id, decision: 'deny' };
+        }
+        return { kind: 'approval', request_id: request.id, decision: 'allow' };
+    }
+    const kind = request.kind === 'elicitation' ? 'elicitation' : 'other';
+    if (['cancel', 'stop'].includes(normalized))
+        return { kind, request_id: request.id, action: 'cancel' };
+    if (['decline', 'no'].includes(normalized))
+        return { kind, request_id: request.id, action: 'decline' };
+    return { kind, request_id: request.id, action: 'accept', content: reply };
+}
+/** The decisions a runtime said its harness accepts, when it said so. */
+export function acceptedDecisions(request) {
+    const payload = request.payload;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return undefined;
+    const declared = payload.decisions;
+    if (!Array.isArray(declared))
+        return undefined;
+    const decisions = declared.filter((entry) => typeof entry === 'string');
+    return decisions.length > 0 ? decisions : undefined;
+}
+/** True when this request asks for content a button click cannot carry. */
+export function requestNeedsTypedReply(request) {
+    if (request.kind === 'approval')
+        return false;
+    const payload = request.payload;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return false;
+    const schema = payload.requested_schema;
+    return schema !== undefined && schema !== null;
+}
+/**
+ * The resolution of a request as a sentence, built from the response's own
+ * fields and the request it answers — never the raw JSON, which says the same
+ * thing in a form only this protocol's authors can read.
+ */
+export function resolutionSentence(response, request, requestId) {
+    const about = request ? requestSubject(request) : undefined;
+    const suffix = about ? ` ${about}` : ` request #${requestId}`;
+    if (!response)
+        return `Resolved${suffix}`;
+    if (response.kind === 'approval') {
+        const verb = { allow: 'Allowed', allow_for_session: 'Allowed for session', deny: 'Denied' }[response.decision];
+        return `${verb ?? 'Resolved'}${suffix}`;
+    }
+    const verb = { accept: 'Accepted', decline: 'Declined', cancel: 'Cancelled' }[response.action];
+    const content = typeof response.content === 'string' && response.content.length > 0
+        ? ` — ${clamp(stripControls(response.content), 160)}`
+        : '';
+    return `${verb ?? 'Resolved'}${suffix}${content}`;
+}
+/** `write_file on hello.txt`, read from the request's own payload. */
+export function requestSubject(request) {
+    const payload = request.payload;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return undefined;
+    const fields = payload;
+    const tool = typeof fields.tool === 'string' ? fields.tool
+        : typeof fields.tool_name === 'string' ? fields.tool_name
+            : undefined;
+    const subject = typeof fields.subject === 'string' ? fields.subject
+        : typeof fields.raw_args === 'string' ? fields.raw_args
+            : typeof fields.arguments === 'object' && fields.arguments !== null && !Array.isArray(fields.arguments)
+                ? toolSubject(JSON.stringify(fields.arguments))
+                : undefined;
+    if (tool && subject)
+        return `${tool} on ${clamp(stripControls(subject), 120)}`;
+    if (tool)
+        return tool;
+    if (subject)
+        return clamp(stripControls(subject), 120);
+    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) {
+    return Array.from(requests).flatMap(request => projectEvent({
+        sequence: 0, kind: 'request', payload: { type: 'request', request },
+    }, context));
+}
+/**
+ * The event to chat-response-part mapping. Pure: every input is the runtime's
+ * own sequenced event, every output describes a VS Code chat part. Each arm
+ * names the producer it reads.
+ */
+export function projectEvent(event, context) {
+    const payload = payloadOf(event);
+    // Hosted Codex 0.4.38 labels terminal polling/output notifications as tool
+    // starts with null ids/names. The actual command item carries its identity,
+    // command and final output; render that item rather than anonymous tool rows.
+    const raw = payload.raw && typeof payload.raw === 'object' && !Array.isArray(payload.raw) ? payload.raw : {};
+    if (event.kind === 'tool_call_started' && !payload.id && !payload.name &&
+        ['item/commandExecution/terminalInteraction', 'item/commandExecution/outputDelta'].includes(text(raw.method)))
+        return [];
+    // Hosted harnesses retain transport metadata in replay. Known lifecycle
+    // notices are not assistant prose; unknown events still use the bounded fallback.
+    if (event.kind === 'native_event') {
+        const object = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+        const raw = object(payload.raw);
+        const params = object(raw.params);
+        const kind = text(payload.kind).toLowerCase();
+        const item = object(params.item);
+        if (['item/started', 'item/completed'].includes(kind) && item.type === 'commandExecution' && typeof item.id === 'string') {
+            return projectEvent({ ...event, kind: kind === 'item/started' ? 'tool_call_started' : 'tool_call_completed', payload: {
+                    id: item.id, name: 'Shell', arguments: JSON.stringify({ command: item.command, cwd: item.cwd }),
+                    output: item.aggregatedOutput ?? '', is_error: typeof item.exitCode === 'number' && item.exitCode !== 0,
+                } }, context);
+        }
+        if (['turn/started', 'thread/started', 'thread/status/changed', 'thread/tokenusage/updated', 'account/ratelimits/updated', 'remotecontrol/status/changed', 'thread/goal/cleared'].includes(kind))
+            return [];
+        if (['item/started', 'item/completed'].includes(kind) && ['userMessage', 'agentMessage', 'reasoning'].includes(text(object(params.item).type)))
+            return [];
+        if (kind === 'mcpserver/startupstatus/updated') {
+            if (params.error)
+                return [stable({ part: 'warning', value: text(params.error) })];
+            if (['starting', 'ready'].includes(text(params.status)))
+                return [];
+        }
+        if (kind === 'deprecationnotice')
+            return [stable({ part: 'progress', value: text(params.summary, 'Harness deprecation notice') })];
+        if (kind === 'system') {
+            if (['init', 'hook_started', 'thinking_tokens'].includes(text(raw.subtype)))
+                return [];
+            if (raw.subtype === 'hook_response' && raw.exit_code === 0)
+                return [];
+        }
+    }
+    switch (event.kind) {
+        // crates/harness/src/server.rs `submit_claimed` — the runtime's echo of the
+        // prompt. VS Code already renders the request turn, so the live view drops
+        // its own echo; only the session-history projection reads it.
+        case 'user_message':
+            return context.echoOwnPrompts
+                ? [stable({ part: 'markdown', value: clamp(stripControls(text(payload.text)), VSCODE_CHAT_LIMITS.partCharacters) })]
+                : [];
+        // crates/harness/src/server.rs `submit_claimed`, and
+        // crates/runtime/src/event.rs `AgentEvent::TurnCompleted` (one model
+        // round-trip). Lifecycle only — the turn resolves on these, never renders.
+        case 'turn_started':
+        case 'turn_completed':
+        case 'turn_succeeded':
+            return [];
+        // crates/runtime/src/event.rs `AgentEvent::TextDelta`.
+        case 'text_delta':
+            return [stable({ part: 'markdown', value: text(payload.text) })];
+        // crates/runtime/src/event.rs `AgentEvent::ToolCallStarted`.
+        case 'tool_call_started': {
+            const toolName = text(payload.name, 'tool');
+            const toolCallId = text(payload.id, `event-${event.sequence}`);
+            const rawArguments = text(payload.arguments);
+            const inputText = clamp(stripControls(parseArguments(rawArguments)), VSCODE_CHAT_LIMITS.partCharacters);
+            const subject = toolSubject(rawArguments);
+            return [{
+                    emit: {
+                        part: 'tool',
+                        toolName,
+                        toolCallId,
+                        invocationMessage: clamp(subject ? `${toolName} · ${subject}` : toolName, VSCODE_CHAT_LIMITS.titleCharacters),
+                        inputText,
+                        isComplete: false,
+                    },
+                    needs: 'chatParticipantAdditions',
+                    fallback: [{
+                            part: 'progress',
+                            value: clamp(subject ? `${toolName} · ${subject}` : toolName, VSCODE_CHAT_LIMITS.titleCharacters),
+                        }],
+                }];
+        }
+        // crates/runtime/src/event.rs `AgentEvent::ToolCallCompleted`.
+        case 'tool_call_completed': {
+            // A harness may name the tool only when the call STARTS — Claude Code's
+            // `tool_result` block carries just the `tool_use_id` it answers — so an
+            // empty name here means "same row", not a tool called `tool`.
+            const toolName = text(payload.name, '');
+            const toolCallId = text(payload.id, `event-${event.sequence}`);
+            const output = clamp(stripControls(text(payload.output)), VSCODE_CHAT_LIMITS.partCharacters);
+            const isError = payload.is_error === true;
+            return [{
+                    emit: {
+                        part: 'tool',
+                        toolName,
+                        toolCallId,
+                        invocationMessage: clamp(toolName, VSCODE_CHAT_LIMITS.titleCharacters),
+                        pastTenseMessage: clamp(toolName, VSCODE_CHAT_LIMITS.titleCharacters),
+                        isError,
+                        isComplete: true,
+                        resultText: output,
+                    },
+                    needs: 'chatParticipantAdditions',
+                    fallback: [{
+                            part: 'markdown',
+                            value: `**${isError ? 'Tool failed' : 'Tool result'}${toolName ? ` · ${toolName}` : ''}**\n\n${fence(output)}`,
+                        }],
+                }];
+        }
+        // crates/codex-frontend/src/codex_app_server_v0_144.rs maps a stock Codex
+        // `turn/diff/updated` onto this kind. MEASURED: its payload carries ONE
+        // unified-diff string (`payload.diff`) and nothing else — no per-file
+        // edits, no resources, no applier. So none of the editor's richer edit
+        // parts can be built from it without inventing data:
+        //   ChatResponseTextEditPart  — wants TextEdit ranges, and the runtime has
+        //     ALREADY written the file, so replaying them would double-apply.
+        //   ChatResponseMultiDiffPart — wants an originalUri and a modifiedUri per
+        //     file, i.e. two resources holding before/after content this frontend
+        //     would have to fabricate and serve.
+        //   ChatResponseExternalEditPart — brackets a callback that PERFORMS the
+        //     edit so the editor can take a before snapshot; ours would be a no-op
+        //     after the write, making the editor's undo stop wrong.
+        // What the payload does state is which files it touched, so this renders
+        // the diff as a `codeblockUri`-bound diff block plus one stable reference
+        // per named file.
+        case 'diff_updated': {
+            const diff = clamp(stripControls(text(payload.diff)), VSCODE_CHAT_LIMITS.partCharacters);
+            const block = fence(diff, 'diff');
+            return [
+                {
+                    emit: { part: 'codeblock', uri: 'supercode-diff:/turn.diff', value: block, language: 'diff' },
+                    needs: 'chatParticipantAdditions',
+                    fallback: [{ part: 'markdown', value: block }],
+                },
+                ...diffPaths(diff).map((file) => stable({ part: 'reference', path: file })),
+            ];
+        }
+        // crates/harness/src/server.rs `FrontendRequestBroker::publish`.
+        case 'request': {
+            const request = (payload.request ?? payload);
+            if (!request || typeof request.id !== 'number') {
+                return [stable({
+                        part: 'markdown',
+                        value: `**supercode** · malformed request event\n\n${fence(opaqueText(event.payload), 'json')}`,
+                    })];
+            }
+            const summary = requestSummary(request);
+            const answers = requestAnswers(request, context.connectionId);
+            const subject = requestSubject(request);
+            const title = subject
+                ? `Approve ${subject}`
+                : `${request.kind === 'approval' ? 'Approval' : 'Assistant'} request #${request.id}`;
+            // Command buttons, and MEASURED rather than assumed. Two richer
+            // mechanisms were tried against a live runtime in the editor's own Chat
+            // view and both failed, so neither ships:
+            //   `ChatResponseConfirmationPart` retires its own buttons on click, but
+            //     the click answers by sending a NEW chat request, and a supercode
+            //     approval is raised while the turn still runs (`decide_approval`
+            //     blocks the agent loop) — the editor refuses that request, so the
+            //     click does nothing and the runtime waits forever.
+            //   `stream.questionCarousel` resolves inside the running turn and the
+            //     widget retires itself — the right shape on paper. Observed: the
+            //     widget renders with its options, Submit retires it, and the
+            //     promise never delivers an answer this frontend can read, so the
+            //     runtime is left blocked. A preferred path that silently swallows
+            //     the answer is worse than a plain one that works.
+            // A command button runs inside the live turn and carries its own answer,
+            // so all three approval decisions are offered. It cannot be withdrawn
+            // once pushed (`chatCommandContentPart` enables on `!isStale` and has no
+            // used-state), so `supercode.frontend.respond` refuses a request that is
+            // no longer pending and SAYS so instead of sending a stale answer.
+            if (context.canRespond === false) {
+                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({
+                    part: 'answers',
+                    title: clamp(title, VSCODE_CHAT_LIMITS.titleCharacters),
+                    message: summary,
+                    answers,
+                })];
+        }
+        // crates/harness/src/server.rs `FrontendRequestBroker::respond`.
+        case 'request_resolved': {
+            const requestId = typeof payload.request_id === 'number' ? payload.request_id : Number.NaN;
+            const response = payload.response;
+            const sentence = resolutionSentence(response, context.pendingRequest?.(requestId), requestId);
+            return [stable({ part: 'markdown', value: `\n\n_${sentence}_\n\n` })];
+        }
+        // crates/runtime/src/event.rs `AgentEvent::CacheWarning`.
+        case 'cache_warning': {
+            const message = clamp(stripControls(text(payload.message)), VSCODE_CHAT_LIMITS.partCharacters);
+            return [{
+                    emit: { part: 'warning', value: message },
+                    needs: 'chatParticipantAdditions',
+                    fallback: [{ part: 'markdown', value: `> ⚠ ${message}` }],
+                }];
+        }
+        // crates/runtime/src/event.rs `AgentEvent::Usage`.
+        case 'usage':
+            return [stable({
+                    part: 'progress',
+                    value: `prompt ${text(payload.prompt_tokens, '?')} · completion ${text(payload.completion_tokens, '?')} · total ${text(payload.total_tokens, '?')} tokens`,
+                })];
+        // 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`.
+        case 'turn_interrupted':
+            return [stable({ part: 'markdown', value: '\n\n_turn interrupted_\n\n' })];
+        // crates/harness/src/server.rs `submit_claimed` emits `turn_failed`. The
+        // other four are the error kinds the donor-neutral reader in
+        // crates/frontend-model/src/transcript.rs treats identically:
+        // `transport_error` from crates/opencode-frontend/src/server.rs,
+        // `watch_error` from crates/interchange/src/watch.rs, and
+        // `runtime_disconnected`, which a frontend synthesizes for itself
+        // (crates/frontend-tui/src/app.rs). `stream_error` has no producer in this
+        // repository and is read only because that reader reads it.
+        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)}`;
+            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
+        // crates/frontend-model/src/transcript.rs reads them.
+        case 'scheduled_prompt_started':
+        case 'scheduled_prompt_deferred':
+        case 'scheduled_prompt_completed':
+            return [stable({
+                    part: 'progress',
+                    value: `${event.kind.replaceAll('_', ' ')} · ${opaqueText(event.payload, 256)}`,
+                })];
+        case 'scheduler_error': {
+            const value = `scheduler error: ${opaqueText(event.payload, 256)}`;
+            return [{
+                    emit: { part: 'warning', value },
+                    needs: 'chatParticipantAdditions',
+                    fallback: [{ part: 'markdown', value: `> ⚠ ${value}` }],
+                }];
+        }
+        // crates/harness/src/runtime/hosted.rs `native_payload`, declared by the
+        // hosted descriptor: a harness's own event that has no canonical
+        // projection (pi's `agent_start`, `message_update`'s `text_start`, …).
+        // What the turn says arrives beside it as `text_delta`/`tool_call_*`, so
+        // it is a transient status line naming the harness's kind, never a JSON
+        // block in the transcript.
+        case 'native_event':
+            return [stable({
+                    part: 'progress',
+                    value: clamp(stripControls(text(payload.kind, 'native event')), VSCODE_CHAT_LIMITS.titleCharacters),
+                })];
+        // Not in this runtime's declared set; read the way
+        // crates/frontend-model/src/transcript.rs reads a donor that emits them.
+        case 'reasoning':
+        case 'thinking': {
+            const body = clamp(stripControls(text(payload.text ?? payload.summary, opaqueText(event.payload))), VSCODE_CHAT_LIMITS.partCharacters);
+            return [{
+                    emit: { part: 'thinking', value: body },
+                    needs: 'chatParticipantAdditions',
+                    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.
+        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`,
+                })];
+    }
+}
+/** Replace every part whose proposal the host did not grant with its fallback. */
+export function resolveParts(parts, granted) {
+    const resolved = [];
+    for (const part of parts) {
+        if (!part.needs || granted.has(part.needs))
+            resolved.push(part.emit);
+        else
+            resolved.push(...(part.fallback ?? []));
+    }
+    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.
+ */
+export const HISTORY_MARKER_PROMPT = '⟨supercode runtime history⟩';
+function messageText(message) {
+    const content = message.content;
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return '';
+        const part = entry;
+        if (['text', 'input_text', 'output_text'].includes(String(part.type)))
+            return String(part.text ?? '');
+        if (['image', 'image_url', 'input_image'].includes(String(part.type)))
+            return '[image]';
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+/**
+ * A HOSTED harness runtime's transcript as chat turns.
+ *
+ * `HostedHarnessRuntime::attach` returns `history: Vec::new()` and puts the
+ * whole conversation in `replay` — the canonical ChatMessage history belongs to
+ * supercode's own agent loop, and a hosted harness has none. So a resumed
+ * Claude Code session's turns are here or nowhere.
+ */
+export function projectReplayTurns(events, granted, context) {
+    const turns = [];
+    let streamedText;
+    for (const event of events) {
+        if (event.kind === 'user_message') {
+            streamedText = undefined;
+            const payload = payloadOf(event);
+            turns.push({ role: 'user', prompt: clamp(stripControls(text(payload.text)), VSCODE_CHAT_LIMITS.partCharacters) });
+            continue;
+        }
+        const parts = resolveParts(projectEvent(event, context), granted);
+        if (parts.length === 0)
+            continue;
+        if (event.kind === 'text_delta' && parts[0]?.part === 'markdown') {
+            if (streamedText) {
+                streamedText.value = clamp(streamedText.value + parts[0].value, VSCODE_CHAT_LIMITS.partCharacters);
+                continue;
+            }
+            streamedText = parts[0];
+        }
+        else {
+            streamedText = undefined;
+        }
+        if (turns.length === 0)
+            turns.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+        const last = turns[turns.length - 1];
+        if (last.role === 'assistant' && last.parts)
+            last.parts.push(...parts);
+        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;
+}
+/**
+ * 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()) {
+    const turns = [];
+    const pushAssistant = (parts) => {
+        const last = turns[turns.length - 1];
+        if (last && last.role === 'assistant' && last.parts) {
+            last.parts.push(...parts);
+            return;
+        }
+        // VS Code's chat history is request/response PAIRS and drops a response
+        // with no request before it. A runtime transcript legitimately opens with
+        // assistant or system content — the runtime compacts, so
+        // `bounded_history_snapshot` can begin `[earlier conversation compacted:
+        // N messages]` with no user turn left. Rather than drop it, this pairs it
+        // with a marker turn that names itself as the runtime's history, so
+        // nothing is invented as a person's prompt.
+        if (turns.length === 0)
+            turns.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+        turns.push({ role: 'assistant', parts });
+    };
+    for (const message of history) {
+        const body = messageText(message);
+        if (message.role === 'user') {
+            turns.push({ role: 'user', prompt: clamp(stripControls(body), VSCODE_CHAT_LIMITS.partCharacters) });
+            continue;
+        }
+        // A person never sees a system prompt — not in a chat product, not in
+        // Blender's own panels. The runtime's canonical history carries it because
+        // the MODEL needs it; a reader does not, and a collapsed block is still a
+        // reader's problem. It renders NOTHING, deliberately, and the transcript
+        // starts where the conversation does.
+        if (message.role === 'system')
+            continue;
+        if (message.role === 'assistant') {
+            if (body) {
+                pushAssistant([{ part: 'markdown', value: clamp(stripControls(body), VSCODE_CHAT_LIMITS.partCharacters) }]);
+            }
+            for (const call of message.tool_calls ?? []) {
+                pushAssistant(resolveParts([{
+                        emit: {
+                            part: 'tool',
+                            toolName: call.function.name,
+                            toolCallId: call.id,
+                            invocationMessage: clamp(call.function.name, VSCODE_CHAT_LIMITS.titleCharacters),
+                            isComplete: true,
+                        },
+                        needs: 'chatParticipantAdditions',
+                        fallback: [{
+                                part: 'markdown',
+                                value: `**Tool call · ${call.function.name}**\n\n${fence(parseArguments(call.function.arguments))}`,
+                            }],
+                    }], granted));
+            }
+            continue;
+        }
+        // The SDK loader inserts this synthetic result for an unfinished native
+        // call. A currently pending approval is authoritative; do not call it an
+        // 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]';
+        pushAssistant([{
+                part: 'markdown',
+                value: pending ? '**Awaiting approval** — no tool result yet.'
+                    : `**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;
+}