clawt 3.8.0 → 3.8.2

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
@@ -242,7 +244,7 @@ clawt home
 ### `clawt tasks` — 任务文件管理
 
 ```bash
-clawt tasks init             # 生成任务模板文件（默认输出到 clawt/tasks/ 目录）
+clawt tasks init             # 生成任务模板文件（默认输出到 .clawt/tasks/ 目录）
 clawt tasks init [path]      # 指定输出路径
 ```
 

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
@@ -890,7 +894,7 @@ var PRE_CHECK_RESUME = {
 };
 
 // src/constants/tasks-template.ts
-var TASK_TEMPLATE_OUTPUT_DIR = "clawt/tasks";
+var TASK_TEMPLATE_OUTPUT_DIR = ".clawt/tasks";
 var TASK_TEMPLATE_FILENAME_PREFIX = "clawt-tasks";
 var TASK_TEMPLATE_CONTENT = `# Clawt \u4EFB\u52A1\u6587\u4EF6
 #
@@ -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";
@@ -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

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`）
      - 有本地提交 → 跳过提交步骤，直接进入合并

package/docs/tasks.md

@@ -3,7 +3,7 @@
 **命令：**
 
 ```bash
-# 生成任务模板文件（默认输出到 clawt/tasks/ 目录）
+# 生成任务模板文件（默认输出到 .clawt/tasks/ 目录）
 clawt tasks init
 
 # 指定输出路径
@@ -20,7 +20,7 @@ clawt tasks init [path]
 
 | 参数 | 必填 | 说明 |
 | ---- | ---- | ---- |
-| `[path]` | 否 | 输出文件路径。不传时默认输出到 `clawt/tasks/clawt-tasks-<时间戳>.md` |
+| `[path]` | 否 | 输出文件路径。不传时默认输出到 `.clawt/tasks/clawt-tasks-<时间戳>.md` |
 
 **功能说明：**
 
@@ -30,7 +30,7 @@ clawt tasks init [path]
 
 1. **确定输出路径**：
    - 传了 `[path]` → 使用指定路径
-   - 未传 → 默认输出到 `clawt/tasks/clawt-tasks-<时间戳>.md`（由 `generateTaskFilename` 生成唯一文件名）
+   - 未传 → 默认输出到 `.clawt/tasks/clawt-tasks-<时间戳>.md`（由 `generateTaskFilename` 生成唯一文件名）
 2. **路径转换**：将路径转为绝对路径（`path.resolve`）
 3. **文件存在性校验**：如果目标文件已存在，抛出错误退出
 4. **创建父目录**：确保输出路径的父目录存在（`ensureDir`）
@@ -66,7 +66,7 @@ clawt tasks init [path]
 
 - 命令注册函数 `registerTasksCommand` 位于 `src/commands/tasks.ts`
 - 模板内容和常量定义在 `src/constants/tasks-template.ts`：
-  - `TASK_TEMPLATE_OUTPUT_DIR`（`clawt/tasks`）：默认输出目录
+  - `TASK_TEMPLATE_OUTPUT_DIR`（`.clawt/tasks`）：默认输出目录
   - `TASK_TEMPLATE_FILENAME_PREFIX`（`clawt-tasks`）：文件名前缀
   - `TASK_TEMPLATE_CONTENT`：模板文件内容
 - 消息常量定义在 `src/constants/messages/tasks.ts`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawt",
-  "version": "3.8.0",
+  "version": "3.8.2",
   "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/commands/tasks.ts

@@ -20,7 +20,7 @@ export function registerTasksCommand(program: Command): void {
     .description('生成任务模板文件')
     .argument('[path]', '输出文件路径')
     .action(async (path?: string) => {
-      // 未指定路径时，默认输出到 clawt/tasks/ 目录下
+      // 未指定路径时，默认输出到 .clawt/tasks/ 目录下
       const filePath = path ?? join(TASK_TEMPLATE_OUTPUT_DIR, generateTaskFilename(TASK_TEMPLATE_FILENAME_PREFIX));
       await handleTasksInit(filePath);
     });

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/constants/tasks-template.ts

@@ -1,5 +1,5 @@
 /** 任务模板默认输出目录 */
-export const TASK_TEMPLATE_OUTPUT_DIR = 'clawt/tasks';
+export const TASK_TEMPLATE_OUTPUT_DIR = '.clawt/tasks';
 
 /** 任务模板文件名前缀 */
 export const TASK_TEMPLATE_FILENAME_PREFIX = 'clawt-tasks';

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/commands/tasks.test.ts

@@ -11,7 +11,7 @@ vi.mock('../../../src/constants/index.js', () => ({
     TASK_INIT_SUCCESS: (path: string) => `✓ 任务模板已生成: ${path}`,
     TASK_INIT_HINT: (path: string) => `使用 clawt run -f ${path} 执行任务`,
   },
-  TASK_TEMPLATE_OUTPUT_DIR: 'clawt/tasks',
+  TASK_TEMPLATE_OUTPUT_DIR: '.clawt/tasks',
   TASK_TEMPLATE_FILENAME_PREFIX: 'clawt-tasks',
   TASK_TEMPLATE_CONTENT: '# 模板内容',
 }));
@@ -90,17 +90,17 @@ describe('handleTasksInit', () => {
     await program.parseAsync(['tasks', 'init'], { from: 'user' });
 
     expect(mockGenerateTaskFilename).toHaveBeenCalledWith('clawt-tasks');
-    // 默认路径应输出到 clawt/tasks/ 目录下
+    // 默认路径应输出到 .clawt/tasks/ 目录下
     expect(mockWriteFileSync).toHaveBeenCalledWith(
-      expect.stringContaining('clawt/tasks/clawt-tasks-2026-01-01-00-00-00.md'),
+      expect.stringContaining('.clawt/tasks/clawt-tasks-2026-01-01-00-00-00.md'),
       '# 模板内容',
       'utf-8',
     );
     expect(mockedPrintSuccess).toHaveBeenCalledWith(
-      expect.stringContaining('clawt/tasks/clawt-tasks-2026-01-01-00-00-00.md'),
+      expect.stringContaining('.clawt/tasks/clawt-tasks-2026-01-01-00-00-00.md'),
     );
     expect(mockedPrintHint).toHaveBeenCalledWith(
-      expect.stringContaining('clawt/tasks/clawt-tasks-2026-01-01-00-00-00.md'),
+      expect.stringContaining('.clawt/tasks/clawt-tasks-2026-01-01-00-00-00.md'),
     );
   });
 

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('提交信息');
+  });
+});