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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deepsieve-cli
-Version: 0.6.0
+Version: 0.8.0
 Summary: DeepSieve CLI — run cited deep research from your terminal
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27
@@ -44,8 +44,11 @@ deepsieve runs retry <id>                     # a retry that charges shows its t
 deepsieve runs reruns <id>                    # a report's re-research waiting for approval
 deepsieve runs monitoring <id> --off          # stop a report's monitoring; asks first
 deepsieve links remove <entity> <record-id> <linked-entity> <target-id>   # asks first
+deepsieve subscription cancel                 # at period end; nothing new is charged; asks first
+deepsieve subscription resume                 # undo it while the period runs; asks first
 deepsieve data catalog                        # entities + columns (never guess)
 deepsieve data get companies --receipts       # rows with per-cell citations
+deepsieve data history companies headquarters_city --record <id>   # one cell's change history
 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_cli-0.6.0 → deepsieve_cli-0.8.0}/README.md

@@ -36,8 +36,11 @@ deepsieve runs retry <id>                     # a retry that charges shows its t
 deepsieve runs reruns <id>                    # a report's re-research waiting for approval
 deepsieve runs monitoring <id> --off          # stop a report's monitoring; asks first
 deepsieve links remove <entity> <record-id> <linked-entity> <target-id>   # asks first
+deepsieve subscription cancel                 # at period end; nothing new is charged; asks first
+deepsieve subscription resume                 # undo it while the period runs; asks first
 deepsieve data catalog                        # entities + columns (never guess)
 deepsieve data get companies --receipts       # rows with per-cell citations
+deepsieve data history companies headquarters_city --record <id>   # one cell's change history
 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_cli-0.6.0 → deepsieve_cli-0.8.0}/pyproject.toml

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

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

@@ -198,9 +198,51 @@ def cmd_whoami(args) -> int:
     print(f"workspace  {me.get('workspace_schema')}")
     print(f"role       {me.get('role')}")
     print(f"scopes     {', '.join(me.get('scopes') or []) or '(full)'}")
+    trial_line = _trial_line(me.get("subscription"), me.get("app_url"))
+    if trial_line:
+        print(f"trial      {trial_line}")
     return EXIT_OK
 
 
+def _trial_line(subscription: dict | None, app_url: str | None) -> str | None:
+    """The free trial in one line (gh #2896), from the dates the server derived: never
+    counted here, so the CLI and the billing page cannot disagree about the day. A cancel is
+    read from `cancel_at_period_end`, never inferred from a missing amount."""
+    sub = subscription or {}
+    trial = sub.get("trial") or {}
+    cancelled = bool(sub.get("cancel_at_period_end"))
+
+    def charge() -> str:
+        cents = trial.get("first_charge_cents")
+        amount = f"{_usd(cents)} " if cents is not None else ""
+        return f"first charge {amount}on {trial.get('first_charge_on')}"
+
+    if trial.get("conversion_failed"):
+        if cancelled:
+            return "ended; the first charge was declined and the plan is cancelled, so it will not be retried."
+        return "ended, and the first charge was declined. Update the card in the app."
+    if trial.get("ended_without_charge"):
+        return f"cancelled and ended on {trial.get('ends_on')}; nothing was charged."
+    if trial.get("conversion_submitted"):
+        return f"ended; {charge()} is being processed and cannot be stopped."
+    if trial.get("conversion_pending"):
+        return f"ended; {charge()} is due."
+    if trial.get("active"):
+        left = trial.get("days_left")
+        days = f"{left} day{'' if left == 1 else 's'} left" if left is not None else "active"
+        if cancelled:
+            return f"{days}; cancelled, so it will not be charged (access until {trial.get('ends_on')})"
+        if trial.get("first_charge_on"):
+            return f"{days}; {charge()}"
+        return days
+    if trial.get("eligible") is True:
+        length = trial.get("offer_days")
+        what = f"a {length}-day trial" if length else "a trial"
+        where = f"{app_url}/pricing" if app_url else "the pricing page"
+        return f"{what} is available. Start one from {where} (it takes a card, so it needs a person)."
+    return None
+
+
 def cmd_profiles(args) -> int:
     profiles = config.list_profiles()
     active = config.profile_name(args.profile)
@@ -262,11 +304,28 @@ def cmd_runs_get(args) -> int:
             print(f"blueprint {bp.get('name')} ({bp.get('id')})")
         if body.get("error"):
             print(f"error    {body['error'].get('message')}")
+        for line in _recheck_lines(body):
+            print(f"result   {line}")
     if not body.get("done"):
         return EXIT_PENDING
     return EXIT_OK if body.get("status") == "completed" else EXIT_FAIL
 
 
+def _recheck_lines(body: dict) -> list[str]:
+    """gh #2781 — what a re-check run found (`check_results`, one line per checked value) or what
+    a follow-up search found (`update_result`), in the sentences the API wrote for a person."""
+    lines = []
+    for entry in body.get("check_results") or []:
+        line = str(entry.get("message") or "")
+        if entry.get("followup_run_id"):
+            line += f" (follow-up run {entry['followup_run_id']})"
+        lines.append(line)
+    update = body.get("update_result") or {}
+    if update.get("message"):
+        lines.append(str(update["message"]))
+    return lines
+
+
 def _folded_text(folds: list[dict]) -> str:
     """gh #2716 — the seeds a request counted once, in one line (the first 4, then a count)."""
     if not folds:
@@ -387,6 +446,8 @@ def _wait(client: Client, run_id: str, args) -> int:
                 print(f"run {run_id} finished: {body.get('status')}")
                 if body.get("error"):
                     print(f"  {body['error'].get('message')}")
