@robota-sdk/agent-ui-terminal 3.0.0-beta.81

package/src/__tests__/command-result-handler.test.ts

@@ -0,0 +1,171 @@
+/**
+ * CMD-004 Phase 2: `applySystemCommandResult` is pure rendering. Host actions are applied (and
+ * consumed) by the session, UI intents arrive via the `ui_intent` session event, and state-change
+ * notifications arrive as broadcast session events (`session_renamed`, `history_cleared`). The
+ * only result-carried hint consumed here is `data.pluginRegistryReloaded` — the requester-local
+ * command-registry/autocomplete refresh.
+ */
+
+import { createTestInteractiveSession } from '@robota-sdk/agent-interface-session/testing';
+
+import { homedir } from 'node:os';
+import { mkdirSync, mkdtempSync, writeFileSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { afterEach, vi } from 'vitest';
+import {
+  CommandRegistry,
+  BundlePluginLoader,
+  PluginCommandSource,
+} from '@robota-sdk/agent-framework';
+import type { IInteractiveSession } from '@robota-sdk/agent-interface-session';
+import { TuiStateManager } from '../tui-state-manager.js';
+import { applySystemCommandResult } from '../hooks/command-result-handler.js';
+
+const PLUGIN_SOURCE_NAME = 'plugin';
+
+function reloadPluginCommandSource(registry: CommandRegistry): void {
+  const pluginsDir = join(process.env.HOME ?? homedir(), '.robota', 'plugins');
+  const loader = new BundlePluginLoader(pluginsDir);
+  try {
+    // allow-fallback: test helper — empty registry on load error is safe
+    const plugins = loader.loadPluginsSync();
+    if (plugins.length === 0) {
+      registry.replaceSource(PLUGIN_SOURCE_NAME);
+    } else {
+      registry.replaceSource(PLUGIN_SOURCE_NAME, new PluginCommandSource(plugins));
+    }
+  } catch {
+    // allow-fallback: test helper — empty registry on load error is safe
+    registry.replaceSource(PLUGIN_SOURCE_NAME);
+  }
+}
+
+describe('applySystemCommandResult', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  function createSession(): IInteractiveSession {
+    return Object.assign(createTestInteractiveSession(), {
+      getContextState: () => ({ usedPercentage: 0, usedTokens: 0, maxTokens: 0 }),
+    });
+  }
+
+  it('renders the message only — UI intents are delivered via the ui_intent session event', () => {
+    const manager = new TuiStateManager();
+
+    applySystemCommandResult(
+      {
+        success: true,
+        message: 'Opening plugin manager...',
+        uiIntents: [{ type: 'show-plugin-manager' }],
+      },
+      createSession(),
+      new CommandRegistry(),
+      manager,
+    );
+
+    // Pure rendering: the message lands in history; the legacy screen effect does nothing here.
+    expect(manager.history).toHaveLength(1);
+    expect(manager.history[0]?.data).toMatchObject({ content: 'Opening plugin manager...' });
+  });
+
+  it('renders a host-actioned result as message only (host applied it; TUI refreshes on result)', () => {
+    const manager = new TuiStateManager();
+
+    applySystemCommandResult(
+      {
+        success: true,
+        message: 'Status line disabled.',
+      },
+      createSession(),
+      new CommandRegistry(),
+      manager,
+    );
+
+    expect(manager.history).toHaveLength(1);
+    expect(manager.history[0]?.data).toMatchObject({ content: 'Status line disabled.' });
+  });
+
+  it('appends the /clear result message AFTER the broadcast-driven clear (event fired during executeCommand)', () => {
+    const manager = new TuiStateManager();
+    manager.addEntry({
+      id: 'old',
+      timestamp: new Date('2026-05-03T00:00:00.000Z'),
+      category: 'chat',
+      type: 'user',
+      data: { role: 'user', content: 'old message' },
+    });
+
+    // Stage E: the transcript clear itself rides the broadcast `history_cleared` session event
+    // (bound in TuiInteractionChannel and emitted while the command executes — before the result
+    // returns), so by the time this renderer runs the history is already empty.
+    manager.clearHistory();
+    applySystemCommandResult(
+      {
+        success: true,
+        message: 'Conversation cleared.',
+      },
+      createSession(),
+      new CommandRegistry(),
+      manager,
+    );
+
+    expect(manager.history).toHaveLength(1);
+    expect(manager.history[0]?.type).toBe('system');
+    expect(manager.history[0]?.data).toMatchObject({ content: 'Conversation cleared.' });
+  });
+
+  it('reloads plugin command source immediately when requested', () => {
+    const home = realpathSync(mkdtempSync(join(tmpdir(), 'robota-plugin-reload-')));
+    const pluginDir = join(
+      home,
+      '.robota',
+      'plugins',
+      'cache',
+      'community',
+      'fresh-plugin',
+      '1.0.0',
+    );
+    mkdirSync(join(pluginDir, '.claude-plugin'), { recursive: true });
+    mkdirSync(join(pluginDir, 'skills', 'fresh-skill'), { recursive: true });
+    writeFileSync(
+      join(pluginDir, '.claude-plugin', 'plugin.json'),
+      JSON.stringify({
+        name: 'fresh-plugin',
+        version: '1.0.0',
+        description: 'Fresh plugin',
+        features: { skills: true },
+      }),
+      'utf8',
+    );
+    writeFileSync(
+      join(pluginDir, 'skills', 'fresh-skill', 'SKILL.md'),
+      '---\ndescription: Fresh skill\n---\n# Fresh Skill\n',
+      'utf8',
+    );
+    vi.stubEnv('HOME', home);
+    const registry = new CommandRegistry();
+    registry.addSource({
+      name: 'plugin',
+      getCommands: () => [{ name: 'stale-skill', description: 'Stale', source: 'plugin' }],
+    });
+    const manager = new TuiStateManager();
+
+    applySystemCommandResult(
+      {
+        success: true,
+        message: 'Reloaded 1 plugin resource.',
+        data: { pluginRegistryReloaded: true },
+      },
+      createSession(),
+      registry,
+      manager,
+      reloadPluginCommandSource,
+    );
+
+    expect(registry.getCommands().map((command) => command.name)).toEqual(['fresh-skill']);
+  });
+});

