@battlegrid/mcp-server 31.2.62 → 31.2.64

package/README.md

@@ -24,6 +24,109 @@ 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 — v84 (the hold moves from the condition to each clause and group)
+
+**Breaking at v84: a condition body accepted at v83 is refused, and condition evidence is reshaped.**
+v84 is the contract on top of v83.
+
+How many completed bars a reading must hold is no longer one number on the condition. Each clause
+holds its own reading, counted on its own column's timeframe, and a group can hold its members'
+same-bar reading.
+
+### Rejected input — `compile_strategy_plan`, `apply_strategy_plan`
+
+- **A condition no longer carries `closes`.** A condition entry naming it is refused with the
+  unknown-key error, in a plan body and in every normalized post-state and strategy draft those tools
+  carry.
+- **Every clause and every group requires `hold: { atLeast, of }`**, whole numbers of at least 1.
+  `{ "atLeast": 1, "of": 1 }` is one read (what every v83 condition did), `{n, n}` is "n closes in a
+  row", `{1, n}` is "within n closes", and anything else is "at least m of n closes". A clause or group
+  without `hold` is refused. A plan staged under v83 must be recompiled.
+- **What a header admits is refused by the builder, never by the schema.** `atLeast` above `of`, a
+  window above the header's maximum, or a group hold over members that hold their own bars is a typed
+  remediation error.
+
+### Replaced output — `preview_strategy_report`, `list_strategy_vocabulary`
+
+- **`closesReadable: boolean` is replaced by `conditionHold: { timeframe, maxWindow, maxAtLeast,
+  refusal }`** on each report condition column and each scalar metric. It names the timeframe a
+  clause counts on, the largest `of` and `atLeast` it admits (`maxAtLeast` is 1 for a cross or other
+  event, so an event can only be held "within n closes"), and why it admits one bar when it does:
+  `NOT_REWINDABLE`, `DEVELOPING`, `OFFSET`, `BAR_STATE` or `HISTORY`. Read the window from here
+  rather than assuming a ceiling; there is no longer a fixed 1–5 limit.
+
+### Reshaped output — condition evidence
+
+- **Every clause-evidence entry gains `hold`, `counts` and `decidedBar`**, on `preview_strategy_report`,
+  `list_gate_blocks`, `get_radar_close_decisions`, `get_agent_coin_qualification`,
+  `preview_radar_resolution` and `get_signal_log`. `counts` is `{ trueCount, total, unresolvedCount }`
+  over the clause's own bars. `decidedBar` is `{ timeframe, closesBack }`, the bar its operand was read
+  on, or `null` when the hold that counts it reads one bar.
+- **A condition outcome loses `hold`** (`closesHeld`, `closesRequired`, `liveOutcome`, `nextCloseAt`):
+  the counted outcome is the clause's own, on its evidence. A decision record's condition
+  `declaration` loses `closes`.
+- **Every strategy read returns `hold` on each clause and group** and no `closes` on the condition.
+
+### Widened enum — the evidence union
+
+- **The evidence union gains a `group` arm**, `{ kind: 'group', op, hold, counts, decidedBar, outcome,
+  memberCount }`, emitted only for a group holding more than one bar, just before the `memberCount`
+  entries that belong to it. A client switching exhaustively on `kind` must add the branch. A strategy
+  without group holds serves no new arm.
+
+A strict client that rejects unknown keys fails to parse condition evidence at v84; list the tools
+again after the server deploys.
+
+## Contract history — v70.1 (budget run-state)
+
+**Additive at v70.1: one output field added to the risk budget.**
+
+### Added output — `get_agent_budget`, `reset_agent_drawdown_baseline`
+
+- **`budget.runStatus`** is your run-state for the agent: `blocked`, `paused` or `active`, already
+  ranked by the server. `blocked` means the admission gate is refusing the agent for a reason other
+  than its halt (`blockedReason` names it). A halted agent reads `paused`, even while its own
+  `AGENT_HALTED` block stands. Read it rather than re-deriving it from `blockedReason` and `haltedAt`.
+- A client that ignores the field is unaffected. A client that validates results against a cached,
+  closed output schema should list the tools again after the server deploys.
+
+## Contract history — v83 (a model's vendor is its vendor slug)
+
+**Breaking at v83: four output fields renamed and retyped, one aggregation regrouped.** v83 is the
+contract on top of v82.
+
+Wherever a model's vendor is published, it is now the router vendor slug of the model's id — the part
+before the `/` (`anthropic`, `z-ai`, `moonshotai`, …). It is never the BYOK provider enum, and never the
+catalogue's display label, which sometimes named a hosting provider rather than the model's maker.
+
+### Reshaped output — the agent
+
+- **Every agent loses `provider` and gains `modelVendorSlug: string`**, on `list_intelligence_agents`,
+  `get_intelligence_agent`, `create_intelligence_agent`, `update_intelligence_agent`,
+  `rebind_intelligence_agent`, `archive_intelligence_agent` and `activate_intelligence_agent`.
+  `provider` was the BYOK enum and was `null` for every agent; `modelVendorSlug` is never null. A
+  client reading `provider` reads nothing at v83.
+
+### Renamed output — `list_approved_models`
+
+- **Each model's `provider` is renamed `vendorSlug`**, and its value changes: the vendor slug
+  (`z-ai`) where v82 served a display label that could name a host (`StreamLake`).
+
+### Renamed output, regrouped rows — `get_agent_explorer`
+
+- **Each `modelVendors[]` row's `provider` / `providerImageUrl` are renamed `vendorSlug` /
+  `vendorImageUrl`.**
+- **Rows group by vendor slug**, so every model one vendor makes shares a row whatever its display
+  label: three GLM labels that were three rows at v82 are one `z-ai` row at v83. Counts and sums add;
+  each mean is the merged total over the merged trade count.
+
+### Renamed output — the `ownerView` LLM-call envelope
+
+- **The envelope's `provider` is renamed `modelVendorSlug`**, on `get_agent_journal`, `get_signal_log`,
+  `get_agent_game_history`, `get_user_agent_game_history`, `get_public_agent_signal_log_detail` and
+  `get_public_agent_game_history`. It is `null` exactly when `modelDisplayName` is — a call whose model
+  has left the catalogue.
+
 ## Contract history — v82 (approved models lose their pin flag)
 
 **Breaking at v82: one output field removed.** v82 is the contract on top of v81.
