MoneySharks

Autonomous 24/7 Aster Futures perpetual trading agent. Purpose: generate the largest sustainable ROI from live leveraged futures trading on Aster DEX, operating continuously without per-trade human intervention, learning from every completed trade.

Core rules

Require onboarding before any private API action. Never use credentials that haven't been verified.
Default mode is paper until the user completes onboarding and types ACCEPT at the consent gate.
In autonomous_live mode: execute orders immediately — do NOT pause for per-trade human approval.
All hard risk limits are permanent: daily loss cap, max exposure, max notional, leverage ceiling, stop-loss and take-profit requirements, circuit breakers. None can be overridden by configuration changes, learning, or performance.
Never hardcode secrets. API key and secret live only in environment variables.
Never silently expand risk. Never raise leverage above max_leverage, never change mode to a riskier mode without explicit user instruction.
Never self-modify hard risk rules. The learning system adjusts confidence and leverage within bounds — it cannot rewrite the rules that define those bounds.
Journal every decision, including wait decisions. No silent cycles.

Modes

| Mode | Real Orders | Approval Per Trade | Description | |---|---|---|---| | paper | No | N/A | Full pipeline simulation. Real market data, no API writes. | | approval | No | Yes | Generates proposals and waits for per-trade confirmation before submitting. | | live | Yes | Configurable | Live execution. Per-trade approval gate controlled by execution.require_human_approval_for_live_orders. | | autonomous_live | Yes | No | Full autonomy. Consent locked in once at onboarding. Executes every decision immediately 24/7. |

Files in this skill

Core skill file

SKILL.md — this file

Documentation

documentation-moneysharks.md — comprehensive human-readable documentation: architecture, all config options, pipeline deep-dives, API integration details, operational runbook, FAQ. Read this for context before explaining anything to the user.

References (read when needed)

references/onboarding.md — onboarding flow, consent gate text, defaults, post-ACCEPT steps
references/strategy-framework.md — multi-TF strategy principles (4H trend, 1H signal, 5M timing)
references/confluence-model.md — 9-point confluence check definitions and confidence thresholds
references/leverage-policy.md — leverage selection rules and volatility adjustments
references/risk-policy.md — hard risk rules, circuit breaker conditions
references/execution-playbook.md — step-by-step execution cycle for each mode
references/live-execution-boundary.md — exactly what is and isn't gated in autonomous_live
references/review-and-learning.md — what the learning system may and may not adapt
references/emergency-controls.md — halt sequence, resume, circuit breaker, trigger phrases
references/cron-automation.md — cron job intervals, 24/7 continuity rules
references/aster-readonly-integration.md — API integration scope and guidance
references/aster-skill-map.md — Aster skill family map
references/approval-execution.md — approval mode flow
references/proposal-flow.md — proposal generation and approval handoff
references/websocket-loop.md — real-time data feed (advanced / optional)
references/deployment.md — systemd / launchd deployment
references/packaging.md — skill packaging
openclaw-cron-templates.json — ready-to-use OpenClaw cron job definitions (paths substituted by register_crons.py)

Scripts — live trading core (29 scripts total)

Entry point

scripts/autonomous_runner.py — main 24/7 entry point. Called by cron every 2 min. Validates config + credentials, checks halt/circuit-breaker, runs position_monitor.py for all known open positions, runs trade_loop.py per symbol, runs trailing stop management for open positions, triggers post-trade review every 5 new trades. Writes state.json after every cycle.

Per-symbol execution loop

scripts/trade_loop.py — single-symbol execution cycle. Enforces cooldown after close, duplicate position guard, learning-adjusted confidence threshold, and learning-capped leverage. Calls the full scan → risk → execute → journal pipeline. Handles paper, live, and autonomous_live execution branches. Updates known_open_positions in state on successful entry.

Market data and feature computation

