clawt 2.16.2 → 2.16.3

package/README.md

@@ -171,6 +171,39 @@ clawt status          # 文本格式
 clawt status --json   # JSON 格式
 ```
 
+展示主 worktree 状态、各 worktree 的变更详情（含分支创建时间和验证状态）以及 validate 快照摘要：
+
+```
+════════════════════════════════════════
+  项目状态总览: my-project
+════════════════════════════════════════
+
+  ◆ 主 Worktree
+    分支: main
+    状态: ✓ 干净
+
+────────────────────────────────────────
+
+  ◆ Worktree 列表 (2 个)
+
+  ● feature-login   [已提交]
+    +120 -30   3 个本地提交   与主分支同步
+    创建于 3 天前
+    上次验证: 2 小时前
+
+  ● feature-signup   [未提交修改]
+    +45 -10   1 个本地提交   落后主分支 2 个提交
+    创建于 1 天前
+    ✗ 未验证
+
+────────────────────────────────────────
+
+  ◆ Validate 快照 (3 个)
+    其中 1 个快照对应的 worktree 已不存在
+
+════════════════════════════════════════
+```
+
 ### `clawt reset` — 重置主 worktree 到干净状态
 
 ```bash

package/dist/index.js

@@ -323,7 +323,7 @@ var STATUS_MESSAGES = {
   /** status worktrees 区块标题 */
   STATUS_WORKTREES_SECTION: "Worktree \u5217\u8868",
   /** status 快照区块标题 */
-  STATUS_SNAPSHOTS_SECTION: "\u672A\u6E05\u7406\u7684 Validate \u5FEB\u7167",
+  STATUS_SNAPSHOTS_SECTION: "Validate \u5FEB\u7167",
   /** status 无 worktree */
   STATUS_NO_WORKTREES: "(\u65E0\u6D3B\u8DC3 worktree)",
   /** status 无未清理快照 */
@@ -337,7 +337,15 @@ var STATUS_MESSAGES = {
   /** status 变更状态：无变更 */
   STATUS_CHANGE_CLEAN: "\u65E0\u53D8\u66F4",
   /** status 快照对应 worktree 已不存在 */
-  STATUS_SNAPSHOT_ORPHANED: "(\u5BF9\u5E94 worktree \u5DF2\u4E0D\u5B58\u5728)"
+  STATUS_SNAPSHOT_ORPHANED: (count) => `\u5176\u4E2D ${count} \u4E2A\u5FEB\u7167\u5BF9\u5E94\u7684 worktree \u5DF2\u4E0D\u5B58\u5728`,
+  /** status 分支创建时间标签 */
+  STATUS_CREATED_AT: (relativeTime) => `\u521B\u5EFA\u4E8E ${relativeTime}`,
+  /** status 分支无分叉提交时的提示 */
+  STATUS_NO_DIVERGED_COMMITS: "\u5C1A\u65E0\u5206\u53C9\u63D0\u4EA4",
+  /** status 上次验证时间标签 */
+  STATUS_LAST_VALIDATED: (relativeTime) => `\u4E0A\u6B21\u9A8C\u8BC1: ${relativeTime}`,
+  /** status 未验证警示 */
+  STATUS_NOT_VALIDATED: "\u2717 \u672A\u9A8C\u8BC1"
 };
 
 // src/constants/messages/alias.ts
@@ -787,6 +795,17 @@ function gitApplyCachedCheck(patchContent, cwd) {
     return false;
   }
 }
+function getBranchCreatedAt(branchName, cwd) {
+  try {
+    const output = execCommand(`git reflog show ${branchName} --format=%cI`, { cwd });
+    if (!output.trim()) return null;
+    const lines = output.trim().split("\n");
+    const lastLine = lines[lines.length - 1];
+    return lastLine || null;
+  } catch {
+    return null;
+  }
+}
 
 // src/utils/formatter.ts
 import chalk2 from "chalk";
@@ -856,6 +875,35 @@ function formatDuration(ms) {
   const seconds = Math.floor(totalSeconds % 60);
   return `${minutes}m${String(seconds).padStart(2, "0")}s`;
 }
