SQD Portal MCP v0.8.5

Portal MCP v0.8.5 turns the SQD Explorer into a data-first beta app that fits its host and is clearly opt-in, corrects fifteen kinds of case where a tool answered with something it should not have, and gives operators cost guardrails and an end-to-end trace of a single tool call.

Correctness

• A network name always means that network. Aliases were matched as substrings in both directions against tokens as short as op, eth and btc, so opbnb answered with Optimism's chain head, ethereum-holesky with Ethereum mainnet, and btc-testnet with Bitcoin mainnet, each with the evidence receipt recording the name that was asked for. Matching is now whole-name, a real dataset beats a nickname, and a network SQD does not carry returns unknown_network instead of a neighbour's data.
• portal_get_time_series no longer answers metrics it does not compute. Nine of its fifteen metrics returned an all-zero series on EVM networks, marked result_complete: true with no empty buckets and a receipt hashing the zeros, so "success rate averaged 0%" was indistinguishable from a real answer. Each chain family now declares what it computes and anything outside that set is refused with unsupported_operation.
• A wallet summary no longer reports a complete result over a section that failed. _coverage.result_complete was keyed off pagination alone, so a summary whose transactions never arrived still reported complete beside its own failed_sections: ["transactions"]. It now requires the window to be covered and every section to have arrived, and names any that did not.
• Maker rebates are no longer counted as fees collected. A Hyperliquid maker rebate arrives as a negative fee. The fills summary was fixed to sum fees signed; portal_hyperliquid_get_analytics kept its own copy of the arithmetic and still summed absolute values, so a window whose makers were paid rebates was reported as one that collected fees, in total_fees_usd, total_fees_formatted and the per-coin fees_usd. The second copy survived the first fix because it sat inside a streaming callback that only a live Portal window could reach; the per-fill arithmetic is now a plain function that six unit tests hold.
• A summary asks for the fields it adds up. A summary that aggregates fields its field preset never requested answers with a confident zero rather than an error. Three tools did it. Trace summaries at field_preset: "minimal" reported total_value_eth of 0 and no top_sighashes; portal_evm_query_transactions reported total_gas of 0, because the minimal preset asks for hash, index, type, from, to and value and not gas; and portal_hyperliquid_query_fills with include_pnl: false reported total_realized_pnl of 0. A summary now reads at least the standard field set, and asks for closedPnl whatever the flag says, because it replaces the rows rather than listing them. A listing still follows the flag.
• One response gives one answer about its window. A Bitcoin fee series came back with _coverage.window_complete: false beside gap_diagnostics.window_complete: true. The two fields share a name and answer different questions, the diagnostics about whether observed data covered the buckets and _coverage about whether the analysed window can be proved to be the one that was asked for, and only _coverage was reconciled against an estimated boundary. A downgrade on either now applies to both. The same series reported expected_buckets: 8 beside returned_buckets: 10; the fee series spans the blocks it scanned rather than exactly duration, because dropping a scanned block would take its fees out of the buckets while leaving them in the window total, so coverage now reports the series it built.
• A bounded scan says how much of the window it read. _coverage.window_complete defaults to true, so a scan that stopped early reported the blocks it never opened as analysed. Four tools were affected: both Tron query tools, portal_evm_query_token_transfers, which stops as soon as the page is full and had reported a 5,000-block window as read after 100 blocks, and portal_evm_get_contract_deployment, which stops at max_scan_blocks and had reported a capped search that found nothing as proof the contract was not there.
• Long time-series windows are refused instead of run. The tool reads every block in the window, so 7d on a two-second chain is 302,400 blocks: it went four minutes without answering and reached 1.9 GB of memory. Windows over 12,000 blocks are now refused with the block count, the bound, and a duration that fits on that chain. A window far over the bound by the chain's own block time is refused in milliseconds, before the two timestamp lookups that used to make the refusal itself take about ten seconds on Ethereum; a borderline window still waits for the exact block count. The limit is blocks rather than time, so 24h still works on Bitcoin and Ethereum and is refused on Base.
• An oldest-first scan can be continued. scan_order: "earliest" on portal_evm_query_logs, portal_evm_query_token_transfers and portal_evm_query_traces answered has_more: true with no cursor, _coverage.continuation claimed a cursor or denied one at random, _ordering described the page as the most recent matches, the answer said the newest blocks had been read, and a notice told the caller to page forward. portal_evm_query_transactions already had a working forward cursor; the other three now use the same offset-based one. _pagination.has_more is true exactly when a cursor is present, _coverage.continuation is derived from that cursor when the response is assembled rather than claimed by each tool, an oldest-first page says so in _ordering and in prose, and the cursor notice names its direction. A capped scan says whether a bigger max_scan_blocks or the cursor is the way to the rest. A live gate, test:scan-order, follows the cursor on all four tools and checks that the blocks, the coverage and the prose agree.
• A window that was not read through says so. A backward scan stops once its page is full, and every tool that reads that way called the requested window complete regardless, so a page from the newest block alone reported the hour below it as read. The fetch now reports whether it reached the window start and _coverage.window_complete follows it in the ten tools concerned. The answer discloses it too, cursor or no cursor, and a capped portal_evm_get_contract_deployment miss says which blocks it searched instead of reading as a complete answer. result_complete keeps its own question, whether there is more to fetch: folding coverage into it would leave no field meaning "there is a next page" and make a deliberately trimmed window, such as portal_evm_get_contract_activity in fast mode, read as a paginated result.
• Hyperliquid tools take Hyperliquid datasets and addresses only. hyperliquid-mainnet is HyperEVM, an EVM chain, and the resolver handed it to the fills, analytics, OHLC and replica-command tools, which failed inside the Portal as a malformed request. They now refuse it with the unsupported-chain error every other tool gives and point at the EVM tools. A user, builder or vault_address filter that is not an address was streamed as written and answered as a complete, empty window; it is rejected as invalid_request before any request is made.
• Token amounts are formatted with the token's decimals or shown raw. Unfiltered portal_evm_query_token_transfers formatted every amount with 18 decimals, so a USDC transfer of 4,238.51 read as 0.000000000004. The token list is consulted whenever there are rows to format, not only when the caller asked for token info, and a token the list does not know shows raw units with a notice instead of a wrong number.
• The catalog finds the nicknames the resolver accepts. portal_list_networks with query: "btc" returned nothing while btc resolved to bitcoin-mainnet. The catalog now matches and lists the server's own aliases beside the Portal's.
• The time-series metric list says which chain family computes what. portal_get_time_series accepts fifteen metrics and each chain family computes a subset, so a client could be sent after success_rate on an EVM network and get an unsupported_operation it had no way to predict. The metric description now names the metrics per family. That grows the tool's catalog entry by 72 tokens, past the 5% the catalog gate allows, so the token baseline was refreshed for it with npm run baseline:catalog-tokens -- --note.
• mode: "fast" reports the window it read. Fast mode reads the newest 1,500 blocks of a longer EVM window on purpose, then bucketed them against the requested duration: a 6h window on Ethereum was called complete with an hour unread, and 24h failed as an incomplete bucket set. The slice is bucketed over its own span, _coverage and gap_diagnostics mark the window incomplete, and a notice says how much was read and that mode: "deep" reads all of it.
• portal_bitcoin_query_transactions says when a page can outgrow the response budget. With inline inputs and outputs in full format, a page near the maximum of 25 exceeds the 50,000-byte response budget and fails closed with the limit to retry with; the limit description now says so.

