@volter/supercode-frontend-vscode 0.1.37 → 0.1.39

package/README.md

@@ -160,7 +160,8 @@ default is never stored as a choice (a pick equal to the default follows the def
 changes), and an Auto approve is never stored for a conversation that cannot answer. Conversations opened before 0.1.36 saved their picker's
 **Ask** when opened and keep it. Auto approve approves the requests the harness would ask you about, including requests to run
 outside its sandbox (Codex's approval requests are its sandbox escalations); the harness's deny
-rules still apply. Each request it answers is noted in the turn ("auto-approved: …"). Unsupported modes are refused. Unanswerable
+rules still apply. Each request it answers is noted in the turn ("auto-approved: …"). A turn
+re-joined after a page reload (the conversation's active response) is answered the same way. Unsupported modes are refused. Unanswerable
 harnesses show **Harness permissions**. Previously answered requests cannot affect another
 connection. Native command-button fallback limitations are documented below.
 

package/dist/extension.js

@@ -238,6 +238,8 @@ function writePart(stream, part, state) {
             return;
         }
         case 'answers':
+            if (part.approval && part.answers.length > 0 && state.quiet?.(part.answers[0].requestId))
+                return;
             if (part.approval && nativeInTurnApprovalCards && part.answers.length > 0) {
                 stream.confirmation(part.title, part.message, {
                     kind: 'supercode.inTurnApproval', version: 1, answers: part.answers,
@@ -369,6 +371,7 @@ export async function activate(context) {
     };
     // The approval sweeps of each conversation's running turns, so a picker change reaches a turn already running.
     const runningTurns = new Map();
+    const answeredRequests = new Map();
     // The host's default for a conversation no one has chosen for (Model Editor declares Auto approve).
     const hostDefault = () => controls?.state.defaultPermission === 'autoApprove' ? 'autoApprove' : 'ask';
     const canAnswer = (connection) => Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve'));
@@ -882,6 +885,7 @@ export async function activate(context) {
         attached: (connection) => attachedIds.has(connection.id),
         catalogue: () => controls?.state.sessions ?? [],
         bindings: boundId,
+        watchApprovals: (connection, stream, token) => watchApprovals(connection, stream, token, () => approvalFor(connection.id)),
     };
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.activateSession', async (resource) => { await connectionFor(vscode.Uri.parse(resource)); }));
     // The host's native focus event is authoritative even when a cached model
@@ -986,25 +990,30 @@ export async function activate(context) {
         });
     }));
     context.subscriptions.push({ dispose: () => frontends.dispose() });
-    const runTurnInto = async (connection, prompt, stream, token, approval) => {
-        if (approval() === 'autoApprove' && !canAnswer(connection)) {
-            throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
-        }
-        const answered = new Set();
-        const state = { toolInputs: new Map(), toolNames: new Map() };
-        const projection = {
-            connectionId: connection.id,
-            pendingRequest: (requestId) => connection.session.pendingRequests.get(requestId) ?? connection.session.resolvedRequests.get(requestId),
-            canRespond: connection.session.descriptor?.actions.respond !== false,
+    // Auto-answers a conversation's approvals while a response is written into `stream`: read at every event
+    // (`sweep`) and on every picker change for that conversation, so switching to Auto approve mid-turn answers
+    // the approvals already waiting and the ones after them. Used by a turn this window runs and by a turn it
+    // re-joins after a reload (the session's active response), whose original handler is gone.
+    const watchApprovals = (connection, stream, token, approval) => {
+        // One answered set per conversation, shared by every watch on it, so a re-joined response and a live turn
+        // never both answer the same request (the second answer would be refused and noted as a failure).
+        const answered = answeredRequests.get(connection.id) ?? new Set();
+        answeredRequests.set(connection.id, answered);
+        // Requests whose card was not shown because this watch was going to answer them.
+        const unshown = new Set();
+        const answers = (requestId) => {
+            if (approval() !== 'autoApprove' || token.isCancellationRequested || !canAnswer(connection))
+                return false;
+            const pending = connection.session.pendingRequests.get(requestId);
+            // Hidden only when this watch's own sweep will answer it: one another watch claimed keeps its card here.
+            if (!pending || pending.kind !== 'approval' || answered.has(requestId))
+                return false;
+            const decisions = acceptedDecisions(pending);
+            if (decisions && !decisions.includes('allow'))
+                return false;
+            unshown.add(requestId);
+            return true;
         };
-        const cancellation = token.onCancellationRequested(() => {
-            void connection.session.interrupt().catch(() => {
-                // The runtime may already be idle; interrupting twice is not an error
-                // this view reports.
-            });
-        });
-        // Read at every event and on every picker change, so switching to Auto approve mid-turn
-        // answers the approvals already waiting and the ones after them.
         const sweep = () => {
             if (approval() !== 'autoApprove' || token.isCancellationRequested || !canAnswer(connection))
                 return;
@@ -1026,26 +1035,65 @@ export async function activate(context) {
                     log.info(text.trim());
                 } };
                 void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).then(() => {
+                    // A card that was never shown needs no note: its resolution line says it was allowed.
+                    if (unshown.has(pending.id))
+                        return;
                     note(`\n_auto-approved: ${opaqueText(named ?? `request #${pending.id}`, 200)}_\n`);
                 }, error => {
                     note(`\nApproval failed: ${String(error.message || error)}. Use the approval buttons to answer.\n`);
+                    // A card this watch hid is shown now: a typed reply cannot reach a running turn, its buttons can.
+                    if (unshown.delete(pending.id) && connection.session.pendingRequests.has(pending.id)) {
+                        try {
+                            writeProjected(stream, projectPendingRequests([pending], {
+                                connectionId: connection.id,
+                                canRespond: connection.session.descriptor?.actions.respond !== false,
+                            }), granted, { toolInputs: new Map(), toolNames: new Map() });
+                        }
+                        catch {
+                            log.info(`Approval card for request #${pending.id} could not be shown: the response has closed`);
+                        }
+                    }
                 });
             }
         };
         const sweeps = runningTurns.get(connection.id) ?? new Set();
         runningTurns.set(connection.id, sweeps.add(sweep));
+        return { sweep, answers, dispose: () => {
+                sweeps.delete(sweep);
+                if (!sweeps.size && runningTurns.get(connection.id) === sweeps) {
+                    runningTurns.delete(connection.id);
+                    answeredRequests.delete(connection.id);
+                }
+            } };
+    };
+    const runTurnInto = async (connection, prompt, stream, token, approval) => {
+        if (approval() === 'autoApprove' && !canAnswer(connection)) {
+            throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
+        }
+        const state = { toolInputs: new Map(), toolNames: new Map() };
+        const projection = {
+            connectionId: connection.id,
+            pendingRequest: (requestId) => connection.session.pendingRequests.get(requestId) ?? connection.session.resolvedRequests.get(requestId),
+            canRespond: connection.session.descriptor?.actions.respond !== false,
+        };
+        const cancellation = token.onCancellationRequested(() => {
+            void connection.session.interrupt().catch(() => {
+                // The runtime may already be idle; interrupting twice is not an error
+                // this view reports.
+            });
+        });
+        const watch = watchApprovals(connection, stream, token, approval);
+        state.quiet = watch.answers;
         let completed = false;
         try {
             await connection.session.runTurn(prompt, (event) => {
                 writeProjected(stream, projectEvent(event, projection), granted, state);
-                sweep();
+                watch.sweep();
             });
             completed = true;
         }
         finally {
-            sweeps.delete(sweep);
-            if (!sweeps.size && runningTurns.get(connection.id) === sweeps)
-                runningTurns.delete(connection.id);
+            watch.dispose();
             cancellation.dispose();
             if (controls && !attachedIds.has(connection.id)) {
                 if (connection.session.descriptor?.session_id)
@@ -1686,18 +1734,29 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 requestHandler: boundHandler,
                 activeResponseCallback: busy
                     ? async (stream, token) => {
-                        const state = { toolInputs: new Map(), toolNames: new Map() };
-                        writeProjected(stream, projectPendingRequests(connection.session.pendingRequests.values(), {
-                            connectionId: connection.id,
-                            canRespond: connection.session.descriptor?.actions.respond !== false,
-                        }), granted, state);
-                        await observeActiveResponse(connection.session, token, (event) => {
-                            writeProjected(stream, projectEvent(event, {
+                        // 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
+                        // already waiting and later ones; Ask leaves them for the person, as before.
+                        const watch = controls && !controls.attached(connection) ? controls.watchApprovals(connection, stream, token) : undefined;
+                        try {
+                            const state = { toolInputs: new Map(), toolNames: new Map(), quiet: watch?.answers };
+                            writeProjected(stream, projectPendingRequests(connection.session.pendingRequests.values(), {
                                 connectionId: connection.id,
-                                pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
                                 canRespond: connection.session.descriptor?.actions.respond !== false,
                             }), 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,
+                                }), granted, state);
+                                watch?.sweep();
+                            });
+                        }
+                        finally {
+                            watch?.dispose();
+                        }
                     }
                     : undefined,
             };

package/package.json

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