+function formatRelativeTime(isoDateString) {
+  const date = new Date(isoDateString);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  if (isNaN(diffMs)) {
+    return null;
+  }
+  if (diffMs < 0 || diffMs < 60 * 1e3) {
+    return "\u521A\u521A";
+  }
+  const diffMinutes = Math.floor(diffMs / (1e3 * 60));
+  const diffHours = Math.floor(diffMs / (1e3 * 60 * 60));
+  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffHours < 1) {
+    return `${diffMinutes} \u5206\u949F\u524D`;
+  }
+  if (diffDays < 1) {
+    return `${diffHours} \u5C0F\u65F6\u524D`;
+  }
+  if (diffDays < 30) {
+    return `${diffDays} \u5929\u524D`;
+  }
+  if (diffDays < 365) {
+    const months = Math.floor(diffDays / 30);
+    return `${months} \u4E2A\u6708\u524D`;
+  }
+  const years = Math.floor(diffDays / 365);
+  return `${years} \u5E74\u524D`;
+}
 
 // src/utils/branch.ts
 function sanitizeBranchName(branchName) {
@@ -1199,7 +1247,7 @@ function launchInteractiveClaudeInNewTerminal(worktree, hasPreviousSession) {
 
 // src/utils/validate-snapshot.ts
 import { join as join4 } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, readdirSync as readdirSync4, rmdirSync as rmdirSync2 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, readdirSync as readdirSync4, rmdirSync as rmdirSync2, statSync } from "fs";
 function getSnapshotPath(projectName, branchName) {
   return join4(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.tree`);
 }
@@ -1209,6 +1257,12 @@ function getSnapshotHeadPath(projectName, branchName) {
 function hasSnapshot(projectName, branchName) {
   return existsSync7(getSnapshotPath(projectName, branchName));
 }
+function getSnapshotModifiedTime(projectName, branchName) {
+  const snapshotPath = getSnapshotPath(projectName, branchName);
+  if (!existsSync7(snapshotPath)) return null;
+  const stat = statSync(snapshotPath);
+  return stat.mtime.toISOString();
+}
 function readSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
@@ -2849,15 +2903,17 @@ function collectWorktreeDetailedStatus(worktree, projectName) {
   const changeStatus = detectChangeStatus(worktree);
   const { commitsAhead, commitsBehind } = countCommitDivergence(worktree.branch);
   const { insertions, deletions } = countDiffStat(worktree.path);
+  const createdAt = resolveBranchCreatedAt(worktree.branch);
   return {
     path: worktree.path,
     branch: worktree.branch,
     changeStatus,
     commitsAhead,
     commitsBehind,
-    hasSnapshot: hasSnapshot(projectName, worktree.branch),
+    snapshotTime: resolveSnapshotTime(projectName, worktree.branch),
     insertions,
-    deletions
+    deletions,
+    createdAt
   };
 }
 function detectChangeStatus(worktree) {
@@ -2893,13 +2949,28 @@ function countDiffStat(worktreePath) {
     return { insertions: 0, deletions: 0 };
   }
 }
+function resolveBranchCreatedAt(branchName) {
+  try {
+    return getBranchCreatedAt(branchName);
+  } catch {
+    return null;
+  }
+}
+function resolveSnapshotTime(projectName, branchName) {
+  try {
+    return getSnapshotModifiedTime(projectName, branchName);
+  } catch {
+    return null;
+  }
+}
 function collectSnapshots(projectName, worktrees) {
   const snapshotBranches = getProjectSnapshotBranches(projectName);
   const worktreeBranchSet = new Set(worktrees.map((wt) => wt.branch));
-  return snapshotBranches.map((branch) => ({
-    branch,
-    worktreeExists: worktreeBranchSet.has(branch)
-  }));
+  const orphaned = snapshotBranches.filter((branch) => !worktreeBranchSet.has(branch)).length;
+  return {
+    total: snapshotBranches.length,
+    orphaned
+  };
 }
 function printStatusAsJson(result) {
   console.log(JSON.stringify(result, null, 2));
@@ -2942,21 +3013,30 @@ function printWorktreesSection(worktrees, total) {
 function printWorktreeItem(wt) {
   const statusLabel = formatChangeStatusLabel(wt.changeStatus);
   printInfo(`  ${chalk8.bold("\u25CF")} ${chalk8.bold(wt.branch)}   [${statusLabel}]`);
-  const parts = [];
   if (wt.insertions > 0 || wt.deletions > 0) {
-    parts.push(`${chalk8.green(`+${wt.insertions}`)} ${chalk8.red(`-${wt.deletions}`)}`);
+    printInfo(`    ${chalk8.green(`+${wt.insertions}`)} ${chalk8.red(`-${wt.deletions}`)}`);
   }
   if (wt.commitsAhead > 0) {
-    parts.push(chalk8.yellow(`${wt.commitsAhead} \u4E2A\u672C\u5730\u63D0\u4EA4`));
+    printInfo(`    ${chalk8.yellow(`${wt.commitsAhead} \u4E2A\u672C\u5730\u63D0\u4EA4`)}`);
   }
   if (wt.commitsBehind > 0) {
-    parts.push(chalk8.yellow(`\u843D\u540E\u4E3B\u5206\u652F ${wt.commitsBehind} \u4E2A\u63D0\u4EA4`));
+    printInfo(`    ${chalk8.yellow(`\u843D\u540E\u4E3B\u5206\u652F ${wt.commitsBehind} \u4E2A\u63D0\u4EA4`)}`);
   } else {
-    parts.push(chalk8.green("\u4E0E\u4E3B\u5206\u652F\u540C\u6B65"));
+    printInfo(`    ${chalk8.green("\u4E0E\u4E3B\u5206\u652F\u540C\u6B65")}`);
+  }
+  if (wt.createdAt) {
+    const relativeTime = formatRelativeTime(wt.createdAt);
+    if (relativeTime) {
+      printInfo(`    ${chalk8.gray(MESSAGES.STATUS_CREATED_AT(relativeTime))}`);
+    }
   }
-  printInfo(`    ${parts.join("   ")}`);
-  if (wt.hasSnapshot) {
-    printInfo(`    ${chalk8.blue("\u6709 validate \u5FEB\u7167")}`);
+  if (wt.snapshotTime) {
+    const relativeTime = formatRelativeTime(wt.snapshotTime);
+    if (relativeTime) {
+      printInfo(`    ${chalk8.green(MESSAGES.STATUS_LAST_VALIDATED(relativeTime))}`);
+    }
+  } else {
+    printInfo(`    ${chalk8.red(MESSAGES.STATUS_NOT_VALIDATED)}`);
   }
   printInfo("");
 }
@@ -2973,17 +3053,9 @@ function formatChangeStatusLabel(status) {
   }
 }
 function printSnapshotsSection(snapshots) {
-  printInfo(`  ${chalk8.bold("\u25C6")} ${chalk8.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.length} \u4E2A)`);
-  printInfo("");
-  if (snapshots.length === 0) {
-    printInfo(`    ${MESSAGES.STATUS_NO_SNAPSHOTS}`);
-    printInfo("");
-    return;
-  }
-  for (const snap of snapshots) {
-    const orphanLabel = snap.worktreeExists ? "" : `  ${chalk8.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED)}`;
-    const icon = snap.worktreeExists ? chalk8.blue("\u25CF") : chalk8.yellow("\u26A0");
-    printInfo(`  ${icon} ${snap.branch}${orphanLabel}`);
+  printInfo(`  ${chalk8.bold("\u25C6")} ${chalk8.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.total} \u4E2A)`);
+  if (snapshots.orphaned > 0) {
+    printInfo(`    ${chalk8.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED(snapshots.orphaned))}`);
   }
   printInfo("");
 }

package/dist/postinstall.js

@@ -314,7 +314,7 @@ var STATUS_MESSAGES = {
   /** status worktrees 区块标题 */
   STATUS_WORKTREES_SECTION: "Worktree \u5217\u8868",
   /** status 快照区块标题 */
-  STATUS_SNAPSHOTS_SECTION: "\u672A\u6E05\u7406\u7684 Validate \u5FEB\u7167",
+  STATUS_SNAPSHOTS_SECTION: "Validate \u5FEB\u7167",
   /** status 无 worktree */
   STATUS_NO_WORKTREES: "(\u65E0\u6D3B\u8DC3 worktree)",
   /** status 无未清理快照 */
@@ -328,7 +328,15 @@ var STATUS_MESSAGES = {
   /** status 变更状态：无变更 */
   STATUS_CHANGE_CLEAN: "\u65E0\u53D8\u66F4",
   /** status 快照对应 worktree 已不存在 */
-  STATUS_SNAPSHOT_ORPHANED: "(\u5BF9\u5E94 worktree \u5DF2\u4E0D\u5B58\u5728)"
+  STATUS_SNAPSHOT_ORPHANED: (count) => `\u5176\u4E2D ${count} \u4E2A\u5FEB\u7167\u5BF9\u5E94\u7684 worktree \u5DF2\u4E0D\u5B58\u5728`,
+  /** status 分支创建时间标签 */
+  STATUS_CREATED_AT: (relativeTime) => `\u521B\u5EFA\u4E8E ${relativeTime}`,
+  /** status 分支无分叉提交时的提示 */
+  STATUS_NO_DIVERGED_COMMITS: "\u5C1A\u65E0\u5206\u53C9\u63D0\u4EA4",
+  /** status 上次验证时间标签 */
+  STATUS_LAST_VALIDATED: (relativeTime) => `\u4E0A\u6B21\u9A8C\u8BC1: ${relativeTime}`,
+  /** status 未验证警示 */
+  STATUS_NOT_VALIDATED: "\u2717 \u672A\u9A8C\u8BC1"
 };
 
 // src/constants/messages/alias.ts

package/docs/spec.md

@@ -1431,7 +1431,7 @@ clawt status [--json]
 
 **使用场景：**
 
-在管理多个 worktree 时，快速了解项目全局状态：主 worktree 当前分支及干净状态、所有 worktree 的变更情况和与主分支的同步状态、未清理的 validate 快照。
+在管理多个 worktree 时，快速了解项目全局状态：主 worktree 当前分支及干净状态、所有 worktree 的变更情况和与主分支的同步状态、validate 快照摘要。
 
 **运行流程：**
 
@@ -1446,17 +1446,18 @@ clawt status [--json]
      - **变更状态**（优先级：合并冲突 > 未提交修改 > 已提交 > 无变更）
      - **行数差异**（新增/删除行数，通过 `getDiffStat()` 获取）
      - **提交差异**（相对于主分支的领先提交数 `getCommitCountAhead()` 和落后提交数 `getCommitCountBehind()`）
-     - **快照状态**（是否存在 validate 快照）
-4. **收集未清理的 validate 快照**：
+     - **快照时间**（validate 快照文件的 mtime，通过 `getSnapshotModifiedTime()` 获取，返回 ISO 8601 时间字符串或 null）
+     - **分支创建时间**（通过 `getBranchCreatedAt()` 从 git reflog 获取分支创建时的时间戳）
+4. **收集 validate 快照摘要**：
    - 通过 `getProjectSnapshotBranches()` 扫描快照目录下的 `.tree` 文件获取所有存在快照的分支名
-   - 对比现有 worktree 分支列表，标识孤立快照（对应 worktree 已不存在的快照）
+   - 统计快照总数和孤立快照数（对应 worktree 已不存在的快照）
 5. **输出状态信息**：
    - 指定 `--json` → 以 JSON 格式输出完整状态数据（`JSON.stringify`）
    - 未指定 → 以文本格式输出
 
 **文本输出格式（默认）：**
 
-输出分为三个区块：主 Worktree、Worktree 列表、未清理的 Validate 快照。
+输出分为三个区块：主 Worktree、Worktree 列表、Validate 快照摘要。每个 worktree 条目每行展示一种信息。
 
 ```
 ════════════════════════════════════════
