@volter/supercode-frontend-vscode 0.1.58 → 0.1.61

package/dist/host-controls.js

@@ -4,6 +4,12 @@ export class ChatHostControls {
     credential;
     state;
     updating = Promise.resolve();
+    #stateListeners = new Set();
+    /** Call `listener` with each state the host replies with; returns the unsubscribe. */
+    onState(listener) {
+        this.#stateListeners.add(listener);
+        return () => this.#stateListeners.delete(listener);
+    }
     constructor(baseUrl, credential, state) {
         this.baseUrl = baseUrl;
         this.credential = credential;
@@ -37,6 +43,8 @@ export class ChatHostControls {
         const pending = this.updating.then(async () => {
             const result = await this.request(path, selection);
             this.state = result;
+            for (const listener of this.#stateListeners)
+                listener(result);
             return result;
         });
         this.updating = pending.then(() => undefined, () => undefined);
@@ -70,9 +78,12 @@ export function runtimeIdentity(harness, model, effective) {
     const harnessName = harnessDisplayName(harness);
     const knownModel = effective?.model || (model && model !== harness ? model : '');
     const modelName = effective?.modelName || { sonnet: 'Claude Sonnet', opus: 'Claude Opus', haiku: 'Claude Haiku' }[knownModel] || knownModel;
+    // The provider of a display name ("Claude Opus 4.8"), whose mark is media/<provider>.svg (supercode-ui's catalogue);
+    // the catalogue's modelProvider reads model ids.
     const provider = /claude|sonnet|opus|haiku/i.test(modelName) || (!modelName && harness === 'claude-code') ? 'anthropic'
         : /^(gpt|o[134]|chatgpt)|\/gpt/i.test(modelName) || (!modelName && harness === 'codex') ? 'openai'
-            : /gemini/i.test(modelName) || (!modelName && harness === 'gemini') ? 'google' : undefined;
+            : /gemini/i.test(modelName) || (!modelName && harness === 'gemini') ? 'google'
+                : /grok/i.test(modelName) || (!modelName && harness === 'grok') ? 'xai' : undefined;
     const effort = effective?.effort ? ` · ${effective.effort}` : '';
     return { name: modelName ? `${modelName}${effort}` : `Model chosen by ${harnessName}`, provider };
 }

package/dist/native-session.d.ts

@@ -1,6 +1,6 @@
 import type { CancellationToken } from 'vscode';
 import type { FrontendEvent } from '../vendor/supercode-frontend/generated.mjs';
 import { type VscodeFrontendSession } from './session.js';
-export declare function sessionStatus(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests'>): 'NeedsInput' | 'InProgress' | 'Completed';
+export declare function sessionStatus(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests' | 'failure'>): 'NeedsInput' | 'Failed' | 'InProgress' | 'Completed';
 /** Follow a restored turn, including the interval between snapshot and callback. */
-export declare function observeActiveResponse(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests' | 'onEvent' | 'interrupt' | 'actions' | 'replay'>, token: CancellationToken, write: (event: FrontendEvent) => void, onSubscribed?: () => void, afterSequence?: number): Promise<void>;
+export declare function observeActiveResponse(session: Pick<VscodeFrontendSession, 'descriptor' | 'pendingRequests' | 'onEvent' | 'onChange' | 'onFailure' | 'interrupt' | 'actions' | 'replay'>, token: CancellationToken, write: (event: FrontendEvent) => void, onSubscribed?: () => void, afterSequence?: number): Promise<void>;

package/dist/native-session.js

@@ -1,10 +1,12 @@
 import { TURN_TERMINAL_KINDS } from './session.js';
 export function sessionStatus(session) {
-    return session.pendingRequests.size ? 'NeedsInput' : session.descriptor?.turn_state === 'busy' ? 'InProgress' : 'Completed';
+    return session.pendingRequests.size ? 'NeedsInput' : session.failure ? 'Failed' : session.descriptor?.turn_state === 'busy' ? 'InProgress' : 'Completed';
 }
 /** Follow a restored turn, including the interval between snapshot and callback. */
 export async function observeActiveResponse(session, token, write, onSubscribed, afterSequence) {
     let unsubscribe = () => { };
+    let unfail = () => { };
+    let unwatch = () => { };
     let cancellation;
     try {
         await new Promise((resolve, reject) => {
@@ -43,6 +45,11 @@ export async function observeActiveResponse(session, token, write, onSubscribed,
                     resolve();
             };
             unsubscribe = session.onEvent(consume);
+            unfail = session.onFailure(reject);
+            unwatch = session.onChange(() => {
+                if (!cancelling && session.descriptor?.turn_state === 'idle' && !session.pendingRequests.size)
+                    resolve();
+            });
             if (afterSequence !== undefined) {
                 for (const event of session.replay)
                     if (event.sequence > afterSequence)
@@ -58,6 +65,8 @@ export async function observeActiveResponse(session, token, write, onSubscribed,
     }
     finally {
         unsubscribe();
+        unfail();
+        unwatch();
         cancellation?.dispose();
     }
 }

package/dist/session.d.ts

@@ -5,6 +5,7 @@ import type { FrontendPermission } from './client.js';
  * here is a second protocol: every member is `@volter/supercode-frontend`'s.
  */
 export interface VscodeRuntimeClient {
+    readonly lastSequence?: number;
     describe(): Promise<FrontendRuntimeDescriptor>;
     attach(limit?: number, options?: {
         afterSequence?: number;
@@ -85,6 +86,8 @@ export declare class VscodeFrontendSession {
     descriptor: FrontendRuntimeDescriptor | null;
     history: ChatMessage[];
     historyCursor: number;
+    historyEvents: FrontendEvent[];
+    historyEventsDropped: number;
     cursor: number;
     /**
      * Every event this attachment has seen, in order — NOT just the last
@@ -108,6 +111,8 @@ export declare class VscodeFrontendSession {
      */
     resolvedRequests: Map<number, FrontendRequest>;
     connection: 'disconnected' | 'connected' | 'closed';
+    /** Exact transport/recovery failure, retained until a fresh attachment succeeds. */
+    failure: Error | null;
     /**
      * `frontend.v2`'s descriptor and history carry NO timestamp, so the only
      * true times this frontend knows are its own: when this window attached, and
@@ -142,6 +147,9 @@ export declare class VscodeFrontendSession {
     /** Subscribe to every event this session projects, from now on. */
     onEvent(listener: (event: FrontendEvent) => void): () => void;
     onChange(observer: () => void): () => void;
+    /** Surface an actual stream/recovery error without inventing a native event or ending its turn. */
+    reportFailure(error: unknown): void;
+    onFailure(listener: (error: Error) => void): () => void;
     private projectEvent;
     /** What this attachment may do: permission AND the descriptor's own advertisement. */
     actions(): VscodeFrontendActions;
@@ -169,6 +177,7 @@ export declare class VscodeFrontendSession {
         throwIfCancelled?: () => void;
         onSubmitted?: () => void;
     }): Promise<FrontendEvent | null>;
+    private requireOpenAttachment;
     private require;
     private notify;
 }

package/dist/session.js

@@ -1,3 +1,4 @@
+import { mergeFrontendSnapshot } from '../vendor/supercode-frontend/client.mjs';
 /** How long a turn waits on a connection that dropped before saying it was lost (the follow loop's re-attach backs
  *  off to 15 s; this outlasts a few of its attempts). */
 const DISCONNECT_GRACE_MS = 60_000;
@@ -46,6 +47,8 @@ export class VscodeFrontendSession {
     descriptor = null;
     history = [];
     historyCursor = 0;
+    historyEvents = [];
+    historyEventsDropped = 0;
     cursor = 0;
     /**
      * Every event this attachment has seen, in order — NOT just the last
@@ -69,6 +72,8 @@ export class VscodeFrontendSession {
      */
     resolvedRequests = new Map();
     connection = 'disconnected';
+    /** Exact transport/recovery failure, retained until a fresh attachment succeeds. */
+    failure = null;
     /**
      * `frontend.v2`'s descriptor and history carry NO timestamp, so the only
      * true times this frontend knows are its own: when this window attached, and
@@ -82,9 +87,12 @@ export class VscodeFrontendSession {
     #subscribed = false;
     #following = null;
     #heartbeat = null;
+    #takingControl = null;
+    #disposed = false;
     #resyncing = false;
     #listeners = new Set();
     #changeObservers = new Set();
+    #failureListeners = new Set();
     #eventListener = (event) => {
         this.applyEvent(event);
     };
@@ -106,17 +114,49 @@ export class VscodeFrontendSession {
      * BEFORE the snapshot RPC, so no event can fall between the two.
      */
     async attach(limit = 1000) {
-        const snapshot = await this.client.attach(limit, { afterSequence: this.cursor });
+        if (this.#disposed)
+            throw new Error('frontend attachment is disposed');
+        const snapshot = await this.client.attach(limit, { afterSequence: this.cursor }).catch(error => {
+            this.reportFailure(error);
+            throw error;
+        });
+        if (this.#disposed) {
+            this.client.stopEvents();
+            throw new Error('frontend attachment is disposed');
+        }
+        const recovery = mergeFrontendSnapshot(snapshot, this.replay, Math.max(this.cursor, this.client.lastSequence ?? 0));
+        const authoritative = Array.isArray(snapshot.pending_requests);
         const staged = {
             descriptor: structuredClone(snapshot.descriptor),
-            pendingRequests: new Map([...this.pendingRequests].map(([id, request]) => [id, structuredClone(request)])),
+            pendingRequests: new Map((authoritative ? snapshot.pending_requests : [...this.pendingRequests.values()])
+                .map(request => [request.id, structuredClone(request)])),
             backgroundTasks: structuredClone(this.backgroundTasks),
-            cursor: Math.max(this.cursor, snapshot.history_cursor),
+            cursor: authoritative ? recovery.captureCursor : Math.max(this.cursor, snapshot.history_cursor),
         };
         // Validate and project the whole attachment before any observable field
         // moves or a live listener is registered.
-        for (const event of snapshot.replay)
-            this.projectEvent(staged, event);
+        if (authoritative) {
+            // Snapshot state is authoritative at capture, before any later events.
+            // Background listings have no separate snapshot field; retain their
+            // latest original event without replaying historical request state.
+            for (const event of recovery.replay) {
+                const payload = (event.payload ?? {});
+                if (event.kind === 'background_tasks' && Array.isArray(payload.tasks)) {
+                    staged.backgroundTasks = payload.tasks
+                        .filter(task => task && typeof task.id === 'string')
+                        .map(task => ({ id: task.id, kind: String(task.kind ?? 'task'), description: String(task.description ?? '') }));
+                }
+            }
+            for (const event of recovery.later)
+                this.projectEvent(staged, event);
+        }
+        else {
+            // Legacy runtimes retain the previous replay-derived request behavior.
+            if (this.cursor > recovery.captureCursor)
+                staged.descriptor = structuredClone(this.descriptor);
+            for (const event of recovery.replay)
+                this.projectEvent(staged, event);
+        }
         // A request seen in the REPLAY is transcript, not an open ask. The runtime
         // re-sequences its request history at every turn boundary
         // (`compact_frontend_request_history`), and that compaction can keep a
@@ -132,12 +172,12 @@ export class VscodeFrontendSession {
         // reads idle while the agent loop is blocked on an approval it raised. Clearing that one left the agent waiting
         // forever with nothing to answer it (2026-10-07). Compaction happens only at a turn boundary, so a request raised
         // AFTER the replay's last boundary and not resolved since is still open, idle or not; only older ones are dropped.
-        if (staged.descriptor?.turn_state !== 'busy' && staged.descriptor?.source_harness !== 'codex') {
+        if (!authoritative && staged.descriptor?.turn_state !== 'busy' && staged.descriptor?.source_harness !== 'codex') {
             // A turn's END, not `turn_completed`: that one is a model round-trip and fires mid-turn.
             const BOUNDARIES = new Set(['turn_succeeded', 'turn_failed', 'turn_interrupted']);
             let lastBoundary = -1;
             const raisedAt = new Map();
-            for (const event of snapshot.replay) {
+            for (const event of recovery.replay) {
                 if (BOUNDARIES.has(event.kind))
                     lastBoundary = Math.max(lastBoundary, event.sequence);
                 const payload = (event.payload ?? {});
@@ -156,22 +196,41 @@ export class VscodeFrontendSession {
         this.descriptor = staged.descriptor;
         this.history = structuredClone(snapshot.history);
         this.historyCursor = snapshot.history_cursor;
-        this.appendTranscript(structuredClone(snapshot.replay));
+        this.historyEvents = structuredClone(snapshot.history_events ?? []);
+        this.historyEventsDropped = snapshot.history_events_dropped ?? 0;
+        this.appendTranscript(structuredClone(recovery.replay));
         this.pendingRequests = staged.pendingRequests;
         this.backgroundTasks = staged.backgroundTasks;
+        const previousCursor = this.cursor;
         this.cursor = staged.cursor;
         this.connection = 'connected';
+        this.failure = null;
         this.attachedAtMs ??= Date.now();
         if (!this.#subscribed) {
             this.client.on('event', this.#eventListener);
             this.client.on('disconnect', this.#disconnectListener);
             this.#subscribed = true;
         }
+        // Recovery delivers original unseen events at their original sequences.
+        // Historical display data never goes through the live-state projector;
+        // the snapshot's request map and descriptor remain authoritative.
+        for (const event of [...this.historyEvents, ...recovery.replay]) {
+            if (event.sequence <= previousCursor)
+                continue;
+            for (const listener of [...this.#listeners]) {
+                try {
+                    listener(event);
+                }
+                catch { /* A view cannot stop recovery. */ }
+            }
+        }
         this.notify();
         return snapshot;
     }
     /** Start consuming the already-open live stream. Resolves when it ends. */
     follow() {
+        if (this.#disposed)
+            return Promise.resolve();
         if (!this.#following) {
             this.#following = this.client.startEvents({ afterSequence: this.cursor }).finally(() => {
                 this.#following = null;
@@ -184,10 +243,23 @@ export class VscodeFrontendSession {
      * never call this; only a permission that can submit needs the lease.
      */
     async takeControlAndHold() {
+        this.requireOpenAttachment();
         if (!this.permissions.has('interact'))
             return;
-        const lease = await this.client.takeControl();
-        this.startHeartbeat(lease.lease_ttl_ms);
+        if (this.#takingControl)
+            return this.#takingControl;
+        const taking = this.client.takeControl().then((lease) => {
+            this.requireOpenAttachment();
+            this.startHeartbeat(lease.lease_ttl_ms);
+        });
+        this.#takingControl = taking;
+        try {
+            await taking;
+        }
+        finally {
+            if (this.#takingControl === taking)
+                this.#takingControl = null;
+        }
     }
     startHeartbeat(ttlMs) {
         this.stopHeartbeat();
@@ -205,6 +277,10 @@ export class VscodeFrontendSession {
         this.#heartbeat = null;
     }
     dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.connection = 'closed';
         this.stopHeartbeat();
         this.client.stopEvents();
         if (this.#subscribed) {
@@ -212,8 +288,10 @@ export class VscodeFrontendSession {
             this.client.off('disconnect', this.#disconnectListener);
             this.#subscribed = false;
         }
+        this.notify();
         this.#listeners.clear();
         this.#changeObservers.clear();
+        this.#failureListeners.clear();
     }
     /** Keep the transcript in order and free of the duplicates a re-attach brings. */
     appendTranscript(events) {
@@ -225,8 +303,8 @@ export class VscodeFrontendSession {
             this.replay.push(event);
         }
         this.replay.sort((left, right) => left.sequence - right.sequence);
-        if (this.replay.length > 2000)
-            this.replay = this.replay.slice(-2000);
+        if (this.replay.length > 4096)
+            this.replay = this.replay.slice(-4096);
     }
     applyEvent(event) {
         let applied;
@@ -264,9 +342,7 @@ export class VscodeFrontendSession {
             return;
         this.#resyncing = true;
         void this.attach()
-            .catch(() => {
-            // An unreachable runtime is reported by the next action, not here.
-        })
+            .catch(error => this.reportFailure(error))
             .finally(() => {
             this.#resyncing = false;
         });
@@ -280,6 +356,29 @@ export class VscodeFrontendSession {
         this.#changeObservers.add(observer);
         return () => this.#changeObservers.delete(observer);
     }
+    /** Surface an actual stream/recovery error without inventing a native event or ending its turn. */
+    reportFailure(error) {
+        if (this.connection === 'closed')
+            return;
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (this.failure?.message === failure.message && this.connection === 'disconnected')
+            return;
+        this.failure = failure;
+        this.connection = 'disconnected';
+        for (const listener of [...this.#failureListeners]) {
+            try {
+                listener(failure);
+            }
+            catch { /* A view cannot stop recovery. */ }
+        }
+        this.notify();
+    }
+    onFailure(listener) {
+        this.#failureListeners.add(listener);
+        if (this.failure)
+            listener(this.failure);
+        return () => this.#failureListeners.delete(listener);
+    }
     projectEvent(state, event) {
         if (event.sequence <= state.cursor)
             return false;
@@ -344,6 +443,10 @@ export class VscodeFrontendSession {
     }
     /** Run one controller action, re-taking an expired lease exactly once. */
     async withControl(action) {
+        // An early picker registration can expose actions while the initial lease
+        // is arriving. Wait for that attempt, then let the runtime enforce its lease.
+        await this.#takingControl?.catch(() => undefined);
+        this.requireOpenAttachment();
         try {
             return await action();
         }
@@ -351,8 +454,8 @@ export class VscodeFrontendSession {
             const name = error?.name ?? '';
             if (!LEASE_ERROR_NAMES.includes(name) || !this.permissions.has('interact'))
                 throw error;
-            const lease = await this.client.takeControl();
-            this.startHeartbeat(lease.lease_ttl_ms);
+            await this.takeControlAndHold();
+            this.requireOpenAttachment();
             return action();
         }
     }
@@ -402,6 +505,8 @@ export class VscodeFrontendSession {
         }
     }
     async detach() {
+        // Do not let a pending acquisition succeed after this client detached.
+        await this.#takingControl?.catch(() => undefined);
         this.require('detach');
         await this.client.detach();
         this.connection = 'disconnected';
@@ -415,8 +520,7 @@ export class VscodeFrontendSession {
     }
     async takeover() {
         this.require('takeover');
-        const lease = await this.client.takeControl();
-        this.startHeartbeat(lease.lease_ttl_ms);
+        await this.takeControlAndHold();
         this.notify();
     }
     async heartbeat() {
@@ -447,14 +551,15 @@ export class VscodeFrontendSession {
                     settle?.(event);
             }
         });
+        const unfail = this.onFailure(error => fail?.(error));
         // A turn that never sees its terminal event must still end: the editor
         // holds the chat response open until this handler resolves, and a frontend
         // that hangs one is worse than one that ends it a beat early. The
         // descriptor going idle after the submit is the second, independent signal.
         let sawBusy = false;
-        // A stream that ends is re-attached from its cursor (the extension's follow loop), and the replay ends the turn;
-        // only a connection closed, or one still down after DISCONNECT_GRACE_MS, ends the wait, said: a response held open
-        // with nothing in it is the silent failure.
+        // Explicit transport/recovery failures end this view through onFailure;
+        // the native turn can still be running. A disconnect with no explicit
+        // failure gets a grace period while the follow loop reattaches.
         let down;
         const lost = () => fail?.(new Error('The connection to this conversation\'s runtime was lost before its turn ended; the turn may still be running. Reopen the chat to see where it stands.'));
         finished.catch(() => undefined); // a loss while the submit is still in flight is answered by the submit's own error
@@ -490,9 +595,16 @@ export class VscodeFrontendSession {
             clearTimeout(down);
             unsubscribe();
             unwatch();
+            unfail();
         }
     }
+    requireOpenAttachment() {
+        if (this.#disposed || this.connection === 'closed')
+            throw new Error('frontend attachment is closed');
+    }
     require(action) {
+        if (this.failure && action === 'submit')
+            throw this.failure;
         if (!this.actions()[action])
             throw new Error(`frontend action ${action} is unavailable`);
     }

package/dist/setup-flow.js

@@ -93,21 +93,29 @@ export class ChatSetupFlow {
                 this.processes.set(operation.id, process);
                 let ended = false;
                 let exitCode;
+                let exitRefreshesRemaining = 2;
                 void process.exited.then(code => { ended = true; exitCode = code; });
                 // Readiness comes only from the host's native inventory. A successful
                 // process exit, a browser opening, and a protocol handshake are not login.
                 while (current()) {
+                    const refreshingAfterExit = ended;
                     await this.refresh(operation);
                     if (setupAgents(this.host.state()).some(a => a.harness === operation.harness && a.signedIn))
                         break;
-                    if (ended)
+                    // The inventory can settle after the native login process exits. Give
+                    // it two reads begun after that exit, keeping inventory authoritative
+                    // even for an exit code of zero and retiring cancelled operations.
+                    if (refreshingAfterExit && --exitRefreshesRemaining === 0)
                         throw new Error(`Sign-in ended ${exitCode === undefined ? 'without an exit status' : `with exit code ${exitCode}`}, without a signed-in account.`);
                     await new Promise(resolve => setTimeout(resolve, 1000));
                 }
             }
             if (!current())
                 return;
-            this.notice = operation.harness === 'codex' ? 'ChatGPT' : operation.harness === 'claude-code' ? 'Claude' : undefined;
+            // The account the host names for the agent now signed in (one signed in from Cyclotron's Accounts menu, say), else
+            // the provider its native sign-in belongs to.
+            const signedIn = setupAgents(this.host.state()).find(a => a.harness === operation.harness && a.signedIn);
+            this.notice = signedIn?.account || (operation.harness === 'codex' ? 'ChatGPT' : operation.harness === 'claude-code' ? 'Claude' : undefined);
             this.update(operation, 'signed-in');
             // Retire only the terminal this click launched. Its native inventory has
             // already confirmed login; closing it never supplies that confirmation.

package/dist/view.d.ts

@@ -133,6 +133,8 @@ export interface ProjectionContext {
     connectionId: string;
     /** Render the runtime's echo of a prompt (history replay does; live does not). */
     echoOwnPrompts?: boolean;
+    /** Show input arriving in an observed turn, without inventing a native request turn. */
+    liveUserMessages?: boolean;
     /** The request a `request_resolved` answers, so its sentence can name it. */
     pendingRequest?: (requestId: number) => FrontendRequest | undefined;
     /**
@@ -172,8 +174,8 @@ export interface ProjectedTurn {
 }
 /**
  * A "user" message no person typed: Claude Code's `<task-notification>` (a background task reporting back) or the
- * editor's automatic tripwire nudge. Neither is shown as the person's words. A task notification is said as one
- * short line ("Background task completed: <its summary>"); a nudge is not shown. Undefined for a person's message.
+ * editor's automatic tripwire nudge or Claude's unmarked interruption record. None is shown as the person's words.
+ * A task notification and interruption are short notices; a nudge is not shown. Undefined for a person's message.
  */
 export declare function automaticPrompt(body: string): {
     notice?: string;

package/dist/view.js

@@ -440,12 +440,26 @@ 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
-        // 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':
+        // 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.
+        case 'user_message': {
+            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);
+                return value ? [stable({ part: 'markdown', value: `${prefix}${value}${suffix}` })] : [];
+            }
             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.
@@ -608,11 +622,11 @@ export function projectEvent(event, context) {
             return [stable({ part: 'warning', value: 'The turn was interrupted.' })];
         // 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:
+        // sdk/interchange/frontend-transcript.mjs 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
+        // (sdk/interchange/frontend-app.mjs). `stream_error` has no producer in this
         // repository and is read only because that reader reads it.
         case 'turn_failed':
         case 'stream_error':
@@ -629,7 +643,7 @@ export function projectEvent(event, context) {
         }
         // 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.
+        // sdk/interchange/frontend-transcript.mjs reads them.
         case 'scheduled_prompt_started':
         case 'scheduled_prompt_deferred':
         case 'scheduled_prompt_completed':
@@ -654,7 +668,7 @@ export function projectEvent(event, context) {
         case 'warning':
             return [stable({ part: 'warning', value: clamp(stripControls(text(payload.message)), VSCODE_CHAT_LIMITS.partCharacters) })];
         // Not in this runtime's declared set; read the way
-        // crates/frontend-model/src/transcript.rs reads a donor that emits them.
+        // sdk/interchange/frontend-transcript.mjs 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);
@@ -704,8 +718,10 @@ function messageText(message) {
         if (!entry || typeof entry !== 'object' || Array.isArray(entry))
             return '';
         const part = entry;
+        // Opaque transcript parts can carry structured text. Use the same bounded
+        // JSON rendering as live payloads rather than JavaScript's object coercion.
         if (['text', 'input_text', 'output_text'].includes(String(part.type)))
-            return String(part.text ?? '');
+            return text(part.text);
         if (['image', 'image_url', 'input_image'].includes(String(part.type)))
             return '[image]';
         return '';
@@ -715,8 +731,8 @@ function messageText(message) {
 }
 /**
  * A "user" message no person typed: Claude Code's `<task-notification>` (a background task reporting back) or the
- * editor's automatic tripwire nudge. Neither is shown as the person's words. A task notification is said as one
- * short line ("Background task completed: <its summary>"); a nudge is not shown. Undefined for a person's message.
+ * editor's automatic tripwire nudge or Claude's unmarked interruption record. None is shown as the person's words.
+ * A task notification and interruption are short notices; a nudge is not shown. Undefined for a person's message.
  */
 export function automaticPrompt(body) {
     const trimmed = body.trimStart();
@@ -728,6 +744,9 @@ export function automaticPrompt(body) {
     }
     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._' };
     return undefined;
 }
 export function projectReplayTurns(events, granted, context, history = []) {
@@ -857,6 +876,11 @@ export function projectHistory(history, granted, pendingToolNames = new Set()) {
                     pushAssistant([{ part: 'markdown', value: `\n\n${automatic.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;

package/dist/workbench-tools.d.ts

@@ -0,0 +1,13 @@
+import * as vscode from 'vscode';
+import type { WorkbenchToolsEndpoint } from './host-controls.js';
+export declare class WorkbenchTools implements vscode.Disposable {
+    #private;
+    /** Serve on the endpoint the host names, or nothing when it names none. A changed endpoint replaces the server.
+     *  Calls apply in order, so two quick state replies cannot race a close against a listen. */
+    serve(endpoint: WorkbenchToolsEndpoint | undefined): Promise<void>;
+    private apply;
+    private answer;
+    private handle;
+    private close;
+    dispose(): void;
+}