@robota-sdk/agent-command 3.0.0-beta.83 → 3.0.0-beta.85

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

@@ -46,7 +46,7 @@ function createCommandSessionRuntime() {
   });
 }
 
-function createCommandHostContext(adapter?: ICommandPluginAdapter) {
+function createCommandHostContext(adapter?: ICommandPluginAdapter, locality?: 'local' | 'remote') {
   const checkpoint = {
     id: 'checkpoint_1',
     sessionId: 'session_1',
@@ -66,6 +66,7 @@ function createCommandHostContext(adapter?: ICommandPluginAdapter) {
       }),
       getAutoCompactThreshold: () => 0.8,
       getCommandHostAdapters: () => (adapter === undefined ? {} : { plugin: adapter }),
+      ...(locality ? { getCommandSurfaceLocality: () => locality } : {}),
       compactContext: async () => undefined,
       getCwd: () => '/workspace',
       listCommands: () => [],
@@ -107,7 +108,9 @@ describe('createPluginCommandModule', () => {
       }),
       expect.objectContaining({
         name: 'reload-plugins',
-        description: 'Reload all plugin resources',
+        description: expect.stringContaining(
+          'refresh the command list, skill routing and model skill catalogue',
+        ),
         source: 'plugin-manager',
         modelInvocable: false,
       }),
@@ -186,6 +189,82 @@ describe('executePluginCommand', () => {
       message: 'Usage: /plugin disable <name>@<marketplace>',
     });
   });
+
+  it('lists installed plugins through the adapter, for the Settings screen (#3282 §4 part b-2)', async () => {
+    const adapter = createPluginAdapter({
+      listInstalled: vi.fn().mockResolvedValue([
+        { name: 'formatter@robota', description: 'Formats code.', enabled: true },
+        { name: 'linter@robota', description: 'Lints code.', enabled: false },
+      ]),
+    });
+
+    const result = await executePluginCommand(createCommandHostContext(adapter), 'list');
+
+    expect(result.success).toBe(true);
+    expect(result.data).toEqual({
+      plugins: [
+        { name: 'formatter@robota', description: 'Formats code.', enabled: true },
+        { name: 'linter@robota', description: 'Lints code.', enabled: false },
+      ],
+    });
+    expect(result.message).toContain('formatter@robota');
+    expect(result.message).toContain('linter@robota (disabled)');
+  });
+
+  it('no plugins installed reports a plain empty list', async () => {
+    const adapter = createPluginAdapter();
+    const result = await executePluginCommand(createCommandHostContext(adapter), 'list');
+    expect(result).toEqual({
+      success: true,
+      message: 'No plugins are installed.',
+      data: { plugins: [] },
+    });
+  });
+
+  describe('install/uninstall stay local-surface-only (#3282 §4 part b-2)', () => {
+    it('runs install from a local surface', async () => {
+      const adapter = createPluginAdapter();
+      const result = await executePluginCommand(
+        createCommandHostContext(adapter, 'local'),
+        'install demo@community',
+      );
+      expect(result.success).toBe(true);
+      expect(adapter.install).toHaveBeenCalledWith('demo@community');
+    });
+
+    it('refuses install from a remote surface with a plain message, writing nothing', async () => {
+      const adapter = createPluginAdapter();
+      const result = await executePluginCommand(
+        createCommandHostContext(adapter, 'remote'),
+        'install demo@community',
+      );
+      expect(result.success).toBe(false);
+      expect(result.message).toMatch(/only works from the desktop app or the page opened here/);
+      expect(result.message).toMatch(/not from a remote device/);
+      expect(adapter.install).not.toHaveBeenCalled();
+    });
+
+    it('refuses uninstall from a remote surface with a plain message, writing nothing', async () => {
+      const adapter = createPluginAdapter();
+      const result = await executePluginCommand(
+        createCommandHostContext(adapter, 'remote'),
+        'uninstall demo@community',
+      );
+      expect(result.success).toBe(false);
+      expect(result.message).toMatch(/not from a remote device/);
+      expect(adapter.uninstall).not.toHaveBeenCalled();
+    });
+
+    it('never refuses enable/disable/reload from a remote surface — only install/uninstall run new code', async () => {
+      const adapter = createPluginAdapter();
+      const enableResult = await executePluginCommand(
+        createCommandHostContext(adapter, 'remote'),
+        'enable demo@community',
+      );
+      expect(enableResult.success).toBe(true);
+      expect(adapter.enable).toHaveBeenCalledWith('demo@community');
+    });
+  });
 });
 
 describe('executeReloadPluginsCommand', () => {
@@ -198,7 +277,8 @@ describe('executeReloadPluginsCommand', () => {
       executeReloadPluginsCommand(createCommandHostContext(adapter), ''),
     ).resolves.toEqual({
       success: true,
-      message: 'Reloaded 3 plugin resources.',
+      message:
+        'Reloaded 3 plugin resources. Plugin commands and skills are active now; hook changes apply to new sessions.',
       data: { pluginRegistryReloaded: true },
     });
     expect(adapter.reloadPlugins).toHaveBeenCalled();
@@ -214,6 +294,7 @@ describe('executeReloadPluginsCommand', () => {
     ).resolves.toEqual({
       success: false,
       message: 'Plugin error: manifest failed',
+      data: { pluginRegistryReloaded: true },
     });
   });
 });

package/src/plugin/plugin-command.ts

@@ -3,9 +3,13 @@ import {
   resolvePluginCommandAdapter,
 } from '@robota-sdk/agent-framework';
 
