clawt 2.10.0 → 2.11.0

package/tests/unit/commands/run.test.ts

@@ -0,0 +1,456 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+import { EventEmitter, Readable } from 'node:stream';
+
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('../../../src/errors/index.js', () => ({
+  ClawtError: class ClawtError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode = 1) {
+      super(message);
+      this.exitCode = exitCode;
+    }
+  },
+}));
+
+vi.mock('../../../src/constants/index.js', () => ({
+  MESSAGES: {
+    BRANCH_EXISTS_USE_RESUME: (name: string) => `分支 ${name} 已存在，请使用 resume 恢复`,
+    WORKTREE_CREATED: (count: number) => `✓ 已创建 ${count} 个 worktree`,
+    INTERRUPTED: '已中断',
+    INTERRUPT_AUTO_CLEANED: (count: number) => `已清理 ${count} 个 worktree`,
+    INTERRUPT_CONFIRM_CLEANUP: '是否清理已创建的 worktree？',
+    INTERRUPT_CLEANED: (count: number) => `已清理 ${count} 个 worktree`,
+    INTERRUPT_KEPT: '已保留 worktree',
+    CONCURRENCY_INFO: (concurrency: number, total: number) => `并发限制: ${concurrency}，共 ${total} 个任务`,
+    CONCURRENCY_INVALID: '并发数必须为正整数',
+    FILE_AND_TASKS_CONFLICT: '--file 和 --tasks 不能同时使用',
+    BRANCH_OR_FILE_REQUIRED: '请指定 -b 或 -f',
+    TASK_FILE_LOADED: (count: number, path: string) => `✓ 从 ${path} 加载了 ${count} 个任务`,
+    TASK_FILE_MISSING_TASK_BY_INDEX: (blockIndex: number) => `第 ${blockIndex} 个任务块缺少任务描述`,
+  },
+}));
+
+/**
+ * mock utils/index.js —— run.ts 的直接依赖
+ * 注意：executeBatchTasks 不在此 mock，由 utils/index.js 的 re-export 指向 task-executor.js 的真实实现
+ */
+vi.mock('../../../src/utils/index.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../../src/utils/index.js')>();
+  return {
+    ...actual,
+    validateMainWorktree: vi.fn(),
+    validateClaudeCodeInstalled: vi.fn(),
+    createWorktrees: vi.fn(),
+    sanitizeBranchName: vi.fn(),
+    checkBranchExists: vi.fn(),
+    getConfigValue: vi.fn().mockReturnValue(0),
+    printSuccess: vi.fn(),
+    printError: vi.fn(),
+    printWarning: vi.fn(),
+    printInfo: vi.fn(),
+    printSeparator: vi.fn(),
+    printDoubleSeparator: vi.fn(),
+    confirmAction: vi.fn(),
+    launchInteractiveClaude: vi.fn(),
+    loadTaskFile: vi.fn(),
+    createWorktreesByBranches: vi.fn(),
+  };
+});
+
+/** task-executor.ts 内部依赖的具体模块 mock */
+vi.mock('../../../src/utils/shell.js', () => ({
+  spawnProcess: vi.fn(),
+  killAllChildProcesses: vi.fn(),
+  execCommand: vi.fn(),
+  execCommandWithInput: vi.fn(),
+}));
+
+vi.mock('../../../src/utils/worktree.js', () => ({
+  cleanupWorktrees: vi.fn(),
+  createWorktrees: vi.fn(),
+  getProjectWorktrees: vi.fn(),
+  getProjectWorktreeDir: vi.fn(),
+  getWorktreeStatus: vi.fn(),
+  createWorktreesByBranches: vi.fn(),
+}));
+
+vi.mock('../../../src/utils/config.js', () => ({
+  getConfigValue: vi.fn().mockReturnValue(0),
+  loadConfig: vi.fn(),
+  writeDefaultConfig: vi.fn(),
+  ensureClawtDirs: vi.fn(),
+}));
+
+vi.mock('../../../src/utils/formatter.js', () => ({
+  printSuccess: vi.fn(),
+  printError: vi.fn(),
+  printWarning: vi.fn(),
+  printInfo: vi.fn(),
+  printSeparator: vi.fn(),
+  printDoubleSeparator: vi.fn(),
+  confirmAction: vi.fn(),
+  confirmDestructiveAction: vi.fn(),
+  formatWorktreeStatus: vi.fn(),
+  isWorktreeIdle: vi.fn(),
+  formatDuration: vi.fn(),
+}));
+
+vi.mock('../../../src/utils/progress.js', () => ({
+  ProgressRenderer: class {
+    start = vi.fn();
+    stop = vi.fn();
+    updateActivity = vi.fn();
+    markRunning = vi.fn();
+    markDone = vi.fn();
+    markFailed = vi.fn();
+  },
+}));
+
+import { registerRunCommand } from '../../../src/commands/run.js';
+import {
+  createWorktrees,
+  createWorktreesByBranches,
+  sanitizeBranchName,
+  checkBranchExists,
+  printSuccess,
+  launchInteractiveClaude,
+  getConfigValue,
+  loadTaskFile,
+} from '../../../src/utils/index.js';
+import { spawnProcess } from '../../../src/utils/shell.js';
+import { printInfo } from '../../../src/utils/formatter.js';
+
+const mockedCreateWorktrees = vi.mocked(createWorktrees);
+const mockedCreateWorktreesByBranches = vi.mocked(createWorktreesByBranches);
+const mockedSanitizeBranchName = vi.mocked(sanitizeBranchName);
+const mockedCheckBranchExists = vi.mocked(checkBranchExists);
+const mockedSpawnProcess = vi.mocked(spawnProcess);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedPrintInfo = vi.mocked(printInfo);
+const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
+const mockedGetConfigValue = vi.mocked(getConfigValue);
+const mockedLoadTaskFile = vi.mocked(loadTaskFile);
+
+/**
+ * 创建模拟子进程
+ * @param {string} stdout - 子进程标准输出内容
+ * @param {number} exitCode - 退出码
+ * @returns {object} 模拟的子进程对象
+ */
+function createMockChildProcess(stdout: string, exitCode: number) {
+  const child = new EventEmitter() as any;
+  const stdoutStream = new Readable({ read() {} });
+  const stderrStream = new Readable({ read() {} });
+  child.stdout = stdoutStream;
+  child.stderr = stderrStream;
+  child.pid = 12345;
+  child.exitCode = null;
+
+  // 延迟触发 close 事件
+  setTimeout(() => {
+    stdoutStream.push(stdout);
+    stdoutStream.push(null);
+    stderrStream.push(null);
+    child.exitCode = exitCode;
+    child.emit('close', exitCode);
+  }, 10);
+
+  return child;
+}
+
+beforeEach(() => {
+  mockedCreateWorktrees.mockReset();
+  mockedCreateWorktreesByBranches.mockReset();
+  mockedSanitizeBranchName.mockReset();
+  mockedCheckBranchExists.mockReset();
+  mockedSpawnProcess.mockReset();
+  mockedPrintSuccess.mockReset();
+  mockedPrintInfo.mockReset();
+  mockedLaunchInteractiveClaude.mockReset();
+  mockedGetConfigValue.mockReset();
+  mockedGetConfigValue.mockReturnValue(0 as any);
+  mockedLoadTaskFile.mockReset();
+  // sanitizeBranchName 默认返回输入值
+  mockedSanitizeBranchName.mockImplementation((name: string) => name);
+});
+
+describe('registerRunCommand', () => {
+  it('注册 run 命令', () => {
+    const program = new Command();
+    registerRunCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'run');
+    expect(cmd).toBeDefined();
+  });
+});
+
+describe('handleRun', () => {
+  it('未传 --tasks 时创建单个 worktree 并打开交互式界面', async () => {
+    mockedSanitizeBranchName.mockReturnValue('feature');
+    mockedCheckBranchExists.mockReturnValue(false);
+    const worktree = { path: '/path/feature', branch: 'feature' };
+    mockedCreateWorktrees.mockReturnValue([worktree]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedCreateWorktrees).toHaveBeenCalledWith('feature', 1);
+    expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree);
+  });
+
+  it('分支已存在时提示使用 resume', async () => {
+    mockedSanitizeBranchName.mockReturnValue('feature');
+    mockedCheckBranchExists.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+
+    await expect(
+      program.parseAsync(['run', '-b', 'feature'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('传 --tasks 时创建对应数量 worktree 并并行执行', async () => {
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2'], { from: 'user' });
+
+    expect(mockedCreateWorktrees).toHaveBeenCalledWith('feat', 2);
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
+  });
+
+  it('任务执行失败时在通知中报告', async () => {
+    const worktrees = [{ path: '/path/feat-1', branch: 'feat-1' }];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: true,
+      duration_ms: 1000,
+      total_cost_usd: 0.01,
+    });
+    mockedSpawnProcess.mockReturnValueOnce(createMockChildProcess(jsonOutput, 1));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'fail-task'], { from: 'user' });
+
+    // 应输出汇总（含失败信息）
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(1);
+  });
+
+  it('子进程发生错误时返回失败结果', async () => {
+    const worktrees = [{ path: '/path/feat-1', branch: 'feat-1' }];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    // 创建会触发 error 事件的子进程
+    const child = new EventEmitter() as any;
+    child.stdout = new Readable({ read() {} });
+    child.stderr = new Readable({ read() {} });
+    child.pid = 12345;
+    child.exitCode = null;
+    setTimeout(() => {
+      child.emit('error', new Error('spawn error'));
+    }, 10);
+    mockedSpawnProcess.mockReturnValueOnce(child);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1'], { from: 'user' });
+
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(1);
+  });
+
+  it('传 --concurrency 限制并发数', async () => {
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+      { path: '/path/feat-3', branch: 'feat-3' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', 'task3', '-c', '1'], { from: 'user' });
+
+    expect(mockedCreateWorktrees).toHaveBeenCalledWith('feat', 3);
+    // 所有任务都应执行完毕
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(3);
+    // 应输出并发限制提示
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+  });
+
+  it('--concurrency 为 0 时不限制并发', async () => {
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', '-c', '0'], { from: 'user' });
+
+    // 不限制并发时不输出并发限制提示
+    expect(mockedPrintInfo).not.toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
+  });
+
+  it('未传 -c 时使用全局配置的 maxConcurrency', async () => {
+    mockedGetConfigValue.mockReturnValue(2 as any);
+
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+      { path: '/path/feat-3', branch: 'feat-3' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', 'task3'], { from: 'user' });
+
+    // 应输出并发限制提示（使用配置值 2）
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(3);
+  });
+
+  it('-f 从文件加载任务并执行（无 -b，使用文件中分支名）', async () => {
+    mockedLoadTaskFile.mockReturnValue([
+      { branch: 'feat-login', task: '实现登录功能' },
+      { branch: 'fix-bug', task: '修复问题' },
+    ]);
+    const worktrees = [
+      { path: '/path/feat-login', branch: 'feat-login' },
+      { path: '/path/fix-bug', branch: 'fix-bug' },
+    ];
+    mockedCreateWorktreesByBranches.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-f', 'tasks.md'], { from: 'user' });
+
+    expect(mockedLoadTaskFile).toHaveBeenCalledWith('tasks.md', { branchRequired: true });
+    expect(mockedCreateWorktreesByBranches).toHaveBeenCalledWith(['feat-login', 'fix-bug']);
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
+  });
+
+  it('-f + -b 模式使用 -b 自动编号', async () => {
+    mockedLoadTaskFile.mockReturnValue([
+      { task: '任务1' },
+      { task: '任务2' },
+    ]);
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '-f', 'tasks.md'], { from: 'user' });
+
+    // 应使用 createWorktrees（带 -b 自动编号），而非 createWorktreesByBranches
+    expect(mockedLoadTaskFile).toHaveBeenCalledWith('tasks.md', { branchRequired: false });
+    expect(mockedCreateWorktrees).toHaveBeenCalledWith('feat', 2);
+    expect(mockedCreateWorktreesByBranches).not.toHaveBeenCalled();
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
+  });
+
+  it('-f 和 --tasks 互斥时报错', async () => {
+    mockedLoadTaskFile.mockReturnValue([{ branch: 'feat', task: '任务' }]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+
+    await expect(
+      program.parseAsync(['run', '-f', 'tasks.md', '--tasks', 'task1'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('未传 -b 和 -f 时报错', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+
+    await expect(
+      program.parseAsync(['run', '--tasks', 'task1'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+});

package/tests/unit/commands/status.test.ts

@@ -0,0 +1,214 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('../../../src/constants/index.js', () => ({
+  MESSAGES: {
+    STATUS_TITLE: (name: string) => `项目 ${name} 状态`,
+    STATUS_MAIN_SECTION: '主 Worktree',
+    STATUS_WORKTREES_SECTION: 'Worktree 列表',
+    STATUS_SNAPSHOTS_SECTION: 'Validate 快照',
+    STATUS_NO_WORKTREES: '无 worktree',
+    STATUS_NO_SNAPSHOTS: '无快照',
+    STATUS_CHANGE_COMMITTED: '已提交',
+    STATUS_CHANGE_UNCOMMITTED: '未提交',
+    STATUS_CHANGE_CONFLICT: '冲突',
+    STATUS_CHANGE_CLEAN: '干净',
+    STATUS_SNAPSHOT_ORPHANED: '(孤立)',
+  },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  validateMainWorktree: vi.fn(),
+  getProjectName: vi.fn(),
+  getCurrentBranch: vi.fn(),
+  isWorkingDirClean: vi.fn(),
+  getProjectWorktrees: vi.fn(),
+  getCommitCountAhead: vi.fn(),
+  getCommitCountBehind: vi.fn(),
+  getDiffStat: vi.fn(),
+  hasMergeConflict: vi.fn(),
+  hasLocalCommits: vi.fn(),
+  hasSnapshot: vi.fn(),
+  getProjectSnapshotBranches: vi.fn(),
+  printInfo: vi.fn(),
+  printDoubleSeparator: vi.fn(),
+  printSeparator: vi.fn(),
+}));
+
+import { registerStatusCommand } from '../../../src/commands/status.js';
+import {
+  getProjectName,
+  getCurrentBranch,
+  isWorkingDirClean,
+  getProjectWorktrees,
+  getCommitCountAhead,
+  getCommitCountBehind,
+  getDiffStat,
+  hasMergeConflict,
+  hasLocalCommits,
+  hasSnapshot,
+  getProjectSnapshotBranches,
+  printInfo,
+} from '../../../src/utils/index.js';
+
+const mockedGetProjectName = vi.mocked(getProjectName);
+const mockedGetCurrentBranch = vi.mocked(getCurrentBranch);
+const mockedIsWorkingDirClean = vi.mocked(isWorkingDirClean);
+const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
+const mockedGetCommitCountAhead = vi.mocked(getCommitCountAhead);
+const mockedGetCommitCountBehind = vi.mocked(getCommitCountBehind);
+const mockedGetDiffStat = vi.mocked(getDiffStat);
+const mockedHasMergeConflict = vi.mocked(hasMergeConflict);
+const mockedHasLocalCommits = vi.mocked(hasLocalCommits);
+const mockedHasSnapshot = vi.mocked(hasSnapshot);
+const mockedGetProjectSnapshotBranches = vi.mocked(getProjectSnapshotBranches);
+const mockedPrintInfo = vi.mocked(printInfo);
+
+beforeEach(() => {
+  mockedGetProjectName.mockReturnValue('test-project');
+  mockedGetCurrentBranch.mockReturnValue('main');
+  mockedIsWorkingDirClean.mockReturnValue(true);
+  mockedGetProjectWorktrees.mockReturnValue([]);
+  mockedGetProjectSnapshotBranches.mockReturnValue([]);
+  mockedGetCommitCountAhead.mockReturnValue(0);
+  mockedGetCommitCountBehind.mockReturnValue(0);
+  mockedGetDiffStat.mockReturnValue({ insertions: 0, deletions: 0 });
+  mockedHasMergeConflict.mockReturnValue(false);
+  mockedHasLocalCommits.mockReturnValue(false);
+  mockedHasSnapshot.mockReturnValue(false);
+  mockedPrintInfo.mockReset();
+});
+
+describe('registerStatusCommand', () => {
+  it('注册 status 命令', () => {
+    const program = new Command();
+    registerStatusCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'status');
+    expect(cmd).toBeDefined();
+  });
+});
+
+describe('handleStatus', () => {
+  it('无 worktree 时文本输出', () => {
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status'], { from: 'user' });
+
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+
+  it('--json 输出完整 JSON 结构', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetCommitCountAhead.mockReturnValue(2);
+    mockedGetDiffStat.mockReturnValue({ insertions: 10, deletions: 5 });
+    mockedHasLocalCommits.mockReturnValue(true);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    expect(jsonCall).toBeDefined();
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.main.projectName).toBe('test-project');
+    expect(parsed.main.branch).toBe('main');
+    expect(parsed.totalWorktrees).toBe(1);
+    expect(parsed.worktrees).toHaveLength(1);
+    expect(parsed.worktrees[0].branch).toBe('feature');
+  });
+
+  it('有 worktree 时收集正确的变更状态', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    // 模拟冲突状态
+    mockedHasMergeConflict.mockReturnValue(true);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.worktrees[0].changeStatus).toBe('conflict');
+  });
+
+  it('主 worktree 不干净时 isClean=false', () => {
+    mockedIsWorkingDirClean.mockReturnValue(false);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.main.isClean).toBe(false);
+  });
+
+  it('存在快照时标识孤立快照', () => {
+    mockedGetProjectSnapshotBranches.mockReturnValue(['feature', 'deleted-branch']);
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.snapshots).toHaveLength(2);
+    expect(parsed.snapshots[0]).toEqual({ branch: 'feature', worktreeExists: true });
+    expect(parsed.snapshots[1]).toEqual({ branch: 'deleted-branch', worktreeExists: false });
+  });
+
+  it('uncommitted 变更状态正确检测', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedHasMergeConflict.mockReturnValue(false);
+    mockedIsWorkingDirClean
+      .mockReturnValueOnce(true)   // 主 worktree
+      .mockReturnValueOnce(false); // 目标 worktree 不干净
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.worktrees[0].changeStatus).toBe('uncommitted');
+  });
+});