@volter/supercode-frontend-vscode 0.1.31 → 0.1.32

package/README.md

@@ -48,8 +48,13 @@ 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 native reveal command succeed for that same session
-and runtime URL. A transient attach/reveal failure stays pending and is retried;
+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

package/dist/extension.js

@@ -447,14 +447,21 @@ export async function activate(context) {
             && setupHandoff.baseUrl === controls?.state.connection?.SUPERCODE_FRONTEND_URL
             && connection?.baseUrl === setupHandoff.baseUrl && connection.session.connection === 'connected');
     };
-    const revealManaged = async () => {
-        const id = controls?.state.activeSession;
-        if (!id || !controls?.state.openSessionCommand)
-            throw new Error('The host cannot reveal this conversation.');
-        await vscode.commands.executeCommand(controls.state.openSessionCommand, vscode.Uri.from({ scheme: SESSION_SCHEME, authority: id, path: '/conversation' }).toString());
+    const revealManaged = async (expected, readinessFocus) => {
+        const id = expected?.id ?? controls?.state.activeSession;
+        const baseUrl = expected?.baseUrl ?? controls?.state.connection?.SUPERCODE_FRONTEND_URL;
+        const command = readinessFocus ? controls?.state.revealReadySessionCommand : controls?.state.openSessionCommand;
+        if (!id || !baseUrl || !controls || !command)
+            throw new Error(readinessFocus
+                ? 'The host does not support a guarded readiness reveal. Open the conversation from history.'
+                : 'The host cannot reveal this conversation.');
+        if (controls.state.activeSession !== id || controls.state.connection?.SUPERCODE_FRONTEND_URL !== baseUrl) {
+            throw new vscode.CancellationError();
+        }
+        await vscode.commands.executeCommand(command, vscode.Uri.from({ scheme: SESSION_SCHEME, authority: id, path: '/conversation' }).toString(), ...(readinessFocus ? [readinessFocus.resource] : []));
         const connection = frontends.get(id);
         if (controls.state.activeSession !== id || !connection || connection.session.connection !== 'connected'
-            || connection.baseUrl !== controls.state.connection?.SUPERCODE_FRONTEND_URL) {
+            || connection.baseUrl !== baseUrl || controls.state.connection?.SUPERCODE_FRONTEND_URL !== baseUrl) {
             throw new Error('The conversation changed or disconnected before setup could reveal it.');
         }
         // Host readiness alone is not completion: the native reveal must succeed too.
@@ -476,28 +483,46 @@ export async function activate(context) {
         const pending = applying.then(async () => {
             if (!controls)
                 return;
+            const generation = focusGeneration;
+            const focusResource = focusedResource?.toString() ?? null;
             // 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();
             const state = controls.state;
             controlsChanged.fire();
-            const preserveDraft = focusedResource?.path.startsWith('/untitled-');
-            if (state.setup?.ready) {
+            if (state.setup?.ready || (!state.setup && state.connection?.SUPERCODE_FRONTEND_URL)) {
                 setupRevealed = false;
-                await connectManaged(state);
+                const connection = await connectManaged(state);
                 controlsChanged.fire();
-                if (!preserveDraft && !setupHandoffComplete())
-                    await revealManaged();
+                return { kind: 'managed', id: connection.id, baseUrl: connection.baseUrl, generation, focusResource };
             }
             else {
                 setupHandoff = undefined;
                 controlsChanged.fire();
-                if (!preserveDraft)
-                    await revealSetup();
+                return { kind: 'setup', generation };
+            }
+        });
+        // Native reveal awaits activation through connectionFor, which queues behind
+        // applying. Release this connection stage before asking the native view to open.
+        const applied = pending.then(() => undefined, () => undefined);
+        applying = applied;
+        const revealed = pending.then(async (target) => {
+            if (!target || !controls || applying !== applied || target.generation !== focusGeneration
+                || focusedResource?.path.startsWith('/untitled-'))
+                return;
+            if (target.kind === 'managed') {
+                if ((controls.state.setup && !controls.state.setup.ready) || controls.state.activeSession !== target.id
+                    || controls.state.connection?.SUPERCODE_FRONTEND_URL !== target.baseUrl)
+                    return;
+                if (!setupHandoffComplete())
+                    await revealManaged(target, { resource: target.focusResource });
+            }
+            else if (!controls.state.setup?.ready) {
+                await revealSetup();
             }
         });
-        applying = pending.then(() => undefined, () => undefined);
-        refreshingSetup = pending.finally(() => { refreshingSetup = undefined; });
+        // Coalesce Check again/polling through actual reveal completion or refusal.
+        refreshingSetup = revealed.finally(() => { refreshingSetup = undefined; });
         return refreshingSetup;
     };
     const setupTerminals = new Map();
@@ -1206,16 +1231,7 @@ export async function activate(context) {
         if (!granted.has('chatSessionsProvider'))
             return;
         if (controls) {
-            if (controls.state.setup && !controls.state.setup.ready) {
-                await revealSetup();
-                return;
-            }
-            try {
-                await revealManaged();
-            }
-            catch (error) {
-                log.error(`Could not open the saved conversation: ${String(error)}`);
-            }
+            await refreshSetup();
             return;
         }
         const connection = frontends.all.find((entry) => Boolean(controls) || entry.session.history.length > 0 ||

package/dist/host-controls.d.ts

@@ -36,6 +36,8 @@ export interface HostState {
     historyTruncated?: boolean;
     activeSession: string | null;
     openSessionCommand?: string;
+    /** Automatic ready-session reveal checks the observed native focus through its queued commit. */
+    revealReadySessionCommand?: string;
     sessions: ManagedChatSession[];
     selection: ChatSelection;
     connection?: Record<string, string>;

package/package.json

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