deepsieve-cli 0.8.0__tar.gz → 0.9.0__tar.gz

{deepsieve_cli-0.8.0 → deepsieve_cli-0.9.0}/.gitignore

@@ -139,3 +139,6 @@ page-*.yml
 # same mechanism as the node_modules note above, a second time. Reports belong
 # in the session scratchpad; a copy in the tree is only ever a transient.
 .review-*/
+
+# gh #3106: the old build scripts/check-cross-version-seam.sh archives (never committed)
+/.cross-version/

{deepsieve_cli-0.8.0 → deepsieve_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deepsieve-cli
-Version: 0.8.0
+Version: 0.9.0
 Summary: DeepSieve CLI — run cited deep research from your terminal
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27

{deepsieve_cli-0.8.0 → deepsieve_cli-0.9.0}/pyproject.toml

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

{deepsieve_cli-0.8.0 → deepsieve_cli-0.9.0}/src/deepsieve_cli/main.py

@@ -343,6 +343,11 @@ def cmd_runs_create(args) -> int:
     if args.query and args.seeds:
         err("pass at most one of --query or --seeds")
         return EXIT_USAGE
+    phrases = [s.strip() for s in (getattr(args, "phrase", None) or []) if s.strip()]
+    file_types = [s.strip() for s in (getattr(args, "file_type", None) or []) if s.strip()]
+    if getattr(args, "no_search_hints", False) and (phrases or file_types):
+        err("pass --no-search-hints, or --phrase/--file-type, not both")
+        return EXIT_USAGE
     # gh #1282 B1: a billable run must NAME its Blueprint (the API refuses one that does not);
     # say so before anything else, with where the id comes from. A dry run is free and may omit it.
     if not args.dry_run and not getattr(args, "blueprint", None):
@@ -364,6 +369,16 @@ def cmd_runs_create(args) -> int:
     if excluded:
         # gh #2641 — repeatable; the server resolves and refuses, the CLI only carries.
         body["excluded_sources"] = excluded
+    # gh #2657 — the exact phrases and file types the researcher also searches for (never a
+    # filter). Given, they REPLACE the ones the server reads from --query; --no-search-hints
+    # sends {} so a misread one is dropped. Neither: the parsed ones, as before.
+    if getattr(args, "no_search_hints", False):
+        body["search_hints"] = {}
+    elif phrases or file_types:
+        body["search_hints"] = {
+            **({"exact_phrases": phrases} if phrases else {}),
+            **({"file_types": file_types} if file_types else {}),
+        }
     if getattr(args, "blueprint", None):
         body["blueprint_id"] = args.blueprint
     if getattr(args, "expected_total", None) is not None:
@@ -738,6 +753,13 @@ def _refund_line(refund: dict | None) -> str:
     if kind == "kept_credits":
         used = plural(credits, "run credit", "run credits") if credits is not None else "run credits"
         return f"Your earlier run used {used}. It finished with no results, and a finished run isn't refunded."
+    if kind == "kept_mixed":
+        # gh #1858: a finished mixed run kept its credits AND its prepaid part.
+        if credits is not None and amount is not None:
+            used = f"{plural(credits, 'run credit', 'run credits')} and {_usd(amount)} of your prepaid balance"
+        else:
+            used = "run credits and your prepaid balance"
+        return f"Your earlier run used {used}. It finished with no results, and a finished run isn't refunded."
     if kind == "refunded_to_ended_plan":
         return f"Your plan has ended, so the credits for your {run} were returned to it and can't be used."
     if kind == "refunded_to_ended_period":
@@ -757,6 +779,10 @@ def _refund_line(refund: dict | None) -> str:
     if kind == "partially_refunded_to_plan":
         return (f"Part of your {run} returned nothing. The credits for that part were returned to "
                 "the plan they came from.")
+    if kind == "not_refunded_account_closed":
+        # gh #3045: closure voids prepaid credit, so nothing was sent: never "refunded".
+        return (f"Nothing was returned for your {run}, because your account is closed and a "
+                "closed account can't hold prepaid credit.")
     if kind == "refunded_unknown":
         return f"Your {run} was refunded in full."
     if kind == "refund_pending":
@@ -781,6 +807,16 @@ def _retry_cost(details: dict) -> str:
     if funding.get("covered_by") == "plan_credits":
         n = funding.get("plan_credits_needed")
         return f"uses {n} plan run credit{'' if n == 1 else 's'} (list price {_usd(total)})"
+    if funding.get("covered_by") == "mixed":
+        # gh #1858: plan credits for the interactions they cover, the balance for the rest.
+        prepaid = _usd(funding.get("prepaid_cents"))
+        cost = (
+            f"uses your plan run credits and {prepaid} from your balance "
+            f"(list price {_usd(total)})"
+        )
+        if (details.get("shortfall_cents") or 0) > 0:
+            cost += f", and your balance is {_usd(details['shortfall_cents'])} short"
+        return cost
     cost = f"charges {_usd(total)}"
     if (details.get("shortfall_cents") or 0) > 0:
         cost += f", and your balance is {_usd(details['shortfall_cents'])} short"
@@ -838,6 +874,10 @@ def cmd_runs_retry(args) -> int:
     if args.expected_funding is not None and args.expected_total is None:
         err("--expected-funding binds the rail of a quoted total: pass --expected-total too")
         return EXIT_USAGE
+    # gh #1858: a mixed rail binds its split, so it needs the prepaid part; nothing else takes one.
+    if (args.expected_funding == "mixed") != (args.expected_prepaid is not None):
+        err("--expected-funding mixed and --expected-prepaid CENTS go together (funding.prepaid_cents)")
+        return EXIT_USAGE
     client, _ = _require_auth(args)
     path = f"/v1/research/runs/{rid}/retry"
     payload: dict = {}
@@ -845,6 +885,8 @@ def cmd_runs_retry(args) -> int:
         payload["expected_total_cents"] = args.expected_total
     if args.expected_funding is not None:
         payload["expected_funding"] = args.expected_funding
+    if args.expected_prepaid is not None:
+        payload["expected_prepaid_cents"] = args.expected_prepaid
     # At most two refusals: the quote, and one re-quote if the price moved while the person was
     # deciding. A third would be the API contradicting itself; stop rather than loop, and never ask
     # a question whose yes would not be sent (seat-2389 L1).
@@ -863,11 +905,24 @@ def cmd_runs_retry(args) -> int:
                 # No quote to state: never prompt "$0.00" (seat-2389 L2).
                 err(f"{exc} (the API sent no total to confirm; nothing was charged)")
                 return EXIT_FAIL
+            funding = exc.details.get("funding") or {}
+            rail = funding.get("covered_by")
+            prepaid = funding.get("prepaid_cents")
+            if rail == "mixed" and (not isinstance(prepaid, int) or isinstance(prepaid, bool)):
+                # gh #1858 review: a mixed quote without its prepaid part cannot be confirmed
+                # (the API refuses `mixed` without it), so say so, never `--expected-prepaid
+                # None`. Checked before the quote text, which prices the split.
+                err(
+                    f"{exc} (the API's quote names a split without its prepaid part; "
+                    "nothing was charged)"
+                )
+                return EXIT_FAIL
             ask = _retry_quote_text(
                 exc.details, moved=exc.code == "retry_price_changed", sent=payload
             )
-            rail = (exc.details.get("funding") or {}).get("covered_by")
             flags = f"--expected-total {total}" + (f" --expected-funding {rail}" if rail else "")
+            if rail == "mixed":
+                flags += f" --expected-prepaid {prepaid}"
             if not _interactive():
                 if args.json:
                     print(json.dumps({"error": {"code": exc.code, "message": ask, "details": exc.details}}))
@@ -881,6 +936,8 @@ def cmd_runs_retry(args) -> int:
             payload = {"expected_total_cents": total}
             if rail:
                 payload["expected_funding"] = rail  # gh #2456: the yes covers what pays too
+            if rail == "mixed":
+                payload["expected_prepaid_cents"] = prepaid  # gh #1858: and the split
     if body is None:
         err("the API kept refusing the confirmation; nothing was charged")
         return EXIT_FAIL
@@ -998,6 +1055,12 @@ def _describe_change(c: dict) -> str:
     if kind == "link_removed":
         link = c.get("link") or {}
         return f"removed {link.get('target_name') or link.get('target_id')} from {link.get('record_name')}"
+    if kind == "choice":
+        ch = c.get("choice") or {}
+        return (
+            f"chose {ch.get('chosen_value')!r} over {ch.get('prior_value')!r} for "
+            f"{ch.get('record_name')}.{ch.get('column')}"
+        )
     return str(kind)
 
 
@@ -1172,6 +1235,90 @@ def cmd_holds_keep(args) -> int:
 def cmd_holds_release(args) -> int:
     return _hold_verb(args, "release")
 
+
+def cmd_holds_conflicts(args) -> int:
+    """Cells waiting for you to choose among the values one run stated (gh #2370)."""
+    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)
+    try:
+        body = client.request("GET", "/v1/conflicts", 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", []):
+        where = f"{c.get('record_name') or c.get('record_id')}.{c.get('column')}"[:40]
+        # The value shown first, then each value it can be chosen from, with the evidence id
+        # `holds choose` takes and `--expected` the shown value's.
+        rows.append([c.get("cell_id", ""), where, str(c.get("value"))[:30], "shown", c.get("value_evidence_id") or "-"])
+        for cand in c.get("candidates") or []:
+            tag = cand.get("verdict") or ""
+            if cand.get("refused_by"):
+                tag += " · kept out by your knowledge"
+            rows.append(["", "", str(cand.get("value"))[:30], tag[:40], cand.get("evidence_id") or "-"])
+    print(
+        _table(rows, ["cell", "cell of", "value", "verdict", "evidence"])
+        if rows
+        else "No cells waiting for you to choose."
+    )
+    if body.get("truncated"):
+        print(
+            f"\nnote: a PREVIEW, not every cell (preview_row_cap={body.get('preview_row_cap')}).",
+            file=sys.stderr,
+        )
+    if body.get("has_more"):
+        print(f"\nMore: --cursor {body.get('next_cursor')}")
+    return EXIT_OK
+
+
+def cmd_holds_choose(args) -> int:
+    """Make one of a cell's values the one it shows (gh #2370). It changes the dataset, so it is
+    confirmed like the other hold verbs: 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 conflicts` printed (it starts with cel_)")
+        return EXIT_USAGE
+    body: dict[str, Any] = {}
+    for name, raw in (("evidence_id", args.evidence_id), ("expected_value_evidence_id", args.expected)):
+        if raw is None:
+            continue
+        try:
+            body[name] = str(uuid.UUID(raw))
+        except ValueError:
+            err(f"{'evidence id' if name == 'evidence_id' else '--expected'} must be an evidence id (a UUID)")
+            return EXIT_USAGE
+    if not args.yes:
+        if not _interactive():
+            err("refusing to change data non-interactively; pass --yes")
+            return EXIT_USAGE
+        if input("Show this value in the cell, and protect it from later research? [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}/choose", json_body=body, headers=headers
+        )
+    except ApiError as exc:
+        err(str(exc))
+        return EXIT_FAIL
+    out(
+        result,
+        args.json,
+        f"chosen; the cell stays protected: {result.get('column')} = {result.get('value')!r}"
+        f" (undo: deepsieve changes undo {result.get('change_id')})",
+    )
+    return EXIT_OK
+
 def _merge_body(args) -> dict[str, Any] | None:
     choices: dict[str, str] = {}
     for c in args.choice or []:
@@ -1462,6 +1609,19 @@ def cmd_data_get(args) -> int:
         err(str(exc))
         return EXIT_FAIL
     out(body, True)  # rows are structured either way; --json only stills the notes
+    conflicting = sum(
+        1
+        for row in body.get("data") or []
+        for cite in (row.get("citations") or {}).values()
+        if ((cite or {}).get("selection") or {}).get("state") == "conflicting"
+    )
+    if conflicting and not args.json:
+        # gh #2370: a cell stated two ways shows the better-sourced value until someone chooses.
+        print(
+            f"\nnote: {conflicting} cell(s) here were stated more than one way and wait for you "
+            "to choose: `deepsieve holds conflicts`.",
+            file=sys.stderr,
+        )
     if body.get("truncated") and not args.json:
         print(
             "\nnote: this response is a PREVIEW, not the full dataset "
@@ -1837,6 +1997,16 @@ def build_parser() -> argparse.ArgumentParser:
     rc.add_argument("--excluded-source", action="append", metavar="PATTERN",
                     help="never cite this source (repeatable): a host, *.tld or "
                          "https://host/path/*; a citation on it is not written")
+    rc.add_argument("--phrase", action="append", metavar="TEXT",
+                    help="also search for pages with this exact wording (repeatable; never a "
+                         "filter). With --file-type, replaces EVERY exact phrase and file type "
+                         "read from --query")
+    rc.add_argument("--file-type", action="append", metavar="EXT",
+                    help="also look for this kind of document, e.g. pdf or xlsx (repeatable; "
+                         "never a filter). With --phrase, replaces EVERY exact phrase and file "
+                         "type read from --query")
+    rc.add_argument("--no-search-hints", action="store_true",
+                    help="drop the exact phrases and file types read from --query")
     rc.add_argument("--blueprint", help="Blueprint id to research; REQUIRED unless --dry-run "
                     "(`deepsieve whoami` shows your active Blueprint's id)")
     rc.add_argument("--depth", default="standard", choices=["standard", "max"])
@@ -1882,10 +2052,17 @@ def build_parser() -> argparse.ArgumentParser:
     )
     rr.add_argument(
         "--expected-funding",
-        choices=["free_run", "plan_credits", "balance"],
+        choices=["free_run", "plan_credits", "balance", "mixed"],
         default=None,
         help="also bind what pays, as quoted (funding.covered_by); needs --expected-total",
     )
+    rr.add_argument(
+        "--expected-prepaid",
+        type=int,
+        default=None,
+        metavar="CENTS",
+        help="with --expected-funding mixed: the balance's part, as quoted (funding.prepaid_cents)",
+    )
     rr.set_defaults(func=cmd_runs_retry)
 
     rm = runs.add_parser(
@@ -1958,10 +2135,10 @@ def build_parser() -> argparse.ArgumentParser:
     ml = members.add_parser("list", help="who is in the organization, and seat usage", parents=[common])
     ml.set_defaults(func=cmd_members_list)
 
-    changes = sub.add_parser("changes", help="merges, renames, successor links and removed links", parents=[common]).add_subparsers(dest="sub", required=True)
+    changes = sub.add_parser("changes", help="merges, renames, successor links, removed links and value choices", 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", "link_removed"])
+    cl.add_argument("--kind", choices=["merge", "renamed", "succeeded_by", "link_removed", "choice"])
     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)
@@ -2022,6 +2199,19 @@ def build_parser() -> argparse.ArgumentParser:
     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)
+    hc = holds.add_parser("conflicts", help="cells waiting for you to choose among one run's values", parents=[common])
+    hc.add_argument("--entity", help="only this entity's cells (an entity key)")
+    hc.add_argument("--limit", type=int, default=25)
+    hc.add_argument("--cursor")
+    hc.add_argument("--blueprint", help="Blueprint id (default: the active one)")
+    hc.set_defaults(func=cmd_holds_conflicts)
+    hch = holds.add_parser("choose", help="show one of a cell's values (needs data:write)", parents=[common])
+    hch.add_argument("cell_id")
+    hch.add_argument("evidence_id", help="the `evidence` id `holds conflicts` printed for the value to show")
+    hch.add_argument("--expected", help="the `evidence` id of the value the cell showed when you looked (a change since is refused)")
+    hch.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    hch.add_argument("--idempotency-key", help="make a retry safe")
+    hch.set_defaults(func=cmd_holds_choose)
 
     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 (

deepsieve_cli-0.9.0/tests/fixtures/conflict_page.json

@@ -0,0 +1,48 @@
+{
+  "data": [
+    {
+      "object": "conflict",
+      "cell_id": "cel_YmxhaGJsYWhibGFoYmxhaA",
+      "entity": "books",
+      "record_id": "00000000-0000-0000-0000-000000000001",
+      "record_name": "Emma",
+      "column": "author",
+      "value": "Jane Austen",
+      "value_evidence_id": "6f1c2d3e-0000-4000-8000-00000000a001",
+      "selection": {
+        "state": "conflicting",
+        "reason": "the quality check supported 2 different values; the better-sourced one is shown until someone chooses"
+      },
+      "candidates": [
+        {
+          "kind": "also_stated",
+          "evidence_id": "6f1c2d3e-0000-4000-8000-00000000a002",
+          "verdict": "supported",
+          "source_hosts": [
+            "trade.test"
+          ],
+          "captured_at": "2026-10-19T10:00:00+00:00",
+          "reason": null,
+          "choosable": true,
+          "refused_by": [
+            "k_cautionb"
+          ],
+          "knowledge_decided": [],
+          "knowledge_cited": [],
+          "value": "J. Austen",
+          "note": "[ALSO STATED] this run also stated this value; the cell shows another"
+        }
+      ],
+      "blueprint": {
+        "id": "bp_1",
+        "name": "Library"
+      }
+    }
+  ],
+  "has_more": false,
+  "next_cursor": null,
+  "blueprint": {
+    "id": "bp_1",
+    "name": "Library"
+  }
+}

{deepsieve_cli-0.8.0 → deepsieve_cli-0.9.0}/tests/test_cli.py

@@ -775,6 +775,35 @@ def test_run_create_forwards_each_excluded_source(monkeypatch):
     assert "excluded_sources" not in seen["body"]
 
 
+def test_run_create_sends_search_hints_and_can_drop_them(monkeypatch, capsys):
+    """gh #2657 — `--phrase` / `--file-type` send `search_hints` (replacing the parsed ones);
+    `--no-search-hints` sends `{}`, which drops every parsed hint; neither sends nothing, which
+    keeps the parsed ones. Both kinds of flag at once is a usage error, never a guess."""
+    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"})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    q = ["runs", "create", "--query", "Acme, PDFs only", "--dry-run"]
+    assert main([*q, "--phrase", " Request for Information ", "--file-type", "pdf"]) == 0
+    assert seen["body"]["search_hints"] == {
+        "exact_phrases": ["Request for Information"],
+        "file_types": ["pdf"],
+    }
+    assert main([*q, "--file-type", "xlsx"]) == 0
+    assert seen["body"]["search_hints"] == {"file_types": ["xlsx"]}
+    assert main([*q, "--no-search-hints"]) == 0
+    assert seen["body"]["search_hints"] == {}
+    assert main(q) == 0
+    assert "search_hints" not in seen["body"]
+    seen.clear()
+    assert main([*q, "--no-search-hints", "--phrase", "x y"]) == 2
+    assert seen == {}, "a usage error sends nothing"
+
+
 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."""
@@ -1226,6 +1255,68 @@ def test_holds_release_refuses_a_malformed_cell_id_and_sends_nothing(monkeypatch
     assert calls == []
 
 
+# ---------------------------------------------------------------------------
+# gh #2370 B2: holds conflicts | choose
+# ---------------------------------------------------------------------------
+
+#: The shape `GET /v1/conflicts` serves; `api/tests/test_v1_choose.py` asserts the API's keys
+#: equal this file's, so the CLI is never tested against a shape the API stopped sending.
+_CONFLICTS = json.loads((Path(__file__).parent / "fixtures" / "conflict_page.json").read_text())
+
+
+def test_holds_conflicts_lists_the_value_shown_and_each_value_to_choose(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=_CONFLICTS)
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["holds", "conflicts", "--entity", "books"]) == 0
+    assert seen["path"] == "/v1/conflicts" and seen["params"]["entity"] == "books"
+    text = capsys.readouterr().out
+    item = _CONFLICTS["data"][0]
+    # Both values, and both evidence ids, so `holds choose` can name one and `--expected` the other.
+    assert "Jane Austen" in text and "J. Austen" in text
+    assert item["value_evidence_id"] in text and item["candidates"][0]["evidence_id"] in text
+    assert "kept out by your knowledge" in text, "a refused value says so"
+
+
+def test_holds_choose_posts_the_value_and_the_value_seen(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen = {}
+    item = _CONFLICTS["data"][0]
+
+    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, "change_id": CID})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    cand = item["candidates"][0]["evidence_id"]
+    rc = main(["holds", "choose", CELL, cand, "--expected", item["value_evidence_id"], "--yes",
+               "--idempotency-key", "k-4"])
+    assert rc == 0
+    assert (seen["path"], seen["key"]) == (f"/v1/cells/{CELL}/choose", "k-4")
+    assert seen["body"] == {"evidence_id": cand, "expected_value_evidence_id": item["value_evidence_id"]}
+    out_ = capsys.readouterr().out
+    assert "stays protected" in out_ and f"changes undo {CID}" in out_
+
+
+def test_holds_choose_asks_in_a_pipe_and_refuses_a_malformed_id(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    calls = []
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: calls.append(r) or httpx.Response(200)))
+    monkeypatch.setattr("deepsieve_cli.main._tty", lambda: False)
+    assert main(["holds", "choose", CELL, CID]) == 2
+    assert "pass --yes" in capsys.readouterr().err
+    assert main(["holds", "choose", CELL, "not-a-uuid", "--yes"]) == 2
+    assert main(["holds", "choose", "../x#", CID, "--yes"]) == 2
+    assert calls == [], "nothing sent"
+
+
 def test_a_billable_run_without_a_blueprint_is_a_usage_error_before_any_request(monkeypatch, capsys):
     """gh #1282 B1: the API now requires `blueprint_id` on run create; the CLI says so first, with
     where the id comes from, and sends nothing. A dry run may omit it (the API's own exception).
@@ -1686,10 +1777,18 @@ def test_a_quote_without_a_total_is_never_asked_as_zero(monkeypatch, capsys):
          "The credits for your failed run were returned to the plan they came from."),
         ({"kind": "partially_refunded_to_plan", "run_status": "failed"},
          "Part of your failed run returned nothing. The credits for that part were returned"),
+        # gh #3045: a refund to a closed account sends nothing: never "refunded".
+        ({"kind": "not_refunded_account_closed", "run_status": "failed"},
+         "Nothing was returned for your failed run, because your account is closed"),
+        # gh #1858: a finished mixed run kept both halves.
+        ({"kind": "kept_mixed", "credits": 2, "amount_cents": 1000, "run_status": "completed"},
+         "Your earlier run used 2 run credits and $10.00 of your prepaid balance. It finished"),
         ({"kind": "unconfirmed"}, "We can't confirm yet whether your earlier run was refunded."),
     ],
     ids=["kept-credits", "pending", "ended-plan", "ended-period", "partial-ended-plan",
-         "partial-ended-period", "returned-to-plan", "partial-returned-to-plan", "unconfirmed"],
+         "partial-ended-period", "returned-to-plan", "partial-returned-to-plan", "closed-account",
+         "kept-mixed",
+         "unconfirmed"],
 )
 def test_every_refund_kind_reads_in_words_never_its_code(monkeypatch, capsys, refund, words):
     """seat-2389 L3: the app's sentences (site `refundHeadline`), never a raw enum name."""
