deepsieve-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{deepsieve_cli-0.3.0 → deepsieve_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deepsieve-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: DeepSieve CLI — run cited deep research from your terminal
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27
@@ -20,6 +20,10 @@ scoped API key. Nothing to copy, nothing pasted into your shell history. The
 credential appears in **Settings → API keys** on your deployment and can be
 revoked there at any time.
 
+The key covers the CLI's own commands and cannot create a Blueprint. If an agent
+will use it to create Blueprints, run `deepsieve login --preset agent`; the
+approval screen lists the extra scopes.
+
 ## Commands
 
 ```bash
@@ -31,8 +35,16 @@ deepsieve runs list
 deepsieve runs get <id>                       # exit 4 while still running
 deepsieve runs cancel <id>
 deepsieve members list                        # who is in the workspace + seat usage
+deepsieve changes list --live                 # merges, renames, successor links
+deepsieve changes undo <id>                   # asks first; --yes in scripts
+deepsieve merge preview <entity> --survivor <id> --loser <id>   # writes nothing
+deepsieve merge apply <entity> --survivor <id> --loser <id> [--choice KEY=loser]
 deepsieve data catalog                        # entities + columns (never guess)
 deepsieve data get companies --receipts       # rows with per-cell citations
+deepsieve chat thread <run-id>                # changes, with status + warnings
+deepsieve chat confirm <action-id>            # apply a change that waits for confirmation
+deepsieve chat dismiss <action-id>            # decline it; nothing is written
+deepsieve chat revert <action-id>             # undo a change a chat answer applied
 deepsieve setup mcp                           # MCP registration for this origin
 ```
 

{deepsieve_cli-0.3.0 → deepsieve_cli-0.4.0}/README.md

@@ -12,6 +12,10 @@ scoped API key. Nothing to copy, nothing pasted into your shell history. The
 credential appears in **Settings → API keys** on your deployment and can be
 revoked there at any time.
 
+The key covers the CLI's own commands and cannot create a Blueprint. If an agent
+will use it to create Blueprints, run `deepsieve login --preset agent`; the
+approval screen lists the extra scopes.
+
 ## Commands
 
 ```bash
@@ -23,8 +27,16 @@ deepsieve runs list
 deepsieve runs get <id>                       # exit 4 while still running
 deepsieve runs cancel <id>
 deepsieve members list                        # who is in the workspace + seat usage
+deepsieve changes list --live                 # merges, renames, successor links
+deepsieve changes undo <id>                   # asks first; --yes in scripts
+deepsieve merge preview <entity> --survivor <id> --loser <id>   # writes nothing
+deepsieve merge apply <entity> --survivor <id> --loser <id> [--choice KEY=loser]
 deepsieve data catalog                        # entities + columns (never guess)
 deepsieve data get companies --receipts       # rows with per-cell citations
+deepsieve chat thread <run-id>                # changes, with status + warnings
+deepsieve chat confirm <action-id>            # apply a change that waits for confirmation
+deepsieve chat dismiss <action-id>            # decline it; nothing is written
+deepsieve chat revert <action-id>             # undo a change a chat answer applied
 deepsieve setup mcp                           # MCP registration for this origin
 ```
 

{deepsieve_cli-0.3.0 → deepsieve_cli-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepsieve-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "DeepSieve CLI — run cited deep research from your terminal"
 requires-python = ">=3.11"
 readme = "README.md"

{deepsieve_cli-0.3.0 → deepsieve_cli-0.4.0}/src/deepsieve_cli/main.py

@@ -110,7 +110,7 @@ def cmd_login(args) -> int:
         return EXIT_OK
 
     try:
-        auth = client.start_device_authorization(CLIENT_NAME)
+        auth = client.start_device_authorization(CLIENT_NAME, preset=args.preset)
     except ApiError as exc:
         err(str(exc))
         return EXIT_FAIL
@@ -172,6 +172,10 @@ def cmd_whoami(args) -> int:
     print(f"profile    {prof.name}")
     print(f"origin     {prof.origin}")
     print(f"org        {me.get('org_id')}")
+    # gh #1282: the Blueprint un-addressed calls act on, by name and by the id every
+    # `--blueprint` / `blueprint_id` accepts — not the internal schema name.
+    bp = me.get("blueprint") or {}
+    print(f"blueprint  {bp.get('name')} ({bp.get('id')})" if bp else "blueprint  (none)")
     print(f"workspace  {me.get('workspace_schema')}")
     print(f"role       {me.get('role')}")
     print(f"scopes     {', '.join(me.get('scopes') or []) or '(full)'}")
@@ -200,6 +204,8 @@ def cmd_runs_list(args) -> int:
     params: dict[str, Any] = {"limit": args.limit}
     if args.status:
         params["status"] = args.status
+    if args.blueprint:
+        params["blueprint_id"] = args.blueprint
     try:
         body = client.request("GET", "/v1/research/runs", params=params)
     except ApiError as exc:
@@ -213,6 +219,9 @@ def cmd_runs_list(args) -> int:
          (r.get("title") or r.get("query") or "")[:48]]
         for r in body.get("data", [])
     ]
+    bp = body.get("blueprint") or {}
+    if bp:
+        print(f"Blueprint: {bp.get('name')} ({bp.get('id')})")
     print(_table(rows, ["id", "status", "created", "title"]) if rows else "No runs yet.")
     return EXIT_OK
 
@@ -229,6 +238,9 @@ def cmd_runs_get(args) -> int:
     else:
         print(f"id       {body.get('id')}")
         print(f"status   {body.get('status')}  (done={body.get('done')})")
+        bp = body.get("blueprint") or {}
+        if bp:
+            print(f"blueprint {bp.get('name')} ({bp.get('id')})")
         if body.get("error"):
             print(f"error    {body['error'].get('message')}")
     if not body.get("done"):
