dsh-task-ledger 0.0.97 → 0.0.99

package/dist/client.js

@@ -4883,8 +4883,8 @@ body[data-ds-dark-theme]{
 				onClick: onBack
 			}, `← ${t("backToConversation")}`), (0, react.createElement)("div", { style: titleStyle }, t("panelTitle"), (0, react.createElement)("span", {
 				style: buildTagStyle,
-				title: `v0.0.97 · 261027-114255-561`
-			}, `v0.0.97 261027-114255-561`))), (0, react.createElement)("div", { style: {
+				title: `v0.0.99 · 261027-123653-555`
+			}, `v0.0.99 261027-123653-555`))), (0, react.createElement)("div", { style: {
 				display: "flex",
 				alignItems: "center",
 				gap: "var(--dtl-space-2)"

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dsh-task-ledger",
-	"version": "0.0.97",
+	"version": "0.0.99",
 	"description": "Task ledger board for dsh (DeepSeek Harness): read-only board over task-ledger skill workspaces. The task-ledger skill is bundled — install the plugin, get the skill globally.",
 	"keywords": [
 		"deepseek",

package/skill/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: task-ledger
 description: 本地任务台账，跨会话记录在办任务的归属、进度与起止。当用户要登记一件新的事（新建任务 / 建个坑 / 这活我领了）、记录已有任务的进展（接着做 / 记一条进展 / 这轮先记下）、查看任务状态或历史（现在该做什么 / 这活谁在做 / 上周做过什么）、给任务结案或退回（做完了 / 验收通过 / 不做了 / 退回待认领）、整理标签或检查台账一致性时加载；只是改代码、讨论方案时不要用。
-version: 1.3.23
+version: 1.3.25
 allowed-tools: Read,Edit,Bash,Grep
 ---
 
@@ -49,7 +49,7 @@ allowed-tools: Read,Edit,Bash,Grep
 
 干什么：建任务、按模板建好过程文档。不加 `--self` = 只建，落公共池等认领；加 `--self` = 建并认领。
 
-分类 / 标签口径（`new` 与 `close` 共用这组参数）：`--category` 答「是什么类型」，单值，中文 ≤4 字 / 纯英文 ≤3 词，吃不准写「其他」；`--tags` 答「涉及什么」，0~5 个、逗号分隔，写不出就不传（传空串等于没传）。tags 不许写 category 的同义词；查询用 tags（包含匹配，见 `list --tag`）。名词性短语、中文优先。**在办任务的分类 / 标签一旦写下就改不了**，只有结案时用 `close --category` / `--tags` 写终值。正例：`--category 缺陷修复 --tags "镜像拉取,超时重试"`；反例：`--category 已完成登录修复`、`--tags 修 bug`。
+分类 / 标签口径（`new` / `set` / `close` 共用这组参数）：`--category` 答「是什么类型」，单值，中文 ≤4 字 / 纯英文 ≤3 词，吃不准写「其他」；`--tags` 答「涉及什么」，0~5 个、逗号分隔，写不出就不传（传空串等于没传）。tags 不许写 category 的同义词；查询用 tags（包含匹配，见 `list --tag`）。名词性短语、中文优先。**建任务时没写、后来想补就用 `set --category` / `--tags`**（在办任务随时可改）；结案时 `close` 写的值会覆盖成终值并进历史行。正例：`--category 缺陷修复 --tags "镜像拉取,超时重试"`；反例：`--category 已完成登录修复`、`--tags 修 bug`。
 
 举例：用户说「新建个任务：把发布流程走通」→ `new --title "把发布流程走通"`（只建，不认领）；用户明确说「新建个任务并开始做」→ `new --title "把发布流程走通" --self`。
 
@@ -63,17 +63,24 @@ allowed-tools: Read,Edit,Bash,Grep
 
 举例：用户说「这活我领了」→ `claim --id 20261023-1117-把发布流程走通-7f3a`。
 
-### set — 释放任务（退回公共池）
+### set — 释放任务 / 改分类标签
 
 | 参数 | 含义 |
 |---|---|
-| `--id <任务号>` | 释放哪个（必填） |
+| `--id <任务号>` | 哪条任务（必填） |
 | `--release` | 释放回公共池（不带人） |
 | `--owner <别人的uuid>` | 把任务转交给对方（预留通道，**agent 不用**，见纪律；只收 uuid，传名字当场报错） |
+| `--category <分类>` | 改分类（改过程文档头部「分类/标签」行 + 分片字段） |
+| `--tags <a、b>` | 改标签（顿号 / 逗号分隔，最多 5 个） |
 
-干什么：把任务放回公共池、状态回「待认领」，别人即可认领；没有单独的「改状态」入口。**`--release` 与 `--owner` 必须二选一、不能同给**（只给 `--id` 会报错）。
+干什么：两组用法，**不能混在一次调用里** ——
 
-举例：用户明确说「把这个任务退回去」→ `set --id <任务号> --release`。
+- `--release` / `--owner`：改归属。释放回公共池、状态回「待认领」，别人即可认领；没有单独的「改状态」入口。**这两个必须二选一、不能同给**。
+- `--category` / `--tags`：改分类标签。只改自己名下**在办**任务；给了哪个就替换哪个，没给的沿用原值；头部那行没有就插到最上面，有就原地改。已结案（在历史里）的任务改不了。
+
+只给 `--id` 会报错，要求你指明要做哪件事。
+
+举例：用户明确说「把这个任务退回去」→ `set --id <任务号> --release`；「这任务归到建设类、打上台账标签」→ `set --id <任务号> --category 建设 --tags 台账、看板`。
 
 ### log — 记一条进展
 
@@ -207,7 +214,16 @@ python3 <本 SKILL.md 所在目录>/scripts/progress.py <子命令> --repo <工
 
 - 「执行记录」节名一个字都别动；老文档缺这一节也不用补。
 - 过程文档找不到时 `log` 只提示不失败；用 `show` 查路径，不要手写。
-- 头部由脚本维护：创建时间 / 创建人、状态行（`> **状态**：doing · @某人（uuid）· 更新 <时间>`）、封卷标记、分类 / 标签行 —— **都不要手改**。老文档没有状态行是合法的（`show` 回退查在办，`--json` 标 `legacy: true`），不用补。
+- 头部是四行，由脚本维护、**都不要手改**，顺序固定 `分类/标签 → 状态 → 创建 → 封卷`，值一律 `· ` 分隔：
+
+  ```markdown
+  - **分类**：建设 · **标签**：DSH、台账
+  - **状态**：doing · 2026-10-27 09:12:33 · @某人 · 8d557c6d-…
+  - **创建**：2026-10-26 23:38:02 · @某人 · 8d557c6d-…
+  - **封卷**：2026-10-27 09:20:10 · @某人 · 8d557c6d-…
+  ```
+
+  分类 / 标签行与封卷行不一定有（没给分类、没结案就没有）。老文档没有状态行是合法的（`show` 回退查在办，`--json` 标 `legacy: true`），不用补。
 - 执行记录行格式 `- 时间（UTC） · 类型 · @谁 · 说明`，`@谁` 是这次动手的人、不是任务现归属；只追加、不改旧行。行首「类型」是脚本内部动作名（会见到 `release`，它就是 `set --release`）；认不出就别当成新命令，按 `--help` 查。
 - 只改某条任务的正文：`show --id <任务号>` 拿路径直接改，不另建 md；已结案的用 `history --months 12 --json` 找回链接（**人话输出里没有链接，必须加 `--json`**）——默认只查近 3 个月，结案久了的要显式放大窗口；只读不改。
 

package/skill/assets/worklog.md

@@ -1,9 +1,11 @@
 # <id>：<title>
 
-> **创建**：<created>（@<creator>）
-> **状态**：<status>
+- **状态**：<status>
+- **创建**：<created> · @<creator>
 
-<!-- 「> **分类**：… ｜ **标签**：…」行由脚本按 new --category / --tags 插入；两者皆空则不写。 -->
+<!-- 头部四行由脚本维护，顺序固定：分类/标签 → 状态 → 创建 → 封卷。
+     「- **分类**：… · **标签**：…」按 new --category / --tags 插在最上面，两者皆空则不写；
+     「- **封卷**：…」在结案时加在最后。 -->
 
 ## 背景
 

package/skill/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "task-ledger",
-	"version": "1.3.23",
+	"version": "1.3.25",
 	"description": "Task-ledger skill for coding agents: per-workspace progress tracking (ledger/pool.json + owners/<hash>.json shards + owners.json index, 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/skill/scripts/ledgerkit/actions/registry.py

@@ -43,7 +43,7 @@ ACTIONS: dict[str, ActionSpec] = {
     "set": ActionSpec(
         set_task.set_task,
         "result",
-        params=("tid", "owner", "release"),
+        params=("tid", "owner", "release", "category", "tags"),
         lock_action="set",
     ),
     "log": ActionSpec(log_progress.log_progress, "result", params=("tid", "note")),

package/skill/scripts/ledgerkit/actions/relabel.py

@@ -0,0 +1,105 @@
+"""改分类 / 标签：分片那两个字段 + 过程文档头部那行，一次改动两处同步。
+
+只动「分类 / 标签」这一件事，不碰归属与状态 —— 归属走 `--owner` / `--release`，
+状态只随命令语义变。已结案的任务不在任何分片里，改不了（历史行是快照）。
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..core.identity import Identity
+from ..core.labels import normalize_label, parse_tags
+from ..core.paths import shard_rel
+from ..core.time import now
+from ..core.worklog_md import (
+    StatusLine,
+    append_exec_log,
+    exec_line,
+    rewrite_label_line,
+    rewrite_status_line,
+)
+from ..errors import Fail
+from ..store.task_store import TaskStore
+from ..store.worklog_store import WorklogStore
+from .guard import require_owner
+from .result import Result, rel
+
+
+def _describe(category: str | None, tags: list[str]) -> str:
+    """执行记录里那一句说明：`建设 · DSH、台账`。"""
+    parts = [category] if category else []
+    if tags:
+        parts.append("、".join(tags))
+    return " · ".join(parts)
+
+
+def relabel(
+    repo: Path,
+    me: Identity,
+    tid: str,
+    *,
+    category: str | None = None,
+    tags: str | tuple[str, ...] | None = None,
+) -> Result:
+    """写序：算最终值 → 过程文档（标签行 + 执行记录 + 状态行，一次写）→ 分片。
+
+    `tags` 收字符串（顿号 / 逗号分隔）或已切好的元组 —— 外壳可能已经切过一遍。
+    """
+    new_category = normalize_label(category, field="分类") if category else None
+    new_tags = parse_tags(tags) if tags else None
+    if new_category is None and new_tags is None:
+        raise Fail(
+            "改分类 / 标签至少要给一个：`--category <分类>` 或 `--tags <a、b>`。"
+        )
+
+    mine = TaskStore(repo, shard_rel(me.uuid), identity=me)
+    task = mine.get(tid)  # 锁内重读
+    if task is None:
+        raise Fail(
+            f"任务 {tid} 不在我的分片里（只能改自己名下在办的任务；已结案的任务改不了）。"
+        )
+    require_owner(task, tid, me)
+
+    # 没给的沿用原值：分类与标签是一行里的两段，写一次就得给全
+    final_category = new_category if new_category else task.get("category")
+    final_tags: list[str] = (
+        [str(tag) for tag in new_tags]
+        if new_tags is not None
+        else [str(tag) for tag in (task.get("tags") or ())]
+    )
+    if not final_category and not final_tags:
+        raise Fail("分类与标签都是空的，没有可写的值。")
+
+    when = now()
+    updated = dict(task)
+    updated["category"] = final_category
+    updated["tags"] = final_tags
+    updated["updated"] = when
+
+    logs = WorklogStore(repo)
+    path = logs.find(tid, task.get("worklog"))
+    if path is None:
+        mine.put(tid, updated)
+        return Result(
+            changed=("category", "tags", "updated"),
+            where=rel(repo, mine.path),
+            message=f"{tid}：改分类 / 标签",
+            notices=("提示：这条任务没有过程文档，只改了分片，文档与历史里看不到。",),
+        )
+
+    text = logs.read(path)
+    note = "改分类 / 标签：" + _describe(final_category, final_tags)
+    text = rewrite_label_line(text, final_category, final_tags)
+    text = append_exec_log(text, exec_line(when, me.stamp(), "set", note))
+    text = rewrite_status_line(
+        text, StatusLine(task.get("status") or "doing", me.name, me.uuid, when)
+    )
+    logs.write(path, text)
+    mine.put(tid, updated)
+
+    return Result(
+        changed=("category", "tags", "updated"),
+        where=rel(repo, mine.path),
+        message=f"{tid}：改分类 / 标签",
+    )

package/skill/scripts/ledgerkit/actions/set_task.py

@@ -18,10 +18,16 @@ from ..errors import Fail
 from ..store.task_store import TaskStore
 from . import claim as claim_mod
 from . import handoff as handoff_mod
+from . import relabel as relabel_mod
 from . import release as release_mod
 from .guard import require_uuid
 from .result import Result, rel
 
+_MIXED = (
+    "--category / --tags 不能与 --release / --owner 同时给："
+    "一个是改分类标签，一个是改归属，分两次跑。"
+)
+
 
 def set_task(
     repo: Path,
@@ -30,15 +36,28 @@ def set_task(
     *,
     owner: str | None = None,
     release: bool = False,
+    category: str | None = None,
+    tags: str | tuple[str, ...] | None = None,
 ) -> Result:
-    """路由：`--release` = 释放；别人的 uuid = 交接；自己的 uuid = 已认领则空转、没认领先认领。"""
+    """路由：`--release` = 释放；别人的 uuid = 交接；自己的 uuid = 已认领则空转、没认领先认领；
+    `--category` / `--tags` = 改分类与标签（只动文档头部那行与分片字段）。
+    """
+    relabel_wanted = bool(category or tags)
     if release:
         if owner is not None:
             raise Fail("--release 与 --owner 不能同时给：释放不带人，交接不带释放。")
+        if relabel_wanted:
+            raise Fail(_MIXED)
         return release_mod.release(repo, me, tid)
-    if owner is None:
+    if owner is not None:
+        if relabel_wanted:
+            raise Fail(_MIXED)
+    else:
+        if relabel_wanted:
+            return relabel_mod.relabel(repo, me, tid, category=category, tags=tags)
         raise Fail(
-            "set 必须二选一：`--release`（释放回公共池）或 `--owner <对方 uuid>`（交接）。"
+            "set 必须给一样：`--release`（释放回公共池）/ `--owner <对方 uuid>`（交接）/ "
+            "`--category <分类>` 或 `--tags <a、b>`（改分类标签）。"
         )
     # 交接目标只收 uuid：名字查不到就当场报错，绝不去猜「他大概是这个人」
     target = require_uuid(owner, field="--owner")

package/skill/scripts/ledgerkit/actions/show_task.py

@@ -34,6 +34,7 @@ def show_task(repo: Path, me: Identity, tid: str) -> ShowResult:
                 "owner_name": status.name,
                 "created": worklog_md.head_created(text),
                 "updated": status.when,
+                "finished": worklog_md.head_frozen(text),
             },
             worklog=WorklogView(path=rel(repo, path), text=text, error=None),
         )

package/skill/scripts/ledgerkit/core/identity.py

@@ -27,10 +27,10 @@ class Identity:
     def stamp(self) -> str:
         """**落盘**用的身份串：`名字 · uuid` —— 名字在前给人读，uuid 在后给机器对。
 
-        与 `label()` 一样**不带 `@`**（`@` 由各落点自己加：模板创建行是 `（@<creator>）`、
-        `exec_line` 拼 ` · @{who} · `、`stamp_frozen` 拼 `（@{who}）`）。
+        与 `label()` 一样**不带 `@`**（`@` 由各落点自己加：头部各行拼 ` · @{stamp}`、
+        `exec_line` 拼 ` · @{who} · `）。
 
-        过程文档（创建行 / 封卷行 / 执行记录）是这个串唯一的落点：文件是最终产物，
+        过程文档（创建行 / 状态行 / 封卷行 / 执行记录）是这个串唯一的落点：文件是最终产物，
         创建人和封卷人可能不是同一个人、也可能中途改过名，所以**两个都要留**，不靠
         历史表回链。没名字就只写 uuid。
         """

package/skill/scripts/ledgerkit/core/labels.py

@@ -15,7 +15,7 @@ LABEL_MAX_WORDS_EN = 3  # 纯 ASCII 时按「词」算
 TAGS_MAX_COUNT = 5
 
 CJK_RE = re.compile(r"[\u4e00-\u9fff]")
-LABEL_CAT_RE = re.compile(r"分类\*\*\s*[：:]\s*([^｜|]+)")
+LABEL_CAT_RE = re.compile(r"分类\*\*\s*[：:]\s*([^｜|·]+)")
 LABEL_TAG_RE = re.compile(r"标签\*\*\s*[：:]\s*(.+)$")
 _SPLIT_RE = re.compile(r"[,，、]")
 
@@ -49,21 +49,33 @@ def parse_tags(raw: str | Iterable[str] | None) -> tuple[str, ...]:
 
 
 def label_line(category: str | None, tags: Iterable[str] | None) -> str:
-    """过程文档头部的「分类/标签」行；两者皆空返回空串（此行不写）。"""
+    """过程文档头部的「分类 / 标签」行；两者皆空返回空串（此行不写）。"""
     segs: list[str] = []
     if category:
         segs.append(f"**分类**：{category}")
     tag_list = [t for t in (tags or ()) if t]
     if tag_list:
         segs.append(f"**标签**：{'、'.join(tag_list)}")
-    return "> " + " ｜ ".join(segs) if segs else ""
+    return "- " + " · ".join(segs) if segs else ""
 
 
 def parse_label_line(text: str) -> tuple[str | None, tuple[str, ...]]:
-    """从过程文档头部（第一个 `## ` 小节之前）解析分类与标签。"""
+    """从过程文档头部（第一个 `## ` 小节之前）解析分类与标签。
+
+    跳过 HTML 注释块：模板注释里举例写着「**分类**：…」，那不是数据。
+    """
+    in_comment = False
     for line in text.splitlines():
         if line.startswith("## "):
             break
+        stripped = line.lstrip()
+        if in_comment:
+            if "-->" in stripped:
+                in_comment = False
+            continue
+        if stripped.startswith("<!--"):
+            in_comment = "-->" not in stripped
+            continue
         mc = LABEL_CAT_RE.search(line)
         mt = LABEL_TAG_RE.search(line)
         if not (mc or mt):

package/skill/scripts/ledgerkit/core/worklog_md.py

@@ -20,33 +20,44 @@ EXEC_HINT = (
     "<!-- 本节由脚本维护：new / claim / set / release / log / close 自动追加，请勿手改。\n"
     '     补记用 progress.py log --id <任务号> --note "一句话"。 -->'
 )
-FROZEN_MARK = "✅ 完成封卷"
-FROZEN_RE = re.compile(r"^>\s*" + FROZEN_MARK, re.MULTILINE)
-CREATED_RE = re.compile(r"^\s*>\s*\*\*创建\*\*")
-# 头部「创建」行：`> **创建**：2026-10-06 00:00（@某人 · uuid）` —— 创建时间与发起人两个来源。
-# 括号里落 `Identity.stamp()`（`@名字 · uuid`）：名字在前给人读，uuid 在后给机器对。
-# 老文档只有名字（没有 uuid）时，下面两个函数各自返回它能读到的那一段，不报错。
+FROZEN_MARK = "封卷"
+#: 头部四行的规范顺序：分类/标签 → 状态 → 创建 → 封卷。
+#: 「分类」只在有分类 / 标签时写，「封卷」只在结案时写，另两行必有。
+HEAD_KEY_ORDER = ("meta", "status", "created", "frozen")
+#: 头部行前缀：新格式是无序列表 `- `，老文档是引用块 `> ` —— 读的时候两种都认。
+_HEAD_BULLET = r"^(?:\s*>\s?|\s*[-*]\s+)"
+FROZEN_RE = re.compile(
+    _HEAD_BULLET + r"(?:\*\*" + FROZEN_MARK + r"\*\*|✅ 完成封卷)", re.MULTILINE
+)
+#: 封卷行的时间（老文档是 `> ✅ 完成封卷：<时间>（@…）`，新格式是 `- **封卷**：<时间> · @…`）。
+_FROZEN_AT_RE = re.compile(
+    _HEAD_BULLET + r"(?:\*\*" + FROZEN_MARK + r"\*\*|✅ 完成封卷)[^：:]*[：:]\s*"
+    r"(\d{4}-\d{2}-\d{2}(?:[ T]\d{1,2}:\d{2}(?::\d{2})?)?)"
+)
+# 头部「创建」行：`- **创建**：2026-10-06 00:00 · @某人 · uuid`。
+# 值一律 `时间 · @名字 · uuid`，与执行记录行同一种分隔符；老文档是 `（@名字 · uuid）`，读得到就认。
+CREATED_RE = re.compile(_HEAD_BULLET + r"\*\*创建\*\*")
 CREATED_AT_RE = re.compile(
-    r"^\s*>\s*\*\*创建\*\*\s*[：:]\s*"
+    _HEAD_BULLET + r"\*\*创建\*\*\s*[：:]\s*"
     r"(\d{4}-\d{2}-\d{2}(?: +\d{1,2}:\d{1,2}(?::\d{1,2})?)?)"
 )
-CREATOR_RE = re.compile(r"^\s*>\s*\*\*创建\*\*\s*[：:].*?（@(.+?)）")
+CREATOR_RE = re.compile(_HEAD_BULLET + r"\*\*创建\*\*\s*[：:].*?@(.+?)\s*[）)]?\s*$")
 
-# 头部「状态」行：`> **状态**：doing · @某人（uuid）· 更新 2026-10-27 08:28:22`。
+# 头部「状态」行：`- **状态**：doing · 2026-10-27 08:28:22 · @某人 · uuid`。
 # 它是**镜像**：分片 / 池里的 `status` / `owner` 才是权威，这行只是让「看一条详情」
-# 不必再翻索引（2026-10-27 用户拍板）。老文档没有这行 ⇒ 合法，读取方回退查分片。
+# 不必再翻索引。老文档没有这行 ⇒ 合法，读取方回退查分片。
 STATUS_MARK = "状态"
-STATUS_LINE_RE = re.compile(r"^\s*>\s*\*\*" + STATUS_MARK + r"\*\*")
-STATUS_RE = re.compile(r"^\s*>\s*\*\*" + STATUS_MARK + r"\*\*\s*[：:]\s*([A-Za-z_]+)")
+STATUS_LINE_RE = re.compile(_HEAD_BULLET + r"\*\*" + STATUS_MARK + r"\*\*")
+STATUS_RE = re.compile(
+    _HEAD_BULLET + r"\*\*" + STATUS_MARK + r"\*\*\s*[：:]\s*([A-Za-z_]+)"
+)
 #: 状态取值（与 `core/labels.STATUSES` + 结案后的 `closed` 同口径，全链路英文）。
 STATUS_VALUES = ("open", "doing", "closed")
 _STATUS_UUID_RE = re.compile(
     r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
 )
 _STATUS_NAME_RE = re.compile(r"@([^（(·]+)")
-_STATUS_WHEN_RE = re.compile(
-    r"更新\s+(\d{4}-\d{2}-\d{2}(?:[ T]\d{1,2}:\d{2}(?::\d{2})?)?)"
-)
+_STATUS_WHEN_RE = re.compile(r"(\d{4}-\d{2}-\d{2}(?:[ T]\d{1,2}:\d{2}(?::\d{2})?)?)")
 _TITLE_RE = re.compile(r"^#\s*(.+?)\s*[：:]\s*(.*)$")
 
 _HEAD_RE = re.compile(r"\A(.*?)(?=^## |\Z)", re.DOTALL | re.MULTILINE)
@@ -84,10 +95,10 @@ def format_problems(text: str) -> list[str]:
     head = _head_lines(lines)
     if not any(CREATED_AT_RE.match(line) for line in head):
         problems.append(
-            "头部缺「创建」时间行（应为 `> **创建**：YYYY-MM-DD HH:MM（@某人）`）"
+            "头部缺「创建」时间行（应为 `- **创建**：YYYY-MM-DD HH:MM:SS · @某人 · uuid`）"
         )
     elif not any(CREATOR_RE.match(line) for line in head):
-        problems.append("头部「创建」行缺发起人（应为 `…（@某人）`）")
+        problems.append("头部「创建」行缺发起人（应为 `… · @某人 · uuid`）")
     # 状态行：**有就必须合法**；缺了不报——老文档没有这行是合法的（读取方回退查分片）
     for line in head:
         if not STATUS_LINE_RE.match(line):
@@ -164,8 +175,8 @@ def render_worklog(
 ) -> str:
     """把模板套成一篇过程文档（`<id>` / `<title>` / `<created>` / `<creator>` / `<status>`）。
 
-    `<status>` 只占状态行的**内容**（`doing · @某人（uuid）· 更新 …`）；模板里的
-    `> **状态**：` 前缀是字面量。不传 status ⇒ 整行删掉（不留空壳）。
+    `<status>` 只占状态行的**内容**（`doing · 时间 · @某人 · uuid`）；模板里的
+    `- **状态**：` 前缀是字面量。不传 status ⇒ 整行删掉（不留空壳）。
     """
     text = (
         template.replace("<id>", tid)
@@ -190,15 +201,50 @@ def render_worklog(
     meta = label_line(category, tags)
     if not meta:
         return text
-    return "\n".join(_insert_after_head(text.splitlines(), meta)) + "\n"
+    return "\n".join(_insert_head_line(text.splitlines(), meta, "meta")) + "\n"
 
 
-def _insert_after_head(lines: list[str], line: str) -> list[str]:
-    """把一行插到「创建」行之后（头部引用块内）；找不到创建行就插标题后。"""
-    at = next((i for i, ln in enumerate(lines) if CREATED_RE.match(ln)), None)
-    if at is None:
+_META_LINE_RE = re.compile(_HEAD_BULLET + r"\*\*(?:分类|标签)\*\*")
+
+
+def _head_key(line: str) -> str | None:
+    """这一行是头部哪个字段（`meta` / `status` / `created` / `frozen`）；都不是给 None。"""
+    if _META_LINE_RE.search(line):
+        return "meta"
+    if STATUS_LINE_RE.match(line):
+        return "status"
+    if CREATED_RE.match(line):
+        return "created"
+    if FROZEN_RE.match(line):
+        return "frozen"
+    return None
+
+
+def _insert_head_line(lines: list[str], line: str, key: str) -> list[str]:
+    """按 `HEAD_KEY_ORDER` 把一行插进头部（第一个 `## ` 之前）。
+
+    排在它后面的字段行先出现就插在那行前面；没有就接在最后一个字段行之后；
+    一个字段行都没有就插在标题（及其后的空行）下面。
+    """
+    rank = HEAD_KEY_ORDER.index(key)
+    last: int | None = None
+    for i, ln in enumerate(lines):
+        if ln.startswith("## "):
+            break
+        found = _head_key(ln)
+        if found is None:
+            continue
+        if HEAD_KEY_ORDER.index(found) > rank:
+            lines.insert(i, line)
+            return lines
+        last = i
+    if last is None:
         at = 1 if lines and lines[0].startswith("# ") else 0
-    lines.insert(at + 1, line)
+        while at + 1 < len(lines) and not lines[at + 1].strip():
+            at += 1
+        lines.insert(at + 1, line)
+    else:
+        lines.insert(last + 1, line)
     return lines
 
 
@@ -217,16 +263,14 @@ def render_status_body(
     uuid: str | None = None,
     when: str | None = None,
 ) -> str:
-    """状态行的**内容**部分（`> **状态**：` 之后那段）。"""
+    """状态行的**内容**部分（`- **状态**：` 之后那段）：`状态 · 时间 · @名字 · uuid`。"""
     parts = [status]
-    if name and uuid:
-        parts.append(f"@{name}（{uuid}）")
-    elif name:
+    if when:
+        parts.append(when)
+    if name:
         parts.append(f"@{name}")
-    elif uuid:
+    if uuid:
         parts.append(uuid)
-    if when:
-        parts.append(f"更新 {when}")
     return " · ".join(parts)
 
 
@@ -236,11 +280,11 @@ def render_status_line(
     uuid: str | None = None,
     when: str | None = None,
 ) -> str:
-    return f"> **{STATUS_MARK}**：{render_status_body(status, name, uuid, when)}"
+    return f"- **{STATUS_MARK}**：{render_status_body(status, name, uuid, when)}"
 
 
 def rewrite_status_line(text: str, status: StatusLine) -> str:
-    """把头部状态行改成 `status`：有就就地替换，没有就插到「创建」行后。"""
+    """把头部状态行改成 `status`：有就就地替换，没有就按头部顺序插进去。"""
     line = render_status_line(status.status, status.name, status.uuid, status.when)
     lines = (text or "").splitlines()
     for i, ln in enumerate(lines):
@@ -249,7 +293,7 @@ def rewrite_status_line(text: str, status: StatusLine) -> str:
         if STATUS_LINE_RE.match(ln):
             lines[i] = line
             return "\n".join(lines) + "\n"
-    return "\n".join(_insert_after_head(lines, line)) + "\n"
+    return "\n".join(_insert_head_line(lines, line, "status")) + "\n"
 
 
 def read_status(text: str) -> StatusLine | None:
@@ -309,25 +353,25 @@ def has_frozen_line(text: str) -> bool:
 
 
 def stamp_frozen(text: str, finished: str, who: str | None = "") -> str:
-    """封卷：在头部打标记行（`finished` 传 UTC，原样写盘——见 exec_line 的口径说明）。"""
-    mark = f"> {FROZEN_MARK}：{finished}"
+    """封卷：在头部打「封卷」行（`finished` 传 UTC，原样写盘——见 exec_line 的口径说明）。"""
+    mark = f"- **{FROZEN_MARK}**：{finished}"
     if who:
-        mark += f"（@{who}）"
+        mark += f" · @{who}"
     if FROZEN_RE.search(text or ""):
         return text
-    return "\n".join(_insert_after_head(text.splitlines(), mark)) + "\n"
+    return "\n".join(_insert_head_line(text.splitlines(), mark, "frozen")) + "\n"
 
 
 def rewrite_label_line(
     text: str, category: str | None, tags: Iterable[str] | None
 ) -> str:
-    """改写头部的分类 / 标签行：有就地替换，没有就插到创建行后。"""
+    """改写头部的分类 / 标签行：有就地替换，没有就按头部顺序插进去。"""
     line = label_line(category, tags)
     lines = text.splitlines()
     for i, ln in enumerate(lines):
         if ln.startswith("## "):
             break
-        if "**分类**" in ln or "**标签**" in ln:
+        if _META_LINE_RE.match(ln):
             if line:
                 lines[i] = line
             else:
@@ -335,7 +379,7 @@ def rewrite_label_line(
             return "\n".join(lines) + "\n"
     if not line:
         return text
-    return "\n".join(_insert_after_head(lines, line)) + "\n"
+    return "\n".join(_insert_head_line(lines, line, "meta")) + "\n"
 
 
 def head_meta(text: str) -> tuple[str | None, tuple[str, ...]]:
@@ -355,8 +399,20 @@ def head_created(text: str) -> str | None:
     return None
 
 
+def head_frozen(text: str) -> str | None:
+    """头部「封卷」行的时间（原样返回，不转时区）；没封卷 / 读不到返回 None。"""
+    for line in text.splitlines():
+        m = _FROZEN_AT_RE.match(line)
+        if m:
+            try:
+                return normalize_time(m.group(1), field="封卷")
+            except Fail:
+                return None
+    return None
+
+
 def head_creator(text: str) -> str | None:
-    """头部「创建」行括号里的发起人**名字**（不带 @、不带 uuid）；读不到返回 None。"""
+    """头部「创建」行的发起人**名字**（不带 @、不带 uuid）；读不到返回 None。"""
     for line in text.splitlines():
         m = CREATOR_RE.match(line)
         if m and m.group(1).strip():
@@ -365,7 +421,7 @@ def head_creator(text: str) -> str | None:
 
 
 def head_creator_uuid(text: str) -> str | None:
-    """头部「创建」行括号里的发起人 **uuid**；老文档没落 uuid 时返回 None。
+    """头部「创建」行的发起人 **uuid**；老文档没落 uuid 时返回 None。
 
     `UUID_RE` 带 `^$` 锚点，只能整串匹配 —— 所以先按 ` · ` 切出尾段再判，不能 search。
     """

package/skill/scripts/ledgerkit/shell/cli.py

@@ -45,10 +45,14 @@ def build_parser() -> argparse.ArgumentParser:
     claim = sub.add_parser("claim", help="认领公共池里的任务")
     claim.add_argument("--id", required=True, dest="tid")
 
-    setp = sub.add_parser("set", help="释放 / 交接任务")
+    setp = sub.add_parser("set", help="释放 / 交接 / 改分类标签")
     setp.add_argument("--id", required=True, dest="tid")
     setp.add_argument("--owner", help="交给别人的 uuid（交接）")
     setp.add_argument("--release", action="store_true", help="释放回公共池")
+    setp.add_argument(
+        "--category", help="改分类（与 --tags 一起改过程文档头部分类/标签行）"
+    )
+    setp.add_argument("--tags", help="改标签，顿号 / 逗号分隔")
 
     logp = sub.add_parser("log", help="记一条进展")
     logp.add_argument("--id", required=True, dest="tid")

package/skill/scripts/ledgerkit/store/worklog_store.py

@@ -23,7 +23,8 @@ from .atomic import ensure_dir, write_text_atomic
 
 FALLBACK_TEMPLATE = """# <id>：<title>
 
-> **创建**：<created>（@<creator>）
+- **状态**：<status>
+- **创建**：<created> · @<creator>
 
 ## 背景