echelongraph-mcp 2.7.2 → 3.0.0

package/dist/tools/cve_intel.js

@@ -41,7 +41,7 @@
 // the rows where fixed_version is not the whole answer.
 import * as z from "zod";
 import { ANNOTATIONS, CVE_ID, NOT_A_FINDING, SHOWN_BASE, api, badInput, boolAt, checked, crashed, envelopeSchema, failed, failure, field, numAt, okHead, opt, strAt, succeeded, } from "../index.js";
-import { TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
+import { answering, FULL_ARG, TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
 const TOOL = "cve_intel";
 // The sections relayed, in the answer's order, and the keys each failed_sections name covers.
 const LISTS = ["cwes", "exploits", "affected_packages", "fixed_versions", "timeline"];
@@ -75,11 +75,16 @@ const API_ROW_LIMIT = { exploits: 10, affected_packages: 50, fixed_versions: 200
 const TIMELINE_RELAYED = 20;
 const CVE_INTEL_METHOD = "EchelonGraph's per-CVE enrichment (GET /api/v1/public/cves/:id/enrichment). cwes: CWE classifications stored from NVD, GitHub (GHSA) and CVE.org records, each with the source that gave it, named from the MITRE CWE catalog EchelonGraph embeds. exploits: public exploit references from EchelonGraph's cve_exploits records, whose data model holds Metasploit modules (metasploit), Exploit-DB entries (exploit_db), nuclei templates (nuclei_template), GitHub proof-of-concept repositories (github_poc) and vendor proofs of concept (vendor_poc), filled by a curated seed and by one poller per automated source, each run only where it is enabled, so which sources are current depends on the deployment. affected_packages and fixed_versions: package-ecosystem advisory data, each row naming its source. timeline: EchelonGraph's enrichment history for the CVE, newest first.";
 const VERIFIED_STATUS_DESCRIPTION = "verified_status is the label stored with each reference: verified for a Metasploit module, for an Exploit-DB entry Exploit-DB marks verified, and for curated seed rows marked so; reported for a public artefact nothing has confirmed works (nuclei templates, GitHub proofs of concept, unverified Exploit-DB entries); unconfirmed where a curated row says so. It is a label from the source, not a guarantee that the exploit works against a given system.";
-const FIXED_BRANCHES_DESCRIPTION = 'fixed_branches lists each affected range of the package on record: introduced, and fixed (the range\'s fix) or last_affected (its last affected version, where no fix is on record), each null when absent, with advisory_id (the OSV record that published the range) and source (the loader\'s label for that record), both null on a row loaded before they were stored. Ranges with an advisory_id are in the order their record lists them (records in id order); ranges without one are oldest first. To pick the range for an installed version, compare in the ecosystem\'s version order (release numbers part by part, as numbers: 2.4 is below 2.13.0): the version is in a range when it is at or above introduced ("0" is the first version) and below fixed, or at or below last_affected; that range\'s fixed is the fix for it, and a version in no range is outside every range on record. fixed_branches is null where the package\'s ranges were never loaded, and [] where no version range is on record (the advisory gives none, only commit ranges, or more than are stored), which is not a finding that no fix exists: fixed_version can still name one. fixed_version is one range\'s fix, kept for compatibility (one per package: the range the loader kept, the advisory\'s last as a rule), not the fix for every affected range: for CVE-2021-44228, its advisory gives log4j-core three ranges, and fixed_version 2.12.2 is the fix for the one from 2.4, while the range holding 2.14.1 (from 2.13.0) is fixed in 2.15.0.';
+const FIXED_BRANCHES_DESCRIPTION = 'fixed_branches lists each affected range of the package on record: introduced, and fixed (the range\'s fix) or last_affected (its last affected version, where no fix is on record), each null when absent, with advisory_id (the OSV record that published the range) and source (the loader\'s label for that record), both null on a row loaded before they were stored. Ranges with an advisory_id are in the order their record lists them (records in id order); ranges without one are oldest first. To pick the range for an installed version, compare in the ecosystem\'s version order (release numbers part by part, as numbers: 2.4 is below 2.13.0): the version is in a range when it is at or above introduced ("0" is the first version) and below fixed, or at or below last_affected; its fix is that range\'s fixed, or, while another range still holds that, the other range\'s fixed (none past a range without one); a version in no range is outside every range on record. fixed_branches is null where the package\'s ranges were never loaded, and [] where no version range is on record (the advisory gives none, only commit ranges, or more than are stored), which is not a finding that no fix exists: fixed_version can still name one. fixed_version is one range\'s fix, kept for compatibility (one per package: the range the loader kept, the advisory\'s last as a rule), not the fix for every affected range: for CVE-2021-44228, its advisory gives log4j-core three ranges, and fixed_version 2.12.2 is the fix for the one from 2.4, while the range holding 2.14.1 (from 2.13.0) is fixed in 2.15.0.';
 // #2876: the exploit dates are named for what they are. Within the 100 characters of headroom
 // under the 2048-character client cut (prompts-resources.test.mjs), the room came from tighter
 // glosses and from the input hint, which inputSchema's cve_id description carries.
-export const CVE_INTEL_DESCRIPTION = `Weakness, public exploit code, affected packages and fixed versions for one CVE, from EchelonGraph's per-CVE enrichment. Returns cwes (each cwe_id with name and source), exploits (each with kind, source_name, source_url, source_published_at (the source's date, null if none), eg_first_seen_at (when EchelonGraph recorded it) and verified_status; at most 10, verified first) with exploits_total, exploits_capped, exploits_by_kind and exploits_by_status, affected_packages (ecosystem, package_name, version_range, fixed_version, fixed_branches), fixed_versions (each fixed version with the vulnerable_range it fixes) and timeline (the newest enrichment-history rows, with timeline_total). fixed_branches lists each affected range on record (introduced, and fixed or last_affected, with advisory_id (its OSV record) and source); in the ecosystem's version order, a version is in a range when it is at or above introduced ("0" is the first version) and below fixed, or at or below last_affected; that range's fixed is the fix for it. fixed_version is one range's fix, kept for compatibility, not the fix for every affected range. fixed_branches [] is not a finding that no fix exists. verified_status is the source's label, not a guarantee the exploit works on a given system. An empty exploits list is not evidence that no public exploit exists: it covers only the sources EchelonGraph ingests, and which are polled depends on the deployment. A section the API could not read is named in coverage.sections_failed and left out of data, never relayed as an empty list. Its structured result carries notes, with data, which the first text block holds whole up to 30,000 characters; its coverage names the sections relayed, failed and left out. ${TEXT_BUDGET_DESCRIPTION}`;
+// #3013's review: in #3074's first cut the fixed_branches sentence still said a range's fixed is
+// the fix for a version it holds, the rule that gave lodash 4.17.15 under CVE-2026-4800 the
+// still-affected 4.17.21 (ranges [0, 4.17.21) and [4.0.0, 4.18.0); the fix is 4.18.0). It now
+// states the walk FIXED_BRANCHES_DESCRIPTION and branchSentences state, in fewer characters than
+// the old rule (a range's bounds folded into the list of its fields), so the headroom holds.
+export const CVE_INTEL_DESCRIPTION = `Weakness, public exploit code, affected packages and fixed versions for one CVE, from EchelonGraph's per-CVE enrichment. Returns cwes (each cwe_id with name and source), exploits (each with kind, source_name, source_url, source_published_at (the source's date, null if none), eg_first_seen_at (when EchelonGraph recorded it) and verified_status; at most 10, verified first) with exploits_total, exploits_capped, exploits_by_kind and exploits_by_status, affected_packages (ecosystem, package_name, version_range, fixed_version, fixed_branches), fixed_versions (each fixed version with the vulnerable_range it fixes) and timeline (the newest enrichment-history rows, with timeline_total). fixed_branches lists each affected range on record (from introduced ("0" is the first version) to below fixed, or through last_affected, with advisory_id (its OSV record) and source); in the ecosystem's version order, an affected version's fix is the first fixed above it that no range of its row holds (none past a range with no fixed). fixed_version is one range's fix, kept for compatibility, not the fix for every affected range. fixed_branches [] is not a finding that no fix exists. verified_status is the source's label, not a guarantee the exploit works on a given system. An empty exploits list is not evidence that no public exploit exists: it covers only the sources EchelonGraph ingests, and which are polled depends on the deployment. A section the API could not read is named in coverage.sections_failed and left out of data, never relayed as an empty list. Its structured result carries notes, with data, which the first text block holds whole up to 30,000 characters; its coverage names the sections relayed, failed and left out. ${TEXT_BUDGET_DESCRIPTION}`;
 // ── outputSchema ──
 const Rows = (shape) => z.array(z.looseObject(shape));
 const CountMap = z.record(z.string(), z.number());
@@ -238,7 +243,7 @@ function branchSentences(rows) {
     });
     const few = (xs) => (xs.length <= 3 ? listed(xs) : `${xs.slice(0, 3).join(", ")} and ${xs.length - 3} more`);
     if (multi.length) {
-        out.push(`${multi.length} affected_packages row${multi.length === 1 ? " lists" : "s list"} more than one affected range in fixed_branches (${few(multi)}): there, fixed_version is one range's fix, and an installed version's fix is the fixed of the range that holds it.`);
+        out.push(`${multi.length} affected_packages row${multi.length === 1 ? " lists" : "s list"} more than one affected range in fixed_branches (${few(multi)}): there, fixed_version is one range's fix, and an installed version's fix is the first fixed above it that no range of the row holds: the fixed of the range that holds it, or, while another range still holds that version, that range's fixed (none where a range on the way has no fixed).`);
     }
     if (unknown.length) {
         out.push(`${unknown.length} affected_packages row${unknown.length === 1 ? " carries" : "s carry"} fixed_branches null (${few(unknown)}): ${unknown.length === 1 ? "its" : "their"} ranges are not on record, so fixed_version, one range's fix, is all the answer holds, and it need not be the fix for a given installed version.`);
@@ -345,13 +350,17 @@ export async function cveIntel(cve_id) {
         return crashed(TOOL, e);
     }
 }
+// #3013: the structured result's cut. CVE-2021-44228's is 12,877 characters, within the budget; past
+// it the newest enrichment-history rows go first, then the affected packages and fixed versions,
+// each to at most the same number of its first entries, then any other list at the top of data.
+const CVE_INTEL_DATA = { steps: [{ lists: ["timeline"] }, { lists: ["affected_packages", "fixed_versions"] }] };
 export function registerCveIntel(server) {
     const { output } = schemasOnce();
     server.registerTool("cve_intel", {
         title: "CVE weakness, exploits and packages",
         description: CVE_INTEL_DESCRIPTION,
-        inputSchema: z.object({ cve_id: z.string().describe("a CVE ID, e.g. CVE-2021-44228") }),
+        inputSchema: z.object({ cve_id: z.string().describe("a CVE ID, e.g. CVE-2021-44228"), full: FULL_ARG }),
         outputSchema: output,
         annotations: ANNOTATIONS,
-    }, async ({ cve_id }) => checked(TOOL, output, await cveIntel(cve_id)));
+    }, async ({ cve_id, full }) => checked(TOOL, output, await answering(full, CVE_INTEL_DATA, () => cveIntel(cve_id))));
 }

