dsh-task-ledger 0.0.101 → 0.0.103

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

@@ -1,90 +0,0 @@
-"""动作的返回值长什么样。字段名是**公开契约**，插件看板直接读，外壳不许重新算。
-
-写动作返回 `Result`，只读动作返回各自的视图对象（不再套一层统一的壳）。
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-
-
-def rel(repo: Path, path: Path) -> str:
-    """绝对路径 → 相对 repo 的字符串（输出给人 / 给界面的一律这个基准）。"""
-    try:
-        return str(Path(path).resolve().relative_to(Path(repo).resolve()))
-    except ValueError:
-        return str(path)
-
-
-@dataclass(frozen=True)
-class WorklogView:
-    """「这条任务的过程文档要怎么显示」。"""
-
-    path: str | None = None  # 相对 repo
-    text: str | None = None  # 全文；读不到时为 None
-    error: str | None = None  # 读不到的原因（缺失 / 读不了），给人看
-
-
-@dataclass(frozen=True)
-class Result:
-    """写动作的返回。"""
-
-    changed: tuple[str, ...] = ()  # 改了哪些**字段名**（不是文件名、不是任务号）
-    where: str | None = None  # 主要落在哪个文件（**相对 repo**）
-    already_done: bool = False  # 重跑发现已经做过 ⇒ 退出码仍是 0
-    message: str | None = None  # git 提交说明；None ⇒ 外壳用默认模板
-    worklog: WorklogView | None = None
-    payload: dict[str, Any] = field(default_factory=dict)
-    notices: tuple[str, ...] = ()
-
-
-@dataclass(frozen=True)
-class TaskRow:
-    """人话表格的一行（9 字段投影）。`--json` 吐的是 `rows`（原样任务对象），不是它。"""
-
-    tid: str
-    title: str
-    status: str
-    owner: str | None = None  # 显示名
-    created: str | None = None
-    started: str | None = None
-    category: str | None = None
-    tags: tuple[str, ...] = ()
-    where: str | None = None  # 所在文件（相对 repo）
-
-
-@dataclass(frozen=True)
-class ListResult:
-    rows: dict[str, dict[str, Any]] = field(default_factory=dict)  # tid → 原样任务对象
-    table: tuple[TaskRow, ...] = ()
-    notices: tuple[str, ...] = ()
-
-
-@dataclass(frozen=True)
-class ShowResult:
-    task: dict[str, Any] = field(default_factory=dict)
-    worklog: WorklogView | None = None
-    others: tuple[str, ...] = ()  # 同一个任务号还出现在哪些文件里
-    #: 字段是从**在办索引**读来的（老文档没有状态行 / 文档丢了），不是文档自述
-    legacy: bool = False
-    notices: tuple[str, ...] = ()
-
-
-@dataclass(frozen=True)
-class HistoryResult:
-    count: int = 0
-    filters: dict[str, Any] = field(default_factory=dict)  # 回显生效的筛选
-    records: tuple[dict[str, Any], ...] = ()
-    warnings: tuple[str, ...] = ()
-    capped: bool = False
-
-
-@dataclass(frozen=True)
-class ValidationReport:
-    problems: tuple[str, ...] = ()  # 只有它影响退出码
-    notices: tuple[str, ...] = ()  # 只提示，不改退出码
-    checked_files: int = 0
-    total_tasks: int = 0
-    deep: bool = False  # 本次是深度检查（--deep）还是默认浅度

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

@@ -1,71 +0,0 @@
-"""改归属 / 改标签的入口：决定走哪个动作，**自己不加锁、不改任何文件**。
-
-它是全树唯一的跨动作引用点（import `release` / `handoff` / `claim` / `relabel`）。
-
-任务状态只随命令语义变（认领 → 进行中、释放 → 待认领、结案 → 历史），
-**没有单独的「改状态」入口**：`--status` 于 2026-10-23 删除 —— 全仓没有任何
-产品调用方（看板只有 claim / release / close 三个写路由），且它能制造
-:「归我名下、状态却还是待认领」的坏状态（看板上显示成没人认领）。
-
-**也没有改分类的入口**（2026-10-27 删除 `--category`）：分类在 `new` 时定死，
-之后谁都改不了；标题与创建时间同理，建完即不可变。`--tags` 仍可随时改。
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..core.identity import Identity, is_me
-from ..core.paths import shard_rel
-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 = "--tags 与 --release / --owner 不能同给：一个改标签，一个改归属。"
-
-
-def set_task(
-    repo: Path,
-    me: Identity,
-    tid: str,
-    *,
-    owner: str | None = None,
-    release: bool = False,
-    tags: str | tuple[str, ...] | None = None,
-) -> Result:
-    """路由：`--release` = 释放；别人的 uuid = 交接；自己的 uuid = 已认领则空转、没认领先认领；
-    `--tags` = 改标签（写分片 + 过程文档头部标签行）。
-    """
-    if release:
-        if owner is not None:
-            raise Fail("--release 与 --owner 不能同时给：释放不带人，交接不带释放。")
-        if tags:
-            raise Fail(_MIXED)
-        return release_mod.release(repo, me, tid)
-    if owner is not None:
-        if tags:
-            raise Fail(_MIXED)
-    else:
-        if tags:
-            return relabel_mod.relabel(repo, me, tid, tags=tags)
-        raise Fail(
-            "set 必须给一样：`--release`（释放回公共池）/ `--owner <对方 uuid>`（交接）/ "
-            "`--tags <a、b>`（改标签）。"
-        )
-    # 交接目标只收 uuid：名字查不到就当场报错，绝不去猜「他大概是这个人」
-    target = require_uuid(owner, field="--owner")
-    if not is_me(me, target):
-        return handoff_mod.handoff(repo, me, tid, to=target)
-    mine = TaskStore(repo, shard_rel(me.uuid), identity=me)
-    if mine.get(tid) is not None:
-        return Result(
-            already_done=True,
-            where=rel(repo, mine.path),
-            notices=(f"任务 {tid} 已经在你名下，无需操作。",),
-        )
-    return claim_mod.claim(repo, me, tid)

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

