dsh-task-ledger 0.0.95 → 0.0.97

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,36 @@ 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,
+            },
+            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/history_md.py

@@ -32,13 +32,18 @@ def esc_cell(text: str) -> str:
 
 
 def owner_cell(owner: str | None) -> str:
-    """owner 列的展示值：人名前加 @（`@` 只是展示约定，匹配一律用裸 uuid）。"""
-    return f"@{owner}" if owner else ""
+    """owner 列的值：裸 uuid，**不加 `@`**（`@` 只加在名字列；匹配一律用裸 uuid）。"""
+    return owner or ""
 
 
 def creator_cell(creator: str | None) -> str:
-    """creator 列展示值（与 owner_cell 同一 `@` 约定）。"""
-    return f"@{creator}" if creator else ""
+    """creator 列的值（与 owner_cell 同一约定：裸 uuid，不加 `@`）。"""
+    return creator or ""
+
+
+def name_cell(name: str | None) -> str:
+    """名字列的展示值：名字前加 `@`（与过程文档 `@名字 · uuid` 同一口径）。"""
+    return f"@{name}" if name else ""
 
 
 def split_row(line: str) -> list[str]:
@@ -74,9 +79,9 @@ def history_line(
 ) -> str:
     """十一列的一行。`worklog` 收**相对 `ledger/`** 的路径，这里负责换成相对 `history/` 的链接。
 
-    owner / creator 传**裸 uuid**（`@` 由 owner_cell / creator_cell 加），外面别先加。
-    `owner_name` / `creator_name` 是**落盘的显示名快照**（结案那一刻的名字，之后改名不改旧行），
-    原值写入、**不加 `@`** —— `@` 只属于 uuid 那两列。
+    owner / creator 传**裸 uuid**、名字传**裸名字**，两处都别先加 `@`：
+    `@` 由 `name_cell` 只加在名字列（与过程文档 `@名字 · uuid` 同一口径），uuid 列永远是裸值。
+    `owner_name` / `creator_name` 是**落盘的显示名快照**（结案那一刻的名字，之后改名不改旧行）。
     """
     log_rel = to_history_rel(worklog) if worklog else ""
     tag_cell = esc_cell("、".join(tags) if tags else "")
@@ -84,8 +89,8 @@ def history_line(
     return (
         f"| {finished} | {created or ''} | {esc_cell(title)} "
         f"| {esc_cell(category or '')} | {tag_cell} "
-        f"| {esc_cell(owner_cell(owner))} | {esc_cell(owner_name or '')} "
-        f"| {esc_cell(creator_cell(creator))} | {esc_cell(creator_name or '')} "
+        f"| {esc_cell(owner_cell(owner))} | {esc_cell(name_cell(owner_name))} "
+        f"| {esc_cell(creator_cell(creator))} | {esc_cell(name_cell(creator_name))} "
         f"| {esc_cell(summary)} | {link} |\n"
     )
 
@@ -94,8 +99,8 @@ def parse_history(text: str) -> tuple[list[Row], list[str]]:
     """解析十一列历史表 → (records, warnings)。坏行（列数不对 / 时间列不合法）跳过并警告。
 
     返回的键：finished / created / title / category / tags / owner / owner_name /
-    creator / creator_name / summary / worklog / fmt / line。owner 与 creator 一律
-    **剥掉 `@`**（存储值是裸 uuid）；两个名字列是**原值**（落盘快照，可能为空）。
+    creator / creator_name / summary / worklog / fmt / line。owner 与 creator 两列
+    **剥掉 `@`**（存储值是裸 uuid）；两个名字列剥掉展示用的 `@`（落盘快照，可能为空）。
     """
     records: list[Row] = []
     warnings: list[str] = []
@@ -135,9 +140,9 @@ def parse_history(text: str) -> tuple[list[Row], list[str]]:
                     t.strip() for t in _TAG_SPLIT_RE.split(tag_cell) if t.strip()
                 ),
                 "owner": owner.strip().removeprefix("@") or None,
