@volter/supercode-frontend-vscode 0.1.41 → 0.1.43

package/README.md

@@ -155,7 +155,8 @@ The permission group offers **Ask for approval** and, on an answerable interacti
 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
+before a host began doing this keeps its behaviour. A new blank chat does not inherit the previous conversation's permission choice.
+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
@@ -403,7 +404,13 @@ the extension manifest beside those bytes with no build step of its own.
 Conversation creation uses `ChatSessionItemController.newChatSessionItemHandler`.
 Permissions use `getChatSessionInputState` and its change/disposal events, with
 per-conversation preferences persisted in workspace state. New untitled chats
-start with Ask; old untitled bindings are read only for backwards compatibility.
+start with the host's new-chat default and offer modes for the selected draft's harness,
+independently of the previous runtime. The paired native host exposes actual
+`initialSessionOptions` separately from its type-wide previous input state, so an
+explicit draft choice survives materialization. Draft input groups refresh after
+agent selection without overwriting the person's choice. Stock hosts without
+that optional context retain their previous-state contract; old untitled bindings
+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.
 

package/dist/extension.js

@@ -410,6 +410,8 @@ export async function activate(context) {
     const resourceBindings = new Map(context.workspaceState.get('supercode.sessionBindings', []));
     const boundId = (resource) => resolveSessionBinding(resource, controls?.state.sessions ?? [], resourceBindings);
     let applying = Promise.resolve();
+    // the reason the last send from a new chat made no conversation, said by that draft's request handler
+    let refusedSend;
     let pendingDraft;
     let focusedResource;
     let focusGeneration = 0;
@@ -506,7 +508,7 @@ export async function activate(context) {
         }));
     }
     const currentOptions = (resource) => {
-        const id = resource ? boundId(resource) : controls?.state.activeSession;
+        const id = resource ? boundId(resource) : activeDraft() ? undefined : controls?.state.activeSession;
         return { permissions: id ? approvalFor(id) : permission ?? newChatDefault() };
     };
     const savedConnections = new Map();
