task-ledger 1.0.2 → 1.2.0

package/README.md

@@ -35,7 +35,7 @@
 
 ### 状态用 JSON，不用 Markdown
 
-状态要频繁改（`doing` → `blocked` → `done`），Markdown 里改一个词很容易顺手改到别处。JSON 结构化、字段固定、一次只动一个值，改动面最小。
+状态要频繁改（`open` → `doing` → 结案），Markdown 里改一个词很容易顺手改到别处。JSON 结构化、字段固定、一次只动一个值，改动面最小。
 
 ### 状态与过程正文分离
 
@@ -114,7 +114,7 @@
 
 ### 并发策略
 
-- 所有写命令（`init` / `new` / `claim` / `set` / `close`）走同一套：**读 → 改内存 → 复查指纹 → 原子写**
+- 所有写命令（`init` / `new` / `claim` / `set` / `log` / `close`）走同一套：**读 → 改内存 → 复查指纹 → 原子写**
 - 临时文件名唯一（`mkstemp`），写完 `fsync` 再 `os.replace`，无论成败都清理临时文件
 - key 按字母序落盘，减少两人同时新增时的文本冲突
 - 冲突时**报错要求重跑**，不静默覆盖
@@ -171,7 +171,7 @@
 graph LR
     U[用户说一句话] --> A[agent 读 SKILL.md 判断意图]
     A -->|只读直接跑| R[list / show / validate / history]
-    A -->|先复述参数再确认| W[init / new / claim / set / close]
+    A -->|写操作| W[init / new / claim / set / log / close]
     W --> P[ledger/progress.json]
     W --> H[ledger/history/年月.md]
     W --> M[ledger/worklog/年月/日-时分-说明-码.md]
@@ -187,15 +187,13 @@ stateDiagram-v2
     [*] --> open: new（不带 --self）
     [*] --> doing: new --self
     open --> doing: claim（认领，写 owner）
-    doing --> blocked: set --status blocked
-    blocked --> doing: set --status doing
-    doing --> open: set --status open（退回未认领，清空 owner）
-    blocked --> open: set --status open
+    doing --> open: set --status open（释放认领，清空 owner）
     doing --> [*]: close（进历史）
-    blocked --> [*]: close（进历史）
     note right of doing
         set --owner 交接：owner 换成别人
         （只有当前 owner 能执行）
