@volter/supercode-frontend-vscode 0.1.57 → 0.1.60

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

@@ -107,7 +107,7 @@ export declare function toolTitles(toolName: string, argumentsText: string): {
 };
 /** The command line of a shell tool call, read from its own arguments; undefined for any other tool. */
 export declare function shellCommand(toolName: string, argumentsText: string): string | undefined;
-/** The summary line this view shows for a request payload. */
+/** The information this view shows for a request payload. */
 export declare function requestSummary(request: FrontendRequest): string;
 /** The answers this view offers for a request, one button each. */
 export declare function requestAnswers(request: FrontendRequest, connectionId: string): ChatAnswer[];
@@ -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;