Operations

• Cost guardrails. MCP_GUARDRAIL_MODE of off (default), shadow or enforce, with per-class ceilings on scan blocks, window seconds and upstream bytes through MCP_GUARDRAIL_<CLASS>_<LIMIT>. There are no numeric defaults, so off and enforce with nothing configured are the same server. Shadow counts what enforcing would cut without changing a response; enforce reports a capped scan through the existing partial-coverage path and refuses an over-cap window before any upstream call. Four Prometheus counters and a Grafana panel.
• Traces, off unless asked for. Metrics say how often and how long; a trace says where the time went inside one call. Set OTEL_EXPORTER_OTLP_ENDPOINT and one tool call arrives as one tree: the MCP request, the tool call, the wait for an admission slot, one span per Portal fetch attempt with its dataset, status, bytes and resend count, and the hashing pass that builds the evidence receipt. A traceparent on the HTTP request or in the tool call's _meta joins the caller's trace, each Portal request carries a traceparent of its own so a Portal-side trace can join, and the JSON log lines carry trace_id and span_id. OpenTelemetry is an optional peer dependency, not a dependency: with the endpoint unset nothing is imported, allocated or sent, and the packages need not be installed. Span attributes carry no arguments, addresses, hashes, cursors or free text; MCP_OTEL_INCLUDE_ARGS=1 adds the raw arguments and is documented as unsafe for production.

