@battlegrid/mcp-server 32.0.99 → 32.0.103
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +31 -0
- package/dist/index.d.ts +1 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +1 -1
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
- package/skills/EXPORT.json +14 -14
- package/skills/battlegrid-agent-management/SKILL.md +79 -59
- package/skills/battlegrid-arena-play/SKILL.md +50 -28
- package/skills/battlegrid-officers/SKILL.md +17 -12
- package/skills/battlegrid-onboarding/SKILL.md +12 -10
- package/skills/battlegrid-radar-deployment/SKILL.md +112 -69
- package/skills/battlegrid-radar-deployment/references/arena-stage-examples.md +41 -1
- package/skills/battlegrid-radar-deployment/references/radar-stage-examples.md +49 -10
- package/skills/battlegrid-strategy-authoring/SKILL.md +72 -59
- package/skills/battlegrid-strategy-doctor/SKILL.md +20 -25
- package/skills/battlegrid-strategy-examples/SKILL.md +65 -35
- package/skills/battlegrid-strategy-examples/references/playbooks.md +1 -1
- package/skills/battlegrid-trade-analysis/SKILL.md +5 -1
- package/skills/battlegrid-trade-proposal/SKILL.md +6 -4
|
@@ -24,7 +24,7 @@ needs no deployment. An Arena deployment enters an agent into a preset's session
|
|
|
24
24
|
**A Radar deployment is one team's watch on one coin.** Each team trades on its own wallet, so a coin
|
|
25
25
|
may be deployed once per team: Main's BTC and Swing's BTC are two deployments that sweep, fire, cool
|
|
26
26
|
down and hold positions independently — one position per team per coin. Every Radar tool names the
|
|
27
|
-
deployment with `
|
|
27
|
+
deployment with the coin's `coinTicker` **and** `teamId`; a `teamId` you omit addresses the player's **Main** team, so
|
|
28
28
|
on a coin deployed for another team always pass that team. `list_radar_deployments` rows carry each
|
|
29
29
|
deployment's `teamId` and `teamName`. The draft commit always names its team.
|
|
30
30
|
|
|
@@ -51,24 +51,29 @@ deployment's `teamId` and `teamName`. The draft commit always names its team.
|
|
|
51
51
|
|
|
52
52
|
### 1. Resolve the target, then read current state
|
|
53
53
|
|
|
54
|
-
**Radar
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
54
|
+
**Radar names a coin by the player's ticker, as `coinTicker`.** Pass the ticker or exchange symbol the
|
|
55
|
+
player said (`SOL`, `AAPL`, `kPEPE`), in any case; the server resolves it to the coin, so no coin-metadata
|
|
56
|
+
read is needed to find a radar coin. A coin the server cannot resolve is refused naming `coinTicker`: ask
|
|
57
|
+
the player which coin they mean. Every radar read serves the coin's `coinTicker` beside its `coinId`; pass
|
|
58
|
+
the `coinTicker` back. **Spell the coin the same way on every call of one flow** — above all on the draft
|
|
59
|
+
read and the commit, which the player's approval card pairs by that spelling: a commit spelled otherwise
|
|
60
|
+
still commits the draft, but its card shows no read to review.
|
|
58
61
|
|
|
59
62
|
Arena deployment is keyed on `presetId` (a UUID) — from `list_game_presets`.
|
|
60
63
|
|
|
61
64
|
Then read what exists:
|
|
62
65
|
|
|
63
|
-
- `get_radar_deployment` (one deployment: `
|
|
66
|
+
- `get_radar_deployment` (one deployment: `coinTicker` and `teamId`) or `list_radar_deployments` (the fleet, plus the platform
|
|
64
67
|
`radarPaused` kill-switch — if that is set, say so up front: nothing will fire whatever you
|
|
65
68
|
write). A `SCANNING` card whose reason is `ENTRIES_PAUSED` is the platform's **entry pause**: new
|
|
66
69
|
entries are paused platform-wide while market data is missing across many coins. Say that up front
|
|
67
70
|
too — the radar takes no new entry on any coin until it lifts, which it does by itself once the
|
|
68
71
|
data is back, and nothing the player changes on a deployment clears it.
|
|
69
72
|
- **For Radar, also read the player's draft of the deployment** with `get_radar_deployment_draft`
|
|
70
|
-
(`
|
|
71
|
-
its rows names its `teamId` and `
|
|
73
|
+
(`coinTicker` and `teamId`) — or `list_radar_deployment_drafts` when no deployment is named yet; each of
|
|
74
|
+
its rows names its `teamId`, `coinId` and `coinTicker`. A row whose `coinTicker` is null is a draft of a
|
|
75
|
+
coin removed from the catalog: it cannot be named here, and the player discards it from the radar
|
|
76
|
+
landing. The player may be part-way through a
|
|
72
77
|
change in their radar builder. **If a draft exists, say so** — what it holds, and when and from
|
|
73
78
|
where it was last written — and propose against it rather than starting over beside it.
|
|
74
79
|
- `get_deployment_policy` / `list_deployment_policies` for Arena, and **the player's draft of the
|
|
@@ -81,12 +86,13 @@ Then read what exists:
|
|
|
81
86
|
If the question is *why did my radar agent not fire*, do not start from the journal — **go to step
|
|
82
87
|
5**, which reads state first and pattern second.
|
|
83
88
|
|
|
84
|
-
**In a conversation the radar builder hosts** — your context names the radar builder, a team and a coin
|
|
85
|
-
|
|
86
|
-
yet. Stage every change into that deployment's draft, naming that `
|
|
87
|
-
in their builder as a proposal.
|
|
88
|
-
|
|
89
|
-
|
|
89
|
+
**In a conversation the radar builder hosts** — your context names the radar builder, a team and a coin's
|
|
90
|
+
ticker — the player's builder is open on that team's deployment of the coin whether or not a draft exists
|
|
91
|
+
yet. Stage every change into that deployment's draft, naming that `coinTicker` and that `teamId`; it lands
|
|
92
|
+
in their builder as a proposal. If your context says no ticker is listed for the coin, nothing can be
|
|
93
|
+
staged for it now: tell the player so. Their own Save
|
|
94
|
+
commits it; you may commit it yourself after the preview this flow requires, on their approval as
|
|
95
|
+
step 3 describes. The builder's state — its rules, the default agent, who is on duty now —
|
|
90
96
|
arrives as the turn's attached scope. An axis their form rewrote after your proposal is their answer:
|
|
91
97
|
propose it again only on their word.
|
|
92
98
|
|
|
@@ -98,13 +104,14 @@ is test-routing a regime. Never carry a fact from a radar conversation into it,
|
|
|
98
104
|
### 2. Stage the change, then preview exactly what would be written
|
|
99
105
|
|
|
100
106
|
**Radar** — the change goes into the player's draft of the deployment, never straight to the policy.
|
|
101
|
-
Name the `
|
|
107
|
+
Name the `coinTicker` and the `teamId` on every call below, spelled the same each time:
|
|
102
108
|
|
|
103
109
|
1. `stage_radar_deployment_draft` with `draftVersion` = the `version` you read (0 when there was
|
|
104
110
|
no draft) and only the axes you are changing, each WHOLE: `RULES` (the complete ordered rule list
|
|
105
111
|
— first is highest priority; every rule that matches is on duty, so priority decides only which
|
|
106
|
-
agent is offered the deployment's one fire on a pass) and `DEFAULT_SLOT`
|
|
107
|
-
when no rule is, or null for none
|
|
112
|
+
agent is offered the deployment's one fire on a pass; always-on rules come last) and `DEFAULT_SLOT`
|
|
113
|
+
(the catch-all, on duty only when no rule is, or null for none — null beside always-on rules). A
|
|
114
|
+
Radar policy has **no timeframe**: each rule's regime
|
|
108
115
|
condition is read at its agent's own regime timeframe, which every slot reports as
|
|
109
116
|
`agentRegimeTimeframe`. Staging writes nothing live and shows the change in the player's builder as
|
|
110
117
|
a proposal. A refusal naming axes means the player changed them after your read: read again and
|
|
@@ -115,8 +122,8 @@ Name the `coinId` and the `teamId` on every call below:
|
|
|
115
122
|
on duty, whether it trades once committed, and for a first deployment the coin cap
|
|
116
123
|
(`admission.coinCapReached` true means the commit will be refused until a deployment is un-deployed;
|
|
117
124
|
a coin deployed for two teams counts twice).
|
|
118
|
-
Do not
|
|
119
|
-
3. `preview_radar_resolution({
|
|
125
|
+
Do not offer to commit a draft whose diagnostics carry an error: stage a fix.
|
|
126
|
+
3. `preview_radar_resolution({ coinTicker, teamId, request: { kind: "DRAFT", draftVersion } })` at the version that
|
|
120
127
|
read returned. It composes the draft over the deployed policy **exactly as the commit will write it**,
|
|
121
128
|
and refuses a draft no longer at that version with `DRAFT_VERSION_MOVED`. Its `ruleCloseCoverage`
|
|
122
129
|
counts, for each hours rule, the closes of its agent's `strategyTimeframe` bar the rule's hours let
|
|
@@ -128,17 +135,26 @@ Name the `coinId` and the `teamId` on every call below:
|
|
|
128
135
|
To try a slot set without touching the draft, preview `{ kind: "SLOTS", slots }` — it resolves
|
|
129
136
|
explicit slots and nothing can commit it.
|
|
130
137
|
|
|
131
|
-
**Shaping a Radar rule.** A rule carries one or two conditions
|
|
132
|
-
|
|
138
|
+
**Shaping a Radar rule.** A rule carries one or two conditions, or `always` alone — never zero
|
|
139
|
+
conditions. A rule with none is refused, and is never read as always-on. Pick the construction from
|
|
140
|
+
what the player asked for:
|
|
133
141
|
|
|
134
142
|
| The player wants the agent on duty… | Construction |
|
|
135
143
|
|---|---|
|
|
136
144
|
| whenever no rule matches | `DEFAULT_SLOT` — on duty only while no rule matches, so on a coin with no rules it is on duty at every instant |
|
|
145
|
+
| always, behind the rules | a rule whose one condition is `always`, after every other rule, with `DEFAULT_SLOT` null |
|
|
137
146
|
| only in named regimes | a rule with a regime condition |
|
|
138
147
|
| in a named regime, standing down while a warning holds | a rule with a regime condition whose `duringWarnings` is `pause` |
|
|
139
148
|
| only in named hours and days | a rule with an hours condition |
|
|
140
149
|
| in named regimes during named hours | a rule with one hours condition and one regime condition |
|
|
141
150
|
|
|
151
|
+
A coin's fallback is either the default slot or always-on rules, never both. The difference is the
|
|
152
|
+
player's choice, so say it when they ask for a backup: the default is on duty only when no rule
|
|
153
|
+
matches; an always-on agent is on duty at every sweep and acts whenever the agents above it do not
|
|
154
|
+
qualify — it still needs its own entry. Several always-on rules back each other up in the order
|
|
155
|
+
listed. An always-on agent trades the coin in every regime, and a team holds one position and one
|
|
156
|
+
cooldown per coin, so its trade can hold the coin's position and cooldown ahead of a rule's agent.
|
|
157
|
+
|
|
142
158
|
A regime condition reads three facts of one reading. `regimes` names the market structures (`bull_trend`,
|
|
143
159
|
`bear_trend`, `bull_range`, `bear_range`); `volatilities` names the volatility levels it runs in, all three meaning no
|
|
144
160
|
volatility constraint; `duringWarnings` says what a warning — a crash, or momentum diverging in a trend — does to it:
|
|
@@ -170,30 +186,40 @@ ask the player which construction they mean, naming the rows that fit — never
|
|
|
170
186
|
choose. Complete stage payloads for every row are in `references/radar-stage-examples.md`.
|
|
171
187
|
|
|
172
188
|
**One agent onto several Radar coins** — when the player wants the same agent on more than one coin,
|
|
173
|
-
always
|
|
174
|
-
on the team the agent trades on (the preview names it; there is no `teamId` to pass).
|
|
175
|
-
|
|
176
|
-
1. `preview_agent_radar_deploy({ agentId, slot,
|
|
177
|
-
`{ kind: "DEFAULT", minConviction }` (
|
|
178
|
-
`{ kind: "RULE", minConviction, conditions }` (one rule, conditions shaped as a staged
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
189
|
+
as the default, always-on, or under one rule. Never stage it coin by coin: one preview and one write
|
|
190
|
+
cover every coin, on the team the agent trades on (the preview names it; there is no `teamId` to pass).
|
|
191
|
+
|
|
192
|
+
1. `preview_agent_radar_deploy({ agentId, slot, coinTickers })`, with `slot` one of
|
|
193
|
+
`{ kind: "DEFAULT", minConviction }` (the coin's default: the agent is on duty only when no rule
|
|
194
|
+
matches), `{ kind: "RULE", minConviction, conditions }` (one rule, conditions shaped as a staged
|
|
195
|
+
rule's), or `{ kind: "RULE", minConviction, conditions: [{ kind: "always" }] }` (always-on: on duty
|
|
196
|
+
at every sweep, behind the coin's other rules), and `coinTickers` the coins by the player's tickers.
|
|
197
|
+
One coin the server cannot resolve refuses the whole preview naming it. It writes nothing. Each coin is `PLACED` with its served `placement`, rule `priority` and
|
|
198
|
+
`enabledAfterCommit`, or `REFUSED` with the reason a Save of that coin would give; `admission` is
|
|
199
|
+
the plan's coin cap for the new coins.
|
|
182
200
|
2. Read every coin's placement — never work it out yourself:
|
|
183
201
|
- `FIRST_DEPLOYMENT`: a new, active deployment holding just this slot;
|
|
184
202
|
- `ADD_DEFAULT`: the coin had no default, so the agent now covers the windows it sat out;
|
|
185
|
-
- `APPEND_RULE`:
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
203
|
+
- `APPEND_RULE`: a rule placed below the coin's other rules and above its always-on agents, which
|
|
204
|
+
each move one priority down; an always-on rule goes last. **While the new rule matches, the
|
|
205
|
+
coin's default is off duty**; name that default by `defaultAgentDisplayName` when it is non-null.
|
|
206
|
+
A coin with a default refuses an always-on spec, and a coin with always-on agents refuses a
|
|
207
|
+
`DEFAULT` spec. An always-on spec the coin already holds for the same agent at the same bar is
|
|
208
|
+
refused as already held, as a repeated regime or hours rule is. A coin refused for "already has a
|
|
209
|
+
default" can still take the agent as a conditional rule: offer that as a second preview, never
|
|
210
|
+
silently — and never swap one fallback kind for the other without the player's word.
|
|
211
|
+
3. State the batch as step 3 says, then one `deploy_agent_to_radar({ agentId, slot, coins })`, on the
|
|
212
|
+
player's approval.
|
|
190
213
|
|
|
191
214
|
**Arena** — the same shape, keyed on `presetId`:
|
|
192
215
|
|
|
193
216
|
1. `stage_deployment_policy_draft` with `draftVersion` = the `version` you read (0 when there was no
|
|
194
217
|
draft) and only the axes you are changing, each WHOLE: `RULES` (the complete ordered rule list —
|
|
195
|
-
first is highest priority; a rule's regime condition names a set
|
|
196
|
-
|
|
218
|
+
first is highest priority; a rule's regime condition names a set; always-on rules come last),
|
|
219
|
+
`DEFAULT_SLOT` (the catch-all, or null for none — null beside always-on rules) and
|
|
220
|
+
`REGIME_ANCHOR` (the anchor override, or null to inherit the arena's). Its `regimeReferenceCoinId` is
|
|
221
|
+
a `coinPoolPreview[].coinId` from `get_deployment_policy` — a coin of this arena's pool, never its
|
|
222
|
+
ticker; a coin outside the pool is refused, and the refusal lists the pool. Pausing is never staged.
|
|
197
223
|
2. `get_deployment_policy_draft` — its `draftVersion`, `committedRevision`, diff, `diagnostics` and
|
|
198
224
|
`impact` (the next session's resolution and whether it will play), exactly as for Radar.
|
|
199
225
|
3. `preview_deployment_resolution({ presetId, request: { kind: "DRAFT", draftVersion } })` at the
|
|
@@ -204,16 +230,25 @@ A draft that would hold no rule and no catch-all is a withdrawal, which a commit
|
|
|
204
230
|
|
|
205
231
|
**Shaping an Arena rule.** A rule needs at least one condition by the time it is committed — a draft
|
|
206
232
|
may hold a rule with none while the player is still choosing, and the draft read's diagnostics flag
|
|
207
|
-
it.
|
|
233
|
+
it. A rule never carries zero conditions once committed, and a rule with none is never read as
|
|
234
|
+
always-on: `always` is spelled out, and is its rule's only condition. Pick the construction from what
|
|
235
|
+
the player asked for:
|
|
208
236
|
|
|
209
237
|
| The player wants the agent to play… | Construction |
|
|
210
238
|
|---|---|
|
|
211
239
|
| whenever no rule matches | `DEFAULT_SLOT` — plays only when no rule wins the session |
|
|
240
|
+
| always, behind the rules | a rule whose one condition is `always`, after every other rule, with `DEFAULT_SLOT` null |
|
|
212
241
|
| only in named regimes | a rule with a regime condition |
|
|
213
242
|
| in a named regime, sitting out while a warning holds | a rule with a regime condition whose `duringWarnings` is `pause` |
|
|
214
243
|
| only at named session starts, or one scheduled occurrence | a rule with one session condition — a start or an occurrence |
|
|
215
244
|
| in named regimes at those sessions | a rule with a regime condition and one session condition |
|
|
216
245
|
|
|
246
|
+
An arena's fallback is either the default slot or always-on rules, never both. The difference is the
|
|
247
|
+
player's choice, so say it when they ask for a backup: the default is on duty only when no rule
|
|
248
|
+
matches; an always-on agent is on duty at every session and plays whenever the agents above it do
|
|
249
|
+
not qualify — it still needs a full admitted grid. Several always-on rules back each other up in the
|
|
250
|
+
order listed.
|
|
251
|
+
|
|
217
252
|
When the ask maps to no single row, or a refusal rules out the construction the player asked for,
|
|
218
253
|
ask the player which construction they mean, naming the rows that fit — never stage one they did not
|
|
219
254
|
choose. Complete stage payloads for every row are in `references/arena-stage-examples.md`.
|
|
@@ -293,9 +328,9 @@ reason is its `UNEVALUATED` entry's `reachReason` in
|
|
|
293
328
|
`readings[].reading.live.reading.conditions.entries[]`, and whether the conditions hold the coin is the
|
|
294
329
|
reading's own conditions gate, `qualification.gates.requiredConditions` — never a verdict of your own.
|
|
295
330
|
|
|
296
|
-
### 3.
|
|
331
|
+
### 3. State the preview, then commit on the player's approval
|
|
297
332
|
|
|
298
|
-
One
|
|
333
|
+
One statement that **references what the preview showed** — the agents it put on duty and
|
|
299
334
|
the reason — and **names what the change does to the stored policy**, read from step 1:
|
|
300
335
|
|
|
301
336
|
- every rule or slot the change **removes** (by agent and priority), because `RULES` and `slots` are
|
|
@@ -303,64 +338,71 @@ the reason — and **names what the change does to the stored policy**, read fro
|
|
|
303
338
|
- a bar, window or regime that **changes** on a rule or slot that survives;
|
|
304
339
|
- whether it will play once committed, from `enabledAfterCommit` — a commit never changes a pause.
|
|
305
340
|
|
|
306
|
-
Then
|
|
341
|
+
Then make the call, **only on the player's approval**. A client that prompts the player to approve
|
|
342
|
+
tool calls collects it: call right after the statement and ask no separate confirming question — the
|
|
343
|
+
client asks the player, or applies the standing setting they chose, and the call runs only if
|
|
344
|
+
approved. A client that does not asks in its reply and waits for the player's word. Words typed while
|
|
345
|
+
an approval prompt is open are not approval: that call does not run, so answer what they said and
|
|
346
|
+
call again only when they ask. Every commit, resume, delete, withdraw and batch deploy below runs
|
|
347
|
+
under this rule:
|
|
307
348
|
|
|
308
|
-
- **Radar** → `commit_radar_deployment_draft({
|
|
349
|
+
- **Radar** → `commit_radar_deployment_draft({ coinTicker, teamId, draftVersion, expectedRevision })`, spelling the coin
|
|
350
|
+
as the draft read did,
|
|
309
351
|
naming exactly the `teamId`, `draftVersion` and `committedRevision` your draft read returned — the
|
|
310
|
-
version your preview resolved.
|
|
311
|
-
pick. The axes it published leave the draft.
|
|
352
|
+
version your preview resolved. The axes it published leave the draft.
|
|
312
353
|
`teamId` is **required** and never inferred: the commit writes that team's deployment of the coin
|
|
313
354
|
and nothing else. For a deployed one, pass the `teamId` its `list_radar_deployments` (or
|
|
314
355
|
`get_radar_deployment`) row carries. For a first deployment, choose one of the player's teams from
|
|
315
356
|
`get_account_state.teams` (ask when there is more than one), stage and read the draft under it, and
|
|
316
|
-
name it in the
|
|
357
|
+
name it in the statement; a coin another team holds stays deployable for this one. Every slot
|
|
317
358
|
agent must trade on that team. A platform agent trades on Main, so it fits only a Main deployment. A
|
|
318
359
|
slot agent of another team is a VALIDATION_ERROR naming the agent and its team, which the draft read
|
|
319
360
|
reports beforehand.
|
|
320
361
|
- **Arena** → `commit_deployment_policy_draft({ presetId, draftVersion, expectedRevision })`,
|
|
321
362
|
the same way.
|
|
322
|
-
- **One agent onto several Radar coins** → the
|
|
363
|
+
- **One agent onto several Radar coins** → the statement groups the coins by served placement and
|
|
323
364
|
names every coin, with its priority and whether it will trade (a paused coin stays paused); how duty
|
|
324
365
|
moves on each `APPEND_RULE` and `ADD_DEFAULT` coin, naming the default's holder; every refused coin
|
|
325
366
|
with its reason; and the `admission`. When `admission.fits` is false, do not offer the deploy: the
|
|
326
|
-
player drops new coins and you preview again. On
|
|
367
|
+
player drops new coins and you preview again. On the player's approval, call
|
|
327
368
|
`deploy_agent_to_radar({ agentId, slot, coins })` with the same `slot`, naming **only the PLACED
|
|
328
|
-
coins**, each
|
|
329
|
-
coin with no policy). A refusal whose `details.reason` is `RADAR_DEPLOY_REFUSED` wrote **nothing**:
|
|
330
|
-
report each of `details.refusals`, then preview and
|
|
369
|
+
coins**, each by the `coinTicker` its preview row served, with the `expectedPolicyId` and
|
|
370
|
+
`expectedRevision` the preview returned (both null for a coin with no policy). A refusal whose `details.reason` is `RADAR_DEPLOY_REFUSED` wrote **nothing**:
|
|
371
|
+
report each of `details.refusals`, then preview and state it again. Otherwise there is one outcome per
|
|
331
372
|
coin; a `CONFLICT` outcome is a coin that changed after the check and is unchanged — name it and
|
|
332
373
|
offer a fresh preview, never a blind retry.
|
|
333
374
|
|
|
334
|
-
**On `DRAFT_VERSION_MOVED` or a CONFLICT: re-read, re-preview, re-
|
|
375
|
+
**On `DRAFT_VERSION_MOVED` or a CONFLICT: re-read, re-preview, re-state.** In that order, and all
|
|
335
376
|
three. The draft or the deployment changed under you, so the state your preview resolved and the
|
|
336
377
|
radius you stated are both stale. A retry with a bumped number commits something the player was not
|
|
337
|
-
shown — the server refuses a version or revision you did not read, and the
|
|
338
|
-
|
|
378
|
+
shown — the server refuses a version or revision you did not read, and the fresh call waits on its
|
|
379
|
+
own approval.
|
|
339
380
|
|
|
340
381
|
### 4. Pause, resume, discard, delete
|
|
341
382
|
|
|
342
|
-
**Pause a deployment** → `pause_radar_deployment({
|
|
383
|
+
**Pause a deployment** → `pause_radar_deployment({ coinTicker, teamId })`. No preview and no revision:
|
|
343
384
|
stopping never waits on a read. Another team's deployment of the coin keeps trading. The player's draft
|
|
344
385
|
keeps its content and is re-based onto the paused revision.
|
|
345
|
-
**Resume** → preview the deployed policy with `preview_radar_resolution({
|
|
346
|
-
agents will go on duty again, and on their
|
|
347
|
-
`resume_radar_deployment({
|
|
386
|
+
**Resume** → preview the deployed policy with `preview_radar_resolution({ coinTicker, teamId, request: { kind: "COMMITTED" } })`, tell the player which
|
|
387
|
+
agents will go on duty again, and on their approval
|
|
388
|
+
`resume_radar_deployment({ coinTicker, teamId, expectedPolicyId, expectedRevision })` naming the `policyId` and
|
|
348
389
|
`revision` that preview returned — so it re-arms the policy the player was shown, or nothing.
|
|
349
390
|
|
|
350
391
|
**Pause an arena** → `pause_deployment_policy({ presetId })`, and **resume** it the Radar way: preview
|
|
351
392
|
`{ kind: "COMMITTED" }`, then `resume_deployment_policy({ presetId, expectedPolicyId, expectedRevision })`
|
|
352
|
-
with the pair it returned, on the player's
|
|
393
|
+
with the pair it returned, on the player's approval. Both touch only the pause, never the rules; the
|
|
353
394
|
player's draft keeps its content.
|
|
354
395
|
|
|
355
396
|
**Entries already made stand.** A pause or a delete of an arena returns `openEntries` — the sessions
|
|
356
397
|
the player's agent already entered that have not locked, each with its lock time and entry fee. They
|
|
357
398
|
play out unless the player cancels them. Name each one, ask whether to cancel it, and call
|
|
358
399
|
`cancel_market_grid_submission({ sessionId, confirm: true })` only for the entries they pick — the
|
|
359
|
-
same cancellation and refund as their own Cancel button
|
|
400
|
+
same cancellation and refund as their own Cancel button, each call running on the player's approval as
|
|
401
|
+
step 3 describes. Say nothing is cancelled when they decline.
|
|
360
402
|
|
|
361
|
-
**Discard a draft** only
|
|
362
|
-
when and from where it was last written; then
|
|
363
|
-
`discard_radar_deployment_draft({
|
|
403
|
+
**Discard a draft** only when the player asks for it. Read it first and tell the player what it holds
|
|
404
|
+
and when and from where it was last written; then, on their approval,
|
|
405
|
+
`discard_radar_deployment_draft({ coinTicker, teamId, draftVersion })` or
|
|
364
406
|
`discard_deployment_policy_draft({ presetId, draftVersion })` at **the version you read**.
|
|
365
407
|
If the draft moved since, it is refused with `DRAFT_VERSION_MOVED` and nothing is removed — read it
|
|
366
408
|
again and show them.
|
|
@@ -373,8 +415,8 @@ to preview once the policy is gone. The evidence is **the deployment's own read*
|
|
|
373
415
|
your read is refused rather than removed.
|
|
374
416
|
|
|
375
417
|
State what stops, from that read: which agents were on duty (every row of `resolvesNow.onDuty`) or
|
|
376
|
-
eligible, what the policy was firing on, and that the slots are not recoverable — and delete only
|
|
377
|
-
|
|
418
|
+
eligible, what the policy was firing on, and that the slots are not recoverable — and delete only on
|
|
419
|
+
the player's approval.
|
|
378
420
|
|
|
379
421
|
**If the player wants to stop trading without losing the slots, that is not a delete** — it is
|
|
380
422
|
`pause_radar_deployment` for Radar and `pause_deployment_policy` for Arena. Offer that
|
|
@@ -393,13 +435,13 @@ by coin through stage, commit or delete: one read and one write cover every coin
|
|
|
393
435
|
windows those rules held** — say so, because another agent may then trade there;
|
|
394
436
|
- `REMOVE_DEFAULT`: the agent's default goes with it; only other agents' rules stay, and the coin
|
|
395
437
|
sits out whenever none matches.
|
|
396
|
-
3.
|
|
397
|
-
4. One `withdraw_agent_from_radar({ agentId, holdings })
|
|
398
|
-
returned it: `teamId`, `
|
|
438
|
+
3. Say that the player can leave coins out, and drop any they name.
|
|
439
|
+
4. One `withdraw_agent_from_radar({ agentId, holdings })` on the player's approval, naming each
|
|
440
|
+
remaining holding as the read returned it: `teamId`, `coinTicker`, its `policyId` as `expectedPolicyId` and its `revision` as
|
|
399
441
|
`expectedRevision`.
|
|
400
442
|
|
|
401
443
|
A refusal whose `details.reason` is `RADAR_WITHDRAW_REFUSED` wrote **nothing**: report each of
|
|
402
|
-
`details.refusals` — its coin and why — and do not call again without a fresh read
|
|
444
|
+
`details.refusals` — its coin and why — and do not call again without a fresh read, stated again.
|
|
403
445
|
Otherwise there is one outcome per holding. A `CONFLICT` outcome is a coin that changed after the check
|
|
404
446
|
and is unchanged: name it and offer to read the holdings again — never call the withdraw again
|
|
405
447
|
unprompted. After a refused archive, archive again only on the player's word.
|
|
@@ -499,7 +541,8 @@ Three negatives, all checkable:
|
|
|
499
541
|
|
|
500
542
|
## Preview-before-commit: your discipline, fenced by the server
|
|
501
543
|
|
|
502
|
-
The preview card and the
|
|
544
|
+
The preview card and the statement before the call are yours to show, every time, and the call runs
|
|
545
|
+
only on the player's approval. What the server
|
|
503
546
|
enforces is the fence under them: a commit names the draft version and committed revision its read
|
|
504
547
|
returned, and a resume or a delete names the deployment and revision it read. A draft that moved after
|
|
505
548
|
your preview is refused with `DRAFT_VERSION_MOVED`; a deployment whose revision moved, or that was
|
|
@@ -7,7 +7,9 @@ Every `<UPPER_SNAKE>` value is a placeholder. Replace it with the id a read retu
|
|
|
7
7
|
|
|
8
8
|
- `<PRESET_ID>` comes from `list_game_presets`.
|
|
9
9
|
- `<AGENT_ID>` comes from your agent list.
|
|
10
|
-
- `<
|
|
10
|
+
- `<OTHER_AGENT_ID>` is a second agent from your agent list, where an example deploys two.
|
|
11
|
+
- `<COIN_ID>` is a `coinPoolPreview[].coinId` from `get_deployment_policy` — a coin of this arena's pool,
|
|
12
|
+
never its ticker.
|
|
11
13
|
|
|
12
14
|
Never send a placeholder as written, and never invent an id. `draftVersion` is the version
|
|
13
15
|
`get_deployment_policy_draft` returned: 0 when the arena has no draft. Each axis you send is written whole, and an
|
|
@@ -115,6 +117,44 @@ This rule plays a bear trend at the US open and sits out while a crash or a mome
|
|
|
115
117
|
}
|
|
116
118
|
```
|
|
117
119
|
|
|
120
|
+
## Rules plus an always-on agent
|
|
121
|
+
|
|
122
|
+
An always-on rule's one condition is `always`, and it comes after every other rule. It is on duty at every session
|
|
123
|
+
and plays whenever the agents above it do not qualify, provided it admits a full grid itself. An arena's fallback is
|
|
124
|
+
the default slot or always-on rules, never both, so this example also clears `DEFAULT_SLOT`. Several always-on rules
|
|
125
|
+
back each other up in the order listed.
|
|
126
|
+
|
|
127
|
+
```json stage_deployment_policy_draft
|
|
128
|
+
{
|
|
129
|
+
"presetId": "<PRESET_ID>",
|
|
130
|
+
"draftVersion": 0,
|
|
131
|
+
"axes": {
|
|
132
|
+
"RULES": {
|
|
133
|
+
"rules": [
|
|
134
|
+
{
|
|
135
|
+
"agentId": "<AGENT_ID>",
|
|
136
|
+
"minConfidence": null,
|
|
137
|
+
"conditions": [
|
|
138
|
+
{
|
|
139
|
+
"kind": "regime",
|
|
140
|
+
"regimes": ["bear_trend", "bear_range"],
|
|
141
|
+
"volatilities": ["contracting", "normal", "expanding"],
|
|
142
|
+
"duringWarnings": "run"
|
|
143
|
+
}
|
|
144
|
+
]
|
|
145
|
+
},
|
|
146
|
+
{
|
|
147
|
+
"agentId": "<OTHER_AGENT_ID>",
|
|
148
|
+
"minConfidence": null,
|
|
149
|
+
"conditions": [{ "kind": "always" }]
|
|
150
|
+
}
|
|
151
|
+
]
|
|
152
|
+
},
|
|
153
|
+
"DEFAULT_SLOT": { "defaultSlot": null }
|
|
154
|
+
}
|
|
155
|
+
}
|
|
156
|
+
```
|
|
157
|
+
|
|
118
158
|
## Override the regime anchor on a deployed arena
|
|
119
159
|
|
|
120
160
|
This stages only `REGIME_ANCHOR`, so the deployed rules and default slot stay as they are. The coin and the timeframe
|
|
@@ -4,14 +4,15 @@ Complete `stage_radar_deployment_draft` inputs, one per construction in **Shapin
|
|
|
4
4
|
checked in CI against the live stage schema and composed into a policy the aggregate accepts, so its
|
|
5
5
|
shape is current.
|
|
6
6
|
|
|
7
|
-
Every `<UPPER_SNAKE>` value is a placeholder. Replace it with the
|
|
7
|
+
Every `<UPPER_SNAKE>` value is a placeholder. Replace it with the value it names:
|
|
8
8
|
|
|
9
|
-
- `<
|
|
9
|
+
- `<COIN_TICKER>` is the coin as the player names it — its ticker or exchange symbol, in any case (`SOL`,
|
|
10
|
+
`AAPL`, `kPEPE`); the server resolves it.
|
|
10
11
|
- `<AGENT_ID>` comes from your agent list.
|
|
11
12
|
- `<OTHER_AGENT_ID>` is a second agent from your agent list, where an example deploys two.
|
|
12
13
|
|
|
13
14
|
Every example addresses the player's Main team's deployment of the coin. For another team's deployment,
|
|
14
|
-
add its `teamId` (from `list_radar_deployments` or `get_account_state.teams`) beside `
|
|
15
|
+
add its `teamId` (from `list_radar_deployments` or `get_account_state.teams`) beside `coinTicker`.
|
|
15
16
|
|
|
16
17
|
Never send a placeholder as written, and never invent an id. `draftVersion` is the version
|
|
17
18
|
`get_radar_deployment_draft` returned: 0 when the deployment has no draft. Each axis you send is written whole, and an axis
|
|
@@ -24,7 +25,7 @@ on this coin" with no condition named.
|
|
|
24
25
|
|
|
25
26
|
```json stage_radar_deployment_draft
|
|
26
27
|
{
|
|
27
|
-
"
|
|
28
|
+
"coinTicker": "<COIN_TICKER>",
|
|
28
29
|
"draftVersion": 0,
|
|
29
30
|
"axes": {
|
|
30
31
|
"DEFAULT_SLOT": { "defaultSlot": { "agentId": "<AGENT_ID>", "minConviction": null } }
|
|
@@ -49,7 +50,7 @@ selected volatilities.
|
|
|
49
50
|
|
|
50
51
|
```json stage_radar_deployment_draft
|
|
51
52
|
{
|
|
52
|
-
"
|
|
53
|
+
"coinTicker": "<COIN_TICKER>",
|
|
53
54
|
"draftVersion": 0,
|
|
54
55
|
"axes": {
|
|
55
56
|
"RULES": {
|
|
@@ -80,7 +81,7 @@ Here the agent works the bear trend and stands down while a crash or a momentum
|
|
|
80
81
|
|
|
81
82
|
```json stage_radar_deployment_draft
|
|
82
83
|
{
|
|
83
|
-
"
|
|
84
|
+
"coinTicker": "<COIN_TICKER>",
|
|
84
85
|
"draftVersion": 0,
|
|
85
86
|
"axes": {
|
|
86
87
|
"RULES": {
|
|
@@ -113,7 +114,7 @@ is staged only as hours the player names.
|
|
|
113
114
|
|
|
114
115
|
```json stage_radar_deployment_draft
|
|
115
116
|
{
|
|
116
|
-
"
|
|
117
|
+
"coinTicker": "<COIN_TICKER>",
|
|
117
118
|
"draftVersion": 0,
|
|
118
119
|
"axes": {
|
|
119
120
|
"RULES": {
|
|
@@ -137,7 +138,7 @@ This rule trades either trend, but only while volatility is expanding, and only
|
|
|
137
138
|
|
|
138
139
|
```json stage_radar_deployment_draft
|
|
139
140
|
{
|
|
140
|
-
"
|
|
141
|
+
"coinTicker": "<COIN_TICKER>",
|
|
141
142
|
"draftVersion": 0,
|
|
142
143
|
"axes": {
|
|
143
144
|
"RULES": {
|
|
@@ -169,7 +170,7 @@ first agent's regimes.
|
|
|
169
170
|
|
|
170
171
|
```json stage_radar_deployment_draft
|
|
171
172
|
{
|
|
172
|
-
"
|
|
173
|
+
"coinTicker": "<COIN_TICKER>",
|
|
173
174
|
"draftVersion": 0,
|
|
174
175
|
"axes": {
|
|
175
176
|
"RULES": {
|
|
@@ -193,6 +194,44 @@ first agent's regimes.
|
|
|
193
194
|
}
|
|
194
195
|
```
|
|
195
196
|
|
|
197
|
+
## Rules plus an always-on agent
|
|
198
|
+
|
|
199
|
+
An always-on rule's one condition is `always`, and it comes after every other rule. It is on duty at every sweep and
|
|
200
|
+
is offered the coin's fire whenever the agents above it do not take it, so here the second agent trades the coin in
|
|
201
|
+
every regime, behind the first. A coin's fallback is the default slot or always-on rules, never both, so this example
|
|
202
|
+
also clears `DEFAULT_SLOT`. Several always-on rules back each other up in the order listed.
|
|
203
|
+
|
|
204
|
+
```json stage_radar_deployment_draft
|
|
205
|
+
{
|
|
206
|
+
"coinTicker": "<COIN_TICKER>",
|
|
207
|
+
"draftVersion": 0,
|
|
208
|
+
"axes": {
|
|
209
|
+
"RULES": {
|
|
210
|
+
"rules": [
|
|
211
|
+
{
|
|
212
|
+
"agentId": "<AGENT_ID>",
|
|
213
|
+
"minConviction": null,
|
|
214
|
+
"conditions": [
|
|
215
|
+
{
|
|
216
|
+
"kind": "regime",
|
|
217
|
+
"regimes": ["bull_trend", "bull_range"],
|
|
218
|
+
"volatilities": ["contracting", "normal", "expanding"],
|
|
219
|
+
"duringWarnings": "run"
|
|
220
|
+
}
|
|
221
|
+
]
|
|
222
|
+
},
|
|
223
|
+
{
|
|
224
|
+
"agentId": "<OTHER_AGENT_ID>",
|
|
225
|
+
"minConviction": null,
|
|
226
|
+
"conditions": [{ "kind": "always" }]
|
|
227
|
+
}
|
|
228
|
+
]
|
|
229
|
+
},
|
|
230
|
+
"DEFAULT_SLOT": { "defaultSlot": null }
|
|
231
|
+
}
|
|
232
|
+
}
|
|
233
|
+
```
|
|
234
|
+
|
|
196
235
|
## Clear the default slot on a deployed coin
|
|
197
236
|
|
|
198
237
|
This stages only `DEFAULT_SLOT`, so the deployed rules stay as they are. Send `RULES` only when the rules change, and
|
|
@@ -201,7 +240,7 @@ returned.
|
|
|
201
240
|
|
|
202
241
|
```json stage_radar_deployment_draft
|
|
203
242
|
{
|
|
204
|
-
"
|
|
243
|
+
"coinTicker": "<COIN_TICKER>",
|
|
205
244
|
"draftVersion": 3,
|
|
206
245
|
"axes": {
|
|
207
246
|
"DEFAULT_SLOT": { "defaultSlot": null }
|