diff --git a/ceki_sdk/__init__.py b/ceki_sdk/__init__.py
index 4a5fe32..b5b3b01 100644
--- a/ceki_sdk/__init__.py
+++ b/ceki_sdk/__init__.py
@@ -21,7 +21,7 @@
 from ._profile import BrowserProfile
 from .humanize import HumanProfile
 
-__version__ = "2.23.0"
+__version__ = "2.35.0"
 __all__ = [
     "connect",
     "ConnectOptions",
diff --git a/ceki_sdk/_browser.py b/ceki_sdk/_browser.py
index 8645ece..41f7f63 100644
--- a/ceki_sdk/_browser.py
+++ b/ceki_sdk/_browser.py
@@ -486,6 +486,121 @@ async def upload(
 
         return parsed
 
+    async def _dispatch_hotkey(self, key: str, code: str) -> None:
+        """Dispatch a Ctrl+<key> hotkey as ``keyDown``+``keyUp`` via CDP.
+
+        ``modifiers=2`` is Chromium's bitmask for Control. We fire both
+        ``keyDown`` and ``keyUp`` because the browser's clipboard shortcuts
+        only trigger on a full press cycle. Used by :meth:`copy` (Ctrl+C)
+        and :meth:`paste` (Ctrl+C on the seed textarea, then Ctrl+V on the
+        target).
+        """
+        vk = ord(key.upper())
+        params = {
+            "modifiers": 2,
+            "key": key,
+            "code": code,
+            "windowsVirtualKeyCode": vk,
+            "nativeVirtualKeyCode": vk,
+        }
+        await self.send({
+            "method": "Input.dispatchKeyEvent",
+            "params": {"type": "keyDown", **params},
+        })
+        await self.send({
+            "method": "Input.dispatchKeyEvent",
+            "params": {"type": "keyUp", **params},
+        })
+
+    async def copy(self) -> str:
+        """Copy the current window selection into the OS clipboard, return it.
+
+        Reads the current selection text via ``Runtime.evaluate``
+        (``window.getSelection().toString()``) so the caller still gets it as a
+        return value, then dispatches a synthetic ``Ctrl+C`` via
+        ``Input.dispatchKeyEvent`` — that is the step that actually flips the OS
+        clipboard. Verified against real headed Chromium in contract task 4098.
+
+        The reason we read the selection before Ctrl+C rather than reading it
+        back from the clipboard: the main-mode CDP allowlist forbids
+        ``navigator.clipboard``, and ``document.execCommand('paste')`` is dead
+        in modern Chromium, so there's no read-back path from JS. Reading the
+        selection directly is cheap and gives an exact return value.
+
+        Returns:
+            The selection text (``""`` when nothing is selected). The OS
+            clipboard is flipped as a side effect regardless of the return.
+        """
+        result = await self.send({
+            "method": "Runtime.evaluate",
+            "params": {
+                "expression": "window.getSelection().toString()",
+                "returnByValue": True,
+            },
+        })
+        selection = (result.get("result") or {}).get("value") or ""
+        await self._dispatch_hotkey("c", "KeyC")
+        return selection
+
+    async def paste(self, selector: str, text: str) -> None:
+        """Put ``text`` into the OS clipboard, focus ``selector``, Ctrl+V it in.
+
+        Real system-clipboard paste: a temporary offscreen ``<textarea>`` is
+        created and selected, then a synthetic ``Ctrl+C`` flips the OS
+        clipboard to ``text``. The temp element is removed, the target element
+        is focused, and a synthetic ``Ctrl+V`` fires — which dispatches a real
+        ``ClipboardEvent`` (``paste`` handler + ``input`` event with
+        ``inputType='insertFromPaste'``). Verified against real headed
+        Chromium in contract task 4098.
+
+        Both ``selector`` and ``text`` are JSON-escaped when interpolated into
+        the ``Runtime.evaluate`` expression — quotes, backticks, backslashes,
+        newlines, and unicode are safe.
+
+        Args:
+            selector: CSS selector for the target input / textarea /
+                contentEditable / any focusable element.
+            text: Arbitrary string to paste. Empty string is allowed; it
+                seeds an empty clipboard and Ctrl+V still fires the
+                ``paste`` event.
+
+        Raises:
+            The underlying ``Runtime.evaluate`` will surface a JS TypeError if
+            ``querySelector`` returns ``null`` — the send() call will reject
+            with a CDP error rather than silently swallowing it.
+        """
+        text_lit = json.dumps(text)
+        seed_expr = (
+            "(function(){"
+            "var __ceki_tmp__=document.createElement('textarea');"
+            "__ceki_tmp__.id='__ceki_paste_tmp__';"
+            "__ceki_tmp__.style.cssText='position:fixed;left:-9999px;top:0;opacity:0';"
+            f"__ceki_tmp__.value={text_lit};"
+            "document.body.appendChild(__ceki_tmp__);"
+            "__ceki_tmp__.focus();__ceki_tmp__.select();"
+            "})()"
+        )
+        await self.send({
+            "method": "Runtime.evaluate",
+            "params": {"expression": seed_expr},
+        })
+        await self._dispatch_hotkey("c", "KeyC")
+
+        selector_lit = json.dumps(selector)
+        cleanup_focus_expr = (
+            "(function(){"
+            "var t=document.getElementById('__ceki_paste_tmp__');"
+            "if(t)t.remove();"
+            f"var el=document.querySelector({selector_lit});"
+            "el.focus();"
+            "})()"
+        )
+        await self.send({
+            "method": "Runtime.evaluate",
+            "params": {"expression": cleanup_focus_expr},
+        })
+        await self._dispatch_hotkey("v", "KeyV")
+
     def set_human(self, profile) -> "HumanProfile | None":
         prev = self._humanizer.profile if self._humanizer else None
         self._humanizer = _resolve_human(profile)
diff --git a/ceki_sdk/cli.py b/ceki_sdk/cli.py
index aa72519..0fa85d8 100644
--- a/ceki_sdk/cli.py
+++ b/ceki_sdk/cli.py
@@ -420,6 +420,93 @@ def _contract_client():
     return ContractClient()
 
 
+def _parse_participant(spec: str) -> dict[str, Any]:
+    """Parse 'agent:5:reviewer' / 'user:7:qa' / 'agent:5:role:42'.
+
+    Returns {participable_id: int, participable_type: 'agent'|'user', role_id: int}
+    — the element shape EventController users[] validation expects
+    (back/2542 renamed the array key from `participants` to `users`;
+    element shape unchanged). CLI flag `--participant` keeps its
+    human-facing name; only the wire key changed.
+    """
+    from .contract import ROLE_QA, ROLE_REVIEWER
+
+    if not spec or not isinstance(spec, str):
+        raise ValueError(f"--participant must be a non-empty string, got: {spec!r}")
+    parts = spec.split(":")
+    if len(parts) < 3:
+        raise ValueError(
+            f"--participant must be 'type:id:role' (e.g. agent:5:reviewer), got: {spec!r}"
+        )
+    ptype, pid, role, *rest = parts
+    if ptype not in ("agent", "user"):
+        raise ValueError(f"--participant type must be 'agent' or 'user', got: {ptype!r}")
+    try:
+        value = int(pid)
+    except ValueError as e:
+        raise ValueError(f"--participant id must be int, got: {pid!r}") from e
+
+    role_map = {"reviewer": ROLE_REVIEWER, "qa": ROLE_QA}
+    if role in role_map:
+        role_id = role_map[role]
+    elif role == "role":
+        if not rest:
+            raise ValueError(
+                f"--participant 'role:NUMBER' needs a number, got: {spec!r}"
+            )
+        try:
+            role_id = int(rest[0])
+        except ValueError as e:
+            raise ValueError(
+                f"--participant role id must be int, got: {rest[0]!r}"
+            ) from e
+    else:
+        raise ValueError(
+            f"--participant unknown role {role!r}; expected 'reviewer', 'qa', "
+            f"or 'role:NUMBER'"
+        )
+    return {
+        "participable_id": value,
+        "type": ptype,
+        "role_id": role_id,
+    }
+
+
+def _parse_tags(spec: str) -> list[dict[str, Any]]:
+    """Parse the `--tags` sugar into settings.tags[] elements.
+
+    Comma-separated list; each item is `key[:label[:color]]`:
+      backend,urgent            -> [{key:backend}, {key:urgent}]
+      backend:Backend:#ff0000   -> [{key:backend, label:Backend, color:#ff0000}]
+      docs::#0af                -> [{key:docs, color:#0af}]   (empty label skipped)
+
+    Returns the {key, label?, color?} dicts the create-contract-event tool
+    persists under events.settings.tags[].
+    """
+    tags: list[dict[str, Any]] = []
+    for raw in spec.split(","):
+        item = raw.strip()
+        if not item:
+            continue
+        key, _, tail = item.partition(":")
+        key = key.strip()
+        if not key:
+            raise ValueError(f"--tags item needs a key, got: {raw!r}")
+        tag: dict[str, Any] = {"key": key}
+        if tail:
+            label, _, color = tail.partition(":")
+            label = label.strip()
+            color = color.strip()
+            if label:
+                tag["label"] = label
+            if color:
+                tag["color"] = color
+        tags.append(tag)
+    if not tags:
+        raise ValueError(f"--tags produced no tags from: {spec!r}")
+    return tags
+
+
 def _contract_dump(value: Any) -> None:
     if isinstance(value, str):
         sys.stdout.write(value)
@@ -448,8 +535,12 @@ def _cmd_contract(args: argparse.Namespace) -> int:
                 for cid in ids:
                     print(f"--- contract {cid} ---")
                     _contract_dump(cli.tasks(int(cid)))
+            elif action == "my-events":
+                _contract_dump(cli.my_events())
             elif action == "my-jobs":
                 _contract_dump(cli.my_jobs())
+            elif action == "call-human":
+                _contract_dump(cli.call_human(args.event_id, args.kind, args.desc))
             elif action == "task":
                 _contract_dump(cli.task(args.eid))
             elif action == "children":
@@ -464,6 +555,15 @@ def _cmd_contract(args: argparse.Namespace) -> int:
                     _err("contract id required (positional or CEKI_CONTRACT_IDS)", "args")
                     return 1
                 data_obj = json.loads(args.data) if args.data else None
+                try:
+                    extra_parts = [
+                        _parse_participant(spec)
+                        for spec in (getattr(args, "participant", None) or [])
+                    ]
+                    tags = _parse_tags(args.tags) if getattr(args, "tags", None) else None
+                except ValueError as e:
+                    _err(str(e), "args")
+                    return 1
                 _contract_dump(cli.create(
                     cid,
                     label=args.label,
@@ -480,11 +580,21 @@ def _cmd_contract(args: argparse.Namespace) -> int:
                     description=args.desc,
                     data=data_obj,
                     benefitable=args.benefitable,
+                    reviewer=args.reviewer,
+                    qa=args.qa,
+                    participants=extra_parts or None,
+                    tags=tags,
                 ))
             elif action == "comment":
+                # A comment's body lives in `label` (events.label is
+                # unbounded TEXT). `--label` wins when both are given;
+                # otherwise `--desc` is the body. `description` is never
+                # sent on a comment — the UI would render it on top of
+                # `label` and duplicate the body.
+                body = args.label if args.label is not None else args.desc
                 _contract_dump(cli.comment(
                     args.eid,
-                    label=args.label,
+                    label=body,
                     type_id=args.type,
                     status_id=args.status,
                     start=args.start,
@@ -493,10 +603,13 @@ def _cmd_contract(args: argparse.Namespace) -> int:
                     duration=args.duration,
                     amount=args.amount,
                     currency=args.currency,
-                    description=args.desc,
                     benefitable=args.benefitable,
                 ))
             elif action == "propose":
+                tags = _parse_tags(args.tags) if getattr(args, "tags", None) else None
+                settings: dict[str, Any] | None = (
+                    {"tags": tags} if tags else None
+                )
                 _contract_dump(cli.propose(
                     args.eid,
                     status_id=args.status,
@@ -509,6 +622,13 @@ def _cmd_contract(args: argparse.Namespace) -> int:
                     amount=args.amount,
                     currency=args.currency,
                     benefitable=args.benefitable,
+                    settings=settings,
+                ))
+            elif action == "progress":
+                _contract_dump(cli.progress(
+                    args.eid,
+                    status=args.status,
+                    desc=args.desc,
                 ))
             elif action == "vote":
                 ids = [int(s) for s in str(args.ids).split(",") if s.strip()]
@@ -748,7 +868,21 @@ def build_parser() -> argparse.ArgumentParser:
     p_ct = csub.add_parser("tasks", help="List contract events (default: CEKI_CONTRACT_IDS)")
     p_ct.add_argument("cid", type=int, nargs="?", help="Contract ID")
 
-    csub.add_parser("my-jobs", help="List events assigned to me")
+    csub.add_parser(
+        "my-events",
+        help=(
+            "List contract events assigned to me (get-my-events). "
+            "The 'plate' feed. Wire tool renamed from get-my-jobs."
+        ),
+    )
+    csub.add_parser(
+        "my-jobs",
+        help=(
+            "List hire schedules I posted, type 3 (get-my-jobs). "
+            "The listings feed. Wire tool reused after the backend swap "
+            "(formerly get-hire-jobs); for contract events use 'my-events'."
+        ),
+    )
 
     p_ctask = csub.add_parser("task", help="Get event")
     p_ctask.add_argument("eid", type=int, help="Event ID")
@@ -779,8 +913,28 @@ def build_parser() -> argparse.ArgumentParser:
     p_cc.add_argument("--amount", type=int)
     p_cc.add_argument("--currency")
     p_cc.add_argument("--benefitable", help="agent:8 or user:61")
+    p_cc.add_argument("--reviewer", help="agent:8 or user:61 (role_id 5 shortcut)")
+    p_cc.add_argument("--qa", help="agent:8 or user:61 (role_id 6 shortcut)")
+    p_cc.add_argument(
+        "--participant",
+        action="append",
+        default=[],
+        dest="participant",
+        help=(
+            "Repeatable. agent:N:reviewer | user:N:qa | agent:N:role:NUMBER. "
+            "Stacks on top of --reviewer/--qa."
+        ),
+    )
     p_cc.add_argument("--desc")
     p_cc.add_argument("--data", help="Extra JSON object passed through as `data`")
+    p_cc.add_argument(
+        "--tags",
+        help=(
+            "Project tags (sugar for settings.tags[]). Comma-separated, each "
+            "item key[:label[:color]]. E.g. 'backend,urgent' or "
+            "'backend:Backend:#ff0000'."
+        ),
+    )
 
     p_cco = csub.add_parser("comment", help="Post comment on event")
     p_cco.add_argument("eid", type=int)
@@ -808,6 +962,22 @@ def build_parser() -> argparse.ArgumentParser:
     p_cp.add_argument("--amount", type=int)
     p_cp.add_argument("--currency")
     p_cp.add_argument("--benefitable")
+    p_cp.add_argument(
+        "--tags",
+        help=(
+            "Project tags (sugar for settings.tags[]). Comma-separated, each "
+            "item key[:label[:color]]. E.g. 'backend,urgent' or "
+            "'backend:Backend:#ff0000'. back/2796 persists onto the event."
+        ),
+    )
+
+    p_cpr = csub.add_parser(
+        "progress",
+        help="Status correction + progress comment (description is not touched)",
+    )
+    p_cpr.add_argument("eid", type=int)
+    p_cpr.add_argument("--status", type=int)
+    p_cpr.add_argument("--desc", required=True)
 
     p_cv = csub.add_parser("vote", help="Vote on correction(s)")
     p_cv.add_argument("eid", type=int)
@@ -819,6 +989,23 @@ def build_parser() -> argparse.ArgumentParser:
     p_cw = csub.add_parser("watch", help="Continuous polling")
     p_cw.add_argument("interval", type=int, nargs="?", default=8, help="Seconds, min 6")
 
+    p_ch = csub.add_parser(
+        "call-human",
+        help="Escalate to a human on an event (input/review/stuck).",
+    )
+    p_ch.add_argument("event_id", type=int)
+    p_ch.add_argument(
+        "--kind",
+        choices=["input", "review", "stuck"],
+        required=True,
+        help="Type of escalation: input | review | stuck.",
+    )
+    p_ch.add_argument(
+        "--desc",
+        required=True,
+        help="Specific question / decision / what was tried.",
+    )
+
     csub.add_parser("tools", help="List available MCP tools")
 
     p_craw = csub.add_parser("raw", help="Call raw MCP tool")
diff --git a/ceki_sdk/contract.py b/ceki_sdk/contract.py
index c3bdde5..6d13bba 100644
--- a/ceki_sdk/contract.py
+++ b/ceki_sdk/contract.py
@@ -11,6 +11,10 @@
 
 from ._config import default_api_url
 
+# Contract role IDs (back/2542 users[] payload — renamed from participants[]).
+ROLE_REVIEWER = 5
+ROLE_QA = 6
+
 
 def _benefitable(value: str | None) -> dict[str, Any] | None:
     if not value:
@@ -22,6 +26,26 @@ def _benefitable(value: str | None) -> dict[str, Any] | None:
     return {"type": btype, "value": int(bid)}
 
 
+def _participant(value: str | None, role_id: int) -> dict[str, Any] | None:
+    """Parse 'agent:8' / 'user:61' into {participable_id, type, role_id}.
+
+    Wire shape declared by the create-contract-event MCP tool schema:
+    `participable_id` + `type` (short token: 'agent' or 'user') +
+    `role_id`. The MCP tool drops any field it does not know about, so
+    sending `participable_type` (FQCN) silently loses the type and the
+    backend membership lookup defaults to user → misleading 422
+    "Participant must be a member of the contract". Send `type`.
+    """
+    base = _benefitable(value)
+    if base is None:
+        return None
+    return {
+        "participable_id": base["value"],
+        "type": base["type"],
+        "role_id": role_id,
+    }
+
+
 def _clean(args: dict[str, Any]) -> dict[str, Any]:
     return {k: v for k, v in args.items() if v is not None}
 
@@ -59,10 +83,17 @@ def _resolve_token() -> str:
     return os.getenv("CEKI_AGENT_TOKEN") or os.getenv("CEKI_API_KEY") or ""
 
 
+# Wire names swapped on the backend:
+#   get-my-jobs   (formerly contract tasks)      → get-my-events
+#   get-hire-jobs (formerly posted hire jobs)    → get-my-jobs
+# The two sugar keys reflect the new, non-cross-contaminated semantics:
+#   "my-events" = contract events assigned to me  (the plate feed)
+#   "my-jobs"   = hire schedules I posted (type 3) (the listings feed)
 _TOOL_MAP = {
     "list": "get-my-contracts",
     "members": "get-contract-members",
     "tasks": "get-contract-events",
+    "my-events": "get-my-events",
     "my-jobs": "get-my-jobs",
     "task": "get-event",
     "children": "get-event-children",
@@ -175,7 +206,43 @@ def members(self, contract_id: int) -> Any:
     def tasks(self, contract_id: int) -> Any:
         return self.call(_TOOL_MAP["tasks"], {"contract_id": int(contract_id)})
 
+    def my_events(self) -> Any:
+        """Contract events assigned to me — the agent's plate feed.
+
+        Calls `get-my-events` (formerly `get-my-jobs`; backend renamed
+        the wire tool when the listings feed reclaimed `get-my-jobs`).
+        """
+        return self.call(_TOOL_MAP["my-events"], {})
+
+    def call_human(self, event_id: int, kind: str, desc: str) -> Any:
+        """Escalate to a human up the event→parent→contract→schedule chain.
+
+        Args:
+            event_id: id of the event to escalate on (must exist).
+            kind: 'input' | 'review' | 'stuck'.
+            desc: what specifically the caller is stuck on.
+
+        Returns a dict shaped
+        ``{"recipients":[{"user_id","label","reason"},...], "dispatched":<int>,
+        "deep_link":"<url>", "kind":"<kind>"}``.
+        """
+        if kind not in ("input", "review", "stuck"):
+            raise ValueError(
+                f"kind must be 'input' | 'review' | 'stuck', got {kind!r}"
+            )
+        return self.call("call-human", {
+            "event_id": int(event_id),
+            "kind": kind,
+            "desc": desc,
+        })
+
     def my_jobs(self) -> Any:
+        """Hire schedules I posted (type 3) — the listings feed.
+
+        Calls `get-my-jobs` (the wire name was reused for this semantic
+        after the backend swap; previously this method returned contract
+        events — use `my_events()` for that now).
+        """
         return self.call(_TOOL_MAP["my-jobs"], {})
 
     def task(self, event_id: int) -> Any:
@@ -206,7 +273,25 @@ def create(
         description: str | None = None,
         data: dict[str, Any] | None = None,
         benefitable: str | None = None,
+        reviewer: str | None = None,
+        qa: str | None = None,
+        participants: list[dict[str, Any]] | None = None,
+        tags: list[dict[str, Any]] | None = None,
     ) -> Any:
+        # back/2542: reviewer/qa now live inside users[] (renamed from
+        # participants[]). Element shape unchanged. The `participants`
+        # kwarg name is kept as a stable Python API for callers, but on
+        # the wire it is emitted under the `users` key.
+        users: list[dict[str, Any]] = []
+        rev = _participant(reviewer, ROLE_REVIEWER)
+        if rev is not None:
+            users.append(rev)
+        qa_p = _participant(qa, ROLE_QA)
+        if qa_p is not None:
+            users.append(qa_p)
+        if participants:
+            users.extend(participants)
+
         args = _clean({
             "contract_id": int(contract_id),
             "label": label,
@@ -223,6 +308,11 @@ def create(
             "description": description,
             "data": data,
             "benefitable": _benefitable(benefitable),
+            "users": users if users else None,
+            # back/3165: project tags live in events.settings.tags[]. `tags`
+            # is CLI/SDK sugar — a bare list of {key,label?,color?} dicts —
+            # emitted on the wire under the `settings` blob the backend expects.
+            "settings": {"tags": tags} if tags else None,
         })
         return self.call(_TOOL_MAP["create"], args)
 
@@ -239,9 +329,16 @@ def comment(
         duration: int | None = None,
         amount: int | None = None,
         currency: str | None = None,
-        description: str | None = None,
         benefitable: str | None = None,
     ) -> Any:
+        """Post a comment event.
+
+        The comment body lives entirely in `label` (events.label is
+        unbounded TEXT). `description` is deliberately NOT exposed: the
+        web UI renders both `label` and `description` on a comment, and
+        the human-typed path only writes to `label`. Passing both would
+        produce a visible duplicate in the renderer.
+        """
         args = _clean({
             "event_id": int(event_id),
             "label": label,
@@ -253,7 +350,6 @@ def comment(
             "duration": duration,
             "amount": amount,
             "currency": currency,
-            "description": description,
             "benefitable": _benefitable(benefitable),
         })
         return self.call(_TOOL_MAP["comment"], args)
@@ -272,6 +368,7 @@ def propose(
         amount: int | None = None,
         currency: str | None = None,
         benefitable: str | None = None,
+        settings: dict[str, Any] | None = None,
     ) -> Any:
         args = _clean({
             "event_id": int(event_id),
@@ -285,9 +382,37 @@ def propose(
             "amount": amount,
             "currency": currency,
             "benefitable": _benefitable(benefitable),
+            # back/2796: ProposeCorrectionTool persists settings (tags,
+            # reply_to, blocked_by, do_after) onto the event. Forwarded
+            # verbatim — only attached when the caller supplies it.
+            "settings": settings,
         })
         return self.call(_TOOL_MAP["propose"], args)
 
+    def progress(
+        self,
+        event_id: int,
+        *,
+        status: int | None = None,
+        desc: str,
+    ) -> dict[str, Any]:
+        """Status correction (optional) + progress comment in one shot.
+
+        The event's own description is NOT touched. `--desc` becomes the
+        body of a child comment-event, not a label/description overwrite
+        on the parent event. Use this for Hand/QA/Reviewer progress
+        reports — `propose --desc` would clobber the parent spec.
+        """
+        status_result: Any = None
+        if status is not None:
+            status_result = self.propose(event_id, status_id=int(status))
+        # events.label is unbounded TEXT — the full body lives there, and
+        # `description` is never set on a comment (the UI renders both,
+        # which would duplicate the body for SDK-posted comments).
+        label = desc if (desc or "").strip() else "progress"
+        comment_result = self.comment(event_id, label=label)
+        return {"status_correction": status_result, "comment": comment_result}
+
     def vote(self, event_id: int, ids: list[int], vote: bool) -> Any:
         return self.call(_TOOL_MAP["vote"], {
             "event_id": int(event_id),
diff --git a/pyproject.toml b/pyproject.toml
index 8b4794f..18c9375 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ceki-sdk"
-version = "2.26.0"
+version = "2.35.0"
 description = "Python SDK for browser.ceki.me — rent real browsers from real people"
 readme = "README.md"
 license = {text = "MIT"}
diff --git a/tests/test_contract.py b/tests/test_contract.py
index 961df8b..94c15af 100644
--- a/tests/test_contract.py
+++ b/tests/test_contract.py
@@ -6,7 +6,7 @@
 import httpx
 import pytest
 
-from ceki_sdk.cli import build_parser
+from ceki_sdk.cli import _parse_tags, build_parser
 from ceki_sdk.contract import (
     ContractClient,
     ContractError,
@@ -188,6 +188,44 @@ def test_comment_strips_undefined():
     assert "amount" not in args
     assert "currency" not in args
     assert "benefitable" not in args
+    # task 2936 — `description` must never appear on a comment payload.
+    assert "description" not in args
+
+
+def test_comment_long_multiline_body_in_label_no_description():
+    """Regression guard for task 2936 (duplicate-comment bug).
+
+    A comment's body lives ENTIRELY in `label` (events.label is
+    unbounded TEXT). `description` is not part of the comment() API and
+    must never end up on the wire — the web renderer would show both
+    `label` and `description`, duplicating the body.
+    """
+    http, _ = _http_mock(_mcp_text({"id": 99}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    body = (
+        "long body across\nmultiple lines exceeding 60 characters in "
+        "total length here for sure"
+    )
+    c.comment(99, label=body)
+    args = _captured_body(http)["params"]["arguments"]
+    # Full body, untruncated, multi-line preserved.
+    assert args["label"] == body
+    assert len(body) > 60  # sanity — the body really is over 60 chars
+    # No description key at all on the wire.
+    assert "description" not in args
+
+
+def test_comment_no_description_kwarg():
+    """The comment() public API must not accept `description=`.
+
+    Dropping this kwarg is the API-level breaking change for 2.30.0:
+    a comment's body lives in `label`. Anyone still passing
+    `description=` gets a TypeError at call time, which is the loud
+    failure we want.
+    """
+    c = ContractClient(endpoint="http://x/mcp/agent", token="t")
+    with pytest.raises(TypeError):
+        c.comment(99, label="x", description="y")  # type: ignore[call-arg]
 
 
 def test_propose_maps_tool():
@@ -217,6 +255,57 @@ def test_history_tool_name():
     assert body["params"]["arguments"] == {"event_id": 42}
 
 
+def test_my_events_uses_get_my_events_tool():
+    """Pin the new wire name for the contract-task plate feed.
+
+    Backend swapped: the wire tool that returns contract events
+    assigned to me is now `get-my-events` (formerly `get-my-jobs`).
+    The Python method is `ContractClient.my_events()`.
+    """
+    http, _ = _http_mock(_mcp_text([]))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.my_events()
+    body = _captured_body(http)
+    assert body["params"]["name"] == "get-my-events"
+    assert body["params"]["arguments"] == {}
+
+
+def test_my_jobs_uses_get_my_jobs_tool_for_hire_schedules():
+    """Pin the reused wire name for the hire-schedules listings feed.
+
+    Backend swapped: `get-my-jobs` (the wire tool) now returns the
+    hire schedules I posted (type 3) — what was previously served by
+    `get-hire-jobs`. The Python method `ContractClient.my_jobs()`
+    targets this new semantic; for contract events use `my_events()`.
+    """
+    http, _ = _http_mock(_mcp_text([]))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.my_jobs()
+    body = _captured_body(http)
+    assert body["params"]["name"] == "get-my-jobs"
+    assert body["params"]["arguments"] == {}
+
+
+def test_no_hire_jobs_wire_name_anywhere():
+    """The old `get-hire-jobs` wire name must be gone from the SDK map."""
+    from ceki_sdk.contract import _TOOL_MAP
+    assert "get-hire-jobs" not in _TOOL_MAP.values()
+    # And the new entries are present under the right sugar keys.
+    assert _TOOL_MAP["my-events"] == "get-my-events"
+    assert _TOOL_MAP["my-jobs"] == "get-my-jobs"
+
+
+def test_parser_contract_my_events():
+    a = build_parser().parse_args(["contract", "my-events"])
+    assert a.command == "contract" and a.contract_action == "my-events"
+
+
+def test_parser_contract_my_jobs_still_present():
+    """`contract my-jobs` is still a valid CLI action (now hire schedules)."""
+    a = build_parser().parse_args(["contract", "my-jobs"])
+    assert a.command == "contract" and a.contract_action == "my-jobs"
+
+
 # ── polling ───────────────────────────────────────────────────────
 
 
@@ -336,6 +425,61 @@ def test_propose_passes_start_end_date():
     assert args["start"] == "s" and args["end"] == "e" and args["date"] == "2026-06-18"
 
 
+def test_propose_forwards_settings_tags_verbatim():
+    """back/2796 / 2825: propose() forwards settings (tags, reply_to,
+    blocked_by, do_after) verbatim onto the propose-correction wire."""
+    http, _ = _http_mock(_mcp_text({}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.propose(
+        7,
+        status_id=222,
+        settings={
+            "tags": [
+                {"key": "backend"},
+                {"key": "ui", "label": "UI"},
+                {"key": "bug", "label": "Bug", "color": "red"},
+            ],
+            "reply_to": 42,
+            "blocked_by": [9, 10],
+            "do_after": "2026-07-04T00:00:00Z",
+        },
+    )
+    args = _captured_body(http)["params"]["arguments"]
+    assert args["settings"] == {
+        "tags": [
+            {"key": "backend"},
+            {"key": "ui", "label": "UI"},
+            {"key": "bug", "label": "Bug", "color": "red"},
+        ],
+        "reply_to": 42,
+        "blocked_by": [9, 10],
+        "do_after": "2026-07-04T00:00:00Z",
+    }
+
+
+def test_propose_omits_settings_when_not_supplied():
+    http, _ = _http_mock(_mcp_text({}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.propose(7, status_id=222)
+    args = _captured_body(http)["params"]["arguments"]
+    assert "settings" not in args
+
+
+def test_parser_propose_tagsSugar_to_settings():
+    """`ceki contract propose <eid> --tags backend,ui:UI` parses into
+    settings.tags[] on the wire via the CLI dispatch."""
+    http, _ = _http_mock(_mcp_text({}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    # Simulate the CLI dispatch path: parse the sugar, build settings, call.
+    tags = _parse_tags("backend,ui:UI")
+    c.propose(7, status_id=222, settings={"tags": tags})
+    args = _captured_body(http)["params"]["arguments"]
+    assert args["settings"]["tags"] == [
+        {"key": "backend"},
+        {"key": "ui", "label": "UI"},
+    ]
+
+
 def test_history_passes_limit():
     http, _ = _http_mock(_mcp_text([]))
     c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
@@ -379,3 +523,560 @@ def test_parser_propose_start_end_date():
         "--start", "s", "--end", "e", "--date", "d",
     ])
     assert a.start == "s" and a.end == "e" and a.date == "d"
+
+
+# ── users[] payload on create (task 2494, back/2542 — renamed from
+#    participants[]) ────────────────────────────────────────────────
+
+
+def test_create_reviewer_folds_into_users():
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(14, label="L", reviewer="agent:9")
+    args = _captured_body(http)["params"]["arguments"]
+    assert args["users"] == [
+        {"participable_id": 9, "type": "agent", "role_id": 5}
+    ]
+    assert "reviewer" not in args
+    assert "qa" not in args
+    assert "participants" not in args
+
+
+def test_create_qa_folds_into_users():
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(14, label="L", qa="user:42")
+    args = _captured_body(http)["params"]["arguments"]
+    assert args["users"] == [
+        {"participable_id": 42, "type": "user", "role_id": 6}
+    ]
+    assert "reviewer" not in args
+    assert "qa" not in args
+    assert "participants" not in args
+
+
+def test_create_reviewer_and_qa_both_in_users():
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(14, label="L", reviewer="agent:9", qa="agent:12")
+    args = _captured_body(http)["params"]["arguments"]
+    assert "reviewer" not in args
+    assert "qa" not in args
+    assert "participants" not in args
+    by_role = {p["role_id"]: p for p in args["users"]}
+    assert by_role[5] == {
+        "participable_id": 9, "type": "agent", "role_id": 5,
+    }
+    assert by_role[6] == {
+        "participable_id": 12, "type": "agent", "role_id": 6,
+    }
+    assert len(args["users"]) == 2
+
+
+def test_create_users_uses_participable_id_keys():
+    """Regression guard for the 422 element-shape bug.
+
+    EventController users[] validation (back/2542; previously named
+    participants[]) requires `participable_id` + `participable_type` +
+    `role_id` keys on each element. The earlier shape
+    {value, type, role_id} was rejected with HTTP 422
+    (`users.0.participable_id field is required`). This test pins the
+    correct shape so the bug can't sneak back.
+    """
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(14, label="L", reviewer="agent:9", qa="agent:12")
+    parts = _captured_body(http)["params"]["arguments"]["users"]
+    assert len(parts) == 2
+    for p in parts:
+        # correct keys present
+        assert "participable_id" in p
+        assert "type" in p
+        assert "role_id" in p
+        # forbidden legacy keys absent
+        assert "value" not in p
+        assert "participable_type" not in p
+    by_role = {p["role_id"]: p for p in parts}
+    assert by_role[5]["participable_id"] == 9
+    assert by_role[5]["type"] == "agent"
+    assert by_role[6]["participable_id"] == 12
+    assert by_role[6]["type"] == "agent"
+
+
+def test_create_uses_users_field_not_participants():
+    """Regression guard pinning the wire-key rename.
+
+    back/2542 renamed the role-attachment array on the wire from
+    `participants` to `users`. This test asserts the emitted payload
+    carries `users` and NOT `participants`, so we don't slip back.
+    """
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(14, label="L", reviewer="agent:9", qa="user:42")
+    args = _captured_body(http)["params"]["arguments"]
+    assert "users" in args
+    assert "participants" not in args
+
+
+def test_create_no_reviewer_no_qa_omits_users():
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(14, label="L", benefitable="agent:8")
+    args = _captured_body(http)["params"]["arguments"]
+    assert "users" not in args
+    assert "participants" not in args
+    assert "reviewer" not in args
+    assert "qa" not in args
+    assert args["benefitable"] == {"type": "agent", "value": 8}
+
+
+def test_create_benefitable_and_billable_stay_top_level():
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(14, label="L", benefitable="agent:8", reviewer="agent:9")
+    args = _captured_body(http)["params"]["arguments"]
+    # benefitable is a different parser — stays {type, value}.
+    assert args["benefitable"] == {"type": "agent", "value": 8}
+    assert args["users"] == [
+        {"participable_id": 9, "type": "agent", "role_id": 5}
+    ]
+    assert "participants" not in args
+
+
+def test_parser_create_reviewer_and_qa():
+    a = build_parser().parse_args([
+        "contract", "create", "14", "--label", "X",
+        "--benefitable", "agent:8",
+        "--reviewer", "agent:9",
+        "--qa", "agent:12",
+    ])
+    assert a.benefitable == "agent:8"
+    assert a.reviewer == "agent:9"
+    assert a.qa == "agent:12"
+
+
+def test_parser_create_participant_repeated():
+    a = build_parser().parse_args([
+        "contract", "create", "14", "--label", "X",
+        "--participant", "agent:5:reviewer",
+        "--participant", "user:7:qa",
+    ])
+    assert a.participant == ["agent:5:reviewer", "user:7:qa"]
+
+
+def test_parse_participant_reviewer_shortcut():
+    from ceki_sdk.cli import _parse_participant
+    assert _parse_participant("agent:5:reviewer") == {
+        "participable_id": 5, "type": "agent", "role_id": 5,
+    }
+
+
+def test_parse_participant_qa_shortcut():
+    from ceki_sdk.cli import _parse_participant
+    assert _parse_participant("user:7:qa") == {
+        "participable_id": 7, "type": "user", "role_id": 6,
+    }
+
+
+def test_parse_participant_numeric_role():
+    from ceki_sdk.cli import _parse_participant
+    assert _parse_participant("agent:5:role:42") == {
+        "participable_id": 5, "type": "agent", "role_id": 42,
+    }
+
+
+def test_parse_participant_unknown_role_raises():
+    from ceki_sdk.cli import _parse_participant
+    with pytest.raises(ValueError, match="unknown role"):
+        _parse_participant("agent:5:bogus")
+
+
+def test_parse_participant_bad_type_raises():
+    from ceki_sdk.cli import _parse_participant
+    with pytest.raises(ValueError, match="type"):
+        _parse_participant("robot:5:reviewer")
+
+
+# ── progress (status correction + comment in one shot) ───────────
+
+
+def test_progress_calls_propose_then_comment(monkeypatch):
+    """progress(eid, status=222, desc='r') → propose(status_id=222) then comment(label='r').
+
+    The full body goes into `label`. `description` is never set on a
+    comment — the UI renders `label` AND `description`, so doing both
+    would visibly duplicate the body.
+    """
+    c = ContractClient(endpoint="http://x/mcp/agent", token="t")
+    calls: list[tuple[str, tuple, dict]] = []
+
+    def fake_propose(self, event_id, **kw):
+        calls.append(("propose", (event_id,), kw))
+        return {"applied": True, "id": 1}
+
+    def fake_comment(self, event_id, **kw):
+        calls.append(("comment", (event_id,), kw))
+        return {"id": 2}
+
+    monkeypatch.setattr(ContractClient, "propose", fake_propose)
+    monkeypatch.setattr(ContractClient, "comment", fake_comment)
+
+    result = c.progress(99, status=222, desc="r")
+
+    assert [name for name, _, _ in calls] == ["propose", "comment"]
+    assert calls[0][1] == (99,)
+    assert calls[0][2] == {"status_id": 222}
+    assert calls[1][1] == (99,)
+    assert calls[1][2] == {"label": "r"}
+    assert "description" not in calls[1][2]
+    assert result == {
+        "status_correction": {"applied": True, "id": 1},
+        "comment": {"id": 2},
+    }
+
+
+def test_progress_without_status_only_comments(monkeypatch):
+    """progress(eid, desc=...) without status → ONLY comment, propose never called."""
+    c = ContractClient(endpoint="http://x/mcp/agent", token="t")
+    propose_calls: list = []
+    comment_calls: list = []
+
+    def fake_propose(self, event_id, **kw):
+        propose_calls.append((event_id, kw))
+        return {"applied": True}
+
+    def fake_comment(self, event_id, **kw):
+        comment_calls.append((event_id, kw))
+        return {"id": 7}
+
+    monkeypatch.setattr(ContractClient, "propose", fake_propose)
+    monkeypatch.setattr(ContractClient, "comment", fake_comment)
+
+    result = c.progress(99, desc="just an update")
+
+    assert propose_calls == []
+    assert comment_calls == [(99, {"label": "just an update"})]
+    assert "description" not in comment_calls[0][1]
+    assert result == {"status_correction": None, "comment": {"id": 7}}
+
+
+def test_progress_never_passes_desc_to_propose(monkeypatch):
+    """Regression guard: --desc must NEVER reach propose (would overwrite spec)."""
+    c = ContractClient(endpoint="http://x/mcp/agent", token="t")
+    propose_kwargs: dict = {}
+
+    def fake_propose(self, event_id, **kw):
+        propose_kwargs.update(kw)
+        return {"applied": True}
+
+    def fake_comment(self, event_id, **kw):
+        return {"id": 1}
+
+    monkeypatch.setattr(ContractClient, "propose", fake_propose)
+    monkeypatch.setattr(ContractClient, "comment", fake_comment)
+
+    c.progress(99, status=222, desc="this is a progress report, NOT a spec")
+
+    assert "status_id" in propose_kwargs
+    assert "desc" not in propose_kwargs
+    assert "description" not in propose_kwargs
+    assert "label" not in propose_kwargs
+
+
+def test_progress_puts_full_desc_in_label_no_description(monkeypatch):
+    """Regression guard for the duplicate-comment bug (task 2936).
+
+    progress() used to send `label = desc.splitlines()[0][:60]` AND the
+    full text as `description`. The UI renders both fields, so the
+    truncated prefix appeared on top of the full body — visible
+    duplication.
+
+    The fix: full body goes into `label` (events.label is unbounded
+    TEXT), and `description` is never set on a comment.
+    """
+    c = ContractClient(endpoint="http://x/mcp/agent", token="t")
+    comment_kwargs: dict = {}
+
+    def fake_propose(self, event_id, **kw):
+        return {"applied": True}
+
+    def fake_comment(self, event_id, **kw):
+        comment_kwargs.update(kw)
+        return {"id": 1}
+
+    monkeypatch.setattr(ContractClient, "propose", fake_propose)
+    monkeypatch.setattr(ContractClient, "comment", fake_comment)
+
+    long_desc = "Long report\nwith multiple\nlines that go well past sixty characters total"
+    c.progress(99, desc=long_desc)
+
+    # Full body in label, untruncated, multi-line preserved.
+    assert comment_kwargs["label"] == long_desc
+    # `description` MUST NOT be passed — UI duplication guard.
+    assert "description" not in comment_kwargs
+
+
+def test_progress_wire_payload_label_only(monkeypatch):
+    """End-to-end wire shape: progress() comment arguments contain
+    `label` with the full body and NO `description` key.
+    """
+    http, _ = _http_mock(_mcp_text({"id": 5}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.progress(99, status=222, desc="Long report\nwith multiple\nlines")
+
+    # Two POSTs: propose, then comment. Comment is the last one.
+    last_body = http.post.call_args.kwargs["json"]
+    assert last_body["params"]["name"] == "comment"
+    args = last_body["params"]["arguments"]
+    assert args["label"] == "Long report\nwith multiple\nlines"
+    assert "description" not in args
+
+
+def test_parser_progress_full():
+    a = build_parser().parse_args([
+        "contract", "progress", "99", "--status", "222", "--desc", "did stuff",
+    ])
+    assert a.contract_action == "progress"
+    assert a.eid == 99
+    assert a.status == 222
+    assert a.desc == "did stuff"
+
+
+def test_parser_progress_no_status():
+    a = build_parser().parse_args([
+        "contract", "progress", "99", "--desc", "just a note",
+    ])
+    assert a.contract_action == "progress"
+    assert a.eid == 99
+    assert a.status is None
+    assert a.desc == "just a note"
+
+
+def test_parser_progress_missing_desc_fails():
+    with pytest.raises(SystemExit):
+        build_parser().parse_args(["contract", "progress", "99"])
+
+
+def test_cli_dispatch_progress(monkeypatch, capsys):
+    """End-to-end: `ceki contract progress 99 --status 222 --desc x` calls client.progress."""
+    from ceki_sdk import cli as cli_module
+
+    captured: dict = {}
+
+    class FakeClient:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *a):
+            return False
+
+        def progress(self, eid, *, status, desc):
+            captured["eid"] = eid
+            captured["status"] = status
+            captured["desc"] = desc
+            return {"status_correction": {"ok": 1}, "comment": {"ok": 2}}
+
+    monkeypatch.setattr(cli_module, "_contract_client", lambda: FakeClient())
+
+    parser = cli_module.build_parser()
+    args = parser.parse_args(["contract", "progress", "99", "--status", "222", "--desc", "x"])
+    rc = cli_module._cmd_contract(args)
+
+    assert rc == 0
+    assert captured == {"eid": 99, "status": 222, "desc": "x"}
+
+
+# ── call-human (task 4019) ────────────────────────────────────────
+
+
+def test_call_human_calls_correct_tool():
+    """`client.call_human(99, 'stuck', 'body')` → tool name 'call-human'
+    on the wire, with `{event_id, kind, desc}` arguments.
+    """
+    http, _ = _http_mock(_mcp_text({
+        "recipients": [], "dispatched": 0, "deep_link": "u", "kind": "stuck",
+    }))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.call_human(99, "stuck", "body")
+    body = _captured_body(http)
+    assert body["params"]["name"] == "call-human"
+    assert body["params"]["arguments"] == {
+        "event_id": 99, "kind": "stuck", "desc": "body",
+    }
+
+
+def test_call_human_rejects_bad_kind():
+    """Any kind outside {'input','review','stuck'} → ValueError."""
+    c = ContractClient(endpoint="http://x/mcp/agent", token="t")
+    with pytest.raises(ValueError, match="kind must be"):
+        c.call_human(99, "urgent", "body")
+    with pytest.raises(ValueError, match="kind must be"):
+        c.call_human(99, "", "body")
+
+
+def test_parser_contract_call_human_ok():
+    a = build_parser().parse_args([
+        "contract", "call-human", "42", "--kind", "review", "--desc", "why",
+    ])
+    assert a.contract_action == "call-human"
+    assert a.event_id == 42
+    assert a.kind == "review"
+    assert a.desc == "why"
+
+
+def test_parser_contract_call_human_missing_kind_fails():
+    with pytest.raises(SystemExit):
+        build_parser().parse_args([
+            "contract", "call-human", "42", "--desc", "why",
+        ])
+
+
+def test_parser_contract_call_human_missing_desc_fails():
+    with pytest.raises(SystemExit):
+        build_parser().parse_args([
+            "contract", "call-human", "42", "--kind", "review",
+        ])
+
+
+def test_parser_contract_call_human_missing_event_id_fails():
+    with pytest.raises(SystemExit):
+        build_parser().parse_args([
+            "contract", "call-human", "--kind", "review", "--desc", "why",
+        ])
+
+
+def test_parser_contract_call_human_bad_kind_rejected():
+    with pytest.raises(SystemExit):
+        build_parser().parse_args([
+            "contract", "call-human", "42", "--kind", "urgent", "--desc", "why",
+        ])
+
+
+def test_cli_dispatch_call_human(monkeypatch, capsys):
+    """End-to-end: CLI `contract call-human 42 --kind review --desc why`
+    hits `client.call_human(42, 'review', 'why')` exactly.
+    """
+    from ceki_sdk import cli as cli_module
+
+    captured: dict = {}
+
+    class FakeClient:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *a):
+            return False
+
+        def call_human(self, event_id, kind, desc):
+            captured["event_id"] = event_id
+            captured["kind"] = kind
+            captured["desc"] = desc
+            return {
+                "recipients": [{"user_id": 1, "label": "L", "reason": "R"}],
+                "dispatched": 1,
+                "deep_link": "https://ex/e/42",
+                "kind": "review",
+            }
+
+    monkeypatch.setattr(cli_module, "_contract_client", lambda: FakeClient())
+
+    parser = cli_module.build_parser()
+    args = parser.parse_args([
+        "contract", "call-human", "42", "--kind", "review", "--desc", "why",
+    ])
+    rc = cli_module._cmd_contract(args)
+
+    assert rc == 0
+    assert captured == {"event_id": 42, "kind": "review", "desc": "why"}
+
+
+def test_create_reviewer_plus_participant_stacks():
+    """--reviewer agent:9 + --participant agent:5:reviewer → two role_id=5 entries.
+
+    The `participants` kwarg is the stable Python API for callers
+    (CLI feeds it from --participant); on the wire both feed into
+    the `users` array (back/2542 rename).
+    """
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(
+        14, label="L",
+        reviewer="agent:9",
+        participants=[
+            {"participable_id": 5, "type": "agent", "role_id": 5}
+        ],
+    )
+    args = _captured_body(http)["params"]["arguments"]
+    parts = args["users"]
+    assert "participants" not in args
+    assert len(parts) == 2
+    assert all(p["role_id"] == 5 for p in parts)
+    values = sorted(p["participable_id"] for p in parts)
+    assert values == [5, 9]
+
+
+# ── tags sugar → settings.tags[] (create only) ────────────────────
+
+
+def test_create_tags_emit_under_settings():
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(14, label="L", tags=[
+        {"key": "backend", "label": "Backend", "color": "#ff0000"},
+        {"key": "urgent"},
+    ])
+    args = _captured_body(http)["params"]["arguments"]
+    assert args["settings"] == {"tags": [
+        {"key": "backend", "label": "Backend", "color": "#ff0000"},
+        {"key": "urgent"},
+    ]}
+
+
+def test_create_without_tags_omits_settings():
+    http, _ = _http_mock(_mcp_text({"id": 1}))
+    c = ContractClient(client=http, endpoint="http://x/mcp/agent", token="t")
+    c.create(14, label="L")
+    args = _captured_body(http)["params"]["arguments"]
+    assert "settings" not in args
+
+
+def test_parse_tags_bare_keys():
+    assert _parse_tags("backend,urgent") == [
+        {"key": "backend"}, {"key": "urgent"}
+    ]
+
+
+def test_parse_tags_key_label_color():
+    assert _parse_tags("backend:Backend:#ff0000") == [
+        {"key": "backend", "label": "Backend", "color": "#ff0000"}
+    ]
+
+
+def test_parse_tags_empty_label_skipped():
+    assert _parse_tags("docs::#0af") == [
+        {"key": "docs", "color": "#0af"}
+    ]
+
+
+def test_parse_tags_trims_and_ignores_blanks():
+    assert _parse_tags(" backend , , qa ") == [
+        {"key": "backend"}, {"key": "qa"}
+    ]
+
+
+def test_parse_tags_missing_key_raises():
+    with pytest.raises(ValueError):
+        _parse_tags(":nope")
+
+
+def test_parse_tags_all_blank_raises():
+    with pytest.raises(ValueError):
+        _parse_tags(" , , ")
+
+
+def test_parser_create_tags_flag():
+    a = build_parser().parse_args([
+        "contract", "create", "14", "--label", "X",
+        "--tags", "backend:Backend:#ff0000,urgent",
+    ])
+    assert a.tags == "backend:Backend:#ff0000,urgent"
diff --git a/tests/test_copy_paste.py b/tests/test_copy_paste.py
new file mode 100644
index 0000000..bb3cff6
--- /dev/null
+++ b/tests/test_copy_paste.py
@@ -0,0 +1,227 @@
+"""Regression guards for ``Browser.copy()`` and ``Browser.paste(selector, text)``.
+
+Both methods drive the *OS clipboard* via synthetic Ctrl+C / Ctrl+V hotkeys
+(``Input.dispatchKeyEvent`` with ``modifiers=2``). ``paste`` seeds arbitrary
+text by staging it through an offscreen ``<textarea>`` before the Ctrl+C.
+Nothing on the extension / relay side changes. These tests pin the wire shape
+so we don't accidentally regress to ``Input.insertText`` (which is direct DOM
+insertion, not the OS clipboard) or drift into ``navigator.clipboard``.
+"""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import AsyncMock, patch
+
+from ceki_sdk._browser import Browser
+
+
+def _make_browser() -> Browser:
+    client = AsyncMock()
+    client._active_browsers = {}
+    client.chat_url = "https://test/chat"
+    client.api_key = "test"
+
+    match = AsyncMock()
+    match.session_id = "copypaste-1"
+    match.schedule_id = 1
+    match.chat_topic_id = "t1"
+    match.browser_info = {}
+    match.provider_user_id = None
+
+    with patch.dict("os.environ", {"CEKI_HUMAN_DISABLE": "1"}):
+        return Browser(client, match)
+
+
+def _assert_ctrl_hotkey(call: dict, *, typ: str, key: str, code: str) -> None:
+    assert call["method"] == "Input.dispatchKeyEvent"
+    params = call["params"]
+    assert params["type"] == typ
+    assert params["modifiers"] == 2
+    assert params["key"] == key
+    assert params["code"] == code
+    vk = ord(key.upper())
+    assert params["windowsVirtualKeyCode"] == vk
+    assert params["nativeVirtualKeyCode"] == vk
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# copy()
+# ──────────────────────────────────────────────────────────────────────────
+
+
+async def test_copy_reads_selection_then_dispatches_ctrl_c():
+    """copy() reads the selection via Runtime.evaluate then fires Ctrl+C.
+
+    Wire order:
+      1. Runtime.evaluate — window.getSelection().toString()
+      2. Input.dispatchKeyEvent(type=keyDown, key='c', code='KeyC', modifiers=2)
+      3. Input.dispatchKeyEvent(type=keyUp,   key='c', code='KeyC', modifiers=2)
+    """
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {"value": "hello world"}})
+
+    got = await b.copy()
+
+    assert got == "hello world"
+    assert b.send.await_count == 3
+
+    first = b.send.await_args_list[0][0][0]
+    assert first["method"] == "Runtime.evaluate"
+    assert first["params"]["expression"] == "window.getSelection().toString()"
+    assert first["params"]["returnByValue"] is True
+
+    _assert_ctrl_hotkey(b.send.await_args_list[1][0][0], typ="keyDown", key="c", code="KeyC")
+    _assert_ctrl_hotkey(b.send.await_args_list[2][0][0], typ="keyUp", key="c", code="KeyC")
+
+
+async def test_copy_returns_empty_when_selection_missing():
+    """Empty selection: CDP returns ``{"result": {}}`` (no ``value`` key).
+
+    We must not raise KeyError — the SDK guards with ``.get(...) or ""``.
+    Ctrl+C still fires (it's cheap and keeps the OS clipboard state
+    consistent with what the caller sees).
+    """
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    assert await b.copy() == ""
+    # 1 Runtime.evaluate + 2 dispatchKeyEvent
+    assert b.send.await_count == 3
+
+
+async def test_copy_returns_empty_when_result_missing():
+    b = _make_browser()
+    b.send = AsyncMock(return_value={})
+
+    assert await b.copy() == ""
+    assert b.send.await_count == 3
+
+
+async def test_copy_returns_empty_string_verbatim_when_value_is_empty_string():
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {"value": ""}})
+
+    assert await b.copy() == ""
+    assert b.send.await_count == 3
+
+
+async def test_copy_never_calls_insertText():
+    """Guard against regression to the 4091 direct-insertion path."""
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {"value": "x"}})
+    await b.copy()
+    for call in b.send.await_args_list:
+        assert call[0][0]["method"] != "Input.insertText"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# paste(selector, text)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+async def test_paste_wire_sequence():
+    """paste() runs: seed textarea -> Ctrl+C -> cleanup+focus -> Ctrl+V.
+
+    Exactly 6 CDP calls:
+      1. Runtime.evaluate — build offscreen <textarea>, set .value, focus+select
+      2. Input.dispatchKeyEvent keyDown 'c'
+      3. Input.dispatchKeyEvent keyUp   'c'
+      4. Runtime.evaluate — remove temp, querySelector(...).focus()
+      5. Input.dispatchKeyEvent keyDown 'v'
+      6. Input.dispatchKeyEvent keyUp   'v'
+    """
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    await b.paste("#foo", "bar")
+
+    assert b.send.await_count == 6
+    calls = [c[0][0] for c in b.send.await_args_list]
+
+    # 1: seed textarea
+    assert calls[0]["method"] == "Runtime.evaluate"
+    seed_expr = calls[0]["params"]["expression"]
+    assert "document.createElement('textarea')" in seed_expr
+    assert "position:fixed;left:-9999px" in seed_expr
+    # text is JSON-escaped ("bar" -> "\"bar\"")
+    assert '="bar"' in seed_expr.replace(" ", "")  # tolerant of whitespace
+
+    # 2-3: Ctrl+C
+    _assert_ctrl_hotkey(calls[1], typ="keyDown", key="c", code="KeyC")
+    _assert_ctrl_hotkey(calls[2], typ="keyUp", key="c", code="KeyC")
+
+    # 4: cleanup + focus target
+    assert calls[3]["method"] == "Runtime.evaluate"
+    cf_expr = calls[3]["params"]["expression"]
+    assert "__ceki_paste_tmp__" in cf_expr
+    assert 'document.querySelector("#foo")' in cf_expr
+    assert ".focus()" in cf_expr
+
+    # 5-6: Ctrl+V
+    _assert_ctrl_hotkey(calls[4], typ="keyDown", key="v", code="KeyV")
+    _assert_ctrl_hotkey(calls[5], typ="keyUp", key="v", code="KeyV")
+
+
+async def test_paste_never_calls_insertText():
+    """Guard against regression to the 4091 direct-insertion path."""
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+    await b.paste("#foo", "bar")
+    for c in b.send.await_args_list:
+        assert c[0][0]["method"] != "Input.insertText"
+
+
+async def test_paste_json_escapes_weird_selector():
+    """Selector with double quotes, single quotes, backslashes must survive.
+
+    The selector goes through ``json.dumps`` so anything that fits in a JSON
+    string fits in a JS string. We check the *cleanup+focus* Runtime.evaluate.
+    """
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    nasty = " #foo[data-x='\"a\\\"b\"'] "
+    await b.paste(nasty, "x")
+
+    cf_expr = b.send.await_args_list[3][0][0]["params"]["expression"]
+    assert f"document.querySelector({json.dumps(nasty)})" in cf_expr
+
+
+async def test_paste_selector_with_newlines_and_unicode():
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    weird = "#foo\n[data-x='ñü']`"
+    await b.paste(weird, "y")
+
+    cf_expr = b.send.await_args_list[3][0][0]["params"]["expression"]
+    assert f"document.querySelector({json.dumps(weird)})" in cf_expr
+
+
+async def test_paste_json_escapes_text_with_quotes_newlines_unicode_backticks():
+    """text is interpolated into a JS expression — it MUST be JSON-escaped."""
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    payload = 'text with \n newlines, "quotes", \\backslash, `backtick`, ñü'
+    await b.paste("#foo", payload)
+
+    seed_expr = b.send.await_args_list[0][0][0]["params"]["expression"]
+    # The raw text must NOT appear un-escaped
+    assert payload not in seed_expr
+    # The JSON-escaped form MUST appear
+    assert json.dumps(payload) in seed_expr
+
+
+async def test_paste_empty_text_still_seeds_and_fires_ctrl_v():
+    """Empty text is still a valid clipboard payload; the whole hotkey dance
+    still runs (6 CDP calls) and the seed literal is an empty JSON string."""
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    await b.paste("#foo", "")
+
+    assert b.send.await_count == 6
+    seed_expr = b.send.await_args_list[0][0][0]["params"]["expression"]
+    assert '=""' in seed_expr.replace(" ", "")