package/src/__tests__/compact-event-bridge.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { createSystemMessage, messageToHistoryEntry } from '@robota-sdk/agent-core';
+import { TuiStateManager } from '../tui-state-manager.js';
+import { applyCompactEventToManager } from '../hooks/useTuiChannel.js';
+
+describe('compact event bridge', () => {
+  it('syncs session history so automatic compaction notifications render', () => {
+    const manager = new TuiStateManager();
+    const notification = messageToHistoryEntry(
+      createSystemMessage('Auto compacted context: 84% -> 35%'),
+    );
+    const session = {
+      getFullHistory: () => [notification],
+    };
+
+    applyCompactEventToManager(session, manager);
+
+    expect(manager.history).toEqual([notification]);
+  });
+});

package/src/__tests__/confirm-permission-flow.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, it } from 'vitest';
+import {
+  applyConfirmPromptInput,
+  getConfirmPromptInputAction,
+} from '../flows/confirm-prompt-flow.js';
+import {
+  applyPermissionPromptInput,
+  getPermissionPromptInputAction,
+  PERMISSION_PROMPT_OPTIONS,
+  permissionPromptOptionsFor,
+} from '../flows/permission-prompt-flow.js';
+import { createSelectionFlowState } from '../flows/selection-flow.js';
+
+describe('confirm prompt flow', () => {
+  it('Given two options When y shortcut is mapped and applied Then first option is selected', () => {
+    const action = getConfirmPromptInputAction('y', {}, 2);
+    expect(action).toEqual({ type: 'shortcut', index: 0 });
+
+    const result = applyConfirmPromptInput(createSelectionFlowState(), action!, 2);
+
+    expect(result.effect).toEqual({ type: 'select', index: 0 });
+  });
+
+  it('Given more than two options When y or n is typed Then shortcuts are ignored', () => {
+    expect(getConfirmPromptInputAction('y', {}, 3)).toBeUndefined();
+    expect(getConfirmPromptInputAction('n', {}, 3)).toBeUndefined();
+  });
+
+  it('Given selection moved right When enter is applied Then current option is selected', () => {
+    const moved = applyConfirmPromptInput(createSelectionFlowState(), 'next', 2).state;
+
+    const result = applyConfirmPromptInput(moved, 'select', 2);
+
+    expect(result.effect).toEqual({ type: 'select', index: 1 });
+  });
+
+  it('Given prompt is resolved When shortcut is applied Then no second selection is emitted', () => {
+    const selected = applyConfirmPromptInput(createSelectionFlowState(), 'select', 2).state;
+
+    const result = applyConfirmPromptInput(selected, { type: 'shortcut', index: 1 }, 2);
+
+    expect(result.effect).toEqual({ type: 'none' });
+  });
+});
+
+describe('permission prompt flow', () => {
+  it('Given y shortcut When applied Then allow decision is emitted', () => {
+    const action = getPermissionPromptInputAction('y', {});
+
+    const result = applyPermissionPromptInput(createSelectionFlowState(), action!);
+
+    expect(result.effect).toEqual({ type: 'resolve', decision: true });
+  });
+
+  it('Given a shortcut When applied Then allow-session decision is emitted', () => {
+    const action = getPermissionPromptInputAction('a', {});
+
+    const result = applyPermissionPromptInput(createSelectionFlowState(), action!);
+
+    expect(result.effect).toEqual({ type: 'resolve', decision: 'allow-session' });
+  });
+
+  it('Given p or 3 shortcut When applied Then allow-project decision is emitted', () => {
+    expect(
+      applyPermissionPromptInput(
+        createSelectionFlowState(),
+        getPermissionPromptInputAction('p', {})!,
+      ).effect,
+    ).toEqual({ type: 'resolve', decision: 'allow-project' });
+    expect(
+      applyPermissionPromptInput(
+        createSelectionFlowState(),
+        getPermissionPromptInputAction('3', {})!,
+      ).effect,
+    ).toEqual({ type: 'resolve', decision: 'allow-project' });
+  });
+
+  it('labels unavailable project approval and ignores its shortcut or selection', () => {
+    expect(permissionPromptOptionsFor('Bash(git *)', false)[2]).toBe(
+      'Project-wide approval unavailable',
+    );
+    const state = createSelectionFlowState();
+    expect(
+      applyPermissionPromptInput(state, getPermissionPromptInputAction('p', {})!, false),
+    ).toEqual({ state, effect: { type: 'none' } });
+    const selectedProject = applyPermissionPromptInput(
+      applyPermissionPromptInput(state, 'next', false).state,
+      'next',
+      false,
+    ).state;
+    expect(applyPermissionPromptInput(selectedProject, 'select', false).effect).toEqual({
+      type: 'none',
+    });
+  });
+
+  it('Given deny shortcuts When applied Then false decision is emitted', () => {
+    expect(
+      applyPermissionPromptInput(
+        createSelectionFlowState(),
+        getPermissionPromptInputAction('n', {})!,
+      ).effect,
+    ).toEqual({ type: 'resolve', decision: false });
+    expect(
+      applyPermissionPromptInput(
+        createSelectionFlowState(),
+        getPermissionPromptInputAction('4', {})!,
+      ).effect,
+    ).toEqual({ type: 'resolve', decision: false });
+  });
+
+  it('Given arrow navigation When enter is applied Then selected permission is resolved', () => {
+    const moved = applyPermissionPromptInput(createSelectionFlowState(), 'next').state;
+
+    const result = applyPermissionPromptInput(moved, 'select');
+
+    expect(result.effect).toEqual({ type: 'resolve', decision: 'allow-session' });
+  });
+
+  it('Given permission is resolved When shortcut is applied Then no second decision is emitted', () => {
+    const resolved = applyPermissionPromptInput(createSelectionFlowState(), 'select').state;
+
+    const result = applyPermissionPromptInput(resolved, { type: 'shortcut', index: 2 });
+
+    expect(result.effect).toEqual({ type: 'none' });
+  });
+
+  // CLI-030 TC-03: [s] option is shown
+  it('Given PERMISSION_PROMPT_OPTIONS When inspected Then session option contains [s] hint', () => {
+    expect(PERMISSION_PROMPT_OPTIONS[1]).toContain('[s]');
+  });
+
+  // CLI-030 TC-03: s key maps to allow-session
+  it('Given s shortcut When applied Then allow-session decision is emitted', () => {
+    const action = getPermissionPromptInputAction('s', {});
+
+    const result = applyPermissionPromptInput(createSelectionFlowState(), action!);
+
+    expect(result.effect).toEqual({ type: 'resolve', decision: 'allow-session' });
+  });
+
+  // CLI-030 TC-04: allow-once (y) does not add to session list
+  it('Given y (allow-once) shortcut When applied Then true decision is emitted (not allow-session)', () => {
+    const action = getPermissionPromptInputAction('y', {});
+
+    const result = applyPermissionPromptInput(createSelectionFlowState(), action!);
+
+    expect(result.effect).toEqual({ type: 'resolve', decision: true });
+  });
+});

