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

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');
+  });
+});

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

@@ -0,0 +1,125 @@
+/** 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');
+  });
+});

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

@@ -0,0 +1,221 @@
+/**
+ * BEHAVIOR-2437 TC-04 — the seam against a REAL temporary repository: argv-only (metacharacters are
+ * data), exit codes as data, stdin closed (a hook that reads it gets EOF), timeout / abort / missing
+ * executable / oversized output as typed failures, and the hook-nesting environment policy.
+ */
+import { execFileSync } from 'node:child_process';
+import { chmodSync, mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { createGitProcess, gitEnvironment, GIT_ENV_DENYLIST } from '../git-process.js';
+
+const dirs: string[] = [];
+afterEach(() => {
+  for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+function tempDir(prefix: string): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), prefix)));
+  dirs.push(dir);
+  return dir;
+}
+
+/** A hermetic environment: no user/system git config, no inherited hook-nesting variables. */
+function hermeticEnv(extra: Record<string, string> = {}): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { PATH: process.env.PATH, HOME: tempDir('git-home-') };
+  env.GIT_CONFIG_NOSYSTEM = '1';
+  env.GIT_CONFIG_GLOBAL = join(env.HOME ?? '', 'gitconfig');
+  writeFileSync(env.GIT_CONFIG_GLOBAL, '[commit]\n\tgpgsign = false\n');
+  return { ...env, ...extra };
+}
+
+function git(cwd: string, env: NodeJS.ProcessEnv, ...args: string[]): string {
+  return execFileSync('git', args, {
+    cwd,
+    env,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function initRepo(env: NodeJS.ProcessEnv, identity = true): string {
+  const repo = tempDir('git-seam-');
+  git(repo, env, 'init', '-q', '-b', 'main');
+  if (identity) {
+    git(repo, env, 'config', 'user.name', 'Seam Test');
+    git(repo, env, 'config', 'user.email', 'seam@example.com');
+  }
+  writeFileSync(join(repo, 'base.txt'), 'base\n');
+  git(repo, env, 'add', '--', 'base.txt');
+  if (identity) git(repo, env, 'commit', '-q', '-m', 'chore: base');
+  return repo;
+}
+
+function installHook(repo: string, name: string, body: string): void {
+  const hooks = join(repo, '.git', 'hooks');
+  mkdirSync(hooks, { recursive: true });
+  const path = join(hooks, name);
+  writeFileSync(path, `#!/bin/sh\n${body}\n`);
+  chmodSync(path, 0o755);
+}
+
+describe('gitEnvironment', () => {
+  it('strips the repository-redirecting variables and preserves identity and config by name', () => {
+    const source: NodeJS.ProcessEnv = {
+      PATH: '/usr/bin',
+      XDG_CONFIG_HOME: '/x',
+      GIT_CONFIG_GLOBAL: '/g',
+      GIT_AUTHOR_NAME: 'a',
+      GIT_AUTHOR_EMAIL: 'a@x',
+      GIT_COMMITTER_NAME: 'c',
+      GIT_COMMITTER_EMAIL: 'c@x',
+      EMAIL: 'e@x',
+      GPG_TTY: '/dev/tty',
+      GNUPGHOME: '/gnupg',
+      SSH_AUTH_SOCK: '/sock',
+    };
+    for (const key of GIT_ENV_DENYLIST) source[key] = `/elsewhere/${key}`;
+    const env = gitEnvironment(source);
+    for (const key of GIT_ENV_DENYLIST) expect(env).not.toHaveProperty(key);
+    for (const key of [
+      'PATH',
+      'XDG_CONFIG_HOME',
+      'GIT_CONFIG_GLOBAL',
+      'GIT_AUTHOR_NAME',
+      'GIT_AUTHOR_EMAIL',
+      'GIT_COMMITTER_NAME',
+      'GIT_COMMITTER_EMAIL',
+      'EMAIL',
+      'GPG_TTY',
+      'GNUPGHOME',
+      'SSH_AUTH_SOCK',
+    ]) {
+      expect(env[key]).toBe(source[key]);
+    }
+  });
+});
+
+describe('createGitProcess against a real repository', () => {
+  it('returns exit codes as data: diff --cached --quiet is 1 when staged, 0 when not', async () => {
+    const env = hermeticEnv();
+    const repo = initRepo(env);
+    const port = createGitProcess({ env });
+    expect(await port.run(['diff', '--cached', '--quiet'], { cwd: repo })).toMatchObject({
+      kind: 'exited',
+      exitCode: 0,
+    });
+    writeFileSync(join(repo, 'new.txt'), 'new\n');
+    git(repo, env, 'add', '--', 'new.txt');
+    expect(await port.run(['diff', '--cached', '--quiet'], { cwd: repo })).toMatchObject({
+      kind: 'exited',
+      exitCode: 1,
+    });
+  });
+
+  it('passes a subject and a path with shell metacharacters as ONE element each (shell: false)', async () => {
+    const env = hermeticEnv();
+    const repo = initRepo(env);
+    const port = createGitProcess({ env });
+    const path = 'a;b c$(touch pwned-path).txt';
+    const subject = 'feat: $(touch pwned) ; echo "quoted" `id` | cat > /dev/null';
+    writeFileSync(join(repo, path), 'x\n');
+    expect(await port.run(['add', '--', path], { cwd: repo })).toMatchObject({ exitCode: 0 });
+    expect(await port.run(['commit', '-m', subject], { cwd: repo })).toMatchObject({ exitCode: 0 });
+    const log = await port.run(['log', '-1', '--format=%s'], { cwd: repo });
+    expect(log).toMatchObject({ kind: 'exited', exitCode: 0, stdout: `${subject}\n` });
+    const status = await port.run(['status', '--porcelain=v2', '-z'], { cwd: repo });
+    expect(status).toMatchObject({ kind: 'exited', exitCode: 0 });
+    // Neither substitution ran: the tree holds only what git was told, and nothing named pwned.
+    if (status.kind === 'exited') expect(status.stdout).not.toContain('pwned');
+    const shown = await port.run(['show', '--name-only', '--format=', 'HEAD'], { cwd: repo });
+    if (shown.kind === 'exited') expect(shown.stdout.trim()).toBe(path);
+  });
+
+  it('closes stdin: a pre-commit hook that reads it sees EOF instead of hanging', async () => {
+    const env = hermeticEnv();
+    const repo = initRepo(env);
+    installHook(repo, 'pre-commit', 'cat > /dev/null\nexit 0');
+    writeFileSync(join(repo, 'new.txt'), 'new\n');
+    git(repo, env, 'add', '--', 'new.txt');
+    const port = createGitProcess({ env });
+    const outcome = await port.run(['commit', '-m', 'feat: hooked'], {
+      cwd: repo,
+      timeoutMs: 5000,
+    });
+    expect(outcome).toMatchObject({ kind: 'exited', exitCode: 0 });
+  });
+
+  it('kills a child that exceeds the timeout and reports failed: timeout', async () => {
+    const env = hermeticEnv();
+    const repo = initRepo(env);
+    installHook(repo, 'pre-commit', 'exec >/dev/null 2>&1\nsleep 5');
+    writeFileSync(join(repo, 'new.txt'), 'new\n');
+    git(repo, env, 'add', '--', 'new.txt');
+    const port = createGitProcess({ env });
+    const outcome = await port.run(['commit', '-m', 'feat: slow'], { cwd: repo, timeoutMs: 300 });
+    expect(outcome).toMatchObject({ kind: 'failed', reason: 'timeout' });
+    expect(git(repo, env, 'log', '--oneline').trim().split('\n')).toHaveLength(1);
+  });
+
+  it('reports an aborted signal as failed: aborted', async () => {
+    const env = hermeticEnv();
+    const repo = initRepo(env);
+    installHook(repo, 'pre-commit', 'exec >/dev/null 2>&1\nsleep 5');
+    writeFileSync(join(repo, 'new.txt'), 'new\n');
+    git(repo, env, 'add', '--', 'new.txt');
+    const port = createGitProcess({ env });
+    const controller = new AbortController();
+    const pending = port.run(['commit', '-m', 'feat: aborted'], {
+      cwd: repo,
+      timeoutMs: 10_000,
+      signal: controller.signal,
+    });
+    setTimeout(() => controller.abort(), 100);
+    expect(await pending).toMatchObject({ kind: 'failed', reason: 'aborted' });
+  });
+
+  it('reports a missing executable as failed: not-found', async () => {
+    const env = hermeticEnv();
+    const repo = initRepo(env);
+    const port = createGitProcess({ env, executable: join(repo, 'no-such-git') });
+    const outcome = await port.run(['status'], { cwd: repo });
+    expect(outcome).toMatchObject({ kind: 'failed', reason: 'not-found' });
+    if (outcome.kind === 'failed') expect(outcome.detail).toContain('ENOENT');
+  });
+
+  it('reports output past 16 MiB as failed: output-too-large', async () => {
+    const env = hermeticEnv();
+    const dir = tempDir('git-big-');
+    const fake = join(dir, 'big-git');
+    writeFileSync(fake, '#!/bin/sh\nhead -c 17000000 /dev/zero\n');
+    chmodSync(fake, 0o755);
+    const port = createGitProcess({ env, executable: fake });
+    const outcome = await port.run(['status'], { cwd: dir, timeoutMs: 20_000 });
+    expect(outcome).toMatchObject({ kind: 'failed', reason: 'output-too-large' });
+  });
+
+  it('a hook-exported GIT_DIR does not redirect the child; GIT_CONFIG_GLOBAL still carries identity', async () => {
+    const env = hermeticEnv();
+    const other = initRepo(env);
+    const repo = initRepo(env, false);
+    writeFileSync(
+      env.GIT_CONFIG_GLOBAL ?? '',
+      '[commit]\n\tgpgsign = false\n[user]\n\tname = Global Identity\n\temail = global@example.com\n',
+    );
+    // A hook-style environment: GIT_DIR points at ANOTHER repository.
+    const port = createGitProcess({
+      env: { ...env, GIT_DIR: join(other, '.git'), GIT_WORK_TREE: other },
+    });
+    const top = await port.run(['rev-parse', '--show-toplevel'], { cwd: repo });
+    expect(top).toMatchObject({ kind: 'exited', exitCode: 0, stdout: `${repo}\n` });
+    const commit = await port.run(['commit', '-m', 'feat: identity'], { cwd: repo });
+    expect(commit).toMatchObject({ kind: 'exited', exitCode: 0 });
+    const author = await port.run(['log', '-1', '--format=%an <%ae>'], { cwd: repo });
+    expect(author).toMatchObject({ stdout: 'Global Identity <global@example.com>\n' });
+    // The other repository is untouched: still exactly its base commit.
+    expect(git(other, env, 'log', '--oneline').trim().split('\n')).toHaveLength(1);
+  });
+});

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

@@ -0,0 +1,117 @@
+/** BEHAVIOR-2437 TC-01 — `/git status`: one porcelain-v2 call, parsed into the four groups. */
+import { describe, expect, it } from 'vitest';
+
+import { executeGitStatus, formatGitStatus, parseStatusPorcelainV2 } from '../git-status.js';
+
+import { exited, fakeGitPort } from './fake-git-port.js';
+
+const H = '0000000000000000000000000000000000000000';
+const rec = (parts: string[]): string => `${parts.join(' ')}\0`;
+/** Captured from a real `git status --porcelain=v2 -z --branch` run, plus the edge paths. */
+const FIXTURE =
+  rec(['#', 'branch.oid', H]) +
+  rec(['#', 'branch.head', 'main']) +
+  rec(['1', 'MM', 'N...', '100644', '100644', '100644', H, H, 'a.txt']) +
+  rec(['2', 'R.', 'N...', '100644', '100644', '100644', H, H, 'R100', 'new.txt']) +
+  'old.txt\0' +
+  rec(['1', '.M', 'N...', '100644', '100644', '100644', H, H, 'sp ace.txt']) +
+  rec(['1', 'A.', 'N...', '000000', '100644', '100644', H, H, 'quo"te.txt']) +
+  rec(['1', 'A.', 'N...', '000000', '100644', '100644', H, H, '한글 파일.txt']) +
+  rec(['?', 'untracked.txt']);
+
+describe('parseStatusPorcelainV2', () => {
+  it('yields the branch and the staged, unstaged and untracked sets, one element per path', () => {
+    const summary = parseStatusPorcelainV2(FIXTURE);
+    expect(summary.branch).toBe('main');
+    expect(summary.unborn).toBe(false);
+    // The MM entry is in BOTH sets; the rename pair stays a pair; each edge path is one element.
+    expect(summary.staged).toEqual([
+      'a.txt',
+      'new.txt (from old.txt)',
+      'quo"te.txt',
+      '한글 파일.txt',
+    ]);
+    expect(summary.unstaged).toEqual(['a.txt', 'sp ace.txt']);
+    expect(summary.untracked).toEqual(['untracked.txt']);
+    expect(summary.conflicted).toEqual([]);
+  });
+
+  it('reads an unborn branch and a detached HEAD', () => {
+    expect(
+      parseStatusPorcelainV2(
+        rec(['#', 'branch.oid', '(initial)']) + rec(['#', 'branch.head', 'main']),
+      ),
+    ).toMatchObject({ branch: 'main', unborn: true });
+    expect(parseStatusPorcelainV2(rec(['#', 'branch.head', '(detached)'])).branch).toBe(
+      '(detached)',
+    );
+  });
+
+  it('collects unmerged entries separately', () => {
+    const fixture = rec([
+      'u',
+      'UU',
+      'N...',
+      '100644',
+      '100644',
+      '100644',
+      '100644',
+      H,
+      H,
+      H,
+      'c.txt',
+    ]);
+    expect(parseStatusPorcelainV2(fixture).conflicted).toEqual(['c.txt']);
+  });
+});
+
+describe('formatGitStatus', () => {
+  it('prints the branch and each group with its count', () => {
+    expect(formatGitStatus(parseStatusPorcelainV2(FIXTURE))).toBe(
+      [
+        'On branch main',
+        'staged (4): a.txt, new.txt (from old.txt), quo"te.txt, 한글 파일.txt',
+        'unstaged (2): a.txt, sp ace.txt',
+        'untracked (1): untracked.txt',
+      ].join('\n'),
+    );
+  });
+});
+
+describe('executeGitStatus', () => {
+  it('runs exactly one porcelain-v2 call and reports the summary', async () => {
+    const port = fakeGitPort({ 'status --porcelain=v2 -z --branch': exited(FIXTURE) });
+    const result = await executeGitStatus(port, '/repo');
+    expect(port.calls).toEqual([['status', '--porcelain=v2', '-z', '--branch']]);
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('On branch main');
+    expect(result.data).toMatchObject({ git: 'status', untracked: ['untracked.txt'] });
+  });
+
+  it('reports git’s own reason on exit 128 and makes no second call', async () => {
+    const port = fakeGitPort({
+      'status --porcelain=v2 -z --branch': exited(
+        '',
+        128,
+        'fatal: not a git repository (or any of the parent directories): .git\n',
+      ),
+    });
+    const result = await executeGitStatus(port, '/not-a-repo');
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('fatal: not a git repository');
+    expect(port.calls).toHaveLength(1);
+  });
+
+  it('reports a spawn failure by its reason', async () => {
+    const port = fakeGitPort({
+      'status --porcelain=v2 -z --branch': {
+        kind: 'failed',
+        reason: 'not-found',
+        detail: 'git could not be run (ENOENT)',
+      },
+    });
+    const result = await executeGitStatus(port, '/repo');
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('ENOENT');
+  });
+});