dsh-task-ledger 0.0.101 → 0.0.102

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

@@ -1,129 +0,0 @@
-"""建任务：拿外壳算好的任务号写过程文档、写进池（或直接写进自己的分片）。
-
-`tid` / `created` 由外壳算好传进来（锁层要靠它们算出那篇文档的路径），
-业务层不许现算现用；缺了就是外壳的 bug，直接 Fail。
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..core.identity import Identity
-from ..core.ids import require_task_id
-from ..core.labels import normalize_label, parse_tags
-from ..core.paths import (
-    POOL_REL,
-    shard_rel,
-    to_repo_rel,
-    worklog_rel,
-)
-from ..core.worklog_md import StatusLine, exec_line
-from ..errors import Fail
-from ..store.atomic import ensure_dir, restore, snapshot
-from ..store.task_store import TaskStore
-from ..store.worklog_store import WorklogStore
-from .result import Result, WorklogView, rel
-
-FIELDS = ("created", "title", "status", "owner", "creator", "worklog")
-
-
-def new_task(
-    repo: Path,
-    me: Identity,
-    *,
-    title: str,
-    tid: str,
-    created: str,
-    category: str | None = None,
-    tags: tuple[str, ...] = (),
-    mine: bool = False,
-) -> Result:
-    """写序：`ensure_dir(当月文档目录)` → 过程文档（含首条记录）→ 台账。"""
-    if not (title or "").strip():
-        raise Fail("标题不能为空。")
-    if not tid:
-        raise Fail("建任务必须由外壳先算好任务号（内部错误：tid 为空）。")
-    if not created:
-        raise Fail("建任务必须由外壳先算好创建时间（内部错误：created 为空）。")
-    tid = require_task_id(tid)
-    clean_title = " ".join(title.strip().split())
-    category = normalize_label(category, field="分类") if category else None
-    tag_list = parse_tags(tags)
-
-    mine_store = TaskStore(repo, shard_rel(me.uuid), identity=me)
-    pool = TaskStore(repo, POOL_REL)
-    target = mine_store if mine else pool
-
-    # 查重：池 + 我自己的分片，**并且在锁内重读**（锁外的快照只配决定锁多宽）
-    if target.get(tid) is not None:
-        raise Fail(f"任务号 {tid} 已经存在了（这不是重跑，是重号）。")
-    other = pool if mine else mine_store
-    if other.get(tid) is not None:
-        raise Fail(f"任务号 {tid} 已经存在了（这不是重跑，是重号）。")
-    # 已结案的号也不能复用，且跨月同号互不干扰：直接看过程文档路径在不在。
-    # 在办任务的文档在磁盘上、已结案任务的文档也留在磁盘上 ⇒ 文档存在即这个号被占过
-    # （撞的是同一篇 worklog 文件，会覆盖 / 日后让 close 误判 already_done 变僵尸）。
-    # O(1)，不必扫历史文件。上面分片 / 池是并发安全闸门，这里补文件级的精确判重。
-    if (repo / to_repo_rel(worklog_rel(tid, created))).exists():
-        raise Fail(
-            f"任务号 {tid} 的过程文档已经存在（同名号的在办 / 已结案任务占着同一篇文档）。\n"
-            "  处理：换一个 --id，别复用历史号。\n"
-            "  若上次 new 崩在中间（文档已写、台账没落），这篇就是它留下的：确认内容要保留就换号重建；"
-            "非要复用这一号，先把那篇文档挪走再重跑。"
-        )
-
-    doc_rel = worklog_rel(tid, created)  # 别叫 rel：那是 result.rel 的函数名
-    path = repo / to_repo_rel(doc_rel)
-    logs = WorklogStore(repo)
-    before_doc = snapshot(path)
-
-    task = {
-        "title": clean_title,
-        "created": created,
-        # --self = 建并认领：直接归自己名下就必须是在做，不留 open 半成品
-        "status": "doing" if mine else "open",
-        "owner": me.uuid if mine else None,
-        "owner_name": me.name if mine else None,
-        "creator": me.uuid,
-        "creator_name": me.name,
-        "category": category,
-        "tags": list(tag_list),
-        "worklog": doc_rel,
-        "started": created if mine else None,
-        "updated": created,
-        "finished": None,
-    }
-    try:
-        ensure_dir(path.parent)
-        _ = logs.create(
-            tid=tid,
-            title=clean_title,
-            created=created,
-            creator=me.stamp(),
-            tags=tag_list,
-            status=StatusLine(
-                "doing" if mine else "open",
-                me.name if mine else None,
-                me.uuid if mine else None,
-                created,
-            ),
-            first_exec=exec_line(
-                created, me.stamp(), "new", "创建任务并认领" if mine else "创建任务"
-            ),
-        )
-        target.put(tid, task)
-    except Exception:
-        # 同一个 atom 内收尾：台账那条 drop 掉，文档原本不存在 ⇒ restore(None) 删掉
-        target.drop(tid)
-        restore(path, before_doc)
-        raise
-
-    text = logs.read(path)
-    return Result(
-        changed=FIELDS,
-        where=rel(repo, target.path),
-        message=f"新建任务 {tid}：{clean_title}",
-        worklog=WorklogView(path=rel(repo, path), text=text, error=None),
-        payload={"tid": tid},
-        notices=(f"新建过程文档：{rel(repo, path)}",),
-    )

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

@@ -1,35 +0,0 @@
-"""查询条件长什么样。外壳把命令行装成它，界面直接构造它 —— **动作层不认识 argparse**。"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-@dataclass(frozen=True)
-class ListQuery:
-    scope: str = "all"  # "all" / "pool" / "mine" / "owner"
-    owner: str | None = None  # scope="owner" 时生效；**只收 uuid**
-    owner_name: str | None = None  # 显示名模糊筛（子串、不分大小写）；只筛不判定
-    statuses: tuple[str, ...] = ()
-    category: str | None = None
-    tag: str | None = None
-    since: str | None = None  # UTC 串，闭区间
-    until: str | None = None  # 同上
-    # `since` / `until` **一律比 `created`**（含边界，只给其一也行），不比 started / updated。
-
-
-@dataclass(frozen=True)
-class HistoryQuery:
-    owner: str | None = None  # **只收 uuid**
-    owner_name: str | None = None  # 显示名模糊筛（子串、不分大小写）
-    mine: bool = False
-    category: str | None = None
-    tag: str | None = None
-    since: str | None = None  # UTC 串，闭区间；比 finished（结案时间），不比 created
-    until: str | None = None  # 同上
-    limit: int | None = None
-    months: int | None = None  # 最近 N 个自然月；与 since/until 互斥
-    count_only: bool = False  # 只要计数，不要 records
-
-
-COUNT_CAP = 10_000  # --count-only 的封顶：超过就 capped=True

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

