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

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

@@ -0,0 +1,265 @@
+/**
+ * #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();
+  });
+
+  // #3459: the host withholds its own credentials from `process.env`; the profile's `$ENV:` key is
+  // checked against the snapshot it hands the command instead.
+  it('switches to a profile whose key is only in the host snapshot', async () => {
+    const writeTargetSettings = vi.fn();
+    const host = createTestCommandHost({ session: { getModelId: () => 'claude-sonnet-4-6' } });
+    const keyed = DEFINITIONS.map((definition) =>
+      definition.type === 'openai' ? { ...definition, requiresApiKey: true } : definition,
+    );
+    const options = {
+      ...buildOptions({ writeTargetSettings }),
+      providerDefinitions: keyed,
+      env: { OPENAI_API_KEY: 'snapshot-key' },
+    };
+    const live = process.env['OPENAI_API_KEY'];
+    delete process.env['OPENAI_API_KEY'];
+    try {
+      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' }]);
+    } finally {
+      if (live !== undefined) process.env['OPENAI_API_KEY'] = live;
+    }
+  });
+});

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,249 @@
+import { selectAction } from '@robota-sdk/agent-core';
+import {
+  buildModelListSnapshot,
+  formatOrgPolicyViolationMessage,
+  resolveModelListSelection,
+  setCurrentProvider,
+  upsertProviderProfile,
+} from '@robota-sdk/agent-framework';
+import { validateProviderConnection } from '../provider/provider-connection-validation.js';
+
+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.
+ */
+async function switchModelAcrossProfiles(
+  selection: IModelListSelection,
+  settings: TProviderSettingsDocument,
+  options: IProviderCommandModuleOptions,
+): Promise<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 {
+    await validateProviderConnection(selection.profileName, updatedProfile, options);
+  } 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();
+  if (
+    merged.currentProvider !== settings.currentProvider ||
+    JSON.stringify(merged.providers?.[selection.profileName]) !== JSON.stringify(profile)
+  ) {
+    return {
+      success: false,
+      message: 'Provider settings changed while switching. Run /model again.',
+    };
+  }
+  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/output-style/__tests__/output-style-command.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+
+import {
+  createOutputStyleCommandEntry,
+  executeOutputStyleCommand,
+} from '../output-style-command-module.js';
+
+const styles = [
+  {
+    id: 'default',
+    name: 'Default',
+    description: 'Balanced responses.',
+    tokenCost: 'baseline',
+    source: 'built-in',
+  },
+  {
+    id: 'concise',
+    name: 'Concise',
+    description: 'Lead with the answer.',
+    tokenCost: 'low',
+    source: 'built-in',
+  },
+] as const;
+
+function context() {
+  const ask = vi.fn().mockResolvedValue({ type: 'answer', values: ['concise'] });
+  const host = createTestCommandHost({
+    overrides: {
+      getActiveOutputStyleId: () => 'default',
+      getUserInteraction: () => ({ ask }),
+      getCommandHostAdapters: () => ({
+        outputStyleRegistry: {
+          listOutputStyles: () => styles,
+          getOutputStyle: (id) =>
+            id === 'concise'
+              ? {
+                  id: 'concise',
+                  name: 'Concise',
+                  instructions: 'Lead with the answer.',
+                  keepCodingInstructions: true,
+                  tokenCost: 'low',
+                }
+              : undefined,
+        },
+      }),
+    },
+  });
+  return { host, ask };
+}
+
+describe('/output-style', () => {
+  it('lists styles with the active marker and token-cost metadata', async () => {
+    const { host } = context();
+    const result = await executeOutputStyleCommand(host, 'list');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain(
+      '* default — Default: Balanced responses. [input cost: baseline]',
+    );
+    expect(result.message).toContain(
+      '  concise — Concise: Lead with the answer. [input cost: low]',
+    );
+    expect(result.data).toEqual({ outputStyles: styles, active: 'default' });
+  });
+
+  it('uses the inline picker when no id is supplied and emits only a style id action', async () => {
+    const { host, ask } = context();
+    const result = await executeOutputStyleCommand(host, '');
+
+    expect(ask).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject({
+      success: true,
+      hostActions: [{ type: 'output-style-change', styleId: 'concise' }],
+      data: { outputStyle: 'concise' },
+    });
+  });
+
+  it('rejects unknown ids and never emits an action', async () => {
+    const { host } = context();
+    const result = await executeOutputStyleCommand(host, 'missing');
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Unknown output style');
+    expect(result.hostActions).toBeUndefined();
+  });
+
+  it('is operator-only', () => {
+    expect(createOutputStyleCommandEntry()).toMatchObject({
+      name: 'output-style',
+      modelInvocable: false,
+      userInvocable: true,
+    });
+  });
+});

package/src/output-style/index.ts

@@ -0,0 +1,6 @@
+export {
+  OutputStyleCommandSource,
+  createOutputStyleCommandEntry,
+  createOutputStyleCommandModule,
+  executeOutputStyleCommand,
+} from './output-style-command-module.js';