dsh-task-ledger 0.0.96 → 0.0.98

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

@@ -7,7 +7,7 @@ from pathlib import Path
 from ..core.identity import Identity
 from ..core.paths import POOL_REL, shard_rel
 from ..core.time import now
-from ..core.worklog_md import exec_line
+from ..core.worklog_md import StatusLine, exec_line
 from ..errors import Fail
 from ..store.task_store import TaskStore
 from ..store.worklog_store import WorklogStore
@@ -63,7 +63,11 @@ def release(repo: Path, me: Identity, tid: str) -> Result:
     if path is None:
         note = f"任务 {tid} 已退回公共池，但过程文档没找到，跳过执行记录。"
     else:
-        logs.append_exec(path, exec_line(now(), me.stamp(), "release", "释放回公共池"))
+        logs.append_exec(
+            path,
+            exec_line(now(), me.stamp(), "release", "释放回公共池"),
+            status=StatusLine("open", None, None, now()),
+        )
     return Result(
         changed=("owner", "owner_name", "status", "updated"),
         where=rel(repo, pool.path),

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

@@ -67,6 +67,8 @@ class ShowResult:
     task: dict[str, Any] = field(default_factory=dict)
     worklog: WorklogView | None = None
     others: tuple[str, ...] = ()  # 同一个任务号还出现在哪些文件里
+    #: 字段是从**在办索引**读来的（老文档没有状态行 / 文档丢了），不是文档自述
+    legacy: bool = False
     notices: tuple[str, ...] = ()
 
 

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

@@ -1,9 +1,17 @@
-"""只读：看一条任务（池 + 索引登记的全部分片都扫，别人的也要能看）。"""
+"""只读：看一条任务。**文档优先**——读到文档就知道状态，不再翻索引（2026-10-27）。
+
+两条路径：
+- 文档存在且头部有状态行 ⇒ 完全按文档自述回答（`status` / 负责人 / 更新时间 / 标题），
+  pool、分片、历史一个都不读，已结案的任务同样看得到；
+- 文档没有状态行（老文档）或根本没有文档 ⇒ 回退 `load_task` 查在办索引，
+  返回里标 `legacy=True`，让调用方知道这些字段不是文档自述的。
+"""
 
 from __future__ import annotations
 
 from pathlib import Path
 
+from ..core import worklog_md
 from ..core.identity import Identity
 from ..store.worklog_store import WorklogStore
 from .guard import load_task
@@ -11,17 +19,37 @@ from .result import ShowResult, WorklogView, rel
 
 
 def show_task(repo: Path, me: Identity, tid: str) -> ShowResult:
-    task, where = load_task(repo, tid)
     logs = WorklogStore(repo)
-    path = logs.find(tid, task.get("worklog"))
+    path = logs.find(tid)  # 只按任务号找文件名：不碰 pool / 分片 / 历史
+    text = logs.read(path) if path is not None else ""
+    status = worklog_md.read_status(text) if text else None
+    if status is not None and path is not None:
+        head_tid, title = worklog_md.head_title(text)
+        return ShowResult(
+            task={
+                "tid": head_tid or tid,
+                "title": title,
+                "status": status.status,
+                "owner": status.uuid,
+                "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),
+        )
+
+    # 老文档 / 文档缺失：回退查在办（找不到会抛，文案与既往一致）
+    task, where = load_task(repo, tid)
     if path is None:
         view = WorklogView(
             path=None, text=None, error="这条任务没有过程文档（或文档已不在原处）。"
         )
     else:
-        view = WorklogView(path=rel(repo, path), text=logs.read(path), error=None)
+        view = WorklogView(path=rel(repo, path), text=text or None, error=None)
     return ShowResult(
         task=task,
         worklog=view,
         others=tuple(rel(repo, p) for p in where),
+        legacy=True,
     )

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

@@ -1,7 +1,10 @@
-"""只读：台账体检。两档：默认浅度只查格式，`--deep` 才读全部历史与过程文档正文。
+"""只读：台账体检。两档：默认浅度只查格式，`--deep` 才读全部历史。
 
-浅度（默认）：池 + 各分片的字段格式、索引与文件对不对得上、**当月**历史、每篇过程文档的模板格式。
-深度（`--deep`）：历史不止当月（全部月份），过程文档再判骨架（正文填了没）。
+浅度（默认）：池 + 各分片的字段格式、索引与文件对不对得上、**当月**历史。
+深度（`--deep`）：历史不止当月（全部月份）。
+
+**两档都不读过程文档正文**（2026-10-27 用户拍板）：过程文档是附件、存量可以上万篇，
+逐篇读全文换不来体检结论，只白花时间；文档自身的格式与内容不在体检范围。
 
 只查格式，不查业务（该谁结案、逾期与否都不管）；也不查「同一任务号落在多个文件」——
 读侧只显示一次（`show` 会点名）、写侧已有防护，撞上了不关体检的事（2026-10-24 用户拍板）。
@@ -21,16 +24,9 @@ from ..core.paths import (
     to_repo_rel,
 )
 from ..core.time import now
-from ..core.worklog_md import (
-    duplicated_sections,
-    format_problems,
-    is_skeleton,
-    lacks_exec_section,
-)
 from ..store.history_store import HistoryStore
 from ..store.owners_index import OwnersIndex
 from ..store.task_store import TaskStore
-from ..store.worklog_store import WorklogStore
 from .guard import owner_of, status_of
 from .result import ValidationReport, rel
 
@@ -138,43 +134,6 @@ def _check_history(
     return checked
 
 
-def _check_worklog(
-    repo: Path,
-    logs: WorklogStore,
-    problems: list[str],
-    notices: list[str],
-    *,
-    deep: bool,
-) -> int:
-    """每篇过程文档：模板格式（浅度就查）+ 空骨架判定（只有 `--deep` 才判）。
-
-    一趟读完两件事都做 —— 格式要看全文找节标题，骨架吃同一份文本，别为此读第二遍。
-    """
-    checked = 0
-    for path in logs.all():
-        checked += 1
-        try:
-            text = logs.read(path)
-        except ValueError:
-            continue
-        if not text:
-            continue
-        where = rel(repo, path)
-        problems.extend(f"{where} 格式：{line}" for line in format_problems(text))
-        if lacks_exec_section(text):
-            notices.append(
-                f"{where} 没有「执行记录」节（老文档；写一条记录会自动补上）。"
-            )
-        dup = duplicated_sections(text)
-        if dup:
-            notices.append(
-                f"{where} 有重复的节：{'、'.join(f'`## {s}`' for s in dup)}。"
-            )
-        if deep and is_skeleton(text):
-            notices.append(f"{where} 还是骨架（正文没填）。")
-    return checked
-
-
 def validate(repo: Path, me: Identity, deep: bool = False) -> ValidationReport:
     problems: list[str] = []
     notices: list[str] = []
@@ -183,7 +142,6 @@ def validate(repo: Path, me: Identity, deep: bool = False) -> ValidationReport:
 
     index = OwnersIndex(repo)
     history = HistoryStore(repo)
-    logs = WorklogStore(repo)
 
     files, tasks = _check_task_files(repo, index, problems)
     checked += files
@@ -197,7 +155,6 @@ def validate(repo: Path, me: Identity, deep: bool = False) -> ValidationReport:
         history,
         notices,
     )
-    checked += _check_worklog(repo, logs, problems, notices, deep=deep)
 
     if not (repo / to_repo_rel(OWNERS_REL)).exists():
         notices.append("还没有 owners.json（索引）：跑一条写命令会自动建。")

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/time.py

@@ -2,7 +2,8 @@
 
 进门规则：不读文件、不写文件、不打印；只依赖 errors。
 所有**存盘**时间都是 UTC（`YYYY-MM-DD HH:MM:SS`，不带偏移量）；
-所有**人话显示**都过 `fmt_local`；`--json` 原样吐 UTC。
+所有**对外输出**（人话表格与 `--json`）的时间字段都过 `fmt_local` 转本机时区，
+内部筛选 / 排序一律用存盘的 UTC —— 调用方拿到的时间不用再转。
 """
 
 from __future__ import annotations

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

@@ -8,28 +8,57 @@ from __future__ import annotations
 import re
 from collections.abc import Iterable
 from itertools import takewhile
+from typing import NamedTuple
 
 from ..errors import Fail
 from .identity import UUID_RE
 from .labels import label_line, parse_label_line
-from .time import fmt_local, normalize_time
+from .time import normalize_time
 
 EXEC_HEAD = "## 执行记录"
 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 · 2026-10-27 08:28:22 · @某人 · uuid`。
+# 它是**镜像**：分片 / 池里的 `status` / `owner` 才是权威，这行只是让「看一条详情」
+# 不必再翻索引。老文档没有这行 ⇒ 合法，读取方回退查分片。
+STATUS_MARK = "状态"
+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"(\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)
 
@@ -66,10 +95,20 @@ 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):
+            continue
+        m = STATUS_RE.match(line)
+        if m is None or m.group(1) not in STATUS_VALUES:
+            problems.append(
+                "头部「状态」行的值不合法（应为 " + " / ".join(STATUS_VALUES) + "）"
+            )
+        break
     heads = section_heads(body)
     missing = [s for s in REQUIRED_SECTIONS if s not in heads]
     if missing:
@@ -131,37 +170,171 @@ def render_worklog(
     creator: str,
     category: str | None = None,
     tags: Iterable[str] | None = None,
+    status: StatusLine | None = None,
     template: str,
 ) -> str:
-    """把模板套成一篇过程文档（`<id>` / `<title>` / `<created>` / `<creator>` 四个占位符）。"""
+    """把模板套成一篇过程文档（`<id>` / `<title>` / `<created>` / `<creator>` / `<status>`）。
+
+    `<status>` 只占状态行的**内容**（`doing · 时间 · @某人 · uuid`）；模板里的
+    `- **状态**：` 前缀是字面量。不传 status ⇒ 整行删掉（不留空壳）。
+    """
     text = (
         template.replace("<id>", tid)
         .replace("<title>", title or "")
         .replace("<created>", created or "")
         .replace("<creator>", creator or "")
     )
+    if status is None:
+        text = (
+            "\n".join(
+                ln
+                for ln in text.splitlines()
+                if not (STATUS_LINE_RE.match(ln) and "<status>" in ln)
+            )
+            + "\n"
+        )
+    else:
+        text = text.replace(
+            "<status>",
+            render_status_body(status.status, status.name, status.uuid, status.when),
+        )
     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"
+
 
+_META_LINE_RE = re.compile(_HEAD_BULLET + r"\*\*(?:分类|标签)\*\*")
 
-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:
+
+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
 
 
+class StatusLine(NamedTuple):
+    """头部状态行的四样内容（`when` 传 UTC，与执行记录同口径）。"""
+
+    status: str
+    name: str | None = None
+    uuid: str | None = None
+    when: str | None = None
+
+
+def render_status_body(
+    status: str,
+    name: str | None = None,
+    uuid: str | None = None,
+    when: str | None = None,
+) -> str:
+    """状态行的**内容**部分（`- **状态**：` 之后那段）：`状态 · 时间 · @名字 · uuid`。"""
+    parts = [status]
+    if when:
+        parts.append(when)
+    if name:
+        parts.append(f"@{name}")
+    if uuid:
+        parts.append(uuid)
+    return " · ".join(parts)
+
+
+def render_status_line(
+    status: str,
+    name: str | None = None,
+    uuid: str | None = None,
+    when: str | None = None,
+) -> str:
+    return f"- **{STATUS_MARK}**：{render_status_body(status, name, uuid, when)}"
+
+
+def rewrite_status_line(text: str, status: StatusLine) -> str:
+    """把头部状态行改成 `status`：有就就地替换，没有就按头部顺序插进去。"""
+    line = render_status_line(status.status, status.name, status.uuid, status.when)
+    lines = (text or "").splitlines()
+    for i, ln in enumerate(lines):
+        if ln.startswith("## "):
+            break
+        if STATUS_LINE_RE.match(ln):
+            lines[i] = line
+            return "\n".join(lines) + "\n"
+    return "\n".join(_insert_head_line(lines, line, "status")) + "\n"
+
+
+def read_status(text: str) -> StatusLine | None:
+    """头部状态行 → `StatusLine`；没有这行、或值不合法 ⇒ None（调用方回退查分片）。"""
+    for line in _head_lines((text or "").lstrip("\ufeff").splitlines()):
+        m = STATUS_RE.match(line)
+        if not (m and m.group(1) in STATUS_VALUES):
+            continue
+        u = _STATUS_UUID_RE.search(line)
+        name = _STATUS_NAME_RE.search(line)
+        when = _STATUS_WHEN_RE.search(line)
+        return StatusLine(
+            m.group(1),
+            (name.group(1).strip() or None) if name else None,
+            (u.group(0).lower() if u else None),
+            (when.group(1) if when else None),
+        )
+    return None
+
+
+def head_title(text: str) -> tuple[str | None, str | None]:
+    """第一行 `# <任务号>：<标题>` → (任务号, 标题)；读不出给 (None, None)。"""
+    for line in (text or "").lstrip("\ufeff").splitlines():
+        if not line.startswith("# "):
+            continue
+        m = _TITLE_RE.match(line)
+        if m:
+            return m.group(1).strip() or None, m.group(2).strip() or None
+        return None, None
+    return None, None
+
+
 def exec_line(when: str, who: str | None, kind: str, note: str) -> str:
-    """一条执行记录：`- 本地时刻 · 类型 · @某人 · 说明`。
+    """一条执行记录：`- 时刻 · 类型 · @某人 · 说明`。
 
-    时刻是**给人读的日志行**，所以在这里转成查看者本地时间（调用方一律传 UTC，
-    别在外面先转一遍）。类型取动作名（new / claim / set / release / log / close）。
+    时刻与台账其它存盘时间同口径：**UTC**（调用方一律传 UTC，这里不再转本地）。
+    正文整篇由 `readWorklog` / `show` 原样读出，脚本无法逐行回转 ⇒ 存什么就显示什么；
+    转本地是消费方（终端 / 看板）的事。
+    类型取动作名（new / claim / set / release / log / close）。
     """
-    head = f"- {fmt_local(when)} · {kind}"
+    head = f"- {when} · {kind}"
     tail = f" · @{who} · {note}" if who else f" · {note}"
     return head + tail
 
@@ -180,25 +353,25 @@ def has_frozen_line(text: str) -> bool:
 
 
 def stamp_frozen(text: str, finished: str, who: str | None = "") -> str:
-    """封卷：在头部打标记行（`finished` 传 UTC，这里转本地给人看）。"""
-    mark = f"> {FROZEN_MARK}：{fmt_local(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:
@@ -206,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, ...]]:
@@ -226,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():
@@ -236,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

