@robota-sdk/agent-command 3.0.0-beta.82 → 3.0.0-beta.84

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

@@ -43,10 +43,13 @@ const MONITOR_MODEL_DESCRIPTION =
   'The command is allowed, refused or asked about by the same permission rules as a shell tool ' +
   'call. Returns the monitor task id, or a refusal naming what the user must allow.';
 const LOOP_MODEL_DESCRIPTION =
-  'Repeat a prompt on a fixed cadence (`<N><s|m|h|d> [prompt]`) or self-paced (bare or prompt ' +
-  'only: each iteration chooses its next delay or stops). Use it when the user asks for recurring ' +
-  'work in this session. `list` shows active loops; `stop <id>` ends one. Returns the loop id and ' +
-  'its next fire time, or the loop list.';
+  'Repeat a prompt on a fixed cadence (`<N><s|m|h|d> <prompt>`) or self-paced (`<prompt>`: each ' +
+  'iteration chooses its next delay or stops). Use it when the user asks for recurring work in ' +
+  'this session, and always give your own prompt: any form that would fall back to the host\'s ' +
+  'default maintenance prompt — bare `/loop` or an interval alone (`<N><s|m|h|d>`) — needs a ' +
+  'person to confirm it and is always refused for you, whether or not one is attached. `list` ' +
+  'shows active loops; `stop <id>` ends one, even mid-turn. Returns the loop id and its next fire ' +
+  'time, the loop list, or a refusal naming the command to suggest.';
 
 export function createScheduleCommandEntry(): ICommand {
   return {
@@ -154,6 +157,7 @@ function createLoopSystemCommand(options: ILoopCommandOptions): ISystemCommand {
         (taskId, reason) => context.cancelBackgroundTask(taskId, reason),
         args,
         options,
+        { ui: context.getUserInteraction(), source: context.getCommandInvocationSource() },
       ),
   };
 }

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

@@ -5,9 +5,9 @@ export function createSettingsCommandEntry(): ICommand {
   return {
     name: 'settings',
     displayName: 'Settings',
-    description: 'Open transport settings — enable/disable transports and configure options',
+    description: 'Open settings — language, output style, preset, permissions and more',
     source: 'settings',
-    // User-only: transport settings screen; UI-only.
+    // User-only: opens a screen; nothing here is a model action.
     modelInvocable: false,
   };
 }

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

@@ -14,6 +14,9 @@ export function createShellCommandEntry(): ICommand {
     source: 'shell',
     // User-only: the user's own shell passthrough; the model has its permission-gated shell tool.
     modelInvocable: false,
+    // It takes over the terminal the user sits at, so that terminal runs it, even when attached.
+    runner: 'client',
+    surfaces: ['terminal'],
   };
 }
 
@@ -26,6 +29,8 @@ function createShellSystemCommand(executable?: string): ISystemCommand {
     requiresPermission: true,
     userInvocable: true,
     modelInvocable: false,
+    runner: entry.runner,
+    surfaces: entry.surfaces,
     lifecycle: 'inline',
     execute: (context, args) => executeShellCommand(context, args, executable),
   };

package/src/terminal-client/__tests__/terminal-client-commands.test.ts