+        阻塞 = 接任务满 7 天；停滞 = 最后更新满 3 天
+        （都由看板按时间算，不是状态）
     end note
 ```
 

package/SKILL.md

@@ -14,11 +14,11 @@ allowed-tools: Read,Write,Bash,Grep
 | 文件 | 装什么 | 谁写 |
 |---|---|---|
 | `ledger/progress.json` | 在办任务的状态：任务号 / 标题 / 创建人 / owner / 状态 / 时间 / **分类（`category`）与标签（`tags`）** / 过程文档路径（`worklog` 字段） | **只由脚本写** |
-| `ledger/worklog/<年月>/<日>-<时分>-<说明>-<随机码>.md` | 该任务的过程正文，固定五节：背景 / 待办 / 下一步 / 过程 / 结论 | **建档只由脚本按模板做**，之后正文由 agent 直接编辑 |
+| `ledger/worklog/<年月>/<日>-<时分>-<说明>-<随机码>.md` | 该任务的过程正文，固定六节：背景 / 待办 / 下一步 / 过程 / 结论 + **执行记录**（末节，脚本维护、禁手改） | **建档只由脚本按模板做**，之后正文（前五节）由 agent 直接编辑 |
 | `ledger/history/<年月>.md` | 已结案任务，一行一条（8 列：结案时间 / 创建时间 / 工作包 / 分类 / 标签 / **owner** / 摘要 / 过程文档）；按**结案时间**分月。存量 `ledger/PROGRESS-HISTORY.md` 只读兼容、永不重写 | **只由脚本写**；查询走 `history` 子命令 |
 
 这三个文件之外不要另建副本。**不要直接编辑状态表和历史索引 —— 一律走脚本。**
-过程文档的**建档也一律走脚本**（`new`）：脚本按模板生成五节骨架、把路径写进状态表；
+过程文档的**建档也一律走脚本**（`new`）：脚本按模板生成六节骨架、把路径写进状态表；
 你只负责往里填正文，**不要自己拼文件名、也不要另建一个 md 顶替它**。
 
 **台账 ≠ 产出物**：台账（`ledger/`）只装「什么时候建 / 谁在做 / 做到哪 / 什么时候结案」
@@ -49,14 +49,14 @@ allowed-tools: Read,Write,Bash,Grep
 |---|---|---|
 | 「现在该做什么」「我还有啥没做完」 | 查自己的在办 | `list --mine` |
 | 「谁在做 X」「有哪些在办任务」 | 查全部在办 | `list` |
-| 「有没有卡住的」 | 按状态查 | `list --status blocked` |
+| 「有哪些在等认领」 | 按状态查 | `list --status open` |
 | 「某件老活是什么时候做的」 | 查已结案 | `history`（只读，可直接跑） |
 | 「谁改过什么」「拉某人的工作日志」 | 按人查已结案 | `history --owner "<名字>"`（**精确匹配**） |
 | 「这周 / 这个月建了啥活」 | 按创建时间查已结案 | `history --since 2026-10-01` |
 | 「新建一个任务」「我要做 X」 | 建任务 | `new` |
 | 「这活我领了」「我来做这个」 | 认领 | `claim` |
-| 「卡住了」「先放一放」 | 改状态 | `set --status blocked` |
-| 「继续做」「解卡了」 | 改状态 | `set --status doing` |
+| 「卡住了」「先放一放」 | 写清卡在哪（不改状态） | 编辑 worklog 的「待办 / 过程」，再 `log --note "卡在…"` |
+| 「继续做」 | 记一条推进 | `log --note "继续推进…"` |
 | 「转给某人」「交接给某人」 | 换负责人 | `set --owner "<新负责人>"` |
 | 「这活做完了」「验收通过」「结案」 | 结案归档 | `close`（**这句必须由用户说**） |
 | 项目里还没有状态表 | 初始化 | `init` |
@@ -80,6 +80,7 @@ python3 <本 SKILL.md 所在目录>/scripts/progress.py <子命令> --repo <当
 | `new` | 新建任务，并自动建过程文档 | `--title`（必填）、`--id`（可选）、`--self`、`--created`（可选，补录创建时间）、`--category` / `--tags`（可选，分类 / 标签，见下节口径） |
 | `claim` | 认领一个待认领任务 | `--id`（必填） |
 | `set` | 改状态 / 换负责人 | `--id`（必填）、`--status`、`--owner` |
+| `log` | 往 worklog 的「执行记录」节补一条 | `--id`（必填）、`--note`（必填，一句话） |
 | `close` | 结案：移出状态 + 追加历史 + 封卷过程文档 | `--id`、`--summary`（都必填）、`--finished`（可选，结案时间）、`--category` / `--tags`（可选，结案时覆盖修正一次） |
 | `list` | 查询在办任务 | `--mine`、`--owner`、`--status`、`--since`、`--until`、`--category`（精确）、`--tag`（包含）、`--json` |
 | `history` | 查已结案任务（只读） | `--owner`、`--mine`、`--since`、`--until`、`--limit`、`--category`（精确）、`--tag`（包含）、`--json`；另：`--count-only`（只数行数、封顶 1 万输出 `{count, capped}`，显示级统计）、`--months N`（只读最近 N 个月文件，不含存量平铺文件） |
@@ -92,13 +93,15 @@ python3 <本 SKILL.md 所在目录>/scripts/progress.py <子命令> --repo <当
 | 命令 | 返回 |
 |---|---|
 | `new` / `claim` / `set` / `show` | 状态行 + **该任务过程文档的路径与全文** —— 拿到就能直接编辑，不用再去找文件、拼路径（`history` 是例外：只给链接不给全文） |
+| `log` | 一行确认（记了什么） |
 | `close` | 结案结果与摘要 |
 | `list` | 在办任务列表（**不含**文档正文，避免撑爆上下文） |
 | `history` | 已结案紧凑列表（结案时间 / 创建时间 / owner / 工作包 / 过程文档链接，行尾附所在历史文件），**默认不含摘要**；要摘要走 `--json` |
 
 ### 几个必须知道的点
 
-- **状态取值**：`open`（已建待认领）/ `doing` / `blocked` / `done`。**`done` 只能由 `close` 产生**，不要用 `set --status done`。
+- **状态取值**：只有 `open`（已建待认领）/ `doing`（已认领在做）两个；`done` 只能由 `close` 产生，不要用 `set --status done`。
+  **没有 `blocked` 状态**：阻塞由时间判定（接任务满 7 天仍未结案），看板自己算，不用也不能手动改；卡在哪里写进 worklog。旧数据里残留的 `blocked` 读侧当进行中处理（`list --status blocked` 可捞出来，用 `set --status doing` 归位）。
 - **`new --self`** = 建完即认领（直接 `doing`）；**不带 `--self`** = 空开，等别人 `claim`。
 - **任务号自动生成**：创建时间（`年月日-时分`）+ 标题里的字母、数字、汉字 + 4 位随机码（如 `20261015-1430-登录接入-sso-7f3a`）。想指定就传 `--id`。
 - **owner 取 `git config user.name`**：认领人**只能是当前 git 身份，不能由外部传入**；读不到就直接报错退出（提示「需要用户名才能执行」），不做任何兜底 —— 先让用户配好 git 身份。（`history` 只有 `--mine` 会取这个身份；`--owner <别人>` 是只读查询，不校验身份）
@@ -117,7 +120,7 @@ python3 <本 SKILL.md 所在目录>/scripts/progress.py <子命令> --repo <当
 ## 过程文档的生命周期
 
 1. **建档** —— 执行 `new` 时，脚本**必须**按 `assets/worklog.md` 模板创建 `ledger/worklog/<年月>/<日>-<时分>-<说明>-<随机码>.md`（`<年月>` 取任务创建月份，如 `202610`；年月已经在目录名里，文件名不再重复）。路径同时写进状态表的 `worklog` 字段，查的时候不必靠推算。
-2. **推进** —— 这个 md 由 **agent 直接编辑**（它是正文，不是状态数据，不走脚本）。五节（背景 / 待办 / 下一步 / 过程 / 结论）**标题结构不能动**。**各写什么、写成什么样算对，模板注释里给了正例**，照它填即可。
+2. **推进** —— 这个 md 由 **agent 直接编辑**（它是正文，不是状态数据，不走脚本）。六节（背景 / 待办 / 下一步 / 过程 / 结论 / 执行记录）**标题结构不能动**，且**末节「执行记录」由脚本维护、不许手改**：改完前五节内容后跑一次 `log --id <任务号> --note "这轮做了什么"`，脚本会按时间追加一行（`new` / `claim` / `set` / `close` 也会各自自动记一条）。记录格式固定 `- 时间 · 类型 · @谁 · 说明`，类型取 `new` / `claim` / `set` / `release`（`set --status open` 释放认领，单列）/ `log` / `close`；**只追加不改旧行**，移交后旧记录仍记在原负责人名下。**各写什么、写成什么样算对，模板注释里给了正例**，照它填即可。
 3. **交付（待验收）** —— 活干完了但**用户还没验收**时，任务仍留在 `doing`：worklog 的「待办」写「待用户验收」，「下一步」写清验收该看什么（哪条命令、哪个文件）。**这一段不产出状态变化，只写正文。**
 4. **封卷** —— 执行 `close` 时，脚本自动打封卷标记并把头部状态改为完成，此后不再修改。历史行按**结案时间**落 `ledger/history/<年月>.md`（存量 `ledger/PROGRESS-HISTORY.md` 只读、不再写入）；封卷后要找回这篇文档：`history` 会给出它的链接与所在历史文件（只读、无需确认）。
 
@@ -149,7 +152,7 @@ python3 <本 SKILL.md 所在目录>/scripts/progress.py <子命令> --repo <当
 
 `init` / `new` / `claim` / `set` / `close` 都有副作用，但**分两档**：
 
-**一、动手类（`init` / `new` / `claim` / `set`）**：执行前先把完整参数复述给用户并取得确认（任务号、标题、负责人、目标状态）。不得先执行再补报告，也不得一次执行多条用户没逐条确认的写操作。
+**一、动手类（`init` / `new` / `claim` / `set` / `log`）**：执行前先把完整参数复述给用户并取得确认（任务号、标题、负责人、目标状态）。不得先执行再补报告，也不得一次执行多条用户没逐条确认的写操作。
 
 **二、`close` 是独立授权，不是做任务流程的最后一步**：
 

package/assets/worklog.md

@@ -29,3 +29,10 @@
 
 <!-- 收尾时填：做成了什么、留了什么坑。
      例：已修复，但只覆盖 UTF-8；GBK 另开任务 -->
+
+## 执行记录
+
+<!-- 本节由脚本维护：new / claim / set / close / log 自动追加，请勿手改。
+     要补一条就跑 progress.py log --id <任务号> --note "做了什么"。
+     每条一行：时间 · 类型 · @谁 · 说明（类型取 new / claim / set / release / log / close）；
+     只追加、不改旧行 —— 移交后旧记录仍留在原负责人名下。 -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-ledger",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Task-ledger skill for coding agents: per-workspace progress tracking (ledger/progress.json, history, worklog) driven by a CLI script. Standalone install for CodeBuddy and other agents; also bundled inside the dsh-task-ledger DSH plugin.",
   "keywords": [
     "skill",

package/scripts/progress.py

@@ -5,7 +5,7 @@
   ledger/progress.json                在办任务的状态
   ledger/worklog/<年月>/<日>-<时分>-<说明>-<随机码>.md
                                      单个任务的过程（路径另记在状态表 worklog 字段）
-  ledger/history/<年月>.md            已结案任务，一行一条（8 列：结案时间 / 创建时间 / 工作包 / 分类 / 标签 / owner / 完成了什么 / 过程文档）；
+  ledger/history/<年月>.md            已结案任务，一行一条（9 列：结案时间 / 创建时间 / 工作包 / 分类 / 标签 / owner / creator / 完成了什么 / 过程文档）；
                                      按结案时间分月归档。存量 ledger/PROGRESS-HISTORY.md 只读兼容、永不重写
 
 只用标准库，无第三方依赖。
@@ -37,7 +37,10 @@ try:
 except ImportError:
     msvcrt = None
 
-STATUSES = ("open", "doing", "blocked", "done")
+STATUSES = ("open", "doing")
+# 旧数据只读兼容：早期版本有 blocked 状态（手动标「卡住」）。现在阻塞按时间判定
+# （接任务满 7 天），不再允许新写入；list / validate / 看板仍能吃老文件。
+LEGACY_STATUSES = ("blocked",)
 PROGRESS_REL = Path("ledger/progress.json")
 # 存量：改造前的单文件历史层，只读兼容、永不重写
 HISTORY_REL = Path("ledger/PROGRESS-HISTORY.md")
@@ -46,13 +49,12 @@ HISTORY_DIR = Path(
 )  # 新历史层：按结案时间分月，ledger/history/<YYYYMM>.md
 WORKLOG_DIR = Path("ledger/worklog")
 HISTORY_TITLE = "# 进度历史（已结案）"
-# 8 列：结案时间 / 创建时间 / 工作包 / 分类 / 标签 / owner / 完成了什么 / 过程文档。
+# 9 列：结案时间 / 创建时间 / 工作包 / 分类 / 标签 / owner / creator / 完成了什么 / 过程文档。
 # owner 独立成列 —— 按人检索是精确列比较，不靠文本切分。
-# 分类/标签列（2026-10-15 存量改造时加入）：close 从 task 直写；旧 4/5/6 列由
-# upgrade_history 升级为 8 列（回链 worklog 头部补值），parse_history 三时代兼容读取。
-HISTORY_HEADER = (
-    "| 结案时间 | 创建时间 | 工作包 | 分类 | 标签 | owner | 完成了什么 | 过程文档 |"
-)
+# creator（2026-10-17 加）：任务的「发起人」——与 owner 区分（owner 可被 claim 改走，
+# 但「谁建的」不变）。看板「新增（我的）= 我创建的」要它；旧 8 列无此列，
+# upgrade_history / cmd_history 回链 worklog 头部「创建」行补（与 created 同一来源，不丢）。
+HISTORY_HEADER = "| 结案时间 | 创建时间 | 工作包 | 分类 | 标签 | owner | creator | 完成了什么 | 过程文档 |"
 HISTORY_SEP = "|---|---|---|---|---|---|---|---|"
 FROZEN_MARK = "✅ 完成封卷"
 ID_RE = re.compile(r"[a-z0-9\u4e00-\u9fff][a-z0-9\u4e00-\u9fff-]*\Z")
@@ -66,6 +68,14 @@ LABEL_MAX_WORDS_EN = 3
 TAGS_MAX_COUNT = 5
 CJK_RE = re.compile(r"[\u4e00-\u9fff]")
 
+# 执行记录：worklog 末尾由脚本维护的一节。老文档没有这一节就不动（不迁移）；
+# 有这一节时脚本按节点自动追加，agent 改完正文跑 log 补一条。
+EXEC_HEAD = "## 执行记录"
+EXEC_HINT = (
+    "<!-- 本节由脚本维护：new / claim / set / close / log 自动追加，请勿手改。\n"
+    '     要补一条就跑 progress.py log --id <任务号> --note "做了什么"。 -->'
+)
+
 SKILL_DIR = Path(__file__).resolve().parent.parent
 WORKLOG_TEMPLATE = SKILL_DIR / "assets" / "worklog.md"
 
@@ -82,6 +92,8 @@ FALLBACK_TEMPLATE = """# <id>：<title>
 ## 过程
 
 ## 结论
+
+## 执行记录
 """
 
 
@@ -403,6 +415,11 @@ def owner_cell(owner: str | None) -> str:
     return f"@{owner}" if owner else ""
 
 
+def creator_cell(creator: str | None) -> str:
+    """creator 列展示值（与 owner_cell 同一 @ 约定）。"""
+    return f"@{creator}" if creator else ""
+
+
 def history_line(
     finished: str,
     created: str | None,
@@ -412,17 +429,19 @@ def history_line(
     log_rel: str,
     category: str | None = None,
     tags: list[str] | None = None,
+    creator: str | None = None,
 ) -> str:
-    """历史层的一行（8 列：结案时间 / 创建时间 / 工作包 / 分类 / 标签 / owner / 完成了什么 / 过程文档）。
+    """历史层的一行（9 列：结案时间 / 创建时间 / 工作包 / 分类 / 标签 / owner / creator / 完成了什么 / 过程文档）。
 
-    close 专用，避免两处格式漂移。owner 是独立列、单独过 esc_cell ——
-    它来自 git config user.name，含 `|` 也不稀奇。分类/标签由 close 传 task 终值。
+    close 专用，避免两处格式漂移。owner / creator 是独立列、单独过 esc_cell ——
+    它们来自 git config user.name，含 `|` 也不稀奇。分类/标签由 close 传 task 终值。
     """
     cat_cell = esc_cell(category or "")
     tag_cell = esc_cell("、".join(tags) if tags else "")
     return (
         f"| {finished} | {created or ''} | {esc_cell(title)} | {cat_cell} | {tag_cell} "
-        f"| {esc_cell(owner_cell(owner))} | {esc_cell(summary)} | [{log_rel}]({log_rel}) |\n"
+        f"| {esc_cell(owner_cell(owner))} | {esc_cell(creator_cell(creator))} "
+        f"| {esc_cell(summary)} | [{log_rel}]({log_rel}) |\n"
     )
 
 
@@ -436,12 +455,13 @@ def history_line_for_cols(
     log_rel: str,
     category: str | None = None,
     tags: list[str] | None = None,
+    creator: str | None = None,
 ) -> str:
     """「历史层有无法解析的行、不敢整体升级」时，按现有列数追加一行，避免列错位。
 
     GFM 按首行列数渲染，列数写错会被静默丢弃 / 错位。cols<=4 ⇒ 旧 4 列（owner 缝在
     工作包末尾）；5 ⇒ 无创建时间列；6 ⇒ 无分类/标签列（存量改造前的最后形态）；
-    否则 8 列。分类/标签只在 8 列里出现 —— 少列的文件硬塞会把整行挤歪。
+    否则 9 列。分类/标签/creator 只在 9 列里出现 —— 少列的文件硬塞会把整行挤歪。
     """
     if cols <= 4:
         who = f" @{owner}" if owner else ""
@@ -460,7 +480,7 @@ def history_line_for_cols(
             f"| {esc_cell(owner_cell(owner))} | {esc_cell(summary)} | [{log_rel}]({log_rel}) |\n"
         )
     return history_line(
-        finished, created, title, owner, summary, log_rel, category, tags
+        finished, created, title, owner, summary, log_rel, category, tags, creator
     )
 
 
@@ -509,11 +529,13 @@ def _looks_like_header(cells: list[str]) -> bool:
 def parse_history(text: str) -> tuple[list[dict[str, Any]], list[str]]:
     """解析历史层，返回 (records, warnings)。
 
-    多格式兼容：8 列 = v8（结案时间 / 创建时间 / 工作包 / 分类 / 标签 / …）；6 列 = v6
+    多格式兼容：9 列 = v9（结案时间 / 创建时间 / 工作包 / 分类 / 标签 / owner / creator / …）；
+    8 列 = v8（存量改造后、2026-10-17 前，无 creator）；6 列 = v6
     （存量改造前最后形态，无分类/标签）；5 列且第 2 列是时间 = 旧 ledger 格式
     （有创建时间列、无 owner 列）；5 列 = 无创建时间列；4 列 = 最旧（owner 缝在工作包末尾）。
     **逐行按自己的列数判别**，表头只用来跳过 —— 旧文件追加新列
-    后是混排态，按表头判列数会切错。坏行（列数不在 4/5/6/8、时间列不合法）不中断：跳过 + 警告。
+    后是混排态，按表头判列数会切错。坏行（列数不在 4/5/6/8/9、时间列不合法）不中断：跳过 + 警告。
+    8 列行无 creator 列 ⇒ creator 留 None，cmd_history 回链 worklog 头部「创建」行补（与 created 同源）。
     """
     records: list[dict[str, Any]] = []
     warnings: list[str] = []
@@ -526,13 +548,31 @@ def parse_history(text: str) -> tuple[list[dict[str, Any]], list[str]]:
         created = ""
         category: str | None = None
         tags: list[str] = []
-        if len(cells) == 8:
+        creator: str | None = None
+        if len(cells) == 9:
+            (
+                finished,
+                created,
+                workpackage,
+                category,
+                tag_cell,
+                owner,
+                creator,
+                summary,
+                doc,
+            ) = cells
+            fmt = "v9"
+            category = category.strip() or None
+            tags = [t.strip() for t in re.split(r"[,，、]", tag_cell) if t.strip()]
+            creator = creator.strip().removeprefix("@") or None
+        elif len(cells) == 8:
             finished, created, workpackage, category, tag_cell, owner, summary, doc = (
                 cells
             )
             fmt = "v8"
             category = category.strip() or None
             tags = [t.strip() for t in re.split(r"[,，、]", tag_cell) if t.strip()]
+            # 旧 8 列无 creator 列：留 None，cmd_history 回链 worklog 头部补（不丢）
         elif len(cells) == 6:
             finished, created, workpackage, owner, summary, doc = cells
             fmt = "v6"
@@ -555,7 +595,7 @@ def parse_history(text: str) -> tuple[list[dict[str, Any]], list[str]]:
                 owner = ""
             fmt = "v4"
         else:
-            warnings.append(f"第 {lineno} 行列数不是 4 / 5 / 6 / 8，已跳过")
+            warnings.append(f"第 {lineno} 行列数不是 4 / 5 / 6 / 8 / 9，已跳过")
             continue
         if not TIME_RE.fullmatch(finished):
             warnings.append(f"第 {lineno} 行时间列 {finished!r} 不合法，已跳过")
@@ -572,6 +612,7 @@ def parse_history(text: str) -> tuple[list[dict[str, Any]], list[str]]:
                 "category": category,
                 "tags": tags,
                 "owner": own or None,
+                "creator": creator,
                 "summary": summary,
                 "log": log or None,
                 "fmt": fmt,
@@ -581,11 +622,14 @@ def parse_history(text: str) -> tuple[list[dict[str, Any]], list[str]]:
     return records, warnings
 
 
-# worklog 头部「创建」行：`> **创建**：2026-10-06 00:00（@某人）`。用于给旧历史行回填创建时间。
+# worklog 头部「创建」行：`> **创建**：2026-10-06 00:00（@某人）`。
+# 时间给旧历史行回填创建时间；括号内 @某人 即 creator（发起人）。
 WORKLOG_CREATED_RE = re.compile(
     r"^\s*>\s*\*\*创建\*\*\s*[：:]\s*"
     r"(\d{4}-\d{2}-\d{2}(?: +\d{1,2}:\d{1,2}(?::\d{1,2})?)?)"
 )
+# 同一行的发起人（@某人）——creator 列来源。
+WORKLOG_CREATOR_RE = re.compile(r"^\s*>\s*\*\*创建\*\*\s*[：:].*?（@(.+?)）")
 
 
 def created_for_history(log_cell: str, history_path: Path) -> str | None:
@@ -611,6 +655,28 @@ def created_for_history(log_cell: str, history_path: Path) -> str | None:
     return None
 
 
+def creator_for_history(log_cell: str | None, history_path: Path) -> str | None:
+    """顺着历史行的文档链接找到 worklog，读它头部「创建」行的发起人（@某人）；找不到返回 None。
+
+    旧 8 列历史行没有 creator 列，迁移 / 只读回填都靠它 —— 与 created 同源，不丢数据。
+    """
+    if not log_cell:
+        return None
+    m = re.fullmatch(r"\[[^\]]*\]\(([^)]*)\)", log_cell.strip())
+    rel = (m.group(1) if m else log_cell).strip()
+    if not rel:
+        return None
+    try:
+        text = (history_path.parent / rel).read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return None
+    for ln in text.splitlines():
+        mm = WORKLOG_CREATOR_RE.match(ln)
+        if mm:
+            return mm.group(1).strip()
+    return None
+
+
 def labels_for_log(
     log_cell: str | None, history_path: Path
 ) -> tuple[str | None, list[str]]:
@@ -633,11 +699,13 @@ def labels_for_log(
 
 
 def upgrade_history(text: str, history_path: Path) -> tuple[str, int] | None:
-    """旧格式（4 / 5 / 6 列）→ v8（8 列）。全部数据行可解析才返回 (新文本, 转换行数)，否则 None。
+    """旧格式（4 / 5 / 6 / 8 列）→ v9（9 列）。全部数据行可解析才返回 (新文本, 转换行数)，否则 None。
 
     None 的语义是「不敢动」：调用方必须退回按原列数追加并明示，绝不半升级、绝不猜。
     分类/标签列：回链每行的 worklog 头部读「分类/标签」行（读不到留空，不编造）——
     与 created 的回填同一模式，依赖 Step 2 已给存量 worklog 补行。
+    creator 列（2026-10-17 加）：旧 8 列无此列，同样回链 worklog 头部「创建」行的
+    （@发起人）补 —— **与 created 同源，迁移不丢发起人**。读不到留空。
     缺创建时间的旧行：先读它链接的 worklog 头部「创建」行，找不到用升级时刻 —— 不允许留空。
     5 列有两种（判别与 parse_history 一致，靠「第 2 列是不是时间」）：旧 ledger 格式
     （结案 / 创建 / 工作包 / 摘要 / 文档，无 owner）行内自带创建时间，优先用它；
@@ -662,13 +730,33 @@ def upgrade_history(text: str, history_path: Path) -> tuple[str, int] | None:
         if _looks_like_header(cells):
             out.append(HISTORY_HEADER)
             continue
-        if len(cells) == 8:
-            # v8 行原样回写：内容已是最终格式（含分类/标签）
+        if len(cells) == 9:
+            # v9 行原样回写：已含 creator
             if time_key(cells[0]) is None:
                 return None
             out.append("| " + " | ".join(cells) + " |")
             continue
         explicit_created: str | None = None
+        creator: str | None = None
+        if len(cells) == 8:
+            # v8 → v9：补 creator 列（回链 worklog 头部「创建」行的 @发起人；读不到留空不编造）
+            finished, created, workpackage, category, tag_cell, owner, summary, doc = (
+                cells
+            )
+            if time_key(finished) is None:
+                return None
+            created_key = time_key(created.strip())
+            cat = category.strip() or None
+            tags = [t.strip() for t in re.split(r"[,，、]", tag_cell) if t.strip()]
+            creator = creator_for_history(doc, history_path) or ""
+            out.append(
+                f"| {finished} | {created_key or ''} | {esc_cell(workpackage)} "
+                f"| {esc_cell(cat or '')} | {esc_cell('、'.join(tags) if tags else '')} "
+                f"| {esc_cell(owner_cell(owner.lstrip('@')))} | {esc_cell(creator_cell(creator))} "
+                f"| {esc_cell(summary)} | {doc} |"
+            )
+            converted += 1
+            continue
         if len(cells) == 6:
             finished, created, workpackage, owner, summary, doc = cells
             # v6 升级：owner 单元格已是展示格式（带 @），剥掉再走 owner_cell，否则升级出 @@
@@ -698,10 +786,12 @@ def upgrade_history(text: str, history_path: Path) -> tuple[str, int] | None:
             return None
         created = explicit_created or created_for_history(doc, history_path) or fallback
         cat, tags = labels_for_log(doc, history_path)
+        creator = creator_for_history(doc, history_path) or ""
         out.append(
             f"| {finished_key} | {created} | {esc_cell(workpackage)} "
             f"| {esc_cell(cat or '')} | {esc_cell('、'.join(tags) if tags else '')} "
-            f"| {esc_cell(owner_cell(owner))} | {esc_cell(summary)} | {doc} |"
+            f"| {esc_cell(owner_cell(owner))} | {esc_cell(creator_cell(creator))} "
+            f"| {esc_cell(summary)} | {doc} |"
         )
         converted += 1
     return "\n".join(out) + "\n", converted
@@ -796,18 +886,27 @@ def append_history_line(
     log_rel: str,
     category: str | None = None,
     tags: list[str] | None = None,
+    creator: str | None = None,
 ) -> tuple[str, int]:
     """把一行历史追加到指定历史文件，返回 (新全文, 升级行数)。
 
-    读目标 → upgrade_history → 解析不了就按现有列数追加（绝不把 8 列写进少列表头）
-    → 文件不存在则带 8 列表头新建。close 专用：「行落哪个月」之外，
-    历史行的落盘逻辑只此一处。分类/标签由 close 传 task 终值。
+    读目标 → upgrade_history → 解析不了就按现有列数追加（绝不把 9 列写进少列表头）
+    → 文件不存在则带 9 列表头新建。close 专用：「行落哪个月」之外，
+    历史行的落盘逻辑只此一处。分类/标签/creator 由 close 传 task 终值。
     """
     if not history_path.exists():
         return (
             f"{HISTORY_TITLE}\n\n{HISTORY_HEADER}\n{HISTORY_SEP}\n"
             + history_line(
-                finished, created, title, owner, summary, log_rel, category, tags
+                finished,
+                created,
+                title,
+                owner,
+                summary,
+                log_rel,
+                category,
+                tags,
+                creator,
             ),
             0,
         )
@@ -836,6 +935,7 @@ def append_history_line(
                 log_rel,
                 category,
                 tags,
+                creator,
             ),
             0,
         )
@@ -843,7 +943,7 @@ def append_history_line(
     return (
         new_text
         + history_line(
-            finished, created, title, owner, summary, log_rel, category, tags
+            finished, created, title, owner, summary, log_rel, category, tags, creator
         ),
         n,
     )
@@ -1047,6 +1147,53 @@ def find_worklog(
     return None
 
 
+def exec_line(when: str, who: str | None, kind: str, note: str) -> str:
+    """一条执行记录：`- 时间 · 类型 · @某人 · 说明`。
+
+    类型取脚本子命令名（new / claim / set / log / close），纯 ASCII、可 grep 统计；
+    记录只追加不改写 —— 移交后旧记录仍记在原来那个人名下。
+    """
+    head = f"- {when} · {kind}"
+    return f"{head} · @{who} · {note}" if who else f"{head} · {note}"
+
+
+def append_exec_log(text: str, line: str) -> str:
+    """把一条记录追加到「执行记录」节末尾；文档没有这一节（老 worklog）原样返回。"""
+    lines = text.splitlines()
+    at = next((i for i, ln in enumerate(lines) if ln.strip() == EXEC_HEAD), None)
+    if at is None:
+        return text
+    end = next(
+        (i for i in range(at + 1, len(lines)) if lines[i].startswith("## ")), len(lines)
+    )
+    insert = end
+    while insert > at + 1 and not lines[insert - 1].strip():
+        insert -= 1
+    lines.insert(insert, line)
+    return "\n".join(lines) + "\n"
+
+
+def record_exec(
+    repo: Path, tid: str, task: dict[str, Any], who: str | None, kind: str, note: str
+) -> None:
+    """给任务的过程文档补一条执行记录（`who` = 这次动手的人，不是任务现 owner）。
+
+    调用方必须已经持有 progress_lock —— 与 close 的封卷（读全文→改写→落盘）互斥，
+    否则两条记录并发追加会互相覆盖。
+    """
+    log = find_worklog(repo, tid, task)
+    if log is None:
+        return
+    try:
+        text = log.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return
+    line = exec_line(now(), who, kind, note)
+    new_text = append_exec_log(text, line)
+    if new_text != text:
+        write_text_atomic(log, new_text)
+
+
 def write_worklog(repo: Path, tid: str, task: dict[str, Any]) -> Path:
     log = repo / worklog_dir_for(task) / worklog_name(tid)
     write_text_atomic(log, render_worklog(tid, task))
@@ -1131,6 +1278,7 @@ def cmd_new(args: argparse.Namespace) -> None:
             "status": "doing" if args.self else "open",
             "created": stamp,
             "started": stamp if args.self else None,
+            "updated": stamp,
             "finished": None,
             "category": category,
             "tags": tags,
@@ -1149,6 +1297,7 @@ def cmd_new(args: argparse.Namespace) -> None:
             except Fail:
                 pass
             raise Fail(f"创建失败，已从状态表撤销该任务：{exc}")
+        record_exec(repo, tid, task, creator, "new", f"创建任务（{task['status']}）")
     print(f"已创建任务 {tid}")
     print(f"  标题    {task['title']}")
     print(f"  状态    {task['status']}")
@@ -1184,10 +1333,13 @@ def cmd_claim(args: argparse.Namespace) -> None:
                 f"任务 {tid} 当前状态是 {task.get('status')}，只有 open 才能认领。"
             )
 
+        stamp = now()
         task["owner"] = owner
         task["status"] = "doing"
-        task["started"] = task.get("started") or now()
+        task["started"] = task.get("started") or stamp
+        task["updated"] = stamp
         commit_guarded(path, before, data)
+        record_exec(repo, tid, task, owner, "claim", "认领 → doing")
     print(f"已认领 {tid} → doing，owner = @{owner}")
     print_worklog(repo, tid, task)
 
@@ -1205,12 +1357,17 @@ def cmd_set(args: argparse.Namespace) -> None:
         raise Fail(
             "--status open（退回未认领）不能同时给 --owner；要交给别人就别改回 open。"
         )
-    if status is not None and status not in STATUSES:
-        raise Fail(f"--status 只能是 {' / '.join(STATUSES)}；结案请用 close。")
+    if status == "blocked":
+        raise Fail(
+            "没有 blocked 状态：阻塞由时间自动判定（接任务满 7 天仍未结案），"
+            "状态只有 open / doing；卡在哪里请写进 worklog。"
+        )
     if status == "done":
         raise Fail(
             "不要把状态直接改成 done —— 用 close 结案（它会同时移出状态、追加历史、封卷 worklog）。"
         )
+    if status is not None and status not in STATUSES:
+        raise Fail(f"--status 只能是 {' / '.join(STATUSES)}；结案请用 close。")
 
     repo = find_repo(args.repo)
     tid = require_task_id(args.id)
@@ -1241,11 +1398,35 @@ def cmd_set(args: argparse.Namespace) -> None:
             task["started"] = task.get("started") or now()
             changed.append(f"owner {old or '（无）'} → {task['owner']}")
 
+        task["updated"] = now()
         commit_guarded(path, before, data)
+        # 释放认领（退回 open）单列一个类型，便于一眼看出「被释放过」
+        kind = "release" if status == "open" else "set"
+        record_exec(repo, tid, task, me, kind, "，".join(changed))
     print(f"已更新 {tid}：" + "，".join(changed))
     print_worklog(repo, tid, task)
 
 
+def cmd_log(args: argparse.Namespace) -> None:
+    repo = find_repo(args.repo)
+    tid = require_task_id(args.id)
+    note = " ".join(args.note.split())
+    if not note:
+        raise Fail("--note 不能为空：一句话写清这轮做了什么。")
+    me = git_user()
+    path = repo / PROGRESS_REL
+    with progress_lock(path):
+        before, data = read_guarded(path)
+        task = data["tasks"].get(tid)
+        if task is None:
+            raise Fail(f"没有任务 {tid}（可能未建或已结案；封卷后不再记）。")
+        require_owner(task, tid, me)
+        task["updated"] = now()
+        commit_guarded(path, before, data)
+        record_exec(repo, tid, task, me, "log", note)
+    print(f"已记入 {tid} 的执行记录：{note}")
+
+
 def cmd_close(args: argparse.Namespace) -> None:
     repo = find_repo(args.repo)
     tid = require_task_id(args.id)
@@ -1308,6 +1489,7 @@ def cmd_close(args: argparse.Namespace) -> None:
             log_rel,
             final_cat,
             final_tags,
+            task.get("creator"),
         )
 
         if log_path.exists():
@@ -1326,29 +1508,33 @@ def cmd_close(args: argparse.Namespace) -> None:
                     if close_tags is not None
                     else list(task.get("tags") or []),
                 )
-            new_log = stamp_frozen(log_text, finished, owner)
         else:
-            new_log = stamp_frozen(
-                render_worklog(
-                    tid,
-                    dict(
-                        task,
-                        status="done",
-                        category=(
-                            close_category
-                            if close_category is not None
-                            else task.get("category")
-                        ),
-                        tags=(
-                            close_tags
-                            if close_tags is not None
-                            else list(task.get("tags") or [])
-                        ),
+            log_text = render_worklog(
+                tid,
+                dict(
+                    task,
+                    status="done",
+                    category=(
+                        close_category
+                        if close_category is not None
+                        else task.get("category")
+                    ),
+                    tags=(
+                        close_tags
+                        if close_tags is not None
+                        else list(task.get("tags") or [])
                     ),
                 ),
-                finished,
-                owner,
             )
+        # 结案本身是最后一个节点：封卷前补上这条记录，封卷后不再追加
+        new_log = stamp_frozen(
+            append_exec_log(
+                log_text,
+                exec_line(finished, me, "close", f"结案：{summary}"),
+            ),
+            finished,
+            owner,
+        )
 
         # 落盘前复查：三个文件都没被别人动过
         for p, mark in (
@@ -1451,18 +1637,13 @@ def cmd_list(args: argparse.Namespace) -> None:
     if args.status is not None:
         wanted = [s.strip() for s in args.status.split(",") if s.strip()]
         if not wanted:
-            raise Fail("--status 不能为空；逗号分隔，如 doing,blocked")
-        bad = [s for s in wanted if s not in STATUSES]
+            raise Fail("--status 不能为空；逗号分隔，如 doing,open")
+        # blocked 只用于捞旧数据（新任务不可能再有这个值）
+        bad = [s for s in wanted if s not in STATUSES and s not in LEGACY_STATUSES]
         if bad:
             raise Fail(
                 f"--status 含非法值 {', '.join(bad)}；可选 {' / '.join(STATUSES)}"
             )
-        if "done" in wanted:
-            print(
-                "提示：done 的任务已结案并移出状态表，用 history 子命令查"
-                "（已结案在 ledger/history/<年月>.md，存量在 ledger/PROGRESS-HISTORY.md）。",
-                file=sys.stderr,
-            )
 
     since = normalize_time(args.since, field="--since") if args.since else None
     until = (
@@ -1646,7 +1827,7 @@ def cmd_validate(args: argparse.Namespace) -> None:
         if not task.get("title"):
             problems.append(f"{tid}: 缺 title")
         status = task.get("status")
-        if status not in STATUSES:
+        if status not in STATUSES and status not in LEGACY_STATUSES:
             problems.append(f"{tid}: status={status!r} 非法")
         if status == "open" and task.get("owner"):
             problems.append(f"{tid}: status=open 却有 owner")
@@ -1788,6 +1969,9 @@ def cmd_history(args: argparse.Namespace) -> None:
             # 8 列行自带分类/标签；旧 4/5/6 列行没有，回链读 worklog 头部兜底
             if not r.get("category") and not r.get("tags"):
                 r["category"], r["tags"] = labels_for_log(r["log"], hp)
+            # v8 行（无 creator 列）回链 worklog 头部「创建」行取发起人，不丢
+            if not r.get("creator"):
+                r["creator"] = creator_for_history(r["log"], hp)
         records.extend(recs)
         warnings.extend(f"{rel} {w}" for w in warns)
 
@@ -1919,6 +2103,12 @@ def build_parser() -> argparse.ArgumentParser:
     add_repo(p)
     p.set_defaults(func=cmd_set)
 
+    p = sub.add_parser("log", help="往 worklog 的「执行记录」节补一条记录")
+    p.add_argument("--id", required=True)
+    p.add_argument("--note", required=True, help="一句话：这轮做了什么")
+    add_repo(p)
+    p.set_defaults(func=cmd_log)
+
     p = sub.add_parser("close", help="结案：移出状态 + 追加历史 + 封卷 worklog")
     p.add_argument("--id", required=True)
     p.add_argument("--summary", required=True, help="做成了什么，一句话")
@@ -1933,7 +2123,7 @@ def build_parser() -> argparse.ArgumentParser:
     p = sub.add_parser("list", help="查询在办任务")
     p.add_argument("--mine", action="store_true", help="只看自己的")
     p.add_argument("--owner", help="只看某个人的")
-    p.add_argument("--status", help="逗号分隔，如 doing,blocked")
+    p.add_argument("--status", help="逗号分隔，如 doing,open")
     p.add_argument("--category", help="按分类过滤（精确匹配）")
     p.add_argument("--tag", help="按标签过滤（包含匹配，命中任一面即算）")
     p.add_argument(