@volter/supercode-frontend-vscode 0.1.35 → 0.1.36

package/README.md

@@ -142,8 +142,17 @@ the same cached conversation. Managed resources then notify
 owns no processes.
 
 The permission group offers **Ask for approval** and, on an answerable interactive attachment,
-**Auto approve**. Policies are scoped by conversation and captured for each turn; automatic
-approval does not bypass harness sandbox rules. Unsupported modes are refused. Unanswerable
+**Auto approve**. Policies are scoped by conversation and read throughout the turn: switching to
+**Auto approve** while a turn runs answers the approvals already waiting and every later one.
+A lifecycle host may declare `defaultPermission: "autoApprove"` for conversations no one has
+picked a mode for (Model Editor does); it applies to Claude Code and Codex where the runtime answers approvals
+through Chat, every other harness keeps its own prompts, and a person's explicit pick always
+wins. Only a pick that differs from the default (or replaces an earlier pick) is saved, so the
+default is never stored as a choice (a pick equal to the default follows the default if it later
+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
 harnesses show **Harness permissions**. Previously answered requests cannot affect another
 connection. Native command-button fallback limitations are documented below.
 

package/dist/extension.js

@@ -356,11 +356,45 @@ export async function activate(context) {
     }), vscode.commands.registerCommand(CHATGPT_SIGN_IN_STATUS, (operationId) => operationId === undefined || operationId === chatGPTSignInOperation?.id ? signInSnapshot() : null));
     const controlsChanged = new vscode.EventEmitter();
     context.subscriptions.push(controlsChanged);
-    let permission = 'ask';
+    // A person's explicit picker choice: per conversation once it is bound, and for the new chat before then.
+    let permission;
     const permissions = new Map(context.workspaceState.get('supercode.sessionPermissions', []));
     const savePermission = (id, value) => {
         permissions.set(id, value);
         void Promise.resolve(context.workspaceState.update('supercode.sessionPermissions', [...permissions])).catch(error => log.error(`Could not persist conversation permissions: ${String(error)}`));
+        for (const sweep of runningTurns.get(id) ?? [])
+            sweep();
+    };
+    // The approval sweeps of each conversation's running turns, so a picker change reaches a turn already running.
+    const runningTurns = 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'));
+    // The host's default for one conversation: Auto approve only for a conversation the host manages and only
+    // where this Chat can answer the runtime's approvals, read from its live connection, or, while it is not
+    // connected, from the harness the host records for it (hosted Claude Code and Codex answer through Chat).
+    // A runtime attached by address and every other harness keep their own prompts.
+    const defaultFor = (id) => {
+        if (hostDefault() !== 'autoApprove' || attachedIds.has(id))
+            return 'ask';
+        const connection = frontends.get(id);
+        const harness = controls?.state.sessions.find(session => session.id === id)?.selection.harness ?? '';
+        // Only the harnesses whose approvals this default was decided for; a runtime that answers through another
+        // protocol (an ACP agent) keeps asking until a host names it.
+        return ['claude-code', 'codex'].includes(harness) && (!connection || canAnswer(connection)) ? 'autoApprove' : 'ask';
+    };
+    // What governs a conversation's approvals: the person's choice, else the host's default.
+    const approvalFor = (id) => permissions.get(id) ?? defaultFor(id);
+    // A picker value becomes the person's choice only when it is one: it differs from the default the picker showed
+    // (`shown`; null when the person already picked it), or replaces an earlier choice. Echoes of the displayed default
+    // (the picker re-applied when a conversation opens) are not saved, and neither is an Auto approve the conversation
+    // cannot answer: the picker offers it only where it can, so there it is a default shown before the harness was known.
+    const choosePermission = (id, value, shown = defaultFor(id)) => {
+        const connection = frontends.get(id);
+        if (value === 'autoApprove' && connection && !canAnswer(connection))
+            return;
+        if (permissions.has(id) || value !== shown)
+            savePermission(id, value);
     };
     const resourceBindings = new Map(context.workspaceState.get('supercode.sessionBindings', []));
     const boundId = (resource) => resolveSessionBinding(resource, controls?.state.sessions ?? [], resourceBindings);