package/dist/tools/cve_remediation.js

@@ -7,13 +7,15 @@
 // What the answer holds:
 //   cisa                 CISA KEV's required_action, due_date, short_description and notes_urls
 //                        for a KEV-listed CVE. CISA directs the action at US federal civilian
-//                        agencies (BOD 22-01); it is not EchelonGraph's advice.
+//                        agencies (under BOD 26-04, which replaced BOD 22-01 on
+//                        10 June 2026); it is not EchelonGraph's advice.
 //   fixed_branches       each affected package with every affected range and its fix.
 //   vendor_remediations  each vendor advisory naming the CVE (at most 20, newest first), with its
 //                        remediation_state and the items it lists for the CVE, each with the
 //                        vendor's own category (kind): vendor_fix, workaround, mitigation,
 //                        no_fix_planned, none_available or other.
-//   fix_references       the record's references tagged Patch or Mitigation.
+//   fix_references       the record's references tagged Patch or Mitigation, by NVD, or patch or
+//                        mitigation, by the CNA (#2841: the API matches the tag in either case).
 //   patches              cve_patches rows.
 //   coverage             parsed_vendors, vendors_not_parsed and the caps.
 //   failed_sections      the sections the API could not read.
@@ -21,19 +23,40 @@
 // The rules the note keeps: not_parsed is not "no remediation"; none_in_source is what the
 // advisory lists, not a finding that no fix exists; an empty section is "none on record", never
 // "no fix"; a failed section is named, never relayed as empty. A REJECTED CVE is not_assessed.
