echelongraph-mcp 2.7.2 → 3.0.2

package/dist/fixStatus.js

@@ -0,0 +1,30 @@
+// fix_status (#2841, #2518 item 3): the API's fix-status rule for a CVE (core-backend
+// internal/cve/fixstatus.go, the rule CVE Pulse pages render), as get_cve's remediation summary
+// (its first field) and cve_remediation's answer carry it. Relayed, never derived here.
+//
+// A module of its own, importing only zod: index.ts and tools/cve_remediation.ts import each
+// other, so a const shared between them would be read before it is initialised whichever loads
+// first.
+import * as z from "zod";
+export const FIX_STATES = ["available", "fix_referenced", "fix_merged", "none_confirmed", "unknown"];
+export const FIX_STATUS_FIELD = "The API's fix-status rule for the CVE, the one CVE Pulse pages show: state is available (a fix is on record), fix_referenced (a reference tagged Patch, often a source commit, and no release confirmed), fix_merged (an upstream fix merged, not yet in a tagged release), none_confirmed (no fix evidence on record, which is not a finding that no fix exists) or unknown (an input could not be read). basis is the step of the rule that decided it; described_by is the CVE description's sentence naming the fix, solution_by the CVE record's solution sentence naming it (statement) and the CNA that wrote it (cna), stated_in_record that patch_evidence counts a fix the CVE record states with no sentence to quote, listed_in_patch_table that a fixed version or patch row is on record; unread_inputs names any input the API could not read. vendor_released (basis vendor_fix_released) is the vendor's own statement that a fix is released where the CVE record names no fixed version: its sentence, verbatim (statement, or null), never a version, so the fixed release is the vendor advisory's to name. solution_by's section is workarounds when the fix sentence is the record's workaround, not its solution.";
+const opt = (t) => t.nullable().optional();
+export function fixStatusSchema() {
+    return z
+        .looseObject({
+        // A state a later API adds is admitted, never a failed call.
+        state: opt(z.union([z.enum(FIX_STATES), z.string()])),
+        basis: opt(z.string()),
+        described_by: opt(z.string()),
+        // #3076 (merged from 24dad5eb): the CVE record's own fix sentence, and its CNA.
+        solution_by: opt(z.looseObject({ statement: opt(z.string()), cna: opt(z.string()), section: opt(z.string()) })),
+        stated_in_record: opt(z.boolean()),
+        listed_in_patch_table: opt(z.boolean()),
+        // #3076, third pass: the vendor's released-fix statement with no version (cause G).
+        vendor_released: opt(z.looseObject({ statement: opt(z.string()) })),
+        unread_inputs: opt(z.array(z.string())),
+    })
+        .nullable()
+        .optional()
+        .describe(FIX_STATUS_FIELD);
+}

package/dist/httpPolicy.js