@@ -0,0 +1,216 @@
+/**
+ * #3189 — the commands a terminal attached to a workspace daemon runs in its own process.
+ *
+ * The attached terminal routes by this set, not by the daemon's catalog, so the set must name exactly
+ * the commands the default assembly marks `runner: 'client'` — a command in one list and not the
+ * other would either run on the daemon or never run at all. And each client command must answer as
+ * the in-process command does, because it is the same command running somewhere else.
+ */
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterAll, describe, expect, it, vi } from 'vitest';
+
+import { createDefaultCommandModules } from '../../default/index.js';
+import { createEditorCommandModule } from '../../editor/index.js';
+import { createKeybindingsCommandModule } from '../../keybindings/index.js';
+import { createShellCommandModule } from '../../shell/index.js';
+import { createThemeCommandModule } from '../../theme/index.js';
+import { createTerminalClientCommands } from '../terminal-client-commands.js';
+
+import type { ITerminalClientCommand } from '../terminal-client-commands.js';
+import type { IProviderDefinition } from '@robota-sdk/agent-core';
+import type {
+  ICommandHostContext,
+  ICommandHostTerminalHandoff,
+  ICommandHostWorkspace,
+  ICommandModule,
+  IProviderCommandSettingsAdapter,
+  TProviderSettingsDocument,
+} from '@robota-sdk/agent-framework';
+import type {
+  IThemeCatalogueEntry,
+  IThemeCataloguePort,
+} from '@robota-sdk/agent-interface-command';
+
+/** User-local storage lives in a private per-run directory, never a fixed name under /tmp. */
+const USER_LOCAL_STORAGE_ROOT = mkdtempSync(join(tmpdir(), 'robota-test-'));
+afterAll(() => rmSync(USER_LOCAL_STORAGE_ROOT, { recursive: true, force: true }));
+
+const providerDefinitions: readonly IProviderDefinition[] = [];
+const providerSettingsAdapter: IProviderCommandSettingsAdapter = {
+  readMergedSettings: () => ({}) as TProviderSettingsDocument,
+  readTargetSettings: () => ({}) as TProviderSettingsDocument,
+  writeTargetSettings: () => undefined,
+};
+
+const THEMES: IThemeCatalogueEntry[] = [
+  { id: 'dark', name: 'Dark', appearance: 'dark', source: 'built-in' },
+  { id: 'light', name: 'Light', appearance: 'light', source: 'built-in' },
+];
+const themeCatalogue: IThemeCataloguePort = {
+  listThemes: () => THEMES,
+  getTheme: (id) => THEMES.find((theme) => theme.id === id),
+  getAppearance: () => ({
+    settings: { theme: 'dark', syntaxHighlighting: true, reducedMotion: false },
+  }),
+};
+
+function allPortsGiven(): readonly ITerminalClientCommand[] {
+  return createTerminalClientCommands({
+    keybindingsFile: { ensureFile: async () => '/tmp/keybindings.json' },
+    themeCatalogue,
+  });
+}
+
+function find(commands: readonly ITerminalClientCommand[], name: string): ITerminalClientCommand {
+  const command = commands.find((candidate) => candidate.name === name);
+  if (!command) throw new Error(`no terminal client command "${name}"`);
+  return command;
+}
+
+/** A terminal the command cannot take over: a host with no interactive TTY. */
+function hostWithoutTerminal(): ICommandHostTerminalHandoff & ICommandHostWorkspace {
+  return {
+    canHandoffTerminal: () => false,
+    runWithTerminal: vi.fn(async () => {
+      throw new Error('a refused handoff must not be attempted');
+    }),
+    getCwd: () => '/tmp',
+    getCommandInvocationSource: () => 'user',
+  };
+}
+
+/** What the in-process command answers for the same host and arguments. */
+async function inProcess(module: ICommandModule, host: unknown, args: string) {
+  const command = module.systemCommands?.[0];
+  if (!command) throw new Error(`module ${module.name} has no command`);
+  return command.execute(host as ICommandHostContext, args);
+}
+
+describe('createTerminalClientCommands (#3189)', () => {
+  it('names exactly the commands the default assembly marks as client-run', () => {
+    const { modules } = createDefaultCommandModules({
+      cwd: '/tmp',
+      userLocalStorageRoot: USER_LOCAL_STORAGE_ROOT,
+      providerDefinitions,
+      providerSettingsAdapter,
+    });
+    const clientRun = modules
+      .flatMap((module) => module.systemCommands ?? [])
+      .filter((command) => command.runner === 'client')
+      .map((command) => command.name)
+      .sort();
+
+    expect(clientRun.length).toBeGreaterThan(0);
+    expect(
+      allPortsGiven()
+        .map((command) => command.name)
+        .sort(),
+    ).toEqual(clientRun);
+  });
+
+  it('leaves out a client command whose module the selection disables, as the default assembly does', () => {
+    const selection = { disabledCommandModules: ['agent-command-shell'] };
+    const { modules } = createDefaultCommandModules({
+      cwd: '/tmp',
+      userLocalStorageRoot: USER_LOCAL_STORAGE_ROOT,
+      providerDefinitions,
+      providerSettingsAdapter,
+      ...selection,
+    });
+    const clientRun = modules
+      .flatMap((module) => module.systemCommands ?? [])
+      .filter((command) => command.runner === 'client')
+      .map((command) => command.name)
+      .sort();
+
+    const names = createTerminalClientCommands({ themeCatalogue, ...selection })
+      .map((command) => command.name)
+      .sort();
+
+    expect(names).not.toContain('shell');
+    expect(names).toEqual(clientRun);
+  });
+
+  it('keeps only the enabled client modules, and a disabled name wins over an enabled one', () => {
+    const names = createTerminalClientCommands({
+      enabledCommandModules: ['agent-command-theme', 'agent-command-editor', 'agent-command-help'],
+      disabledCommandModules: ['agent-command-editor'],
+    }).map((command) => command.name);
+
+    expect(names).toEqual(['theme']);
+  });
+
+  it('with no selection, offers all four client commands', () => {
+    expect(
+      createTerminalClientCommands({})
+        .map((command) => command.name)
+        .sort(),
+    ).toEqual(['editor', 'keybindings', 'shell', 'theme']);
+  });
+
+  it('/shell refuses a host that cannot hand off the terminal exactly as the in-process command does', async () => {
+    const host = hostWithoutTerminal();
+
+    const client = await find(allPortsGiven(), 'shell').execute(host, 'ls');
+
+    expect(client).toEqual(await inProcess(createShellCommandModule(), host, 'ls'));
+    expect(client.success).toBe(false);
+    expect(host.runWithTerminal).not.toHaveBeenCalled();
+  });
+
+  it('/editor and /keybindings refuse a host without a terminal as their in-process commands do', async () => {
+    const keybindingsFile = { ensureFile: vi.fn(async () => '/tmp/keybindings.json') };
+    const commands = createTerminalClientCommands({ keybindingsFile, themeCatalogue });
+
+    const editorHost = hostWithoutTerminal();
+    const editor = await find(commands, 'editor').execute(editorHost, 'draft');
+    expect(editor).toEqual(await inProcess(createEditorCommandModule(), editorHost, 'draft'));
+    expect(editor.success).toBe(false);
+
+    const keybindingsHost = hostWithoutTerminal();
+    const keybindings = await find(commands, 'keybindings').execute(keybindingsHost, '');
+    expect(keybindings).toEqual(
+      await inProcess(createKeybindingsCommandModule(keybindingsFile), keybindingsHost, ''),
+    );
+    expect(keybindings.success).toBe(false);
+    expect(keybindingsFile.ensureFile).not.toHaveBeenCalled();
+  });
+
+  it('/theme with no arguments asks the terminal to open its theme picker', async () => {
+    const result = await find(allPortsGiven(), 'theme').execute(hostWithoutTerminal(), '');
+
+    expect(result).toMatchObject({ success: true, uiIntents: [{ type: 'show-theme-picker' }] });
+    expect(result.hostActions).toBeUndefined();
+  });
+
+  it('/theme with a known id returns one appearance settings patch for the terminal to write', async () => {
+    const result = await find(allPortsGiven(), 'theme').execute(hostWithoutTerminal(), 'light');
+
+    expect(result.success).toBe(true);
+    expect(result.hostActions).toEqual([
+      { type: 'appearance-settings-patch', patch: { theme: 'light' } },
+    ]);
+    expect(result).toEqual(await inProcess(createThemeCommandModule(themeCatalogue), {}, 'light'));
+  });
+
+  it('without their ports, /keybindings and /theme still run on the terminal and answer as in-process', async () => {
+    const commands = createTerminalClientCommands({});
+    // The set does not shrink: a command missing from it would be sent to the daemon instead.
+    expect(commands.map((command) => command.name).sort()).toEqual(
+      allPortsGiven()
+        .map((command) => command.name)
+        .sort(),
+    );
+
+    const host = hostWithoutTerminal();
+    expect(await find(commands, 'keybindings').execute(host, '')).toEqual(
+      await inProcess(createKeybindingsCommandModule(undefined), host, ''),
+    );
+    expect(await find(commands, 'theme').execute(host, 'light')).toEqual(
+      await inProcess(createThemeCommandModule(undefined), host, 'light'),
+    );
+  });
+});

