swarph-cli 0.72.14__tar.gz → 0.72.16__tar.gz

{swarph_cli-0.72.14/src/swarph_cli.egg-info → swarph_cli-0.72.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.14
+Version: 0.72.16
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.14 → swarph_cli-0.72.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.14"
+version = "0.72.16"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.72.14 → swarph_cli-0.72.16}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.72.14"
+__version__ = "0.72.16"
 
 __all__ = ["__version__"]

{swarph_cli-0.72.14 → swarph_cli-0.72.16}/src/swarph_cli/commands/board.py

@@ -631,7 +631,8 @@ def _step_list(values) -> list[str]:
 
 
 def _ask_payload(self_name, what, *, holder=None, step=None, needs=None, hours=None,
-                 done=None, accept=None, kind="action", timeout_hours=None) -> dict:
+                 done=None, accept=None, kind="action", timeout_hours=None,
+                 task=None, task_needs=None) -> dict:
     """POST /board/cards/{id}/ask body. None = not mentioned = key ABSENT (#191's
     rule; test_532 pins that a null `accept` on the wire would overwrite the
     gateway's own normalization). No holder → `requested`; `me` → the caller's
@@ -653,6 +654,10 @@ def _ask_payload(self_name, what, *, holder=None, step=None, needs=None, hours=N
         p["accept"] = accept
     if timeout_hours is not None:
         p["timeout_hours"] = timeout_hours
+    if task is not None:
+        p["task"] = task
+    if task_needs is not None and _step_list(task_needs):
+        p["task_needs"] = _step_list(task_needs)
     return p
 
 
@@ -680,6 +685,8 @@ def _ask_line(d) -> str:
         return _format_ask(d)
     n = d.get("id"); card = d.get("card_id")
     step = _s(d.get("step")) or "unstepped"
+    if d.get("task"):
+        step = f"{step} {_s(d.get('task'))}"
     holder = _s(d.get("holder")); take = _s(d.get("take_with"))
     missing = ", ".join(_s(m) for m in d.get("still_missing") or [])  # the gateway's field (mesh-gateway #157)
     if state == "requested":
@@ -980,6 +987,17 @@ def _build_parser() -> argparse.ArgumentParser:
     ck.add_argument("--done", default=None, metavar="EVIDENCE",
                     help="mint + take + close in ONE act (needs --holder me); the "
                          "container the step names — a ref, >=40 words, or a verdict")
+    ck.add_argument("--task", default=None, metavar="task:<slug>",
+                    help="task id, one token task:<slug> (letters, digits, dots, "
+                         "underscores, hyphens). A pull-request task is "
+                         "task:pr-<repo>-<digits>. pr:<repo>#<n> is refused. "
+                         "Set at mint; amend cannot add it. Two live rows of one "
+                         "step need different task ids. Omit it for the one live "
+                         "unsplit row")
+    ck.add_argument("--task-needs", action="append", dest="task_needs", default=None,
+                    metavar="task:<slug>",
+                    help="sibling task id on this same step (repeatable). The "
+                         "gateway stores the edge and refuses a cycle")
     ck.add_argument("--json", action="store_true"); _add_common(ck)
 
     cf = cards.add_parser(
@@ -1055,7 +1073,7 @@ def _build_parser() -> argparse.ArgumentParser:
         "list", help="list obligations — the READ half (#590): an obligation "
                      "that can be minted and closed but never read makes the "
                      "holder the only auditor")
-    ol.add_argument("--status", choices=["open", "closed", "fallback_fired"])
+    ol.add_argument("--status", choices=["open", "closed", "fallback_fired", "withdrawn"])
     ol.add_argument("--holder", help="only obligations this peer owes")
     ol.add_argument("--card", type=int, dest="card_id", help="only this card")
     ol.add_argument("--overdue", action="store_true",
@@ -1092,6 +1110,15 @@ def _build_parser() -> argparse.ArgumentParser:
                     help="the contract's signed spelling: `+step` adds, `-step` removes "
                          "(write the latter `--needs=-step`; a bare `-step` reads as a flag)")
     oa.add_argument("--json", action="store_true"); _add_common(oa)
+    ow = obl.add_parser(
+        "withdraw",
+        help="WITHDRAW an untaken row (asker, card assignee, or orchestrator). "
+             "A taken row is closed or declined, not withdrawn. Status becomes "
+             "withdrawn, which is neither pass nor fail")
+    ow.add_argument("id", type=int, help="the obligation id")
+    ow.add_argument("--reason", required=True,
+                    help="why the row is withdrawn; whitespace is refused")
+    ow.add_argument("--json", action="store_true"); _add_common(ow)
     return p
 
 
@@ -1194,6 +1221,20 @@ def run_board(argv: list[str]) -> int:
                 return 2
             st, d = _patch_json(f"{gw}/board/obligations/{args.id}/amend", patch, token)
             return _out(st, d, _obligation_act_line, aj)
+        if args.command == "withdraw":
+            reason = args.reason
+            if not reason.strip():
+                print("swarph board obligations withdraw: --reason is "
+                      "whitespace-only", file=sys.stderr)
+                return 2
+            st, d = _post_json(
+                f"{gw}/board/obligations/{args.id}/withdraw",
+                {"reason": reason}, token)
+            return _out(st, d, lambda x: (
+                f"obligation #{_s(x.get('id', args.id))} WITHDRAWN by "
+                f"{_s(x.get('closed_by', self_name))}"
+                + (f" task {_s(x.get('task'))}" if x.get("task") else "")
+            ), aj)
 
     if args.group == "cards":
         if args.command == "list":
@@ -1350,7 +1391,8 @@ def run_board(argv: list[str]) -> int:
             body = _ask_payload(self_name, args.what, holder=holder,
                                 step=args.step, needs=args.needs, hours=args.hours,
                                 done=args.done, accept=args.accept, kind=args.kind,
-                                timeout_hours=args.timeout_hours)
+                                timeout_hours=args.timeout_hours,
+                                task=args.task, task_needs=args.task_needs)
             st, d = _post_json(f"{gw}/board/cards/{args.id}/ask", body, token)
             return _out(st, d, _ask_line, args.json)
         if args.command == "confirm-flow":

{swarph_cli-0.72.14 → swarph_cli-0.72.16}/src/swarph_cli/commands/triage.py

@@ -212,6 +212,7 @@ def run_triage(*, gateway, token, sender, owners_map, state_file,
         sent[key] = now_iso
         return True
 
+    from swarph_cli.triage.backend import BackendError
     from swarph_cli.triage.rows import TriageStore
     store = TriageStore(store_backend)
     if dry_run:
@@ -219,8 +220,14 @@ def run_triage(*, gateway, token, sender, owners_map, state_file,
             print(f"DRY {record['source_organ']} {record['type']} "
                   f"sharp={record['sharp']} item={record['item_id']}")
         return 0, {"dry_run_records": len(records)}
-    summary = _job.route_and_store(store, owners_map, records,
-                                   dm_sender=dm_sender)
+    try:
+        summary = _job.route_and_store(store, owners_map, records,
+                                       dm_sender=dm_sender)
+    except BackendError as exc:
+        # A failed create or append names itself here and exits non-zero
+        # — never the bare 'accept line not added' assertion (#1446).
+        print(f"swarph triage: board write failed: {exc}", file=sys.stderr)
+        return 1, {"board_error": str(exc)}
     _save_state(state_file, sent)
     return 0, summary
 
@@ -262,6 +269,9 @@ def _build_parser():
     p.add_argument("--owners-file", default=None,
                    help="local owner-map override (PROVEN calibration "
                         "writes here; deep-merges over shipped owners.json)")
+    p.add_argument("--project-id", type=int, default=None,
+                   help="board project for triage-row cards (default: "
+                        "project_id from the owner map, 9)")
     p.add_argument("--json", action="store_true")
     p.add_argument("--as", dest="self_name", default=None,
                    help="DM sender identity")
@@ -298,9 +308,12 @@ def run_triage_cmd(argv):
             return 2
         state_file = args.state_file or os.environ.get(
             "SWARPH_SWEEP_STATE", _sweep._default_state_file())
+        project_id = (args.project_id if args.project_id is not None
+                      else owners_map.get("project_id", 9))
         backend = _backend.BoardBackend(
             args.gateway, resolution.token, sender,
-            _mesh._http_get_json, _mesh._post_json)
+            _mesh._http_get_json, _mesh._post_json,
+            project_id=project_id)
         rc, summary = run_triage(
             gateway=args.gateway, token=resolution.token, sender=sender,
             owners_map=owners_map, state_file=state_file,

{swarph_cli-0.72.14 → swarph_cli-0.72.16}/src/swarph_cli/triage/backend.py

@@ -5,20 +5,36 @@ protocol; production rows live on board cards titled "<owner> triage".
 from __future__ import annotations
 
 
+class BackendError(RuntimeError):
+    """A named board failure: what was attempted, the HTTP status, and
+    the gateway's own detail. Raised, never a row with id None."""
+
+
 class MemoryBackend:
-    """In-memory double for tests: rows are dicts, posts are dicts."""
+    """In-memory double for tests: rows are dicts, posts are dicts.
+
+    Strict where the gateway is strict (card #1073, #1446): a create
+    without a project_id is refused, and a post to a thread that does
+    not exist is refused — the old permissive double is what let the
+    0.72.14 live failure pass every test.
+    """
 
-    def __init__(self):
+    def __init__(self, project_id=9):
         self.rows: dict[str, dict] = {}
         self.posts: dict[str, list[dict]] = {}
         self.next_id = 1
+        self.project_id = project_id
 
     def find_open_row(self, title):
         return self.rows.get(title)
 
     def create_row(self, title, owner):
+        if self.project_id is None:
+            raise BackendError(
+                f"create '{title}': project_id is required — the gateway "
+                f"refuses a card create without one (BoardCardCreate)")
         row = {"id": self.next_id, "title": title, "owner": owner,
-               "status": "open"}
+               "project_id": self.project_id, "status": "open"}
         self.next_id += 1
         self.rows[title] = row
         self.posts[title] = []
@@ -28,6 +44,10 @@ class MemoryBackend:
         return list(self.posts.get(row["title"], []))
 
     def append(self, row, body, kind="item"):
+        if row["title"] not in self.posts:
+            raise BackendError(
+                f"post to '{row['title']}': no such thread — the row was "
+                f"never created")
         post = {"id": self.next_id, "body": body, "kind": kind}
         self.next_id += 1
         self.posts[row["title"]].append(post)
