echelongraph-mcp 2.7.1 → 3.0.0

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,12 +65,13 @@ 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 { 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 { 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
@@ -372,12 +379,34 @@ export const checked = (tool, schema, r) => {
 };
 // 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 +692,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 +809,73 @@ 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");
+    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)
+        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 +885,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 +911,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,
@@ -1206,6 +1340,86 @@ function lastCheck(radar, data) {
         `${radar}.last_run_at is not the time of every record the ${radar} numbers count, which cover everything still on record, not only what that check found; nor is it ${radar}.generated_at, when the API computed those numbers.`,
     ];
 }
+// ── Staleness: a radar whose last completed check is older than its cycle allows (#3010) ──
+//
+// Through 2.7.1 the note flagged only the two radars whose answer carries a liveness verdict
+// (shadow_ai's poller.running, mcp_servers.enabled), and every answer ended "Each radar refreshes
+// on its own schedule.". So during the #2975 scanning pause exposed_databases (77 h since its last
+// completed check) and leaked_credentials (68 h) read as current. Each radar now has a threshold
+// keyed to the cadence core-backend runs it at (cmd/server/main.go builds each poller; an interval
+// of 0 takes the package's defaultInterval):
+//   kev_exposure        kevexposure/poller.go defaultInterval, 12 h: 24 h, two cycles
+//   exposed_databases   exposeddb/poller.go defaultInterval, 12 h: 24 h, two cycles
+//   leaked_credentials  leakedcreds/poller.go defaultInterval, 10 min: 1 h, six cycles, so a stopped
+//                       radar shows within the hour and a slow cycle or two never trips it
+//   shadow_ai           the API's own poller.running (shadowctlog pollerSilentAfter, 30 min) first;
+//                       only when the answer gives no verdict, 30 minutes by poller.last_run_at
+//   mcp_servers         the API's own enabled (aiexposure liveWindow, 45 min) first; only when the
+//                       answer gives no verdict, 45 minutes by last_run_at
+// These are copies of numbers core-backend owns, so test/radar-staleness.test.mjs reads the Go files
+// and fails when a threshold is under twice the cadence it parses, when a cycle named here is not
+// the one it parses, when a radar has no entry, or when a constant can no longer be parsed.
+//
+// The age is taken against this server's clock when the answer is composed, never against a
+// radar's generated_at: that is when the API's stats cache computed the totals, and the cache is
+// stale-while-revalidate (core-backend internal/cache/swr.go keeps serving its last value while a
+// refresh fails), so it can lag the answer by hours and would understate the age. last_run_at is
+// read fresh (the API omits it when its last good read is more than two minutes old). The note
+// gives the age and the cycle, says the numbers may be stale, and gives no cause: the answer gives
+// none.
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+export const STALE_AFTER = {
+    kev_exposure: { after: 24 * HOUR, cycle: 12 * HOUR },
+    exposed_databases: { after: 24 * HOUR, cycle: 12 * HOUR },
+    leaked_credentials: { after: HOUR, cycle: 10 * MINUTE },
+    shadow_ai: { after: 30 * MINUTE },
+    mcp_servers: { after: 45 * MINUTE },
+};
+const counted = (n, unit) => `${n} ${unit}${n === 1 ? "" : "s"}`;
+// A threshold or a cycle: "24 hours", "1 hour", "45 minutes"; as an adjective, "12-hour".
+const span = (ms) => (ms % HOUR === 0 ? counted(ms / HOUR, "hour") : counted(Math.round(ms / MINUTE), "minute"));
+const spanAdj = (ms) => (ms % HOUR === 0 ? `${ms / HOUR}-hour` : `${Math.round(ms / MINUTE)}-minute`);
+// An age, rounded: minutes under two hours, hours under a week, days past that.
+const age = (ms) => ms < 2 * HOUR ? counted(Math.round(ms / MINUTE), "minute") : ms < 168 * HOUR ? counted(Math.round(ms / HOUR), "hour") : counted(Math.round(ms / (24 * HOUR)), "day");
+// How long before `now` the instant `at` was, when that is past the radar's threshold; otherwise
+// (or when `at` is not a real instant) undefined.
+function staleBy(radar, at, now) {
+    if (typeof at !== "string" || !realInstant(at))
+        return undefined;
+    const ms = now - Date.parse(at);
+    return ms > STALE_AFTER[radar].after ? ms : undefined;
+}
+// The note's sentence for a stats radar whose relayed last_run_at is past its threshold. It does not
+// repeat the stamp, which lastCheck prints once.
+function staleCheck(radar, data, now) {
+    const ms = staleBy(radar, data.last_run_at, now);
+    if (ms === undefined)
+        return [];
+    const { after, cycle } = STALE_AFTER[radar];
+    const times = after / cycle === 2 ? "twice" : `${after / cycle} times`;
+    return [`${radar}.last_run_at is about ${age(ms)} before this answer, more than ${times} the radar's ${spanAdj(cycle)} cycle, so the ${radar} numbers may be stale.`];
+}
+// The last sentence of every answer. "Each radar refreshes on its own schedule." said the radars
+// were refreshing whatever their last completed checks said. This says only what the answer
+// shows: each radar has a cycle of its own (not that it is running on it), and either the radars
+// that may be stale, the same ones whose own sentences above say so, or that nothing shows one past
+// its threshold, with each threshold named. "Nothing shows" stays true when the API serves no
+// last_run_at (#2335: the note then says nothing about a last completed check), and the envelope's
+// own note (RADAR_FRESHNESS_NOTE) already points to freshness on every answer.
+function freshnessClose(stale) {
+    if (stale.length)
+        return `Each radar has its own cycle, and ${stale.length} of the ${RADARS.length} radars may be stale: ${listed(stale)}.`;
+    const byAfter = new Map();
+    for (const [name] of RADARS) {
+        const s = STALE_AFTER[name];
+        if (s.cycle !== undefined)
+            byAfter.set(s.after, [...(byAfter.get(s.after) ?? []), name]);
+    }
+    const timed = [...byAfter].map(([after, names]) => `${span(after)} for ${listed(names)}`);
+    const verdicts = `for shadow_ai and mcp_servers, the API's own poller.running and enabled verdicts, or ${span(STALE_AFTER.shadow_ai.after)} and ${span(STALE_AFTER.mcp_servers.after)} where the answer gives none`;
+    return `Each radar has its own cycle, and neither freshness nor anything else in this answer shows a radar past its threshold for calling its numbers stale (${timed.join(", ")}; ${verdicts}).`;
+}
 // The first row of a relayed ranking, for the note: "(first: http_server, 9120 services)".
 function firstOf(rows, label, count, unit) {
     const top = Array.isArray(rows) ? rows[0] : undefined;
@@ -1288,7 +1502,7 @@ function newestKEVRow(r) {
         row.exposed_hosts = hosts;
     return { row, state, outside: tracked === false };
 }
-function readKEVExposure(body) {
+function readKEVExposure(body, now) {
     const { data, unknown, unusable, undated } = readRadar(body, KEV_SPEC);
     const sentences = [];
     const n = (k) => numIn(data, k);
@@ -1346,8 +1560,10 @@ function readKEVExposure(body) {
     }
     sentences.push(...windowSentences("kev_exposure", { window: data.window, undated, bad: false }, "when Shodan collected the banners of the oldest and the newest of the service×CVE pairs counted, Shodan's own times, not when EchelonGraph stored or re-checked a pair"));
     sentences.push(...lastCheck("kev_exposure", data));
+    const stale = staleCheck("kev_exposure", data, now);
+    sentences.push(...stale);
     sentences.push(...leftOut("kev_exposure", unknown, unusable));
-    return { data, sentences };
+    return { data, sentences, stale: stale.length > 0 };
 }
 // ── exposed_databases: GET /api/v1/public/exposed-databases/stats (#2313 item 7) ──
 //
@@ -1375,7 +1591,7 @@ const EXPOSED_DB_SPEC = {
     instants: ["generated_at", "last_run_at"],
     window: "observed_window",
 };
-function readExposedDatabases(body) {
+function readExposedDatabases(body, now) {
     const { data, unknown, unusable, undated } = readRadar(body, EXPOSED_DB_SPEC);
     const sentences = [];
     const n = (k) => numIn(data, k);
@@ -1401,8 +1617,10 @@ function readExposedDatabases(body) {
     }
     sentences.push(...windowSentences("exposed_databases", { window: data.window, undated, bad: false }, "when EchelonGraph's check last confirmed the oldest and the newest of the services counted answering without authentication"));
     sentences.push(...lastCheck("exposed_databases", data));
+    const stale = staleCheck("exposed_databases", data, now);
+    sentences.push(...stale);
     sentences.push(...leftOut("exposed_databases", unknown, unusable));
-    return { data, sentences };
+    return { data, sentences, stale: stale.length > 0 };
 }
 // ── leaked_credentials: GET /api/v1/public/leaked-credentials/stats (#2313 item 7) ──
 //
@@ -1425,7 +1643,7 @@ const LEAKED_CREDS_SPEC = {
     instants: ["generated_at", "last_run_at"],
     window: "observed_window",
 };
-function readLeakedCredentials(body) {
+function readLeakedCredentials(body, now) {
     const { data, unknown, unusable, undated } = readRadar(body, LEAKED_CREDS_SPEC);
     const sentences = [];
     const n = (k) => numIn(data, k);
@@ -1448,10 +1666,12 @@ function readLeakedCredentials(body) {
     }
     sentences.push(...windowSentences("leaked_credentials", { window: data.window, undated, bad: false }, "when EchelonGraph's detector last found the oldest and the newest of the (repository, secret) pairs counted in a public commit"));
     sentences.push(...lastCheck("leaked_credentials", data));
+    const stale = staleCheck("leaked_credentials", data, now);
+    sentences.push(...stale);
     sentences.push(...leftOut("leaked_credentials", unknown, unusable));
-    return { data, sentences };
+    return { data, sentences, stale: stale.length > 0 };
 }
-function readShadowAI(sa) {
+function readShadowAI(sa, now) {
     const sentences = [];
     const stats = field(sa, "stats");
     const used = new Set();
@@ -1574,6 +1794,10 @@ function readShadowAI(sa) {
         data.authentication = authentication;
     const lastRun = strAt(sa, "poller", "last_run_at");
     const running = boolAt(sa, "poller", "running");
+    // #3010: running is the API's own verdict and decides; only a block with a real last_run_at and
+    // no verdict is judged by STALE_AFTER.shadow_ai, the API's own window, and that time is still
+    // not relayed (the block stays left out) or repeated: the note gives its age.
+    const unjudged = running === undefined ? staleBy("shadow_ai", lastRun, now) : undefined;
     if (realInstant(lastRun) && running === true) {
         data.poller = { running, last_run_at: lastRun };
         sentences.push(`Shadow-AI radar freshness: the radar's leader last completed a Certificate Transparency (crt.sh) discovery cycle at ${lastRun} (poller.running is true: that was within ${SHADOW_AI_SILENT_AFTER} of the API's answer).`);
@@ -1587,10 +1811,13 @@ function readShadowAI(sa) {
     }
     else {
         sentences.push("Shadow-AI radar freshness is unknown: the answer's poller block does not give both a real time at which the radar's leader last completed a cycle (poller.last_run_at) and a running verdict (poller.running), so that block was left out of the data above.");
+        if (unjudged !== undefined) {
+            sentences.push(`The shadow-AI poller block gives no running verdict, but its last_run_at is about ${age(unjudged)} before this answer, more than the ${span(STALE_AFTER.shadow_ai.after)} after which the API reports the radar not running, so the shadow-AI figures may be stale.`);
+        }
     }
     if (realInstant(lastObservation))
         sentences.push(`Latest shadow-AI observation on record: ${lastObservation}.`);
-    return { data, sentences };
+    return { data, sentences, stale: (realInstant(lastRun) && running === false) || unjudged !== undefined };
 }
 // ── mcp_servers: GET /api/v1/public/ai-exposure/stats?service=mcp (#2315) ──
 //
@@ -1716,7 +1943,7 @@ function mcpRefusal(body) {
     }
     return undefined;
 }
-function readMCPServers(src) {
+function readMCPServers(src, now) {
     const data = {};
     const unusable = [];
     const unsummed = [];
@@ -1807,12 +2034,18 @@ function readMCPServers(src) {
     if (typeof at === "string") {
         sentences.push(`mcp_servers last completed check: ${at} (mcp_servers.last_run_at, a timestamp, not a count).`, "mcp_servers.last_run_at is when the AI-exposure radar, which checks other AI services as well as MCP servers, last finished a cycle whose reads succeeded and whose scan opt-out register answered.", "mcp_servers.last_run_at is not the time of every verdict the mcp_servers numbers count (mcp_servers.window says when those were checked); nor is it mcp_servers.counted_at, when the API read those numbers.");
     }
+    // #3010: enabled is the API's own verdict and decides; only an answer without a usable one is
+    // judged by STALE_AFTER.mcp_servers, the API's own window, on the last_run_at relayed above.
+    const unjudged = data.enabled === undefined ? staleBy("mcp_servers", data.last_run_at, now) : undefined;
     if (data.enabled === true) {
         sentences.push(`mcp_servers.enabled is true: the API reports the AI-exposure radar running, a check having completed within ${MCP_ENABLED_WITHIN} of its answer.`);
     }
     else if (data.enabled === false) {
         sentences.push(`mcp_servers.enabled is false: the API does not report the AI-exposure radar running (no check completed within ${MCP_ENABLED_WITHIN} of its answer), so these numbers may be stale.`);
     }
+    else if (unjudged !== undefined) {
+        sentences.push(`The answer gives no usable mcp_servers.enabled verdict, but mcp_servers.last_run_at is about ${age(unjudged)} before this answer, more than the ${span(STALE_AFTER.mcp_servers.after)} within which the API reports the AI-exposure radar running, so the mcp_servers numbers may be stale.`);
+    }
     if (typeof data.counted_at === "string") {
         sentences.push(`mcp_servers.counted_at (${data.counted_at}) is when the API read these counts: a timestamp, not a count, and not when any verdict was checked.`);
     }
@@ -1822,7 +2055,7 @@ function readMCPServers(src) {
     if (unnamed) {
         sentences.push(`Also left out of mcp_servers: ${unnamed} field${unnamed === 1 ? "" : "s"} whose name is not shaped like a field name, not repeated here, since a name could itself identify a server.`);
     }
-    return { data, sentences };
+    return { data, sentences, stale: data.enabled === false || unjudged !== undefined };
 }
 // #2842: the description is a head that fits the client cut (requiredText.ts); what each radar's
 // numbers count, field by field, is the outputSchema's description of that radar (RADAR_*_FIELDS
@@ -1858,9 +2091,38 @@ const RADAR_MCP_FIELDS = `mcp_servers: counts and timestamps only, no hostname.
 // not_assessed with measured_at null, the window is relayed in data and labelled by the note,
 // and the envelope's own note names it.
 const RADAR_METHOD = "Aggregate counts over what each radar holds on record: kev_exposure, Shodan banners whose version maps to a CISA-KEV-listed CVE; exposed_databases, services found through Shodan (LeakIX when Shodan query credits run low) and confirmed by EchelonGraph's own identified check; leaked_credentials, credential-shaped strings in public GitHub push events; shadow_ai, services found through Certificate Transparency logs and Shodan and checked by EchelonGraph's identified probes; mcp_servers, the latest verdict on record per hostname named like an MCP server in EchelonGraph's own Certificate Transparency feed, from EchelonGraph's identified MCP probe (server/discover, and initialize only if that is refused; never tools/call), where protected means the endpoint's RFC 9728 protected-resource metadata validated.";
-const RADAR_NAMES = RADARS.map(([name]) => name);
+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 {
@@ -1891,43 +2153,50 @@ async function exposureRadar() {
             const radars = failures.map(([radar, f]) => ({ radar, kind: f.kind, path: f.path, status: f.status ?? null, message: f.detail }));
             return failure("failed", message, { kind: "radars", path: null, status: null, message: `${failures.length} of ${RADARS.length} radars could not be read`, radars }, { radars: RADAR_NAMES, answered, failed: failures.map(([name]) => name) });
         }
-        // Each radar's answer is relayed cut to the fields its reader can label, in RADARS order.
-        const read = {
-            kev_exposure: readKEVExposure(data.kev_exposure),
-            exposed_databases: readExposedDatabases(data.exposed_databases),
-            leaked_credentials: readLeakedCredentials(data.leaked_credentials),
-            shadow_ai: readShadowAI(data.shadow_ai),
-            mcp_servers: readMCPServers(data.mcp_servers),
-        };
-        const relayed = {};
-        const said = [];
-        for (const [name] of RADARS) {
-            relayed[name] = read[name].data;
-            said.push(...read[name].sentences);
-        }
-        // Only what the readers relayed: a last_run_at that is not a real instant never got there.
-        const stamp = (radar, ...keys) => instantOrNull(strAt(relayed[radar], ...keys));
-        const running = boolAt(relayed.shadow_ai, "poller", "running");
-        const enabled = boolAt(relayed.mcp_servers, "enabled");
-        return succeeded(relayed, `${okHead(tool)} All ${RADARS.length} radars answered: ${RADARS.map(([name]) => name).join(", ")}. Every number relayed is labelled below by what it counts, and a field this version cannot label is left out and named. ${said.join(" ")} ${RADAR_SOURCES} ${SHODAN_OWNERSHIP} Each radar refreshes on its own schedule.`, {
-            state: "not_assessed",
-            measured_at: null,
-            method: RADAR_METHOD,
-            coverage: { radars: RADAR_NAMES, answered: RADAR_NAMES, failed: [] },
-            freshness: {
-                kev_exposure: { last_run_at: stamp("kev_exposure", "last_run_at") },
-                exposed_databases: { last_run_at: stamp("exposed_databases", "last_run_at") },
-                leaked_credentials: { last_run_at: stamp("leaked_credentials", "last_run_at") },
-                shadow_ai: { last_run_at: stamp("shadow_ai", "poller", "last_run_at"), running: running ?? null },
-                mcp_servers: { last_run_at: stamp("mcp_servers", "last_run_at"), enabled: enabled ?? null },
-            },
-            notes: [RADAR_STATE_NOTE, RADAR_FRESHNESS_NOTE],
-        });
+        return radarAnswer(data, Date.now());
     }
     catch (e) {
         return crashed(tool, e);
     }
 }
+// exposure_radar's answer once every radar has answered (and mcp_servers has passed mcpRefusal):
+// each radar's answer relayed cut to the fields its reader can label, in RADARS order, and the
+// note. `now` is the clock the radars' last completed checks are aged against (#3010; see
+// STALE_AFTER), a parameter so that the suite can set it.
+export function radarAnswer(data, now) {
+    const read = {
+        kev_exposure: readKEVExposure(data.kev_exposure, now),
+        exposed_databases: readExposedDatabases(data.exposed_databases, now),
+        leaked_credentials: readLeakedCredentials(data.leaked_credentials, now),
+        shadow_ai: readShadowAI(data.shadow_ai, now),
+        mcp_servers: readMCPServers(data.mcp_servers, now),
+    };
+    const relayed = {};
+    const said = [];
+    for (const [name] of RADARS) {
+        relayed[name] = read[name].data;
+        said.push(...read[name].sentences);
+    }
+    const stale = RADAR_NAMES.filter((name) => read[name].stale);
+    // Only what the readers relayed: a last_run_at that is not a real instant never got there.
+    const stamp = (radar, ...keys) => instantOrNull(strAt(relayed[radar], ...keys));
+    const running = boolAt(relayed.shadow_ai, "poller", "running");
+    const enabled = boolAt(relayed.mcp_servers, "enabled");
+    return succeeded(relayed, `${okHead("exposure_radar")} All ${RADARS.length} radars answered: ${RADARS.map(([name]) => name).join(", ")}. Every number relayed is labelled below by what it counts, and a field this version cannot label is left out and named. ${said.join(" ")} ${RADAR_SOURCES} ${SHODAN_OWNERSHIP} ${freshnessClose(stale)}`, {
+        state: "not_assessed",
+        measured_at: null,
+        method: RADAR_METHOD,
+        coverage: { radars: RADAR_NAMES, answered: RADAR_NAMES, failed: [] },
+        freshness: {
+            kev_exposure: { last_run_at: stamp("kev_exposure", "last_run_at") },
+            exposed_databases: { last_run_at: stamp("exposed_databases", "last_run_at") },
+            leaked_credentials: { last_run_at: stamp("leaked_credentials", "last_run_at") },
+            shadow_ai: { last_run_at: stamp("shadow_ai", "poller", "last_run_at"), running: running ?? null },
+            mcp_servers: { last_run_at: stamp("mcp_servers", "last_run_at"), enabled: enabled ?? null },
+        },
+        notes: [RADAR_STATE_NOTE, RADAR_FRESHNESS_NOTE],
+    });
+}
 // ── outputSchema: the envelope, per tool (#2311, #2313) ──
 //
 // A discriminated union on state: a success (measured, not_assessed) carries data and a method;
@@ -1953,6 +2222,10 @@ 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() }));
 export function envelopeSchema(o) {
     const coverage = o.coverage ? o.coverage.nullable() : z.null();
     return z.discriminatedUnion("state", [
@@ -1964,6 +2237,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({
@@ -1994,9 +2269,23 @@ 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"];
+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, written by its CNA, that names a fixed version; relayed as cna_solution) and description_fix (a sentence of the CVE description that names a fixed version)";
+// #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, 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. Absent where the record's solutions name no fixed version, as well as where the field itself is: " +
+    CVE_CNA_ABSENT;
 // #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.";
@@ -2008,14 +2297,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()),
@@ -2030,6 +2319,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()),
@@ -2043,12 +2335,18 @@ 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),
     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()),
@@ -2303,9 +2601,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.`,
@@ -2317,30 +2616,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.
@@ -2361,7 +2662,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