package/src/terminal-client/index.ts

@@ -0,0 +1,5 @@
+export {
+  createTerminalClientCommands,
+  type ITerminalClientCommand,
+  type ITerminalClientCommandOptions,
+} from './terminal-client-commands.js';

package/src/terminal-client/terminal-client-commands.ts

@@ -0,0 +1,109 @@
+/**
+ * #3189: the commands that belong to the terminal the user sits at — the ones the default assembly
+ * marks `runner: 'client'`. A terminal attached to a workspace daemon runs these in its own process,
+ * on its own terminal and working directory, and sends nothing to the daemon.
+ *
+ * Each one is the in-process command's own execute function, so an attached terminal answers exactly
+ * as a standalone one does; only where it runs changes.
+ */
+import { selectCommandModules } from '@robota-sdk/agent-framework';
+
+import { createEditorCommandModule } from '../editor/editor-command-module.js';
+import { executeEditorCommand } from '../editor/editor-command.js';
+import {
+  createKeybindingsCommandModule,
+  executeKeybindingsCommand,
+} from '../keybindings/keybindings-command-module.js';
+import { createShellCommandModule } from '../shell/shell-command-module.js';
+import { executeShellCommand } from '../shell/shell-command.js';
+import { createThemeCommandModule, executeThemeCommand } from '../theme/theme-command-module.js';
+
+import type { IKeybindingsFilePort } from '../keybindings/keybindings-command-module.js';
+import type {
+  ICommandHostTerminalHandoff,
+  ICommandHostWorkspace,
+  ICommandModule,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult, IThemeCataloguePort } from '@robota-sdk/agent-interface-command';
+
+/** A command the terminal runs itself, with the terminal's own handoff and working directory. */
+export interface ITerminalClientCommand {
+  readonly name: string;
+  execute(
+    host: ICommandHostTerminalHandoff & ICommandHostWorkspace,
+    args: string,
+  ): ICommandResult | Promise<ICommandResult>;
+}
+
+/** The terminal's own capabilities — the same ones its in-process command modules are given. */
+export interface ITerminalClientCommandOptions {
+  /** The shell `/shell` runs; absent → the platform shell, as for the in-process command. */
+  readonly shellExecutable?: string;
+  /** Product-owned prefix for `/editor`'s temporary directory; absent → the command's default. */
+  readonly editorTemporaryDirectoryPrefix?: string;
+  /** Absent → `/keybindings` answers where key bindings live, as the in-process command does. */
+  readonly keybindingsFile?: IKeybindingsFilePort;
+  /** Absent → `/theme` answers where themes live, as the in-process command does. */
+  readonly themeCatalogue?: IThemeCataloguePort;
+  /**
+   * The same module selection the default assembly is given (`agent-command-shell`, …): a module it
+   * leaves out is left out here too, so an attached terminal offers no command a standalone one
+   * would not. Absent → every client-run module.
+   */
+  readonly enabledCommandModules?: readonly string[];
+  /** Applied after `enabledCommandModules`, as in the default assembly (deny > allow). */
+  readonly disabledCommandModules?: readonly string[];
+}
+
+type TClientExecute = ITerminalClientCommand['execute'];
+
+/**
+ * Every client-run command the module selection keeps, whether or not its port is given. The set
+ * shrinks only with the selection, never with a missing port: the attached terminal routes by it, so
+ * a selected command left out would run on the daemon instead — and without its port the command
+ * still answers as its in-process twin does.
+ */
+export function createTerminalClientCommands(
+  options: ITerminalClientCommandOptions,
+): readonly ITerminalClientCommand[] {
+  const {
+    shellExecutable,
+    editorTemporaryDirectoryPrefix,
+    keybindingsFile,
+    themeCatalogue,
+    enabledCommandModules,
+    disabledCommandModules,
+  } = options;
+  // Each client command is paired with its in-process module, so selection matches by the module's
+  // own name and the command keeps that module's command name.
+  const candidates: ReadonlyArray<readonly [ICommandModule, TClientExecute]> = [
+    [
+      createShellCommandModule(shellExecutable),
+      (host, args) => executeShellCommand(host, args, shellExecutable),
+    ],
+    [
+      createEditorCommandModule(editorTemporaryDirectoryPrefix),
+      (host, args) => executeEditorCommand(host, args, editorTemporaryDirectoryPrefix),
+    ],
+    [
+      createKeybindingsCommandModule(keybindingsFile),
+      (host) => executeKeybindingsCommand(keybindingsFile, host),
+    ],
+    [
+      createThemeCommandModule(themeCatalogue),
+      (_host, args) => executeThemeCommand(themeCatalogue, args),
+    ],
+  ];
+  const selected = new Set(
+    selectCommandModules(
+      candidates.map(([module]) => module),
+      enabledCommandModules,
+      disabledCommandModules,
+    ),
+  );
+  return candidates
+    .filter(([module]) => selected.has(module))
+    .flatMap(([module, execute]) =>
+      (module.systemCommands ?? []).map((command) => ({ name: command.name, execute })),
+    );
+}

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

