@robota-sdk/agent-command 3.0.0-beta.100

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

@@ -0,0 +1,884 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { IProviderDefinition } from '@robota-sdk/agent-core';
+import { SystemCommandExecutor } from '@robota-sdk/agent-framework';
+import type {
+  ICommandHostContext,
+  IProviderCommandSettingsAdapter,
+  TProviderSettingsDocument,
+} from '@robota-sdk/agent-framework';
+import { createProviderCommandModule } from '../provider-command-module.js';
+import { scriptedContext } from './scripted-interaction.js';
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+
+const providerDefinitions: readonly IProviderDefinition[] = [
+  {
+    type: 'openai',
+    displayName: 'OpenAI Compatible',
+    description: 'Use OpenAI or an OpenAI-compatible endpoint',
+    defaults: {
+      model: 'supergemma4-26b-uncensored-v2',
+      apiKey: 'lm-studio',
+      baseURL: 'http://localhost:1234/v1',
+    },
+    setupHelpLinks: [
+      {
+        kind: 'official',
+        label: 'OpenAI-compatible local server docs',
+        url: 'https://lmstudio.ai/docs/developer',
+      },
+    ],
+    setupSteps: [
+      {
+        key: 'baseURL',
+        title: 'OpenAI-compatible base URL',
+        defaultValue: 'http://localhost:1234/v1',
+      },
+      {
+        key: 'model',
+        title: 'OpenAI-compatible model',
+        defaultValue: 'supergemma4-26b-uncensored-v2',
+      },
+      {
+        key: 'apiKey',
+        title: 'OpenAI-compatible API key',
+        defaultValue: 'lm-studio',
+        masked: true,
+      },
+    ],
+    requiresApiKey: true,
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  },
+  {
+    type: 'anthropic',
+    defaults: {
+      model: 'claude-sonnet-4-6',
+      apiKey: '$ENV:ANTHROPIC_API_KEY',
+    },
+    setupSteps: [
+      { key: 'apiKey', title: 'anthropic API key', masked: true },
+      { key: 'model', title: 'anthropic model', defaultValue: 'claude-sonnet-4-6' },
+    ],
+    requiresApiKey: true,
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  },
+];
+
+function createSettingsAdapter(
+  merged: TProviderSettingsDocument,
+  target: TProviderSettingsDocument = {},
+): {
+  adapter: IProviderCommandSettingsAdapter;
+  readTarget: () => TProviderSettingsDocument;
+} {
+  let writable = target;
+  return {
+    adapter: {
+      readMergedSettings: () => merged,
+      readTargetSettings: () => writable,
+      writeTargetSettings: (next) => {
+        writable = next;
+      },
+    },
+    readTarget: () => writable,
+  };
+}
+
+function createExecutor(adapter: IProviderCommandSettingsAdapter): SystemCommandExecutor {
+  const module = createProviderCommandModule({
+    providerDefinitions,
+    settings: adapter,
+  });
+  return new SystemCommandExecutor([...(module.systemCommands ?? [])]);
+}
+
+/** Context with no interactive renderer attached (headless/automation). */
+const headlessContext = createTestCommandHost();
+
+describe('createProviderCommandModule', () => {
+  it('contributes /provider metadata and executable command from the provider package', () => {
+    const { adapter } = createSettingsAdapter({});
+    const module = createProviderCommandModule({ providerDefinitions, settings: adapter });
+    const commands = module.commandSources?.flatMap((source) => source.getCommands()) ?? [];
+
+    expect(module.name).toBe('agent-command-provider');
+    expect(commands.map((command) => command.name)).toEqual(['provider']);
+    expect(commands[0]?.subcommands?.map((command) => command.name)).toContain('switch');
+    expect(module.systemCommands?.map((command) => command.name)).toEqual(['provider']);
+  });
+
+  it('asks the user to pick a provider profile from injected merged settings', 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: 'cancelled' }]);
+    const result = await createExecutor(adapter).execute('provider', context, 'list');
+
+    expect(result?.success).toBe(true);
+    const picker = requests[0];
+    expect(picker?.title).toBe('Select provider profile');
+    expect(picker?.options?.map((option) => option.label)).toEqual(
+      expect.arrayContaining([
+        expect.stringContaining('* openai'),
+        expect.stringContaining('anthropic'),
+      ]),
+    );
+  });
+
+  it('returns a plain text list when no interactive renderer is attached', async () => {
+    const { adapter } = createSettingsAdapter({
+      currentProvider: 'openai',
+      providers: {
+        openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+        anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+      },
+    });
+
+    const result = await createExecutor(adapter).execute('provider', headlessContext, 'list');
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toContain('* openai');
+    expect(result?.message).toContain('anthropic');
+  });
+
+  it('opens a provider profile action menu from /provider after picking a profile', 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' },
+    ]);
+    const result = await createExecutor(adapter).execute('provider', context, '');
+
+    expect(result?.success).toBe(true);
+    expect(requests[0]?.title).toBe('Select provider profile');
+    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(
+      {
+        currentProvider: 'anthropic',
+        providers: {
+          openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+          anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+        },
+      },
+      {},
+    );
+
+    const result = await createExecutor(adapter).execute(
+      'provider',
+      headlessContext,
+      'switch openai',
+    );
+
+    expect(result?.message).toBe(
+      'Switched to openai (supergemma4-26b-uncensored-v2). History preserved.',
+    );
+    expect(readTarget().currentProvider).toBe('openai');
+    expect(result?.hostActions).toEqual([{ type: 'provider-hot-swap', profileName: 'openai' }]);
+  });
+
+  it('switches from the provider profile action menu immediately without confirmation', async () => {
+    const { adapter, readTarget } = createSettingsAdapter(
+      {
+        currentProvider: 'anthropic',
+        providers: {
+          openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+          anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+        },
+      },
+      {},
+    );
+
+    const { context } = scriptedContext([
+      { type: 'answer', values: ['openai'] },
+      { type: 'answer', values: ['switch'] },
+    ]);
+    const result = await createExecutor(adapter).execute('provider', context, 'list');
+
+    expect(result?.message).toBe(
+      'Switched to openai (supergemma4-26b-uncensored-v2). History preserved.',
+    );
+    expect(readTarget().currentProvider).toBe('openai');
+    expect(result?.hostActions).toEqual([{ type: 'provider-hot-swap', profileName: 'openai' }]);
+  });
+
+  it('edits a provider profile through provider-owned setup metadata without exposing secrets', 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: ['anthropic'] },
+      { type: 'answer', values: ['edit'] },
+      { type: 'answer', values: [], text: '' },
+      { type: 'answer', values: [], text: 'claude-opus-4-5' },
+    ]);
+    const completed = await createExecutor(adapter).execute('provider', context, 'list');
+
+    const apiKeyRequest = requests[2];
+    expect(apiKeyRequest?.title).toBe('anthropic API key');
+    expect(apiKeyRequest?.allowFreeText).toBe(true);
+    expect(apiKeyRequest?.placeholder).toBe('(unchanged)');
+    expect(apiKeyRequest?.masked).toBe(true);
+
+    expect(readTarget()).toMatchObject({
+      providers: {
+        anthropic: {
+          type: 'anthropic',
+          model: 'claude-opus-4-5',
+          apiKey: 'sk-ant-secret',
+        },
+      },
+    });
+    expect(completed?.message).toBe('Provider anthropic updated. Switching...');
+    expect(completed?.hostActions).toEqual([
+      { type: 'provider-hot-swap', profileName: 'anthropic' },
+    ]);
+  });
+
+  it('duplicates a provider profile from the action menu without switching sessions', 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: ['openai'] },
+      { type: 'answer', values: ['duplicate'] },
+      { type: 'answer', values: [], text: '' },
+    ]);
+    const completed = await createExecutor(adapter).execute('provider', context, 'list');
+
+    expect(requests[2]?.title).toBe('Duplicate openai as');
+    expect(requests[2]?.placeholder).toBe('openai-copy');
+    expect(readTarget()).toMatchObject({
+      providers: {
+        'openai-copy': {
+          type: 'openai',
+          model: 'supergemma4-26b-uncensored-v2',
+          apiKey: 'lm-studio',
+        },
+      },
+    });
+    expect(completed?.hostActions).toBeUndefined();
+  });
+
+  it('deletes inactive provider profiles after confirmation', 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: ['anthropic'] },
+      { type: 'answer', values: ['delete'] },
+      { type: 'answer', values: ['yes'] },
+    ]);
+    const completed = await createExecutor(adapter).execute('provider', context, 'list');
+
+    // 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 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('requires a replacement before deleting the active provider profile', 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([
+      { type: 'answer', values: ['anthropic'] },
+      { type: 'answer', values: ['delete'] },
+      { type: 'answer', values: ['yes'] },
+      { type: 'answer', values: ['openai'] },
+    ]);
+    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 profile "anthropic"?');
+    expect(requests[3]?.title).toBe('Replacement provider for anthropic');
+    expect(readTarget()).toEqual({
+      currentProvider: 'openai',
+      providers: {
+        openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+      },
+    });
+    expect(completed?.hostActions).toEqual([
+      {
+        type: 'session-restart',
+        reason: 'other',
+        message: 'Provider delete restart',
+      },
+    ]);
+  });
+
+  it('blocks deletion of inherited provider profiles instead of pretending to remove them', 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 } = scriptedContext([
+      { type: 'answer', values: ['anthropic'] },
+      { type: 'answer', values: ['delete'] },
+    ]);
+    const result = await createExecutor(adapter).execute('provider', context, 'list');
+
+    expect(result?.success).toBe(false);
+    expect(result?.message).toContain('not stored in the active write target');
+  });
+
+  it('owns provider setup flow, writes settings, and hot-swaps a session actually in setup mode (#3282 §3)', async () => {
+    const { adapter, readTarget } = createSettingsAdapter({}, {});
+
+    // #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');
+    expect(requests[0]?.description).toBe(
+      '  Setup help: Official: OpenAI-compatible local server docs - https://lmstudio.ai/docs/developer',
+    );
+    expect(requests[0]?.placeholder).toBe('http://localhost:1234/v1');
+    expect(requests[0]?.allowEmpty).toBe(true);
+    // All three setup steps must be asked in order — a dropped step would otherwise be hidden by the
+    // scripted double returning the surplus answers to whatever remains.
+    expect(requests.map((request) => request.title)).toEqual([
+      'OpenAI-compatible base URL',
+      'OpenAI-compatible model',
+      'OpenAI-compatible API key',
+    ]);
+
+    expect(readTarget()).toMatchObject({
+      currentProvider: 'openai',
+      providers: {
+        openai: {
+          type: 'openai',
+          baseURL: 'http://localhost:1234/v1',
+          model: 'supergemma4-26b-uncensored-v2',
+          apiKey: 'lm-studio',
+        },
+      },
+    });
+    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' },
+    ]);
+  });
+
+  it('asks the user to pick a provider type when /provider add is called without one', async () => {
+    const { adapter, readTarget } = createSettingsAdapter({}, {});
+
+    const { context, requests } = scriptedContext([
+      { type: 'answer', values: ['openai'] },
+      { type: 'answer', values: [], text: '' },
+      { type: 'answer', values: [], text: '' },
+      { type: 'answer', values: [], text: '' },
+    ]);
+    const completed = await createExecutor(adapter).execute('provider', context, 'add');
+
+    expect(requests[0]?.title).toBe('Select provider');
+    expect(requests[0]?.options?.map((option) => option.value)).toEqual(['openai', 'anthropic']);
+    expect(readTarget()).toMatchObject({
+      currentProvider: 'openai',
+      providers: { openai: { type: 'openai' } },
+    });
+    expect(completed?.success).toBe(true);
+  });
+
+  it('reports usage for /provider add without a type when no renderer is attached', async () => {
+    const { adapter } = createSettingsAdapter({}, {});
+
+    const result = await createExecutor(adapter).execute('provider', headlessContext, 'add');
+
+    expect(result?.success).toBe(false);
+    expect(result?.message).toContain('Usage: provider add <type>');
+  });
+
+  it('creates another profile when provider type already exists', async () => {
+    const { adapter, readTarget } = createSettingsAdapter(
+      {
+        currentProvider: 'openai',
+        providers: {
+          openai: {
+            type: 'openai',
+            baseURL: 'http://localhost:1234/v1',
+            model: 'supergemma4-26b-uncensored-v2',
+            apiKey: 'lm-studio',
+          },
+        },
+      },
+      {},
+    );
+
+    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');
+
+    // #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: {
+        'openai-2': {
+          type: 'openai',
+          baseURL: 'http://localhost:1234/v1',
+          model: 'supergemma4-26b-uncensored-v2',
+          apiKey: 'lm-studio',
+        },
+      },
+    });
+  });
+
+  it('validates provider profile before probe without blocking manual configuration', async () => {
+    const probe = vi.fn().mockResolvedValue({ ok: false, message: 'Connection failed' });
+    const { adapter } = createSettingsAdapter({
+      currentProvider: 'openai',
+      providers: {
+        openai: {
+          type: 'openai',
+          model: 'supergemma4-26b-uncensored-v2',
+          baseURL: 'http://localhost:1234/v1',
+        },
+      },
+    });
+
+    const module = createProviderCommandModule({
+      providerDefinitions: [
+        {
+          ...providerDefinitions[0]!,
+          requiresApiKey: false,
+          probeProfile: probe,
+        },
+      ],
+      settings: adapter,
+    });
+    const result = await new SystemCommandExecutor([...(module.systemCommands ?? [])]).execute(
+      'provider',
+      headlessContext,
+      'test openai',
+    );
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toContain('Connection failed');
+    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.');
+    });
+  });
+
+  // #3459: a host that withholds its own credentials from `process.env` checks `$ENV:` credentials
+  // against the snapshot it took first, which it hands the command as `env`.
+  describe('credentials the host withheld from process.env', () => {
+    const settings: TProviderSettingsDocument = {
+      currentProvider: 'openai',
+      providers: {
+        openai: { type: 'openai', model: 'supergemma4-26b-uncensored-v2' },
+        anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+      },
+    };
+    const snapshot = { ANTHROPIC_API_KEY: 'snapshot-key' };
+
+    function withoutLiveKey<T>(run: () => Promise<T>): Promise<T> {
+      const live = process.env['ANTHROPIC_API_KEY'];
+      delete process.env['ANTHROPIC_API_KEY'];
+      return run().finally(() => {
+        if (live !== undefined) process.env['ANTHROPIC_API_KEY'] = live;
+      });
+    }
+
+    function executorWithSnapshot(adapter: IProviderCommandSettingsAdapter): SystemCommandExecutor {
+      const module = createProviderCommandModule({ providerDefinitions, settings: adapter, env: snapshot });
+      return new SystemCommandExecutor([...(module.systemCommands ?? [])]);
+    }
+
+    it('switches to a profile whose key is only in the snapshot', async () => {
+      const { adapter, readTarget } = createSettingsAdapter(settings);
+      const result = await withoutLiveKey(() =>
+        executorWithSnapshot(adapter).execute('provider', headlessContext, 'switch anthropic'),
+      );
+
+      expect(result?.success).toBe(true);
+      expect(readTarget().currentProvider).toBe('anthropic');
+    });
+
+    it('adds a profile whose default key is only in the snapshot', async () => {
+      const { adapter, readTarget } = createSettingsAdapter(settings);
+      const { context } = scriptedContext([
+        { type: 'answer', values: [], text: '' },
+        { type: 'answer', values: [], text: '' },
+      ]);
+      const module = createProviderCommandModule({ providerDefinitions, settings: adapter, env: snapshot });
+      const result = await withoutLiveKey(() =>
+        new SystemCommandExecutor([...(module.systemCommands ?? [])]).execute('provider', context, 'add anthropic'),
+      );
+
+      expect(result?.success).not.toBe(false);
+      expect(readTarget().providers?.['anthropic-2']).toMatchObject({ type: 'anthropic' });
+    });
+
+    it('edits a profile whose default key is only in the snapshot', async () => {
+      const { adapter, readTarget } = createSettingsAdapter(settings);
+      const { context } = scriptedContext([
+        { type: 'answer', values: [], text: '' },
+        { type: 'answer', values: [], text: 'claude-opus-4-5' },
+      ]);
+      const module = createProviderCommandModule({ providerDefinitions, settings: adapter, env: snapshot });
+      const result = await withoutLiveKey(() =>
+        new SystemCommandExecutor([...(module.systemCommands ?? [])]).execute('provider', context, 'edit anthropic'),
+      );
+
+      expect(result?.message).toBe('Provider anthropic updated.');
+      expect(readTarget().providers?.['anthropic']).toMatchObject({ model: 'claude-opus-4-5' });
+    });
+
+    it('tests a profile whose key is only in the snapshot', async () => {
+      const { adapter } = createSettingsAdapter(settings);
+      const result = await withoutLiveKey(() =>
+        executorWithSnapshot(adapter).execute('provider', headlessContext, 'test anthropic'),
+      );
+
+      expect(result?.message).toBe(
+        'Provider "anthropic" test passed: Profile fields are valid; no endpoint probe configured.',
+      );
+    });
+  });
+});