# Professional Trader Desk to Tiny/Full Autonomy Pattern

Use this when the user wants JARVIS/Hermes to move from negative rigid bot candidates toward professional trader-style Hyperliquid autonomy.

## Trigger

- Existing strategy variants are negative or inconclusive under realistic paper lifecycle.
- User asks for “professional trader”, “use all information”, or a plan to autonomous Hyperliquid trading.
- The wallet is explicitly treated as risk capital / written off, but the bot still must not gamble without controls.

## Product shape

Build a separate **Trader Desk decision layer** before live autonomy:

1. Read-only market/context aggregation.
2. Professional trade-plan scoring.
3. Shadow/watch journaling.
4. Tiny-live candidate output only when score and hard blockers pass.
5. Tiny live runtime consumes candidates only after final preflight.

The Trader Desk is not an exchange executor. It should always emit:

```text
live_order_allowed=false
mainnet_signed_action=false
```

## Inputs to combine

- Hyperliquid price/mids, L2 spread/depth/impact, funding, premium, open interest.
- Market snapshot/confluence: trend, momentum, volatility, liquidity, derivatives, risk/regime.
- CoinGecko/fundamental context, explicitly neutral if not loaded.
- TradingView/community analysis only as `research_only` sentiment/track-record context.
- Existing paper/live journals, open exposure, lifecycle evidence.
- User mandate: allowed coins, long-only/shorts, notional caps, loss limits, max open positions.

## TradePlan contract

Each coin should produce a structured plan:

```text
coin
direction: long | short | none
action: no_trade | watch_shadow | tiny_live_candidate
score
confidence
setup
entry_zone
stop_loss
take_profit / management
risk_reward
notional_cap_usdc
reasons
blockers
evidence
requires_preflight
live_order_allowed=false
mainnet_signed_action=false
```

## Suggested v1 scoring/action rules

- Score `<70` or any hard blocker → `no_trade`.
- Score `70–79` → `watch_shadow`.
- Score `>=80`, coin in allowed list, direction allowed by mandate → `tiny_live_candidate`.
- Under initial tiny-live mandate, shorts are `watch_shadow` unless explicitly approved.
- A tiny-live candidate is **not** an order authorization; it only means “eligible for final preflight + runtime gates”.

Hard blockers should include at least:

```text
stale_data
low_reliability
weak_liquidity
spread_unknown / spread_too_wide
l2_unavailable
impact_unknown / impact_slippage_too_high
volatility_too_high
risk_score_too_low
confluence_below_threshold
spread_above_mandate
```

## Tiny live mandate default

Start conservative even if the wallet is written off:

```text
long-only
BTC, ETH, SOL, LINK only
max_notional_per_trade: 10–15 USDC
max_total_open_notional: 45 USDC
max_open_trades: 3
1x default leverage, 2x hard cap
max_daily_loss: 2 USDC
max_weekly_loss: 5 USDC
loss_streak_pause: 2
no martingale
no averaging down
no new live strategy/coin without paper/shadow evidence + user approval
```

## Implementation sequence

1. Add pure Trader Desk domain model and deterministic tests.
2. Add CLI that can consume an existing market-confluence report or build a fresh read-only report.
3. Write `runtime/reports/trader_desk_latest.json`; keep it token/secret-free.
4. Add docs explaining that `tiny_live_candidate` still requires final preflight.
5. Run targeted tests, full tests, compile checks, unsafe-pattern scan, and a fresh read-only smoke.
6. Next increment: shadow runner that journals every plan per tick and later evaluates plan score vs outcome.
7. Then: adapter from Trader Desk candidates into tiny live runtime, still fail-closed on preflight/reconcile/stop gates.

## User-facing reporting

For trading/autonomy questions, answer like a trader/risk manager first:

- Current live status: paused/running.
- Whether any tiny-live candidates exist now.
- Best watchlist coin/action/score.
- Explicit “no Mainnet orders / signed=false” until final preflight.
- Next decision: collect shadow evidence, run final preflight, or pause.

Do not lead with commits or raw JSON unless the user asks.