@@ -1473,16 +1474,18 @@ clawt status [--json]
 
   ● feature-login   [已提交]
     +120 -30   3 个本地提交   与主分支同步
-    有 validate 快照
+    创建于 3 天前
+    上次验证: 2 小时前
 
   ● feature-signup   [未提交修改]
     +45 -10   1 个本地提交   落后主分支 2 个提交
+    创建于 1 天前
+    ✗ 未验证
 
 ────────────────────────────────────────
 
-  ◆ 未清理的 Validate 快照 (1 个)
-
-  ⚠ old-feature   (对应 worktree 已不存在)
+  ◆ Validate 快照 (3 个)
+    其中 1 个快照对应的 worktree 已不存在
 
 ════════════════════════════════════════
 ```
@@ -1502,11 +1505,21 @@ clawt status [--json]
 - 本地提交数（`N 个本地提交`）仅在有提交时展示
 - 与主分支同步状态始终展示（落后时显示黄色，同步时显示绿色）
 
+**分支创建时间行：**
+
+- 通过 `getBranchCreatedAt()` 从 git reflog 获取分支创建时间，以 `formatRelativeTime()` 格式化为中文相对时间（如"3 天前"、"2 小时前"、"刚刚"）
+- 展示为灰色文本 `创建于 X前`，无法获取时不展示
+
+**验证状态行：**
+
+- 有快照时：显示绿色 `上次验证: X前`（通过 `getSnapshotModifiedTime()` 获取快照文件 mtime，再用 `formatRelativeTime()` 格式化）
+- 无快照时：显示红色 `✗ 未验证` 警示
+
 **快照区块：**
 
-- 每个快照显示对应的分支名
-- 如果对应的 worktree 仍存在，显示蓝色圆点图标
-- 如果对应的 worktree 已不存在（孤立快照），显示黄色警告图标并标注 `(对应 worktree 已不存在)`
+- 标题显示快照总数
+- 如果存在孤立快照（对应 worktree 已不存在），显示黄色警告 `其中 N 个快照对应的 worktree 已不存在`
+- 无孤立快照时不显示额外信息
 
 **JSON 输出格式（`--json`）：**
 
@@ -1524,25 +1537,31 @@ clawt status [--json]
       "changeStatus": "committed",
       "commitsAhead": 3,
       "commitsBehind": 0,
-      "hasSnapshot": true,
+      "snapshotTime": "2025-02-06T12:30:00.000Z",
       "insertions": 120,
-      "deletions": 30
-    }
-  ],
-  "snapshots": [
-    {
-      "branch": "old-feature",
-      "worktreeExists": false
+      "deletions": 30,
+      "createdAt": "2025-02-03T10:00:00.000Z"
     }
   ],
+  "snapshots": {
+    "total": 3,
+    "orphaned": 1
+  },
   "totalWorktrees": 1
 }
 ```
 
 **实现要点：**
 