+                for line in _recheck_lines(body):
+                    print(f"  {line}")
             return EXIT_OK if body.get("status") == "completed" else EXIT_FAIL
         if not args.json and _tty():
             print(f"  status: {body.get('status')}…", end="\r", flush=True)
@@ -683,6 +744,19 @@ def _refund_line(refund: dict | None) -> str:
         # gh #2460: the plan is still running; an earlier billing period's allowance ended.
         return (f"The credits for your {run} went back to the billing period they came from, "
                 "which has ended, so they can't be used again.")
+    if kind == "partially_refunded_to_ended_plan":
+        # gh #2462: only the part that returned nothing gave its credits back.
+        return (f"Part of your {run} returned nothing. Your plan has ended, so the credits for "
+                "that part were returned to it and can't be used.")
+    if kind == "partially_refunded_to_ended_period":
+        return (f"Part of your {run} returned nothing. The credits for that part went back to the "
+                "billing period they came from, which has ended, so they can't be used again.")
+    if kind == "refunded_to_plan":
+        # gh #2302: whether the credits can be spent cannot be told: never "back", never "ended".
+        return f"The credits for your {run} were returned to the plan they came from."
+    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 == "refunded_unknown":
         return f"Your {run} was refunded in full."
     if kind == "refund_pending":
@@ -713,9 +787,24 @@ def _retry_cost(details: dict) -> str:
     return cost
 
 
-def _retry_quote_text(details: dict, moved: bool) -> str:
+def _retry_quote_text(details: dict, moved: bool, sent: dict | None = None) -> str:
+    # gh #2456 (review, seat-contract 2a): say WHAT moved. `sent` is the confirmation just
+    # refused; a rail that moved at the same total is not a price change.
+    sent = sent or {}
+    rail_moved = bool(sent.get("expected_funding")) and sent.get("expected_funding") != (
+        details.get("funding") or {}
+    ).get("covered_by")
+    total_moved = sent.get("expected_total_cents") != details.get("total_price_cents")
+    if not moved:
+        what = ""
+    elif rail_moved and not total_moved:
+        what = "What would pay for this retry changed since the quote; the total did not."
+    elif rail_moved:
+        what = "The price, and what would pay for this retry, changed since the quote."
+    else:
+        what = "The price changed since the quote."
     parts = [
-        "The price changed since the quote." if moved else "",
+        what,
         _refund_line(details.get("refund")),
         f"Retrying starts a new run and {_retry_cost(details)}.",
     ]
@@ -737,15 +826,25 @@ def cmd_runs_retry(args) -> int:
     (`retry_confirmation_required`) until it is sent with the total it was quoted: here, an
     explicit question showing the refund and the total, or --expected-total CENTS. In a pipe it
     never confirms by itself. A price that moved meanwhile (`retry_price_changed`) is asked again
-    with the new total; nothing is charged in between."""
+    with the new total; nothing is charged in between.
+
+    gh #2456: the yes is bound to what PAYS as well as the total. The interactive confirmation
+    sends the quote's `funding.covered_by` as `expected_funding`, so a retry agreed as "uses 1
+    plan run credit" is never paid from the balance instead; --expected-funding does the same
+    in a script."""
     rid = _uuid_arg(args.run_id, "run_id")
     if rid is None:
         return EXIT_USAGE
+    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
     client, _ = _require_auth(args)
     path = f"/v1/research/runs/{rid}/retry"
     payload: dict = {}
     if args.expected_total is not None:
         payload["expected_total_cents"] = args.expected_total
+    if args.expected_funding is not None:
+        payload["expected_funding"] = args.expected_funding
     # 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).
@@ -764,11 +863,15 @@ 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
-            ask = _retry_quote_text(exc.details, moved=exc.code == "retry_price_changed")
+            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 not _interactive():
                 if args.json:
                     print(json.dumps({"error": {"code": exc.code, "message": ask, "details": exc.details}}))
-                err(f"{ask} Pass --expected-total {total} to confirm that charge.")
+                err(f"{ask} Pass {flags} to confirm that charge.")
                 return EXIT_USAGE
             if attempt == attempts - 1:
                 break  # the last refusal: no request would follow, so ask nothing
@@ -776,6 +879,8 @@ def cmd_runs_retry(args) -> int:
                 print("Cancelled. Nothing was charged.")
                 return EXIT_OK
             payload = {"expected_total_cents": total}
+            if rail:
+                payload["expected_funding"] = rail  # gh #2456: the yes covers what pays too
     if body is None:
         err("the API kept refusing the confirmation; nothing was charged")
         return EXIT_FAIL
@@ -1222,6 +1327,68 @@ def cmd_links_remove(args) -> int:
     return EXIT_OK
 
 
