@volter/supercode-frontend-vscode 0.1.50 → 0.1.52

package/README.md

@@ -11,74 +11,55 @@ package or npm.
 
 ## Native chat controls
 
-When the host has an extension gallery and the workbench install command, setup
-also offers **Sign in with ChatGPT** using the official `openai.chatgpt` extension.
-Only a click installs it, using `workbench.extensions.installExtension` with
-`enable: true` so the workbench waits for registration in the running extension
-registry; subsequent clicks reuse it. `chatgpt.openSidebar` then opens its own sign-in view
-(the extension does not contribute a public sign-in command). No terminal or
-Supercode settings are involved in this path. The choice also appears whenever
-the agent picker is shown; it does not interrupt automatic startup or the
-sole-local-agent New Session shortcut.
-Gallery detection reads the host's `product.json` through `vscode.workspace.fs`
-at `vscode.env.appRoot`; hosts without an inspectable gallery configuration hide
-the choice. Neither the extension nor its credentials are bundled or copied.
-
-The welcome's primary action uses `supercode.frontend.beginChatGPTSignIn`:
-it starts one retained install/sidebar operation and returns a copied receipt
-with its id, timestamps and current phase. This is a launch receipt, not proof
-that installation, sidebar presentation or authentication succeeded. A second
-begin while that operation is running returns the same id and starts no extra
-installation. `supercode.frontend.chatGPTSignInStatus` reads its current phase
-locally without waiting for host readiness or installation; pass the operation
-id to receive only that operation (a mismatched id returns null).
-Phases name the selected work before its awaited command: `checking-gallery`,
-`installing-extension`, `opening-sidebar`, then `completed` or `failed`.
-Completed means the official command sequence fulfilled, not signed in. Failures
-remain in operation status and the existing native error notification/output.
-Only the current or most recent operation is retained, for this extension-window
-lifetime; reload does not restore or automatically retry it. Runtime status
-inspection also includes this snapshot as `chatGPTSignIn`.
-The existing `supercode.frontend.signInWithChatGPT` still awaits the same work
-with its existing error-notification/fulfillment behavior, and the agent picker
-continues to use it. Ordinary relay budgets and draft guards are unchanged.
-
-The optional host-controls state can include `setup: { ready, actions, reason,
-cwd }`. Each action supplies `kind` (`login` or `install`), `harness`, `name` and
-the exact `command` revalidated before execution. On a signed-out first open,
-Chat shows its native empty-session welcome: one primary **Sign in with ChatGPT**
-button for the official extension, followed by **Supercode · local agents** and
-each installed agent's own sign-in link, labeled with its reported name. The
-`defaultChatParticipant` proposal supplies `additionalWelcomeMessage`; the pinned
-Code-OSS `ChatViewWelcomePart`, with the editor's native-welcome-button overlay,
-turns the standalone trusted command link into a native button. Stock hosts
-render it as an ordinary command link; product release requires the overlay.
-Setup creates no transcript turns, status sessions or protocol markers, and displays no terminal commands, filesystem paths or runtime banner.
-No installed agents means an explanatory empty state, without invented choices.
-Clicking asks the host's authenticated `/setup` door to revalidate `{ kind,
-harness }` and return the action plus a structured `{ program, arguments, cwd, env? }`
-terminal launch. Absolute executables and an optional host-authored PATH keep
-the terminal on the same installation and discovery path as the host's probe.
-It runs directly as the integrated terminal's process, without typing a shell
-command; credentials and
-browser interaction belong to the harness. Failed or cancelled processes can be
-retried, and closing a terminal never counts as successful authentication.
-
-While setup is not ready, Chat refreshes `/state` every three seconds and exposes
-**Check again**. When the host returns a ready runtime connection, it attaches
-and reveals that conversation without a reload. Polling only finishes after both
-attachment and the host's guarded readiness reveal command succeed for that same
-session and runtime URL. Readiness/connection work completes before awaiting the
-native reveal, which may call back into activation. The optional
-`revealReadySessionCommand` checks the observed native conversation throughout
-queued navigation; a newer draft or selection cancels that automatic reveal.
-Hosts without that capability leave the handoff incomplete and direct the person
-to open the conversation from history. A transient attach/reveal failure stays pending and is retried;
-**Check again** retries that handoff even when the host already reports ready.
-Changed inventory updates welcome metadata in place, without opening another
-session or moving focus. Ready connections clear the welcome and reveal the
-actual conversation. Hosts without these optional fields keep the existing
-runtime-attachment commands.
+When no coding agent is ready, native Chat offers **Sign in with ChatGPT**
+(Codex) and **Sign in with Claude** (Claude Code), with the subtitle
+“Use the AI plan you already pay for.” Both use the coding agent in this Chat.
+A click starts one install/sign-in operation for that agent. The host returns
+its exact structured terminal launch through the authenticated `/setup` door;
+a missing agent installs from its vendor package, then the same click continues
+to login. The frontend never interprets repair prose as a command.
+
+The host's `/state` supplies `setup: {ready, actions, agents, reason, cwd}`.
+Each agent supplies `{harness, name, installed, signedIn, account}`; an unknown
+account is `null`. Each action supplies `{kind, harness, name, command}` with
+`kind` equal to `install` or `login`. The host revalidates the chosen action
+before returning `{program, arguments, cwd, env?}`. Credentials remain with
+the coding agent; browser sign-in requires the person's approval.
+
+The versioned local `supercode.frontend.setupState` command returns
+`{version:1, visible, title, subtitle, footnote, composerPlaceholder,
+composerEnabled, rows, signedInNotice}`. Rows include both providers with their
+installation/login state, `phase` (`idle`, `installing`, `signing-in`, `failed`,
+`signed-in`), `buttonLabel`, `caption`, `busy`, and `operationId`. A renderer
+uses `visible` and `composerEnabled`, rather than the mere presence of rows,
+to decide whether the welcome or disabled composer belongs in the current
+view. This local read starts no process and makes no host request.
+
+`supercode.frontend.beginSetup(harness)` starts work and returns its receipt.
+Duplicate clicks on a busy agent return the same operation. The other agent
+remains usable. `supercode.frontend.cancelSetup(harness, operationId)` cancels
+only the terminal that operation started; a stale operation id does nothing.
+Cancel returns to idle, while process failure shows **Try again** and
+**Sign-in didn't finish.** The full reason is written to the Chat output log.
+A process finishing never proves authentication: the host's native inventory
+must report a signed-in account. Once it does, readiness polling attaches
+and reveals the conversation without requiring another click, including when
+sign-in finishes in a separate terminal.
+
+Welcome metadata changes in place on each phase change. Cyclotron's paired
+native renderer uses it to show primary/secondary buttons, disabled spinners,
+one caption/Cancel/error slot per provider, and **Sign in to start a chat**
+in the disabled composer. Stock hosts retain native Markdown links. The
+editor's renderer/build is a separate integration; the frontend package alone
+does not claim those richer controls are installed in every host. A successful
+explicit sign-in publishes **Signed in with ChatGPT** or **Signed in with
+Claude** above the newly opened Chat.
+
+Setup creates no transcript turns. The guarded readiness reveal preserves a
+newer draft or selection; a welcome-owned empty draft can give way to the first
+ready conversation. Hosts without the guarded reveal command report the
+limitation. Passive inventory polling retries a transient handoff failure until
+attachment and reveal both succeed for the same conversation.
 
 A bundling host can expose a private lifecycle endpoint through
 `SUPERCODE_FRONTEND_HOST_URL` and `SUPERCODE_FRONTEND_HOST_CREDENTIAL_FILE`.
@@ -89,17 +70,15 @@ and returns its new scoped connection. The host owns validation, process lifetim
 persistence, and failure handling. Prompts and approvals still use the generated frontend client.
 The contract is in `src/host-controls.ts`.
 
-With that host, **New Session** / **Chat: New Chat: Choose Agent** asks only
-which startable agent to use. It refreshes the host's available choices first;
-with one ready local agent and no pending native sign-in choices it opens
-immediately, even when the official ChatGPT choice is available. Otherwise the
-picker includes the official choice on supported hosts; with no choices it returns
-to setup. Picking an agent sends model
-and reasoning as empty values, leaving both at the harness's own defaults,
-even if the previous conversation used explicit settings. Each agent whose model
-and reasoning a chat can set (Claude Code, Codex) is also listed in the picker as **<agent>: model
-and reasoning…**, which goes on to the model and effort choices below. Cancelling the agent
-picker starts no backend conversation.
+With that host, **New Session** / **Chat: New Chat: Choose Agent** lists all
+coding agents, including Codex and Claude Code when missing or signed out.
+Their rows say **Signed in with ChatGPT/Claude** or **Sign in with
+ChatGPT/Claude…**. A sign-in row starts the same install/login operation as the
+welcome. Selecting a ready agent leaves model and reasoning at its defaults;
+the separate **<agent>: model and reasoning…** rows retain explicit settings.
+The picker is titled **New chat**, with **Choose your coding agent** as its
+placeholder. Cancelling it starts no backend conversation. Initial automatic
+agent selection and last-used selection remain the host's responsibility.
 
 The native blank chat opens before the picker appears. First send waits for the
 choice and the host's new connection through Code-OSS's session-creation handler;
@@ -111,7 +90,7 @@ paths. A failed startup leaves the draft available to retry.
 
 The pending agent/model choice belongs to that blank chat's untitled resource
 and is retired when another conversation opens. Cancelling or opening sign-in
-does not choose an agent. Readiness polling and **Check again** still discover
+does not choose an agent. Readiness polling continues to discover
 agents while a draft is open, updating the welcome and model catalogue without
 replacing its widget or input. First send refreshes readiness; after a native
 sign-in choice it uses that agent once ready, otherwise it keeps the draft with
@@ -414,6 +393,22 @@ are read only for backwards compatibility.
 Restored response cancellation interrupts the runtime and waits for acknowledgement.
 Session-list updates consistently prioritize pending input over busy status.
 
+Reload restoration joins the runtime's canonical history to events after its
+`history_cursor`. A separately loaded native transcript is a fallback when the
+runtime has no user history; it never replaces the live event tail. The final
+running response is replayed through `activeResponseCallback`, with each pending
+request drawn once from the snapshot and later events followed by sequence.
+An idle runtime with a pending request also keeps this callback open until the
+request is resolved. Standalone requests use the explicit runtime-history marker
+instead of reopening an earlier answer. Managed conversations save their native
+identity before sending input, as well as when a turn ends.
+Stop is observed during the save and checked before input, including a lease
+renewal retry. Retained request/decision records with no originating replay
+prompt appear in a separate runtime-history turn.
+The [reload investigation](../../docs/evidence/chat-pending-approval-reload-2026-10-08.md)
+separates the retained first-user failure from this source change; a live
+candidate reload and approval click remain unmeasured.
+
 The pinned Code-OSS host needs a resource-scoping repair in its input-state change
 routing: stock code broadcasts changes to all input states of a provider. The
 Volter overlay guards this fix with a native regression test. The former legacy

package/dist/chat-setup.d.ts

@@ -1,25 +1,40 @@
-/** Native Chat presentation; the host supplies inventory and terminal actions. */
+/** Native Chat setup. The host owns inventory, commands and provider credentials. */
 import * as vscode from 'vscode';
-import type { ChatSetupState } from './host-controls.js';
-export declare const CHATGPT_SIGN_IN = "supercode.frontend.signInWithChatGPT";
-export declare const CHATGPT_SIGN_IN_BEGIN = "supercode.frontend.beginChatGPTSignIn";
-export declare const CHATGPT_SIGN_IN_STATUS = "supercode.frontend.chatGPTSignInStatus";
-export type ChatGPTSignInWorkPhase = 'checking-gallery' | 'installing-extension' | 'opening-sidebar';
-export interface ChatGPTSignInOperation {
+import type { ChatSetupAgent, HostState } from './host-controls.js';
+export declare const SETUP_BEGIN = "supercode.frontend.beginSetup";
+export declare const SETUP_CANCEL = "supercode.frontend.cancelSetup";
+export declare const SETUP_STATE = "supercode.frontend.setupState";
+export type ChatSetupPhase = 'idle' | 'installing' | 'signing-in' | 'failed' | 'signed-in';
+export interface ChatSetupOperation {
     readonly id: string;
-    readonly phase: ChatGPTSignInWorkPhase | 'completed' | 'failed';
+    readonly harness: string;
+    readonly phase: ChatSetupPhase;
     readonly startedAt: number;
     readonly updatedAt: number;
-    readonly finishedAt?: number;
 }
-/** The install command also exists in gallery-less Code-OSS. Fail closed when
- * the host's product configuration cannot be inspected through the VS Code API. */
-export declare function chatGPTAvailable(): Promise<boolean>;
-/** Only called by an explicit click. The gallery and extension own installation
- * and authentication; there is no terminal or provider credential handling here. */
-export declare function signInWithChatGPT(report?: (phase: ChatGPTSignInWorkPhase) => void): Promise<void>;
-/** Empty-chat welcome content, rendered by Code-OSS's ChatViewWelcomePart.
- * Only the official extension gets the primary button; native local sign-in
- * actions remain ordinary links. Commands and host diagnostic paths stay out
- * of the welcome, and the host still revalidates every action on click. */
-export declare function setupWelcome(setup: ChatSetupState, chatGPT?: boolean): vscode.MarkdownString;
+export interface ChatSetupProvider extends ChatSetupAgent {
+    provider: string;
+    phase: ChatSetupPhase;
+    buttonLabel: string;
+    caption: string;
+    busy: boolean;
+    operationId: string | null;
+}
+export interface ChatSetupPresentation {
+    version: 1;
+    visible: boolean;
+    title: string;
+    subtitle: string;
+    footnote: string;
+    composerPlaceholder: string;
+    composerEnabled: boolean;
+    rows: ChatSetupProvider[];
+    signedInNotice: string | null;
+}
+/** Older hosts can describe readiness through actions and startable choices.
+ * An absent account stays unknown; a launched process never establishes login. */
+export declare function setupAgents(state: HostState): ChatSetupAgent[];
+export declare function setupPresentation(state: HostState, operations: ReadonlyMap<string, ChatSetupOperation>, notice?: string): ChatSetupPresentation;
+/** Stock hosts keep native Markdown. Cyclotron reads the same state through
+ * SETUP_STATE to render disabled buttons, progress and the composer in place. */
+export declare function setupWelcome(presentation: ChatSetupPresentation): vscode.MarkdownString;

package/dist/chat-setup.js

@@ -1,69 +1,65 @@
-/** Native Chat presentation; the host supplies inventory and terminal actions. */
+/** Native Chat setup. The host owns inventory, commands and provider credentials. */
 import * as vscode from 'vscode';
-export const CHATGPT_SIGN_IN = 'supercode.frontend.signInWithChatGPT';
-export const CHATGPT_SIGN_IN_BEGIN = 'supercode.frontend.beginChatGPTSignIn';
-export const CHATGPT_SIGN_IN_STATUS = 'supercode.frontend.chatGPTSignInStatus';
-const CODEX_EXTENSION = 'openai.chatgpt';
-const INSTALL_EXTENSION = 'workbench.extensions.installExtension';
-/** The install command also exists in gallery-less Code-OSS. Fail closed when
- * the host's product configuration cannot be inspected through the VS Code API. */
-export async function chatGPTAvailable() {
-    try {
-        if (!vscode.env.appRoot || !(await vscode.commands.getCommands(true)).includes(INSTALL_EXTENSION))
-            return false;
-        const bytes = await vscode.workspace.fs.readFile(vscode.Uri.joinPath(vscode.Uri.file(vscode.env.appRoot), 'product.json'));
-        const product = JSON.parse(Buffer.from(bytes).toString('utf8'));
-        const serviceUrl = product?.extensionsGallery?.serviceUrl;
-        return typeof serviceUrl === 'string' && /^https?:\/\//.test(serviceUrl);
-    }
-    catch {
-        return false;
-    }
+export const SETUP_BEGIN = 'supercode.frontend.beginSetup';
+export const SETUP_CANCEL = 'supercode.frontend.cancelSetup';
+export const SETUP_STATE = 'supercode.frontend.setupState';
+const PROVIDERS = [
+    { harness: 'codex', name: 'Codex', provider: 'ChatGPT', caption: 'Runs Codex · ChatGPT Plus, Pro or Business' },
+    { harness: 'claude-code', name: 'Claude Code', provider: 'Claude', caption: 'Runs Claude Code · Claude Pro or Max' },
+];
+/** Older hosts can describe readiness through actions and startable choices.
+ * An absent account stays unknown; a launched process never establishes login. */
+export function setupAgents(state) {
+    if (state.setup?.agents)
+        return state.setup.agents.map(agent => ({ ...agent }));
+    const ids = new Set([...PROVIDERS.map(p => p.harness), ...state.harnesses.map(h => h.id), ...(state.setup?.actions ?? []).map(a => a.harness)]);
+    return [...ids].map(harness => {
+        const choice = state.harnesses.find(h => h.id === harness);
+        const actions = state.setup?.actions.filter(a => a.harness === harness) ?? [];
+        return { harness, name: choice?.name ?? PROVIDERS.find(p => p.harness === harness)?.name ?? actions[0]?.name ?? harness,
+            installed: !actions.some(a => a.kind === 'install') && Boolean(choice || actions.some(a => a.kind === 'login')),
+            signedIn: choice?.autoStart === true && !actions.some(a => a.kind === 'login'), account: null };
+    });
 }
-/** Only called by an explicit click. The gallery and extension own installation
- * and authentication; there is no terminal or provider credential handling here. */
-export async function signInWithChatGPT(report) {
-    report?.('checking-gallery');
-    if (!await chatGPTAvailable())
-        throw new Error('This host does not provide an extension gallery.');
-    if (!vscode.extensions.getExtension(CODEX_EXTENSION)) {
-        // enable makes the workbench await the running extension registry, not
-        // just the installed inventory, before we dispatch the contributed command.
-        report?.('installing-extension');
-        await vscode.commands.executeCommand(INSTALL_EXTENSION, CODEX_EXTENSION, { enable: true });
-    }
-    // openai.chatgpt contributes this command, not a public sign-in command.
-    // Revealing its sidebar presents its own Sign in with ChatGPT when signed out.
-    report?.('opening-sidebar');
-    await vscode.commands.executeCommand('chatgpt.openSidebar');
+export function setupPresentation(state, operations, notice) {
+    const agents = setupAgents(state);
+    const providers = PROVIDERS.map(provider => {
+        const agent = agents.find(a => a.harness === provider.harness) ?? { harness: provider.harness, name: provider.name, installed: false, signedIn: false, account: null };
+        const operation = operations.get(provider.harness);
+        const phase = agent.signedIn ? 'signed-in' : operation?.phase ?? 'idle';
+        const busy = phase === 'installing' || phase === 'signing-in';
+        return { ...agent, provider: provider.provider, phase,
+            buttonLabel: phase === 'installing' ? `Installing ${provider.name}…` : phase === 'signing-in' ? 'Finish signing in in your browser…'
+                : phase === 'failed' ? 'Try again' : `Sign in with ${provider.provider}`,
+            caption: busy ? 'Cancel' : phase === 'failed' ? "Sign-in didn't finish." : provider.caption,
+            busy, operationId: operation?.id ?? null };
+    });
+    const visible = Boolean(state.setup && !state.setup.ready);
+    return { version: 1, visible, title: 'Chat', subtitle: 'Use the AI plan you already pay for.',
+        footnote: 'Runs on this computer with your own account.', composerPlaceholder: visible ? 'Sign in to start a chat' : 'Ask a question or describe a task',
+        composerEnabled: !visible, rows: providers, signedInNotice: notice ? `Signed in with ${notice}` : null };
 }
-/** Empty-chat welcome content, rendered by Code-OSS's ChatViewWelcomePart.
- * Only the official extension gets the primary button; native local sign-in
- * actions remain ordinary links. Commands and host diagnostic paths stay out
- * of the welcome, and the host still revalidates every action on click. */
-export function setupWelcome(setup, chatGPT = false) {
+/** Stock hosts keep native Markdown. Cyclotron reads the same state through
+ * SETUP_STATE to render disabled buttons, progress and the composer in place. */
+export function setupWelcome(presentation) {
     const welcome = new vscode.MarkdownString();
-    welcome.isTrusted = { enabledCommands: [CHATGPT_SIGN_IN_BEGIN, 'supercode.frontend.setup', 'supercode.frontend.refreshSetup'] };
-    if (chatGPT) {
-        welcome.appendMarkdown(`[Sign in with ChatGPT](command:${CHATGPT_SIGN_IN_BEGIN})\n\n`);
-        welcome.appendMarkdown('Use the official Codex extension.');
+    welcome.isTrusted = { enabledCommands: [SETUP_BEGIN, SETUP_CANCEL] };
+    welcome.appendMarkdown(`${presentation.subtitle}\n\n`);
+    for (const provider of presentation.rows) {
+        const args = encodeURIComponent(JSON.stringify([provider.harness]));
+        if (provider.busy)
+            welcome.appendText(provider.buttonLabel);
+        else
+            welcome.appendMarkdown(`[${provider.buttonLabel}](command:${SETUP_BEGIN}?${args})`);
         welcome.appendMarkdown('\n\n');
-    }
-    welcome.appendMarkdown('**Supercode · local agents**\n\n');
-    const login = setup.actions.filter(action => action.kind === 'login');
-    if (login.length) {
-        for (const action of login) {
-            const title = new vscode.MarkdownString().appendText(`Sign in with ${action.name}`).value;
-            const args = encodeURIComponent(JSON.stringify([action.kind, action.harness]));
-            welcome.appendMarkdown(`- [${title}](command:supercode.frontend.setup?${args})\n`);
+        if (provider.busy) {
+            const cancel = encodeURIComponent(JSON.stringify([provider.harness, provider.operationId]));
+            welcome.appendMarkdown(`[Cancel](command:${SETUP_CANCEL}?${cancel})`);
         }
-        welcome.appendMarkdown('\n');
-        welcome.appendMarkdown('Each agent opens its own sign-in.');
-    }
-    else {
-        welcome.appendMarkdown('No local agents are ready. Install an agent on this machine to use it with Supercode.');
+        else
+            welcome.appendText(provider.caption);
+        welcome.appendMarkdown('\n\n');
     }
-    // Inline so it remains a secondary link, not another primary button.
-    welcome.appendMarkdown('\n\nAlready signed in? [Check again](command:supercode.frontend.refreshSetup).');
+    welcome.appendText(presentation.footnote);
     return welcome;
 }

package/dist/extension.js

@@ -2,14 +2,15 @@ import { resolveSessionBinding } from './bindings.js';
 import { withTextContext } from './context.js';
 import { randomUUID } from 'node:crypto';
 import { ChatHostControls, runtimeIdentity, harnessDisplayName, turnPermission } from './host-controls.js';
-import { CHATGPT_SIGN_IN, CHATGPT_SIGN_IN_BEGIN, CHATGPT_SIGN_IN_STATUS, chatGPTAvailable, setupWelcome, signInWithChatGPT } from './chat-setup.js';
+import { SETUP_BEGIN, SETUP_CANCEL, SETUP_STATE, setupAgents, setupPresentation, setupWelcome } from './chat-setup.js';
+import { ChatSetupFlow } from './setup-flow.js';
 import * as vscode from 'vscode';
 import { createFrontendClient } from './client.js';
 import { readCredentialFile } from './credential.js';
 import { grantedProposals, PROPOSAL_EFFECTS, REQUESTED_PROPOSALS } from './proposals.js';
 import { observeActiveResponse, sessionStatus } from './native-session.js';
 import { RequestNotPendingError, VscodeFrontendSession } from './session.js';
-import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
+import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, HISTORY_MARKER_PROMPT, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
 const SESSION_SCHEME = 'supercode';
 /** The harnesses whose model and reasoning effort a new chat can set (the host passes them to the CLI). */
 const CONFIGURABLE_HARNESSES = ['claude-code', 'codex'];
@@ -345,38 +346,6 @@ export async function activate(context) {
         }
     }
     const controls = await ChatHostControls.fromEnvironment();
-    const offerChatGPT = await chatGPTAvailable();
-    let signingInWithChatGPT;
-    let chatGPTSignInOperation;
-    const signInSnapshot = () => chatGPTSignInOperation ? { ...chatGPTSignInOperation } : null;
-    const startChatGPTSignIn = () => {
-        if (signingInWithChatGPT)
-            return signingInWithChatGPT;
-        const startedAt = Date.now();
-        const operation = { id: randomUUID(), startedAt };
-        const update = (phase) => {
-            const updatedAt = Date.now();
-            chatGPTSignInOperation = { ...operation, phase, updatedAt,
-                ...(phase === 'completed' || phase === 'failed' ? { finishedAt: updatedAt } : {}) };
-        };
-        signingInWithChatGPT = signInWithChatGPT(phase => update(phase)).then(() => {
-            // Fulfilled install/sidebar commands do not establish authentication.
-            update('completed');
-        }).catch(error => {
-            update('failed');
-            log.error(`Could not open ChatGPT sign-in: ${String(error)}`);
-            void vscode.window.showErrorMessage(`Could not open ChatGPT sign-in: ${error instanceof Error ? error.message : String(error)}`);
-        }).finally(() => { signingInWithChatGPT = undefined; });
-        return signingInWithChatGPT;
-    };
-    context.subscriptions.push(
-    // Preserve the completion-awaiting command used by the agent picker.
-    vscode.commands.registerCommand(CHATGPT_SIGN_IN, startChatGPTSignIn), 
-    // A click starts one retained task. Its receipt is not install/login success.
-    vscode.commands.registerCommand(CHATGPT_SIGN_IN_BEGIN, () => {
-        void startChatGPTSignIn();
-        return signInSnapshot();
-    }), vscode.commands.registerCommand(CHATGPT_SIGN_IN_STATUS, (operationId) => operationId === undefined || operationId === chatGPTSignInOperation?.id ? signInSnapshot() : null));
     const controlsChanged = new vscode.EventEmitter();
     context.subscriptions.push(controlsChanged);
     // A person's explicit picker choice: per conversation once it is bound, and for the new chat before then.
@@ -628,6 +597,7 @@ export async function activate(context) {
         setupHandoff = { id, baseUrl: connection.baseUrl };
     };
     let setupRevealed = false;
+    let welcomeWasVisible = controls?.state.setup?.ready === false;
     const revealSetup = async () => {
         if (!granted.has('chatSessionsProvider') || !controls?.state.setup || controls.state.setup.ready || setupRevealed)
             return;
@@ -636,6 +606,13 @@ export async function activate(context) {
         await vscode.commands.executeCommand(`workbench.action.chat.openNewChatSessionInPlace.${SESSION_SCHEME}`, 'sidebar');
         setupRevealed = true;
     };
+    let refreshingInventory;
+    const refreshInventory = () => {
+        if (!controls)
+            return Promise.resolve();
+        refreshingInventory ??= controls.refresh().then(() => { controlsChanged.fire(); }).finally(() => { refreshingInventory = undefined; });
+        return refreshingInventory;
+    };
     let refreshingSetup;
     const refreshSetup = () => {
         if (refreshingSetup)
@@ -645,9 +622,10 @@ export async function activate(context) {
                 return;
             const generation = focusGeneration;
             const focusResource = focusedResource?.toString() ?? null;
+            welcomeWasVisible ||= controls.state.setup?.ready === false;
             // Discover and publish readiness even while a blank chat holds a draft.
             // Only the automatic reveal is suppressed; discovery must never stall.
-            await controls.refresh();
+            await refreshInventory();
             const state = controls.state;
             controlsChanged.fire();
             if (state.setup?.ready || (!state.setup && state.connection?.SUPERCODE_FRONTEND_URL)) {
@@ -672,7 +650,7 @@ export async function activate(context) {
             const live = target?.kind === 'managed' && Boolean(frontends.get(target.id)?.session.pendingRequests.size
                 || frontends.get(target.id)?.session.descriptor?.turn_state === 'busy');
             if (!target || !controls || applying !== applied || target.generation !== focusGeneration
-                || (focusedResource?.path.startsWith('/untitled-') && !live))
+                || (focusedResource?.path.startsWith('/untitled-') && !live && !welcomeWasVisible))
                 return;
             if (target.kind === 'managed') {
                 if ((controls.state.setup && !controls.state.setup.ready) || controls.state.activeSession !== target.id
@@ -680,45 +658,74 @@ export async function activate(context) {
                     return;
                 if (!setupHandoffComplete())
                     await revealManaged(target, { resource: target.focusResource });
+                if (setupHandoffComplete())
+                    welcomeWasVisible = false;
             }
             else if (!controls.state.setup?.ready) {
                 await revealSetup();
             }
         });
-        // Coalesce Check again/polling through actual reveal completion or refusal.
+        // Coalesce inventory refresh through actual reveal completion or refusal.
         refreshingSetup = revealed.finally(() => { refreshingSetup = undefined; });
         return refreshingSetup;
     };
     const setupTerminals = new Map();
     context.subscriptions.push(vscode.window.onDidCloseTerminal(terminal => {
-        for (const [key, value] of setupTerminals)
-            if (value === terminal)
-                setupTerminals.delete(key);
-    }));
-    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.refreshSetup', refreshSetup));
-    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.setup', async (kind, harness) => {
-        if (!controls)
-            throw new Error('This host does not expose sign-in.');
-        const key = `${kind}/${harness}`;
-        const existing = setupTerminals.get(key);
-        if (existing && existing.exitStatus === undefined) {
-            existing.show();
-            return;
+        const resolve = setupTerminals.get(terminal);
+        if (resolve) {
+            setupTerminals.delete(terminal);
+            resolve(terminal.exitStatus?.code);
         }
-        await controls.refresh();
-        const offered = controls.state.setup?.actions.find(a => a.kind === kind && a.harness === harness);
-        if (!offered) {
-            await refreshSetup();
-            throw new Error('This setup action is no longer available.');
-        }
-        const action = await controls.setup(kind, harness);
-        if (action.command !== offered.command)
-            throw new Error('The setup command changed. Check again before running it.');
-        const terminal = vscode.window.createTerminal({ name: `${action.name} · ${kind === 'login' ? 'sign in' : 'install'}`,
-            cwd: action.cwd, shellPath: action.program, shellArgs: action.arguments, env: action.env });
-        setupTerminals.set(key, terminal);
-        terminal.show();
     }));
+    const setupFlow = controls ? new ChatSetupFlow({
+        state: () => controls.state,
+        refresh: async () => {
+            await refreshInventory();
+            // Inventory settles independently of guarded navigation: a person moving
+            // focus does not turn a successful native login into a failed one.
+            if (controls.state.setup?.ready && !setupHandoffComplete()) {
+                void refreshSetup().catch(error => log.warn(`Could not reveal signed-in Chat: ${String(error)}`));
+            }
+        },
+        changed: () => {
+            const choice = activeDraft()?.choice;
+            if (choice?.kind === 'signIn' && choice.harness && setupAgents(controls.state).some(agent => agent.harness === choice.harness && agent.signedIn)) {
+                activeDraft().choice = { kind: 'agent', selection: { harness: choice.harness, model: '', effort: '' } };
+            }
+            controlsChanged.fire();
+        },
+        log: message => log.error(message),
+        launch: async (kind, harness, current) => {
+            if (!current())
+                throw new vscode.CancellationError();
+            const offered = controls.state.setup?.actions.find(a => a.kind === kind && a.harness === harness);
+            if (!offered)
+                throw new Error('This sign-in or install action is unavailable.');
+            const action = await controls.setup(kind, harness);
+            if (!current())
+                throw new vscode.CancellationError();
+            if (action.command !== offered.command)
+                throw new Error('The sign-in command changed. Try again.');
+            const terminal = vscode.window.createTerminal({ name: `${action.name} · ${kind === 'login' ? 'sign in' : 'install'}`,
+                cwd: action.cwd, shellPath: action.program, shellArgs: action.arguments, env: action.env });
+            const exited = new Promise(resolve => {
+                setupTerminals.set(terminal, resolve);
+                // The process can finish before the close listener has observed this terminal.
+                if (terminal.exitStatus) {
+                    setupTerminals.delete(terminal);
+                    resolve(terminal.exitStatus.code);
+                }
+            });
+            terminal.show();
+            return { exited, cancel: () => terminal.dispose() };
+        },
+    }) : undefined;
+    const setupState = () => controls ? setupPresentation(controls.state, setupFlow?.operations ?? new Map(), setupFlow?.notice) : null;
+    context.subscriptions.push({ dispose: () => setupFlow?.dispose() }, vscode.commands.registerCommand('supercode.frontend.refreshSetup', refreshSetup), vscode.commands.registerCommand(SETUP_STATE, setupState), vscode.commands.registerCommand(SETUP_BEGIN, (harness) => {
+        if (!setupFlow)
+            throw new Error('This host does not expose sign-in.');
+        return setupFlow.begin(harness);
+    }), vscode.commands.registerCommand(SETUP_CANCEL, (harness, operationId) => setupFlow?.cancel(harness, operationId) ?? false));
     const restoring = new Map();
     const connectionFor = async (resource, activate = true, token) => {
         if (savedAttachments.has(resource.authority)) {
@@ -943,7 +950,7 @@ export async function activate(context) {
             throw new Error(`Finish signing in with ${harnessDisplayName(loginHarness)} before sending.`);
         }
         if (choice?.kind !== 'agent' && controls.state.setup && !controls.state.setup.ready) {
-            throw new Error('Sign in before sending; use Check again after signing in.');
+            throw new Error('Sign in to start a chat.');
         }
         const selection = choice?.kind === 'agent' ? choice.selection
             : { harness: loginHarness ?? controls.state.selection.harness, model: '', effort: '' };
@@ -1078,41 +1085,31 @@ export async function activate(context) {
             return;
         }
         await controls.refresh();
-        // Sign-in choices stay visible alongside agents that can be explicitly started.
-        const login = controls.state.setup?.actions.filter(action => action.kind === 'login') ?? [];
-        const localChoices = [
-            ...login.map(action => ({ label: action.name, id: action.harness, description: 'Sign in…', login: true, autoStart: false, configure: false })),
-            ...controls.state.harnesses.filter(h => !login.some(action => action.harness === h.id))
-                .map(h => ({ label: h.name, id: h.id, description: h.description, login: false, autoStart: h.autoStart === true, configure: false })),
-        ];
-        // Each agent whose model and reasoning a chat can set also offers that, right where the agent is chosen.
+        const agents = setupAgents(controls.state);
+        const localChoices = agents.map(agent => ({ label: agent.name, id: agent.harness,
+            description: agent.harness === 'codex' ? (agent.signedIn ? 'Signed in with ChatGPT' : 'Sign in with ChatGPT…')
+                : agent.harness === 'claude-code' ? (agent.signedIn ? 'Signed in with Claude' : 'Sign in with Claude…')
+                    : controls.state.harnesses.find(h => h.id === agent.harness)?.description,
+            login: controls.state.setup?.actions.some(a => a.harness === agent.harness) ?? false,
+            autoStart: controls.state.harnesses.some(h => h.id === agent.harness && h.autoStart), configure: false }));
         const modelChoices = localChoices.filter(choice => !choice.login && CONFIGURABLE_HARNESSES.includes(choice.id))
-            .map(choice => ({ ...choice, label: `${choice.label}: model and reasoning…`, description: 'Choose the model and reasoning effort', autoStart: false, configure: true }));
-        const choices = [
-            ...(offerChatGPT ? [{ label: 'Sign in with ChatGPT', id: CHATGPT_SIGN_IN, description: 'Official Codex extension', login: false, autoStart: false, configure: false }] : []),
-            ...localChoices,
-            ...modelChoices,
-        ];
+            .map(choice => ({ ...choice, label: `${choice.label}: model and reasoning…`, description: undefined, autoStart: false, configure: true }));
+        const choices = [...localChoices, ...(modelChoices.length ? [{ label: '', id: '__models__', kind: vscode.QuickPickItemKind.Separator,
+                    description: undefined, login: false, autoStart: false, configure: false }, ...modelChoices] : [])];
         if (!choices.length) {
             await revealSetup();
             return;
         }
-        // A sole sign-in option still requires a deliberate click before opening its terminal.
-        // The official choice must not disable the existing sole-local-agent shortcut.
         await chooseNewChat(async () => {
-            const harness = localChoices.length === 1 && localChoices[0].autoStart ? localChoices[0] : await vscode.window.showQuickPick(choices, { title: 'New chat · Agent', placeHolder: 'Choose your coding agent. Its default model and reasoning apply unless you choose them.' });
+            const harness = await vscode.window.showQuickPick(choices, { title: 'New chat', placeHolder: 'Choose your coding agent' });
             if (!harness)
                 return { kind: 'cancelled' };
             if (harness.configure) {
                 const chosen = await pickModelAndEffort(harness.id);
                 return chosen ? { kind: 'agent', selection: { harness: harness.id, ...chosen } } : { kind: 'cancelled' };
             }
-            if (harness.id === CHATGPT_SIGN_IN) {
-                await vscode.commands.executeCommand(CHATGPT_SIGN_IN);
-                return { kind: 'signIn' };
-            }
             if (harness.login) {
-                await vscode.commands.executeCommand('supercode.frontend.setup', 'login', harness.id);
+                await vscode.commands.executeCommand(SETUP_BEGIN, harness.id);
                 return { kind: 'signIn', harness: harness.id };
             }
             return { kind: 'agent', selection: { harness: harness.id, model: '', effort: '' } };
@@ -1298,6 +1295,11 @@ export async function activate(context) {
             } };
     };
     const runTurnInto = async (connection, prompt, stream, token, approval) => {
+        const throwIfCancelled = () => {
+            if (token.isCancellationRequested)
+                throw new vscode.CancellationError();
+        };
+        throwIfCancelled();
         if (approval() === 'autoApprove' && !canAnswer(connection)) {
             throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
         }
@@ -1338,13 +1340,20 @@ export async function activate(context) {
         const unwatchTasks = connection.session.onChange(sayTasks);
         let completed = false;
         try {
+            // Observe Stop throughout the save, then check the token before input.
+            // A cancellation while this idle runtime saves cannot be handled by an
+            // interrupt alone: there is no running turn to interrupt yet.
+            if (controls && !attachedIds.has(connection.id) && connection.session.descriptor?.session_id) {
+                await controls.remember(connection.id, connection.session.descriptor.session_id);
+            }
+            throwIfCancelled();
             await connection.session.runTurn(prompt, (event) => {
                 // A turn the person stopped is marked stopped by VS Code itself; only an interruption from elsewhere is said.
                 if (event.kind === 'turn_interrupted' && token.isCancellationRequested)
                     return;
                 writeProjected(stream, projectEvent(event, projection), granted, state);
                 watch.sweep();
-            });
+            }, { throwIfCancelled });
             completed = true;
         }
         finally {
@@ -1447,14 +1456,18 @@ export async function activate(context) {
         if (!granted.has('defaultChatParticipant'))
             return;
         const setup = controls?.state.setup;
-        const welcome = setup && !setup.ready ? setupWelcome(setup, offerChatGPT)
+        const presentation = setupState();
+        const welcome = setup && !setup.ready ? setupWelcome(presentation)
             : !controls && frontends.all.length === 0 ? new vscode.MarkdownString(unavailableMarkdown(frontends.unavailable))
                 : undefined;
-        if (welcomeValue === welcome?.value)
+        const key = JSON.stringify([welcome?.value, presentation]);
+        if (welcomeValue === key)
             return;
-        welcomeValue = welcome?.value;
+        welcomeValue = key;
         // Metadata updates merge across RPC; undefined can leave the previous
         // sign-in message behind. An explicit empty value clears it in place.
+        // The native renderer owns the signed-in notice above a ready conversation.
+        // Keeping it in this fallback message would draw it again below that notice.
         for (const participant of participants)
             participant.additionalWelcomeMessage = welcome ?? new vscode.MarkdownString('');
     };
@@ -1615,7 +1628,7 @@ export async function activate(context) {
             await controls.refresh();
         if (inspect === true)
             return {
-                chatGPTSignIn: signInSnapshot(),
+                setupState: setupState(),
                 connections: frontends.all.map(c => ({ ...frontends.info(c), permissions: [...c.session.permissions],
                     pendingRequests: [...c.session.pendingRequests.values()] })),
                 selection: controls?.state.selection, activeSession: controls?.state.activeSession,
@@ -1779,7 +1792,10 @@ export async function activate(context) {
     let setupDisposed = false;
     const pollSetup = () => {
         const choice = activeDraft()?.choice;
-        const awaitingLogin = choice?.kind === 'signIn' && choice.harness && !controls?.state.harnesses.some(h => h.id === choice.harness && h.autoStart);
+        const awaitingLogin = (choice?.kind === 'signIn' && choice.harness && !setupAgents(controls.state).some(h => h.harness === choice.harness && h.signedIn))
+            || [...(setupFlow?.operations.values() ?? [])].some(operation => operation.phase === 'installing' || operation.phase === 'signing-in');
+        if ([...(setupFlow?.operations.values() ?? [])].some(operation => operation.phase === 'installing' || operation.phase === 'signing-in'))
+            return;
         if (setupTimer || setupDisposed || !controls?.state.setup || (controls.state.setup.ready && setupHandoffComplete() && !awaitingLogin))
             return;
         setupTimer = setTimeout(() => {
@@ -1788,6 +1804,7 @@ export async function activate(context) {
         }, 3000);
     };
     pollSetup();
+    context.subscriptions.push(controlsChanged.event(pollSetup));
     context.subscriptions.push({ dispose: () => { setupDisposed = true; clearTimeout(setupTimer); } });
     return {
         connect: async (options) => {
@@ -2021,12 +2038,16 @@ function registerSessions(context, frontends, participant, granted, handler, his
             // canonical transcript, replayed as turns.
             const history = [];
             const authorId = historyParticipant(connection);
-            // A hosted harness runtime has no canonical ChatMessage history —
-            // `HostedHarnessRuntime::attach` returns an empty one and puts the
-            // conversation in `replay`. Read whichever the runtime actually
-            // filled, or a resumed session opens blank beside the person's own
-            // conversation.
-            const canonicalHistory = connection.persistedHistory?.length ? connection.persistedHistory : connection.session.history;
+            // History and replay are one runtime snapshot, joined by its cursor.
+            // A host's separately loaded native transcript has no replay cursor;
+            // selecting it instead hid every turn started since the runtime was
+            // created. Keep it only as a fallback when no runtime user history is
+            // available, rather than trying to align equal-looking prompt text.
+            const runtimeHistory = connection.session.history;
+            const replay = connection.session.replay.filter(event => event.sequence > connection.session.historyCursor);
+            const hasRuntimeHistory = runtimeHistory.length > 0 || replay.some(event => event.kind === 'user_message');
+            const usingSavedHistory = !hasRuntimeHistory && Boolean(connection.persistedHistory?.length);
+            const canonicalHistory = usingSavedHistory ? connection.persistedHistory : runtimeHistory;
             const pendingToolNames = new Set();
             if (connection.session.descriptor?.turn_state === 'busy') {
                 for (const request of connection.session.pendingRequests.values()) {
@@ -2038,14 +2059,44 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         pendingToolNames.add(name);
                 }
             }
-            const projected = canonicalHistory.length > 0
-                ? projectHistory(canonicalHistory, granted, pendingToolNames)
-                : projectReplayTurns(connection.session.replay, granted, {
-                    connectionId: connection.id,
-                    pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
-                    canRespond: connection.session.descriptor?.actions.respond !== false,
-                });
-            if (connection.historyTruncated)
+            const projected = projectReplayTurns(replay.filter(event => {
+                if (event.kind !== 'request')
+                    return true;
+                const payload = event.payload;
+                return !payload?.request || !connection.session.pendingRequests.has(payload.request.id);
+            }), granted, {
+                connectionId: connection.id,
+                pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
+                canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
+            }, projectHistory(canonicalHistory, granted, pendingToolNames));
+            const live = connection.session.descriptor?.turn_state === 'busy' || connection.session.pendingRequests.size > 0;
+            const activeParts = [];
+            if (live) {
+                // Standalone requests have no user turn. Give their live response
+                // an explicit runtime marker instead of reopening an old answer.
+                let lastBoundary = -1;
+                let lastUser = -1;
+                for (const event of replay) {
+                    if (['turn_succeeded', 'turn_failed', 'turn_interrupted'].includes(event.kind))
+                        lastBoundary = event.sequence;
+                    if (event.kind === 'user_message')
+                        lastUser = event.sequence;
+                }
+                if (!projected.some(turn => turn.role === 'user')
+                    || (connection.session.descriptor?.turn_state !== 'busy' && lastUser <= lastBoundary)) {
+                    projected.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+                }
+                // Leave the final request without a historical response, so the
+                // callback creates its response from live progress. Rehydrated
+                // responses can be stale; their command buttons are disabled.
+                const last = projected.at(-1);
+                if (last?.role === 'assistant') {
+                    activeParts.push(...(projected.pop()?.parts ?? []).map(part => part.part === 'answers'
+                        ? { part: 'markdown', value: `**${part.title}**\n\n${part.message}` }
+                        : part));
+                }
+            }
+            if (usingSavedHistory && connection.historyTruncated)
                 history.push(new turns.ChatRequestTurn('[Earlier conversation history]', undefined, [], authorId, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart('_Showing the latest 120 saved messages. Earlier context remains in the harness session._')], {}, authorId));
             for (const turn of projected) {
                 if (turn.role === 'user') {
@@ -2054,16 +2105,16 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 }
                 history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, authorId));
             }
-            const busy = connection.session.descriptor?.turn_state === 'busy';
             const renderedCursor = connection.session.cursor;
-            if (!busy)
+            const pendingAtCursor = [...connection.session.pendingRequests.values()];
+            if (!live)
                 connection.viewReady = attached;
             return {
                 title: connection.label,
                 options: controls?.attached(connection) ? undefined : controls?.currentOptions(resource),
                 history,
                 requestHandler: boundHandler,
-                activeResponseCallback: busy
+                activeResponseCallback: live
                     ? async (stream, token) => {
                         // A turn re-joined after a reload has lost the handler that ran it, so its approvals are
                         // answered here under the conversation's mode (t_39dac582): Auto approve answers the cards
@@ -2071,22 +2122,24 @@ function registerSessions(context, frontends, participant, granted, handler, his
                         const watch = controls && !controls.attached(connection) ? controls.watchApprovals(connection, stream, token) : undefined;
                         try {
                             const state = { toolInputs: new Map(), toolNames: new Map(), toolTitles: new Map(), toolCommands: new Map(), quiet: watch?.answers };
-                            writeProjected(stream, projectPendingRequests(connection.session.pendingRequests.values(), {
+                            for (const part of oneRowPerToolCall(activeParts))
+                                writePart(stream, part, state);
+                            writeProjected(stream, projectPendingRequests(pendingAtCursor.filter(request => connection.session.pendingRequests.has(request.id)), {
                                 connectionId: connection.id,
-                                canRespond: connection.session.descriptor?.actions.respond !== false,
+                                canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
                             }), granted, state);
                             watch?.sweep();
                             await observeActiveResponse(connection.session, token, (event) => {
                                 writeProjected(stream, projectEvent(event, {
                                     connectionId: connection.id,
                                     pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
-                                    canRespond: connection.session.descriptor?.actions.respond !== false,
+                                    canRespond: Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve')),
                                 }), granted, state);
                                 watch?.sweep();
                             }, () => { connection.viewReady = true; }, renderedCursor);
                         }
                         finally {
-                            connection.viewReady = connection.session.descriptor?.turn_state !== 'busy';
+                            connection.viewReady = connection.session.descriptor?.turn_state !== 'busy' && !connection.session.pendingRequests.size;
                             watch?.dispose();
                         }
                     }

package/dist/host-controls.d.ts

@@ -35,9 +35,17 @@ export interface ChatSetupAction {
     name: string;
     command: string;
 }
+export interface ChatSetupAgent {
+    harness: string;
+    name: string;
+    installed: boolean;
+    signedIn: boolean;
+    account: string | null;
+}
 export interface ChatSetupState {
     ready: boolean;
     actions: ChatSetupAction[];
+    agents?: ChatSetupAgent[];
     reason: string | null;
     cwd: string;
 }

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { createFrontendClient, type FrontendPermission, type VscodeFrontendConnection } from './client.js';
 export { readCredentialFile } from './credential.js';
-export type { ChatGPTSignInWorkPhase, ChatGPTSignInOperation } from './chat-setup.js';
+export type { ChatSetupPhase, ChatSetupOperation, ChatSetupProvider, ChatSetupPresentation } from './chat-setup.js';
+export type { ChatSetupAgent } from './host-controls.js';
 export { grantedProposals, PROPOSAL_EFFECTS, REQUESTED_PROPOSALS, type ProposalName, } from './proposals.js';
 export { EventSequenceGapError, LEASE_ERROR_NAMES, RequestNotPendingError, TURN_TERMINAL_KINDS, VscodeFrontendSession, type VscodeFrontendActions, type VscodeRuntimeClient, } from './session.js';
 export { HISTORY_MARKER_PROMPT, VSCODE_CHAT_LIMITS, acceptedDecisions, diffPaths, fence, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, requestAnswers, requestNeedsTypedReply, requestSubject, requestSummary, resolutionSentence, resolveParts, toolSubject, typedAnswer, type ChatAnswer, type ChatPart, type ProjectedPart, type ProjectedTurn, type ProjectionContext, } from './view.js';

package/dist/native-session.d.ts

@@ -3,4 +3,4 @@ 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';
 /** Follow a restored turn, including the interval between snapshot and callback. */
-export declare function observeActiveResponse(session: Pick<VscodeFrontendSession, 'descriptor' | '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' | 'interrupt' | 'actions' | 'replay'>, token: CancellationToken, write: (event: FrontendEvent) => void, onSubscribed?: () => void, afterSequence?: number): Promise<void>;

package/dist/native-session.js

@@ -34,7 +34,12 @@ export async function observeActiveResponse(session, token, write, onSubscribed,
                     reject(error);
                     return;
                 }
-                if (!cancelling && TURN_TERMINAL_KINDS.includes(event.kind))
+                if (event.kind === 'runtime_disconnected') {
+                    resolve();
+                    return;
+                }
+                const ended = TURN_TERMINAL_KINDS.includes(event.kind) || event.kind === 'request_resolved';
+                if (!cancelling && ended && session.descriptor?.turn_state !== 'busy' && !session.pendingRequests.size)
                     resolve();
             };
             unsubscribe = session.onEvent(consume);
@@ -47,7 +52,7 @@ export async function observeActiveResponse(session, token, write, onSubscribed,
             cancellation = token.onCancellationRequested(cancel);
             if (token.isCancellationRequested)
                 cancel();
-            else if (session.descriptor?.turn_state !== 'busy')
+            else if (session.descriptor?.turn_state !== 'busy' && !session.pendingRequests.size)
                 resolve();
         });
     }

package/dist/session.d.ts

@@ -147,7 +147,7 @@ export declare class VscodeFrontendSession {
     actions(): VscodeFrontendActions;
     /** Run one controller action, re-taking an expired lease exactly once. */
     private withControl;
-    submit(prompt: string): Promise<void>;
+    submit(prompt: string, throwIfCancelled?: () => void): Promise<void>;
     steer(prompt: string): Promise<void>;
     interrupt(): Promise<void>;
     /** Stop one of the harness's own background tasks, by the id it listed it with. */
@@ -164,6 +164,7 @@ export declare class VscodeFrontendSession {
      */
     runTurn(prompt: string, onEvent: (event: FrontendEvent) => void, options?: {
         onCancel?: (cancel: () => void) => void;
+        throwIfCancelled?: () => void;
     }): Promise<FrontendEvent | null>;
     private require;
     private notify;

package/dist/session.js

@@ -356,11 +356,16 @@ export class VscodeFrontendSession {
             return action();
         }
     }
-    async submit(prompt) {
+    async submit(prompt, throwIfCancelled) {
+        throwIfCancelled?.();
         this.require('submit');
         if (prompt.length === 0)
             throw new TypeError('prompt must not be empty');
-        await this.withControl(() => this.client.sendInput(prompt));
+        await this.withControl(() => {
+            // The same guard covers a send retried after an awaited lease renewal.
+            throwIfCancelled?.();
+            return this.client.sendInput(prompt);
+        });
     }
     async steer(prompt) {
         this.require('steer');
@@ -474,7 +479,7 @@ export class VscodeFrontendSession {
             void this.interrupt().catch((error) => fail?.(error));
         });
         try {
-            await this.submit(prompt);
+            await this.submit(prompt, options.throwIfCancelled);
             return await finished;
         }
         finally {

package/dist/setup-flow.d.ts

@@ -0,0 +1,28 @@
+import type { HostState } from './host-controls.js';
+import { type ChatSetupOperation } from './chat-setup.js';
+export interface SetupProcess {
+    exited: Promise<number | undefined>;
+    cancel(): void;
+}
+export interface SetupFlowHost {
+    state(): HostState;
+    refresh(): Promise<void>;
+    launch(kind: 'login' | 'install', harness: string, current: () => boolean): Promise<SetupProcess>;
+    changed(): void;
+    log(message: string): void;
+}
+export declare class ChatSetupFlow {
+    private readonly host;
+    readonly operations: Map<string, ChatSetupOperation>;
+    private processes;
+    private disposed;
+    notice: string | undefined;
+    constructor(host: SetupFlowHost);
+    begin(harness: string): ChatSetupOperation;
+    cancel(harness: string, id: string): boolean;
+    dispose(): void;
+    private current;
+    private update;
+    private refresh;
+    private run;
+}

package/dist/setup-flow.js

@@ -0,0 +1,127 @@
+/** One user-requested install/sign-in operation per agent. No credentials cross this boundary. */
+import { randomUUID } from 'node:crypto';
+import { setupAgents } from './chat-setup.js';
+export class ChatSetupFlow {
+    host;
+    operations = new Map();
+    processes = new Map();
+    disposed = false;
+    notice;
+    constructor(host) {
+        this.host = host;
+    }
+    begin(harness) {
+        if (this.disposed)
+            throw new Error('Chat setup has closed.');
+        const existing = this.operations.get(harness);
+        if (existing?.phase === 'installing' || existing?.phase === 'signing-in')
+            return { ...existing };
+        const agent = setupAgents(this.host.state()).find(a => a.harness === harness);
+        if (!agent)
+            throw new Error('That coding agent is unavailable.');
+        const now = Date.now();
+        const operation = { id: randomUUID(), harness, phase: agent.signedIn ? 'signed-in' : agent.installed ? 'signing-in' : 'installing', startedAt: now, updatedAt: now };
+        this.operations.set(harness, operation);
+        this.host.changed();
+        if (!agent.signedIn)
+            void this.run(operation);
+        return { ...operation };
+    }
+    cancel(harness, id) {
+        const operation = this.operations.get(harness);
+        if (!operation || operation.id !== id || !['installing', 'signing-in'].includes(operation.phase))
+            return false;
+        // Retire ownership before disposing the terminal: its close callback is not a failed sign-in.
+        this.operations.delete(harness);
+        this.processes.get(id)?.cancel();
+        this.processes.delete(id);
+        this.host.changed();
+        return true;
+    }
+    dispose() {
+        this.disposed = true;
+        for (const operation of this.operations.values())
+            this.processes.get(operation.id)?.cancel();
+        this.processes.clear();
+    }
+    current(operation) {
+        return !this.disposed && this.operations.get(operation.harness)?.id === operation.id;
+    }
+    update(operation, phase) {
+        if (!this.current(operation))
+            return;
+        this.operations.set(operation.harness, { ...operation, phase, updatedAt: Date.now() });
+        this.host.changed();
+    }
+    async refresh(operation) {
+        await this.host.refresh();
+        if (!this.current(operation))
+            throw new Error('Sign-in cancelled.');
+    }
+    async run(operation) {
+        const current = () => this.current(operation);
+        let process;
+        try {
+            await this.refresh(operation);
+            let agent = setupAgents(this.host.state()).find(a => a.harness === operation.harness);
+            if (!agent?.installed) {
+                this.update(operation, 'installing');
+                process = await this.host.launch('install', operation.harness, current);
+                if (!current()) {
+                    process.cancel();
+                    return;
+                }
+                this.processes.set(operation.id, process);
+                const exitCode = await process.exited;
+                this.processes.delete(operation.id);
+                if (!current())
+                    return;
+                if (exitCode !== 0)
+                    throw new Error(`Installation ended ${exitCode === undefined ? 'without an exit status' : `with exit code ${exitCode}`}.`);
+                await this.refresh(operation);
+                agent = setupAgents(this.host.state()).find(a => a.harness === operation.harness);
+                if (!agent?.installed)
+                    throw new Error('Installation completed, but the coding agent is not available to this editor.');
+            }
+            if (!agent.signedIn) {
+                this.update(operation, 'signing-in');
+                process = await this.host.launch('login', operation.harness, current);
+                if (!current()) {
+                    process.cancel();
+                    return;
+                }
+                this.processes.set(operation.id, process);
+                let ended = false;
+                let exitCode;
+                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()) {
+                    await this.refresh(operation);
+                    if (setupAgents(this.host.state()).some(a => a.harness === operation.harness && a.signedIn))
+                        break;
+                    if (ended)
+                        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;
+            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.
+            process?.cancel();
+        }
+        catch (error) {
+            if (current()) {
+                this.host.log(`Could not sign in with ${operation.harness}: ${String(error)}`);
+                this.update(operation, 'failed');
+                process?.cancel();
+            }
+        }
+        finally {
+            this.processes.delete(operation.id);
+        }
+    }
+}

package/dist/view.d.ts

@@ -170,14 +170,6 @@ export interface ProjectedTurn {
     /** Rendered parts for an assistant turn. */
     parts?: ChatPart[];
 }
-/**
- * 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.
- */
 /**
  * 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
@@ -186,7 +178,7 @@ export interface ProjectedTurn {
 export declare function automaticPrompt(body: string): {
     notice?: string;
 } | undefined;
-export declare function projectReplayTurns(events: readonly FrontendEvent[], granted: ReadonlySet<string>, context: ProjectionContext): ProjectedTurn[];
+export declare function projectReplayTurns(events: readonly FrontendEvent[], granted: ReadonlySet<string>, context: ProjectionContext, history?: readonly ProjectedTurn[]): ProjectedTurn[];
 /**
  * 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.

package/dist/view.js

@@ -650,14 +650,6 @@ function messageText(message) {
         .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.
- */
 /**
  * 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
@@ -675,8 +667,13 @@ export function automaticPrompt(body) {
         return {};
     return undefined;
 }
-export function projectReplayTurns(events, granted, context) {
-    const turns = [];
+export function projectReplayTurns(events, granted, context, history = []) {
+    // Join canonical history with its sequenced tail. Retained request/decision
+    // events can be re-sequenced past history_cursor with no originating turn.
+    // Before the replay supplies a prompt, give its parts their own runtime
+    // history turn rather than attributing old approvals to the latest answer.
+    const turns = history.map(turn => ({ ...turn, parts: turn.parts?.slice() }));
+    let replayTurn = false;
     let streamedText;
     for (const event of events) {
         if (event.kind === 'user_message') {
@@ -686,8 +683,10 @@ export function projectReplayTurns(events, granted, context) {
             if (automatic) {
                 if (!automatic.notice)
                     continue;
-                if (turns.length === 0)
+                if (!replayTurn) {
                     turns.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+                    replayTurn = true;
+                }
                 const last = turns[turns.length - 1];
                 const notice = { part: 'markdown', value: `\n\n${automatic.notice}\n\n` };
                 if (last.role === 'assistant' && last.parts)
@@ -697,6 +696,7 @@ export function projectReplayTurns(events, granted, context) {
                 continue;
             }
             turns.push({ role: 'user', prompt: clamp(stripControls(text(payload.text)), VSCODE_CHAT_LIMITS.partCharacters) });
+            replayTurn = true;
             continue;
         }
         const parts = resolveParts(projectEvent(event, context), granted);
@@ -712,8 +712,10 @@ export function projectReplayTurns(events, granted, context) {
         else {
             streamedText = undefined;
         }
-        if (turns.length === 0)
+        if (!replayTurn) {
             turns.push({ role: 'user', prompt: HISTORY_MARKER_PROMPT });
+            replayTurn = true;
+        }
         const last = turns[turns.length - 1];
         if (last.role === 'assistant' && last.parts)
             last.parts.push(...parts);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",