-- 类型定义在 `src/types/status.ts`：`WorktreeDetailedStatus`、`MainWorktreeStatus`、`SnapshotInfo`、`StatusResult`
-- 消息常量在 `MESSAGES.STATUS_*` 系列
+- 类型定义在 `src/types/status.ts`：`WorktreeDetailedStatus`（`hasSnapshot` 已改为 `snapshotTime: string | null`，新增 `createdAt: string | null`）、`MainWorktreeStatus`、`SnapshotInfo`、`SnapshotSummary`（新增，包含 `total` 和 `orphaned`）、`StatusResult`（`snapshots` 已从 `SnapshotInfo[]` 改为 `SnapshotSummary`）
+- 消息常量在 `MESSAGES.STATUS_*` 系列，新增：
+  - `STATUS_LAST_VALIDATED`：上次验证时间标签（如 `上次验证: 2 小时前`）
+  - `STATUS_NOT_VALIDATED`：未验证红色警示文本（`✗ 未验证`）
+  - `STATUS_CREATED_AT`：分支创建时间标签（如 `创建于 3 天前`）
+  - `STATUS_SNAPSHOT_ORPHANED`：改为接受数量参数的函数（如 `其中 1 个快照对应的 worktree 已不存在`）
+- `getBranchCreatedAt()` 是新增的工具函数（在 `src/utils/git.ts`），通过 `git reflog show <branch> --format=%cI` 获取 reflog 最后一条记录的时间戳（即分支创建时间），返回 ISO 8601 格式字符串或 null
+- `getSnapshotModifiedTime()` 是新增的工具函数（在 `src/utils/validate-snapshot.ts`），通过 `fs.statSync` 获取快照文件的修改时间（mtime），返回 ISO 8601 格式字符串或 null
+- `formatRelativeTime()` 是新增的格式化函数（在 `src/utils/formatter.ts`），将 ISO 8601 日期字符串转换为中文相对时间描述（如"3 天前"、"2 小时前"、"刚刚"），无效日期时返回 null
 - `getCommitCountBehind()` 是新增的工具函数（在 `src/utils/git.ts`），通过 `git rev-list --count <branch>..HEAD` 计算落后提交数
 - `getProjectSnapshotBranches()` 是新增的工具函数（在 `src/utils/validate-snapshot.ts`），通过扫描快照目录下的 `.tree` 文件提取分支名列表
 

package/package.json

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

package/src/commands/status.ts

@@ -2,7 +2,7 @@ import type { Command } from 'commander';
 import chalk from 'chalk';
 import { MESSAGES } from '../constants/index.js';
 import { logger } from '../logger/index.js';
