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

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

@@ -0,0 +1,61 @@
+import { executeForkCommand } from './fork-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+export function createForkCommandEntry(): ICommand {
+  return {
+    name: 'fork',
+    displayName: 'Fork Session',
+    description:
+      'Copy this conversation into a new background session and keep working here. ' +
+      'The fork inherits the whole conversation and the assembled system prompt; it is a copy, ' +
+      'so nothing it does reaches this session and it never merges back.',
+    source: 'fork',
+    // The model does not decide to duplicate the operator's conversation. Forking spends a second
+    // session's budget and creates a second worktree, both of which are the operator's call.
+    // User-only: starts a separate session the user owns and attaches to.
+    modelInvocable: false,
+    argumentHint: '[name] [--same-dir]',
+  };
+}
+
+function createForkSystemCommand(
+  formatResumeCommand?: (sessionId: string) => string,
+): ISystemCommand {
+  const entry = createForkCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    lifecycle: 'inline',
+    ...(entry.argumentHint !== undefined ? { argumentHint: entry.argumentHint } : {}),
+    // `ICommandHostContext` aggregates both role ports `/fork` declares, so the narrowing is the
+    // parameter's own type — no assertion, and a role the command stops satisfying is a build error.
+    execute: (context, args) => executeForkCommand(context, args, formatResumeCommand),
+  };
+}
+
+export class ForkCommandSource implements ICommandSource {
+  readonly name = 'fork';
+
+  getCommands(): ICommand[] {
+    return [createForkCommandEntry()];
+  }
+}
+
+export function createForkCommandModule(
+  formatResumeCommand?: (sessionId: string) => string,
+): ICommandModule {
+  return {
+    name: 'agent-command-fork',
+    commandSources: [new ForkCommandSource()],
+    systemCommands: [createForkSystemCommand(formatResumeCommand)],
+    // A fork is a background agent job resuming a session record; a host with no agent runtime has
+    // neither half, so the command is not offered rather than offered and refused.
+    sessionRequirements: ['runtime'],
+  };
+}

package/src/fork/fork-command.ts