@@ -1,220 +0,0 @@
-"""只读：查已结案（按结案时间过滤，倒序取最近）。不写任何字节、不依赖格式升级。
-
-时间区间一律落在**结案时间** `finished` 上 —— 历史文件本来就按结案月归档
-（`history/<结案年月>.md`），按创建时间过滤会漏掉「上月建、本月结」的记录。
-"""
-
-from __future__ import annotations
-
-from dataclasses import replace
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Any
-
-from ..core import history_md
-from ..core.identity import Identity, normalize
-from ..core.paths import HISTORY_DIR, month_of, to_repo_rel
-from ..core.time import now, time_key
-from ..errors import Fail
-from ..store.history_store import HistoryStore
-from ..store.owners_index import OwnersIndex
-from .guard import is_mine, require_uuid
-from .query import COUNT_CAP, HistoryQuery
-from .result import HistoryResult, rel
-
-#: 一次最多读多少个历史文件（按月分文件；不区分连续 / 分散，只数总数）。
-MAX_HISTORY_FILES = 13
-#: 没给任何时间参数时，默认只看最近几个自然月。
-DEFAULT_HISTORY_MONTHS = 3
-
-
-def _recent_month_keys(count: int) -> list[str]:
-    """最近 count 个自然月的月份键（含当月），按当前 UTC 推，从新到旧。"""
-    stamp = now()
-    year, month = int(stamp[0:4]), int(stamp[5:7])
-    keys: list[str] = []
-    for _ in range(max(count, 0)):
-        keys.append(f"{year:04d}{month:02d}")
-        month -= 1
-        if month == 0:
-            year, month = year - 1, 12
-    return keys
-
-
-def _shift_month(ym: str, delta: int) -> str:
-    """`YYYYMM` 偏移 delta 个月；越过年份边界自动进位 / 借位。"""
-    idx = int(ym[0:4]) * 12 + (int(ym[4:6]) - 1) + delta
-    return f"{idx // 12:04d}{idx % 12 + 1:02d}"
-
-
-def _month_keys_between(lo_ym: str, hi_ym: str) -> list[str]:
-    """`[lo_ym, hi_ym]` 闭区间内的月份键（升序）；两端给反了也能兜住。"""
-    if lo_ym > hi_ym:
-        lo_ym, hi_ym = hi_ym, lo_ym
-    keys: list[str] = []
-    cur = lo_ym
-    while cur <= hi_ym:
-        keys.append(cur)
-        cur = _shift_month(cur, 1)
-    return keys
-
-
-def _month_end(ym: str) -> str:
-    """`YYYYMM` 所在月的最后一秒（`YYYY-MM-DD HH:MM:SS`），用于把老平铺文件也框进区间。"""
-    year, month = int(ym[0:4]), int(ym[4:6])
-    nxt = datetime(year + (1 if month == 12 else 0), (month % 12) + 1, 1)
-    return (nxt - timedelta(seconds=1)).strftime("%Y-%m-%d %H:%M:%S")
-
-
-def _target_month_keys(q: HistoryQuery) -> list[str]:
-    """由时间参数算出「要读的月份键」；超过上限直接 Fail（不碰磁盘）。
-
-    - 无任何时间参数 ⇒ 最近 `DEFAULT_HISTORY_MONTHS` 个自然月；
-    - `--months N` ⇒ 最近 N 个自然月（与 `--since/--until` 互斥）；
-    - `--since/--until` ⇒ 结案月区间（只给一端时，另一端按默认口径补齐）。
-    """
-    if q.months is not None and (q.since or q.until):
-        raise Fail("--months 与 --since/--until 不能同时用（时间口径二选一）。")
-    if q.months is not None:
-        if q.months < 1:
-            raise Fail("--months 至少为 1。")
-        keys = _recent_month_keys(q.months)
-    elif q.since or q.until:
-        if q.since:
-            lo = month_of(q.since)
-        elif q.until:
-            # 只给 --until：往前补到默认窗口（与「默认近 3 月」一致）
-            lo = _shift_month(month_of(q.until), -(DEFAULT_HISTORY_MONTHS - 1))
-        else:  # pragma: no cover - 上面已保证至少给了一个
-            raise Fail("--since/--until 至少要给一个。")
-        hi = month_of(q.until) if q.until else month_of(now())
-        if not lo or not hi:
-            raise Fail("--since/--until 时间格式不对，算不出月份。")
-        keys = _month_keys_between(lo, hi)
-    else:
-        keys = _recent_month_keys(DEFAULT_HISTORY_MONTHS)
-    # 上限卡的是「要读的文件总数」，不是月跨度：按月分文件，一个键一个文件；
-    # 连不连续、将来把多段时间拼在一起也都只数总数。
-    files = sorted(set(keys))
-    if len(files) > MAX_HISTORY_FILES:
-        raise Fail(
-            f"历史查询一次最多读 {MAX_HISTORY_FILES} 个历史文件（按月分文件，不区分连续/分散），"
-            f"本次要读 {len(files)} 个 ⇒ 缩小 --since/--until 或 --months。"
-        )
-    return files
-
-
-def _candidate_paths(repo: Path, keys: list[str]) -> list[Path]:
-    """按月键【直接拼】`history/<年月>.md`（不扫磁盘）。"""
-    return [repo / to_repo_rel(HISTORY_DIR / f"{ym}.md") for ym in keys]
-
-
-def query_history(repo: Path, me: Identity, q: HistoryQuery) -> HistoryResult:
-    """`--owner` / `--mine` 一律按 **uuid 精确相等**；名字只能走 `--owner-name` 模糊筛。
-
-    `--since` / `--until` 比 `finished`（结案时间）。
-    """
-    if q.owner is not None:
-        if q.mine:
-            raise Fail("--owner 不能和 --mine 一起用：一次只按一种范围筛。")
-        q = replace(q, owner=require_uuid(q.owner, field="--owner"))
-    keys = _target_month_keys(q)
-    store = HistoryStore(repo)
-    records: list[dict[str, Any]] = []
-    warnings: list[str] = []
-    for path in _candidate_paths(repo, keys):
-        if not path.is_file():
-            continue  # 该月无记录 / 老平铺文件不存在 ⇒ 跳过，不报错
-        rows, warns = history_md.parse_history(store.read(path))
-        warnings.extend(f"{rel(repo, path)}：{w}" for w in warns)
-        for row in rows:
-            row = dict(row)
-            row["src"] = rel(repo, path)
-            row["created"] = time_key(row.get("created") or "") or row.get("created")
-            row["finished"] = time_key(row.get("finished") or "") or row.get("finished")
-            # 每行自带 `mine`（只比 uuid）：调用方不必自己拿 uuid 再比一次
-            row["mine"] = is_mine(row, me)
-            records.append(row)
-
-    index = OwnersIndex(repo)
-    roster = index.all()
-    if q.mine:
-        wanted = {normalize(me.uuid)}
-        records = [r for r in records if normalize(r.get("owner") or "") in wanted]
-    elif q.owner:
-        key = normalize(q.owner)
-        records = [r for r in records if normalize(r.get("owner") or "") == key]
-    if q.owner_name:
-        # 名字已经落在历史行里 ⇒ 直接比它（子串、不分大小写）。落的是**当时**那个名字，
-        # 改名后的旧行仍留旧名 ⇒ 按新名筛不到旧行，这是快照语义，不是漏。
-        # 老行（升级前落的）没有名字列，退回按 uuid 片段比，不至于一条都筛不出来。
-        needle = q.owner_name.strip().lower()
-        records = [
-            r
-            for r in records
-            if needle in str(r.get("owner_name") or "").lower()
-            or needle in normalize(r.get("owner") or "")
-        ]
-
-    # 名字**已经落盘**（`owner_name` / `creator_name` 两列）。这里只给没名字的**老行**
-    # 按名册兜底补一次 —— 补的是读时展示值，不回写文件。
-    for row in records:
-        for field, target in (("owner", "owner_name"), ("creator", "creator_name")):
-            if row.get(target):
-                continue
-            key = normalize(row.get(field) or "")
-            name = str((roster.get(key) or {}).get("name") or "")
-            if name:
-                row[target] = name
-    if q.category:
-        records = [r for r in records if (r.get("category") or "") == q.category]
-    if q.tag:
-        records = [r for r in records if q.tag in (r.get("tags") or ())]
-
-    # 有效结案区间：显式 --since/--until 优先（精确到秒），缺的一端用月份窗口补，
-    # 这样老平铺文件里的行也会被同一条规则框住，不会在月份查询里「漏网」。
-    lo_key, hi_key = min(keys), max(keys)
-    eff_since = q.since or f"{lo_key[0:4]}-{lo_key[4:6]}-01 00:00:00"
-    eff_until = q.until or _month_end(hi_key)
-    if eff_since > eff_until:
-        raise Fail(
-            f"时间区间反了：--since（{eff_since}）晚于 --until（{eff_until}）。\n"
-            "  处理：把两端换过来；只给一端就只给一端。"
-        )
-    records = [r for r in records if (r.get("finished") or "") >= eff_since]
-    records = [r for r in records if (r.get("finished") or "") <= eff_until]
-
-    records.sort(key=lambda r: str(r.get("finished") or ""), reverse=True)
-    if q.count_only and q.limit is not None:
-        raise Fail("--count-only 与 --limit 不能同时用：计数不截断，列表才截断。")
-    limit: int | None = None
-    if q.limit is not None:
-        limit = int(q.limit)
-        if limit < 1:
-            raise Fail(f"--limit 必须 ≥ 1（收到 {limit}）。")
-    capped = False
-    if q.count_only and len(records) > COUNT_CAP:
-        capped = True
-        records = records[:COUNT_CAP]
-    elif limit is not None:
-        capped = len(records) > limit  # 截断了要让调用方知道「还有更多」
-        records = records[:limit]
-
-    filters = {
-        "owner": q.owner,
-        "owner_name": q.owner_name,
-        "mine": q.mine,
-        "category": q.category,
-        "tag": q.tag,
-        "since": q.since,
-        "until": q.until,
-        "limit": q.limit,
-        "months": q.months,
-    }
-    return HistoryResult(
-        count=len(records),
-        filters=filters,
-        records=tuple(records),
-        warnings=tuple(warnings),
-        capped=capped,
-    )

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

