@battlegrid/mcp-server 31.2.7 → 31.2.9

package/README.md

@@ -24,7 +24,7 @@ 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 — v37 → v49.5
+## Contract history — v37 → v52
 
 Eleven majors reached authors while this section stopped at v36. That gap is the mechanism, not an
 oversight: since v31 a contract move needs no release here, so nothing forced a note to be written —
@@ -32,11 +32,43 @@ and the documentation ships inside the tarball, so a note written but unpublishe
 Both halves are now closed by a rule keyed to the *served* contract rather than to a release of this
 package.
 
+**50.0.0 and 51.0.0 arrived late, and the reason is worth naming.** The re-vendoring errand that
+used to carry these notes is now a generated export
+(`battlegrid-app/server/scripts/export-mcp-skills.mjs`), and it owns three paths — `skills/`,
+`skills/EXPORT.json`, and the vendored digest. It deliberately does not touch this file. So the
+digest kept arriving on time while the note stopped travelling with it, and this section sat at
+v49.5 against a served contract of 51.0.0. Nothing a client could observe was wrong; what was
+missing was the sentence telling them so. **A contract move still needs a human-authored entry
+here, and the export lane will not remind you.**
+
 ### Accepted again — input that was rejected now compiles
 
 Nothing to migrate. This is the one direction that cannot break a client: a body the server used to
 refuse is now stored. Listed because a client that special-cased the refusal can delete that branch.
 
+- **A signal rule patch no longer forces you to restate `allocation` and `required`** (51.0.0,
+  `fix-signal-rule-patch-semantics`). On `update_strategy_signal_rule`, and on the `rules` element
+  of `compile_strategy_plan`, both fields become optional and join `params` under ONE omission
+  rule: **an omitted mutable field preserves the stored value for that signal.** "Raise this
+  signal's weight" is now expressible.
+
+  ```jsonc
+  { "strategyId": "…", "expectedRevision": 7, "signalId": "volume_surge",
+    "allocation": 3 }               // `required` and `params` keep exactly what is stored
+  ```
+
+  **Every existing client keeps working** — a complete payload is still a valid patch — so this is
+  listed for what you can now STOP sending. Before it, both fields were mandatory on every rule
+  surface, so a caller that had not first read the current rule had to invent a value it was never
+  asked about. That is not hypothetical: revision 5 of a production strategy flipped `required`
+  false → true unasked while moving a weight 2 → 3, turning a scoring signal into a **mandatory
+  gate** — which changes whether the agent takes trades at all.
+
+  One boundary on the newly legal ground, and it breaks nothing: a patch carrying **no** mutable
+  field is refused — *"A rule patch must change something: supply at least one of allocation,
+  required or params."* — rather than minting a no-op revision. Under 50.0.0 that request could not
+  be formed at all, so nothing that used to work is now refused.
+
 - **An arming trigger no longer constrains its required conditions' clock** (49.4.0,
   `restore-arming-trigger-authoring`). `compile_strategy_plan`, `apply_strategy_plan` and
   `fork_strategy` accept a strategy whose entry trigger is `ON_CANDLE_CLOSE`, `STOP_THROUGH_LEVEL`
@@ -55,6 +87,14 @@ refuse is now stored. Listed because a client that special-cased the refusal can
 
 ### Changed meaning, unchanged shape
 
+- **`blocksScanGate` reads `true` for a class it did not** (50.0.0, `own-scan-served-set-once`), on
+  `preview_radar_resolution`. Blocking is now derived from the lane's **served set** rather than
+  switched over the reach reason, so a `FEED`-reason refusal on an operand no reader in the lane
+  serves BLOCKS instead of deferring. No field changes shape, and a client that already renders the
+  key renders the new answer — but a client that treated `blocksScanGate: false` as "this will
+  resolve once data arrives" now sees a deployment that will not fire. Nothing in the payload tells
+  you this moved.
+
 - **Three tools serve different values for identical input** (47.3.0, `derive-scan-fetch-from-report`).
   The radar scan leg now derives its timeframe fetch from the strategy's **report** rather than the
   on-duty agent's three perception rungs, so a required condition addressing an absolute timeframe
@@ -72,6 +112,59 @@ refuse is now stored. Listed because a client that special-cased the refusal can
 
 ### Rejected input — something you author is no longer accepted
 
