@robota-sdk/agent-command 3.0.0-beta.83 → 3.0.0-beta.85

package/src/schedule/loop-command.ts

@@ -2,10 +2,14 @@
 
 import { randomUUID } from 'node:crypto';
 
+import { selectAction } from '@robota-sdk/agent-core';
+import { isLoopStopVerb } from '@robota-sdk/agent-framework';
+
 import { jitterFixedLoop } from './loop-jitter.js';
 
+import type { IUserInteraction } from '@robota-sdk/agent-core';
 import type { IAgentJobHostContext } from '@robota-sdk/agent-framework';
-import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+import type { ICommandResult, TCommandInvocationSource } from '@robota-sdk/agent-interface-command';
 import type { IBackgroundTaskState } from '@robota-sdk/agent-interface-execution';
 
 const LOOP_LABEL = 'Loop: ';
@@ -14,6 +18,7 @@ const HOURS_PER_DAY = 24;
 const MAX_LABEL_LENGTH = 48;
 const MAX_ACTIVE_LOOPS = 3;
 const LOOP_LIFETIME_MS = 7 * 24 * 60 * 60_000;
+const LOOP_LIFETIME_DAYS = LOOP_LIFETIME_MS / (HOURS_PER_DAY * 60 * SECONDS_PER_MINUTE * 1_000);
 const MAX_DEFAULT_PROMPT_LENGTH = 4_096;
 const pendingCreates = new WeakMap<object, number>();
 const TRAILING_UNITS = new Set([
@@ -31,6 +36,20 @@ export interface ILoopCommandOptions {
   disabled?: boolean;
 }
 
+/**
+ * #3288 §1: who invoked `/loop`, and how to ask them. `ui` is the injected "ask the user" port
+ * (absent for a headless/automation host — see `ICommandHostUserInteraction`); `source` is the
+ * command's own invocation source. Defaults to `{ ui: undefined, source: 'user' }` when the caller
+ * omits it, matching every pre-existing (headless) call site: proceed unconfirmed, the same as
+ * before this gate existed.
+ */
+export interface ILoopInvocationContext {
+  readonly ui: IUserInteraction | undefined;
+  readonly source: TCommandInvocationSource;
+}
+
+const DEFAULT_INVOCATION: ILoopInvocationContext = { ui: undefined, source: 'user' };
+
 const UNIT_MS: Record<string, number> = {
   s: 1_000,
   m: 60_000,
@@ -164,20 +183,80 @@ function loopIdOf(task: IBackgroundTaskState): string {
   return typeof id === 'string' && id.length > 0 ? id : task.id;
 }
 
+function describeActiveLoops(
+  host: Pick<IAgentJobHostContext, 'listSchedules' | 'listSelfPacedLoops'>,
+): string {
+  const loops = activeLoops(host);
+  const selfPaced = activeSelfPacedLoops(host);
+  if (loops.length + selfPaced.length === 0) return 'No other active loops.';
+  return [
+    ...loops.map((task) => `- ${loopIdOf(task)} [${task.status}] ${task.label}`),
+    ...selfPaced.map((loop) => `- ${loop.loopId} [${loop.phase}] Loop: ${loop.instruction}`),
+  ].join('\n');
+}
+
+/** The plain refusal for a default-prompt loop with no one to ask — never a silent, unconfirmed start. */
+const HEADLESS_REFUSAL =
+  'A loop with the default maintenance prompt needs someone to confirm it. Start it from an ' +
+  'interactive session, or give the loop its own prompt: /loop <prompt>';
+
+/**
+ * #3288 §1: every form that falls back to the host's default maintenance prompt — bare `/loop` or an
+ * interval-only `/loop <N><s|m|h|d>` — keeps working on its own for up to 7 days: a standing
+ * commitment the operator never typed, gated the same way regardless of which form reached it.
+ * Returns the refusal/decline result to return in place of creating the loop, or `undefined` to
+ * proceed. A `source: 'model'` call is refused outright and never asks — the model must give its own
+ * prompt, or name `/loop` to the user (AGENTS.md: trust and permission-widening actions stay
+ * user-only, and a refusal names the command to suggest). A headless/automation host (no ask port —
+ * print mode, a scheduled run) is refused too, the same reason: a loop that can run for a week must
+ * not start without a person saying yes, and there is no one here to ask.
+ */
+async function confirmDefaultLoopStart(
+  host: Pick<IAgentJobHostContext, 'listSchedules' | 'listSelfPacedLoops'>,
+  invocation: ILoopInvocationContext,
+  instruction: string,
+): Promise<ICommandResult | undefined> {
+  if (invocation.source === 'model') {
+    return {
+      success: false,
+      message:
+        'Starting a loop with its built-in prompt needs a person to confirm it — ' +
+        'ask the user to run /loop, or give your own prompt with /loop <prompt>.',
+    };
+  }
+  const { ui } = invocation;
+  if (!ui) return { success: false, message: HEADLESS_REFUSAL };
+  const firstLine = instruction.split('\n')[0]!.trim() || instruction;
+  const response = await ui.ask(
+    selectAction(
+      'loop-start-default',
+      `Start a loop that keeps working on its own for up to ${LOOP_LIFETIME_DAYS} days? It will: ${firstLine}`,
+      [
+        { value: 'start', label: 'Start' },
+        { value: 'cancel', label: 'Cancel' },
+      ],
+      { description: describeActiveLoops(host) },
+    ),
+  );
+  if (response.type === 'answer' && response.values.includes('start')) return undefined;
+  return { success: true, message: 'Loop not started.' };
+}
+
 export async function executeLoopCommand(
   host: Pick<IAgentJobHostContext, 'spawnScheduledWake' | 'listSchedules' | 'createSelfPacedLoop' | 'listSelfPacedLoops' | 'stopSelfPacedLoop'>,
   cancelBackgroundTask: (taskId: string, reason: string) => Promise<void>,
   args: string,
   options: ILoopCommandOptions = {},
+  invocation: ILoopInvocationContext = DEFAULT_INVOCATION,
 ): Promise<ICommandResult> {
   const trimmed = args.trim();
   if (trimmed === 'list') return listLoops(host, options);
-  if (/^stop(?:\s|$)/.test(trimmed)) return stopLoop(host, cancelBackgroundTask, trimmed);
+  if (isLoopStopVerb(trimmed)) return stopLoop(host, cancelBackgroundTask, trimmed);
 
   if (options.disabled) {
     return { success: false, message: 'Session loops are disabled by the host.' };
   }
-  return createLoop(host, trimmed, options);
+  return createLoop(host, trimmed, options, invocation);
 }
 
 function listLoops(
@@ -237,6 +316,7 @@ async function createLoop(
   host: Pick<IAgentJobHostContext, 'spawnScheduledWake' | 'listSchedules' | 'createSelfPacedLoop' | 'listSelfPacedLoops'>,
   args: string,
   options: ILoopCommandOptions,
+  invocation: ILoopInvocationContext = DEFAULT_INVOCATION,
 ): Promise<ICommandResult> {
   const useDefaultPrompt = args === '' || /^\d+(s|m|h|d)$/i.test(args);
   let defaultPrompt = options.defaultPrompt;
@@ -259,6 +339,10 @@ async function createLoop(
     if (!host.createSelfPacedLoop) {
       return { success: false, message: 'Self-paced loops require a persistent interactive session.' };
     }
+    if (useDefaultPrompt) {
+      const declined = await confirmDefaultLoopStart(host, invocation, instruction);
+      if (declined) return declined;
+    }
     const pending = pendingCreates.get(host) ?? 0;
     if (activeLoops(host).length + activeSelfPacedLoops(host).length + pending >= MAX_ACTIVE_LOOPS) {
       return { success: false, message: `At most ${MAX_ACTIVE_LOOPS} active loops are allowed. Stop one before creating another.` };
@@ -279,6 +363,14 @@ async function createLoop(
       else pendingCreates.set(host, remaining);
     }
   }
+  // #3288 §1: an interval-only form (`/loop 5m`) that fell back to the host's default prompt is
+  // gated exactly like the bare form — it is the SAME standing commitment (up to 7 days, unattended),
+  // only on a fixed cadence instead of self-paced. An explicit prompt (`/loop 5m check the build`)
+  // never reaches here with `useDefaultPrompt` true, so it is never gated.
+  if (useDefaultPrompt) {
+    const declined = await confirmDefaultLoopStart(host, invocation, parsed.instruction);
+    if (declined) return declined;
+  }
   const pending = pendingCreates.get(host) ?? 0;
   if (activeLoops(host).length + activeSelfPacedLoops(host).length + pending >= MAX_ACTIVE_LOOPS) {
     return {

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

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

@@ -1,221 +0,0 @@
-/**
- * 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

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