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

package/src/doctor/doctor-types.ts

@@ -0,0 +1,109 @@
+/**
+ * The doctor's evidence model (OBSERVABILITY-1991).
+ *
+ * `fail` is the only status that raises the exit code — the diagnostic command contract shipped
+ * with. `not-configured` names an absent optional capability out loud instead of treating
+ * it as healthy. `not-probed` is a CLOSED list of probes the read-only doctor deliberately does not
+ * run (see {@link TDoctorNotProbed}); an UNEXPECTED inability to probe is `warn` with its reason,
+ * never `not-probed` — the third state `enforcement-architecture.md` says must never read as a pass.
+ */
+import type { IProviderDefinition } from '@robota-sdk/agent-core';
+import type {
+  IContributionSource,
+  ISkillRootDescriptor,
+  TSettingsSource,
+  TWorkspaceProjectAccess,
+} from '@robota-sdk/agent-framework';
+import type { ICommandMCPActivationAdapter } from '@robota-sdk/agent-framework';
+
+export type TDoctorCheckStatus = 'ok' | 'warn' | 'fail' | 'not-configured' | 'not-probed';
+
+/** The enumerated probes the read-only doctor does not run. Adding one is a spec change. */
+export type TDoctorNotProbed = 'mcp-connection' | 'hook-execution' | 'owner-only-mode';
+
+export interface IDoctorCheck {
+  /** Stable, user-typeable id (`settings.<scope>.<family>`, `storage.user`, `mcp.plugin.<id>.<server>`). */
+  readonly id: string;
+  readonly label: string;
+  readonly status: TDoctorCheckStatus;
+  /** The exact file or directory the finding is about, when there is one. */
+  readonly path?: string;
+  /** The specific cause, as the owner reported it — a state word, an issue path, an errno; never a secret. */
+  readonly cause?: string;
+  /** Free-text detail lines rendered under the check. */
+  readonly detail?: readonly string[];
+  /** Present when this run can repair the finding; names the allowlisted repair id (equal to `id`). */
+  readonly repair?: string;
+}
+
+export interface IDoctorReport {
+  readonly checks: readonly IDoctorCheck[];
+  readonly failCount: number;
+  readonly warnCount: number;
+  /** Ids of checks whose `repair` is set in THIS run. */
+  readonly repairable: readonly string[];
+  /** Exit-code contract: `0` when `failCount === 0`, else `1`. */
+  readonly exitCode: 0 | 1;
+}
+
+/** One TCP reachability result; the probe is injected so tests never touch the network. */
+export interface IDoctorEndpointProbeResult {
+  readonly reachable: boolean;
+  readonly elapsedMs?: number;
+  readonly error?: string;
+}
+
+/** What the host knows and the runner does not: the composition the shell built, and its facts. */
+export interface IDoctorInputs {
+  readonly cwd: string;
+  readonly userHome: string;
+  /**
+   * The product's own user settings file — the only settings layer the repair allowlist may rewrite.
+   * The host names it; this library knows no product layout.
+   */
+  readonly userSettingsPath: string;
+  /** The product's user store root and its sessions directory, as the host lays them out. */
+  readonly userStorage: { readonly root: string; readonly sessions: string };
+  /** The project state root under a trusted workspace, when the host has one. */
+  readonly projectStorageRoot?: string;
+  /** Every settings source the runtime merge chain reads, in precedence order. */
+  readonly settingsSources: readonly TSettingsSource[];
+  readonly projectAccess: TWorkspaceProjectAccess;
+  readonly providerDefinitions: readonly IProviderDefinition[];
+  /** Optional host wording for remediation; omitted values use product-neutral guidance. */
+  readonly diagnosticGuidance?: {
+    readonly providerResolution?: string;
+    readonly projectTrust?: string;
+  };
+  /** Environment map (test seam; default `process.env`). */
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly contributionSources: readonly IContributionSource[];
+  readonly skillRoots: readonly ISkillRootDescriptor[];
+  /** Plugin scope directories, most specific first — the same list the session loader reads. */
+  readonly pluginsDirs: readonly string[];
+  /** Host-composed MCP activation adapter; absent means the CLI has no MCP host. */
+  readonly mcpActivation?: ICommandMCPActivationAdapter;
+  /** Checks only the host can make (Node version, terminal, CLI version); rendered first. */
+  readonly hostChecks: readonly IDoctorCheck[];
+  /** A workspace-composition failure the host converted into a check rather than a crash. */
+  readonly compositionFailure?: IDoctorCheck;
+}
+
+/** Storage facts about one path, probed without writing. */
+export interface IDoctorPathFacts {
+  readonly exists: boolean;
+  readonly isDirectory: boolean;
+  readonly writable: boolean;
+  /** POSIX mode bits, or `undefined` when the platform does not assert them. */
+  readonly mode?: number;
+}
+
+/** Every side effect the runner needs, with Node defaults in `doctor-node-deps.ts`. */
+export interface IDoctorDeps {
+  readonly probeEndpoint: (host: string, port: number) => Promise<IDoctorEndpointProbeResult>;
+  readonly inspectPath: (path: string) => IDoctorPathFacts;
+  /** `true` when a bare command name resolves on `PATH`, or a path-form command exists. */
+  readonly resolveCommand: (command: string) => boolean;
+  /** The platform's owner-only guarantee, from `@robota-sdk/agent-core/node`. */
+  readonly ownerOnlyGuarantee: () => 'posix-mode' | 'windows-acl';
+}