@@ -73,7 +73,7 @@ describe('/theme without a catalogue (SCREEN-2002 TC-09)', () => {
     const result = executeThemeCommand(undefined, 'light');
 
     expect(result.success).toBe(false);
-    expect(result.message).toBe('Themes are not available in this environment.');
+    expect(result.message).toMatch(/Run \/theme in the robota terminal/);
     expect(result.hostActions).toBeUndefined();
   });
 });

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

@@ -16,7 +16,10 @@ const THEME_DESCRIPTION =
   'List, preview or switch the terminal colour theme, and toggle syntax highlighting and motion';
 const THEME_ARGUMENT_HINT = 'list | <theme-id> | syntax on|off | motion on|off';
 
-const THEME_UNAVAILABLE = 'Themes are not available in this environment.';
+// A host without a terminal (the desktop app's sidecar) still answers, so the command is never
+// "unknown" there — it says where themes live instead.
+const THEME_UNAVAILABLE =
+  'Themes belong to the robota terminal, and this surface has none. Run /theme in the robota terminal.';
 
 function formatToggle(value: boolean): string {
   return value ? 'on' : 'off';
@@ -179,6 +182,9 @@ export function createThemeCommandEntry(): ICommand {
     userInvocable: true,
     // User-only: UI preference.
     modelInvocable: false,
+    // Themes belong to the terminal the user sits at, so that terminal runs it, even when attached.
+    runner: 'client',
+    surfaces: ['terminal'],
   };
 }
 