@@ -1,55 +0,0 @@
-"""只读：看一条任务。**文档优先**——读到文档就知道状态，不再翻索引（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
-from .result import ShowResult, WorklogView, rel
-
-
-def show_task(repo: Path, me: Identity, tid: str) -> ShowResult:
-    logs = WorklogStore(repo)
-    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=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,189 +0,0 @@
-"""只读：台账体检。两档：默认浅度只查格式，`--deep` 才读全部历史。
-
-浅度（默认）：池 + 各分片的字段格式、索引与文件对不对得上、**当月**历史。
-深度（`--deep`）：历史不止当月（全部月份）。
-
-**两档都不读过程文档正文**（2026-10-27 用户拍板）：过程文档是附件、存量可以上万篇，
-逐篇读全文换不来体检结论，只白花时间；文档自身的格式与内容不在体检范围。
-
-只查格式，不查业务（该谁结案、逾期与否都不管）；也不查「同一任务号落在多个文件」——
-读侧只显示一次（`list` / `show` 都不重复）、写侧已有防护，撞上了不关体检的事（2026-10-24 用户拍板）。
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..core import history_md
-from ..core.identity import Identity
-from ..core.labels import STATUSES
-from ..core.paths import (
-    LEDGER_DIR,
-    OWNERS_REL,
-    POOL_REL,
-    to_repo_rel,
-)
-from ..core.time import now
-from ..store.history_store import HistoryStore
-from ..store.owners_index import OwnersIndex
-from ..store.task_store import TaskStore
-from .guard import owner_of, status_of
-from .result import ValidationReport, rel
-
-
-def _read_tasks(repo: Path, store: TaskStore, problems: list[str]) -> dict:
-    """读一个任务文件；撞上**程序自留**的冲突标记 ⇒ 记一条 problem 继续。
-
-    推送被拒后 rebase 给 JSON 留的 `<<<<<<<` 是程序自己产的坏数据，validate
-    要能指出来（退 1 给清单），而不是整条命令退 3（2026-10-24 修）。
-    其余读错误（用户手改坏）不在此列，照旧抛出。
-    """
-    try:
-        return store.all()
-    except ValueError:
-        text = store.path.read_text(encoding="utf-8", errors="replace")
-        if "<<<<<<<" in text:
-            problems.append(
-                f"{rel(repo, store.path)} 带着冲突标记"
-                "（推送被拒后 rebase 没解完）：先解决冲突，再跑 validate。"
-            )
-            return {}
-        raise
-
-
-def _check_task_files(
-    repo: Path, index: OwnersIndex, problems: list[str]
-) -> tuple[int, int]:
-    """池 + 各分片的字段格式（owner / status / 分片归属）；返回 (查了几个文件, 几条任务)。"""
-    checked = 0
-    total = 0
-
-    pool = TaskStore(repo, POOL_REL)
-    if pool.path.exists():
-        checked += 1
-        for tid, task in _read_tasks(repo, pool, problems).items():
-            total += 1
-            if owner_of(task):
-                problems.append(
-                    f"公共池里的 {tid} 带着 owner（池里的行必须无人认领）。"
-                )
-            if task.get("status") not in STATUSES:
-                problems.append(f"公共池里的 {tid} 状态 {task.get('status')!r} 非法。")
-
-    for key, path in index.shards().items():
-        if not path.exists():
-            problems.append(f"索引登记了 {key}，但分片文件 {path.name} 不存在。")
-            continue
-        checked += 1
-        store = TaskStore(repo, Path(path).relative_to(repo / "ledger"))
-        for tid, task in _read_tasks(repo, store, problems).items():
-            total += 1
-            owner = owner_of(task)
-            if not owner:
-                problems.append(f"分片 {key} 里的 {tid} 没有 owner。")
-            elif owner != key:
-                problems.append(
-                    f"分片 {key} 里的 {tid} 的 owner 是 {owner}（分片主人与分区键不一致）。"
-                )
-            status = status_of(task)
-            if status not in STATUSES:
-                problems.append(f"分片 {key} 里的 {tid} 状态 {status!r} 非法。")
-
-    return checked, total
-
-
-def _check_orphan_shards(index: OwnersIndex, problems: list[str]) -> None:
-    """目录里有、索引没登记的分片（全仓唯一扫目录的地方）。"""
-    registered = {p.name for p in index.shards().values()}
-    for path in index.disk_shards():
-        if path.name not in registered:
-            problems.append(
-                f"owners/ 里的 {path.name} 没有在索引里登记（对它人等于不存在）。"
-            )
-
-
-def _history_paths(store: HistoryStore, *, deep: bool) -> list[Path]:
-    """要读的历史文件：浅度只读当月那个月文件（存量平铺文件不读），深度读全部。"""
-    sources = store.sources()
-    if deep:
-        return sources
-    month = now()[0:4] + now()[5:7]
-    return [p for p in sources if store.month_key(p) == month]
-
-
-def _check_history(
-    repo: Path,
-    paths: list[Path],
-    open_docs: set[str],
-    store: HistoryStore,
-    notices: list[str],
-) -> int:
-    """历史文件的格式与对账：解析警告、行尾文档链接对得上在办任务没。"""
-    checked = 0
-    for path in paths:
-        checked += 1
-        rows, warns = history_md.parse_history(store.read(path))
-        notices.extend(f"{rel(repo, path)}：{w}" for w in warns)
-        for row in rows:
-            name = Path(row.get("worklog") or "").name
-            if name and name in open_docs:
-                notices.append(
-                    f"历史里有「{row.get('title') or name}」的结案行，"
-                    "但它还挂在在办台账里。"
-                )
-    return checked
-
-
-def validate(repo: Path, me: Identity, deep: bool = False) -> ValidationReport:
-    problems: list[str] = []
-    notices: list[str] = []
-    checked = 0
-    total = 0
-
-    index = OwnersIndex(repo)
-    history = HistoryStore(repo)
-
-    files, tasks = _check_task_files(repo, index, problems)
-    checked += files
-    total += tasks
-    _check_orphan_shards(index, problems)
-
-    checked += _check_history(
-        repo,
-        _history_paths(history, deep=deep),
-        _open_worklog_names(repo, index),
-        history,
-        notices,
-    )
-
-    if not (repo / to_repo_rel(OWNERS_REL)).exists():
-        notices.append("还没有 owners.json（索引）：跑一条写命令会自动建。")
-    stray = repo / LEDGER_DIR / LEDGER_DIR
-    if stray.is_dir():
-        problems.append(
-            f"{rel(repo, stray)} 是错位的台账目录（根被当成 ledger/ 时写出来的幻影）；"
-            "确认哪份是真台账后删掉多余的，命令一律带 --repo <工作区根>。"
-        )
-
-    return ValidationReport(
-        problems=tuple(problems),
-        notices=tuple(notices),
-        checked_files=checked,
-        total_tasks=total,
-        deep=deep,
-    )
-
-
-def _open_worklog_names(repo: Path, index: OwnersIndex) -> set[str]:
-    """在办任务的过程文档**文件名**集合（池 + 全部分片）：历史行按它对账。"""
-    stores = [TaskStore(repo, POOL_REL)]
-    for path in index.shards().values():
-        if path.exists():
-            stores.append(TaskStore(repo, Path(path).relative_to(repo / "ledger")))
-    out: set[str] = set()
-    for store in stores:
-        for task in store.all().values():
-            name = Path((task.get("worklog") or "").strip()).name
-            if name:
-                out.add(name)
-    return out

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

