clawt 3.1.1 → 3.1.3

package/src/utils/config-strategy.ts

@@ -73,14 +73,16 @@ export function parseConfigValue(
  * - string + 有 allowedValues → Select(枚举列表)
  * - string + 无 allowedValues → Input(自由输入)
  *
- * @param {keyof ClawtConfig} key - 配置项名称
- * @param {ClawtConfig[keyof ClawtConfig]} currentValue - 当前值
- * @returns {Promise<ClawtConfig[keyof ClawtConfig]>} 用户输入/选择的新值
+ * @param {string} key - 配置项名称
+ * @param {unknown} currentValue - 当前值
+ * @param {readonly string[]} [allowedValues] - 可选的枚举值列表
+ * @returns {Promise<unknown>} 用户输入/选择的新值
  */
 export async function promptConfigValue(
-  key: keyof ClawtConfig,
-  currentValue: ClawtConfig[keyof ClawtConfig],
-): Promise<ClawtConfig[keyof ClawtConfig]> {
+  key: string,
+  currentValue: unknown,
+  allowedValues?: readonly string[],
+): Promise<unknown> {
   const expectedType = typeof currentValue;
 
   // 布尔类型策略
@@ -94,9 +96,8 @@ export async function promptConfigValue(
   }
 
   // 字符串类型：根据 allowedValues 自动选择提示策略
-  const definition = CONFIG_DEFINITIONS[key];
-  if (definition.allowedValues) {
-    return promptEnumValue(key, currentValue as string, definition.allowedValues);
+  if (allowedValues) {
+    return promptEnumValue(key, currentValue as string, allowedValues);
   }
 
   return promptStringValue(key, currentValue as string);
@@ -104,23 +105,70 @@ export async function promptConfigValue(
 
 /**
  * 格式化配置值的显示样式
- * @param {ClawtConfig[keyof ClawtConfig]} value - 配置值
+ * @param {unknown} value - 配置值
  * @returns {string} 格式化后的字符串
  */
-export function formatConfigValue(value: ClawtConfig[keyof ClawtConfig]): string {
+export function formatConfigValue(value: unknown): string {
+  if (value === undefined || value === null) {
+    return chalk.dim('(未设置)');
+  }
   if (typeof value === 'boolean') {
     return value ? chalk.green('true') : chalk.yellow('false');
   }
   return chalk.cyan(String(value));
 }
 
+/**
+ * 通用交互式配置编辑器
+ * @param {T} config - 当前配置对象
+ * @param {Record<string, { description: string; allowedValues?: readonly string[] }>} definitions - 配置项定义（含 description、allowedValues）
+ * @param {object} [options] - 可选配置
+ * @param {string} [options.selectPrompt] - 选择配置项的提示语
+ * @param {Record<string, string>} [options.disabledKeys] - 不可编辑的键及其禁用提示
+ * @returns {Promise<{ key: string; newValue: unknown }>} 修改后的 key 和 newValue
+ */
+export async function interactiveConfigEditor<T extends object>(
+  config: T,
+  definitions: Record<string, { description: string; allowedValues?: readonly string[] }>,
+  options?: { selectPrompt?: string; disabledKeys?: Record<string, string> },
+): Promise<{ key: keyof T; newValue: unknown }> {
+  const keys = Object.keys(definitions);
+  const disabledKeys = options?.disabledKeys ?? {};
+  const configRecord = config as Record<string, unknown>;
+
+  // 构建选择列表，显示配置项名称、当前值和描述
+  const choices = keys.map((k) => {
+    const isDisabled = k in disabledKeys;
+    const value = configRecord[k];
+    const isObject = typeof value === 'object' && value !== null;
+    return {
+      name: k,
+      message: `${k}: ${isObject || isDisabled ? chalk.dim(isObject ? JSON.stringify(value) : String(value ?? '')) : formatConfigValue(value)}  ${chalk.dim(`— ${definitions[k].description}`)}`,
+      ...(isDisabled && { disabled: disabledKeys[k] }),
+    };
+  });
+
+  // @ts-expect-error enquirer 类型声明未导出 Select 类，但运行时存在
+  const selectedKey: string = await new Enquirer.Select({
+    message: options?.selectPrompt ?? MESSAGES.CONFIG_SELECT_PROMPT,
+    choices,
+  }).run();
+
+  // 根据类型和 allowedValues 自动选择提示策略
+  const currentValue = configRecord[selectedKey];
+  const definition = definitions[selectedKey];
+  const newValue = await promptConfigValue(selectedKey, currentValue, definition.allowedValues);
+
+  return { key: selectedKey as keyof T, newValue };
+}
+
 /**
  * 交互式布尔值选择（内部辅助函数）
- * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {string} key - 配置项名称
  * @param {boolean} currentValue - 当前值
  * @returns {Promise<boolean>} 用户选择的布尔值
  */
-async function promptBooleanValue(key: keyof ClawtConfig, currentValue: boolean): Promise<boolean> {
+async function promptBooleanValue(key: string, currentValue: boolean): Promise<boolean> {
   const choices = [
     { name: 'true', message: 'true' },
     { name: 'false', message: 'false' },
@@ -138,11 +186,11 @@ async function promptBooleanValue(key: keyof ClawtConfig, currentValue: boolean)
 
 /**
  * 交互式数字输入（内部辅助函数）
- * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {string} key - 配置项名称
  * @param {number} currentValue - 当前值
  * @returns {Promise<number>} 用户输入的数字值
  */
-async function promptNumberValue(key: keyof ClawtConfig, currentValue: number): Promise<number> {
+async function promptNumberValue(key: string, currentValue: number): Promise<number> {
   // @ts-expect-error enquirer 类型声明未导出 Input 类，但运行时存在
   const input: string = await new Enquirer.Input({
     message: MESSAGES.CONFIG_INPUT_PROMPT(key),
@@ -158,13 +206,13 @@ async function promptNumberValue(key: keyof ClawtConfig, currentValue: number):
 
 /**
  * 交互式枚举值选择（内部辅助函数，用于有 allowedValues 的 string 配置项）
- * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {string} key - 配置项名称
  * @param {string} currentValue - 当前值
  * @param {readonly string[]} allowedValues - 允许的枚举值列表
  * @returns {Promise<string>} 用户选择的枚举值
  */
 async function promptEnumValue(
-  key: keyof ClawtConfig,
+  key: string,
   currentValue: string,
   allowedValues: readonly string[],
 ): Promise<string> {
@@ -183,14 +231,14 @@ async function promptEnumValue(
 
 /**
  * 交互式字符串自由输入（内部辅助函数，用于无 allowedValues 的 string 配置项）
- * @param {keyof ClawtConfig} key - 配置项名称
+ * @param {string} key - 配置项名称
  * @param {string} currentValue - 当前值
  * @returns {Promise<string>} 用户输入的字符串值
  */
-async function promptStringValue(key: keyof ClawtConfig, currentValue: string): Promise<string> {
+async function promptStringValue(key: string, currentValue: string): Promise<string> {
   // @ts-expect-error enquirer 类型声明未导出 Input 类，但运行时存在
   return await new Enquirer.Input({
     message: MESSAGES.CONFIG_INPUT_PROMPT(key),
-    initial: currentValue,
+    initial: currentValue || '',
   }).run();
 }

package/src/utils/index.ts

@@ -68,9 +68,9 @@ export type { ParsedActivity, StreamEvent, LineBuffer } from './stream-parser.js
 export { detectTerminalApp, openCommandInNewTerminalTab } from './terminal.js';
 export { truncateTaskDesc, printDryRunPreview } from './dry-run.js';
 export { applyAliases } from './alias.js';
-export { isValidConfigKey, getValidConfigKeys, parseConfigValue, promptConfigValue, formatConfigValue } from './config-strategy.js';
+export { isValidConfigKey, getValidConfigKeys, parseConfigValue, promptConfigValue, formatConfigValue, interactiveConfigEditor } from './config-strategy.js';
 export { checkForUpdates } from './update-checker.js';
-export { getProjectConfigPath, loadProjectConfig, saveProjectConfig, requireProjectConfig, getMainWorkBranch } from './project-config.js';
+export { getProjectConfigPath, loadProjectConfig, saveProjectConfig, requireProjectConfig, getMainWorkBranch, getValidateRunCommand } from './project-config.js';
 export { getValidateBranchName, createValidateBranch, deleteValidateBranch, rebuildValidateBranch, ensureOnMainWorkBranch, handleDirtyWorkingDir } from './validate-branch.js';
 export { safeStringify } from './json.js';
 export { InteractivePanel } from './interactive-panel.js';

package/src/utils/project-config.ts

@@ -75,3 +75,12 @@ export function getMainWorkBranch(): string {
   const config = requireProjectConfig();
   return config.clawtMainWorkBranch;
 }
+
+/**
+ * 从项目配置中获取 validate 成功后自动执行的命令
+ * @returns {string | undefined} 配置的命令字符串，未配置时返回 undefined
+ */
+export function getValidateRunCommand(): string | undefined {
+  const config = loadProjectConfig();
+  return config?.validateRunCommand || undefined;
+}

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

@@ -38,6 +38,7 @@ vi.mock('../../../src/utils/index.js', async (importOriginal) => {
     parseConfigValue: original.parseConfigValue,
     promptConfigValue: original.promptConfigValue,
     formatConfigValue: original.formatConfigValue,
+    interactiveConfigEditor: original.interactiveConfigEditor,
   };
 });
 

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

@@ -12,6 +12,12 @@ vi.mock('../../../src/constants/index.js', () => ({
     INIT_SHOW: (configJson: string) => `当前项目配置:\n${configJson}`,
     PROJECT_NOT_INITIALIZED: '项目尚未初始化，请先执行 clawt init 设置主工作分支',
     PROJECT_CONFIG_MISSING_BRANCH: '项目配置缺少主工作分支信息，请重新执行 clawt init 设置主工作分支',
+    INIT_SELECT_PROMPT: '选择要修改的项目配置项',
+    INIT_SET_SUCCESS: (key: string, value: string) => `✓ 项目配置 ${key} 已设置为 ${value}`,
+  },
+  PROJECT_CONFIG_DEFINITIONS: {
+    clawtMainWorkBranch: { defaultValue: '', description: '主 worktree 的工作分支名' },
+    validateRunCommand: { defaultValue: undefined, description: 'validate 成功后自动执行的命令' },
   },
 }));
 
@@ -24,6 +30,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   printSuccess: vi.fn(),
   printInfo: vi.fn(),
   safeStringify: vi.fn((value: unknown, indent: number = 2) => JSON.stringify(value, null, indent)),
+  interactiveConfigEditor: vi.fn(),
 }));
 
 import { registerInitCommand } from '../../../src/commands/init.js';
@@ -32,16 +39,16 @@ import {
   saveProjectConfig,
   requireProjectConfig,
   printSuccess,
-  printInfo,
   getCurrentBranch,
+  interactiveConfigEditor,
 } from '../../../src/utils/index.js';
 
 const mockedLoadProjectConfig = vi.mocked(loadProjectConfig);
 const mockedSaveProjectConfig = vi.mocked(saveProjectConfig);
 const mockedRequireProjectConfig = vi.mocked(requireProjectConfig);
 const mockedPrintSuccess = vi.mocked(printSuccess);
-const mockedPrintInfo = vi.mocked(printInfo);
 const mockedGetCurrentBranch = vi.mocked(getCurrentBranch);
+const mockedInteractiveConfigEditor = vi.mocked(interactiveConfigEditor);
 
 beforeEach(() => {
   mockedLoadProjectConfig.mockReset();
@@ -49,8 +56,8 @@ beforeEach(() => {
   mockedRequireProjectConfig.mockReset();
   mockedRequireProjectConfig.mockReturnValue({ clawtMainWorkBranch: 'main' });
   mockedPrintSuccess.mockReset();
-  mockedPrintInfo.mockReset();
   mockedGetCurrentBranch.mockReturnValue('main');
+  mockedInteractiveConfigEditor.mockReset();
 });
 
 describe('registerInitCommand', () => {
@@ -132,15 +139,43 @@ describe('handleInit', () => {
 });
 
 describe('handleInitShow (show 子命令)', () => {
-  it('clawt init show 展示当前配置', async () => {
+  it('clawt init show 进入交互式面板并保存修改', async () => {
     mockedRequireProjectConfig.mockReturnValue({ clawtMainWorkBranch: 'develop' });
+    mockedInteractiveConfigEditor.mockResolvedValue({ key: 'validateRunCommand', newValue: 'npm test' });
+
+    const program = new Command();
+    program.exitOverride();
+    registerInitCommand(program);
+    await program.parseAsync(['init', 'show'], { from: 'user' });
+
+    // 验证调用了交互式配置编辑器
+    expect(mockedInteractiveConfigEditor).toHaveBeenCalled();
+    // 验证保存了合并后的配置
+    expect(mockedSaveProjectConfig).toHaveBeenCalledWith({
+      clawtMainWorkBranch: 'develop',
+      validateRunCommand: 'npm test',
+    });
+    // 验证输出了成功消息
+    expect(mockedPrintSuccess).toHaveBeenCalledWith(
+      expect.stringContaining('validateRunCommand'),
+    );
+  });
+
+  it('clawt init show 修改已有配置项', async () => {
+    mockedRequireProjectConfig.mockReturnValue({
+      clawtMainWorkBranch: 'main',
+      validateRunCommand: 'npm test',
+    });
+    mockedInteractiveConfigEditor.mockResolvedValue({ key: 'clawtMainWorkBranch', newValue: 'develop' });
 
     const program = new Command();
     program.exitOverride();
     registerInitCommand(program);
     await program.parseAsync(['init', 'show'], { from: 'user' });
 
-    expect(mockedPrintInfo).toHaveBeenCalled();
-    expect(mockedSaveProjectConfig).not.toHaveBeenCalled();
+    expect(mockedSaveProjectConfig).toHaveBeenCalledWith({
+      clawtMainWorkBranch: 'develop',
+      validateRunCommand: 'npm test',
+    });
   });
 });

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

@@ -11,6 +11,8 @@ vi.mock('../../../src/constants/index.js', () => ({
     RESUME_SELECT_BRANCH: '选择要恢复的分支',
     RESUME_MULTIPLE_MATCHES: (keyword: string) => `找到多个匹配 "${keyword}" 的分支`,
     RESUME_NO_MATCH: (keyword: string, branches: string[]) => `未找到匹配 "${keyword}" 的分支`,
+    RESUME_ALL_CONFIRM: (count: number) => `确认恢复 ${count} 个分支？`,
+    RESUME_ALL_SUCCESS: (count: number) => `已恢复 ${count} 个分支`,
   },
 }));
 
@@ -19,8 +21,14 @@ vi.mock('../../../src/utils/index.js', () => ({
   validateClaudeCodeInstalled: vi.fn(),
   getProjectWorktrees: vi.fn(),
   launchInteractiveClaude: vi.fn(),
+  launchInteractiveClaudeInNewTerminal: vi.fn(),
+  hasClaudeSessionHistory: vi.fn(),
   resolveTargetWorktrees: vi.fn(),
   promptGroupedMultiSelectBranches: vi.fn(),
+  printInfo: vi.fn(),
+  printSuccess: vi.fn(),
+  confirmAction: vi.fn(),
+  getConfigValue: vi.fn(),
 }));
 
 import { registerResumeCommand } from '../../../src/commands/resume.js';
@@ -29,24 +37,36 @@ import {
   validateClaudeCodeInstalled,
   getProjectWorktrees,
   launchInteractiveClaude,
+  launchInteractiveClaudeInNewTerminal,
+  hasClaudeSessionHistory,
   resolveTargetWorktrees,
   promptGroupedMultiSelectBranches,
+  confirmAction,
+  getConfigValue,
 } from '../../../src/utils/index.js';
 
 const mockedValidateMainWorktree = vi.mocked(validateMainWorktree);
 const mockedValidateClaudeCodeInstalled = vi.mocked(validateClaudeCodeInstalled);
 const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
 const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
+const mockedLaunchInteractiveClaudeInNewTerminal = vi.mocked(launchInteractiveClaudeInNewTerminal);
+const mockedHasClaudeSessionHistory = vi.mocked(hasClaudeSessionHistory);
 const mockedResolveTargetWorktrees = vi.mocked(resolveTargetWorktrees);
 const mockedPromptGroupedMultiSelectBranches = vi.mocked(promptGroupedMultiSelectBranches);
+const mockedConfirmAction = vi.mocked(confirmAction);
+const mockedGetConfigValue = vi.mocked(getConfigValue);
 
 beforeEach(() => {
   mockedValidateMainWorktree.mockReset();
   mockedValidateClaudeCodeInstalled.mockReset();
   mockedGetProjectWorktrees.mockReset();
   mockedLaunchInteractiveClaude.mockReset();
+  mockedLaunchInteractiveClaudeInNewTerminal.mockReset();
+  mockedHasClaudeSessionHistory.mockReset();
   mockedResolveTargetWorktrees.mockReset();
   mockedPromptGroupedMultiSelectBranches.mockReset();
+  mockedConfirmAction.mockReset();
+  mockedGetConfigValue.mockReset();
 });
 
 describe('registerResumeCommand', () => {
@@ -63,6 +83,7 @@ describe('handleResume', () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
     mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
+    mockedGetConfigValue.mockReturnValue(true);
 
     const program = new Command();
     program.exitOverride();
@@ -83,6 +104,7 @@ describe('handleResume', () => {
     ];
     mockedGetProjectWorktrees.mockReturnValue(worktrees);
     mockedPromptGroupedMultiSelectBranches.mockResolvedValue([worktrees[0]]);
+    mockedGetConfigValue.mockReturnValue(true);
 
     const program = new Command();
     program.exitOverride();
@@ -100,6 +122,7 @@ describe('handleResume', () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
     mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
+    mockedGetConfigValue.mockReturnValue(true);
 
     const program = new Command();
     program.exitOverride();
@@ -110,3 +133,93 @@ describe('handleResume', () => {
     expect(mockedPromptGroupedMultiSelectBranches).not.toHaveBeenCalled();
   });
 });
+
+describe('handleResume — resumeInPlace 配置', () => {
+  it('resumeInPlace 为 true 时，单选在当前终端就地恢复', async () => {
+    const worktree = { path: '/path/feature', branch: 'feature' };
+    mockedGetProjectWorktrees.mockReturnValue([worktree]);
+    mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
+    mockedGetConfigValue.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedGetConfigValue).toHaveBeenCalledWith('resumeInPlace');
+    expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree, { autoContinue: true });
+    expect(mockedLaunchInteractiveClaudeInNewTerminal).not.toHaveBeenCalled();
+  });
+
+  it('resumeInPlace 为 false 时，单选在新终端 Tab 中恢复', async () => {
+    const worktree = { path: '/path/feature', branch: 'feature' };
+    mockedGetProjectWorktrees.mockReturnValue([worktree]);
+    mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
+    mockedGetConfigValue.mockReturnValue(false);
+    mockedHasClaudeSessionHistory.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedGetConfigValue).toHaveBeenCalledWith('resumeInPlace');
+    expect(mockedHasClaudeSessionHistory).toHaveBeenCalledWith(worktree.path);
+    expect(mockedLaunchInteractiveClaudeInNewTerminal).toHaveBeenCalledWith(worktree, true);
+    expect(mockedLaunchInteractiveClaude).not.toHaveBeenCalled();
+  });
+
+  it('resumeInPlace 为 false 且无历史会话时，传 false 给新终端启动', async () => {
+    const worktree = { path: '/path/feature', branch: 'feature' };
+    mockedGetProjectWorktrees.mockReturnValue([worktree]);
+    mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
+    mockedGetConfigValue.mockReturnValue(false);
+    mockedHasClaudeSessionHistory.mockReturnValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedLaunchInteractiveClaudeInNewTerminal).toHaveBeenCalledWith(worktree, false);
+  });
+
+  it('多选时不受 resumeInPlace 影响，始终在新 Tab 中打开', async () => {
+    const worktrees = [
+      { path: '/path/feature-a', branch: 'feature-a' },
+      { path: '/path/feature-b', branch: 'feature-b' },
+    ];
+    mockedGetProjectWorktrees.mockReturnValue(worktrees);
+    mockedPromptGroupedMultiSelectBranches.mockResolvedValue(worktrees);
+    mockedConfirmAction.mockResolvedValue(true);
+    mockedHasClaudeSessionHistory.mockReturnValue(false);
+    mockedGetConfigValue.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume'], { from: 'user' });
+
+    // 多选走 handleBatchResume，不读取 resumeInPlace
+    expect(mockedLaunchInteractiveClaude).not.toHaveBeenCalled();
+    expect(mockedLaunchInteractiveClaudeInNewTerminal).toHaveBeenCalledTimes(2);
+  });
+
+  it('用户未选择任何分支时直接退出', async () => {
+    const worktrees = [
+      { path: '/path/feature-a', branch: 'feature-a' },
+      { path: '/path/feature-b', branch: 'feature-b' },
+    ];
+    mockedGetProjectWorktrees.mockReturnValue(worktrees);
+    mockedPromptGroupedMultiSelectBranches.mockResolvedValue([]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume'], { from: 'user' });
+
+    expect(mockedLaunchInteractiveClaude).not.toHaveBeenCalled();
+    expect(mockedLaunchInteractiveClaudeInNewTerminal).not.toHaveBeenCalled();
+    expect(mockedGetConfigValue).not.toHaveBeenCalled();
+  });
+});

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

@@ -101,6 +101,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   handleDirtyWorkingDir: vi.fn(),
   checkBranchExists: vi.fn().mockReturnValue(true),
   getCurrentBranch: vi.fn().mockReturnValue('main'),
+  getValidateRunCommand: vi.fn(),
 }));
 
 import { registerValidateCommand } from '../../../src/commands/validate.js';
@@ -140,6 +141,7 @@ import {
   printSeparator,
   parseParallelCommands,
   runParallelCommands,
+  getValidateRunCommand,
 } from '../../../src/utils/index.js';
 
 const mockedGetProjectName = vi.mocked(getProjectName);
@@ -177,6 +179,7 @@ const mockedPrintError = vi.mocked(printError);
 const mockedPrintSeparator = vi.mocked(printSeparator);
 const mockedParseParallelCommands = vi.mocked(parseParallelCommands);
 const mockedRunParallelCommands = vi.mocked(runParallelCommands);
+const mockedGetValidateRunCommand = vi.mocked(getValidateRunCommand);
 
 const worktree = { path: '/path/feature', branch: 'feature' };
 
@@ -216,6 +219,7 @@ beforeEach(() => {
   mockedPrintSeparator.mockReset();
   mockedParseParallelCommands.mockReset();
   mockedRunParallelCommands.mockReset();
+  mockedGetValidateRunCommand.mockReset();
   // 默认让 parseParallelCommands 返回单命令数组，保持旧测试兼容
   mockedParseParallelCommands.mockImplementation((cmd: string) => [cmd]);
 });
@@ -632,3 +636,62 @@ describe('--run 并行命令', () => {
     expect(mockedRunParallelCommands).not.toHaveBeenCalled();
   });
 });
+
+describe('配置读取 fallback（resolveRunCommand）', () => {
+  /** 设置首次 validate 成功的公共 mock */
+  function setupSuccessfulFirstValidate(): void {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedHasSnapshot.mockReturnValue(false);
+    mockedGitDiffBinaryAgainstBranch.mockReturnValue(Buffer.from('diff'));
+    mockedGitWriteTree.mockReturnValue('treehash');
+    mockedGetHeadCommitHash.mockReturnValue('headhash');
+  }
+
+  it('未传 -r 但项目配置有 validateRunCommand 时从配置读取执行', async () => {
+    setupSuccessfulFirstValidate();
+    mockedGetValidateRunCommand.mockReturnValue('pnpm test');
+    mockedRunCommandInherited.mockReturnValue({
+      pid: 0, output: [], stdout: Buffer.alloc(0), stderr: Buffer.alloc(0),
+      status: 0, signal: null, error: undefined,
+    });
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature'], { from: 'user' });
+
+    // 应该从配置读取命令并执行
+    expect(mockedRunCommandInherited).toHaveBeenCalledWith('pnpm test', { cwd: '/repo' });
+  });
+
+  it('传了 -r 时以用户参数为准，忽略项目配置', async () => {
+    setupSuccessfulFirstValidate();
+    mockedGetValidateRunCommand.mockReturnValue('pnpm test');
+    mockedRunCommandInherited.mockReturnValue({
+      pid: 0, output: [], stdout: Buffer.alloc(0), stderr: Buffer.alloc(0),
+      status: 0, signal: null, error: undefined,
+    });
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature', '-r', 'pnpm build'], { from: 'user' });
+
+    // 应该使用用户传入的命令，而非配置中的
+    expect(mockedRunCommandInherited).toHaveBeenCalledWith('pnpm build', { cwd: '/repo' });
+  });
+
+  it('未传 -r 且项目配置无 validateRunCommand 时不执行命令', async () => {
+    setupSuccessfulFirstValidate();
+    mockedGetValidateRunCommand.mockReturnValue(undefined);
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature'], { from: 'user' });
+
+    // 没有命令可执行
+    expect(mockedRunCommandInherited).not.toHaveBeenCalled();
+  });
+});

package/tests/unit/constants/config.test.ts

@@ -33,6 +33,7 @@ describe('DEFAULT_CONFIG', () => {
     expect(DEFAULT_CONFIG.confirmDestructiveOps).toBe(true);
     expect(DEFAULT_CONFIG.maxConcurrency).toBe(0);
     expect(DEFAULT_CONFIG.aliases).toEqual({});
+    expect(DEFAULT_CONFIG.resumeInPlace).toBe(false);
   });
 });
 

package/tests/unit/utils/config-strategy.test.ts

@@ -48,6 +48,7 @@ vi.mock('../../../src/constants/index.js', async (importOriginal) => {
       CONFIG_INVALID_ENUM: (key: string, validValues: readonly string[]) =>
         `配置项 ${key} 仅接受以下值: ${validValues.join(', ')}`,
       CONFIG_INPUT_PROMPT: (key: string) => `输入 ${key} 的新值`,
+      CONFIG_SELECT_PROMPT: '选择要修改的配置项',
     },
   };
 });
@@ -58,6 +59,7 @@ import {
   parseConfigValue,
   promptConfigValue,
   formatConfigValue,
+  interactiveConfigEditor,
 } from '../../../src/utils/config-strategy.js';
 
 beforeEach(() => {
@@ -184,7 +186,7 @@ describe('promptConfigValue', () => {
 
   it('字符串 + 有 allowedValues 使用 Select 提示', async () => {
     mockSelectRun.mockResolvedValueOnce('iterm2');
-    const result = await promptConfigValue('terminalApp', 'auto');
+    const result = await promptConfigValue('terminalApp', 'auto', ['auto', 'iterm2', 'terminal']);
     expect(result).toBe('iterm2');
     expect(mockSelectRun).toHaveBeenCalledTimes(1);
   });
@@ -217,4 +219,78 @@ describe('formatConfigValue', () => {
     const result = formatConfigValue('hello');
     expect(result).toContain('hello');
   });
+
+  it('undefined 显示为 (未设置)', () => {
+    const result = formatConfigValue(undefined);
+    expect(result).toContain('未设置');
+  });
+
+  it('null 显示为 (未设置)', () => {
+    const result = formatConfigValue(null);
+    expect(result).toContain('未设置');
+  });
+});
+
+describe('interactiveConfigEditor', () => {
+  it('选择配置项并返回新值（布尔类型）', async () => {
+    // 第一次 Select 选择配置项，第二次 Select 选择布尔值
+    mockSelectRun.mockResolvedValueOnce('enabled');
+    mockSelectRun.mockResolvedValueOnce('true');
+
+    const config = { enabled: false, name: 'test' };
+    const definitions = {
+      enabled: { description: '是否启用' },
+      name: { description: '名称' },
+    };
+
+    const result = await interactiveConfigEditor(config, definitions);
+    expect(result.key).toBe('enabled');
+    expect(result.newValue).toBe(true);
+  });
+
+  it('选择配置项并返回新值（字符串类型）', async () => {
+    mockSelectRun.mockResolvedValueOnce('name');
+    mockInputRun.mockResolvedValueOnce('new-name');
+
+    const config = { enabled: false, name: 'test' };
+    const definitions = {
+      enabled: { description: '是否启用' },
+      name: { description: '名称' },
+    };
+
+    const result = await interactiveConfigEditor(config, definitions);
+    expect(result.key).toBe('name');
+    expect(result.newValue).toBe('new-name');
+  });
+
+  it('支持自定义 selectPrompt', async () => {
+    mockSelectRun.mockResolvedValueOnce('name');
+    mockInputRun.mockResolvedValueOnce('value');
+
+    const config = { name: 'test' };
+    const definitions = { name: { description: '名称' } };
+
+    await interactiveConfigEditor(config, definitions, {
+      selectPrompt: '自定义提示',
+    });
+
+    // 验证 Select 被调用（无需检查具体参数，因为 mock 不保留构造参数）
+    expect(mockSelectRun).toHaveBeenCalledTimes(1);
+  });
+
+  it('有 allowedValues 的字符串配置项使用 Select 提示', async () => {
+    mockSelectRun.mockResolvedValueOnce('mode');
+    mockSelectRun.mockResolvedValueOnce('fast');
+
+    const config = { mode: 'normal' };
+    const definitions = {
+      mode: { description: '模式', allowedValues: ['normal', 'fast', 'slow'] as const },
+    };
+
+    const result = await interactiveConfigEditor(config, definitions);
+    expect(result.key).toBe('mode');
+    expect(result.newValue).toBe('fast');
+    // 两次 Select：一次选择配置项，一次选择枚举值
+    expect(mockSelectRun).toHaveBeenCalledTimes(2);
+  });
 });