-import type { StatusOptions, WorktreeDetailedStatus, MainWorktreeStatus, SnapshotInfo, StatusResult, WorktreeInfo } from '../types/index.js';
+import type { StatusOptions, WorktreeDetailedStatus, MainWorktreeStatus, SnapshotSummary, StatusResult, WorktreeInfo } from '../types/index.js';
 import {
   validateMainWorktree,
   getProjectName,
@@ -14,8 +14,10 @@ import {
   getDiffStat,
   hasMergeConflict,
   hasLocalCommits,
-  hasSnapshot,
+  getSnapshotModifiedTime,
   getProjectSnapshotBranches,
+  getBranchCreatedAt,
+  formatRelativeTime,
   printInfo,
   printDoubleSeparator,
   printSeparator,
@@ -96,6 +98,7 @@ function collectWorktreeDetailedStatus(worktree: WorktreeInfo, projectName: stri
   const changeStatus = detectChangeStatus(worktree);
   const { commitsAhead, commitsBehind } = countCommitDivergence(worktree.branch);
   const { insertions, deletions } = countDiffStat(worktree.path);
+  const createdAt = resolveBranchCreatedAt(worktree.branch);
 
   return {
     path: worktree.path,
@@ -103,9 +106,10 @@ function collectWorktreeDetailedStatus(worktree: WorktreeInfo, projectName: stri
     changeStatus,
     commitsAhead,
     commitsBehind,
-    hasSnapshot: hasSnapshot(projectName, worktree.branch),
+    snapshotTime: resolveSnapshotTime(projectName, worktree.branch),
     insertions,
     deletions,
+    createdAt,
   };
 }
 
@@ -162,20 +166,47 @@ function countDiffStat(worktreePath: string): { insertions: number; deletions: n
 }
 
 /**
- * 收集未清理的 validate 快照信息
- * 对比快照分支与现有 worktree 分支，标识孤立快照
+ * 获取分支的创建时间
+ * @param {string} branchName - 分支名
+ * @returns {string | null} ISO 8601 格式的创建时间，获取失败时返回 null
+ */
+function resolveBranchCreatedAt(branchName: string): string | null {
+  try {
+    return getBranchCreatedAt(branchName);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 获取分支的 validate 快照修改时间
+ * @param {string} projectName - 项目名
+ * @param {string} branchName - 分支名
+ * @returns {string | null} ISO 8601 格式的快照时间，无快照时返回 null
+ */
+function resolveSnapshotTime(projectName: string, branchName: string): string | null {
+  try {
+    return getSnapshotModifiedTime(projectName, branchName);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 收集 validate 快照摘要信息
  * @param {string} projectName - 项目名
  * @param {WorktreeInfo[]} worktrees - 当前有效的 worktree 列表
- * @returns {SnapshotInfo[]} 快照信息列表
+ * @returns {SnapshotSummary} 快照摘要
  */
-function collectSnapshots(projectName: string, worktrees: WorktreeInfo[]): SnapshotInfo[] {
+function collectSnapshots(projectName: string, worktrees: WorktreeInfo[]): SnapshotSummary {
   const snapshotBranches = getProjectSnapshotBranches(projectName);
   const worktreeBranchSet = new Set(worktrees.map((wt) => wt.branch));
+  const orphaned = snapshotBranches.filter((branch) => !worktreeBranchSet.has(branch)).length;
 
-  return snapshotBranches.map((branch) => ({
-    branch,
-    worktreeExists: worktreeBranchSet.has(branch),
-  }));
+  return {
+    total: snapshotBranches.length,
+    orphaned,
+  };
 }
 
 /**
@@ -256,31 +287,39 @@ function printWorktreeItem(wt: WorktreeDetailedStatus): void {
   const statusLabel = formatChangeStatusLabel(wt.changeStatus);
   printInfo(`  ${chalk.bold('●')} ${chalk.bold(wt.branch)}   [${statusLabel}]`);
 
-  // 差异统计行
-  const parts: string[] = [];
-
-  // 行数变更（仅在有变更时展示）
+  // 变更行数
   if (wt.insertions > 0 || wt.deletions > 0) {
-    parts.push(`${chalk.green(`+${wt.insertions}`)} ${chalk.red(`-${wt.deletions}`)}`);
+    printInfo(`    ${chalk.green(`+${wt.insertions}`)} ${chalk.red(`-${wt.deletions}`)}`);
   }
 
   // 本地提交数
   if (wt.commitsAhead > 0) {
-    parts.push(chalk.yellow(`${wt.commitsAhead} 个本地提交`));
+    printInfo(`    ${chalk.yellow(`${wt.commitsAhead} 个本地提交`)}`);
   }
 
   // 与主分支的同步状态
   if (wt.commitsBehind > 0) {
-    parts.push(chalk.yellow(`落后主分支 ${wt.commitsBehind} 个提交`));
+    printInfo(`    ${chalk.yellow(`落后主分支 ${wt.commitsBehind} 个提交`)}`);
   } else {
-    parts.push(chalk.green('与主分支同步'));
+    printInfo(`    ${chalk.green('与主分支同步')}`);
   }
 
-  printInfo(`    ${parts.join('   ')}`);
+  // 分支创建时间
+  if (wt.createdAt) {
+    const relativeTime = formatRelativeTime(wt.createdAt);
+    if (relativeTime) {
+      printInfo(`    ${chalk.gray(MESSAGES.STATUS_CREATED_AT(relativeTime))}`);
+    }
+  }
 
-  // 快照状态
-  if (wt.hasSnapshot) {
-    printInfo(`    ${chalk.blue('有 validate 快照')}`);
+  // 验证状态
+  if (wt.snapshotTime) {
+    const relativeTime = formatRelativeTime(wt.snapshotTime);
+    if (relativeTime) {
+      printInfo(`    ${chalk.green(MESSAGES.STATUS_LAST_VALIDATED(relativeTime))}`);
+    }
+  } else {
+    printInfo(`    ${chalk.red(MESSAGES.STATUS_NOT_VALIDATED)}`);
   }
 
   printInfo('');
@@ -305,23 +344,13 @@ function formatChangeStatusLabel(status: WorktreeDetailedStatus['changeStatus'])
 }
 
 /**
- * 输出未清理快照区块
- * @param {SnapshotInfo[]} snapshots - 快照信息列表
+ * 输出快照摘要区块
+ * @param {SnapshotSummary} snapshots - 快照摘要信息
  */
-function printSnapshotsSection(snapshots: SnapshotInfo[]): void {
-  printInfo(`  ${chalk.bold('◆')} ${chalk.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.length} 个)`);
-  printInfo('');
-
-  if (snapshots.length === 0) {
-    printInfo(`    ${MESSAGES.STATUS_NO_SNAPSHOTS}`);
-    printInfo('');
-    return;
-  }
-
-  for (const snap of snapshots) {
-    const orphanLabel = snap.worktreeExists ? '' : `  ${chalk.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED)}`;
-    const icon = snap.worktreeExists ? chalk.blue('●') : chalk.yellow('⚠');
-    printInfo(`  ${icon} ${snap.branch}${orphanLabel}`);
+function printSnapshotsSection(snapshots: SnapshotSummary): void {
+  printInfo(`  ${chalk.bold('◆')} ${chalk.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.total} 个)`);
+  if (snapshots.orphaned > 0) {
+    printInfo(`    ${chalk.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED(snapshots.orphaned))}`);
   }
   printInfo('');
 }

package/src/constants/messages/status.ts

@@ -7,7 +7,7 @@ export const STATUS_MESSAGES = {
   /** status worktrees 区块标题 */
   STATUS_WORKTREES_SECTION: 'Worktree 列表',
   /** status 快照区块标题 */
-  STATUS_SNAPSHOTS_SECTION: '未清理的 Validate 快照',
+  STATUS_SNAPSHOTS_SECTION: 'Validate 快照',
   /** status 无 worktree */
   STATUS_NO_WORKTREES: '(无活跃 worktree)',
   /** status 无未清理快照 */
@@ -21,5 +21,13 @@ export const STATUS_MESSAGES = {
   /** status 变更状态：无变更 */
   STATUS_CHANGE_CLEAN: '无变更',
   /** status 快照对应 worktree 已不存在 */
-  STATUS_SNAPSHOT_ORPHANED: '(对应 worktree 已不存在)',
+  STATUS_SNAPSHOT_ORPHANED: (count: number) => `其中 ${count} 个快照对应的 worktree 已不存在`,
+  /** status 分支创建时间标签 */
+  STATUS_CREATED_AT: (relativeTime: string) => `创建于 ${relativeTime}`,
+  /** status 分支无分叉提交时的提示 */
+  STATUS_NO_DIVERGED_COMMITS: '尚无分叉提交',
+  /** status 上次验证时间标签 */
+  STATUS_LAST_VALIDATED: (relativeTime: string) => `上次验证: ${relativeTime}`,
+  /** status 未验证警示 */
+  STATUS_NOT_VALIDATED: '✗ 未验证',
 } as const;

package/src/types/index.ts

@@ -3,5 +3,5 @@ export type { CreateOptions, RunOptions, ValidateOptions, MergeOptions, RemoveOp
 export type { WorktreeInfo, WorktreeStatus } from './worktree.js';
 export type { ClaudeCodeResult } from './claudeCode.js';
 export type { TaskResult, TaskSummary } from './taskResult.js';
-export type { WorktreeDetailedStatus, MainWorktreeStatus, SnapshotInfo, StatusResult } from './status.js';
+export type { WorktreeDetailedStatus, MainWorktreeStatus, SnapshotInfo, SnapshotSummary, StatusResult } from './status.js';
 export type { TaskFileEntry, ParseTaskFileOptions } from './taskFile.js';

package/src/types/status.ts

@@ -10,12 +10,14 @@ export interface WorktreeDetailedStatus {
   commitsAhead: number;
   /** 落后于主分支的提交数 */
   commitsBehind: number;
-  /** 是否存在 validate 快照 */
-  hasSnapshot: boolean;
+  /** 上次 validate 验证时间（ISO 8601 时间字符串），无快照时为 null */
+  snapshotTime: string | null;
   /** 工作区和暂存区的新增行数 */
   insertions: number;
   /** 工作区和暂存区的删除行数 */
   deletions: number;
+  /** 分支创建时间（首次分叉提交的 ISO 8601 时间字符串），无分叉提交时为 null */
+  createdAt: string | null;
 }
 
 /** 主 worktree 状态信息 */
@@ -36,14 +38,22 @@ export interface SnapshotInfo {
   worktreeExists: boolean;
 }
 
+/** validate 快照摘要信息 */
+export interface SnapshotSummary {
+  /** 快照总数 */
+  total: number;
+  /** 孤立快照数（对应 worktree 已不存在） */
+  orphaned: number;
+}
+
 /** status 命令的完整输出结构 */
 export interface StatusResult {
   /** 主 worktree 状态 */
   main: MainWorktreeStatus;
   /** 各 worktree 的详细状态 */
   worktrees: WorktreeDetailedStatus[];
-  /** 未清理的 validate 快照列表 */
-  snapshots: SnapshotInfo[];
+  /** validate 快照摘要 */
+  snapshots: SnapshotSummary;
   /** worktree 总数 */
   totalWorktrees: number;
 }

package/src/utils/formatter.ts

@@ -142,3 +142,45 @@ export function formatDuration(ms: number): string {
   const seconds = Math.floor(totalSeconds % 60);
   return `${minutes}m${String(seconds).padStart(2, '0')}s`;
 }
+
+/**
+ * 将 ISO 8601 日期字符串格式化为中文相对时间描述
+ * 例如: "3 天前"、"2 小时前"、"刚刚"
+ * @param {string} isoDateString - ISO 8601 格式的日期字符串
+ * @returns {string | null} 中文相对时间描述，无效日期时返回 null
+ */
+export function formatRelativeTime(isoDateString: string): string | null {
+  const date = new Date(isoDateString);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+
+  // 无效日期返回 null
+  if (isNaN(diffMs)) {
+    return null;
+  }
+
+  // 未来时间或不到 1 分钟
+  if (diffMs < 0 || diffMs < 60 * 1000) {
+    return '刚刚';
+  }
+
+  const diffMinutes = Math.floor(diffMs / (1000 * 60));
+  const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+
+  if (diffHours < 1) {
+    return `${diffMinutes} 分钟前`;
+  }
+  if (diffDays < 1) {
+    return `${diffHours} 小时前`;
+  }
+  if (diffDays < 30) {
+    return `${diffDays} 天前`;
+  }
+  if (diffDays < 365) {
+    const months = Math.floor(diffDays / 30);
+    return `${months} 个月前`;
+  }
+  const years = Math.floor(diffDays / 365);
+  return `${years} 年前`;
+}

package/src/utils/git.ts

@@ -481,3 +481,23 @@ export function gitApplyCachedCheck(patchContent: Buffer, cwd?: string): boolean
     return false;
   }
 }
+
+/**
+ * 获取分支的创建时间（通过 reflog 获取分支创建时的时间戳）
+ * reflog 的最后一条记录即为分支创建时的记录
+ * @param {string} branchName - 目标分支名
+ * @param {string} [cwd] - 工作目录
+ * @returns {string | null} ISO 8601 格式的时间字符串，无法获取时返回 null
+ */
+export function getBranchCreatedAt(branchName: string, cwd?: string): string | null {
+  try {
+    const output = execCommand(`git reflog show ${branchName} --format=%cI`, { cwd });
+    if (!output.trim()) return null;
+    // 取最后一行，即分支创建时的 reflog 记录
+    const lines = output.trim().split('\n');
+    const lastLine = lines[lines.length - 1];
+    return lastLine || null;
+  } catch {
+    return null;
+  }
+}

package/src/utils/index.ts

@@ -45,16 +45,17 @@ export {
   getCommitTreeHash,
   gitDiffTree,
   gitApplyCachedCheck,
+  getBranchCreatedAt,
 } from './git.js';
 export { sanitizeBranchName, generateBranchNames, validateBranchesNotExist } from './branch.js';
 export { validateMainWorktree, validateGitInstalled, validateClaudeCodeInstalled } from './validation.js';
 export { createWorktrees, getProjectWorktrees, getProjectWorktreeDir, cleanupWorktrees, getWorktreeStatus, createWorktreesByBranches } from './worktree.js';
 export { loadConfig, writeDefaultConfig, writeConfig, saveConfig, getConfigValue, ensureClawtDirs, parseConcurrency } from './config.js';
-export { printSuccess, printError, printWarning, printInfo, printHint, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle, formatDuration } from './formatter.js';
+export { printSuccess, printError, printWarning, printInfo, printHint, printSeparator, printDoubleSeparator, confirmAction, confirmDestructiveAction, formatWorktreeStatus, isWorktreeIdle, formatDuration, formatRelativeTime } from './formatter.js';
 export { ensureDir, removeEmptyDir } from './fs.js';
 export { multilineInput } from './prompt.js';
 export { launchInteractiveClaude, hasClaudeSessionHistory, launchInteractiveClaudeInNewTerminal } from './claude.js';
-export { getSnapshotPath, hasSnapshot, readSnapshotTreeHash, readSnapshot, writeSnapshot, removeSnapshot, removeProjectSnapshots, getProjectSnapshotBranches } from './validate-snapshot.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 type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from './worktree-matcher.js';
 export { ProgressRenderer } from './progress.js';

package/src/utils/validate-snapshot.ts

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
-import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, rmdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, rmdirSync, statSync } from 'node:fs';
 import { VALIDATE_SNAPSHOTS_DIR } from '../constants/index.js';
 import { ensureDir } from './fs.js';
 import { logger } from '../logger/index.js';
@@ -34,6 +34,19 @@ export function hasSnapshot(projectName: string, branchName: string): boolean {
   return existsSync(getSnapshotPath(projectName, branchName));
 }
 
+/**
+ * 获取指定项目和分支的 validate 快照文件修改时间
+ * @param {string} projectName - 项目名
+ * @param {string} branchName - 分支名
+ * @returns {string | null} ISO 8601 格式的修改时间，快照不存在时返回 null
+ */
+export function getSnapshotModifiedTime(projectName: string, branchName: string): string | null {
+  const snapshotPath = getSnapshotPath(projectName, branchName);
+  if (!existsSync(snapshotPath)) return null;
+  const stat = statSync(snapshotPath);
+  return stat.mtime.toISOString();
+}
+
 /**
  * 读取指定项目和分支的 validate 快照中存储的 tree hash
  * @param {string} projectName - 项目名

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

@@ -17,7 +17,11 @@ vi.mock('../../../src/constants/index.js', () => ({
     STATUS_CHANGE_UNCOMMITTED: '未提交',
     STATUS_CHANGE_CONFLICT: '冲突',
     STATUS_CHANGE_CLEAN: '干净',
-    STATUS_SNAPSHOT_ORPHANED: '(孤立)',
+    STATUS_SNAPSHOT_ORPHANED: (count: number) => `其中 ${count} 个快照对应的 worktree 已不存在`,
+    STATUS_CREATED_AT: (relativeTime: string) => `创建于 ${relativeTime}`,
+    STATUS_NO_DIVERGED_COMMITS: '尚无分叉提交',
+    STATUS_LAST_VALIDATED: (relativeTime: string) => `上次验证: ${relativeTime}`,
+    STATUS_NOT_VALIDATED: '✗ 未验证',
   },
 }));
 
@@ -32,8 +36,10 @@ vi.mock('../../../src/utils/index.js', () => ({
   getDiffStat: vi.fn(),
   hasMergeConflict: vi.fn(),
   hasLocalCommits: vi.fn(),
-  hasSnapshot: vi.fn(),
+  getSnapshotModifiedTime: vi.fn(),
   getProjectSnapshotBranches: vi.fn(),
+  getBranchCreatedAt: vi.fn(),
+  formatRelativeTime: vi.fn(),
   printInfo: vi.fn(),
   printDoubleSeparator: vi.fn(),
   printSeparator: vi.fn(),
@@ -50,8 +56,10 @@ import {
   getDiffStat,
   hasMergeConflict,
   hasLocalCommits,
-  hasSnapshot,
+  getSnapshotModifiedTime,
   getProjectSnapshotBranches,
+  getBranchCreatedAt,
+  formatRelativeTime,
   printInfo,
 } from '../../../src/utils/index.js';
 
@@ -64,8 +72,10 @@ const mockedGetCommitCountBehind = vi.mocked(getCommitCountBehind);
 const mockedGetDiffStat = vi.mocked(getDiffStat);
 const mockedHasMergeConflict = vi.mocked(hasMergeConflict);
 const mockedHasLocalCommits = vi.mocked(hasLocalCommits);
-const mockedHasSnapshot = vi.mocked(hasSnapshot);
+const mockedGetSnapshotModifiedTime = vi.mocked(getSnapshotModifiedTime);
 const mockedGetProjectSnapshotBranches = vi.mocked(getProjectSnapshotBranches);
+const mockedGetBranchCreatedAt = vi.mocked(getBranchCreatedAt);
+const mockedFormatRelativeTime = vi.mocked(formatRelativeTime);
 const mockedPrintInfo = vi.mocked(printInfo);
 
 beforeEach(() => {
@@ -79,7 +89,9 @@ beforeEach(() => {
   mockedGetDiffStat.mockReturnValue({ insertions: 0, deletions: 0 });
   mockedHasMergeConflict.mockReturnValue(false);
   mockedHasLocalCommits.mockReturnValue(false);
-  mockedHasSnapshot.mockReturnValue(false);
+  mockedGetSnapshotModifiedTime.mockReturnValue(null);
+  mockedGetBranchCreatedAt.mockReturnValue(null);
+  mockedFormatRelativeTime.mockReturnValue('3 天前');
   mockedPrintInfo.mockReset();
 });
 
@@ -167,7 +179,7 @@ describe('handleStatus', () => {
     expect(parsed.main.isClean).toBe(false);
   });
 
-  it('存在快照时标识孤立快照', () => {
+  it('快照摘要包含总数和孤立数', () => {
     mockedGetProjectSnapshotBranches.mockReturnValue(['feature', 'deleted-branch']);
     mockedGetProjectWorktrees.mockReturnValue([
       { path: '/path/feature', branch: 'feature' },
@@ -184,9 +196,8 @@ describe('handleStatus', () => {
       try { JSON.parse(call[0]); return true; } catch { return false; }
     });
     const parsed = JSON.parse(jsonCall![0]);
-    expect(parsed.snapshots).toHaveLength(2);
-    expect(parsed.snapshots[0]).toEqual({ branch: 'feature', worktreeExists: true });
-    expect(parsed.snapshots[1]).toEqual({ branch: 'deleted-branch', worktreeExists: false });
+    expect(parsed.snapshots.total).toBe(2);
+    expect(parsed.snapshots.orphaned).toBe(1);
   });
 
   it('uncommitted 变更状态正确检测', () => {
@@ -211,4 +222,112 @@ describe('handleStatus', () => {
     const parsed = JSON.parse(jsonCall![0]);
     expect(parsed.worktrees[0].changeStatus).toBe('uncommitted');
   });
+
+  it('createdAt 字段包含在 JSON 输出中', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetBranchCreatedAt.mockReturnValue('2026-02-20T14:30:00+08:00');
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.worktrees[0].createdAt).toBe('2026-02-20T14:30:00+08:00');
+  });
+
+  it('snapshotTime 字段包含在 JSON 输出中', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetSnapshotModifiedTime.mockReturnValue('2026-02-22T10:00:00.000Z');
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.worktrees[0].snapshotTime).toBe('2026-02-22T10:00:00.000Z');
+  });
+
+  it('文本模式显示分支创建时间', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetBranchCreatedAt.mockReturnValue('2026-02-20T14:30:00+08:00');
+    mockedFormatRelativeTime.mockReturnValue('2 天前');
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status'], { from: 'user' });
+
+    const printedLines = mockedPrintInfo.mock.calls.map((call) => call[0]);
+    const createdAtLine = printedLines.find((line) => line.includes('创建于'));
+    expect(createdAtLine).toBeDefined();
+  });
+
+  it('文本模式 createdAt 为 null 时不显示创建时间', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetBranchCreatedAt.mockReturnValue(null);
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status'], { from: 'user' });
+
+    const printedLines = mockedPrintInfo.mock.calls.map((call) => call[0]);
+    const createdAtLine = printedLines.find((line) => line.includes('创建于'));
+    expect(createdAtLine).toBeUndefined();
+  });
+
+  it('文本模式无快照时显示未验证警示', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetSnapshotModifiedTime.mockReturnValue(null);
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status'], { from: 'user' });
+
+    const printedLines = mockedPrintInfo.mock.calls.map((call) => call[0]);
+    const unverifiedLine = printedLines.find((line) => line.includes('未验证'));
+    expect(unverifiedLine).toBeDefined();
+  });
+
+  it('文本模式有快照时显示上次验证时间', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetSnapshotModifiedTime.mockReturnValue('2026-02-22T10:00:00.000Z');
+    mockedFormatRelativeTime.mockReturnValue('5 小时前');
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status'], { from: 'user' });
+
+    const printedLines = mockedPrintInfo.mock.calls.map((call) => call[0]);
+    const validatedLine = printedLines.find((line) => line.includes('上次验证'));
+    expect(validatedLine).toBeDefined();
+    const unverifiedLine = printedLines.find((line) => line.includes('未验证'));
+    expect(unverifiedLine).toBeUndefined();
+  });
 });

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { formatWorktreeStatus, printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, isWorktreeIdle, formatDuration } from '../../../src/utils/formatter.js';
+import { formatWorktreeStatus, printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, isWorktreeIdle, formatDuration, formatRelativeTime } from '../../../src/utils/formatter.js';
 import { createWorktreeStatus } from '../../helpers/fixtures.js';
 
 describe('formatWorktreeStatus', () => {
@@ -136,3 +136,44 @@ describe('formatDuration', () => {
     expect(formatDuration(3661000)).toBe('61m01s');
   });
 });
+
+describe('formatRelativeTime', () => {
+  it('不到 1 分钟时返回"刚刚"', () => {
+    const now = new Date();
+    expect(formatRelativeTime(now.toISOString())).toBe('刚刚');
+  });
+
+  it('数分钟前', () => {
+    const date = new Date(Date.now() - 5 * 60 * 1000);
+    expect(formatRelativeTime(date.toISOString())).toBe('5 分钟前');
+  });
+
+  it('数小时前', () => {
+    const date = new Date(Date.now() - 3 * 60 * 60 * 1000);
+    expect(formatRelativeTime(date.toISOString())).toBe('3 小时前');
+  });
+
+  it('数天前', () => {
+    const date = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+    expect(formatRelativeTime(date.toISOString())).toBe('7 天前');
+  });
+
+  it('数月前', () => {
+    const date = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000);
+    expect(formatRelativeTime(date.toISOString())).toBe('2 个月前');
+  });
+
+  it('数年前', () => {
+    const date = new Date(Date.now() - 400 * 24 * 60 * 60 * 1000);
+    expect(formatRelativeTime(date.toISOString())).toBe('1 年前');
+  });
+
+  it('无效日期返回 null', () => {
+    expect(formatRelativeTime('invalid-date')).toBeNull();
+  });
+
+  it('未来时间返回"刚刚"', () => {
+    const future = new Date(Date.now() + 60 * 60 * 1000);
+    expect(formatRelativeTime(future.toISOString())).toBe('刚刚');
+  });
+});

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

@@ -63,6 +63,7 @@ import {
   getCommitTreeHash,
   gitDiffTree,
   gitApplyCachedCheck,
+  getBranchCreatedAt,
 } from '../../../src/utils/git.js';
 
 const mockedExecCommand = vi.mocked(execCommand);
@@ -574,3 +575,38 @@ describe('getCommitCountBehind', () => {
     expect(getCommitCountBehind('feature')).toBe(0);
   });
 });
+
+describe('getBranchCreatedAt', () => {
+  it('多条 reflog 记录时返回最后一条（分支创建时间）', () => {
+    mockedExecCommand.mockReturnValue('2026-02-21T10:00:00+08:00\n2026-02-20T14:30:00+08:00');
+    expect(getBranchCreatedAt('feature')).toBe('2026-02-20T14:30:00+08:00');
+    expect(mockedExecCommand).toHaveBeenCalledWith(
+      'git reflog show feature --format=%cI',
+      { cwd: undefined },
+    );
+  });
+
+  it('单条 reflog 记录时返回该时间', () => {
+    mockedExecCommand.mockReturnValue('2026-02-20T14:30:00+08:00');
+    expect(getBranchCreatedAt('feature')).toBe('2026-02-20T14:30:00+08:00');
+  });
+
+  it('无 reflog 记录时返回 null', () => {
+    mockedExecCommand.mockReturnValue('');
+    expect(getBranchCreatedAt('feature')).toBeNull();
+  });
+
+  it('命令失败时返回 null', () => {
+    mockedExecCommand.mockImplementation(() => { throw new Error('fail'); });
+    expect(getBranchCreatedAt('feature')).toBeNull();
+  });
+
+  it('传递 cwd 参数', () => {
+    mockedExecCommand.mockReturnValue('2026-02-20T14:30:00+08:00');
+    getBranchCreatedAt('feature', '/repo');
+    expect(mockedExecCommand).toHaveBeenCalledWith(
+      'git reflog show feature --format=%cI',
+      { cwd: '/repo' },
+    );
+  });
+});

package/tests/unit/utils/validate-snapshot.test.ts

@@ -8,6 +8,7 @@ vi.mock('node:fs', () => ({
   unlinkSync: vi.fn(),
   readdirSync: vi.fn(),
   rmdirSync: vi.fn(),
+  statSync: vi.fn(),
 }));
 
 // mock logger
@@ -29,11 +30,12 @@ vi.mock('../../../src/constants/index.js', async (importOriginal) => {
   };
 });
 
-import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, rmdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, rmdirSync, statSync } from 'node:fs';
 import { ensureDir } from '../../../src/utils/fs.js';
 import {
   getSnapshotPath,
   hasSnapshot,
+  getSnapshotModifiedTime,
   readSnapshot,
   readSnapshotTreeHash,
   writeSnapshot,
@@ -48,6 +50,7 @@ const mockedWriteFileSync = vi.mocked(writeFileSync);
 const mockedUnlinkSync = vi.mocked(unlinkSync);
 const mockedReaddirSync = vi.mocked(readdirSync);
 const mockedRmdirSync = vi.mocked(rmdirSync);
+const mockedStatSync = vi.mocked(statSync);
 const mockedEnsureDir = vi.mocked(ensureDir);
 
 describe('getSnapshotPath', () => {
@@ -174,3 +177,20 @@ describe('getProjectSnapshotBranches', () => {
     expect(result).toEqual([]);
   });
 });
+
+describe('getSnapshotModifiedTime', () => {
+  it('快照存在时返回 ISO 时间字符串', () => {
+    mockedExistsSync.mockReturnValue(true);
+    const testDate = new Date('2026-02-22T10:00:00.000Z');
+    // @ts-expect-error statSync 返回类型简化
+    mockedStatSync.mockReturnValue({ mtime: testDate });
+    const result = getSnapshotModifiedTime('proj', 'branch');
+    expect(result).toBe('2026-02-22T10:00:00.000Z');
+  });
+
+  it('快照不存在时返回 null', () => {
+    mockedExistsSync.mockReturnValue(false);
+    const result = getSnapshotModifiedTime('proj', 'branch');
+    expect(result).toBeNull();
+  });
+});