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

package/src/plugin/__tests__/plugin-host-boundary.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+
+import * as commands from '../../index.js';
+
+describe('plugin command host boundary', () => {
+  it('keeps the concrete plugin host adapter out of the command package entrypoint', () => {
+    expect(commands).not.toHaveProperty('createDefaultPluginCommandAdapter');
+    expect(commands).not.toHaveProperty('reloadPluginCommandSource');
+    expect(commands).not.toHaveProperty('pluginScopeDirs');
+  });
+});

package/src/plugin/index.ts

@@ -0,0 +1,7 @@
+export {
+  createPluginCommandEntry,
+  createPluginCommandModule,
+  createReloadPluginsCommandEntry,
+  PluginManagerCommandSource,
+} from './plugin-command-module.js';
+export { executePluginCommand, executeReloadPluginsCommand } from './plugin-command.js';

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

@@ -0,0 +1,85 @@
+import {
+  buildPluginCommandSubcommands,
+  PLUGIN_COMMAND_ARGUMENT_HINT,
+  PLUGIN_COMMAND_DESCRIPTION,
+  RELOAD_PLUGINS_COMMAND_DESCRIPTION,
+} from '@robota-sdk/agent-framework';
+
+import { executePluginCommand, executeReloadPluginsCommand } from './plugin-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export function createPluginCommandEntry(): ICommand {
+  return {
+    name: 'plugin',
+    displayName: 'Plugins',
+    description: PLUGIN_COMMAND_DESCRIPTION,
+    source: 'plugin-manager',
+    // User-only: installs and enables code; a trust decision.
+    modelInvocable: false,
+    argumentHint: PLUGIN_COMMAND_ARGUMENT_HINT,
+    subcommands: buildPluginCommandSubcommands(),
+  };
+}
+
+export function createReloadPluginsCommandEntry(): ICommand {
+  return {
+    name: 'reload-plugins',
+    displayName: 'Reload Plugins',
+    description: RELOAD_PLUGINS_COMMAND_DESCRIPTION,
+    source: 'plugin-manager',
+    // User-only: reloading activates whatever plugin code is installed now; a trust decision.
+    modelInvocable: false,
+  };
+}
+
+function createPluginSystemCommand(): ISystemCommand {
+  const entry = createPluginCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    lifecycle: 'inline',
+    canRunDuringTurn: (args) => {
+      const parts = args.trim().split(/\s+/);
+      return parts.length === 2 && ['disable', 'uninstall'].includes(parts[0]!);
+    },
+    subcommands: entry.subcommands,
+    execute: executePluginCommand,
+  };
+}
+
+function createReloadPluginsSystemCommand(): ISystemCommand {
+  const entry = createReloadPluginsCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    lifecycle: 'inline',
+    execute: executeReloadPluginsCommand,
+  };
+}
+
+export class PluginManagerCommandSource implements ICommandSource {
+  readonly name = 'plugin-manager';
+
+  getCommands(): ICommand[] {
+    return [createPluginCommandEntry(), createReloadPluginsCommandEntry()];
+  }
+}
+
+export function createPluginCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-plugin',
+    commandSources: [new PluginManagerCommandSource()],
+    systemCommands: [createPluginSystemCommand(), createReloadPluginsSystemCommand()],
+  };
+}

package/src/plugin/plugin-command.ts