package/src/doctor/index.ts

@@ -0,0 +1,32 @@
+export {
+  DoctorCommandSource,
+  createDoctorCommandEntry,
+  createDoctorCommandModule,
+} from './doctor-command-module.js';
+export { createNodeDoctorDeps, resolveCommandOnPath } from './doctor-node-deps.js';
+export { renderDoctorReport } from './doctor-render.js';
+export type { IDoctorDisplayVocabulary } from './doctor-render.js';
+export { collectSettingsSecrets, redactDiagnosticText } from './doctor-redaction.js';
+export {
+  STORAGE_REPAIR_ID,
+  doctorRepairAllowlist,
+  applyDoctorRepair,
+  isDoctorRepairId,
+  planDoctorRepair,
+} from './doctor-repair.js';
+export type {
+  IDoctorRepairPlan,
+  TDoctorRepairOutcome,
+  TDoctorRepairPlanResult,
+} from './doctor-repair.js';
+export { buildDoctorReport, runDoctor } from './doctor-runner.js';
+export type {
+  IDoctorCheck,
+  IDoctorDeps,
+  IDoctorEndpointProbeResult,
+  IDoctorInputs,
+  IDoctorPathFacts,
+  IDoctorReport,
+  TDoctorCheckStatus,
+  TDoctorNotProbed,
+} from './doctor-types.js';

package/src/editor/__tests__/editor-command-functional.test.ts

