@battlegrid/mcp-server 31.2.68 → 31.2.70

package/README.md

@@ -24,6 +24,98 @@ Seeing package `31.x` alongside handshake `battlegrid@33.x` — the package **be
 
 **What this changes for you:** nothing about how you call anything. Upgrading the package no longer waits on a server deploy, and a server deploy no longer strands you on a package that names the wrong contract — reconnect and the announcement follows. **Contract breaking-change notes are no longer keyed to package versions**, since a contract move is no longer a release here; the v11-and-earlier notes below are kept as history, and the live vocabulary is always discovery.
 
+## Contract history — v88.1 (an open position keeps the exit rules it opened under)
+
+**Additive at v88.1: acceptance widens and one served value narrows; no input or output schema
+changes.** v88.1 is the contract on top of v88.
+
+### Widened acceptance — `commit_strategy_draft`, `restore_strategy`, `commit_agent_draft`
+
+- **An open position no longer refuses a strategy commit, a restore or a rebind.** At v88 a write that
+  would leave an exit rule unreadable on a coin a bound agent held an open position on was refused with
+  `CONDITION_UNREADABLE_BY_RADAR_SCAN` or `CONDITION_OPERAND_UNSERVED_IN_LANE`. At v88.1 it commits. A radar
+  slot's coin and a pending manual request's coin are still checked, and refused exactly as before.
+- The three tools' descriptions now say this, so their description hashes move.
+
+### Narrowed served value — the readability refusal's `coinRole`
+
+- The refusal's error context serves `coinRole` as `SLOT` or `MANUAL_REQUEST` only. `OPEN_POSITION` is no
+  longer emitted. A client switching on it loses a member it can no longer receive.
+
+### Behaviour behind unchanged schemas
+
+- **An open position keeps what it opened with.** An agent position records the exit rules it opened
+  under, with the report and timeframes they read, and its exit rules are evaluated from that record for
+  the life of the trade. An exit-rule, exit-policy or level edit reaches only positions opened after it;
+  a revision, rebind, SYSTEM update or timeframe change after the open never reaches an open trade.
+
+Nothing accepted at v88 is refused at v88.1.
+
+## Contract history — v88 (an exit rule names the side it closes)
+
+**Breaking at v88: a condition body accepted at v87 is refused, and condition and chart output is
+reshaped.** v88 is the contract on top of v87.
+
+A condition is an entry condition or an exit rule, never both. An exit rule names the side it closes,
+where `exit: true` read that side from the condition's verdict.
+
+### Rejected input — `stage_strategy_draft`, `preview_strategy_report`
+
+- **A condition no longer carries `exit`.** A condition entry naming it is refused with the unknown-key
+  error, on the `CONDITIONS` axis of `stage_strategy_draft` and in the conditions of
+  `preview_strategy_report`'s `source: { kind: 'FIELDS', … }`.
+- **Every condition requires `exitSide`**: `LONG`, `SHORT` or `BOTH` for an exit rule, `null` for an
+  entry condition. It is nullable, never optional; a condition without it is refused.
+- **An exit rule carries `verdict: null` and `required: false`, and an entry condition cannot reference
+  an exit rule.** The builder refuses each with a typed remediation error —
+  `CONDITION_EXIT_RULE_CARRIES_VERDICT`, `CONDITION_EXIT_RULE_REQUIRED`,
+  `CONDITION_ENTRY_REFERENCES_EXIT_RULE` — in a staged draft's `diagnostics`, and as the refusal of its
+  `commit_strategy_draft`. An exit rule may reference anything: "exit when the entry setup stops holding"
+  is an exit rule whose definition is `NOT` a `conditionRef` to the entry condition.
+
+### Reshaped output
+
+- **Every condition a strategy read or commit returns carries `exitSide` and no `exit`**:
+  `get_strategy`, `archive_strategy`, `restore_strategy` and `commit_strategy_draft`.
+- **`get_agent_coin_qualification`'s chart names the side each exit rule closes.** Every served level
+  gains `referrers`, `{ conditionKey, conditionName, exitSide }` for each of its set's declared
+  conditions that reach it. Every series clause referrer and every `conditionsWithoutLevels` entry gains
+  `exitSide`, `null` on every entry-set referrer. The `ENTRY` set no longer lists exit rules; they are
+  listed under `EXIT`.
+
+### Widened enums
+
+- **`CONDITION_EXIT_RULE_CLOSES_DIRECTION`** joins the qualification gate code, the trade evaluation
+  attempt reason, the trade gate reason and the trade screen reason. It can appear in the output of
+  `get_agent_coin_qualification`, `scan_agent_coins`, `scan_coin_agents`, `list_gate_blocks`,
+  `get_signal_log`, `get_public_agent_signal_log_detail`, `get_radar_activity`,
+  `get_radar_activity_summary`, `get_radar_close_decisions`, `get_radar_deployment`,
+  `list_radar_deployments`, `preview_radar_resolution`, `propose_entry_decision`,
+  `get_trade_conversation`, `get_agent_budget` and `reset_agent_drawdown_baseline`. A gate block under it
+  names the refusing exit rule in `decidedBy`.
+- **`BLOCKED_BY_CONDITION_EXIT_RULE`** joins the radar evaluation outcome, on `get_radar_activity` and
+  `get_radar_activity_summary`.
+
+A client switching exhaustively on any of them meets a member it has not seen.
+
+### Behaviour
+
+- **An exit rule closes exactly the side it names.** A settled TRUE on a completed bar closes the
+  agent's open position on that side. No verdict chooses it; `exit: true` closed the side its verdict
+  opposed, and both sides for a `NEITHER` or `null` verdict.
+- **While an exit rule reads TRUE, its side is not offered for entry.** Scan qualification and compose
+  refuse that side under `CONDITION_EXIT_RULE_CLOSES_DIRECTION`, after any verdict refusal of the same
+  side.
+- **A stored `exit: true` condition is split and closes what it closed.** It keeps its verdict as an
+  entry condition, and its strategy gains an exit rule `CLOSE_ON_<conditionKey>`, a `conditionRef` to
+  it closing the side its verdict opposed (`UP` → `SHORT`, `DOWN` → `LONG`, `NEITHER` → `BOTH`). A
+  strategy read returns both.
+- **Unchanged names keep their place.** `list_strategies`' `conditionTally.exit` now counts exit rules,
+  and a decision record's condition `declaration` keeps `exit: boolean`, true for an exit rule.
+
+A strict client that rejects unknown keys fails to parse every condition and every chart level at v88;
+list the tools again after the server deploys.
+
 ## Contract history — v87 (a fork's create resolves its source again)
 
 **Breaking at v87: a fork's create can now be refused where it committed.** v87 is the contract on top of

