@volter/supercode-frontend-vscode 0.1.39 → 0.1.41

package/README.md

@@ -152,8 +152,10 @@ owns no processes.
 The permission group offers **Ask for approval** and, on an answerable interactive attachment,
 **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
+A lifecycle host may start the conversations it creates in **Auto approve**: it records
+`defaultPermission: "autoApprove"` on each such conversation and declares `newChatPermission` for the new
+chat's picker (Model Editor does). A conversation without its own recorded default asks, so one that existed
+before a host began doing this keeps its behaviour. 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

package/dist/extension.js

@@ -13,6 +13,8 @@ import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, pr
 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'];
+/** How long an automatic approval may go unanswered before its card is shown for the person to answer. */
+const AUTO_ANSWER_SETTLE_MS = 15_000;
 const PARTICIPANT_ID = 'supercode.chat';
 const DEFAULT_PARTICIPANT_ID = 'supercode.chat.default';
 /** `package.json` gates the `isDefault` participant on this key. */
@@ -372,18 +374,22 @@ 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';
+    // The mode a NEW chat's picker shows (`HostState.newChatPermission`; Model Editor declares Auto approve). It is
+    // never applied to a conversation that exists: that reads its own recorded default below.
+    const newChatDefault = () => controls?.state.newChatPermission === '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.
+    // The default of one conversation: the one the host recorded for THAT conversation when it created it
+    // (`ManagedChatSession.defaultPermission`), so a conversation that existed before a host began starting chats
+    // in Auto approve keeps asking. 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 its
+    // harness (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))
+        const session = controls?.state.sessions.find(entry => entry.id === id);
+        if (session?.defaultPermission !== 'autoApprove' || attachedIds.has(id))
             return 'ask';
         const connection = frontends.get(id);
