@robota-sdk/agent-command 3.0.0-beta.79 → 3.0.0-beta.81

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

@@ -1,8 +1,12 @@
 import type { ICommandHostContext, ICommandSessionRuntime } from '@robota-sdk/agent-framework';
-import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-transport';
+import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-command';
 import { describe, expect, it, vi } from 'vitest';
 import { createPluginCommandModule } from '../plugin-command-module.js';
 import { executePluginCommand, executeReloadPluginsCommand } from '../plugin-command.js';
+import {
+  createTestCommandHost,
+  createTestSessionRuntime,
+} from '@robota-sdk/agent-framework/testing';
 
 function createPluginAdapter(overrides?: Partial<ICommandPluginAdapter>): ICommandPluginAdapter {
   return {
@@ -21,8 +25,8 @@ function createPluginAdapter(overrides?: Partial<ICommandPluginAdapter>): IComma
   };
 }
 
-function createCommandSessionRuntime(): ICommandSessionRuntime {
-  return {
+function createCommandSessionRuntime() {
+  return createTestSessionRuntime({
     clearHistory: () => undefined,
     compact: async () => undefined,
     getContextState: () => ({
@@ -39,10 +43,10 @@ function createCommandSessionRuntime(): ICommandSessionRuntime {
     getAutoCompactThreshold: () => false,
     getFullHistory: () => [],
     getHistory: () => [],
-  };
+  });
 }
 
-function createCommandHostContext(adapter?: ICommandPluginAdapter): ICommandHostContext {
+function createCommandHostContext(adapter?: ICommandPluginAdapter) {
   const checkpoint = {
     id: 'checkpoint_1',
     sessionId: 'session_1',
@@ -51,39 +55,41 @@ function createCommandHostContext(adapter?: ICommandPluginAdapter): ICommandHost
     createdAt: '2026-05-03T00:00:00.000Z',
     fileCount: 0,
   };
-  return {
-    getSession: () => createCommandSessionRuntime(),
-    getContextState: () => ({
-      maxTokens: 100,
-      usedTokens: 10,
-      usedPercentage: 10,
-      remainingPercentage: 90,
-    }),
-    getAutoCompactThreshold: () => 0.8,
-    getCommandHostAdapters: () => (adapter === undefined ? {} : { plugin: adapter }),
-    compactContext: async () => undefined,
-    getCwd: () => '/workspace',
-    listCommands: () => [],
-    listEditCheckpoints: () => [],
-    restoreEditCheckpoint: async () => ({
-      target: checkpoint,
-      restoredCheckpointCount: 0,
-      restoredFileCount: 0,
-      removedCheckpointCount: 0,
-    }),
-    rollbackEditCheckpoint: async () => ({
-      target: checkpoint,
-      restoredCheckpointCount: 0,
-      restoredFileCount: 0,
-      removedCheckpointCount: 0,
-    }),
-    getUsedMemoryReferences: () => [],
-    recordMemoryEvent: () => undefined,
-    listBackgroundTasks: () => [],
-    readBackgroundTaskLog: async (taskId) => ({ taskId, lines: [] }),
-    cancelBackgroundTask: async () => undefined,
-    closeBackgroundTask: async () => undefined,
-  };
+  return createTestCommandHost({
+    overrides: {
+      getSession: () => createCommandSessionRuntime(),
+      getContextState: () => ({
+        maxTokens: 100,
+        usedTokens: 10,
+        usedPercentage: 10,
+        remainingPercentage: 90,
+      }),
+      getAutoCompactThreshold: () => 0.8,
+      getCommandHostAdapters: () => (adapter === undefined ? {} : { plugin: adapter }),
+      compactContext: async () => undefined,
+      getCwd: () => '/workspace',
+      listCommands: () => [],
+      listEditCheckpoints: () => [],
+      restoreEditCheckpoint: async () => ({
+        target: checkpoint,
+        restoredCheckpointCount: 0,
+        restoredFileCount: 0,
+        removedCheckpointCount: 0,
+      }),
+      rollbackEditCheckpoint: async () => ({
+        target: checkpoint,
+        restoredCheckpointCount: 0,
+        restoredFileCount: 0,
+        removedCheckpointCount: 0,
+      }),
+      getUsedMemoryReferences: () => [],
+      recordMemoryEvent: () => undefined,
+      listBackgroundTasks: () => [],
+      readBackgroundTaskLog: async (taskId) => ({ taskId, lines: [] }),
+      cancelBackgroundTask: async () => undefined,
+      closeBackgroundTask: async () => undefined,
+    },
+  });
 }
 
 describe('createPluginCommandModule', () => {
@@ -119,7 +125,7 @@ describe('executePluginCommand', () => {
     await expect(executePluginCommand(createCommandHostContext(), '')).resolves.toEqual({
       success: true,
       message: 'Opening plugin manager...',
-      effects: [{ type: 'plugin-tui-requested' }],
+      uiIntents: [{ type: 'show-plugin-manager' }],
     });
   });
 
@@ -193,7 +199,7 @@ describe('executeReloadPluginsCommand', () => {
     ).resolves.toEqual({
       success: true,
       message: 'Reloaded 3 plugin resources.',
-      effects: [{ type: 'plugin-registry-reload-requested' }],
+      data: { pluginRegistryReloaded: true },
     });
     expect(adapter.reloadPlugins).toHaveBeenCalled();
   });

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/plugin-command-module.ts

@@ -8,7 +8,7 @@ import {
 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-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
 
 export function createPluginCommandEntry(): ICommand {
   return {
@@ -16,6 +16,7 @@ export function createPluginCommandEntry(): ICommand {
     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(),
@@ -28,6 +29,7 @@ export function createReloadPluginsCommandEntry(): ICommand {
     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,
   };
 }

package/src/plugin/plugin-command.ts

@@ -1,11 +1,10 @@
 import {
-  createPluginRegistryReloadRequestedEffect,
-  createPluginTuiRequestedEffect,
+  createShowPluginManagerIntent,
   resolvePluginCommandAdapter,
 } from '@robota-sdk/agent-framework';
 
-import type { ICommandHostContext } from '@robota-sdk/agent-framework';
-import type { ICommandPluginAdapter, ICommandResult } from '@robota-sdk/agent-interface-transport';
+import type { ICommandHostAdapterAccess } from '@robota-sdk/agent-framework';
+import type { ICommandPluginAdapter, ICommandResult } from '@robota-sdk/agent-interface-command';
 
 function getSubcommandParts(args: string): { subcommand: string; subArgs: string } {
   const parts = args
@@ -25,12 +24,12 @@ function usage(message: string): ICommandResult {
   };
 }
 
-function getPluginAdapter(context: ICommandHostContext): ICommandPluginAdapter | undefined {
+function getPluginAdapter(context: ICommandHostAdapterAccess): ICommandPluginAdapter | undefined {
   return resolvePluginCommandAdapter(context);
 }
 
 async function executePluginOperation(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess,
   operation: (adapter: ICommandPluginAdapter) => Promise<string>,
 ): Promise<ICommandResult> {
   const adapter = getPluginAdapter(context);
@@ -56,7 +55,7 @@ async function executePluginOperation(
 }
 
 async function executeMarketplaceCommand(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess,
   subArgs: string,
 ): Promise<ICommandResult> {
   const { subcommand, subArgs: marketplaceArgs } = getSubcommandParts(subArgs);
@@ -102,7 +101,7 @@ type TPluginIdOperation = (
 ) => Promise<string> | string;
 
 function executePluginIdOperation(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess,
   pluginId: string,
   usageMessage: string,
   operation: TPluginIdOperation,
@@ -119,12 +118,12 @@ function executePluginManager(): ICommandResult {
   return {
     success: true,
     message: 'Opening plugin manager...',
-    effects: [createPluginTuiRequestedEffect()],
+    uiIntents: [createShowPluginManagerIntent()],
   };
 }
 
 function executeInstallCommand(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess,
   pluginId: string,
 ): Promise<ICommandResult> {
   return executePluginIdOperation(
@@ -139,7 +138,7 @@ function executeInstallCommand(
 }
 
 function executeUninstallCommand(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess,
   pluginId: string,
 ): Promise<ICommandResult> {
   return executePluginIdOperation(
@@ -154,7 +153,7 @@ function executeUninstallCommand(
 }
 
 function executeEnableCommand(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess,
   pluginId: string,
 ): Promise<ICommandResult> {
   return executePluginIdOperation(
@@ -169,7 +168,7 @@ function executeEnableCommand(
 }
 
 function executeDisableCommand(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess,
   pluginId: string,
 ): Promise<ICommandResult> {
   return executePluginIdOperation(
@@ -184,7 +183,7 @@ function executeDisableCommand(
 }
 
 export async function executePluginCommand(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess,
   args: string,
 ): Promise<ICommandResult> {
   const { subcommand, subArgs } = getSubcommandParts(args);
@@ -208,7 +207,7 @@ export async function executePluginCommand(
 }
 
 export async function executeReloadPluginsCommand(
-  context: ICommandHostContext,
+  context: ICommandHostAdapterAccess,
   _args: string,
 ): Promise<ICommandResult> {
   return executePluginOperation(context, async (adapter) => {
@@ -220,9 +219,11 @@ export async function executeReloadPluginsCommand(
     return `Reloaded ${suffix}.`;
   }).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.
     return {
       ...result,
-      effects: [createPluginRegistryReloadRequestedEffect()],
+      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

@@ -1,10 +1,19 @@
 import { describe, expect, it, vi } from 'vitest';
-import { listPresets } from '@robota-sdk/agent-preset';
-import type { ICommandHostContext, ICommandSessionRuntime } from '@robota-sdk/agent-framework';
+import { createPresetRegistry } from '@robota-sdk/agent-preset';
+import type {
+  ICommandHostContext,
+  ICommandSessionRuntime,
+  IUnknownCommandModuleName,
+} from '@robota-sdk/agent-framework';
 import { createPresetCommandModule, executePresetCommand } from '../index.js';
-
-function createSessionRuntime(overrides?: Partial<ICommandSessionRuntime>): ICommandSessionRuntime {
-  return {
+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: () => ({
@@ -22,59 +31,61 @@ function createSessionRuntime(overrides?: Partial<ICommandSessionRuntime>): ICom
     getFullHistory: () => [],
     getHistory: () => [],
     ...overrides,
-  };
+  });
 }
 
 function createCommandHostContext(
   runtime: ICommandSessionRuntime,
-  overrides?: Partial<ICommandHostContext>,
-): ICommandHostContext {
-  return {
-    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,
-  };
+  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', () => {
@@ -90,7 +101,7 @@ describe('preset command module', () => {
     const result = await executePresetCommand(context, '');
 
     expect(result.success).toBe(true);
-    for (const preset of listPresets()) {
+    for (const preset of createPresetRegistry().listPresets()) {
       expect(result.message).toContain(preset.id);
     }
     // The active preset is marked with the `* ` prefix.
@@ -130,7 +141,7 @@ describe('preset command module', () => {
     const result = await executePresetCommand(context, '__nope__');
 
     expect(result.success).toBe(false);
-    for (const preset of listPresets()) {
+    for (const preset of createPresetRegistry().listPresets()) {
       expect(result.message).toContain(preset.id);
     }
     expect(setActivePresetId).not.toHaveBeenCalled();
@@ -171,4 +182,39 @@ describe('preset command module', () => {
     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);
+    });
+  });
 });

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

@@ -1,20 +1,37 @@
-import { listPresets } from '@robota-sdk/agent-preset';
+import { createPresetRegistry } from '@robota-sdk/agent-preset';
 
 import { executePresetCommand } from './preset-command.js';
 
 import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
-import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
 
 const PRESET_COMMAND_DESCRIPTION = 'List presets or switch the active preset';
 const PRESET_ARGUMENT_HINT = 'list | <preset-id>';
 
-/** Build one subcommand per registered preset id (mirrors the permission-mode subcommands). */
+/**
+ * Build one subcommand per registered preset id (mirrors the permission-mode subcommands).
+ *
+ * ARCH-009 LIMIT, stated rather than left implicit: this lists the BUILT-INS, because it builds a
+ * STATIC catalog entry at module-construction time and has no `ICommandHostContext` to reach a
+ * host-supplied registry. `/preset`'s own execution — listing, lookup, resolution — goes through the
+ * host's registry, so an embedded host with its own presets resolves and applies correctly; only the
+ * pre-computed subcommand hints for tab-completion omit that host's external presets.
+ *
+ * What ARCH-009 changed here is what the limit COSTS. This used to read a process-wide mutable
+ * registry, so the hints a host saw depended on which other host had loaded presets first. They are
+ * now the built-ins and nothing else — wrong the same way for everyone, and never someone else's.
+ *
+ * Closing it needs the catalog to be built per host rather than per module, which is a change to how
+ * command modules are constructed and not to this file. Filed separately.
+ */
 function buildPresetSubcommands(source = 'preset'): ICommand[] {
-  return listPresets().map((preset) => ({
-    name: preset.id,
-    description: preset.description,
-    source,
-  }));
+  return createPresetRegistry()
+    .listPresets()
+    .map((preset) => ({
+      name: preset.id,
+      description: preset.description,
+      source,
+    }));
 }
 
 export function createPresetCommandEntry(): ICommand {
@@ -25,6 +42,7 @@ export function createPresetCommandEntry(): ICommand {
     source: 'preset',
     argumentHint: PRESET_ARGUMENT_HINT,
     subcommands: buildPresetSubcommands('preset'),
+    // User-only: a preset swaps tools, commands and permission posture; the user chooses it.
     modelInvocable: false,
   };
 }