dsh-task-ledger 0.0.101 → 0.0.103

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

@@ -1,191 +0,0 @@
-"""结案：历史加一行 → 封卷过程文档 → **最后**删分片那行。
-
-`finished` 必填、由外壳算好（同一个值也用于算锁集与刷取范围）—— 业务层不许再调时钟，
-这是跨月刷错月份的唯一根因。
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..core.identity import Identity
-from ..core.labels import parse_tags
-from ..core.paths import history_path_for, shard_rel, to_repo_rel, worklog_name
-from ..core.worklog_md import (
-    StatusLine,
-    append_exec_log,
-    exec_line,
-    has_frozen_line,
-    rewrite_label_line,
-    rewrite_status_line,
-    stamp_frozen,
-)
-from ..errors import Fail
-from ..store.atomic import ensure_dir, fingerprint, restore, snapshot
-from ..store.history_store import HIT, UNDECIDABLE, HistoryStore
-from ..store.task_store import TaskStore
-from ..store.worklog_store import WorklogStore
-from .guard import require_owner
-from .result import Result, rel
-
-
-def close_task(
-    repo: Path,
-    me: Identity,
-    tid: str,
-    *,
-    summary: str,
-    finished: str,
-    tags: tuple[str, ...] | None = None,
-) -> Result:
-    """写序四步：改标签行 → 历史加一行 → 封卷 → 删分片（永远是最后一步）。"""
-    if not finished:
-        raise Fail("结案必须由外壳先算好时间（内部错误：finished 为空）。")
-    text_summary = " ".join((summary or "").split())
-    if not text_summary:
-        raise Fail("结案要写一句「完成了什么」（--summary 不能为空）。")
-    new_tags = parse_tags(tags) if tags else None
-
-    logs = WorklogStore(repo)
-    history = HistoryStore(repo)
-    hist_path = repo / to_repo_rel(history_path_for(finished))
-
-    mine = TaskStore(repo, shard_rel(me.uuid), identity=me)
-    task = mine.get(tid)  # 锁内重读
-    if task is None:
-        # 分片里已经没有这条：上次崩在「删分片」之后。只按过程文档名判重，命中即已结案
-        state = history.has_log(
-            hist_path, log_name=worklog_name(tid), created=None, title=None
-        )
-        if state == HIT:
-            return Result(
-                already_done=True,
-                where=rel(repo, hist_path),
-                notices=(f"任务 {tid} 已经结过案，无需重复。",),
-            )
-        raise Fail(f"任务 {tid} 不在我的分片里（只能结案自己的任务）。")
-
-    # 分片里在、但行内 owner 不是我 ⇒ 台账脏了（validate 会报⑤）：先拦下来，别用我的 uuid 记历史
-    require_owner(task, tid, me)
-
-    # 分类取任务原值（**不可改**）；标签给了参数用新值，没给沿用原值
-    final_category = task.get("category")
-    final_tags = tuple(new_tags) if new_tags else tuple(task.get("tags") or ())
-
-    doc_path = logs.find(tid, task.get("worklog"))
-
-    # 写前核对：指纹任一变了就中止，同时留三份字节备用
-    paths = [p for p in (mine.path, hist_path, doc_path) if p is not None]
-    stamps = {p: fingerprint(p) for p in paths}
-    backups = {p: snapshot(p) for p in paths}
-
-    try:
-        log_name = Path(doc_path).name if doc_path else None
-        state = history.has_log(
-            hist_path,
-            log_name=log_name,
-            created=task.get("created"),
-            title=task.get("title"),
-        )
-        if state == HIT:
-            # 崩在②（历史行已写）之后、③/④之前：历史里已有，但分片行可能还在、
-            # 过程文档可能还没封卷。不补齐就留下「已结案却仍在办」的僵尸 ——
-            # 它还能收 log，甚至被释放推回公共池让别人认领（2026-10-24 修）。
-            notes = [f"任务 {tid} 已经结过案，无需重复。"]
-            if doc_path is not None:
-                text = logs.read(doc_path)
-                if not has_frozen_line(text):
-                    frozen = stamp_frozen(text, finished, me.stamp())
-                    frozen = append_exec_log(
-                        frozen, exec_line(finished, me.stamp(), "close", "结案封卷")
-                    )
-                    frozen = rewrite_status_line(
-                        frozen, StatusLine("closed", me.name, me.uuid, finished)
-                    )
-                    logs.write(doc_path, frozen)
-                    notes.append("补齐上次未完成的封卷。")
-            if mine.get(tid) is not None:
-                mine.drop(tid)
-                notes.append("补齐上次未完成的移出分片。")
-            return Result(
-                already_done=True,
-                where=rel(repo, hist_path),
-                notices=tuple(notes),
-            )
-        if state == UNDECIDABLE:
-            raise Fail(
-                f"历史里有一条没有过程文档链接的旧行，判不出是不是 {tid} ⇒ 已中止，"
-                f"请人工看一眼 {rel(repo, hist_path)} 再重跑。"
-            )
-        # 写前核对（2026-10-23 补）：三个文件的指纹与读到时不一致 ⇒ 有人在锁外动过，
-        # 一个字节都不写（snapshot 那份留着给下面的异常分支按字节退回）。
-        for path in paths:
-            if fingerprint(path) != stamps[path]:
-                raise Fail(
-                    f"{rel(repo, path)} 在本命令执行期间被改动过"
-                    "（可能是编辑器或 git 操作），已中止、未写入任何内容；重跑一次即可。"
-                )
-
-        # ① 改标签行（给了 --tags 才做，且必须在封卷之前）
-        if doc_path is not None and new_tags:
-            text = logs.read(doc_path)
-            logs.write(doc_path, rewrite_label_line(text, final_tags))
-
-        # ② 历史加一行（先 ensure_dir：首次结案时 history/ 可能还不存在）
-        ensure_dir(hist_path.parent)
-        out = history.append_row(
-            hist_path,
-            {
-                "finished": finished,
-                "created": task.get("created"),
-                "title": task.get("title") or "",
-                "category": final_category,
-                "tags": final_tags,
-                # 历史里 uuid 与名字**都落盘**：uuid 是判定键（`@` + 裸 uuid，
-                # `--owner` / `--mine` 比它），名字是**结案那一刻的快照** —— 之后改名
-                # 不回写旧行，看历史看到的就是当时那个名字。
-                # 取值优先用任务行里认领 / 建任务时写下的那份；老任务没有就留空，不编造。
-                "owner": me.uuid,
-                "owner_name": task.get("owner_name") or me.name,
-                "creator": task.get("creator") or me.uuid,
-                "creator_name": task.get("creator_name"),
-                "summary": text_summary,
-                "worklog": task.get("worklog") if doc_path else None,
-            },
-        )
-        history.write(hist_path, out["text"])
-
-        # ③ 封卷（没有过程文档就跳过）
-        if doc_path is not None:
-            text = logs.read(doc_path)
-            if not has_frozen_line(text):
-                frozen = stamp_frozen(text, finished, me.stamp())
-                frozen = append_exec_log(
-                    frozen, exec_line(finished, me.stamp(), "close", "结案封卷")
-                )
-                frozen = rewrite_status_line(
-                    frozen, StatusLine("closed", me.name, me.uuid, finished)
-                )
-                logs.write(doc_path, frozen)
-
-        # ④ 删我分片那行（永远最后）
-        mine.drop(tid)
-    except Exception:
-        for path in paths:
-            if path in backups:
-                restore(path, backups[path])
-        raise
-
-    notices: list[str] = []
-    if doc_path is None:
-        notices.append(f"提示：任务 {tid} 没有过程文档，已跳过封卷，历史末列留空。")
-    return Result(
-        changed=("status", "finished"),
-        where=rel(repo, hist_path),
-        message=f"结案 {tid}：{task.get('title') or ''}".strip(),
-        payload={
-            "history_path": rel(repo, hist_path),
-            "worklog_path": rel(repo, doc_path) if doc_path else None,
-        },
-        notices=tuple(notices),
-    )

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

@@ -1,158 +0,0 @@
-"""业务校验的共用件：任务号形态、任务存不存在、「这条是不是你的」。
-
-**`owner` / `status` 的读取只走这里的四个谓词**：`store/` 里不许出现 `get("owner")`，
-`actions/` 里除本文件外也不许裸写字段名比较。
-"""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-from pathlib import Path
-from typing import Any
-
-from ..core.identity import Identity, is_me, looks_like_uuid, normalize
-from ..core.paths import POOL_REL
-from ..errors import Fail
-from ..store.owners_index import OwnersIndex
-from ..store.task_store import TaskStore
-from .query import ListQuery
-
-
-def current_identity(repo: Path) -> Identity:
-    """env 的本机身份（不写盘、不登记）。全站只认 uuid 这一个身份键。"""
-    from .. import env
-
-    return env.current(repo)
-
-
-def require_uuid(value: str, *, field: str) -> str:
-    """身份参数只收 UUID：名字 / 邮箱一律当场报错，绝不悄悄比不到东西。
-
-    名字只能用于查询筛选（`--owner-name`），这一点要在报错里说清楚，
-    否则用户会以为「名字也行，只是没查到」。
-    """
-    text = normalize(value)
-    if not looks_like_uuid(text):
-        raise Fail(
-            f"{field} 只收身份 uuid（形如 00000000-0000-4000-8000-000000000000），"
-            f"不接受名字 / 邮箱：{value.strip()}\n"
-            "  按显示名模糊筛请用 --owner-name <片段>；"
-            "不知道对方 uuid 就先跑 list --json 看，或让本人跑 list --mine。"
-        )
-    return text
-
-
-def require_task(tasks: Mapping[str, Any], tid: str, *, where: Path) -> dict[str, Any]:
-    """取一条任务；缺失时给可读原因（带所在文件）。"""
-    task = tasks.get(tid)
-    if task is None:
-        raise Fail(f"任务 {tid} 不在 {_show(where)} 里。")
-    if not isinstance(task, dict):
-        raise Fail(f"任务 {tid} 在 {_show(where)} 里不是一条对象，台账可能坏了。")
-    return dict(task)
-
-
-def require_owner(task: Mapping[str, Any], tid: str, me: Identity) -> None:
-    """只有当前 owner 能改。"""
-    owner = owner_of(task)
-    if not owner:
-        raise Fail(f"任务 {tid} 还没有人认领（在公共池里），先 claim 再改。")
-    if not is_me(me, owner):
-        raise Fail(f"任务 {tid} 的负责人是 {owner}，不是你（{me.label()}）。")
-
-
-def same_task_ignoring_stamp(a: Mapping[str, Any], b: Mapping[str, Any]) -> bool:
-    """两份内容是不是只差 `updated`（交接重跑时以对方那份为准的判据）。"""
-    left = {k: v for k, v in a.items() if k not in ("updated", "updated_by")}
-    right = {k: v for k, v in b.items() if k not in ("updated", "updated_by")}
-    return left == right
-
-
-def owner_of(task: Mapping[str, Any]) -> str | None:
-    """读 `owner` 的唯一入口。"""
-    value = task.get("owner")
-    return normalize(value) if isinstance(value, str) and value.strip() else None
-
-
-def status_of(task: Mapping[str, Any]) -> str:
-    """读 `status` 的唯一入口。"""
-    value = task.get("status")
-    if not isinstance(value, str) or not value.strip():
-        return "open"
-    return value.strip().lower()
-
-
-def is_mine(task: Mapping[str, Any], me: Identity) -> bool:
-    """这条任务是不是我的（只比 uuid）。"""
-    return is_me(me, owner_of(task) or "")
-
-
-def in_scope(
-    task: Mapping[str, Any],
-    q: ListQuery,
-    *,
-    me: Identity,
-    name_keys: set[str] | frozenset[str] = frozenset(),
-) -> bool:
-    """`list` 的过滤谓词：范围、状态、分类、标签、创建时间闭区间。
-
-    `name_keys` 是 `--owner-name` 先在名册里模糊匹配出来的 uuid 集合（由调用方查好传进来）：
-    **名字只用来缩小 uuid 集合，判定本身仍按 uuid 比。**
-    """
-    if q.scope == "mine" and not is_mine(task, me):
-        return False
-    if q.scope == "pool" and owner_of(task):
-        return False
-    if q.scope == "owner" and q.owner and normalize(q.owner) != owner_of(task):
-        return False
-    if q.owner_name and owner_of(task) not in name_keys:
-        return False
-    if q.statuses and status_of(task) not in set(q.statuses):
-        return False
-    if q.category and (task.get("category") or "") != q.category:
-        return False
-    if q.tag and q.tag not in (task.get("tags") or ()):
-        return False
-    created = task.get("created")
-    if q.since and isinstance(created, str) and created[:19] < q.since[:19]:
-        return False
-    return not (q.until and isinstance(created, str) and created[:19] > q.until[:19])
-
-
-def _show(path: Path) -> str:
-    try:
-        return str(Path(path).name)
-    except Exception:  # noqa: BLE001
-        return str(path)
-
-
-def load_task(repo: Path, tid: str) -> tuple[dict[str, Any], list[Path]]:
-    """在池 + 索引登记的全部分片里找这条任务（只读），返回 (任务, 出现过的文件)。"""
-    index = OwnersIndex(repo)
-    index.assert_present()
-    found: dict[str, Any] | None = None
-    where: list[Path] = []
-    pool = TaskStore(repo, POOL_REL)
-    if pool.get(tid):
-        found = pool.get(tid)
-        where.append(pool.path)
-    for rel in _shard_rels(repo, index):
-        store = TaskStore(repo, rel)
-        task = store.get(tid)
-        if task:
-            where.append(store.path)
-            if found is None:
-                found = task
-    if found is None:
-        raise Fail(f"找不到任务 {tid}（池与已登记的分片里都没有）。")
-    return found, where
-
-
-def _shard_rels(repo: Path, index: OwnersIndex) -> list[Path]:
-    out: list[Path] = []
-    for path in index.shards().values():
-        try:
-            out.append(path.relative_to(repo / "ledger"))
-        except ValueError:  # pragma: no cover
-            continue
-    return out

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

@@ -1,93 +0,0 @@
-"""交接：先写进对方分片，再删我分片那行，再记一笔。"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..core.identity import Identity, normalize
-from ..core.paths import shard_rel
-from ..core.time import now
-from ..core.worklog_md import StatusLine, exec_line
-from ..errors import Fail
-from ..store.owners_index import OwnersIndex
-from ..store.task_store import TaskStore
-from ..store.worklog_store import WorklogStore
-from .guard import owner_of, same_task_ignoring_stamp
-from .result import Result, rel
-
-
-def handoff(repo: Path, me: Identity, tid: str, *, to: str) -> Result:
-    """写序：对方分片 → 删我分片那行 → 过程文档记一笔。"""
-    index = OwnersIndex(repo)
-    record = index.get(to)
-    if record is None:
-        raise Fail(
-            f"{to} 还没在索引里登记过 ⇒ 不能交接给他（写出一份对别人不存在的分片，他自己也看不到）。"
-        )
-    mine = TaskStore(repo, shard_rel(me.uuid), identity=me)
-    task = mine.get(tid)  # 锁内重读
-    if task is None:
-        raise Fail(f"任务 {tid} 不在我的分片里，交接不了。")
-
-    to_key = normalize(to)
-    # 行内 owner 只能是我（正常）或已经是对方（上次交接崩在半途，这次要补齐）：
-    # 别的一律拒绝——分片里有、owner 却写着第三个人 ⇒ 台账脏了
-    owner = owner_of(task)
-    if owner not in (normalize(me.uuid), to_key):
-        raise Fail(
-            f"任务 {tid} 的负责人是 {owner}，不是你（{me.label()}），交接不了。\n"
-            "  处理：跑 validate 看台账是不是脏了。"
-        )
-    to_name = str(record.get("name") or "") or None  # 只用于显示
-    who = to_name or to_key  # 给人看：命令输出、提示语
-    # 落盘用「名字 · uuid」：接收人拿什么键去分片里找，比执行者更需要 uuid
-    who_stamp = Identity(uuid=to_key, name=to_name or "").stamp()
-    to_store = TaskStore(repo, shard_rel(to_key))
-    moved = dict(task)
-    moved["owner"] = to_key
-    moved["owner_name"] = to_name
-    moved["updated"] = now()
-
-    existing = to_store.get(tid)
-    if existing is not None:
-        if not same_task_ignoring_stamp(existing, moved):
-            raise Fail(
-                f"任务 {tid} 在 {to_key} 的分片里已经存在，且内容与本次不一致 ⇒ 拒绝交接。"
-            )
-        # 重跑：以对方那份为准，只补删我这边
-        mine.drop(tid)
-        logs = WorklogStore(repo)
-        path = logs.find(tid, moved.get("worklog"))
-        if path is not None:
-            logs.append_exec(
-                path,
-                exec_line(now(), me.stamp(), "set", f"交接给 @{who_stamp}（补齐）"),
-                status=StatusLine("doing", to_name, to_key, now()),
-            )
-        return Result(
-            already_done=True,
-            where=rel(repo, to_store.path),
-            message=f"交接 {tid} → {who}：补齐上次未完成的清理",
-            notices=(f"任务 {tid} 已在对方分片里（内容一致），本次只补删我分片那行。",),
-        )
-
-    to_store.put(tid, moved)
-    mine.drop(tid)
-
-    logs = WorklogStore(repo)
-    path = logs.find(tid, moved.get("worklog"))
-    note = None
-    if path is None:
-        note = f"任务 {tid} 已交给 {who}，但过程文档没找到，跳过执行记录。"
-    else:
-        logs.append_exec(
-            path,
-            exec_line(now(), me.stamp(), "set", f"交接给 @{who_stamp}"),
-            status=StatusLine("doing", to_name, to_key, now()),
-        )
-    return Result(
-        changed=("owner", "owner_name", "updated"),
-        where=rel(repo, to_store.path),
-        message=f"交接 {tid} → {who}",
-        notices=(note,) if note else (),
-    )

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