-                "owner_name": owner_name.strip() or None,
+                "owner_name": owner_name.strip().removeprefix("@") or None,
                 "creator": creator.strip().removeprefix("@") or None,
-                "creator_name": creator_name.strip() or None,
+                "creator_name": creator_name.strip().removeprefix("@") or None,
                 "summary": summary,
                 "worklog": (m.group(1) if m else doc.strip()) or None,
                 "fmt": "v11",

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,11 +8,12 @@ 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 = (
@@ -31,6 +32,23 @@ CREATED_AT_RE = re.compile(
 )
 CREATOR_RE = re.compile(r"^\s*>\s*\*\*创建\*\*\s*[：:].*?（@(.+?)）")
 
+# 头部「状态」行：`> **状态**：doing · @某人（uuid）· 更新 2026-10-27 08:28:22`。
+# 它是**镜像**：分片 / 池里的 `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_]+)")
+#: 状态取值（与 `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})?)?)"
+)
+_TITLE_RE = re.compile(r"^#\s*(.+?)\s*[：:]\s*(.*)$")
+
 _HEAD_RE = re.compile(r"\A(.*?)(?=^## |\Z)", re.DOTALL | re.MULTILINE)
 
 
@@ -70,6 +88,16 @@ def format_problems(text: str) -> list[str]:
         )
     elif not any(CREATOR_RE.match(line) for line in head):
         problems.append("头部「创建」行缺发起人（应为 `…（@某人）`）")
+    # 状态行：**有就必须合法**；缺了不报——老文档没有这行是合法的（读取方回退查分片）
+    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,15 +159,34 @@ 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
@@ -155,13 +202,95 @@ def _insert_after_head(lines: list[str], line: str) -> list[str]:
     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:
+    """状态行的**内容**部分（`> **状态**：` 之后那段）。"""
+    parts = [status]
+    if name and uuid:
+        parts.append(f"@{name}（{uuid}）")
+    elif name:
+        parts.append(f"@{name}")
+    elif uuid:
+        parts.append(uuid)
+    if when:
+        parts.append(f"更新 {when}")
+    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_after_head(lines, line)) + "\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,8 +309,8 @@ 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}）"
     if FROZEN_RE.search(text or ""):

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：只写机器身份文件。
 

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

@@ -18,6 +18,7 @@ from ..actions.result import (
     ShowResult,
     ValidationReport,
 )
+from ..core.identity import Identity
 from ..core.time import fmt_local
 
 
@@ -51,6 +52,23 @@ def _json(data: Any) -> None:
     sys.stdout.write(json.dumps(data, ensure_ascii=False, indent=2) + "\n")
 
 
+#: 任务 / 历史行里要转本机时区的时间字段（存盘一律 UTC，出门一律本机时区）。
+TIME_FIELDS = ("created", "started", "updated", "finished")
+
+
+def localize_times(data: dict) -> dict:
+    """复制一份，把上面四个时间字段转成本机时区；其余字段原样。
+
+    **只动这四个**：任务号里嵌的时间戳、过程文档正文里的时间都不动（原文照旧）。
+    """
+    out = dict(data)
+    for key in TIME_FIELDS:
+        value = out.get(key)
+        if value:
+            out[key] = fmt_local(value)
+    return out
+
+
 def result(res: Result, *, as_json: bool) -> None:
     """写动作：一律人话（`--json` 不挂写动作，传进来也按人话打）。"""
     del as_json
@@ -71,7 +89,7 @@ def result(res: Result, *, as_json: bool) -> None:
 
 def list_view(res: ListResult, q: ListQuery | None, *, as_json: bool) -> None:
     if as_json:
-        _json({tid: task for tid, task in res.rows.items()})
+        _json({tid: localize_times(task) for tid, task in res.rows.items()})
         return
     if not res.table:
         _out("没有符合条件的在办任务。")