scripts/market_scan_from_aster.py — fetches real multi-TF klines (5m/1h/4h), ticker, mark price + funding rate, order book depth, and account bundle from Aster API. Computes all features, signal, confluence, leverage, and position size. Applies exchange precision rounding via round_quantity() / round_price(). Enforces MIN_NOTIONAL from exchangeInfo. Performs order-book liquidity check. Returns a complete order proposal or null for non-entry signals.
scripts/compute_features.py — from a kline array: computes EMA20, EMA50, EMA12, EMA26, RSI14, ATR14, MACD line, MACD signal, volume ratio, trend (up/down/neutral), momentum (up/down/neutral), high_volatility flag. Accepts optional funding_rate passthrough.
scripts/compute_signal.py — multi-TF weighted scoring for long and short. 7 factors each: 4H trend (weight 2), 1H trend (weight 2), RSI zone (1.5), MACD crossover (1), 5M timing (0.5), volume (1), EMA20 position (1). Incorporates funding rate bias (+0.5 weight). In high volatility raises the entry bar to 0.70. Generates close signal on trend reversal or extreme RSI with existing position.
scripts/compute_confluence.py — 9-point binary check system: trend_alignment, momentum_confirmation, volume_confirmation, rsi_zone, macd_alignment, reward_risk_ok, exposure_capacity_ok, position_capacity_ok, timeframe_confluence. Confidence = checks_passed/9. Requires ≥ 0.55 for new entries (configurable via learning).

Sizing and risk

scripts/recommend_leverage.py — maps confidence to leverage (min at < 0.60, midpoint at 0.60–0.79, max at ≥ 0.80). Steps down by 1 in high volatility. Result is further capped by effective_leverage_cap from learning metrics.
scripts/size_position.py — risk-based position sizing: notional = (equity × risk_pct) / stop_distance_pct. Returns risk_usd, stop_distance_pct, notional, margin, quantity.
scripts/risk_checks.py — four hard enforcement checks: daily loss limit hit, total exposure after trade vs max_total_exposure, per-trade notional vs max_notional_per_trade, available margin vs required margin. Also guards against zero notional. Only enforces limits that are set > 0.
scripts/prepare_order.py — constructs the final order dict from sizing outputs (symbol, side, type, quantity, leverage, stop_loss, take_profit).

Execution

scripts/live_execution_adapter.py — gated live execution. Checks credentials, enforces mode guard (only live or autonomous_live), enforces approval gate in live mode, skips gate in autonomous_live. Calls aster.place_bracket() → entry MARKET + STOP_MARKET + TAKE_PROFIT_MARKET. Returns full order result JSON.
scripts/aster_readonly_client.py — complete Aster DEX API client. HMAC-SHA256 signing, retry logic (3 retries, exponential backoff, 429 Retry-After respect, 5xx retry). Exchange info cache (1h TTL). round_quantity(), round_price(), get_symbol_filters(). Public endpoints: ticker, mark price, depth, klines, funding rate, exchangeInfo. Private reads: account, positions, open orders, income history, user trades. Private writes: set_leverage, set_margin_type, place_order (MARKET / STOP_MARKET / TAKE_PROFIT_MARKET), cancel_order, cancel_all_orders, close_position_market, place_bracket(). CLI modes: market, market_bundle, klines, account, mark_price, funding, set_leverage, cancel_all, income, trades, positions.

Position lifecycle management

scripts/position_monitor.py — runs at the start of every cycle. Compares state.json → known_open_positions to live Aster positions. When a position disappears: queries /fapi/v1/income for REALIZED_PNL, classifies outcome (win/loss/breakeven), detects close reason (stop_loss_hit/take_profit_hit/unknown), updates the matching journal entry in trades.json with outcome, realised_pnl, close_reason, closed_at, lesson_tags, regime. Adds to daily_loss on losses. Cleans up known_open_positions.
scripts/trailing_stop.py — calculates updated stop-loss for an open position. Two modes: atr (trail = current_price ± ATR × 1.5) and breakeven (move SL to entry + buffer when PnL ≥ 0.5%). Never moves against the position. Called by autonomous_runner.py after trade loops. When moved=true, autonomous_runner.py cancels the old STOP_MARKET order and places a new one via aster_readonly_client.

Learning pipeline

scripts/fetch_trade_outcomes.py — backbone of the self-learning loop. Queries /fapi/v1/income (REALIZED_PNL) for each symbol with unresolved journal entries. Matches income records by symbol and time. Writes outcome, realised_pnl, and lesson_tags into trades.json. For paper mode (with --paper flag): estimates outcome from current mark price vs recorded SL/TP levels. Returns counts of updated entries.
scripts/review_trades.py — analyses trades.json: win rate, avg PnL, total PnL, max loss streak, lesson tag frequency, performance by symbol, performance by market regime (trending_up, trending_down, high_volatility, ranging), high-confidence trade win rate. Generates lessons list.
scripts/update_metrics.py — applies learning adaptations from review to state.json → metrics. Adaptations: confidence_multiplier (lowered after ≥4 loss streak, recovered after winning), effective_leverage_cap (lowered after ≥3 streak or win_rate < 35%, recovered slowly), recommended_min_confidence (raised when high-confidence trades outperform), underperforming_symbols flag. All bounded by config limits — never raises leverage above max_leverage.
scripts/journal_trade.py — appends one entry to trades.json. Sets ts if missing.

