talis-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{talis_cli-0.2.0 → talis_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talis-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Command-line client for the Talis trading platform. Sign in via device flow, manage sessions, view portfolio, place orders.
 Author: Talis
 License-Expression: Apache-2.0
@@ -114,6 +114,27 @@ suitable for parsing from scripts or LLM agents. Force JSON anywhere with
 The CLI stores its session token at `~/.talis/credentials` with `chmod 600`
 on POSIX systems. The token is a JWT; treat it like any other credential.
 
+### Sessions renew themselves
+
+You should not have to think about session expiry. When the CLI or the MCP
+server runs with under 48 hours left on the clock, it renews in place against
+`POST /auth/session/refresh` before doing its work — at most once every 15
+minutes, so a burst of commands costs one renewal, not one each. Renewal
+preserves the
+session's **original grant**, not a fresh maximum — a token issued with a 24h
+life renews to another 24h, never to something longer. That is deliberate: an
+auto-renewing session must not be able to ratchet itself into a longer-lived
+credential than the one you approved.
+
+Renewal is best-effort and silent: if it cannot happen, your existing
+credential is left untouched and the command still runs. What you WILL see is a
+`session_warning` on MCP tool responses once renewal stops keeping up, or when
+under six hours remain. If that appears and keeps counting down, renewal is
+failing — run `talis login` to sign in again.
+
+A steady `session_hours_remaining` with no `session_warning` is the healthy
+state, not a countdown to worry about.
+
 ## Relationship to `cli/jarvis_cli.sh`
 
 The bash script at [`cli/jarvis_cli.sh`](../../cli/jarvis_cli.sh) is the legacy
@@ -142,12 +163,16 @@ your portfolio, pull Talis Research, place paper trades, create strategies,
 set price alerts, and talk to the Talis chat agent. Log in first
 (`talis login`); the server authenticates as the logged-in user.
 
-Add it to **Claude Code**:
+Install and add it to **Claude Code**:
 
 ```bash
+pip install talis-cli        # or: uv tool install talis-cli
+talis login                  # device-flow browser approval, once
 claude mcp add talis -- talis mcp
 ```
 
+No local checkout required — `talis` is on PyPI.
+
 Or to **Claude Desktop** (and other clients using the `mcpServers` config
 shape) — `claude_desktop_config.json`:
 
@@ -162,14 +187,33 @@ shape) — `claude_desktop_config.json`:
 }
 ```
 
-Tools: `whoami`, `portfolio`, `balance`, `research`, `packets`,
-`brief_latest`, `history`, `buy`, `sell`, `close`, `create_strategy`, `chat`,
-`notifications_create`.
-
-**Safety**: the trading tools (`buy` / `sell` / `close` / `create_strategy`)
-default to `paper=True` — an isolated simulated book. An agent must pass
-`paper=False` explicitly to trade real money. Set `TALIS_PAPER=1` in the
-server's environment to force paper mode regardless of tool arguments.
+Tools (26):
+
+`amend_strategy`, `backtest`, `balance`, `brief_latest`, `buy`, `cancel_all_orders`,
+`cancel_order`, `chat`, `close`, `create_strategy`, `history`,
+`notifications_create`, `open_orders`, `outcomes`, `packets`, `place_order`,
+`portfolio`, `research`, `sell`, `start_strategy`, `stop_strategy`,
+`strategies`, `strategy`, `strategy_activity`, `validate_strategy`, `whoami`.
+
+**Strategy workflow.** `validate_strategy(dsl)` checks a DSL without side
+effects; `backtest(pair, dsl, days=30, interval="1h")` runs it through the live
+engine on real historical candles (read-only) and returns return, Sharpe,
+drawdown, trade count; `create_strategy(pair, dsl, paper=True)` runs it on the
+simulated book; the same call with `paper=False, confirm_real_money=True`
+deploys it live.
+
+**Safety — read this before pointing an agent at it.** The trading tools
+(`buy` / `sell` / `close` / `create_strategy`) execute with **REAL MONEY by
+default** (`paper=False`). Pass `paper=True` to simulate instead.
+
+`buy`, `sell` and `create_strategy` additionally refuse to spend real money
+unless the caller passes `confirm_real_money=True`. `close` deliberately has no
+such gate: a protective exit must never be blocked by a missing flag.
+`place_order` (limit orders, spot, HIP-4 outcome markets) has **no paper mode
+at all** and refuses without `confirm_real_money=True`.
+
+Set `TALIS_PAPER=1` in the server's environment to force paper mode regardless
+of tool arguments.
 Withdrawals and wallet creation are not exposed over MCP. For a strictly
 read-only agent, log in with `talis login --read-only` — the server rejects
 every mutation at the API layer.

{talis_cli-0.2.0 → talis_cli-0.3.0}/README.md

@@ -86,6 +86,27 @@ suitable for parsing from scripts or LLM agents. Force JSON anywhere with
 The CLI stores its session token at `~/.talis/credentials` with `chmod 600`
 on POSIX systems. The token is a JWT; treat it like any other credential.
 
+### Sessions renew themselves
+
+You should not have to think about session expiry. When the CLI or the MCP
+server runs with under 48 hours left on the clock, it renews in place against
+`POST /auth/session/refresh` before doing its work — at most once every 15
+minutes, so a burst of commands costs one renewal, not one each. Renewal
+preserves the
+session's **original grant**, not a fresh maximum — a token issued with a 24h
+life renews to another 24h, never to something longer. That is deliberate: an
+auto-renewing session must not be able to ratchet itself into a longer-lived
+credential than the one you approved.
+
+Renewal is best-effort and silent: if it cannot happen, your existing
+credential is left untouched and the command still runs. What you WILL see is a
+`session_warning` on MCP tool responses once renewal stops keeping up, or when
+under six hours remain. If that appears and keeps counting down, renewal is
+failing — run `talis login` to sign in again.
+
+A steady `session_hours_remaining` with no `session_warning` is the healthy
+state, not a countdown to worry about.
+
 ## Relationship to `cli/jarvis_cli.sh`
 
 The bash script at [`cli/jarvis_cli.sh`](../../cli/jarvis_cli.sh) is the legacy
@@ -114,12 +135,16 @@ your portfolio, pull Talis Research, place paper trades, create strategies,
 set price alerts, and talk to the Talis chat agent. Log in first
 (`talis login`); the server authenticates as the logged-in user.
 
-Add it to **Claude Code**:
+Install and add it to **Claude Code**:
 
 ```bash