+- **`entry.levelSource` is refused — the level is derived, never authored** (52.0.0,
+  `derive-entry-level`). The strict `entry` object on `compile_strategy_plan`, `apply_strategy_plan`
+  and `fork_strategy` is six keys — `trigger`, `confirmTf`, `closes`, `bandAtrMultiple`,
+  `levelOffsetAtrMultiple`, `validForBars` — and a body carrying `levelSource` is refused naming
+  the key where 51.0.0 accepted it. `STOP_THROUGH_LEVEL` rests a stop past the swing channel's
+  CURRENT edge in the trade's direction (the 20-bar high for a long, the 20-bar low for a short);
+  `ON_RETEST` rests a limit in front of the edge a close most recently BROKE. Your two dials are the
+  unsigned distance from that edge (`levelOffsetAtrMultiple`, 0–2 ATR; a long adds, a short
+  subtracts) and the bar validity (`validForBars`, 1–24). A meaningful `validForBars` under
+  `AT_SIGNAL` or `ON_CANDLE_CLOSE` is now refused as `PARAMETER_NOT_HONOURED` like the other level
+  dials.
+
+  **Drop the key.** That is the whole migration for what you send; the six-key example below is
+  the current shape.
+
+- **`update_strategy_signal_rule` requires `confirm: true` when the strategy has bound agents**
+  (51.0.0, `fix-signal-rule-patch-semantics`). The write re-materializes scoring configuration onto
+  every bound agent immediately — including agents holding open USDC positions — and until now
+  nothing on the server asked. A rule edit on a strategy with one or more bound agents is refused
+  without the flag, and the message names the count. An edit on a strategy with **nothing bound is
+  unaffected**, and so is every path through the web editor.
+
+  **Send `confirm: true`.** That is the whole migration, and `confirm` is published on the input
+  schema — but nothing in the schema says WHEN it becomes mandatory, because the condition is the
+  bound-agent count rather than the shape of your body. The refusal rides the existing
+  `VALIDATION_ERROR` code, so a client that omits it discovers the rule at the refusal.
+
+  Why it moved to the server: the guard existed, but only as served prose the calling model could
+  decline — and did, twice in production on 2026-08-24. `archive_strategy` and
+  `rebind_intelligence_agent` have taken a server-enforced `confirm` all along; single-rule tuning
+  was the outlier among its own siblings, and it is the one that writes to scoring.
+
+- **A radar deployment is refused when its strategy reads a session-field scalar** (50.0.0,
+  `own-scan-served-set-once`). `upsert_radar_deployment` refuses a deployment whose slot agents'
+  bound strategy carries a condition reading one of five SESSION-FIELD scalars — `fieldPlayers`,
+  `fieldUpBias`, `fieldBiasDir`, `captConc`, `picksSpread` — with
+  `CONDITION_OPERAND_UNSERVED_IN_LANE`. A body accepted under 49.5.0 is refused under 50.0.0
+  without one byte of it changing.
+
+  **Why a refusal and not a warning.** Those five describe a game SESSION, and radar runs outside a
+  session at BOTH its stages — so such a condition can never resolve there. The deployment formed
+  no fire edge and the agent did nothing on that coin, silently, forever. The refusal converts a
+  permanent silence into an error at the moment you author it.
+
+  **Migrate** by moving the clause to a scalar radar reads — the Market Breadth or Reference Pairs
+  families, which are market-wide reads with no session dimension — or by binding the strategy to
+  an arena agent instead. The error carries both halves: `allowedDomain` enumerates every servable
+  header, and the message names the sections.
+
+  **Strategy authoring is untouched by this bump.** The same strategy is legal, and reads those
+  scalars correctly, on an arena agent — which is why the refusal is on the DEPLOYMENT and not on
+  `compile_strategy_plan` / `apply_strategy_plan`.
+
 - **A benchmark-bound section no longer accepts crowd metrics or rank transforms** (49.0.0,
   `fix-benchmark-legality-save-path`). On a custom section carrying a non-null `benchmarkTicker`, a
   column whose metric is enrichment-stage (the `CROWD_*` family, `FLOW_ALIGN`, `SMART_RETAIL`,
@@ -123,11 +216,11 @@ refuse is now stored. Listed because a client that special-cased the refusal can
   that clause into its own LIVE condition and `conditionRef` it. `exit: true` is legal only under
   `clock: "CLOSE"` — an exit fired on a forming bar is an intrabar exit.
 
-- **A strategy requires a seven-key `entry` object** (44.0.0 for four keys, 47.0.0 for three more —
-  `add-entry-on-close`, `add-level-trigger-execution`). Required on every CREATE, on
-  `compile_strategy_plan`, `apply_strategy_plan` and `update_intelligence_agent`. A client sending
-  44.0.0's four-key object is refused under 47 with `entry.levelSource: Required` without one byte of
-  it changing.
+- **A strategy requires a six-key `entry` object** (44.0.0 for four keys, 47.0.0 for three more —
+  `add-entry-on-close`, `add-level-trigger-execution` — and 52.0.0 removed `levelSource`,
+  `derive-entry-level`). Required on every CREATE, on `compile_strategy_plan`, `apply_strategy_plan`
+  and `update_intelligence_agent`. A client sending 44.0.0's four-key object is refused with
+  `entry.levelOffsetAtrMultiple: Required` without one byte of it changing.
 
   ```jsonc
   "entry": {
@@ -135,14 +228,13 @@ refuse is now stored. Listed because a client that special-cased the refusal can
     "confirmTf": "4h",               // the strategy timeframe or the rung below it — nothing else
     "closes": 1,                     // 1–5; must be 1 unless ON_CANDLE_CLOSE
     "bandAtrMultiple": 1.0,          // > 0, and <= the platform's entry-deviation gate
-    "levelSource": "SWING_HIGH",     // | SWING_LOW | BOLLINGER_UPPER | BOLLINGER_LOWER
-    "levelOffsetAtrMultiple": 0,     // 0–2, UNSIGNED; must be 0 unless a level trigger
-    "validForBars": 4                // 1–24 of the strategy's own bars
+    "levelOffsetAtrMultiple": 0,     // 0–2, UNSIGNED distance from the derived edge; 0 unless a level trigger
+    "validForBars": 4                // 1–24 of the strategy's own bars; 4 unless a level trigger
   }
   ```
 
   `AT_SIGNAL` with those values is byte-identical to pre-44 behaviour. The legality matrix runs one
-  way: all seven keys are always present, so a MEANINGFUL value under a trigger that ignores it is
+  way: all six keys are always present, so a MEANINGFUL value under a trigger that ignores it is
   refused rather than accepted-and-dropped — a dial never silently does nothing.
 
 - **A `strategyTimeframe` the platform does not ingest is refused** (39.0.0,
@@ -179,6 +271,31 @@ refuse is now stored. Listed because a client that special-cased the refusal can
 
 ### Reshaped output — the same call returns a different shape
 
+- **The stored entry discipline no longer names a level source** (52.0.0, `derive-entry-level`).
+  `StrategyDTO.entry` (`get_strategy`, `list_strategies`, the `fork_strategy` / `archive_strategy` /
+  `restore_strategy` envelopes) and the apply envelope's `postState.entry` lose `levelSource`.
+  `TradeOutcomeDTO.entryDiscipline` (`get_trade_outcome_by_decision`, `list_trade_outcomes`) loses
+  it and gains `levelOffsetAtrMultiple: number | null` — the offset in force at the fire, `null` on
+  rows written before its column existed. A reader that rendered the level source renders the
+  geometry from `trigger` and the outcome's `direction` instead: which edge and which order shape
+  are a pure function of those two fields, so no stored copy is served.
+
+- **`update_strategy_signal_rule` gains its own response envelope** (51.0.0,
+  `fix-signal-rule-patch-semantics`). It no longer shares `{ strategy }` with its siblings. The
+  response is `{ strategy, ruleChanges }`, where `ruleChanges` is the server's own before/after
+  pair for the edited signal — `[{ signalId, before, after }]`, each side a full rule object. It is
+  `null` when the mutation changed no rule, **never `[]`**.
+
+  **Report the change from that pair, not from memory.** The planner always computed the diff and
+  the tool discarded it, so a caller narrating what it just did had only its own recollection of
+  the before-value. One production edit shipped a wrong receipt on top of a wrong write that way,
+  and the write was unreconstructable from the audit trail afterwards.
+
+  Additive, but published on a `.strict()` shape — a decoder pinned to the old two-key object
+  rejects the new key. `fork_strategy`, `archive_strategy` and `restore_strategy` keep the shared
+  `StrategyResponseSchema` and publish exactly what they did; it was deliberately NOT widened for
+  them, so this reshape reaches one tool only.
+
 - **An entry void now names the gate that refused it** (49.5.0,
   `fix-arming-trigger-clock-authority`), on `get_radar_activity_summary`. In the cause rollup, the
   `ENTRY_VOID` group's `gateCode` widens from always-`null` to `QualificationGateCode | null`: a
@@ -223,6 +340,13 @@ refuse is now stored. Listed because a client that special-cased the refusal can
 
 ### Widened enum — new members your own copy rejects
 
+- **`TradeExecutionFailureReason` gains `LEVEL_NOT_RESTABLE`** (52.0.0, `derive-entry-level`): a
+  level entry refused at placement because its resting price sat on the wrong side of the exchange
+  mid — a buy stop at or below it, a buy limit at or above it, and the mirror for a sell. It appears
+  on the `list_signal_logs` failure-reason filter input and on the signal-pipeline execution
+  summary's `failureReason`, with origin `CLIENT_GATE`. There is no distance limit: a level far from
+  the mark rests until its bar validity expires.
+
 - **The authorable metric vocabulary widens by 29 keys** (46.1.0, `add-indicator-catalog-coverage`):
   Keltner (`KC_UPPER`/`KC_MID`/`KC_LOWER`), Supertrend (`ST_LINE`/`ST_DIR`), Hull (`HMA20`),
   WaveTrend (`WT1`/`WT2`), QQE (`QQE_RSI_MA`/`QQE_STOP`), Parabolic SAR (`PSAR`), Ichimoku

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.7";
+export declare const PACKAGE_VERSION = "31.2.9";
 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.7';
+export const PACKAGE_VERSION = '31.2.9';
 export const DEFAULT_URL = 'https://mcp.battlegrid.trade/mcp';
 const MAX_RETRIES = 3;
 const RETRY_DELAYS_MS = [2000, 4000, 8000];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@battlegrid/mcp-server",
-  "version": "31.2.7",
+  "version": "31.2.9",
   "description": "BattleGrid MCP server — play crypto prediction games from AI agents",
   "type": "module",
   "main": "dist/index.js",