@@ -1,82 +0,0 @@
-"""动作名册：命令写法 → `ActionSpec`。只有 `shell/cli.py` 与 `shell/runner.py` 会 import 它。
-
-**渲染函数只存名字**，不 import `shell/render.py` —— 否则 actions → shell 的依赖就反了；
-由 runner 用 `getattr(render, spec.render)` 取到函数。
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-
-from ..errors import Fail
-from . import (
-    bootstrap,
-    claim,
-    close_task,
-    list_tasks,
-    log_progress,
-    new_task,
-    query_history,
-    set_task,
-    show_task,
-    validate,
-)
-
-
-@dataclass(frozen=True)
-class ActionSpec:
-    func: Callable  # (repo, me, **params) -> Result | 视图对象
-    render: str  # 渲染函数**名**；runner 用 getattr 取
-    readonly: bool = False
-    lock_action: str = ""  # 交给 lock_scope 的动作名；默认同命令名
-    params: tuple[str, ...] = field(default=())  # 从参数里挑哪些键传给 func
-
-
-ACTIONS: dict[str, ActionSpec] = {
-    "new": ActionSpec(
-        new_task.new_task,
-        "result",
-        params=("title", "tid", "created", "category", "tags", "mine"),
-    ),
-    "claim": ActionSpec(claim.claim, "result", params=("tid",)),
-    "set": ActionSpec(
-        set_task.set_task,
-        "result",
-        params=("tid", "owner", "release", "tags"),
-        lock_action="set",
-    ),
-    "log": ActionSpec(log_progress.log_progress, "result", params=("tid", "note")),
-    "close": ActionSpec(
-        close_task.close_task,
-        "result",
-        params=("tid", "summary", "finished", "tags"),
-    ),
-    "list": ActionSpec(
-        list_tasks.list_tasks, "list_view", readonly=True, params=("q",)
-    ),
-    "show": ActionSpec(
-        show_task.show_task, "show_view", readonly=True, params=("tid",)
-    ),
-    "history": ActionSpec(
-        query_history.query_history, "history_view", readonly=True, params=("q",)
-    ),
-    "validate": ActionSpec(
-        validate.validate, "validate_view", readonly=True, params=("deep",)
-    ),
-}
-
-READONLY = tuple(name for name, spec in ACTIONS.items() if spec.readonly)
-
-
-def spec_of(command: str) -> ActionSpec:
-    """按命令写法取名册项；不在名册里就是用法错（业务错，退 1 人话）。"""
-    spec = ACTIONS.get(command)
-    if spec is None:
-        raise Fail(f"未知命令：{command}")
-    return spec
-
-
-def bootstrap_func():
-    """自举不是名册里的命令（runner 单独调），这里只给它的入口，避免 shell 直接 import 动作。"""
-    return bootstrap.bootstrap

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

@@ -1,89 +0,0 @@
-"""改标签：分片 `tags` + 过程文档头部标签行，一次写两处。
-
-**分类不可改**（2026-10-27 用户拍板）：它在 `new` 时定死，之后没有任何入口能改 —
-不进过程文档、不进 `set` / `close` 参数；历史行里那个值就是建任务时那个值。
-
-只动「标签」这一件事，不碰归属与状态 —— 归属走 `--owner` / `--release`，
-状态只随命令语义变。已结案的任务不在任何分片里，改不了（历史行是快照）。
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..core.identity import Identity
-from ..core.labels import 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 relabel(
-    repo: Path,
-    me: Identity,
-    tid: str,
-    *,
-    tags: str | tuple[str, ...] | None = None,
-) -> Result:
-    """写序：算最终值 → 过程文档（标签行 + 执行记录 + 状态行，一次写）→ 分片。
-
-    `tags` 收字符串（顿号 / 逗号分隔）或已切好的元组 —— 外壳可能已经切过一遍。
-    """
-    new_tags = parse_tags(tags) if tags else None
-    if new_tags is None:
-        raise Fail("改标签要给 `--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_tags: list[str] = [str(tag) for tag in new_tags]
-    if not final_tags:
-        raise Fail("标签是空的，没有可写的值。")
-
-    when = now()
-    updated = dict(task)
-    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=("tags", "updated"),
-            where=rel(repo, mine.path),
-            message=f"{tid}：改标签",
-            notices=("提示：这条任务没有过程文档，只改了分片，文档与历史里看不到。",),
-        )
-
-    text = logs.read(path)
-    note = "改标签：" + "、".join(final_tags)
-    text = rewrite_label_line(text, 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=("tags", "updated"),
-        where=rel(repo, mine.path),
-        message=f"{tid}：改标签",
-    )

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