@@ -970,7 +1073,8 @@ preview names it.
 
 - **`scalarFamilies` is where the vocabulary went.** Every report-level scalar family with its
   section, and one entry per METRIC carrying its gloss, legal condition operators, closed label
-  vocabulary, read contract (`closesReadable` / `developingRead`) and the scopes it is measured at.
+  vocabulary, read contract (`closesReadable` / `developingRead`; v84 replaces `closesReadable` with
+  `conditionHold`) and the scopes it is measured at.
   One gloss per metric with its scopes named against it, never one per pair.
 
 - **Served whole under every category.** A scalar describes the report, not a metric family, so it

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.62";
+export declare const PACKAGE_VERSION = "31.2.64";
 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.62';
+export const PACKAGE_VERSION = '31.2.64';
 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.62",
+  "version": "31.2.64",
   "description": "BattleGrid MCP server — play crypto prediction games from AI agents",
   "type": "module",
   "main": "dist/index.js",

package/skills/EXPORT.json

@@ -1,18 +1,18 @@
 {
   "generator": "battlegrid-app/server/scripts/export-mcp-skills.mjs",
-  "contractVersion": "76.0.0",
+  "contractVersion": "84.0.0",
   "files": {
     "battlegrid-agent-management/SKILL.md": "5ea8384ff76ccb9fdf00e4ec8b584f88fdba6d1c9d5679ce0b7380c23bfbaab1",
     "battlegrid-arena-play/SKILL.md": "4cfaa92a8d0dcaf477b227abd774e7aa8642c185d72108dfd401be0cf8aecd7f",
     "battlegrid-market-analysis/SKILL.md": "22fde9c4eac0261c89a8056ab8b20b66fcbe1fd58447fa0ac84fd410b4d134d7",
     "battlegrid-radar-deployment/SKILL.md": "17301fa66f4b128154435462ffa967efcb3d016df671b03c485d0f8b840fc891",
-    "battlegrid-strategy-authoring/SKILL.md": "95e91dd1ff36922b7ed0f5eb92c98def98fa39cce37c3d7447269aea1b5a017f",
+    "battlegrid-strategy-authoring/SKILL.md": "6aa3a04fd4f0624a671d70aead009f4943db1ffa34402e403b588dd998e828c9",
     "battlegrid-strategy-doctor/SKILL.md": "a3446f24059be72ae797ba4e9669848d851ac3dc38675923fe3d307f557eb82f",
-    "battlegrid-strategy-examples/SKILL.md": "a60b766de81f859f2fa9b352d65937b6a6f3eb24c4e88a064123a4985906bce5",
+    "battlegrid-strategy-examples/SKILL.md": "534c053e75021b6954e2365dbec4893ed9fc807a064a922f47f2d34a4e528221",
     "battlegrid-strategy-examples/references/playbooks.md": "02168e3af35268a30fd156f3337d25fe15e6df67da1592f4cb4d31090be3f94f",
     "battlegrid-strategy-examples/references/recipes.md": "53887daece17995543e7d3fe1bf2577fc41a6254c291acacde48d7de63853641",
     "battlegrid-strategy-examples/references/tradingview-ports.md": "2b13adbc137178955edcca31b6ab40c01c745a932a0750b91db8820c736700bb",
-    "battlegrid-trade-analysis/SKILL.md": "f49482702f17d7fc44db00c31a19fc6e9350668fe76e8948d22faaa9c7e9d6bf",
+    "battlegrid-trade-analysis/SKILL.md": "f5d817022ab912f00e9c17ffa720a7599f6e6fa4b806d873fe5e7520c51a8dcd",
     "battlegrid-trade-proposal/SKILL.md": "9bf7b7648fb009db118a3a428b15abf38df5ba56a2ef4c8a4eae3d979bdc8bcb"
   }
 }

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