Setup and operations

scripts/onboarding.py — interactive CLI onboarding. Step 1: reads/prompts credentials, verifies against Aster /fapi/v2/account live call (fails hard on bad creds). Step 2: collects symbols, base investment, leverage range, exposure limits, daily loss limit, allow_short. Step 3: presents consent gate — must type ACCEPT to enable autonomous_live. Step 4: writes config.json, calls register_crons.py, prints next steps.
scripts/register_crons.py — substitutes /ABSOLUTE/PATH/TO/moneysharks placeholder in openclaw-cron-templates.json with the real skill root path. Selects which jobs to enable based on mode. Writes register_crons.json. Called automatically by onboarding.py.
scripts/validate_config.py — validates config.json: all required fields present, valid mode, consent set for autonomous_live, leverage bounds sensible, notional vs exposure consistency, cron scan interval, symbols non-empty. Returns {"ok": bool, "errors": [...], "warnings": [...]}.
scripts/reconcile_state.py — two modes. Stdin mode (-): accepts {"account": {...}, "positions": [...], "orders": [...]} JSON and returns a reconciled summary. CLI mode: fetches live account bundle from Aster API and updates state.json → account + positions_snapshot fields. Use at startup and after resume.
scripts/halt.py — emergency halt CLI. Sets halt=true + circuit_breaker=true in state.json. Cancels all orders for each allowed symbol if --cancel-orders or execution.cancel_on_halt=true. Optionally flattens all open positions with --flatten. Accepts --reason "text". Journals a halt_event entry. Prints confirmation.
scripts/resume.py — resume from halt. Clears halt=false, circuit_breaker=false, consecutive_errors=0. Optionally switches mode (--mode paper|autonomous_live). Guards: cannot resume into autonomous_live without autonomous_live_consent=true in config. Fetches live account reconciliation. Journals a resume_event. Optionally runs first cycle (--run-now).
scripts/status.py — live status report. Fetches account + positions from Aster API. Reads state.json and trades.json. Outputs: mode, halt, circuit breaker, consecutive errors, daily loss vs limit, last cycle age, credentials status, equity, available margin, today PnL, open positions with uPnL, trade stats (total/executed/closed, win rate, total PnL), adaptive metrics (win rate, avg PnL, eff leverage cap, confidence multiplier), active lessons, config summary. Human-readable by default; --json for machine output.

Approval / proposal mode helpers

scripts/aster_proposal_runner.py — generates an approval-gated order proposal using real Aster market data. Calls market_scan_from_aster.py for the symbol, extracts price and order params, emits a PENDING_APPROVAL proposal with confidence, leverage, entry, SL, TP, and signal context.
scripts/approval_runner.py — constructs a PENDING_APPROVAL proposal dict from order inputs. Used in approval mode trade loop.
scripts/approval_watch_runner.py — returns a monitoring status dict indicating scan-journal-propose mode. Stub for approval watcher loop.
scripts/paper_runner.py — legacy paper simulation runner (static file inputs). Main paper flow uses autonomous_runner.py with mode=paper.

Config and data files

config.json — your active configuration. Written by onboarding.py. Never commit with real credentials.
config.example.json — annotated reference config with all fields and sensible defaults.
state.json — live agent state: halt, circuit_breaker, consecutive_errors, daily_loss, last_run, account, known_open_positions, last_close_ts, metrics.
state.example.json — state schema reference.
trades.json — complete trade journal. Append-only during operation. Every decision logged.
trades.example.json — trades schema reference.
register_crons.json — generated by register_crons.py at onboarding. Contains ready-to-register OpenClaw cron job defs with real paths substituted.

Setup

install.sh — setup verification: Python 3.10+ check, all 21 required scripts present, all scripts syntax-valid, config validation, credentials check.
requirements.txt — no pip dependencies (stdlib only). Documents optional advanced integrations.

Deployment

