dkitchen 0.2.2__tar.gz → 0.3.1__tar.gz

{dkitchen-0.2.2/src/dkitchen.egg-info → dkitchen-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkitchen
-Version: 0.2.2
+Version: 0.3.1
 Summary: A multi-agent workflow for research repos, with the ding CLI for messaging and waking agent sessions
 Author: 917Dhj
 License-Expression: MIT
@@ -120,6 +120,7 @@ A research repo has more resources than any single agent sees: GPUs on several s
 `ding` passes messages between agent sessions and wakes a session when its long job ends.
 
 ```bash
+ding new --cwd . --issue 42 --name 'Ablation' --message-file brief.md   # start a Codex session for #42; prints its UUID
 ding board                                            # who is working on what, in this repo
 ding send '#42' --from orchestrator --message-file note.md
 ding launch train -- python train.py                  # run in tmux, wake me when it exits

{dkitchen-0.2.2 → dkitchen-0.3.1}/README.md

@@ -88,6 +88,7 @@ A research repo has more resources than any single agent sees: GPUs on several s
 `ding` passes messages between agent sessions and wakes a session when its long job ends.
 
 ```bash
+ding new --cwd . --issue 42 --name 'Ablation' --message-file brief.md   # start a Codex session for #42; prints its UUID
 ding board                                            # who is working on what, in this repo
 ding send '#42' --from orchestrator --message-file note.md
 ding launch train -- python train.py                  # run in tmux, wake me when it exits

{dkitchen-0.2.2 → dkitchen-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dkitchen"
-version = "0.2.2"
+version = "0.3.1"
 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.2.2 → dkitchen-0.3.1}/src/dkitchen/config.py

@@ -27,12 +27,16 @@ Every key is optional. The defaults match the English templates in kitchen/:
     [log]
     issue = 1                            # the pinned orchestrator log ticket
     pending = "Waiting for the user"
+
+    [sessions]
+    name = "【#{issue}】{name}"           # `ding new --issue N --name NAME`; also {repo}
 """
 from __future__ import annotations
 
 from dataclasses import dataclass, fields as dataclass_fields, replace
 from pathlib import Path
 import re
+import string
 import subprocess
 import sys
 
@@ -81,6 +85,38 @@ class Log:
     pending: str = "Waiting for the user"
 
 
+@dataclass(frozen=True)
+class Sessions:
+    name: str = "【#{issue}】{name}"
+
+    def session_name(self, *, issue: int, name: str, repo: str) -> str:
+        return self.name.format(issue=issue, name=name, repo=repo)
+
+
+SESSION_FIELDS = ("issue", "name", "repo")
+
+
+def session_template(value: object) -> str:
+    """A session name template using only SESSION_FIELDS, checked when the config is read."""
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{FILE}: [sessions] name must be a nonempty string")
+    allowed = ", ".join(f"{{{field}}}" for field in SESSION_FIELDS)
+    try:
+        for _, field, spec, conversion in string.Formatter().parse(value):
+            if field is None:
+                continue
+            if field not in SESSION_FIELDS:
+                raise ValueError(f"{FILE}: [sessions] name uses {{{field}}}; use only {allowed}")
+            if conversion or "{" in spec:
+                raise ValueError(f"{FILE}: [sessions] name: write {{{field}}} without a conversion or nested field")
+        Sessions(value).session_name(issue=1, name="name", repo="owner/name")
+    except ValueError as exc:
+        if str(exc).startswith(FILE):
+            raise
+        raise ValueError(f"{FILE}: [sessions] name is not a valid template: {exc}") from exc
+    return value
+
+
 @dataclass(frozen=True)
 class Config:
     root: Path
@@ -89,6 +125,7 @@ class Config:
     status: Status = Status()
     labels: Labels = Labels()
     log: Log = Log()
+    sessions: Sessions = Sessions()
 
     def repository(self) -> str:
         """The configured repository, or the one gh sees from the repository root."""
@@ -116,6 +153,8 @@ def section(cls, values: object, name: str):
             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")
             value = tuple(item.strip() for item in value)
+        elif key == "name" and cls is Sessions:
+            value = session_template(value)
         elif key == "issue":
             if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
                 raise ValueError(f"{FILE}: [{name}] issue must be a positive issue number")
@@ -141,7 +180,7 @@ 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}
+    sections = {"stations": Stations, "status": Status, "labels": Labels, "log": Log, "sessions": Sessions}
     unknown = sorted(set(data) - {"repo", *sections})
     if unknown:
         raise ValueError(f"{FILE}: unknown keys: {', '.join(unknown)}")

{dkitchen-0.2.2 → dkitchen-0.3.1}/src/dkitchen/ding.py

@@ -135,6 +135,16 @@ def read_status(call, thread_id: str) -> dict:
     return status
 
 
+def read_info(call, thread_id: str) -> dict:
+    """A session's ID, name (None when unnamed), working directory, and status."""
+    result = call("thread/read", {"threadId": thread_id, "includeTurns": False})
+    thread = result.get("thread")
+    info = thread_metadata(thread)
+    if info["id"] != thread_id:
+        raise ValueError("App Server returned a different thread.")
+    return {**info, "name": thread.get("name") or None}
+
+
 def read_reply(call, thread_id: str) -> str:
     cursor = None
     seen_cursors = set()
@@ -324,6 +334,11 @@ def github_repository() -> str:
     return repo
 
 
+def ownership_note(repo: str, number: int, thread_id: str) -> str:
+    return (f"You own ticket {repo}#{number}. Before anything else, post a comment on it "
+            f"with the line `Codex owner: {thread_id}`.\n\n")
+
+
 def session_references(body: str | None, label: str = "session") -> list[str]:
     if body is None:
         return []
@@ -1162,6 +1177,46 @@ def message_text(message: str | None, message_file: str | None, sender: str | No
     return message
 
 
+def new_task(args) -> int:
+    thread_id = None
+    stage = "validation"
+    try:
+        cwd = Path(args.cwd).expanduser().resolve() if args.cwd else None
+        if cwd is None or not cwd.is_dir():
+            raise ValueError("--cwd must name an existing directory.")
+        message = message_text(args.message, args.message_file, None)
+        if not message.strip():
+            raise ValueError("The first message (--message or --message-file) must not be empty.")
+        stage = "connection"
+        with app_server(socket_path(args.socket)) as call:
+            stage = "thread/start"
+            thread = call(stage, {"cwd": str(cwd), "ephemeral": False}).get("thread")
+            try:
+                thread_id = str(UUID(thread["id"]))
+            except (KeyError, ValueError, TypeError, AttributeError) as exc:
+                raise ValueError("Malformed App Server thread ID.") from exc
+            stage = "thread/name/set"
+            call(stage, {"threadId": thread_id, "name": args.name})
+            if args.issue is not None:
+                message = ownership_note(args.repo, args.issue, thread_id) + message
+            stage = "turn/start"
+            turn = call(stage, {"threadId": thread_id,
+                                "input": [{"type": "text", "text": message}]}).get("turn")
+            if (not isinstance(turn, dict) or not isinstance(turn.get("id"), str)
+                    or not turn["id"] or turn.get("status") not in ("inProgress", "completed")):
+                raise ValueError("App Server did not return an accepted turn.")
+        print(thread_id)
+        return 0
+    except (OSError, ValueError, RuntimeError, KeyboardInterrupt) as exc:
+        recovery = ""
+        if thread_id is not None:
+            recovery = f"; session {thread_id}; inspect Desktop or ding board before retrying"
+        elif stage == "thread/start":
+            recovery = "; session creation is unconfirmed; inspect Desktop or ding board before retrying"
+        print(f"ding: new {stage}: {str(exc) or type(exc).__name__}{recovery}", file=sys.stderr)
+        return 130 if isinstance(exc, KeyboardInterrupt) else 1
+
+
 def send_task(args) -> int:
     state = Path(os.environ.get("XDG_STATE_HOME") or Path.home() / ".local/state")
     record = state / "ding/sent.jsonl"
@@ -1324,6 +1379,16 @@ def main(argv=None) -> int:
         installed = "unknown"
     parser.add_argument("--version", action="version", version=f"ding {installed}")
     commands = parser.add_subparsers(dest="action", required=True)
+    sub = commands.add_parser("new", help="Create a saved Codex session and start its first message")
+    sub.add_argument("--cwd", required=True, help="Existing working directory for the session")
+    sub.add_argument("--name", required=True, help="Session title; with --issue, filled into the "
+                                                   "[sessions] name template")
+    sub.add_argument("--issue", type=int, help="Ticket this session owns: formats --name with the [sessions] "
+                                               "name template and asks the session to post its Codex owner line")
+    message = sub.add_mutually_exclusive_group(required=True)
+    message.add_argument("--message", help="First message text, or '-' to read stdin")
+    message.add_argument("--message-file", help="UTF-8 file holding the first message")
+    sub.add_argument("--socket", help="Existing local App Server Unix socket path")
     board = commands.add_parser("board", help="List sessions, run states, and local unwrapped tasks")
     board.add_argument("--all", action="store_true", help="Include all non-archived sessions")
     board.add_argument("--status", action="store_true", help="Show the latest executor comment status block")
@@ -1337,6 +1402,8 @@ def main(argv=None) -> int:
                        help="Minimum lifetime CPU percent per core outside tmux panes (default: 10)")
     for action, summary in (("read", "Print a session's latest final reply"),
                             ("status", "Print a session's App Server status as JSON"),
+                            ("info", "Print a session's ID, name, working directory, and status as JSON"),
+                            ("rename", "Change a session's name without starting a model turn"),
                             ("send", "Send a message to a session"),
                             ("run", "Run a command and message a session when it exits"),
                             ("launch", "Run a command in a new tmux session and wake this Codex session when it exits")):
@@ -1350,6 +1417,8 @@ def main(argv=None) -> int:
         sub.add_argument("--socket", help="Existing local App Server Unix socket path")
         if action == "read":
             sub.add_argument("--head", action="store_true", help="Print only the first paragraph of the final reply")
+        if action == "rename":
+            sub.add_argument("--name", required=True, help="New session name, preserved exactly as supplied")
         if action in {"send", "run", "launch"}:
             message = sub.add_mutually_exclusive_group(required=action != "launch")
             message.add_argument("--message", help="Message text, or '-' to read stdin")
@@ -1402,11 +1471,22 @@ def main(argv=None) -> int:
         command = argv[separator + 1:]
         argv = argv[:separator]
     args = parser.parse_args(argv)
+    if args.action == "rename" and not args.name.strip():
+        parser.error("--name must contain non-whitespace text")
     if getattr(args, "issue", None) is not None and args.issue <= 0:
         parser.error("--issue must be a positive issue number")
     if args.action in {"run", "launch"} and not command:
         parser.error(f"{args.action} requires a task command after --")
     try:
+        if args.action == "new":
+            if not args.name.strip():
+                parser.error("--name must contain non-whitespace text")
+            if args.issue is not None and args.cwd and Path(args.cwd).expanduser().is_dir():
+                from dkitchen import config
+                settings = config.load(Path(args.cwd).expanduser().resolve())
+                args.repo = settings.repository()
+                args.name = settings.sessions.session_name(issue=args.issue, name=args.name, repo=args.repo)
+            return new_task(args)
         if args.action == "check-refs":
             from dkitchen import refs
             return refs.check_refs(args)
@@ -1442,6 +1522,15 @@ def main(argv=None) -> int:
         if args.action == "run":
             return run_task(args, command)
         path = socket_path(args.socket)
+        if args.action == "rename":
+            with app_server(path) as call:
+                call("thread/name/set", {"threadId": args.thread_id, "name": args.name})
+            print(args.thread_id)
+            return 0
+        if args.action == "info":
+            with app_server(path) as call:
+                print(json.dumps(read_info(call, args.thread_id), ensure_ascii=False))
+            return 0
         result = query(args.thread_id, path, status_only=args.action == "status")
         if args.action == "read" and args.head:
             result = reply_head(result)

{dkitchen-0.2.2 → dkitchen-0.3.1/src/dkitchen.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkitchen
-Version: 0.2.2
+Version: 0.3.1
 Summary: A multi-agent workflow for research repos, with the ding CLI for messaging and waking agent sessions
 Author: 917Dhj
 License-Expression: MIT
@@ -120,6 +120,7 @@ A research repo has more resources than any single agent sees: GPUs on several s
 `ding` passes messages between agent sessions and wakes a session when its long job ends.
 
 ```bash
+ding new --cwd . --issue 42 --name 'Ablation' --message-file brief.md   # start a Codex session for #42; prints its UUID
 ding board                                            # who is working on what, in this repo
 ding send '#42' --from orchestrator --message-file note.md
 ding launch train -- python train.py                  # run in tmux, wake me when it exits

{dkitchen-0.2.2 → dkitchen-0.3.1}/tests/test_codex_session.py

@@ -252,6 +252,363 @@ def test_status_cli(capsys, monkeypatch):
     assert json.loads(capsys.readouterr().out) == {"type": "active", "activeFlags": []}
 
 
+@pytest.mark.parametrize("name, expected", [("【#57】消融实验", "【#57】消融实验"), (None, None), ("", None)])
+def test_info_protocol_keeps_unnamed_sessions_unnamed(name, expected):
+    status = {"type": "idle", "activeFlags": []}
+    ws = Connection([{"result": {}}, {"result": {"thread": {
+        "id": THREAD_ID.upper(), "name": name, "cwd": "/work/worktree-57", "status": status, "turns": []}}}])
+    assert ding.read_info(ding.initialize(ws), THREAD_ID) == {
+        "id": THREAD_ID, "name": expected, "cwd": "/work/worktree-57", "status": status}
+    assert [r["method"] for r in ws.requests] == ["initialize", "initialized", "thread/read"]
+    assert ws.requests[-1]["params"] == {"threadId": THREAD_ID, "includeTurns": False}
+
+
+@pytest.mark.parametrize("thread, error", [
+    (None, "Malformed App Server thread"),
+    ({"id": "nope", "cwd": "/w", "status": {"type": "idle"}}, "thread ID"),
+    ({"id": THREAD_ID, "name": 3, "cwd": "/w", "status": {"type": "idle"}}, "thread metadata"),
+    ({"id": THREAD_ID, "cwd": "relative", "status": {"type": "idle"}}, "thread metadata"),
+    ({"id": THREAD_ID, "cwd": "/w", "status": {}}, "thread metadata"),
+    ({"id": OTHER_ID, "cwd": "/w", "status": {"type": "idle"}}, "different thread"),
+])
+def test_invalid_info(thread, error):
+    ws = Connection([{"result": {}}, {"result": {"thread": thread}}])
+    with pytest.raises(ValueError, match=error):
+        ding.read_info(ding.initialize(ws), THREAD_ID)
+
+
+@pytest.mark.parametrize("target", [["#42"], ["--issue", "42"], ["Build"]])
+def test_info_cli_resolves_targets_and_prints_json(issue_data, monkeypatch, capsys, target):
+    calls = []
+
+    def call(method, params):
+        calls.append((method, params))
+        if method == "thread/list":
+            return {"data": [thread()]}
+        return {"thread": thread(name="【#42】构建", cwd="/work/repo")}
+
+    monkeypatch.setattr(ding, "app_server", lambda path: server_calls(call))
+    assert ding.main(["info", *target, "--socket", "/test.sock"]) == 0
+    assert calls[-1] == ("thread/read", {"threadId": THREAD_ID, "includeTurns": False})
+    assert all(method in {"thread/list", "thread/read"} for method, _ in calls)
+    captured = capsys.readouterr()
+    assert captured.out == '{"id": "%s", "name": "【#42】构建", "cwd": "/work/repo", ' \
+                           '"status": {"type": "idle"}}\n' % THREAD_ID
+    assert captured.err == ""
+
+
+def test_info_cli_reports_failures(monkeypatch, capsys):
+    monkeypatch.setattr(ding, "app_server", lambda path: server_calls(lambda *a: {"thread": None}))
+    assert ding.main(["info", THREAD_ID, "--socket", "/test.sock"]) == 1
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "Malformed App Server thread" in captured.err
+
+
+@pytest.mark.parametrize("missing", ["--cwd", "--name", "--message"])
+def test_new_requires_options(tmp_path, monkeypatch, capsys, missing):
+    monkeypatch.setattr(ding, "app_server", lambda *a: pytest.fail("must not connect"))
+    options = {"--cwd": str(tmp_path), "--name": "Build", "--message": "Start"}
+    argv = ["new"]
+    for flag, value in options.items():
+        if flag != missing:
+            argv.extend([flag, value])
+    with pytest.raises(SystemExit) as exc:
+        ding.main(argv)
+    assert exc.value.code == 2
+    assert missing in capsys.readouterr().err
+
+
+def test_new_rejects_message_and_message_file(tmp_path, monkeypatch, capsys):
+    monkeypatch.setattr(ding, "app_server", lambda *a: pytest.fail("must not connect"))
+    note = tmp_path / "note.md"
+    note.write_text("Start", encoding="utf-8")
+    with pytest.raises(SystemExit) as exc:
+        ding.main(["new", "--cwd", str(tmp_path), "--name", "Build",
+                   "--message", "Start", "--message-file", str(note)])
+    assert exc.value.code == 2
+    assert "not allowed with argument" in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("name", ["", " \t\n", "\u2003"])
+def test_new_rejects_blank_name_like_rename(tmp_path, monkeypatch, capsys, name):
+    monkeypatch.setattr(ding, "socket_path", lambda *a: pytest.fail("blank name must not look up"))
+    with pytest.raises(SystemExit) as exc:
+        ding.main(["new", "--cwd", str(tmp_path), "--name", name, "--message", "Start"])
+    assert exc.value.code == 2
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "--name must contain non-whitespace text" in captured.err
+
+
+@pytest.mark.parametrize("invalid", ["missing-dir", "file", "empty-cwd",
+                                   "blank-message", "empty-message", "blank-stdin", "empty-stdin",
+                                   "blank-file", "empty-file", "missing-file"])
+def test_new_validates_before_socket_lookup(tmp_path, monkeypatch, capsys, invalid):
+    monkeypatch.setattr(ding, "socket_path", lambda *a: pytest.fail("must validate before socket lookup"))
+    monkeypatch.chdir(tmp_path)
+    cwd, message_option = str(tmp_path), ["--message", "Start"]
+    if invalid == "missing-dir":
+        cwd = str(tmp_path / "missing")
+    elif invalid == "file":
+        cwd = str(tmp_path / "file")
+        Path(cwd).touch()
+    elif invalid == "empty-cwd":
+        cwd = ""
+    else:
+        text = " \t\r\n" if invalid.startswith("blank") else ""
+        if invalid.endswith("stdin"):
+            monkeypatch.setattr(ding.sys, "stdin", io.StringIO(text))
+            message_option = ["--message", "-"]
+        elif invalid.endswith("file"):
+            note = tmp_path / "note.md"
+            if invalid != "missing-file":
+                note.write_text(text, encoding="utf-8")
+            message_option = ["--message-file", str(note)]
+        else:
+            message_option = ["--message", text]
+    assert ding.main(["new", "--cwd", cwd, "--name", "Build", *message_option]) == 1
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "new validation" in captured.err
+    assert ("--cwd" if invalid in {"missing-dir", "file", "empty-cwd"} else
+            "note.md" if invalid == "missing-file" else "--message") in captured.err
+
+
+def ticket_repo(tmp_path, template=None):
+    text = 'repo = "example/project"\n'
+    if template is not None:
+        text += f"[sessions]\nname = {json.dumps(template)}\n"
+    (tmp_path / ".dkitchen.toml").write_text(text, encoding="utf-8")
+    return tmp_path
+
+
+@pytest.mark.parametrize("template, expected", [
+    (None, "【#57】Ablation {seed}"), ("{repo}#{issue:04d} {name}", "example/project#0057 Ablation {seed}"),
+])
+def test_new_issue_formats_name_and_asks_for_owner_line(tmp_path, monkeypatch, capsys, template, expected):
+    cwd = ticket_repo(tmp_path, template)
+    requests = []
+
+    def call(method, params):
+        requests.append((method, params))
+        return {"thread/start": {"thread": {"id": THREAD_ID}}, "thread/name/set": {},
+                "turn/start": {"turn": {"id": "turn-1", "status": "inProgress"}}}[method]
+
+    for function in ("gh_json", "gh_records", "github_repository"):
+        monkeypatch.setattr(ding, function, lambda *a: pytest.fail("must not read GitHub"))
+    monkeypatch.setattr(ding, "app_server", lambda path: server_calls(call))
+    assert ding.main(["new", "--cwd", str(cwd), "--issue", "57", "--name", "Ablation {seed}",
+                      "--message", "Brief", "--socket", "/test.sock"]) == 0
+    assert requests[1] == ("thread/name/set", {"threadId": THREAD_ID, "name": expected})
+    assert requests[2][1]["input"] == [{"type": "text", "text":
+        f"You own ticket example/project#57. Before anything else, post a comment on it "
+        f"with the line `Codex owner: {THREAD_ID}`.\n\nBrief"}]
+    assert capsys.readouterr().out == THREAD_ID + "\n"
+
+
+def test_new_issue_still_needs_a_name(tmp_path, monkeypatch, capsys):
+    monkeypatch.setattr(ding, "socket_path", lambda *a: pytest.fail("must not look up a socket"))
+    with pytest.raises(SystemExit) as exc:
+        ding.main(["new", "--cwd", str(ticket_repo(tmp_path)), "--issue", "57", "--message", "Start"])
+    assert exc.value.code == 2
+    assert "--name" in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("issue", ["0", "-3"])
+def test_new_issue_must_be_positive(tmp_path, monkeypatch, capsys, issue):
+    monkeypatch.setattr(ding, "socket_path", lambda *a: pytest.fail("must not look up a socket"))
+    with pytest.raises(SystemExit) as exc:
+        ding.main(["new", "--cwd", str(tmp_path), "--issue", issue, "--name", "Build", "--message", "Start"])
+    assert exc.value.code == 2
+    assert "positive issue number" in capsys.readouterr().err
+
+
+def test_new_issue_with_blank_name_is_refused_before_the_template(tmp_path, monkeypatch, capsys):
+    cwd = ticket_repo(tmp_path, "#{issue} {name}")
+    monkeypatch.setattr(ding, "socket_path", lambda *a: pytest.fail("must not look up a socket"))
+    with pytest.raises(SystemExit) as exc:
+        ding.main(["new", "--cwd", str(cwd), "--issue", "57", "--name", " \t", "--message", "Start"])
+    assert exc.value.code == 2
+    assert "--name must contain non-whitespace text" in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("failure", ["template", "repository"])
+def test_new_issue_config_failure_creates_nothing(tmp_path, monkeypatch, capsys, failure):
+    if failure == "template":
+        cwd = ticket_repo(tmp_path, "{title}")
+    else:
+        cwd = tmp_path
+        real_run = subprocess.run
+
+        def gh_repo_view(argv, *args, **kwargs):
+            if argv[:3] == ["gh", "repo", "view"]:
+                return subprocess.CompletedProcess(argv, 1, "", "no git remotes found")
+            return real_run(argv, *args, **kwargs)
+
+        monkeypatch.setattr(subprocess, "run", gh_repo_view)
+    monkeypatch.setattr(ding, "app_server", lambda *a: pytest.fail("must not connect"))
+    assert ding.main(["new", "--cwd", str(cwd), "--issue", "57", "--name", "Build", "--message", "Start"]) == 1
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert ("{title}" if failure == "template" else "no git remotes found") in captured.err
+
+
+@pytest.mark.parametrize("source, status, explicit_socket", [
+    ("argument", "inProgress", True), ("stdin", "completed", False), ("file", "inProgress", False),
+])
+def test_new_protocol_and_exact_text(tmp_path, monkeypatch, capsys, source, status, explicit_socket):
+    cwd = tmp_path / "project space" / "nested"
+    cwd.mkdir(parents=True)
+    (tmp_path / "work").symlink_to(cwd, target_is_directory=True)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("XDG_STATE_HOME", str(tmp_path / "state"))
+    message = '  Review "quoted"; $(not-shell)\r\n世界\n'
+    name = "  检查\n配置  "
+    thread_id = "00000000-0000-4000-8000-0000000000ab"
+    requests, opened, closed = [], [], []
+
+    def call(method, params):
+        requests.append((method, params))
+        return {"thread/start": {"thread": {"id": "{" + thread_id.upper() + "}"}},
+                "thread/name/set": {}, "turn/start": {"turn": {"id": "turn-1", "status": status}}}[method]
+
+    @contextmanager
+    def server(path):
+        opened.append(path)
+        try:
+            yield call
+        finally:
+            closed.append(path)
+
+    def discover(directory):
+        assert not explicit_socket
+        assert directory == Path(f"/tmp/codex-daemon-{ding.os.getuid()}")
+        return "/test.sock"
+
+    monkeypatch.setattr(ding, "app_server", server)
+    monkeypatch.setattr(ding, "discover_socket", discover)
+    monkeypatch.setattr(ding, "resolve_target", lambda *a: pytest.fail("new has no target"))
+    monkeypatch.setattr(ding, "deliver_message", lambda *a: pytest.fail("first message must not queue"))
+    monkeypatch.setattr(ding, "send_task", lambda *a: pytest.fail("first message must not use send"))
+    message_option = ["--message", message]
+    if source == "stdin":
+        monkeypatch.setattr(ding.sys, "stdin", io.StringIO(message))
+        message_option = ["--message", "-"]
+    elif source == "file":
+        (tmp_path / "note.md").write_bytes(message.encode("utf-8"))
+        message_option = ["--message-file", "note.md"]
+    options = ["--socket", "/test.sock"] if explicit_socket else []
+    assert ding.main(["new", "--cwd", "work", "--name", name, *message_option, *options]) == 0
+    assert requests == [
+        ("thread/start", {"cwd": str(cwd), "ephemeral": False}),
+        ("thread/name/set", {"threadId": thread_id, "name": name}),
+        ("turn/start", {"threadId": thread_id, "input": [{"type": "text", "text": message}]}),
+    ]
+    assert opened == closed == ["/test.sock"]
+    captured = capsys.readouterr()
+    assert captured.out == thread_id + "\n"
+    assert captured.err == ""
+    assert not (tmp_path / "state/ding").exists()
+
+
+@pytest.mark.parametrize("point", ["socket lookup", "connection"])
+@pytest.mark.parametrize("error", [OSError("unavailable"), KeyboardInterrupt()])
+def test_new_connection_failure_never_creates(tmp_path, monkeypatch, capsys, point, error):
+    def fail(*args):
+        raise error
+
+    monkeypatch.setattr(ding, "socket_path", fail if point == "socket lookup" else lambda *a: "/test.sock")
+    monkeypatch.setattr(ding, "app_server", fail if point == "connection" else
+                        lambda *a: pytest.fail("socket lookup failed"))
+    assert ding.main(["new", "--cwd", str(tmp_path), "--name", "Build", "--message", "Start"]) == (
+        130 if isinstance(error, KeyboardInterrupt) else 1)
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "new connection" in captured.err
+    assert "creation is unconfirmed" not in captured.err
+    assert THREAD_ID not in captured.err
+
+
+@pytest.mark.parametrize("stage", ["thread/start", "thread/name/set", "turn/start"])
+@pytest.mark.parametrize("error", [ding.AppServerError("request rejected"), TimeoutError("response lost"),
+                                  ding.AppServerUnavailable("connection closed"), KeyboardInterrupt()])
+def test_new_failure_preserves_session_without_retry(tmp_path, monkeypatch, capsys, stage, error):
+    requests, connections = [], []
+    stages = ["thread/start", "thread/name/set", "turn/start"]
+
+    def call(method, params):
+        requests.append(method)
+        if method == stage:
+            raise error
+        return {"thread": {"id": THREAD_ID}}
+
+    def server(path):
+        connections.append(path)
+        return server_calls(call)
+
+    monkeypatch.setattr(ding, "app_server", server)
+    assert ding.main(["new", "--cwd", str(tmp_path), "--name", "Build", "--message", "Start",
+                      "--socket", "/test.sock"]) == (130 if isinstance(error, KeyboardInterrupt) else 1)
+    assert requests == stages[:stages.index(stage) + 1]
+    assert connections == ["/test.sock"]
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert f"new {stage}" in captured.err
+    assert (str(error) or type(error).__name__) in captured.err
+    assert "inspect Desktop or ding board before retrying" in captured.err
+    if stage == "thread/start":
+        assert "session creation is unconfirmed" in captured.err
+        assert THREAD_ID not in captured.err
+    else:
+        assert f"session {THREAD_ID}" in captured.err
+
+
+@pytest.mark.parametrize("reply", [{}, {"thread": None}, {"thread": []}, {"thread": {}},
+                                   {"thread": {"id": None}}, {"thread": {"id": 7}},
+                                   {"thread": {"id": "invalid"}}])
+def test_new_rejects_invalid_thread_before_naming(tmp_path, monkeypatch, capsys, reply):
+    requests = []
+
+    def call(method, params):
+        requests.append(method)
+        return reply
+
+    monkeypatch.setattr(ding, "app_server", lambda path: server_calls(call))
+    assert ding.main(["new", "--cwd", str(tmp_path), "--name", "Build", "--message", "Start",
+                      "--socket", "/test.sock"]) == 1
+    assert requests == ["thread/start"]
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "new thread/start: Malformed App Server thread ID" in captured.err
+    assert "session creation is unconfirmed" in captured.err
+
+
+@pytest.mark.parametrize("turn", [None, [], {}, {"id": None, "status": "inProgress"},
+                                  {"id": "", "status": "inProgress"}, {"id": 7, "status": "inProgress"},
+                                  {"id": "turn-1"}, {"id": "turn-1", "status": "failed"},
+                                  {"id": "turn-1", "status": "interrupted"},
+                                  {"id": "turn-1", "status": "future-state"},
+                                  {"id": "turn-1", "status": {}}])
+def test_new_rejects_unaccepted_turn_and_keeps_id(tmp_path, monkeypatch, capsys, turn):
+    requests = []
+
+    def call(method, params):
+        requests.append(method)
+        return {"thread/start": {"thread": {"id": THREAD_ID}},
+                "thread/name/set": {}, "turn/start": {"turn": turn}}[method]
+
+    monkeypatch.setattr(ding, "app_server", lambda path: server_calls(call))
+    assert ding.main(["new", "--cwd", str(tmp_path), "--name", "Build", "--message", "Start",
+                      "--socket", "/test.sock"]) == 1
+    assert requests == ["thread/start", "thread/name/set", "turn/start"]
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "new turn/start: App Server did not return an accepted turn" in captured.err
+    assert f"session {THREAD_ID}" in captured.err
+    assert "inspect Desktop or ding board before retrying" in captured.err
+
+
 def test_send_persists_intent_before_delivery(monkeypatch, tmp_path):
     calls = []
     message = 'text "quoted"; $(not-shell)\nnext'
@@ -2829,3 +3186,98 @@ def test_pane_representative_skips_empty_ancestor_command_and_breaks_ties_by_pid
     panes = {10: {"pane_id": "%1", "session": "work", "window": "task"}}
     assert [row["pid"] for row in ding.unwrapped_processes(
         processes, panes, min_age=600, min_cpu=10, proc=tmp_path)] == [11]
+
+
+@pytest.mark.parametrize("arguments", [
+    [], [THREAD_ID], ["--name", "New name"], [THREAD_ID, "--name"],
+    [THREAD_ID, "--issue", "42", "--name", "New name"],
+])
+def test_rename_requires_one_target_and_name(monkeypatch, capsys, arguments):
+    monkeypatch.setattr(ding, "resolve_target", lambda *a: pytest.fail("invalid arguments must not resolve"))
+    with pytest.raises(SystemExit) as exc:
+        ding.main(["rename", *arguments])
+    assert exc.value.code == 2
+    assert capsys.readouterr().out == ""
+
+
+@pytest.mark.parametrize("name", ["", " \t\n", "\u2003"])
+@pytest.mark.parametrize("target", [["Build"], ["--issue", "42"]])
+def test_rename_rejects_blank_name_before_lookup(monkeypatch, capsys, name, target):
+    for function in ("resolve_target", "socket_path", "app_server", "github_repository", "gh_json"):
+        monkeypatch.setattr(ding, function, lambda *a: pytest.fail("blank name must not look up"))
+    with pytest.raises(SystemExit) as exc:
+        ding.main(["rename", *target, "--name", name])
+    assert exc.value.code == 2
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "--name must contain non-whitespace text" in captured.err
+
+
+@pytest.mark.parametrize("target,issue", [
+    (THREAD_ID, None), ("Build", None), (None, 42), ("#42", None),
+    ("example/project#42", None), ("https://github.com/example/project/issues/42", None),
+])
+def test_rename_delegates_target_resolution(monkeypatch, capsys, target, issue):
+    resolved = []
+    calls = []
+
+    def resolve(value, number, path):
+        resolved.append((value, number, path))
+        return THREAD_ID
+
+    def call(method, params):
+        calls.append((method, params))
+        return {}
+
+    monkeypatch.setattr(ding, "resolve_target", resolve)
+    monkeypatch.setattr(ding, "app_server", lambda path: server_calls(call))
+    arguments = [target] if target is not None else ["--issue", str(issue)]
+    assert ding.main(["rename", *arguments, "--name", "New name", "--socket", "/test.sock"]) == 0
+    assert resolved == [(target, issue, "/test.sock")]
+    assert calls == [("thread/name/set", {"threadId": THREAD_ID, "name": "New name"})]
+    captured = capsys.readouterr()
+    assert captured.out == THREAD_ID + "\n"
+    assert captured.err == ""
+
+
+@pytest.mark.parametrize("reply,status,error", [
+    ({"result": {}}, 0, None),
+    ({"error": {"code": -32602, "message": "name refused"}}, 1, "name refused"),
+    ("", 1, "closed the connection"),
+    ({"result": None}, 1, "Malformed App Server result"),
+])
+def test_rename_rpc_acknowledgement_and_failure(tmp_path, monkeypatch, capsys, reply, status, error):
+    websocket = pytest.importorskip("websocket")
+    ws = Connection([{"result": {}}, reply])
+    monkeypatch.setattr(websocket, "create_connection", lambda *a, **kw: ws)
+    name = '  评测 "quoted" $(not-shell)\nnext  '
+    path = str(tmp_path / "server")
+    with socket.socket(socket.AF_UNIX) as server:
+        server.bind(path)
+        server.listen(1)
+        assert ding.main(["rename", "{" + THREAD_ID + "}", "--name", name, "--socket", path]) == status
+    captured = capsys.readouterr()
+    assert captured.out == (THREAD_ID + "\n" if status == 0 else "")
+    assert (error in captured.err) if error else captured.err == ""
+    assert [request["method"] for request in ws.requests] == ["initialize", "initialized", "thread/name/set"]
+    assert ws.requests[-1]["params"] == {"threadId": THREAD_ID, "name": name}
+    assert ws.closed
+
+
+@pytest.mark.parametrize("target", ["Build", "#42"])
+def test_rename_refuses_ambiguous_targets(issue_data, monkeypatch, capsys, target):
+    issue, comments = issue_data
+    comments.append({"body": f"Codex session: {OTHER_ID}"})
+    calls = []
+
+    def call(method, params):
+        calls.append(method)
+        assert method == "thread/list"
+        return {"data": [thread(), thread(OTHER_ID, "Build")]}
+
+    monkeypatch.setattr(ding, "app_server", lambda path: server_calls(call))
+    assert ding.main(["rename", target, "--name", "New name", "--socket", "/test.sock"]) == 1
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert THREAD_ID in captured.err and OTHER_ID in captured.err
+    assert calls == ["thread/list"]

{dkitchen-0.2.2 → dkitchen-0.3.1}/tests/test_kitchen.py

@@ -70,6 +70,28 @@ def test_bad_config_is_refused_with_its_key(tmp_path, text, error):
         settings(tmp_path, text)
 
 
+def test_session_name_template_defaults_and_fills_names_verbatim(tmp_path):
+    assert settings(tmp_path).sessions.session_name(issue=57, name="Fix {x} 100%", repo="o/r") == \
+        "【#57】Fix {x} 100%"
+    loaded = settings(tmp_path, '[sessions]\nname = "{repo}#{issue:04d} {name}"')
+    assert loaded.sessions.session_name(issue=7, name="Plot", repo="o/r") == "o/r#0007 Plot"
+
+
+@pytest.mark.parametrize("template, error", [
+    ("", "nonempty string"),
+    ("{issue} {title}", r"uses \{title\}; use only \{issue\}, \{name\}, \{repo\}"),
+    ("{} {name}", r"uses \{\}"),
+    ("{name.upper}", r"uses \{name.upper\}"),
+    ("{name!r}", "without a conversion"),
+    ("{name", "not a valid template"),
+    ("{name:d}", "not a valid template"),
+    ("{issue:{name}}", "nested field"),
+])
+def test_bad_session_name_template_is_refused_on_load(tmp_path, template, error):
+    with pytest.raises(ValueError, match=error):
+        settings(tmp_path, f"[sessions]\nname = {json.dumps(template)}")
+
+
 def test_board_status_falls_back_to_the_config_fields(tmp_path, monkeypatch, capsys):
     monkeypatch.chdir(tmp_path)
     (tmp_path / config.FILE).write_text(CHINESE, encoding="utf-8")