@robota-sdk/agent-command 3.0.0-beta.82 → 3.0.0-beta.84

package/src/provider/__tests__/provider-command-module.test.ts

@@ -169,6 +169,31 @@ describe('createProviderCommandModule', () => {
     expect(requests[1]?.title).toBe('Provider profile: anthropic');
   });
 
+  it('#3282 §2: the profile action menu offers Switch, Edit, Test, Duplicate and Delete — no separate Cancel option (the picker\'s own Cancel affordance is the only one)', async () => {
+    const { adapter } = createSettingsAdapter({
+      currentProvider: 'openai',
+      providers: {
+        openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+        anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+      },
+    });
+
+    const { context, requests } = scriptedContext([
+      { type: 'answer', values: ['anthropic'] },
+      { type: 'cancelled' },
+    ]);
+    await createExecutor(adapter).execute('provider', context, '');
+
+    const actionMenu = requests[1];
+    expect(actionMenu?.options?.map((option) => option.value)).toEqual([
+      'switch',
+      'edit',
+      'test',
+      'duplicate',
+      'delete',
+    ]);
+  });
+
   it('switches provider immediately via /provider switch without confirmation dialog', async () => {
     const { adapter, readTarget } = createSettingsAdapter(
       {
@@ -323,7 +348,7 @@ describe('createProviderCommandModule', () => {
 
     // The confirm prompt must actually be issued — guards against a silent drop of the
     // confirmation step that would still "delete and pass".
-    expect(requests[2]?.title).toBe('Delete provider profile anthropic?');
+    expect(requests[2]?.title).toBe('Delete profile "anthropic"?');
     expect(completed?.message).toBe('Provider profile deleted: anthropic.');
     expect(readTarget()).toEqual({
       currentProvider: 'openai',
@@ -360,7 +385,7 @@ describe('createProviderCommandModule', () => {
     const completed = await createExecutor(adapter).execute('provider', context, 'list');
 
     // The confirm precedes the replacement picker — assert both so neither step can be dropped silently.
-    expect(requests[2]?.title).toBe('Delete provider profile anthropic?');
+    expect(requests[2]?.title).toBe('Delete profile "anthropic"?');
     expect(requests[3]?.title).toBe('Replacement provider for anthropic');
     expect(readTarget()).toEqual({
       currentProvider: 'openai',
@@ -399,14 +424,20 @@ describe('createProviderCommandModule', () => {
     expect(result?.message).toContain('not stored in the active write target');
   });
 
-  it('owns provider setup flow and writes settings after generic prompt submissions', async () => {
+  it('owns provider setup flow, writes settings, and hot-swaps a session actually in setup mode (#3282 §3)', async () => {
     const { adapter, readTarget } = createSettingsAdapter({}, {});
 
-    const { context, requests } = scriptedContext([
-      { type: 'answer', values: [], text: '' },
-      { type: 'answer', values: [], text: '' },
-      { type: 'answer', values: [], text: '' },
-    ]);
+    // #3282 §3: the session's own live `isSetupRequired()` says so — a served runtime's setup mode has
+    // no session to restart into, so this hot-swaps a running placeholder instead. Restarting a live
+    // session that already has a provider (adding a second profile, below) is unaffected.
+    const { context, requests } = scriptedContext(
+      [
+        { type: 'answer', values: [], text: '' },
+        { type: 'answer', values: [], text: '' },
+        { type: 'answer', values: [], text: '' },
+      ],
+      true,
+    );
     const completed = await createExecutor(adapter).execute('provider', context, 'add openai');
 
     expect(requests[0]?.title).toBe('OpenAI-compatible base URL');
@@ -434,12 +465,26 @@ describe('createProviderCommandModule', () => {
         },
       },
     });
+    expect(completed?.hostActions).toEqual([{ type: 'provider-hot-swap', profileName: 'openai' }]);
+  });
+
+  it('restarts (never hot-swaps) an env-default session with no persisted provider either (#3282 §3)', async () => {
+    // A session that started from a recognized provider env key (zero-config) has no `currentProvider`
+    // persisted, exactly like a served runtime's setup-mode session — but it is NOT in setup mode.
+    // Inferring "first ever" from settings alone would hot-swap it silently; only the session's own
+    // `isSetupRequired()` (false here, the default) tells the two apart.
+    const { adapter, readTarget } = createSettingsAdapter({}, {});
+
+    const { context } = scriptedContext([
+      { type: 'answer', values: [], text: '' },
+      { type: 'answer', values: [], text: '' },
+      { type: 'answer', values: [], text: '' },
+    ]);
+    const completed = await createExecutor(adapter).execute('provider', context, 'add openai');
+
+    expect(readTarget()).toMatchObject({ currentProvider: 'openai' });
     expect(completed?.hostActions).toEqual([
-      {
-        type: 'session-restart',
-        reason: 'other',
-        message: 'Provider setup restart',
-      },
+      { type: 'session-restart', reason: 'other', message: 'Provider setup restart' },
     ]);
   });
 
@@ -493,8 +538,13 @@ describe('createProviderCommandModule', () => {
       { type: 'answer', values: [], text: '' },
       { type: 'answer', values: [], text: '' },
     ]);
-    await createExecutor(adapter).execute('provider', context, 'add openai');
+    const completed = await createExecutor(adapter).execute('provider', context, 'add openai');
 
+    // #3282 §3: this session is not in setup mode (scriptedContext's isSetupRequired default, false) —
+    // it restarts to pick up the new profile, exactly as an ordinary session with one already active.
+    expect(completed?.hostActions).toEqual([
+      { type: 'session-restart', reason: 'other', message: 'Provider setup restart' },
+    ]);
     expect(readTarget()).toMatchObject({
       currentProvider: 'openai-2',
       providers: {
@@ -542,4 +592,216 @@ describe('createProviderCommandModule', () => {
     expect(result?.message).toContain('manual configuration can continue');
     expect(probe).toHaveBeenCalled();
   });
+
+  // #3282 §4b: direct, non-interactive forms of Edit/Duplicate/Delete — the Settings screen already
+  // knows which profile a button belongs to, so it names it directly instead of repeating the
+  // profile-action menu's own "which profile" ask.
+  describe('direct edit/duplicate/delete subcommands (#3282 §4b)', () => {
+    it('edits a named profile directly, skipping the "which profile" ask', async () => {
+      const { adapter, readTarget } = createSettingsAdapter(
+        {
+          currentProvider: 'anthropic',
+          providers: {
+            anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6', apiKey: 'sk-ant-secret' },
+          },
+        },
+        {},
+      );
+
+      const { context, requests } = scriptedContext([
+        { type: 'answer', values: [], text: '' },
+        { type: 'answer', values: [], text: 'claude-opus-4-5' },
+      ]);
+      const completed = await createExecutor(adapter).execute('provider', context, 'edit anthropic');
+
+      expect(requests[0]?.title).toBe('anthropic API key');
+      expect(readTarget()).toMatchObject({
+        providers: { anthropic: { model: 'claude-opus-4-5', apiKey: 'sk-ant-secret' } },
+      });
+      expect(completed?.message).toBe('Provider anthropic updated. Switching...');
+    });
+
+    it('requires an interactive renderer to edit', async () => {
+      const { adapter } = createSettingsAdapter({
+        currentProvider: 'anthropic',
+        providers: { anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' } },
+      });
+
+      const result = await createExecutor(adapter).execute('provider', headlessContext, 'edit anthropic');
+
+      expect(result?.success).toBe(false);
+      expect(result?.message).toContain('interactive session');
+    });
+
+    it('duplicates a named profile directly, skipping the "which profile" ask', async () => {
+      const { adapter, readTarget } = createSettingsAdapter({
+        currentProvider: 'openai',
+        providers: {
+          openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2', apiKey: 'lm-studio' },
+        },
+      });
+
+      const { context, requests } = scriptedContext([{ type: 'answer', values: [], text: '' }]);
+      const completed = await createExecutor(adapter).execute('provider', context, 'duplicate openai');
+
+      expect(requests[0]?.title).toBe('Duplicate openai as');
+      expect(readTarget()).toMatchObject({
+        providers: { 'openai-copy': { type: 'openai', model: 'supergemma4-26b-uncensored-v2' } },
+      });
+      expect(completed?.hostActions).toBeUndefined();
+    });
+
+    it('the Settings screen\'s own write (--confirmed) deletes with no confirm ask and no replacement ask', async () => {
+      const { adapter, readTarget } = createSettingsAdapter(
+        {
+          currentProvider: 'openai',
+          providers: {
+            openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+            anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+          },
+        },
+        {
+          currentProvider: 'openai',
+          providers: {
+            openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+            anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+          },
+        },
+      );
+
+      const { context, requests } = scriptedContext([]);
+      const completed = await createExecutor(adapter).execute(
+        'provider',
+        context,
+        'delete anthropic --confirmed',
+      );
+
+      expect(requests).toEqual([]);
+      expect(completed?.message).toBe('Provider profile deleted: anthropic.');
+      expect(readTarget()).toEqual({
+        currentProvider: 'openai',
+        providers: { openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' } },
+      });
+    });
+
+    it('a plainly-typed delete confirms first, interactively, before deleting', async () => {
+      const { adapter, readTarget } = createSettingsAdapter(
+        {
+          currentProvider: 'openai',
+          providers: {
+            openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+            anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+          },
+        },
+        {
+          currentProvider: 'openai',
+          providers: {
+            openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+            anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+          },
+        },
+      );
+
+      const { context, requests } = scriptedContext([{ type: 'answer', values: ['yes'] }]);
+      const completed = await createExecutor(adapter).execute('provider', context, 'delete anthropic');
+
+      expect(requests[0]?.title).toBe('Delete profile "anthropic"?');
+      expect(completed?.message).toBe('Provider profile deleted: anthropic.');
+      expect(readTarget()).toEqual({
+        currentProvider: 'openai',
+        providers: { openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' } },
+      });
+    });
+
+    it('a declined confirm cancels a plainly-typed delete, deleting nothing', async () => {
+      const settings = {
+        currentProvider: 'openai',
+        providers: {
+          openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+          anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+        },
+      };
+      const { adapter, readTarget } = createSettingsAdapter(settings, settings);
+
+      const { context } = scriptedContext([{ type: 'answer', values: ['no'] }]);
+      const result = await createExecutor(adapter).execute('provider', context, 'delete anthropic');
+
+      expect(result).toEqual({ message: 'Provider delete cancelled.', success: true });
+      expect(readTarget().providers?.['anthropic']).toBeDefined();
+    });
+
+    it('a headless (non-interactive) delete proceeds without asking, matching /clear\'s convention', async () => {
+      const settings = {
+        currentProvider: 'openai',
+        providers: {
+          openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+          anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+        },
+      };
+      const { adapter, readTarget } = createSettingsAdapter(settings, settings);
+
+      const result = await createExecutor(adapter).execute('provider', headlessContext, 'delete anthropic');
+
+      expect(result?.message).toBe('Provider profile deleted: anthropic.');
+      expect(readTarget().providers?.['anthropic']).toBeUndefined();
+    });
+
+    it('refuses to delete the profile in use, unlike the menu\'s Delete which asks for a replacement', async () => {
+      const { adapter, readTarget } = createSettingsAdapter(
+        {
+          currentProvider: 'anthropic',
+          providers: {
+            openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+            anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+          },
+        },
+        {
+          currentProvider: 'anthropic',
+          providers: {
+            openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+            anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+          },
+        },
+      );
+
+      const { context, requests } = scriptedContext([]);
+      const result = await createExecutor(adapter).execute(
+        'provider',
+        context,
+        'delete anthropic --confirmed',
+      );
+
+      expect(result?.success).toBe(false);
+      expect(result?.message).toBe('Cannot delete the profile in use. Switch to another profile first.');
+      expect(requests).toEqual([]); // never asks — a modal write has nowhere to ask a follow-up
+      expect(readTarget().providers?.['anthropic']).toBeDefined(); // nothing was deleted
+    });
+
+    it('refuses to delete the only provider profile', async () => {
+      const { adapter } = createSettingsAdapter(
+        { currentProvider: 'openai', providers: { openai: { type: 'openai', model: 'x' } } },
+        { currentProvider: 'openai', providers: { openai: { type: 'openai', model: 'x' } } },
+      );
+
+      const result = await createExecutor(adapter).execute('provider', headlessContext, 'delete openai');
+
+      expect(result?.success).toBe(false);
+      expect(result?.message).toBe('Cannot delete the only provider profile.');
+    });
+
+    it('reports an unknown profile for a direct delete', async () => {
+      const { adapter } = createSettingsAdapter({
+        currentProvider: 'openai',
+        providers: {
+          openai: { type: 'openai', model: 'x' },
+          anthropic: { type: 'anthropic', model: 'y' },
+        },
+      });
+
+      const result = await createExecutor(adapter).execute('provider', headlessContext, 'delete ghost');
+
+      expect(result?.success).toBe(false);
+      expect(result?.message).toBe('Provider profile "ghost" was not found.');
+    });
+  });
 });

package/src/provider/__tests__/scripted-interaction.ts

@@ -8,7 +8,15 @@ import type { IActionRequest, IUserInteraction, TActionResponse } from '@robota-
  * the rendered action shape) and returns the next scripted answer; once the script is exhausted it
  * returns `{ type: 'cancelled' }`, mirroring a user dismissing the prompt.
  */
-export function scriptedContext(answers: readonly TActionResponse[]): {
+export function scriptedContext(
+  answers: readonly TActionResponse[],
+  /**
+   * #3282 §3: whether THIS session is running with no provider configured yet — `/provider add`
+   * reads it (never settings) to decide hot-swap vs. restart. Defaults to `false`, an ordinary
+   * session, matching every test written before setup mode existed.
+   */
+  isSetupRequired = false,
+): {
   context: ReturnType<typeof createTestCommandHost>;
   requests: IActionRequest[];
 } {
@@ -25,6 +33,8 @@ export function scriptedContext(answers: readonly TActionResponse[]): {
   // ARCH-029: the double answers "no capability of that kind" for everything else, so this fixture
   // states exactly the one capability it scripts. The double cast it replaced —
   // `as Partial<…> as ICommandHostContext` — asserted conformance twice over one member.
-  const context = createTestCommandHost({ overrides: { getUserInteraction: () => ui } });
+  const context = createTestCommandHost({
+    overrides: { getUserInteraction: () => ui, isSetupRequired: () => isSetupRequired },
+  });
   return { context, requests };
 }

package/src/provider/provider-command-execution.ts

@@ -1,17 +1,24 @@
 import {
+  confirmAction,
   findProviderDefinition,
   formatSupportedProviderTypes,
+  isConfirmed,
   selectAction,
 } from '@robota-sdk/agent-core';
 import { testProviderProfileCommand } from '@robota-sdk/agent-framework';
 
-import { buildProviderSwitch } from './provider-command-profile-operations.js';
+import {
+  buildProviderDuplicate,
+  buildProviderProfileDelete,
+} from './provider-command-profile-lifecycle.js';
+import { buildProviderEdit, buildProviderSwitch } from './provider-command-profile-operations.js';
 import { askProviderProfileSelection } from './provider-command-profile.js';
 import { createSetupFlow, runProviderAddSetup } from './provider-command-setup.js';
 import { formatProviderSetupChoiceLabel } from './provider-setup-flow.js';
 
 import type { IUserInteraction } from '@robota-sdk/agent-core';
 import type {
+  ICommandHostSetupState,
   ICommandHostUserInteraction,
   IProviderCommandModuleOptions,
   IProviderProfileSettings,
@@ -19,17 +26,21 @@ import type {
 import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 export async function executeProviderCommand(
-  context: ICommandHostUserInteraction,
+  context: ICommandHostUserInteraction & ICommandHostSetupState,
   args: string,
   options: IProviderCommandModuleOptions,
 ): Promise<ICommandResult> {
   const ui = context.getUserInteraction();
+  // #3282 §3: the session's own live state, never inferred from settings — an ordinary env-default
+  // session also has no persisted `currentProvider`, and is not in setup mode either.
+  const isSetupRequired = context.isSetupRequired?.() === true;
   const settings = options.settings.readMergedSettings();
   const trimmedArgs = args.trim();
   if (trimmedArgs.length === 0) {
     return buildProviderProfilePicker(ui, settings.currentProvider, settings.providers, options);
   }
-  const [subcommand = 'current', profileArg] = trimmedArgs.split(/\s+/);
+  const argTokens = trimmedArgs.split(/\s+/);
+  const [subcommand = 'current', profileArg] = argTokens;
 
   if (subcommand === 'list') {
     return buildProviderProfilePicker(ui, settings.currentProvider, settings.providers, options);
@@ -51,12 +62,45 @@ export async function executeProviderCommand(
       options,
     );
   }
+  // #3282 §4b: direct, non-interactive forms of what the profile-action menu otherwise reaches
+  // through two asks (`askProviderProfileSelection` then `askProviderProfileAction`) — for a caller
+  // (the Settings screen, or a typed command) that already names the profile and does not want the
+  // "which profile" ask repeated. `edit`/`duplicate` still ask their own follow-up questions (the
+  // new name, the changed fields) exactly as the menu's Edit/Duplicate do.
+  if (subcommand === 'edit') {
+    if (!ui) return { message: 'Provider edit requires an interactive session.', success: false };
+    if (!profileArg) return { message: 'Usage: provider edit <profile>', success: false };
+    return buildProviderEdit(ui, profileArg, options);
+  }
+  if (subcommand === 'duplicate') {
+    if (!ui) return { message: 'Provider duplicate requires an interactive session.', success: false };
+    if (!profileArg) return { message: 'Usage: provider duplicate <profile>', success: false };
+    return buildProviderDuplicate(ui, profileArg, options);
+  }
+  if (subcommand === 'delete') {
+    // #3282 §4b: `--confirmed` is set ONLY by the Settings screen's own write (`settings-reporter.ts`)
+    // — its "Delete…" button already confirmed through its own ConfirmDialog before sending this, and
+    // a modal write has nowhere to ask a follow-up question. A plainly-typed `delete <profile>` never
+    // carries it, so it confirms here first when a human can answer (matching `/clear`'s "confirm only
+    // when interactive; with no human the explicit form proceeds") — deleting a profile also deletes
+    // its stored key, unlike `switch`, which this direct-form family otherwise mirrors.
+    if (!profileArg) return { message: 'Usage: provider delete <profile>', success: false };
+    const preConfirmed = argTokens.includes('--confirmed');
+    if (!preConfirmed && ui) {
+      const response = await ui.ask(confirmAction('provider-delete', `Delete profile "${profileArg}"?`));
+      if (!isConfirmed(response)) {
+        return { message: 'Provider delete cancelled.', success: true };
+      }
+    }
+    return buildProviderProfileDelete(settings.providers, settings.currentProvider, profileArg, options);
+  }
   if (subcommand === 'add') {
-    return buildProviderSetup(ui, profileArg, options);
+    return buildProviderSetup(ui, profileArg, options, isSetupRequired);
   }
 
   return {
-    message: 'Usage: provider [current|list|switch <profile>|add <type>|test [profile]]',
+    message:
+      'Usage: provider [current|list|switch <profile>|edit <profile>|duplicate <profile>|delete <profile>|add <type>|test [profile]]',
     success: false,
   };
 }
@@ -121,6 +165,7 @@ function buildProviderSetup(
   ui: IUserInteraction | undefined,
   type: string | undefined,
   options: IProviderCommandModuleOptions,
+  isSetupRequired: boolean,
 ): Promise<ICommandResult> | ICommandResult {
   if (type === undefined || type.length === 0) {
     if (!ui) {
@@ -129,7 +174,7 @@ function buildProviderSetup(
         success: false,
       };
     }
-    return askProviderSetupType(ui, options);
+    return askProviderSetupType(ui, options, isSetupRequired);
   }
   if (findProviderDefinition(options.providerDefinitions, type) === undefined) {
     return {
@@ -143,12 +188,13 @@ function buildProviderSetup(
       success: false,
     };
   }
-  return runProviderAddSetup(ui, createSetupFlow(type, options), options);
+  return runProviderAddSetup(ui, createSetupFlow(type, options), options, isSetupRequired);
 }
 
 async function askProviderSetupType(
   ui: IUserInteraction,
   options: IProviderCommandModuleOptions,
+  isSetupRequired: boolean,
 ): Promise<ICommandResult> {
   const typeOptions = options.providerDefinitions.map((definition) => ({
     value: definition.type,
@@ -167,5 +213,5 @@ async function askProviderSetupType(
       success: false,
     };
   }
-  return runProviderAddSetup(ui, createSetupFlow(type, options), options);
+  return runProviderAddSetup(ui, createSetupFlow(type, options), options, isSetupRequired);
 }

package/src/provider/provider-command-profile-lifecycle.ts

@@ -8,7 +8,10 @@ import {
 import { formatProviderChoiceLabel } from './provider-command-profile-operations.js';
 
 import type { IUserInteraction } from '@robota-sdk/agent-core';
-import type { IProviderCommandModuleOptions } from '@robota-sdk/agent-framework';
+import type {
+  IProviderCommandModuleOptions,
+  IProviderProfileSettings,
+} from '@robota-sdk/agent-framework';
 import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 const MAX_DUPLICATE_PROFILE_SUFFIX = 1000;
@@ -90,6 +93,47 @@ function completeProviderDuplicate(
   };
 }
 
+/**
+ * #3282 §4b: the direct, non-interactive delete itself — no replacement ask (the interactive
+ * per-profile menu's Delete, `buildProviderDelete` below, still offers one); refuses instead when the
+ * profile is the one in use. Never asks to CONFIRM either — its caller in `provider-command-execution`
+ * does that first, when a human can answer, before reaching this function; this function itself is
+ * called only once a delete is already decided (confirmed by a human, or `--confirmed` from the
+ * Settings screen's own ConfirmDialog).
+ */
+export function buildProviderProfileDelete(
+  providers: Record<string, IProviderProfileSettings> | undefined,
+  currentProvider: string | undefined,
+  profileName: string | undefined,
+  options: IProviderCommandModuleOptions,
+): ICommandResult {
+  if (!profileName) {
+    return { message: 'Usage: /provider delete <profile>', success: false };
+  }
+  if (!providers?.[profileName]) {
+    return { message: `Provider profile "${profileName}" was not found.`, success: false };
+  }
+  if (Object.keys(providers).length <= 1) {
+    return { message: 'Cannot delete the only provider profile.', success: false };
+  }
+  if (currentProvider === profileName) {
+    return {
+      message: 'Cannot delete the profile in use. Switch to another profile first.',
+      success: false,
+    };
+  }
+  if (options.settings.readTargetSettings().providers?.[profileName] === undefined) {
+    return {
+      message: `Provider profile "${profileName}" is not stored in the active write target; edit its source settings file or override it before deleting.`,
+      success: false,
+    };
+  }
+  options.settings.writeTargetSettings(
+    deleteProviderProfile(options.settings.readTargetSettings(), profileName),
+  );
+  return { message: `Provider profile deleted: ${profileName}.`, success: true };
+}
+
 export async function buildProviderDelete(
   ui: IUserInteraction,
   profileName: string,
@@ -109,8 +153,10 @@ export async function buildProviderDelete(
       success: false,
     };
   }
+  // #3282 §2: the GUI renders this confirm on its shared ConfirmDialog (id 'provider-delete') with
+  // this exact title — kept in the quoted-name form the TUI's inline picker shows the same way.
   const response = await ui.ask(
-    confirmAction('provider-delete', `Delete provider profile ${profileName}?`),
+    confirmAction('provider-delete', `Delete profile "${profileName}"?`),
   );
   if (!isConfirmed(response)) {
     return { message: 'Provider delete cancelled.', success: true };

package/src/provider/provider-command-profile-operations.ts

@@ -4,6 +4,7 @@ import {
   isApiKeyPlaintext,
   setCurrentProvider,
   upsertProviderProfile,
+  validateProviderProfile,
 } from '@robota-sdk/agent-framework';
 
 import { runProviderSetupAsk } from './provider-command-setup.js';
@@ -51,6 +52,19 @@ export function buildProviderSwitch(
     return { message: `Already using provider "${profileName}".`, success: true };
   }
   const profile = providers[profileName];
+  // #3282: the hot-swap this returns as a `hostActions` entry builds this exact profile against
+  // these exact definitions (`resolveUserSettingsProviderSwitch` in agent-framework). Validating it
+  // HERE, before anything is written, means a switch that would fail changes nothing on disk — the
+  // previous behavior wrote `currentProvider` unconditionally and let a downstream hot-swap failure
+  // (e.g. "Unknown provider: anthropic. Currently supported: ", an empty list) stand uncorrected.
+  try {
+    validateProviderProfile(profileName, profile, { providerDefinitions: options.providerDefinitions });
+  } catch (error) {
+    return {
+      message: `Failed to switch to "${profileName}": ${error instanceof Error ? error.message : String(error)}`,
+      success: false,
+    };
+  }
   const target = options.settings.readTargetSettings();
   const merged = options.settings.readMergedSettings();
   const next =

package/src/provider/provider-command-profile.ts

@@ -23,7 +23,6 @@ const ACTION_EDIT = 'edit';
 const ACTION_TEST = 'test';
 const ACTION_DUPLICATE = 'duplicate';
 const ACTION_DELETE = 'delete';
-const ACTION_CANCEL = 'cancel';
 
 /**
  * Ask the user to pick a provider profile, then drive its action menu (CMD-004 inline ask). Replaces
@@ -58,6 +57,13 @@ async function askProviderProfileAction(
   if (!settings.providers?.[profileName]) {
     return { message: `Provider profile "${profileName}" was not found.`, success: false };
   }
+  // #3282 §2: no separate 'cancel' option here — the picker's own persistent Cancel affordance
+  // (every ask renderer offers one, e.g. `PermissionPrompt`'s ghost Cancel button in agent-ui-web)
+  // is the only Cancel a person sees. A second one, indistinguishable from Switch/Edit/Test/Duplicate
+  // in a flat list, was the audited bug (#3282 issue text): "Delete looks the same as Switch... plus
+  // a second Cancel." Order matters too — Switch first as the primary action, then Edit/Test/
+  // Duplicate, with Delete last: a client (the GUI's provider-action menu) that wants Delete
+  // separated and styled destructive can rely on it always being the final entry.
   const response = await ui.ask(
     selectAction('provider-profile-action', `Provider profile: ${profileName}`, [
       { value: ACTION_SWITCH, label: 'Switch' },
@@ -65,7 +71,6 @@ async function askProviderProfileAction(
       { value: ACTION_TEST, label: 'Test' },
       { value: ACTION_DUPLICATE, label: 'Duplicate' },
       { value: ACTION_DELETE, label: 'Delete' },
-      { value: ACTION_CANCEL, label: 'Cancel' },
     ]),
   );
   if (response.type !== 'answer' || response.values[0] === undefined) {
@@ -97,8 +102,6 @@ async function executeProviderProfileAction(
       return buildProviderDuplicate(ui, profileName, options);
     case ACTION_DELETE:
       return buildProviderDelete(ui, profileName, options);
-    case ACTION_CANCEL:
-      return { message: 'Provider profile action cancelled.', success: true };
     default:
       return { message: `Unknown provider profile action "${action}".`, success: false };
   }