package/src/__tests__/confirm-prompt.test.tsx

@@ -0,0 +1,103 @@
+import React from 'react';
+import { describe, it, expect, vi } from 'vitest';
+import { render } from 'ink-testing-library';
+import ConfirmPrompt from '../ConfirmPrompt.js';
+import { formatKeyHints } from '../key-hint-footer.js';
+
+const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe('ConfirmPrompt', () => {
+  it('renders message text', () => {
+    const { lastFrame } = render(<ConfirmPrompt message="Are you sure?" onSelect={() => {}} />);
+    expect(lastFrame()).toContain('Are you sure?');
+  });
+
+  it('renders default Yes/No options', () => {
+    const { lastFrame } = render(<ConfirmPrompt message="Confirm?" onSelect={() => {}} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Yes');
+    expect(frame).toContain('No');
+  });
+
+  it('renders custom options', () => {
+    const { lastFrame } = render(
+      <ConfirmPrompt message="Pick" options={['A', 'B', 'C']} onSelect={() => {}} />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('A');
+    expect(frame).toContain('B');
+    expect(frame).toContain('C');
+  });
+
+  it('first option is highlighted by default', () => {
+    const { lastFrame } = render(<ConfirmPrompt message="Confirm?" onSelect={() => {}} />);
+    const frame = lastFrame()!;
+    // The selected item has '> ' prefix
+    expect(frame).toContain('> Yes');
+  });
+
+  it('selects first option on Enter', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    stdin.write('\r');
+    expect(onSelect).toHaveBeenCalledWith(0);
+  });
+
+  it('navigates to second option with arrow down and selects', async () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    // Arrow down (move to No)
+    stdin.write('\x1b[B');
+    await delay(50);
+    stdin.write('\r');
+    expect(onSelect).toHaveBeenCalledWith(1);
+  });
+
+  it('y shortcut selects first option (Yes)', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    stdin.write('y');
+    expect(onSelect).toHaveBeenCalledWith(0);
+  });
+
+  it('n shortcut selects second option (No)', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    stdin.write('n');
+    expect(onSelect).toHaveBeenCalledWith(1);
+  });
+
+  it('y/n shortcuts do not work with more than 2 options', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(
+      <ConfirmPrompt message="Pick" options={['A', 'B', 'C']} onSelect={onSelect} />,
+    );
+    stdin.write('y');
+    stdin.write('n');
+    expect(onSelect).not.toHaveBeenCalled();
+  });
+
+  it('ignores input after selection (no double-fire)', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    stdin.write('\r');
+    stdin.write('\r');
+    stdin.write('y');
+    expect(onSelect).toHaveBeenCalledTimes(1);
+  });
+
+  // SCREEN-005: footer names the real keys (←→; the flow suppresses Esc, so the footer omits it —
+  // the footer lists exactly the keys that do something).
+  it('renders the footer in the shared key-hint grammar and omits Esc', () => {
+    const { lastFrame } = render(<ConfirmPrompt message="Confirm?" onSelect={() => {}} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain(
+      formatKeyHints([
+        { keys: '←→', label: 'Navigate' },
+        { keys: 'Enter', label: 'Confirm' },
+      ]),
+    );
+    expect(frame).not.toContain('Esc');
+    expect(frame).not.toContain('arrow keys');
+  });
+});

