clawt 2.19.0 → 2.20.0

package/dist/postinstall.js

@@ -487,6 +487,10 @@ var CONFIG_DESCRIPTIONS = deriveConfigDescriptions(CONFIG_DEFINITIONS);
 // src/constants/update.ts
 var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 
+// src/constants/prompt.ts
+import chalk from "chalk";
+var UNKNOWN_DATE_SEPARATOR_LABEL = `\u2550\u2550\u2550\u2550 ${chalk.bold.hex("#FF8C00")("\u672A\u77E5\u65E5\u671F")} \u2550\u2550\u2550\u2550`;
+
 // scripts/postinstall.ts
 function ensureDirectory(dirPath) {
   if (!existsSync(dirPath)) {

package/docs/spec.md

@@ -1346,13 +1346,13 @@ clawt resume
 
 1. **主 worktree 校验** (2.1)
 2. **Claude Code CLI 校验**：确认 `claude` CLI 可用
-3. **解析目标 worktree（多选模式）**：统一使用 `resolveTargetWorktrees`（多选版本）解析目标 worktree，匹配策略如下：
+3. **解析目标 worktree**：根据是否传入 `-b` 参数以及 worktree 数量，采用不同的解析策略：
    - **未传 `-b` 参数**：
      - 获取当前项目所有 worktree
      - 无可用 worktree → 报错退出
-     - 仅 1 个 worktree → 直接使用，无需选择
-     - 多个 worktree → 通过交互式多选列表（Enquirer.MultiSelect）让用户选择（空格选择，回车确认），顶部提供「全选」选项
-   - **传了 `-b` 参数**：
+     - 仅 1 个 worktree → 通过 `resolveTargetWorktrees` 直接使用，无需选择
+     - 多个 worktree → 通过 `promptGroupedMultiSelectBranches` 展示**按日期分组的交互式多选列表**（详见下文「按日期分组多选」）
+   - **传了 `-b` 参数**：通过 `resolveTargetWorktrees` 解析，匹配策略如下：
      1. **精确匹配优先**：在 worktree 列表中查找分支名完全相同的 worktree，找到则直接使用
      2. **模糊匹配**（子串匹配，大小写不敏感）：
         - 唯一匹配 → 直接使用
@@ -1387,6 +1387,32 @@ clawt resume
 
 启动命令通过配置项 `claudeCodeCommand`（默认值 `claude`）指定，与 `clawt run` 不传 `--tasks` 时的交互式界面行为一致。
 
+**按日期分组多选：**
+
+当未传 `-b` 且有多个 worktree 时，使用 `promptGroupedMultiSelectBranches` 展示按创建日期分组的交互式多选列表，实现流程如下：
+
+1. **日期分组**（`groupWorktreesByDate`）：通过 `statSync` 获取各 worktree 目录的文件系统创建时间（`birthtime`），按本地时区格式化为 `YYYY-MM-DD` 作为分组键。无法获取创建时间的分支归入「未知日期」组。分组按日期降序排列，未知日期组在最后。
+2. **构建选项列表**（`buildGroupedChoices`）：生成包含以下元素的 Enquirer MultiSelect choices 数组：
+   - 顶部：全局全选选项 `[select-all]`
+   - 每组：日期分隔线（显示日期和相对时间，如「2026-02-26（昨天）」）→ 组级全选选项 `[select-all: YYYY-MM-DD]` → 该组内各分支
+3. **三级联动选择**：通过继承 Enquirer MultiSelect 并覆写 `space()` 方法实现：
+   - **全局全选**：toggle 所有 choices（含组全选）
+   - **组级全选**：toggle 该组内所有分支，并同步全局全选状态
+   - **普通分支**：toggle 该分支，同步所属组全选和全局全选状态
+4. **过滤结果**：返回时过滤掉全选项和组全选项，只返回实际选中的 worktree
+
+相对日期显示规则：`formatRelativeDate` 基于自然日差值计算——今天 / 昨天 / N 天前 / N 个月前 / N 年前。
+
+相关常量定义在 `src/constants/prompt.ts`：
+
+| 常量 | 说明 |
+| ---- | ---- |
+| `GROUP_SELECT_ALL_PREFIX` | 组级全选选项的 name 前缀（`__group_select_all_`） |
+| `GROUP_SELECT_ALL_LABEL(dateLabel)` | 生成组级全选选项的显示文本 |
+| `GROUP_SEPARATOR_LABEL(dateLabel, relativeTime)` | 生成日期分隔线的显示文本（含 chalk 高亮） |
+| `UNKNOWN_DATE_GROUP` | 无法获取创建日期时的默认分组名称（`未知日期`） |
+| `UNKNOWN_DATE_SEPARATOR_LABEL` | 未知日期分组的分隔线显示文本 |
+
 **会话自动续接：** 启动前会自动检测该 worktree 是否存在 Claude Code 历史会话（通过检查 `~/.claude/projects/<encoded-path>/` 下是否有 `.jsonl` 文件判断），如果存在则自动追加 `--continue` 参数继续上次对话，否则打开新对话。启动信息中会显示当前模式（"继续上次对话"或"新对话"）。路径编码规则：将绝对路径中所有非字母数字字符替换为 `-`（与 Claude Code 源码的编码逻辑一致）。
 
 ---

package/package.json

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

package/src/commands/resume.ts

@@ -11,6 +11,7 @@ import {
   launchInteractiveClaudeInNewTerminal,
   hasClaudeSessionHistory,
   resolveTargetWorktrees,
+  promptGroupedMultiSelectBranches,
   printInfo,
   printSuccess,
   confirmAction,
@@ -51,8 +52,13 @@ async function handleResume(options: ResumeOptions): Promise<void> {
   logger.info(`resume 命令执行，分支过滤: ${options.branch ?? '(无)'}`);
   const worktrees = getProjectWorktrees();
 
-  // 统一走多选解析（精确匹配 / 模糊匹配 / 交互多选）
-  const targetWorktrees = await resolveTargetWorktrees(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
+  // 未指定 -b 且有多个 worktree 时，默认使用按日期分组的多选交互
+  let targetWorktrees: WorktreeInfo[];
+  if (!options.branch && worktrees.length > 1) {
+    targetWorktrees = await promptGroupedMultiSelectBranches(worktrees, RESUME_RESOLVE_MESSAGES.selectBranch);
+  } else {
+    targetWorktrees = await resolveTargetWorktrees(worktrees, RESUME_RESOLVE_MESSAGES, options.branch);
+  }
 
   // 用户未选择任何分支时直接退出
   if (targetWorktrees.length === 0) {

package/src/constants/index.ts

@@ -29,4 +29,4 @@ export {
   CLEAR_SCREEN,
   CURSOR_HOME,
 } from './progress.js';
-export { SELECT_ALL_NAME, SELECT_ALL_LABEL } from './prompt.js';
+export { SELECT_ALL_NAME, SELECT_ALL_LABEL, GROUP_SELECT_ALL_PREFIX, GROUP_SELECT_ALL_LABEL, GROUP_SEPARATOR_LABEL, UNKNOWN_DATE_GROUP, UNKNOWN_DATE_SEPARATOR_LABEL } from './prompt.js';

package/src/constants/prompt.ts

@@ -1,5 +1,33 @@
+import chalk from 'chalk';
+
 /** 多选列表中全选选项的标识名称 */
 export const SELECT_ALL_NAME = '__select_all__';
 
 /** 多选列表中全选选项的显示文本 */
 export const SELECT_ALL_LABEL = '[select-all]';
+
+/** 组级全选选项的 name 前缀 */
+export const GROUP_SELECT_ALL_PREFIX = '__group_select_all_';
+
+/**
+ * 生成组级全选选项的显示文本
+ * @param {string} dateLabel - 日期标签
+ * @returns {string} 格式化的组全选显示文本
+ */
+export const GROUP_SELECT_ALL_LABEL = (dateLabel: string): string => `[select-all: ${dateLabel}]`;
+
+/**
+ * 生成日期分组分隔线的显示文本
+ * 日期部分高亮显示，两侧使用 === 分隔线增强视觉区分
+ * @param {string} dateLabel - 日期标签
+ * @param {string} relativeTime - 相对时间描述
+ * @returns {string} 格式化的分隔线文本
+ */
+export const GROUP_SEPARATOR_LABEL = (dateLabel: string, relativeTime: string): string =>
+  `════ ${chalk.bold.hex('#FF8C00')(dateLabel)}（${chalk.hex('#FF8C00')(relativeTime)}） ════`;
+
+/** 无法获取创建日期时的默认分组名称 */
+export const UNKNOWN_DATE_GROUP = '未知日期';
+
+/** 未知日期分组的分隔线显示文本 */
+export const UNKNOWN_DATE_SEPARATOR_LABEL = `════ ${chalk.bold.hex('#FF8C00')('未知日期')} ════`;

package/src/utils/index.ts

@@ -56,7 +56,7 @@ export { ensureDir, removeEmptyDir, calculateDirSize } from './fs.js';
 export { multilineInput } 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, promptSelectBranch, promptMultiSelectBranches, resolveTargetWorktree, resolveTargetWorktrees } from './worktree-matcher.js';
+export { findExactMatch, findFuzzyMatches, promptSelectBranch, promptMultiSelectBranches, promptGroupedMultiSelectBranches, resolveTargetWorktree, resolveTargetWorktrees, groupWorktreesByDate, buildGroupedChoices, buildGroupMembershipMap } from './worktree-matcher.js';
 export type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from './worktree-matcher.js';
 export { ProgressRenderer } from './progress.js';
 export { parseTaskFile, loadTaskFile, parseTasksFromOptions } from './task-file.js';

package/src/utils/worktree-matcher.ts

@@ -1,6 +1,15 @@
 import Enquirer from 'enquirer';
+import { statSync } from 'node:fs';
 import { ClawtError } from '../errors/index.js';
-import { SELECT_ALL_NAME, SELECT_ALL_LABEL } from '../constants/index.js';
+import {
+  SELECT_ALL_NAME,
+  SELECT_ALL_LABEL,
+  GROUP_SELECT_ALL_PREFIX,
+  GROUP_SELECT_ALL_LABEL,
+  GROUP_SEPARATOR_LABEL,
+  UNKNOWN_DATE_GROUP,
+  UNKNOWN_DATE_SEPARATOR_LABEL,
+} from '../constants/index.js';
 import type { WorktreeInfo } from '../types/index.js';
 
 /** enquirer MultiSelect 选项条目的运行时结构 */
@@ -264,3 +273,261 @@ export async function resolveTargetWorktree(
   const allBranches = worktrees.map((wt) => wt.branch);
   throw new ClawtError(messages.noMatch(branchName, allBranches));
 }
+
+/** enquirer MultiSelect 分隔线条目结构 */
+interface MultiSelectSeparator {
+  role: 'separator';
+  message: string;
+}
+
+/** enquirer MultiSelect choices 数组的条目类型 */
+type GroupedChoice = { name: string; message: string } | MultiSelectSeparator;
+
+/**
+ * 将 Date 对象格式化为本地时区的 YYYY-MM-DD 字符串
+ * @param {Date} date - 日期对象
+ * @returns {string} YYYY-MM-DD 格式的本地日期字符串
+ */
+function formatLocalDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * 获取 worktree 目录的创建日期（本地时区）
+ * 通过文件系统的 birthtime 获取目录实际创建时间，比 git reflog 更准确
+ * @param {string} dirPath - worktree 目录路径
+ * @returns {string | null} YYYY-MM-DD 格式的本地日期字符串，无法获取时返回 null
+ */
+function getWorktreeCreatedDate(dirPath: string): string | null {
+  try {
+    const stat = statSync(dirPath);
+    return formatLocalDate(stat.birthtime);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 将 YYYY-MM-DD 日期字符串格式化为中文相对日期描述
+ * 基于自然日计算，适用于日期分组场景
+ * @param {string} dateStr - YYYY-MM-DD 格式的日期字符串
+ * @returns {string} 中文相对日期描述，如"今天"、"昨天"、"3 天前"
+ */
+function formatRelativeDate(dateStr: string): string {
+  const today = formatLocalDate(new Date());
+  const todayMs = new Date(today).getTime();
+  const targetMs = new Date(dateStr).getTime();
+  const diffDays = Math.round((todayMs - targetMs) / (1000 * 60 * 60 * 24));
+
+  if (diffDays === 0) return '今天';
+  if (diffDays === 1) return '昨天';
+  if (diffDays < 30) return `${diffDays} 天前`;
+  if (diffDays < 365) {
+    const months = Math.floor(diffDays / 30);
+    return `${months} 个月前`;
+  }
+  const years = Math.floor(diffDays / 365);
+  return `${years} 年前`;
+}
+
+/**
+ * 按创建日期对 worktree 列表进行分组
+ * 通过 worktree 目录的文件系统创建时间进行分组
+ * 无法获取日期的分支归入"未知日期"组
+ * @param {WorktreeInfo[]} worktrees - worktree 列表
+ * @returns {Map<string, WorktreeInfo[]>} 日期 → worktree 列表的映射，按日期降序排列，未知日期在最后
+ */
+export function groupWorktreesByDate(worktrees: WorktreeInfo[]): Map<string, WorktreeInfo[]> {
+  const groups = new Map<string, WorktreeInfo[]>();
+
+  for (const wt of worktrees) {
+    const dateKey = getWorktreeCreatedDate(wt.path) ?? UNKNOWN_DATE_GROUP;
+
+    if (!groups.has(dateKey)) {
+      groups.set(dateKey, []);
+    }
+    groups.get(dateKey)!.push(wt);
+  }
+
+  // 按日期降序排列，未知日期放最后
+  const sortedEntries = [...groups.entries()].sort((a, b) => {
+    if (a[0] === UNKNOWN_DATE_GROUP) return 1;
+    if (b[0] === UNKNOWN_DATE_GROUP) return -1;
+    return b[0].localeCompare(a[0]);
+  });
+
+  return new Map(sortedEntries);
+}
+
+/**
+ * 根据分组数据构建 enquirer MultiSelect 的 choices 数组
+ * 包含全局全选、每组的分隔线和组全选、以及各组内的分支选项
+ * @param {Map<string, WorktreeInfo[]>} groups - 日期分组数据
+ * @returns {GroupedChoice[]} enquirer choices 数组
+ */
+export function buildGroupedChoices(groups: Map<string, WorktreeInfo[]>): GroupedChoice[] {
+  const choices: GroupedChoice[] = [];
+
+  // 顶部插入全局全选
+  choices.push({ name: SELECT_ALL_NAME, message: SELECT_ALL_LABEL });
+
+  for (const [dateKey, worktreeList] of groups) {
+    // 分隔线
+    if (dateKey === UNKNOWN_DATE_GROUP) {
+      choices.push({ role: 'separator', message: UNKNOWN_DATE_SEPARATOR_LABEL });
+    } else {
+      const relativeTime = formatRelativeDate(dateKey);
+      choices.push({ role: 'separator', message: GROUP_SEPARATOR_LABEL(dateKey, relativeTime) });
+    }
+
+    // 组级全选
+    const groupSelectAllName = `${GROUP_SELECT_ALL_PREFIX}${dateKey}`;
+    choices.push({ name: groupSelectAllName, message: GROUP_SELECT_ALL_LABEL(dateKey) });
+
+    // 该组内各分支
+    for (const wt of worktreeList) {
+      choices.push({ name: wt.branch, message: wt.branch });
+    }
+  }
+
+  return choices;
+}
+
+/**
+ * 构建组全选 name 到该组分支 name 列表的映射
+ * 用于 space() 方法中快速查找某个组全选项对应的所有分支
+ * @param {Map<string, WorktreeInfo[]>} groups - 日期分组数据
+ * @returns {Map<string, string[]>} 组全选 name → 分支 name 列表的映射
+ */
+export function buildGroupMembershipMap(groups: Map<string, WorktreeInfo[]>): Map<string, string[]> {
+  const map = new Map<string, string[]>();
+
+  for (const [dateKey, worktreeList] of groups) {
+    const groupSelectAllName = `${GROUP_SELECT_ALL_PREFIX}${dateKey}`;
+    map.set(groupSelectAllName, worktreeList.map((wt) => wt.branch));
+  }
+
+  return map;
+}
+
+/**
+ * 通过交互式多选列表（按日期分组）让用户选择多个分支
+ * 提供三级联动：全局全选、组级全选、单个分支
+ * @param {WorktreeInfo[]} worktrees - 可供选择的 worktree 列表
+ * @param {string} message - 选择提示信息
+ * @returns {Promise<WorktreeInfo[]>} 用户选择的 worktree 列表
+ */
+export async function promptGroupedMultiSelectBranches(
+  worktrees: WorktreeInfo[],
+  message: string,
+): Promise<WorktreeInfo[]> {
+  const groups = groupWorktreesByDate(worktrees);
+  const choices = buildGroupedChoices(groups);
+  const groupMembershipMap = buildGroupMembershipMap(groups);
+
+  // 收集所有组全选的 name，用于判断某个 choice 是否为组全选项
+  const groupSelectAllNames = new Set(groupMembershipMap.keys());
+
+  // 收集所有实际分支的 name
+  const allBranchNames = new Set(worktrees.map((wt) => wt.branch));
+
+  // @ts-expect-error enquirer 类型声明未导出 MultiSelect 类，但运行时存在
+  const MultiSelect: new (options: Record<string, unknown>) => MultiSelectInstance = Enquirer.MultiSelect;
+
+  /**
+   * 扩展 MultiSelect，实现三级联动的 space() 覆写
+   * - 全局全选：切换所有 choices（含组全选）
+   * - 组级全选：切换该组内所有分支，同步全局全选状态
+   * - 普通分支：toggle 该分支，同步所属组全选和全局全选状态
+   */
+  class MultiSelectWithGroupSelectAll extends MultiSelect {
+    space(this: MultiSelectInstance) {
+      if (!this.focused) return;
+
+      const focusedName = this.focused.name;
+
+      if (focusedName === SELECT_ALL_NAME) {
+        // 全局全选：切换所有 choices
+        const willEnable = !this.focused.enabled;
+        for (const ch of this.choices) {
+          ch.enabled = willEnable;
+        }
+        return this.render();
+      }
+
+      if (groupSelectAllNames.has(focusedName)) {
+        // 组级全选：切换该组内所有分支
+        const willEnable = !this.focused.enabled;
+        const memberNames = groupMembershipMap.get(focusedName)!;
+        // 切换组全选自身
+        this.focused.enabled = willEnable;
+        // 切换该组的所有分支
+        for (const ch of this.choices) {
+          if (memberNames.includes(ch.name)) {
+            ch.enabled = willEnable;
+          }
+        }
+        // 同步全局全选状态：检查所有实际分支是否全选
+        syncGlobalSelectAll(this.choices);
+        return this.render();
+      }
+
+      // 普通分支：toggle 该分支
+      this.toggle(this.focused);
+
+      // 同步所属组全选状态
+      syncGroupSelectAll(this.choices, focusedName);
+      // 同步全局全选状态
+      syncGlobalSelectAll(this.choices);
+
+      return this.render();
+    }
+  }
+
+  /**
+   * 同步全局全选状态
+   * 根据所有实际分支的选中状态更新全局全选项
+   * @param {MultiSelectChoice[]} choiceList - choices 列表
+   */
+  function syncGlobalSelectAll(choiceList: MultiSelectChoice[]): void {
+    const selectAllChoice = choiceList.find((ch) => ch.name === SELECT_ALL_NAME);
+    if (!selectAllChoice) return;
+
+    const branchItems = choiceList.filter((ch) => allBranchNames.has(ch.name));
+    selectAllChoice.enabled = branchItems.length > 0 && branchItems.every((ch) => ch.enabled);
+  }
+
+  /**
+   * 同步指定分支所属组的全选状态
+   * 根据该组内所有分支的选中状态更新组全选项
+   * @param {MultiSelectChoice[]} choiceList - choices 列表
+   * @param {string} branchName - 刚被 toggle 的分支名
+   */
+  function syncGroupSelectAll(choiceList: MultiSelectChoice[], branchName: string): void {
+    for (const [groupName, memberNames] of groupMembershipMap) {
+      if (!memberNames.includes(branchName)) continue;
+
+      const groupChoice = choiceList.find((ch) => ch.name === groupName);
+      if (!groupChoice) continue;
+
+      const memberChoices = choiceList.filter((ch) => memberNames.includes(ch.name));
+      groupChoice.enabled = memberChoices.length > 0 && memberChoices.every((ch) => ch.enabled);
+      break;
+    }
+  }
+
+  const selectedBranches: string[] = await new MultiSelectWithGroupSelectAll({
+    message,
+    choices,
+    // 使用空心圆/实心圆作为选中指示符
+    symbols: {
+      indicator: { on: '●', off: '○' },
+    },
+  }).run();
+
+  // 过滤掉全选项和组全选项，只返回实际选中的 worktree
+  return worktrees.filter((wt) => selectedBranches.includes(wt.branch));
+}

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

@@ -20,6 +20,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   getProjectWorktrees: vi.fn(),
   launchInteractiveClaude: vi.fn(),
   resolveTargetWorktrees: vi.fn(),
+  promptGroupedMultiSelectBranches: vi.fn(),
 }));
 
 import { registerResumeCommand } from '../../../src/commands/resume.js';
@@ -29,6 +30,7 @@ import {
   getProjectWorktrees,
   launchInteractiveClaude,
   resolveTargetWorktrees,
+  promptGroupedMultiSelectBranches,
 } from '../../../src/utils/index.js';
 
 const mockedValidateMainWorktree = vi.mocked(validateMainWorktree);
@@ -36,6 +38,7 @@ const mockedValidateClaudeCodeInstalled = vi.mocked(validateClaudeCodeInstalled)
 const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
 const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
 const mockedResolveTargetWorktrees = vi.mocked(resolveTargetWorktrees);
+const mockedPromptGroupedMultiSelectBranches = vi.mocked(promptGroupedMultiSelectBranches);
 
 beforeEach(() => {
   mockedValidateMainWorktree.mockReset();
@@ -43,6 +46,7 @@ beforeEach(() => {
   mockedGetProjectWorktrees.mockReset();
   mockedLaunchInteractiveClaude.mockReset();
   mockedResolveTargetWorktrees.mockReset();
+  mockedPromptGroupedMultiSelectBranches.mockReset();
 });
 
 describe('registerResumeCommand', () => {
@@ -55,7 +59,7 @@ describe('registerResumeCommand', () => {
 });
 
 describe('handleResume', () => {
-  it('成功恢复 Claude Code 会话', async () => {
+  it('传 -b 时走标准解析流程', async () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
     mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
@@ -68,10 +72,31 @@ describe('handleResume', () => {
     expect(mockedValidateMainWorktree).toHaveBeenCalled();
     expect(mockedValidateClaudeCodeInstalled).toHaveBeenCalled();
     expect(mockedResolveTargetWorktrees).toHaveBeenCalled();
+    expect(mockedPromptGroupedMultiSelectBranches).not.toHaveBeenCalled();
     expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree, { autoContinue: true });
   });
 
-  it('不传 -b 时也能调用 resolveTargetWorktrees', async () => {
+  it('不传 -b 且多个 worktree 时默认使用分组多选', async () => {
+    const worktrees = [
+      { path: '/path/feature-a', branch: 'feature-a' },
+      { path: '/path/feature-b', branch: 'feature-b' },
+    ];
+    mockedGetProjectWorktrees.mockReturnValue(worktrees);
+    mockedPromptGroupedMultiSelectBranches.mockResolvedValue([worktrees[0]]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume'], { from: 'user' });
+
+    expect(mockedPromptGroupedMultiSelectBranches).toHaveBeenCalledWith(
+      worktrees,
+      expect.any(String),
+    );
+    expect(mockedResolveTargetWorktrees).not.toHaveBeenCalled();
+  });
+
+  it('仅 1 个 worktree 时走标准流程', async () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
     mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
@@ -81,11 +106,7 @@ describe('handleResume', () => {
     registerResumeCommand(program);
     await program.parseAsync(['resume'], { from: 'user' });
 
-    // branchName 参数为 undefined
-    expect(mockedResolveTargetWorktrees).toHaveBeenCalledWith(
-      expect.any(Array),
-      expect.any(Object),
-      undefined,
-    );
+    expect(mockedResolveTargetWorktrees).toHaveBeenCalled();
+    expect(mockedPromptGroupedMultiSelectBranches).not.toHaveBeenCalled();
   });
 });

package/tests/unit/utils/worktree-matcher.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi } from 'vitest';
-import { findExactMatch, findFuzzyMatches, resolveTargetWorktree, resolveTargetWorktrees } from '../../../src/utils/worktree-matcher.js';
+import { findExactMatch, findFuzzyMatches, resolveTargetWorktree, resolveTargetWorktrees, groupWorktreesByDate, buildGroupedChoices, buildGroupMembershipMap } from '../../../src/utils/worktree-matcher.js';
 import { createWorktreeInfo, createWorktreeList } from '../../helpers/fixtures.js';
 import { ClawtError } from '../../../src/errors/index.js';
+import { SELECT_ALL_NAME, GROUP_SELECT_ALL_PREFIX, UNKNOWN_DATE_GROUP } from '../../../src/constants/index.js';
 import type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from '../../../src/utils/worktree-matcher.js';
 
 // mock enquirer
@@ -16,6 +17,19 @@ vi.mock('enquirer', () => ({
   },
 }));
 
+// mock getBranchCreatedAt，分组测试中按需控制返回值
+vi.mock('../../../src/utils/git.js', () => ({
+  getBranchCreatedAt: vi.fn().mockReturnValue(null),
+}));
+
+// mock node:fs 的 statSync，分组测试中按需控制返回值
+vi.mock('node:fs', () => ({
+  statSync: vi.fn().mockReturnValue({ birthtime: new Date('2026-02-27T10:00:00') }),
+}));
+
+import { statSync } from 'node:fs';
+const mockedStatSync = vi.mocked(statSync);
+
 /** 测试用消息配置 */
 const testMessages: WorktreeResolveMessages = {
   noWorktrees: '无可用 worktree',
@@ -190,3 +204,130 @@ describe('resolveTargetWorktrees', () => {
     await expect(resolveTargetWorktrees(worktrees, testMultiMessages, 'xyz')).rejects.toThrow(ClawtError);
   });
 });
+
+describe('groupWorktreesByDate', () => {
+  it('多日期分组：不同日期的分支被正确分组，最新日期在前', () => {
+    const worktrees = [
+      createWorktreeInfo({ path: '/worktrees/feature-auth', branch: 'feature-auth' }),
+      createWorktreeInfo({ path: '/worktrees/feature-login', branch: 'feature-login' }),
+      createWorktreeInfo({ path: '/worktrees/bugfix-nav', branch: 'bugfix-nav' }),
+    ];
+
+    mockedStatSync
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T10:00:00') } as any)
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T14:00:00') } as any)
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-25T09:00:00') } as any);
+
+    const groups = groupWorktreesByDate(worktrees);
+    const keys = [...groups.keys()];
+
+    // 最新日期在前
+    expect(keys).toEqual(['2026-02-26', '2026-02-25']);
+    // 2026-02-26 组有 2 个分支
+    expect(groups.get('2026-02-26')).toHaveLength(2);
+    expect(groups.get('2026-02-26')!.map((wt) => wt.branch)).toEqual(['feature-auth', 'feature-login']);
+    // 2026-02-25 组有 1 个分支
+    expect(groups.get('2026-02-25')).toHaveLength(1);
+    expect(groups.get('2026-02-25')![0].branch).toBe('bugfix-nav');
+  });
+
+  it('statSync 异常时归入"未知日期"组', () => {
+    const worktrees = [
+      createWorktreeInfo({ path: '/worktrees/feature-auth', branch: 'feature-auth' }),
+      createWorktreeInfo({ path: '/worktrees/old-branch', branch: 'old-branch' }),
+    ];
+
+    mockedStatSync
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T10:00:00') } as any)
+      .mockImplementationOnce(() => { throw new Error('ENOENT'); });
+
+    const groups = groupWorktreesByDate(worktrees);
+    const keys = [...groups.keys()];
+
+    // 未知日期在最后
+    expect(keys).toEqual(['2026-02-26', UNKNOWN_DATE_GROUP]);
+    expect(groups.get(UNKNOWN_DATE_GROUP)).toHaveLength(1);
+    expect(groups.get(UNKNOWN_DATE_GROUP)![0].branch).toBe('old-branch');
+  });
+
+  it('单日期分组：所有分支同一天', () => {
+    const worktrees = [
+      createWorktreeInfo({ path: '/worktrees/feature-a', branch: 'feature-a' }),
+      createWorktreeInfo({ path: '/worktrees/feature-b', branch: 'feature-b' }),
+    ];
+
+    mockedStatSync
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T10:00:00') } as any)
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T15:00:00') } as any);
+
+    const groups = groupWorktreesByDate(worktrees);
+    const keys = [...groups.keys()];
+
+    expect(keys).toEqual(['2026-02-26']);
+    expect(groups.get('2026-02-26')).toHaveLength(2);
+  });
+});
+
+describe('buildGroupedChoices', () => {
+  it('构建的 choices 包含全局全选、分隔线、组全选和分支', () => {
+    const groups = new Map<string, Array<{ path: string; branch: string }>>([
+      ['2026-02-26', [
+        createWorktreeInfo({ branch: 'feature-auth' }),
+        createWorktreeInfo({ branch: 'feature-login' }),
+      ]],
+      [UNKNOWN_DATE_GROUP, [
+        createWorktreeInfo({ branch: 'old-branch' }),
+      ]],
+    ]);
+
+    const choices = buildGroupedChoices(groups);
+
+    // 全局全选在顶部
+    expect(choices[0]).toEqual({ name: SELECT_ALL_NAME, message: '[select-all]' });
+
+    // 第一组分隔线
+    expect(choices[1]).toHaveProperty('role', 'separator');
+
+    // 第一组组全选
+    expect(choices[2]).toEqual({
+      name: `${GROUP_SELECT_ALL_PREFIX}2026-02-26`,
+      message: '[select-all: 2026-02-26]',
+    });
+
+    // 第一组分支
+    expect(choices[3]).toEqual({ name: 'feature-auth', message: 'feature-auth' });
+    expect(choices[4]).toEqual({ name: 'feature-login', message: 'feature-login' });
+
+    // 未知日期组分隔线（含 chalk 高亮，使用 stringContaining 匹配）
+    expect(choices[5]).toHaveProperty('role', 'separator');
+    expect((choices[5] as { message: string }).message).toContain('未知日期');
+
+    // 未知日期组全选
+    expect(choices[6]).toEqual({
+      name: `${GROUP_SELECT_ALL_PREFIX}${UNKNOWN_DATE_GROUP}`,
+      message: `[select-all: ${UNKNOWN_DATE_GROUP}]`,
+    });
+
+    // 未知日期组分支
+    expect(choices[7]).toEqual({ name: 'old-branch', message: 'old-branch' });
+  });
+});
+
+describe('buildGroupMembershipMap', () => {
+  it('构建组全选 name 到分支 name 列表的正确映射', () => {
+    const groups = new Map<string, Array<{ path: string; branch: string }>>([
+      ['2026-02-26', [
+        createWorktreeInfo({ branch: 'feature-auth' }),
+        createWorktreeInfo({ branch: 'feature-login' }),
+      ]],
+      ['2026-02-25', [
+        createWorktreeInfo({ branch: 'bugfix-nav' }),
+      ]],
+    ]);
+
+    const membershipMap = buildGroupMembershipMap(groups);
+
+    expect(membershipMap.get(`${GROUP_SELECT_ALL_PREFIX}2026-02-26`)).toEqual(['feature-auth', 'feature-login']);
+    expect(membershipMap.get(`${GROUP_SELECT_ALL_PREFIX}2026-02-25`)).toEqual(['bugfix-nav']);
+  });
+});