@@ -295,7 +295,7 @@ export class Slots {
 //   - V8's heap. In that sandbox (a cgroup v1 on a 16 GB host) Node 22 sized V8's heap from the
 //     host's memory, not the cgroup's (heap_size_limit 8,195 MiB in 256 MiB), so V8 left the
 //     garbage of the requests served (~1 MB each) uncollected until the kernel killed the
-//     instance. So the image caps V8's old space at 128 MiB (Dockerfile.http), and V8 collects
+//     instance. So the image caps V8's old space at 104 MiB (Dockerfile.http; 128 until 3.0.2), and V8 collects
 //     first. On Cloud Run this is not verified: an instance that shows Node only its 256 MiB gets
 //     a default heap near the cap already, and then the cap changes little. Its start-up line says
 //     which (heap_limit_mb; memory_limit_mb, null where Node is told no limit).
@@ -482,7 +482,22 @@ export function uaFamily(ua) {
 // method name), so the message is never logged. It is matched against the SDK's own fixed
 // prefixes and only the matching label is logged; anything unrecognised is "other". A
 // ProtocolError also carries its numeric JSON-RPC code, which is content-free.
+//
+// #2923 (2.7.1 audit, 2026-10-10): 78 of 78 production lines were "other": the list held the legacy
+// transport's messages, not those of the bundled SDK's createMcpHandler (@modelcontextprotocol/server
+// 2.1.0 dist/index.mjs), which reports "Rejected inbound request (<cell>): …" (:1346, :1384, :1458),
+// "Rejected 2025-era request on a modern-only endpoint (<cell>): …" (:1438), an
+// UnsupportedProtocolVersionError, "Unsupported protocol version: <requested>", code -32022 (:1338;
+// src-D-y6h4N7.mjs:3693), and a MissingRequiredClientCapabilityError, "Missing required client
+// capabilities: …" (:1357; src-D-y6h4N7.mjs:3727). The legacy transport's own wording is
+// "Bad Request: Unsupported protocol version: …" (index.mjs:896). All of these lead the list, each
+// with its fixed prefix only (the cell and the rest can name the client's method or version).
 const HANDLER_ERROR_CLASSES = [
+    ["Rejected 2025-era request on a modern-only endpoint (", "rejected_legacy_on_modern_only"],
+    ["Rejected inbound request (", "rejected_inbound_request"],
+    ["Unsupported protocol version", "unsupported_protocol_version"],
+    ["Bad Request: Unsupported protocol version", "unsupported_protocol_version"],
+    ["Missing required client capabilities", "missing_client_capability"],
     ["Not Acceptable", "not_acceptable"],
     ["Unsupported Media Type", "unsupported_media_type"],
     ["Method not allowed", "method_not_allowed"],

package/dist/index.js

@@ -16,8 +16,9 @@
 //     what it left out (readKEVExposure, readExposedDatabases, readLeakedCredentials,
 //     readShadowAI and readMCPServers; #2307, #2313, #2315). content[2] is the envelope below,
 //     as JSON, less what content[0] and the note already say. Past 30,000 characters of JSON,
-//     content[0] is that JSON cut to fit and the note ends by saying how (TEXT CUT); the
-//     envelope's data is always the answer whole (textBudget.ts, #2783).
+//     content[0] is that JSON cut to fit and the note ends by saying how (TEXT CUT, #2783); past
+//     30,000 characters of structured result, the envelope's data is cut too, unless the call
+//     says full: true, and the note says how (DATA CUT, #3013; both in textBudget.ts).
 //   - failure (isError: true): the lookup did not complete — unreachable host, non-2xx,
 //     timeout, or a 2xx whose body is not a JSON object — named by tool, cause and base URL,
 //     in content[0]; content[1] is the envelope below, as JSON, less the message's sentences.
@@ -27,18 +28,23 @@
 // Structured results (#2311, #2313). Every result, success or failure, also carries
 // structuredContent: one envelope that says how the answer was measured — state (measured,
 // not_assessed, failed, invalid_input), measured_at, method, coverage, freshness and notes —
-// with, on a success, `data`, the answer whole, and on a failure an `error`. content[0] carries
-// `data` as JSON up to 30,000 characters, and past them a cut of it that the note names (TEXT
-// CUT, #2783), so past them content[0] is not equal to `data` (#2802). Each tool advertises the
-// envelope as its outputSchema.
+// with, on a success, `data`, the answer, and on a failure an `error`. content[0] carries the
+// answer as JSON up to 30,000 characters, and past them a cut of it that the note names (TEXT
+// CUT, #2783), so past them content[0] is not equal to `data` (#2802). `data` is the answer whole
+// unless the whole structured result would pass 30,000 characters of JSON: then, unless the call
+// says full: true, its lists are cut in the order the tool names (DATA CUT, #3013), data_truncated
+// is true and truncated gives each list cut (data_truncated is false otherwise). Each tool
+// advertises the envelope as its outputSchema, which `data` validates against cut or whole.
 //
 // The envelope in the text (#2440, #2467). Many clients pass only `content` to the model, so the
 // last text block of every result is structuredContent serialized as JSON, less what an earlier
 // text block already carries: `data` (content[0] on a success, whole or cut as above), the note's
 // sentences (the block just before, which structuredContent's notes end with), and method where
 // that note quotes it. The rest — state, measured_at, coverage, freshness, the envelope's own notes
-// and, on a failure, error — is copied key for key, so the text blocks together are the whole of
-// structuredContent, but for what a TEXT CUT leaves out of `data`, and cannot disagree with it. The
+// and, on a failure, error; on a success data_truncated and truncated — is copied key for key, so
+// the text blocks together are the whole of structuredContent, but for what a TEXT CUT leaves out
+// of the answer, and cannot disagree with it. Beside a DATA CUT (#3013) content[0] is still cut from
+// the answer whole, not from the cut data, so it can hold entries data leaves out. The
 // MCP spec (2025-06-18, Tools, Structured Content) asks a tool that returns structured content to
 // return it serialized in a text block too; the JSON block stays first and the note second, as in
 // 1.x, so a client that parses content[0] still parses the answer's JSON, which past 30,000
@@ -59,13 +65,14 @@ import { registerCheckSbom } from "./tools/check_sbom.js";
 import { registerScanManifest } from "./tools/scan_manifest.js";
 import { registerCveIntel } from "./tools/cve_intel.js";
 import { registerCveRemediation } from "./tools/cve_remediation.js";
+import { fixStatusSchema } from "./fixStatus.js";
 import { registerGetCwe } from "./tools/get_cwe.js";
 import { holdRequest, isHttpEntrypoint, requestSignal, upstreamHeaders, upstreamUserAgent } from "./runtime.js";
 import { registerVendorAdvisoryTools } from "./tools/vendor_advisories.js";
 import { registerPrompts } from "./prompts.js";
 import { registerResources } from "./resources.js";
-import { dataText, GET_CVE_WHOLE, TEXT_BUDGET_DESCRIPTION } from "./textBudget.js";
-import { SHODAN_ATTRIBUTION, SHODAN_OWNERSHIP } from "./requiredText.js";
+import { answering, answeringNow, cutData, dataText, FIRST_TEXT_BLOCK_BESIDE_A_CUT, FULL_ARG, GET_CVE_WHOLE, NO_DATA_CUT, STRUCTURED_BUDGET, TEXT_BUDGET_DESCRIPTION, wholePage, } from "./textBudget.js";
+import { PATCH_AVAILABLE_WITHDRAWN, SHODAN_ATTRIBUTION, SHODAN_OWNERSHIP } from "./requiredText.js";
 // The package actually running, read from the package.json that ships beside dist/. The MCP
 // handshake (serverInfo) and the User-Agent both carry its name and version, so the API's
 // access log can count adoption per version without a code change per release.
@@ -367,17 +374,41 @@ function unexpectedShape(tool, error) {
 export const checked = (tool, schema, r) => {
     if (r.isError)
         return r;
-    const p = schema.safeParse(r.structuredContent);
+    // #3121: the published schema's success branch is open; this server's own answers are held to
+    // the closed one.
+    const p = (STRICT.get(schema) ?? schema).safeParse(r.structuredContent);
     return p.success ? r : unexpectedShape(tool, p.error);
 };
 // A success: content[0] is the data (cut to DATA_TEXT_BUDGET when it is larger, #2783), content[1]
 // the note, content[2] the envelope less both; the envelope carries both, the note as sentences
-// after any the envelope adds about itself. structuredContent.data is the data whole.
+// after any the envelope adds about itself. structuredContent.data is the data whole, or (#3013),
+// when the structured result would pass STRUCTURED_BUDGET and the call (answering()) does not say
+// full: true, cut as the call's DataCut says, with data_truncated, truncated and the note's DATA CUT
+// sentences saying how. content[0] is cut from the data whole either way.
 export const succeeded = (data, note, env, cut) => {
     const own = env.notes ?? [];
+    const call = answeringNow();
     const shown = dataText(data, cut);
-    const said = shown.said ? `${note} ${shown.said}` : note;
-    const structuredContent = { ...env, notes: [...own, ...sentences(said)], data };
+    const structuredOf = (d, said, truncated) => ({
+        ...env,
+        notes: [...own, ...sentences(said)],
+        data_truncated: truncated !== undefined,
+        ...(truncated === undefined ? {} : { truncated }),
+        data: d,
+    });
+    let said = shown.said ? `${note} ${shown.said}` : note;
+    let structuredContent = structuredOf(data, said);
+    const wholeChars = JSON.stringify(structuredContent).length;
+    if (call?.full !== true && wholeChars > STRUCTURED_BUDGET) {
+        // The same text, with the sentences a first text block beside a cut data says.
+        const beside = dataText(data, cut, FIRST_TEXT_BLOCK_BESIDE_A_CUT).said;
+        const head = beside ? `${note} ${beside}` : note;
+        const c = cutData(data, call?.cut ?? NO_DATA_CUT, wholeChars, (d, truncated, dataSaid) => structuredOf(d, `${head} ${dataSaid}`, truncated));
+        if (c) {
+            said = `${head} ${c.said}`;
+            structuredContent = c.structured;
+        }
+    }
     return { content: [text(shown.text), text(said), envelopeText(structuredContent, said, own)], structuredContent };
 };
 export const okHead = (tool, status) => `${tool} OK: EchelonGraph answered${status === undefined ? "" : ` HTTP ${status}`} from ${SHOWN_BASE}.`;
@@ -663,6 +694,35 @@ const SEARCH_CVES_TEXT = {
     whole: `${GET_CVE_WHOLE}.`,
     page: (shown, _rows, d) => `To read the rows left out in the text, call search_cves again with the same arguments and offset ${(numAt(d, "offset") ?? 0) + shown}; a page of ${shown} rows or fewer like these fits the text without leaving rows out.`,
 };
+// #3013: the structured result's cut. A row of production's answer is about 4,200 characters of
+// compact JSON (score_factors, cpe_match and references, about 2,000 of them, are get_cve's), so the
+// default page of 20 was 85,383 characters of structured result. Before any row leaves, every row
+// is thinned: first to the first text cut level's fields, its description whole; then to the fields
+// the description names, without the description. Only then do rows leave data from the end, and
+// the note gives the offset to read them from, and the page size whose rows fit data whole. Through
+// #3013's review that size was the number of thinned rows data kept, so a page of it came back
+// thinned again (data_truncated true) while the note said it fit data whole: it is now counted on
+// the rows whole (PageAt.wholeFit), the same call's envelope and note beside them.
+const SEARCH_CVES_DATA = {
+    steps: [
+        {
+            lists: ["cves"],
+            thin: [
+                [
+                    "cve_id", "description", "severity", "cvss_v3_score", "echelongraph_score", "echelongraph_severity", "echelongraph_risk", "score_assessed", "score_unassessed_reason", "epss_score",
+                    "kev_listed", "kev_ransomware", "published", "vuln_status", "patch_available", "patch_evidence", "exploit_poc_available",
+                ],
+                ["cve_id", "severity", "cvss_v3_score", "echelongraph_score", "score_assessed", "score_unassessed_reason", "epss_score", "kev_listed", "kev_ransomware", "published", "patch_available", "patch_evidence"],
+            ],
+        },
+    ],
+    page: (t, d, at) => {
+        const k = t.cves?.returned;
+        if (!k || !t.cves || k === t.cves.total)
+            return "";
+        return `To read the rows past the first ${k} in data, call search_cves again with the same arguments and offset ${(numAt(d, "offset") ?? 0) + k}; ${wholePage(at.wholeFit("cves"))}`;
+    },
+};
 async function searchCVEs(a) {
     const tool = "search_cves";
     try {
@@ -751,10 +811,79 @@ function kevTextNote(rec) {
         return "";
     const has = ["kev_required_action", "kev_short_description", "kev_notes_urls"].some((k) => field(rec, k) !== undefined && field(rec, k) !== null);
     return has
-        ? " kev_required_action, kev_short_description and kev_notes_urls are CISA's own text from its KEV catalog, relayed verbatim: CISA's required action is directed at US federal civilian agencies under Binding Operational Directive 22-01 and is not EchelonGraph's advice."
+        ? " kev_required_action, kev_short_description and kev_notes_urls are CISA's own text from its KEV catalog, relayed verbatim: CISA's required action is directed at US federal civilian agencies under Binding Operational Directive 26-04 (which replaced BOD 22-01 on 10 June 2026) and is not EchelonGraph's advice."
         : "";
 }
+// #2880: what the record's CISA BOD 26-04 timeline is, where the scorer wrote it
+// (core-backend/internal/cve/scoring/bod2604.go, algorithm v3.4+): given for both answers to "is
+// the system publicly exposed?", because that is the reader's own system's, each input with its
+// source. A record scored before v3.4, or a malformed block, gets no sentence: the JSON is relayed
+// whole either way. What the SSVC decision is (EchelonGraph's run of CISA's table, never a
+// decision CISA published, #3053) is in the outputSchema's echelongraph_ssvc_decision, not the
+// note: get_cve's text is measured to the character (test/text-bound.mjs).
+const BOD_TIMELINE = {
+    FSU: "Fix on system upgrade",
+    "60D": "60 days",
+    "14D": "14 days",
+    "3D": "3 days",
+    "3DF": "3 days & forensic triage",
+};
+const BOD_SOURCE = {
+    "cisa-adp": "CISA's Vulnrichment value",
+    cisa_kev: "CISA's KEV catalog",
+    cvss_v4_au: "the CVSS v4.0 Automatable metric",
+    cvss_v4_av_physical: "CVSS v4.0 attack vector Physical",
+    cvss_v4_vc_vi_high: "CVSS v4.0 confidentiality and integrity impact both High",
+    cvss_v4_vc_vi_not_high: "CVSS v4.0 confidentiality and integrity impact neither High",
+    cisa_bod_26_04_default: "CISA's BOD 26-04 default for a CVE not in KEV that nobody has assessed",
+    not_supplied: "not yet published by CISA, so every timeline it allows is listed",
+};
+function bodTimelines(v) {
+    if (!Array.isArray(v) || v.length === 0 || !v.every((k) => typeof k === "string" && BOD_TIMELINE[k]))
+        return null;
+    const w = v.map((k) => BOD_TIMELINE[k]);
+    return w.length === 1 ? w[0] : `${w.slice(0, -1).join(", ")} or ${w[w.length - 1]}`;
+}
+function bodNote(cve, rec) {
+    const b = field(rec, "score_factors", "bod_26_04");
+    const exposed = bodTimelines(field(b, "if_publicly_exposed"));
+    const internal = bodTimelines(field(b, "if_not_publicly_exposed"));
+    const kev = strAt(b, "kev", "value");
+    const input = (k, name) => {
+        const v = strAt(b, k, "value");
+        const src = strAt(b, k, "source");
+        return v && src ? `${name} ${v} (${BOD_SOURCE[src] ?? src})` : null;
+    };
+    const auto = input("automatable", "automatable");
+    const ti = input("technical_impact", "technical impact");
+    if (!(exposed && internal && (kev === "yes" || kev === "no") && auto && ti))
+        return "";
+    return ` score_factors.bod_26_04 is CISA BOD 26-04's remediation timeline for ${cve}: ${exposed} if the affected system is publicly exposed, ${internal} if it is not; whether a system is publicly exposed is its owner's to say. Its inputs: in CISA KEV ${kev}, ${auto}, ${ti}. BOD 26-04 binds US Federal Civilian Executive Branch agencies; for anyone else it is CISA's published timeline, not EchelonGraph's advice.`;
+}
 // #2841: one sentence on the record's remediation summary, where the API sends one.
+// #3070, #3076: the CNA's own date and fix sentence, named as the CNA's. Nothing when the record
+// carries neither; a value of another JSON type is not quoted (the outputSchema refuses it).
+function cnaRecordNote(cve, rec) {
+    const cna = field(rec, "cna");
+    const nameOf = (k) => (cna && typeof cna === "object" && typeof field(cna, k) === "string" ? String(field(cna, k)).trim() : "");
+    const who = nameOf("name") || nameOf("short_name");
+    // An appositive name is closed by a comma: "its CNA, Palo Alto Networks, Inc., states".
+    const by = who ? `its CNA, ${who},` : "its CNA";
+    const date = strAt(rec, "date_public");
+    const fix = strAt(rec, "cna_solution");
+    // #3178: a sentence of the record's workarounds is said to be its workaround.
+    const workaround = strAt(rec, "cna_solution_section") === "workaround";
+    const parts = [];
+    if (date)
+        parts.push(` date_public is when ${cve} was made public as ${by} states it in the CVE record (datePublic), not the record's publication date.`);
+    if (fix && workaround) {
+        parts.push(` cna_solution is a fix statement from the CVE record's workarounds (cna_solution_section workaround), not its solutions, written by ${by} and relayed verbatim: it names the fixed release, and is not EchelonGraph's advice.`);
+    }
+    else if (fix) {
+        parts.push(` cna_solution is the CVE record's own fix statement, written by ${by} and relayed verbatim: it names the fixed release, and is not EchelonGraph's advice.`);
+    }
+    return parts.join("");
+}
 function remediationSummaryNote(cve, rec) {
     const s = field(rec, "remediation");
     if (s === null || typeof s !== "object")
@@ -764,8 +893,21 @@ function remediationSummaryNote(cve, rec) {
     const failed = field(s, "failed_sections");
     const notRead = Array.isArray(failed) && failed.length ? ` The summary could not read ${failed.join(", ")} (failed_sections), so a missing count there is not a finding of none.` : "";
     const byKind = counted.length ? ` Vendor advisories list ${counted.map(([k, n]) => `${k} (${n})`).join(", ")}, by the vendor's own category.` : "";
-    return ` remediation summarises how ${cve} is fixed, as its sources state it; cve_remediation returns each vendor's text, CISA's action and every fixed range.${byKind}${notRead}`;
+    // #2841: fix_status is the API's, relayed; a state is named only as the API sent it.
+    const fs = field(s, "fix_status");
+    const state = strAt(fs, "state");
+    const basis = strAt(fs, "basis");
+    const fix = state
+        ? ` remediation.fix_status is ${state}${basis ? ` (basis ${basis})` : ""}, the API's fix-status rule${state === "none_confirmed" ? ", which is not a finding that no fix exists" : ""}.`
+        : "";
+    return ` remediation summarises how ${cve} is fixed, as its sources state it; cve_remediation returns each vendor's text, CISA's action and every fixed range.${fix}${byKind}${notRead}`;
 }
+// #3013: the structured result's cut. CVE-2021-44228's record is 64,170 characters of structured
+// result, 41,091 of them cpe_match (396 entries) and 17,103 references (103): those two are cut
+// first, each to at most the same number of its first entries, then cpe_configurations, then any
+// other list at the top level of the record. The remediation summary (#2841), an object, is never
+// cut, so its fix_status is whole at every level.
+const GET_CVE_DATA = { steps: [{ lists: ["cpe_match", "references"] }, { lists: ["cpe_configurations"] }] };
 async function getCVE(cve_id) {
     const tool = "get_cve";
     const id = cve_id.trim();
@@ -777,7 +919,7 @@ async function getCVE(cve_id) {
             return failed(tool, r);
         const written = strAt(r.data, "updated_at");
         const cve = strAt(r.data, "cve_id") ?? id;
-        return succeeded(r.data, `${okHead(tool, r.status)} Returned the record for ${cve}.${cveScoreNote(cve, r.data)}${kevTextNote(r.data)}${remediationSummaryNote(cve, r.data)}`, {
+        return succeeded(r.data, `${okHead(tool, r.status)} Returned the record for ${cve}.${cveScoreNote(cve, r.data)}${bodNote(cve, r.data)}${kevTextNote(r.data)}${cnaRecordNote(cve, r.data)}${remediationSummaryNote(cve, r.data)}`, {
             state: "measured",
             measured_at: instantOrNull(written),
             method: CVE_FEED_METHOD,
@@ -1960,6 +2102,35 @@ const RADAR_METHOD = "Aggregate counts over what each radar holds on record: kev
 export const RADAR_NAMES = RADARS.map(([name]) => name);
 const RADAR_STATE_NOTE = "state is not_assessed: every radar answered, but none gives one time at which what it counts was observed: kev_exposure, exposed_databases, leaked_credentials, shadow_ai's confirmed_exposed and mcp_servers date what they count at most by a window (kev_exposure.window, exposed_databases.window, leaked_credentials.window, shadow_ai.confirmed_exposed.window, mcp_servers.window), from the oldest observation among the rows counted to the newest, so no count here is presented as a dated measurement and measured_at is null. Each count is what that radar holds on record, and the note labels each one by what it counts.";
 const RADAR_FRESHNESS_NOTE = "freshness gives each radar's last completed check where the API serves one (freshness.kev_exposure.last_run_at, freshness.exposed_databases.last_run_at, freshness.leaked_credentials.last_run_at, freshness.shadow_ai.last_run_at with freshness.shadow_ai.running, and freshness.mcp_servers.last_run_at with freshness.mcp_servers.enabled), and null where it does not.";
+// #3013: the structured result's cut. Production's answers of 2026-10-05 (fixtures/prod-answers) are
+// 33,278 characters of structured result, past the budget by notes that label every number (about
+// 20,000 characters) beside 12,733 of data. The notes say what each list counts, from the answer
+// whole, so the lists are cut, never a note: first the two series (shadow_ai.observed.trend_30d,
+// kev_exposure.trend), then every ranking to at most the same number of its first rows, then
+// kev_exposure.newest_kev, whose CVEs and exposure states the note names one by one. #3013's
+// review: the series arrive oldest first (a day, a week a row), and a cut that kept their first
+// entries showed the oldest, lowest weeks as the trend and left out the latest; each now keeps its
+// newest entries (keepNewest), and the note says so.
+const EXPOSURE_RADAR_DATA = {
+    steps: [
+        { lists: ["shadow_ai.observed.trend_30d", "kev_exposure.trend"], keepNewest: true },
+        {
+            lists: [
+                "kev_exposure.top_products",
+                "kev_exposure.top_countries",
+                "kev_exposure.top_cves",
+                "exposed_databases.top_engines",
+                "exposed_databases.top_countries",
+                "leaked_credentials.top_providers",
+                "leaked_credentials.top_types",
+                "shadow_ai.observed.top_products",
+                "shadow_ai.observed.top_countries",
+                "shadow_ai.observed.top_issuers",
+            ],
+        },
+        { lists: ["kev_exposure.newest_kev"] },
+    ],
+};
 async function exposureRadar() {
     const tool = "exposure_radar";
     try {
@@ -2059,10 +2230,47 @@ export const NOTES = z.array(z.string()).describe("Caveats, one sentence each.")
 // says both, and leaves what each count is to the notes and exposure_state, which say it per
 // answer; it makes no blanket claim about the numbers, in either direction.
 const SUCCESS_STATE = "measured: a measurement of what was asked; an exposure count is measured only with measured_at and method. not_assessed: the answer holds no dated measurement of what was asked, so no count in it is presented as one; it can still relay a count, as what the source holds on record, undated, and its notes (and exposure_state, where the result carries it) say what each count is.";
+// #3013: what a success says of its data's cut (textBudget.ts cutData), one constant string each.
+const DATA_TRUNCATED_FIELD = "false: data is the answer whole. true: the structured result would pass 30,000 characters of JSON with data whole, so data is cut (DATA CUT): the entries of some of its lists keep only some of their fields, or the lists only some of their entries, truncated gives each, and no string is shortened. The same call with full: true returns data whole.";
+const TRUNCATED_FIELD = "Present when data_truncated is true: each list of data that was cut, by its path in data (a dot between the names of an object and a list inside it), with total, its entries in the answer, returned, the entries data holds, and thinned, true when each of them keeps only some of its fields.";
+const TRUNCATED = z.record(z.string(), z.strictObject({ total: z.number().int().min(0), returned: z.number().int().min(0), thinned: z.literal(true).optional() }));
+// #3121: the success branch is published open to fields it does not name, and this server holds
+// its own answers to the closed one (STRICT, read by checked). Through 3.0.0 both branches were
+// closed (additionalProperties false), and a client validates against the outputSchema it listed,
+// which the hosted endpoint never tells it to list again (stateless, listChanged false): a Claude
+// Code session that listed the tools under 2.7.2 failed its first check_sbom call once 3.0.0 went
+// live, "Structured content does not match the tool's output schema: data must NOT have additional
+// properties" (ajv's root is "data"; 3.0.0 added data_truncated and truncated to every success),
+// until it reconnected. So a field added beside them in a minor release would break every such
+// session too, against the README's semver promise. Opening the success branch keeps such a field
+// additive for a client holding an older list; the failure branch stays closed (a failure is never
+// read as data), and data keeps each tool's own schema. The suite validates answers against the
+// closed branch (test/strict-output.mjs), and checked() does here, so a field this server adds
+// without naming it in the schema still fails, as it did when the branch was closed.
+//
+// 3.0.2: every output schema is built once per process, and its strict copy with it. The hosted
+// endpoint builds a server for each request (http.ts: createMcpHandler's stateless leg calls
+// createServer), and through 3.0.1 the tool modules that take envelopeSchema from this file
+// (check_affected, check_sbom, epss_history, kev_recent, scan_manifest and the three vendor-advisory
+// tools) built their output schemas in their register functions, so once per request in flight.
+// 3.0.1's strict copy doubled those: 1,371 KB of heap per server, against 3.0.0's 1,168
+// (64 servers held at once, node --expose-gc). test/http-memory.test.mjs's "served as they come"
+// case holds 64 requests in flight beside two 5,000,000-character SBOMs; it failed the 3.0.1
+// release run at Dockerfile.http's 128 MiB, and passed here only at 128, where 3.0.0 passes at
+// 112. At 112 V8 aborted 3.5 s in, with 59 servers live and both documents still at their first
+// batches, so before either answer was cut (a heap snapshot near the limit). Each such module now
+// keeps its schemas per envelopeSchema, as cve_intel, cve_remediation and get_cwe already did
+// (schemasOnce): 611 KB a server, and the case passes at --max-old-space-size=80.
+const STRICT = new WeakMap();
 export function envelopeSchema(o) {
+    const published = envelopeOf(o, z.looseObject);
+    STRICT.set(published, envelopeOf(o, z.strictObject));
+    return published;
+}
+function envelopeOf(o, success) {
     const coverage = o.coverage ? o.coverage.nullable() : z.null();
     return z.discriminatedUnion("state", [
-        z.strictObject({
+        success({
             state: z.enum(["measured", "not_assessed"]).describe(SUCCESS_STATE),
             measured_at: Instant.nullable().describe("When the underlying observation was made, as the API states it; null when the answer does not say or holds no observation."),
             method: z.string().describe("How the numbers were produced."),
@@ -2070,6 +2278,8 @@ export function envelopeSchema(o) {
             freshness: (o.freshness ? o.freshness.nullable() : z.null()).describe("The producing radar's last completed check (last_run_at), where the API serves one."),
             notes: NOTES,
             ...(o.extra ?? {}),
+            data_truncated: z.boolean().describe(DATA_TRUNCATED_FIELD),
+            truncated: TRUNCATED.optional().describe(TRUNCATED_FIELD),
             data: o.data,
         }),
         z.strictObject({
@@ -2100,13 +2310,41 @@ const CPE_CONFIGURATIONS_DESCRIPTION = "NVD's configurations array as NVD sent i
 // the GitHub API, a published release holding the fix; its HTML heuristics, the CISA KEV inference
 // among them, are not evidence) and cna_patch_reference (the CNA's own CVE record tags a reference
 // "patch"; NVD's capitalised "Patch" stays nvd_patch_reference).
+// #3076 / #2518 (rule 3): vendor_advisory_fix (a vendor's own structured "vendor fix" for the CVE:
+// Red Hat CSAF, Microsoft CVRF), cna_solution and description_fix (a sentence of the CVE record's
+// solutions, or of its description, that states a released fix in core-backend's fix-statement
+// templates, internal/cve/fix_statement.go). The last two are the record's own words: get_cve
+// relays the solution's sentence as cna_solution, and the description is in the record.
 // One constant string each (the site's tool-claims check folds only constant strings).
-const PATCH_EVIDENCE_LABELS = ["vendor_patch", "fixed_version", "release_reference", "nvd_patch_reference", "cna_patch_reference"];
-const PATCH_EVIDENCE_SOURCES = "vendor_patch (a vendor patch on record, from Ubuntu or Red Hat), fixed_version (a fixed version recorded for an affected package, or the fixed bound of an affected version range), release_reference (a reference that EchelonGraph confirmed through the GitHub API is a published release containing the fix, or a pull request or commit that a published release contains), nvd_patch_reference (an NVD reference tagged Patch) and cna_patch_reference (a reference the CVE's CNA tagged patch in its CVE record)";
+const PATCH_EVIDENCE_LABELS = ["vendor_patch", "fixed_version", "release_reference", "vendor_advisory_fix", "nvd_patch_reference", "cna_patch_reference", "cna_solution", "description_fix", "vendor_fix_released"];
+const PATCH_EVIDENCE_SOURCES = "vendor_patch (a vendor patch on record, from Ubuntu or Red Hat), fixed_version (a fixed version recorded for an affected package, or the fixed bound of an affected version range), release_reference (a reference that EchelonGraph confirmed through the GitHub API is a published release containing the fix, or a pull request or commit that a published release contains), vendor_advisory_fix (a vendor advisory that lists a fix for the CVE under the vendor's own structured category: Red Hat's CSAF vendor_fix, Microsoft's Vendor Fix), nvd_patch_reference (an NVD reference tagged Patch), cna_patch_reference (a reference the CVE's CNA tagged patch in its CVE record), cna_solution (a sentence of the CVE record's solutions or workarounds, written by its CNA, that names a fixed version; relayed as cna_solution), description_fix (a sentence of the CVE description that names a fixed version) and vendor_fix_released (the vendor states, in the CVE record, that a fix is released and the record names no fixed version; check the vendor's advisory)";
+// #3070, #3076: what the CVE record's CNA wrote, as GET /cves/:id serves it (core-backend
+// cna_record.go). One constant string each.
+const CVE_CNA_ABSENT = "Absent where EchelonGraph has not read the CVE record's CNA container yet, where the record has none, for a REJECTED CVE, and from an API older than the field.";
+const DATE_PUBLIC_FIELD = "When the vulnerability was made public, as the CVE record's CNA states it (the record's datePublic: \"if known, the date/time the vulnerability was disclosed publicly\"). It is the CNA's date, not the record's own publication date, which is published. " +
+    CVE_CNA_ABSENT;
+const DATE_PUBLIC_SOURCE_FIELD = "Whose date date_public is: cna, the CVE record's CNA. Absent whenever date_public is.";
+const CNA_FIELD = "The CNA that wrote the CVE record: short_name as the record gives it, and name, the CVE Program's name for that CNA (the short name where its list does not hold it). " + CVE_CNA_ABSENT;
+const CNA_SOLUTION_FIELD = "The sentence of the CVE record's solutions or workarounds, written by its CNA, that names a released fix, verbatim: what makes cna_solution patch evidence. It is the CNA's text, not EchelonGraph's advice. cna_solution_section says which of the two sections it is. Absent where the record's solutions name no fixed version, as well as where the field itself is: " +
+    CVE_CNA_ABSENT;
+// #3178: which section cna_solution is. MCP relays a field its outputSchema does not describe without saying what it
+// is, so the section is described here, beside the sentence.
+const CNA_SOLUTION_SECTION_FIELD = "Which section of the CVE record cna_solution was read from: solution (the record's solutions) or workaround (its workarounds, read only where its solutions name no fix: a temporary measure the CNA lists beside its fix). A workaround's sentence is the record's workaround, never its solution. Present whenever cna_solution is; absent from an API older than the field.";
 // #2842: what the descriptions say; the sources, and that patch_available once true is never set
 // back, are the outputSchema's (PATCH_AVAILABLE_FIELD, PATCH_EVIDENCE_FIELD).
-const PATCH_AVAILABLE_DESCRIPTION = "patch_available is true when EchelonGraph holds evidence of a fix for the CVE, and patch_evidence names its sources, strongest first. patch_available false means no fix evidence is on record, which is not a finding that no fix exists.";
-const PATCH_AVAILABLE_FIELD = "true: EchelonGraph holds evidence of a fix for the CVE, its sources named in patch_evidence. false: no fix evidence is on record, which is not a finding that no fix exists. Once true it is never set back to false. An answer with no patch_evidence (an API older than that field) does not name the evidence, and a false there is not a finding that no fix exists either.";
+const PATCH_AVAILABLE_DESCRIPTION = "patch_available is true when EchelonGraph holds, or once held, fix evidence for the CVE; patch_evidence is what it holds now, strongest first. patch_available false means no fix evidence is on record, which is not a finding that no fix exists.";
+// #3138: true says evidence was held at some point, not that it is held now: the sources held now
+// are patch_evidence's, and true beside an empty one is a withdrawal (requiredText.ts
+// PATCH_AVAILABLE_WITHDRAWN, pinned there). #3138's review: round 1 changed the field text only,
+// and this sentence, in get_cve's and search_cves' descriptions, still said true means
+// EchelonGraph holds evidence; it now says "holds, or once held", in 9 more characters than it
+// had, as get_cve's description had 9 left under #2924's headroom of 100 below the 2,048 cut
+// (get_cve 1,948 characters, search_cves 1,807; test/prompts-resources.test.mjs holds the
+// headroom, test/client-cut.mjs (b) the cut, and marketing-site lib/mcpToolClaims.test.ts the
+// word "for" in get_cve's description, which its /pulse/mcp row uses).
+const PATCH_AVAILABLE_FIELD = "true: EchelonGraph holds, or once held, evidence of a fix for the CVE; patch_evidence names the sources it holds now. " +
+    PATCH_AVAILABLE_WITHDRAWN +
+    " false: no fix evidence is on record, which is not a finding that no fix exists. An answer with no patch_evidence (an API older than that field) does not name the evidence, and a false there is not a finding that no fix exists either.";
 const PATCH_EVIDENCE_FIELD = "The sources of the fix evidence EchelonGraph holds for the CVE, strongest first: " +
     PATCH_EVIDENCE_SOURCES +
     ". Empty where none was found when EchelonGraph last computed it. Absent (an API older than the field): the answer does not name the evidence.";
@@ -2114,14 +2352,14 @@ const PATCH_EVIDENCE_FIELD = "The sources of the fix evidence EchelonGraph holds
 // while kev_listed. Relayed as CISA's, verbatim; the required action is CISA's directive to US
 // federal civilian agencies, not EchelonGraph's advice. Constant strings, like the others here.
 const KEV_TEXT_ABSENT = "Absent where the CVE is not CISA-KEV-listed, where CISA's entry has none, or where EchelonGraph has not stored it yet (an API older than the field serves none).";
-const KEV_REQUIRED_ACTION_FIELD = "CISA's requiredAction for the CVE, verbatim from its Known Exploited Vulnerabilities catalog: the action CISA requires of US federal civilian agencies under Binding Operational Directive 22-01, by kev_due_date. It is CISA's text, not EchelonGraph's advice. " +
+const KEV_REQUIRED_ACTION_FIELD = "CISA's requiredAction for the CVE, verbatim from its Known Exploited Vulnerabilities catalog: the action CISA requires of US federal civilian agencies under Binding Operational Directive 26-04 (which replaced BOD 22-01 on 10 June 2026), by kev_due_date. It is CISA's text, not EchelonGraph's advice. " +
     KEV_TEXT_ABSENT;
 const KEV_SHORT_DESCRIPTION_FIELD = "CISA's shortDescription of the vulnerability, verbatim from its Known Exploited Vulnerabilities catalog. " + KEV_TEXT_ABSENT;
 const KEV_NOTES_URLS_FIELD = "The https links in CISA's notes for the CVE, in CISA's order, de-duplicated, at most 10: the references CISA's catalog entry gives, such as the vendor's advisory or instructions and NVD's page. " +
     KEV_TEXT_ABSENT;
 // #2841: what get_cve's remediation is. One constant string (the site's tool-claims check folds
 // only constant strings).
-const REMEDIATION_SUMMARY_FIELD = "A capped summary (at most 1,500 characters of JSON) of how the CVE is fixed, as its sources state it: vendor_remediation_kinds (per kind, the vendor advisories listing one for this CVE, by the vendor's own category), vendor_advisories, vendors_not_parsed, kev_required_action (CISA's, verbatim), fixed_branches_count, fixed_versions (per package, fixed versions on record), fix_references (URLs tagged Patch or Mitigation), failed_sections, truncated, and see, the name of the tool that returns the whole, with each text. A kind missing from vendor_remediation_kinds is not a finding that no such remediation exists. Absent for a REJECTED CVE and from an API older than the field.";
+const REMEDIATION_SUMMARY_FIELD = "A capped summary (at most 1,500 characters of JSON) of how the CVE is fixed, as its sources state it: fix_status first (the API's fix-status rule: state, basis, described_by, solution_by, stated_in_record, listed_in_patch_table and unread_inputs), vendor_remediation_kinds (per kind, the vendor advisories listing one for this CVE, by the vendor's own category), vendor_advisories, vendors_not_parsed, kev_required_action (CISA's, verbatim), fixed_branches_count, fixed_versions (per package, fixed versions on record), fix_references (URLs tagged Patch or Mitigation by NVD, or patch or mitigation by the CNA), failed_sections, truncated, and see, the name of the tool that returns the whole, with each text. A kind missing from vendor_remediation_kinds is not a finding that no such remediation exists. Absent for a REJECTED CVE and from an API older than the field.";
 const CVERecord = z.looseObject({
     cve_id: opt(z.string()),
     description: opt(z.string()),
@@ -2136,6 +2374,9 @@ const CVERecord = z.looseObject({
     score_confidence: opt(z.string()).describe("How confident EchelonGraph is in its score: NONE when score_assessed is false."),
     score_assessed: opt(z.boolean()).describe("Whether EchelonGraph has scored the CVE. true: echelongraph_score, echelongraph_severity and echelongraph_risk are its score. false: the CVE is NOT YET SCORED, not scored 0, and any of those three it carries is a placeholder, not a rating; the API may leave them out. Absent (an API older than the field): the answer does not say whether the CVE was scored."),
     score_unassessed_reason: opt(z.string()).describe("Why score_assessed is false: no_signal, no source has yet published severity data EchelonGraph can score; or rejected, the record was withdrawn by its numbering authority and is never scored. Absent when the CVE is scored."),
+    // #2880: the SSVC decision, and CISA BOD 26-04's timeline (bodNote words it in the note).
+    echelongraph_ssvc_decision: opt(z.string()).describe("The SSVC decision (Act, Attend, Track* or Track) EchelonGraph computes with CISA's decision table at medium mission impact. CISA publishes the table and, for some CVEs, its inputs, not a decision for a CVE. score_factors.ssvc gives the decision at low, medium and high mission impact, with each input and its source."),
+    score_factors: z.unknown().optional().describe("EchelonGraph's evidence for its score. ssvc: the SSVC decision at every mission impact level, each input with its source. bod_26_04 (scorer v3.4 and later): CISA BOD 26-04's remediation timeline, if_publicly_exposed and if_not_publicly_exposed, each a list of CERT/CC's keys (3DF, 3D, 14D, 60D, FSU) named in timelines, with kev, automatable and technical_impact, each with its source; source cisa_bod_26_04_default is CISA's own default for a CVE not in KEV that nobody has assessed."),
     epss_score: opt(z.number()),
     epss_percentile: opt(z.number()),
     kev_listed: opt(z.boolean()),
@@ -2149,12 +2390,20 @@ const CVERecord = z.looseObject({
     // #2861: fix evidence. A label the API adds later is admitted, never a failed call.
     patch_available: opt(z.boolean()).describe(PATCH_AVAILABLE_FIELD),
     patch_evidence: opt(z.array(z.union([z.enum(PATCH_EVIDENCE_LABELS), z.string()]))).describe(PATCH_EVIDENCE_FIELD),
+    // #3070, #3076: what the CVE record's CNA wrote (see cnaRecordNote).
+    date_public: opt(z.string()).describe(DATE_PUBLIC_FIELD),
+    date_public_source: opt(z.string()).describe(DATE_PUBLIC_SOURCE_FIELD),
+    cna: opt(z.looseObject({ short_name: opt(z.string()), name: opt(z.string()) })).describe(CNA_FIELD),
+    cna_solution: opt(z.string()).describe(CNA_SOLUTION_FIELD),
+    // #3178: a section the API adds later is relayed, never a failed call (as patch_evidence's labels).
+    cna_solution_section: opt(z.union([z.enum(["solution", "workaround"]), z.string()])).describe(CNA_SOLUTION_SECTION_FIELD),
     references: z.unknown().optional(),
     // #2720: NVD's configurations, losslessly, beside the flat list (see cpeConfigurationsNote).
     cpe_match: z.unknown().optional().describe(CPE_MATCH_DESCRIPTION),
     cpe_configurations: opt(z.array(z.unknown())).describe(CPE_CONFIGURATIONS_DESCRIPTION),
-    // #2841: a capped summary of how the CVE is fixed; cve_remediation returns the whole.
-    remediation: opt(z.looseObject({})).describe(REMEDIATION_SUMMARY_FIELD),
+    // #2841: a capped summary of how the CVE is fixed; cve_remediation returns the whole. Its first
+    // field, fix_status, is the API's fix-status rule, relayed (src/fixStatus.ts).
+    remediation: opt(z.looseObject({ fix_status: fixStatusSchema() })).describe(REMEDIATION_SUMMARY_FIELD),
     published: opt(z.string()),
     modified: opt(z.string()),
     updated_at: opt(z.string()),
@@ -2409,9 +2658,10 @@ export function createServer() {
     server.registerTool("cve_summary", {
         title: "CVE feed summary",
         description: `Summary of EchelonGraph's CVE Pulse feed: summary.total active CVEs, their counts by severity band (summary.critical, summary.high, summary.medium, summary.low), the count with no band (summary.none), and summary.last_updated, the newest modification time among those records. ${SUMMARY_NONE_DESCRIPTION} ${SUMMARY_NVD_DESCRIPTION} ${SUMMARY_REJECTED_DESCRIPTION} ${SUMMARY_POLLER_HEAD} The feed is polled from its sources on a schedule; this is the state as of that update. ${CVE_SUMMARY_ENVELOPE} ${TEXT_BUDGET_DESCRIPTION}`,
+        inputSchema: z.object({ full: FULL_ARG }),
         outputSchema: CVE_SUMMARY_OUTPUT,
         annotations: ANNOTATIONS,
-    }, async () => checked("cve_summary", CVE_SUMMARY_OUTPUT, await cveSummary()));
+    }, async (a) => checked("cve_summary", CVE_SUMMARY_OUTPUT, await answering(a.full, NO_DATA_CUT, () => cveSummary())));
     server.registerTool("search_cves", {
         title: "Search CVEs",
         description: `Search/list CVEs from EchelonGraph's CVE feed (NVD + MITRE-CNA pre-NVD + CISA-KEV + EPSS + GitHub GHSA, each polled on a schedule). Filter by severity, minimum CVSS, free text, and sort; page with limit and offset. Returns cves, each with cve_id, severity, cvss_v3_score, echelongraph_score and score_assessed (whether EchelonGraph has scored it), epss_score and kev_listed where the record has them, and the list's total, total_counted (false: total is not a count), total_is_lower_bound (true: at least total), search_relaxed, limit and offset. ${SCORE_ASSESSED_DESCRIPTION} ${PATCH_AVAILABLE_DESCRIPTION} ${FEED_ENVELOPE} ${TEXT_BUDGET_DESCRIPTION} Cut, each row keeps at least the fields named above and the first 200 characters of its description (100 on a page too long for that), or rows are left out and the note gives the offset to call next.`,
@@ -2423,30 +2673,32 @@ export function createServer() {
             limit: z.number().int().min(1).max(50).optional().describe("page size (default 20, max 50)"),
             // #2783: the next page, which the note names when the text leaves rows out.
             offset: z.number().int().min(0).max(10000).optional().describe("rows to skip (default 0)"),
+            full: FULL_ARG,
         }),
         outputSchema: SEARCH_CVES_OUTPUT,
         annotations: ANNOTATIONS,
-    }, async (a) => checked("search_cves", SEARCH_CVES_OUTPUT, await searchCVEs(a)));
+    }, async (a) => checked("search_cves", SEARCH_CVES_OUTPUT, await answering(a.full, SEARCH_CVES_DATA, () => searchCVEs(a))));
     server.registerTool("get_cve", {
         title: "CVE detail",
         description: `One CVE's record: description, severity, cvss_v3_score, cvss_v4_score and cvss_v4_severity, echelongraph_score, echelongraph_severity and score_confidence, epss_score and epss_percentile, CISA-KEV status (kev_listed, kev_added_date, kev_due_date, kev_ransomware) and, if KEV-listed, CISA's own text relayed verbatim (kev_required_action, not EchelonGraph's advice; kev_short_description; kev_notes_urls), ghsa_id, references, cpe_match (one flat list) and cpe_configurations (NVD's configurations as NVD sent them, with each AND/OR operator; absent where none is stored, which is not a finding that no product is affected), remediation (a capped summary of its fix), published, modified and updated_at; each field only where the record has it. Pass a CVE ID like CVE-2023-44487. ${SCORE_ASSESSED_DESCRIPTION} ${PATCH_AVAILABLE_DESCRIPTION} ${FEED_ENVELOPE} ${TEXT_BUDGET_DESCRIPTION} Cut, each list in the record keeps its first entries, and the note names each list cut with its full length.`,
-        inputSchema: z.object({ cve_id: CVE_ID_ARG }),
+        inputSchema: z.object({ cve_id: CVE_ID_ARG, full: FULL_ARG }),
         outputSchema: GET_CVE_OUTPUT,
         annotations: ANNOTATIONS,
-    }, async ({ cve_id }) => checked("get_cve", GET_CVE_OUTPUT, await getCVE(cve_id)));
+    }, async ({ cve_id, full }) => checked("get_cve", GET_CVE_OUTPUT, await answering(full, GET_CVE_DATA, () => getCVE(cve_id))));
     server.registerTool("cve_exposure", {
         title: "Internet exposure for one CVE",
         description: `${CVE_EXPOSURE_DESCRIPTION} Its structured result's state is not_assessed with measured_at null, since the answer dates no observation; the count is still relayed, labelled, as what the radar holds on record. exposure_state says what the count is: exposed, measured_zero, not_assessed or tracking_unknown; coverage.in_scope is the API's tracked verdict; freshness is null; data is the API's JSON. ${TEXT_BUDGET_DESCRIPTION}`,
-        inputSchema: z.object({ cve_id: CVE_ID_ARG }),
+        inputSchema: z.object({ cve_id: CVE_ID_ARG, full: FULL_ARG }),
         outputSchema: CVE_EXPOSURE_OUTPUT,
         annotations: ANNOTATIONS,
-    }, async ({ cve_id }) => checked("cve_exposure", CVE_EXPOSURE_OUTPUT, await cveExposure(cve_id)));
+    }, async ({ cve_id, full }) => checked("cve_exposure", CVE_EXPOSURE_OUTPUT, await answering(full, NO_DATA_CUT, () => cveExposure(cve_id))));
     server.registerTool("exposure_radar", {
         title: "Exposure radar totals",
         description: `${EXPOSURE_RADAR_DESCRIPTION} Its structured result's state is not_assessed with measured_at null, since no radar dates what it counts; each count is still relayed as what that radar holds on record. freshness gives each radar's last_run_at where the API serves one; coverage names the radars that answered. ${TEXT_BUDGET_DESCRIPTION}`,
+        inputSchema: z.object({ full: FULL_ARG }),
         outputSchema: EXPOSURE_RADAR_OUTPUT,
         annotations: ANNOTATIONS,
-    }, async () => checked("exposure_radar", EXPOSURE_RADAR_OUTPUT, await exposureRadar()));
+    }, async (a) => checked("exposure_radar", EXPOSURE_RADAR_OUTPUT, await answering(a.full, EXPOSURE_RADAR_DATA, () => exposureRadar())));
     registerKevRecent(server, { api, succeeded, failed, badInput, crashed, checked, envelopeSchema, okHead, annotations: ANNOTATIONS });
     registerEPSSHistory(server, TOOL_KIT);
     // #2716: its logic, schemas and description live in tools/check_affected.ts.
@@ -2467,7 +2719,8 @@ export function createServer() {
     // #2722: prompts and resources, in prompts.ts and resources.ts. Both lists are fixed per
     // connection, so listChanged is false above.
     registerPrompts(server, { cveId: CVE_ID });
-    registerResources(server, { api, cveId: CVE_ID, shownBase: SHOWN_BASE, sentences, getCve: async (id) => checked("get_cve", GET_CVE_OUTPUT, await getCVE(id)) });
+    // #3013: cve:// cuts get_cve's data itself (DATA CUT, resources.ts), so it reads it whole.
+    registerResources(server, { api, cveId: CVE_ID, shownBase: SHOWN_BASE, sentences, getCve: async (id) => checked("get_cve", GET_CVE_OUTPUT, await answering(true, GET_CVE_DATA, () => getCVE(id))) });
     return server;
 }
 // The package identity and API settings, for the hosted HTTP entrypoint's health answer and