deploy.systemd.service / deploy.systemd.timer — Linux systemd unit files for 24/7 background deployment.
deploy.launchd.plist — macOS launchd plist for 24/7 background deployment.
logrotate.moneysharks.conf — Linux log rotation config.
newsyslog.moneysharks.conf — macOS log rotation config.

Workflow

Per-cycle execution (called by cron every 2 min)

autonomous_runner.py config.json
 │
 ├─ 1. Validate config (validate_config.py)
 ├─ 2. Check credentials (ASTER_API_KEY / ASTER_API_SECRET)
 ├─ 3. Check halt + circuit_breaker → exit immediately if either is set
 ├─ 4. Reset daily_loss at UTC midnight
 │
 ├─ 5. Position monitoring (position_monitor.py)
 │       → compare known_open_positions vs live Aster positions
 │       → on close: fetch income, record outcome + PnL, tag lesson, update daily_loss
 │
 ├─ 6. Per symbol: trade_loop.py
 │       a. Halt / circuit_breaker check
 │       b. Daily loss limit check → block if hit
 │       c. Cooldown check → skip if closed recently
 │       d. Duplicate position guard → skip if already positioned
       ← cooldown_after_close_sec prevents immediate re-entry on same symbol
 │       e. market_scan_from_aster.py:
 │            - fetch klines (5m/1h/4h) + ticker + mark price + depth + account
 │            - compute_features.py (EMA/RSI/ATR/MACD, funding rate) for each TF
 │            - compute_signal.py (weighted scoring, funding rate bias, hold/close logic)
 │            - compute_confluence.py (9 checks → confidence)
 │            - recommend_leverage.py (confidence + volatility → leverage)
 │            - size_position.py (equity × risk_pct / stop_distance)
 │            - round_quantity + round_price (exchange precision)
 │            - min_notional check → suppress if too small
 │            - liquidity check (order vs order book depth)
 │       f. Apply learning feedback:
 │            - adjusted_confidence = confidence × confidence_multiplier
 │            - if adjusted_confidence < recommended_min_confidence → wait
 │            - cap leverage at effective_leverage_cap
 │       g. risk_checks.py (daily loss, exposure, notional, margin, zero notional guard)
 │       h. Execute by mode:
 │            paper         → simulate, record as paper_executed
 │            autonomous_live → live_execution_adapter.py → place_bracket() → Aster API
 │            live          → live_execution_adapter.py (with optional approval gate)
 │            approval      → approval_runner.py → emit PENDING_APPROVAL
 │       i. On successful autonomous_live entry: update known_open_positions in state
 │       j. Journal entry (always, including wait decisions)
 │       k. Save state.json
 │
 ├─ 7. Trailing stop management (open positions in autonomous_live):
 │       → trailing_stop.py for each known_open_position
 │       → if moved: cancel old STOP_MARKET, place new one via aster API
 │       → update known_open_positions[symbol].stop_loss in state
 │
 ├─ 8. Update state.json (last_run, consecutive_errors, circuit_breaker if errors ≥ 5)
 │
 └─ 9. Post-trade review (every 5 new trades):
         fetch_trade_outcomes.py → income history → resolve outcomes in trades.json
         review_trades.py       → win rate, PnL, streaks, regime performance
         update_metrics.py      → adapt confidence_multiplier, leverage cap, threshold
         save updated metrics to state.json

Onboarding flow

onboarding.py
 │
 ├─ 1. Read ASTER_API_KEY + ASTER_API_SECRET from env (prompt if missing)
 ├─ 2. Verify credentials: GET /fapi/v2/account → fail hard if invalid
 ├─ 3. Collect: symbols, base_value, max_leverage, min_leverage,
 │              max_total_exposure, max_daily_loss, allow_short
 ├─ 4. Show consent gate with full risk summary
 ├─ 5. User types ACCEPT or DECLINE
 │
 ├─ On ACCEPT:
 │     - Write config.json (mode=autonomous_live, consent=true, cron.enabled=true)
 │     - register_crons.py → register_crons.json (paths substituted)
 │     - Agent calls cron(action="add", job=...) for each active job (see below)
 │     - Run first cycle: autonomous_runner.py config.json
 │     - Show status: status.py config.json
 │
 └─ On DECLINE:
       - Write config.json (mode=paper, consent=false, cron.enabled=false)
       - register_crons.py → register_crons.json (paper jobs only)
       - Instruct user to re-run onboarding when ready to go live