+pip install talis-cli        # or: uv tool install talis-cli
+talis login                  # device-flow browser approval, once
 claude mcp add talis -- talis mcp
 ```
 
+No local checkout required — `talis` is on PyPI.
+
 Or to **Claude Desktop** (and other clients using the `mcpServers` config
 shape) — `claude_desktop_config.json`:
 
@@ -134,14 +159,33 @@ shape) — `claude_desktop_config.json`:
 }
 ```
 
-Tools: `whoami`, `portfolio`, `balance`, `research`, `packets`,
-`brief_latest`, `history`, `buy`, `sell`, `close`, `create_strategy`, `chat`,
-`notifications_create`.
-
-**Safety**: the trading tools (`buy` / `sell` / `close` / `create_strategy`)
-default to `paper=True` — an isolated simulated book. An agent must pass
-`paper=False` explicitly to trade real money. Set `TALIS_PAPER=1` in the
-server's environment to force paper mode regardless of tool arguments.
+Tools (26):
+
+`amend_strategy`, `backtest`, `balance`, `brief_latest`, `buy`, `cancel_all_orders`,
+`cancel_order`, `chat`, `close`, `create_strategy`, `history`,
+`notifications_create`, `open_orders`, `outcomes`, `packets`, `place_order`,
+`portfolio`, `research`, `sell`, `start_strategy`, `stop_strategy`,
+`strategies`, `strategy`, `strategy_activity`, `validate_strategy`, `whoami`.
+
+**Strategy workflow.** `validate_strategy(dsl)` checks a DSL without side
+effects; `backtest(pair, dsl, days=30, interval="1h")` runs it through the live
+engine on real historical candles (read-only) and returns return, Sharpe,
+drawdown, trade count; `create_strategy(pair, dsl, paper=True)` runs it on the
+simulated book; the same call with `paper=False, confirm_real_money=True`
+deploys it live.
+
+**Safety — read this before pointing an agent at it.** The trading tools
+(`buy` / `sell` / `close` / `create_strategy`) execute with **REAL MONEY by
+default** (`paper=False`). Pass `paper=True` to simulate instead.
+
+`buy`, `sell` and `create_strategy` additionally refuse to spend real money
+unless the caller passes `confirm_real_money=True`. `close` deliberately has no
+such gate: a protective exit must never be blocked by a missing flag.
+`place_order` (limit orders, spot, HIP-4 outcome markets) has **no paper mode
+at all** and refuses without `confirm_real_money=True`.
+
+Set `TALIS_PAPER=1` in the server's environment to force paper mode regardless
+of tool arguments.
 Withdrawals and wallet creation are not exposed over MCP. For a strictly
 read-only agent, log in with `talis login --read-only` — the server rejects
 every mutation at the API layer.