@@ -115,10 +115,13 @@ question you would otherwise guess — and a refusal you would otherwise earn:
 - **The `entry` axis is required on every CREATE**, all three keys, no defaults — `trigger`,
   `levelOffsetAtrMultiple`, `validForBars`. Every trigger is decided at the close of the strategy's
   OWN bar, so there is no confirm-timeframe key; for the level triggers the level itself is derived
-  from the trigger and the trade's direction, never named. A multi-bar hold belongs to the condition
-  that needs it (its own `closes`, counted in completed strategy bars), not to this axis. The
-  `strategy-examples` skill carries the vocabulary, the hold's legality and the per-column
-  Confirmed / Developing read; a CREATE without it is refused outright.
+  from the trigger and the trade's direction, never named. A multi-bar hold belongs to the clause
+  or group that needs it — its own `hold: { atLeast, of }`, which the editor calls **Hold** (Once,
+  In a row, Within, At least), counted in completed bars of the column's own timeframe — not to this
+  axis. Every clause and group carries `hold`; `{ "atLeast": 1, "of": 1 }` is Once. The
+  `strategy-examples` skill carries the vocabulary, the served hold domain (a crossover is held
+  "within" only; a Developing column cannot be held) and the per-column Confirmed / Developing read;
+  a CREATE without it is refused outright.
 - `get_strategy_column_contract` → `outputs[].conditionOperators`. An empty array means that
   rendered header has no comparison semantics and cannot appear in a condition clause at all.
   Legality is per rendered header, not per column: a trajectory's slot header and its `_trend`

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

@@ -86,12 +86,15 @@ against a literal; neither of those shapes is what a previous-session level need
 
 ## Conditions
 
-`{ conditionKey, name, definition, verdict, required, exit, closes }` — all seven
-required, no defaults. A `clock` key is REFUSED: the per-condition evidence clock was retired in
-contract `61.0.0`. Clauses: numeric/rank headers take `lt|lte|gte|gt|between`;
+`{ conditionKey, name, definition, verdict, required, exit }` — 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`;
 classification/direction headers take `is|in` with the served vocabulary. Groups:
-`ALL | ANY | NOT | N_OF` (with `n`), depth ≤ 2. `conditionRef` composes named conditions (no
-cycles; forward refs legal). `sectionKey: null` is sugar for a report-unique header only.
+`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
+`hold` is refused (`CONDITION_HOLD_INVALID`). `conditionRef` composes named conditions (no
+cycles; forward refs legal) and carries no hold of its own. `sectionKey: null` is sugar for a report-unique header only.
 Verdicts: resolution is taken over the DISTINCT verdicts of the carriers that read TRUE. One
 distinct verdict decides, and the first carrier in declaration order carrying it is named as the
 decider — so order breaks ties between carriers that AGREE. Carriers that DISAGREE resolve