+//
+// fix_status (#2841, #2518 item 3) is the API's fix-status rule (core-backend cve/fixstatus.go,
+// the rule /pulse pages render), relayed: this file derives nothing from it.
+//
+// The installed version (#2841): ecosystem, package and version, all three or none. They travel
+// in the X-EG-Ecosystem, X-EG-Package and X-EG-Version request headers, percent-encoded as
+// check_affected sends them, and never in the URL (#1983: Cloud Run's request log records the URL
+// and no request header). The API answers installed (what was asked and its verdict) and fixed_in,
+// the first version above it that no affected range on record holds (the fixed bound of the range
+// holding it, moved past any overlapping range, with fixed_in_detail naming it, #3074), or null
+// with fixed_in_reason, from the registry matcher check_affected's registry path runs; that answer
+// is private, no-store.
 import * as z from "zod";
 import { ANNOTATIONS, CVE_ID, SHOWN_BASE, api, badInput, checked, crashed, envelopeSchema, failed, failure, field, NOT_A_FINDING, okHead, opt, strAt, succeeded } from "../index.js";
-import { TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
+import { answering, FULL_ARG, TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
+import { fixStatusSchema } from "../fixStatus.js";
+import { MATCH_HEADERS } from "./check_affected.js";
 const TOOL = "cve_remediation";
 const SECTIONS = ["cisa", "fixed_branches", "vendor_remediations", "fix_references", "patches"];
 const KINDS = ["vendor_fix", "workaround", "mitigation", "no_fix_planned", "none_available", "other"];
 const STATES = ["parsed", "none_in_source", "not_parsed", "withdrawn"];
+// core-backend cve/pkgmatch_fixedin.go InstalledFix's verdicts.
+const VERDICTS = ["affected", "not_affected", "undetermined", "not_assessed"];
+// The installed version's arguments, in the order the headers are named.
+const INSTALLED = ["ecosystem", "package", "version"];
 // Required in the description's head (src/requiredText.ts REQUIRED_IN_HEAD.cve_remediation).
 export const REMEDIATION_UNTESTED = "Every text is relayed as stated by its source; EchelonGraph has not tested it.";
 export const REMEDIATION_NOT_A_ZERO = "An empty list or a remediation_state of none_in_source or not_parsed is not a finding that no fix exists.";
-export const REMEDIATION_CISA = "CISA's required_action is directed at US federal civilian agencies (BOD 22-01) and is not EchelonGraph's advice.";
-const METHOD = "EchelonGraph's stored sources for one CVE (GET /api/v1/public/cves/:id/remediation): CISA's Known Exploited Vulnerabilities catalog text; the affected ranges and fixes of OSV advisories; the remediation each vendor advisory lists, categorised by the vendor's own category (Red Hat CSAF remediations, MSRC CVRF Workaround, Mitigation and Vendor Fix rows, Palo Alto's solution and work_around sections); the CVE record's references NVD tagged Patch or Mitigation; and cve_patches. Nothing is generated or tested.";
-export const CVE_REMEDIATION_DESCRIPTION = `How one CVE is fixed, as its sources state it, in one answer. ${REMEDIATION_UNTESTED} ${REMEDIATION_NOT_A_ZERO} Returns cisa (kev_listed, and for a KEV-listed CVE CISA's required_action, due_date, short_description and notes_urls, verbatim; ${REMEDIATION_CISA}), fixed_branches (each affected package with fixed_branches: every affected range, introduced and fixed or last_affected, and fixed_version, one range's fix), vendor_remediations (each vendor advisory naming the CVE, newest first, at most 20: vendor, vendor_advisory_id, remediation_state, remediation_kinds and items, each item with kind, source_category, text, url, fixed_build, product_ids and product_count), fix_references (the record's references NVD tagged Patch or Mitigation), patches, coverage (parsed_vendors, vendors_not_parsed and the caps) and failed_sections. kind is the vendor's own category, never read from the text: vendor_fix, workaround, mitigation, no_fix_planned, none_available, or other with the vendor's name for it in source_category. remediation_state is parsed, none_in_source (parsed; the advisory lists none for this CVE), not_parsed (EchelonGraph does not read that vendor's remediation) or withdrawn. A section the API could not read is named in failed_sections and coverage.sections_failed, never relayed as empty. A REJECTED CVE answers not_assessed. Pass a CVE ID like CVE-2021-44228. ${TEXT_BUDGET_DESCRIPTION} Cut, vendor texts are shortened first; kinds, states and URLs are kept.`;
+export const REMEDIATION_CISA = "CISA's required_action is directed at US federal civilian agencies (under BOD 26-04, which replaced BOD 22-01 on 10 June 2026) and is not EchelonGraph's advice.";
+const METHOD = "EchelonGraph's stored sources for one CVE (GET /api/v1/public/cves/:id/remediation): CISA's Known Exploited Vulnerabilities catalog text; the affected ranges and fixes of OSV advisories; the remediation each vendor advisory lists, categorised by the vendor's own category (Red Hat CSAF remediations, MSRC CVRF Workaround, Mitigation and Vendor Fix rows, Palo Alto's solution and work_around sections); the CVE record's references tagged Patch or Mitigation by NVD, or patch or mitigation by the CNA; and cve_patches. Nothing is generated or tested.";
+// #3084 (merged from 24dad5eb): REMEDIATION_CISA names BOD 26-04, which replaced BOD 22-01, 48 characters
+// longer, which left this description 71 under the 2048-character cut (#2924's floor is 100); the
+// remediation_state parentheses and the failed_sections sentence are said shorter, every claim kept.
+export const CVE_REMEDIATION_DESCRIPTION = `How one CVE is fixed, as its sources state it, in one answer. ${REMEDIATION_UNTESTED} ${REMEDIATION_NOT_A_ZERO} Returns fix_status (the API's fix-status rule, as CVE Pulse shows it: state and basis), cisa (for a KEV-listed CVE CISA's required_action, due_date, short_description and notes_urls, verbatim; ${REMEDIATION_CISA}), fixed_branches (each affected package with fixed_branches: every affected range, introduced and fixed or last_affected, and fixed_version, one range's fix), vendor_remediations (each vendor advisory naming the CVE, newest first, at most 20, with remediation_state, remediation_kinds and items, each with kind, source_category, text and url), fix_references (references NVD or the CNA tagged Patch or Mitigation), patches, coverage and failed_sections. kind is the vendor's own category, never read from the text: vendor_fix, workaround, mitigation, no_fix_planned, none_available or other. remediation_state is parsed, none_in_source (none listed for this CVE), not_parsed (that vendor's remediation is not read) or withdrawn. ecosystem, package and version (all three or none, sent in request headers, never in the URL) add installed, the verdict at that version, and fixed_in, the lowest unaffected version above it, or null with fixed_in_reason. A section the API could not read is named in failed_sections, not relayed as empty. A REJECTED CVE answers not_assessed. ${TEXT_BUDGET_DESCRIPTION} Cut, vendor texts are shortened first; kinds, states and URLs are kept.`;
 // ── outputSchema ──
 // Built on first use: index.ts imports this file, so its exports are not initialised while this
 // module's top level runs.
@@ -67,6 +90,19 @@ function schemas() {
         cve_id: opt(z.string()),
         state: opt(z.string()).describe("assessed, or not_assessed for a CVE record rejected by its numbering authority."),
         not_assessed_reason: opt(z.string()),
+        fix_status: fixStatusSchema(),
+        installed: opt(z.looseObject({
+            ecosystem: opt(z.string()).describe("The ecosystem asked for, in its canonical OSV spelling."),
+            ecosystem_recognised: opt(z.boolean()),
+            package: opt(z.string()),
+            version: opt(z.string()),
+            verdict: opt(z.union([z.enum(VERDICTS), z.string()])).describe("affected (a range on record holds the version), not_affected (no range on record holds it), undetermined (a range could not be decided at it) or not_assessed (the record names no such package for this CVE, or the lookup did not run)."),
+            version_evidence: opt(z.string()),
+            interval: opt(z.looseObject({ introduced: opt(z.string()), fixed: opt(z.string()), last_affected: opt(z.string()) })).describe("The affected range holding the version (fixed is exclusive, last_affected inclusive); absent when none holds it."),
+        })).describe("The installed version asked for, as the API read it from the request headers, and its verdict against this CVE; absent when none was asked."),
+        fixed_in: opt(z.string()).describe("With an installed version: the first version above it that no affected range on record holds, always above it, as the advisory states it: the fixed bound of the range holding it, moved past any overlapping range that still holds that bound (fixed_in_detail then names it). null when no range on record holds it, no fix is on record past the ranges holding it, or the version was not assessed, with fixed_in_reason saying which. Absent when no installed version was asked."),
+        fixed_in_reason: opt(z.string()).describe("Why fixed_in is null; absent when fixed_in is a version."),
+        fixed_in_detail: opt(z.string()).describe("Set when fixed_in is not the fixed bound of the range holding the installed version: the overlapping ranges of the same record it moved past, which still hold that bound."),
         cisa: z
             .looseObject({
             kev_listed: opt(z.boolean()),
@@ -103,6 +139,10 @@ function schemas() {
         vendor_advisory_limit: z.number().nullable(),
         item_text_cap: z.number().nullable(),
         items_per_advisory_cap: z.number().nullable(),
+        installed_asked: z
+            .strictObject({ ecosystem: z.string(), package: z.string(), version: z.string() })
+            .nullable()
+            .describe("The installed version this call sent (in request headers), as given; null when none."),
     });
     return { output: envelopeSchema({ data, coverage, freshness: null }) };
 }
@@ -115,7 +155,42 @@ const CUT = {
         { keep: ["vendor", "vendor_advisory_id", "withdrawn", "remediation_state", "remediation_kinds", "items_total", ["items", ["kind", "source_category", "text", "url", "fixed_build"]]], clip: 400, cap: 16 },
         { keep: ["vendor", "vendor_advisory_id", "remediation_state", "remediation_kinds", ["items", ["kind", "url"]]], clip: 2048, cap: 8 },
     ],
-    whole: "get_vendor_advisory returns any one of these advisories by its vendor and vendor_advisory_id, whole in its structuredContent.data, with every remediation item it lists.",
+    whole: "get_vendor_advisory returns any one of these advisories by its vendor and vendor_advisory_id, whole in its structuredContent.data with full: true, with every remediation item it lists.",
+};
+// #3013: the structured result's cut. CVE-2021-44228's answer is 75,963 characters of structured
+// result, 61,248 of them its 20 vendor_remediations, whose items carry the vendor's text (about 550
+// characters an item, the payload) and its product_ids (about 550, the vendor's own identifiers).
+// Before any advisory leaves, every advisory's items are thinned: product_ids first, keeping each
+// text; then the texts, keeping each item's kind, source_category, url and fixed_build, so every
+// advisory stays named with its state, kinds and links (get_vendor_advisory returns one whole).
+// Only then do advisories leave from the end, then the patches, then any other list at the top of
+// data. fix_status and fixed_in (#2841) are not lists, and installed is an object, so none of them
+// is ever cut.
+//
+// #3013's review: the second level leaves every item's text out of data, and the text is the
+// vendor's step itself (a workaround's or mitigation's wording), which the triage_cve and
+// sbom_review prompts have the model quote. No string is shortened (the cut's rule), so the note
+// says the text is gone and where each one is: get_vendor_advisory, by the advisory's vendor and
+// vendor_advisory_id, returns that advisory's remediations with their texts, and the same call
+// with full: true returns this data whole; the prompts send the model there when it is cut.
+const ADVISORY_FIELDS = ["vendor", "vendor_display_name", "vendor_advisory_id", "vendor_published_at", "withdrawn", "remediation_state", "remediation_kinds", "items_total"];
+const ITEM_TEXT_ELSEWHERE = "No item in data keeps its text, the vendor's own wording of the step (a workaround or mitigation among them): get_vendor_advisory, given an advisory's vendor and its vendor_advisory_id as advisory_id, returns it among that advisory's remediations, whole in its structuredContent.data with full: true.";
+const CVE_REMEDIATION_DATA = {
+    steps: [
+        {
+            lists: ["vendor_remediations"],
+            thin: [
+                [...ADVISORY_FIELDS, ["items", ["kind", "source_category", "source_subcategory", "text", "text_truncated", "text_chars", "url", "fixed_build", "product_count"]]],
+                [...ADVISORY_FIELDS, ["items", ["kind", "source_category", "url", "fixed_build"]]],
+            ],
+        },
+        { lists: ["patches"] },
+    ],
+    // Said where the advisories kept are thinned to a level whose items keep no text.
+    page: (_t, _d, at) => {
+        const items = at.keeps.vendor_remediations?.find((x) => typeof x !== "string" && x[0] === "items");
+        return items && !items[1].includes("text") ? ITEM_TEXT_ELSEWHERE : "";
+    },
 };
 const listed = (xs) => (xs.length <= 1 ? (xs[0] ?? "") : `${xs.slice(0, -1).join(", ")} and ${xs.at(-1)}`);
 const arr = (v) => (Array.isArray(v) ? v : null);
@@ -162,18 +237,64 @@ function branchSentence(rows) {
                 fixed++;
         }
     }
-    return `fixed_branches lists ${rows.length} affected package${rows.length === 1 ? "" : "s"} with ${ranges} affected range${ranges === 1 ? "" : "s"}, ${fixed} with a fix on record; an installed version's fix is the fixed of the range that holds it, compared in the ecosystem's version order.`;
+    return `fixed_branches lists ${rows.length} affected package${rows.length === 1 ? "" : "s"} with ${ranges} affected range${ranges === 1 ? "" : "s"}, ${fixed} with a fix on record; an installed version's fix is the first fixed above it that no range of its package holds (the fixed of the range that holds it, or, while another range still holds that version, that range's fixed), compared in the ecosystem's version order.`;
+}
+// fix_status's sentence: what the API's rule says, relayed. Nothing about the fix is inferred here.
+function fixStatusSentence(cve, fs) {
+    if (fs === null || fs === undefined)
+        return null;
+    const state = strAt(fs, "state");
+    if (!state)
+        return null;
+    const basis = strAt(fs, "basis");
+    const unread = Array.isArray(field(fs, "unread_inputs")) ? field(fs, "unread_inputs").filter((x) => typeof x === "string") : [];
+    const why = state === "none_confirmed" ? ", which is not a finding that no fix exists" : "";
+    const notRead = unread.length ? `; it rests without ${listed(unread)}, which the API could not read (unread_inputs)` : "";
+    return `fix_status for ${cve} is ${state}${basis ? ` (basis ${basis})` : ""}, the API's fix-status rule${why}${notRead}.`;
 }