+def _subscription_summary(sub: dict, app_url: str | None) -> str:
+    """The subscription after a cancel or resume, from the server's own fields (gh #2903)."""
+    lines = [f"status     {sub.get('status')}"]
+    if sub.get("cancel_at_period_end"):
+        trial_ = sub.get("trial") or {}
+        tail = (
+            "the first charge already in flight still goes ahead"
+            if trial_.get("conversion_submitted")
+            else "nothing new is charged"
+        )
+        lines.append(f"cancelled  access until {sub.get('access_through')}; {tail}")
+    elif sub.get("access_through"):
+        lines.append(f"renews     {sub.get('access_through')}")
+    trial_line = _trial_line(sub, app_url)
+    if trial_line:
+        lines.append(f"trial      {trial_line}")
+    if sub.get("retry"):
+        lines.append(f"retry      {sub['retry']}")
+    return "\n".join(lines)
+
+
+def _subscription_change(args, verb: str, prompt: str) -> int:
+    client, _ = _require_auth(args)
+    if not args.yes:
+        if not _interactive():
+            err(f"refusing to {verb} the subscription non-interactively; pass --yes")
+            return EXIT_USAGE
+        if input(prompt).strip().lower() not in ("y", "yes"):
+            print("Nothing changed.")
+            return EXIT_OK
+    headers = {"Idempotency-Key": args.idempotency_key} if args.idempotency_key else None
+    try:
+        sub_ = client.request("POST", f"/v1/subscription/{verb}", headers=headers)
+    except ApiError as exc:
+        err(str(exc))
+        return _api_exit(exc)
+    out(sub_, args.json, _subscription_summary(sub_, None))
+    return EXIT_OK
+
+
+def cmd_subscription_cancel(args) -> int:
+    """Cancel the subscription at the end of the period (gh #2903). Confirmed interactively,
+    or with --yes, never silently in a pipe. Undone by `deepsieve subscription resume`."""
+    return _subscription_change(
+        args,
+        "cancel",
+        "Cancel the subscription at the end of the period? Nothing new is charged after it (a "
+        "first charge already in flight still goes ahead). [y/N] ",
+    )
+
+
+def cmd_subscription_resume(args) -> int:
+    """Undo a cancellation while the period runs (gh #2903). A past-due account gets one
+    immediate charge attempt, so this is confirmed like a cancel."""
+    return _subscription_change(
+        args,
+        "resume",
+        "Resume the subscription? Its renewal is charged as before, and a past-due account is "
+        "charged once now. [y/N] ",
+    )
+
+
 def _blueprint_id(client, args) -> str | None:
     """The Blueprint these commands address: ``--blueprint``, else the active one.
 
@@ -1304,6 +1471,148 @@ def cmd_data_get(args) -> int:
     return EXIT_OK
 
 
+#: Width a value may take in a history row. The tag after it ("QA corrected") is never cut.
+_HISTORY_VALUE_WIDTH = 30
+
+#: An entity or column key. Both go into the URL path; anything else is refused here.
+_KEY = re.compile(r"[A-Za-z0-9_-]{1,128}")
+
+
+def _hv(value: Any) -> str:
+    text = "(empty)" if value is None else str(value)
+    w = _HISTORY_VALUE_WIDTH
+    return text if len(text) <= w else text[: w - 1] + "…"
+
+
+def _describe_history(e: dict) -> str:
+    """One change log entry in the source popover's words (`LineageBlock`, #2129).
+
+    A `change` this CLI does not know prints the bare value, as `unknown` does, with no tag: the
+    #2129 changelog entry tells clients to read an unrecognised `change` as `unknown`."""
+    kind, value = e.get("change"), _hv(e.get("value"))
+    if kind == "changed":
+        return f"{_hv(e.get('previous_value'))} → {value}"
+    if kind == "amended":
+        pre = e.get("pre_amend")
+        if pre == "recorded":
+            return f"{_hv(e.get('pre_amend_value'))} → {value}  QA corrected"
+        if pre == "not_recorded":
+            return f"{value}  QA corrected · earlier value not recorded"
+        # A missing or unknown `pre_amend` reads as `none`: say only what is known.
+        return f"{value}  QA corrected"
+    if kind == "unchanged":
+        return "re-verified"
+    if kind == "observed":
+        return f"seen, not applied: {value}"
+    if kind == "not_applied":
+        return f"found, not applied: {value}"
+    return value
+
+
+def _history_when(captured_at: Any) -> str:
+    """`captured_at` in UTC, to the second, saying so (a bare slice dropped the offset)."""
+    from datetime import datetime, timezone  # noqa: PLC0415
+
+    if not captured_at:
+        return "date unknown"
+    try:
+        at = datetime.fromisoformat(str(captured_at))
+    except ValueError:
+        return str(captured_at)
+    if at.tzinfo is None:
+        return str(captured_at)
+    return at.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def cmd_data_history(args) -> int:
+    """A cell's change history (#2960): a column's log across records, one record's cell
+    (`--record`), or one cell by its id (`--cell`: a `--json` entry's `cell_id`, or `holds list`)."""
+    by_cell = args.cell is not None
+    if by_cell and (args.entity or args.column):
+        err("give either <entity> <column>, or --cell <cell id>, not both")
+        return EXIT_USAGE
+    if not by_cell and not (args.entity and args.column):
+        err("give <entity> <column> (see `deepsieve data catalog`), or --cell <cell id>")
+        return EXIT_USAGE
+    if by_cell and (args.record is not None or args.blueprint is not None):
+        err("--record and --blueprint go with <entity> <column>; a cell id names its own")
+        return EXIT_USAGE
+    if args.rechecks and not by_cell:
+        err("--rechecks needs --cell (re-checks are listed per cell)")
+        return EXIT_USAGE
+    if by_cell and not _CELL_ID.fullmatch(args.cell):
+        # The id goes into the URL path; anything else is refused before a request.
+        err("cell id must be a `cell_id` from `--json` output or `deepsieve holds list` (cel_…)")
+        return EXIT_USAGE
+    if not by_cell and not (_KEY.fullmatch(args.entity) and _KEY.fullmatch(args.column)):
+        err("entity and column must be keys from `deepsieve data catalog`")
+        return EXIT_USAGE
+    if args.blueprint is not None:
+        # It goes into the URL path too; a mangled one read another endpoint (review, LOW-2).
+        try:
+            args.blueprint = str(uuid.UUID(args.blueprint))
+        except ValueError:
+            err("--blueprint must be a Blueprint id (a UUID)")
+            return EXIT_USAGE
+    params: dict[str, Any] = {"limit": args.limit}
+    if args.record is not None:
+        try:
+            params["record_id"] = str(uuid.UUID(args.record))
+        except ValueError:
+            err("--record must be a record id (a UUID, from `deepsieve data get`)")
+            return EXIT_USAGE
+    for flag in ("cursor", "since"):
+        if getattr(args, flag):
+            params[flag] = getattr(args, flag)
+    if args.rechecks:
+        params["include"] = "rechecks"
+    client, _ = _require_auth(args)
+    if by_cell:
+        path = f"/v1/cells/{args.cell}/changes"
+    else:
+        bp_id = _blueprint_id(client, args)
+        if bp_id is None:
+            return EXIT_FAIL
+        path = f"/v1/blueprints/{bp_id}/entities/{args.entity}/columns/{args.column}/changes"
+    try:
+        body = client.request("GET", path, params=params)
+    except ApiError as exc:
+        err(str(exc))
+        return _api_exit(exc)
+    if not isinstance(body, dict) or not isinstance(body.get("data"), list):
+        # "Found nothing" must never read like "could not look": a 200 that is not a change log
+        # (an HTML page from the wrong origin) is a failure, not an empty history.
+        err(f"unexpected response from {path}: not a change log (is the profile's origin the API?)")
+        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')})")
+    cell = body.get("cell") or {}
+    if cell:
+        print(f"Cell: {cell.get('record_name') or cell.get('record_id')}.{cell.get('column')}")
+    rows = []
+    for e in body["data"]:
+        row = [_history_when(e.get("captured_at"))]
+        if not by_cell:
+            row.append(str(e.get("record_name") or e.get("record_id") or "")[:30])
+        row += [_describe_history(e), e.get("run_id") or "-"]
+        rows.append(row)
+    headers = ["when (utc)", "change", "run"]
+    if not by_cell:
+        headers.insert(1, "record")
+    print(_table(rows, headers) if rows else "No history found.")
+    if body.get("has_more") and body.get("next_cursor"):
+        print(f"\nMore: --cursor {body.get('next_cursor')}")
+    if body.get("truncated"):
+        # A clipped log must never read as a complete one (the same rule as `data get`).
+        reason = body.get("truncated_reason") or "this is a preview, not the full log."
+        print(f"\nnote: {reason}", file=sys.stderr)
+    return EXIT_OK
+
+
 def _remote_server_name(prof) -> str:
     """The MCP server name this deployment tells agents to register.
 
@@ -1571,6 +1880,12 @@ def build_parser() -> argparse.ArgumentParser:
         metavar="CENTS",
         help="confirm a charging retry at the total you were quoted, in cents",
     )
+    rr.add_argument(
+        "--expected-funding",
+        choices=["free_run", "plan_credits", "balance"],
+        default=None,
+        help="also bind what pays, as quoted (funding.covered_by); needs --expected-total",
+    )
     rr.set_defaults(func=cmd_runs_retry)
 
     rm = runs.add_parser(
@@ -1672,6 +1987,16 @@ def build_parser() -> argparse.ArgumentParser:
     lr.add_argument("--idempotency-key", help="make a retry safe")
     lr.set_defaults(func=cmd_links_remove)
 
+    subs = sub.add_parser("subscription", help="cancel or resume the subscription", parents=[common]).add_subparsers(dest="sub", required=True)
+    sc = subs.add_parser("cancel", help="cancel at the end of the period; nothing new is charged (needs billing:cancel)", parents=[common])
+    sc.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    sc.add_argument("--idempotency-key", help="make a retry safe")
+    sc.set_defaults(func=cmd_subscription_cancel)
+    sr = subs.add_parser("resume", help="undo a cancellation while the period runs (needs billing:write)", parents=[common])
+    sr.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    sr.add_argument("--idempotency-key", help="make a retry safe")
+    sr.set_defaults(func=cmd_subscription_resume)
+
     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)")
@@ -1735,6 +2060,23 @@ def build_parser() -> argparse.ArgumentParser:
     dg.add_argument("--blueprint", help="Blueprint id (default: the active one)")
     dg.set_defaults(func=cmd_data_get)
 
+    dh = data.add_parser(
+        "history",
+        help="a cell's change history: <entity> <column> [--record ID], or --cell ID",
+        parents=[common],
+    )
+    dh.add_argument("entity", nargs="?", help="entity key (see `deepsieve data catalog`)")
+    dh.add_argument("column", nargs="?", help="column key")
+    dh.add_argument("--record", help="only this record's cell (a record id)")
+    dh.add_argument("--cell", help="one cell, by its cell_id (in --json output, or from `holds list`)")
+    dh.add_argument("--rechecks", action="store_true",
+                    help="with --cell: also re-checks that found a change and did not apply it")
+    dh.add_argument("--since", help="only changes after this ISO timestamp")
+    dh.add_argument("--limit", type=int, default=25)
+    dh.add_argument("--cursor")
+    dh.add_argument("--blueprint", help="Blueprint id (default: the active one)")
+    dh.set_defaults(func=cmd_data_history)
+
     setup = sub.add_parser("setup", help="connect other tools", parents=[common]).add_subparsers(
         dest="sub", required=True
     )

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

@@ -820,6 +820,61 @@ def test_runs_get_and_whoami_name_the_blueprint(monkeypatch, capsys):
     assert "blueprint  Widgets (bp-a)" in printed and "workspace  ws_x" in printed
 
 
+# ── a re-check's result (#2781) ─────────────────────────────────────────────
+
+_RECHECK = {
+    "id": "rc_1", "status": "completed", "done": True, "run_type": "reverify",
+    "check_results": [
+        {"evidence_id": "e1", "outcome": "confirmed",
+         "message": "Checked: the value is still correct.", "followup_run_id": None},
+        {"evidence_id": "e2", "outcome": "looking",
+         "message": "Checked: the value looks out of date. Looking for the current one.",
+         "followup_run_id": "fu_1"},
+    ],
+    "update_result": None,
+}
+_FOLLOWUP = {
+    "id": "fu_1", "status": "completed", "done": True, "run_type": "research_update",
+    "check_results": None,
+    "update_result": {"outcome": "updated",
+                      "message": "Found the current value and updated the cell."},
+}
+
+
+@pytest.mark.parametrize("command", [["runs", "get"], ["runs", "wait", "--interval", "0"]],
+                         ids=["get", "wait"])
+def test_a_recheck_says_what_it_found_and_names_the_followup(monkeypatch, capsys, command):
+    """The human view printed only id/status/error, so a person could not see what a re-check
+    found without --json. The follow-up id it prints is the one the next command takes."""
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    runs = {"rc_1": _RECHECK, "fu_1": _FOLLOWUP}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json=runs[request.url.path.rsplit("/", 1)[-1]])
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main([*command, "rc_1"]) == 0
+    out = capsys.readouterr().out
+    print(out)
+    assert "Checked: the value is still correct." in out
+    assert "Looking for the current one. (follow-up run fu_1)" in out
+    assert out.count("follow-up run") == 1, "only the entry that started a search names one"
+
+    assert main([*command, "fu_1"]) == 0
+    out = capsys.readouterr().out
+    print(out)
+    assert "Found the current value and updated the cell." in out
+
+
+def test_a_run_with_no_recheck_result_prints_no_extra_lines(monkeypatch, capsys):
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    body = {"id": "r", "status": "completed", "done": True,
+            "check_results": None, "update_result": None}
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(200, json=body)))
+    assert main(["runs", "get", "r"]) == 0
+    assert "result" not in capsys.readouterr().out
+
+
 # ── chat changes (#2187) ────────────────────────────────────────────────────
 
 
@@ -1621,9 +1676,20 @@ def test_a_quote_without_a_total_is_never_asked_as_zero(monkeypatch, capsys):
          "Your plan has ended, so the credits for your stopped run were returned to it"),
         ({"kind": "refunded_to_ended_period", "run_status": "failed"},
          "The credits for your failed run went back to the billing period they came from"),
+        # gh #2462: a PARTIAL refund to an ended plan or period is said of the part.
+        ({"kind": "partially_refunded_to_ended_plan", "run_status": "failed"},
+         "Part of your failed run returned nothing. Your plan has ended, so the credits for that part"),
+        ({"kind": "partially_refunded_to_ended_period", "run_status": "failed"},
+         "Part of your failed run returned nothing. The credits for that part went back"),
+        # gh #2302: whether the credits can be spent cannot be told.
+        ({"kind": "refunded_to_plan", "run_status": "failed"},
+         "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"),
         ({"kind": "unconfirmed"}, "We can't confirm yet whether your earlier run was refunded."),
     ],
-    ids=["kept-credits", "pending", "ended-plan", "ended-period", "unconfirmed"],
+    ids=["kept-credits", "pending", "ended-plan", "ended-period", "partial-ended-plan",
+         "partial-ended-period", "returned-to-plan", "partial-returned-to-plan", "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."""
@@ -1970,3 +2036,425 @@ def test_run_create_says_which_seeds_were_counted_once(monkeypatch, capsys):
     reply.pop("folded_duplicates")
     assert main(["runs", "create", "--seeds", "Fund X", "--dry-run"]) == 0
     assert "counted once" not in capsys.readouterr().out