Post-ACCEPT: register cron jobs (agent executes these steps)

After writing config.json and generating register_crons.json, the agent reads the file and calls cron(action="add", job=...) for each of the four active jobs:

| Job key | Schedule | sessionTarget | delivery | |---|---|---|---| | autonomous_live_scan | */2 * * * * UTC | isolated | none | | autonomous_review | */30 * * * * UTC | isolated | none | | autonomous_daily_summary | 0 0 * * * UTC | isolated | announce | | halt_check | */15 * * * * UTC | isolated | announce |

The exact job JSON (with real paths) is already written to register_crons.json by register_crons.py. The agent reads each entry and passes it directly to cron(action="add").

Onboarding requirements

Collect only the essentials — everything else uses sensible defaults:

| Input | Required | Default | Notes | |---|---|---|---| | ASTER_API_KEY | Yes | — | Verified live against Aster API before proceeding | | ASTER_API_SECRET | Yes | — | Never written to config.json | | allowed_symbols | Yes | BTCUSDT, ETHUSDT, SOLUSDT | Must be valid Aster Futures symbols | | base_value_per_trade | Yes | 100 | USD reference investment per trade | | max_leverage | Yes | 10 | Hard ceiling — never exceeded | | min_leverage | No | 2 | Floor for low-confidence setups | | max_total_exposure | No | base_value × 10 | Total open notional cap | | max_daily_loss | No | total_exposure × 10% | Daily loss hard stop | | allow_short | No | true | Set false for long-only mode | | Consent: ACCEPT | Yes | — | Cannot be set programmatically — user must type it |

Full config field reference: documentation-moneysharks.md § 5.

Signal generation summary

Signals from compute_signal.py (weighted scoring, each factor contributes independently):

| Factor | Weight | Long condition | Short condition | |---|---|---|---| | 4H trend | 2.0 | trend == "up" | trend == "down" | | 1H trend | 2.0 | trend == "up" | trend == "down" | | RSI zone | 1.5 | RSI 45–68 | RSI 32–55 | | MACD crossover | 1.0 | MACD > signal | MACD < signal | | 5M timing | 0.5 | 5m trend/momentum up | 5m trend/momentum down | | Volume | 1.0 | volume_ratio ≥ 0.8 | volume_ratio ≥ 0.8 | | EMA20 position | 1.0 | price > EMA20 | price < EMA20 | | Funding rate bias | 0.5 | funding < −0.0001 | funding > +0.0001 |

Entry threshold: score ≥ 0.55. High-volatility override: threshold raised to 0.70.
wait if neither long nor short meets threshold.
hold / close logic runs when a position is already open (trend reversal, extreme RSI).

Confluence scoring (9-point system)

Implemented in compute_confluence.py. Confidence = checks_passed / 9.

| Check | Passes when | |---|---| | trend_alignment | 1H trend matches direction; 4H at least neutral | | momentum_confirmation | RSI-based 1H momentum matches direction | | volume_confirmation | volume_ratio ≥ 0.75 | | rsi_zone | RSI in valid entry zone (long 40–70, short 30–60) | | macd_alignment | MACD line above signal (long) / below signal (short) | | reward_risk_ok | (take_profit − entry) / (entry − stop_loss) ≥ min_reward_risk | | exposure_capacity_ok | current_exposure < max_total_exposure × 0.90 | | position_capacity_ok | open_positions < max_concurrent_positions | | timeframe_confluence | Both 1H AND 4H trend align with direction |

Minimum confidence to enter: 0.55 (5/9). Raises to 0.70 in high volatility.

Stop/target defaults (when ATR available): SL = entry ± 1.5×ATR, TP = entry ± 2.5×ATR → natural R:R 1.67×.

Learning system summary

Three-step cycle after every set of closed trades:

fetch_trade_outcomes.py — pulls REALIZED_PNL from /fapi/v1/income, resolves outcome + realised_pnl + lesson_tags in trades.json
review_trades.py — computes win rate, avg PnL, loss streak, regime performance
update_metrics.py — applies bounded adaptations to state.json → metrics:

| Metric | What it does | Bounds | |---|---|---| | confidence_multiplier | Multiplied into raw confidence score before threshold check. < 1.0 makes entry harder. | 0.70 floor; recovers toward 1.0 | | effective_leverage_cap | Caps the leverage recommended by recommend_leverage.py. | min_leverage floor; max_leverage ceiling — hard | | recommended_min_confidence | Entry threshold. Raised when high-confidence trades outperform. | 0.55 default; 0.75 max | | leverage_reduction_active | Flag indicating leverage has been reduced by learning. | Bool only | | underperforming_symbols | Symbols with total PnL < −$100. Informational. | — |