@@ -0,0 +1,124 @@
+/**
+ * TERM-004: `/editor` — framework functional test.
+ *
+ * Drives the command through a REAL InteractiveSession with an injected fake handoff and a FAKE
+ * editor (a tiny script that writes known content to its file arg). Verifies the round-trip: the
+ * command opens the editor via `runWithTerminal`, captures the saved text, and cleans up — without a
+ * real interactive editor (which is a manual gate, TERM-002).
+ */
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+  realpathSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { scriptedSession, type ScriptedSessionHarness } from '@robota-sdk/agent-framework/testing';
+
+import { createEditorCommandModule } from '../editor-command-module.js';
+
+import type { ITerminalHandoff } from '@robota-sdk/agent-interface-session';
+
+const TEST_TIMEOUT = 20_000;
+
+function fakeHandoff(canHandoff: boolean): ITerminalHandoff {
+  return {
+    canHandoffTerminal: canHandoff,
+    async runWithTerminal<T>(fn: () => Promise<T>): Promise<T> {
+      return fn();
+    },
+  };
+}
+
+/** Write a fake `$EDITOR`: a script that writes `content` into the file it is given as $1. */
+function installFakeEditor(content: string): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'agent-test-fake-editor-')));
+  const script = join(dir, 'fake-editor.sh');
+  writeFileSync(
+    script,
+    `#!/bin/sh\nprintf '%s' '${content}' > "$1"\nif [ -n "$EDITOR_CAPTURE_PATH" ]; then printf '%s' "$1" > "$EDITOR_CAPTURE_PATH"; fi\n`,
+    'utf8',
+  );
+  chmodSync(script, 0o755);
+  return script;
+}
+
+let h: ScriptedSessionHarness | undefined;
+afterEach(async () => {
+  await h?.dispose();
+  h = undefined;
+  vi.unstubAllEnvs();
+});
+
+describe('/editor command (framework functional)', () => {
+  it(
+    'opens the editor via the handoff and returns the saved text',
+    async () => {
+      vi.stubEnv('VISUAL', undefined);
+      vi.stubEnv('EDITOR', installFakeEditor('composed in editor'));
+      h = scriptedSession({
+        turns: [{ text: 'unused' }],
+        terminalHandoff: fakeHandoff(true),
+        commandModules: [createEditorCommandModule()],
+      });
+
+      const result = await h.command('editor', '');
+
+      expect(result?.success).toBe(true);
+      expect(result?.message).toBe('composed in editor');
+      expect((result?.data as { content: string }).content).toBe('composed in editor');
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    'uses a neutral temporary directory and removes it after editing',
+    async () => {
+      const captureDir = mkdtempSync(join(tmpdir(), 'editor-capture-'));
+      const capturePath = join(captureDir, 'opened-path');
+      try {
+        vi.stubEnv('VISUAL', undefined);
+        vi.stubEnv('EDITOR', installFakeEditor('neutral draft'));
+        vi.stubEnv('EDITOR_CAPTURE_PATH', capturePath);
+        h = scriptedSession({
+          turns: [{ text: 'unused' }],
+          terminalHandoff: fakeHandoff(true),
+          commandModules: [createEditorCommandModule()],
+        });
+
+        const result = await h.command('editor', '');
+        const openedPath = readFileSync(capturePath, 'utf8');
+        expect(result?.message).toBe('neutral draft');
+        expect(basename(dirname(openedPath))).toMatch(/^agent-editor-/);
+        expect(existsSync(dirname(openedPath))).toBe(false);
+      } finally {
+        rmSync(captureDir, { recursive: true, force: true });
+      }
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    'is unavailable when there is no interactive terminal',
+    async () => {
+      vi.stubEnv('EDITOR', installFakeEditor('unused'));
+      h = scriptedSession({
+        turns: [{ text: 'unused' }],
+        commandModules: [createEditorCommandModule()],
+      });
+
+      const result = await h.command('editor', '');
+
+      expect(result?.success).toBe(false);
+      expect(result?.message).toMatch(/unavailable/i);
+    },
+    TEST_TIMEOUT,
+  );
+});

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

@@ -0,0 +1,53 @@
+/**
+ * TERM-004: `/editor` command module — a framework-level consumer of the terminal-handoff capability.
+ */
+import { EDITOR_COMMAND_DESCRIPTION, executeEditorCommand } from './editor-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export function createEditorCommandEntry(): ICommand {
+  return {
+    name: 'editor',
+    displayName: 'Editor',
+    description: EDITOR_COMMAND_DESCRIPTION,
+    source: 'editor',
+    // User-only: opens the user's terminal editor; UI-only.
+    modelInvocable: false,
+    // It takes over the terminal the user sits at, so that terminal runs it, even when attached.
+    runner: 'client',
+    surfaces: ['terminal'],
+  };
+}
+
+function createEditorSystemCommand(temporaryDirectoryPrefix?: string): ISystemCommand {
+  const entry = createEditorCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    runner: entry.runner,
+    surfaces: entry.surfaces,
+    lifecycle: 'inline',
+    execute: (context, args) => executeEditorCommand(context, args, temporaryDirectoryPrefix),
+  };
+}
+
+export class EditorCommandSource implements ICommandSource {
+  readonly name = 'editor';
+
+  getCommands(): ICommand[] {
+    return [createEditorCommandEntry()];
+  }
+}
+
+export function createEditorCommandModule(temporaryDirectoryPrefix?: string): ICommandModule {
+  return {
+    name: 'agent-command-editor',
+    commandSources: [new EditorCommandSource()],
+    systemCommands: [createEditorSystemCommand(temporaryDirectoryPrefix)],
+  };
+}