@@ -49,12 +69,26 @@ class BoardBackend:
     gateway errors by returning None/[] (unevaluable, never invented).
     """
 
-    def __init__(self, gateway, token, sender, http_get, http_post):
+    def __init__(self, gateway, token, sender, http_get, http_post,
+                 project_id=9):
         self.gateway = gateway.rstrip("/")
         self.token = token
         self.sender = sender
         self._http_get = http_get
         self._http_post = http_post
+        self.project_id = project_id
+
+    @staticmethod
+    def _detail(body) -> str:
+        if isinstance(body, dict):
+            detail = body.get("detail")
+            if isinstance(detail, str) and detail.strip():
+                return detail.strip()
+        return "<no detail>"
+
+    def _refused(self, what: str, status, body) -> BackendError:
+        return BackendError(
+            f"{what}: gateway refused {status}: {self._detail(body)}")
 
     def find_open_row(self, title):
         try:
@@ -76,31 +110,50 @@ class BoardBackend:
         return None
 
     def create_row(self, title, owner):
+        # BoardCardCreate REQUIRES project_id (card #1073, #1446: the
+        # 0.72.14 live run POSTed title+body only, was refused, and the
+        # old code carried the refusal forward as a row with id None).
+        # The owner is the card assignee, so the row lands in a queue.
+        payload = {"actor": self.sender, "project_id": self.project_id,
+                   "title": title,
+                   "body": f"Daily triage row for {owner} (card #1073). "
+                           "Items are appended by the triage job; "
+                           "owners work them off the row.",
+                   "assignee": owner}
         try:
             status, body = self._http_post(
-                f"{self.gateway}/board/cards",
-                {"title": title,
-                 "body": f"Daily triage row for {owner} (card #1073). "
-                         "Items are appended by the triage job; "
-                         "owners work them off the row."},
-                self.token)
-        except Exception:
-            return {"id": None, "title": title, "status": "unknown"}
+                f"{self.gateway}/board/cards", payload, self.token)
+        except Exception as exc:
+            raise BackendError(f"create '{title}': {exc}") from exc
+        if status is None or not 200 <= status < 300:
+            raise self._refused(f"create '{title}'", status, body)
         card = body if isinstance(body, dict) else {}
+        if not isinstance(card.get("id"), int):
+            raise BackendError(
+                f"create '{title}': gateway replied {status} with no card "
+                f"id: {self._detail(body)}")
         return {"id": card.get("id"), "title": title, "owner": owner,
                 "status": "open"}
 
     def _thread_uuid(self, row):
         if not row.get("id"):
-            return None
+            raise BackendError(
+                f"post to '{row.get('title')}': the row has no board id — "
+                f"its create failed and was not reported")
         try:
             status, body = self._http_get(
                 f"{self.gateway}/board/cards/{row['id']}", self.token)
-        except Exception:
-            return None
+        except Exception as exc:
+            raise BackendError(
+                f"thread of '{row.get('title')}': {exc}") from exc
         if status != 200 or not isinstance(body, dict):
-            return None
-        return body.get("thread_uuid")
+            raise self._refused(f"thread of '{row.get('title')}'", status,
+                                body)
+        thread_uuid = body.get("thread_uuid")
+        if not thread_uuid:
+            raise BackendError(
+                f"thread of '{row.get('title')}': card has no thread")
+        return thread_uuid
 
     def list_posts(self, row):
         if not row.get("id"):
@@ -121,8 +174,6 @@ class BoardBackend:
 
     def append(self, row, body, kind="item"):
         thread_uuid = self._thread_uuid(row)
-        if thread_uuid is None:
-            return {"id": None, "body": body, "kind": kind}
         try:
             status, resp = self._http_post(
                 f"{self.gateway}/messages",
@@ -131,7 +182,11 @@ class BoardBackend:
                  "kind": "answer" if kind == "security" else "fyi",
                  "content": body, "thread_id": thread_uuid},
                 self.token)
-        except Exception:
-            return {"id": None, "body": body, "kind": kind}
+        except Exception as exc:
+            raise BackendError(
+                f"append to '{row.get('title')}': {exc}") from exc
+        if status is None or not 200 <= status < 300:
+            raise self._refused(f"append to '{row.get('title')}'", status,
+                                resp)
         msg = resp if isinstance(resp, dict) else {}
         return {"id": msg.get("id"), "body": body, "kind": kind}

{swarph_cli-0.72.14 → swarph_cli-0.72.16}/src/swarph_cli/triage/owners.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "comment": "Organ triage owner map + calibration thresholds (card #1073, rulings #1413). DATA, not code: the router reads this file and contains no owner or threshold literals. Thresholds are written by a PROVEN calibration; until an organ has one, every model result for it is split. Owners keyed here route to '<owner> triage' rows; an organ with no entry routes to lab-ovh and is counted.",
+  "comment": "Organ triage owner map + calibration thresholds (card #1073, rulings #1413). DATA, not code: the router reads this file and contains no owner or threshold literals. Thresholds are written by a PROVEN calibration; until an organ has one, every model result for it is split. Owners keyed here route to '<owner> triage' rows; an organ with no entry routes to lab-ovh and is counted. project_id is the board project triage-row cards are created under (BoardCardCreate requires it; #1446).",
   "owners": {
     "stuck-work": {
       "owner": null,
@@ -19,6 +19,7 @@
       "note": "pattern: detector calibration -> science-claude"
     }
   },
+  "project_id": 9,
   "thresholds": {},
   "label_sets": {
     "stuck-work": ["real-stall", "deliberate-wait", "needed-row-closed-race"],

{swarph_cli-0.72.14 → swarph_cli-0.72.16/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.14
+Version: 0.72.16
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.14 → swarph_cli-0.72.16}/src/swarph_cli.egg-info/SOURCES.txt

@@ -216,7 +216,9 @@ tests/test_1064_stuck_sweep.py
 tests/test_1065_release.py
 tests/test_1066_quiet_wakes.py
 tests/test_1073_triage.py
+tests/test_1073_triage_board.py
 tests/test_1073_wheel_install.py
+tests/test_1075_task_cli.py
 tests/test_124_register_merge.py
 tests/test_126_pending_from_complete.py
 tests/test_132_ensure_monitor_state_dir.py

swarph_cli-0.72.16/tests/test_1073_triage_board.py

@@ -0,0 +1,254 @@
+"""card #1073 rework (#1446): the router's first live run died on the
+board it never wrote to in tests.
+
+0.72.14 POSTed a card create with title+body only; the gateway refused
+it (BoardCardCreate requires project_id); the old code carried the
+refusal forward as a row with id None and died on the bare 'accept
+line not added' assertion. These tests pin the fix: the create sends
+project_id + assignee, every non-2xx names its status and detail, the
+run exits non-zero saying so, and the double rejects what the gateway
+rejects (a create without project_id, a post to a missing thread).
+"""
+from __future__ import annotations
+
+import pytest
+
+from swarph_cli.commands import triage as _triage_cmd
+from swarph_cli.triage import backend as _backend
+from swarph_cli.triage import router as _router
+
+NOW = 1_790_000_000.0
+
+
+def _iso(age_s):
+    from datetime import datetime, timezone
+    return datetime.fromtimestamp(NOW - age_s, timezone.utc).isoformat()
+
+
+class _FakeHttp:
+    """Records bodies; scripted (status, body) per URL suffix.
+
+    Enforces caller-binding like the gateway (card #1073, #1451):
+    POST /board/cards requires actor == the sender, POST /messages
+    requires from_node == the sender; anything else is refused 403
+    with the gateway's shape. Enforcement runs before the scripted
+    responses, so a mutant dropping the identity fails every test.
+    """
+
+    def __init__(self, sender="lab-ovh"):
+        self.posts = []
+        self.scripts = {}
+        self.sender = sender
+        self.card_threads = {}
+        self.thread_messages = {}
+        self.next_id = 501
+
+    def on_post(self, suffix, status, body):
+        self.scripts[("POST", suffix)] = (status, body)
+
+    def on_get(self, suffix, status, body):
+        self.scripts[("GET", suffix)] = (status, body)
+
+    def _binding_refusal(self, field, claimed):
+        return (403, {"detail":
+                      f"caller-binding: authenticated peer {self.sender!r} "
+                      f"may not act as {field}={claimed!r}"})
+
+    def post(self, url, payload, token):
+        self.posts.append((url, dict(payload)))
+        if url.endswith("/board/cards"):
+            actor = payload.get("actor")
+            if actor != self.sender:
+                return self._binding_refusal("actor", actor)
+        if url.endswith("/messages"):
+            sender = payload.get("from_node")
+            if sender != self.sender:
+                return self._binding_refusal("from_node", sender)
+        for (method, suffix), response in self.scripts.items():
+            if method == "POST" and url.endswith(suffix):
+                status, body = response
+                if url.endswith("/messages") and status is not None and (
+                        200 <= status < 300):
+                    # Like the gateway, a thread-bound post lands in the
+                    # card thread a later GET .../thread reads back.
+                    self.thread_messages.setdefault(
+                        payload.get("thread_id"), []).append(
+                        {"id": self.next_id,
+                         "content": payload.get("content"),
+                         "kind": payload.get("kind")})
+                    self.next_id += 1
+                return response
+        raise AssertionError(f"unscripted POST {url}")
+
+    def get(self, url, token):
+        import re
+        thread = re.search(r"/board/cards/(\d+)/thread$", url)
+        if thread:
+            uuid = self.card_threads.get(thread.group(1))
+            return 200, {"card_id": int(thread.group(1)),
+                         "messages": list(
+                             self.thread_messages.get(uuid, []))}
+        for (method, suffix), response in self.scripts.items():
+            if method == "GET" and url.endswith(suffix):
+                card = re.search(r"/board/cards/(\d+)$", url)
+                if card and isinstance(response[1], dict):
+                    uuid = response[1].get("thread_uuid")
+                    if uuid:
+                        self.card_threads[card.group(1)] = uuid
+                return response
+        raise AssertionError(f"unscripted GET {url}")
+
+
+def _board(project_id=9):
+    http = _FakeHttp()
+    return _backend.BoardBackend("http://gw:9", "tok", "lab-ovh",
+                                 http.get, http.post,
+                                 project_id=project_id), http
+
+
+def test_create_sends_project_id_and_assignee():
+    backend, http = _board(project_id=9)
+    http.on_post("/board/cards", 200, {"id": 77})
+    row = backend.create_row("lab-ovh triage", "lab-ovh")
+    assert row["id"] == 77
+    _url, payload = http.posts[-1]
+    assert payload["project_id"] == 9
+    assert payload["assignee"] == "lab-ovh"
+    assert payload["title"] == "lab-ovh triage"
+    assert payload["actor"] == "lab-ovh"
+
+
+def test_actor_none_is_refused_like_the_live_run():
+    """The 0.72.15 shape: no actor identity on the create is a 403
+    naming caller-binding, not a silent row."""
+    backend, http = _board()
+    backend.sender = None
+    with pytest.raises(_backend.BackendError) as exc:
+        backend.create_row("lab-ovh triage", "lab-ovh")
+    assert "403" in str(exc.value) and "caller-binding" in str(exc.value)
+
+
+def test_append_without_sender_is_refused():
+    backend, http = _board()
+    http.on_get("/board/cards/77", 200, {"id": 77,
+                                         "thread_uuid": "thread-1"})
+    backend.sender = None
+    row = {"id": 77, "title": "lab-ovh triage", "owner": "lab-ovh",
+           "status": "open"}
+    with pytest.raises(_backend.BackendError) as exc:
+        backend.append(row, "ACCEPT x y")
+    assert "403" in str(exc.value) and "from_node" in str(exc.value)
+
+
+def test_create_422_names_status_and_detail():
+    backend, http = _board()
+    http.on_post("/board/cards", 422, {"detail": "project_id: field required"})
+    with pytest.raises(_backend.BackendError) as exc:
+        backend.create_row("lab-ovh triage", "lab-ovh")
+    assert "422" in str(exc.value)
+    assert "project_id: field required" in str(exc.value)
+
+
+def test_append_422_names_status_and_detail():
+    backend, http = _board()
+    http.on_get("/board/cards/77", 200, {"id": 77,
+                                         "thread_uuid": "thread-1"})
+    http.on_post("/messages", 422, {"detail": "unknown thread"})
+    row = {"id": 77, "title": "lab-ovh triage", "owner": "lab-ovh",
+           "status": "open"}
+    with pytest.raises(_backend.BackendError) as exc:
+        backend.append(row, "ACCEPT x y")
+    assert "422" in str(exc.value) and "unknown thread" in str(exc.value)
+
+
+def test_failed_create_is_never_a_row_with_id_none():
+    backend, http = _board()
+    http.on_post("/board/cards", 500, {"detail": "boom"})
+    with pytest.raises(_backend.BackendError):
+        backend.create_row("lab-ovh triage", "lab-ovh")
+
+
+def test_memory_double_rejects_create_without_project_id():
+    backend = _backend.MemoryBackend(project_id=None)
+    with pytest.raises(_backend.BackendError) as exc:
+        backend.create_row("lab-ovh triage", "lab-ovh")
+    assert "project_id" in str(exc.value)
+
+
+def test_memory_double_rejects_post_to_missing_thread():
+    backend = _backend.MemoryBackend()
+    with pytest.raises(_backend.BackendError) as exc:
+        backend.append({"id": 999, "title": "ghost triage",
+                        "owner": "lab-ovh", "status": "open"}, "ACCEPT x y")
+    assert "no such thread" in str(exc.value)
+
+
+def _board_fixture():
+    old = _iso(10 * 86400)
+    waiter = {"id": 1, "status": "open", "taken_at": old, "step": "build",
+              "card_id": 7, "holder": "waiter"}
+    dep = {"id": 2, "status": "open", "holder": "lab-ovh",
+           "holder_known": True, "created_at": old, "card_id": 8}
+    return [waiter], {1: waiter, 2: dep}, {"lab-ovh"}
+
+
+def _live_http():
+    http = _FakeHttp()
+    http.on_get("/board/cards/7/graph", 200, {"steps": [
+        {"step": "build", "needs": [
+            {"step": "dep", "row_id": 2, "satisfied": False}]}]})
+    http.on_get("/board/cards/8", 200, {"id": 8, "due_at": None})
+    return http
+
+
+def test_run_names_the_refusal_and_exits_nonzero(capsys, tmp_path):
+    """The 0.72.14 shape end to end: the create is refused, the run
+    says so (status + detail) and exits 1 — no bare assertion."""
+    backend, http = _board()
+    http.on_post("/board/cards", 422,
+                 {"detail": "project_id: field required"})
+    live = _live_http()
+    rows, by_id, peers = _board_fixture()
+    rc, summary = _triage_cmd.run_triage(
+        gateway="http://gw:9", token="tok", sender="lab-ovh",
+        owners_map=_router.load_owners(_triage_cmd._OWNERS_DEFAULT),
+        state_file=str(tmp_path / "state.json"), store_backend=backend,
+        peers_fetcher=None, board_fetcher=lambda: (rows, by_id, peers),
+        http_get=live.get, http_post=http.post, now=NOW)
+    err = capsys.readouterr().err
+    assert rc == 1
+    assert "422" in err and "project_id: field required" in err
+    assert "accept line not added" not in err
+    assert "board_error" in summary
+
+
+def test_run_dm_carries_sender_identity(tmp_path):
+    """Third write path (card #1073, #1451): the one-a-day DM POSTs
+    /messages with from_node == the sender. Caller-binding enforcement
+    is active on the fake, so a mutant dropping the identity fails
+    here (append raises first) or starves dm_sent (DM refused)."""
+    http = _FakeHttp()
+    http.on_get("/board/cards", 200, {"cards": []})
+    http.on_get("/board/cards/7/graph", 200, {"steps": [
+        {"step": "build", "needs": [
+            {"step": "dep", "row_id": 2, "satisfied": False}]}]})
+    http.on_get("/board/cards/8", 200, {"id": 8, "due_at": None})
+    http.on_get("/board/cards/77", 200, {"id": 77,
+                                         "thread_uuid": "thread-1"})
+    http.on_post("/board/cards", 200, {"id": 77})
+    http.on_post("/messages", 200, {"id": 501})
+    backend = _backend.BoardBackend(
+        "http://gw:9", "tok", "lab-ovh", http.get, http.post,
+        project_id=9)
+    rows, by_id, peers = _board_fixture()
+    rc, summary = _triage_cmd.run_triage(
+        gateway="http://gw:9", token="tok", sender="lab-ovh",
+        owners_map=_router.load_owners(_triage_cmd._OWNERS_DEFAULT),
+        state_file=str(tmp_path / "state.json"), store_backend=backend,
+        peers_fetcher=None, board_fetcher=lambda: (rows, by_id, peers),
+        http_get=http.get, http_post=http.post, now=NOW)
+    assert rc == 0
+    assert summary["dm_sent"] == 1
+    message_posts = [p for u, p in http.posts if u.endswith("/messages")]
+    assert message_posts, "no /messages write happened at all"
+    assert all(p.get("from_node") == "lab-ovh" for p in message_posts)

swarph_cli-0.72.16/tests/test_1075_task_cli.py

@@ -0,0 +1,24 @@
+"""card #1075 — the ask carries a task id, and withdraw is its own act."""
+from swarph_cli.commands import board
+
+
+def test_ask_payload_sends_task_and_omits_it_when_absent():
+    p = board._ask_payload(
+        "cursor-lin", "wire it", holder="me", step="build",
+        task="task:pr-lab-orchestrator-160",
+        task_needs=["task:pr-lab-orchestrator-159"])
+    assert p["task"] == "task:pr-lab-orchestrator-160"
+    assert p["task_needs"] == ["task:pr-lab-orchestrator-159"]
+    assert p["holder"] == "cursor-lin"
+    bare = board._ask_payload("cursor-lin", "wire it", step="build")
+    assert "task" not in bare and "task_needs" not in bare
+
+
+def test_withdraw_is_a_command():
+    parser = board._build_parser()
+    args = parser.parse_args(
+        ["obligations", "withdraw", "1422", "--reason", "asker pulls it"])
+    assert args.group == "obligations"
+    assert args.command == "withdraw"
+    assert args.id == 1422
+    assert args.reason == "asker pulls it"