-        const harness = controls?.state.sessions.find(session => session.id === id)?.selection.harness ?? '';
+        const harness = session.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';
@@ -429,6 +435,16 @@ export async function activate(context) {
     // reports them, and never taken for the conversation the host manages.
     const attachedIds = new Set();
     const managed = () => frontends.all.find((connection) => !attachedIds.has(connection.id));
+    // The host runs one conversation at a time, so a running or waiting turn refuses a new or another chat. This is
+    // the sentence that refusal says to the person; each caller picks the one place it is shown (see its uses).
+    const busyRefusal = (active, action) => {
+        if (!active)
+            return;
+        if (active.session.pendingRequests.size)
+            return `The current chat is waiting for your answer. Answer it or cancel the turn before ${action}.`;
+        if (active.session.descriptor?.turn_state === 'busy')
+            return `A turn is still running in the current chat. Let it finish or cancel it before ${action}.`;
+    };
     // The attached runtime the person is looking at: the Chat names its harness, not the host's.
     let focusedAttached;
     let approvalAvailable = false;
@@ -491,7 +507,7 @@ export async function activate(context) {
     }
     const currentOptions = (resource) => {
         const id = resource ? boundId(resource) : controls?.state.activeSession;
-        return { permissions: id ? approvalFor(id) : permission ?? hostDefault() };
+        return { permissions: id ? approvalFor(id) : permission ?? newChatDefault() };
     };
     const savedConnections = new Map();
     const saveManagedHistory = async (connection) => {
@@ -670,9 +686,11 @@ export async function activate(context) {
             return existing.pending;
         const pending = applying.then(async () => {
             const active = managed();
-            if (active && active.id !== id && (active.session.descriptor?.turn_state === 'busy' || active.session.pendingRequests.size))
-                throw new Error('Finish or cancel the active turn before opening another conversation.');
             if (active && active.id !== id) {
+                // Thrown as is: the workbench shows a focus command's error, and a send writes it into the chat.
+                const refusal = busyRefusal(active, 'opening another conversation');
+                if (refusal)
+                    throw new Error(refusal);
                 // Capture the exact saved transcript while its runtime still belongs
                 // to the host. Subsequent background content reads need no activation.
                 await saveManagedHistory(active);
@@ -710,8 +728,12 @@ export async function activate(context) {
         if (!controls)
             throw new Error('This host does not expose harness or model configuration.');
         const active = managed();
-        if (active?.session.descriptor?.turn_state === 'busy' || active?.session.pendingRequests.size)
-            throw new Error('Finish or cancel the current turn before starting a new chat.');
+        // A send from a blank chat lands here, and the workbench does not show its error: say it, then refuse.
+        const refusal = busyRefusal(active, 'starting a new chat');
+        if (refusal) {
+            void vscode.window.showWarningMessage(refusal);
+            throw new Error(refusal);
+        }
         if (active)
             await saveManagedHistory(active);
         const state = await controls.select(selection);
@@ -722,9 +744,13 @@ export async function activate(context) {
     const openNewChat = async () => {
         if (!controls || !granted.has('chatSessionsProvider'))
             throw new Error('This host does not expose native conversation creation.');
-        const active = managed();
-        if (active?.session.descriptor?.turn_state === 'busy' || active?.session.pendingRequests.size)
-            throw new Error('Finish or cancel the current turn before starting a new chat.');
+        // Its callers (the new-chat pickers) swallow the cancellation, so the warning is the one message shown. An error
+        // would reach the person as a bare "Canceled" or not at all through the contributed-command boundary.
+        const refusal = busyRefusal(managed(), 'starting a new chat');
+        if (refusal) {
+            void vscode.window.showWarningMessage(refusal);
+            throw new vscode.CancellationError();
+        }
         // Code-OSS materializes this untitled session on first send, awaiting our
         // newChatSessionItemHandler before accepting/clearing the draft. Never boot
         // beside the old widget and reveal another resource after it accepts input.
@@ -785,20 +811,23 @@ export async function activate(context) {
     const chooseNewChat = async (pick) => {
         if (pendingDraft?.choosing)
             throw new Error('Finish choosing an agent before starting another chat.');
-        // Open before the picker: a send can beat its result across the extension-
-        // host boundary. Materialization awaits this exact draft's choice too.
-        const draft = await openNewChat();
-        const picking = (async () => {
-            const choice = await pick();
-            if (activeDraft() !== draft)
-                throw new vscode.CancellationError();
-            draft.choice = choice;
-            controlsChanged.fire();
-            if (choice.kind !== 'agent')
-                throw new vscode.CancellationError();
-        })();
-        draft.choosing = picking;
+        let draft;
+        let picking;
         try {
+            // Open before the picker: a send can beat its result across the extension-
+            // host boundary. Materialization awaits this exact draft's choice too.
+            // Inside the try: a busy refusal is a cancellation already explained.
+            const opened = draft = await openNewChat();
+            picking = (async () => {
+                const choice = await pick();
+                if (activeDraft() !== opened)
+                    throw new vscode.CancellationError();
+                opened.choice = choice;
+                controlsChanged.fire();
+                if (choice.kind !== 'agent')
+                    throw new vscode.CancellationError();
+            })();
+            opened.choosing = picking;
             await picking;
         }
         catch (error) {
@@ -806,9 +835,9 @@ export async function activate(context) {
                 throw error;
         }
         finally {
-            if (draft.choosing === picking)
+            if (draft && draft.choosing === picking)
                 draft.choosing = undefined;
-            if (draft.choice?.kind === 'signIn') {
+            if (draft?.choice?.kind === 'signIn') {
                 void refreshSetup().catch(error => log.warn(`Could not refresh sign-in: ${String(error)}`)).finally(pollSetup);
             }
         }
@@ -873,7 +902,7 @@ export async function activate(context) {
             const connection = await pending;
             // 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());
+            choosePermission(connection.id, picked, permission !== undefined ? null : newChatDefault());
             permission = undefined;
             if (pendingDraft === draft) {
                 pendingDraft = undefined;
@@ -961,17 +990,20 @@ export async function activate(context) {
             return { kind: 'agent', selection: { harness: harness.id, model: '', effort: '' } };
         });
     }));
-    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.configureModel', async (resource, sessionId) => {
+    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.configureModel', async (resource, _sessionId) => {
         if (!controls || focusedAttached)
             throw new Error('Model settings require a host-managed conversation.');
         await controls.refresh();
-        // The native session-options picker prepends its exact resource to command arguments.
-        const bound = resource ? boundId(resource) : undefined;
-        if (resource && (!bound || (sessionId && bound !== sessionId)))
-            throw new Error('Model settings have no matching conversation binding.');
+        // The native session-options picker prepends its widget's resource to command arguments, so the resource is the
+        // conversation the person clicked from. `sessionId` is not used: the workbench keeps one option-group list per
+        // session type, last written by whichever input state updated, so any chat's dropdown can carry another
+        // conversation's id. A resource with no binding (a blank draft) is no conversation; only the command palette,
+        // which passes no resource, falls back to the active one. Either way the choice opens a new chat.
+        const bound = resource ? boundId(resource) : controls.state.activeSession ?? undefined;
         // The conversation it was opened from sets the agent and the current values; with none open (a fresh project,
-        // the command palette) the person picks the agent first. Either way the choice opens a new chat.
-        const selected = controls.state.sessions.find(session => session.id === (bound ?? controls.state.activeSession));
+        // the command palette) the person picks the agent first. A running turn refuses the new chat before any picker
+        // opens, and says so (`openNewChat`).
+        const selected = controls.state.sessions.find(session => session.id === bound);
         // An agent that still needs sign-in is set up from the agent picker first, as there.
         const needsSignIn = new Set((controls.state.setup?.actions ?? []).filter(action => action.kind === 'login').map(action => action.harness));
         const configurable = controls.state.harnesses.filter(harness => CONFIGURABLE_HARNESSES.includes(harness.id) && !needsSignIn.has(harness.id));
@@ -1034,25 +1066,36 @@ export async function activate(context) {
                 catch {
                     log.info(text.trim());
                 } };
+                const label = opaqueText(named ?? `request #${pending.id}`, 200);
+                // A card this watch hid is shown when its automatic answer fails or does not settle: a typed reply cannot
+                // reach a running turn, its buttons can. With the response closed, the person is told an approval waits.
+                const showCard = () => {
+                    if (!unshown.delete(pending.id) || !connection.session.pendingRequests.has(pending.id))
+                        return;
+                    try {
+                        writeProjected(stream, projectPendingRequests([pending], {
+                            connectionId: connection.id,
+                            canRespond: connection.session.descriptor?.actions.respond !== false,
+                        }), granted, { toolInputs: new Map(), toolNames: new Map() });
+                    }
+                    catch {
+                        void vscode.window.showWarningMessage(`${connection.label}: ${label} is waiting for approval. Open its chat to answer it.`);
+                    }
+                };
+                const unsettled = setTimeout(() => {
+                    note(`\nAuto approve has had no answer for ${label} for ${AUTO_ANSWER_SETTLE_MS / 1000} s. Use the approval buttons to answer.\n`);
+                    showCard();
+                }, AUTO_ANSWER_SETTLE_MS);
                 void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).then(() => {
+                    clearTimeout(unsettled);
                     // 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`);
+                    note(`\n_auto-approved: ${label}_\n`);
                 }, error => {
+                    clearTimeout(unsettled);
                     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`);
-                        }
-                    }
+                    showCard();
                 });
             }
         };

package/dist/host-controls.d.ts

@@ -13,12 +13,14 @@ export interface ChatChoice {
     autoStart?: boolean;
     efforts?: string[];
 }
+/** `defaultPermission`: the approval mode the host started this conversation in when no one picked one; absent, it asks. */
 export interface ManagedChatSession {
     id: string;
     selection: ChatSelection;
     identity: string | null;
     title: string;
     created: number;
+    defaultPermission?: 'ask' | 'autoApprove';
 }
 /** Host-owned operations. The host revalidates commands before native terminal execution. */
 export interface ChatSetupAction {
@@ -51,9 +53,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';
+    /** The mode a new chat's picker shows. A conversation's own default is its `ManagedChatSession.defaultPermission`;
+     *  this is never applied to one that exists. `autoApprove` takes effect only where the runtime can answer approvals. */
+    newChatPermission?: 'ask' | 'autoApprove';
 }
 export interface HostSelectionResult extends HostState {
     connection: Record<string, string>;

package/package.json

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