package/src/editor/editor-command.ts

@@ -0,0 +1,58 @@
+/**
+ * TERM-004: `/editor` — compose a message/prompt in `$EDITOR` via the terminal-handoff capability,
+ * then return the saved text. The temp file is pre-filled with any args and removed afterward.
+ */
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { resolveEditor } from './resolve-editor.js';
+import { spawnInherited } from '../shell/spawn-inherited.js';
+
+import type {
+  ICommandHostTerminalHandoff,
+  ICommandHostWorkspace,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+export const EDITOR_COMMAND_DESCRIPTION =
+  'Compose a message in $EDITOR (optionally pre-filled with `/editor <text>`), then return it.';
+export const DEFAULT_EDITOR_TEMPORARY_DIRECTORY_PREFIX = 'agent-editor-';
+
+export async function executeEditorCommand(
+  context: ICommandHostTerminalHandoff & ICommandHostWorkspace,
+  args: string,
+  temporaryDirectoryPrefix: string = DEFAULT_EDITOR_TEMPORARY_DIRECTORY_PREFIX,
+): Promise<ICommandResult> {
+  if (!context.canHandoffTerminal()) {
+    return {
+      message: 'An editor is unavailable here (no interactive terminal).',
+      success: false,
+    };
+  }
+
+  const editor = resolveEditor();
+  const dir = mkdtempSync(join(tmpdir(), temporaryDirectoryPrefix));
+  const file = join(dir, 'message.md');
+  writeFileSync(file, args ?? '', 'utf8');
+
+  try {
+    const exitCode = await context.runWithTerminal(async () =>
+      spawnInherited(editor.command, [...editor.args, file], context.getCwd()),
+    );
+    if (exitCode !== 0) {
+      return {
+        message: `Editor exited without saving (code ${exitCode}).`,
+        success: false,
+        data: { exitCode },
+      };
+    }
+    const content = readFileSync(file, 'utf8').replace(/\s+$/u, '');
+    if (content.length === 0) {
+      return { message: 'Editor closed with empty content; nothing composed.', success: false };
+    }
+    return { message: content, success: true, data: { content } };
+  } finally {
+    rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 20 });
+  }
+}

package/src/editor/index.ts

@@ -0,0 +1,7 @@
+export { resolveEditor, type IResolvedEditor } from './resolve-editor.js';
+export { executeEditorCommand, EDITOR_COMMAND_DESCRIPTION } from './editor-command.js';
+export {
+  EditorCommandSource,
+  createEditorCommandEntry,
+  createEditorCommandModule,
+} from './editor-command-module.js';

package/src/editor/resolve-editor.ts