{talis_cli-0.2.0 → talis_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "talis-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "Command-line client for the Talis trading platform. Sign in via device flow, manage sessions, view portfolio, place orders."
 readme = "README.md"
 license = "Apache-2.0"

{talis_cli-0.2.0 → talis_cli-0.3.0}/talis/api.py

@@ -491,6 +491,27 @@ class Client:
             params={"tenant_id": tenant_id},
         )
 
+    def get_candles(self, *, symbol: str, interval: str = "1h", limit: int = 500,
+                    exchange: str | None = None) -> dict:
+        """Historical candles from the control plane (``GET /candles``).
+
+        Returns ``{"candles": [{t,o,h,l,c,v}, ...], "symbol", "interval"}`` —
+        abbreviated OHLCV keys, newest last. The backtester wants the full
+        names; ``backtest_candles`` in the MCP layer does that mapping.
+        """
+        params: dict[str, Any] = {"symbol": symbol, "interval": interval, "limit": limit}
+        if exchange:
+            params["exchange"] = exchange
+        return self._request("GET", "/candles", params=params)
+
+    def create_backtest(self, *, body: dict) -> dict:
+        """Submit a backtest (``POST /backtests``). Returns ``{backtest_id, status}``."""
+        return self._request("POST", "/backtests", json=body)
+
+    def get_backtest(self, *, backtest_id: str) -> dict:
+        """Backtest status + results (``GET /backtests/{id}``)."""
+        return self._request("GET", f"/backtests/{backtest_id}")
+
     def validate_strategy(self, *, dsl: dict) -> dict:
         """Validate a DSL WITHOUT creating anything. No side effects.
 

{talis_cli-0.2.0 → talis_cli-0.3.0}/talis/cli.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 import typer
 
-from . import __version__, output
+from . import __version__, config, output
 from .commands import auth, mcp_server, trade
 from .commands import chat as chat_cmd
 from .commands import guide as guide_cmd
@@ -83,6 +83,71 @@ app.add_typer(fund_app, name="fund")
 app.command("deposit")(__import__("talis.commands.fund",fromlist=["deposit"]).deposit)
 
 
+# Commands that must NEVER trigger a renewal.
+#   login/signup/approve — there is no session yet to renew.
+#   logout — we are about to revoke the session we hold; renewing it first is
+#     wasted work and muddies the audit trail.
+#   version — must stay answerable with no credentials and no network at all.
+_NO_RENEW = frozenset({"login", "signup", "approve", "logout", "version"})
+
+# Minimum gap between renewal attempts across separate CLI invocations.
+_RENEW_COOLDOWN_SECONDS = 900.0
+
+
+def _renewed_recently() -> bool:
+    """True when the stored credential was rewritten inside the cooldown.
+
+    WHY A COOLDOWN AT ALL. ensure_fresh fires whenever under 48h remain, but a
+    session's grant is 24h — permanently under that threshold. Without a gate,
+    wiring renewal into the CLI would mint a new JWT and pay a network
+    round-trip on EVERY command, forever.
+
+    WHY MTIME rather than a new state file. The MCP server uses an in-memory
+    cooldown, which cannot work here: a CLI process is born and dies per
+    command. The credentials file's mtime is ALREADY an exact record of the
+    last SUCCESSFUL renewal (renewal rewrites it via atomic replace), so use
+    that instead of inventing a second source of truth that could disagree
+    with the first.
+
+    A FAILED renewal leaves mtime untouched, so a broken renewal keeps being
+    retried rather than being silenced by its own failure — the behaviour we
+    want, obtained for free.
+    """
+    import os
+    import time as _t
+    try:
+        age = _t.time() - os.stat(str(config.credentials_path())).st_mtime
+    except OSError:
+        return False          # unreadable/absent: let ensure_fresh decide
+    # A negative age means the clock moved; treat it as recent so a skewed
+    # machine backs off rather than renewing in a tight loop.
+    return age < _RENEW_COOLDOWN_SECONDS
+
+
+@app.callback()
+def _keep_session_alive(ctx: typer.Context) -> None:
+    """Renew a short-lived session before running the command.
+
+    WHY THIS EXISTS: renewal was wired into the MCP server only, so a human
+    running `talis portfolio` every day still watched their session run out —
+    the CLI shipped the renewal code and never called it. The README promised
+    otherwise. This is the code catching up to the claim.
+
+    Best-effort BY CONTRACT: any failure leaves the stored credential exactly
+    as it was and the command runs anyway. config.ensure_fresh also no-ops
+    without touching the network unless the session is genuinely short, so this
+    costs nothing on the overwhelming majority of invocations.
+    """
+    if ctx.invoked_subcommand in _NO_RENEW or _renewed_recently():
+        return
+    try:
+        creds = config.load()
+        if creds:
+            config.ensure_fresh(creds)
+    except Exception:
+        pass
+
+
 @app.command("version")
 def version(json_: bool = typer.Option(False, "--json", help="JSON output.")) -> None:
     """Print the CLI version."""

{talis_cli-0.2.0 → talis_cli-0.3.0}/talis/commands/mcp_server.py

@@ -35,8 +35,11 @@ Design notes
 from __future__ import annotations
 
 import contextlib
+import json
 import os
+import re
 import sys
+import time
 from typing import Any
 
 import typer
@@ -64,9 +67,31 @@ class NotLoggedInError(RuntimeError):
 # warning, because the tool being used is the only one guaranteed to be seen.
 _SESSION_WARN_HOURS = 48.0
 
+# Below this the session is genuinely at risk and we warn however healthy
+# renewal looks. Above it, a session that is renewing on schedule is NOT news.
+#
+# WHY THIS SECOND TIER EXISTS: /auth/session/refresh deliberately carries the
+# ORIGINAL grant rather than issuing a fresh maximum-length one — a token minted
+# with a 24h life renews to 24h, never to 7d. That is the token-lifetime ceiling
+# working as designed. But it means a perfectly self-renewing session sits
+# permanently at ~24h, which is permanently under a 48h warn floor. Warning on
+# that alone emitted SESSION EXPIRES on every single tool response forever — one
+# second after a successful renewal included. And because the warning is
+# deliberately hoisted to the FRONT of the dict, it was the first thing the model
+# read on every call. A warning that always fires is one the reader learns to
+# skip, including on the day renewal actually breaks.
+_SESSION_CRITICAL_HOURS = 6.0
+
+# What the last renewal attempt actually ACHIEVED. Written by _maybe_renew, read
+# below to tell "short grant, renewing fine" apart from "renewal is broken".
+# Starts "unknown" and "unknown" warns: absence of evidence that renewal works
+# is not evidence that it does.
+_RENEW_OUTCOME = ["unknown"]  # unknown | renewed | not_needed | failed
+_RENEW_HEALTHY = ("renewed", "not_needed")
+
 
 def _session_expiry_warning(creds) -> dict:
-    """{} when the session is comfortably alive, else a loud actionable dict."""
+    """{} when the session is alive AND renewing, else a loud actionable dict."""
     raw = getattr(creds, "expires_at", None)
     if not raw:
         return {}
@@ -84,17 +109,21 @@ def _session_expiry_warning(creds) -> dict:
     if hours <= 0:
         return {"session_expired": True,
                 "session_warning": (
-                    f"SESSION EXPIRED at {raw}. Every call will now fail. Renew with "
-                    "`talis_token_refresh.py --force` (admin key), or a human "
-                    "can run `talis login`.")}
-    return {"session_hours_remaining": round(hours, 1),
+                    f"SESSION EXPIRED at {raw}. Every call will now fail. "
+                    "Automatic renewal did not save it — run `talis login` to "
+                    "sign in again.")}
+    # Always REPORT the number; raise the ALARM only when renewal is not holding
+    # the line. Readers key off `session_warning`, never off this field.
+    remaining = {"session_hours_remaining": round(hours, 1)}
+    if hours > _SESSION_CRITICAL_HOURS and _RENEW_OUTCOME[0] in _RENEW_HEALTHY:
+        return remaining
+    return {**remaining,
             "session_warning": (
-                f"SESSION EXPIRES IN {hours:.1f} HOURS ({raw}). The token itself carries no "
-                "refresh token, but tools/talis-cli/talis_token_refresh.py "
-                "re-mints it via POST /auth/tokens and is installed as a "
-                "LaunchAgent (com.talis.token-refresh, every 6h, renews under "
-                "8h remaining). If this warning keeps counting down below 8h, "
-                "that job is NOT running — check ~/.talis/token-refresh.log.")}
+                f"SESSION EXPIRES IN {hours:.1f} HOURS ({raw}). This client "
+                "renews itself against POST /auth/session/refresh as you use "
+                "it, but the last attempt did not extend the session. If this "
+                "keeps counting down, renewal is failing — run `talis login` "
+                "to sign in again before it expires.")}
 
 
 _LAST_RENEW_ATTEMPT = [0.0]
@@ -111,7 +140,9 @@ def _maybe_renew() -> None:
     and config.ensure_fresh itself no-ops unless the session is actually short.
 
     Silent by contract: a renewal that cannot happen must never turn into a
-    tool error. The session_warning that follows is what tells the reader.
+    tool error. The session_warning that follows is what tells the reader — and
+    it can only tell the truth if this records what actually happened, so every
+    exit path here writes _RENEW_OUTCOME.
     """
     import time as _t
 