@@ -0,0 +1,162 @@
+/**
+ * `/fork [name] [--same-dir]` (CLI-1994, issue #1994) — copy this conversation into a background
+ * session and keep working here.
+ *
+ * The two halves are deliberately separate calls to two different capabilities, because they are two
+ * different facts. `forkSession` writes a COPY of the live conversation as a new session record: the
+ * messages, the parent's assembled system message, the tool schemas and the transcript, under a
+ * fresh id and a name that is not the parent's. Spawning then starts a background agent job that
+ * carries ONLY that id — the conversation never rides on the request, so it never crosses the
+ * child-process wire (ARCH-044); the child reads the record from the session store, exactly as the
+ * startup `--fork-session` does.
+ *
+ * A fork is a copy, not a branch of one live thing: from the moment the record is written, work in
+ * the fork and work here are two histories that never rejoin. Attaching to the fork later (the
+ * background panel's `attach` control) switches the terminal's VIEW to that session; it does not
+ * merge anything back.
+ */
+
+import type { ICommandHostAgentJobs, ICommandHostSessionAccess } from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+import type { TBackgroundTaskIsolation } from '@robota-sdk/agent-interface-execution';
+
+/** What `/fork` needs from its host: the copy-writer and the job dispatcher. */
+export type TForkCommandContext = ICommandHostSessionAccess & ICommandHostAgentJobs;
+
+/**
+ * The fork runs in its own worktree by DEFAULT.
+ *
+ * A spawned job inherits the parent's cwd, so a fork that keeps working in the same directory writes
+ * over the files the parent is still editing — the "work in it does not affect the original"
+ * property lost through the filesystem rather than through the conversation. `--same-dir` is the
+ * explicit opt-out for a fork that is meant to read and think rather than to edit.
+ */
+const DEFAULT_ISOLATION: TBackgroundTaskIsolation = 'worktree';
+const SAME_DIR_ISOLATION: TBackgroundTaskIsolation = 'none';
+const SAME_DIR_FLAG = '--same-dir';
+
+/** The agent a forked conversation continues under — the general one, since the fork IS the context. */
+const FORK_AGENT_TYPE = 'general-purpose';
+
+/**
+ * The fork's first turn input.
+ *
+ * A fork inherits the parent's whole conversation and its assembled system message, so there is
+ * nothing left to brief it about — this is a minimal continuation cue, deliberately NOT a prompt.
+ * § Solution 5 asked for an empty string; a turn with no user content is rejected by providers, and
+ * one word is the smallest thing that is not — the divergence is recorded in the spec beside it. Anything longer would be this neutral command layer
+ * deciding how a forked agent should behave, which is the product layer's call
+ * (`scan-prompt-prose` is the mechanical form of that rule).
+ */
+const FORK_FIRST_TURN = 'Continue.';
+
+export interface IParsedForkArgs {
+  readonly name: string | undefined;
+  readonly isolation: TBackgroundTaskIsolation;
+}
+
+/** A rejected argument string, kept distinct from a parse so neither can be read as the other. */
+export interface IForkArgsError {
+  readonly error: string;
+}
+
+/**
+ * `--same-dir` may appear anywhere; everything else is the name.
+ *
+ * An unrecognised `--flag` is REFUSED rather than folded into the name: a mistyped `--same-dr` that
+ * became a session called "--same-dr" would silently give the operator a worktree they asked not to
+ * have, and the name is the one field they will later use to find the fork.
+ */
+export function parseForkArgs(args: string): IParsedForkArgs | IForkArgsError {
+  const tokens = args
+    .trim()
+    .split(/\s+/)
+    .filter((token) => token.length > 0);
+  const unknownFlag = tokens.find((token) => token.startsWith('--') && token !== SAME_DIR_FLAG);
+  if (unknownFlag !== undefined) {
+    return { error: `Unknown option: ${unknownFlag}\nUsage: /fork [name] [${SAME_DIR_FLAG}]` };
+  }
+  const nameTokens = tokens.filter((token) => token !== SAME_DIR_FLAG);
+  return {
+    name: nameTokens.length > 0 ? nameTokens.join(' ') : undefined,
+    isolation: tokens.includes(SAME_DIR_FLAG) ? SAME_DIR_ISOLATION : DEFAULT_ISOLATION,
+  };
+}
+
+function formatError<TError>(error: TError): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function describeFork(name: string, taskId: string, isolation: TBackgroundTaskIsolation): string {
+  const where = isolation === SAME_DIR_ISOLATION ? 'in this directory' : 'in its own worktree';
+  return [
+    `Forked this conversation into "${name}" (${taskId}), running ${where}.`,
+    'The fork is a copy: this session keeps going, and the two are separate records.',
+    'See its progress with /background list. Attaching from the background panel points this',
+    "terminal at the copy as it was forked; the fork's own turns stay in its task transcript.",
+  ].join('\n');
+}
+
+/**
+ * The copy is on disk and the job is not. Both facts are reported, because the record is still
+ * resumable by name and an operator told only "failed" would not know that.
+ */
+function describeSpawnFailure(
+  fork: { sessionId: string; name: string },
+  reason: string,
+  formatResumeCommand?: (sessionId: string) => string,
+): string {
+  const resumeHint = formatResumeCommand?.(fork.sessionId);
+  return (
+    `The fork "${fork.name}" was written (${fork.sessionId}) but its background job could not ` +
+    `start: ${reason}\n${resumeHint === undefined ? 'Resume the saved session through your host.' : `Resume it in a new terminal with: ${resumeHint}`}`
+  );
+}
+
+export async function executeForkCommand(
+  context: TForkCommandContext,
+  args = '',
+  formatResumeCommand?: (sessionId: string) => string,
+): Promise<ICommandResult> {
+  const parsed = parseForkArgs(args);
+  if ('error' in parsed) return { message: parsed.error, success: false };
+
+  const jobs = context.getAgentJobCapability();
+  if (!jobs) {
+    return {
+      message: 'This session cannot start background jobs, so it cannot run a fork.',
+      success: false,
+    };
+  }
+
+  // The copy is written FIRST, and a failure here is reported without spawning: a job that resumes a
+  // record which was never written is a child that fails on its own far side, out of the operator's
+  // sight.
+  let fork: { sessionId: string; name: string };
+  try {
+    fork = await context.forkSession(parsed.name !== undefined ? { name: parsed.name } : {});
+  } catch (error) {
+    return { message: `Could not fork this session: ${formatError(error)}`, success: false };
+  }
+
+  try {
+    const state = await jobs.spawnAgentJob({
+      agentType: FORK_AGENT_TYPE,
+      label: fork.name,
+      mode: 'background',
+      prompt: FORK_FIRST_TURN,
+      isolation: parsed.isolation,
+      resumeSessionId: fork.sessionId,
+    });
+    return {
+      message: describeFork(fork.name, state.id, parsed.isolation),
+      success: true,
+      data: { sessionId: fork.sessionId, name: fork.name, taskId: state.id },
+    };
+  } catch (error) {
+    return {
+      message: describeSpawnFailure(fork, formatError(error), formatResumeCommand),
+      success: false,
+    };
+  }
+}