@@ -0,0 +1,21 @@
+/**
+ * TERM-004: editor-selection seam. Resolves `$VISUAL` → `$EDITOR` → `vi` (POSIX-first; a Windows
+ * default is a TERM-007 concern). Splits on whitespace so `"code -w"` / `"subl -w"` style values work.
+ */
+export interface IResolvedEditor {
+  command: string;
+  args: readonly string[];
+}
+
+export function resolveEditor(): IResolvedEditor {
+  const visual = process.env.VISUAL?.trim();
+  const editor = process.env.EDITOR?.trim();
+  const chosen =
+    visual !== undefined && visual.length > 0
+      ? visual
+      : editor !== undefined && editor.length > 0
+        ? editor
+        : 'vi';
+  const parts = chosen.split(/\s+/).filter((p) => p.length > 0);
+  return { command: parts[0] ?? 'vi', args: parts.slice(1) };
+}

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

@@ -0,0 +1,51 @@
+import { MODEL_EFFORT_VALUES } from '@robota-sdk/agent-core';
+
+import { executeEffortCommand } from './effort-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+const EFFORT_ARGUMENT_HINT = `auto | ${MODEL_EFFORT_VALUES.join(' | ')}`;
+
+export function createEffortCommandEntry(): ICommand {
+  return {
+    name: 'effort',
+    displayName: 'Model Effort',
+    description: 'Show or change the model effort level',
+    source: 'effort',
+    argumentHint: EFFORT_ARGUMENT_HINT,
+    // User-only: the effort tier is the user's cost/latency preference.
+    modelInvocable: false,
+  };
+}
+
+function createEffortSystemCommand(): ISystemCommand {
+  const entry = createEffortCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    lifecycle: 'inline',
+    execute: executeEffortCommand,
+  };
+}
+
+export class EffortCommandSource implements ICommandSource {
+  readonly name = 'effort';
+
+  getCommands(): ICommand[] {
+    return [createEffortCommandEntry()];
+  }
+}
+
+export function createEffortCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-effort',
+    commandSources: [new EffortCommandSource()],
+    systemCommands: [createEffortSystemCommand()],
+  };
+}

