dexterm-cli 0.1.7 → 0.2.0

package/dist/packages/agents/src/spectator.js

@@ -20,7 +20,9 @@ const ADDR_RE = new RegExp(`${BASE58}{32,44}`, 'g');
 const LONG_B58_RE = new RegExp(`${BASE58}{45,}`, 'g');
 /** A hex run of ≥64 chars is a 32-byte key / signature. */
 const HEX_KEY_RE = /\b[0-9a-fA-F]{64,}\b/g;
-export const SENSITIVE_KEY_RE = /(secret|private|privkey|mnemonic|seed|passphrase|password|signature|sig|apikey|api[_-]?key|keypair|token)/i;
+// task-1645: real mode's trade-fire signals and receipts stay out of shared views (`sig` already covers signal,
+// signalId and txSig; receipt, nonce and trade_fire are added).
+export const SENSITIVE_KEY_RE = /(secret|private|privkey|mnemonic|seed|passphrase|password|signature|sig|apikey|api[_-]?key|keypair|token|receipt|nonce|trade[_-]?fire)/i;
 /** Mask one address the way the product's shortAddr does (head4…tail4). */
 export function maskAddress(s) {
     return s.length <= 10 ? s : `${s.slice(0, 4)}…${s.slice(-4)}`;

package/dist/packages/agents/src/tiers.js

@@ -76,6 +76,9 @@ export const TOOL_TIERS = Object.freeze({
     telegram_status: 'observe',
     trading_status: 'observe',
     backtest_requests: 'observe',
+    // THE JOURNEY (task-1647): a strategy's ladder and a forward test's report vs its backtest
+    strategy_journey: 'observe',
+    strategy_forward_report: 'observe',
     subscribe: 'observe',
     unsubscribe: 'observe',
     // ---- annotate: non-financial navigation + agent-owned annotations
@@ -93,6 +96,12 @@ export const TOOL_TIERS = Object.freeze({
     strategy_propose_new: 'propose',
     // a backtest REQUEST (task-1530): a file the user runs or dismisses with `dexterm autotrade requests`
     backtest_request: 'propose',
+    // THE JOURNEY (task-1647): a paper forward test (the strategy's own bankroll, a bounded window, never real) and a
+    // promotion PROPOSAL the user applies (always-on: a key; real: their own caps + a typed phrase on their terminal).
+    // Vetted by hand: "promote" is on the never-list for agent tiers; this one only writes a proposal file.
+    strategy_forward_start: 'propose',
+    strategy_forward_stop: 'propose',
+    strategy_promote_propose: 'propose',
 });
 /** Tools that are proposals (write-shaped): they need an idempotency key and count against the proposal quota. */
 export const PROPOSAL_TOOLS = new Set(['propose_alert', 'propose_order_plan', 'add_to_watchlist']);

package/dist/packages/agents/src/tools.js

@@ -50,16 +50,18 @@ const TOOLS_DEF = [
     { name: 'strategy_validate', tier: 'observe', description: 'AUTOTRADE (paper): validate a whole dexterm-strategy/1 document ({ok, errors, warnings}). Saves nothing.', inputSchema: { type: 'object', properties: { doc: { free: true } }, required: ['doc'], additionalProperties: false } },
     { name: 'strategy_backtest', tier: 'observe', description: 'AUTOTRADE (paper): backtest a strategy or a pending proposal on recorded history (days <= 14). Read-only, one at a time, rate-limited.', inputSchema: { type: 'object', properties: { id: STRATEGY, proposalId: { type: 'string', maxLength: 40 }, tape: { type: 'string', enum: ['recorded'] }, days: { type: 'integer', minimum: 1, maximum: 14 } }, additionalProperties: false } },
     { name: 'autotrade_status', tier: 'observe', description: 'AUTOTRADE (paper): the paper runner\'s status, the strategy count and the proposals waiting for the user.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
-    { name: 'ledger_trades', tier: 'observe', description: 'TRADE LEDGER: trades from the unified ledger (paper, the agent paper desk, autotrade runs, the live signer), newest first: strategy id+version+hash, profile + entry reason and where each came from, exit reason, size and % of book, entry/exit price and market cap, fees, impact, hold, MFE/MAE, rug flag, wallet mode, tx signatures, model session ids and cost. PAPER rows are simulated.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 }, status: { type: 'string', enum: ['open', 'closed'] }, limit: { type: 'integer', minimum: 1, maximum: 200 }, fills: { type: 'boolean' } }, additionalProperties: false } },
-    { name: 'ledger_positions', tier: 'observe', description: 'TRADE LEDGER: the open trades (cost, % of book, held time, profile). No price fetch, no balance.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 }, limit: { type: 'integer', minimum: 1, maximum: 200 } }, additionalProperties: false } },
-    { name: 'ledger_equity', tier: 'observe', description: 'TRADE LEDGER: the realized equity curve and its max drawdown (at most 200 points).', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 } }, additionalProperties: false } },
-    { name: 'ledger_summary', tier: 'observe', description: 'TRADE LEDGER: win rate with its 95% interval, P/L, drawdown, rug rate, hold, MFE/MAE, declared-tag coverage, and breakdowns by profile, exit reason, strategy, source and mode.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 } }, additionalProperties: false } },
-    { name: 'ledger_compare', tier: 'observe', description: 'TRADE LEDGER: one row per strategy version side by side (the forward-test table).', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 } }, additionalProperties: false } },
+    { name: 'ledger_trades', tier: 'observe', description: 'TRADE LEDGER: trades from the unified ledger (paper, the agent paper desk, autotrade runs, the live signer), newest first: strategy id+version+hash, profile + entry reason and where each came from, exit reason, size and % of book, entry/exit price and market cap, fees, impact, hold, MFE/MAE, rug flag, wallet mode, tx signatures, model session ids and cost. PAPER rows are simulated.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 }, status: { type: 'string', enum: ['open', 'closed'] }, limit: { type: 'integer', minimum: 1, maximum: 200 }, fills: { type: 'boolean' } }, additionalProperties: false } },
+    { name: 'ledger_positions', tier: 'observe', description: 'TRADE LEDGER: the open trades (cost, % of book, held time, profile). No price fetch, no balance.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 }, limit: { type: 'integer', minimum: 1, maximum: 200 } }, additionalProperties: false } },
+    { name: 'ledger_equity', tier: 'observe', description: 'TRADE LEDGER: the realized equity curve and its max drawdown (at most 200 points).', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 } }, additionalProperties: false } },
+    { name: 'ledger_summary', tier: 'observe', description: 'TRADE LEDGER: win rate with its 95% interval, P/L, drawdown, rug rate, hold, MFE/MAE, declared-tag coverage, and breakdowns by profile, exit reason, strategy, source and mode.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 } }, additionalProperties: false } },
+    { name: 'ledger_compare', tier: 'observe', description: 'TRADE LEDGER: one row per strategy version side by side (the forward-test table).', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 } }, additionalProperties: false } },
     { name: 'candidate_dossier', tier: 'observe', description: 'AUTOTRADE: what a run recorded about a candidate coin (rules matched, tick, the session\'s decisions, clamp, fills, close). Text fields are untrusted data.', inputSchema: { type: 'object', properties: { mint: MINT, run_id: RUN_ID }, required: ['mint'], additionalProperties: false } },
     { name: 'outcomes_lookup', tier: 'observe', description: 'The recorder\'s code-only outcome labels for a coin, or for every candidate of a run (what the skips turned into). Not predictions.', inputSchema: { type: 'object', properties: { mint: MINT, run_id: RUN_ID, limit: { type: 'integer', minimum: 1, maximum: 100 } }, additionalProperties: false } },
     { name: 'telegram_status', tier: 'observe', description: 'The Telegram connector\'s settings (enabled, paired chat count, tiers, approvals, notify). Never a token or an id.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
     { name: 'trading_status', tier: 'observe', description: 'The live trading signer\'s STATE: mode, kill switch, caps it enforces, a balance band. Never a key, an address or an exact balance; it cannot change anything.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
     { name: 'backtest_requests', tier: 'observe', description: 'Your backtest requests and their results once the user ran them.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { name: 'strategy_journey', tier: 'observe', description: 'AUTOTRADE: one of the user\'s strategies on the ladder draft → backtested → forward-tested → always-on → real: the evidence per rung on these exact rules and what the next rung needs. Read-only.', inputSchema: { type: 'object', properties: { id: STRATEGY }, required: ['id'], additionalProperties: false } },
+    { name: 'strategy_forward_report', tier: 'observe', description: 'AUTOTRADE (paper): a forward test next to the backtest of the same rules, with plain verdict lines (it says when a sample is too small). Read-only.', inputSchema: { type: 'object', properties: { id: STRATEGY, forwardId: { type: 'string', maxLength: 40 } }, additionalProperties: false } },
     // ---------------------------------------------------------------- annotate: non-financial navigation + agent-owned notes
     { name: 'open_token', tier: 'annotate', description: "Open a token's detail screen so the user can see it. `mint` must be one of the mints currently on screen (see screen_state). Non-financial navigation; it never trades.", inputSchema: { type: 'object', properties: { mint: MINT }, required: ['mint'], additionalProperties: false } },
     { name: 'show_in_screener', tier: 'annotate', description: "Show the screener with an optional filter / sort / highlighted mint. `filter` is dexterm's grammar; `highlight` must be a mint on screen.", inputSchema: { type: 'object', properties: { filter: { type: 'string', maxLength: 200 }, sort: { type: 'object', properties: { key: { type: 'string', maxLength: 24 }, dir: { type: 'string', enum: ['asc', 'desc'] } }, required: ['key'], additionalProperties: false }, highlight: MINT }, additionalProperties: false } },
@@ -71,6 +73,9 @@ const TOOLS_DEF = [
     { name: 'strategy_propose_edit', tier: 'propose', description: 'AUTOTRADE (paper): PROPOSE JSON-patch ops (<= 20) on one of the user\'s strategies, with a why. Returns the diff, validation and riskDelta. Never applied by you: the user applies it with a key on the Q screen (a looser edit needs a second key). /mode, /bankroll, /agent/budgetUsdPerDay and /execution/minExitLiquidityUsd are user-only.', inputSchema: { type: 'object', properties: { id: STRATEGY, ops: PATCH_OPS, why: { type: 'string', maxLength: 200 } }, required: ['id', 'ops', 'why'], additionalProperties: false } },
     { name: 'strategy_propose_new', tier: 'propose', description: 'AUTOTRADE (paper): PROPOSE a new paper strategy copied from a preset under a new id and name, with optional ops (<= 20). Never applied by you; the user confirms it with a key.', inputSchema: { type: 'object', properties: { fromPreset: STRATEGY, id: STRATEGY, name: { type: 'string', maxLength: 80 }, ops: PATCH_OPS, why: { type: 'string', maxLength: 200 } }, required: ['fromPreset', 'id', 'name'], additionalProperties: false } },
     { name: 'backtest_request', tier: 'propose', description: 'PROPOSE a longer backtest (a stored strategy id, 1 to 60 days, optionally every candidate) with a why. The user runs or dismisses it with `dexterm autotrade requests`; nothing runs here.', inputSchema: { type: 'object', properties: { id: STRATEGY, days: { type: 'integer', minimum: 1, maximum: 60 }, every_candidate: { type: 'boolean' }, why: { type: 'string', maxLength: 200 } }, required: ['id', 'why'], additionalProperties: false } },
+    { name: 'strategy_forward_start', tier: 'propose', description: 'AUTOTRADE (paper): start a forward test of one of the user\'s strategies on live data, on paper, with its own bankroll, for hours (0.25-72) and/or closed trades (1-200). Needs a backtest first. Never real; cannot set a bankroll or a cap.', inputSchema: { type: 'object', properties: { id: STRATEGY, hours: { type: 'number', minimum: 0.25, maximum: 72 }, trades: { type: 'integer', minimum: 1, maximum: 200 } }, required: ['id'], additionalProperties: false } },
+    { name: 'strategy_forward_stop', tier: 'propose', description: 'AUTOTRADE (paper): stop a running forward test (it flattens and writes its report; an early stop does not count).', inputSchema: { type: 'object', properties: { id: STRATEGY, forwardId: { type: 'string', maxLength: 40 } }, additionalProperties: false } },
+    { name: 'strategy_promote_propose', tier: 'propose', description: 'AUTOTRADE: PROPOSE promoting a strategy one rung (always-on or real) with an evidence card. Never applied by you and no rung can be skipped: the user applies always-on with a key, real only above their evidence floor (a completed forward test with their minimum of closed paper trades + a backtest), with their own caps and a typed phrase on their terminal.', inputSchema: { type: 'object', properties: { id: STRATEGY, to: { type: 'string', enum: ['always-on', 'real'] }, why: { type: 'string', maxLength: 200 } }, required: ['id', 'to', 'why'], additionalProperties: false } },
     { name: 'add_to_watchlist', tier: 'propose', description: "Propose adding a token to the user's watchlist. Appears as a PROPOSAL labelled with this agent. Needs idempotency_key.", inputSchema: { type: 'object', properties: { mint: MINT, note: { type: 'string', maxLength: 200 }, idempotency_key: IDEMPOTENCY }, required: ['mint', 'idempotency_key'], additionalProperties: false } },
 ];
 /** task-1537: the read tools whose results carry prices also carry market-cap twins; their descriptions say so + the basis. */

package/dist/packages/autotrade/assets/limits.schema.json

@@ -0,0 +1,569 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://dexterm.xyz/schemas/limits.schema.json",
+  "title": "dexterm-limits/1",
+  "description": "dexterm real-mode limits: $DEXTERM_HOME/autotrade/real/limits.json. A number in global replaces the placeholder default (null turns it off); every other scope can only tighten (the stricter number wins). Only `dexterm autotrade limits` writes it; raising needs a typed confirmation on a real terminal.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema"
+  ],
+  "properties": {
+    "schema": {
+      "const": "dexterm-limits/1"
+    },
+    "global": {
+      "$ref": "#/$defs/globalSet"
+    },
+    "modes": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "real": {
+          "$ref": "#/$defs/set"
+        },
+        "paper": {
+          "$ref": "#/$defs/set"
+        }
+      }
+    },
+    "strategies": {
+      "type": "object",
+      "propertyNames": {
+        "pattern": "^[a-z0-9][a-z0-9._-]{0,63}$"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/set"
+      }
+    },
+    "accounts": {
+      "type": "object",
+      "propertyNames": {
+        "pattern": "^[a-z0-9][a-z0-9._-]{0,63}$"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/set"
+      }
+    },
+    "updatedAt": {
+      "type": "number"
+    },
+    "migratedFrom": {
+      "type": "string"
+    }
+  },
+  "$defs": {
+    "set": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "perTradeSol": {
+          "type": "number",
+          "minimum": 1e-06,
+          "maximum": 1000000000000,
+          "description": "the most SOL one buy signal may spend (a bigger buy is clamped down to it) (SOL; a cap: smaller is stricter)"
+        },
+        "perTradePct": {
+          "type": "number",
+          "minimum": 0.01,
+          "maximum": 100,
+          "description": "the most one buy may spend as a percent of the book (bookSol, else the strategy book); with perTradeSol set too, the smaller wins (% of book; a cap: smaller is stricter)"
+        },
+        "dailySol": {
+          "type": "number",
+          "minimum": 1e-06,
+          "maximum": 1000000000000,
+          "description": "SOL all buy signals may spend per local day (a buy over it is refused) (SOL/day; a cap: smaller is stricter)"
+        },
+        "buysPerDay": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 1000000,
+          "description": "buy signals per local day (0 = no buys) (buys/day; a cap: smaller is stricter)"
+        },
+        "maxOpenPositions": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 100000,
+          "description": "real positions open at once, across every strategy and account on this home (open; a cap: smaller is stricter)"
+        },
+        "maxExposurePct": {
+          "type": "number",
+          "minimum": 0.01,
+          "maximum": 100,
+          "description": "the cost of every open real position together, as a percent of the book (a buy is clamped to what is left) (% of book; a cap: smaller is stricter)"
+        },
+        "minPositionSol": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1000000000000,
+          "description": "a buy smaller than this after every clamp is refused (no dust orders) (SOL; a floor: larger is stricter)"
+        },
+        "maxPositionSol": {
+          "type": "number",
+          "minimum": 1e-06,
+          "maximum": 1000000000000,
+          "description": "the most SOL one position may cost, adds included (a buy is clamped to what is left) (SOL; a cap: smaller is stricter)"
+        },
+        "perCoinSolPerDay": {
+          "type": "number",
+          "minimum": 1e-06,
+          "maximum": 1000000000000,
+          "description": "SOL spent on one coin per local day, re-entries included (a buy over it is refused) (SOL/day; a cap: smaller is stricter)"
+        },
+        "perCoinBuysPerDay": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 100000,
+          "description": "buy signals on one coin per local day (buys/day; a cap: smaller is stricter)"
+        },
+        "bookSol": {
+          "type": "number",
+          "minimum": 1e-06,
+          "maximum": 1000000000000,
+          "description": "what the percent limits are a percent of: the size of YOUR account (unset = the strategy's own book) (SOL; a cap: smaller is stricter)"
+        },
+        "dailyLossSol": {
+          "type": "number",
+          "minimum": 1e-06,
+          "maximum": 1000000000000,
+          "description": "when the day's realized loss reaches this, no new buy goes out until the next local day (exits still do) (SOL/day; a cap: smaller is stricter)"
+        },
+        "maxDrawdownSol": {
+          "type": "number",
+          "minimum": 1e-06,
+          "maximum": 1000000000000,
+          "description": "the drawdown breaker: realized PnL this far below its peak trips it; no new buy until you reset it (typed) (SOL; a cap: smaller is stricter)"
+        },
+        "lossStreak": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 10000,
+          "description": "this many losing closes in a row pause new buys for lossStreakPauseMin (losses; a cap: smaller is stricter)"
+        },
+        "lossStreakPauseMin": {
+          "type": "number",
+          "minimum": 1,
+          "maximum": 525600,
+          "description": "how long the loss-streak pause lasts (min; a floor: larger is stricter)"
+        },
+        "maxHoldMinutes": {
+          "type": "number",
+          "minimum": 1,
+          "maximum": 525600,
+          "description": "a real position held this long gets its exit signal (the stricter of this and the exit profile's own cap) (min; a cap: smaller is stricter)"
+        },
+        "minLiquidityUsd": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1000000000000,
+          "description": "no buy on a coin with less pool liquidity (unknown liquidity is refused while this is set) (USD; a floor: larger is stricter)"
+        },
+        "minMcapUsd": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1000000000000,
+          "description": "no buy on a coin below this market cap (unknown is refused while this is set) (USD; a floor: larger is stricter)"
+        },
+        "maxSlippageBps": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 10000,
+          "description": "the slippage tolerance a signal states (the stricter of this and the strategy's) (bps; a cap: smaller is stricter)"
+        },
+        "maxPriceImpactPct": {
+          "type": "number",
+          "minimum": 0.01,
+          "maximum": 100,
+          "description": "the price impact a buy may have on the pool (constant-product estimate): a buy is clamped to it; the signal states it (%; a cap: smaller is stricter)"
+        },
+        "signalTtlSec": {
+          "type": "integer",
+          "minimum": 10,
+          "maximum": 600,
+          "description": "how long an executor may act on a signal (the stricter of this and the channel setting) (s; a cap: smaller is stricter)"
+        },
+        "maxBuysPerMinute": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 10000,
+          "description": "the signal rate limit: buy signals in any 60 s (buys/min; a cap: smaller is stricter)"
+        },
+        "maxSellsPerMinute": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 10000,
+          "description": "OPTIONAL: sells are never capped unless you set this; a sell over it waits for the next tick (sells/min; a cap: smaller is stricter)"
+        },
+        "minForwardTrades": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 100000,
+          "description": "the evidence floor for real: arming needs a COMPLETED forward test of these exact rules with at least this many closed paper trades, and a backtest on record (below it only a typed override on your own terminal arms, journaled) (trades; a floor: larger is stricter)"
+        },
+        "executorSilenceMin": {
+          "type": "number",
+          "minimum": 1,
+          "maximum": 525600,
+          "description": "no heartbeat, receipt or ack from your executor for this long pauses new buy signals (exits still go out) (min; a cap: smaller is stricter)"
+        }
+      }
+    },
+    "globalSet": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "perTradeSol": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1e-06,
+              "maximum": 1000000000000,
+              "description": "the most SOL one buy signal may spend (a bigger buy is clamped down to it) (SOL; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "perTradePct": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 0.01,
+              "maximum": 100,
+              "description": "the most one buy may spend as a percent of the book (bookSol, else the strategy book); with perTradeSol set too, the smaller wins (% of book; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "dailySol": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1e-06,
+              "maximum": 1000000000000,
+              "description": "SOL all buy signals may spend per local day (a buy over it is refused) (SOL/day; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "buysPerDay": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 1000000,
+              "description": "buy signals per local day (0 = no buys) (buys/day; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "maxOpenPositions": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 100000,
+              "description": "real positions open at once, across every strategy and account on this home (open; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "maxExposurePct": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 0.01,
+              "maximum": 100,
+              "description": "the cost of every open real position together, as a percent of the book (a buy is clamped to what is left) (% of book; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "minPositionSol": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1000000000000,
+              "description": "a buy smaller than this after every clamp is refused (no dust orders) (SOL; a floor: larger is stricter)"
+            }
+          ]
+        },
+        "maxPositionSol": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1e-06,
+              "maximum": 1000000000000,
+              "description": "the most SOL one position may cost, adds included (a buy is clamped to what is left) (SOL; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "perCoinSolPerDay": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1e-06,
+              "maximum": 1000000000000,
+              "description": "SOL spent on one coin per local day, re-entries included (a buy over it is refused) (SOL/day; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "perCoinBuysPerDay": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 100000,
+              "description": "buy signals on one coin per local day (buys/day; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "bookSol": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1e-06,
+              "maximum": 1000000000000,
+              "description": "what the percent limits are a percent of: the size of YOUR account (unset = the strategy's own book) (SOL; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "dailyLossSol": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1e-06,
+              "maximum": 1000000000000,
+              "description": "when the day's realized loss reaches this, no new buy goes out until the next local day (exits still do) (SOL/day; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "maxDrawdownSol": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1e-06,
+              "maximum": 1000000000000,
+              "description": "the drawdown breaker: realized PnL this far below its peak trips it; no new buy until you reset it (typed) (SOL; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "lossStreak": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 10000,
+              "description": "this many losing closes in a row pause new buys for lossStreakPauseMin (losses; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "lossStreakPauseMin": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1,
+              "maximum": 525600,
+              "description": "how long the loss-streak pause lasts (min; a floor: larger is stricter)"
+            }
+          ]
+        },
+        "maxHoldMinutes": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1,
+              "maximum": 525600,
+              "description": "a real position held this long gets its exit signal (the stricter of this and the exit profile's own cap) (min; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "minLiquidityUsd": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1000000000000,
+              "description": "no buy on a coin with less pool liquidity (unknown liquidity is refused while this is set) (USD; a floor: larger is stricter)"
+            }
+          ]
+        },
+        "minMcapUsd": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1000000000000,
+              "description": "no buy on a coin below this market cap (unknown is refused while this is set) (USD; a floor: larger is stricter)"
+            }
+          ]
+        },
+        "maxSlippageBps": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 10000,
+              "description": "the slippage tolerance a signal states (the stricter of this and the strategy's) (bps; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "maxPriceImpactPct": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 0.01,
+              "maximum": 100,
+              "description": "the price impact a buy may have on the pool (constant-product estimate): a buy is clamped to it; the signal states it (%; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "signalTtlSec": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "integer",
+              "minimum": 10,
+              "maximum": 600,
+              "description": "how long an executor may act on a signal (the stricter of this and the channel setting) (s; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "maxBuysPerMinute": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 10000,
+              "description": "the signal rate limit: buy signals in any 60 s (buys/min; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "maxSellsPerMinute": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 10000,
+              "description": "OPTIONAL: sells are never capped unless you set this; a sell over it waits for the next tick (sells/min; a cap: smaller is stricter)"
+            }
+          ]
+        },
+        "minForwardTrades": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 100000,
+              "description": "the evidence floor for real: arming needs a COMPLETED forward test of these exact rules with at least this many closed paper trades, and a backtest on record (below it only a typed override on your own terminal arms, journaled) (trades; a floor: larger is stricter)"
+            }
+          ]
+        },
+        "executorSilenceMin": {
+          "oneOf": [
+            {
+              "type": "null",
+              "description": "off: this limit does not apply"
+            },
+            {
+              "type": "number",
+              "minimum": 1,
+              "maximum": 525600,
+              "description": "no heartbeat, receipt or ack from your executor for this long pauses new buy signals (exits still go out) (min; a cap: smaller is stricter)"
+            }
+          ]
+        }
+      }
+    }
+  }
+}