package/src/fork/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Only the module factory leaves this directory — the same rule the sibling `src/peers/` follows.
+ *
+ * `executeForkCommand`, `parseForkArgs` and `ForkCommandSource` are how the module is BUILT, not how
+ * it is used: `/fork` is registered by default, so nothing outside constructs one. Exporting them
+ * would add entries to this package's frozen undocumented-surface count for a reach nobody asked for.
+ */
+export { createForkCommandModule } from './fork-command-module.js';

package/src/git/__tests__/fake-git-port.ts

@@ -0,0 +1,35 @@
+/**
+ * A scripted `IGitProcessPort`: answers by argv, records every call, throws on an unscripted one.
+ *
+ * The port and outcome types moved to `@robota-sdk/agent-framework` with the git process module
+ * (#3282 §4c); this double stays here (duplicated, not imported cross-package) because it is a tiny,
+ * self-contained test fixture, the same call `agent-framework`'s own `git/__tests__/fake-git-port.ts`
+ * makes for its side.
+ */
+import type { IGitProcessPort, TGitProcessOutcome } from '@robota-sdk/agent-framework';
+
+export interface IFakeGitPort extends IGitProcessPort {
+  readonly calls: readonly (readonly string[])[];
+}
+
+export function exited(stdout: string, exitCode = 0, stderr = ''): TGitProcessOutcome {
+  return { kind: 'exited', stdout, stderr, exitCode };
+}
+
+export function fakeGitPort(
+  script: Readonly<
+    Record<string, TGitProcessOutcome | ((args: readonly string[]) => TGitProcessOutcome)>
+  >,
+): IFakeGitPort {
+  const calls: (readonly string[])[] = [];
+  return {
+    calls,
+    async run(args) {
+      calls.push([...args]);
+      const key = args.join(' ');
+      const entry = script[key];
+      if (entry === undefined) throw new Error(`unscripted git call: ${key}`);
+      return typeof entry === 'function' ? entry(args) : entry;
+    },
+  };
+}

package/src/git/__tests__/git-command-module.test.ts