@@ -1,152 +0,0 @@
-"""历史表格的文本操作：拼十一列一行、解析十一列一行。
-
-**只认十一列这一种格式**：存量九列的文件按 `docs/history-creator-upgrade.md`
-那份手册一次性升级，脚本不做运行时迁移。
-"""
-
-from __future__ import annotations
-
-import re
-from collections.abc import Iterable
-from typing import Any
-
-from .paths import to_history_rel
-from .time import TIME_RE, time_key
-
-HISTORY_TITLE = "# 进度历史（已结案）"
-HISTORY_HEADER = (
-    "| 结案时间 | 创建时间 | 标题 | 分类 | 标签 "
-    "| owner | owner_name | creator | creator_name | 完成了什么 | 过程文档 |"
-)
-HISTORY_SEP = "|---|---|---|---|---|---|---|---|---|---|---|"
-
-_LINK_RE = re.compile(r"\[[^\]]*\]\(([^)]*)\)")
-_TAG_SPLIT_RE = re.compile(r"[,，、]")
-
-Row = dict[str, Any]  # 一条历史行：见 parse_history 的返回
-
-
-def esc_cell(text: str) -> str:
-    """表格单元格：折叠空白并转义竖线，避免把历史表格写坏。"""
-    return " ".join((text or "").split()).replace("|", "\\|")
-
-
-def owner_cell(owner: str | None) -> str:
-    """owner 列的值：裸 uuid，**不加 `@`**（`@` 只加在名字列；匹配一律用裸 uuid）。"""
-    return owner or ""
-
-
-def creator_cell(creator: str | None) -> str:
-    """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]:
-    """按 `|` 切表格行：转义竖线 `\\|` 不当分隔符，切完反转义、去首尾空单元。"""
-    cells = re.split(r"(?<!\\)\|", line.strip())
-    if cells and cells[0] == "":
-        cells = cells[1:]
-    if cells and cells[-1] == "":
-        cells = cells[:-1]
-    return [c.strip().replace("\\|", "|") for c in cells]
-
-
-def is_sep_row(cells: list[str]) -> bool:
-    return bool(cells) and all(re.fullmatch(r":?-+:?", c) for c in cells)
-
-
-def _looks_like_header(cells: list[str]) -> bool:
-    return bool(cells) and cells[0] in ("时间", "结案时间")
-
-
-def history_line(
-    finished: str,
-    created: str | None,
-    title: str,
-    owner: str | None,
-    summary: str,
-    worklog: str | None,
-    category: str | None = None,
-    tags: Iterable[str] | None = None,
-    creator: str | None = None,
-    owner_name: str | None = None,
-    creator_name: str | None = None,
-) -> str:
-    """十一列的一行。`worklog` 收**相对 `ledger/`** 的路径，这里负责换成相对 `history/` 的链接。
-
-    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 "")
-    link = f"[{log_rel}]({log_rel})" if log_rel else ""
-    return (
-        f"| {finished} | {created or ''} | {esc_cell(title)} "
-        f"| {esc_cell(category or '')} | {tag_cell} "
-        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"
-    )
-
-
-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）；两个名字列剥掉展示用的 `@`（落盘快照，可能为空）。
-    """
-    records: list[Row] = []
-    warnings: list[str] = []
-    for lineno, raw in enumerate(text.splitlines(), 1):
-        if not raw.strip().startswith("|"):
-            continue
-        cells = split_row(raw)
-        if not cells or is_sep_row(cells) or _looks_like_header(cells):
-            continue
-        if len(cells) != 11:
-            warnings.append(f"第 {lineno} 行不是十一列（历史表只认十一列），已跳过")
-            continue
-        (
-            finished,
-            created,
-            title,
-            category,
-            tag_cell,
-            owner,
-            owner_name,
-            creator,
-            creator_name,
-            summary,
-            doc,
-        ) = cells
-        if not TIME_RE.fullmatch(finished):
-            warnings.append(f"第 {lineno} 行时间列 {finished!r} 不合法，已跳过")
-            continue
-        m = _LINK_RE.fullmatch(doc.strip())
-        records.append(
-            {
-                "finished": finished,
-                "created": time_key(created) if created else None,
-                "title": title,
-                "category": category.strip() or None,
-                "tags": tuple(
-                    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().removeprefix("@") or None,
-                "creator": creator.strip().removeprefix("@") 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",
-                "line": lineno,
-            }
-        )
-    return records, warnings

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

@@ -1,54 +0,0 @@
-"""身份这个值对象：uuid 是唯一键，name 只用于显示与查询筛选。
-
-**只做字符串换算，不读文件**（读身份归 env.py）。名字永远不参与归属判定：
-认领 / 释放 / 交接 / 查「我的」，一律只比 uuid。
-"""
-
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-
-#: 合法身份键的形态（8-4-4-4-12 的十六进制 UUID）。`--owner` 只收这种值。
-UUID_RE = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
-
-
-@dataclass(frozen=True)
-class Identity:
-    """一个人的身份。`uuid` 是唯一键，`name` 只用于显示。"""
-
-    uuid: str
-    name: str = ""
-
-    def label(self) -> str:
-        """显示名：没名字就用 uuid 前 8 位。只给人看（报错文案、界面）。"""
-        return self.name or self.uuid[:8]
-
-    def stamp(self) -> str:
-        """**落盘**用的身份串：`名字 · uuid` —— 名字在前给人读，uuid 在后给机器对。
-
-        与 `label()` 一样**不带 `@`**（`@` 由各落点自己加：头部各行拼 ` · @{stamp}`、
-        `exec_line` 拼 ` · @{who} · `）。
-
-        过程文档（创建行 / 状态行 / 封卷行 / 执行记录）是这个串唯一的落点：文件是最终产物，
-        创建人和封卷人可能不是同一个人、也可能中途改过名，所以**两个都要留**，不靠
-        历史表回链。没名字就只写 uuid。
-        """
-        if not self.name:
-            return self.uuid
-        return f"{self.name} · {self.uuid}"
-
-
-def normalize(who: str) -> str:
-    """归一化：去首尾空白 + 转小写。全仓只此一处。"""
-    return (who or "").strip().lower()
-
-
-def looks_like_uuid(who: str | None) -> bool:
-    """是不是一个 UUID 形态的身份键（名字、邮箱一律 False）。"""
-    return bool(UUID_RE.match(normalize(who or "")))
-
-
-def is_me(identity: Identity, who: str | None) -> bool:
-    """`who`（uuid）是不是这个人。全站只认 uuid 这一个身份键。"""
-    return normalize(who or "") == normalize(identity.uuid)

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

@@ -1,58 +0,0 @@
-"""任务号：生成、形态校验。只做字符串换算。"""
-
-from __future__ import annotations
-
-import re
-import secrets
-from collections.abc import Mapping
-
-from ..errors import Fail
-from .time import now
-
-ID_RE = re.compile(r"[a-z0-9\u4e00-\u9fff][a-z0-9\u4e00-\u9fff-]*\Z")
-
-
-def slugify(title: str) -> str:
-    """任务号用：保留 ASCII 字母数字与汉字，其余转连字符，截到 40 字。"""
-    s = re.sub(r"[^a-z0-9\u4e00-\u9fff]+", "-", title.strip().lower())
-    return s.strip("-")[:40].strip("-")
-
-
-def id_stamp(created: str) -> str:
-    """`created`（YYYY-MM-DD HH:MM:SS）→ 任务号前缀 `YYYYMMDD-HHMM`（任务号只到分）。"""
-    return (
-        f"{created[0:4]}{created[5:7]}{created[8:10]}-{created[11:13]}{created[14:16]}"
-    )
-
-
-def make_id(title: str, tasks: Mapping[str, object], created: str | None = None) -> str:
-    """按标题生成一个不撞号的任务号。
-
-    随机码不能省：`make_id` 只在**在办**任务里去重，而结案的过程文档长期留在磁盘上，
-    去掉随机码会让新任务撞上已结案文档的名字。
-    """
-    slug = slugify(title)
-    if not slug:
-        raise Fail(
-            "标题里没有可用字符（字母、数字或汉字），无法自动生成任务号。"
-            f'用 --id 指定一个，例如 --id "task-{secrets.token_hex(2)}"。'
-        )
-    stamp = id_stamp(created or now())
-    for _ in range(20):
-        tid = f"{stamp}-{slug}-{secrets.token_hex(2)}"
-        if tid not in tasks:
-            return tid
-    raise Fail("任务号连续冲突 20 次，请检查台账是否异常。")
-
-
-def require_task_id(tid: str) -> str:
-    """任务号形态校验（全仓唯一入口）。不合法直接抛 Fail。"""
-    value = (tid or "").strip()
-    if not value:
-        raise Fail("任务号不能为空。")
-    if not ID_RE.fullmatch(value.lower()):
-        raise Fail(
-            f"任务号 {tid!r} 不合法：只能用小写字母、数字、汉字和连字符，"
-            "且不能以连字符开头或结尾。"
-        )
-    return value