clawt 3.5.0 → 3.5.2

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

@@ -67,7 +67,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   hasCommitWithMessage: vi.fn(),
   gitMergeBase: vi.fn(),
   gitResetSoftTo: vi.fn(),
-  getCurrentBranch: vi.fn(),
+  getCurrentBranch: vi.fn().mockReturnValue('main'),
   gitResetHard: vi.fn(),
   gitCleanForce: vi.fn(),
   gitCheckout: vi.fn(),
@@ -77,6 +77,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   ensureOnMainWorkBranch: vi.fn(),
   guardMainWorkBranch: vi.fn().mockResolvedValue(undefined),
   guardMainWorkBranchExists: vi.fn(),
+  handleMergeConflict: vi.fn(),
 }));
 
 import { registerMergeCommand } from '../../../src/commands/merge.js';
@@ -101,6 +102,7 @@ import {
   cleanupWorktrees,
   hasCommitWithMessage,
   resolveTargetWorktree,
+  handleMergeConflict,
 } from '../../../src/utils/index.js';
 
 const mockedGetProjectName = vi.mocked(getProjectName);
@@ -123,6 +125,7 @@ const mockedConfirmAction = vi.mocked(confirmAction);
 const mockedCleanupWorktrees = vi.mocked(cleanupWorktrees);
 const mockedHasCommitWithMessage = vi.mocked(hasCommitWithMessage);
 const mockedResolveTargetWorktree = vi.mocked(resolveTargetWorktree);
+const mockedHandleMergeConflict = vi.mocked(handleMergeConflict);
 
 const worktree = { path: '/path/feature', branch: 'feature' };
 