+
+
+# ── the free trial on whoami (gh #2896) ─────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    "subscription, line",
+    [
+        ({"cancel_at_period_end": False,
+          "trial": {"active": True, "days_left": 12, "first_charge_on": "2026-11-13",
+                    "first_charge_cents": 9900, "ends_on": "2026-11-13"}},
+         "trial      12 days left; first charge $99.00 on 2026-11-13"),
+        ({"cancel_at_period_end": True,
+          "trial": {"active": True, "days_left": 1, "first_charge_on": None,
+                    "first_charge_cents": None, "ends_on": "2026-11-13"}},
+         "trial      1 day left; cancelled, so it will not be charged (access until 2026-11-13)"),
+        # Not cancelled, amount unknown (a tier with no self-serve price): never "cancelled".
+        ({"cancel_at_period_end": False,
+          "trial": {"active": True, "days_left": 10, "first_charge_on": "2026-11-13",
+                    "first_charge_cents": None, "ends_on": "2026-11-13"}},
+         "trial      10 days left; first charge on 2026-11-13"),
+        ({"trial": {"conversion_pending": True, "first_charge_on": "2026-11-13",
+                    "first_charge_cents": 9900}},
+         "trial      ended; first charge $99.00 on 2026-11-13 is due."),
+        ({"cancel_at_period_end": True,
+          "trial": {"conversion_submitted": True, "first_charge_on": "2026-11-13",
+                    "first_charge_cents": 9900}},
+         "trial      ended; first charge $99.00 on 2026-11-13 is being processed and cannot "
+         "be stopped."),
+        ({"trial": {"active": False, "conversion_failed": True}},
+         "trial      ended, and the first charge was declined. Update the card in the app."),
+        ({"cancel_at_period_end": True, "trial": {"active": False, "conversion_failed": True}},
+         "trial      ended; the first charge was declined and the plan is cancelled, so it "
+         "will not be retried."),
+        ({"cancel_at_period_end": True,
+          "trial": {"active": False, "ended_without_charge": True, "ends_on": "2026-11-13"}},
+         "trial      cancelled and ended on 2026-11-13; nothing was charged."),
+        ({"trial": {"active": False, "eligible": True, "offer_days": 30}},
+         "trial      a 30-day trial is available. Start one from https://app.x.test/pricing "
+         "(it takes a card, so it needs a person)."),
+    ],
+    ids=["charging", "cancelled", "amount-unknown", "pending", "submitted", "declined",
+         "declined-then-cancelled", "ended-without-charge", "eligible"],
+)
+def test_whoami_states_the_trial_from_the_servers_dates(monkeypatch, capsys, subscription, line):
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    seen = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request.url.path)
+        return httpx.Response(200, json={
+            "org_id": "o", "role": "owner", "app_url": "https://app.x.test",
+            "subscription": {"status": "trialing", **subscription},
+        })
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["whoami"]) == 0
+    assert seen == ["/v1/me"]
+    assert line in capsys.readouterr().out.splitlines()
+
+
+@pytest.mark.parametrize(
+    "subscription",
+    [None, {"status": "active", "trial": None},
+     {"status": "none", "trial": {"active": False, "eligible": None}}],
+    ids=["unknown", "no-trial-block", "eligibility-unknown"],
+)
+def test_whoami_prints_no_trial_line_when_there_is_nothing_to_say(
+    monkeypatch, capsys, subscription
+):
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(
+        200, json={"org_id": "o", "role": "owner", "subscription": subscription})))
+    assert main(["whoami"]) == 0
+    out = capsys.readouterr().out
+    assert "role       owner" in out, "control: whoami printed its identity"
+    assert "trial" not in out
+
+
+# ── subscription cancel / resume (gh #2903) ─────────────────────────────────
+
+
+def test_subscription_cancel_refuses_in_a_pipe_without_yes(monkeypatch, capsys):
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    seen = []
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: seen.append(r) or httpx.Response(200)))
+    assert main(["subscription", "cancel"]) == 2
+    assert seen == [], "nothing reached the API"
+    assert "pass --yes" in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("verb", ["cancel", "resume"])
+def test_subscription_change_posts_and_prints_what_the_server_says(monkeypatch, capsys, verb):
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    seen = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append((request.method, request.url.path, request.headers.get("Idempotency-Key")))
+        return httpx.Response(200, json={
+            "object": "subscription", "status": "trialing",
+            "cancel_at_period_end": verb == "cancel", "access_through": "2026-11-13",
+            "retry": None,
+            "trial": {"active": True, "days_left": 12, "ends_on": "2026-11-13",
+                      "first_charge_on": None if verb == "cancel" else "2026-11-13",
+                      "first_charge_cents": None if verb == "cancel" else 9900},
+        })
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["subscription", verb, "--yes", "--idempotency-key", "k-1"]) == 0
+    assert seen == [("POST", f"/v1/subscription/{verb}", "k-1")]
+    printed = capsys.readouterr().out.splitlines()
+    if verb == "cancel":
+        assert "cancelled  access until 2026-11-13; nothing new is charged" in printed
+    else:
+        assert "trial      12 days left; first charge $99.00 on 2026-11-13" in printed
+
+
+def test_subscription_resume_after_the_end_exits_non_zero_with_the_servers_words(
+    monkeypatch, capsys
+):
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(409, json={
+        "error": {"type": "conflict_error", "code": "subscription_ended",
+                  "message": "This subscription has ended, so it can't be resumed.",
+                  "retriable": False, "request_id": "r"}})))
+    assert main(["subscription", "resume", "--yes"]) != 0
+    assert "can't be resumed" in capsys.readouterr().err
+
+
+# ── data history: a cell's change log (#2960) ────────────────────────────────
+
+BP = "0b5e4f1a-1111-4222-8333-444455556666"
+REC = "9a8b7c6d-0000-4000-8000-000000000001"
+
+
+def _entry(change, **over):
+    base = {
+        "cell_id": CELL, "entity_key": "books", "record_id": REC, "record_name": "Emma",
+        "column": "author", "evidence_id": "e-1", "value": "J. Austen",
+        "captured_at": "2026-10-15T09:30:00+00:00", "run_id": "run-1", "source_stage": "extract",
+        "source_urls": [], "confidence_label": "high", "qa_notes": None,
+        "previous_evidence_id": None, "previous_value": None, "lineage": "none",
+        "change": change, "pre_amend": "none", "pre_amend_value": None,
+    }
+    return base | over
+
+
+def _history(*entries, **over):
+    return {"object": "list", "data": list(entries), "has_more": False, "next_cursor": None,
+            "blueprint": {"id": BP, "name": "Library"}} | over
+
+
+def _serve(monkeypatch, body, status=200):
+    seen: list[httpx.Request] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request)
+        return httpx.Response(status, json=body)
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    return seen
+
+
+#: Every `change` the API publishes, plus one it may add later, with the line each must print.
+#: The wording is the source popover's (`source-popover.tsx` `LineageBlock`).
+_KINDS = [
+    (_entry("changed", previous_value="Austen", lineage="recorded"), "Austen → J. Austen"),
+    (_entry("changed", previous_value=None, lineage="recorded"), "(empty) → J. Austen"),
+    (_entry("amended", pre_amend="recorded", pre_amend_value="Jane Austin"),
+     "Jane Austin → J. Austen  QA corrected"),
+    (_entry("amended", pre_amend="not_recorded"),
+     "J. Austen  QA corrected · earlier value not recorded"),
+    (_entry("amended"), "J. Austen  QA corrected"),
+    (_entry("unchanged"), "re-verified"),
+    (_entry("observed", value="Austen, J."), "seen, not applied: Austen, J."),
+    (_entry("not_applied", value="Jane"), "found, not applied: Jane"),
+    (_entry("initial"), "J. Austen"),
+    (_entry("unknown", value=None), "(empty)"),
+    (_entry("rewritten_by_a_future_writer"), "J. Austen"),
+]
+
+
+@pytest.mark.parametrize("entry,line", _KINDS, ids=[
+    f"{i}-{e['change']}-{e['pre_amend']}" for i, (e, _) in enumerate(_KINDS)])
+def test_history_prints_every_change_kind_in_the_popovers_words(monkeypatch, capsys, entry, line):
+    _signed_in(monkeypatch)
+    _serve(monkeypatch, _history(entry))
+    assert main(["data", "history", "--cell", CELL]) == 0
+    out_lines = capsys.readouterr().out.splitlines()
+    header = next(r for r in out_lines if r.startswith("WHEN"))
+    row = out_lines[out_lines.index(header) + 1]
+    # Slice the CHANGE column out of the row by the header's offsets and compare it EXACTLY: a
+    # substring check let a tag or a prefix on a bare-value kind through (review, MEDIUM-1).
+    start, end = header.index("CHANGE"), header.index("RUN")
+    assert row[start:end].rstrip() == line
+
+
+def test_history_truncates_a_long_value_and_never_the_qa_tag(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    long_old, long_new = "A" * 200, "B" * 200
+    _serve(monkeypatch, _history(
+        _entry("amended", pre_amend="recorded", pre_amend_value=long_old, value=long_new),
+        _entry("amended", pre_amend="not_recorded", value=long_new),
+    ))
+    assert main(["data", "history", "--cell", CELL]) == 0
+    text = capsys.readouterr().out
+    assert long_old not in text and long_new not in text
+    assert "A" * 29 + "… → " + "B" * 29 + "…  QA corrected" in text
+    assert "B" * 29 + "…  QA corrected · earlier value not recorded" in text
+
+
+def test_history_json_is_the_api_envelope_reprinted(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    body = _history(
+        _entry("amended", pre_amend="recorded", pre_amend_value="Jane Austin"),
+        _entry("amended", pre_amend="not_recorded"),
+        cell={"cell_id": CELL, "entity_key": "books", "record_id": REC, "record_name": "Emma",
+              "column": "author"},
+    )
+    _serve(monkeypatch, body)
+    assert main(["data", "history", "--cell", CELL, "--json"]) == 0
+    printed = capsys.readouterr().out
+    assert printed == json.dumps(body, indent=2) + "\n"
+    assert json.loads(printed)["data"][0]["pre_amend_value"] == "Jane Austin"
+
+
+def test_history_by_cell_reads_the_cell_endpoint_with_its_flags(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen = _serve(monkeypatch, _history(_entry("initial"), has_more=True, next_cursor="nx",
+                                        cell={"record_name": "Emma", "column": "author"}))
+    rc = main(["data", "history", "--cell", CELL, "--rechecks", "--since",
+               "2026-10-01T00:00:00Z", "--cursor", "cc", "--limit", "5"])
+    assert rc == 0
+    assert len(seen) == 1  # a cell id names its Blueprint: no /v1/blueprints lookup
+    assert seen[0].url.path == f"/v1/cells/{CELL}/changes"
+    assert dict(seen[0].url.params) == {"limit": "5", "cursor": "cc",
+                                        "since": "2026-10-01T00:00:00Z", "include": "rechecks"}
+    text = capsys.readouterr().out
+    assert "Cell: Emma.author" in text and "--cursor nx" in text
+    assert "RECORD" not in text  # one cell: the record is in the Cell line, not a column
+
+
+def test_history_by_column_resolves_the_active_blueprint_and_passes_the_record(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen: list[httpx.Request] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request)
+        if request.url.path == "/v1/blueprints":
+            return httpx.Response(200, json={"data": [{"id": BP, "is_active": True}]})
+        return httpx.Response(200, json=_history(_entry("changed", previous_value="Austen")))
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["data", "history", "books", "author", "--record", REC]) == 0
+    assert [r.url.path for r in seen] == [
+        "/v1/blueprints", f"/v1/blueprints/{BP}/entities/books/columns/author/changes"]
+    assert dict(seen[1].url.params) == {"limit": "25", "record_id": REC}
+    text = capsys.readouterr().out
+    assert "RECORD" in text and "Emma" in text and "Austen → J. Austen" in text
+
+
+def test_history_with_blueprint_skips_the_lookup(monkeypatch):
+    _signed_in(monkeypatch)
+    seen = _serve(monkeypatch, _history())
+    assert main(["data", "history", "books", "author", "--blueprint", BP]) == 0
+    assert [r.url.path for r in seen] == [f"/v1/blueprints/{BP}/entities/books/columns/author/changes"]
+
+
+def test_history_empty_page_says_so(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    _serve(monkeypatch, _history())
+    assert main(["data", "history", "--cell", CELL]) == 0
+    assert "No history found." in capsys.readouterr().out
+
+
+@pytest.mark.parametrize("argv", [
+    ["data", "history"],
+    ["data", "history", "books"],
+    ["data", "history", "books", "author", "--cell", CELL],
+    ["data", "history", "--cell", CELL, "--record", REC],
+    ["data", "history", "--cell", CELL, "--blueprint", BP],
+    ["data", "history", "books", "author", "--rechecks"],
+    ["data", "history", "--cell", "../../v1/holds"],
+    ["data", "history", "books", "author", "--record", "not-a-uuid"],
+    ["data", "history", "books", "../holds", "--blueprint", BP],
+    ["data", "history", "books", "author", "--record", ""],
+    ["data", "history", "books", "author", "--blueprint", "../../v1/holds#"],
+    ["data", "history", "--cell", CELL, "--record", ""],
+], ids=["neither", "entity-only", "both-forms", "cell-with-record", "cell-with-blueprint",
+        "rechecks-without-cell", "bad-cell-id", "bad-record", "bad-column", "empty-record",
+        "bad-blueprint", "cell-with-empty-record"])
+def test_history_usage_errors_exit_2_and_send_nothing(monkeypatch, capsys, argv):
+    _signed_in(monkeypatch)
+    seen = _serve(monkeypatch, _history())
+    assert main(argv) == 2
+    assert capsys.readouterr().err.startswith("error: ")
+    assert seen == []
+
+
+def test_history_outside_the_preview_surfaces_the_refusal(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    _serve(monkeypatch, {"error": {"type": "payment_error", "code": "payment_required",
+                                   "message": "This row is outside your free preview.",
+                                   "retriable": False, "request_id": "r"}}, status=402)
+    assert main(["data", "history", "--cell", CELL]) == 1
+    assert "outside your free preview" in capsys.readouterr().err
+
+
+def test_history_a_preview_page_says_it_is_clipped_on_stderr(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    _serve(monkeypatch, _history(_entry("initial"), truncated=True,
+                                 truncated_reason="Free preview: only changes on the 5 preview rows."))
+    assert main(["data", "history", "books", "author", "--blueprint", BP]) == 0
+    captured = capsys.readouterr()
+    assert "Free preview" in captured.err and "Free preview" not in captured.out
+
+
+@pytest.mark.parametrize("body", [{"raw": "<html>not the API</html>"}, {"data": None}],
+                         ids=["html-page", "no-list"])
+def test_history_a_response_that_is_not_a_change_log_is_a_failure_not_empty(monkeypatch, capsys,
+                                                                           body):
+    """Found nothing and could not look must not print the same line (review, LOW-3)."""
+    _signed_in(monkeypatch)
+    _serve(monkeypatch, body)
+    assert main(["data", "history", "--cell", CELL]) == 1
+    captured = capsys.readouterr()
+    assert "No history found." not in captured.out
+    assert "not a change log" in captured.err
+
+
+def test_history_times_are_shown_in_utc(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    _serve(monkeypatch, _history(_entry("initial", captured_at="2026-10-15T11:30:00+02:00"),
+                                 _entry("initial", captured_at=None)))
+    assert main(["data", "history", "--cell", CELL]) == 0
+    text = capsys.readouterr().out
+    assert "WHEN (UTC)" in text and "2026-10-15T09:30:00Z" in text and "date unknown" in text
+
+
+# gh #2456: the yes binds what pays as well as the total.
+
+_RAIL_QUOTE = {
+    **_RETRY_QUOTE,
+    "funding": {"covered_by": "plan_credits", "plan_credits_needed": 2,
+                "plan_credits_available": 5, "balance_cents": 0},
+}
+
+
+def _rail_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_funding") != "plan_credits" or body.get("expected_total_cents") != 1200:
+            return httpx.Response(409, json={"error": {
+                "code": "retry_confirmation_required", "message": "confirm",
+                "param": "expected_total_cents", "retriable": False, "details": _RAIL_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_the_rail_shown(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(_rail_handler(seen)))
+    assert main(["runs", "retry", RUN]) == 0
+    assert seen == [{}, {"expected_total_cents": 1200, "expected_funding": "plan_credits"}]
+    assert "uses 2 plan run credits" in prompts[0]
+
+
+def test_in_a_pipe_the_hint_names_the_rail_flag(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    monkeypatch.setattr("deepsieve_cli.main._interactive", lambda: False)
+    seen: list = []
+    monkeypatch.setattr(httpx, "Client", _mock(_rail_handler(seen)))
+    assert main(["runs", "retry", RUN]) == 2
+    assert "--expected-total 1200 --expected-funding plan_credits" in capsys.readouterr().err
+
+
+def test_expected_funding_is_sent_beside_the_total(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen: list = []
+    monkeypatch.setattr(httpx, "Client", _mock(_rail_handler(seen)))
+    argv = ["runs", "retry", RUN, "--expected-total", "1200", "--expected-funding", "plan_credits"]
+    assert main(argv) == 0
+    assert seen == [{"expected_total_cents": 1200, "expected_funding": "plan_credits"}]
+
+
+def test_expected_funding_without_its_total_sends_nothing(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    seen: list = []
+    monkeypatch.setattr(httpx, "Client", _mock(_rail_handler(seen)))
+    assert main(["runs", "retry", RUN, "--expected-funding", "plan_credits"]) == 2
+    assert seen == []
+
+
+def test_a_moved_rail_at_the_same_total_is_not_called_a_price_change(monkeypatch, capsys):
+    """gh #2456 review (seat-contract 2a): the person is told what moved."""
+    _signed_in(monkeypatch)
+    monkeypatch.setattr("deepsieve_cli.main._interactive", lambda: True)
+    prompts: list = []
+    monkeypatch.setattr("builtins.input", lambda prompt="": prompts.append(prompt) or "n")
+    balance_quote = {**_RAIL_QUOTE, "funding": {**_RAIL_QUOTE["funding"], "covered_by": "balance"}}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(409, json={"error": {
+            "code": "retry_price_changed", "message": "moved", "param": "expected_funding",
+            "retriable": False, "details": balance_quote,
+        }})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    argv = ["runs", "retry", RUN, "--expected-total", "1200", "--expected-funding", "plan_credits"]
+    assert main(argv) == 0
+    assert "What would pay for this retry changed" in prompts[0]
+    assert "price changed" not in prompts[0]