@@ -452,7 +486,7 @@ export async function activate(context) {
     }
     const currentOptions = (resource) => {
         const id = resource ? boundId(resource) : controls?.state.activeSession;
-        return { permissions: id ? permissions.get(id) ?? 'ask' : permission };
+        return { permissions: id ? approvalFor(id) : permission ?? hostDefault() };
     };
     const savedConnections = new Map();
     const saveManagedHistory = async (connection) => {
@@ -749,8 +783,8 @@ export async function activate(context) {
             const active = resource ? (id ? frontends.get(id) : undefined) : managed();
             const canApprove = active?.session.descriptor?.actions.respond && active.session.permissions.has('approve');
             const permissionItems = [{ id: 'ask', name: canApprove ? 'Ask for approval' : 'Harness permissions', description: canApprove ? 'Show each approval requested by the harness.' : 'Approval controls are unavailable for this harness.' },
-                ...((canApprove || (!active && resource && currentOptions(resource).permissions === 'autoApprove')) ? [{ id: 'autoApprove', name: 'Auto approve', description: 'Allow tool approval requests for this chat. Harness sandbox rules still apply.' }] : [])];
-            const groups = [{ id: 'permissions', name: 'Permissions', kind: 'permissions', items: permissionItems, selected: permissionItems.find(i => i.id === (resource ? currentOptions(resource).permissions : 'ask')) }];
+                ...((canApprove || (!active && resource && currentOptions(resource).permissions === 'autoApprove')) ? [{ id: 'autoApprove', name: 'Auto approve', description: 'Approve the requests the harness would ask you about, including requests to run outside its sandbox. Its deny rules still apply.' }] : [])];
+            const groups = [{ id: 'permissions', name: 'Permissions', kind: 'permissions', items: permissionItems, selected: permissionItems.find(i => i.id === currentOptions(resource).permissions) }];
             const selected = controls?.state.sessions.find(session => session.id === id);
             if (selected && ['claude-code', 'codex'].includes(selected.selection.harness)) {
                 // Native session-option commands remain reachable for nondelegating providers,
@@ -768,7 +802,7 @@ export async function activate(context) {
             if (controls && !id)
                 throw new Error('This conversation has no session binding.');
             if (id)
-                savePermission(id, turnPermission(value));
+                choosePermission(id, turnPermission(value));
             else
                 permission = turnPermission(value);
         },
@@ -794,7 +828,10 @@ export async function activate(context) {
             const pending = applying.then(() => applySelection(selection));
             applying = pending.then(() => undefined, () => undefined);
             const connection = await pending;
-            savePermission(connection.id, turnPermission(inputState.groups.find(group => group.id === 'permissions')?.selected?.id));
+            // The picker shows the host's default until someone changes it; only a change is the person's choice.
+            const picked = turnPermission(inputState.groups.find(group => group.id === 'permissions')?.selected?.id);
+            choosePermission(connection.id, picked, permission !== undefined ? null : hostDefault());
+            permission = undefined;
             if (pendingDraft === draft) {
                 pendingDraft = undefined;
                 controlsChanged.fire();
@@ -825,7 +862,7 @@ export async function activate(context) {
         if (supplied?.permissions) {
             const id = controls?.state.activeSession;
             if (id)
-                savePermission(id, turnPermission(supplied.permissions));
+                choosePermission(id, turnPermission(supplied.permissions));
             else
                 permission = turnPermission(supplied.permissions);
             controlsChanged.fire();
@@ -909,7 +946,7 @@ export async function activate(context) {
     }));
     context.subscriptions.push({ dispose: () => frontends.dispose() });
     const runTurnInto = async (connection, prompt, stream, token, approval) => {
-        if (approval === 'autoApprove' && (!connection.session.descriptor?.actions.respond || !connection.session.permissions.has('approve'))) {
+        if (approval() === 'autoApprove' && !canAnswer(connection)) {
             throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
         }
         const answered = new Set();
@@ -925,25 +962,40 @@ export async function activate(context) {
                 // 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;
+            for (const pending of connection.session.pendingRequests.values()) {
+                if (pending.kind !== 'approval' || answered.has(pending.id))
+                    continue;
+                const decisions = acceptedDecisions(pending);
+                if (decisions && !decisions.includes('allow'))
+                    continue;
+                answered.add(pending.id);
+                // Its card is already in the stream (the event that raised it was written first), so say it was answered.
+                const payload = pending.payload && typeof pending.payload === 'object' && !Array.isArray(pending.payload) ? pending.payload : {};
+                const named = [payload.title, payload.tool, payload.tool_name].find((value) => typeof value === 'string');
+                void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).then(() => {
+                    stream.markdown(`\n_auto-approved: ${opaqueText(named ?? `request #${pending.id}`, 200)}_\n`);
+                }, error => {
+                    stream.markdown(`\nApproval failed: ${String(error.message || error)}. Use the approval buttons to answer.\n`);
+                });
+            }
+        };
+        const sweeps = runningTurns.get(connection.id) ?? new Set();
+        runningTurns.set(connection.id, sweeps.add(sweep));
         try {
             await connection.session.runTurn(prompt, (event) => {
                 writeProjected(stream, projectEvent(event, projection), granted, state);
-                if (approval === 'autoApprove' && !token.isCancellationRequested) {
-                    for (const pending of connection.session.pendingRequests.values()) {
-                        if (pending.kind !== 'approval' || answered.has(pending.id))
-                            continue;
-                        const decisions = acceptedDecisions(pending);
-                        if (decisions && !decisions.includes('allow'))
-                            continue;
-                        answered.add(pending.id);
-                        void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).catch(error => {
-                            stream.markdown(`\nApproval failed: ${String(error.message || error)}. Use the approval buttons to answer.\n`);
-                        });
-                    }
-                }
+                sweep();
             });
         }
         finally {
+            sweeps.delete(sweep);
+            if (!sweeps.size && runningTurns.get(connection.id) === sweeps)
+                runningTurns.delete(connection.id);
             cancellation.dispose();
             if (controls && !attachedIds.has(connection.id)) {
                 if (connection.session.descriptor?.session_id)
@@ -993,7 +1045,8 @@ export async function activate(context) {
             stream.markdown('_nothing to submit_');
             return {};
         }
-        const approval = turnPermission(controls ? permissions.get(connection.id) ?? 'ask' : request.permissionLevel);
+        const native = controls ? undefined : turnPermission(request.permissionLevel);
+        const approval = () => native ?? approvalFor(connection.id);
         const attached = [];
         for (const reference of request.references) {
             const value = reference.value;

package/dist/host-controls.d.ts

@@ -49,6 +49,9 @@ export interface HostState {
     actualModel?: string | null;
     configurable: boolean;
     setup?: ChatSetupState;
+    /** The approval mode of a conversation no one has picked one for. `autoApprove` takes effect only
+     *  where the runtime can answer approvals through Chat; absent, every conversation asks. */
+    defaultPermission?: 'ask' | 'autoApprove';
 }
 export interface HostSelectionResult extends HostState {
     connection: Record<string, string>;
@@ -75,7 +78,7 @@ export declare class ChatHostControls {
     private update;
     private request;
 }
-/** Approval policy is captured for one turn, never inferred from connection privileges. */
+/** A picked approval mode, never inferred from connection privileges (those only keep a host default at ask). */
 export declare function turnPermission(value: string | undefined): 'ask' | 'autoApprove';
 export declare function harnessDisplayName(harness: string | null | undefined): string;
 export declare function runtimeIdentity(harness: string | null | undefined, model: string | null | undefined): {

package/dist/host-controls.js

@@ -53,7 +53,7 @@ export class ChatHostControls {
         return value;
     }
 }
-/** Approval policy is captured for one turn, never inferred from connection privileges. */
+/** A picked approval mode, never inferred from connection privileges (those only keep a host default at ask). */
 export function turnPermission(value) {
     if (!value || value === 'default' || value === 'ask')
         return 'ask';

package/package.json

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