@@ -147,6 +150,8 @@ beforeEach(() => {
   mockedPrintWarning.mockReset();
   mockedRemoveSnapshot.mockReset();
   mockedCleanupWorktrees.mockReset();
+  mockedHandleMergeConflict.mockReset();
+  mockedHandleMergeConflict.mockResolvedValue(true); // 默认 AI 解决成功
 });
 
 describe('registerMergeCommand', () => {
@@ -229,11 +234,29 @@ describe('handleMerge', () => {
     expect(mockedPrintSuccess).toHaveBeenCalled();
   });
 
-  it('合并冲突时抛出错误', async () => {
+  it('合并冲突时调用 handleMergeConflict', async () => {
     mockedIsWorkingDirClean.mockReturnValue(true);
     mockedHasLocalCommits.mockReturnValue(true);
     mockedGitMerge.mockImplementation(() => { throw new Error('merge conflict'); });
     mockedHasMergeConflict.mockReturnValue(true);
+    mockedHandleMergeConflict.mockResolvedValue(true);
+    mockedConfirmAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedHandleMergeConflict).toHaveBeenCalledWith('main', 'feature', '/repo', undefined);
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('合并冲突且 handleMergeConflict 抛出时向上传播错误', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedGitMerge.mockImplementation(() => { throw new Error('merge conflict'); });
+    mockedHasMergeConflict.mockReturnValue(true);
+    mockedHandleMergeConflict.mockRejectedValue(new Error('请手动解决冲突'));
 
     const program = new Command();
     program.exitOverride();
@@ -244,6 +267,39 @@ describe('handleMerge', () => {
     ).rejects.toThrow();
   });
 
+  it('合并冲突且 AI 部分解决时提前返回', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedGitMerge.mockImplementation(() => { throw new Error('merge conflict'); });
+    mockedHasMergeConflict.mockReturnValue(true);
+    mockedHandleMergeConflict.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    // AI 未完全解决，不应继续到 pull/push 和 success
+    expect(mockedGitPull).not.toHaveBeenCalled();
+    expect(mockedPrintSuccess).not.toHaveBeenCalled();
+  });
+
+  it('--auto 参数传递给 handleMergeConflict', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedGitMerge.mockImplementation(() => { throw new Error('merge conflict'); });
+    mockedHasMergeConflict.mockReturnValue(true);
+    mockedHandleMergeConflict.mockResolvedValue(true);
+    mockedConfirmAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature', '--auto'], { from: 'user' });
+
+    expect(mockedHandleMergeConflict).toHaveBeenCalledWith('main', 'feature', '/repo', true);
+  });
+
   it('autoPullPush=true 时执行 pull 和 push', async () => {
     mockedIsWorkingDirClean.mockReturnValue(true);
     mockedHasLocalCommits.mockReturnValue(true);
@@ -303,7 +359,7 @@ describe('handleMerge', () => {
     });
     mockedGitPull.mockImplementation(() => { throw new Error('pull failed'); });
     // merge 成功后的调用顺序：
-    // 1. 步骤 6 二次确认 hasMergeConflict → false
+    // 1. 步骤 5.5 二次确认 hasMergeConflict → false（merge 成功无冲突）
     // 2. pull catch 中 hasMergeConflict → true（触发 printWarning 并 return）
     mockedHasMergeConflict.mockReturnValueOnce(false)
       .mockReturnValueOnce(true);

package/tests/unit/utils/conflict-resolver.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// mock logger
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+// mock errors
+vi.mock('../../../src/errors/index.js', () => ({
+  ClawtError: class ClawtError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode = 1) {
+      super(message);
+      this.exitCode = exitCode;
+    }
+  },
+}));
+
+// mock node:child_process
+vi.mock('node:child_process', () => ({
+  execFileSync: vi.fn(),
+}));
+
+// mock constants（使用与 src/constants/messages/merge.ts 一致的消息文本）
+vi.mock('../../../src/constants/index.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../../src/constants/index.js')>();
+  return {
+    ...actual,
+    MESSAGES: {
+      ...actual.MESSAGES,
+      MERGE_CONFLICT_ASK_AI: '检测到合并冲突，是否使用 Claude Code 自动解决？',
+      MERGE_CONFLICT_AI_START: (fileCount: number) =>
+        `正在使用 Claude Code 分析并解决 ${fileCount} 个冲突文件...`,
+      MERGE_CONFLICT_AI_SUCCESS: '✓ Claude Code 已成功解决所有冲突',
+      MERGE_CONFLICT_AI_PARTIAL: (remaining: number) =>
+        `Claude Code 已处理冲突文件，但仍有 ${remaining} 个文件存在冲突\n  请手动处理剩余冲突后执行 git add . && git merge --continue`,
+      MERGE_CONFLICT_AI_FAILED: (errorMsg: string) =>
+        `Claude Code 解决冲突失败: ${errorMsg}\n  请手动处理：\n  解决冲突后执行 git add . && git merge --continue`,
+      MERGE_CONFLICT_MANUAL: '合并存在冲突，请手动处理：\n  解决冲突后执行 git add . && git merge --continue',
+    },
+  };
+});
+
+// mock config（determineConflictResolveMode 仍需要）
+vi.mock('../../../src/utils/config.js', () => ({
+  getConfigValue: vi.fn(),
+}));
+
+// mock formatter
+vi.mock('../../../src/utils/formatter.js', () => ({
+  printInfo: vi.fn(),
+  printSuccess: vi.fn(),
+  printWarning: vi.fn(),
+  confirmAction: vi.fn(),
+}));
+
+// mock git
+vi.mock('../../../src/utils/git.js', () => ({
+  getConflictFiles: vi.fn(),
+  hasMergeConflict: vi.fn(),
+  gitAddFiles: vi.fn(),
+  gitMergeContinue: vi.fn(),
+}));
+
+import { execFileSync } from 'node:child_process';
+import {
+  buildConflictResolvePrompt,
+  invokeClaudeForConflictResolve,
+  resolveConflictsWithAI,
+  determineConflictResolveMode,
+  handleMergeConflict,
+} from '../../../src/utils/conflict-resolver.js';
+import { getConfigValue } from '../../../src/utils/config.js';
+import { confirmAction, printInfo, printSuccess, printWarning } from '../../../src/utils/formatter.js';
+import { getConflictFiles, gitAddFiles, gitMergeContinue } from '../../../src/utils/git.js';
+import { ClawtError } from '../../../src/errors/index.js';
+
+const mockedExecFileSync = vi.mocked(execFileSync);
+const mockedGetConfigValue = vi.mocked(getConfigValue);
+const mockedConfirmAction = vi.mocked(confirmAction);
+const mockedGetConflictFiles = vi.mocked(getConflictFiles);
+const mockedGitAddFiles = vi.mocked(gitAddFiles);
+const mockedGitMergeContinue = vi.mocked(gitMergeContinue);
+const mockedPrintInfo = vi.mocked(printInfo);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedPrintWarning = vi.mocked(printWarning);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockedGetConfigValue.mockReturnValue('ask');
+});
+
+describe('buildConflictResolvePrompt', () => {
+  it('生成纯指令性 prompt（无参数）', () => {
+    const prompt = buildConflictResolvePrompt();
+
+    expect(prompt).toContain('Git 合并冲突解决专家');
+    expect(prompt).toContain('git status');
+    expect(prompt).toContain('git log');
+    expect(prompt).toContain('冲突标记');
+    expect(prompt).toContain('请直接开始');
+  });
+});
+
+describe('invokeClaudeForConflictResolve', () => {
+  it('成功调用 execFileSync 并返回输出', () => {
+    mockedExecFileSync.mockReturnValue('冲突已解决');
+
+    const result = invokeClaudeForConflictResolve('test prompt', '/repo');
+
+    expect(result).toBe('冲突已解决');
+    expect(mockedExecFileSync).toHaveBeenCalledWith(
+      'claude',
+      ['-p', 'test prompt', '--permission-mode', 'bypassPermissions'],
+      expect.objectContaining({ cwd: '/repo' }),
+    );
+  });
+
+  it('Claude Code 执行失败时抛出 ClawtError', () => {
+    mockedExecFileSync.mockImplementation(() => { throw new Error('command failed'); });
+
+    expect(() => invokeClaudeForConflictResolve('test prompt', '/repo')).toThrow(ClawtError);
+  });
+});
+
+describe('resolveConflictsWithAI', () => {
+  it('无冲突文件时直接返回 true', () => {
+    mockedGetConflictFiles.mockReturnValue([]);
+
+    const result = resolveConflictsWithAI('main', 'feature', '/repo');
+
+    expect(result).toBe(true);
+  });
+
+  it('AI 成功解决所有冲突后 git add 并 merge continue', () => {
+    mockedGetConflictFiles
+      .mockReturnValueOnce(['src/a.ts']) // 初始冲突文件
+      .mockReturnValueOnce([]); // AI 解决后无冲突
+    mockedExecFileSync.mockReturnValue('resolved');
+
+    const result = resolveConflictsWithAI('main', 'feature', '/repo');
+
+    expect(result).toBe(true);
+    expect(mockedGitAddFiles).toHaveBeenCalledWith(['src/a.ts'], '/repo');
+    expect(mockedGitMergeContinue).toHaveBeenCalledWith('/repo');
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('AI 部分解决冲突时 git add 已解决的文件并返回 false', () => {
+    mockedGetConflictFiles
+      .mockReturnValueOnce(['src/a.ts', 'src/b.ts']) // 初始 2 个冲突
+      .mockReturnValueOnce(['src/b.ts']); // AI 后还剩 1 个
+    mockedExecFileSync.mockReturnValue('partial');
+
+    const result = resolveConflictsWithAI('main', 'feature', '/repo');
+
+    expect(result).toBe(false);
+    expect(mockedGitAddFiles).toHaveBeenCalledWith(['src/a.ts'], '/repo');
+    expect(mockedPrintWarning).toHaveBeenCalled();
+  });
+
+  it('AI 调用失败时输出警告并返回 false', () => {
+    mockedGetConflictFiles.mockReturnValueOnce(['src/a.ts']);
+    mockedExecFileSync.mockImplementation(() => { throw new Error('timeout'); });
+
+    const result = resolveConflictsWithAI('main', 'feature', '/repo');
+
+    expect(result).toBe(false);
+    expect(mockedPrintWarning).toHaveBeenCalled();
+    expect(mockedGitAddFiles).not.toHaveBeenCalled();
+    expect(mockedGitMergeContinue).not.toHaveBeenCalled();
+  });
+});
+
+describe('determineConflictResolveMode', () => {
+  it('--auto 参数优先返回 auto', () => {
+    mockedGetConfigValue.mockReturnValue('manual');
+
+    expect(determineConflictResolveMode(true)).toBe('auto');
+  });
+
+  it('配置为 auto 时返回 auto', () => {
+    mockedGetConfigValue.mockReturnValue('auto');
+
+    expect(determineConflictResolveMode()).toBe('auto');
+  });
+
+  it('配置为 manual 时返回 manual', () => {
+    mockedGetConfigValue.mockReturnValue('manual');
+
+    expect(determineConflictResolveMode()).toBe('manual');
+  });
+
+  it('配置为 ask 时返回 ask', () => {
+    mockedGetConfigValue.mockReturnValue('ask');
+
+    expect(determineConflictResolveMode()).toBe('ask');
+  });
+
+  it('默认返回 ask', () => {
+    mockedGetConfigValue.mockReturnValue('unknown');
+
+    expect(determineConflictResolveMode()).toBe('ask');
+  });
+});
+
+describe('handleMergeConflict', () => {
+  it('manual 模式抛出 ClawtError', async () => {
+    mockedGetConfigValue.mockReturnValue('manual');
+
+    await expect(
+      handleMergeConflict('main', 'feature', '/repo'),
+    ).rejects.toThrow(ClawtError);
+  });
+
+  it('auto 模式直接调用 AI 解决', async () => {
+    mockedGetConflictFiles
+      .mockReturnValueOnce(['src/a.ts'])
+      .mockReturnValueOnce([]);
+    mockedExecFileSync.mockReturnValue('resolved');
+
+    const result = await handleMergeConflict('main', 'feature', '/repo', true);
+
+    expect(result).toBe(true);
+    expect(mockedConfirmAction).not.toHaveBeenCalled();
+  });
+
+  it('ask 模式用户选择使用 AI 时调用 AI 解决', async () => {
+    mockedGetConfigValue.mockReturnValue('ask');
+    mockedConfirmAction.mockResolvedValue(true);
+    mockedGetConflictFiles
+      .mockReturnValueOnce(['src/a.ts'])
+      .mockReturnValueOnce([]);
+    mockedExecFileSync.mockReturnValue('resolved');
+
+    const result = await handleMergeConflict('main', 'feature', '/repo');
+
+    expect(result).toBe(true);
+    expect(mockedConfirmAction).toHaveBeenCalled();
+  });
+
+  it('ask 模式用户拒绝 AI 时抛出 ClawtError', async () => {
+    mockedGetConfigValue.mockReturnValue('ask');
+    mockedConfirmAction.mockResolvedValue(false);
+
+    await expect(
+      handleMergeConflict('main', 'feature', '/repo'),
+    ).rejects.toThrow(ClawtError);
+  });
+});

package/src/constants/messages.ts

@@ -1,179 +0,0 @@
-/** 提示消息模板 */
-export const MESSAGES = {
-  /** 不在主 worktree 根目录 */
-  NOT_MAIN_WORKTREE: '请在主 worktree 的根目录下执行 clawt',
-  /** Git 未安装 */
-  GIT_NOT_INSTALLED: 'Git 未安装或不在 PATH 中，请先安装 Git',
-  /** Claude Code CLI 未安装 */
-  CLAUDE_NOT_INSTALLED: 'Claude Code CLI 未安装，请先安装：npm install -g @anthropic-ai/claude-code',
-  /** 分支已存在 */
-  BRANCH_EXISTS: (name: string) => `分支 ${name} 已存在，无法创建`,
-  /** 分支已存在时提示使用 resume */
-  BRANCH_EXISTS_USE_RESUME: (name: string) =>
-    `分支 ${name} 已存在，请使用 clawt resume -b ${name} 恢复会话`,
-  /** 分支名清理后为空 */
-  BRANCH_NAME_EMPTY: (original: string) =>
-    `分支名 "${original}" 中不包含合法字符，无法创建分支`,
-  /** 分支名被转换 */
-  BRANCH_SANITIZED: (original: string, sanitized: string) =>
-    `分支名已转换: ${original} → ${sanitized}`,
-  /** worktree 创建成功 */
-  WORKTREE_CREATED: (count: number) => `✓ 已创建 ${count} 个 worktree`,
-  /** worktree 移除成功 */
-  WORKTREE_REMOVED: (path: string) => `✓ 已移除 worktree: ${path}`,
-  /** 没有 worktree */
-  NO_WORKTREES: '(无 worktree)',
-  /** 目标 worktree 不存在 */
-  WORKTREE_NOT_FOUND: (name: string) => `worktree ${name} 不存在`,
-  /** 主 worktree 有未提交更改 */
-  MAIN_WORKTREE_DIRTY: '主 worktree 有未提交的更改，请先处理',
-  /** 目标 worktree 无更改 */
-  TARGET_WORKTREE_CLEAN: '该 worktree 的分支上没有任何更改，无需验证',
-  /** validate 成功 */
-  VALIDATE_SUCCESS: (branch: string) =>
-    `✓ 已将分支 ${branch} 的变更应用到主 worktree\n  可以开始验证了`,
-  /** merge 成功 */
-  MERGE_SUCCESS: (branch: string, message: string, pushed: boolean) =>
-    `✓ 分支 ${branch} 已成功合并到当前分支\n  提交信息: ${message}${pushed ? '\n  已推送到远程仓库' : ''}`,
-  /** merge 成功（无提交信息，目标 worktree 已提交过） */
-  MERGE_SUCCESS_NO_MESSAGE: (branch: string, pushed: boolean) =>
-    `✓ 分支 ${branch} 已成功合并到当前分支${pushed ? '\n  已推送到远程仓库' : ''}`,
-  /** merge 冲突 */
-  MERGE_CONFLICT: '合并存在冲突，请手动处理：\n  解决冲突后执行 git add . && git merge --continue',
-  /** merge 后清理 worktree 和分支成功 */
-  WORKTREE_CLEANED: (branch: string) => `✓ 已清理 worktree 和分支: ${branch}`,
-  /** 请提供提交信息 */
-  COMMIT_MESSAGE_REQUIRED: '请提供提交信息（-m 参数）',
-  /** 目标 worktree 有未提交修改但未指定 -m */
-  TARGET_WORKTREE_DIRTY_NO_MESSAGE: (worktreePath: string) =>
-    `${worktreePath} 有未提交的修改，请通过 -m 参数提供提交信息`,
-  /** 目标 worktree 既干净又无本地提交 */
-  TARGET_WORKTREE_NO_CHANGES: '目标 worktree 没有任何可合并的变更（工作区干净且无本地提交）',
-  /** 检测到用户中断 */
-  INTERRUPTED: '检测到退出指令，已停止 Claude Code 任务',
-  /** 中断后自动清理完成 */
-  INTERRUPT_AUTO_CLEANED: (count: number) => `✓ 已自动清理 ${count} 个 worktree 和对应分支`,
-  /** 中断后手动确认清理 */
-  INTERRUPT_CONFIRM_CLEANUP: '是否移除刚刚创建的 worktree 和对应分支？',
-  /** 中断后清理完成 */
-  INTERRUPT_CLEANED: (count: number) => `✓ 已清理 ${count} 个 worktree 和对应分支`,
-  /** 中断后保留 worktree */
-  INTERRUPT_KEPT: '已保留 worktree，可稍后使用 clawt remove 手动清理',
-  /** 配置文件损坏，已重新生成默认配置 */
-  CONFIG_CORRUPTED: '配置文件损坏或无法解析，已重新生成默认配置',
-  /** 配置已恢复为默认值 */
-  CONFIG_RESET_SUCCESS: '✓ 配置已恢复为默认值',
-  /** 分隔线 */
-  SEPARATOR: '────────────────────────────────────────',
-  /** 粗分隔线 */
-  DOUBLE_SEPARATOR: '════════════════════════════════════════',
-  /** 创建数量参数无效 */
-  INVALID_COUNT: (value: string) => `无效的创建数量: "${value}"，请输入正整数`,
-  /** worktree 状态获取失败 */
-  WORKTREE_STATUS_UNAVAILABLE: '(状态不可用)',
-  /** 增量 validate 成功提示 */
-  INCREMENTAL_VALIDATE_SUCCESS: (branch: string) =>
-    `✓ 已将分支 ${branch} 的最新变更应用到主 worktree（增量模式）\n  暂存区 = 上次快照，工作目录 = 最新变更`,
-  /** 增量 validate 降级为全量模式提示 */
-  INCREMENTAL_VALIDATE_FALLBACK: '增量对比失败，已降级为全量模式',
-  /** validate 状态已清理 */
-  VALIDATE_CLEANED: (branch: string) => `✓ 分支 ${branch} 的 validate 状态已清理`,
-  /** merge 命令检测到 validate 状态的提示 */
-  MERGE_VALIDATE_STATE_HINT: (branch: string) =>
-    `主 worktree 可能存在 validate 残留状态，可先执行 clawt validate -b ${branch} --clean 清理`,
-  /** sync 自动保存未提交变更 */
-  SYNC_AUTO_COMMITTED: (branch: string) =>
-    `已自动保存 ${branch} 分支的未提交变更`,
-  /** sync 开始合并 */
-  SYNC_MERGING: (targetBranch: string, mainBranch: string) =>
-    `正在将 ${mainBranch} 合并到 ${targetBranch} ...`,
-  /** sync 成功 */
-  SYNC_SUCCESS: (targetBranch: string, mainBranch: string) =>
-    `✓ 已将 ${mainBranch} 的最新代码同步到 ${targetBranch}`,
-  /** sync 冲突 */
-  SYNC_CONFLICT: (worktreePath: string) =>
-    `合并存在冲突，请进入目标 worktree 手动解决：\n  cd ${worktreePath}\n  解决冲突后执行 git add . && git merge --continue\n  clawt validate -b <branch> 验证变更`,
-  /** validate patch apply 失败，提示用户同步主分支 */
-  VALIDATE_PATCH_APPLY_FAILED: (branch: string) =>
-    `变更迁移失败：目标分支与主分支差异过大\n  请先执行 clawt sync -b ${branch} 同步主分支后重试`,
-  /** merge 检测到 auto-save 提交，提示用户是否压缩 */
-  MERGE_SQUASH_PROMPT: '检测到 sync 产生的临时提交，是否将所有提交压缩为一个？\n  压缩后变更将保留在目标worktree的暂存区，需要重新提交（可使用 Claude Code Cli或其他工具生成提交信息）',
-  /** squash 完成且通过 -m 直接提交后的提示 */
-  MERGE_SQUASH_COMMITTED: (branch: string) =>
-    `✓ 已将分支 ${branch} 的所有提交压缩为一个`,
-  /** squash 完成但未提供 -m，提示用户自行提交 */
-  MERGE_SQUASH_PENDING: (worktreePath: string, branch: string) =>
-    `✓ 已将所有提交压缩到暂存区\n  请在目标 worktree 中提交后重新执行 merge：\n  cd ${worktreePath}\n  提交完成后执行：clawt merge -b ${branch}`,
-  /** 用户取消破坏性操作 */
-  DESTRUCTIVE_OP_CANCELLED: '已取消操作',
-  /** reset 成功 */
-  RESET_SUCCESS: '✓ 主 worktree 工作区和暂存区已重置',
-  /** reset 时工作区和暂存区已干净 */
-  RESET_ALREADY_CLEAN: '主 worktree 工作区和暂存区已是干净状态，无需重置',
-  /** 批量移除部分失败 */
-  REMOVE_PARTIAL_FAILURE: (failures: Array<{ path: string; error: string }>) =>
-    `以下 worktree 移除失败：\n${failures.map((f) => `  ✗ ${f.path}: ${f.error}`).join('\n')}`,
-  /** resume 无可用 worktree */
-  RESUME_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
-  /** resume 模糊匹配无结果，列出可用分支 */
-  RESUME_NO_MATCH: (name: string, branches: string[]) =>
-    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
-  /** resume 交互选择提示 */
-  RESUME_SELECT_BRANCH: '请选择要恢复的分支',
-  /** resume 模糊匹配到多个结果提示 */
-  RESUME_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
-  /** validate 无可用 worktree */
-  VALIDATE_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
-  /** validate 模糊匹配无结果，列出可用分支 */
-  VALIDATE_NO_MATCH: (name: string, branches: string[]) =>
-    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
-  /** validate 交互选择提示 */
-  VALIDATE_SELECT_BRANCH: '请选择要验证的分支',
-  /** validate 模糊匹配到多个结果提示 */
-  VALIDATE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
-  /** merge 无可用 worktree */
-  MERGE_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
-  /** merge 模糊匹配无结果，列出可用分支 */
-  MERGE_NO_MATCH: (name: string, branches: string[]) =>
-    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
-  /** merge 交互选择提示 */
-  MERGE_SELECT_BRANCH: '请选择要合并的分支',
-  /** merge 模糊匹配到多个结果提示 */
-  MERGE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
-  /** sync 无可用 worktree */
-  SYNC_NO_WORKTREES: '当前项目没有可用的 worktree，请先通过 clawt run 或 clawt create 创建',
-  /** sync 模糊匹配无结果，列出可用分支 */
-  SYNC_NO_MATCH: (name: string, branches: string[]) =>
-    `未找到与 "${name}" 匹配的分支\n  可用分支：\n${branches.map((b) => `    - ${b}`).join('\n')}`,
-  /** sync 交互选择提示 */
-  SYNC_SELECT_BRANCH: '请选择要同步的分支',
-  /** sync 模糊匹配到多个结果提示 */
-  SYNC_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支，请选择：`,
-  /** status 命令标题 */
-  STATUS_TITLE: (projectName: string) => `项目状态总览: ${projectName}`,
-  /** status 主 worktree 区块标题 */
-  STATUS_MAIN_SECTION: '主 Worktree',
-  /** status worktrees 区块标题 */
-  STATUS_WORKTREES_SECTION: 'Worktree 列表',
-  /** status 快照区块标题 */
-  STATUS_SNAPSHOTS_SECTION: '未清理的 Validate 快照',
-  /** status 无 worktree */
-  STATUS_NO_WORKTREES: '(无活跃 worktree)',
-  /** status 无未清理快照 */
-  STATUS_NO_SNAPSHOTS: '(无未清理的快照)',
-  /** status 变更状态：已提交 */
-  STATUS_CHANGE_COMMITTED: '已提交',
-  /** status 变更状态：未提交修改 */
-  STATUS_CHANGE_UNCOMMITTED: '未提交修改',
-  /** status 变更状态：合并冲突 */
-  STATUS_CHANGE_CONFLICT: '合并冲突',
-  /** status 变更状态：无变更 */
-  STATUS_CHANGE_CLEAN: '无变更',
-  /** status 快照对应 worktree 已不存在 */
-  STATUS_SNAPSHOT_ORPHANED: '(对应 worktree 已不存在)',
-  /** merge 后 pull 冲突 */
-  PULL_CONFLICT:
-    '自动 pull 时发生冲突，merge 已完成但远程同步失败\n  请手动解决冲突：\n  解决冲突后执行 git add . && git commit\n  然后执行 git push 推送到远程',
-  /** push 失败 */
-  PUSH_FAILED: '自动 push 失败，merge 和 pull 已完成\n  请手动执行 git push',
-} as const;