osv-scanner-mcp 0.12.0 → 0.13.0

package/README.md

@@ -7,19 +7,19 @@
 
 An MCP server that wraps Google's [OSV-Scanner](https://github.com/google/osv-scanner). Ask an MCP client such as Claude to "check this project for vulnerabilities", and it returns the known vulnerabilities (CVE / GHSA) in your dependencies as a report sorted by severity, together with recommended upgrades.
 
-> **Status**: [Published on npm](https://www.npmjs.com/package/osv-scanner-mcp) (`npx -y osv-scanner-mcp`). Supports lockfiles and manifests for Java (Maven / Gradle), JavaScript (npm / yarn / pnpm / bun), Python (Poetry / uv / Pipenv / PDM / requirements.txt), Go, and Rust (`Cargo.lock`), with upgrade recommendations for all but Rust (planned). Setup instructions are provided for Claude Code, Claude Desktop, Codex CLI, Antigravity, and VS Code (GitHub Copilot).
+> **Status**: [Published on npm](https://www.npmjs.com/package/osv-scanner-mcp) (`npx -y osv-scanner-mcp`). Supports lockfiles and manifests for Java (Maven / Gradle), JavaScript (npm / yarn / pnpm / bun), Python (Poetry / uv / Pipenv / PDM / requirements.txt), Go, and Rust (`Cargo.lock`), with upgrade recommendations for Maven, npm, PyPI, Go, and crates.io. Setup instructions are provided for Claude Code, Claude Desktop, Codex CLI, Antigravity, and VS Code (GitHub Copilot).
 
 ## Features
 
 - **One-shot multi-language scan**: Pass a project path to `scan_project`, and it detects and scans the Java, JavaScript, Python, Go, and Rust lockfiles in the project together. Dependencies that could not be scanned (for example, a manifest without a lockfile or an unpinned requirement) are reported up front in `coverage`
-- **Upgrade recommendations**: `suggest_fix` recommends, for each vulnerable package, the upgrade closest to the current release line that fixes all its known vulnerabilities, for Maven, npm, PyPI, and Go. The recommended version is also checked against the OSV database so that it does not introduce other known vulnerabilities
+- **Upgrade recommendations**: `suggest_fix` recommends, for each vulnerable package, the upgrade closest to the current release line that addresses its fix targets, for Maven, npm, PyPI, Go, and Rust (crates.io). Known unfixed and informational advisories remain visible. The recommended version is also checked against the OSV database for additional fix-target vulnerabilities
 - **Rust without false positives**: For `Cargo.lock`, only crates from crates.io are scanned. Your own workspace crates, git dependencies, and crates from private registries are not looked up as crates.io crates (OSV-Scanner alone would match them by name, and send their names to the OSV API). RustSec notices about unmaintained or unsound crates are labeled `informational` and counted apart from vulnerabilities
 - **Direct and transitive dependencies**: Packages are marked as direct or transitive dependencies (from `package-lock.json`, `go.mod`, `requirements.txt`, and `pom.xml`), and update hints are tailored accordingly, for example by naming the direct dependency that pulls in a transitive one
 - **Java project scan**: `scan_java_project` scans only the Java (Maven / Gradle) manifests and returns a formatted report
 - **JAR/WAR scan**: `scan_java_artifact` detects known vulnerabilities from the metadata inside JAR/WAR archives, for projects without a lockfile or with only shaded/fat JARs (best-effort identification, stated explicitly in `coverage`)
 - **SBOM scan**: `scan_sbom` checks the dependencies recorded in a CycloneDX/SPDX JSON SBOM. It states explicitly that the SBOM's completeness and its match with the actual artifacts are not verified
 - **Severity-sorted reports**: Vulnerabilities are grouped by package and sorted by CVSS score, with five severity labels (critical / high / medium / low / unknown) and summary counts
-- **Fixed versions**: Each vulnerability includes `fixed_versions`, sorted correctly by Maven version precedence (including non-semver forms such as `2.17.1-RELEASE`), Semantic Versioning precedence for npm and Go, and PEP 440 for PyPI
+- **Fixed versions**: Each vulnerability includes `fixed_versions`, sorted correctly by Maven version precedence (including non-semver forms such as `2.17.1-RELEASE`), Semantic Versioning precedence for npm, Go, and Rust, and PEP 440 for PyPI
 - **Security first**: No shell execution, a fixed argument allowlist, path normalization and boundary checks, scanning private copies instead of the original files, and timeouts and output size limits are built in
 
 ## Requirements
@@ -262,14 +262,15 @@ Detects the lockfiles and manifests in a project and scans the Java / JavaScript
   - Each list holds up to 200 entries; the number of omitted entries is returned in `omitted_items`
 - `ecosystem_breakdown` includes ecosystems with zero findings, to show that they were scanned
 - **Informational advisories (Rust)**: RustSec also publishes notices that are not vulnerabilities: `unmaintained` (the crate is no longer maintained), `unsound` (a soundness bug), and `notice`. Most have no fixed version. When every advisory in a group is such a notice (every related ID, including aliases, must have its details available and be a notice of a known kind; otherwise it is treated as a vulnerability), the vulnerability has `informational` set to its kind, is listed after the vulnerabilities of the package, and is counted in `informational_count` (and in `ecosystem_breakdown`) instead of `vulnerability_count`, `severity_breakdown`, and `vulnerable_package_count`. If another database (such as GitHub's) lists the same issue as a vulnerability, it stays a vulnerability. `informational_count` appears only when there is at least one
-- `dependency_relation` shows whether a package is a direct (`direct`) or transitive (`transitive`) dependency. OSV-Scanner does not report this, so the server determines it by parsing the scanned copies:
+- `dependency_relation` shows whether a package is a direct (`direct`) or transitive (`transitive`) dependency. OSV-Scanner does not report this, so the server determines it from validated manifest data and scanned copies:
   - `package-lock.json` (v2 or later): dependencies of the root and workspace `package.json` files, resolved with Node's lookup rules (nested `node_modules` first, then parent directories), are direct; everything reachable from them is transitive. Direct dependencies list the `package.json` files that declare them in `declared_in`; transitive dependencies list the direct dependencies that require them in `introduced_by` (up to 10, with the rest counted in `introduced_by_omitted`). A version that is both a direct dependency and required by another dependency is `direct` and also has `introduced_by`
   - `go.mod`: `require` lines without `// indirect` are direct. Modules affected by a `replace` directive are marked `replaced_in_go_mod: true` (OSV-Scanner reports the replacement module and version)
   - `requirements.txt`: dependencies written in the file are direct; dependencies resolved through deps.dev are transitive
   - `pom.xml`: OSV-Scanner reports the dependencies declared in `pom.xml` (and its parent POMs) and the transitive dependencies resolved through deps.dev as separate results (`source.type` `lockfile` / `unknown`), and this split is used (so parent POMs, profiles, properties, and dependency management are interpreted exactly as OSV-Scanner does). `introduced_by` / `declared_in` are not available. This relies on undocumented OSV-Scanner output, so anything unexpected is reported as `unknown`
-  - Other formats (`gradle.lockfile`, `yarn.lock`, `pnpm-lock.yaml`, `bun.lock`, `poetry.lock`, `uv.lock`, `Pipfile.lock`, `pdm.lock`, and `Cargo.lock` for now), lockfile version 1, and entries not reachable from the project are `unknown`. If lockfiles disagree, the value is `mixed`
+  - `Cargo.lock`: crates.io dependencies immediately required by a local/workspace/path crate are direct; crates.io dependencies reachable through them (including git and alternate-registry origins) are transitive. `introduced_by` names the first direct dependency on each path. References are resolved by exact name, version, and source where provided; ambiguous references are not guessed. Replacements are followed. `declared_in` lists project-relative Cargo.toml paths only when every declaring crate has a unique matching manifest. Otherwise `declaring_crates` names the unmapped declaring crates (up to 10, with the rest in `declaring_crates_omitted`). Dev/build/target-specific distinctions are unavailable. Traversal over 2,000,000 edges returns `unknown`
+  - Other formats (`gradle.lockfile`, `yarn.lock`, `pnpm-lock.yaml`, `bun.lock`, `poetry.lock`, `uv.lock`, `Pipfile.lock`, and `pdm.lock`), npm lockfile version 1, and entries not reachable from the project are `unknown`. If lockfiles disagree, the value is `mixed`
 - `dependency_groups` is the raw dependency group reported by OSV-Scanner (for example `dev`). It is missing or inaccurate for some lockfile formats (absent for pnpm, `optional` for pdm, and so on), so treat it as informational
-- Upgrade recommendations (`suggest_fix`) are available for Java, JavaScript, Python, and Go. Rust packages are returned with `verification: "unsupported_ecosystem"` for now
+- Upgrade recommendations (`suggest_fix`) are available for Maven, npm, PyPI, Go, and Rust (crates.io)
 
 ### `scan_java_project`
 
@@ -334,7 +335,7 @@ If an existing parent POM cannot be read (larger than 10 MiB, not a regular file
 ```
 
 - `packages` is sorted by the most severe vulnerability, and each `vulnerabilities` list by severity (unknown last)
-- `fixed_versions` lists the fixed versions recorded in OSV, in ascending order: by Maven precedence for Maven, Semantic Versioning precedence for npm and Go (values that are not valid SemVer come last), and PEP 440 for PyPI (in the order listed by OSV up to v0.5.0); other ecosystems keep the order listed by OSV (the order is not guaranteed). Several release lines may be mixed (for example a 2.12 backport and the 2.15 line). Pre-releases (`5.0.0-beta.3`) and Go pseudo-versions (`0.0.0-20180925071336-cf3bd585ca2a`) may be included. An empty array means that OSV lists no fixed version. Up to v0.4.1, this was always empty for packages outside Maven
+- `fixed_versions` lists the fixed versions recorded in OSV, in ascending order: by Maven precedence for Maven, Semantic Versioning precedence for npm, Go, and Rust (values that are not valid SemVer come last), and PEP 440 for PyPI (in the order listed by OSV up to v0.5.0); other ecosystems keep the order listed by OSV (the order is not guaranteed). Several release lines may be mixed (for example a 2.12 backport and the 2.15 line). Pre-releases (`5.0.0-beta.3`) and Go pseudo-versions (`0.0.0-20180925071336-cf3bd585ca2a`) may be included. An empty array means that OSV lists no fixed version. Up to v0.4.1, this was always empty for packages outside Maven
 - Vulnerabilities without a severity score are reported as `null` / `"unknown"`
 
 ### `scan_java_artifact`
@@ -391,7 +392,7 @@ Invalid JSON returns `invalid_sbom`, an unsupported format `unsupported_sbom_for
 
 ### `suggest_fix`
 
-Runs the same detection and scan as `scan_project` and recommends an **upgrade version** for each vulnerable package. Recommendations are available for Java (Maven / Gradle), JavaScript (npm), Python (PyPI), and Go. Instead of simply taking the highest fixed version, it picks the fixed version closest to the current release line, falling back through three tiers:
+Runs the same detection and scan as `scan_project` and recommends an **upgrade version** for each vulnerable package. Recommendations are available for Java (Maven / Gradle), JavaScript (npm), Python (PyPI), Go, and Rust (crates.io). Instead of simply taking the highest fixed version, it picks the fixed version closest to the current release line, falling back through three tiers:
 
 | Tier | Meaning |
 |---|---|
@@ -399,7 +400,7 @@ Runs the same detection and scan as `scan_project` and recommends an **upgrade v
 | `major_internal` | A fixed version within the same major version (a minor upgrade) |
 | `cross_major` | A major upgrade is needed (may include breaking changes) |
 
-For npm, Go, and PyPI, the "same release line" is the range npm's caret (`^`) treats as compatible (PyPI has no common compatibility rule, but some 0.x packages make breaking changes in minor releases, so the same rule is used; a change of epoch is also `cross_major`). From 1.0.0 the line is major.minor, as for Maven. For 0.x, only the same `0.minor` is the same line, so a minor update (`0.3` → `0.4`) is `cross_major`, and for 0.0.x every update is `cross_major` (SemVer does not guarantee compatibility for 0.x updates).
+For npm, Go, PyPI, and Rust, the "same release line" is the range a caret (`^`) treats as compatible (PyPI has no common compatibility rule, but some 0.x packages make breaking changes in minor releases, so the same rule is used; a change of epoch is also `cross_major`). From 1.0.0 the line is major.minor, as for Maven. For 0.x, only the same `0.minor` is the same line, so a minor update (`0.3` → `0.4`) is `cross_major`, and for 0.0.x every update is `cross_major` (SemVer does not guarantee compatibility for 0.x updates).
 
 **Input**: the same as `scan_project` (`project_path`)
 
@@ -438,14 +439,16 @@ For npm, Go, and PyPI, the "same release line" is the range npm's caret (`^`) tr
 - Pre-releases (`5.0.0-beta.3`, `15.6.0-canary.61`, Go pseudo-versions, PyPI `rc` and `dev` versions; post-releases count as stable) are recommended only when no stable candidate fixes every vulnerability, and are marked `recommended_is_prerelease: true`. A stable version in a higher tier is preferred over a pre-release in a lower tier.
 - When a version is recommended, `verification` is `verified`, and each CVE's `recommended_status` is `affected` / `not_affected` / `unknown` (`not_evaluated` when the recommendation is withheld). `per_cve_detail.fixed_in` is the candidate for that CVE alone; see `recommended_status` for the final recommendation.
 - CVEs with no fixed version newer than the current one get `tier: "unfixed"` and are left out of the recommendation (the data may be incomplete). They are still evaluated against the recommended version, and the result is shown. If every CVE is unfixed, `recommended_upgrade` is `null` as well. A CVE whose fixed version is listed but cannot be parsed as a version (such as `13.0`, which is not SemVer) gets `tier: "unparseable_fix"`; it is not treated as unfixed but stays in the set to be fixed, so the recommendation is withheld (`no_verified_candidate`).
+- Rust uses SemVer (`SEMVER` ranges) and Cargo caret compatibility: 0.x minor updates and 0.0.x patch updates are `cross_major`. `unmaintained` and `notice` advisories, and `unsound` advisories without a newer fixed version, remain in `per_cve_detail` with `tier: "informational"`, their kind, and `recommended_status`, but are not fix targets or counted as unfixed. An `unsound` advisory with a newer fixed version is a version-specific defect, so it is a fix target like a vulnerability (its tier is computed normally and it keeps `informational: "unsound"`). Packages with no fix target left return `verification: "informational_only"` without an upgrade. Unmaintained crates may need replacement; use `explain_vulnerability` for notices.
 - Suggestions include an `update_hint`, tailored to whether the package is a direct or transitive dependency:
   - Maven (from `pom.xml`): for a direct dependency, update the `<dependency>` version (or the parent POM, property, or BOM that manages it); for a transitive dependency, override the version in `<dependencyManagement>` or update the direct dependency that requires it
   - npm: for a direct dependency, update the version in the `package.json` listed in `declared_in`; for a transitive dependency, update the direct dependency named in `introduced_by`, or set the version with `overrides` in the root `package.json` (effective only in the root project)
   - Go: `go get <module>@<version>` (also for `// indirect` modules). For a module affected by `replace`, update the version in the `replace` directive instead of `require`. Major versions 2 and later use a different module path (`/v2` and so on) and are separate packages in OSV, so fixes in a newer major line are not included as candidates. If the current version is a pseudo-version (an untagged commit), `upgrade_note` says so
   - PyPI: update the version in `requirements.txt`, `pyproject.toml`, or `Pipfile` and regenerate the lockfile; for a transitive dependency, use a pip constraints file (`-c`) or the override settings of uv or Poetry
+  - Rust: where version requirements permit it, `cargo update -p <crate>@<current> --precise <recommended>` updates the lockfile. Otherwise change the direct requirement in the declaring Cargo.toml or update the parent dependency in `introduced_by`. Cross-major upgrades may break compatibility, including 0.x updates. Pre-releases may require explicit `=<version>` requirements and must be allowed by transitive parents. Build metadata is omitted from `--precise`. `[patch.crates-io]` changes a source, not the allowed version range; backports must satisfy parent requirements. Check yanked versions, MSRV, and compiler compatibility. Cargo is never executed by the server
   - When the relation is `unknown` or `mixed`, both cases are described (no hint is given for Maven packages from `gradle.lockfile`)
 - **Checking recommended versions against OSV**: Recommendations are verified only against the vulnerabilities found in the scan (those affecting the current version), so a recommended version could be affected by newer vulnerabilities (for example, cryptography 3.2's candidate 49.0.0 is affected by two vulnerabilities introduced in 44.0.0 and fixed in 50.0.0). The server therefore queries `api.osv.dev` about the recommended version, and if it is affected, adds those vulnerabilities to the set to be fixed and chooses again with their fixed versions as candidates (50.0.0 in this example, with the reason in `upgrade_note`). The result is reported in `candidate_check`:
-  - `clean`: OSV reports no known vulnerabilities for the recommended version
+  - `clean`: OSV reports no additional fix-target vulnerabilities after excluding known `unfixed` advisories, known informational advisories that are not fix targets, and new Rust `unmaintained` / `notice` records. These advisories may still apply; check `per_cve_detail[].recommended_status`. Newly discovered `unsound` records are added as fix targets
   - `has_known_vulnerabilities`: no candidate avoids them, so the recommended version has known vulnerabilities (IDs in `recommended_known_vulnerabilities`)
   - `conflict`: OSV reports that a candidate is affected by a vulnerability the scan had evaluated as not affecting it (the range data disagree), and no other candidate is available, so the recommendation is withheld (`recommended_upgrade: null`, `verification: "no_verified_candidate"`)
   - `failed`: the query failed or returned a malformed response (the recommendation, verified against the scanned vulnerabilities, is still returned)
@@ -557,7 +560,7 @@ Design notes and open items are in [docs/DESIGN_TODO.md](docs/DESIGN_TODO.md) (i
 - [x] Running under Node's permission model
 - [x] English tool descriptions and messages
 - [x] `scan_project` for Rust (`Cargo.lock`, crates.io crates only) and RustSec informational advisories
-- [ ] `suggest_fix` and direct/transitive dependencies for Rust
+- [x] `suggest_fix` and direct/transitive dependencies for Rust
 - [ ] Direct and transitive dependencies for `gradle.lockfile` and the YAML/TOML lockfiles
 
 ## License

package/dist/index.js

@@ -61,7 +61,7 @@ if (startupWarning !== null) {
 // NOTE: リリース時はpackage.jsonのversionと同じ値に更新すること
 const server = new McpServer({
     name: "osv-scanner-mcp",
-    version: "0.12.0",
+    version: "0.13.0",
 });
 server.registerTool("scan_project", {
     title: "Scan project dependencies for vulnerabilities (Java / JavaScript / Python / Go / Rust)",
@@ -73,7 +73,7 @@ server.registerTool("scan_project", {
         "For Cargo.lock, only crates from crates.io are scanned: the project's own crates are counted in local_crates, and git or private-registry crates are listed in unscannable_crates. " +
         "Vulnerabilities marked informational (RustSec notices such as unmaintained or unsound crates) are not counted in vulnerability_count; they are counted in informational_count. " +
         "Each package's dependency_relation tells whether it is a direct or transitive dependency (determined for package-lock.json, go.mod, requirements.txt, and pom.xml; unknown otherwise). " +
-        "If coverage.complete is false, do not conclude that the project is safe even with zero findings. Upgrade recommendations (suggest_fix) are available for Java, JavaScript, Python, and Go (not yet for Rust).",
+        "If coverage.complete is false, do not conclude that the project is safe even with zero findings. Upgrade recommendations (suggest_fix) are available for Java, JavaScript, Python, Go, and Rust. Cargo.lock dependency graphs provide direct/transitive relations, introduced_by, and uniquely mapped declaring Cargo.toml paths in declared_in.",
     inputSchema: {
         project_path: z
             .string()
@@ -97,16 +97,18 @@ server.registerTool("scan_java_project", {
 server.registerTool("suggest_fix", {
     title: "Recommend upgrades that fix vulnerabilities",
     description: "Scans the project with the same detection as scan_project and recommends an upgrade version for each vulnerable package. " +
-        "Recommendations are available for Java (Maven / Gradle), JavaScript (npm), Python (PyPI), and Go. " +
+        "Recommendations are available for Java (Maven / Gradle), JavaScript (npm), Python (PyPI), Go, and Rust (crates.io). " +
         "The fixed version closest to the current release line is chosen with a three-tier fallback " +
         "(same_minor: same release line -> major_internal: same major version -> cross_major: major upgrade), " +
-        "and the response gives the recommended version, the upgrade distance (upgrade_tier), and the fixed version per CVE. For npm, Go, and PyPI, a minor update within 0.x is also cross_major (may include breaking changes). " +
+        "and the response gives the recommended version, the upgrade distance (upgrade_tier), and the fixed version per CVE. For npm, Go, PyPI, and Rust, a minor update within 0.x is also cross_major (may include breaking changes). " +
         "Dependencies scanned at a requirements.txt lower bound (>=) are marked version_is_lower_bound, and the recommendation then means raising the lower bound. " +
-        "update_hint explains how to upgrade, depending on whether the package is a direct or transitive dependency (dependency_relation; for npm also introduced_by and declared_in). " +
-        "The recommended version is checked against api.osv.dev, and versions with known vulnerabilities that do not affect the current version are avoided (result in candidate_check; " +
-        "with has_known_vulnerabilities, failed, or skipped, the recommended version has not been confirmed safe; conflict means the data disagreed and the recommendation is withheld). " +
+        "update_hint explains how to upgrade, depending on whether the package is a direct or transitive dependency (dependency_relation; for npm and Cargo.lock also introduced_by and declared_in). Cargo updates are conditional on parent version requirements; cross-major updates may require Cargo.toml changes. " +
+        "The recommended version is checked against api.osv.dev, and versions with known vulnerabilities that do not affect the current version are avoided (result in candidate_check). " +
+        "clean excludes known unfixed advisories, known informational advisories that are not fix targets, and new Rust unmaintained/notice records; these may still apply. New unsound records are fix targets. " +
+        "With has_known_vulnerabilities, failed, or skipped, the recommended version has not been confirmed safe; conflict means the data disagreed and the recommendation is withheld. " +
         "Candidates are checked against the affected ranges of every vulnerability to fix, and the recommendation is withheld when the data are insufficient. Pre-releases are recommended only when no stable version fixes everything, and are marked recommended_is_prerelease. " +
         "CVEs with no fixed version newer than the current one are reported separately as unfixed, together with their status at the recommended version. " +
+        "Rust unmaintained/notice advisories and unsound advisories without a newer fixed version have tier informational and are not fix targets; unsound advisories with a fixed version are fixed like vulnerabilities. Packages with no fix target left have verification informational_only and no recommendation. " +
         "Always check coverage in the response (if complete is false, some dependencies are not included in the suggestions). " +
         "If dependency_resolution.warning is present, vulnerabilities in transitive dependencies are not included.",
     inputSchema: {

package/dist/osv/candidateCheck.js

@@ -15,7 +15,7 @@ import { asString, asStrings } from "../utils/unknownJson.js";
 import { sanitizeExternalText } from "../utils/externalText.js";
 import { extractAffectedVersions } from "./affectedVersions.js";
 import { queryOsvPackageVersion } from "./osvApi.js";
-import { extractFixedVersions } from "./scanReport.js";
+import { extractFixedVersions, recordInformationalKind } from "./scanReport.js";
 import { suggestUpgradeForPackage } from "./suggestFix.js";
 export const NO_CANDIDATE_CHECK_ENV = "OSV_MCP_NO_CANDIDATE_CHECK";
 /** 環境変数で無効化されているか(1/true/yes) */
@@ -43,6 +43,14 @@ class QueryBudget {
 }
 async function checkPackage(pkg, initial, budget, options) {
     const known = new Set(pkg.vulnerabilities.flatMap((v) => [v.id, ...v.aliases]));
+    const unfixed = new Set(initial.per_cve_detail.filter((v) => v.tier === "unfixed" || v.tier === "informational").map((v) => v.id));
+    const ignoredKnown = new Set(pkg.vulnerabilities.filter((v) => unfixed.has(v.id)).flatMap((v) => [v.id, ...v.aliases]));
+    // 別名が修正対象とも重なる場合は、その対象の判定を優先する。
+    for (const vuln of pkg.vulnerabilities) {
+        if (!unfixed.has(vuln.id))
+            for (const id of [vuln.id, ...vuln.aliases])
+                ignoredKnown.delete(id);
+    }
     const extraTargets = [];
     const excluded = new Set();
     const rejected = [];
@@ -62,9 +70,18 @@ async function checkPackage(pkg, initial, budget, options) {
                 return { suggestion, status: "failed", rejected };
             throw error;
         }
+        // 修正版なしの既知の脆弱性は修正対象ではなく、推奨先でもaffectedであることと矛盾しない。
+        // 新しく照会で見つかった対象はknownへ追加されるが、ignoredKnownには入れない。
+        records = records.filter((record) => {
+            const matched = recordIds(record).filter((id) => known.has(id));
+            if (matched.length > 0)
+                return matched.some((id) => !ignoredKnown.has(id));
+            const kind = pkg.ecosystem === "crates.io" ? recordInformationalKind(record, pkg.name, pkg.ecosystem) : null;
+            return kind !== "unmaintained" && kind !== "notice";
+        });
         if (records.length === 0)
             return { suggestion, status: "clean", rejected };
-        // 新しい脆弱性は修正対象に加え、修正版を候補に加える。スキャンで既に知っている脆弱性なのに該当と返った場合は、
+        // 新しい脆弱性は修正対象に加え、修正版を候補に加える。既知の修正対象の脆弱性に該当と返った場合は、
         // 手元の範囲情報とOSVの判定が食い違っているため、その候補を除外する(安全側)
         let conflict = false;
         for (const record of records) {

package/dist/osv/suggestFix.js

@@ -79,8 +79,54 @@ function updateHint(pkg) {
             return UPDATE_HINTS[pkg.ecosystem];
     }
 }
-function hintFields(pkg) {
-    const hint = updateHint(pkg);
+/** OSV由来の版・crate名を案内のコマンドに埋め込めるか(外部データのため文字の範囲を限定する) */
+const SAFE_VERSION = /^[0-9A-Za-z.+-]{1,64}$/;
+const SAFE_CRATE_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+/**
+ * crates.ioの更新方法(docs/DESIGN_TODO.md「suggest_fixのRust対応」の表)。直接/推移的依存とTierで分ける。
+ * 推奨がない場合はコマンドを示さず、方向だけを示す
+ */
+function cargoUpdateHint(pkg, recommended, tier) {
+    const manifest = pkg.declared_in?.join(", ") ?? (pkg.declaring_crates?.length
+        ? `the Cargo.toml of ${pkg.declaring_crates.join(", ")}` : "the declaring Cargo.toml");
+    const parent = pkg.introduced_by?.join(", ") ?? "the direct dependency that requires this crate";
+    if (recommended === null) {
+        const direct = `No verified upgrade is recommended (see upgrade_note and per_cve_detail). Any fix requires a version allowed by the requirement in ${manifest}.`;
+        const transitive = `No verified upgrade is recommended (see upgrade_note and per_cve_detail). Any fix must be allowed by the requirements of ${parent}.`;
+        return pkg.dependency_relation === "direct" ? `Direct dependency. ${direct}`
+            : pkg.dependency_relation === "transitive" ? `Transitive dependency. ${transitive}`
+                : `For a direct dependency: ${direct} For a transitive dependency: ${transitive}`;
+    }
+    const embeddable = SAFE_VERSION.test(recommended) && SAFE_VERSION.test(pkg.version) && SAFE_CRATE_NAME.test(pkg.name);
+    // OSVの修正版はビルドメタデータを含むことがある。cargoは`--precise`・`=`の要求でメタデータなしの版を受け付ける(cargo 1.98で確認)
+    const precise = recommended.split("+")[0];
+    const target = embeddable ? recommended : "the recommended version";
+    const command = embeddable
+        ? `cargo update -p ${pkg.name}@${pkg.version} --precise ${precise}`
+        : "cargo update with an appropriate -p package specification and --precise version";
+    const direct = tier === "cross_major"
+        ? `Change the requirement in ${manifest} to allow ${target}; this may include breaking changes (in 0.x, even a minor update).`
+        : `If the requirement in ${manifest} allows ${target} (the default caret requirement does), run ${command}; only Cargo.lock changes. ` +
+            `If the requirement pins the version (= or ~), change it in ${manifest}.`;
+    const transitive = tier === "cross_major"
+        ? `Update ${parent} to a version whose requirements permit ${target}. ` +
+            "[patch.crates-io] does not override version requirements: use it only for a fix (such as a backport) from another source that still satisfies the requirements of the crates that depend on it."
+        : `If the requirements of ${parent} allow ${target}, run ${command}; only Cargo.lock changes. If cargo reports that the requirements cannot be satisfied, update ${parent}.`;
+    let hint = pkg.dependency_relation === "direct" ? `Direct dependency. ${direct}`
+        : pkg.dependency_relation === "transitive" ? `Transitive dependency. ${transitive}`
+            : `For a direct dependency: ${direct} For a transitive dependency: ${transitive}`;
+    if (pkg.dependency_relation === "direct" && pkg.introduced_by?.length)
+        hint += ` It is also required by ${parent}, whose requirements must allow ${target} as well.`;
+    if (versionSchemeFor("crates.io").isPrerelease(recommended)) {
+        hint += ` ${target} is a pre-release: Cargo requirements match a pre-release only when they name one, so cargo update --precise alone may fail. ` +
+            (embeddable ? `For a direct dependency, set the requirement to "=${precise}"` : "For a direct dependency, set the requirement to the exact pre-release version") +
+            "; for a transitive dependency, the crate that requires it must allow it.";
+    }
+    hint += " Before updating, check that the version is not yanked and that it supports your Rust version (MSRV).";
+    return hint;
+}
+function hintFields(pkg, recommended = null, tier = null) {
+    const hint = pkg.ecosystem === "crates.io" ? cargoUpdateHint(pkg, recommended, tier) : updateHint(pkg);
     return hint === undefined ? {} : { update_hint: hint };
 }
 /** スキャン結果に付いた直接/推移的依存の項目を提案にも写す(無ければ何も出さない) */
@@ -90,6 +136,8 @@ function relationFields(pkg) {
         ...(pkg.introduced_by !== undefined ? { introduced_by: pkg.introduced_by } : {}),
         ...(pkg.introduced_by_omitted !== undefined ? { introduced_by_omitted: pkg.introduced_by_omitted } : {}),
         ...(pkg.declared_in !== undefined ? { declared_in: pkg.declared_in } : {}),
+        ...(pkg.declaring_crates !== undefined ? { declaring_crates: pkg.declaring_crates } : {}),
+        ...(pkg.declaring_crates_omitted !== undefined ? { declaring_crates_omitted: pkg.declaring_crates_omitted } : {}),
         ...(pkg.replaced_in_go_mod ? { replaced_in_go_mod: true } : {}),
     };
 }
@@ -115,7 +163,8 @@ function notEvaluatedSuggestion(pkg, verification) {
             cve: vuln.cve,
             severity: vuln.severity,
             fixed_in: null,
-            tier: "unsupported",
+            tier: vuln.informational !== undefined ? "informational" : "unsupported",
+            ...(vuln.informational !== undefined ? { informational: vuln.informational, recommended_status: "not_evaluated" } : {}),
         })),
         verification,
     };
@@ -172,6 +221,36 @@ function buildNote(scheme, pkg, recommended, tier, fixableCount, unfixedCount) {
     }
     return note;
 }
+/**
+ * 1パッケージ分のアップグレード提案を組み立てる(同期・純粋)。
+ * contextを渡すと、照会で見つかった脆弱性も避けて候補を選び直す(contextなしの結果が従来の推奨)。
+ */
+/**
+ * 修正対象にしない情報提供のアドバイザリ。unmaintained・noticeは版を上げても解消しない(版と無関係)。
+ * unsoundは版ごとの欠陥のため、現在より新しい修正版があれば通常の脆弱性と同じく修正対象にする
+ * (v0.13.0の実装中に判明: 修正版のあるunsoundを外すと、lru 0.6.0に0.7.1(RUSTSEC-2026-0253の0.18.2未満)を推奨した)
+ */
+function isExcludedInformational(vuln, scheme, current) {
+    if (vuln.informational === undefined)
+        return false;
+    if (vuln.informational !== "unsound")
+        return true;
+    return rankCandidates(scheme, current, vuln.fixed_versions).length === 0 && vuln.fixed_versions.every((v) => scheme.isValid(v));
+}
+function informationalNote(pkg, excluded) {
+    const notes = [];
+    const kinds = (pick) => new Set(pkg.vulnerabilities.filter((v, i) => v.informational !== undefined && pick(excluded[i])).map((v) => v.informational));
+    const out = kinds((e) => e);
+    if (out.has("unmaintained"))
+        notes.push("Unmaintained advisories are not resolved by upgrading; consider an alternative crate.");
+    if (out.has("unsound"))
+        notes.push("Unsound advisories without a fixed version remain; check recommended_status.");
+    if (out.has("notice"))
+        notes.push("For notices, use explain_vulnerability for details.");
+    if (kinds((e) => !e).has("unsound"))
+        notes.push("Unsound advisories with a fixed version are included in the fix.");
+    return notes.join(" ");
+}
 /**
  * 1パッケージ分のアップグレード提案を組み立てる(同期・純粋)。
  * contextを渡すと、照会で見つかった脆弱性も避けて候補を選び直す(contextなしの結果が従来の推奨)。
@@ -182,7 +261,23 @@ export function suggestUpgradeForPackage(pkg, context = {}) {
         return notEvaluatedSuggestion(pkg, "unsupported_ecosystem");
     if (!scheme.isValid(pkg.version))
         return { ...notEvaluatedSuggestion(pkg, "unparseable_version"), ...hintFields(pkg) };
-    const details = pkg.vulnerabilities.map((vuln) => {
+    const excluded = pkg.vulnerabilities.map((vuln) => isExcludedInformational(vuln, scheme, pkg.version));
+    const informationalNotes = informationalNote(pkg, excluded);
+    if (pkg.vulnerabilities.length > 0 && excluded.every((e) => e)) {
+        return {
+            package: pkg.name, current_version: pkg.version, ecosystem: pkg.ecosystem, ...relationFields(pkg),
+            recommended_upgrade: null, upgrade_tier: null, upgrade_note: informationalNotes,
+            per_cve_detail: pkg.vulnerabilities.map((v) => ({ id: v.id, cve: v.cve, severity: v.severity,
+                fixed_in: null, tier: "informational", informational: v.informational, recommended_status: "not_evaluated" })),
+            verification: "informational_only",
+        };
+    }
+    const details = pkg.vulnerabilities.map((vuln, i) => {
+        if (excluded[i])
+            return {
+                id: vuln.id, cve: vuln.cve, severity: vuln.severity, fixed_in: null,
+                tier: "informational", informational: vuln.informational,
+            };
         const fix = rankCandidates(scheme, pkg.version, vuln.fixed_versions)[0];
         return {
             id: vuln.id,
@@ -191,14 +286,16 @@ export function suggestUpgradeForPackage(pkg, context = {}) {
             fixed_in: fix ?? null,
             tier: fix !== undefined ? scheme.classify(pkg.version, fix)
                 : vuln.fixed_versions.some((v) => !scheme.isValid(v)) ? "unparseable_fix" : "unfixed",
+            // 修正対象にした情報提供(修正版のあるunsound)も種類を示す
+            ...(vuln.informational !== undefined ? { informational: vuln.informational } : {}),
         };
     });
     const unfixedCount = details.filter((d) => d.tier === "unfixed").length;
     const unparseableCount = details.filter((d) => d.tier === "unparseable_fix").length;
-    const fixableCount = details.length - unfixedCount;
+    const fixableCount = details.filter((d) => d.tier !== "unfixed" && d.tier !== "informational").length;
     // 解釈できない修正版のCVEも修正対象に残す。その影響範囲は情報不足のため、どの候補も検証できず推奨を保留する
     const targets = [
-        ...pkg.vulnerabilities.filter((_, i) => details[i].tier !== "unfixed"),
+        ...pkg.vulnerabilities.filter((_, i) => details[i].tier !== "unfixed" && details[i].tier !== "informational"),
         ...(context.extraTargets ?? []),
     ];
     const candidates = rankCandidates(scheme, pkg.version, targets.flatMap((v) => v.fixed_versions));
@@ -217,11 +314,11 @@ export function suggestUpgradeForPackage(pkg, context = {}) {
         recommended_upgrade: recommended,
         upgrade_tier: upgradeTier,
         ...(recommended !== null && scheme.isPrerelease(recommended) ? { recommended_is_prerelease: true } : {}),
-        upgrade_note: recommended === null && fixableCount > 0
+        upgrade_note: (recommended === null && fixableCount > 0
             ? "No known fixed version could be confirmed to be outside the affected ranges of every CVE to fix. The recommendation is also withheld when the data are insufficient or use unsupported range types." +
                 (unparseableCount > 0 ? ` ${unparseableCount} CVEs list fixed versions that cannot be parsed as versions (tier: unparseable_fix), so the recommendation is withheld.` : "")
-            : buildNote(scheme, pkg, recommended, upgradeTier, fixableCount, unfixedCount),
-        ...hintFields(pkg),
+            : buildNote(scheme, pkg, recommended, upgradeTier, fixableCount, unfixedCount)) + (informationalNotes ? ` ${informationalNotes}` : ""),
+        ...hintFields(pkg, recommended, upgradeTier),
         ...(pkg.version_is_lower_bound ? { version_is_lower_bound: true } : {}),
         per_cve_detail: details,
         verification: recommended === null ? "no_verified_candidate" : "verified",

package/dist/osv/versionScheme.js

@@ -3,6 +3,7 @@
  *
  * - Maven: Mavenの優先順位(mavenVersion.ts)。範囲はECOSYSTEM型
  * - npm・Go: SemVer 2.0.0の優先順位(semverVersion.ts)。範囲はSEMVER型とECOSYSTEM型
+ * - crates.io: SemVerの優先順位とCargoキャレット互換。範囲はSEMVER型
  * - PyPI: PEP 440の優先順位(pep440Version.ts)。範囲はECOSYSTEM型。名前はPEP 503で正規化して照合する
  * - その他: 比較器なし。範囲はECOSYSTEM型
  *
@@ -11,7 +12,7 @@
 import { compareMavenVersions, mavenVersionSeries } from "../utils/mavenVersion.js";
 import { compareParsedPep440, parsePep440 } from "../utils/pep440Version.js";
 import { compareParsedSemver, parseSemver } from "../utils/semverVersion.js";
-const SEMVER_ECOSYSTEMS = new Set(["npm", "Go"]);
+const SEMVER_ECOSYSTEMS = new Set(["npm", "Go", "crates.io"]);
 const MAVEN_SCHEME = {
     isValid: () => true,
     compare: compareMavenVersions,
@@ -126,6 +127,8 @@ export function samePackageName(a, b, ecosystem) {
 export function versionRangeTypes(ecosystem) {
     if (ecosystem === "Maven")
         return new Set(["ECOSYSTEM"]);
+    if (ecosystem === "crates.io")
+        return new Set(["SEMVER"]);
     if (SEMVER_ECOSYSTEMS.has(ecosystem))
         return new Set(["SEMVER", "ECOSYSTEM"]);
     return new Set(["ECOSYSTEM"]);

package/dist/tools/scanProject.js

@@ -8,7 +8,7 @@ import path from "node:path";
 import { ScanToolError } from "../errors.js";
 import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
 import { hasVulnerability, packageSources, parseOsvScanOutput } from "../osv/scanReport.js";
-import { combineRelations, goModRelations, npmLockRelations, pomRelations, requirementsRelations, } from "../utils/dependencyRelations.js";
+import { combineRelations, cargoLockRelations, goModRelations, npmLockRelations, pomRelations, requirementsRelations, } from "../utils/dependencyRelations.js";
 import { cargoLockCopyContent } from "../utils/cargoLock.js";
 import { sanitizeExternalText } from "../utils/externalText.js";
 import { readRegularFile } from "../utils/safeRead.js";
@@ -122,7 +122,7 @@ const MAX_INTRODUCED_BY = 10;
 export async function buildRelationLookups(copies, maxTotalBytes = MAX_RELATION_LOCKFILE_BYTES) {
     const lookups = new Map();
     let remaining = maxTotalBytes;
-    for (const { copy, format, originalRelative, entries } of copies) {
+    for (const { copy, format, originalRelative, entries, cargoPackages, declaringManifests } of copies) {
         const lockDir = originalRelative === null ? "" : path.dirname(originalRelative);
         let lookup = null;
         try {
@@ -141,6 +141,9 @@ export async function buildRelationLookups(copies, maxTotalBytes = MAX_RELATION_
             else if (format === "requirements.txt" && entries !== undefined) {
                 lookup = requirementsRelations(entries);
             }
+            else if (format === "Cargo.lock" && cargoPackages !== undefined) {
+                lookup = cargoLockRelations(cargoPackages, declaringManifests);
+            }
         }
         catch {
             lookup = null; // 解析できないファイルはunknown(スキャン自体は続ける)
@@ -156,6 +159,7 @@ function annotateRelations(packages, lookups) {
         // 同じファイルで直接依存と判定された結果があれば直接依存とする
         const byFile = new Map();
         const declaredIn = new Set();
+        const declaringCrates = new Set();
         const rank = { direct: 2, transitive: 1, unknown: 0 };
         for (const source of packageSources(pkg)) {
             const entry = lookups.get(source.path);
@@ -165,6 +169,8 @@ function annotateRelations(packages, lookups) {
                 byFile.set(source.path, info);
             for (const manifest of info.declaredIn ?? [])
                 declaredIn.add(path.join(entry.lockDir, manifest));
+            for (const name of info.declaringCrates ?? [])
+                declaringCrates.add(name);
         }
         const infos = [...byFile.values()];
         const { relation, introducedBy, replaced } = combineRelations(infos);
@@ -175,6 +181,8 @@ function annotateRelations(packages, lookups) {
             ...(introducedBy.length > 0 ? { introduced_by: introducedBy.slice(0, MAX_INTRODUCED_BY).map(sanitizeExternalText) } : {}),
             ...(introducedBy.length > MAX_INTRODUCED_BY ? { introduced_by_omitted: introducedBy.length - MAX_INTRODUCED_BY } : {}),
             ...(declaredIn.size > 0 ? { declared_in: [...declaredIn].sort().map(sanitizeExternalText) } : {}),
+            ...(declaringCrates.size > 0 ? { declaring_crates: [...declaringCrates].sort().slice(0, MAX_INTRODUCED_BY).map(sanitizeExternalText) } : {}),
+            ...(declaringCrates.size > MAX_INTRODUCED_BY ? { declaring_crates_omitted: declaringCrates.size - MAX_INTRODUCED_BY } : {}),
             ...(replaced ? { replaced_in_go_mod: true } : {}),
             vulnerabilities,
         };
@@ -213,7 +221,8 @@ export async function scanFromSnapshot(project, options) {
                 continue;
             const generated = await snapshot.writeGenerated(cargoLockCopyContent(copy.packages));
             targets.push({ path: generated, format: "Cargo.lock" });
-            relationSources.push({ copy: generated, format: "Cargo.lock", originalRelative: copy.path });
+            relationSources.push({ copy: generated, format: "Cargo.lock", originalRelative: copy.path,
+                cargoPackages: copy.allPackages, declaringManifests: copy.declaringManifests });
         }
         if (targets.length === 0)
             return parseOsvScanOutput({ results: [] });

package/dist/tools/suggestFix.js

@@ -1,7 +1,7 @@
 /**
  * `suggest_fix`ツールのハンドラ。
  * scan_projectと同じ検出・スキャンを実行し、脆弱なパッケージごとの
- * 推奨アップグレードバージョン(3段階Tier)を返す。推奨はMaven・npm・Go・PyPIに対応し、
+ * 推奨アップグレードバージョン(3段階Tier)を返す。推奨はMaven・npm・Go・PyPI・crates.ioに対応し、
  * それ以外はunsupported_ecosystemとして返す。
  */
 import { isRemoteResolutionDisabled } from "../osv/runner.js";

package/dist/utils/cargoLock.js

@@ -257,7 +257,7 @@ export const UNSCANNABLE_CRATE_REASONS = {
         "so it was not checked (and its name was not sent to api.osv.dev)",
 };
 export function classifyCargoPackages(packages) {
-    const result = { cratesIo: [], localCrates: [], unscannable: [] };
+    const result = { allPackages: [...packages], cratesIo: [], localCrates: [], unscannable: [] };
     const seen = new Set();
     for (const pkg of packages) {
         // [replace]で置換されたパッケージは使われない(置換先は別のパッケージとして分類する)

package/dist/utils/dependencyRelations.js

@@ -2,15 +2,121 @@
  * 直接/推移的依存の判定(docs/DESIGN_TODO.md「直接/推移的依存の区別(v0.7.0)詳細設計メモ」)。
  *
  * osv-scannerの出力には直接/推移的の区別がないため、スキャンしたファイル(スナップショットのコピー)を解析する。
- * 新しい外部依存は追加せず、JSON(package-lock.json)と行形式(go.mod、requirements.txt)だけを扱う。
+ * 新しい外部依存は追加せず、JSON・行形式・解析済みのCargo.lockグラフを扱う。
  * - package-lock.json(v2以降): ルートとworkspaceの依存をNodeの解決規則で解決したものが直接依存、
  *   そこからたどれるものが推移的依存。経由した直接依存の名前(introduced_by)と、宣言したpackage.json(declared_in)を返す
  * - go.mod: `// indirect`のないrequireが直接依存。replaceの置換先にも同じ関係を当てる(osv-scannerは置換先で報告する)
  * - requirements.txt: 本サーバーが書いたコピーの行が直接依存、それ以外(deps.devで解決された依存)が推移的依存
+ * - Cargo.lock: local/path/workspace crateの直下を直接依存、そこから到達するcrates.ioのcrateを推移的依存とする
  */
+import { cargoSourceKind, parsePackageId } from "./cargoLock.js";
 /** たどる依存の辺の上限(巨大・悪意あるlockfileで処理が膨らまないように) */
 export const MAX_DEPENDENCY_EDGES = 2_000_000;
 const UNKNOWN = { relation: "unknown" };
+/** Cargoの省略されたpackage IDは、一意に解決できるときだけたどる。 */
+export function cargoLockRelations(packages, manifests = new Map(), maxEdges = MAX_DEPENDENCY_EDGES) {
+    const identity = (p) => JSON.stringify([p.name, p.version, p.source]);
+    const entries = new Map(packages.map((p) => [identity(p), p]));
+    const names = new Map();
+    const versions = new Map();
+    for (const [id, p] of entries) {
+        const named = names.get(p.name) ?? [];
+        named.push(id);
+        names.set(p.name, named);
+        const nv = JSON.stringify([p.name, p.version]);
+        const versioned = versions.get(nv) ?? [];
+        versioned.push(id);
+        versions.set(nv, versioned);
+    }
+    let edges = 0;
+    let exceeded = false;
+    const tick = () => { if (++edges > maxEdges)
+        exceeded = true; return !exceeded; };
+    const resolve = (reference) => {
+        let ref = reference;
+        const seen = new Set();
+        for (;;) {
+            if (!tick())
+                return null;
+            const parsed = parsePackageId(ref);
+            const candidates = parsed === null ? names.get(ref)
+                : parsed.source === null ? versions.get(JSON.stringify([parsed.name, parsed.version]))
+                    : entries.has(identity(parsed)) ? [identity(parsed)] : undefined;
+            if (candidates?.length !== 1)
+                return null;
+            const id = candidates[0];
+            if (seen.has(id))
+                return null;
+            seen.add(id);
+            const p = entries.get(id);
+            if (p.replace === undefined)
+                return id;
+            ref = p.replace;
+        }
+    };
+    const direct = new Map();
+    const introduced = new Map();
+    const origins = new Set();
+    for (const root of entries.values()) {
+        if (root.source !== null || root.replace !== undefined)
+            continue;
+        for (const dep of root.dependencies) {
+            const target = resolve(dep);
+            if (exceeded)
+                return null;
+            if (target === null)
+                continue;
+            // ローカルのcrate(pathの依存)はそれ自体が起点で、その依存は直接依存になる。経由した依存元(introduced_by)には含めない
+            if (entries.get(target).source === null)
+                continue;
+            origins.add(target);
+            if (cargoSourceKind(entries.get(target).source) !== "crates_io")
+                continue;
+            const declared = direct.get(target) ?? new Set();
+            declared.add(root.name);
+            direct.set(target, declared);
+        }
+    }
+    for (const origin of origins) {
+        const visited = new Set([origin]);
+        const queue = [origin];
+        while (queue.length) {
+            for (const dep of entries.get(queue.pop()).dependencies) {
+                const target = resolve(dep);
+                if (exceeded)
+                    return null;
+                if (target === null || visited.has(target))
+                    continue;
+                visited.add(target);
+                queue.push(target);
+                if (cargoSourceKind(entries.get(target).source) !== "crates_io")
+                    continue;
+                const by = introduced.get(target) ?? new Set();
+                by.add(entries.get(origin).name);
+                introduced.set(target, by);
+            }
+        }
+    }
+    const byPackage = new Map();
+    for (const [id, p] of entries) {
+        if (p.replace !== undefined || cargoSourceKind(p.source) !== "crates_io")
+            continue;
+        const declared = direct.get(id);
+        const by = introduced.get(id);
+        const mapped = declared === undefined ? [] : [...declared].map((name) => manifests.get(name));
+        const info = {
+            relation: declared ? "direct" : by ? "transitive" : "unknown",
+            ...(by ? { introducedBy: by } : {}),
+            ...(mapped.length > 0 && mapped.every((m) => m !== undefined) ? { declaredIn: new Set(mapped) } : {}),
+            ...(declared && !mapped.every((m) => m !== undefined) ? { declaringCrates: declared } : {}),
+        };
+        const key = JSON.stringify([p.name, p.version]);
+        const prior = byPackage.get(key);
+        // Multiple crates.io source identities cannot be distinguished in the scanner output.
+        byPackage.set(key, prior === undefined ? info : UNKNOWN);
+    }
+    return (name, version) => byPackage.get(JSON.stringify([name, version])) ?? UNKNOWN;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/utils/manifestDetector.js

@@ -126,6 +126,19 @@ const MAX_CARGO_TOML_BYTES = 1024 * 1024;
 export class CargoLockCache {
     results = new Map();
     remaining;
+    tomls = new Map();
+    remainingToml = MAX_LOCKFILE_TOTAL_BYTES;
+    async toml(file, projectDir) {
+        if (this.tomls.has(file))
+            return this.tomls.get(file);
+        const read = this.remainingToml > 0
+            ? await readRegularFile(file, { maxBytes: Math.min(MAX_CARGO_TOML_BYTES, this.remainingToml), boundary: projectDir }) : null;
+        const text = read?.ok ? read.bytes.toString("utf8") : null;
+        if (read?.ok)
+            this.remainingToml -= read.bytes.length;
+        this.tomls.set(file, text);
+        return text;
+    }
     constructor(maxTotalBytes = MAX_LOCKFILE_TOTAL_BYTES) {
         this.remaining = maxTotalBytes;
     }
@@ -156,8 +169,8 @@ export class CargoLockCache {
     async workspace(lockAbs, projectDir) {
         if (this.workspaces.has(lockAbs))
             return this.workspaces.get(lockAbs);
-        const read = await readRegularFile(path.join(path.dirname(lockAbs), "Cargo.toml"), { maxBytes: MAX_CARGO_TOML_BYTES, boundary: projectDir });
-        const workspace = read.ok ? cargoWorkspace(read.bytes.toString("utf8")) : null;
+        const text = await this.toml(path.join(path.dirname(lockAbs), "Cargo.toml"), projectDir);
+        const workspace = text === null ? null : cargoWorkspace(text);
         this.workspaces.set(lockAbs, workspace);
         return workspace;
     }
@@ -174,8 +187,8 @@ async function cargoLockfileRecords(cache, projectDir, lockfile, memberToml) {
     const lock = await cache.get(path.join(projectDir, lockfile.path), projectDir);
     if ("reason" in lock)
         return null;
-    const read = await readRegularFile(path.join(projectDir, memberToml), { maxBytes: MAX_CARGO_TOML_BYTES, boundary: projectDir });
-    const name = read.ok ? cargoTomlPackageName(read.bytes.toString("utf8")) : null;
+    const text = await cache.toml(path.join(projectDir, memberToml), projectDir);
+    const name = text === null ? null : cargoTomlPackageName(text);
     if (name === null)
         return null;
     if (!lock.localCrates.includes(name))
@@ -262,6 +275,17 @@ async function finalize(projectDir, manifests, markers, allowedRootReal) {
         skippedFiles: [],
     };
     const readContext = createRequirementsReadContext();
+    const cargoManifests = new Map();
+    const cargoMarkers = new Set([
+        ...markers.filter((m) => m.path.endsWith("Cargo.toml")).map((m) => m.path),
+        ...manifests.filter((m) => m.format === "Cargo.lock").map((m) => path.join(path.dirname(m.path), "Cargo.toml")),
+    ]);
+    for (const marker of cargoMarkers) {
+        const text = await cargoCache.toml(path.join(projectDir, marker), projectDir);
+        const name = text === null ? null : cargoTomlPackageName(text);
+        if (name !== null)
+            cargoManifests.set(name, [...(cargoManifests.get(name) ?? []), marker]);
+    }
     for (const manifest of manifests) {
         const absolute = path.join(projectDir, manifest.path);
         if (manifest.format === "requirements.txt") {
@@ -281,7 +305,12 @@ async function finalize(projectDir, manifests, markers, allowedRootReal) {
                 result.skippedFiles.push({ path: manifest.path, reason: lock.reason });
                 continue;
             }
-            result.cargoCopies.push({ path: manifest.path, packages: lock.cratesIo });
+            const declaringManifests = new Map();
+            for (const [name, paths] of cargoManifests) {
+                if (paths.length === 1)
+                    declaringManifests.set(name, path.relative(path.dirname(manifest.path), paths[0]));
+            }
+            result.cargoCopies.push({ path: manifest.path, packages: lock.cratesIo, allPackages: lock.allPackages, declaringManifests });
             result.localCrateCount += lock.localCrates.length;
             result.unscannableCrates.push(...lock.unscannable.map((c) => ({ file: manifest.path, name: c.name, version: c.version, reason: UNSCANNABLE_CRATE_REASONS[c.kind] })));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osv-scanner-mcp",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "MCP server that wraps Google's OSV-Scanner to scan Java projects for known vulnerabilities",
   "type": "module",
   "license": "Apache-2.0",