@@ -255,6 +267,8 @@ def cmd_runs_create(args) -> int:
         # #1802 — repeatable; the server resolves and refuses, the CLI only carries.
         # Only blanks given → no list at all, never an empty one (the server 400s on []).
         body["allowed_sources"] = allowed
+    if getattr(args, "blueprint", None):
+        body["blueprint_id"] = args.blueprint
 
     # A real run spends money. Confirm interactively unless told not to — and
     # never silently in a pipe, where nobody is watching.
@@ -264,6 +278,10 @@ def cmd_runs_create(args) -> int:
             return EXIT_USAGE
         print(f"This starts a REAL research run on {prof.origin} — it spends credits "
               f"and takes 15-60 minutes.")
+        # gh #1282: say which Blueprint BEFORE it spends; the 202 is too late.
+        target = (f"Blueprint {args.blueprint}" if getattr(args, "blueprint", None)
+                  else "your active Blueprint (see `deepsieve whoami`; choose with --blueprint)")
+        print(f"It runs on {target}.")
         if input("Continue? [y/N] ").strip().lower() not in ("y", "yes"):
             print("Cancelled.")
             return EXIT_OK
@@ -284,6 +302,9 @@ def cmd_runs_create(args) -> int:
         return EXIT_OK
     run_id = created.get("id")
     print(f"started run {run_id} ({'dry run' if args.dry_run else 'billable'})")
+    bp = created.get("blueprint") or {}
+    if bp:
+        print(f"Blueprint: {bp.get('name')} ({bp.get('id')})")
     if not args.wait:
         print(f"poll with: deepsieve runs get {run_id}")
         return EXIT_OK
@@ -330,6 +351,80 @@ def cmd_runs_cancel(args) -> int:
     return EXIT_OK
 
 
+def _uuid_arg(value: str, what: str) -> str | None:
+    """An id interpolated into a URL path must be a UUID, never a path fragment."""
+    import uuid as _uuid  # noqa: PLC0415
+
+    try:
+        return str(_uuid.UUID(value))
+    except ValueError:
+        err(f"{what} must be a UUID")
+        return None
+
+
+def cmd_chat_thread(args) -> int:
+    """A run's chat thread: questions, answers, and each change with its status. A change
+    `pending_confirmation` waits for `chat confirm` or `chat dismiss` (#2187)."""
+    rid = _uuid_arg(args.run_id, "run_id")
+    if rid is None:
+        return EXIT_FAIL
+    client, _ = _require_auth(args)
+    try:
+        body = client.request("GET", f"/v1/research/runs/{rid}/chat")
+    except ApiError as exc:
+        err(str(exc))
+        return EXIT_FAIL
+    if args.json:
+        out(body, True)
+        return EXIT_OK
+    rows = []
+    for message in body.get("messages") or []:
+        for action in message.get("actions") or []:
+            warnings = "; ".join(w.get("message", "") for w in action.get("warnings") or [])
+            rows.append(
+                [
+                    action.get("id", ""),
+                    action.get("status", ""),
+                    action.get("action_type", ""),
+                    f"{action.get('record_name') or ''} {action.get('column_name') or ''}".strip(),
+                    warnings or action.get("note") or "",
+                ]
+            )
+    print(f"{len(body.get('messages') or [])} message(s)")
+    if rows:
+        print(_table(rows, ["action", "status", "type", "cell", "warning / note"]))
+    return EXIT_OK
+
+
+def _chat_action(args, op: str, done: str) -> int:
+    aid = _uuid_arg(args.action_id, "action_id")
+    if aid is None:
+        return EXIT_FAIL
+    client, _ = _require_auth(args)
+    try:
+        body = client.request("POST", f"/v1/chat/actions/{aid}/{op}")
+    except ApiError as exc:
+        err(str(exc))
+        return EXIT_FAIL
+    out(body, args.json, f"{done} {aid}")
+    return EXIT_OK
+
+
+def cmd_chat_confirm(args) -> int:
+    """Apply a waiting change anyway, having read its warnings (`chat thread`)."""
+    return _chat_action(args, "confirm", "applied")
+
+
+def cmd_chat_dismiss(args) -> int:
+    """Decline a waiting change: nothing is written."""
+    return _chat_action(args, "dismiss", "dismissed")
+
+
+def cmd_chat_revert(args) -> int:
+    """Undo a change a chat answer applied."""
+    return _chat_action(args, "revert", "reverted")
+
+
 def cmd_members_list(args) -> int:
     """Who is in this workspace and how many editor seats are in use (#985).
     Read-only; inviting is a human-admin action in the UI."""
@@ -351,6 +446,262 @@ def cmd_members_list(args) -> int:
     return EXIT_OK
 
 
