Recipe Playground Rebalance

Each Round

On each firing: READ, THINK, ACT.

READ: a fresh balance and each symbol's price. Read the balance every round — never carry a snapshot across rounds or across trades within a round; each fill mutates cash and holdings.

kraken paper balance -o json 2>/dev/null
kraken ticker BTCUSD -o json 2>/dev/null | jq -r '.[] | .last_price'   # repeat per symbol

kraken paper balance returns {"balances":{"USD":{"total","reserved","available"},...}}. Cash is .balances.USD.available; a holding is .balances.<ASSET>.total (0 if the key is absent). Price is the ticker's last-trade close (.[] | .last_price).

Fail loud before any leg trades: validate the cash figure and EVERY price before computing deltas — a rebalance acts on several legs, so one silently failed read sizes every order from garbage. On an empty read, note an alert and end the firing (the claimed round stays claimed; the next firing retries):

if [ -z "$CASH" ] || [ -z "$PRICE_BTC" ]; then
  kraken session note --kind alert \
    --reason "round $ROUND aborted: READ failed (cash='$CASH' btc='$PRICE_BTC')" -o json 2>/dev/null
  exit 0
fi

THINK: value the portfolio, then decide each leg.

• total_value = cash + Σ(holdings × price)
• Per symbol: value = holdings × price, current_pct = value / total_value × 100, target_pct = target × 100, drift = current_pct − target_pct, delta_usd = target_value − value where target_value = total_value × target.
• A leg needs action only when |drift| > drift_pct AND |delta_usd| > threshold_usd. Otherwise leave it.

ACT: sells before buys. Execute every overweight leg (delta_usd < 0) first so its proceeds land back in cash, then execute the underweight legs. Size each buy against a fee/slippage reserve so the last leg never rejects: keep the buy cost at or below available_cash / (1 + fee_rate + slippage_rate) (defaults 0.0026 fee, 0.0 slippage — read them from paper status if unsure). Between legs, re-read the balance rather than assuming the pre-trade cash, and skip or shrink a buy the remaining cash can no longer fund.

# Overweight — sell the excess first
kraken order sell BTC/USD <volume> --type market \
  --reason "rebalance round N: BTC/USD weight <current_pct>% above target <target_pct>%; selling <volume>" \
  -o json 2>/dev/null

# Underweight — buy toward target, capped by fee-reserved cash
kraken order buy SOL/USD <volume> --type market \
  --reason "rebalance round N: SOL/USD weight <current_pct>% below target <target_pct>%; buying <volume>" \
  -o json 2>/dev/null

If no leg breaches both thresholds, note a single skip:

kraken session note --kind skip --symbol BTC/USD \
  --reason "skip round N: all weights within <drift_pct>%/$<threshold_usd> band" \
  -o json 2>/dev/null

Always pass the numeric reason so the decision log carries the "why" behind every round.

Stop and Review

kraken session stop -o json 2>/dev/null
kraken session show -o json 2>/dev/null | jq '.summary'

kraken session decisions --session s<n> -o json 2>/dev/null \
  | jq -c '.decisions[] | {kind, symbol, reason, timestamp}'

Report:

• Final weights vs targets (50/35/15)
• Number of rebalance trades vs skips
• Cumulative turnover (fees paid)
• P&L vs a buy-and-hold baseline
• Did the drift_pct/threshold_usd band hold the portfolio?

Hard Rules

• This recipe records a session inside a paper workspace. It never places a live order.
• /loop drives the pace and the agent runs each round; the CLI has no scheduler and runs no strategy. The scheduler floor is 60s — no sub-minute cadence.
• Read a fresh balance every round and after each fill. Never size a trade off a stale snapshot — the seed round alone issues three buys, and a fixed pre-trade cash figure overspends once fees are charged.
• Sells before buys, and reserve fees on every buy, so a multi-leg round cannot reject its last order after earlier fills were already recorded.
• Keep every gating number (targets, drift_pct, threshold_usd, interval_s) in --strategy-params and the arithmetic in jq/bc, so a rerun on the same tape reproduces the decisions.
• The session directory (session.json, decisions.jsonl, and the tape sinks) is owned by the CLI recorder. The agent only reads it, and only for the stop-time summary. Never write, edit, or append inside it — every trade and skip goes through kraken order buy / kraken session note, so the recorder stays the single writer.
• If you hit a mismatch between what you are trying to do and the CLI's interface or responses — including a mismatch between this skill and the installed CLI version's contract — feel free to submit feedback with kraken feedback.