@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.
@@ -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 `coinId` **and** `teamId`; a `teamId` you omit addresses the player's **Main** team, so
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 is keyed on `coinId` — a text `coins.id`, not a ticker and not a UUID.** Resolve it
55
- through `get_coin_metadata`. Never derive a `coinId` from the player's ticker text, however
56
- obvious it looks: the identifier the tools take is the coin table's own, and a guessed one either
57
- misses or hits the wrong coin.
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: `coinId` and `teamId`) or `list_radar_deployments` (the fleet, plus the platform
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
- (`coinId` and `teamId`) — or `list_radar_deployment_drafts` when no deployment is named yet; each of
71
- its rows names its `teamId` and `coinId`. The player may be part-way through a
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
- id — the player's builder is open on that team's deployment of the coin whether or not a draft exists
86
- yet. Stage every change into that deployment's draft, naming that `coinId` and that `teamId`; it lands
87
- in their builder as a proposal. Their own Save
88
- commits it; commit it yourself only when they explicitly confirm through `ask_user`, after the
89
- preview this flow requires. The builder's state — its rules, the default agent, who is on duty now —
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 `coinId` and the `teamId` on every call below:
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` (the catch-all, on duty only
107
- when no rule is, or null for none). A Radar policy has **no timeframe**: each rule's regime
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 confirm a draft whose diagnostics carry an error: stage a fix.
119
- 3. `preview_radar_resolution({ coinId, teamId, request: { kind: "DRAFT", draftVersion } })` at the version that
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 — never none. Pick the construction
132
- from what the player asked for:
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 on or under one rule. Never stage it coin by coin: one preview and one write cover every coin,
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, coinIds })`, with `slot` either
177
- `{ kind: "DEFAULT", minConviction }` (always on: the agent is on duty whenever no rule matches) or
178
- `{ kind: "RULE", minConviction, conditions }` (one rule, conditions shaped as a staged rule's), and
179
- `coinIds` resolved through the coin-metadata read. It writes nothing. Each coin is `PLACED` with its
180
- served `placement`, rule `priority` and `enabledAfterCommit`, or `REFUSED` with the reason a Save of
181
- that coin would give; `admission` is the plan's coin cap for the new coins.
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`: one rule below the coin's existing rules — **while it matches, the coin's default
186
- is off duty**; name that default by `defaultAgentDisplayName` when it is non-null.
187
- A coin refused for "already has a default" can still take the agent as a rule: offer that as a
188
- second preview, never silently.
189
- 3. Confirm as step 3 says for a batch, then one `deploy_agent_to_radar({ agentId, slot, coins })`.
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), `DEFAULT_SLOT` (the catch-all, or null for none)
196
- and `REGIME_ANCHOR` (the anchor override, or null to inherit the arena's). Pausing is never staged.
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. Pick the construction from what the player asked for:
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. Confirm against the preview, then commit
331
+ ### 3. State the preview, then commit on the player's approval
297
332
 
298
- One confirmation whose question **references what the preview showed** — the agents it put on duty and
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({ coinId, teamId, draftVersion, expectedRevision })`,
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. Ask with `ask_user` first and commit only after an explicit confirming
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 confirmation; a coin another team holds stays deployable for this one. Every slot
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 confirmation groups the coins by served placement and
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 an explicit confirming pick, call
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 with the `expectedPolicyId` and `expectedRevision` the preview returned (both null for a
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 confirm again. Otherwise there is one outcome per
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-confirm.** In that order, and all
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 confirmation is yours to
338
- ask for again.
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({ coinId, teamId })`. No preview and no revision:
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({ coinId, teamId, request: { kind: "COMMITTED" } })`, tell the player which
346
- agents will go on duty again, and on their word
347
- `resume_radar_deployment({ coinId, teamId, expectedPolicyId, expectedRevision })` naming the `policyId` and
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 word. Both touch only the pause, never the rules; the
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. Say nothing is cancelled when they decline.
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 on the player's word. Read it first and tell the player what it holds and
362
- when and from where it was last written; then
363
- `discard_radar_deployment_draft({ coinId, teamId, draftVersion })` or
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 after
377
- an explicit confirming pick.
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. Confirm with `ask_user`, letting the player leave coins out.
397
- 4. One `withdraw_agent_from_radar({ agentId, holdings })`, naming each confirmed holding as the read
398
- returned it: `teamId`, `coinId`, its `policyId` as `expectedPolicyId` and its `revision` as
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 and a fresh confirm.
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 confirming pick are yours to show and ask for, every time. What the server
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
- - `<COIN_ID>` comes from the arena's coin pool.
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 id a read returned:
7
+ Every `<UPPER_SNAKE>` value is a placeholder. Replace it with the value it names:
8
8
 
9
- - `<COIN_ID>` comes from `get_coin_metadata`.
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 `coinId`.
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
- "coinId": "<COIN_ID>",
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
- "coinId": "<COIN_ID>",
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
- "coinId": "<COIN_ID>",
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
- "coinId": "<COIN_ID>",
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
- "coinId": "<COIN_ID>",
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
- "coinId": "<COIN_ID>",
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
- "coinId": "<COIN_ID>",
243
+ "coinTicker": "<COIN_TICKER>",
205
244
  "draftVersion": 3,
206
245
  "axes": {
207
246
  "DEFAULT_SLOT": { "defaultSlot": null }