@@ -14,7 +14,7 @@ from pathlib import Path
 from ..actions.query import HistoryQuery, ListQuery
 from ..core.roots import as_root, root_of
 from ..core.time import to_utc
-from ..errors import BUSINESS, USAGE, Fail
+from ..errors import BUSINESS, OK, USAGE, Fail
 from . import render, runner
 from .gitops import repo_sync_lock
 
@@ -99,11 +99,15 @@ def build_parser() -> argparse.ArgumentParser:
     hist.add_argument("--json", action="store_true")
 
     valp = sub.add_parser(
-        "validate", help="台账体检（默认浅度；--deep 读全部历史与过程文档）"
+        "validate",
+        help="台账体检（默认浅度；--deep 历史读全部月份；两档都不读过程文档）",
     )
     valp.add_argument("--deep", action="store_true")
     valp.add_argument("--json", action="store_true")
 
+    who = sub.add_parser("whoami", help="我是谁（本机身份；未初始化也照常回答）")
+    who.add_argument("--json", action="store_true")
+
     initp = sub.add_parser("init", help="初始化本机身份（一台机器只一次）")
     initp.add_argument("--claim", help="认领名册里已有的 uuid")
     initp.add_argument("--new", action="store_true", dest="new_id", help="新建身份")
@@ -229,6 +233,8 @@ def main(argv: list[str] | None = None) -> int:
     to_query(args)
 
     command = command_of(args)
+    if command == "whoami":
+        return _run_whoami(args)
     if command == "init":
         return _run_init(args)
     try:
@@ -405,6 +411,22 @@ def _confirm(question: str) -> bool:
         print("请输入 Y 或 N。")
 
 
+def _run_whoami(args: argparse.Namespace) -> int:
+    """只读机器身份：不解析台账、不碰 git、不看 `--repo`。
+
+    未初始化**不是错误**：照常回答（`uuid` / `name` 双 null），由调用方据此引导 init。
+    """
+    from .. import env
+
+    try:
+        identity = env.read_identity()
+    except Fail as exc:
+        render.fail_message(exc)
+        return BUSINESS
+    render.whoami_view(identity, as_json=bool(getattr(args, "json", False)))
+    return OK
+
+
 def _run_init(args: argparse.Namespace) -> int:
     """init 不进 runner、不解析台账、不碰 git：只写机器身份文件。