clawt 3.8.1 → 3.8.3

package/README.md

@@ -186,11 +186,13 @@ clawt sync -b <branch>
 ### `clawt merge` — 合并分支到主 worktree
 
 ```bash
-clawt merge -b <branch> -m "feat: 提交信息"   # 有未提交修改时需要 -m
-clawt merge -b <branch>                        # 已提交过可省略 -m
+clawt merge -b <branch> -m "feat: 提交信息"   # 通过 -m 直接指定提交信息
+clawt merge -b <branch>                        # 交互模式下有未提交修改时会询问输入提交信息
 clawt merge -b <branch> --auto                 # 遇到冲突直接调用 AI 解决
 ```
 
+交互模式下，如果目标 worktree 有未提交修改或 squash 后需要提交，会自动询问输入提交信息，无需提前指定 `-m`。非交互模式（`-y` / CI）下未提供 `-m` 时会提示退出。
+
 ### `clawt remove` — 移除 worktree
 
 ```bash
@@ -339,7 +341,7 @@ clawt alias remove l
 | `aliases` | `{}` | 命令别名映射（如 `{"l": "list", "r": "run"}`） |
 | `autoUpdate` | `true` | 自动检查新版本（每 24 小时检查一次 npm registry） |
 | `conflictResolveMode` | `"ask"` | merge 冲突时的解决模式：`ask`（询问是否使用 AI）、`auto`（自动 AI 解决）、`manual`（手动解决） |
-| `conflictResolveTimeoutMs` | `300000` | Claude Code 冲突解决超时时间（毫秒），默认 5 分钟 |
+| `conflictResolveTimeoutMs` | `600000` | Claude Code 冲突解决超时时间（毫秒），默认 10 分钟 |
 
 ## postCreate Hook
 

package/dist/index.js

@@ -188,7 +188,11 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   \u8BF7\u624B\u52A8\u5904\u7406\uFF1A
   \u89E3\u51B3\u51B2\u7A81\u540E\u6267\u884C git add . && git merge --continue`,
   /** --auto 模式下的冲突手动解决（配置为 manual） */
-  MERGE_CONFLICT_MANUAL: "\u5408\u5E76\u5B58\u5728\u51B2\u7A81\uFF0C\u8BF7\u624B\u52A8\u5904\u7406\uFF1A\n  \u89E3\u51B3\u51B2\u7A81\u540E\u6267\u884C git add . && git merge --continue"
+  MERGE_CONFLICT_MANUAL: "\u5408\u5E76\u5B58\u5728\u51B2\u7A81\uFF0C\u8BF7\u624B\u52A8\u5904\u7406\uFF1A\n  \u89E3\u51B3\u51B2\u7A81\u540E\u6267\u884C git add . && git merge --continue",
+  /** 目标 worktree 有未提交修改时的交互式提交信息提示 */
+  MERGE_PROMPT_COMMIT_MESSAGE: "\u76EE\u6807 worktree \u6709\u672A\u63D0\u4EA4\u7684\u4FEE\u6539\uFF0C\u8BF7\u8F93\u5165\u63D0\u4EA4\u4FE1\u606F",
+  /** squash 后的交互式提交信息提示 */
+  MERGE_SQUASH_PROMPT_COMMIT_MESSAGE: "\u8BF7\u8F93\u5165 squash \u540E\u7684\u63D0\u4EA4\u4FE1\u606F"
 };
 
 // src/constants/messages/validate.ts