@@ -1,76 +0,0 @@
-"""释放：写回公共池，再删我分片那行，再记一笔。"""
-
-from __future__ import annotations
-
-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 StatusLine, exec_line
-from ..errors import Fail
-from ..store.task_store import TaskStore
-from ..store.worklog_store import WorklogStore
-from .guard import owner_of, require_owner, status_of
-from .result import Result, rel
-
-
-def release(repo: Path, me: Identity, tid: str) -> Result:
-    """写序：写回池（已有同号就不覆盖）→ 删我分片那行 → 过程文档记一笔。"""
-    pool = TaskStore(repo, POOL_REL)
-    mine = TaskStore(repo, shard_rel(me.uuid), identity=me)
-    task = mine.get(tid)  # 锁内重读
-    if task is None:
-        in_pool = pool.get(tid)
-        if in_pool is not None:
-            # 幂等分支也要验「池里那条真的已经是没人要的开放任务」，
-            # 否则池里混进带 owner 的脏行时，release 会报「无需重复释放」而任务实际仍被占
-            if owner_of(in_pool) or status_of(in_pool) != "open":
-                raise Fail(
-                    f"任务 {tid} 在公共池里，但身上还挂着 owner / 不是 open —— 台账脏了。\n"
-                    "  处理：跑 validate 看清单，别用 release 强行覆盖。"
-                )
-            return Result(
-                already_done=True,
-                where=rel(repo, pool.path),
-                notices=(f"任务 {tid} 已经在公共池里，无需重复释放。",),
-            )
-        raise Fail(f"任务 {tid} 不在我的分片里，也没在公共池里。")
-
-    # 分片里在、但行内 owner 不是我 ⇒ 台账脏了（validate ⑤）：不许把别人的行推进池
-    require_owner(task, tid, me)
-
-    back = dict(task)
-    back["owner"] = None
-    back["owner_name"] = None  # 冗余显示名跟着 owner 一起清，否则池里那条仍显示原负责人
-    back["status"] = "open"
-    back["updated"] = now()
-    if pool.get(tid) is None:
-        pool.put(tid, back)
-    else:
-        # 池里已有同号：那份必须是干净的空位，否则不写回（它的 owner/owner_name 会被旧值带脏）
-        existing = pool.get(tid) or {}
-        if owner_of(existing) or status_of(existing) != "open":
-            raise Fail(
-                f"公共池里已经有一条 {tid}，且它带着 owner / 不是 open —— 台账脏了。\n"
-                "  处理：跑 validate 看清单，先确认哪条是真的。"
-            )
-    mine.drop(tid)
-
-    logs = WorklogStore(repo)
-    path = logs.find(tid, back.get("worklog"))
-    note = None
-    if path is None:
-        note = f"任务 {tid} 已退回公共池，但过程文档没找到，跳过执行记录。"
-    else:
-        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),
-        message=f"释放 {tid}：{back.get('title') or ''}".strip(),
-        notices=(note,) if note else (),
-    )