-import type { ICommandHostAdapterAccess } from '@robota-sdk/agent-framework';
+import type { ICommandHostAdapterAccess, ICommandHostWorkspace } from '@robota-sdk/agent-framework';
 import type { ICommandPluginAdapter, ICommandResult } from '@robota-sdk/agent-interface-command';
 
+/** What `/plugin` reaches: its adapter port, and — for install/uninstall — this connection's locality. */
+export type TPluginCommandContext = ICommandHostAdapterAccess &
+  Partial<Pick<ICommandHostWorkspace, 'getCommandSurfaceLocality'>>;
+
 function getSubcommandParts(args: string): { subcommand: string; subArgs: string } {
   const parts = args
     .trim()
@@ -28,6 +32,20 @@ function getPluginAdapter(context: ICommandHostAdapterAccess): ICommandPluginAda
   return resolvePluginCommandAdapter(context);
 }
 
+const REMOTE_INSTALL_REFUSAL =
+  'Installing and uninstalling plugins runs code on this computer, so it only works from the ' +
+  'desktop app or the page opened here — not from a remote device.';
+
+/**
+ * #3282 §4 part b-2: the same rule the GUI's Settings screen applies before it ever sends the
+ * write — installing/uninstalling stays local-surface-only because it runs third-party code.
+ * `getCommandSurfaceLocality` absent (an older host, a test double, the in-process TUI) reads as
+ * `'local'`, matching the allow-by-default posture the rest of the command layer already uses.
+ */
+function isRemoteSurface(context: TPluginCommandContext): boolean {
+  return (context.getCommandSurfaceLocality?.() ?? 'local') === 'remote';
+}
+
 async function executePluginOperation(
   context: ICommandHostAdapterAccess,
   operation: (adapter: ICommandPluginAdapter) => Promise<string>,
@@ -123,9 +141,10 @@ function executePluginManager(): ICommandResult {
 }
 
 function executeInstallCommand(
-  context: ICommandHostAdapterAccess,
+  context: TPluginCommandContext,
   pluginId: string,
 ): Promise<ICommandResult> {
+  if (isRemoteSurface(context)) return Promise.resolve(usage(REMOTE_INSTALL_REFUSAL));
   return executePluginIdOperation(
     context,
     pluginId,
@@ -138,9 +157,10 @@ function executeInstallCommand(
 }
 
 function executeUninstallCommand(
-  context: ICommandHostAdapterAccess,
+  context: TPluginCommandContext,
   pluginId: string,
 ): Promise<ICommandResult> {
+  if (isRemoteSurface(context)) return Promise.resolve(usage(REMOTE_INSTALL_REFUSAL));
   return executePluginIdOperation(
     context,
     pluginId,
@@ -152,6 +172,27 @@ function executeUninstallCommand(
   );
 }
 
+/** #3282 §4 part b-2: the Settings screen's Plugins section reads through this, like `/mcp status`. */
+async function executeListInstalledCommand(
+  context: ICommandHostAdapterAccess,
+): Promise<ICommandResult> {
+  const adapter = getPluginAdapter(context);
+  if (adapter === undefined) {
+    return { success: true, message: 'Plugin management is not available.', data: { plugins: [] } };
+  }
+  try {
+    const plugins = await adapter.listInstalled();
+    const message =
+      plugins.length === 0
+        ? 'No plugins are installed.'
+        : `Installed plugins:\n${plugins.map((plugin) => `  ${plugin.name}${plugin.enabled ? '' : ' (disabled)'} — ${plugin.description}`).join('\n')}`;
+    return { success: true, message, data: { plugins } };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, message: `Plugin error: ${message}` };
+  }
+}
+
 function executeEnableCommand(
   context: ICommandHostAdapterAccess,
   pluginId: string,
@@ -183,7 +224,7 @@ function executeDisableCommand(
 }
 
 export async function executePluginCommand(
-  context: ICommandHostAdapterAccess,
+  context: TPluginCommandContext,
   args: string,
 ): Promise<ICommandResult> {
   const { subcommand, subArgs } = getSubcommandParts(args);
@@ -191,6 +232,8 @@ export async function executePluginCommand(
     case '':
     case 'manage':
       return executePluginManager();
+    case 'list':
+      return executeListInstalledCommand(context);
     case 'install':
       return executeInstallCommand(context, subArgs);
     case 'uninstall':
@@ -216,11 +259,10 @@ export async function executeReloadPluginsCommand(
       result.loadedPluginCount === 1
         ? '1 plugin resource'
         : `${result.loadedPluginCount} plugin resources`;
-    return `Reloaded ${suffix}.`;
+    return `Reloaded ${suffix}. Plugin commands and skills are active now; hook changes apply to new sessions.`;
   }).then((result) => {
-    if (!result.success) return result;
-    // CMD-004 Stage E: the semantic reload already ran HOST-side above (`adapter.reloadPlugins()`);
-    // the requester-local registry/autocomplete refresh rides the result as a data hint.
+    // A failed reload must also refresh the admitted snapshot: malformed settings must not leave
+    // previously loaded code executable. Preserve the error while requesting the same refresh.
     return {
       ...result,
       data: { ...result.data, pluginRegistryReloaded: true },

package/src/provider/__tests__/org-policy.test.ts

@@ -97,6 +97,10 @@ describe('org policy enforcement in provider commands', () => {
   });
 
   it('allows /provider switch when target is in allowedProviders', async () => {
+    // #3282: the switch now validates the target profile against `providerDefinitions` before
+    // writing anything, the same way the hot-swap it triggers would build the provider — so the
+    // profile needs a resolvable credential, same as a real one would.
+    vi.stubEnv('OPENAI_API_KEY', 'sk-test');
     const { adapter } = createSettingsAdapter({
       currentProvider: 'anthropic',
       providers: {

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 };
 }