package/src/__tests__/contextual-keybindings-input.test.tsx

@@ -0,0 +1,158 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createLoopCommandEntry, createRemoteControlCommandEntry } from '@robota-sdk/agent-command';
+import InputArea from '../InputArea.js';
+import { KeybindingsProvider } from '../keybindings/keybindings-context.js';
+import { parseKeybindingsDocument } from '../keybindings/keybinding-registry.js';
+
+import type { IInputAreaHistorySearch } from '../hooks/useInputAreaHistorySearch.js';
+import type { IKeybindingsSource } from '../keybindings/node-keybindings-source.js';
+import type { ITuiCommandQueryPort } from '../tui-app-channel-port.js';
+
+async function tick(ms = 25): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function source(
+  bindings: Record<string, Record<string, string>> = {
+    'chat-input': { submit: 'ctrl+j' },
+    'autocomplete-menu': { accept: 'ctrl+j' },
+  },
+): IKeybindingsSource {
+  const parsed = parseKeybindingsDocument(
+    JSON.stringify({ version: 1, bindings }),
+    '/tmp/keybindings.json',
+  );
+  if (!parsed.ok) throw new Error(parsed.diagnostic.message);
+  return {
+    filePath: '/tmp/keybindings.json',
+    start: async () => undefined,
+    isStarted: () => true,
+    ensureFile: async () => '/tmp/keybindings.json',
+    getSnapshot: () => parsed.snapshot,
+    subscribe: () => () => undefined,
+    dispose: () => undefined,
+  };
+}
+
+describe('InputArea contextual keybindings', () => {
+  it('uses the same chord for autocomplete accept and then chat submit without double execution', async () => {
+    const onSubmit = vi.fn();
+    const commandQueryPort: ITuiCommandQueryPort = {
+      getCommands: () => [{ name: 'help', description: 'Show help', source: 'test' }],
+      getSubcommands: () => [],
+    };
+    const { stdin, lastFrame } = render(
+      <KeybindingsProvider source={source()}>
+        <InputArea onSubmit={onSubmit} isDisabled={false} commandQueryPort={commandQueryPort} />
+      </KeybindingsProvider>,
+    );
+    await tick();
+    stdin.write('/he');
+    await tick();
+    expect(lastFrame()).toContain('/help');
+    expect(lastFrame()).toContain('Ctrl+J Submit');
+
+    stdin.write('\r\n');
+    await tick();
+    expect(onSubmit).not.toHaveBeenCalled();
+
+    stdin.write('\r\n');
+    await tick(50);
+    expect(onSubmit).toHaveBeenCalledTimes(1);
+    expect(onSubmit).toHaveBeenCalledWith('/help');
+  });
+
+  it.each([
+    { name: 'remote-control', firstAction: 'status', entry: createRemoteControlCommandEntry() },
+    { name: 'loop', firstAction: 'list', entry: createLoopCommandEntry() },
+  ])(
+    'resets the selection when autocomplete changes from another parent to /$name',
+    async ({ name, firstAction, entry }) => {
+      const onSubmit = vi.fn();
+      const otherChildren = ['first', 'second', 'third'].map((child) => ({
+        name: child,
+        description: child,
+        source: 'test',
+        execute: async () => {},
+      }));
+      const commandQueryPort: ITuiCommandQueryPort = {
+        getCommands: () => [],
+        getSubcommands: (parent) =>
+          parent === 'other' ? otherChildren : parent === name ? (entry.subcommands ?? []) : [],
+      };
+      const { stdin, lastFrame } = render(
+        <KeybindingsProvider source={source()}>
+          <InputArea
+            initialValue="/other "
+            onSubmit={onSubmit}
+            isDisabled={false}
+            commandQueryPort={commandQueryPort}
+          />
+        </KeybindingsProvider>,
+      );
+      await tick();
+
+      stdin.write('\x1b[B\x1b[B'); // select index 2 under /other
+      await tick();
+      expect(lastFrame()).toContain('> third');
+      stdin.write('\x1b'); // dismiss so the text editor owns the next key
+      await tick();
+      stdin.write('\x15'); // Ctrl+U clears the current line
+      stdin.write(`/${name} `);
+      await tick();
+      expect(lastFrame()).toContain(`> ${firstAction}`);
+
+      stdin.write('\r\n');
+      await tick();
+      expect(onSubmit).not.toHaveBeenCalled();
+      stdin.write('\r\n');
+      await tick(50);
+      expect(onSubmit).toHaveBeenCalledWith(`/${name} ${firstAction}`);
+    },
+  );
+
+  // SCREEN-1993 TC-05: the open key and every overlay action are rebindable through the document,
+  // and the footer lists the live keys rather than the defaults.
+  it('rebinds the history-search open key and its actions through the document', async () => {
+    const onSubmit = vi.fn();
+    const historySearch: IInputAreaHistorySearch = {
+      source: {
+        async *read() {
+          yield {
+            entries: [
+              { at: '', sessionId: 'x', project: '/x', text: 'rotate the staging secrets' },
+            ],
+            skippedLines: 0,
+          };
+        },
+      },
+      sessionId: 's1',
+      project: '/p',
+    };
+    const { stdin, lastFrame } = render(
+      <KeybindingsProvider
+        source={source({
+          'chat-input': { 'history-search': 'ctrl+o' },
+          'history-search': { execute: 'ctrl+x', cancel: 'ctrl+g' },
+        })}
+      >
+        <InputArea onSubmit={onSubmit} isDisabled={false} historySearch={historySearch} />
+      </KeybindingsProvider>,
+    );
+    await tick();
+    stdin.write('\x12'); // the default ctrl+r no longer opens it
+    await tick();
+    expect(lastFrame()).not.toContain('(reverse-i-search)');
+    stdin.write('\x0f'); // ctrl+o
+    await tick();
+    expect(lastFrame()).toContain('(reverse-i-search)');
+    expect(lastFrame()).toContain('Ctrl+X Run');
+    expect(lastFrame()).toContain('Ctrl+G Close');
+    stdin.write('\x18'); // ctrl+x
+    await tick();
+    expect(onSubmit).toHaveBeenCalledWith('rotate the staging secrets');
+  });
+});

