@volter/supercode-frontend-vscode 0.1.35 → 0.1.37

package/README.md

@@ -94,9 +94,11 @@ which startable agent to use. It refreshes the host's available choices first;
 with one ready local agent and no pending native sign-in choices it opens
 immediately, even when the official ChatGPT choice is available. Otherwise the
 picker includes the official choice on supported hosts; with no choices it returns
-to setup. Model
-and reasoning are sent as empty values, leaving both at the harness's own defaults,
-even if the previous conversation used explicit settings. Cancelling the agent
+to setup. Picking an agent sends model
+and reasoning as empty values, leaving both at the harness's own defaults,
+even if the previous conversation used explicit settings. Each agent whose model
+and reasoning a chat can set (Claude Code, Codex) is also listed in the picker as **<agent>: model
+and reasoning…**, which goes on to the model and effort choices below. Cancelling the agent
 picker starts no backend conversation.
 
 The native blank chat opens before the picker appears. First send waits for the
@@ -116,8 +118,14 @@ sign-in choice it uses that agent once ready, otherwise it keeps the draft with
 a visible sign-in error.
 
 The composer's native **Model settings** control offers **Choose model and reasoning
-for a new chat…** for Claude Code and Codex. This optional path retains the model
-list, exact model ID entry and reasoning choices. Only completing the choices
+for a new chat…** for Claude Code and Codex, and **Chat: Model and Reasoning: Open New
+Chat** does the same from anywhere (with no conversation open it asks for the agent
+first). The models and each model's reasoning efforts are the host's
+`modelsByHarness` choices, which a host reads from the harness itself (Model Editor:
+Claude Code's `--help`, Codex's models cache), so levels such as `xhigh` and `max`
+appear as the harness offers them; a host that sends no efforts gets low/medium/high.
+Exact model ID entry remains. When a turn ends, its reply notes the model it ran on
+(as the harness's replies name it) and the effort it was given. Only completing the choices
 configures the new blank chat; its backend starts on first send. Cancelling a
 choice starts no backend and leaves the blank chat available.
 A conversation's harness, model and reasoning remain fixed: this integration does
@@ -142,8 +150,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

@@ -11,6 +11,8 @@ import { observeActiveResponse, sessionStatus } from './native-session.js';
 import { RequestNotPendingError, VscodeFrontendSession } from './session.js';
 import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
 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'];
 const PARTICIPANT_ID = 'supercode.chat';
 const DEFAULT_PARTICIPANT_ID = 'supercode.chat.default';
 /** `package.json` gates the `isDefault` participant on this key. */
@@ -356,11 +358,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 +488,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) => {
@@ -705,6 +741,44 @@ export async function activate(context) {
             throw new vscode.CancellationError();
         return draft;
     };
+    // A new chat's model and reasoning effort, offered from what the harness itself lists (the host reads its models
+    // and each model's efforts from the harness). Escape cancels; "Harness default" passes nothing, so the harness's
+    // own settings decide. A host that sends no efforts gets the levels every configurable harness takes.
+    // A single pick that opens on the current value (showQuickPick's `picked` applies only to multi-select).
+    const pickWithCurrent = (items, title, placeholder, currentId) => {
+        const quick = vscode.window.createQuickPick();
+        quick.title = title;
+        quick.placeholder = placeholder;
+        quick.items = items;
+        quick.activeItems = items.filter(item => item.id === currentId);
+        return new Promise(resolve => {
+            quick.onDidAccept(() => resolve(quick.selectedItems[0]));
+            quick.onDidHide(() => resolve(undefined));
+            quick.show();
+        }).finally(() => quick.dispose());
+    };
+    const pickModelAndEffort = async (harness, current) => {
+        const choices = controls?.state.modelsByHarness?.[harness] ?? [{ id: '', name: 'Harness default' }];
+        const name = harnessDisplayName(harness);
+        const items = [...choices.map(model => ({ label: model.name, description: [model.id, model.description].filter(Boolean).join(' · ') || undefined, id: model.id, efforts: model.efforts })),
+            { label: 'Enter an exact model ID…', description: undefined, id: '__custom__', efforts: choices.find(model => model.id === '')?.efforts }];
+        const picked = await pickWithCurrent(items, `New chat · ${name} model`, 'Model availability depends on your harness account.', current?.model ?? '');
+        if (!picked)
+            return;
+        let model = picked.id;
+        if (picked.id === '__custom__') {
+            const typed = await vscode.window.showInputBox({ title: `New chat · ${name} exact model`, prompt: 'Model ID or CLI alias supported by this harness account.', value: current?.model });
+            if (typed === undefined)
+                return;
+            model = typed.trim();
+        }
+        const levels = picked.efforts ?? ['low', 'medium', 'high'];
+        const efforts = [{ label: 'Harness default', id: '' }, ...levels.map(id => ({ label: id, id }))];
+        const effort = levels.length === 0 ? efforts[0] : await pickWithCurrent(efforts, `New chat · ${name} reasoning effort`, model ? `For ${model}` : 'For the harness default model', current?.effort ?? '');
+        if (!effort)
+            return;
+        return { model, effort: effort.id };
+    };
     const chooseNewChat = async (pick) => {
         if (pendingDraft?.choosing)
             throw new Error('Finish choosing an agent before starting another chat.');
@@ -749,8 +823,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 +842,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 +868,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 +902,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();
@@ -843,13 +920,17 @@ export async function activate(context) {
         // Sign-in choices stay visible alongside agents that can be explicitly started.
         const login = controls.state.setup?.actions.filter(action => action.kind === 'login') ?? [];
         const localChoices = [
-            ...login.map(action => ({ label: action.name, id: action.harness, description: 'Sign in…', login: true, autoStart: false })),
+            ...login.map(action => ({ label: action.name, id: action.harness, description: 'Sign in…', login: true, autoStart: false, configure: false })),
             ...controls.state.harnesses.filter(h => !login.some(action => action.harness === h.id))
-                .map(h => ({ label: h.name, id: h.id, description: h.description, login: false, autoStart: h.autoStart === true })),
+                .map(h => ({ label: h.name, id: h.id, description: h.description, login: false, autoStart: h.autoStart === true, configure: false })),
         ];
+        // Each agent whose model and reasoning a chat can set also offers that, right where the agent is chosen.
+        const modelChoices = localChoices.filter(choice => !choice.login && CONFIGURABLE_HARNESSES.includes(choice.id))
+            .map(choice => ({ ...choice, label: `${choice.label}: model and reasoning…`, description: 'Choose the model and reasoning effort', autoStart: false, configure: true }));
         const choices = [
-            ...(offerChatGPT ? [{ label: 'Sign in with ChatGPT', id: CHATGPT_SIGN_IN, description: 'Official Codex extension', login: false, autoStart: false }] : []),
+            ...(offerChatGPT ? [{ label: 'Sign in with ChatGPT', id: CHATGPT_SIGN_IN, description: 'Official Codex extension', login: false, autoStart: false, configure: false }] : []),
             ...localChoices,
+            ...modelChoices,
         ];
         if (!choices.length) {
             await revealSetup();
@@ -858,9 +939,13 @@ export async function activate(context) {
         // A sole sign-in option still requires a deliberate click before opening its terminal.
         // The official choice must not disable the existing sole-local-agent shortcut.
         await chooseNewChat(async () => {
-            const harness = localChoices.length === 1 && localChoices[0].autoStart ? localChoices[0] : await vscode.window.showQuickPick(choices, { title: 'New chat · Agent', placeHolder: 'Choose your coding agent. Model and reasoning use its defaults.' });
+            const harness = localChoices.length === 1 && localChoices[0].autoStart ? localChoices[0] : await vscode.window.showQuickPick(choices, { title: 'New chat · Agent', placeHolder: 'Choose your coding agent. Its default model and reasoning apply unless you choose them.' });
             if (!harness)
                 return { kind: 'cancelled' };
+            if (harness.configure) {
+                const chosen = await pickModelAndEffort(harness.id);
+                return chosen ? { kind: 'agent', selection: { harness: harness.id, ...chosen } } : { kind: 'cancelled' };
+            }
             if (harness.id === CHATGPT_SIGN_IN) {
                 await vscode.commands.executeCommand(CHATGPT_SIGN_IN);
                 return { kind: 'signIn' };
@@ -880,36 +965,29 @@ export async function activate(context) {
         const bound = resource ? boundId(resource) : undefined;
         if (resource && (!bound || (sessionId && bound !== sessionId)))
             throw new Error('Model settings have no matching conversation binding.');
-        const id = bound ?? controls.state.activeSession;
-        const selected = controls.state.sessions.find(session => session.id === id);
-        if (!selected || selected.id !== controls.state.activeSession)
-            throw new Error('Open this conversation before choosing model settings.');
-        const selection = { ...selected.selection };
-        if (!['claude-code', 'codex'].includes(selection.harness))
-            throw new Error('This harness uses its own model defaults; configuration is not advertised.');
+        // 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));
+        // 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));
+        if (!configurable.length && !(selected && CONFIGURABLE_HARNESSES.includes(selected.selection.harness)))
+            throw new Error('No agent on this machine takes a model or reasoning choice here; its own defaults apply.');
         await chooseNewChat(async () => {
-            const choices = controls.state.modelsByHarness?.[selection.harness] ?? [{ id: '', name: 'Harness default' }];
-            const picked = await vscode.window.showQuickPick([...choices.map(model => ({ label: model.name, id: model.id })), { label: 'Enter an exact model ID…', id: '__custom__' }], { title: 'New chat · Model', placeHolder: 'Model availability depends on your harness account.' });
-            if (!picked)
-                return { kind: 'cancelled' };
-            if (picked.id === '__custom__') {
-                const model = await vscode.window.showInputBox({ title: 'New chat · Exact model', prompt: 'Model ID or CLI alias supported by this harness account.', value: selection.model });
-                if (model === undefined)
+            let harness = selected && CONFIGURABLE_HARNESSES.includes(selected.selection.harness) ? selected.selection.harness : undefined;
+            if (!harness) {
+                const agent = configurable.length === 1 ? configurable[0] : await vscode.window.showQuickPick(configurable.map(choice => ({ ...choice, label: choice.name })), { title: 'New chat · Agent', placeHolder: 'Choose the agent whose model and reasoning to set.' });
+                if (!agent)
                     return { kind: 'cancelled' };
-                selection.model = model.trim();
+                harness = agent.id;
             }
-            else
-                selection.model = picked.id;
-            const effort = await vscode.window.showQuickPick([{ label: 'Harness default', id: '' }, ...['low', 'medium', 'high'].map(id => ({ label: id, id }))], { title: 'New chat · Reasoning effort' });
-            if (!effort)
-                return { kind: 'cancelled' };
-            selection.effort = effort.id;
-            return { kind: 'agent', selection };
+            const chosen = await pickModelAndEffort(harness, selected?.selection.harness === harness ? selected.selection : undefined);
+            return chosen ? { kind: 'agent', selection: { harness, ...chosen } } : { kind: 'cancelled' };
         });
     }));
     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 +1003,49 @@ 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');
+                // The answer can settle after the turn's response has closed, when writing to it throws: the note is then dropped.
+                const note = (text) => { try {
+                    stream.markdown(text);
+                }
+                catch {
+                    log.info(text.trim());
+                } };
+                void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).then(() => {
+                    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`);
+                });
+            }
+        };
+        const sweeps = runningTurns.get(connection.id) ?? new Set();
+        runningTurns.set(connection.id, sweeps.add(sweep));
+        let completed = false;
         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();
             });
+            completed = true;
         }
         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)
@@ -951,6 +1053,12 @@ export async function activate(context) {
                 await controls.refresh().catch(error => log.warn(`Could not refresh chat identity: ${String(error)}`));
                 controlsChanged.fire();
             }
+            // The model the turn ran on: what the harness's own replies name (the host watches them), else what the
+            // runtime reports; and the effort it was given.
+            const ran = (controls?.state.activeSession === connection.id ? controls.state.actualModel : undefined) || connection.session.descriptor?.model;
+            const effort = controls?.state.sessions.find(session => session.id === connection.id)?.selection.effort;
+            if (completed && ran && !token.isCancellationRequested)
+                stream.markdown(`\n\n_Ran on ${opaqueText(ran, 120)}${effort ? ` · ${opaqueText(effort, 24)} effort` : ''}_`);
         }
     };
     const handler = async (request, chatContext, stream, token) => {
@@ -993,7 +1101,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

@@ -5,11 +5,13 @@ export interface ChatSelection {
     model: string;
     effort: string;
 }
+/** `efforts`: the reasoning efforts a model takes, as the host read them from the harness (absent from older hosts). */
 export interface ChatChoice {
     id: string;
     name: string;
     description?: string;
     autoStart?: boolean;
+    efforts?: string[];
 }
 export interface ManagedChatSession {
     id: string;
@@ -49,6 +51,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 +80,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.37",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",