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

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 CLI-067 contract `robota diagnose`
+ * 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

@@ -6,17 +6,25 @@
  * 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, mkdtempSync, writeFileSync } from 'node:fs';
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+  realpathSync,
+} from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 
-import { afterEach, describe, expect, it } from 'vitest';
+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-transport';
+import type { ITerminalHandoff } from '@robota-sdk/agent-interface-session';
 
 const TEST_TIMEOUT = 20_000;
 
@@ -31,32 +39,30 @@ function fakeHandoff(canHandoff: boolean): ITerminalHandoff {
 
 /** Write a fake `$EDITOR`: a script that writes `content` into the file it is given as $1. */
 function installFakeEditor(content: string): string {
-  const dir = mkdtempSync(join(tmpdir(), 'robota-fake-editor-'));
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'robota-fake-editor-')));
   const script = join(dir, 'fake-editor.sh');
-  writeFileSync(script, `#!/bin/sh\nprintf '%s' '${content}' > "$1"\n`, 'utf8');
+  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;
 }
 
-const origEditor = process.env.EDITOR;
-const origVisual = process.env.VISUAL;
-
 let h: ScriptedSessionHarness | undefined;
 afterEach(async () => {
   await h?.dispose();
   h = undefined;
-  if (origEditor === undefined) delete process.env.EDITOR;
-  else process.env.EDITOR = origEditor;
-  if (origVisual === undefined) delete process.env.VISUAL;
-  else process.env.VISUAL = origVisual;
+  vi.unstubAllEnvs();
 });
 
 describe('/editor command (framework functional)', () => {
   it(
     'opens the editor via the handoff and returns the saved text',
     async () => {
-      delete process.env.VISUAL;
-      process.env.EDITOR = installFakeEditor('composed in editor');
+      vi.stubEnv('VISUAL', undefined);
+      vi.stubEnv('EDITOR', installFakeEditor('composed in editor'));
       h = scriptedSession({
         turns: [{ text: 'unused' }],
         terminalHandoff: fakeHandoff(true),
@@ -72,10 +78,37 @@ describe('/editor command (framework functional)', () => {
     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 () => {
-      process.env.EDITOR = installFakeEditor('unused');
+      vi.stubEnv('EDITOR', installFakeEditor('unused'));
       h = scriptedSession({
         turns: [{ text: 'unused' }],
         commandModules: [createEditorCommandModule()],

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

@@ -4,7 +4,7 @@
 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-transport';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
 
 export function createEditorCommandEntry(): ICommand {
   return {
@@ -12,11 +12,12 @@ export function createEditorCommandEntry(): ICommand {
     displayName: 'Editor',
     description: EDITOR_COMMAND_DESCRIPTION,
     source: 'editor',
+    // User-only: opens the user's terminal editor; UI-only.
     modelInvocable: false,
   };
 }
 
-function createEditorSystemCommand(): ISystemCommand {
+function createEditorSystemCommand(temporaryDirectoryPrefix?: string): ISystemCommand {
   const entry = createEditorCommandEntry();
   return {
     name: entry.name,
@@ -26,7 +27,7 @@ function createEditorSystemCommand(): ISystemCommand {
     userInvocable: true,
     modelInvocable: false,
     lifecycle: 'inline',
-    execute: executeEditorCommand,
+    execute: (context, args) => executeEditorCommand(context, args, temporaryDirectoryPrefix),
   };
 }
 
@@ -38,10 +39,10 @@ export class EditorCommandSource implements ICommandSource {
   }
 }
 
-export function createEditorCommandModule(): ICommandModule {
+export function createEditorCommandModule(temporaryDirectoryPrefix?: string): ICommandModule {
   return {
     name: 'agent-command-editor',
     commandSources: [new EditorCommandSource()],
-    systemCommands: [createEditorSystemCommand()],
+    systemCommands: [createEditorSystemCommand(temporaryDirectoryPrefix)],
   };
 }

package/src/editor/editor-command.ts

@@ -9,17 +9,22 @@ import { join } from 'node:path';
 import { resolveEditor } from './resolve-editor.js';
 import { spawnInherited } from '../shell/spawn-inherited.js';
 
-import type { ICommandHostContext } from '@robota-sdk/agent-framework';
-import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
+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: ICommandHostContext,
+  context: ICommandHostTerminalHandoff & ICommandHostWorkspace,
   args: string,
+  temporaryDirectoryPrefix: string = DEFAULT_EDITOR_TEMPORARY_DIRECTORY_PREFIX,
 ): Promise<ICommandResult> {
-  if (context.canHandoffTerminal?.() !== true || context.runWithTerminal === undefined) {
+  if (!context.canHandoffTerminal()) {
     return {
       message: 'An editor is unavailable here (no interactive terminal).',
       success: false,
@@ -27,7 +32,7 @@ export async function executeEditorCommand(
   }
 
   const editor = resolveEditor();
-  const dir = mkdtempSync(join(tmpdir(), 'robota-editor-'));
+  const dir = mkdtempSync(join(tmpdir(), temporaryDirectoryPrefix));
   const file = join(dir, 'message.md');
   writeFileSync(file, args ?? '', 'utf8');
 

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,140 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { executeEffortCommand } from './effort-command.js';
+
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+
+describe('/effort', () => {
+  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.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).toContain('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).toContain('effective=medium');
+    expect(applyModelOptions).not.toHaveBeenCalled();
+    expect(writeSettings).not.toHaveBeenCalled();
+  });
+});

package/src/effort/effort-command.ts

@@ -0,0 +1,122 @@
+import { MODEL_EFFORT_VALUES, selectAction } from '@robota-sdk/agent-core';
+import { parseModelEffort, resolveModelEffort } from '@robota-sdk/agent-framework';
+
+import type {
+  ICommandHostAdapterAccess,
+  ICommandHostAdapters,
+  ICommandHostSessionAccess,
+  ICommandHostUserInteraction,
+  ICommandHostWorkspace,
+  IModelEffortResolution,
+  TEffortSelection,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+const EFFORT_SELECTIONS: readonly TEffortSelection[] = ['auto', ...MODEL_EFFORT_VALUES];
+
+function formatEffortMessage(resolution: {
+  requested: TEffortSelection;
+  effective: string;
+  source: string;
+  disposition: string;
+}): string {
+  return `Model effort: requested=${resolution.requested}, effective=${resolution.effective}, source=${resolution.source}, disposition=${resolution.disposition}.`;
+}
+
+async function askForEffort(
+  context: ICommandHostUserInteraction,
+): Promise<TEffortSelection | undefined> {
+  const interaction = context.getUserInteraction();
+  if (interaction === undefined) return undefined;
+  const response = await interaction.ask(
+    selectAction(
+      'effort',
+      'Select model effort',
+      EFFORT_SELECTIONS.map((value) => ({ value, label: value })),
+    ),
+  );
+  const selected = response.type === 'answer' ? response.values[0] : undefined;
+  return parseModelEffort(selected, '/effort');
+}
+
+function readCurrentResolution(
+  context: ICommandHostAdapterAccess & ICommandHostSessionAccess,
+): IModelEffortResolution {
+  const adapter = context.getCommandHostAdapters?.().effort;
+  if (adapter !== undefined) return adapter.getResolution();
+  const selection = context.getSession().getModelEffort();
+  return resolveModelEffort({
+    command: selection,
+    modelDefault: selection === 'auto' ? 'high' : selection,
+  });
+}
+
+function readAdapters(context: ICommandHostAdapterAccess): ICommandHostAdapters {
+  return context.getCommandHostAdapters?.() ?? {};
+}
+
+function persistEffortSelection(
+  context: ICommandHostAdapterAccess,
+  selection: TEffortSelection,
+): void {
+  const settings = readAdapters(context).settings;
+  if (settings === undefined || selection === 'max') return;
+  const current = settings.read();
+  if (selection === 'auto') {
+    const { effort: _effort, ...withoutEffort } = current;
+    settings.write(withoutEffort);
+    return;
+  }
+  settings.write({ ...current, effort: selection });
+}
+
+export async function executeEffortCommand(
+  context: ICommandHostAdapterAccess &
+    ICommandHostSessionAccess &
+    ICommandHostUserInteraction &
+    ICommandHostWorkspace,
+  args: string,
+): Promise<ICommandResult> {
+  let selection: TEffortSelection | undefined;
+  try {
+    selection = parseModelEffort(args.trim() || undefined, '/effort');
+    if (selection === undefined) selection = await askForEffort(context);
+  } catch (error) {
+    return { message: error instanceof Error ? error.message : String(error), success: false };
+  }
+
+  const current = readCurrentResolution(context);
+  if (selection === undefined) {
+    return {
+      message: formatEffortMessage(current),
+      success: true,
+      data: { effort: current },
+    };
+  }
+
+  const adapter = readAdapters(context).effort;
+  let resolution;
+  try {
+    resolution =
+      adapter === undefined
+        ? resolveModelEffort({ command: selection, modelDefault: current.effective })
+        : await adapter.apply(selection, context.getSession());
+    if (adapter === undefined) {
+      await context.getSession().applyModelOptions({ effort: selection });
+    }
+    if (context.getCommandInvocationSource() === 'user') {
+      persistEffortSelection(context, selection);
+    }
+  } catch (error) {
+    return {
+      message: `Model effort was not applied: ${error instanceof Error ? error.message : String(error)}`,
+      success: false,
+    };
+  }
+
+  return {
+    message: formatEffortMessage(resolution),
+    success: true,
+    data: { effort: resolution },
+  };
+}

package/src/effort/index.ts

@@ -0,0 +1,6 @@
+export {
+  createEffortCommandEntry,
+  createEffortCommandModule,
+  EffortCommandSource,
+} from './effort-command-module.js';
+export { executeEffortCommand } from './effort-command.js';