dkitchen 0.5.2__tar.gz → 0.5.4__tar.gz

{dkitchen-0.5.2/src/dkitchen.egg-info → dkitchen-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkitchen
-Version: 0.5.2
+Version: 0.5.4
 Summary: A multi-agent workflow for research repos, with the ding CLI for messaging and waking agent sessions
 Author: 917Dhj
 License-Expression: MIT

{dkitchen-0.5.2 → dkitchen-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dkitchen"
-version = "0.5.2"
+version = "0.5.4"
 description = "A multi-agent workflow for research repos, with the ding CLI for messaging and waking agent sessions"
 readme = "README.md"
 requires-python = ">=3.10"

{dkitchen-0.5.2 → dkitchen-0.5.4}/src/dkitchen/config.py

@@ -35,6 +35,11 @@ Every key is optional. The defaults match the English templates in kitchen/:
 
     [relay]
     superseding = "New decision; it replaces earlier relays not yet carried out."   # first line of a default relay
+
+    [rule]                               # `ding rule`: the designer's reply opens with the designer's signature,
+    type_label = "Type"                  # then a line `<type_label><separator><one of types>`
+    types = ["actionable", "proposal, awaiting user", "record"]
+    notify = "#{ticket} answered, see the ticket {url}"   # message `--notify` sends; also {first_line}
 """
 from __future__ import annotations
 
@@ -105,6 +110,13 @@ class Relay:
     superseding: str = "New decision; it replaces earlier relays not yet carried out."
 
 
+@dataclass(frozen=True)
+class Rule:
+    type_label: str = "Type"
+    types: tuple[str, ...] = ("actionable", "proposal, awaiting user", "record")
+    notify: str = "#{ticket} answered, see the ticket {url}"
+
+
 SESSION_FIELDS = ("issue", "name", "repo")
 
 
@@ -139,6 +151,7 @@ class Config:
     log: Log = Log()
     sessions: Sessions = Sessions()
     relay: Relay = Relay()
+    rule: Rule = Rule()
 
     def repository(self) -> str:
         """The configured repository, or the one gh sees from the repository root."""
@@ -162,10 +175,18 @@ def section(cls, values: object, name: str):
     result = cls()
     for key, value in values.items():
         default = getattr(result, key)
-        if key == "fields":
+        if key in {"fields", "types"}:
             if not isinstance(value, list) or not value or not all(isinstance(item, str) and item.strip() for item in value):
-                raise ValueError(f"{FILE}: [{name}] fields must be a nonempty list of field names")
+                raise ValueError(f"{FILE}: [{name}] {key} must be a nonempty list of "
+                                 f"{'field names' if key == 'fields' else 'words'}")
             value = tuple(item.strip() for item in value)
+        elif key == "notify":
+            if not isinstance(value, str) or "{url}" not in value:
+                raise ValueError(f"{FILE}: [rule] notify must be a string holding {{url}}")
+            try:
+                value.format(ticket=1, url="u", first_line="l")
+            except (ValueError, KeyError, IndexError) as exc:
+                raise ValueError(f"{FILE}: [rule] notify is not a valid template: {exc}") from exc
         elif key == "name" and cls is Sessions:
             value = session_template(value)
         elif key == "parent" and cls is Sessions:
@@ -200,7 +221,8 @@ def load(cwd: Path | None = None) -> Config:
         data = tomllib.loads(path.read_text(encoding="utf-8"))
     except tomllib.TOMLDecodeError as exc:
         raise ValueError(f"{path}: {exc}") from exc
-    sections = {"stations": Stations, "status": Status, "labels": Labels, "log": Log, "sessions": Sessions, "relay": Relay}
+    sections = {"stations": Stations, "status": Status, "labels": Labels, "log": Log, "sessions": Sessions, "relay": Relay,
+                "rule": Rule}
     unknown = sorted(set(data) - {"repo", *sections})
     if unknown:
         raise ValueError(f"{FILE}: unknown keys: {', '.join(unknown)}")

{dkitchen-0.5.2 → dkitchen-0.5.4}/src/dkitchen/ding.py

@@ -1705,9 +1705,45 @@ def main(argv=None) -> int:
     sub.add_argument("--stale-hours", type=float, default=6, help="Executor silence that counts as stale (default: 6)")
     sub.add_argument("--stale-every", type=float, default=3600, help="Seconds between stale checks (default: 3600)")
     sub.add_argument("--max-errors", type=int, default=10, help="Consecutive failed polls before exiting (default: 10)")
+    sub = commands.add_parser(
+        "rule", help="Post the designer's ruling on a ticket after checking it, and tell a session",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="Post a designer ruling as a ticket comment (or, with --edit-body, as the ticket's new body).\n"
+                    "Before anything is sent it checks that:\n"
+                    "  - the draft's line 1 starts with the designer's signature and line 2 with the type label\n"
+                    "    and one of the allowed types ([stations] and [rule] in .dkitchen.toml; comments only);\n"
+                    "  - `ding check-refs` finds no wrong reference in it;\n"
+                    "  - with --reply-to, no comment came after the one answered (--force posts anyway); without\n"
+                    "    it, the time and first line of the latest comment are shown as a hint;\n"
+                    "  - with --edit-body, the ticket body still equals the --base file.\n"
+                    "Then it posts with gh. stdout is only the URL gh returns; everything else goes to stderr.\n"
+                    "With --notify it then sends the [rule] notify message (default: '#N answered, see the ticket "
+                    "URL')\nplus the draft's first line. A failed notification is reported, and the comment stays.",
+        epilog="examples:\n"
+               "  ding rule 42 reply.md --reply-to https://github.com/o/r/issues/42#issuecomment-123 --notify '#42'\n"
+               "  gh api repos/o/r/issues/42 --jq .body > base.md   # take the baseline, edit a copy, then:\n"
+               "  ding rule 42 new-body.md --edit-body --base base.md\n"
+               "--notify reaches Codex sessions (via `ding send`: UUID, name, '#N', ticket URL). ding cannot "
+               "message\nClaude Code sessions; tell them with SendMessage after the URL is printed.")
+    sub.add_argument("ticket", type=int, help="Ticket number")
+    sub.add_argument("draft", help="Draft file (UTF-8): the comment, or with --edit-body the new ticket body")
+    sub.add_argument("--reply-to", help="Comment answered, as its link or id; stops when later comments exist")
+    sub.add_argument("--force", action="store_true", help="With --reply-to: post although later comments exist")
+    sub.add_argument("--notify", help="Codex session to tell, as for `ding send` (UUID, name, '#N', ticket URL)")
+    sub.add_argument("--edit-body", action="store_true", help="Replace the ticket body, not add a comment; needs --base")
+    sub.add_argument("--base", help="With --edit-body: file holding the body you started from; stops if the ticket's "
+                                    "body differs from it")
+    where = sub.add_mutually_exclusive_group()
+    where.add_argument("--ref", default="origin/main", help="check-refs: Git revision the references point into "
+                                                            "(default: origin/main)")
+    where.add_argument("--root", type=Path, help="check-refs: directory to read files from instead")
+    sub.add_argument("--tolerance", type=int, default=0, help="check-refs: lines around a reference that may hold its name")
+    sub.add_argument("--repo", help="Repository (default: repo in .dkitchen.toml, then the one gh sees)")
+    sub.add_argument("--offline", action="store_true", help="check-refs: do not ask GitHub")
     sub = commands.add_parser("check-refs", help="Check `file:line`, sha256, ticket, PR, and comment references "
                                                  "in a draft comment")
-    sub.add_argument("draft", help="Draft comment file")
+    sub.add_argument("draft", nargs="+", help="Draft comment file; several files are checked one by one and "
+                                              "the exit status is nonzero when any has a wrong reference")
     where = sub.add_mutually_exclusive_group()
     where.add_argument("--ref", default="origin/main", help="Git revision the references point into (default: origin/main)")
     where.add_argument("--root", type=Path, help="Directory to read files from instead, such as a worktree or output folder")
@@ -1731,6 +1767,15 @@ def main(argv=None) -> int:
         parser.error("--parent must be a positive issue number")
     if args.action == "merge" and args.ticket is not None and args.ticket <= 0:
         parser.error("--ticket must be a positive issue number")
+    if args.action == "rule":
+        if args.ticket <= 0:
+            parser.error("ticket must be a positive issue number")
+        if args.edit_body and (args.reply_to or args.force):
+            parser.error("--edit-body edits the ticket body; --reply-to and --force belong to comments")
+        if args.edit_body != (args.base is not None):
+            parser.error("--edit-body and --base go together")
+        if args.force and not args.reply_to:
+            parser.error("--force goes with --reply-to")
     if args.action in {"run", "launch"} and not command:
         parser.error(f"{args.action} requires a task command after --")
     try:
@@ -1751,6 +1796,9 @@ def main(argv=None) -> int:
                                                   settings.sessions.parent.format(parent=args.parent))
                 args.name = settings.sessions.session_name(issue=args.issue, name=args.name, repo=args.repo)
             return new_task(args)
+        if args.action == "rule":
+            from dkitchen import config, rule
+            return rule.rule(args, config.load())
         if args.action == "check-refs":
             from dkitchen import refs
             return refs.check_refs(args)

{dkitchen-0.5.2 → dkitchen-0.5.4}/src/dkitchen/refs.py

@@ -221,21 +221,36 @@ def default_repository() -> str | None:
         return None
 
 
-def check_refs(args) -> int:
-    github = None if getattr(args, "offline", False) else GitHub(getattr(args, "repo", None), default=default_repository)
+def report(path: str, args, source: Source, github: GitHub | None, many: bool, emit_json: bool = True) -> int:
+    """Check one draft and report it on stderr (and as a JSON line on stdout); 1 when something is wrong, 2 when
+    the draft cannot be read. With several drafts every line names its file."""
+    label = f"{path}: " if many else ""
     counts: dict[str, int] = {}
     try:
-        findings, notes, checked = check(Path(args.draft).read_text(encoding="utf-8"), Source(args.ref, args.root),
-                                         args.tolerance, github, counts)
+        findings, notes, checked = check(Path(path).read_text(encoding="utf-8"), source, args.tolerance, github, counts)
     except (OSError, subprocess.CalledProcessError) as error:
         print(f"ding: {error}", file=sys.stderr)
         return 2
     for line in findings:
-        print(f"wrong: {line}", file=sys.stderr)
+        print(f"wrong: {label}{line}", file=sys.stderr)
     for line in notes:
-        print(f"not checked: {line}", file=sys.stderr)
+        print(f"not checked: {label}{line}", file=sys.stderr)
     kinds = ", ".join(f"{counts[kind]} {kind}" for kind in KINDS if counts.get(kind)) or "none"
-    print(f"checked {checked} references ({kinds}): {len(findings)} wrong, {len(notes)} not checked", file=sys.stderr)
-    print(json.dumps({"checked": checked, "findings": len(findings), "unchecked": len(notes),
-                      "by_kind": counts, "wrong": findings, "not_checked": notes}, ensure_ascii=False))
+    print(f"{label}checked {checked} references ({kinds}): {len(findings)} wrong, {len(notes)} not checked", file=sys.stderr)
+    if emit_json:
+        print(json.dumps({**({"draft": path} if many else {}), "checked": checked, "findings": len(findings),
+                          "unchecked": len(notes), "by_kind": counts, "wrong": findings, "not_checked": notes},
+                         ensure_ascii=False))
     return int(bool(findings))
+
+
+def check_refs(args, emit_json: bool = True) -> int:
+    """Report each draft in turn; 0 when none has a wrong reference, 1 when one does, 2 when one cannot be read."""
+    drafts = [args.draft] if isinstance(args.draft, (str, Path)) else list(args.draft)
+    github = None if getattr(args, "offline", False) else GitHub(getattr(args, "repo", None), default=default_repository)
+    try:
+        source = Source(args.ref, args.root)
+    except OSError as error:
+        print(f"ding: {error}", file=sys.stderr)
+        return 2
+    return max(report(path, args, source, github, len(drafts) > 1, emit_json) for path in drafts)

dkitchen-0.5.4/src/dkitchen/rule.py

@@ -0,0 +1,189 @@
+"""Post the designer's ruling on a ticket: check the draft, guard against overwriting, post, and notify.
+
+Steps, each stopping the command before anything is sent when it fails:
+- the draft opens with the designer's signature and a type line (`[rule]` in .dkitchen.toml);
+- `ding check-refs` finds nothing wrong in it;
+- with --reply-to, no comment came after the one answered (--force posts anyway); without it, the latest
+  comment is shown as a hint;
+- with --edit-body, the ticket body still equals the baseline file (--base).
+Then it posts with gh and prints only the URL gh returns. A failed notification is reported but never undoes
+the comment.
+"""
+from __future__ import annotations
+
+import contextlib
+import difflib
+import json
+import re
+import sys
+from types import SimpleNamespace
+
+from dkitchen import ding, refs
+from dkitchen.config import Config
+from dkitchen.orchestrate import call, fail
+
+CLAUDE_ADDRESS = re.compile(r"^(?:uds|bridge|did):|^local_")
+COMMENT_URL = re.compile(r"^https://\S+#issuecomment-\d+$")
+COMMENT_ID = re.compile(r"(?:#issuecomment-)?(\d+)$")
+
+
+def first_line(text: str) -> str:
+    return next((line.strip() for line in text.splitlines() if line.strip()), "")[:100]
+
+
+def format_problem(draft: str, config: Config) -> str | None:
+    """Why the draft's first two lines are wrong, or None when they are right."""
+    stations, rule = config.stations, config.rule
+    lines = draft.split("\n")
+    signature = stations.signature(stations.designer)
+    if not lines[0].startswith(signature):
+        return f"line 1 must start with {signature!r}, not {lines[0][:40]!r}"
+    label = f"{rule.type_label}{stations.separator}"
+    if len(lines) < 2 or not lines[1].startswith(label):
+        return f"line 2 must start with {label!r}, not {(lines[1] if len(lines) > 1 else '')[:40]!r}"
+    kind = lines[1][len(label):].strip()
+    if kind not in rule.types:
+        return f"line 2 type {kind!r} must be one of: {', '.join(rule.types)}"
+    return None
+
+
+def comments_of(config: Config, repo: str, ticket: int) -> list[dict]:
+    result = call(config, "gh", "api", "--paginate", "--slurp", f"repos/{repo}/issues/{ticket}/comments?per_page=100")
+    if result.returncode:
+        raise RuntimeError(result.stderr.strip() or "cannot read the ticket's comments")
+    return [comment for page in json.loads(result.stdout) for comment in page]
+
+
+def comment_id(reply_to: str, repo: str, ticket: int) -> int:
+    """The id in a comment URL or a bare id; refuses a link to another ticket."""
+    if reply_to.startswith("http"):
+        link = refs.LINK.fullmatch(reply_to.strip())
+        if link is None or not link.group(4) or not link.group(4).startswith("issuecomment-"):
+            raise ValueError(f"--reply-to {reply_to!r} is not an issue comment link")
+        if (link.group(1), int(link.group(3))) != (repo, ticket):
+            raise ValueError(f"--reply-to {reply_to!r} is not on {repo}#{ticket}")
+    found = COMMENT_ID.search(reply_to.strip())
+    if found is None:
+        raise ValueError(f"--reply-to {reply_to!r} is neither a comment link nor a comment id")
+    return int(found.group(1))
+
+
+def guard_reply(config: Config, repo: str, ticket: int, args) -> int | None:
+    """Stop (1) when a comment came after the one answered; otherwise show what the ticket's last comment is."""
+    comments = comments_of(config, repo, ticket)
+    if args.reply_to is None:
+        if comments:
+            latest = comments[-1]
+            print(f"latest comment on #{ticket}: {latest['created_at']} {first_line(latest['body'])!r} "
+                  f"({latest['html_url']})", file=sys.stderr)
+        else:
+            print(f"#{ticket} has no comments yet", file=sys.stderr)
+        return None
+    target = comment_id(args.reply_to, repo, ticket)
+    ids = [comment["id"] for comment in comments]
+    if target not in ids:
+        raise ValueError(f"comment {target} is not among the comments of {repo}#{ticket}")
+    newer = comments[ids.index(target) + 1:]
+    if not newer:
+        return None
+    for comment in newer:
+        print(f"newer: {comment['html_url']} {first_line(comment['body'])!r}", file=sys.stderr)
+    if getattr(args, "force", False):
+        print(f"{len(newer)} newer comment(s) after the one answered; posting anyway (--force)", file=sys.stderr)
+        return None
+    return fail(f"{len(newer)} comment(s) came after the one you answer; read them, then rerun (--force posts anyway). "
+                "Nothing posted")
+
+
+def notify(config: Config, args, ticket: int, url: str, draft: str) -> int:
+    message = config.rule.notify.format(ticket=ticket, url=url, first_line=first_line(draft))
+    if "{first_line}" not in config.rule.notify:
+        message += "\n" + first_line(draft)
+    send = ["send", args.notify, "--from", config.stations.designer, "--message", message]
+    try:
+        with contextlib.redirect_stdout(sys.stderr):
+            code = ding.main(send)
+    except SystemExit as error:
+        code = error.code or 1
+    if code:
+        return fail(f"posted {url}, but the notification to {args.notify} failed (ding send exit {code}); "
+                    "the comment stays. Send the message by hand")
+    return 0
+
+
+def normal(text: str) -> str:
+    return text.replace("\r\n", "\n").rstrip("\r\n")
+
+
+def edit_body(config: Config, repo: str, ticket: int, args, draft: str) -> int:
+    """Replace the ticket body when it still equals the --base file, then check what was written back."""
+    path = f"repos/{repo}/issues/{ticket}"
+
+    def current() -> str:
+        result = call(config, "gh", "api", path, "--jq", ".body")
+        if result.returncode:
+            raise RuntimeError(result.stderr.strip() or f"cannot read {repo}#{ticket}")
+        return result.stdout[:-1] if result.stdout.endswith("\n") else result.stdout
+
+    body = current()
+    with open(args.base, encoding="utf-8") as handle:
+        base = handle.read()
+    if normal(body) != normal(base):
+        changes = [line for line in difflib.unified_diff(normal(base).split("\n"), normal(body).split("\n"),
+                                                         "--base", "ticket now", lineterm="", n=0)
+                   if line[:1] in "+-" and line[:3] not in {"+++", "---"}][:6]
+        print("\n".join(changes), file=sys.stderr)
+        return fail(f"the body of {repo}#{ticket} changed since {args.base}; merge the change into the draft and "
+                    "take a new baseline. Nothing edited")
+    result = call(config, "gh", "issue", "edit", str(ticket), "--repo", repo, "--body-file", args.draft)
+    if result.returncode:
+        return fail(f"edit failed: {result.stderr.strip()}")
+    url = result.stdout.strip()
+    if current().rstrip("\n").encode("utf-8") != draft.rstrip("\n").encode("utf-8"):
+        return fail(f"edited {url}, but the body read back differs from the draft; check the ticket before relying on it")
+    print(url)
+    return 0 if args.notify is None else notify(config, args, ticket, url, draft)
+
+
+def rule(args, config: Config) -> int:
+    ticket = args.ticket
+    if args.notify and CLAUDE_ADDRESS.search(args.notify):
+        return fail(f"--notify {args.notify}: ding cannot message a Claude Code session; use SendMessage for it. "
+                    "Nothing posted")
+    try:
+        with open(args.draft, encoding="utf-8") as handle:
+            draft = handle.read()
+    except (OSError, UnicodeDecodeError) as error:
+        return fail(str(error))
+    if not draft.strip():
+        return fail(f"{args.draft} is empty")
+    if not args.edit_body:
+        problem = format_problem(draft, config)
+        if problem:
+            return fail(f"{args.draft}: {problem}. Nothing posted")
+    try:
+        repo = args.repo or config.repository()
+        args.repo = repo
+        if refs.check_refs(_refs_args(args), emit_json=False):
+            return fail("check-refs found wrong or unreadable references; fix the draft. Nothing posted")
+        if args.edit_body:
+            return edit_body(config, repo, ticket, args, draft)
+        stop = guard_reply(config, repo, ticket, args)
+        if stop is not None:
+            return stop
+        result = call(config, "gh", "issue", "comment", str(ticket), "--repo", repo, "--body-file", args.draft)
+    except (RuntimeError, ValueError, OSError, KeyError, TypeError) as error:
+        return fail(f"{error}. Nothing posted")
+    url = result.stdout.strip()
+    if result.returncode:
+        return fail(f"comment failed: {result.stderr.strip()}")
+    if not COMMENT_URL.match(url):
+        return fail(f"gh did not print a comment link (got {url!r}); look at the ticket before posting again")
+    print(url)
+    return 0 if args.notify is None else notify(config, args, ticket, url, draft)
+
+
+def _refs_args(args):
+    """What `check_refs` reads from the options `rule` shares with `check-refs`."""
+    return SimpleNamespace(draft=[args.draft], ref=args.ref, root=args.root, tolerance=args.tolerance,
+                           repo=args.repo, offline=args.offline)

{dkitchen-0.5.2 → dkitchen-0.5.4}/src/dkitchen/watch.py

@@ -63,7 +63,8 @@ def issue_number(url: str) -> int:
 
 def role(body: str, config: Config) -> str:
     """The station named at the start of the first line; otherwise the executor by a line starting with its
-    session signature; else the user. A session signature quoted inside a line signs nothing."""
+    session signature (`Codex session:`, or `Claude session:` for an executor run in Claude Code); else the user.
+    A session signature quoted inside a line signs nothing."""
     stations = config.stations
     first = next((line for line in body.splitlines() if line.strip()), "")
     first = re.sub(r"^[\s#*>]+", "", first)
@@ -71,7 +72,7 @@ def role(body: str, config: Config) -> str:
                    if first.startswith(name)), None)
     if signed:
         return signed
-    return stations.executor if re.search(r"(?m)^[ \t]*Codex session:", body) else stations.user
+    return stations.executor if re.search(r"(?m)^[ \t]*(?:Codex|Claude) session:", body) else stations.user
 
 
 def fields(body: str, config: Config) -> dict[str, str]:

{dkitchen-0.5.2 → dkitchen-0.5.4/src/dkitchen.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkitchen
-Version: 0.5.2
+Version: 0.5.4
 Summary: A multi-agent workflow for research repos, with the ding CLI for messaging and waking agent sessions
 Author: 917Dhj
 License-Expression: MIT

{dkitchen-0.5.2 → dkitchen-0.5.4}/src/dkitchen.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/dkitchen/config.py
 src/dkitchen/ding.py
 src/dkitchen/orchestrate.py
 src/dkitchen/refs.py
+src/dkitchen/rule.py
 src/dkitchen/watch.py
 src/dkitchen.egg-info/PKG-INFO
 src/dkitchen.egg-info/SOURCES.txt

{dkitchen-0.5.2 → dkitchen-0.5.4}/tests/test_kitchen.py

@@ -7,7 +7,7 @@ from types import SimpleNamespace
 
 import pytest
 
-from dkitchen import config, ding, orchestrate, refs, watch
+from dkitchen import config, ding, orchestrate, refs, rule, watch
 
 
 CHINESE = """
@@ -246,6 +246,22 @@ def test_merge_finds_the_one_ticket_with_executor_comments(tmp_path, monkeypatch
         f"repos/o/r/issues/{number}/comments?per_page=100" for number in tickets]
 
 
+CLAUDE = "Claude session: ToM agent person experience record implementation"
+
+
+@pytest.mark.parametrize("bodies, code", [
+    ((f"状态：进行中\n在等：总编排审合PR7\n关键数字：1\n下一步：合入后冒烟\n{CLAUDE}",), 0),
+    ((WAITING, f"状态：进行中\n在等：无\n关键数字：1\n下一步：还在改PR7\n{CLAUDE}"), 1),
+    ((f"状态：完成\n在等：无\n关键数字：1\n下一步：交给执行者\n{CLAUDE}", WAITING), 0),
+])
+def test_merge_reads_claude_and_codex_executors_by_the_latest_comment(tmp_path, monkeypatch, capsys, bodies, code):
+    loaded = settings(tmp_path, CHINESE)
+    responses = [view(), thread_comments("总设计：答复", *bodies)] + ([(0, ""), view("MERGED")] if code == 0 else [])
+    monkeypatch.setattr(orchestrate, "call", fake_call(responses, []))
+    assert orchestrate.merge(SimpleNamespace(pr=7, sha="abc", ticket=1020, no_ticket=False), loaded) == code
+    assert f"#1020 latest executor status (https://c/{len(bodies)}):" in capsys.readouterr().out
+
+
 def test_merge_refuses_a_ticket_without_executor_comments(tmp_path, monkeypatch, capsys):
     loaded = settings(tmp_path, CHINESE)
     monkeypatch.setattr(orchestrate, "call", fake_call([view(), thread_comments("总设计：答复")], []))
@@ -468,4 +484,238 @@ def test_a_quoted_session_signature_signs_nothing(tmp_path, text):
                 "| request body | ok: it starts with the status block and contains `Codex session:` |\n")
     assert watch.role(verifier, loaded) == stations.verifier
     assert watch.role("I checked it; the body has `Codex session:` in it.", loaded) == stations.user
+    assert watch.role("Quoting `Claude session:` signs nothing.", loaded) == stations.user
+    assert watch.role("Status: done\nWaiting on: none\n\nClaude session: impl", loaded) == stations.executor
     assert watch.role(executor("Status: done\nWaiting on: none\nKey numbers: 1\nNext: merge"), loaded) == stations.executor
+
+
+RULING = CHINESE + """
+[rule]
+type_label = "类型"
+types = ["可执行", "方案，等用户", "记录"]
+notify = "#{ticket} 已答复，见票 {url}"
+"""
+REPLY = "总设计：结论\n类型：可执行\n\n正文 见 `pkg/work.py:9` holds `Ledger`\n"
+URL = "https://github.com/o/r/issues/42#issuecomment-900"
+
+
+def comment_pages(*bodies):
+    return 0, json.dumps([[{"id": 100 + index, "body": body, "created_at": f"2026-10-28T0{index}:00:00Z",
+                            "html_url": f"https://github.com/o/r/issues/42#issuecomment-{100 + index}"}
+                           for index, body in enumerate(bodies)]])
+
+
+@pytest.fixture
+def ruling(tree, tmp_path, monkeypatch):
+    """`ding rule` run offline in a Chinese-vocabulary repo whose gh and ding send are doubles."""
+    (tmp_path / config.FILE).write_text(RULING, encoding="utf-8")
+    monkeypatch.chdir(tmp_path)
+    state = SimpleNamespace(calls=[], sends=[], send_code=0, draft=tmp_path / "draft.md")
+    state.draft.write_text(REPLY, encoding="utf-8")
+
+    def run(responses, *options, text=None):
+        if text is not None:
+            state.draft.write_text(text, encoding="utf-8")
+        monkeypatch.setattr(rule, "call", fake_call(list(responses), state.calls))
+        return real_main(["rule", "42", str(state.draft), "--root", str(tree), "--offline", *options])
+
+    real_main = ding.main
+
+    def main(argv):
+        if argv[0] != "send":
+            return real_main(argv)
+        state.sends.append(argv)
+        print("started")
+        return state.send_code
+
+    monkeypatch.setattr(ding, "main", main)
+
+    state.run = run
+    return state
+
+
+def test_rule_posts_and_prints_only_the_url(ruling, capsys):
+    assert ruling.run([comment_pages("用户：请裁定", "核查：通过"), (0, URL + "\n")], "--reply-to", "101") == 0
+    captured = capsys.readouterr()
+    assert captured.out == URL + "\n"
+    assert "latest comment" not in captured.err
+    assert ruling.calls[0][:4] == ("gh", "api", "--paginate", "--slurp")
+    assert ruling.calls[1] == ("gh", "issue", "comment", "42", "--repo", "o/r", "--body-file", str(ruling.draft))
+    assert ruling.sends == []
+
+
+def test_rule_without_reply_to_shows_the_latest_comment(ruling, capsys):
+    assert ruling.run([comment_pages("用户：请裁定", "核查：通过\n第二行"), (0, URL)]) == 0
+    captured = capsys.readouterr()
+    assert captured.out == URL + "\n"
+    assert "latest comment on #42: 2026-10-28T01:00:00Z '核查：通过'" in captured.err
+
+
+@pytest.mark.parametrize("text, message", [
+    ("核查：结论\n类型：可执行\n", "line 1 must start with '总设计：'"),
+    ("总设计：结论\n", "line 2 must start with '类型：'"),
+    ("总设计：结论\n正文\n类型：可执行\n", "line 2 must start with '类型：'"),
+    ("总设计：结论\n类型：大概可以\n", "must be one of: 可执行, 方案，等用户, 记录"),
+])
+def test_rule_stops_when_the_first_two_lines_are_wrong(ruling, capsys, text, message):
+    assert ruling.run([], text=text) == 1
+    assert message in capsys.readouterr().err
+    assert ruling.calls == [] and ruling.sends == []
+
+
+def test_rule_accepts_each_type(ruling, capsys):
+    for kind in ("方案，等用户", "记录"):
+        assert ruling.run([comment_pages("用户：问"), (0, URL)], text=f"总设计：结论\n类型：{kind}\n") == 0
+
+
+def test_rule_stops_on_a_wrong_reference_and_posts_nothing(ruling, capsys):
+    assert ruling.run([], text="总设计：结论\n类型：可执行\n`pkg/work.py:6` holds `Ledger`\n") == 1
+    captured = capsys.readouterr()
+    assert "wrong: line 3 `pkg/work.py:6`" in captured.err and "Nothing posted" in captured.err
+    assert captured.out == "" and ruling.calls == [] and ruling.sends == []
+
+
+def test_rule_stops_when_a_comment_came_after_the_one_answered(ruling, capsys):
+    pages = comment_pages("用户：请裁定", "用户：补充一点", "核查：新数字")
+    link = "https://github.com/o/r/issues/42#issuecomment-100"
+    assert ruling.run([pages], "--reply-to", link, "--notify", "#42") == 1
+    captured = capsys.readouterr()
+    assert captured.out == "" and len(ruling.calls) == 1 and ruling.sends == []
+    assert "newer: https://github.com/o/r/issues/42#issuecomment-101 '用户：补充一点'" in captured.err
+    assert "newer: https://github.com/o/r/issues/42#issuecomment-102 '核查：新数字'" in captured.err
+    assert "--force" in captured.err
+
+
+def test_rule_force_posts_despite_newer_comments(ruling, capsys):
+    assert ruling.run([comment_pages("用户：请裁定", "用户：补充一点"), (0, URL)], "--reply-to", "100", "--force") == 0
+    captured = capsys.readouterr()
+    assert captured.out == URL + "\n" and "posting anyway" in captured.err
+
+
+@pytest.mark.parametrize("reply_to, message", [
+    ("999", "comment 999 is not among"),
+    ("https://github.com/o/r/issues/43#issuecomment-100", "is not on o/r#42"),
+    ("https://github.com/o/r/issues/42", "not an issue comment link"),
+])
+def test_rule_refuses_a_reply_target_that_is_not_on_the_ticket(ruling, capsys, reply_to, message):
+    assert ruling.run([comment_pages("用户：请裁定")], "--reply-to", reply_to) == 1
+    assert message in capsys.readouterr().err and len(ruling.calls) <= 1
+
+
+def test_rule_reports_a_failed_notification_but_keeps_the_comment(ruling, capsys):
+    ruling.send_code = 1
+    assert ruling.run([comment_pages("用户：请裁定"), (0, URL)], "--reply-to", "100", "--notify", "#42") == 1
+    captured = capsys.readouterr()
+    assert captured.out == URL + "\n"
+    assert "the comment stays" in captured.err and "failed" in captured.err
+    assert ruling.sends == [["send", "#42", "--from", "总设计", "--message", f"#42 已答复，见票 {URL}\n总设计：结论"]]
+    assert [call[:3] for call in ruling.calls] == [("gh", "api", "--paginate"), ("gh", "issue", "comment")]
+
+
+def test_rule_notifies_a_codex_session_and_keeps_stdout_clean(ruling, capsys):
+    assert ruling.run([comment_pages("用户：请裁定"), (0, URL)], "--notify", "00000000-0000-4000-8000-000000000001") == 0
+    captured = capsys.readouterr()
+    assert captured.out == URL + "\n" and "started" in captured.err
+    assert ruling.sends[0][:2] == ["send", "00000000-0000-4000-8000-000000000001"]
+
+
+def test_rule_refuses_a_claude_session_before_posting(ruling, capsys):
+    assert ruling.run([], "--notify", "uds:/tmp/cc-socks/1.sock") == 1
+    assert "cannot message a Claude Code session" in capsys.readouterr().err
+    assert ruling.calls == [] and ruling.sends == []
+
+
+def test_rule_reports_a_failed_post_and_a_non_url_answer(ruling, capsys):
+    assert ruling.run([comment_pages("用户：问"), (1, "")]) == 1
+    assert "comment failed: boom" in capsys.readouterr().err
+    assert ruling.run([comment_pages("用户：问"), (0, "created\n")], "--notify", "#42") == 1
+    assert "did not print a comment link" in capsys.readouterr().err and ruling.sends == []
+
+
+BODY = "票面\n第二行\n"
+
+
+def test_edit_body_writes_only_over_the_baseline_and_verifies(ruling, tmp_path, capsys):
+    base = tmp_path / "base.md"
+    base.write_text(BODY, encoding="utf-8")
+    new = "新票面 `pkg/work.py:9` holds `Ledger`\n"
+    responses = [(0, BODY.replace("\n", "\r\n") + "\n"), (0, "https://github.com/o/r/issues/42\n"), (0, new)]
+    assert ruling.run(responses, "--edit-body", "--base", str(base), text=new) == 0
+    assert capsys.readouterr().out == "https://github.com/o/r/issues/42\n"
+    assert ruling.calls[0] == ("gh", "api", "repos/o/r/issues/42", "--jq", ".body")
+    assert ruling.calls[1] == ("gh", "issue", "edit", "42", "--repo", "o/r", "--body-file", str(ruling.draft))
+
+
+def test_edit_body_stops_when_the_body_changed(ruling, tmp_path, capsys):
+    base = tmp_path / "base.md"
+    base.write_text(BODY, encoding="utf-8")
+    assert ruling.run([(0, "票面\n别人改了\n")], "--edit-body", "--base", str(base), text="新票面\n") == 1
+    captured = capsys.readouterr()
+    assert "+别人改了" in captured.err and "Nothing edited" in captured.err and len(ruling.calls) == 1
+
+
+def test_edit_body_reports_a_body_that_reads_back_differently(ruling, tmp_path, capsys):
+    base = tmp_path / "base.md"
+    base.write_text(BODY, encoding="utf-8")
+    responses = [(0, BODY), (0, "https://github.com/o/r/issues/42\n"), (0, "新票面 被改了\n")]
+    assert ruling.run(responses, "--edit-body", "--base", str(base), text="新票面\n") == 1
+    captured = capsys.readouterr()
+    assert captured.out == "" and "read back differs" in captured.err
+
+
+@pytest.mark.parametrize("options, error", [
+    (["--edit-body"], "--edit-body and --base go together"),
+    (["--base", "x"], "--edit-body and --base go together"),
+    (["--edit-body", "--base", "x", "--reply-to", "1"], "belong to comments"),
+    (["--force"], "--force goes with --reply-to"),
+])
+def test_rule_option_combinations(capsys, options, error):
+    with pytest.raises(SystemExit) as exc:
+        ding.main(["rule", "42", "draft.md", *options])
+    assert exc.value.code == 2 and error in capsys.readouterr().err
+
+
+def test_rule_help_explains_the_steps(capsys):
+    with pytest.raises(SystemExit):
+        ding.main(["rule", "--help"])
+    out = capsys.readouterr().out
+    for word in ("--reply-to", "--notify", "--edit-body", "--base", "--force", "check-refs", "SendMessage"):
+        assert word in out
+
+
+def test_check_refs_reports_each_draft_and_fails_when_any_is_wrong(tree, capsys):
+    good, bad = tree / "good.md", tree / "bad.md"
+    good.write_text("`pkg/work.py:9` holds `Ledger`\n")
+    bad.write_text("`pkg/work.py:6` holds `Ledger`\n")
+    assert ding.main(["check-refs", str(good), "--root", str(tree)]) == 0
+    assert "draft" not in json.loads(capsys.readouterr().out)
+    assert ding.main(["check-refs", str(good), str(bad), str(good), "--root", str(tree)]) == 1
+    captured = capsys.readouterr()
+    reports = [json.loads(line) for line in captured.out.splitlines()]
+    assert [(r["draft"], r["findings"]) for r in reports] == [(str(good), 0), (str(bad), 1), (str(good), 0)]
+    assert f"wrong: {bad}: line 1 `pkg/work.py:6`" in captured.err
+    assert f"{good}: checked 1 references (1 file:line): 0 wrong" in captured.err
+
+
+def test_check_refs_keeps_going_past_an_unreadable_draft(tree, capsys):
+    good = tree / "good.md"
+    good.write_text("`pkg/work.py:9` holds `Ledger`\n")
+    assert ding.main(["check-refs", str(tree / "missing.md"), str(good), "--root", str(tree)]) == 2
+    captured = capsys.readouterr()
+    assert "missing.md" in captured.err and json.loads(captured.out)["draft"] == str(good)
+
+
+@pytest.mark.parametrize("text, error", [
+    ("[rule]\ntypes = []", "types must be a nonempty list"),
+    ("[rule]\nnotify = 'no link'", "holding {url}"),
+    ("[rule]\nnotify = '{url} {oops}'", "not a valid template"),
+])
+def test_rule_config_is_checked(tmp_path, text, error):
+    with pytest.raises(ValueError, match=error):
+        settings(tmp_path, text)
+
+
+def test_rule_defaults_are_english(tmp_path):
+    loaded = settings(tmp_path)
+    assert loaded.rule.type_label == "Type" and "actionable" in loaded.rule.types
+    assert rule.format_problem("Designer: x\nType: record\n", loaded) is None