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..1bc2d98 100644
--- a/ceki_sdk/_browser.py
+++ b/ceki_sdk/_browser.py
@@ -6,6 +6,7 @@
 import logging
 import mimetypes
 import os
+import random
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Awaitable, Callable, Coroutine, Literal, cast
@@ -41,6 +42,17 @@
 
 _ERROR_TERMINAL = {-1011, -1012, -1015, -1018}
 
+# task 4109 — anti-detect branching for Browser.type().
+# When both gates pass, a long text-with-selector call routes through the
+# real system-clipboard Ctrl+V path (from task 4098) instead of the per-key
+# Ceki.typeText path. Perfect per-key rhythm on a long string is a classic
+# bot signal; a paste event with inputType=insertFromPaste looks like the
+# normal "user pasted from clipboard" behavior. Named constants live here
+# (not inside the method) so tests can pin them and future tuning does not
+# leave magic numbers in two places.
+TYPE_PASTE_MIN_CHARS = 500
+TYPE_PASTE_PROBABILITY = 0.625
+
 
 def _resolve_human(human) -> Humanizer | None:
     if os.environ.get("CEKI_HUMAN_DISABLE", "").lower() in ("1", "true", "yes"):
@@ -279,6 +291,33 @@ async def type(
         # because Chrome routed the bare CDP eval to the page's service-worker
         # execution context where `document` is undefined. chrome.scripting
         # always lands in a page frame.
+        #
+        # task 4109 — anti-detect branching. For LONG text delivered into a
+        # KNOWN selector, roll the dice against TYPE_PASTE_PROBABILITY and (if
+        # the gate opens) route through the real-clipboard Ctrl+V path from
+        # task 4098 instead of Ceki.typeText. Reasons this branch is gated on
+        # both `selector` and length:
+        #   - no selector => we don't know where to focus for the OS paste,
+        #     so the per-char path (which types into current focus) is the
+        #     only sane fallback;
+        #   - short text has no rhythm-signature problem to begin with, and
+        #     paste-events on short strings look weirder than per-key ones.
+        # Humanizer pre-click / after-hooks still run — the selector focus
+        # inside _hotkey_paste_into replaces the extension's focus step for
+        # this branch.
+        if (
+            selector is not None
+            and len(text) > TYPE_PASTE_MIN_CHARS
+            and random.random() < TYPE_PASTE_PROBABILITY
+        ):
+            h_pre = self._humanize_for_call(human)
+            if h_pre:
+                await h_pre.before("type")
+            await self._hotkey_paste_into(selector, text)
+            if h_pre:
+                await h_pre.after("type")
+            return
+
         h = self._humanize_for_call(human)
         if h:
             if self._last_pointer is not None and selector is None:
@@ -486,6 +525,143 @@ 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 _hotkey_paste_into(self, selector: str, text: str) -> None:
+        """Real system-clipboard paste of ``text`` into ``selector``.
+
+        Shared 6-CDP-call sequence (from task 4098):
+
+          1. Runtime.evaluate — build offscreen ``<textarea>``, set value, focus+select
+          2. Input.dispatchKeyEvent keyDown ``c`` (Ctrl+C — flips OS clipboard)
+          3. Input.dispatchKeyEvent keyUp   ``c``
+          4. Runtime.evaluate — remove temp element, focus target selector
+          5. Input.dispatchKeyEvent keyDown ``v`` (Ctrl+V — fires paste event)
+          6. Input.dispatchKeyEvent keyUp   ``v``
+
+        Both ``selector`` and ``text`` are JSON-escaped when interpolated —
+        quotes, backticks, backslashes, newlines, and unicode are safe.
+
+        Called by :meth:`paste` (public API) and :meth:`type` (task 4109
+        anti-detect branch for long text). Extracting this keeps the two
+        callers wire-identical and avoids the copy() logging noise inside a
+        type() call.
+        """
+        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")
+
+    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.
+        """
+        await self._hotkey_paste_into(selector, text)
+
     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..4ec3e66 100644
--- a/ceki_sdk/cli.py
+++ b/ceki_sdk/cli.py
@@ -420,6 +420,58 @@ 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 _contract_dump(value: Any) -> None:
     if isinstance(value, str):
         sys.stdout.write(value)
@@ -448,8 +500,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 +520,14 @@ 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 [])
+                    ]
+                except ValueError as e:
+                    _err(str(e), "args")
+                    return 1
                 _contract_dump(cli.create(
                     cid,
                     label=args.label,
@@ -480,11 +544,20 @@ 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,
                 ))
             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,7 +566,6 @@ 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":
@@ -510,6 +582,12 @@ def _cmd_contract(args: argparse.Namespace) -> int:
                     currency=args.currency,
                     benefitable=args.benefitable,
                 ))
+            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()]
                 vote = str(args.vote).lower() in ("true", "1", "yes")
@@ -748,7 +826,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,6 +871,18 @@ 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`")
 
@@ -809,6 +913,14 @@ def build_parser() -> argparse.ArgumentParser:
     p_cp.add_argument("--currency")
     p_cp.add_argument("--benefitable")
 
+    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)
     p_cv.add_argument("--ids", required=True, help="Comma-separated correction IDs")
@@ -819,6 +931,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..0749c5f 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,24 @@ 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,
     ) -> 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 +307,7 @@ def create(
             "description": description,
             "data": data,
             "benefitable": _benefitable(benefitable),
+            "users": users if users else None,
         })
         return self.call(_TOOL_MAP["create"], args)
 
@@ -239,9 +324,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 +345,6 @@ def comment(
             "duration": duration,
             "amount": amount,
             "currency": currency,
-            "description": description,
             "benefitable": _benefitable(benefitable),
         })
         return self.call(_TOOL_MAP["comment"], args)
@@ -288,6 +379,30 @@ def propose(
         })
         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..faaac35 100644
--- a/tests/test_contract.py
+++ b/tests/test_contract.py
@@ -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 ───────────────────────────────────────────────────────
 
 
@@ -379,3 +468,493 @@ 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]
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(" ", "")
diff --git a/tests/test_type_paste_branch.py b/tests/test_type_paste_branch.py
new file mode 100644
index 0000000..e8b20f4
--- /dev/null
+++ b/tests/test_type_paste_branch.py
@@ -0,0 +1,305 @@
+"""Anti-detect probabilistic paste path in ``Browser.type()`` (task 4109).
+
+``type(text, selector=...)`` gets two gates before it routes through the
+real-clipboard Ctrl+V path from task 4098:
+
+  1. ``selector`` is not ``None`` (we need a focus target for the OS paste).
+  2. ``len(text) > TYPE_PASTE_MIN_CHARS`` (short text has no rhythm signature).
+  3. ``random.random() < TYPE_PASTE_PROBABILITY``.
+
+When any gate fails, the existing per-key ``Ceki.typeText`` path is used
+verbatim. These tests pin every gate, prove the shared hotkey helper is the
+same wire shape as :func:`Browser.paste`, and guard the module constants
+against future magic-number drift.
+"""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import AsyncMock, patch
+
+from ceki_sdk import _browser
+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 = "typepaste-1"
+    match.schedule_id = 1
+    match.chat_topic_id = "t1"
+    match.browser_info = {}
+    match.provider_user_id = None
+
+    # CEKI_HUMAN_DISABLE=1 so the humanizer does not fire click() calls that
+    # would add noise to send.await_count assertions.
+    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
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Module constants
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def test_constants_at_module_scope():
+    """The threshold and probability MUST live at module scope so tests can
+    pin them and future tuning does not leave magic numbers in two places
+    (``type()`` body + ``_hotkey_paste_into`` doc string, etc.)."""
+    assert _browser.TYPE_PASTE_MIN_CHARS == 500
+    assert _browser.TYPE_PASTE_PROBABILITY == 0.625
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Gate A — no selector → NEVER paste path, even for long text and forced dice
+# ──────────────────────────────────────────────────────────────────────────
+
+
+async def test_type_no_selector_never_paste_even_when_long_and_dice_low():
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    long_text = "X" * 5000
+    with patch("ceki_sdk._browser.random.random", return_value=0.0):
+        await b.type(long_text)
+
+    # One Ceki.typeText call — nothing else.
+    assert b.send.await_count == 1
+    call = b.send.await_args_list[0][0][0]
+    assert call["method"] == "Ceki.typeText"
+    assert call["params"]["text"] == long_text
+    assert "selector" not in call["params"]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Gate B — text length
+# ──────────────────────────────────────────────────────────────────────────
+
+
+async def test_type_short_text_with_selector_stays_per_key():
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    with patch("ceki_sdk._browser.random.random", return_value=0.0):
+        await b.type("a" * 100, selector="#in")
+
+    assert b.send.await_count == 1
+    call = b.send.await_args_list[0][0][0]
+    assert call["method"] == "Ceki.typeText"
+    assert call["params"]["selector"] == "#in"
+
+
+async def test_type_at_threshold_exact_500_stays_per_key():
+    """Boundary: ``> 500`` means 500 exactly still goes per-key."""
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    with patch("ceki_sdk._browser.random.random", return_value=0.0):
+        await b.type("a" * 500, selector="#in")
+
+    assert b.send.await_count == 1
+    assert b.send.await_args_list[0][0][0]["method"] == "Ceki.typeText"
+
+
+async def test_type_empty_string_with_selector_never_paste():
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    with patch("ceki_sdk._browser.random.random", return_value=0.0):
+        await b.type("", selector="#in")
+
+    assert b.send.await_count == 1
+    assert b.send.await_args_list[0][0][0]["method"] == "Ceki.typeText"
+
+
+async def test_type_whitespace_only_and_single_char_never_paste():
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    with patch("ceki_sdk._browser.random.random", return_value=0.0):
+        await b.type("   ", selector="#in")
+        await b.type("x", selector="#in")
+
+    # Two per-key calls, nothing else.
+    assert b.send.await_count == 2
+    for c in b.send.await_args_list:
+        assert c[0][0]["method"] == "Ceki.typeText"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Gate C — probability
+# ──────────────────────────────────────────────────────────────────────────
+
+
+async def test_type_long_with_selector_dice_above_threshold_stays_per_key():
+    """random() >= 0.625 falls through to Ceki.typeText."""
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    long_text = "X" * 600
+    with patch("ceki_sdk._browser.random.random", return_value=0.9):
+        await b.type(long_text, selector="#in")
+
+    assert b.send.await_count == 1
+    assert b.send.await_args_list[0][0][0]["method"] == "Ceki.typeText"
+
+
+async def test_type_long_with_selector_dice_at_boundary_stays_per_key():
+    """random() == 0.625 (not strictly less than) falls through."""
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    with patch("ceki_sdk._browser.random.random", return_value=0.625):
+        await b.type("X" * 600, selector="#in")
+
+    assert b.send.await_count == 1
+    assert b.send.await_args_list[0][0][0]["method"] == "Ceki.typeText"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Paste path fires: exact 6-CDP-call sequence, no Ceki.typeText
+# ──────────────────────────────────────────────────────────────────────────
+
+
+async def test_type_long_with_selector_dice_low_fires_paste_sequence():
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    long_text = "X" * 600
+    with patch("ceki_sdk._browser.random.random", return_value=0.0):
+        await b.type(long_text, selector="#in")
+
+    # Exactly the 6-call clipboard-hotkey sequence from task 4098:
+    #   1 seed textarea, 2-3 Ctrl+C, 4 cleanup+focus, 5-6 Ctrl+V.
+    assert b.send.await_count == 6
+    calls = [c[0][0] for c in b.send.await_args_list]
+
+    # No Ceki.typeText anywhere — the paste path replaces it entirely.
+    for c in calls:
+        assert c["method"] != "Ceki.typeText"
+
+    assert calls[0]["method"] == "Runtime.evaluate"
+    seed_expr = calls[0]["params"]["expression"]
+    assert "document.createElement('textarea')" in seed_expr
+    # Text JSON-escaped into the seed.
+    assert json.dumps(long_text) in seed_expr
+
+    _assert_ctrl_hotkey(calls[1], typ="keyDown", key="c", code="KeyC")
+    _assert_ctrl_hotkey(calls[2], typ="keyUp", key="c", code="KeyC")
+
+    assert calls[3]["method"] == "Runtime.evaluate"
+    cf_expr = calls[3]["params"]["expression"]
+    assert "__ceki_paste_tmp__" in cf_expr
+    assert 'document.querySelector("#in")' in cf_expr
+    assert ".focus()" in cf_expr
+
+    _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_type_paste_path_json_escapes_weird_selector_and_text():
+    """Selector + text both go through json.dumps in the shared helper."""
+    b = _make_browser()
+    b.send = AsyncMock(return_value={"result": {}})
+
+    nasty_selector = " #in[data-x='\"a\\\"b\"'] "
+    nasty_text = (
+        'X' * 600
+        + '\n"quotes",\n`backticks`,\\backslash,ñü'
+    )
+
+    with patch("ceki_sdk._browser.random.random", return_value=0.0):
+        await b.type(nasty_text, selector=nasty_selector)
+
+    calls = [c[0][0] for c in b.send.await_args_list]
+
+    seed_expr = calls[0]["params"]["expression"]
+    # Raw text with un-escaped newline must NOT appear un-escaped.
+    assert nasty_text not in seed_expr
+    assert json.dumps(nasty_text) in seed_expr
+
+    cf_expr = calls[3]["params"]["expression"]
+    assert f"document.querySelector({json.dumps(nasty_selector)})" in cf_expr
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# paste() still works — regression guard on the 4098 wire shape
+# ──────────────────────────────────────────────────────────────────────────
+
+
+async def test_paste_public_still_emits_the_same_6_call_sequence():
+    """After refactor into _hotkey_paste_into, paste() must still be
+    identical on the wire to task 4098 — same 6 CDP calls, same order.
+    """
+    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]
+
+    assert calls[0]["method"] == "Runtime.evaluate"
+    assert "document.createElement('textarea')" in calls[0]["params"]["expression"]
+    _assert_ctrl_hotkey(calls[1], typ="keyDown", key="c", code="KeyC")
+    _assert_ctrl_hotkey(calls[2], typ="keyUp", key="c", code="KeyC")
+    assert calls[3]["method"] == "Runtime.evaluate"
+    assert 'document.querySelector("#foo")' in calls[3]["params"]["expression"]
+    _assert_ctrl_hotkey(calls[4], typ="keyDown", key="v", code="KeyV")
+    _assert_ctrl_hotkey(calls[5], typ="keyUp", key="v", code="KeyV")
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Statistical sanity — dice distribution matches the constant
+# ──────────────────────────────────────────────────────────────────────────
+
+
+async def test_statistical_gate_matches_probability_constant():
+    """Feed a deterministic cycle of ``random()`` values through 200 calls,
+    count paste-path invocations, confirm they match the ``< 0.625`` count.
+
+    Belt-and-braces guard that the comparison is strict ``<`` (not ``<=``)
+    and that we did not accidentally invert the condition.
+    """
+    # 200 values in [0, 1). 125 are < 0.625, 75 are >= 0.625.
+    values = [i / 200 for i in range(200)]
+    expected_paste = sum(1 for v in values if v < _browser.TYPE_PASTE_PROBABILITY)
+    assert expected_paste == 125  # sanity check on the fixture itself
+
+    paste_hits = 0
+    per_key_hits = 0
+
+    long_text = "X" * 600
+
+    it = iter(values)
+    with patch("ceki_sdk._browser.random.random", side_effect=lambda: next(it)):
+        for _ in range(200):
+            b = _make_browser()
+            b.send = AsyncMock(return_value={"result": {}})
+            await b.type(long_text, selector="#in")
+            n_calls = b.send.await_count
+            if n_calls == 6:
+                paste_hits += 1
+            elif n_calls == 1:
+                per_key_hits += 1
+            else:
+                raise AssertionError(f"unexpected send count {n_calls}")
+
+    assert paste_hits == expected_paste
+    assert per_key_hits == 200 - expected_paste