@@ -1,90 +0,0 @@
-"""init：初始化本机身份（写 `~/.taskledger/identity.json`，一台机器只一次）。
-
-只做逻辑，不打印、不读 stdin；交互/机器读在 shell 层。
-- `claim`：认领名册里已有的 uuid（连 name 一起复制，不输入）。
-- `new`  ：新建 uuid（必须给 name）。
-- 都不给且名册有人：返回候选列表，交给调用方去问用户。
-"""
-
-from __future__ import annotations
-
-import json
-import uuid as uuidlib
-from pathlib import Path
-from typing import Any
-
-from .. import env
-from ..core.identity import Identity, looks_like_uuid, normalize
-from ..core.paths import OWNERS_REL, to_repo_rel
-from ..errors import Fail
-
-
-def _read_workers(repo: Path | None) -> dict[str, Any]:
-    if repo is None:
-        return {}
-    try:
-        raw = (repo / to_repo_rel(OWNERS_REL)).read_text(encoding="utf-8")
-        data = json.loads(raw)
-    except (OSError, ValueError):
-        return {}
-    return (data or {}).get("workers", {}) or {}
-
-
-def init_identity(
-    repo: Path | None, *, claim: str | None, new: bool, name: str
-) -> dict[str, Any]:
-    path = env.identity_file()
-    existing = env.read_identity()
-    if existing is not None:
-        # 已初始化 = 幂等空转（与 release/claim/close 的重跑口径一致）：退 0、零写。
-        # 只有「认领另一个 uuid」才是真冲突——换身份不归 init 管。
-        if claim is None or normalize(claim) == existing.uuid:
-            return {
-                "already": True,
-                "uuid": existing.uuid,
-                "name": existing.name,
-                "path": str(path),
-            }
-        raise Fail(
-            f"这台机器已经是 {existing.uuid}（{path}），不能再认领 {claim.strip()}。\n"
-            "  处理：要换身份请手动改该文件的 uuid；一台机器一个身份。"
-        )
-
-    workers = _read_workers(repo)
-    if claim:
-        key = normalize(claim)  # 名册键一律小写；--claim 抄来的大小写不影响
-        # 认领目标必须是 uuid：老台账的键还可能是个邮箱 / 名字，认来会让整台机器
-        # 拿非 uuid 当身份写进每一处（--owner 反倒拒收自己）
-        if not looks_like_uuid(key):
-            raise Fail(
-                f"认领目标不是 uuid：{claim.strip()}\n"
-                "  处理：老台账（身份键是邮箱 / 名字）请改走 `init --new --name=<名字>`；"
-                "先把那本台账迁到 uuid 身份，再谈认领。"
-            )
-        record = workers.get(key)
-        if record is None:
-            raise Fail(
-                f"名册里没有 uuid={claim}。\n"
-                "  处理：不带参数跑一次 init 看可选用户，再 --claim 选一个。"
-            )
-        identity = Identity(uuid=key, name=str(record.get("name") or ""))
-    elif workers and not new:
-        return {
-            "need_choose": True,
-            "path": str(path),
-            "options": [
-                {"uuid": key, "name": str((rec or {}).get("name") or "")}
-                for key, rec in workers.items()
-            ],
-        }
-    else:
-        if not name.strip():
-            raise Fail("新建身份必须输入一个名字（--name=<名字>）。")
-        identity = Identity(uuid=str(uuidlib.uuid4()), name=name.strip())
-
-    path.parent.mkdir(parents=True, exist_ok=True)
-    payload = {"uuid": identity.uuid, "name": identity.name}
-    path.write_text(
-        json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
-    )
-    return {"uuid": identity.uuid, "name": identity.name, "path": str(path)}

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