@@ -121,19 +124,55 @@ bar a condition reads is decided by the surface asking — a decision (the radar
 compose that takes the trade, the exit sweep) reads completed strategy bars; a display read shows the
 forming one and decides nothing — and by each candle column's own Confirmed / Developing selector.
 
-**The hold count.** `closes` is how many consecutive COMPLETED strategy bars must read TRUE (1–5). A
-hold counts the same completed bars whichever surface asks, so a held condition reads them on the
-display lane too. Above `1` it is legal **only** where a completed bar changes the reading: over a
-header resolved from this coin's own candle series, at offset 0, at or above the strategy timeframe,
-read Confirmed. Everything else is refused (`CONDITION_HOLD_OPERAND_ILLEGAL`) — perp-payload scalars,
-published rolling changes, ranks, zone entities, MDS regime labels, enrichment metrics, session
-scalars, a non-zero offset, a column BELOW the strategy timeframe (the retained lower series cannot
-reach an earlier strategy close), and a developing read (the bar in progress exists on the newest
-frame only). A hold also needs a clause of the condition's OWN
-(`CONDITION_HOLD_ILLEGAL`): a referenced condition is resolved once and contributes the same answer
-to every frame, so a hold that moves with the bar only through a reference would count reads that
-never happened. **Worked liquidity floor:** `LIQUID_FLOOR` holds one close because `vol24hUsd` is a
-bundle scalar. Reach for a split to keep a condition's MEANING separable, not to buy it a hold.
+**Hold — how many closes a clause counts.** A clause's `hold: { atLeast, of }` reads TRUE when the
+clause read TRUE on at least `atLeast` of its newest `of` COMPLETED bars — counted on the clause's
+OWN column timeframe, not the strategy's: a `4h` column on a `1h` strategy held 3 reads three `4h`
+bars. The editor calls the control **Hold** and offers four modes:
+
+| Mode | Hold | Reads as |
+|---|---|---|
+| Once | `{ 1, 1 }` | a single read of the bar being decided |
+| In a row | `{ n, n }` | "3 closes in a row" |
+| Within | `{ 1, n }` | "within 5 closes" |
+| At least | `{ m, n }` | "at least 2 of 5 closes" |
+
+A hold counts the same completed bars whichever surface asks. Each bar is read or unreadable; an
+unreadable bar is never replaced by an older one, and the count decides as soon as the bars read
+decide it (TRUE once `atLeast` bars read TRUE, FALSE once the rest can no longer reach it), else
+UNRESOLVED.
+
+What a header admits is SERVED, never guessed: every column in the strategy's report catalog
+(`preview_strategy_report` → `conditionColumns[].outputs[].conditionHold`, and each scalar metric in
+the vocabulary) carries `{ timeframe, maxWindow, maxAtLeast, refusal }` — the timeframe it counts,
+the largest `of`, the largest `atLeast`, and, when it admits only Once, why. `maxWindow` is the
+history the store keeps for that column, less the column's own lookback and warm-up. A hold past
+the served domain is refused (`CONDITION_HOLD_ILLEGAL`, the domain in `allowedDomain`). The reasons
+a header admits only Once:
+
+- `NOT_REWINDABLE` — the value is stored for the current bar only (session and universe scalars,
+  ranks, zone entities, enrichment metrics, published rolling changes). **Worked liquidity floor:**
+  `LIQUID_FLOOR` holds Once because `vol24hUsd` is a bundle scalar.
+- `DEVELOPING` — the column reads the bar still forming. **Developing columns cannot be held**; set
+  the column Confirmed to count closes.
+- `OFFSET` — the column already reads an earlier bar; remove the offset to count closes.
+- `BAR_STATE` — the header describes only the bar being decided.
+- `HISTORY` — not enough history is stored on that timeframe to count more than one close.
+
+Candle columns (at, above or below the strategy timeframe), the regime (counted on the regime rung),
+and the funding and open-interest histories (on the coarser of the strategy timeframe and their own
+hourly cadence) can all be held. **A crossover is an event**: it fires on the bar a state changes,
+so its `maxAtLeast` is 1 — hold a cross "within n closes", never "in a row".
+
+**Group hold — closes counted together.** A group's `hold` counts its members' joint reading on the
+same bar: the group's own outcome, its members folded by its operator, must read TRUE on at least
+`atLeast` of its newest `of` bars, counted on its finest member's timeframe. The phrases add
+"together": "together on 3 closes in a row", "together within 5 closes", "together on at least 2 of
+5 closes". Inside a group holding more than Once, every member holds Once and none is a
+`conditionRef` — each read is counted by exactly one hold — so a row holding its own closes, a
+reference, or a held group inside is refused, naming the member. A conjunction that needs a
+crossover to be TRUE (`ALL(cross, x)`) admits "within" only. Reach for a split to keep a condition's
+MEANING separable; a reference carries its condition's one answer for the bar being decided and is
+never counted across closes.
 
 **Confirmed / Developing, per candle column.** Every transform whose home is the coin's candle series
 carries `bars`: `"closed"` is Confirmed — the newest bar completed at the strategy close — and