@@ -190,7 +196,9 @@ export class ThemeCommandSource implements ICommandSource {
   }
 }
 
-export function createThemeCommandModule(catalogue: IThemeCataloguePort): ICommandModule {
+export function createThemeCommandModule(
+  catalogue: IThemeCataloguePort | undefined,
+): ICommandModule {
   const entry = createThemeCommandEntry();
   const command: ISystemCommand = {
     name: entry.name,
@@ -200,6 +208,8 @@ export function createThemeCommandModule(catalogue: IThemeCataloguePort): IComma
     requiresPermission: false,
     userInvocable: true,
     modelInvocable: false,
+    runner: entry.runner,
+    surfaces: entry.surfaces,
     lifecycle: 'inline',
     execute: (_context, args) => executeThemeCommand(catalogue, args),
   };

package/src/user-local/__tests__/user-local-command.test.ts

@@ -21,8 +21,8 @@ afterEach(async () => {
 });
 
 describe('user-local command', () => {
-  it('does not advertise a specific product from the neutral command entry', () => {
-    const module = createUserLocalCommandModule('/tmp/selected-storage');
+  it('does not advertise a specific product from the neutral command entry', async () => {
+    const module = createUserLocalCommandModule(await createTempRoot('robota-selected-storage-'));
     expect(module.commandSources?.[0]?.getCommands()[0]?.description).not.toMatch(/Robota/i);
   });
 

package/src/git/__tests__/git-diff.test.ts

@@ -1,125 +0,0 @@
-/** BEHAVIOR-2437 TC-02 — `/git diff`: the closed grammar and the exact argv sequence per branch. */
-import { describe, expect, it } from 'vitest';
-
-import { executeGitDiff, gitDiffArgv, parseGitDiffArgs, GIT_DIFF_USAGE } from '../git-diff.js';
-
-import { exited, fakeGitPort } from './fake-git-port.js';
-
-const revParse = (rev: string): string =>
-  `rev-parse --verify --quiet --end-of-options ${rev}^{commit}`;
-
-describe('parseGitDiffArgs', () => {
-  it('accepts the four forms and the path list', () => {
-    expect(parseGitDiffArgs([])).toEqual({
-      ok: true,
-      args: { target: { kind: 'worktree' }, paths: [] },
-    });
-    expect(parseGitDiffArgs(['--staged'])).toMatchObject({
-      ok: true,
-      args: { target: { kind: 'staged' } },
-    });
-    expect(parseGitDiffArgs(['HEAD~1'])).toMatchObject({
-      ok: true,
-      args: { target: { kind: 'revision', revision: 'HEAD~1' } },
-    });
-    expect(parseGitDiffArgs(['main..feature', '--', 'p', 'q'])).toEqual({
-      ok: true,
-      args: { target: { kind: 'range', from: 'main', to: 'feature' }, paths: ['p', 'q'] },
-    });
-  });
-
-  it('refuses every other dash token with the usage line', () => {
-    for (const token of ['--output=/tmp/x', '-p', '--cached', '-U3']) {
-      const parsed = parseGitDiffArgs([token]);
-      expect(parsed.ok).toBe(false);
-      if (!parsed.ok) {
-        expect(parsed.message).toContain(token);
-        expect(parsed.message).toContain(GIT_DIFF_USAGE);
-      }
-    }
-  });
-
-  it('refuses a malformed range, a bare `--`, and extra positionals', () => {
-    expect(parseGitDiffArgs(['a..'])).toMatchObject({ ok: false });
-    expect(parseGitDiffArgs(['a...b'])).toMatchObject({ ok: false });
-    expect(parseGitDiffArgs(['--'])).toMatchObject({ ok: false });
-    expect(parseGitDiffArgs(['a', 'b'])).toMatchObject({ ok: false });
-  });
-});
-
-describe('gitDiffArgv', () => {
-  it('places --end-of-options before revisions and -- before paths', () => {
-    expect(gitDiffArgv({ target: { kind: 'worktree' }, paths: [] })).toEqual(['diff']);
-    expect(gitDiffArgv({ target: { kind: 'staged' }, paths: [] })).toEqual(['diff', '--staged']);
-    expect(gitDiffArgv({ target: { kind: 'revision', revision: '-p' }, paths: ['-p'] })).toEqual([
-      'diff',
-      '--end-of-options',
-      '-p',
-      '--',
-      '-p',
-    ]);
-    expect(
-      gitDiffArgv({ target: { kind: 'range', from: 'a', to: 'b' }, paths: ['p', 'q'] }),
-    ).toEqual(['diff', '--end-of-options', 'a..b', '--', 'p', 'q']);
-  });
-});
-
-describe('executeGitDiff', () => {
-  it('bare and --staged run one diff call each', async () => {
-    const port = fakeGitPort({ diff: exited('+x\n'), 'diff --staged': exited('') });
-    expect((await executeGitDiff(port, '/r', '')).message).toBe('+x');
-    expect((await executeGitDiff(port, '/r', '--staged')).message).toBe('No differences.');
-    expect(port.calls).toEqual([['diff'], ['diff', '--staged']]);
-  });
-
-  it('verifies one revision, then diffs, with a trailing path list', async () => {
-    const port = fakeGitPort({
-      [revParse('HEAD~1')]: exited('abc\n'),
-      'diff --end-of-options HEAD~1 -- p q': exited('+y\n'),
-    });
-    const result = await executeGitDiff(port, '/r', 'HEAD~1 -- p q');
-    expect(result.success).toBe(true);
-    expect(port.calls).toEqual([
-      ['rev-parse', '--verify', '--quiet', '--end-of-options', 'HEAD~1^{commit}'],
-      ['diff', '--end-of-options', 'HEAD~1', '--', 'p', 'q'],
-    ]);
-  });
-
-  it('verifies both ends of a range before one diff call', async () => {
-    const port = fakeGitPort({
-      [revParse('a')]: exited('1\n'),
-      [revParse('b')]: exited('2\n'),
-      'diff --end-of-options a..b': exited(''),
-    });
-    await executeGitDiff(port, '/r', 'a..b');
-    expect(port.calls.map((c) => c.join(' '))).toEqual([
-      revParse('a'),
-      revParse('b'),
-      'diff --end-of-options a..b',
-    ]);
-  });
-
-  it('refuses an unknown revision by name with no diff call', async () => {
-    const port = fakeGitPort({ [revParse('nosuchrev')]: exited('', 1) });
-    const result = await executeGitDiff(port, '/r', 'nosuchrev');
-    expect(result.success).toBe(false);
-    expect(result.message).toContain('nosuchrev');
-    expect(port.calls).toHaveLength(1);
-  });
-
-  it('refuses a flag with the usage line and no call at all', async () => {
-    const port = fakeGitPort({});
-    const result = await executeGitDiff(port, '/r', '--output=/tmp/x');
-    expect(result.success).toBe(false);
-    expect(result.message).toContain('--output=/tmp/x');
-    expect(result.message).toContain('--staged');
-    expect(port.calls).toEqual([]);
-  });
-
-  it('reports a diff failure with git’s stderr', async () => {
-    const port = fakeGitPort({ diff: exited('', 129, 'fatal: bad\n') });
-    const result = await executeGitDiff(port, '/r', '');
-    expect(result.success).toBe(false);
-    expect(result.message).toContain('fatal: bad');
-  });
-});