@@ -1,74 +0,0 @@
-"""只读：查在办任务（池 + 分片，后读到的为准）。不拿锁、不跑自举、不做取最新。"""
-
-from __future__ import annotations
-
-from dataclasses import replace
-from pathlib import Path
-from typing import Any
-
-from ..core.identity import Identity
-from ..core.labels import STATUSES
-from ..core.paths import POOL_REL
-from ..errors import Fail
-from ..store.owners_index import OwnersIndex
-from ..store.task_store import TaskStore
-from .guard import in_scope, is_mine, owner_of, require_uuid, status_of
-from .query import ListQuery
-from .result import ListResult, TaskRow, rel
-
-
-def list_tasks(repo: Path, me: Identity, q: ListQuery) -> ListResult:
-    """合并顺序定死：先池、再按索引键排序的各分片，同一任务号由分片那份胜出。"""
-    # `--owner` 只认 uuid，且**给了就必须生效**：和 --mine / --pool 同传直接报错，
-    # 不许出现「传了 uuid 却被范围参数静默吃掉」（--owner "" 也算给了，同样报错）。
-    if q.owner is not None:
-        if q.scope in ("mine", "pool"):
-            raise Fail("--owner 不能和 --mine / --pool 一起用：一次只按一种范围筛。")
-        q = replace(q, owner=require_uuid(q.owner, field="--owner"))
-    # `--status` 只认白名单：`--status blocked` 这种早该消失的值不许静默返回空表
-    unknown = [s for s in q.statuses if s not in STATUSES]
-    if unknown:
-        raise Fail(
-            f"--status 只认 {' / '.join(STATUSES)}（收到 {', '.join(unknown)}）。"
-        )
-    rows: dict[str, dict[str, Any]] = {}
-    where: dict[str, Path] = {}
-
-    pool = TaskStore(repo, POOL_REL)
-    for tid, task in pool.all().items():
-        rows[tid] = task
-        where[tid] = pool.path
-
-    index = OwnersIndex(repo)
-    index.assert_present()
-    for key in sorted(index.shards()):
-        path = index.shards()[key]
-        store = TaskStore(repo, Path(path).relative_to(repo / "ledger"))
-        for tid, task in store.all().items():
-            rows[tid] = task
-            where[tid] = store.path
-
-    name_keys = index.keys_of_name(q.owner_name) if q.owner_name else set()
-    kept = {
-        tid: t for tid, t in rows.items() if in_scope(t, q, me=me, name_keys=name_keys)
-    }
-    # 每行自带 `mine`（只比 uuid，零额外 IO）：调用方不必自己拿 uuid 再比一次
-    for task in kept.values():
-        task["mine"] = is_mine(task, me)
-    table = tuple(
-        TaskRow(
-            tid=tid,
-            title=str(task.get("title") or ""),
-            status=status_of(task),
-            owner=task.get("owner_name") or owner_of(task),
-            created=task.get("created"),
-            started=task.get("started"),
-            category=task.get("category"),
-            tags=tuple(task.get("tags") or ()),
-            where=rel(repo, where[tid]),
-        )
-        for tid, task in sorted(
-            kept.items(), key=lambda kv: str(kv[1].get("created") or "")
-        )
-    )
-    return ListResult(rows=kept, table=table)

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

