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

package/src/model/__tests__/model-command.test.ts

@@ -0,0 +1,240 @@
+/**
+ * #3282 §2 — `/model`.
+ *
+ * `buildProviderSwitch` (#3282 §1 fix, PR #3297) validates a cross-profile switch BEFORE writing
+ * settings, so a switch that would fail changes nothing on disk. `/model` follows the same shape for
+ * its cross-profile branch, and for the same-profile branch goes one step further: it performs the
+ * live hot-swap itself (via `applyModelOptions`, the same seam `/effort` and `/preset` use) and
+ * persists only once THAT succeeds — never a static validation standing in for the real attempt.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+
+import { executeModelCommand } from '../model-command.js';
+
+import type { IProviderCommandModuleOptions, IProviderProfileSettings } from '@robota-sdk/agent-framework';
+import type { IProviderDefinition } from '@robota-sdk/agent-core';
+
+const DEFINITIONS: readonly IProviderDefinition[] = [
+  {
+    type: 'anthropic',
+    displayName: 'Anthropic',
+    modelCatalog: {
+      status: 'live',
+      entries: [
+        { id: 'claude-sonnet-4-6', displayName: 'Claude Sonnet 4.6' },
+        { id: 'claude-haiku-4-5', displayName: 'Claude Haiku 4.5' },
+      ],
+    },
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  },
+  {
+    type: 'openai',
+    displayName: 'OpenAI',
+    modelCatalog: { status: 'unavailable' },
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  },
+];
+
+function providers(): Record<string, IProviderProfileSettings> {
+  return {
+    anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+    'my-openai': { type: 'openai', model: 'gpt-5.1', apiKey: '$ENV:OPENAI_API_KEY' },
+  };
+}
+
+function buildOptions(overrides: {
+  writeTargetSettings?: ReturnType<typeof vi.fn>;
+  currentProvider?: string;
+  providers?: Record<string, IProviderProfileSettings>;
+  allowedProviders?: string[];
+}): IProviderCommandModuleOptions {
+  const providerMap = overrides.providers ?? providers();
+  const document = { currentProvider: overrides.currentProvider ?? 'anthropic', providers: providerMap };
+  return {
+    providerDefinitions: DEFINITIONS,
+    settings: {
+      readMergedSettings: () => document,
+      readTargetSettings: () => document,
+      writeTargetSettings: overrides.writeTargetSettings ?? vi.fn(),
+    },
+    ...(overrides.allowedProviders !== undefined
+      ? { orgPolicy: { allowedProviders: overrides.allowedProviders } }
+      : {}),
+  };
+}
+
+describe('/model', () => {
+  it('hot-swaps within the current profile and persists only after the swap succeeds', async () => {
+    const applyModelOptions = vi.fn().mockResolvedValue(undefined);
+    const writeTargetSettings = vi.fn();
+    const host = createTestCommandHost({
+      session: { applyModelOptions, getModelId: () => 'claude-sonnet-4-6' },
+    });
+    const options = buildOptions({ writeTargetSettings });
+
+    const result = await executeModelCommand(host, 'claude-haiku-4-5', options);
+
+    expect(result).toEqual({ message: 'Model: Claude Haiku 4.5', success: true });
+    expect(applyModelOptions).toHaveBeenCalledWith({ model: 'claude-haiku-4-5' });
+    expect(writeTargetSettings).toHaveBeenCalledTimes(1);
+    const written = writeTargetSettings.mock.calls[0]![0];
+    expect(written.providers.anthropic).toMatchObject({ model: 'claude-haiku-4-5' });
+  });
+
+  it('a failed same-profile swap persists nothing', async () => {
+    const applyModelOptions = vi.fn().mockRejectedValue(new Error('boom'));
+    const writeTargetSettings = vi.fn();
+    const host = createTestCommandHost({
+      session: { applyModelOptions, getModelId: () => 'claude-sonnet-4-6' },
+    });
+    const options = buildOptions({ writeTargetSettings });
+
+    const result = await executeModelCommand(host, 'claude-haiku-4-5', options);
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('boom');
+    expect(writeTargetSettings).not.toHaveBeenCalled();
+  });
+
+  it('a cross-profile id switches profile through the provider-hot-swap host action', async () => {
+    const writeTargetSettings = vi.fn();
+    const host = createTestCommandHost({
+      session: { getModelId: () => 'claude-sonnet-4-6' },
+    });
+    const options = buildOptions({ writeTargetSettings });
+
+    const result = await executeModelCommand(host, 'gpt-5.1', options);
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Model: gpt-5.1');
+    expect(result.hostActions).toEqual([{ type: 'provider-hot-swap', profileName: 'my-openai' }]);
+    expect(writeTargetSettings).toHaveBeenCalledTimes(1);
+    const written = writeTargetSettings.mock.calls[0]![0];
+    expect(written.currentProvider).toBe('my-openai');
+    expect(written.providers['my-openai']).toMatchObject({ model: 'gpt-5.1' });
+  });
+
+  it('an org policy still allowing the target profile leaves a cross-profile switch working', async () => {
+    const writeTargetSettings = vi.fn();
+    const host = createTestCommandHost({ session: { getModelId: () => 'claude-sonnet-4-6' } });
+    const options = buildOptions({ writeTargetSettings, allowedProviders: ['anthropic', 'my-openai'] });
+
+    const result = await executeModelCommand(host, 'gpt-5.1', options);
+
+    expect(result.success).toBe(true);
+    expect(result.hostActions).toEqual([{ type: 'provider-hot-swap', profileName: 'my-openai' }]);
+    expect(writeTargetSettings).toHaveBeenCalledTimes(1);
+  });
+
+  it('refuses a cross-profile switch to a profile org policy disallows, changing nothing on disk', async () => {
+    const writeTargetSettings = vi.fn();
+    const host = createTestCommandHost({ session: { getModelId: () => 'claude-sonnet-4-6' } });
+    // Typing the id resolves it (resolution is never filtered) so the refusal names the profile
+    // specifically, rather than the id falling through to a generic "Unknown model" error.
+    const options = buildOptions({ writeTargetSettings, allowedProviders: ['anthropic'] });
+
+    const result = await executeModelCommand(host, 'gpt-5.1', options);
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('organization policy');
+    expect(result.message).toContain('my-openai');
+    expect(result.hostActions).toBeUndefined();
+    expect(writeTargetSettings).not.toHaveBeenCalled();
+  });
+
+  it('the listing omits a profile org policy disallows', async () => {
+    const host = createTestCommandHost({ session: { getModelId: () => 'claude-sonnet-4-6' } });
+    const options = buildOptions({ allowedProviders: ['anthropic'] });
+
+    const result = await executeModelCommand(host, '', options);
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('Anthropic (anthropic)');
+    expect(result.message).not.toContain('OpenAI');
+    expect(result.message).not.toContain('my-openai');
+  });
+
+  it('an unknown id gives a plain error naming /model', async () => {
+    const host = createTestCommandHost({ session: { getModelId: () => 'claude-sonnet-4-6' } });
+    const options = buildOptions({});
+
+    const result = await executeModelCommand(host, 'not-a-real-model', options);
+
+    expect(result).toEqual({
+      message: 'Unknown model "not-a-real-model". Run /model to see the choices.',
+      success: false,
+    });
+  });
+
+  it('prefers the current profile when an id is offered by more than one profile', async () => {
+    const applyModelOptions = vi.fn().mockResolvedValue(undefined);
+    const writeTargetSettings = vi.fn();
+    const shared = {
+      anthropic: { type: 'anthropic', model: 'claude-sonnet-4-6' },
+      'anthropic-2': { type: 'anthropic', model: 'claude-haiku-4-5' },
+    };
+    const host = createTestCommandHost({
+      session: { applyModelOptions, getModelId: () => 'claude-sonnet-4-6' },
+    });
+    const options = buildOptions({ writeTargetSettings, providers: shared, currentProvider: 'anthropic' });
+
+    const result = await executeModelCommand(host, 'claude-haiku-4-5', options);
+
+    // Resolved against the CURRENT profile's catalog entry, not "anthropic-2" — applyModelOptions
+    // (same-profile hot-swap), not a provider-hot-swap host action, proves which branch ran.
+    expect(result.success).toBe(true);
+    expect(applyModelOptions).toHaveBeenCalledWith({ model: 'claude-haiku-4-5' });
+    expect(result.hostActions).toBeUndefined();
+  });
+
+  it('lists models as plain text without an interactive renderer', async () => {
+    const host = createTestCommandHost({ session: { getModelId: () => 'claude-sonnet-4-6' } });
+    const options = buildOptions({});
+
+    const result = await executeModelCommand(host, '', options);
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('Anthropic (anthropic)');
+    expect(result.message).toContain('* Claude Sonnet 4.6');
+    expect(result.message).toContain('OpenAI (my-openai)');
+  });
+
+  it('drives the inline picker and applies the chosen model when a renderer is attached', async () => {
+    const applyModelOptions = vi.fn().mockResolvedValue(undefined);
+    const writeTargetSettings = vi.fn();
+    const host = createTestCommandHost({
+      session: { applyModelOptions, getModelId: () => 'claude-sonnet-4-6' },
+      overrides: {
+        getUserInteraction: () => ({
+          ask: async () => ({ type: 'answer', values: ['claude-haiku-4-5'] }),
+        }),
+      },
+    });
+    const options = buildOptions({ writeTargetSettings });
+
+    const result = await executeModelCommand(host, '', options);
+
+    expect(result).toEqual({ message: 'Model: Claude Haiku 4.5', success: true });
+  });
+
+  it('reports cancellation without changing anything when the picker is cancelled', async () => {
+    const writeTargetSettings = vi.fn();
+    const host = createTestCommandHost({
+      session: { getModelId: () => 'claude-sonnet-4-6' },
+      overrides: { getUserInteraction: () => ({ ask: async () => ({ type: 'cancelled' }) }) },
+    });
+    const options = buildOptions({ writeTargetSettings });
+
+    const result = await executeModelCommand(host, '', options);
+
+    expect(result).toEqual({ message: 'Model selection cancelled.', success: true });
+    expect(writeTargetSettings).not.toHaveBeenCalled();
+  });
+});

package/src/model/index.ts

@@ -0,0 +1,6 @@
+export {
+  createModelCommandEntry,
+  createModelCommandModule,
+  ModelCommandSource,
+} from './model-command-module.js';
+export { executeModelCommand } from './model-command.js';

package/src/model/model-command-module.ts

@@ -0,0 +1,56 @@
+import { executeModelCommand } from './model-command.js';
+
+import type {
+  ICommandModule as TCommandModule,
+  IProviderCommandModuleOptions,
+  ISystemCommand as TSystemCommand,
+} from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+export type { IProviderCommandModuleOptions };
+
+const MODEL_COMMAND_DESCRIPTION = 'Show/change the model';
+
+export function createModelCommandEntry(): ICommand {
+  return {
+    name: 'model',
+    displayName: 'Model',
+    description: MODEL_COMMAND_DESCRIPTION,
+    source: 'model',
+    argumentHint: '[<id>]',
+    example: '/model claude-sonnet-4-6',
+    // User-only: switching the model changes cost and capability, so the person decides.
+    modelInvocable: false,
+  };
+}
+
+function createModelSystemCommand(options: IProviderCommandModuleOptions): TSystemCommand {
+  const entry = createModelCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    example: entry.example,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    lifecycle: 'inline',
+    execute: (context, args) => executeModelCommand(context, args, options),
+  };
+}
+
+export class ModelCommandSource implements ICommandSource {
+  readonly name = 'model';
+
+  getCommands(): ICommand[] {
+    return [createModelCommandEntry()];
+  }
+}
+
+export function createModelCommandModule(options: IProviderCommandModuleOptions): TCommandModule {
+  return {
+    name: 'agent-command-model',
+    commandSources: [new ModelCommandSource()],
+    systemCommands: [createModelSystemCommand(options)],
+  };
+}

package/src/model/model-command.ts

@@ -0,0 +1,223 @@
+import { selectAction } from '@robota-sdk/agent-core';
+import {
+  buildModelListSnapshot,
+  formatOrgPolicyViolationMessage,
+  resolveModelListSelection,
+  setCurrentProvider,
+  upsertProviderProfile,
+  validateProviderProfile,
+} from '@robota-sdk/agent-framework';
+
+import type { IUserInteraction } from '@robota-sdk/agent-core';
+import type {
+  ICommandHostSessionAccess,
+  ICommandHostUserInteraction,
+  IModelListSelection,
+  IProviderCommandModuleOptions,
+  IProviderProfileSettings,
+  TProviderSettingsDocument,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+import type { IModelListSnapshot } from '@robota-sdk/agent-interface-session';
+
+type TModelCommandContext = ICommandHostSessionAccess & ICommandHostUserInteraction;
+
+/** The current model, read from the live session; falls back to the profile's configured one. */
+function readCurrentModel(
+  context: ICommandHostSessionAccess,
+  currentProfile: IProviderProfileSettings | undefined,
+): string {
+  return context.getSession().getModelId() ?? currentProfile?.model ?? '';
+}
+
+/**
+ * `allowFiltered` controls whether a profile org policy disallows is left out of the snapshot.
+ * The PICKER (no id typed) always filters: a disallowed profile must never be offered as a choice.
+ * RESOLVING a typed/clicked id never filters: `switchModelAcrossProfiles` is the one place that
+ * decides a disallowed target, exactly as `buildProviderSwitch` decides it for `/provider switch` —
+ * a filtered resolution snapshot would turn that decision into an unreachable "Unknown model"
+ * instead of the specific, actionable organization-policy refusal.
+ */
+function buildSnapshot(
+  context: ICommandHostSessionAccess,
+  settings: TProviderSettingsDocument,
+  options: IProviderCommandModuleOptions,
+  allowFiltered: boolean,
+): IModelListSnapshot {
+  const currentProfile =
+    settings.currentProvider !== undefined ? settings.providers?.[settings.currentProvider] : undefined;
+  return buildModelListSnapshot(
+    settings.providers,
+    settings.currentProvider,
+    readCurrentModel(context, currentProfile),
+    options.providerDefinitions,
+    allowFiltered ? options.orgPolicy?.allowedProviders : undefined,
+  );
+}
+
+export async function executeModelCommand(
+  context: TModelCommandContext,
+  args: string,
+  options: IProviderCommandModuleOptions,
+): Promise<ICommandResult> {
+  const settings = options.settings.readMergedSettings();
+  const id = args.trim();
+
+  if (id.length === 0) {
+    const visible = buildSnapshot(context, settings, options, true);
+    return pickModel(context.getUserInteraction(), visible, context, options);
+  }
+
+  const full = buildSnapshot(context, settings, options, false);
+  const selection = resolveModelListSelection(full, id);
+  if (selection === undefined) {
+    return {
+      message: `Unknown model "${id}". Run /model to see the choices.`,
+      success: false,
+    };
+  }
+
+  if (selection.profileName === settings.currentProvider) {
+    return switchModelWithinCurrentProfile(context, selection, settings, options);
+  }
+  return switchModelAcrossProfiles(selection, settings, options);
+}
+
+/**
+ * With an interactive renderer attached, drive the inline picker (CMD-004); without one — headless,
+ * automation, or a model-invoked caller, though this command is never offered to a model — return the
+ * list as plain text instead of guessing a choice.
+ */
+async function pickModel(
+  ui: IUserInteraction | undefined,
+  snapshot: IModelListSnapshot,
+  context: TModelCommandContext,
+  options: IProviderCommandModuleOptions,
+): Promise<ICommandResult> {
+  if (snapshot.groups.length === 0) {
+    return { message: 'No provider profiles configured. Run /provider add to add one.', success: true };
+  }
+  if (!ui) {
+    return { message: formatModelListText(snapshot), success: true };
+  }
+  const modelOptions = snapshot.groups.flatMap((group) =>
+    group.models.map((model) => ({
+      value: model.id,
+      label: formatModelOptionLabel(snapshot, group.profileName, group.providerLabel, model),
+    })),
+  );
+  const response = await ui.ask(selectAction('model', 'Select model', modelOptions, { maxVisible: 8 }));
+  if (response.type !== 'answer' || response.values[0] === undefined) {
+    return { message: 'Model selection cancelled.', success: true };
+  }
+  return executeModelCommand(context, response.values[0], options);
+}
+
+function formatModelListText(snapshot: IModelListSnapshot): string {
+  const lines: string[] = [];
+  for (const group of snapshot.groups) {
+    lines.push(`${group.providerLabel} (${group.profileName})`);
+    for (const model of group.models) {
+      const marker =
+        model.id === snapshot.currentModel && group.profileName === snapshot.currentProfile ? '*' : '-';
+      lines.push(`  ${marker} ${model.label}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+function formatModelOptionLabel(
+  snapshot: IModelListSnapshot,
+  profileName: string,
+  providerLabel: string,
+  model: { id: string; label: string },
+): string {
+  const marker = model.id === snapshot.currentModel && profileName === snapshot.currentProfile ? '* ' : '';
+  const sharedLabelCount = snapshot.groups.filter((group) => group.providerLabel === providerLabel).length;
+  const disambiguator = sharedLabelCount > 1 ? ` (${profileName})` : '';
+  return `${marker}${providerLabel}: ${model.label}${disambiguator}`;
+}
+
+/**
+ * The id belongs to the CURRENT profile's provider (#3282 §2): hot-swap the live model first, and
+ * persist it to the current profile only once that succeeds — a failed swap must leave settings
+ * exactly as they were.
+ */
+async function switchModelWithinCurrentProfile(
+  context: ICommandHostSessionAccess,
+  selection: IModelListSelection,
+  settings: TProviderSettingsDocument,
+  options: IProviderCommandModuleOptions,
+): Promise<ICommandResult> {
+  const currentProfileName = selection.profileName;
+  try {
+    await context.getSession().applyModelOptions({ model: selection.model.id });
+  } catch (error) {
+    return {
+      message: `Could not switch to "${selection.model.label}": ${error instanceof Error ? error.message : String(error)}`,
+      success: false,
+    };
+  }
+  const target = options.settings.readTargetSettings();
+  // Based on MERGED (not target-only) so a profile that lives in a lower-priority settings layer
+  // keeps its other fields (type, apiKey, baseURL) — only `model` changes at the target layer.
+  const currentProfile = settings.providers?.[currentProfileName] ?? target.providers?.[currentProfileName] ?? {};
+  options.settings.writeTargetSettings(
+    upsertProviderProfile(target, currentProfileName, { ...currentProfile, model: selection.model.id }),
+  );
+  return { message: `Model: ${selection.model.label}`, success: true };
+}
+
+/**
+ * The id belongs to ANOTHER profile's provider (#3282 §2): switch to that profile through the same
+ * validate-before-write path `/provider switch` uses, with the requested model folded into the same
+ * settings write, then hot-swap through the existing `provider-hot-swap` host action — which re-reads
+ * settings at execution time, so it picks up the model this write just persisted.
+ */
+function switchModelAcrossProfiles(
+  selection: IModelListSelection,
+  settings: TProviderSettingsDocument,
+  options: IProviderCommandModuleOptions,
+): ICommandResult {
+  const { orgPolicy } = options;
+  // Checked BEFORE anything is read or written — exactly buildProviderSwitch's order — so a switch
+  // org policy refuses changes nothing on disk, the same guarantee /provider switch already gives.
+  if (orgPolicy?.allowedProviders && !orgPolicy.allowedProviders.includes(selection.profileName)) {
+    return {
+      message: formatOrgPolicyViolationMessage(
+        `Provider "${selection.profileName}" is not allowed by your organization policy. Allowed: ${orgPolicy.allowedProviders.join(', ')}.`,
+        orgPolicy.adminContact,
+      ),
+      success: false,
+    };
+  }
+  const profile = settings.providers?.[selection.profileName];
+  if (profile === undefined) {
+    return { message: `Provider profile "${selection.profileName}" was not found.`, success: false };
+  }
+  const updatedProfile: IProviderProfileSettings = { ...profile, model: selection.model.id };
+  try {
+    validateProviderProfile(selection.profileName, updatedProfile, {
+      providerDefinitions: options.providerDefinitions,
+    });
+  } catch (error) {
+    return {
+      message: `Could not switch to "${selection.model.label}": ${error instanceof Error ? error.message : String(error)}`,
+      success: false,
+    };
+  }
+  const target = options.settings.readTargetSettings();
+  const merged = options.settings.readMergedSettings();
+  const withModel = upsertProviderProfile(target, selection.profileName, updatedProfile);
+  const next =
+    target.providers?.[selection.profileName] !== undefined ||
+    merged.providers?.[selection.profileName] !== undefined
+      ? { ...withModel, currentProvider: selection.profileName }
+      : setCurrentProvider(withModel, selection.profileName);
+  options.settings.writeTargetSettings(next);
+  return {
+    message: `Model: ${selection.model.label}`,
+    success: true,
+    hostActions: [{ type: 'provider-hot-swap', profileName: selection.profileName }],
+  };
+}

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

@@ -46,7 +46,10 @@ function createCommandSessionRuntime() {
   });
 }
 
-function createCommandHostContext(adapter?: ICommandPluginAdapter) {
+function createCommandHostContext(
+  adapter?: ICommandPluginAdapter,
+  locality?: 'local' | 'remote',
+) {
   const checkpoint = {
     id: 'checkpoint_1',
     sessionId: 'session_1',
@@ -66,6 +69,7 @@ function createCommandHostContext(adapter?: ICommandPluginAdapter) {
       }),
       getAutoCompactThreshold: () => 0.8,
       getCommandHostAdapters: () => (adapter === undefined ? {} : { plugin: adapter }),
+      ...(locality ? { getCommandSurfaceLocality: () => locality } : {}),
       compactContext: async () => undefined,
       getCwd: () => '/workspace',
       listCommands: () => [],
@@ -186,6 +190,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', () => {