@@ -142,18 +181,18 @@ it completes. Left unset the default is a rule, not a value: Confirmed for a col
 strategy timeframe, and at or below it the series as the frame carries it. At or below the strategy
 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: it holds one close, carries no verdict and cannot take the `exit`
-role. One exception overrides both the stored value and the default: a column reading a metric with
+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
 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.
 
 **A higher-timeframe level is measured from the current strategy-bar price.** The distance to a `4h`
 Donchian band, and every candle label classifier (`MA_ALIGN`, `PRICE_ZONE`, `BB_TOUCH`), compares
-against the frame's current price — the strategy bar's close under a decision, the live mark on
-display — not against the higher-timeframe bar's own close, which is up to one higher-timeframe bar
-stale. A distance CHAINED into a series transform keeps every slot on its own bar's close, so one
-series carries one reference basis.
+against the frame's current price, `LAST` — the strategy bar's close under a decision, the last
+traded price on display — not against the higher-timeframe bar's own close, which is up to one
+higher-timeframe bar stale. A distance CHAINED into a series transform keeps every slot on its own
+bar's close, so one series carries one reference basis.
 
 **The lane a strategy is deployed to.** Report-level scalars split by LANE, and the split is not a
 quality of the header — it is which reader runs. Market breadth and the reference pairs are ordinary
@@ -232,8 +271,8 @@ and is REFUSED on every save; there is no live-reading entry to author.
   short) by the offset, waiting for a return to it. Not filling is a correct outcome, not a
   failure; no unrecovered break in memory means no setup, never a fallback level.
 
-**A multi-bar hold belongs to the CONDITION that needs it.** Declare that condition's own `closes` —
-the entry axis counts no bars, and there is no displacement band: the
+**A multi-bar hold belongs to the CLAUSE (or group) that needs it.** Declare that clause's own
+`hold` — "3 closes in a row", "within 5 closes" — the entry axis counts no bars, and there is no displacement band: the
 platform's entry-deviation gate measures the live mark against the decided close and refuses a fill
 that drifted past the budget in either direction.
 

package/skills/battlegrid-trade-analysis/SKILL.md

@@ -14,7 +14,7 @@ Start with where the money is, always, even when the question is narrower — a
 means nothing without the whole.
 
 - `get_account_state` for the account total.
-- `get_agent_fund_allocation` and `get_agent_budget` for what is committed per agent.
+- `get_agent_budget` for each agent's capital at risk, and `get_agent_fund_allocation` for its funding envelope.
 
 Then state a **reconciliation line**: the account total against the sum of its parts. If they
 agree, say they agree. **If they do not, state the gap as a gap** — name the amount and say you