@@ -84,11 +102,33 @@ def list_view(res: ListResult, q: ListQuery | None, *, as_json: bool) -> None:
         _err(line)
 
 
+def whoami_view(identity: Identity | None, *, as_json: bool) -> None:
+    """本机身份：未初始化给 `uuid` / `name` 双 null（不是错误，调用方据此引导 init）。"""
+    if as_json:
+        _json(
+            {
+                "uuid": identity.uuid if identity else None,
+                "name": identity.name if identity else None,
+            }
+        )
+        return
+    if identity is None:
+        _out("这台机器还没有初始化身份。")
+        _out(
+            "  处理：请用户在自己的终端运行 "
+            "`progress.py init --repo <工作区根>`，由 ta 亲自选择/新建并确认。"
+        )
+        return
+    _out(f"@{identity.label()}   {identity.uuid}")
+
+
 def show_view(res: ShowResult, *, as_json: bool) -> None:
     if as_json:
         _json(
             {
-                "task": res.task,
+                "task": localize_times(res.task),
+                # 文档自述还是回退查在办：调用方据此知道字段来源（老文档 / 文档缺失）
+                "legacy": res.legacy,
                 "worklog": {
                     "path": res.worklog.path if res.worklog else None,
                     "text": res.worklog.text if res.worklog else None,
@@ -125,11 +165,15 @@ def history_view(res: HistoryResult, q: HistoryQuery | None, *, as_json: bool) -
         _json({"count": res.count, "capped": res.capped})
         return
     if as_json:
+        filters = dict(res.filters)
+        for key in ("since", "until"):
+            if filters.get(key):
+                filters[key] = fmt_local(filters[key])
         _json(
             {
                 "count": res.count,
-                "filters": res.filters,
-                "records": list(res.records),
+                "filters": filters,
+                "records": [localize_times(row) for row in res.records],
                 "warnings": list(res.warnings),
                 "capped": res.capped,
             }

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

@@ -131,9 +131,10 @@ class WorklogStore:
         creator: str,
         category: str | None = None,
         tags: tuple[str, ...] = (),
+        status: worklog_md.StatusLine | None = None,
         first_exec: str | None = None,
     ) -> Path:
-        """一次写完整篇（含首条执行记录）。返回绝对路径。"""
+        """一次写完整篇（含状态行与首条执行记录）。返回绝对路径。"""
         rel = worklog_rel(tid, created)
         path = self.repo / to_repo_rel(rel)
         ensure_dir(path.parent)
@@ -144,6 +145,7 @@ class WorklogStore:
             creator=creator,
             category=category,
             tags=tags,
+            status=status,
             template=self.template(),
         )
         if first_exec:
@@ -155,14 +157,23 @@ class WorklogStore:
         """写回「锚点编辑后的新全文」；不许用它替换前五节正文。"""
         write_text_atomic(path, text)
 
-    def append_exec(self, path: Path, line: str) -> bool:
-        """追加一条执行记录；写不进返回 False，**不抛**（调用方自己决定报不报）。"""
+    def append_exec(
+        self, path: Path, line: str, *, status: worklog_md.StatusLine | None = None
+    ) -> bool:
+        """追加一条执行记录，并在**同一次写盘**里顺带刷新头部状态行（`status` 给了才刷）。
+
+        写不进返回 False，**不抛**（调用方自己决定报不报）。状态行与执行记录必须一起落地：
+        分两写就会留下「记录写了、状态没刷」这种不报错的不一致。
+        """
         try:
             text = path.read_text(encoding="utf-8-sig")
         except (OSError, UnicodeDecodeError):
             return False
         try:
-            write_text_atomic(path, worklog_md.append_exec_log(text, line))
+            new = worklog_md.append_exec_log(text, line)
+            if status is not None:
+                new = worklog_md.rewrite_status_line(new, status)
+            write_text_atomic(path, new)
         except Exception:  # noqa: BLE001 —— 写不进是这条记录的失败，不该掀翻整条命令
             return False
         return True