package/dist/index.d.ts

@@ -49,7 +49,7 @@ import { type Implementation, type Prompt, type Resource } from '@modelcontextpr
  * being asked. Move it for a change to THIS package — a proxy fix, a dependency bump, a docs
  * correction. Never move it to track the server.
  */
-export declare const PACKAGE_VERSION = "31.2.68";
+export declare const PACKAGE_VERSION = "31.2.70";
 export declare const DEFAULT_URL = "https://mcp.battlegrid.trade/mcp";
 export interface EnvConfig {
     apiKeys: string[];

package/dist/index.js

@@ -52,7 +52,7 @@ import { ListToolsRequestSchema, CallToolRequestSchema, ListPromptsRequestSchema
  * being asked. Move it for a change to THIS package — a proxy fix, a dependency bump, a docs
  * correction. Never move it to track the server.
  */
-export const PACKAGE_VERSION = '31.2.68';
+export const PACKAGE_VERSION = '31.2.70';
 export const DEFAULT_URL = 'https://mcp.battlegrid.trade/mcp';
 const MAX_RETRIES = 3;
 const RETRY_DELAYS_MS = [2000, 4000, 8000];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@battlegrid/mcp-server",
-  "version": "31.2.68",
-  "description": "BattleGrid MCP server — play crypto prediction games from AI agents",
+  "version": "31.2.70",
+  "description": "BattleGrid MCP server \u2014 play crypto prediction games from AI agents",
   "type": "module",
   "main": "dist/index.js",
   "bin": {

package/skills/EXPORT.json

@@ -1,14 +1,14 @@
 {
   "generator": "battlegrid-app/server/scripts/export-mcp-skills.mjs",
-  "contractVersion": "87.0.0",
+  "contractVersion": "88.1.0",
   "files": {
     "battlegrid-agent-management/SKILL.md": "b2f04d76480de2f9fdbd00f8cb25610d2b72fcaa4f87ca57a09bd9ffc78fdbba",
     "battlegrid-arena-play/SKILL.md": "4cfaa92a8d0dcaf477b227abd774e7aa8642c185d72108dfd401be0cf8aecd7f",
     "battlegrid-market-analysis/SKILL.md": "3a9943de9f482a8230fb2983efd2f2d8b8c17d49c242e49b68e7243c20c3aa7b",
-    "battlegrid-radar-deployment/SKILL.md": "17301fa66f4b128154435462ffa967efcb3d016df671b03c485d0f8b840fc891",
+    "battlegrid-radar-deployment/SKILL.md": "a624807c9d1f0e1fa650592bfbbdab228d75098d66a9c2d4d3cd3f85e5d3796c",
     "battlegrid-strategy-authoring/SKILL.md": "a5066740d7d57f095545fd812b0228a8eef6e3b08c87047596a0e1639ae4971d",
     "battlegrid-strategy-doctor/SKILL.md": "14f20bff9e2b5a59d11634fe3615b1298d672d5e2eba06d3dc8698b571b3bee3",
-    "battlegrid-strategy-examples/SKILL.md": "3c11942f7327e00208d48a7a256faf83d80faf568bd0181b707657bace3c1ef9",
+    "battlegrid-strategy-examples/SKILL.md": "7ec80099efe3a923e1a701703eba5edbbe3ce044628273c806dfd688f2fd715c",
     "battlegrid-strategy-examples/references/playbooks.md": "63aa07f3d55f97e53b2bf6401528807ab23bd093a4bbc37e598158249db24a59",
     "battlegrid-strategy-examples/references/recipes.md": "61382acdd295fa159f055b787ba501f1c015f383f59a6714a973057f10de611f",
     "battlegrid-strategy-examples/references/tradingview-ports.md": "2b13adbc137178955edcca31b6ab40c01c745a932a0750b91db8820c736700bb",

package/skills/battlegrid-radar-deployment/SKILL.md

@@ -122,7 +122,7 @@ resolve.
 
 **A Radar preview refuses an agent the scan cannot read on the coin.** Every slot agent, on duty now
 or not, must have every condition the radar acts on — its required conditions, the ones carrying a
-verdict, its exit conditions, and every condition they reference — readable by the radar scan on this
+verdict, its exit rules, and every condition they reference — readable by the radar scan on this
 coin. When one is not, the preview itself is refused, issues no certificate, and nothing can be
 committed: `CONDITION_UNREADABLE_BY_RADAR_SCAN`, whose `details.context.reachReason` says why
 (`INSTRUMENT` — the market-data profile of the coin, or of a benchmark section's own instrument, carries

package/skills/battlegrid-strategy-examples/SKILL.md

@@ -88,10 +88,11 @@ against a literal; neither of those shapes is what a previous-session level need
 
 ## Conditions
 
-`{ conditionKey, name, definition, verdict, required, exit }` — all six
+`{ conditionKey, name, definition, verdict, required, exitSide }` — all six
 required, no defaults. A `clock` key is REFUSED (the per-condition evidence clock was retired in
-contract `61.0.0`), and so is a condition-level `closes` key: the hold lives on each clause and each
-group (contract `84.0.0`). Clauses: numeric/rank headers take `lt|lte|gte|gt|between`;
+contract `61.0.0`), so is a condition-level `closes` key — the hold lives on each clause and each
+group (contract `84.0.0`) — and so is a boolean `exit` key: the side an exit closes is its own
+`exitSide` (contract `88.0.0`). Clauses: numeric/rank headers take `lt|lte|gte|gt|between`;
 classification/direction headers take `is|in` with the served vocabulary. Groups:
 `ALL | ANY | NOT | N_OF` (with `n`), depth ≤ 2. Every clause and every group carries a required
 `hold: { atLeast, of }` — `{ "atLeast": 1, "of": 1 }` is a single read; a clause or group without
@@ -184,7 +185,7 @@ strategy timeframe, and at or below it the series as the frame carries it. At or
 timeframe the choice therefore sets only what the live lane shows — no bar is in progress at the
 anchor's own close — so Developing there is legal and changes no decision. A condition reading a
 developing bar is single-frame: its clause holds Once (a Developing column cannot be held), it
-carries no verdict and it cannot take the `exit` role. One exception overrides both the stored value and the default: a column reading a metric with
+carries no verdict and it cannot be an exit rule. One exception overrides both the stored value and the default: a column reading a metric with
 no live value (itself, or a `spread` operand) reads completed bars at every rung, because the forming
 bar publishes nothing for it. The resolved answer for a column is served on
 `effectiveParameters.bars`, and it states that exception.
@@ -205,7 +206,7 @@ strategy reads one is refused outright (`CONDITION_OPERAND_UNSERVED_IN_LANE`), n
 can read instead.
 
 **What the radar scan can read on a coin.** Beyond the lane, a condition the radar acts on — a
-required one, one carrying a verdict, an exit one, and every condition they reference — must be
+required one, one carrying a verdict, an exit rule, and every condition they reference — must be
 readable by the radar scan on each coin the radar acts on for the agent, or it would be decided unread.
 What a coin can be read for is its market-data profile: the kinds of data the market-data service
 publishes that it serves for that coin, never the coin's asset class. A refusal carries
@@ -216,12 +217,12 @@ column on a ticker with no catalog row), `AGENT_TIMEFRAME` when the agent has no
 enabled ladder, and `FEED` when the radar scan never reads that data for the agent (crowd reads:
 compose reads them, but only for a coin the scan has already admitted). An `INSTRUMENT` refusal names
 the kind of data the profile lacks, or says the coin has no profile. The fixes it names: take the
-condition's radar role away (neither required nor a verdict, or no exit role), read a column the radar
+condition's radar role away (neither required nor a verdict, or, for an exit rule, its exit role), read a column the radar
 scan has on that coin, or free the coin.
 
 **The refusal lands where an agent meets a coin**: at the radar deploy (its preview, the builder's
 Save and the draft commit); at a manual entry request, as `CONDITION_UNREADABLE_ON_COIN`;
-and, for an agent already deployed or holding an open position or a pending manual request, at a
+and, for an agent already deployed or holding a pending manual request, at a
 strategy commit (`commit_strategy_draft`, the builder's Save, `restore_strategy`) or a rebind (the
 agent draft's STRATEGY_BINDING commit). A commit is checked only on behalf of those agents: a
 strategy carries no lane of its own, so one with no agent the radar acts on is never checked, and
@@ -229,13 +230,22 @@ the same strategy is legal, and reads session-field scalars correctly, on an are
 may hold such content — staging never refuses a draft for being invalid — but its commit is
 refused, so it never reaches the agents.
 
-**The exit role.** `exit: true` makes a settled TRUE reading close open positions its verdict
-opposes — UP exits SHORTs, DOWN exits LONGs, a NEITHER or `null` verdict exits both. Legal only over
-a closure every operand of which a completed bar MOVES (`CONDITION_EXIT_READ_ILLEGAL`), which rules
-out a developing read — a bar in progress is the forming bar, and an exit fired on one is an intrabar
-exit — and rules out a frame-inert operand, which could never fire. Orthogonal to `required` — the
-two act on disjoint lifecycles, pre-entry versus open — so a condition may carry both, either, or
-neither.
+**Exit rules.** A condition is an entry condition (`exitSide: null`) or an exit rule, never both.
+An exit rule's `exitSide` names the side it closes — `LONG`, `SHORT` or `BOTH` — and it has two
+effects: a settled TRUE on a completed bar closes the agent's open position on that side, and while it
+reads TRUE that side is not offered for entry (a scan qualification or a compose refusal under
+`CONDITION_EXIT_RULE_CLOSES_DIRECTION`, after any verdict refusal of the same side). No verdict chooses
+the side: an exit rule carries `verdict: null` and `required: false` (`CONDITION_EXIT_RULE_CARRIES_VERDICT`,
+`CONDITION_EXIT_RULE_REQUIRED`). An entry condition cannot reference an exit rule
+(`CONDITION_ENTRY_REFERENCES_EXIT_RULE`), so editing an exit rule never changes what the agent enters;
+an exit rule may reference anything, so "exit when the entry setup stops holding" is an exit rule
+whose definition is `NOT` a `conditionRef` to the entry condition. An exit rule is legal only over a
+closure every operand of which a completed bar MOVES (`CONDITION_EXIT_READ_ILLEGAL`), which rules out
+a developing read — a bar in progress is the forming bar, and an exit fired on one is an intrabar
+exit — and rules out a frame-inert operand, which could never fire. A position stamps the exit rules
+it opened under, with the report and timeframes they read: an exit-rule edit applies to positions
+opened after it, and an open position keeps the exit rules it opened with, so an open position never
+refuses a commit or a rebind.
 
 **A state column is not a flip event.** `ST_DIR` reads the same on every bar of a trend, so
 `ST_DIR is "bullish"` is a regime filter and never an entry signal. The flip needs an event column