Highlights

• Beta, opt in: the Explorer is labelled Beta in the widget, in the resource description, and as _app.stage. It stays off by default. MCP_APP_ENABLED=true enables it for a deployment; ?app=1 and ?app=0 on the connection override that in either direction. /health reports app.enabled, the deployment's setting as the restarted process sees it, so turning it on or rolling it back can be confirmed without a tool call. docs/explorer-design.md records what the app is held to, why, and how to turn it on and off again.
• Fits the host: the inline card reports its exact content height, so hosts no longer pad it with blank space. Structural colours follow the host's MCP Apps style variables in light and dark with SQD design-system fallbacks, and full screen opens a two-column workspace.
• Data, not narrative: each result is headed by its subject (address, market, or network window) and the primary number leads the metric row. Receipt lines, context chips, caller-facing notices, and chart range sliders leave the view; the JSON keeps them.
• Explorer links and chain identity: addresses, transaction hashes, and blocks link to the public explorer for their network (Etherscan family, Solscan, mempool.space, Subscan, Hyperliquid, Tronscan). Network chips show the chain logo and display name from SQD network metadata, regenerated with npm run sync:chains.
• One chart engine: every chart the Explorer draws (line, area, bar, and candle) now renders through the same charting library the candle chart already used, replacing a second hand-written SVG renderer that had drifted from it in axis ticks, hover behaviour, gap handling, and palette. Sparse series keep their gaps: a missing bucket leaves a hole instead of a straight line drawn through it, because each unbroken run is drawn as its own series over a shared whitespace timeline that holds the empty slots open. Candle charts keep their fixed two-line readout (time and OHLCV, then fills, VWAP, size, and open or partial bucket state) instead of a floating tooltip, so hovering never resizes the chart, and labels render at native size in the terminal palette.
• The chart surface declares what it has: src/app-ui/capabilities.ts states what the charts actually implement (hover, crosshair, snap to data, zoom on the time axis, a legend that switches a series off, reset zoom, and range presets) and what they do not (no drag-a-box-to-zoom, no PNG export). The app reads it when deciding whether to draw a control, and test:app-contract holds the server's tool contract against it, so a control cannot be promised to a model without existing. For two releases the contract offered a PNG export and a visual switch that were never built.
• A follow-up no longer throws the view away: every render rebuilt the whole app, so asking a follow-up destroyed and recreated every chart, losing the zoom, the hidden series, and the scroll position, and flashing the panel on the way. A render whose payload and structure are unchanged now updates the header in place and leaves the charts running, so a pending follow-up dims the view rather than replacing it.
• A view file that can be reviewed: src/app-ui/view.ts had grown to 3,157 lines holding the shell, both chart renderers, the tables, the panels, and every empty and error state, which made any change to one of them a diff against all of them. It is now eight modules with a one-way import graph (common, charts/range, charts/terminal, masthead, tables, panels, states, and a 167-line view entry point). Behaviour is unchanged: the layout baseline matched all 78 recorded cells before and after the split.
• The Explorer's design decisions are written down: docs/explorer-design.md records what the app is held to, where each rule comes from, the two places it deliberately departs from the chart spec and why, and how a visual change is reviewed. scripts/app-ui-baselines/layout-<platform>.json locks the box of 26 selectors across 78 fixture, viewport, and theme combinations and fails on a one-pixel move, naming the selector and both numbers; refresh it deliberately with npm run baseline:app-ui. npm run contact-sheet:app-ui renders every recorded fixture at three widths in both themes for review, and the pull request template asks for both whenever src/app-ui/ changes.
• Short pages, full data: ranked and timeline panels show ten rows with one Show all control, tables page ten rows with search across every row, identifier cells link out, and missing values are blank rather than "n/a".
• Every action verified in a host: Load older, Back, Forward, JSON and CSV downloads through the host download request, Full receipt, row dialogs, explorer links, filter, sort, and Exit full screen are driven through the official AppBridge in test:app-host.
• Truthful Bitcoin fees: portal_bitcoin_get_analytics sums fees in exact satoshis from inputs and outputs over the newest 36 blocks of the analyzed window, reports that block set with exact satoshi and BTC totals, and marks a sample-scoped scan in the answer, notices, _coverage.sections, execution notes, and receipt instead of presenting it as a window total. The fees_btc time series now computes real per-bucket fees whose sum reconciles to the window total. Time-series and candle summaries declare their bucket alignment (anchored_to_latest_block versus interval_boundary) so they are not joined bucket for bucket by mistake.
• Hyperliquid fill summaries: portal_hyperliquid_query_fills with response_format: "summary" returned internal_error instead of aggregates. Fill amounts are normalized to exact decimal text, so adding realized PnL built a string and the aggregate step then failed. Every summary aggregate now parses its amounts before adding them, and unparseable or missing values count as zero rather than producing null totals. The summary returns the fill count, unique traders and coins, volume, fees, realized PnL, the direction breakdown, and the top coins by volume alongside the usual _coverage and _pagination blocks. The same coercion covers the Bitcoin input, output, and transaction-size aggregates, which normalize amounts the same way. npm run test:unit covers the aggregates and npm run test:tools calls the summary format against live Portal data.
• The required check can now pass, and says so for the right reason: the offline gate had failed on every push, always on the same cell, because the Explorer layout baseline is recorded in the pinned Playwright image and the gate measured on a bare runner. Different fonts, every text box about ten percent wider, nothing in the markup changed. The gate was reporting a real difference, so neither re-recording it nor loosening the tolerance was the answer: the job runs in that image now, and npm run test:workflow-pins holds the image tag in the workflow and in baseline:app-ui:ci against the locked Playwright version, so a dependency bump cannot re-font the comparison quietly. Two more environment assumptions went with it. The Docker image build died on ERR_MODULE_NOT_FOUND because a new bundler plugin was added to the build and not to the .dockerignore allowlist, and MCPB packaging shelled out to zip and unzip, which that image does not carry; both now use the official MCPB CLI. npm run test:distribution gained two checks for the class: every file npm run build reaches has to be let into the image, and everything the offline gate runs may use node and npm and nothing else.
• Fast, honest CI: pull requests run npm run test:offline (build, Biome lint, typecheck, unit tests, and every suite that needs no Portal access) as the required check; npm run test:live runs the Portal-dependent suites and reports without blocking. A main push publishes edge from the offline gate; a release tag runs the full matrix. Playwright's browser is cached between runs.
• Lint, typecheck, and unit tests: npm run lint, npm run typecheck, and npm run test:unit (node --test on src/**/*.test.ts) cover timeframe parsing, exact decimals, signed cursors, address validation, coverage rules, Bitcoin fee accounting, and a wallet-summary characterisation on a recorded response. One formatting commit, listed in .git-blame-ignore-revs, brought the repository to Biome's format; generated files are excluded and the blanket rule overrides are gone.
• Native Tron query tools: portal_tron_query_transactions (native TRX transfers, TRC-10 transfers, smart-contract calls by contract and method, or any contract type, with inline logs and internal transactions) and portal_tron_query_logs (TVM event logs by contract and topics with event aliases, the parent transaction hash on every row, and inline decoding). Addresses may be given as Base58, 41-prefixed hex, or 20-byte hex and are converted to the form Portal expects in each position; results carry both hex and Base58, second-precision timestamps beside the raw millisecond values, and amounts labelled by what they actually are: amount_sun with amount_trx on a native TRX transfer, and asset_amount in the asset's own base units on a TRC-10 transfer, which is never counted as TRX. Malformed addresses, wrong checksums, and filters that do not fit the chosen transaction kind are rejected before any Portal request. The catalog grows from 28 to 30 tools, tron is a toolset, and test:data-integrity checks both tools against direct Portal rows.
• EVM traces: portal_evm_query_traces returns the execution traces under a transaction: internal calls, contract creations, self-destructs, and block rewards. Filter by trace type, caller, callee, 4-byte selector or method alias, deployer, or created contract, or pass transaction_hash with its block to get the full internal call tree of one transaction. Portal's nested action and result objects are flattened into stable fields (call_from, call_to, call_sighash, value_eth, gas_used, created_contract_address, success), every row carries the parent transaction hash and a deterministic id built from that hash and the trace address, and rows sort by block, transaction index, then trace address. Scans are bounded with a continuation cursor and the usual coverage disclosure; unfiltered windows stay small on purpose because traces are the heaviest Portal table. The catalog grows from 30 to 31 tools, and test:data-integrity checks a pinned transaction's traces against direct Portal rows.
• A response-size baseline that can be refreshed: scripts/quality-baseline-v0.7.9.json was pinned to a release from long before this one and had to be edited by hand, so three tools failed the size gate simply because the data behind them grew. It is now scripts/quality-baseline.json, written by npm run baseline:quality -- --note "<why>", and it records the package version it was measured at, the capture time, the sample count, and the reason it was taken. Budgets are the measured median and p95 plus 10 percent headroom. The current baseline covers all 31 tools and the size gate passes with no failures.
• Model-in-the-loop eval: npm run eval:model-loop has a model answer 21 pinned questions (18 across EVM, Solana, Bitcoin, Substrate, Hyperliquid, and Tron at fixed blocks, slots, and timestamps, plus an unsupported network, a malformed address, and a future window) through the real server and grades the final answer. It records tool calls, tokens, and wall time per question, writes a JSON artifact and a Markdown summary, and fails under a 90% pass rate or a 20% rise in median tool calls over the previous runs. --model mock replays the recorded reference calls to check the answers against live Portal data without an API key. A nightly workflow runs it with ANTHROPIC_API_KEY and keeps the artifacts.
• Fair admission per caller: tool admission now keys work by hashed connection (the address the trusted proxies observed with MCP_TRUST_PROXY, otherwise the socket address; never stored or labelled). One caller holds at most MCP_TOOL_CLIENT_WEIGHT_SHARE percent of the weight budget (default 50) and MCP_TOOL_CLIENT_MAX_QUEUE queued calls; over that it receives the retryable overloaded result with reason: client_share while other callers keep flowing. mcp_tool_admission_active_by_family and the client_share rejection reason are exported, and calls slower than MCP_SLOW_REQUEST_MS log one JSON line with admission wait and execution timings.
• Public repository hygiene: SECURITY.md (private reporting only), CONTRIBUTING.md, CODE_OF_CONDUCT.md, a pull request template that mirrors the offline gate, bug and feature issue templates, CODEOWNERS, and AGENTS.md with the build, test, and release commands. .gitignore names the local planning files it protects instead of ignoring every Markdown file. RELEASE_ASSURANCE.md now leads with the current contract and keeps a short history; scripts/README.md lists every suite with its gate; the README and the directory submission packet describe the server as it is.
• One-click Claude Desktop install: every release ships sqd.mcpb, an MCP Bundle with the server, its production dependencies, and an optional "SQD Explorer (beta)" setting. npm run package:mcpb builds it from the local install with no network, validates the manifest with the official CLI, and fails above 15 MB; npm run test:mcpb unpacks and starts it in the offline gate. Directory Health checks the asset on the current release.
• Toolsets: every tool belongs to one of nine toolsets (discovery, convenience, evm, solana, bitcoin, substrate, hyperliquid, tron, debug). MCP_TOOLSETS (or MCP_TOOLS for exact names) trims a deployment's catalog at registration time, so production can run without the debug tools; ?toolsets= or X-MCP-Toolsets narrows a single HTTP connection and can never widen it. Prompts that name a disabled tool are not offered, the instructions follow the active set, and mcp_tool_client_calls_total carries the bounded active set. With nothing configured tools/list is unchanged, which the catalog token gate checks.
• Reviewable UI diffs: the generated Explorer bundle is no longer tracked in git. npm run build regenerates it, and dev, typecheck, and the source-importing test scripts rebuild it only when it is missing or older than its inputs, so a fresh clone works with npm ci && npm run dev and merges stop conflicting on a minified blob.
• Third-party text is data: token-list names and symbols, pallet, call, event, program, and coin labels are listed in _tool_contract.untrusted_fields and reach prose only cleaned and quoted (control, zero-width, and bidi characters removed, length capped, plain tickers such as USDC unchanged). Structured fields keep the raw value byte for byte. The shared formatter and the error envelope clean every prose field once more, the Explorer renders values as text, and CSV export neutralises formula prefixes. The policy is written down in RELEASE_ASSURANCE.md.
• Frugal catalog, measured: npm run test:catalog-tokens counts what every session pays for tools/list, prompts/list, resources/list, and the instructions, per tool and for both the App-disabled and App-enabled surfaces, and fails the offline gate when the total or any tool grows more than 5% over scripts/catalog-token-baseline.json. The shared output schema now leaves free-form blocks untyped with short descriptions (767 to 485 tokens per tool), and the per-tool "MCP APP" paragraph moved into the server instructions once. Measured with o200k_base: the App-disabled catalog fell from 42,578 to 34,682 tokens and the App-enabled catalog from 45,721 to 36,824.
• Hardened HTTP transport: the server binds loopback by default and checks Host and Origin on every route (loopback always passes, requests without Origin pass, MCP_ALLOWED_HOSTS and MCP_ALLOWED_ORIGINS extend the list, * switches a check off). A non-loopback bind without those lists logs a startup error. Header, request, and keep-alive timeouts and a MCP_MAX_BODY_BYTES cap (413 before parsing) bound every request. /ready answers 200 only once the dataset catalog has loaded and the latest Portal probe is fresh, with Retry-After on 503; the Docker image's health check uses it and sets MCP_BIND=0.0.0.0.
• Traceable builds: /health and every tool result's _server block report the git commit the image was built from, and the image carries it as an OCI label. Docker Hub latest now means the latest v* tag; main pushes publish edge and sha-<commit> instead.
• Release from the changelog: pushing a v* tag creates the GitHub release with the dated changelog section as its body and uploads the Gemini extension archive, alongside the registry publication and the Docker image, with no manual step in between.
• One Node runtime: Node 22 across .nvmrc, .mise.toml, the Dockerfile, every workflow, and the engines field.
• Workflow supply chain: every GitHub Action is pinned to a full commit SHA with a version comment, checkouts drop their credentials, workflows start from empty permissions and grant per job, release images do not share a layer cache with edge builds, Renovate keeps the pins current, and npm run test:workflow-pins guards all of it.
• Directory Health that means something: the daily check reads the Smithery registry API instead of a browser-rendered page, reports pending review queues without failing, and turns red only when a required listing regresses.
• A fair share the caller cannot help itself to: the admission key mixed in the client family, which is whatever the client calls itself in clientInfo, so one connection could claim a share per name it declared. The key is now the connection alone, and the family stays on the metric label where it describes traffic instead of granting budget. MCP_TRUST_PROXY also read the leftmost X-Forwarded-For hop, the one part of that header a caller writes itself: a new value per request meant a new identity per request and no limit at all. Three things changed. The header is read only when the immediate peer is a trusted proxy, because the setting alone was never a trust boundary and a caller reaching the origin directly could still forge its own identity; loopback and private ranges are trusted by default and MCP_TRUSTED_PROXY_PREFIXES names the proxies when they are elsewhere. The hop is counted from the right, and MCP_TRUST_PROXY accepts the number of proxies in front of the server, so a header shorter than that chain falls back to the socket address. Addresses are canonicalised before hashing, so 203.0.113.9, ::ffff:203.0.113.9, and 203.0.113.9:51234 are one caller rather than three.
• Prompts and guides follow the active toolset: the toolset selection lives in a scope that wraps tool registration, so anything asking whether a tool is active from a later callback saw the full catalog instead. sqd://tools therefore listed all 31 tools and routed callers through tools a trimmed deployment does not serve, and the investigation prompts and sqd://investigations still walked through portal_evm_query_traces with the EVM toolset switched off. The selection is now captured while registering and honoured afterwards: the guide lists, counts, starting points, and routes cover only registered tools, each investigation step names only the tools that are actually there and is dropped when none is, and a prompt is offered only when every step it cannot run without has a tool. The server instructions are built the same way: they named both Tron tools and four Explorer example tools unconditionally, and now name only what the selection registers and describe only the chain families it serves. Because these resources vary by connection, their cache hint is private, so a full-catalog client's copy is never replayed to a trimmed one. With MCP_TOOLSETS=discovery,convenience the guide reports 7 tools of 7 registered, and no served surface names a tool that is missing: not the instructions, the tool guide's notes and routes, a tool entry's own advice, the investigation guide, or a rendered prompt. An investigation the connection cannot run is no longer published at all, and a prompt's network argument is built per connection: a Hyperliquid-only deployment used to suggest ethereum-mainnet for the market investigation, accept it, and render a Hyperliquid-only workflow beside it, so the first tool call failed against a dataset with no fills table. A network is now offered, and accepted, only when a tool that can query its chain is registered. A unit test extracts every portal_* name from the instructions under nine selections, including an exact-name MCP_TOOLS deployment, which keeps every toolset while registering two tools and so defeated a check written against toolsets alone.
• Truncated lists say so: portal_resolve_entity ranks its candidates and cuts the list to limit, then reported the cut length as match_count under the default coverage that declares a result complete, so a query matching 58 protocols answered as though 3 were all of them. Each resolver now returns how many candidates it matched. The answer, a notice, total_match_count, and _coverage.result_complete all state the truncation, _pagination.has_more stays false because there is no next page to request, and the caller is told to raise the limit or narrow the query. Pool resolution also bounds its own candidate search and skips a failed lookup, so its total counts what was searched rather than what exists; a bounded search now says so instead of reporting a complete result. A result that declares no continuation no longer draws the shared formatter's "continue with the cursor" sentence, which named a field the response does not carry.
• Gates that actually gate: the repository had two lockfiles. CI installed from package-lock.json, the Docker image installed from pnpm-lock.yaml, and nothing compared them, so the two trees drifted until a dependency difference broke the image build with every check green. There is now one lockfile: the image installs it with npm ci, and npm run test:lockfiles fails if a second lockfile appears, if package.json drifts from it, or if the Dockerfile stops installing it. Three more gates were reporting success without checking: npm run test:workflow-pins read a fixed seven lines after each checkout, so it failed a workflow that set persist-credentials: false below a longer with: block and passed one that never set it at all; three rounds of review then holed its replacement three more times, each in a different way, so it no longer scans text at all. It parses each workflow as YAML and reads the step: uses must be a 40-character SHA carrying a version comment, and actions/checkout (matched case-insensitively) must set persist-credentials to false as a key of its own with: mapping. Flow mappings, block scalars, comments, indentation, and line endings stop being the gate's problem. Twenty-four workflow fixtures, one per construct that fooled a previous version, now run before the real workflows do: twelve that must pass and twelve that must fail, so the gate is checked before it checks anything; CI skipped every check on a documentation-only pull request (the path filter is gone, and the gate reads those files anyway); and the Tron transaction summary assertions were nested inside an isError check, so an erroring summary skipped its own assertions instead of failing.
• Real data everywhere: UI fixtures are recorded Portal responses (scripts/record-app-fixtures.ts), and npm run app:host runs a local MCP Apps host with live tool calls for trying the Explorer.

Full Changelog: v0.8.4...v0.8.5