@@ -1,67 +0,0 @@
-"""记进展：刷分片的「最后更新」，再往过程文档追加一行。"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..core.identity import Identity
-from ..core.paths import shard_rel
-from ..core.time import now
-from ..core.worklog_md import StatusLine, exec_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 log_progress(repo: Path, me: Identity, tid: str, note: str) -> Result:
-    """写序：刷 `updated` → 过程文档追加一行。
-
-    文档写不进（`append_exec` 回 False）⇒ **不算失败**：分片已经刷了就照常提交，
-    只留一条警告 —— 抛错让外壳回滚会变成「改了又不提交」，下一条命令被写前 guard 拦死。
-    """
-    text = " ".join((note or "").split())
-    if not text:
-        raise Fail("--note 不能为空。")
-    mine = TaskStore(repo, shard_rel(me.uuid), identity=me)
-    task = mine.get(tid)  # 锁内重读
-    if task is None:
-        raise Fail(f"任务 {tid} 不在我的分片里（只能给自己的任务记进展）。")
-    # 分片里有、行内 owner 却不是我 ⇒ 台账脏了（validate ⑤），先拦下来
-    require_owner(task, tid, me)
-
-    updated = dict(task)
-    updated["updated"] = now()
-    mine.put(tid, updated)
-
-    logs = WorklogStore(repo)
-    path = logs.find(tid, updated.get("worklog"))
-    if path is None:
-        return Result(
-            changed=("updated",),
-            where=rel(repo, mine.path),
-            message=f"{tid}：记进展",
-            notices=(
-                "提示：这条任务没有过程文档，已跳过执行记录（分片的最后更新已刷）。",
-            ),
-        )
-    ok = logs.append_exec(
-        path,
-        exec_line(now(), me.stamp(), "log", text),
-        status=StatusLine("doing", me.name, me.uuid, now()),
-    )
-    if not ok:
-        return Result(
-            changed=("updated",),
-            where=rel(repo, mine.path),
-            message=f"{tid}：记进展",
-            notices=(
-                "警告：分片的最后更新已刷，过程文档补不上（文件不可写）；已写的分片照常提交，文档那行要手动补。",
-            ),
-        )
-    return Result(
-        changed=("updated",),
-        where=rel(repo, mine.path),
-        message=f"{tid}：记进展",
-    )