@@ -2431,6 +2530,96 @@ def test_expected_funding_is_sent_beside_the_total(monkeypatch, capsys):
     assert seen == [{"expected_total_cents": 1200, "expected_funding": "plan_credits"}]
 
 
+# gh #1858: a mixed quote's yes binds its split (`funding.prepaid_cents`) as well as its rail.
+
+_MIXED_QUOTE = {
+    **_RETRY_QUOTE,
+    "total_price_cents": 3000,
+    "funding": {"covered_by": "mixed", "plan_credits_needed": 3, "plan_credits_available": 2,
+                "balance_cents": 5000, "prepaid_cents": 1000},
+}
+
+
+def _mixed_handler(seen: list):
+    def handler(request: httpx.Request) -> httpx.Response:
+        body = json.loads(request.content) if request.content else {}
+        seen.append(body)
+        if body.get("expected_prepaid_cents") != 1000 or body.get("expected_funding") != "mixed":
+            return httpx.Response(409, json={"error": {
+                "code": "retry_confirmation_required", "message": "confirm",
+                "param": "expected_total_cents", "retriable": False, "details": _MIXED_QUOTE,
+            }})
+        return httpx.Response(202, json={
+            "object": "run", "id": "new-run", "status": "queued",
+            "retry": {"source_run_id": RUN, "mode": "restarted"},
+        })
+
+    return handler
+
+
+def test_interactively_the_yes_binds_a_mixed_split(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    monkeypatch.setattr("deepsieve_cli.main._interactive", lambda: True)
+    prompts: list = []
+    monkeypatch.setattr("builtins.input", lambda prompt="": prompts.append(prompt) or "y")
+    seen: list = []
+    monkeypatch.setattr(httpx, "Client", _mock(_mixed_handler(seen)))
+    assert main(["runs", "retry", RUN]) == 0
+    assert seen == [
+        {},
+        {"expected_total_cents": 3000, "expected_funding": "mixed", "expected_prepaid_cents": 1000},
+    ]
+    assert "uses your plan run credits and $10.00 from your balance" in prompts[0]
+
+
+def test_in_a_pipe_the_hint_names_the_prepaid_flag_for_a_mixed_quote(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    monkeypatch.setattr("deepsieve_cli.main._interactive", lambda: False)
+    seen: list = []
+    monkeypatch.setattr(httpx, "Client", _mock(_mixed_handler(seen)))
+    assert main(["runs", "retry", RUN]) == 2
+    err = capsys.readouterr().err
+    assert "--expected-total 3000 --expected-funding mixed --expected-prepaid 1000" in err
+
+
+@pytest.mark.parametrize("interactive", [True, False], ids=["prompt", "pipe"])
+def test_a_mixed_quote_without_its_prepaid_part_is_never_confirmed(monkeypatch, capsys, interactive):
+    """gh #1858 review: a quote naming `mixed` with no `prepaid_cents` printed
+    `--expected-prepaid None` in a pipe, and at a prompt sent a body the API refuses. It is
+    refused here, nothing is sent after the first request, and the message says why."""
+    _signed_in(monkeypatch)
+    monkeypatch.setattr("deepsieve_cli.main._interactive", lambda: interactive)
+    monkeypatch.setattr("builtins.input", lambda prompt="": "y")
+    broken = {**_MIXED_QUOTE, "funding": {**_MIXED_QUOTE["funding"], "prepaid_cents": None}}
+    seen: list = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(json.loads(request.content) if request.content else {})
+        return httpx.Response(409, json={"error": {
+            "code": "retry_confirmation_required", "message": "confirm",
+            "param": "expected_total_cents", "retriable": False, "details": broken,
+        }})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["runs", "retry", RUN]) == 1
+    err = capsys.readouterr().err
+    assert "without its prepaid part" in err
+    assert "None" not in err
+    assert seen == [{}]
+
+
+def test_a_mixed_rail_and_its_prepaid_part_go_together(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen: list = []
+    monkeypatch.setattr(httpx, "Client", _mock(_mixed_handler(seen)))
+    alone = ["runs", "retry", RUN, "--expected-total", "3000", "--expected-funding", "mixed"]
+    assert main(alone) == 2
+    stray = ["runs", "retry", RUN, "--expected-total", "3000", "--expected-funding", "balance",
+             "--expected-prepaid", "1000"]
+    assert main(stray) == 2
+    assert seen == []
+
+
 def test_expected_funding_without_its_total_sends_nothing(monkeypatch, capsys):
     _signed_in(monkeypatch)
     seen: list = []