package/src/__tests__/default-tui-cli-adapter-host-settings.test.ts

@@ -0,0 +1,45 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { createNodeHostSettingsSource } from '@robota-sdk/agent-framework';
+import { afterEach, expect, it } from 'vitest';
+
+import { createDefaultTuiCliAdapter } from '../create-default-tui-cli-adapter.js';
+
+const roots: string[] = [];
+
+afterEach(() => {
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+it('updates the host-selected settings file when changing the active model', () => {
+  const root = mkdtempSync(join(tmpdir(), 'tui-host-settings-'));
+  roots.push(root);
+  const settingsPath = join(root, 'product-settings.json');
+  writeFileSync(settingsPath, JSON.stringify({ currentProvider: 'custom', providers: { custom: {} } }));
+
+  const adapter = createDefaultTuiCliAdapter({
+    providerDefinitions: [],
+    reloadPluginCommandSource: () => undefined,
+    userSettingsPath: settingsPath,
+    settingsSources: [createNodeHostSettingsSource('user', settingsPath)],
+  });
+
+  adapter.applyActiveModelChange(root, 'custom-model', {});
+
+  expect(JSON.parse(readFileSync(settingsPath, 'utf8'))).toMatchObject({
+    providers: { custom: { model: 'custom-model' } },
+  });
+});
+
+it('keeps the host resume command formatter when one is supplied', () => {
+  const adapter = createDefaultTuiCliAdapter({
+    providerDefinitions: [],
+    reloadPluginCommandSource: () => undefined,
+    userSettingsPath: '/tmp/product-settings.json',
+    settingsSources: [],
+    formatResumeCommand: (sessionId) => `product --resume ${sessionId}`,
+  });
+  expect(adapter.formatResumeCommand?.('session_1')).toBe('product --resume session_1');
+});