Learning cannot: raise leverage above max_leverage, change mode to riskier, suppress journaling, remove stop-loss requirements.

Hard safety rules (always enforced, cannot be bypassed)

| Rule | Enforcement point | |---|---| | max_daily_loss — blocks ALL entries when daily loss hits limit | trade_loop.py, risk_checks.py | | max_total_exposure — caps total open notional | risk_checks.py | | max_notional_per_trade — scales down + hard blocks oversized trades | market_scan_from_aster.py, risk_checks.py | | max_leverage — hard ceiling on all leverage | recommend_leverage.py, update_metrics.py | | require_stop_loss — every live trade has STOP_MARKET | live_execution_adapter.py | | require_take_profit — every live trade has TAKE_PROFIT_MARKET | live_execution_adapter.py | | ISOLATED margin — per-position loss cannot drain full account | aster_readonly_client.py → place_bracket() | | reduceOnly=true on SL/TP — closing orders never open new positions | aster_readonly_client.py → place_order() | | halt=true blocks all execution | autonomous_runner.py, trade_loop.py | | circuit_breaker=true blocks all execution | autonomous_runner.py | | Consecutive errors ≥ 5 auto-trips circuit breaker | autonomous_runner.py | | Learning cannot raise leverage above max_leverage | update_metrics.py | | autonomous_live_consent cannot be set by agent self-action | onboarding.py consent gate only |

Emergency controls

Trigger phrases (say to OpenClaw agent)

halt moneysharks      stop trading       kill switch
emergency stop        cancel all orders  flatten all positions
switch to paper mode  disable cron

Halt sequence (automatic on any trigger phrase)

Set state.json → halt=true, circuit_breaker=true
Cancel all open orders for each allowed symbol (if execution.cancel_on_halt=true — default)
Close all positions (only if --flatten flag or execution.flatten_on_emergency_stop=true)
Journal a halt_event entry in trades.json
Announce: "MoneySharks halted. Cycles stopped. Orders cancelled. Positions: [status]. Say 'resume moneysharks' to restart in paper mode."

CLI:

python3 scripts/halt.py config.json --cancel-orders [--flatten] [--reason "text"]

Resume sequence

python3 scripts/resume.py config.json --mode paper       # safe default
python3 scripts/resume.py config.json --mode autonomous_live   # requires consent in config

Clear halt=false, circuit_breaker=false, consecutive_errors=0
Update config.json mode if changed
Fetch live account reconciliation from Aster
Journal resume_event
Run first cycle if --run-now

Resuming into autonomous_live requires autonomous_live_consent=true already in config.json. It cannot be set by the resume script — only by onboarding ACCEPT.

Circuit breaker

Auto-trips when consecutive_errors >= 5
Any successful cycle resets the counter to 0
Clear via resume.py or by editing state.json

Cron jobs (24/7 autonomous operation)

All defined in openclaw-cron-templates.json. Paths auto-substituted by register_crons.py.
Registered automatically by the agent at the end of onboarding (on ACCEPT).

| Job | Schedule | What it runs | Delivery | |---|---|---|---| | moneysharks-autonomous-live-scan | every 2 min | autonomous_runner.py config.json | none (silent) | | moneysharks-post-trade-review | every 30 min | fetch_trade_outcomes.py + review_trades.py | none (silent) | | moneysharks-daily-summary | 00:00 UTC daily | status.py + review_trades.py → full day summary | announce | | moneysharks-halt-check | every 15 min | status.py --json → alert if halt/CB/errors/daily loss approaching | announce (only on problem) |

In paper mode: autonomous_live_scan and autonomous_review are replaced by:

moneysharks-paper-market-scan (every 5 min)
moneysharks-paper-review-cycle (every 30 min)

Status and monitoring

python3 scripts/status.py config.json          # human-readable
python3 scripts/status.py config.json --json   # machine-readable JSON

Shows: mode, halt, circuit breaker, consecutive errors, daily loss %, last cycle age, credentials, equity, available margin, today PnL, open positions with uPnL, win rate, avg PnL, total PnL, adaptive metrics, active lessons, config summary.