@@ -740,8 +744,8 @@ var CONFIG_DEFINITIONS = {
     allowedValues: ["ask", "auto", "manual"]
   },
   conflictResolveTimeoutMs: {
-    defaultValue: 3e5,
-    description: "Claude Code \u51B2\u7A81\u89E3\u51B3\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4 300000\uFF085 \u5206\u949F\uFF09"
+    defaultValue: 6e5,
+    description: "Claude Code \u51B2\u7A81\u89E3\u51B3\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4 600000\uFF0810 \u5206\u949F\uFF09"
   }
 };
 function deriveDefaultConfig(definitions) {
@@ -1922,6 +1926,19 @@ function parseConcurrency(optionValue, configValue) {
 
 // src/utils/prompt.ts
 import Enquirer2 from "enquirer";
+async function promptCommitMessage(promptMessage, nonInteractiveErrorMessage) {
+  if (isNonInteractive()) {
+    throw new ClawtError(nonInteractiveErrorMessage);
+  }
+  const prompt = new Enquirer2.Input({
+    message: promptMessage
+  });
+  const result = await prompt.run();
+  if (!result.trim()) {
+    throw new ClawtError("\u63D0\u4EA4\u4FE1\u606F\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  return result.trim();
+}
 
 // src/utils/claude.ts
 import { spawnSync as spawnSync3 } from "child_process";
@@ -4275,7 +4292,7 @@ var InteractivePanel = class {
 
 // src/utils/conflict-resolver.ts
 import { execFileSync as execFileSync4 } from "child_process";
-var DEFAULT_CONFLICT_RESOLVE_TIMEOUT_MS = 3e5;
+var DEFAULT_CONFLICT_RESOLVE_TIMEOUT_MS = 6e5;
 function buildConflictResolvePrompt() {
   return CONFLICT_RESOLVE_PROMPT;
 }
@@ -5104,6 +5121,11 @@ var MERGE_RESOLVE_MESSAGES = {
   multipleMatches: MESSAGES.MERGE_MULTIPLE_MATCHES,
   noMatch: MESSAGES.MERGE_NO_MATCH
 };
+function commitSquash(message, worktreePath, branchName) {
+  gitAddAll(worktreePath);
+  gitCommit(message, worktreePath);
+  printSuccess(MESSAGES.MERGE_SQUASH_COMMITTED(branchName));
+}
 async function handleSquashIfNeeded(targetWorktreePath, mainWorktreePath, branchName, commitMessage) {
   if (!hasCommitWithMessage(branchName, AUTO_SAVE_COMMIT_MESSAGE, mainWorktreePath)) {
     return false;
@@ -5117,12 +5139,19 @@ async function handleSquashIfNeeded(targetWorktreePath, mainWorktreePath, branch
   logger.info(`squash: merge-base = ${mergeBase}, \u5206\u652F = ${branchName}`);
   gitResetSoftTo(mergeBase, targetWorktreePath);
   if (commitMessage) {
-    gitCommit(commitMessage, targetWorktreePath);
-    printSuccess(MESSAGES.MERGE_SQUASH_COMMITTED(branchName));
+    commitSquash(commitMessage, targetWorktreePath, branchName);
     return false;
   }
-  printInfo(MESSAGES.MERGE_SQUASH_PENDING(targetWorktreePath, branchName));
-  return true;
+  if (isNonInteractive()) {
+    printInfo(MESSAGES.MERGE_SQUASH_PENDING(targetWorktreePath, branchName));
+    return true;
+  }
+  const userCommitMessage = await promptCommitMessage(
+    MESSAGES.MERGE_SQUASH_PROMPT_COMMIT_MESSAGE,
+    MESSAGES.MERGE_SQUASH_PENDING(targetWorktreePath, branchName)
+  );
+  commitSquash(userCommitMessage, targetWorktreePath, branchName);
+  return false;
 }
 async function shouldCleanupAfterMerge(branchName) {
   const autoDelete = getConfigValue("autoDeleteBranch");
@@ -5156,11 +5185,12 @@ async function handleMerge(options) {
   }
   const targetClean = isWorkingDirClean(targetWorktreePath);
   if (!targetClean) {
-    if (!options.message) {
-      throw new ClawtError(MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE(targetWorktreePath));
-    }
+    const commitMessage = options.message ?? await promptCommitMessage(
+      MESSAGES.MERGE_PROMPT_COMMIT_MESSAGE,
+      MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE(targetWorktreePath)
+    );
     gitAddAll(targetWorktreePath);
-    gitCommit(options.message, targetWorktreePath);
+    gitCommit(commitMessage, targetWorktreePath);
   } else {
     if (!hasLocalCommits(branch, mainWorktreePath)) {
       throw new ClawtError(MESSAGES.TARGET_WORKTREE_NO_CHANGES);

package/dist/postinstall.js

@@ -179,7 +179,11 @@ ${branches.map((b) => `    - ${b}`).join("\n")}`,
   \u8BF7\u624B\u52A8\u5904\u7406\uFF1A
   \u89E3\u51B3\u51B2\u7A81\u540E\u6267\u884C git add . && git merge --continue`,
   /** --auto 模式下的冲突手动解决（配置为 manual） */
-  MERGE_CONFLICT_MANUAL: "\u5408\u5E76\u5B58\u5728\u51B2\u7A81\uFF0C\u8BF7\u624B\u52A8\u5904\u7406\uFF1A\n  \u89E3\u51B3\u51B2\u7A81\u540E\u6267\u884C git add . && git merge --continue"
+  MERGE_CONFLICT_MANUAL: "\u5408\u5E76\u5B58\u5728\u51B2\u7A81\uFF0C\u8BF7\u624B\u52A8\u5904\u7406\uFF1A\n  \u89E3\u51B3\u51B2\u7A81\u540E\u6267\u884C git add . && git merge --continue",
+  /** 目标 worktree 有未提交修改时的交互式提交信息提示 */
+  MERGE_PROMPT_COMMIT_MESSAGE: "\u76EE\u6807 worktree \u6709\u672A\u63D0\u4EA4\u7684\u4FEE\u6539\uFF0C\u8BF7\u8F93\u5165\u63D0\u4EA4\u4FE1\u606F",
+  /** squash 后的交互式提交信息提示 */
+  MERGE_SQUASH_PROMPT_COMMIT_MESSAGE: "\u8BF7\u8F93\u5165 squash \u540E\u7684\u63D0\u4EA4\u4FE1\u606F"
 };
 
 // src/constants/messages/validate.ts
@@ -676,8 +680,8 @@ var CONFIG_DEFINITIONS = {
     allowedValues: ["ask", "auto", "manual"]
   },
   conflictResolveTimeoutMs: {
-    defaultValue: 3e5,
-    description: "Claude Code \u51B2\u7A81\u89E3\u51B3\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4 300000\uFF085 \u5206\u949F\uFF09"
+    defaultValue: 6e5,
+    description: "Claude Code \u51B2\u7A81\u89E3\u51B3\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4 600000\uFF0810 \u5206\u949F\uFF09"
   }
 };
 function deriveDefaultConfig(definitions) {

package/docs/config-file.md

@@ -26,7 +26,7 @@
   "aliases": {},
   "autoUpdate": true,
   "conflictResolveMode": "ask",
-  "conflictResolveTimeoutMs": 300000
+  "conflictResolveTimeoutMs": 600000
 }
 ```
 
@@ -44,6 +44,6 @@
 | `aliases` | `Record<string, string>` | `{}` | 命令别名映射，键为别名，值为目标内置命令名 |
 | `autoUpdate` | `boolean` | `true` | 是否启用自动更新检查（每 24 小时通过 npm registry 检查一次新版本） |
 | `conflictResolveMode` | `string` | `"ask"` | merge 冲突时的解决模式：`ask`（询问是否使用 AI）、`auto`（自动 AI 解决）、`manual`（手动解决） |
-| `conflictResolveTimeoutMs` | `number` | `300000` | Claude Code 冲突解决超时时间（毫秒），默认 300000（5 分钟） |
+| `conflictResolveTimeoutMs` | `number` | `600000` | Claude Code 冲突解决超时时间（毫秒），默认 600000（10 分钟） |
 
 ---

package/docs/merge.md

@@ -15,7 +15,7 @@ clawt merge [-m <commitMessage>]
 | 参数 | 必填 | 说明                                                                     |
 | ---- | ---- | ------------------------------------------------------------------------ |
 | `-b` | 否   | 要合并的分支名（支持模糊匹配，不传则列出所有分支供选择）                   |
-| `-m` | 否   | 提交信息（目标 worktree 工作区有修改时必填）                               |
+| `-m` | 否   | 提交信息（目标 worktree 工作区有修改时使用；交互模式下未提供会询问输入）     |
 | `--auto` | 否   | 遇到冲突直接调用 AI 解决，不再询问                                        |
 
 **运行流程：**
@@ -54,25 +54,30 @@ clawt merge [-m <commitMessage>]
      1. 获取主分支名（从项目级配置 `clawtMainWorkBranch` 获取）
      2. 计算分叉点：`git merge-base <mainBranch> <branchName>`
      3. 在目标 worktree 中执行 `git reset --soft <merge-base>`，将所有 commit 撤销到暂存区
-     4. 如果用户提供了 `-m` → 直接在目标 worktree 执行 `git commit -m '<commitMessage>'`，输出成功提示，继续步骤 7
-     5. 如果用户未提供 `-m` → 提示用户前往目标 worktree 自行提交后重新执行 `clawt merge`：
-        ```
-        ✓ 已将所有提交压缩到暂存区
-          请在目标 worktree 中提交后重新执行 merge：
-          cd <worktreePath>
-          提交完成后执行：clawt merge -b <branch>
-        ```
-        **退出流程**
+     4. 如果用户提供了 `-m` → 在目标 worktree 执行 `git add . && git commit -m '<commitMessage>'`，输出成功提示，继续步骤 7
+     5. 如果用户未提供 `-m`：
+        - **交互模式** → 通过 `promptCommitMessage` 交互式询问用户输入提交信息，用户输入后执行 `git add . && git commit`，继续步骤 7
+        - **非交互模式** → 提示用户前往目标 worktree 自行提交后重新执行 `clawt merge`，**退出流程**（不执行 `git add`，不改变暂存区）：
+          ```
+          ✓ 已将所有提交压缩到暂存区
+            请在目标 worktree 中提交后重新执行 merge：
+            cd <worktreePath>
+            提交完成后执行：clawt merge -b <branch>
+          ```
+
+   > **最小副作用原则**：`git add .` 延后到确定要提交时才执行，紧邻 `git commit` 之前。非交互模式温和退出时不触发 `git add .`，避免不必要地改变暂存区状态。提交逻辑通过 `commitSquash` 函数统一封装（`git add . → git commit → 输出成功提示`），确保单一职责。
 7. **根据目标 worktree 状态决定是否需要提交**
    - 检测目标 worktree 工作区是否干净（`git status --porcelain`）
    - **工作区有未提交修改**：
-     - 如果用户未提供 `-m`，提示 `<worktreePath> 有未提交的修改，请通过 -m 参数提供提交信息`（其中 `<worktreePath>` 为目标 worktree 的完整路径），退出
      - 提供了 `-m` → 执行提交：
        ```bash
        cd ~/.clawt/worktrees/<project>/<branchName>
        git add .
        git commit -m '<commitMessage>'
        ```
+     - 未提供 `-m`：
+       - **交互模式** → 通过 `promptCommitMessage` 交互式询问用户输入提交信息，输入后执行 `git add . && git commit`
+       - **非交互模式** → 提示 `<worktreePath> 有未提交的修改，请通过 -m 参数提供提交信息`，退出
    - **工作区干净**：
      - 检查目标分支相对于主分支是否有本地提交（`git log HEAD..<branchName> --oneline`）
      - 有本地提交 → 跳过提交步骤，直接进入合并
@@ -99,7 +104,7 @@ clawt merge [-m <commitMessage>]
    | `auto` | — | 直接调用 AI 解决，不询问 |
    | `manual` | — | 输出冲突提示信息，用户手动解决 |
 
-   AI 解决冲突时，调用 Claude Code CLI 在主 worktree 中分析并解决冲突文件，超时时间由配置项 `conflictResolveTimeoutMs` 控制（默认 5 分钟）。AI 解决成功后自动执行 `git add . && git merge --continue` 完成合并。
+   AI 解决冲突时，调用 Claude Code CLI 在主 worktree 中分析并解决冲突文件，超时时间由配置项 `conflictResolveTimeoutMs` 控制（默认 10 分钟）。AI 解决成功后自动执行 `git add . && git merge --continue` 完成合并。
 10. **推送（受 `autoPullPush` 配置控制）**
    - `autoPullPush` 为 `false` → 输出提示 `已跳过自动 pull/push，请手动执行 git pull && git push`
    - `autoPullPush` 为 `true` → 执行 `git pull` + `git push`：

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawt",
-  "version": "3.8.1",
+  "version": "3.8.3",
   "description": "本地并行执行多个Claude Code Agent任务，融合 Git Worktree 与 Claude Code CLI 的命令行工具",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/merge.ts

@@ -35,6 +35,8 @@ import {
   getMainWorkBranch,
   getCurrentBranch,
   handleMergeConflict,
+  promptCommitMessage,
+  isNonInteractive,
 } from '../utils/index.js';
 import type { WorktreeResolveMessages } from '../utils/index.js';
 
@@ -62,6 +64,18 @@ const MERGE_RESOLVE_MESSAGES: WorktreeResolveMessages = {
   noMatch: MESSAGES.MERGE_NO_MATCH,
 };
 
+/**
+ * 执行 squash 提交：暂存所有变更并提交
+ * @param {string} message - 提交信息
+ * @param {string} worktreePath - 目标 worktree 路径
+ * @param {string} branchName - 分支名（用于输出提示）
+ */
+function commitSquash(message: string, worktreePath: string, branchName: string): void {
+  gitAddAll(worktreePath);
+  gitCommit(message, worktreePath);
+  printSuccess(MESSAGES.MERGE_SQUASH_COMMITTED(branchName));
+}
+
 /**
  * 检测并处理目标分支的 auto-save 提交压缩
  * 如果检测到 sync 产生的临时提交，提示用户是否将所有提交压缩为一个
@@ -98,14 +112,24 @@ async function handleSquashIfNeeded(
 
   if (commitMessage) {
     // 有 -m 参数，直接提交
-    gitCommit(commitMessage, targetWorktreePath);
-    printSuccess(MESSAGES.MERGE_SQUASH_COMMITTED(branchName));
+    commitSquash(commitMessage, targetWorktreePath, branchName);
     return false;
   }
 
-  // 没有 -m 参数，提示用户自行提交
-  printInfo(MESSAGES.MERGE_SQUASH_PENDING(targetWorktreePath, branchName));
-  return true;
+  // 非交互模式下保持原有温和退出行为（不执行 gitAddAll，不改变暂存区）
+  if (isNonInteractive()) {
+    printInfo(MESSAGES.MERGE_SQUASH_PENDING(targetWorktreePath, branchName));
+    return true;
+  }
+
+  // 交互式询问用户输入提交信息
+  const userCommitMessage = await promptCommitMessage(
+    MESSAGES.MERGE_SQUASH_PROMPT_COMMIT_MESSAGE,
+    MESSAGES.MERGE_SQUASH_PENDING(targetWorktreePath, branchName),
+  );
+  // 用户输入完成后再提交，避免用户退出时暂存区被不必要地改变
+  commitSquash(userCommitMessage, targetWorktreePath, branchName);
+  return false;
 }
 
 /**
@@ -171,12 +195,14 @@ async function handleMerge(options: MergeOptions): Promise<void> {
   const targetClean = isWorkingDirClean(targetWorktreePath);
 
   if (!targetClean) {
-    // 目标 worktree 有未提交修改，必须提供 -m
-    if (!options.message) {
-      throw new ClawtError(MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE(targetWorktreePath));
-    }
+    // 目标 worktree 有未提交修改，需要提交信息
+    const commitMessage = options.message
+      ?? await promptCommitMessage(
+        MESSAGES.MERGE_PROMPT_COMMIT_MESSAGE,
+        MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE(targetWorktreePath),
+      );
     gitAddAll(targetWorktreePath);
-    gitCommit(options.message, targetWorktreePath);
+    gitCommit(commitMessage, targetWorktreePath);
   } else {
     // 目标 worktree 干净，检查是否有本地提交
     if (!hasLocalCommits(branch, mainWorktreePath)) {

package/src/constants/config.ts

@@ -53,8 +53,8 @@ export const CONFIG_DEFINITIONS: ConfigDefinitions = {
     allowedValues: ['ask', 'auto', 'manual'] as const,
   },
   conflictResolveTimeoutMs: {
-    defaultValue: 300000,
-    description: 'Claude Code 冲突解决超时时间（毫秒），默认 300000（5 分钟）',
+    defaultValue: 600000,
+    description: 'Claude Code 冲突解决超时时间（毫秒），默认 600000（10 分钟）',
   },
 };
 

package/src/constants/messages/merge.ts

@@ -55,4 +55,8 @@ export const MERGE_MESSAGES = {
     `Claude Code 解决冲突失败: ${errorMsg}\n  请手动处理：\n  解决冲突后执行 git add . && git merge --continue`,
   /** --auto 模式下的冲突手动解决（配置为 manual） */
   MERGE_CONFLICT_MANUAL: '合并存在冲突，请手动处理：\n  解决冲突后执行 git add . && git merge --continue',
+  /** 目标 worktree 有未提交修改时的交互式提交信息提示 */
+  MERGE_PROMPT_COMMIT_MESSAGE: '目标 worktree 有未提交的修改，请输入提交信息',
+  /** squash 后的交互式提交信息提示 */
+  MERGE_SQUASH_PROMPT_COMMIT_MESSAGE: '请输入 squash 后的提交信息',
 } as const;

package/src/utils/conflict-resolver.ts

@@ -10,7 +10,7 @@ import { CONFLICT_RESOLVE_PROMPT } from '../constants/ai-prompts.js';
 import { getEnvWithoutNestedSessionFlag } from './shell.js';
 
 /** 默认 Claude Code 冲突解决超时时间（毫秒） */
-const DEFAULT_CONFLICT_RESOLVE_TIMEOUT_MS = 300000;
+const DEFAULT_CONFLICT_RESOLVE_TIMEOUT_MS = 600000;
 
 /**
  * 构建发送给 Claude Code 的冲突解决 prompt

package/src/utils/index.ts

@@ -64,7 +64,7 @@ export { createWorktrees, getProjectWorktrees, getProjectWorktreeDir, cleanupWor
 export { loadConfig, writeDefaultConfig, writeConfig, saveConfig, getConfigValue, ensureClawtDirs, parseConcurrency } from './config.js';
 export { printSuccess, printError, printWarning, printInfo, printHint, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle, formatDuration, formatRelativeTime, formatDiskSize, formatLocalISOString, generateTaskFilename } from './formatter.js';
 export { ensureDir, removeEmptyDir, calculateDirSize } from './fs.js';
-export { multilineInput } from './prompt.js';
+export { multilineInput, promptCommitMessage } from './prompt.js';
 export { launchInteractiveClaude, hasClaudeSessionHistory, launchInteractiveClaudeInNewTerminal } from './claude.js';
 export { getSnapshotPath, hasSnapshot, getSnapshotModifiedTime, readSnapshotTreeHash, readSnapshot, writeSnapshot, removeSnapshot, removeProjectSnapshots, getProjectSnapshotBranches } from './validate-snapshot.js';
 export { findExactMatch, findFuzzyMatches, promptGroupedMultiSelectBranches, resolveTargetWorktree, resolveTargetWorktrees, groupWorktreesByDate, buildGroupedChoices, buildGroupMembershipMap, formatRelativeDate, getWorktreeCreatedDate, getWorktreeCreatedTime } from './worktree-matcher.js';

package/src/utils/prompt.ts

@@ -1,4 +1,6 @@
 import Enquirer from 'enquirer';
+import { isNonInteractive } from './interactive.js';
+import { ClawtError } from '../errors/index.js';
 
 /**
  * 多行交互式输入框
@@ -16,3 +18,35 @@ export async function multilineInput(message: string): Promise<string> {
   const result: string = await prompt.run();
   return result;
 }
+
+/**
+ * 交互式询问提交信息（单行输入）
+ * 非交互模式下直接抛出 ClawtError，空输入同样抛错
+ * @param {string} promptMessage - 交互式提示信息
+ * @param {string} nonInteractiveErrorMessage - 非交互模式下的错误消息
+ * @returns {Promise<string>} 用户输入的提交信息
+ * @throws {ClawtError} 非交互模式或用户输入为空时抛出
+ */
+export async function promptCommitMessage(
+  promptMessage: string,
+  nonInteractiveErrorMessage: string,
+): Promise<string> {
+  // 非交互模式下无法弹出输入框，直接抛错
+  if (isNonInteractive()) {
+    throw new ClawtError(nonInteractiveErrorMessage);
+  }
+
+  // @ts-expect-error enquirer 类型声明未导出 Input 类，但运行时存在
+  const prompt = new Enquirer.Input({
+    message: promptMessage,
+  });
+
+  const result: string = await prompt.run();
+
+  // 空输入视为无效
+  if (!result.trim()) {
+    throw new ClawtError('提交信息不能为空');
+  }
+
+  return result.trim();
+}

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

@@ -28,6 +28,8 @@ vi.mock('../../../src/constants/index.js', async (importOriginal) => {
       MERGE_SQUASH_COMMITTED: (branch: string) => `已压缩提交: ${branch}`,
       MERGE_SQUASH_PENDING: (path: string, branch: string) => `请手动提交: ${path}`,
       MERGE_VALIDATE_STATE_HINT: (branch: string) => `分支 ${branch} 存在 validate 状态`,
+      MERGE_PROMPT_COMMIT_MESSAGE: '目标 worktree 有未提交的修改，请输入提交信息',
+      MERGE_SQUASH_PROMPT_COMMIT_MESSAGE: '请输入 squash 后的提交信息',
       MAIN_WORKTREE_DIRTY: '主 worktree 有未提交的更改',
       TARGET_WORKTREE_DIRTY_NO_MESSAGE: (worktreePath: string) =>
         `${worktreePath} 有未提交修改，请提供 -m 参数`,
@@ -79,6 +81,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   guardMainWorkBranchExists: vi.fn(),
   handleMergeConflict: vi.fn(),
   isNonInteractive: vi.fn().mockReturnValue(false),
+  promptCommitMessage: vi.fn(),
 }));
 
 import { registerMergeCommand } from '../../../src/commands/merge.js';
@@ -104,6 +107,8 @@ import {
   hasCommitWithMessage,
   resolveTargetWorktree,
   handleMergeConflict,
+  promptCommitMessage,
+  isNonInteractive,
 } from '../../../src/utils/index.js';
 
 const mockedGetProjectName = vi.mocked(getProjectName);
@@ -127,6 +132,8 @@ const mockedCleanupWorktrees = vi.mocked(cleanupWorktrees);
 const mockedHasCommitWithMessage = vi.mocked(hasCommitWithMessage);
 const mockedResolveTargetWorktree = vi.mocked(resolveTargetWorktree);
 const mockedHandleMergeConflict = vi.mocked(handleMergeConflict);
+const mockedPromptCommitMessage = vi.mocked(promptCommitMessage);
+const mockedIsNonInteractive = vi.mocked(isNonInteractive);
 
 const worktree = { path: '/path/feature', branch: 'feature' };
 
@@ -153,6 +160,9 @@ beforeEach(() => {
   mockedCleanupWorktrees.mockReset();
   mockedHandleMergeConflict.mockReset();
   mockedHandleMergeConflict.mockResolvedValue(true); // 默认 AI 解决成功
+  mockedPromptCommitMessage.mockReset();
+  mockedIsNonInteractive.mockReset();
+  mockedIsNonInteractive.mockReturnValue(false); // 默认交互模式
 });
 
 describe('registerMergeCommand', () => {
@@ -177,18 +187,22 @@ describe('handleMerge', () => {
     ).rejects.toThrow();
   });
 
-  it('目标 worktree 有未提交修改但未提供 -m 时抛出', async () => {
+  it('目标 worktree 有未提交修改且无 -m 时交互式询问提交信息', async () => {
     mockedIsWorkingDirClean
       .mockReturnValueOnce(true) // 主 worktree 干净
       .mockReturnValueOnce(false); // 目标 worktree 不干净
+    mockedPromptCommitMessage.mockResolvedValue('用户输入的提交信息');
+    mockedConfirmAction.mockResolvedValue(false);
 
     const program = new Command();
     program.exitOverride();
     registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
 
-    await expect(
-      program.parseAsync(['merge', '-b', 'feature'], { from: 'user' }),
-    ).rejects.toThrow();
+    expect(mockedPromptCommitMessage).toHaveBeenCalled();
+    expect(mockedGitAddAll).toHaveBeenCalledWith('/path/feature');
+    expect(mockedGitCommit).toHaveBeenCalledWith('用户输入的提交信息', '/path/feature');
+    expect(mockedGitMerge).toHaveBeenCalledWith('feature', '/repo');
   });
 
   it('目标 worktree 有未提交修改且提供 -m 时先提交再合并', async () => {
@@ -390,4 +404,94 @@ describe('handleMerge', () => {
 
     expect(mockedPrintWarning).toHaveBeenCalled();
   });
+
+  it('非交互模式下目标 worktree 有未提交修改且无 -m 时 promptCommitMessage 抛错', async () => {
+    mockedIsWorkingDirClean
+      .mockReturnValueOnce(true)   // 主 worktree 干净
+      .mockReturnValueOnce(false); // 目标 worktree 不干净
+    mockedPromptCommitMessage.mockRejectedValue(new Error('/path/feature 有未提交修改，请提供 -m 参数'));
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+
+    await expect(
+      program.parseAsync(['merge', '-b', 'feature'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('squash 后无 -m 交互模式下询问用户输入并继续合并', async () => {
+    // 主 worktree 干净
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    // 存在 auto-save commit
+    mockedHasCommitWithMessage.mockReturnValue(true);
+    // 用户选择压缩
+    mockedConfirmAction.mockResolvedValueOnce(true)  // squash 确认
+      .mockResolvedValueOnce(false); // 不清理 worktree
+    // mock promptCommitMessage 返回用户输入
+    mockedPromptCommitMessage.mockResolvedValue('squash 提交信息');
+    // 有本地提交
+    mockedHasLocalCommits.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedPromptCommitMessage).toHaveBeenCalled();
+    expect(mockedGitAddAll).toHaveBeenCalledWith('/path/feature');
+    expect(mockedGitCommit).toHaveBeenCalledWith('squash 提交信息', '/path/feature');
+    expect(mockedGitMerge).toHaveBeenCalledWith('feature', '/repo');
+
+    // 验证 gitAddAll 在 promptCommitMessage 之后调用（延后到确定要提交时才执行）
+    const addAllOrder = mockedGitAddAll.mock.invocationCallOrder[0];
+    const promptOrder = mockedPromptCommitMessage.mock.invocationCallOrder[0];
+    const commitOrder = mockedGitCommit.mock.invocationCallOrder[0];
+    expect(addAllOrder).toBeGreaterThan(promptOrder);
+    expect(addAllOrder).toBeLessThan(commitOrder);
+  });
+
+  it('squash 后 gitAddAll 应在 gitResetSoftTo 之后被调用以暂存工作区变更', async () => {
+    // 主 worktree 干净
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    // 存在 auto-save commit
+    mockedHasCommitWithMessage.mockReturnValue(true);
+    // 用户选择压缩
+    mockedConfirmAction.mockResolvedValueOnce(true)  // squash 确认
+      .mockResolvedValueOnce(false); // 不清理 worktree
+    // 有本地提交
+    mockedHasLocalCommits.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature', '-m', 'squash msg'], { from: 'user' });
+
+    // 验证 squash 流程中 gitAddAll 在 gitCommit 之前被调用
+    expect(mockedGitAddAll).toHaveBeenCalledWith('/path/feature');
+    expect(mockedGitCommit).toHaveBeenCalledWith('squash msg', '/path/feature');
+
+    // 步骤 4 不应再触发（squash 已处理完毕，工作区应干净）
+    expect(mockedGitMerge).toHaveBeenCalledWith('feature', '/repo');
+  });
+
+  it('squash 后无 -m 非交互模式下提示自行处理并退出', async () => {
+    // 主 worktree 干净
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    // 存在 auto-save commit
+    mockedHasCommitWithMessage.mockReturnValue(true);
+    // 用户选择压缩
+    mockedConfirmAction.mockResolvedValue(true);
+    // 非交互模式
+    mockedIsNonInteractive.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    // 非交互模式下不执行 gitAddAll 和 gitMerge，提前退出
+    expect(mockedGitAddAll).not.toHaveBeenCalled();
+    expect(mockedGitMerge).not.toHaveBeenCalled();
+  });
 });

package/tests/unit/utils/prompt.test.ts

@@ -1,5 +1,24 @@
 import { describe, it, expect, vi } from 'vitest';
 
+// mock 非交互模式判断函数
+const { mockIsNonInteractive } = vi.hoisted(() => {
+  return { mockIsNonInteractive: vi.fn().mockReturnValue(false) };
+});
+
+vi.mock('../../../src/utils/interactive.js', () => ({
+  isNonInteractive: mockIsNonInteractive,
+}));
+
+vi.mock('../../../src/errors/index.js', () => ({
+  ClawtError: class ClawtError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode = 1) {
+      super(message);
+      this.exitCode = exitCode;
+    }
+  },
+}));
+
 // mock enquirer - 使用 vi.hoisted 确保变量在 vi.mock 提升后仍可访问
 const { mockRun, MockInput } = vi.hoisted(() => {
   const mockRun = vi.fn();
@@ -16,7 +35,7 @@ vi.mock('enquirer', () => ({
   },
 }));
 
-import { multilineInput } from '../../../src/utils/prompt.js';
+import { multilineInput, promptCommitMessage } from '../../../src/utils/prompt.js';
 
 describe('multilineInput', () => {
   it('返回用户输入的内容', async () => {
@@ -51,3 +70,49 @@ describe('multilineInput', () => {
     expect(result).toBe('第一行\n第二行\n第三行');
   });
 });
+
+describe('promptCommitMessage', () => {
+  it('交互模式下正常返回用户输入', async () => {
+    mockIsNonInteractive.mockReturnValue(false);
+    mockRun.mockResolvedValue('用户输入的提交信息');
+
+    const result = await promptCommitMessage('请输入提交信息', '非交互模式错误');
+
+    expect(result).toBe('用户输入的提交信息');
+  });
+
+  it('非交互模式下抛出 ClawtError', async () => {
+    mockIsNonInteractive.mockReturnValue(true);
+
+    await expect(
+      promptCommitMessage('请输入提交信息', '非交互模式下不可用'),
+    ).rejects.toThrow('非交互模式下不可用');
+  });
+
+  it('用户输入为空时抛出 ClawtError', async () => {
+    mockIsNonInteractive.mockReturnValue(false);
+    mockRun.mockResolvedValue('');
+
+    await expect(
+      promptCommitMessage('请输入提交信息', '非交互模式错误'),
+    ).rejects.toThrow('提交信息不能为空');
+  });
+
+  it('用户输入仅空白字符时抛出 ClawtError', async () => {
+    mockIsNonInteractive.mockReturnValue(false);
+    mockRun.mockResolvedValue('   ');
+
+    await expect(
+      promptCommitMessage('请输入提交信息', '非交互模式错误'),
+    ).rejects.toThrow('提交信息不能为空');
+  });
+
+  it('返回 trim 后的用户输入', async () => {
+    mockIsNonInteractive.mockReturnValue(false);
+    mockRun.mockResolvedValue('  提交信息  ');
+
+    const result = await promptCommitMessage('请输入提交信息', '非交互模式错误');
+
+    expect(result).toBe('提交信息');
+  });
+});