+def _describe_change(c: dict) -> str:
+    """One line a person can read: what the change did, in its own words."""
+    kind = c.get("kind")
+    if kind == "merge":
+        folded = ", ".join(c.get("merged_names") or [])
+        return f"merged {folded} into {c.get('survivor_name')}"
+    if kind == "renamed":
+        return f"renamed {c.get('old_name')} to {c.get('new_name')}"
+    if kind == "succeeded_by":
+        return f"{c.get('old_name')} succeeded by {c.get('new_name')}"
+    return str(kind)
+
+
+def cmd_changes_list(args) -> int:
+    """Merges, renames and successor links, newest first (#1577)."""
+    client, _ = _require_auth(args)
+    params: dict[str, Any] = {"limit": args.limit}
+    for flag, key in (("entity", "entity"), ("kind", "kind"), ("by", "by"), ("cursor", "cursor"),
+                      ("blueprint", "blueprint_id")):
+        if getattr(args, flag, None):
+            params[key] = getattr(args, flag)
+    if args.live:
+        params["live"] = "true"
+    try:
+        body = client.request("GET", "/v1/changes", params=params)
+    except ApiError as exc:
+        err(str(exc))
+        return EXIT_FAIL
+    if args.json:
+        out(body, True)
+        return EXIT_OK
+    bp = body.get("blueprint") or {}
+    if bp:
+        print(f"Blueprint: {bp.get('name')} ({bp.get('id')})")
+    rows = []
+    for c in body.get("data", []):
+        if c.get("undone_at"):
+            state = "undone"
+        elif c.get("undoable"):
+            state = "undoable"
+        else:
+            state = "cannot undo"
+        rows.append([c.get("id", ""), str(c.get("created_at", ""))[:19], c.get("entity", ""),
+                     _describe_change(c)[:60], state])
+    print(_table(rows, ["id", "when", "entity", "change", "state"]) if rows else "No changes.")
+    if body.get("has_more"):
+        print(f"\nMore: --cursor {body.get('next_cursor')}")
+    return EXIT_OK
+
+
+def cmd_changes_undo(args) -> int:
+    """Undo one change. It changes the dataset, so it is confirmed like a billable
+    run: interactively, or with --yes, and never silently in a pipe."""
+    client, _ = _require_auth(args)
+    try:
+        # The id goes into the URL path; a non-UUID could reach another endpoint.
+        change_id = str(uuid.UUID(args.change_id))
+    except ValueError:
+        err("change id must be a UUID (from `deepsieve changes list`)")
+        return EXIT_USAGE
+    if not args.yes:
+        if not _tty():
+            err("refusing to change data non-interactively; pass --yes")
+            return EXIT_USAGE
+        if input(f"Undo change {change_id}? This changes your dataset. [y/N] ").strip().lower() not in ("y", "yes"):
+            print("Cancelled.")
+            return EXIT_OK
+    headers = {"Idempotency-Key": args.idempotency_key} if args.idempotency_key else None
+    payload = {"overwrite_changes": True} if getattr(args, "overwrite_changes", False) else None
+    try:
+        body = client.request(
+            "POST", f"/v1/changes/{change_id}/undo", json_body=payload, headers=headers
+        )
+    except ApiError as exc:
+        # The API names its body field; a CLI user has a flag for it (second review, n3).
+        err(str(exc).replace("Send `overwrite_changes: true`", "Run again with --overwrite-changes"))
+        return EXIT_FAIL
+    out(body, args.json, f"undone: {_describe_change(body)}")
+    return EXIT_OK
+
+
+
+#: A cell id as /v1 issues them. It goes into a URL path; anything else is refused here.
+_CELL_ID = re.compile(r"cel_[A-Za-z0-9_-]{8,1024}")
+
+
+def cmd_holds_list(args) -> int:
+    """Cells you set on purpose, and what research found since (#2196)."""
+    client, _ = _require_auth(args)
+    params: dict[str, Any] = {"limit": args.limit}
+    for flag, key in (("entity", "entity"), ("cursor", "cursor"), ("blueprint", "blueprint_id")):
+        if getattr(args, flag, None):
+            params[key] = getattr(args, flag)
+    if args.pending:
+        params["pending"] = "true"
+    try:
+        body = client.request("GET", "/v1/holds", params=params)
+    except ApiError as exc:
+        err(str(exc))
+        return EXIT_FAIL
+    if args.json:
+        out(body, True)
+        return EXIT_OK
+    bp = body.get("blueprint") or {}
+    if bp:
+        print(f"Blueprint: {bp.get('name')} ({bp.get('id')})")
+    rows = []
+    for h in body.get("data", []):
+        pf = h.get("pending_finding") or {}
+        rows.append([
+            h.get("cell_id", ""),
+            f"{h.get('record_name') or h.get('record_id')}.{h.get('column')}"[:40],
+            str(h.get("value"))[:30],
+            str(pf.get("value"))[:30] if pf else "-",
+            # Printed so `holds apply --finding` can name what you saw (a newer one is refused).
+            pf.get("evidence_id") or "-",
+        ])
+    print(
+        _table(rows, ["cell", "cell of", "your value", "research found", "finding"])
+        if rows
+        else "No held cells."
+    )
+    if body.get("has_more"):
+        print(f"\nMore: --cursor {body.get('next_cursor')}")
+    return EXIT_OK
+
+
+def _hold_verb(args, verb: str) -> int:
+    """Apply or release one held cell. Both change what the dataset protects, so they are
+    confirmed like an undo: interactively, or with --yes, never silently in a pipe."""
+    client, _ = _require_auth(args)
+    if not _CELL_ID.fullmatch(args.cell_id or ""):
+        err("cell id must be one `deepsieve holds list` printed (it starts with cel_)")
+        return EXIT_USAGE
+    body: dict[str, Any] = {}
+    if verb == "apply" and args.finding:
+        try:
+            body["finding_evidence_id"] = str(uuid.UUID(args.finding))
+        except ValueError:
+            err("--finding must be the finding's evidence id (a UUID)")
+            return EXIT_USAGE
+    if not args.yes:
+        if not _tty():
+            err("refusing to change data non-interactively; pass --yes")
+            return EXIT_USAGE
+        what = "Take research's newer value for" if verb == "apply" else "Stop protecting"
+        if input(f"{what} this cell? [y/N] ").strip().lower() not in ("y", "yes"):
+            print("Cancelled.")
+            return EXIT_OK
+    headers = {"Idempotency-Key": args.idempotency_key} if args.idempotency_key else None
+    try:
+        result = client.request(
+            "POST", f"/v1/cells/{args.cell_id}/{verb}", json_body=body or None, headers=headers
+        )
+    except ApiError as exc:
+        err(str(exc))
+        return EXIT_FAIL
+    done = "applied; the cell stays protected" if verb == "apply" else "released; research may update it"
+    out(result, args.json, f"{done}: {result.get('column')} = {result.get('value')!r}")
+    return EXIT_OK
+
+
+def cmd_holds_apply(args) -> int:
+    return _hold_verb(args, "apply")
+
+
+def cmd_holds_release(args) -> int:
+    return _hold_verb(args, "release")
+
+def _merge_body(args) -> dict[str, Any] | None:
+    choices: dict[str, str] = {}
+    for c in args.choice or []:
+        key, sep, side = c.rpartition("=")
+        if not sep or side not in ("survivor", "loser"):
+            err(f"--choice takes KEY=survivor or KEY=loser, not {c!r}")
+            return None
+        choices[key] = side
+    body: dict[str, Any] = {
+        "entity": args.entity,
+        "survivor_id": args.survivor,
+        "loser_ids": list(args.loser),
+        "choices": choices,
+    }
+    if getattr(args, "blueprint", None):
+        body["blueprint_id"] = args.blueprint
+    return body
+
+
+def _print_merge(body: dict) -> None:
+    print(f"survivor: {body.get('survivor_name')} ({body.get('survivor_id')})")
+    print(f"merges:   {', '.join(n or '?' for n in body.get('merged_names') or [])}")
+    for f in body.get("fills") or []:
+        print(f"  fill      {f.get('column')}: {f.get('value')} (from {f.get('from')})")
+    for c in body.get("conflicts") or []:
+        how = {"tie": "TIE", "held": "set on purpose"}.get(c.get("basis"), "evidence")
+        mark = " (your choice)" if c.get("chosen") else ""
+        print(f"  conflict  {c.get('column')}: keeps {c.get('resolved_to')} [{how}]{mark}  "
+              f"survivor={c.get('survivor_value')!r} {c.get('loser_name')}={c.get('loser_value')!r}  "
+              f"key={c.get('choice_key')}")
+    ties = body.get("unresolved_ties") or []
+    if ties:
+        print(f"\nopen ties ({len(ties)}): settle each with --choice KEY=survivor|loser, "
+              "or pass --accept-survivor-on-ties")
+
+
+def cmd_merge_preview(args) -> int:
+    """What a merge would do; writes nothing (#1577 2c-3)."""
+    client, _ = _require_auth(args)
+    body = _merge_body(args)
+    if body is None:
+        return EXIT_USAGE
+    try:
+        out_ = client.request("POST", "/v1/merges/preview", json_body=body)
+    except ApiError as exc:
+        err(str(exc))
+        return EXIT_FAIL
+    if args.json:
+        out(out_, True)
+    else:
+        _print_merge(out_)
+    return EXIT_OK
+
+
+def cmd_merge_apply(args) -> int:
+    """Merge rows into a survivor. It changes the dataset, so it is confirmed like a
+    billable run: interactively, or with --yes, never silently in a pipe."""
+    client, _ = _require_auth(args)
+    body = _merge_body(args)
+    if body is None:
+        return EXIT_USAGE
+    body["accept_survivor_on_ties"] = bool(args.accept_survivor_on_ties)
+    if not args.yes:
+        if not _tty():
+            err("refusing to change data non-interactively; pass --yes")
+            return EXIT_USAGE
+        prompt = f"Merge {len(body['loser_ids'])} row(s) into {args.survivor}? This changes your dataset. [y/N] "
+        if input(prompt).strip().lower() not in ("y", "yes"):
+            print("Cancelled.")
+            return EXIT_OK
+    headers = {"Idempotency-Key": args.idempotency_key} if args.idempotency_key else None
+    try:
+        out_ = client.request("POST", "/v1/merges", json_body=body, headers=headers)
+    except ApiError as exc:
+        err(str(exc))
+        # An open tie is fixed by changing the command (--choice, or
+        # --accept-survivor-on-ties), so it exits as a usage error: a script can tell it
+        # apart from a failure without --json.
+        return EXIT_USAGE if exc.code == "ties_unresolved" else EXIT_FAIL
+    if args.json:
+        out(out_, True)
+    else:
+        _print_merge(out_)
+        print(f"\nmerged. Undo: deepsieve changes undo {out_.get('change_id')}")
+    return EXIT_OK
+
+
 def _blueprint_id(client, args) -> str | None:
     """The Blueprint these commands address: ``--blueprint``, else the active one.
 
@@ -610,12 +961,22 @@ def build_parser() -> argparse.ArgumentParser:
     lg.add_argument("--origin", help="deployment URL (e.g. https://staging.deepsieve.ai)")
     lg.add_argument("--api-key", help="headless: use a key instead of the browser flow")
     lg.add_argument("--no-browser", action="store_true", help="print the URL, don't open it")
+    # #1799: the default `cli` token carries no `blueprint:create`; it has no
+    # Blueprint command to spend that consent on. `--preset agent` is the explicit
+    # widening for a developer driving an agent from this credential, and the
+    # consent screen lists the wider set. The server clamps to `agent` either way.
+    lg.add_argument(
+        "--preset",
+        choices=("cli", "agent"),
+        default="cli",
+        help="scope preset to request: cli (default) or agent (adds Blueprint creation)",
+    )
     lg.set_defaults(func=cmd_login)
 
     lo = sub.add_parser("logout", help="forget this profile's stored credential", parents=[common])
     lo.set_defaults(func=cmd_logout)
 
-    wa = sub.add_parser("whoami", help="show the resolved identity, workspace and scopes", parents=[common])
+    wa = sub.add_parser("whoami", help="show the resolved identity, active Blueprint and scopes", parents=[common])
     wa.set_defaults(func=cmd_whoami)
 
     pr = sub.add_parser("profiles", help="list configured profiles", parents=[common])
@@ -626,6 +987,11 @@ def build_parser() -> argparse.ArgumentParser:
     rl = runs.add_parser("list", help="recent runs", parents=[common])
     rl.add_argument("--status")
     rl.add_argument("--limit", type=int, default=20)
+    rl.add_argument(
+        "--blueprint",
+        help="list one Blueprint's runs, by id (`deepsieve whoami` shows your active "
+        "one's); omitted: your active Blueprint",
+    )
     rl.set_defaults(func=cmd_runs_list)
 
     rg = runs.add_parser("get", help="one run's status", parents=[common])
@@ -639,6 +1005,8 @@ def build_parser() -> argparse.ArgumentParser:
                     help="restrict evidence to this source (repeatable): a host, *.gov, "
                          "https://host/path/*, or blueprint:primary; a cell cited only "
                          "elsewhere is not written")
+    rc.add_argument("--blueprint", help="Blueprint id to research (default: your active one, "
+                    "which `deepsieve whoami` shows)")
     rc.add_argument("--depth", default="standard", choices=["standard", "max"])
     rc.add_argument("--dry-run", action="store_true", help="free simulated run (~15s)")
     rc.add_argument("--no-monitor", dest="monitored", action="store_false",
@@ -660,10 +1028,79 @@ def build_parser() -> argparse.ArgumentParser:
     rx.add_argument("run_id")
     rx.set_defaults(func=cmd_runs_cancel)
 
+    chat = sub.add_parser("chat", help="a run's chat and the changes it proposed", parents=[common]).add_subparsers(dest="sub", required=True)
+    ct = chat.add_parser("thread", help="the thread, with each change's status and warnings", parents=[common])
+    ct.add_argument("run_id")
+    ct.set_defaults(func=cmd_chat_thread)
+    for name, fn, text in (
+        ("confirm", cmd_chat_confirm, "apply a change that is waiting for confirmation"),
+        ("dismiss", cmd_chat_dismiss, "decline a change that is waiting for confirmation"),
+        ("revert", cmd_chat_revert, "undo a change a chat answer applied"),
+    ):
+        cp = chat.add_parser(name, help=text, parents=[common])
+        cp.add_argument("action_id")
+        cp.set_defaults(func=fn)
+
     members = sub.add_parser("members", help="your workspace's team", parents=[common]).add_subparsers(dest="sub", required=True)
     ml = members.add_parser("list", help="who is in the workspace, and seat usage", parents=[common])
     ml.set_defaults(func=cmd_members_list)
 
+    changes = sub.add_parser("changes", help="merges, renames and successor links", parents=[common]).add_subparsers(dest="sub", required=True)
+    cl = changes.add_parser("list", help="newest first; undone ones included unless --live", parents=[common])
+    cl.add_argument("--entity", help="only this entity's records (an entity key)")
+    cl.add_argument("--kind", choices=["merge", "renamed", "succeeded_by"])
+    cl.add_argument("--by", choices=["user", "automatic", "operator"], help="who made the change")
+    cl.add_argument("--live", action="store_true", help="leave out undone changes")
+    cl.add_argument("--limit", type=int, default=25)
+    cl.add_argument("--cursor")
+    cl.add_argument("--blueprint", help="Blueprint id (default: the active one)")
+    cl.set_defaults(func=cmd_changes_list)
+    cu = changes.add_parser("undo", help="undo one change (needs data:write)", parents=[common])
+    cu.add_argument("change_id")
+    cu.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    cu.add_argument("--idempotency-key", help="make a retry safe")
+    cu.add_argument("--overwrite-changes", action="store_true",
+                    help="undo a merge even though cells it filled changed since")
+    cu.set_defaults(func=cmd_changes_undo)
+
+    holds = sub.add_parser("holds", help="cells you set on purpose, and newer research", parents=[common]).add_subparsers(dest="sub", required=True)
+    hl = holds.add_parser("list", help="newest first; --pending for those with newer research", parents=[common])
+    hl.add_argument("--entity", help="only this entity's cells (an entity key)")
+    hl.add_argument("--pending", action="store_true", help="only cells where research found something newer")
+    hl.add_argument("--limit", type=int, default=25)
+    hl.add_argument("--cursor")
+    hl.add_argument("--blueprint", help="Blueprint id (default: the active one)")
+    hl.set_defaults(func=cmd_holds_list)
+    ha = holds.add_parser("apply", help="take research's newer value (needs data:write)", parents=[common])
+    ha.add_argument("cell_id")
+    ha.add_argument("--finding", help="the `finding` id `holds list` printed for the value you reviewed (a newer one since is refused)")
+    ha.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    ha.add_argument("--idempotency-key", help="make a retry safe")
+    ha.set_defaults(func=cmd_holds_apply)
+    hr = holds.add_parser("release", help="stop protecting a cell (needs data:write)", parents=[common])
+    hr.add_argument("cell_id")
+    hr.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    hr.add_argument("--idempotency-key", help="make a retry safe")
+    hr.set_defaults(func=cmd_holds_release)
+
+    merge = sub.add_parser("merge", help="mark rows as duplicates of one another", parents=[common]).add_subparsers(dest="sub", required=True)
+    for name, helptext, func in (
+        ("preview", "what a merge would do (writes nothing)", cmd_merge_preview),
+        ("apply", "merge rows into a survivor (needs data:write)", cmd_merge_apply),
+    ):
+        mp = merge.add_parser(name, help=helptext, parents=[common])
+        mp.add_argument("entity", help="entity key (see `deepsieve data catalog`)")
+        mp.add_argument("--survivor", required=True, help="the row that stays")
+        mp.add_argument("--loser", required=True, action="append", help="a row merged into it (repeatable)")
+        mp.add_argument("--choice", action="append", help="settle a tie: KEY=survivor|loser (repeatable)")
+        mp.add_argument("--blueprint", help="Blueprint id (default: the active one)")
+        if name == "apply":
+            mp.add_argument("--accept-survivor-on-ties", action="store_true",
+                            help="keep the survivor's value on every tie you did not settle")
+            mp.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+            mp.add_argument("--idempotency-key", help="make a retry safe")
+        mp.set_defaults(func=func)
+
     data = sub.add_parser("data", help="your cited dataset", parents=[common]).add_subparsers(dest="sub", required=True)
 
     dc = data.add_parser("catalog", help="entities and columns (never guess these)", parents=[common])

{deepsieve_cli-0.3.0 → deepsieve_cli-0.4.0}/tests/test_cli.py

@@ -177,6 +177,29 @@ def test_login_rejects_a_bad_key_without_storing_it(monkeypatch):
     assert cfg.load_profile().api_key is None, "a rejected key must never be persisted"
 
 
+@pytest.mark.parametrize(("argv", "expected"), [([], "cli"), (["--preset", "agent"], "agent")])
+def test_device_login_requests_the_chosen_preset(monkeypatch, argv, expected):
+    """#1799: the default `cli` token has no `blueprint:create`; `--preset agent`
+    is the explicit widening. Assert what goes on the wire, and the credential
+    the flow stores, so a flag parsed but never sent cannot pass."""
+    sent: list[dict] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.url.path == "/v1/auth/device/code":
+            sent.append(json.loads(request.content))
+            return httpx.Response(201, json={
+                "device_code": "dc", "user_code": "A", "verification_uri": "u",
+                "verification_uri_complete": "u", "expires_in": 600, "interval": 0,
+            })
+        return httpx.Response(200, json={"api_key": "ds_live_dev", "key_name": "CLI"})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    rc = main(["login", "--origin", "https://x.test", "--no-browser", *argv])
+    assert rc == 0
+    assert [b["preset"] for b in sent] == [expected]
+    assert cfg.load_profile().api_key == "ds_live_dev"
+
+
 def test_commands_refuse_without_a_credential(capsys):
     assert main(["whoami"]) == 3
     assert "deepsieve login" in capsys.readouterr().err
@@ -333,6 +356,10 @@ def test_unfinished_run_exits_pending(monkeypatch):
         ["runs", "list", "--profile", "staging"],
         ["whoami", "--json"],
         ["setup", "mcp", "--json"],
+        ["changes", "list", "--live", "--json"],
+        ["merge", "preview", "books", "--survivor", "s", "--loser", "l", "--json"],
+        ["merge", "apply", "books", "--survivor", "s", "--loser", "l", "--loser", "m", "--yes"],
+        ["changes", "undo", "00000000-0000-0000-0000-000000000000", "--yes"],
     ],
 )
 def test_documented_command_lines_parse(argv):
@@ -667,3 +694,361 @@ def test_run_create_forwards_each_allowed_source(monkeypatch):
     # Only blanks → no key at all, never `[]` (the server refuses an empty list).
     assert main(["runs", "create", "--seeds", "Acme", "--dry-run", "--allowed-source", " "]) == 0
     assert "allowed_sources" not in seen["body"]
+
+
+def test_run_create_names_the_blueprint_it_sends_and_the_one_it_got(monkeypatch, capsys):
+    """gh #1282: `--blueprint` reaches the body, and the Blueprint the run is on is
+    printed, so a run on the wrong one is visible at once."""
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["body"] = json.loads(request.content)
+        return httpx.Response(
+            202,
+            json={"id": "run_1", "status": "queued", "blueprint": {"id": "bp-a", "name": "Widgets"}},
+        )
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["runs", "create", "--seeds", "Acme", "--dry-run", "--blueprint", "bp-a"]) == 0
+    assert seen["body"]["blueprint_id"] == "bp-a"
+    assert "Blueprint: Widgets (bp-a)" in capsys.readouterr().out
+
+
+def test_runs_get_and_whoami_name_the_blueprint(monkeypatch, capsys):
+    """gh #1282: text mode shows the Blueprint a run is on, and whoami keeps its
+    workspace line beside the new blueprint line (additive: scripts may parse it)."""
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.url.path == "/v1/me":
+            return httpx.Response(
+                200,
+                json={"org_id": "o", "workspace_schema": "ws_x", "role": "owner",
+                      "blueprint": {"id": "bp-a", "name": "Widgets"}},
+            )
+        return httpx.Response(
+            200,
+            json={"id": "run_1", "status": "completed", "done": True,
+                  "blueprint": {"id": "bp-a", "name": "Widgets"}},
+        )
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["runs", "get", "run_1"]) == 0
+    assert main(["whoami"]) == 0
+    printed = capsys.readouterr().out
+    assert "blueprint Widgets (bp-a)" in printed
+    assert "blueprint  Widgets (bp-a)" in printed and "workspace  ws_x" in printed
+
+
+# ── chat changes (#2187) ────────────────────────────────────────────────────
+
+
+_AID = "2d6c5d6e-7a57-4a53-9c1c-7b0e0f6a0b11"
+
+
+@pytest.mark.parametrize("op", ["confirm", "dismiss", "revert"])
+def test_chat_action_commands_post_to_their_endpoint(monkeypatch, op):
+    monkeypatch.setenv(cfg.ENV_KEY, "ds_live_k")
+    seen: list[tuple[str, str]] = []
+
+    def handler(request):
+        seen.append((request.method, request.url.path))
+        return httpx.Response(200, json={"action_id": _AID, "status": "ok"})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["chat", op, _AID, "--json"]) == 0
+    assert seen == [("POST", f"/v1/chat/actions/{_AID}/{op}")]
+
+
+def test_a_chat_action_id_must_be_a_uuid(monkeypatch, capsys):
+    monkeypatch.setenv(cfg.ENV_KEY, "ds_live_k")
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: pytest.fail("no request expected")))
+    assert main(["chat", "confirm", "../keys"]) != 0
+    assert "must be a UUID" in capsys.readouterr().err
+
+
+def test_chat_thread_lists_each_change_with_its_warning(monkeypatch, capsys):
+    monkeypatch.setenv(cfg.ENV_KEY, "ds_live_k")
+    body = {
+        "messages": [
+            {
+                "actions": [
+                    {
+                        "id": _AID,
+                        "status": "pending_confirmation",
+                        "action_type": "update_cell",
+                        "record_name": "Acme",
+                        "column_name": "fee",
+                        "warnings": [{"code": "unit_conversion", "message": "a unit change"}],
+                    }
+                ]
+            }
+        ]
+    }
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(200, json=body)))
+    assert main(["chat", "thread", _AID]) == 0
+    printed = capsys.readouterr().out
+    assert "pending_confirmation" in printed and "a unit change" in printed and _AID in printed
+
+
+# ── changes (#1577 2c-2) ─────────────────────────────────────────────────────
+
+
+CID = "6f1d8b43-95d7-430b-b355-764435da6663"
+
+
+def _change(**over):
+    base = {"object": "change", "id": "c-1", "kind": "renamed", "entity": "books",
+            "created_at": "2026-09-25T10:00:00+00:00", "undone_at": None, "undoable": True,
+            "old_name": "Bronte Hall", "new_name": "Bronte House", "survivor_name": None,
+            "merged_names": None}
+    return base | over
+
+
+def test_changes_list_says_what_each_change_did(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["path"], seen["params"] = request.url.path, dict(request.url.params)
+        return httpx.Response(200, json={
+            "data": [
+                _change(id="m-1", kind="merge", survivor_name="Keep Press",
+                        merged_names=["Keep Press Ltd"], old_name=None, new_name=None),
+                _change(undone_at="2026-09-25T11:00:00+00:00", undoable=False),
+            ],
+            "has_more": True, "next_cursor": "abc", "blueprint": {"id": "bp", "name": "Library"},
+        })
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["changes", "list", "--kind", "merge", "--live", "--entity", "books"]) == 0
+    text = capsys.readouterr().out
+    assert seen["path"] == "/v1/changes"
+    assert seen["params"] == {"limit": "25", "kind": "merge", "live": "true", "entity": "books"}
+    assert "merged Keep Press Ltd into Keep Press" in text and "undoable" in text
+    assert "renamed Bronte Hall to Bronte House" in text and "undone" in text
+    assert "--cursor abc" in text
+
+
+def test_changes_undo_is_refused_in_a_pipe_without_yes_and_sends_nothing(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    monkeypatch.setattr("deepsieve_cli.main._tty", lambda: False)
+    calls = []
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: calls.append(r) or httpx.Response(200)))
+    assert main(["changes", "undo", CID]) == 2
+    assert "pass --yes" in capsys.readouterr().err
+    assert calls == []
+
+
+def test_changes_undo_with_yes_posts_and_forwards_the_idempotency_key(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["method"], seen["path"] = request.method, request.url.path
+        seen["key"] = request.headers.get("idempotency-key")
+        return httpx.Response(200, json=_change(undone_at="2026-09-25T11:00:00+00:00"))
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["changes", "undo", CID, "--yes", "--idempotency-key", "k-1"]) == 0
+    assert (seen["method"], seen["path"], seen["key"]) == ("POST", f"/v1/changes/{CID}/undo", "k-1")
+    assert "undone: renamed Bronte Hall to Bronte House" in capsys.readouterr().out
+
+
+def test_changes_undo_surfaces_the_role_floor_refusal(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    body = {"error": {"type": "permission_error", "code": "insufficient_role",
+                      "message": "data:write needs the member role or above", "retriable": False}}
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(403, json=body)))
+    assert main(["changes", "undo", CID, "--yes"]) == 1
+    assert "needs the member role" in capsys.readouterr().err
+
+
+def test_changes_undo_names_the_flag_when_cells_changed_since(monkeypatch, capsys):
+    """#2199 review n3: the API names its body field; the CLI user is told the flag."""
+    _signed_in(monkeypatch)
+    body = {"error": {"type": "invalid_request_error", "code": "conflict", "param": "overwrite_changes",
+                      "message": "Changed since the merge: Author. Undoing restores the values from "
+                                 "before the merge and overwrites the newer ones. Send "
+                                 "`overwrite_changes: true` to undo anyway.", "retriable": False}}
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(409, json=body)))
+    assert main(["changes", "undo", CID, "--yes"]) == 1
+    err_text = capsys.readouterr().err
+    assert "Run again with --overwrite-changes to undo anyway." in err_text
+    assert "overwrite_changes: true" not in err_text
+
+
+def test_changes_undo_refuses_a_non_uuid_id_and_sends_nothing(monkeypatch, capsys):
+    """2c-2 review F9: the id goes into the URL path, so a crafted one could reach
+    another endpoint. Refused before any request, even with --yes."""
+    _signed_in(monkeypatch)
+    calls = []
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: calls.append(r) or httpx.Response(200)))
+    assert main(["changes", "undo", "../research/runs/x/cancel#", "--yes"]) == 2
+    assert "must be a UUID" in capsys.readouterr().err
+    assert calls == []
+
+
+# ── merge (#1577 2c-3) ───────────────────────────────────────────────────────
+
+_S, _L = "11111111-1111-1111-1111-111111111111", "22222222-2222-2222-2222-222222222222"
+
+
+def _merge_result(**over):
+    base = {"object": "merge", "change_id": None, "applied": False, "survivor_id": _S,
+            "survivor_name": "Tie Press", "merged_names": ["Tie Press Ltd"], "fills": [],
+            "conflicts": [{"choice_key": f"author::{_L}", "column": "author", "loser_id": _L,
+                           "loser_name": "Tie Press Ltd", "survivor_value": "Ann", "loser_value": "Bea",
+                           "basis": "tie", "resolved_to": "survivor", "chosen": False}],
+            "unresolved_ties": [f"author::{_L}"], "blueprint": {"id": "bp", "name": "Library"}}
+    return base | over
+
+
+def test_merge_preview_sends_the_body_and_names_the_open_tie(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["path"], seen["body"] = request.url.path, json.loads(request.content)
+        return httpx.Response(200, json=_merge_result())
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["merge", "preview", "books", "--survivor", _S, "--loser", _L]) == 0
+    assert seen["path"] == "/v1/merges/preview"
+    assert seen["body"] == {"entity": "books", "survivor_id": _S, "loser_ids": [_L], "choices": {}}
+    text = capsys.readouterr().out
+    assert f"key=author::{_L}" in text and "open ties (1)" in text
+
+
+def test_merge_preview_labels_a_held_conflict_as_set_on_purpose(monkeypatch, capsys):
+    """#2199 review m2: a held conflict is not an evidence decision."""
+    _signed_in(monkeypatch)
+    held = _merge_result(unresolved_ties=[])
+    held["conflicts"][0] |= {"basis": "held"}
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(200, json=held)))
+    assert main(["merge", "preview", "books", "--survivor", _S, "--loser", _L]) == 0
+    text = capsys.readouterr().out
+    assert "[set on purpose]" in text and "[evidence]" not in text
+
+
+def test_merge_apply_is_refused_in_a_pipe_without_yes_and_sends_nothing(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    monkeypatch.setattr("deepsieve_cli.main._tty", lambda: False)
+    calls = []
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: calls.append(r) or httpx.Response(201)))
+    assert main(["merge", "apply", "books", "--survivor", _S, "--loser", _L]) == 2
+    assert "pass --yes" in capsys.readouterr().err and calls == []
+
+
+def test_merge_apply_forwards_choices_the_tie_flag_and_the_key(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["body"], seen["key"] = json.loads(request.content), request.headers.get("idempotency-key")
+        return httpx.Response(201, json=_merge_result(applied=True, change_id="c-9", unresolved_ties=[]))
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    argv = ["merge", "apply", "books", "--survivor", _S, "--loser", _L,
+            "--choice", f"author::{_L}=loser", "--accept-survivor-on-ties", "--yes",
+            "--idempotency-key", "k-1"]
+    assert main(argv) == 0
+    assert seen["body"]["choices"] == {f"author::{_L}": "loser"}
+    assert seen["body"]["accept_survivor_on_ties"] is True and seen["key"] == "k-1"
+    assert "deepsieve changes undo c-9" in capsys.readouterr().out
+
+
+def test_a_malformed_choice_is_refused_before_any_request(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    calls = []
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: calls.append(r) or httpx.Response(200)))
+    assert main(["merge", "preview", "books", "--survivor", _S, "--loser", _L, "--choice", "author=maybe"]) == 2
+    assert "KEY=survivor or KEY=loser" in capsys.readouterr().err and calls == []
+
+
+def test_an_unsettled_tie_surfaces_the_servers_refusal(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    body = {"error": {"type": "conflict_error", "code": "ties_unresolved", "retriable": False,
+                      "message": f"1 tie(s) have no choice: author::{_L}.", "param": "choices"}}
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(409, json=body)))
+    assert main(["merge", "apply", "books", "--survivor", _S, "--loser", _L, "--yes"]) == 2
+    assert f"author::{_L}" in capsys.readouterr().err
+
+
+# ---------------------------------------------------------------------------
+# #2196 PR 2: holds list | apply | release
+# ---------------------------------------------------------------------------
+
+CELL = "cel_YmxhaGJsYWhibGFoYmxhaA"
+
+
+def _hold_item(**kw):
+    return {
+        "object": "cell_hold",
+        "cell_id": CELL,
+        "entity": "books",
+        "record_id": "00000000-0000-0000-0000-000000000001",
+        "record_name": "Emma",
+        "column": "author",
+        "value": "Austen",
+        "source": "chat_edit",
+        "set_at": "2026-09-25T10:00:00+00:00",
+        "pending_finding": {"evidence_id": "6f1c2d3e-0000-4000-8000-00000000f1d0", "value": "J. Austen", "source_urls": [],
+                            "found_at": "2026-09-25T11:00:00+00:00", "stage": "extract"},
+        **kw,
+    }
+
+
+def test_holds_list_shows_the_users_value_beside_what_research_found(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["path"], seen["params"] = request.url.path, dict(request.url.params)
+        return httpx.Response(200, json={"data": [_hold_item()], "has_more": False, "next_cursor": None})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["holds", "list", "--pending"]) == 0
+    assert seen["path"] == "/v1/holds" and seen["params"]["pending"] == "true"
+    text = capsys.readouterr().out
+    assert "Austen" in text and "J. Austen" in text
+    # The finding id is printed, so `holds apply --finding` can name the value reviewed.
+    assert _hold_item()["pending_finding"]["evidence_id"] in text
+
+
+def test_holds_apply_is_refused_in_a_pipe_without_yes_and_sends_nothing(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    monkeypatch.setattr("deepsieve_cli.main._tty", lambda: False)
+    calls = []
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: calls.append(r) or httpx.Response(200)))
+    assert main(["holds", "apply", CELL]) == 2
+    assert "pass --yes" in capsys.readouterr().err
+    assert calls == []
+
+
+def test_holds_apply_posts_the_finding_and_the_idempotency_key(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["path"], seen["key"] = request.url.path, request.headers.get("idempotency-key")
+        seen["body"] = json.loads(request.content or b"{}")
+        return httpx.Response(200, json={"object": "cell", "column": "author", "value": "J. Austen",
+                                         "held": True})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    rc = main(["holds", "apply", CELL, "--finding", CID, "--yes", "--idempotency-key", "k-2"])
+    assert rc == 0
+    assert (seen["path"], seen["key"]) == (f"/v1/cells/{CELL}/apply", "k-2")
+    assert seen["body"] == {"finding_evidence_id": CID}
+    assert "stays protected" in capsys.readouterr().out
+
+
+def test_holds_release_refuses_a_malformed_cell_id_and_sends_nothing(monkeypatch, capsys):
+    """The id goes into the URL path, so a crafted one could reach another endpoint."""
+    _signed_in(monkeypatch)
+    calls = []
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: calls.append(r) or httpx.Response(200)))
+    assert main(["holds", "release", "../research/runs/x/cancel#", "--yes"]) == 2
+    assert calls == []