@@ -0,0 +1,111 @@
+/** BEHAVIOR-2437 TC-05 — registration, the descriptor, and the verb parse through the real session. */
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterAll, afterEach, describe, expect, it } from 'vitest';
+
+import { scriptedSession, type ScriptedSessionHarness } from '@robota-sdk/agent-framework/testing';
+
+import { createDefaultCommandModules } from '../../default/default-command-modules.js';
+import { createHelpCommandModule } from '../../help/help-command-module.js';
+import {
+  createGitCommandEntry,
+  createGitCommandModule,
+  executeGitCommand,
+} from '../git-command-module.js';
+
+import { exited, fakeGitPort } from './fake-git-port.js';
+
+import type { IProviderDefinition } from '@robota-sdk/agent-core';
+import type {
+  IProviderCommandSettingsAdapter,
+  TProviderSettingsDocument,
+} from '@robota-sdk/agent-framework';
+
+const providerDefinitions: readonly IProviderDefinition[] = [
+  {
+    type: 'anthropic',
+    defaults: { model: 'claude-sonnet-4-6', apiKey: '$ENV:ANTHROPIC_API_KEY' },
+    setupSteps: [{ key: 'apiKey', title: 'anthropic API key', masked: true }],
+    requiresApiKey: true,
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  },
+];
+const providerSettingsAdapter: IProviderCommandSettingsAdapter = {
+  readMergedSettings: () => ({}) as TProviderSettingsDocument,
+  readTargetSettings: () => ({}) as TProviderSettingsDocument,
+  writeTargetSettings: () => undefined,
+};
+/** User-local storage lives in a private per-run directory, never a fixed name under /tmp. */
+const USER_LOCAL_STORAGE_ROOT = mkdtempSync(join(tmpdir(), 'agent-test-test-'));
+afterAll(() => rmSync(USER_LOCAL_STORAGE_ROOT, { recursive: true, force: true }));
+
+const BASE_OPTIONS = { cwd: '/tmp', userLocalStorageRoot: USER_LOCAL_STORAGE_ROOT, providerDefinitions, providerSettingsAdapter } as const;
+
+const STATUS_FIXTURE = '# branch.head main\0? scratch.log\0';
+
+let h: ScriptedSessionHarness | undefined;
+afterEach(async () => {
+  await h?.dispose();
+  h = undefined;
+});
+
+describe('the /git descriptor', () => {
+  it('is host-only, with the three verbs as descriptive subcommands', () => {
+    const entry = createGitCommandEntry();
+    expect(entry.name).toBe('git');
+    expect(entry.modelInvocable).toBe(false);
+    expect(entry.subcommands?.map((s) => s.name)).toEqual(['status', 'diff', 'commit']);
+    const module = createGitCommandModule({ port: fakeGitPort({}) });
+    expect(module.name).toBe('agent-command-git');
+    expect(module.systemCommands?.[0]).toMatchObject({
+      name: 'git',
+      requiresPermission: true,
+      modelInvocable: false,
+      lifecycle: 'blocking',
+    });
+  });
+
+  it('is in the base list, and the name `status` is registered nowhere', () => {
+    const { modules } = createDefaultCommandModules(BASE_OPTIONS);
+    expect(modules.map((m) => m.name)).toContain('agent-command-git');
+    const names = modules.flatMap((m) => (m.systemCommands ?? []).map((c) => c.name));
+    expect(names).toContain('git');
+    expect(names).not.toContain('status');
+  });
+});
+
+describe('executeGitCommand verb parse', () => {
+  const context = { getCwd: () => '/r', getUserInteraction: () => undefined };
+
+  it('routes status, refuses arguments to it, and refuses unknown or missing verbs', async () => {
+    const port = fakeGitPort({ 'status --porcelain=v2 -z --branch': exited(STATUS_FIXTURE) });
+    expect((await executeGitCommand(context, '  status ', port)).message).toContain(
+      'On branch main',
+    );
+    expect((await executeGitCommand(context, 'status extra', port)).success).toBe(false);
+    const unknown = await executeGitCommand(context, 'push', port);
+    expect(unknown.success).toBe(false);
+    expect(unknown.message).toContain('push');
+    expect((await executeGitCommand(context, '', port)).message).toContain('Usage: /git');
+    expect(port.calls).toHaveLength(1);
+  });
+});
+
+describe('/git through the real session', () => {
+  it('/help lists /git, and /git status answers through the injected port', async () => {
+    const port = fakeGitPort({ 'status --porcelain=v2 -z --branch': exited(STATUS_FIXTURE) });
+    h = scriptedSession({
+      turns: [{ text: 'unused' }],
+      commandModules: [createHelpCommandModule(), createGitCommandModule({ port })],
+    });
+    const help = await h.command('help');
+    expect(help?.message).toContain('/git');
+    const status = await h.command('git', 'status');
+    expect(status?.success).toBe(true);
+    expect(status?.message).toContain('untracked (1): scratch.log');
+  });
+});

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