@@ -121,10 +152,30 @@ def _maybe_renew() -> None:
     _LAST_RENEW_ATTEMPT[0] = now
     try:
         creds = config.load()
-        if creds:
-            config.ensure_fresh(creds)
+        if not creds:
+            _RENEW_OUTCOME[0] = "unknown"
+            return
+        before_token = getattr(creds, "token", None)
+        before_hours = config.hours_remaining(creds)
+        fresh = config.ensure_fresh(creds)
+        after_token = getattr(fresh, "token", None)
+        if after_token and after_token != before_token:
+            # A DIFFERENT token came back — renewal demonstrably worked. Keyed
+            # on token identity, not on elapsed hours: comparing expiries means
+            # comparing floats across a wall-clock read, and a no-op would drift
+            # below its own start value on any slow call.
+            _RENEW_OUTCOME[0] = "renewed"
+        elif before_hours is None or before_hours > config.REFRESH_UNDER_HOURS:
+            # ensure_fresh no-ops above the threshold, and for API-key creds
+            # which carry no expiry at all. Nothing was attempted, so nothing
+            # failed — do not cry wolf.
+            _RENEW_OUTCOME[0] = "not_needed"
+        else:
+            # Under the threshold and the token did not change: renewal was
+            # attempted and did not take. THIS is the state worth shouting at.
+            _RENEW_OUTCOME[0] = "failed"
     except Exception:
-        pass
+        _RENEW_OUTCOME[0] = "failed"
 
 
 def _with_session_warning(fn):
@@ -708,6 +759,116 @@ def close(symbol: str, paper: bool = False) -> dict:
     return resp
 
 
+_CANDLE_KEYS = {"t": "timestamp", "o": "open", "h": "high", "l": "low", "c": "close", "v": "volume"}
+_INTERVAL_MINUTES = {"1m": 1, "5m": 5, "15m": 15, "30m": 30, "1h": 60, "4h": 240, "1d": 1440}
+_BACKTEST_MAX_CANDLES = 5000      # the venue's candleSnapshot ceiling per request
+_PAIR_RE = re.compile(r"\b([A-Z0-9]{2,12}-USD)\b")
+
+
+def backtest_candles(raw: list[dict]) -> list[dict]:
+    """Map the control plane's abbreviated candle keys onto the backtester's."""
+    return [{_CANDLE_KEYS.get(k, k): v for k, v in c.items()} for c in raw]
+
+
+def backtest(pair: str, dsl: dict, days: int = 30, interval: str = "1h",
+             timeout_seconds: int = 180) -> dict:
+    """Backtest a Talis DSL strategy on `pair` over the last `days` of `interval` candles. Read-only — never places an order.
+
+    Runs the SAME engine that executes live strategies (fast mode) against
+    real historical candles fetched for you, so the result is what this exact
+    DSL would have done. Validates the DSL first; an invalid DSL returns the
+    validator's errors and runs nothing.
+
+    Returns the backtest id, the window actually covered, and `results` with
+    `total_return_pct`, `sharpe_ratio`, `max_drawdown_pct`, `total_trades`,
+    `profit_factor` (plus whatever else the engine reports). Cross-asset
+    triggers (e.g. "ETH-USD.rsi_14") get their candles fetched automatically.
+
+    Workflow: validate_strategy → backtest → create_strategy(paper=True) →
+    create_strategy(paper=False, confirm_real_money=True). `days` × `interval`
+    is capped at the venue's 5000-candle window; the response says if it was.
+    """
+    if interval not in _INTERVAL_MINUTES:
+        raise ValueError(f"interval must be one of {sorted(_INTERVAL_MINUTES)}")
+    if days <= 0:
+        raise ValueError("days must be positive")
+    creds = _require_creds()
+    trading_pair = to_trading_pair(pair)
+    dsl_config = dict(dsl)
+    cfg = dict(dsl_config.get("config") or {})
+    cfg.setdefault("exchange", _EXCHANGE)
+    cfg.setdefault("trading_pair", trading_pair)
+    dsl_config["config"] = cfg
+
+    wanted = days * 1440 // _INTERVAL_MINUTES[interval]
+    limit = min(wanted, _BACKTEST_MAX_CANDLES)
+    capped = wanted > _BACKTEST_MAX_CANDLES
+
+    with api.client_from_credentials(creds) as c:
+        check = c.validate_strategy(dsl=dsl_config)
+        if isinstance(check, dict) and check.get("valid") is False:
+            return {"valid": False, "errors": check.get("errors"),
+                    "summary": check.get("human_readable_summary"),
+                    "note": "DSL rejected by the engine validator; nothing was run."}
+        primary = c.get_candles(symbol=base_coin(trading_pair), interval=interval,
+                                limit=limit, exchange=cfg["exchange"])
+        raw = list(primary.get("candles") or [])
+        if not raw:
+            return {"error": f"no candles returned for {trading_pair} at {interval}"}
+        candles = backtest_candles(raw)
+        cross: dict[str, list[dict]] = {}
+        for other in sorted(set(_PAIR_RE.findall(json.dumps(dsl_config))) - {trading_pair}):
+            resp = c.get_candles(symbol=base_coin(other), interval=interval,
+                                 limit=limit, exchange=cfg["exchange"])
+            if resp.get("candles"):
+                cross[other] = backtest_candles(resp["candles"])
+        start_ts = int(candles[0]["timestamp"])
+        end_ts = int(candles[-1]["timestamp"])
+        body: dict[str, Any] = {
+            "tenant_id": creds.tenant_id,
+            "mode": "fast",
+            "exchange": cfg["exchange"],
+            "trading_pair": trading_pair,
+            "start_ts": start_ts,
+            "end_ts": end_ts,
+            "interval": interval,
+            "candles": candles,
+            "dsl": dsl_config,
+        }
+        if cross:
+            body["cross_asset_candles"] = cross
+        submitted = c.create_backtest(body=body)
+        backtest_id = submitted.get("backtest_id")
+        if not backtest_id:
+            return {"error": "backtest was not accepted", "response": submitted}
+        deadline = time.monotonic() + timeout_seconds
+        status = submitted
+        while time.monotonic() < deadline:
+            status = c.get_backtest(backtest_id=backtest_id)
+            if str(status.get("status", "")).upper() not in ("RUNNING", "PENDING", "QUEUED", ""):
+                break
+            time.sleep(2)
+
+    results = status.get("results") if isinstance(status, dict) else None
+    out: dict[str, Any] = {
+        "backtest_id": backtest_id,
+        "status": status.get("status"),
+        "pair": trading_pair,
+        "window": {"interval": interval, "candles": len(candles), "start_ts": start_ts,
+                   "end_ts": end_ts, "requested_days": days, "capped_to_venue_window": capped},
+        "cross_assets": sorted(cross),
+        "results": results,
+    }
+    if isinstance(results, dict):
+        out["summary"] = {k: results.get(k) for k in (
+            "total_return_pct", "sharpe_ratio", "max_drawdown_pct", "total_trades", "profit_factor")}
+    if str(out["status"] or "").upper() in ("RUNNING", "PENDING", "QUEUED"):
+        out["note"] = f"still running after {timeout_seconds}s; call again later via the API: GET /backtests/{backtest_id}"
+    out["next"] = ("create_strategy(pair, dsl, paper=True) runs it on the simulated book; "
+                   "create_strategy(pair, dsl, paper=False, confirm_real_money=True) goes live.")
+    return out
+
+
 def create_strategy(pair: str, dsl: dict, paper: bool = False,
                     confirm_real_money: bool = False) -> dict:
     """Create and auto-start a trading strategy on `pair` from a Talis DSL dict. Trades REAL money by default — a real strategy requires confirm_real_money=True; pass paper=True to simulate.
@@ -1211,6 +1372,7 @@ TOOL_FUNCTIONS = (
     strategy,
     strategy_activity,
     validate_strategy,
+    backtest,
     outcomes,
     buy,
     sell,
@@ -1245,7 +1407,9 @@ _SERVER_INSTRUCTIONS = (
     "never left unprotected. `stop_strategy` does NOT close the position; it "
     "only ends the automation and leaves any position unmanaged, so use `close` "
     "to actually exit, and `cancel_order` to kill an unfilled limit order. "
-    "Check `validate_strategy` before creating anything with paper=False. "
+    "Check `validate_strategy` before creating anything with paper=False, and "
+    "`backtest` (read-only, real historical candles, the live engine) to see what "
+    "a DSL would have done before deploying it. "
     "Withdrawals are not available through this server."
 )
 

{talis_cli-0.2.0 → talis_cli-0.3.0}/talis_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talis-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Command-line client for the Talis trading platform. Sign in via device flow, manage sessions, view portfolio, place orders.
 Author: Talis
 License-Expression: Apache-2.0
@@ -114,6 +114,27 @@ suitable for parsing from scripts or LLM agents. Force JSON anywhere with
 The CLI stores its session token at `~/.talis/credentials` with `chmod 600`
 on POSIX systems. The token is a JWT; treat it like any other credential.
 
+### Sessions renew themselves
+
+You should not have to think about session expiry. When the CLI or the MCP
+server runs with under 48 hours left on the clock, it renews in place against
+`POST /auth/session/refresh` before doing its work — at most once every 15
+minutes, so a burst of commands costs one renewal, not one each. Renewal
+preserves the
+session's **original grant**, not a fresh maximum — a token issued with a 24h
+life renews to another 24h, never to something longer. That is deliberate: an
+auto-renewing session must not be able to ratchet itself into a longer-lived
+credential than the one you approved.
+
+Renewal is best-effort and silent: if it cannot happen, your existing
+credential is left untouched and the command still runs. What you WILL see is a
+`session_warning` on MCP tool responses once renewal stops keeping up, or when
+under six hours remain. If that appears and keeps counting down, renewal is
+failing — run `talis login` to sign in again.
+
+A steady `session_hours_remaining` with no `session_warning` is the healthy
+state, not a countdown to worry about.
+
 ## Relationship to `cli/jarvis_cli.sh`
 
 The bash script at [`cli/jarvis_cli.sh`](../../cli/jarvis_cli.sh) is the legacy
@@ -142,12 +163,16 @@ your portfolio, pull Talis Research, place paper trades, create strategies,
 set price alerts, and talk to the Talis chat agent. Log in first
 (`talis login`); the server authenticates as the logged-in user.
 
-Add it to **Claude Code**:
+Install and add it to **Claude Code**:
 
 ```bash
+pip install talis-cli        # or: uv tool install talis-cli
+talis login                  # device-flow browser approval, once
 claude mcp add talis -- talis mcp
 ```
 
+No local checkout required — `talis` is on PyPI.
+
 Or to **Claude Desktop** (and other clients using the `mcpServers` config
 shape) — `claude_desktop_config.json`:
 
@@ -162,14 +187,33 @@ shape) — `claude_desktop_config.json`:
 }
 ```
 
-Tools: `whoami`, `portfolio`, `balance`, `research`, `packets`,
-`brief_latest`, `history`, `buy`, `sell`, `close`, `create_strategy`, `chat`,
-`notifications_create`.
-
-**Safety**: the trading tools (`buy` / `sell` / `close` / `create_strategy`)
-default to `paper=True` — an isolated simulated book. An agent must pass
-`paper=False` explicitly to trade real money. Set `TALIS_PAPER=1` in the
-server's environment to force paper mode regardless of tool arguments.
+Tools (26):
+
+`amend_strategy`, `backtest`, `balance`, `brief_latest`, `buy`, `cancel_all_orders`,
+`cancel_order`, `chat`, `close`, `create_strategy`, `history`,
+`notifications_create`, `open_orders`, `outcomes`, `packets`, `place_order`,
+`portfolio`, `research`, `sell`, `start_strategy`, `stop_strategy`,
+`strategies`, `strategy`, `strategy_activity`, `validate_strategy`, `whoami`.
+
+**Strategy workflow.** `validate_strategy(dsl)` checks a DSL without side
+effects; `backtest(pair, dsl, days=30, interval="1h")` runs it through the live
+engine on real historical candles (read-only) and returns return, Sharpe,
+drawdown, trade count; `create_strategy(pair, dsl, paper=True)` runs it on the
+simulated book; the same call with `paper=False, confirm_real_money=True`
+deploys it live.
+
+**Safety — read this before pointing an agent at it.** The trading tools
+(`buy` / `sell` / `close` / `create_strategy`) execute with **REAL MONEY by
+default** (`paper=False`). Pass `paper=True` to simulate instead.
+
+`buy`, `sell` and `create_strategy` additionally refuse to spend real money
+unless the caller passes `confirm_real_money=True`. `close` deliberately has no
+such gate: a protective exit must never be blocked by a missing flag.
+`place_order` (limit orders, spot, HIP-4 outcome markets) has **no paper mode
+at all** and refuses without `confirm_real_money=True`.
+
+Set `TALIS_PAPER=1` in the server's environment to force paper mode regardless
+of tool arguments.
 Withdrawals and wallet creation are not exposed over MCP. For a strictly
 read-only agent, log in with `talis login --read-only` — the server rejects
 every mutation at the API layer.

{talis_cli-0.2.0 → talis_cli-0.3.0}/talis_cli.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ tests/test_history.py
 tests/test_login_flow.py
 tests/test_loopback_login.py
 tests/test_mcp.py
+tests/test_mcp_backtest.py
 tests/test_mcp_balance_contract.py
 tests/test_mcp_docstring_contract.py
 tests/test_mcp_mode_contract.py