@@ -606,8 +608,12 @@ export async function activate(context) {
         const applied = pending.then(() => undefined, () => undefined);
         applying = applied;
         const revealed = pending.then(async (target) => {
+            // A blank chat the workbench restored keeps the focus, except from a conversation whose turn runs or waits for an
+            // answer: after a reload mid-turn, that is the chat a person needs (its Stop button, its pending approval).
+            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-'))
+                || (focusedResource?.path.startsWith('/untitled-') && !live))
                 return;
             if (target.kind === 'managed') {
                 if ((controls.state.setup && !controls.state.setup.ready) || controls.state.activeSession !== target.id
@@ -746,11 +752,7 @@ export async function activate(context) {
             throw new Error('This host does not expose native conversation creation.');
         // 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();
-        }
+        // A turn running elsewhere does not stop a draft: its first send is refused there, in the chat (`create`).
         // 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.
@@ -852,11 +854,16 @@ export async function activate(context) {
             if (controls?.state.setup && !controls.state.setup.ready)
                 return [];
             const id = resource ? boundId(resource) : undefined;
-            const active = resource ? (id ? frontends.get(id) : undefined) : managed();
-            const canApprove = active?.session.descriptor?.actions.respond && active.session.permissions.has('approve');
+            const active = id ? frontends.get(id) : undefined;
+            // A new draft's harness, not the previous runtime, owns its offered modes.
+            const harness = resource ? controls?.state.sessions.find(session => session.id === id)?.selection.harness : draftSelection()?.harness;
+            const canApprove = resource ? (active ? canAnswer(active) : ['claude-code', 'codex'].includes(harness ?? ''))
+                : (harness ? ['claude-code', 'codex'].includes(harness) : newChatDefault() === 'autoApprove' || ['claude-code', 'codex'].includes(controls?.state.selection.harness ?? ''));
+            // An unbound input is a new chat, not the active conversation left behind it.
+            const selectedPermission = resource ? currentOptions(resource).permissions : permission ?? newChatDefault();
             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: '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 groups = [{ id: 'permissions', name: 'Permissions', kind: 'permissions', items: permissionItems, selected: permissionItems.find(i => i.id === selectedPermission) ?? permissionItems[0] }];
             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,
@@ -881,6 +888,13 @@ export async function activate(context) {
         create: async (inputState) => {
             if (!controls)
                 throw new Error('The host does not expose conversation creation.');
+            // A send while another turn runs makes no conversation: the host then runs the request on the draft itself, and
+            // its handler says why in the chat. A rejection here reaches nobody (the host's acceptInput drops it).
+            const busy = busyRefusal(managed(), 'starting a new chat');
+            if (busy) {
+                refusedSend = busy;
+                return undefined;
+            }
             const draft = activeDraft();
             await draft?.choosing;
             if (draft && activeDraft() !== draft)
@@ -901,7 +915,8 @@ export async function activate(context) {
             applying = pending.then(() => undefined, () => undefined);
             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);
+            const selected = inputState.groups.find(group => group.id === 'permissions')?.selected?.id;
+            const picked = selected === 'ask' || selected === 'autoApprove' ? selected : permission ?? newChatDefault();
             choosePermission(connection.id, picked, permission !== undefined ? null : newChatDefault());
             permission = undefined;
             if (pendingDraft === draft) {
@@ -1155,6 +1170,12 @@ export async function activate(context) {
     const handler = async (request, chatContext, stream, token) => {
         await applying;
         const requestedResource = chatContext.chatSessionContext?.chatSessionItem?.resource;
+        if (refusedSend && requestedResource?.path.startsWith('/untitled-') && !boundId(requestedResource)) {
+            const refusal = refusedSend;
+            refusedSend = undefined;
+            // thrown as is: the workbench writes a handler's error into the chat
+            throw new Error(`${refusal} Nothing was sent; send it again in a new chat once that turn has ended.`);
+        }
         if (controls?.state.setup && !controls.state.setup.ready) {
             stream.markdown('Sign in before sending a message. Use **New Chat: Choose Agent** to get started.');
             return {};
@@ -1676,19 +1697,30 @@ function registerSessions(context, frontends, participant, granted, handler, his
     context.subscriptions.push(controller, frontends.onDidChange(refreshItems));
     if (controls) {
         const states = new Set();
-        controller.getChatSessionInputState = (resource, { previousInputState }) => {
-            const previous = previousInputState?.groups.find(group => group.id === 'permissions')?.selected?.id;
-            // Saved conversation preferences survive extension-host reloads. Native input state
-            // owns live changes; a blank conversation always starts with its own Ask default.
-            const groups = controls.options(resource).map(group => ({ ...group,
-                selected: group.items.find(item => item.id === (resource ? group.selected?.id : previous ?? group.selected?.id)) ?? group.selected,
-            }));
-            const state = controller.createChatSessionInputState(groups);
+        const draftPermissions = new WeakMap();
+        const applyOptions = (groups, options) => groups.map(group => {
+            const value = options.find(option => option.optionId === group.id)?.value;
+            const selected = group.items.find(item => item.id === value);
+            return selected ? { ...group, selected } : group;
+        });
+        controller.getChatSessionInputState = (resource, inputContext) => {
+            const groups = controls.options(resource);
+            // Native request options belong to this draft. previousInputState may instead
+            // be the type-wide last chat, so the paired host exposes them separately.
+            // Stock hosts without that context keep their existing previous-state contract.
+            const initial = inputContext.initialSessionOptions ?? inputContext.previousInputState?.groups.flatMap(group => group.selected ? [{ optionId: group.id, value: group.selected.id }] : []) ?? [];
+            const state = controller.createChatSessionInputState(resource ? groups : applyOptions(groups, initial));
+            const initialPermission = initial.find(option => option.optionId === 'permissions')?.value;
+            if (!resource && initialPermission)
+                draftPermissions.set(state, initialPermission);
             states.add(state);
             const changed = state.onDidChange(() => {
                 const target = state.sessionResource ?? resource;
+                const value = state.groups.find(group => group.id === 'permissions')?.selected?.id;
                 if (target)
-                    controls.setPermission(target, state.groups.find(group => group.id === 'permissions')?.selected?.id);
+                    controls.setPermission(target, value);
+                else if (value)
+                    draftPermissions.set(state, value);
             });
             const disposed = state.onDidDispose(() => { states.delete(state); changed.dispose(); disposed.dispose(); });
             return state;
@@ -1696,13 +1728,15 @@ function registerSessions(context, frontends, participant, granted, handler, his
         controller.newChatSessionItemHandler = async ({ inputState }, token) => {
             if (token.isCancellationRequested)
                 throw new vscode.CancellationError();
-            return connectedItem(await controls.create(inputState));
+            const connection = await controls.create(inputState);
+            return connection ? connectedItem(connection) : undefined;
         };
         context.subscriptions.push(controls.changed(() => {
             refreshItems();
             for (const state of states) {
-                if (state.sessionResource)
-                    state.groups = controls.options(state.sessionResource);
+                const groups = controls.options(state.sessionResource);
+                const value = draftPermissions.get(state);
+                state.groups = state.sessionResource || !value ? groups : applyOptions(groups, [{ optionId: 'permissions', value }]);
             }
         }));
     }

package/package.json

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