@@ -0,0 +1,185 @@
+/** BEHAVIOR-2437 TC-03 — `/git commit`: every branch of the staged-check → subject → confirm flow. */
+import { describe, expect, it } from 'vitest';
+
+import {
+  executeGitCommit,
+  normalizeCommitSubject,
+  validateConventionalSubject,
+} from '../git-commit.js';
+
+import { exited, fakeGitPort } from './fake-git-port.js';
+
+import type { IActionRequest, IUserInteraction, TActionResponse } from '@robota-sdk/agent-core';
+
+const STAGED = 'diff --cached --quiet';
+const LISTING = 'diff --cached --name-status';
+const STATUS = 'status --porcelain=v2 -z --branch';
+const H = '0000000000000000000000000000000000000000';
+const NOTHING_STAGED_STATUS =
+  `# branch.head main\0` +
+  `1 .M N... 100644 100644 100644 ${H} ${H} notes.txt\0` +
+  `? scratch.log\0`;
+
+function scriptedUi(
+  answer: (request: IActionRequest) => TActionResponse,
+): IUserInteraction & { readonly asked: IActionRequest[] } {
+  const asked: IActionRequest[] = [];
+  return {
+    asked,
+    async ask(request) {
+      asked.push(request);
+      return answer(request);
+    },
+  };
+}
+const yes = (): TActionResponse => ({ type: 'answer', values: ['yes'] });
+const no = (): TActionResponse => ({ type: 'answer', values: ['no'] });
+
+describe('validateConventionalSubject', () => {
+  it('accepts the MUST forms and only warns on the conventions', () => {
+    expect(validateConventionalSubject('feat!: x')).toEqual({ ok: true, warnings: [] });
+    expect(validateConventionalSubject('fix(scope): y')).toEqual({ ok: true, warnings: [] });
+    expect(validateConventionalSubject('feat(a-b)!: z')).toEqual({ ok: true, warnings: [] });
+    const long = validateConventionalSubject(`feat: ${'x'.repeat(80)}`);
+    expect(long.ok).toBe(true);
+    if (long.ok) expect(long.warnings[0]).toContain('72');
+    const odd = validateConventionalSubject('wip: thing.');
+    expect(odd.ok).toBe(true);
+    if (odd.ok) {
+      expect(odd.warnings.some((w) => w.includes('"wip"'))).toBe(true);
+      expect(odd.warnings.some((w) => w.includes('period'))).toBe(true);
+    }
+  });
+
+  it('refuses a MUST-rule violation naming the rule', () => {
+    const noSeparator = validateConventionalSubject('add greeting');
+    expect(noSeparator).toMatchObject({ ok: false });
+    if (!noSeparator.ok) expect(noSeparator.reason).toContain('`: `');
+    expect(validateConventionalSubject('feat: ')).toMatchObject({ ok: false });
+    expect(validateConventionalSubject('feat:')).toMatchObject({ ok: false });
+    expect(validateConventionalSubject('feat scope: x')).toMatchObject({ ok: false });
+    expect(validateConventionalSubject('(scope): x')).toMatchObject({ ok: false });
+    expect(validateConventionalSubject('')).toMatchObject({ ok: false });
+  });
+});
+
+describe('normalizeCommitSubject', () => {
+  it('strips a leading -m and ONE matching pair of outer quotes', () => {
+    expect(normalizeCommitSubject('feat: x')).toBe('feat: x');
+    expect(normalizeCommitSubject('-m feat: x')).toBe('feat: x');
+    expect(normalizeCommitSubject('"feat: x"')).toBe('feat: x');
+    expect(normalizeCommitSubject("'feat: x'")).toBe('feat: x');
+    expect(normalizeCommitSubject('""feat: x""')).toBe('"feat: x"');
+    expect(normalizeCommitSubject('"feat: x')).toBe('"feat: x');
+    expect(normalizeCommitSubject('-m')).toBe('');
+  });
+});
+
+describe('executeGitCommit', () => {
+  it('nothing staged → guidance with the counts, no commit call, no dialog', async () => {
+    const port = fakeGitPort({ [STAGED]: exited('', 0), [STATUS]: exited(NOTHING_STAGED_STATUS) });
+    const ui = scriptedUi(yes);
+    const result = await executeGitCommit(port, '/r', 'feat: nothing to commit', ui);
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Nothing is staged (1 unstaged, 1 untracked)');
+    expect(result.message).toContain('git add');
+    expect(result.message).toContain('/shell git add');
+    expect(ui.asked).toEqual([]);
+    expect(port.calls.map((c) => c[0])).not.toContain('commit');
+  });
+
+  it('a MUST-rule violation is refused before any listing or dialog', async () => {
+    const port = fakeGitPort({ [STAGED]: exited('', 1) });
+    const ui = scriptedUi(yes);
+    const result = await executeGitCommit(port, '/r', 'add greeting', ui);
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('`: `');
+    expect(ui.asked).toEqual([]);
+    expect(port.calls).toEqual([['diff', '--cached', '--quiet']]);
+  });
+
+  it('a refused confirmation → "Commit cancelled." and no commit call', async () => {
+    const port = fakeGitPort({ [STAGED]: exited('', 1), [LISTING]: exited('M\tgreeting.txt\n') });
+    const ui = scriptedUi(no);
+    const result = await executeGitCommit(port, '/r', 'feat: add greeting', ui);
+    expect(result.success).toBe(false);
+    expect(result.message).toBe('Commit cancelled.');
+    expect(ui.asked).toHaveLength(1);
+    expect(ui.asked[0]?.description).toContain('feat: add greeting');
+    expect(ui.asked[0]?.description).toContain('M greeting.txt');
+    expect(port.calls.map((c) => c[0])).not.toContain('commit');
+  });
+
+  it('an absent IUserInteraction is a cancellation, never a commit', async () => {
+    const port = fakeGitPort({ [STAGED]: exited('', 1), [LISTING]: exited('M\tgreeting.txt\n') });
+    const result = await executeGitCommit(port, '/r', 'feat: add greeting', undefined);
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('cancelled');
+    expect(result.message).toContain('confirmation');
+    // Nothing beyond the staged check runs: no listing, no commit.
+    expect(port.calls).toEqual([['diff', '--cached', '--quiet']]);
+  });
+
+  it('a confirmed commit runs exactly commit -m <subject> after the listing, quotes stripped', async () => {
+    const port = fakeGitPort({
+      [STAGED]: exited('', 1),
+      [LISTING]: exited('M\tgreeting.txt\n'),
+      'commit -m feat: add greeting': exited(
+        '[main abc1234] feat: add greeting\n 1 file changed\n',
+      ),
+    });
+    const ui = scriptedUi(yes);
+    const result = await executeGitCommit(port, '/r', '"feat: add greeting"', ui);
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('abc1234');
+    expect(result.message).toContain('feat: add greeting');
+    expect(port.calls).toEqual([
+      ['diff', '--cached', '--quiet'],
+      ['diff', '--cached', '--name-status'],
+      ['commit', '-m', 'feat: add greeting'],
+    ]);
+    expect(port.calls.flat()).not.toContain('-a');
+    expect(port.calls.map((c) => c[0])).not.toContain('add');
+  });
+
+  it('a long subject only warns in the confirmation and still commits', async () => {
+    const subject = `feat: ${'x'.repeat(80)}`;
+    const port = fakeGitPort({
+      [STAGED]: exited('', 1),
+      [LISTING]: exited('A\tnew.txt\n'),
+      [`commit -m ${subject}`]: exited(`[main 1234567] ${subject}\n`),
+    });
+    const ui = scriptedUi(yes);
+    const result = await executeGitCommit(port, '/r', subject, ui);
+    expect(result.success).toBe(true);
+    expect(ui.asked[0]?.description).toContain('Warning:');
+    expect(ui.asked[0]?.description).toContain('72');
+  });
+
+  it('with no inline subject, asks for one as free text and validates the answer', async () => {
+    const port = fakeGitPort({
+      [STAGED]: exited('', 1),
+      [LISTING]: exited('A\tnew.txt\n'),
+      'commit -m fix: typo': exited('[main 1234567] fix: typo\n'),
+    });
+    const ui = scriptedUi((request) =>
+      request.id === 'git-commit-subject'
+        ? { type: 'answer', values: [], text: 'fix: typo' }
+        : yes(),
+    );
+    const result = await executeGitCommit(port, '/r', '', ui);
+    expect(result.success).toBe(true);
+    expect(ui.asked.map((r) => r.id)).toEqual(['git-commit-subject', 'git-commit']);
+  });
+
+  it('a failing commit (hook) reports git’s stderr', async () => {
+    const port = fakeGitPort({
+      [STAGED]: exited('', 1),
+      [LISTING]: exited('A\tnew.txt\n'),
+      'commit -m feat: x': exited('', 1, 'pre-commit hook refused\n'),
+    });
+    const result = await executeGitCommit(port, '/r', 'feat: x', scriptedUi(yes));
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('pre-commit hook refused');
+  });
+});