package/src/effort/effort-command.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { executeEffortCommand } from './effort-command.js';
+
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+
+describe('/effort', () => {
+  it('#3282 §2: reports plainly when the model has no matching effort control at all', async () => {
+    const host = createTestCommandHost({
+      overrides: {
+        getCommandHostAdapters: () => ({
+          settings: { read: () => ({}), write: vi.fn() },
+          effort: {
+            getResolution: () => ({
+              requested: 'low',
+              effective: 'low',
+              source: 'command',
+              disposition: 'not-applied',
+              modelDefault: 'high',
+            }),
+            apply: async () => ({
+              requested: 'low',
+              effective: 'low',
+              source: 'command',
+              disposition: 'not-applied',
+              modelDefault: 'high',
+            }),
+          },
+        }),
+      },
+    });
+
+    const result = await executeEffortCommand(host, 'low');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe("This model doesn't support effort levels, so it will use its default.");
+  });
+
+  it('applies a requested level and returns the complete resolution', async () => {
+    const applyModelOptions = vi.fn();
+    const writeSettings = vi.fn();
+    const host = createTestCommandHost({
+      session: { applyModelOptions },
+      overrides: {
+        getCommandHostAdapters: () => ({
+          settings: { read: () => ({ theme: 'brief' }), write: writeSettings },
+          effort: {
+            getResolution: () => ({
+              requested: 'high',
+              effective: 'high',
+              source: 'model-default',
+              disposition: 'model-default',
+              modelDefault: 'high',
+            }),
+            apply: async (selection) => ({
+              requested: selection,
+              effective: selection === 'auto' ? 'high' : selection,
+              source: 'command',
+              disposition: selection === 'auto' ? 'model-default' : 'applied',
+              modelDefault: 'high',
+            }),
+          },
+        }),
+      },
+    });
+
+    const result = await executeEffortCommand(host, 'low');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Effort: Low');
+    expect(result.data).toMatchObject({
+      effort: { requested: 'low', effective: 'low', source: 'command', disposition: 'applied' },
+    });
+    expect(applyModelOptions).not.toHaveBeenCalled();
+    expect(writeSettings).toHaveBeenCalledWith({ theme: 'brief', effort: 'low' });
+  });
+
+  it('reports the current value without changing it when headless selection has no argument', async () => {
+    const applyModelOptions = vi.fn();
+    const host = createTestCommandHost({ session: { applyModelOptions } });
+
+    const result = await executeEffortCommand(host, '');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Effort: High');
+    expect(applyModelOptions).not.toHaveBeenCalled();
+  });
+
+  it('reports an unadapted auto selection without treating auto as a concrete effective tier', async () => {
+    const host = createTestCommandHost({
+      session: { getModelEffort: () => 'auto' },
+    });
+
+    const result = await executeEffortCommand(host, '');
+
+    expect(result.data).toMatchObject({
+      effort: { requested: 'auto', effective: 'high', disposition: 'model-default' },
+    });
+  });
+
+  it('removes a persisted explicit value when auto is selected', async () => {
+    const writeSettings = vi.fn();
+    const host = createTestCommandHost({
+      overrides: {
+        getCommandHostAdapters: () => ({
+          settings: { read: () => ({ effort: 'low', theme: 'brief' }), write: writeSettings },
+          effort: {
+            getResolution: () => ({
+              requested: 'low',
+              effective: 'low',
+              source: 'settings',
+              disposition: 'applied',
+              modelDefault: 'high',
+            }),
+            apply: async () => ({
+              requested: 'auto',
+              effective: 'high',
+              source: 'command',
+              disposition: 'model-default',
+              modelDefault: 'high',
+            }),
+          },
+        }),
+      },
+    });
+
+    await executeEffortCommand(host, 'auto');
+
+    expect(writeSettings).toHaveBeenCalledWith({ theme: 'brief' });
+  });
+
+  it('preserves auto in the session when no effort adapter is installed', async () => {
+    const applyModelOptions = vi.fn();
+    const host = createTestCommandHost({ session: { applyModelOptions } });
+
+    const result = await executeEffortCommand(host, 'auto');
+
+    expect(result.success).toBe(true);
+    expect(applyModelOptions).toHaveBeenCalledWith({ effort: 'auto' });
+  });
+
+  it('leaves the live value and settings unchanged when the picker is cancelled', async () => {
+    const applyModelOptions = vi.fn();
+    const writeSettings = vi.fn();
+    const host = createTestCommandHost({
+      session: { applyModelOptions },
+      overrides: {
+        getUserInteraction: () => ({ ask: async () => ({ type: 'cancelled' }) }),
+        getCommandHostAdapters: () => ({
+          settings: { read: () => ({ effort: 'medium' }), write: writeSettings },
+          effort: {
+            getResolution: () => ({
+              requested: 'medium',
+              effective: 'medium',
+              source: 'settings',
+              disposition: 'applied',
+              modelDefault: 'high',
+            }),
+            apply: vi.fn(),
+          },
+        }),
+      },
+    });
+
+    const result = await executeEffortCommand(host, '');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Effort: Medium');
+    expect(applyModelOptions).not.toHaveBeenCalled();
+    expect(writeSettings).not.toHaveBeenCalled();
+  });
+
+  it('#3282 §2: uses the full plain word for xhigh, not the internal id', async () => {
+    const host = createTestCommandHost({
+      overrides: {
+        getCommandHostAdapters: () => ({
+          settings: { read: () => ({}), write: vi.fn() },
+          effort: {
+            getResolution: () => ({
+              requested: 'auto',
+              effective: 'high',
+              source: 'model-default',
+              disposition: 'model-default',
+              modelDefault: 'high',
+            }),
+            apply: async (selection) => ({
+              requested: selection,
+              effective: selection === 'auto' ? 'high' : selection,
+              source: 'command',
+              disposition: 'applied',
+              modelDefault: 'high',
+            }),
+          },
+        }),
+      },
+    });
+
+    const result = await executeEffortCommand(host, 'xhigh');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Effort: Extra high');
+  });
+});