-export async function cveRemediation(cve_id) {
-    const id = cve_id.trim();
+// The sentence on the installed version asked: what the API answered for it, relayed.
+function installedSentence(asked, d) {
+    const who = `${asked.ecosystem} ${asked.package} ${asked.version}`;
+    if (!("fixed_in" in d)) {
+        return `The answer carries no fixed_in for the installed version asked (${who}): the API did not assess it, which is not a finding either way.`;
+    }
+    const inst = field(d, "installed");
+    const verdict = strAt(inst, "verdict");
+    const fixedIn = strAt(d, "fixed_in");
+    if (fixedIn) {
+        // #3074: fixed_in moved past an overlapping range, so it is not the holding range's bound.
+        const detail = strAt(d, "fixed_in_detail");
+        if (detail) {
+            return `For the installed version asked (${who}), installed.verdict is ${verdict ?? "not given"} and fixed_in is ${fixedIn}: the first version above it that no affected range on record holds (${detail}), as the advisory states it; EchelonGraph has not tested it.`;
+        }
+        const lo = strAt(field(inst, "interval"), "introduced");
+        const range = lo ? ` [${lo}, ${fixedIn})` : "";
+        return `For the installed version asked (${who}), installed.verdict is ${verdict ?? "not given"} and fixed_in is ${fixedIn}: the fixed bound of the affected range${range} that holds it, as the advisory states it; EchelonGraph has not tested it.`;
+    }
+    const reason = strAt(d, "fixed_in_reason") ?? "the answer gives no fixed_in_reason";
+    return `For the installed version asked (${who}), installed.verdict is ${verdict ?? "not given"} and fixed_in is null: ${reason}.`;
+}
+export async function cveRemediation(args) {
+    const id = (args.cve_id ?? "").trim();
     if (!id)
         return badInput(TOOL, "cve_id is required");
     if (!CVE_ID.test(id))
         return badInput(TOOL, `cve_id ${JSON.stringify(id.slice(0, 32))} is not a CVE id (expected the form CVE-2021-44228)`);
+    // The installed version: all three or none.
+    const given = { ecosystem: (args.ecosystem ?? "").trim(), package: (args.package ?? "").trim(), version: (args.version ?? "").trim() };
+    const present = INSTALLED.filter((k) => given[k] !== "");
+    const missing = INSTALLED.filter((k) => given[k] === "");
+    if (present.length > 0 && missing.length > 0) {
+        return badInput(TOOL, `ecosystem, package and version go together, all three or none: ${listed([...missing])} ${missing.length === 1 ? "is" : "are"} missing (given: ${listed([...present])})`);
+    }
+    const asked = present.length === INSTALLED.length ? given : null;
     const cve = id.toUpperCase();
     const path = `/api/v1/public/cves/${encodeURIComponent(cve)}/remediation`;
+    // #1983: percent-encoded, as the backend's matchHeaderValue decodes them; never in the URL.
+    const enc = encodeURIComponent;
+    const headers = asked ? { [MATCH_HEADERS.ecosystem]: enc(asked.ecosystem), [MATCH_HEADERS.package]: enc(asked.package), [MATCH_HEADERS.version]: enc(asked.version) } : undefined;
     try {
-        const r = await api(path);
+        const r = await api(path, headers ? { headers } : undefined);
         if (!r.ok)
             return failed(TOOL, r);
         const d = r.data;
@@ -197,11 +318,13 @@ export async function cveRemediation(cve_id) {
             vendor_advisory_limit: typeof field(cov, "vendor_advisory_limit") === "number" ? field(cov, "vendor_advisory_limit") : null,
             item_text_cap: typeof field(cov, "item_text_cap") === "number" ? field(cov, "item_text_cap") : null,
             items_per_advisory_cap: typeof field(cov, "items_per_advisory_cap") === "number" ? field(cov, "items_per_advisory_cap") : null,
+            installed_asked: asked,
         };
         const head = okHead(TOOL, r.status);
         if (state === "not_assessed") {
             const reason = strAt(d, "not_assessed_reason") ?? "the API gives no reason";
-            return succeeded(d, `${head} NOT ASSESSED: ${cve}'s remediation is not assessed (${reason}). A rejected CVE record is not an active vulnerability, so no fix is relayed for it.`, {
+            const inst = asked ? ` ${installedSentence(asked, d)}` : "";
+            return succeeded(d, `${head} NOT ASSESSED: ${cve}'s remediation is not assessed (${reason}). A rejected CVE record is not an active vulnerability, so no fix is relayed for it.${inst}`, {
                 state: "not_assessed",
                 measured_at: null,
                 method: METHOD,
@@ -211,6 +334,11 @@ export async function cveRemediation(cve_id) {
             });
         }
         const said = [];
+        const fixSaid = fixStatusSentence(cve, field(d, "fix_status"));
+        if (fixSaid)
+            said.push(fixSaid);
+        if (asked)
+            said.push(installedSentence(asked, d));
         const cisa = field(d, "cisa");
         const action = strAt(cisa, "required_action");
         if (field(cisa, "kev_listed") === true) {
@@ -225,8 +353,12 @@ export async function cveRemediation(cve_id) {
         if (vendors && !(reported ?? []).includes("vendor_remediations"))
             said.push(...vendorSentences(cve, vendors));
         const refs = arr(field(d, "fix_references"));
-        if (refs)
-            said.push(refs.length ? `fix_references lists ${refs.length} reference${refs.length === 1 ? "" : "s"} the CVE record tags Patch or Mitigation.` : "No reference of the CVE record is tagged Patch or Mitigation.");
+        // #2841: the API keeps both spellings, NVD's (Patch, Mitigation) and a CNA's (patch, mitigation).
+        if (refs) {
+            said.push(refs.length
+                ? `fix_references lists ${refs.length} reference${refs.length === 1 ? "" : "s"} the CVE record tags as a patch or mitigation (NVD's Patch or Mitigation, or the CNA's patch or mitigation), each with the tags as written.`
+                : "No reference of the CVE record is tagged as a patch or mitigation, in NVD's spelling (Patch, Mitigation) or the CNA's (patch, mitigation).");
+        }
         if (reported === null)
             said.push("The answer carries no failed_sections, so an empty section may be one the API could not read, not a finding of none.");
         else if (reported.length)
@@ -250,8 +382,16 @@ export function registerCveRemediation(server) {
     server.registerTool(TOOL, {
         title: "How one CVE is fixed",
         description: CVE_REMEDIATION_DESCRIPTION,
-        inputSchema: z.object({ cve_id: z.string().describe("a CVE ID, e.g. CVE-2021-44228") }),
+        inputSchema: CVE_REMEDIATION_INPUT,
         outputSchema: output,
         annotations: ANNOTATIONS,
-    }, async ({ cve_id }) => checked(TOOL, output, await cveRemediation(cve_id)));
+    }, async (args) => checked(TOOL, output, await answering(args.full, CVE_REMEDIATION_DATA, () => cveRemediation(args))));
 }
+// The installed version is optional and all-or-none (cveRemediation refuses a partial set).
+export const CVE_REMEDIATION_INPUT = z.object({
+    cve_id: z.string().describe("a CVE ID, e.g. CVE-2021-44228"),
+    ecosystem: z.string().optional().describe("Installed version, with package and version: the package's ecosystem, such as npm, PyPI or Maven. Sent in a request header."),
+    package: z.string().optional().describe("Installed version, with ecosystem and version: the package name in that ecosystem, such as org.apache.logging.log4j:log4j-core. Sent in a request header."),
+    version: z.string().optional().describe("Installed version, with ecosystem and package: the version installed, such as 2.14.1. Sent in a request header."),
+    full: FULL_ARG,
+});

package/dist/tools/epss_history.js

@@ -1,5 +1,5 @@
 import * as z from "zod";
-import { TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
+import { answering, FULL_ARG, NO_DATA_CUT, TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
 const TOOL = "epss_history";
 const CVE_ID = /^CVE-\d{4}-\d{4,}$/i;
 export const EPSS_HISTORY_METHOD = "EchelonGraph's record of FIRST's EPSS scores: the nightly EPSS fetcher overwrites each CVE's epss_score and epss_percentile from FIRST's published file and, for every CVE whose value changed, records the new values with the time it wrote them; this series is those records, oldest first, with repeated records of one change collapsed into the first.";
@@ -213,8 +213,11 @@ export function registerEPSSHistory(server, kit) {
     server.registerTool(TOOL, {
         title: "EPSS change history for one CVE",
         description: EPSS_HISTORY_DESCRIPTION,
-        inputSchema: z.object({ cve_id: kit.cveIdArg }),
+        inputSchema: z.object({ cve_id: kit.cveIdArg, full: FULL_ARG }),
         outputSchema: output,
         annotations: kit.annotations,
-    }, async ({ cve_id }) => kit.checked(TOOL, output, await epssHistory(kit, cve_id)));
+    }, 
+    // #3013: a few points a CVE, the API's own cap on them, 2,508 characters for CVE-2021-44228:
+    // no list is named, so only a list at the top level of data would be cut past the budget.
+    async ({ cve_id, full }) => kit.checked(TOOL, output, await answering(full, NO_DATA_CUT, () => epssHistory(kit, cve_id))));
 }

package/dist/tools/get_cwe.js

@@ -13,7 +13,7 @@
 // the note says it can lag the feed.
 import * as z from "zod";
 import { ANNOTATIONS, api, badInput, checked, crashed, envelopeSchema, failed, field, lenAt, numAt, okHead, opt, rowsScoreNote, strAt, succeeded, } from "../index.js";
-import { GET_CVE_WHOLE, TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
+import { answering, FULL_ARG, GET_CVE_WHOLE, TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
 const TOOL = "get_cwe";
 const CWE_ARG = /^(?:CWE-)?0*(\d{1,6})$/i;
 const MAX_PAGE = 200;
@@ -27,6 +27,10 @@ const GET_CWE_TEXT = {
     levels: [{ keep: ["cve_id", "severity", "cvss_v3_score", "echelongraph_score", "echelongraph_severity", "score_assessed", "score_unassessed_reason", "kev_listed", "published", "description"], clip: 120 }],
     whole: `${GET_CVE_WHOLE}.`,
 };
+// #3013: the structured result's cut. CWE-79's page of 50 is 24,276 characters of structured result,
+// within the budget; rows a few times longer leave data from the end. A page is always 50 rows, so
+// full: true is the only way to read the rest of one.
+const GET_CWE_DATA = { steps: [{ lists: ["cves"] }] };
 function schemas() {
     const row = z.looseObject({
         cve_id: opt(z.string()),
@@ -150,8 +154,9 @@ export function registerGetCwe(server) {
         inputSchema: z.object({
             cwe_id: z.string().describe("a CWE ID, e.g. CWE-79 (or 79)"),
             page: z.number().int().min(1).max(MAX_PAGE).optional().describe(`page of 50 CVEs (default 1, max ${MAX_PAGE})`),
+            full: FULL_ARG,
         }),
         outputSchema: output,
         annotations: ANNOTATIONS,
-    }, async ({ cwe_id, page }) => checked(TOOL, output, await getCwe(cwe_id, page)));
+    }, async ({ cwe_id, page, full }) => checked(TOOL, output, await answering(full, GET_CWE_DATA, () => getCwe(cwe_id, page))));
 }

package/dist/tools/kev_recent.js

@@ -1,5 +1,5 @@
 import * as z from "zod";
-import { GET_CVE_WHOLE, TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
+import { answering, FULL_ARG, GET_CVE_WHOLE, TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
 const TOOL = "kev_recent";
 const PATH = "/api/v1/public/kev/recent";
 export const KEV_RECENT_MAX_LIMIT = 200;
@@ -145,6 +145,21 @@ function kevText(a) {
         page: (shown) => `next_cursor continues after the last row of this page, not after the last row in this text: to read the rows left out in the text, call kev_recent again with the same filters${a.cursor?.trim() ? " and cursor" : ""} and a limit of ${shown}, whose rows are the ones in this text, then with that page's next_cursor and a limit of ${shown} or fewer.`,
     };
 }
+// #3013: the structured result's cut. A production row is about 400 characters of compact JSON, so
+// the default page of 50 fits (23,234 characters of structured result) and the largest, 200, was
+// 84,380: rows leave data from the end, and, as for the text, the note says how to read them
+// without skipping one, since next_cursor continues after the page, not after data's last row.
+function kevData(a) {
+    return {
+        steps: [{ lists: ["kev"] }],
+        page: (t) => {
+            const k = t.kev?.returned;
+            if (!k)
+                return "";
+            return `next_cursor continues after the last row of this page, not after the last row in data: to read the rows data leaves out, call kev_recent again with the same filters${a.cursor?.trim() ? " and cursor" : ""} and a limit of ${k}, whose rows are the ones in data, then with that page's next_cursor and a limit of ${k} or fewer.`;
+        },
+    };
+}
 async function kevRecent(d, a) {
     try {
         const h = headersFor(a);
@@ -221,8 +236,9 @@ export function registerKevRecent(server, d) {
             vendor: z.string().optional().describe("CISA vendorProject, an exact case-insensitive match, e.g. 'Microsoft'"),
             limit: z.number().int().min(1).max(KEV_RECENT_MAX_LIMIT).optional().describe("page size (default 50, max 200)"),
             cursor: z.string().optional().describe("next_cursor from the previous page"),
+            full: FULL_ARG,
         }),
         outputSchema: output,
         annotations: d.annotations,
-    }, async (a) => d.checked(TOOL, output, await kevRecent(d, a)));
+    }, async (a) => d.checked(TOOL, output, await answering(a.full, kevData(a), () => kevRecent(d, a))));
 }

package/dist/tools/match_batch.js

@@ -256,8 +256,11 @@ export async function sendBatches(deps, tool, purls) {
 // sent are always the input's distinct purls from position sent + 1 on
 // (purls.slice(answers.length * MAX_COMPONENTS)), which it can rebuild from its own input, given
 // the order they are counted in (`readOrder`), which the sentence says whenever it gives the
-// position, not only when the text cuts the list. `retry` is the tool and argument to send them
-// to ("check_sbom again with purls set to").
+// position, not only when the text cuts the list. #3013: the structured result's cut empties
+// data.not_sent_purls before any row leaves (it is rebuilt from the position), and gives it back
+// only the first entries the room the rows leave holds, so the sentence says it lists them whole
+// with full: true. `retry` is the tool and argument to send them to ("check_sbom
+// again with purls set to").
 export function sendingSentences(g, distinct, readOrder, retry) {
     const out = [];
     if (g.batches > 1) {
@@ -270,7 +273,7 @@ export function sendingSentences(g, distinct, readOrder, retry) {
     if (notSent > 0) {
         const one = notSent === 1;
         const where = one ? `it is the input's distinct purl at position ${g.sent + 1}` : `they are the input's distinct purls from position ${g.sent + 1} on`;
-        out.push(`${plural(notSent, "purl was", "purls were")} NOT sent (not_sent_reason ${g.not_sent_reason}: ${g.not_sent_detail}), so ${one ? "it is" : "they are"} not checked and not clean; ${where}, ${readOrder}, and data.not_sent_purls lists ${one ? "it" : "them"}: call ${retry} ${one ? "it" : "them"}${g.not_sent_reason === "request_failed" ? "" : " after a minute"}.`);
+        out.push(`${plural(notSent, "purl was", "purls were")} NOT sent (not_sent_reason ${g.not_sent_reason}: ${g.not_sent_detail}), so ${one ? "it is" : "they are"} not checked and not clean; ${where}, ${readOrder}, and data.not_sent_purls lists ${one ? "it" : "them"} whole with full: true (past the structured result's budget, that list can be cut by default): call ${retry} ${one ? "it" : "them"}${g.not_sent_reason === "request_failed" ? "" : " after a minute"}.`);
     }
     return out;
 }
@@ -312,7 +315,7 @@ export function verdictSentences(d, g) {
             out.push(`Affected: ${named.join("; ")}${hits.length > NOTE_AFFECTED_MAX ? `; and ${hits.length - NOTE_AFFECTED_MAX} more affected components in data.results` : ""}.`);
             // Said only when the answer carries fixed_in (an API before #2834 sends none).
             if (hits.some((r) => (Array.isArray(field(r, "matches")) ? field(r, "matches") : []).some((m) => isObj(m) && "fixed_in" in m))) {
-                out.push("Each match's fixed_in is the fixed bound of the advisory interval that holds the component's version; null, with fixed_in_reason, where the advisory records no fix for that version.");
+                out.push("Each match's fixed_in is the first version above the component's that no affected interval of the advisory holds; null, with fixed_in_reason, where the advisory records no fix for that version.");
             }
         }
         // #2836: rows matched by the source package their purl's upstream qualifier names.
@@ -364,10 +367,11 @@ export const Row = z.looseObject({
         cve_id: opt(z.string()),
         kev_listed: opt(z.boolean()).describe("Whether the CVE is in CISA's Known Exploited Vulnerabilities catalog, as EchelonGraph's record holds it."),
         epss_score: opt(z.number()).describe("The CVE's EPSS score (FIRST), as EchelonGraph's record holds it; null when it has none."),
-        match_reason: opt(z.string()).describe("Why the advisory applies, with the advisory interval the version falls inside: \"[A, B)\" names the fixed version B, \"[A, B]\" the last affected version B. On an upstream row it ends by naming the source package and the purl name."),
+        match_reason: opt(z.string()).describe("Why the advisory applies, with the advisory interval the version falls inside: \"[A, B)\" names that interval's fixed bound B (another interval of the advisory can still hold B; fixed_in is the version past them all), \"[A, B]\" the last affected version B. On an upstream row it ends by naming the source package and the purl name."),
         interval: opt(z.looseObject({ introduced: opt(z.string()), fixed: opt(z.string()), last_affected: opt(z.string()) })).describe("The advisory interval that holds this component's version (fixed is exclusive, last_affected inclusive); absent when no interval holds it."),
-        fixed_in: opt(z.string()).describe("The fixed bound of the advisory interval that holds this component's version, always above it. null when that interval records no fix (it ends at last_affected, or has no end) or no interval holds the version, with fixed_in_reason saying which."),
+        fixed_in: opt(z.string()).describe("The lowest version above this component's that no affected interval of the CVE's record for the package holds, always above it: the fixed bound of the interval that holds the component's version, moved past any overlapping interval that still holds that bound (fixed_in_detail then names it). null when no such version is on record (an interval on the way records no fix: it ends at last_affected, or has no end) or no interval holds the version, with fixed_in_reason saying which."),
         fixed_in_reason: opt(z.string()).describe("Why fixed_in is null; absent when fixed_in is a version."),
+        fixed_in_detail: opt(z.string()).describe("Set when fixed_in is not the fixed bound of the interval that holds the component's version: the overlapping intervals of the same record it moved past, which still hold that bound."),
     }))),
     count: opt(z.number()),
     advisories_considered: opt(z.number()),

package/dist/tools/scan_manifest.js

@@ -1,6 +1,6 @@
 import * as z from "zod";
-import { TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
-import { sbomText } from "./check_sbom.js";
+import { answering, FULL_ARG, TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
+import { sbomData, sbomText } from "./check_sbom.js";
 import { FORMAT_NAMES, FORMATS, NOT_CHECKED_REASONS, detect, readFile } from "./manifests/index.js";
 import { CLEAN_NOTE, DISTRO_NOTE, FRESHNESS_NOTE, MAX_PURLS, MEASURED_AT_NOTE, METHOD, batchDataShape, dedupe, field, plural, purlsRefusal, sendBatches, sendingCoverage, sendingCoverageShape, sendingSentences, verdictSentences, } from "./match_batch.js";
 export const SCAN_MANIFEST = "scan_manifest";
@@ -37,6 +37,9 @@ export function manifestText(sent) {
         page: (shown) => `To read every row in the text, pass files that hold ${shown} or fewer distinct purls per call.`,
     };
 }
+// #3013: the structured result's cut, check_sbom's (sbomData: the lists beside the rows, then every
+// row thinned, then rows leaving, clean ones first) with not_checked beside not_sent_purls.
+const MANIFEST_DATA = sbomData(["not_sent_purls", "not_checked"], (k) => `To read every row in data, pass files that hold ${k} or fewer distinct purls per call.`);
 export function readFiles(a) {
     if (!Array.isArray(a.files))
         return "files must be a list of {filename, content}";
@@ -79,8 +82,13 @@ export function readFiles(a) {
         out.skipped = r.skipped;
         out.notes = r.notes;
         out.replaced = r.replaced ?? [];
-        all.push(...r.pinned.map((x) => x.purl));
-        notChecked.push(...r.not_checked.map((x) => ({ file: f.filename, ...x })));
+        // One by one, never push(...list): a 5,000,000-character requirements.txt of unpinned lines
+        // is some 170,000 entries, and, spread into push() as that many arguments, they overflowed
+        // V8's stack ("Maximum call stack size exceeded", #3013's review): the call crashed.
+        for (const p of r.pinned)
+            all.push(p.purl);
+        for (const n of r.not_checked)
+            notChecked.push({ file: f.filename, ...n });
     }
     if (files.every((f) => !f.read))
         return `no file could be read: ${files.map((f) => `${f.filename}: ${f.refused}`).join("; ")}`;
@@ -112,7 +120,11 @@ function noteFor(head, x, d, g) {
     const nc = x.not_checked.length;
     if (nc) {
         const parts = NOT_CHECKED_REASONS.filter((r) => by[r] > 0).map((r) => `${r} ${by[r]}`);
-        out.push(`${plural(nc, "entry was", "entries were")} NOT checked and ${nc === 1 ? "is" : "are"} not clean (${parts.join(", ")}): data.not_checked lists each with its file, line and reason, and none was sent to the API.`);
+        // #3013's review: the note is written before the structured result is cut, and a DATA CUT can
+        // cut data.not_checked (it goes before any row), so this says the list is whole with full:
+        // true, as the sentence on data.not_sent_purls does (match_batch.ts sendingSentences); the
+        // counts above are coverage.not_checked_by_reason's, which no cut touches.
+        out.push(`${plural(nc, "entry was", "entries were")} NOT checked and ${nc === 1 ? "is" : "are"} not clean (${parts.join(", ")}): data.not_checked lists each with its file, line and reason, whole with full: true (past the structured result's budget, that list can be cut by default), and none was sent to the API.`);
     }
     out.push(...sendingSentences(g, x.purls.length, READ_ORDER, "check_sbom with purls set to"));
     if (d === null)
@@ -247,11 +259,12 @@ export function registerScanManifest(server, deps) {
                 format: formatEnum.optional().describe("the format to read the file as, when its name does not say"),
             }))
                 .describe("1 to 20 files, up to 5,000,000 characters of content in all; read by this MCP server into purls, and only the purls are sent to the API; over the hosted endpoint (mcp.echelongraph.io) the files are the request body"),
+            full: FULL_ARG,
         }),
         outputSchema: output,
         annotations: deps.annotations,
-    }, async (a, ctx) => {
+    }, async (a, ctx) => answering(a.full, MANIFEST_DATA, async () => {
         const run = scanManifest({ ...deps, signal: ctx.mcpReq.signal }, a);
         return deps.checked(SCAN_MANIFEST, output, await (deps.hold ? deps.hold(run) : run));
-    });
+    }));
 }