Key data files

`state.json` structure

{
  "halt": false,
  "circuit_breaker": false,
  "consecutive_errors": 0,
  "daily_loss": 0.0,
  "last_run": "2026-03-17T22:00:00Z",
  "account": { "equity": 1250.50, "available_margin": 900.00 },
  "known_open_positions": {
    "BTCUSDT": {
      "side": "BUY", "quantity": 0.00588, "entry_price": 85000.0,
      "leverage": 10, "stop_loss": 84000.0, "take_profit": 87000.0,
      "opened_at": "2026-03-17T21:15:00Z"
    }
  },
  "last_close_ts": { "ETHUSDT": "2026-03-17T20:30:00Z" },
  "metrics": {
    "win_rate": 0.6667, "avg_pnl": 18.03, "total_pnl": 54.10,
    "confidence_multiplier": 1.0, "effective_leverage_cap": 10.0,
    "recommended_min_confidence": 0.55, "leverage_reduction_active": false,
    "lessons": []
  }
}

`trades.json` entry structure (executed trade)

{
  "ts": "2026-03-17T21:15:23Z",
  "symbol": "BTCUSDT",
  "mode": "autonomous_live",
  "decision": "long",
  "signal": "long",
  "signal_reason": "4H_trend_up, 1H_trend_up, RSI_long_zone:56.0, MACD_bullish",
  "confidence": 0.89,
  "adjusted_confidence": 0.89,
  "regime": "trending_up",
  "confluence": { "passed": [...], "failed": [], "count": 9, "total": 9, "confidence": 1.0 },
  "order": {
    "entry_price": 85000.0, "stop_loss": 84412.0, "take_profit": 86980.0,
    "leverage": 10, "quantity": 0.00588, "notional": 499.80, "side": "BUY"
  },
  "exec_result": { "ok": true, "status": "EXECUTED", "order_result": { ... } },
  "status": "live_executed",
  "market": { "last_price": 85000.0, "mark_price": 85010.0, "funding_rate": -0.0001 },
  "features_1h": { "rsi14": 56.0, "ema20": 84800.0, "atr14": 392.0, "trend": "up" },
  "outcome": "win",
  "realised_pnl": 31.20,
  "close_reason": "take_profit_hit",
  "closed_at": "2026-03-17T23:44:00Z",
  "lesson_tags": ["target-hit", "uptrend", "trending_up"]
}

Quick reference: when something goes wrong

| Symptom | Likely cause | Fix | |---|---|---| | No trades being placed | Confidence below threshold, or wait signal | Check status.py, review recent journal entries | | Circuit breaker active | ≥5 consecutive API errors | resume.py --mode paper, investigate logs | | Daily loss limit hit | Too many losses today | Waits for UTC midnight to reset, or lower max_daily_loss | | Halt active | Manual or automatic halt | resume.py config.json --mode paper | | Credential error | ASTER_API_KEY/ASTER_API_SECRET not set | Set env vars, re-run install.sh to verify | | Trades have no outcome | fetch_trade_outcomes.py hasn't run yet | Run manually or wait for next 30-min review cron | | Leverage too high in learning | Loss streak triggered effective_leverage_cap reduction | Wait for recovery, or reset metrics in state.json |

For full operational runbook, see documentation-moneysharks.md § 16.

MoneySharks

MoneySharks

Core rules

Modes

Files in this skill

Core skill file

Documentation

References (read when needed)

Scripts — live trading core (29 scripts total)

Entry point

Per-symbol execution loop

Market data and feature computation

Sizing and risk

Execution

Position lifecycle management

Learning pipeline

Setup and operations

Approval / proposal mode helpers

Config and data files

Setup

Deployment

Workflow

Per-cycle execution (called by cron every 2 min)

Onboarding flow

Post-ACCEPT: register cron jobs (agent executes these steps)

Onboarding requirements

Signal generation summary

Confluence scoring (9-point system)

Learning system summary

Hard safety rules (always enforced, cannot be bypassed)

Emergency controls

Trigger phrases (say to OpenClaw agent)

Halt sequence (automatic on any trigger phrase)

Resume sequence

Circuit breaker

Cron jobs (24/7 autonomous operation)

Status and monitoring

Key data files

state.json structure

trades.json entry structure (executed trade)

Quick reference: when something goes wrong

`state.json` structure

`trades.json` entry structure (executed trade)