@@ -0,0 +1,271 @@
+import {
+  createShowPluginManagerIntent,
+  resolvePluginCommandAdapter,
+} 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()
+    .split(/\s+/)
+    .filter((part) => part.length > 0);
+  return {
+    subcommand: parts[0] ?? '',
+    subArgs: parts.slice(1).join(' ').trim(),
+  };
+}
+
+function usage(message: string): ICommandResult {
+  return {
+    success: false,
+    message,
+  };
+}
+
+function getPluginAdapter(context: ICommandHostAdapterAccess): ICommandPluginAdapter | undefined {
+  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>,
+): Promise<ICommandResult> {
+  const adapter = getPluginAdapter(context);
+  if (adapter === undefined) {
+    return {
+      success: false,
+      message: 'Plugin management is not available.',
+    };
+  }
+
+  try {
+    return {
+      success: true,
+      message: await operation(adapter),
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Plugin error: ${message}`,
+    };
+  }
+}
+
+async function executeMarketplaceCommand(
+  context: ICommandHostAdapterAccess,
+  subArgs: string,
+): Promise<ICommandResult> {
+  const { subcommand, subArgs: marketplaceArgs } = getSubcommandParts(subArgs);
+
+  if (subcommand === 'add' && marketplaceArgs.length > 0) {
+    return executePluginOperation(context, async (adapter) => {
+      const registeredName = await adapter.marketplaceAdd(marketplaceArgs);
+      return `Added marketplace: "${registeredName}" (from ${marketplaceArgs})\nInstall plugins with: /plugin install <name>@${registeredName}`;
+    });
+  }
+
+  if (subcommand === 'remove' && marketplaceArgs.length > 0) {
+    return executePluginOperation(context, async (adapter) => {
+      await adapter.marketplaceRemove(marketplaceArgs);
+      return `Removed marketplace "${marketplaceArgs}" and uninstalled its plugins.`;
+    });
+  }
+
+  if (subcommand === 'update' && marketplaceArgs.length > 0) {
+    return executePluginOperation(context, async (adapter) => {
+      await adapter.marketplaceUpdate(marketplaceArgs);
+      return `Updated marketplace "${marketplaceArgs}".`;
+    });
+  }
+
+  if (subcommand === 'list') {
+    return executePluginOperation(context, async (adapter) => {
+      const sources = await adapter.marketplaceList();
+      if (sources.length === 0) {
+        return 'No marketplace sources configured.';
+      }
+      const lines = sources.map((source) => `  ${source.name} (${source.type})`);
+      return `Marketplace sources:\n${lines.join('\n')}`;
+    });
+  }
+
+  return usage('Usage: /plugin marketplace add <source> | remove <name> | update <name> | list');
+}
+
+type TPluginIdOperation = (
+  adapter: ICommandPluginAdapter,
+  pluginId: string,
+) => Promise<string> | string;
+
+function executePluginIdOperation(
+  context: ICommandHostAdapterAccess,
+  pluginId: string,
+  usageMessage: string,
+  operation: TPluginIdOperation,
+): Promise<ICommandResult> {
+  if (pluginId.length === 0) {
+    return Promise.resolve(usage(usageMessage));
+  }
+  return executePluginOperation(context, (adapter) =>
+    Promise.resolve(operation(adapter, pluginId)),
+  );
+}
+
+function executePluginManager(): ICommandResult {
+  return {
+    success: true,
+    message: 'Opening plugin manager...',
+    uiIntents: [createShowPluginManagerIntent()],
+  };
+}
+
+function executeInstallCommand(
+  context: TPluginCommandContext,
+  pluginId: string,
+): Promise<ICommandResult> {
+  if (isRemoteSurface(context)) return Promise.resolve(usage(REMOTE_INSTALL_REFUSAL));
+  return executePluginIdOperation(
+    context,
+    pluginId,
+    'Usage: /plugin install <name>@<marketplace>',
+    async (adapter, targetPluginId) => {
+      await adapter.install(targetPluginId);
+      return `Installed plugin: ${targetPluginId}`;
+    },
+  );
+}
+
+function executeUninstallCommand(
+  context: TPluginCommandContext,
+  pluginId: string,
+): Promise<ICommandResult> {
+  if (isRemoteSurface(context)) return Promise.resolve(usage(REMOTE_INSTALL_REFUSAL));
+  return executePluginIdOperation(
+    context,
+    pluginId,
+    'Usage: /plugin uninstall <name>@<marketplace>',
+    async (adapter, targetPluginId) => {
+      await adapter.uninstall(targetPluginId);
+      return `Uninstalled plugin: ${targetPluginId}`;
+    },
+  );
+}
+
+/** #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,
+): Promise<ICommandResult> {
+  return executePluginIdOperation(
+    context,
+    pluginId,
+    'Usage: /plugin enable <name>@<marketplace>',
+    async (adapter, targetPluginId) => {
+      await adapter.enable(targetPluginId);
+      return `Enabled plugin: ${targetPluginId}`;
+    },
+  );
+}
+
+function executeDisableCommand(
+  context: ICommandHostAdapterAccess,
+  pluginId: string,
+): Promise<ICommandResult> {
+  return executePluginIdOperation(
+    context,
+    pluginId,
+    'Usage: /plugin disable <name>@<marketplace>',
+    async (adapter, targetPluginId) => {
+      await adapter.disable(targetPluginId);
+      return `Disabled plugin: ${targetPluginId}`;
+    },
+  );
+}
+
+export async function executePluginCommand(
+  context: TPluginCommandContext,
+  args: string,
+): Promise<ICommandResult> {
+  const { subcommand, subArgs } = getSubcommandParts(args);
+  switch (subcommand) {
+    case '':
+    case 'manage':
+      return executePluginManager();
+    case 'list':
+      return executeListInstalledCommand(context);
+    case 'install':
+      return executeInstallCommand(context, subArgs);
+    case 'uninstall':
+      return executeUninstallCommand(context, subArgs);
+    case 'enable':
+      return executeEnableCommand(context, subArgs);
+    case 'disable':
+      return executeDisableCommand(context, subArgs);
+    case 'marketplace':
+      return executeMarketplaceCommand(context, subArgs);
+    default:
+      return usage(`Unknown plugin subcommand: ${subcommand}`);
+  }
+}
+
+export async function executeReloadPluginsCommand(
+  context: ICommandHostAdapterAccess,
+  _args: string,
+): Promise<ICommandResult> {
+  return executePluginOperation(context, async (adapter) => {
+    const result = await adapter.reloadPlugins();
+    const suffix =
+      result.loadedPluginCount === 1
+        ? '1 plugin resource'
+        : `${result.loadedPluginCount} plugin resources`;
+    return `Reloaded ${suffix}. Plugin commands and skills are active now; hook changes apply to new sessions.`;
+  }).then((result) => {
+    // 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/preset/__tests__/host-supplied-preset-registry.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { executePresetCommand } from '../preset-command.js';
+
+/**
+ * ARCH-009 — `/preset` discovers through the registry the HOST resolved with.
+ *
+ * ARCH-008 moved startup preset resolution onto a per-call instance registry, but `/preset` kept
+ * reading `agent-preset`'s module-global one, because a command runs with only an
+ * `ICommandHostContext` and had no path to the instance the shell built. That left the last mutable
+ * process-global on this axis load-bearing, and it made ARCH-008's R8 property — two products in one
+ * process, each with its own presets — only half-true: both would have shared one registry.
+ *
+ * The registry arrives in the host-ADAPTER bag, the path `/permission-mode` and `/plugin` already take
+ * to their host capabilities. A capability the composition root supplies is what that bag is for, and
+ * reusing it means this seam has no shape of its own to get wrong.
+ *
+ * The decisive case is the last one. Everything else is a property of a single host; only "two hosts,
+ * one process" is impossible to satisfy with a global, which is why it is the one that proves the
+ * seam rather than merely exercising it.
+ */
+function presetSummary(id: string) {
+  return { id, title: `${id} title`, description: `${id} description` };
+}
+
+/** A host whose registry contains exactly the ids it was built with. */
+function hostWithPresets(ids: string[]) {
+  const applied: string[] = [];
+  return {
+    applied,
+    context: {
+      getCommandHostAdapters: () => ({
+        presetRegistry: {
+          listPresets: () => ids.map(presetSummary),
+          getPreset: (id: string) => (ids.includes(id) ? presetSummary(id) : undefined),
+          resolvePreset: (id: string) => ({ id }),
+        },
+      }),
+      getSession: () => ({ getActivePresetId: () => 'default' }),
+      getUserInteraction: () => undefined,
+      applyPersona: vi.fn(),
+      applySelfVerification: vi.fn(),
+      applyCommandModuleSelection: () => [],
+    } as never,
+  };
+}
+
+describe('ARCH-009 — /preset reads the host-supplied registry', () => {
+  it('lists the host registry, not the built-ins', async () => {
+    const { context } = hostWithPresets(['acme-reviewer']);
+
+    const result = await executePresetCommand(context, 'list');
+
+    expect(result.message).toContain('acme-reviewer');
+    // `careful-reviewer` is a shipped built-in and is what the no-registry fallback would list. Its
+    // absence here is what shows the fallback was not taken.
+    expect(result.message).not.toContain('careful-reviewer');
+  });
+
+  it('rejects an id the HOST does not have, even though a built-in would resolve it', async () => {
+    const { context } = hostWithPresets(['acme-reviewer']);
+
+    const result = await executePresetCommand(context, 'careful-reviewer');
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Unknown preset');
+  });
+
+  it('falls back to the built-ins when the host supplies no registry', async () => {
+    // Deliberate, not transitional: a host that never loads external presets has nothing to hand
+    // over, and `/preset` should still list the built-ins rather than reporting an empty catalog.
+    const context = {
+      getSession: () => ({ getActivePresetId: () => 'default' }),
+      getUserInteraction: () => undefined,
+      applyPersona: vi.fn(),
+      applySelfVerification: vi.fn(),
+      applyCommandModuleSelection: () => [],
+    } as never;
+
+    const result = await executePresetCommand(context, 'list');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('Available presets:');
+  });
+
+  it('gives two hosts in ONE process their own presets — the property a global makes impossible', async () => {
+    const first = hostWithPresets(['acme-reviewer']);
+    const second = hostWithPresets(['globex-auditor']);
+
+    const firstList = await executePresetCommand(first.context, 'list');
+    const secondList = await executePresetCommand(second.context, 'list');
+
+    expect(firstList.message).toContain('acme-reviewer');
+    expect(firstList.message).not.toContain('globex-auditor');
+    expect(secondList.message).toContain('globex-auditor');
+    expect(secondList.message).not.toContain('acme-reviewer');
+  });
+});

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

@@ -0,0 +1,220 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createPresetRegistry } from '@robota-sdk/agent-preset';
+import type {
+  ICommandHostContext,
+  ICommandSessionRuntime,
+  IUnknownCommandModuleName,
+} from '@robota-sdk/agent-framework';
+import { createPresetCommandModule, executePresetCommand } from '../index.js';
+import { createTestSessionRuntime } from '@robota-sdk/agent-framework/testing';
+import {
+  createTestCommandHost,
+  type ICreateTestCommandHostOptions,
+} from '@robota-sdk/agent-framework/testing';
+
+function createSessionRuntime(overrides?: Partial<ICommandSessionRuntime>) {
+  return createTestSessionRuntime({
+    clearHistory: () => undefined,
+    compact: async () => undefined,
+    getContextState: () => ({
+      maxTokens: 100,
+      usedTokens: 10,
+      usedPercentage: 10,
+      remainingPercentage: 90,
+    }),
+    getPermissionMode: () => 'default',
+    setPermissionMode: () => undefined,
+    getSessionId: () => 'session_1',
+    getMessageCount: () => 0,
+    getSessionAllowedTools: () => [],
+    getAutoCompactThreshold: () => false,
+    getFullHistory: () => [],
+    getHistory: () => [],
+    ...overrides,
+  });
+}
+
+function createCommandHostContext(
+  runtime: ICommandSessionRuntime,
+  overrides?: ICreateTestCommandHostOptions['overrides'],
+) {
+  return createTestCommandHost({
+    overrides: {
+      getSession: () => runtime,
+      getContextState: () => ({
+        maxTokens: 100,
+        usedTokens: 10,
+        usedPercentage: 10,
+        remainingPercentage: 90,
+      }),
+      getAutoCompactThreshold: () => 0.8,
+      compactContext: async () => undefined,
+      getCwd: () => '/workspace',
+      listEditCheckpoints: () => [],
+      restoreEditCheckpoint: async () => ({
+        target: {
+          id: 'checkpoint_1',
+          sessionId: 'session_1',
+          sequence: 1,
+          prompt: 'edit',
+          createdAt: '2026-05-03T00:00:00.000Z',
+          fileCount: 0,
+        },
+        restoredCheckpointCount: 1,
+        restoredFileCount: 0,
+        removedCheckpointCount: 0,
+      }),
+      rollbackEditCheckpoint: async () => ({
+        target: {
+          id: 'checkpoint_1',
+          sessionId: 'session_1',
+          sequence: 1,
+          prompt: 'edit',
+          createdAt: '2026-05-03T00:00:00.000Z',
+          fileCount: 0,
+        },
+        restoredCheckpointCount: 1,
+        restoredFileCount: 0,
+        removedCheckpointCount: 0,
+      }),
+      getUsedMemoryReferences: () => [],
+      recordMemoryEvent: () => undefined,
+      listBackgroundTasks: () => [],
+      readBackgroundTaskLog: async (taskId) => ({ taskId, lines: [] }),
+      cancelBackgroundTask: async () => undefined,
+      closeBackgroundTask: async () => undefined,
+      ...overrides,
+    },
+  });
+}
+
+describe('preset command module', () => {
+  it('exposes a single preset system command (structure)', async () => {
+    const module = createPresetCommandModule();
+    expect(module.systemCommands?.map((command) => command.name)).toContain('preset');
+  });
+
+  it('TC-01: lists every preset and marks the active one', async () => {
+    const runtime = createSessionRuntime({ getActivePresetId: () => 'autonomous-builder' });
+    const context = createCommandHostContext(runtime);
+
+    const result = await executePresetCommand(context, '');
+
+    expect(result.success).toBe(true);
+    for (const preset of createPresetRegistry().listPresets()) {
+      expect(result.message).toContain(preset.id);
+    }
+    // The active preset is marked with the `* ` prefix.
+    expect(result.message).toContain('* autonomous-builder');
+    expect(result.message).not.toContain('* default');
+    expect(result.data?.active).toBe('autonomous-builder');
+  });
+
+  it('TC-02: switches to a valid preset and drives the live re-apply seams', async () => {
+    const setActivePresetId = vi.fn();
+    const setPermissionMode = vi.fn();
+    const applyModelOptions = vi.fn();
+    const runtime = createSessionRuntime({
+      setActivePresetId,
+      setPermissionMode,
+      applyModelOptions,
+    });
+    const context = createCommandHostContext(runtime);
+
+    const result = await executePresetCommand(context, 'careful-reviewer');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Switched to preset: careful-reviewer');
+    expect(result.data?.preset).toBe('careful-reviewer');
+    expect(setActivePresetId).toHaveBeenCalledWith('careful-reviewer');
+    // careful-reviewer resolves autonomy ask-first → default permission posture (PRESET-012)
+    // and effort high → applyModelOptions (PRESET-013).
+    expect(setPermissionMode).toHaveBeenCalledWith('default');
+    expect(applyModelOptions).toHaveBeenCalledWith(expect.objectContaining({ effort: 'high' }));
+  });
+
+  it('TC-04: rejects an unknown preset id without switching', async () => {
+    const setActivePresetId = vi.fn();
+    const runtime = createSessionRuntime({ setActivePresetId });
+    const context = createCommandHostContext(runtime);
+
+    const result = await executePresetCommand(context, '__nope__');
+
+    expect(result.success).toBe(false);
+    for (const preset of createPresetRegistry().listPresets()) {
+      expect(result.message).toContain(preset.id);
+    }
+    expect(setActivePresetId).not.toHaveBeenCalled();
+  });
+
+  it('CMD-004: asks the user to pick a preset when none is given, then switches', async () => {
+    const setActivePresetId = vi.fn();
+    const setPermissionMode = vi.fn();
+    const applyModelOptions = vi.fn();
+    const runtime = createSessionRuntime({
+      setActivePresetId,
+      setPermissionMode,
+      applyModelOptions,
+    });
+    const context = createCommandHostContext(runtime, {
+      getUserInteraction: () => ({
+        ask: async () => ({ type: 'answer', values: ['careful-reviewer'] }),
+      }),
+    });
+
+    const result = await executePresetCommand(context, '');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Switched to preset: careful-reviewer');
+    expect(setActivePresetId).toHaveBeenCalledWith('careful-reviewer');
+  });
+
+  it('CMD-004: shows the preset list when the pick is cancelled', async () => {
+    const setActivePresetId = vi.fn();
+    const runtime = createSessionRuntime({ setActivePresetId });
+    const context = createCommandHostContext(runtime, {
+      getUserInteraction: () => ({ ask: async () => ({ type: 'cancelled' }) }),
+    });
+
+    const result = await executePresetCommand(context, '');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('Available presets:');
+    expect(setActivePresetId).not.toHaveBeenCalled();
+  });
+
+  describe('INFRA-032: unmatched command-module names surface in the /preset result', () => {
+    it('a preset disabling an unknown module name reports it (no longer silent)', async () => {
+      // ARCH-009: the external preset reaches `/preset` through the HOST, not through a process-wide
+      // registration this case used to perform and then have to undo in an afterEach. This is the
+      // seam the item added, exercised by a case that already needed an external preset.
+      const registry = createPresetRegistry([
+        {
+          id: 'ext-unknown-module',
+          title: 'Ext Unknown Module',
+          description: 'disables a short-form command module name',
+          disabledCommandModules: ['editor'],
+        },
+      ]);
+      const unknowns: readonly IUnknownCommandModuleName[] = [{ name: 'editor', kind: 'disabled' }];
+      const applyCommandModuleSelection = vi.fn(() => unknowns);
+      const runtime = createSessionRuntime({ setActivePresetId: vi.fn() });
+      const context = createCommandHostContext(runtime, {
+        applyCommandModuleSelection,
+        getCommandHostAdapters: () => ({ presetRegistry: registry }),
+      });
+
+      const result = await executePresetCommand(context, 'ext-unknown-module');
+
+      expect(applyCommandModuleSelection).toHaveBeenCalledWith(undefined, ['editor']);
+      // Non-fatal: the switch still succeeds…
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Switched to preset: ext-unknown-module');
+      // …and the unmatched name is surfaced in the command result (message + data).
+      expect(result.message).toContain(
+        'Preset command-module "editor" (disabled) matched no module',
+      );
+      expect(result.data?.unknownCommandModules).toEqual(unknowns);
+    });
+  });
+});