@dennisrepa/elevate 1.4.0 → 1.6.0

package/dist/cli.js

@@ -4,8 +4,65 @@
 import { render } from "ink";
 
 // src/config.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname8, join as join18, resolve as resolve10 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import { dirname as dirname10, join as join23, resolve as resolve14 } from "path";
+
+// src/domain/version-policy.ts
+import semver2 from "semver";
+
+// src/domain/versions.ts
+import semver from "semver";
+var PRE_RELEASE = /(?:^|[.\-_+]|(?<=\d))(alpha|beta|rc|cr|milestone|preview|snapshot|ea|dev|pre|(?:a|b|m)(?=\d))(?=$|[.\-_+]|\d)/i;
+function isPreReleaseVersion(version) {
+  return PRE_RELEASE.test(version);
+}
+function extractPreReleaseTag(version) {
+  const match = version.match(PRE_RELEASE);
+  if (!match) return void 0;
+  const token = match[1].toLowerCase();
+  if (token === "a") return "ALPHA";
+  if (token === "b") return "BETA";
+  if (token === "m") {
+    const number = version.slice((match.index ?? 0) + match[0].length).match(/^\d+/)?.[0];
+    return `M${number ?? ""}`;
+  }
+  return token.toUpperCase();
+}
+function cleanJavaVersion(version) {
+  const match = version.match(/^v?(\d+(?:\.\d+){0,2})/);
+  if (!match) return null;
+  return semver.coerce(match[1])?.version ?? null;
+}
+function diffVersions(from, to) {
+  const kind = semver.diff(from, to);
+  if (kind === "major" || kind === "premajor") return "major";
+  if (kind === "minor" || kind === "preminor") return "minor";
+  return "patch";
+}
+function rangePrefix(range) {
+  if (range.startsWith("^")) return "^";
+  if (range.startsWith("~")) return "~";
+  return "";
+}
+
+// src/domain/version-policy.ts
+function semverDiff(current, target, normalize) {
+  const to = normalize(target);
+  if (!to || !semver2.valid(current)) return "minor";
+  return semver2.eq(current, to) ? "patch" : diffVersions(current, to);
+}
+var npmVersionPolicy = {
+  normalize: (v) => semver2.valid(v),
+  rewrite: (current, target) => `${rangePrefix(current)}${target}`,
+  diff: (current, target) => semverDiff(current, target, (v) => semver2.valid(v)),
+  allowsManualTargets: true
+};
+var mavenVersionPolicy = {
+  normalize: cleanJavaVersion,
+  rewrite: (_current, target) => target,
+  diff: (current, target) => semverDiff(current, target, cleanJavaVersion),
+  allowsManualTargets: false
+};
 
 // src/adapters/npm/npm-package-manager.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
@@ -37,7 +94,7 @@ var UnsafeArgumentError = class extends Error {
 var IS_WINDOWS = process.platform === "win32";
 var WINDOWS_UNSAFE = /["%!^&|<>\r\n]/;
 function runCommand(command, args, options) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve16, reject) => {
     const spawnOptions = { cwd: options.cwd, windowsHide: true, env: process.env };
     let child2;
     if (IS_WINDOWS) {
@@ -67,19 +124,19 @@ function runCommand(command, args, options) {
     });
     child2.on("close", (code) => {
       if (timer) clearTimeout(timer);
-      resolve12({ exitCode: code ?? 1, stdout, stderr, timedOut });
+      resolve16({ exitCode: code ?? 1, stdout, stderr, timedOut });
     });
   });
 }
 function runShellScript(script, options) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve16) => {
     exec(
       script,
       { cwd: options.cwd, timeout: options.timeoutMs, maxBuffer: 64 * 1024 * 1024, windowsHide: true },
       (error, stdout, stderr) => {
         const timedOut = Boolean(error?.killed);
         const exitCode = error ? typeof error.code === "number" ? error.code : 1 : 0;
-        resolve12({ exitCode, stdout, stderr, timedOut });
+        resolve16({ exitCode, stdout, stderr, timedOut });
       }
     );
   });
@@ -304,7 +361,7 @@ var NpmModuleDiscoveryAdapter = class {
 };
 
 // src/adapters/npm/npm-registry.ts
-import semver from "semver";
+import semver3 from "semver";
 
 // src/domain/origin.ts
 function buildWorkspaceIndex(modules) {
@@ -434,13 +491,13 @@ var NpmRegistryAdapter = class {
     if (!isValidPackageName(coordinate.identifier)) return null;
     if (channel === "stable") {
       const latest = await this.view(coordinate.identifier, "dist-tags.latest", cwd);
-      if (typeof latest === "string" && semver.valid(latest) && semver.prerelease(latest) === null) {
+      if (typeof latest === "string" && semver3.valid(latest) && semver3.prerelease(latest) === null) {
         return latest;
       }
       const releases = (await this.getAllVersions(coordinate, cwd)).filter(
-        (v) => semver.valid(v) && semver.prerelease(v) === null
+        (v) => semver3.valid(v) && semver3.prerelease(v) === null
       );
-      return releases.length > 0 ? semver.rsort(releases)[0] : null;
+      return releases.length > 0 ? semver3.rsort(releases)[0] : null;
     }
     const version = await this.view(coordinate.identifier, "version", cwd);
     return typeof version === "string" && version ? version : null;
@@ -470,42 +527,7 @@ var NpmRegistryAdapter = class {
 // src/adapters/npm/npm-scanner.ts
 import { readFileSync as readFileSync4 } from "fs";
 import { join as join5 } from "path";
-import semver3 from "semver";
-
-// src/domain/versions.ts
-import semver2 from "semver";
-var PRE_RELEASE = /(?:^|[.\-_+]|(?<=\d))(alpha|beta|rc|cr|milestone|preview|snapshot|ea|dev|pre|(?:a|b|m)(?=\d))(?=$|[.\-_+]|\d)/i;
-function isPreReleaseVersion(version) {
-  return PRE_RELEASE.test(version);
-}
-function extractPreReleaseTag(version) {
-  const match = version.match(PRE_RELEASE);
-  if (!match) return void 0;
-  const token = match[1].toLowerCase();
-  if (token === "a") return "ALPHA";
-  if (token === "b") return "BETA";
-  if (token === "m") {
-    const number = version.slice((match.index ?? 0) + match[0].length).match(/^\d+/)?.[0];
-    return `M${number ?? ""}`;
-  }
-  return token.toUpperCase();
-}
-function cleanJavaVersion(version) {
-  const match = version.match(/^v?(\d+(?:\.\d+){0,2})/);
-  if (!match) return null;
-  return semver2.coerce(match[1])?.version ?? null;
-}
-function diffVersions(from, to) {
-  const kind = semver2.diff(from, to);
-  if (kind === "major" || kind === "premajor") return "major";
-  if (kind === "minor" || kind === "preminor") return "minor";
-  return "patch";
-}
-function rangePrefix(range) {
-  if (range.startsWith("^")) return "^";
-  if (range.startsWith("~")) return "~";
-  return "";
-}
+import semver4 from "semver";
 
 // src/adapters/shared/pool.ts
 async function mapPooled(items, concurrency, fn) {
@@ -636,9 +658,9 @@ var NpmDependencyAdapter = class {
     if (!latest) {
       return { skipped: { identifier: dep.name, origin: origin.kind, reason: "lookup-failed" } };
     }
-    const currentClean = semver3.minVersion(dep.range)?.version;
-    if (!currentClean || !semver3.valid(latest) || !semver3.gt(latest, currentClean)) return null;
-    const tag = semver3.prerelease(latest) ? extractPreReleaseTag(latest) ?? "PRE" : void 0;
+    const currentClean = semver4.minVersion(dep.range)?.version;
+    if (!currentClean || !semver4.valid(latest) || !semver4.gt(latest, currentClean)) return null;
+    const tag = semver4.prerelease(latest) ? extractPreReleaseTag(latest) ?? "PRE" : void 0;
     const diff = diffVersions(currentClean, latest);
     return {
       candidate: {
@@ -673,18 +695,18 @@ function declaredDependencies(pkg) {
 function isUpgradableRange(range) {
   const trimmed = range.trim();
   if (trimmed === "" || trimmed === "*" || trimmed.toLowerCase() === "x") return false;
-  return semver3.validRange(trimmed) !== null;
+  return semver4.validRange(trimmed) !== null;
 }
 function alignmentCandidate(dep, target, origin, pnpm = false) {
   const split = pnpm ? splitRangeProtocol(dep.range) : { protocol: void 0, rest: dep.range };
   const range = split.protocol === "workspace" ? split.rest : dep.range;
   const protocol = split.protocol === "workspace" ? "workspace:" : "";
   const local = target.version;
-  if (!local || !semver3.valid(local) || !isUpgradableRange(range)) return null;
-  if (semver3.satisfies(local, range, { includePrerelease: true })) return null;
-  const currentClean = semver3.minVersion(range)?.version ?? "0.0.0";
+  if (!local || !semver4.valid(local) || !isUpgradableRange(range)) return null;
+  if (semver4.satisfies(local, range, { includePrerelease: true })) return null;
+  const currentClean = semver4.minVersion(range)?.version ?? "0.0.0";
   const diff = diffVersions(currentClean, local);
-  const tag = semver3.prerelease(local) ? extractPreReleaseTag(local) ?? "PRE" : void 0;
+  const tag = semver4.prerelease(local) ? extractPreReleaseTag(local) ?? "PRE" : void 0;
   return {
     coordinate: { identifier: dep.name, artifact: dep.name, ecosystem: "npm" },
     currentRange: dep.range,
@@ -1035,6 +1057,7 @@ var NpmEcosystemStrategy = class {
   }
   icon = "\u{1F4E6}";
   manifestFile = "package.json";
+  versioning = npmVersionPolicy;
   discovery = new NpmModuleDiscoveryAdapter();
   registry = new NpmRegistryAdapter();
   reader = new NpmDependencyAdapter(this.registry, this.registry.config);
@@ -1049,17 +1072,799 @@ var NpmEcosystemStrategy = class {
   }
 };
 
-// src/adapters/maven/maven-discovery.ts
-import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname5, join as join11, relative as relative3, resolve as resolve6 } from "path";
+// src/adapters/cargo/cargo-strategy.ts
+import semver10 from "semver";
 
-// src/adapters/maven/maven-project.ts
-import { existsSync as existsSync6, readdirSync, statSync as statSync2 } from "fs";
-import { join as join10, resolve as resolve5 } from "path";
+// src/adapters/cargo/cargo-discovery.ts
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname4, join as join9, relative as relative3, resolve as resolve4 } from "path";
 
-// src/adapters/maven/maven-pom.ts
-import { existsSync as existsSync5, readFileSync as readFileSync8, statSync } from "fs";
-import { dirname as dirname4, join as join9, resolve as resolve4 } from "path";
+// src/adapters/cargo/cargo-command.ts
+var CargoUnavailableError = class extends Error {
+  constructor() {
+    super("Cargo is not available: no `cargo` on the PATH. Install Rust (https://rustup.rs).");
+    this.name = "CargoUnavailableError";
+  }
+};
+async function runCargo(args, options) {
+  let result;
+  try {
+    result = await runCommand("cargo", args, options);
+  } catch (err) {
+    if (err.code === "ENOENT") throw new CargoUnavailableError();
+    throw err;
+  }
+  if (looksLikeMissingCommand(result) && !await cargoStarts(options.cwd)) throw new CargoUnavailableError();
+  return result;
+}
+function looksLikeMissingCommand(result) {
+  return process.platform === "win32" && result.exitCode !== 0 && !result.stdout.trim() && !/^error/m.test(result.stderr);
+}
+async function cargoStarts(cwd) {
+  try {
+    return (await runCommand("cargo", ["--version"], { cwd, timeoutMs: 3e4 })).exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+function cargoErrors(output) {
+  const lines = output.split(/\r?\n/);
+  const errors = lines.filter((l) => /^error(\[E\d+\])?:/.test(l));
+  const summary = (errors.length > 0 ? errors : lines.filter((l) => l.trim()).slice(-10)).slice(0, 12);
+  if (/toolchain '.+' is not installed/.test(output)) {
+    summary.push("Install it with `rustup toolchain install` (the project pins it in rust-toolchain.toml).");
+  }
+  return summary.join("\n");
+}
+
+// src/adapters/cargo/cargo-metadata.ts
+var CargoMetadataError = class extends Error {
+  constructor(message2, dir) {
+    super(message2);
+    this.dir = dir;
+    this.name = "CargoMetadataError";
+  }
+  dir;
+};
+async function loadMetadata(dir) {
+  const result = await runCargo(["metadata", "--no-deps", "--format-version", "1"], { cwd: dir, timeoutMs: 6e4 });
+  if (result.exitCode !== 0) {
+    throw new CargoMetadataError(`cargo metadata failed in ${dir}: ${cargoErrors(result.stderr || result.stdout)}`, dir);
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    throw new CargoMetadataError(`cargo metadata printed no JSON in ${dir}.`, dir);
+  }
+}
+
+// src/adapters/cargo/cargo-discovery.ts
+var IGNORED = /* @__PURE__ */ new Set(["target", "node_modules", "vendor", "dist", "build", "out", "src"]);
+var norm = (path) => resolve4(path).replace(/\\/g, "/");
+function findManifests(root) {
+  const found = [];
+  const walk = (dir, depth) => {
+    let entries2;
+    try {
+      entries2 = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (entries2.some((e) => e.isFile() && e.name === "Cargo.toml")) found.push(join9(dir, "Cargo.toml"));
+    for (const entry of entries2) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && !IGNORED.has(entry.name)) walk(join9(dir, entry.name), depth + 1);
+    }
+  };
+  walk(root, 0);
+  return found.sort((a, b) => a.split(/[\\/]/).length - b.split(/[\\/]/).length || a.localeCompare(b));
+}
+var declaresWorkspace = (dir) => {
+  try {
+    return /^\s*\[workspace[\].]/m.test(readFileSync8(join9(dir, "Cargo.toml"), "utf8"));
+  } catch {
+    return false;
+  }
+};
+var CargoModuleDiscoveryAdapter = class {
+  problems = [];
+  diagnostics() {
+    return [...this.problems];
+  }
+  /** The nearest ancestor declaring `[workspace]`; failing that, the nearest directory with a manifest. */
+  findRoot(startDir, boundaryDir) {
+    const boundary = boundaryDir ? resolve4(boundaryDir) : void 0;
+    const chain = [];
+    for (let dir = resolve4(startDir); ; ) {
+      chain.push(dir);
+      const parent = dirname4(dir);
+      if (dir === boundary || parent === dir) break;
+      dir = parent;
+    }
+    return chain.find(declaresWorkspace) ?? chain.find((d) => existsSync5(join9(d, "Cargo.toml")));
+  }
+  async discover(rootDir) {
+    const covered = /* @__PURE__ */ new Set();
+    const modules = [];
+    const errors = [];
+    this.problems = [];
+    for (const manifest of findManifests(rootDir)) {
+      if (covered.has(norm(manifest))) continue;
+      try {
+        const metadata = await loadMetadata(dirname4(manifest));
+        for (const pkg of metadata.packages) {
+          covered.add(norm(pkg.manifest_path));
+          const path = dirname4(pkg.manifest_path);
+          const relPath = relative3(rootDir, path).replace(/\\/g, "/");
+          modules.push({
+            id: pkg.name,
+            name: pkg.name,
+            path,
+            relPath: relPath === "" ? "Root" : relPath,
+            ecosystem: "cargo",
+            isRoot: relPath === "",
+            version: pkg.version,
+            aggregatorDir: resolve4(metadata.workspace_root)
+          });
+        }
+      } catch (err) {
+        if (err instanceof CargoUnavailableError) throw err;
+        if (err instanceof CargoMetadataError) {
+          errors.push(err);
+          this.problems.push(err.message);
+        } else throw err;
+      }
+    }
+    if (modules.length === 0 && errors.length > 0) throw errors[0];
+    modules.sort((a, b) => a.isRoot ? -1 : b.isRoot ? 1 : a.relPath.localeCompare(b.relPath));
+    const taken = /* @__PURE__ */ new Set();
+    for (const module of modules) {
+      if (taken.has(module.id)) module.id = `${module.name} (${module.relPath})`;
+      taken.add(module.id);
+    }
+    return modules;
+  }
+};
+
+// src/adapters/cargo/cargo-config.ts
+import { existsSync as existsSync6, readFileSync as readFileSync9 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname5, isAbsolute, join as join10, resolve as resolve5 } from "path";
+import { getStaticTOMLValue, parseTOML } from "toml-eslint-parser";
+var CRATES_IO = "registry+https://github.com/rust-lang/crates.io-index";
+var PUBLIC_HOSTS = /* @__PURE__ */ new Set(["index.crates.io", "static.crates.io", "crates.io", "github.com"]);
+var UnsupportedSourceError = class extends Error {
+  constructor(detail) {
+    super(`Cargo is configured to use a package source Elevate cannot read (${detail}). No lookup was made.`);
+    this.name = "UnsupportedSourceError";
+  }
+};
+function isPublicIndex(index) {
+  try {
+    const url = new URL(index.replace(/^(sparse|registry)\+/, ""));
+    return PUBLIC_HOSTS.has(url.hostname.toLowerCase()) && (url.hostname !== "github.com" || url.pathname.includes("crates.io-index"));
+  } catch {
+    return false;
+  }
+}
+function merge(base, top) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(top)) {
+    const existing = out[key];
+    out[key] = value && typeof value === "object" && !Array.isArray(value) && existing && typeof existing === "object" && !Array.isArray(existing) ? merge(existing, value) : value;
+  }
+  return out;
+}
+function loadFile(file, depth = 0) {
+  let table;
+  try {
+    table = getStaticTOMLValue(parseTOML(readFileSync9(file, "utf8")));
+  } catch {
+    return {};
+  }
+  const includes = table.include;
+  delete table.include;
+  if (!Array.isArray(includes) || depth > 4) return table;
+  let included = {};
+  for (const entry of includes) {
+    const path = typeof entry === "string" ? entry : entry?.path;
+    if (typeof path === "string") included = merge(included, loadFile(isAbsolute(path) ? path : resolve5(dirname5(file), path), depth + 1));
+  }
+  return merge(included, table);
+}
+var CargoConfigReader = class {
+  env;
+  cache = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.env = options.env ?? process.env;
+  }
+  /** The configuration as Cargo would merge it for `cwd`: nearest file first, CARGO_HOME last. */
+  config(cwd) {
+    const start = resolve5(cwd);
+    let cached = this.cache.get(start);
+    if (cached) return cached;
+    const files = [];
+    for (let dir = start; ; ) {
+      for (const name of ["config.toml", "config"]) {
+        const file = join10(dir, ".cargo", name);
+        if (existsSync6(file)) {
+          files.push(file);
+          break;
+        }
+      }
+      const parent = dirname5(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    const home2 = this.env.CARGO_HOME ?? join10(homedir(), ".cargo");
+    for (const name of ["config.toml", "config"]) {
+      const file = join10(home2, name);
+      if (existsSync6(file) && !files.includes(file)) {
+        files.push(file);
+        break;
+      }
+    }
+    cached = files.reduceRight((acc, file) => merge(acc, loadFile(file)), {});
+    this.cache.set(start, cached);
+    return cached;
+  }
+  /** `[source.*]` comes from files only: Cargo ignores `CARGO_SOURCE_*` variables (checked with Cargo 1.97). */
+  sourceField(config, source, field) {
+    const value = config.source?.[source]?.[field];
+    return typeof value === "string" ? value : void 0;
+  }
+  /**
+   * The index a lookup goes to. `registry` is the index URL of an alternative
+   * registry as Cargo reports it, or undefined for crates.io.
+   */
+  async resolve(registry, cwd) {
+    const config = this.config(cwd);
+    let name = registry === void 0 ? "crates-io" : this.sourceNamed(config, registry);
+    let index = registry ?? CRATES_IO;
+    const seen = /* @__PURE__ */ new Set();
+    while (name !== void 0) {
+      if (seen.has(name)) throw new UnsupportedSourceError(`replacement cycle at '${name}'`);
+      seen.add(name);
+      const next = this.sourceField(config, name, "replace-with");
+      if (next === void 0) break;
+      for (const kind of ["directory", "local-registry", "git"]) {
+        if (this.sourceField(config, next, kind) !== void 0) throw new UnsupportedSourceError(`'${next}' is a ${kind} source`);
+      }
+      const target = this.sourceField(config, next, "registry");
+      if (target !== void 0) {
+        index = target;
+        name = next;
+        if (this.sourceField(config, next, "replace-with") === void 0) break;
+        continue;
+      }
+      if (this.sourceField(config, next, "replace-with") === void 0) {
+        throw new UnsupportedSourceError(`'${next}' has no registry`);
+      }
+      name = next;
+    }
+    return { index, isPublic: isPublicIndex(index) };
+  }
+  /** Name of the `[source.*]` table whose registry is `url`, if any. */
+  sourceNamed(config, url) {
+    return Object.keys(config.source ?? {}).find((n) => this.sourceField(config, n, "registry") === url);
+  }
+};
+
+// src/version.ts
+import { createRequire } from "module";
+var VERSION = true ? "1.6.0" : fromPackage();
+
+// src/adapters/cargo/cargo-index.ts
+var RegistryAuthRequiredError = class extends Error {
+  constructor(index) {
+    super(`The registry ${index} requires authentication. Elevate does not handle registry credentials.`);
+    this.index = index;
+    this.name = "RegistryAuthRequiredError";
+  }
+  index;
+};
+var CrateNotFoundError = class extends Error {
+  constructor(crate, index) {
+    super(`'${crate}' is not in the registry ${index}.`);
+    this.crate = crate;
+    this.index = index;
+    this.name = "CrateNotFoundError";
+  }
+  crate;
+  index;
+};
+var UnsupportedIndexError = class extends Error {
+  constructor(index) {
+    super(`The registry index ${index} is not a sparse index; Elevate cannot read it.`);
+    this.index = index;
+    this.name = "UnsupportedIndexError";
+  }
+  index;
+};
+var CRATES_IO_SPARSE = "https://index.crates.io/";
+var CRATES_IO_GIT = "registry+https://github.com/rust-lang/crates.io-index";
+function indexPath(name) {
+  const n = name.toLowerCase();
+  if (n.length <= 2) return `${n.length}/${n}`;
+  if (n.length === 3) return `3/${n[0]}/${n}`;
+  return `${n.slice(0, 2)}/${n.slice(2, 4)}/${n}`;
+}
+function parseIndex(text) {
+  const versions = [];
+  for (const raw of text.split(/\r?\n/)) {
+    if (!raw.trim()) continue;
+    try {
+      const entry = JSON.parse(raw);
+      if (typeof entry.vers !== "string") continue;
+      versions.push({ version: entry.vers, yanked: entry.yanked === true, rustVersion: entry.rust_version });
+    } catch {
+    }
+  }
+  return versions;
+}
+function sparseRoot(index) {
+  if (index === CRATES_IO_GIT) return CRATES_IO_SPARSE;
+  if (index.startsWith("sparse+")) {
+    const url = index.slice("sparse+".length);
+    return url.endsWith("/") ? url : `${url}/`;
+  }
+  throw new UnsupportedIndexError(index);
+}
+var userAgent = () => `elevate/${VERSION} (+https://github.com/DennisRepa/Elevate)`;
+function networkReason(err) {
+  const cause = err?.cause?.message;
+  return cause ?? (err instanceof Error ? err.message : String(err));
+}
+var CargoIndexClient = class {
+  constructor(fetchFn = fetch, env = process.env) {
+    this.fetchFn = fetchFn;
+    this.env = env;
+  }
+  fetchFn;
+  env;
+  memo = /* @__PURE__ */ new Map();
+  /** All versions of a crate in oldest-first file order. Memoised per index and crate. */
+  versions(index, crate) {
+    const key = `${index}
+${crate.toLowerCase()}`;
+    let pending = this.memo.get(key);
+    if (!pending) {
+      pending = this.load(index, crate);
+      this.memo.set(key, pending);
+    }
+    return pending;
+  }
+  async load(index, crate) {
+    const url = `${sparseRoot(index)}${indexPath(crate)}`;
+    let response;
+    try {
+      response = await this.fetchFn(url, { headers: { "user-agent": userAgent() } });
+    } catch (err) {
+      throw new Error(`Cannot reach ${url}: ${networkReason(err)}${this.proxyHint()}`);
+    }
+    if (response.status === 401 || response.status === 403) throw new RegistryAuthRequiredError(index);
+    if (response.status === 404) throw new CrateNotFoundError(crate, index);
+    if (!response.ok) throw new Error(`Registry answered ${response.status} for ${url}.`);
+    return parseIndex(await response.text());
+  }
+  /**
+   * Node's fetch ignores HTTP(S)_PROXY unless NODE_USE_ENV_PROXY=1 is set when
+   * the process starts (measured with Node 22.23; it cannot be switched on later).
+   */
+  proxyHint() {
+    const proxied = this.env.HTTPS_PROXY || this.env.https_proxy || this.env.HTTP_PROXY || this.env.http_proxy;
+    if (!proxied || this.env.NODE_USE_ENV_PROXY === "1") return "";
+    return " A proxy is configured, but Node does not use it for registry lookups unless you start Elevate with NODE_USE_ENV_PROXY=1.";
+  }
+};
+
+// src/adapters/cargo/cargo-registry.ts
+import semver6 from "semver";
+
+// src/adapters/cargo/cargo-versions.ts
+import semver5 from "semver";
+var rust = (v) => semver5.coerce(v)?.version;
+function eligibleVersions(versions, options) {
+  const project = options.rustVersion ? rust(options.rustVersion) : void 0;
+  return versions.filter((v) => !v.yanked && semver5.valid(v.version)).filter((v) => options.channel === "all" || semver5.prerelease(v.version) === null).filter((v) => {
+    const needs = v.rustVersion ? rust(v.rustVersion) : void 0;
+    return !(project && needs && semver5.gt(needs, project));
+  }).map((v) => v.version).sort(semver5.rcompare);
+}
+function selectVersion(versions, options) {
+  const candidates = versions.filter((v) => !v.yanked && semver5.valid(v.version)).filter((v) => options.channel === "all" || semver5.prerelease(v.version) === null).sort((a, b) => semver5.rcompare(a.version, b.version));
+  const project = options.rustVersion ? rust(options.rustVersion) : void 0;
+  let blocked;
+  for (const candidate of candidates) {
+    const needs = candidate.rustVersion ? rust(candidate.rustVersion) : void 0;
+    if (project && needs && semver5.gt(needs, project)) {
+      blocked ??= { version: candidate.version, requires: candidate.rustVersion };
+      continue;
+    }
+    return { version: candidate.version, ...blocked ? { blockedByMsrv: blocked } : {} };
+  }
+  return { version: void 0, ...blocked ? { blockedByMsrv: blocked } : {} };
+}
+
+// src/adapters/cargo/cargo-registry.ts
+var CargoRegistryAdapter = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async resolveEndpoint(coordinate, cwd) {
+    const { index, isPublic } = await this.deps.endpoint(coordinate.registry, cwd);
+    return { url: index, isPublic };
+  }
+  async getLatestVersion(coordinate, channel = "stable", cwd = process.cwd()) {
+    return selectVersion(await this.load(coordinate, cwd), { channel }).version ?? null;
+  }
+  /** Published, not yanked, newest first. Lookup errors propagate so they are not mistaken for "no versions". */
+  async getAllVersions(coordinate, cwd = process.cwd()) {
+    return (await this.load(coordinate, cwd)).filter((v) => !v.yanked && semver6.valid(v.version)).map((v) => v.version).sort(semver6.rcompare);
+  }
+  async load(coordinate, cwd) {
+    const { index } = await this.deps.endpoint(coordinate.registry, cwd);
+    return this.deps.index.versions(index, coordinate.artifact);
+  }
+};
+
+// src/adapters/cargo/cargo-requirement.ts
+import semver7 from "semver";
+var SIMPLE = /^(\^|~|=)?\s*(\d+(?:\.\d+){0,2})$/;
+function toSemverRange(requirement) {
+  const parts = requirement.split(",").map((p) => p.trim());
+  if (parts.some((p) => p === "")) return null;
+  const converted = parts.map((part) => {
+    const bare = part.match(/^\d/);
+    return bare ? `^${part}` : part;
+  });
+  return semver7.validRange(converted.join(" ")) ? converted.join(" ") : null;
+}
+function satisfiesRequirement(requirement, version) {
+  const range = toSemverRange(requirement);
+  return range !== null && semver7.satisfies(version, range, { includePrerelease: false });
+}
+function isUpgradableRequirement(requirement) {
+  return SIMPLE.test(requirement.trim());
+}
+function requirementFloor(requirement) {
+  const range = toSemverRange(requirement);
+  return range ? semver7.minVersion(range)?.version ?? null : null;
+}
+function rewriteRequirement(current, target) {
+  const match = current.trim().match(SIMPLE);
+  if (!match) return target;
+  if (semver7.prerelease(target)) return `${match[1] ?? ""}${target}`;
+  const precision = match[2].split(".").length;
+  const [major, minor, patch] = target.split(/[-+]/)[0].split(".");
+  const written = [major, minor, patch].slice(0, precision).join(".");
+  return `${match[1] ?? ""}${written}`;
+}
+function cargoDiff(from, to) {
+  const a = semver7.parse(from);
+  const b = semver7.parse(to);
+  if (!a || !b) return "minor";
+  if (a.major > 0 || b.major > a.major) {
+    if (b.major !== a.major) return "major";
+    return b.minor !== a.minor ? "minor" : "patch";
+  }
+  if (a.minor > 0) {
+    if (b.minor !== a.minor) return "major";
+    return "minor";
+  }
+  return "major";
+}
+
+// src/adapters/cargo/cargo-scanner.ts
+import { readFileSync as readFileSync11 } from "fs";
+import { join as join11, relative as relative4 } from "path";
+import semver8 from "semver";
+
+// src/adapters/cargo/cargo-toml.ts
+import { parseTOML as parseTOML2 } from "toml-eslint-parser";
+var SECTIONS2 = {
+  dependencies: "dependencies",
+  "dev-dependencies": "dev-dependencies",
+  dev_dependencies: "dev-dependencies",
+  "build-dependencies": "build-dependencies",
+  build_dependencies: "build-dependencies"
+};
+function parseCargoManifest(source) {
+  const root = parseTOML2(source).body[0];
+  const leaves = [];
+  const keyPath = (key) => key.keys.map((k) => k.type === "TOMLBare" ? k.name : k.value);
+  const visitPair = (prefix, pair) => {
+    const path = [...prefix, ...keyPath(pair.key)];
+    leaves.push({ path, node: pair.value });
+    if (pair.value.type === "TOMLInlineTable") for (const inner of pair.value.body) visitPair(path, inner);
+  };
+  for (const element of root.body) {
+    if (element.type === "TOMLKeyValue") visitPair([], element);
+    else if (element.type === "TOMLTable") {
+      const header = keyPath(element.key);
+      for (const pair of element.body) visitPair(header, pair);
+      leaves.push({ path: header, node: element });
+    }
+  }
+  const byKey = /* @__PURE__ */ new Map();
+  for (const { path, node } of leaves) {
+    const located = locateSection(path);
+    if (!located || located.rest.length === 0) continue;
+    const [key, field] = located.rest;
+    const id = `${located.inWorkspace}|${located.target ?? ""}|${located.section}|${key}`;
+    let decl = byKey.get(id);
+    if (!decl) {
+      decl = { key, section: located.section, target: located.target, inWorkspace: located.inWorkspace, inherited: false };
+      byKey.set(id, decl);
+    }
+    if (located.rest.length === 1 && node.type === "TOMLValue" && node.kind === "string") {
+      decl.version = literalOf(node);
+    } else if (field === "version" && located.rest.length === 2 && node.type === "TOMLValue" && node.kind === "string") {
+      decl.version = literalOf(node);
+    } else if (field === "workspace" && located.rest.length === 2 && node.value === true) {
+      decl.inherited = true;
+    } else if (field === "package" && located.rest.length === 2 && node.type === "TOMLValue") {
+      decl.package = String(node.value);
+    }
+  }
+  return [...byKey.values()];
+}
+function literalOf(node) {
+  return { value: node.value, start: node.range[0] + 1, end: node.range[1] - 1 };
+}
+function locateSection(path) {
+  let i = 0;
+  let target;
+  let inWorkspace = false;
+  if (path[0] === "workspace" && path[1] === "dependencies") {
+    return { section: "dependencies", inWorkspace: true, target, rest: path.slice(2) };
+  }
+  if (path[0] === "target" && path.length >= 3) {
+    target = path[1];
+    i = 2;
+  }
+  const section = SECTIONS2[path[i] ?? ""];
+  if (!section) return void 0;
+  return { section, inWorkspace, target, rest: path.slice(i + 1) };
+}
+
+// src/adapters/cargo/cargo-lockfile.ts
+import { existsSync as existsSync7, readFileSync as readFileSync10 } from "fs";
+import { getStaticTOMLValue as getStaticTOMLValue2, parseTOML as parseTOML3 } from "toml-eslint-parser";
+function readLockedVersions(lockFile) {
+  const locked = /* @__PURE__ */ new Map();
+  if (!existsSync7(lockFile)) return locked;
+  try {
+    const data = getStaticTOMLValue2(parseTOML3(readFileSync10(lockFile, "utf8")));
+    for (const pkg of data.package ?? []) locked.set(pkg.name, [...locked.get(pkg.name) ?? [], pkg.version]);
+  } catch {
+  }
+  return locked;
+}
+
+// src/adapters/cargo/cargo-scanner.ts
+var CONCURRENCY2 = 6;
+var DIFF_ORDER2 = { major: 0, minor: 1, patch: 2 };
+var CargoDependencyAdapter = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async scan(module, context) {
+    const metadata = await this.deps.loadMetadata(module.aggregatorDir ?? module.path);
+    const pkg = metadata.packages.find((p) => samePath(join11(p.manifest_path, ".."), module.path));
+    if (!pkg) return { candidates: [], skipped: [] };
+    const own = readDeclarations(pkg.manifest_path);
+    const locks = readLockedVersions(join11(metadata.workspace_root, "Cargo.lock"));
+    const rootManifest = join11(metadata.workspace_root, "Cargo.toml");
+    const root = readDeclarations(rootManifest);
+    const groups = groupDependencies(pkg.dependencies);
+    const outcomes = await mapPooled(groups, CONCURRENCY2, async (group) => {
+      const primary = group.find((d) => d.kind === null) ?? group[0];
+      const key = primary.rename ?? primary.name;
+      const decl = findDeclaration(own, key, primary);
+      const located = locate(decl, root, key, context.rootDir, pkg.manifest_path, rootManifest);
+      const scope = group.every((d) => d.kind === "dev") ? "dev" : "prod";
+      const qualifier = primary.target ?? (primary.kind === "build" ? "build" : void 0);
+      const common = { scope, qualifier };
+      if (primary.source === null && primary.path) {
+        const target = [...context.workspace.values()].find((m) => samePath(m.path, primary.path));
+        return target ? alignment(primary, target, located, common) : null;
+      }
+      if (!primary.source || primary.source.startsWith("git+")) return null;
+      const outcome = await this.registryOutcome(primary, located, pkg, metadata, locks, common, context);
+      const other = group.find((d) => d !== primary && !sameRequirement(d.req, primary.req));
+      if (outcome && "candidate" in outcome && other) {
+        outcome.note = {
+          identifier: primary.name,
+          origin: outcome.candidate.origin.kind,
+          reason: "declaration-mismatch",
+          detail: `${sectionOf(other)} requires ${other.req}; it is not changed`
+        };
+      }
+      return outcome;
+    });
+    const candidates = [];
+    const skipped = [];
+    for (const outcome of outcomes) {
+      if (!outcome) continue;
+      if ("candidate" in outcome) {
+        candidates.push(outcome.candidate);
+        if (outcome.note) skipped.push(outcome.note);
+      } else skipped.push(outcome.skipped);
+    }
+    candidates.sort((a, b) => (DIFF_ORDER2[a.diff] ?? 3) - (DIFF_ORDER2[b.diff] ?? 3));
+    return { candidates, skipped };
+  }
+  async registryOutcome(dep, located, pkg, metadata, locks, common, context) {
+    const literal = located?.version.value ?? dep.req;
+    if (!isUpgradableRequirement(literal)) return null;
+    if (!located || !sameRequirement(located.version.value, dep.req)) {
+      return { skipped: { identifier: dep.name, origin: "public", reason: "declaration-mismatch", detail: `${literal} in the manifest, ${dep.req} for Cargo` } };
+    }
+    let origin = { kind: "public" };
+    if (dep.registry) origin = { kind: "private", matchedBy: "scoped-registry", registry: dep.registry };
+    else if (matchesInternalScope(dep.name, "cargo", context.internalScopes)) origin = { kind: "private", matchedBy: "internal-scope" };
+    const endpoint = await this.deps.endpoint(dep.registry ?? void 0, context.rootDir);
+    if (origin.kind === "private" && endpoint.isPublic) {
+      return { skipped: { identifier: dep.name, origin: "private", reason: "private-on-public-registry", detail: endpoint.index } };
+    }
+    let versions;
+    try {
+      versions = await this.deps.index.versions(endpoint.index, dep.name);
+    } catch (err) {
+      return { skipped: { identifier: dep.name, origin: origin.kind, reason: "lookup-failed", detail: err instanceof Error ? err.message : String(err) } };
+    }
+    const chosen = selectVersion(versions, { channel: context.channel, rustVersion: pkg.rust_version ?? void 0 });
+    const floor = requirementFloor(literal);
+    if (!chosen.version) {
+      if (chosen.blockedByMsrv && floor) {
+        const { version, requires } = chosen.blockedByMsrv;
+        return { skipped: { identifier: dep.name, origin: origin.kind, reason: "incompatible-rust-version", detail: ` (${version} needs Rust ${requires})` } };
+      }
+      return { skipped: { identifier: dep.name, origin: origin.kind, reason: "lookup-failed", detail: "no usable version in the registry" } };
+    }
+    const latest = chosen.version;
+    if (!floor || !semver8.gt(latest, floor)) {
+      const held = chosen.blockedByMsrv;
+      if (floor && held && semver8.gt(held.version, floor)) {
+        return { skipped: { identifier: dep.name, origin: origin.kind, reason: "incompatible-rust-version", detail: ` (${held.version} needs Rust ${held.requires})` } };
+      }
+      return null;
+    }
+    const newRange = rewriteRequirement(literal, latest);
+    if (newRange === literal) return lockOutcome(dep, literal, origin, versions, pkg, metadata, locks, common, context);
+    const tag = semver8.prerelease(latest) ? extractPreReleaseTag(latest) ?? "PRE" : void 0;
+    const diff = cargoDiff(floor, latest);
+    const candidate = {
+      coordinate: { identifier: dep.name, artifact: dep.name, ecosystem: "cargo", ...dep.registry ? { registry: dep.registry } : {} },
+      currentRange: literal,
+      currentClean: floor,
+      latest,
+      newRange,
+      diff,
+      scope: common.scope,
+      selected: diff !== "major",
+      origin,
+      action: "update",
+      declaration: located.declaration,
+      isPreRelease: tag !== void 0,
+      preReleaseTag: tag,
+      ...common.qualifier ? { qualifier: common.qualifier } : {},
+      ...located.inherited ? { sharedWith: sharersOf(metadata, pkg, dep.rename ?? dep.name) } : {}
+    };
+    return { candidate };
+  }
+};
+function lockOutcome(dep, requirement, origin, versions, pkg, metadata, locks, common, context) {
+  const locked = (locks.get(dep.name) ?? []).filter((v) => satisfiesRequirement(requirement, v)).sort(semver8.rcompare)[0];
+  if (!locked) return null;
+  const options = { channel: context.channel, rustVersion: pkg.rust_version ?? void 0 };
+  const allowed = versions.filter((v) => satisfiesRequirement(requirement, v.version));
+  const newer = eligibleVersions(allowed, options).filter((v) => semver8.gt(v, locked));
+  const latest = newer[0];
+  if (!latest) return null;
+  const lockFile = join11(metadata.workspace_root, "Cargo.lock");
+  return {
+    candidate: {
+      coordinate: { identifier: dep.name, artifact: dep.name, ecosystem: "cargo", ...dep.registry ? { registry: dep.registry } : {} },
+      currentRange: locked,
+      currentClean: locked,
+      latest,
+      newRange: latest,
+      diff: cargoDiff(locked, latest),
+      scope: common.scope,
+      // A release the requirement allows is compatible by definition, so it is safe to preselect.
+      selected: true,
+      origin,
+      action: "lock",
+      declaration: { file: lockFile, kind: "lockfile", displayPath: display(context.rootDir, lockFile) },
+      availableVersions: newer,
+      ...common.qualifier ? { qualifier: common.qualifier } : {}
+    }
+  };
+}
+function alignment(dep, target, located, common) {
+  const local = target.version;
+  if (!located || !local || !semver8.valid(local)) return null;
+  const literal = located.version.value;
+  if (!isUpgradableRequirement(literal) || satisfiesRequirement(literal, local)) return null;
+  const floor = requirementFloor(literal) ?? "0.0.0";
+  const diff = cargoDiff(floor, local);
+  const tag = semver8.prerelease(local) ? extractPreReleaseTag(local) ?? "PRE" : void 0;
+  return {
+    candidate: {
+      coordinate: { identifier: dep.name, artifact: dep.name, ecosystem: "cargo" },
+      currentRange: literal,
+      currentClean: floor,
+      latest: local,
+      newRange: rewriteRequirement(literal, local),
+      diff,
+      scope: common.scope,
+      selected: diff !== "major",
+      origin: { kind: "workspace", moduleId: target.id, moduleRelPath: target.relPath },
+      action: "align",
+      declaration: located.declaration,
+      availableVersions: [local],
+      isPreRelease: tag !== void 0,
+      preReleaseTag: tag,
+      ...common.qualifier ? { qualifier: common.qualifier } : {}
+    }
+  };
+}
+function groupDependencies(deps) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const dep of deps) {
+    const id = `${dep.rename ?? dep.name}`;
+    groups.set(id, [...groups.get(id) ?? [], dep]);
+  }
+  return [...groups.values()];
+}
+function readDeclarations(manifestPath) {
+  try {
+    return parseCargoManifest(readFileSync11(manifestPath, "utf8"));
+  } catch {
+    return [];
+  }
+}
+var sectionOf = (dep) => dep.kind === "dev" ? "dev-dependencies" : dep.kind === "build" ? "build-dependencies" : "dependencies";
+function findDeclaration(decls, key, dep) {
+  const candidates = decls.filter((d) => !d.inWorkspace && d.key === key);
+  return candidates.find((d) => d.section === sectionOf(dep) && (d.target ?? null) === dep.target) ?? candidates[0];
+}
+function locate(decl, root, key, repoRoot, manifestPath, rootManifest) {
+  if (!decl) return void 0;
+  if (decl.inherited) {
+    const shared = root.find((d) => d.inWorkspace && d.key === key);
+    if (!shared?.version) return void 0;
+    return {
+      version: shared.version,
+      inherited: true,
+      declaration: { file: rootManifest, kind: "dependency-management", displayPath: display(repoRoot, rootManifest) }
+    };
+  }
+  if (!decl.version) return void 0;
+  return {
+    version: decl.version,
+    inherited: false,
+    declaration: { file: manifestPath, kind: "dependency", displayPath: display(repoRoot, manifestPath) }
+  };
+}
+function sharersOf(metadata, self, key) {
+  return metadata.packages.filter((p) => p !== self).filter((p) => readDeclarations(p.manifest_path).some((d) => d.key === key && d.inherited)).map((p) => p.name);
+}
+var display = (repoRoot, file) => relative4(repoRoot, file).replace(/\\/g, "/");
+var samePath = (a, b) => relative4(a, b) === "";
+function sameRequirement(literal, req) {
+  const a = toSemverRange(literal);
+  const b = toSemverRange(req);
+  return a !== null && b !== null && semver8.validRange(a) === semver8.validRange(b);
+}
+
+// src/adapters/cargo/cargo-updater.ts
+import { existsSync as existsSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync2 } from "fs";
+import { join as join12, resolve as resolve6 } from "path";
+import semver9 from "semver";
 
 // src/adapters/shared/xml.ts
 import { SaxesParser } from "saxes";
@@ -1192,9 +1997,241 @@ function localName(qualified) {
   return colon >= 0 ? qualified.slice(colon + 1) : qualified;
 }
 
+// src/adapters/shared/text-edit.ts
+function applyRangeEdits(source, edits) {
+  for (const edit of edits) {
+    const found = source.slice(edit.start, edit.end);
+    if (found !== edit.expected) {
+      throw new StaleEditError(`Found '${found}', expected '${edit.expected}'. The file changed since it was scanned.`);
+    }
+  }
+  const ordered = [...edits].sort((a, b) => b.start - a.start);
+  for (let i = 1; i < ordered.length; i++) {
+    if (ordered[i].end > ordered[i - 1].start) throw new StaleEditError("Overlapping edits on the same text.");
+  }
+  let result = source;
+  for (const edit of ordered) result = result.slice(0, edit.start) + edit.replacement + result.slice(edit.end);
+  return result;
+}
+
+// src/adapters/cargo/cargo-updater.ts
+var UPDATE_TIMEOUT_MS = 10 * 6e4;
+var workspaceDir = (module, rootDir) => module.aggregatorDir ?? module.path ?? rootDir;
+var CargoUpdaterAdapter = class {
+  affectedFiles(module, rootDir, updates) {
+    const files = new Set(updates.map((u) => resolve6(u.declaration?.file ?? join12(module.path, "Cargo.toml"))));
+    files.add(join12(workspaceDir(module, rootDir), "Cargo.lock"));
+    return [...files];
+  }
+  async applyUpdates(module, rootDir, updates, onProgress) {
+    const dir = workspaceDir(module, rootDir);
+    const lockFile = join12(dir, "Cargo.lock");
+    const lockedBefore = readLockedVersions(lockFile);
+    const lockUpdates = updates.filter((u) => u.action === "lock");
+    updates = updates.filter((u) => u.action !== "lock");
+    this.checkLockUpdates(lockUpdates, lockFile, lockedBefore);
+    const byFile = /* @__PURE__ */ new Map();
+    for (const update of updates) {
+      const file = resolve6(update.declaration?.file ?? join12(module.path, "Cargo.toml"));
+      byFile.set(file, [...byFile.get(file) ?? [], update]);
+    }
+    const writes = [];
+    for (const [file, fileUpdates] of byFile) {
+      onProgress(`Preparing ${fileUpdates.length} change(s) in ${file}\u2026`);
+      const source = readFileSync12(file, "utf8");
+      const decls = parseCargoManifest(source);
+      const edits = [];
+      for (const update of fileUpdates) {
+        const inWorkspace = update.declaration?.kind === "dependency-management";
+        const name = update.coordinate.identifier;
+        const found = decls.filter(
+          (d) => d.inWorkspace === inWorkspace && (d.package ?? d.key) === name && d.version?.value === update.currentRange
+        );
+        if (found.length === 0) {
+          throw new InstallError(`${file}: cannot find the version of ${name} (${update.currentRange}) any more; rescan the module.`);
+        }
+        for (const d of found) {
+          edits.push({ start: d.version.start, end: d.version.end, expected: d.version.value, replacement: update.newRange });
+        }
+      }
+      try {
+        writes.push({ file, content: applyRangeEdits(source, edits) });
+      } catch (err) {
+        if (err instanceof StaleEditError) throw new InstallError(`${file}: ${err.message}`);
+        throw err;
+      }
+    }
+    onProgress("Writing Cargo.toml files\u2026");
+    for (const write of writes) writeFileSync2(write.file, write.content, "utf8");
+    const registryUpdates = updates.filter((u) => u.action === "update");
+    if (existsSync8(lockFile) && registryUpdates.length > 0) {
+      await this.refreshLock(dir, lockFile, lockedBefore, registryUpdates, onProgress);
+    }
+    for (const update of lockUpdates) {
+      const name = update.coordinate.identifier;
+      onProgress(`Locking ${name} at ${update.latest}\u2026`);
+      await this.cargoUpdate(dir, ["-p", `${name}@${update.currentClean}`, "--precise", update.latest]);
+    }
+    const parts = [];
+    if (updates.length > 0) {
+      parts.push(`Updated ${updates.length} requirement(s) in ${writes.length} Cargo.toml file(s)${existsSync8(lockFile) ? "; Cargo.lock refreshed" : ""}`);
+    }
+    if (lockUpdates.length > 0) parts.push(`locked ${lockUpdates.length} crate(s) at a newer version in Cargo.lock`);
+    const message2 = parts.join("; ");
+    return {
+      updatedCount: updates.length + lockUpdates.length,
+      auditMessage: `${message2.charAt(0).toUpperCase()}${message2.slice(1)}.`,
+      auditSeverity: "clean",
+      integrityViolations: []
+    };
+  }
+  /** A lock-only update needs a lock file that still holds the version the scan saw. */
+  checkLockUpdates(lockUpdates, lockFile, locked) {
+    if (lockUpdates.length === 0) return;
+    if (!existsSync8(lockFile)) {
+      throw new InstallError(`${lockFile} does not exist any more; rescan the module.`);
+    }
+    for (const update of lockUpdates) {
+      const name = update.coordinate.identifier;
+      if (!(locked.get(name) ?? []).includes(update.currentClean)) {
+        throw new InstallError(`Cargo.lock no longer locks ${name} at ${update.currentClean}; rescan the module.`);
+      }
+    }
+  }
+  async resync() {
+  }
+  async refreshLock(dir, lockFile, before, updates, onProgress) {
+    const specs = [];
+    for (const update of updates) {
+      const name = update.coordinate.identifier;
+      const versions = before.get(name) ?? [];
+      const old = versions.find((v) => satisfiesRequirement(update.currentRange, v)) ?? versions[0];
+      if (old) specs.push(`${name}@${old}`);
+    }
+    if (specs.length === 0) return;
+    onProgress("Updating Cargo.lock\u2026");
+    await this.cargoUpdate(dir, specs.flatMap((s) => ["-p", s]));
+    const after = readLockedVersions(lockFile);
+    for (const update of updates) {
+      const name = update.coordinate.identifier;
+      const locked = (after.get(name) ?? []).find((v) => satisfiesRequirement(update.newRange, v));
+      if (locked && semver9.valid(update.latest) && locked !== update.latest) {
+        onProgress(`Pinning ${name} to ${update.latest}\u2026`);
+        await this.cargoUpdate(dir, ["-p", `${name}@${locked}`, "--precise", update.latest]);
+      }
+    }
+  }
+  async cargoUpdate(dir, args) {
+    const result = await runCommand("cargo", ["update", ...args], { cwd: dir, timeoutMs: UPDATE_TIMEOUT_MS });
+    if (result.exitCode !== 0) {
+      const reason = result.timedOut ? "cargo update timed out" : "cargo update failed";
+      throw new InstallError(reason, tail(result.stderr || result.stdout));
+    }
+  }
+};
+
+// src/adapters/cargo/cargo-verifier.ts
+import { existsSync as existsSync9 } from "fs";
+import { join as join13, relative as relative5, resolve as resolve7 } from "path";
+var VERIFY_TIMEOUT_MS2 = 30 * 6e4;
+var same = (a, b) => relative5(resolve7(a), resolve7(b)) === "";
+function planCheck(metadata, module, changedFiles, locked) {
+  const args = ["check", "--all-targets", ...locked ? ["--locked"] : []];
+  const rootManifest = join13(metadata.workspace_root, "Cargo.toml");
+  const lockFile = join13(metadata.workspace_root, "Cargo.lock");
+  const memberManifests = new Set(metadata.packages.map((p) => resolve7(p.manifest_path)));
+  if (changedFiles.some((f) => same(f, rootManifest))) {
+    const isVirtualRoot = !memberManifests.has(resolve7(rootManifest));
+    if (isVirtualRoot || metadata.packages.length > 1) return [...args, "--workspace"];
+  }
+  if (changedFiles.length > 0 && changedFiles.every((f) => same(f, lockFile))) return [...args, "--workspace"];
+  const changed = new Set(
+    metadata.packages.filter((p) => changedFiles.some((f) => same(f, p.manifest_path))).map((p) => p.name)
+  );
+  if (changed.size === 0) changed.add(module.id);
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const p of metadata.packages) {
+      if (changed.has(p.name)) continue;
+      if (p.dependencies.some((d) => d.source === null && d.path && changed.has(d.name))) {
+        changed.add(p.name);
+        grew = true;
+      }
+    }
+  }
+  const ordered = metadata.packages.filter((p) => changed.has(p.name)).map((p) => p.name);
+  return [...args, ...ordered.flatMap((name) => ["-p", name])];
+}
+var CargoVerificationAdapter = class {
+  constructor(deps = { loadMetadata, hasLock: (dir) => existsSync9(join13(dir, "Cargo.lock")) }) {
+    this.deps = deps;
+  }
+  deps;
+  async verify(module, rootDir, options = {}) {
+    const dir = module.aggregatorDir ?? module.path ?? rootDir;
+    if (options.customScript) {
+      const label2 = options.customLabel || options.customScript;
+      const result2 = await runShellScript(options.customScript, { cwd: dir, timeoutMs: VERIFY_TIMEOUT_MS2 });
+      return result2.exitCode === 0 ? { status: "clean", details: "Verification script succeeded.", label: label2 } : { status: "warn", details: tail(result2.stderr || result2.stdout), label: label2 };
+    }
+    const metadata = await this.deps.loadMetadata(dir);
+    const args = planCheck(metadata, module, options.changedFiles ?? [], this.deps.hasLock(dir));
+    const label = `Cargo build (cargo ${args.join(" ")})`;
+    const result = await runCargo(args, { cwd: dir, timeoutMs: VERIFY_TIMEOUT_MS2 });
+    if (result.exitCode === 0) return { status: "clean", details: "All affected crates type-check, including tests.", label };
+    return {
+      status: "warn",
+      details: result.timedOut ? "cargo check timed out." : cargoErrors(`${result.stderr}
+${result.stdout}`),
+      label
+    };
+  }
+};
+
+// src/adapters/cargo/cargo-strategy.ts
+var cargoVersionPolicy = {
+  normalize: (v) => semver10.valid(v),
+  rewrite: rewriteRequirement,
+  diff: (current, target) => semver10.valid(current) && semver10.valid(target) ? semver10.eq(current, target) ? "patch" : cargoDiff(current, target) : "minor",
+  // Updates are written where the scan found the declaration.
+  allowsManualTargets: false
+};
+var CargoEcosystemStrategy = class {
+  ecosystem = "cargo";
+  displayName = "Rust / Cargo";
+  icon = "\u{1F980}";
+  manifestFile = "Cargo.toml";
+  versioning = cargoVersionPolicy;
+  config = new CargoConfigReader();
+  index = new CargoIndexClient();
+  endpoint = (registry, cwd) => this.config.resolve(registry, cwd);
+  discovery = new CargoModuleDiscoveryAdapter();
+  registry = new CargoRegistryAdapter({ index: this.index, endpoint: this.endpoint });
+  reader = new CargoDependencyAdapter({ loadMetadata, index: this.index, endpoint: this.endpoint });
+  updater = new CargoUpdaterAdapter();
+  verifier = new CargoVerificationAdapter();
+  getTabLabels(counts, t) {
+    return {
+      all: t.tabs.all(counts.total),
+      prod: t.tabs.dependencies(counts.prodCount),
+      dev: t.tabs.devDependencies(counts.devCount)
+    };
+  }
+};
+
+// src/adapters/maven/maven-discovery.ts
+import { existsSync as existsSync12 } from "fs";
+import { dirname as dirname7, join as join16, relative as relative6, resolve as resolve10 } from "path";
+
+// src/adapters/maven/maven-project.ts
+import { existsSync as existsSync11, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join15, resolve as resolve9 } from "path";
+
 // src/adapters/maven/maven-pom.ts
+import { existsSync as existsSync10, readFileSync as readFileSync13, statSync } from "fs";
+import { dirname as dirname6, join as join14, resolve as resolve8 } from "path";
 function readPom(file) {
-  const source = readFileSync8(file, "utf8");
+  const source = readFileSync13(file, "utf8");
   return parsePom(source, file);
 }
 function parsePom(source, file) {
@@ -1213,7 +2250,7 @@ function parsePom(source, file) {
   }
   return {
     file,
-    dir: dirname4(file),
+    dir: dirname6(file),
     groupId: childText(project, "groupId"),
     artifactId: childText(project, "artifactId") ?? "unknown",
     version: childText(project, "version"),
@@ -1242,9 +2279,9 @@ function parentPomFile(pom) {
   if (!pom.parent) return void 0;
   const relativePath = pom.parent.relativePath ?? "../pom.xml";
   if (relativePath === "") return void 0;
-  let candidate = resolve4(pom.dir, relativePath);
-  if (existsSync5(candidate) && statSync(candidate).isDirectory()) candidate = join9(candidate, "pom.xml");
-  return existsSync5(candidate) ? candidate : void 0;
+  let candidate = resolve8(pom.dir, relativePath);
+  if (existsSync10(candidate) && statSync(candidate).isDirectory()) candidate = join14(candidate, "pom.xml");
+  return existsSync10(candidate) ? candidate : void 0;
 }
 function builtinProperty(name, module) {
   switch (name) {
@@ -1319,9 +2356,9 @@ var MavenProject = class _MavenProject {
       }
       poms.push(pom);
       for (const entry of pom.modules) {
-        const target = resolve5(pom.dir, entry);
-        const moduleFile = target.endsWith(".xml") ? target : join10(target, "pom.xml");
-        if (!seen.has(moduleFile) && existsSync6(moduleFile)) {
+        const target = resolve9(pom.dir, entry);
+        const moduleFile = target.endsWith(".xml") ? target : join15(target, "pom.xml");
+        if (!seen.has(moduleFile) && existsSync11(moduleFile)) {
           seen.add(moduleFile);
           queue.push(moduleFile);
         }
@@ -1330,7 +2367,7 @@ var MavenProject = class _MavenProject {
     return new _MavenProject(rootDir, poms);
   }
   pomAt(file) {
-    return this.byFile.get(resolve5(file));
+    return this.byFile.get(resolve9(file));
   }
   /** The project followed by its local parents, stopping at the first external parent. */
   chainOf(pom) {
@@ -1373,7 +2410,7 @@ var MavenProject = class _MavenProject {
       return groupId === parent.groupId && candidate.artifactId === parent.artifactId && (version.includes("${") || expected.includes("${") || version === expected);
     };
     const file = parentPomFile(pom);
-    const byPath = file ? this.byFile.get(resolve5(file)) : void 0;
+    const byPath = file ? this.byFile.get(resolve9(file)) : void 0;
     return matches(byPath) ? byPath : void 0;
   }
   /**
@@ -1390,8 +2427,8 @@ var MavenProject = class _MavenProject {
         if (this.aggregators.has(pom.file)) continue;
         this.aggregators.set(pom.file, aggregator.dir);
         for (const entry of pom.modules) {
-          const target = resolve5(pom.dir, entry);
-          const file = target.endsWith(".xml") ? target : join10(target, "pom.xml");
+          const target = resolve9(pom.dir, entry);
+          const file = target.endsWith(".xml") ? target : join15(target, "pom.xml");
           const modulePom = this.byFile.get(file);
           if (modulePom) queue.push(modulePom);
         }
@@ -1401,23 +2438,23 @@ var MavenProject = class _MavenProject {
 };
 function findPomFiles(rootDir) {
   const results = [];
-  const rootPom = join10(rootDir, "pom.xml");
-  if (existsSync6(rootPom)) results.push(resolve5(rootPom));
+  const rootPom = join15(rootDir, "pom.xml");
+  if (existsSync11(rootPom)) results.push(resolve9(rootPom));
   const walk = (dir, depth) => {
     if (depth > MAX_DEPTH) return;
     let entries2;
     try {
-      entries2 = readdirSync(dir, { withFileTypes: true });
+      entries2 = readdirSync2(dir, { withFileTypes: true });
     } catch {
       return;
     }
-    const isProject = existsSync6(join10(dir, "pom.xml"));
+    const isProject = existsSync11(join15(dir, "pom.xml"));
     for (const entry of entries2) {
       if (!entry.isDirectory() || entry.name.startsWith(".") || SKIPPED_DIRS.has(entry.name)) continue;
       if (isProject && entry.name === "src") continue;
-      const subDir = join10(dir, entry.name);
-      const pom = join10(subDir, "pom.xml");
-      if (existsSync6(pom) && statSync2(pom).isFile()) results.push(resolve5(pom));
+      const subDir = join15(dir, entry.name);
+      const pom = join15(subDir, "pom.xml");
+      if (existsSync11(pom) && statSync2(pom).isFile()) results.push(resolve9(pom));
       walk(subDir, depth + 1);
     }
   };
@@ -1432,9 +2469,9 @@ var MavenModuleDiscoveryAdapter = class {
    * the POM above until there is none: the top of the connected POM chain.
    */
   findRoot(startDir, boundaryDir) {
-    let dir = resolve6(startDir);
-    if (!existsSync7(join11(dir, "pom.xml"))) return void 0;
-    const boundary = boundaryDir ? resolve6(boundaryDir) : void 0;
+    let dir = resolve10(startDir);
+    if (!existsSync12(join16(dir, "pom.xml"))) return void 0;
+    const boundary = boundaryDir ? resolve10(boundaryDir) : void 0;
     for (; ; ) {
       const above = pomAbove(dir, boundary);
       if (!above) return dir;
@@ -1445,7 +2482,7 @@ var MavenModuleDiscoveryAdapter = class {
     const project = MavenProject.load(rootDir);
     const modules = project.poms.map((pom) => {
       const coordinates = project.coordinatesOf(pom);
-      const relPath = relative3(rootDir, pom.dir).replace(/\\/g, "/");
+      const relPath = relative6(rootDir, pom.dir).replace(/\\/g, "/");
       return {
         id: coordinates.groupId ? `${coordinates.groupId}:${coordinates.artifactId}` : coordinates.artifactId,
         name: pom.name ? interpolate(pom.name, project.chainOf(pom).poms) : pom.artifactId,
@@ -1472,7 +2509,7 @@ function ancestorsWithin(dir, boundary) {
   const result = [];
   let current = dir;
   while (current !== boundary) {
-    const parent = dirname5(current);
+    const parent = dirname7(current);
     if (parent === current) break;
     result.push(parent);
     current = parent;
@@ -1480,22 +2517,22 @@ function ancestorsWithin(dir, boundary) {
   return result;
 }
 function pomAbove(dir, boundary) {
-  const pom = tryReadPom(join11(dir, "pom.xml"));
+  const pom = tryReadPom(join16(dir, "pom.xml"));
   if (!pom) return void 0;
   const ancestors = ancestorsWithin(dir, boundary);
   const found = [];
   const parentFile = parentPomFile(pom);
-  if (parentFile && pom.parent && ancestors.includes(dirname5(parentFile))) {
+  if (parentFile && pom.parent && ancestors.includes(dirname7(parentFile))) {
     const parent = tryReadPom(parentFile);
     const groupId = parent?.groupId ?? parent?.parent?.groupId;
     if (parent && parent.artifactId === pom.parent.artifactId && groupId === pom.parent.groupId) {
-      found.push(dirname5(parentFile));
+      found.push(dirname7(parentFile));
     }
   }
-  const ownFile = join11(dir, "pom.xml");
+  const ownFile = join16(dir, "pom.xml");
   const aggregator = ancestors.find(
-    (ancestor) => tryReadPom(join11(ancestor, "pom.xml"))?.modules.some((entry) => {
-      const target = resolve6(ancestor, entry);
+    (ancestor) => tryReadPom(join16(ancestor, "pom.xml"))?.modules.some((entry) => {
+      const target = resolve10(ancestor, entry);
       return target === dir || target === ownFile;
     })
   );
@@ -1504,12 +2541,12 @@ function pomAbove(dir, boundary) {
 }
 
 // src/adapters/maven/maven-registry.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join19 } from "path";
 
 // src/adapters/maven/maven-command.ts
-import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname6, isAbsolute, join as join12, relative as relative4, resolve as resolve7, sep } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join17, relative as relative7, resolve as resolve11, sep } from "path";
 var MavenUnavailableError = class extends Error {
   constructor() {
     super("Maven is not available: no Maven Wrapper (mvnw) in the project and no `mvn` on the PATH.");
@@ -1529,27 +2566,27 @@ var WRAPPER = IS_WINDOWS2 ? "mvnw.cmd" : "mvnw";
 var BATCH_ARGS = ["-B", "--no-transfer-progress"];
 var mvnOnPath;
 function findMavenWrapper(fromDir, rootDir) {
-  let dir = resolve7(fromDir);
-  const root = resolve7(rootDir);
+  let dir = resolve11(fromDir);
+  const root = resolve11(rootDir);
   for (; ; ) {
-    const candidate = join12(dir, WRAPPER);
-    if (existsSync8(candidate)) return candidate;
-    if (dir === root || relative4(root, dir).startsWith("..")) return void 0;
-    const parent = dirname6(dir);
+    const candidate = join17(dir, WRAPPER);
+    if (existsSync13(candidate)) return candidate;
+    if (dir === root || relative7(root, dir).startsWith("..")) return void 0;
+    const parent = dirname8(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
 function relativeToCwd(cwd, file) {
-  const path = relative4(cwd, file);
-  return isAbsolute(path) ? file : path || ".";
+  const path = relative7(cwd, file);
+  return isAbsolute2(path) ? file : path || ".";
 }
 async function runMaven(args, options) {
   const wrapper = findMavenWrapper(options.cwd, options.rootDir);
   const run = { cwd: options.cwd, timeoutMs: options.timeoutMs };
   if (wrapper) {
     const relativeWrapper = relativeToCwd(options.cwd, wrapper);
-    const path = isAbsolute(relativeWrapper) || relativeWrapper.includes(sep) ? relativeWrapper : `.${sep}${relativeWrapper}`;
+    const path = isAbsolute2(relativeWrapper) || relativeWrapper.includes(sep) ? relativeWrapper : `.${sep}${relativeWrapper}`;
     return IS_WINDOWS2 ? runCommand(path, [...BATCH_ARGS, ...args], run) : runCommand("sh", [path, ...BATCH_ARGS, ...args], run);
   }
   mvnOnPath ??= runCommand("mvn", ["-v"], { cwd: options.cwd, timeoutMs: 3e4 }).then(
@@ -1566,8 +2603,8 @@ function mavenErrors(output) {
 
 // src/adapters/maven/maven-resolution.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync9, mkdirSync, readFileSync as readFileSync9, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, mkdirSync, readFileSync as readFileSync14, readdirSync as readdirSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join18 } from "path";
 var DEFAULT_MAVEN_PLUGINS = { help: "3.5.2", versions: "2.22.0" };
 var HELP_PLUGIN_ID = "org.apache.maven.plugins:maven-help-plugin";
 var VERSIONS_PLUGIN_ID = "org.codehaus.mojo:versions-maven-plugin";
@@ -1599,21 +2636,21 @@ var ScratchDirectory = class {
   target;
   createdTarget;
   constructor(moduleDir) {
-    this.target = join13(moduleDir, "target");
-    this.createdTarget = !existsSync9(this.target);
-    this.path = join13(this.target, `.elevate-${randomUUID().slice(0, 8)}`);
+    this.target = join18(moduleDir, "target");
+    this.createdTarget = !existsSync14(this.target);
+    this.path = join18(this.target, `.elevate-${randomUUID().slice(0, 8)}`);
     mkdirSync(this.path, { recursive: true });
   }
   dispose() {
     rmSync(this.path, { recursive: true, force: true });
     try {
-      if (this.createdTarget && readdirSync2(this.target).length === 0) rmSync(this.target, { recursive: true });
+      if (this.createdTarget && readdirSync3(this.target).length === 0) rmSync(this.target, { recursive: true });
     } catch {
     }
   }
 };
 async function readEffectivePoms(pomFile, moduleDir, rootDir, scratch, plugins, recursive = false) {
-  const output = join13(scratch.path, "effective-pom.xml");
+  const output = join18(scratch.path, "effective-pom.xml");
   const args = [
     "-f",
     relativeToCwd(moduleDir, pomFile),
@@ -1625,7 +2662,7 @@ async function readEffectivePoms(pomFile, moduleDir, rootDir, scratch, plugins,
     rootDir,
     timeoutMs: MAVEN_TIMEOUT_MS
   });
-  if (result.exitCode !== 0 || !existsSync9(output)) {
+  if (result.exitCode !== 0 || !existsSync14(output)) {
     const text = `${result.stdout}
 ${result.stderr}`;
     if (isPluginUnavailable(text, HELP_PLUGIN_ID)) {
@@ -1637,7 +2674,7 @@ ${result.stderr}`;
     throw new MavenCommandError(`Maven could not build the effective POM:
 ${mavenErrors(text)}`, text);
   }
-  return parseEffectivePoms(readFileSync9(output, "utf8"));
+  return parseEffectivePoms(readFileSync14(output, "utf8"));
 }
 function parseEffectivePoms(source) {
   const root = parseXml(source);
@@ -1649,7 +2686,7 @@ function parseEffectivePoms(source) {
   return models;
 }
 function mergeRepositories(models) {
-  const merge = (name, pick) => {
+  const merge2 = (name, pick) => {
     const byId = /* @__PURE__ */ new Map();
     for (const element of models.map(pick)) {
       for (const repository of element?.children ?? []) {
@@ -1662,8 +2699,8 @@ function mergeRepositories(models) {
   return {
     dependencies: [],
     managedDependencies: [],
-    repositories: merge("repositories", (m) => m.repositories),
-    pluginRepositories: merge("pluginRepositories", (m) => m.pluginRepositories)
+    repositories: merge2("repositories", (m) => m.repositories),
+    pluginRepositories: merge2("pluginRepositories", (m) => m.pluginRepositories)
   };
 }
 function toEffectiveModel(project) {
@@ -1721,10 +2758,10 @@ function buildProbePom(artifacts, model) {
 }
 async function queryNewerVersions(artifacts, model, moduleDir, rootDir, scratch, plugins) {
   if (artifacts.length === 0) return { newerVersions: /* @__PURE__ */ new Map(), failedLookups: /* @__PURE__ */ new Set() };
-  const probeDir = join13(scratch.path, "probe");
+  const probeDir = join18(scratch.path, "probe");
   mkdirSync(probeDir, { recursive: true });
-  const probePom = join13(probeDir, "pom.xml");
-  writeFileSync2(probePom, buildProbePom(artifacts, model), "utf8");
+  const probePom = join18(probeDir, "pom.xml");
+  writeFileSync3(probePom, buildProbePom(artifacts, model), "utf8");
   const result = await runMaven(
     [
       "-N",
@@ -1738,8 +2775,8 @@ async function queryNewerVersions(artifacts, model, moduleDir, rootDir, scratch,
   );
   const log = `${result.stdout}
 ${result.stderr}`;
-  const reportFile = join13(probeDir, "target", "dependency-updates-report.xml");
-  if (result.exitCode !== 0 || !existsSync9(reportFile)) {
+  const reportFile = join18(probeDir, "target", "dependency-updates-report.xml");
+  if (result.exitCode !== 0 || !existsSync14(reportFile)) {
     if (isPluginUnavailable(log, VERSIONS_PLUGIN_ID)) {
       throw new MavenPluginUnavailableError(
         { id: VERSIONS_PLUGIN_ID, version: plugins.versions, key: "versions", purpose: "look up newer versions" },
@@ -1750,7 +2787,7 @@ ${result.stderr}`;
 ${mavenErrors(log)}`, log);
   }
   return {
-    newerVersions: parseUpdatesReport(readFileSync9(reportFile, "utf8")),
+    newerVersions: parseUpdatesReport(readFileSync14(reportFile, "utf8")),
     failedLookups: parseFailedLookups(log)
   };
 }
@@ -1835,18 +2872,18 @@ var MavenRegistryAdapter = class {
   }
 };
 async function projectRepositories(cwd, scratch, plugins) {
-  const rootPom = join14(cwd, "pom.xml");
-  if (!existsSync10(rootPom)) return NO_REPOSITORIES;
+  const rootPom = join19(cwd, "pom.xml");
+  if (!existsSync15(rootPom)) return NO_REPOSITORIES;
   const models = await readEffectivePoms(rootPom, cwd, cwd, scratch, plugins);
   return [...models.values()][0] ?? NO_REPOSITORIES;
 }
 
 // src/adapters/maven/maven-scanner.ts
-import { join as join15 } from "path";
-import semver4 from "semver";
+import { join as join20 } from "path";
+import semver11 from "semver";
 
 // src/adapters/maven/maven-locator.ts
-import { relative as relative5 } from "path";
+import { relative as relative8 } from "path";
 function locateDependencyVersion(chain, target, rootDir) {
   for (const pom of chain) {
     const dependency = findDependency(pom.dependencies, target, chain);
@@ -1927,13 +2964,13 @@ function resolveLiteral(pom, kind, versionElement, chain, target, rootDir) {
     file,
     kind: propertyName ? "property" : kind,
     propertyName,
-    displayPath: relative5(rootDir, file).replace(/\\/g, "/")
+    displayPath: relative8(rootDir, file).replace(/\\/g, "/")
   };
   return { found: true, declaration, element, value };
 }
 
 // src/adapters/maven/maven-scanner.ts
-var DIFF_ORDER2 = { major: 0, minor: 1, patch: 2 };
+var DIFF_ORDER3 = { major: 0, minor: 1, patch: 2 };
 var MavenDependencyAdapter = class {
   constructor(plugins = DEFAULT_MAVEN_PLUGINS) {
     this.plugins = plugins;
@@ -1987,14 +3024,14 @@ function groupModules(project, modules) {
     if (module.aggregatorDir) reactorSizes.set(module.aggregatorDir, (reactorSizes.get(module.aggregatorDir) ?? 0) + 1);
   }
   for (const module of modules) {
-    const pom = project.pomAt(join15(module.path, "pom.xml"));
+    const pom = project.pomAt(join20(module.path, "pom.xml"));
     if (!pom) continue;
     const reactor = module.aggregatorDir;
     const batched = reactor !== void 0 && (reactorSizes.get(reactor) ?? 0) > 1;
     const key = batched ? `reactor:${reactor}` : `module:${module.path}`;
     const group = groups.get(key) ?? {
       dir: batched ? reactor : module.path,
-      aggregatorPom: batched ? join15(reactor, "pom.xml") : void 0,
+      aggregatorPom: batched ? join20(reactor, "pom.xml") : void 0,
       members: []
     };
     group.members.push({ module, pom });
@@ -2083,7 +3120,7 @@ function finishModule(plan, report, channel) {
     collect2(updateCandidate(subject, latest, newer, origin), candidates, skipped);
   }
   markSharedDeclarations(candidates);
-  candidates.sort((a, b) => (DIFF_ORDER2[a.diff] ?? 3) - (DIFF_ORDER2[b.diff] ?? 3));
+  candidates.sort((a, b) => (DIFF_ORDER3[a.diff] ?? 3) - (DIFF_ORDER3[b.diff] ?? 3));
   return { candidates, skipped };
 }
 function newerThan(current, ascending) {
@@ -2114,7 +3151,7 @@ function buildCandidate(subject, target, origin, action) {
   }
   const currentClean = cleanJavaVersion(subject.version) ?? "0.0.0";
   const targetClean = cleanJavaVersion(target) ?? currentClean;
-  const diff = semver4.eq(currentClean, targetClean) ? "patch" : diffVersions(currentClean, targetClean);
+  const diff = semver11.eq(currentClean, targetClean) ? "patch" : diffVersions(currentClean, targetClean);
   const isPreRelease = isPreReleaseVersion(target);
   return {
     candidate: {
@@ -2162,11 +3199,11 @@ function markSharedDeclarations(candidates) {
 }
 
 // src/adapters/maven/maven-updater.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "fs";
-import { join as join16, resolve as resolve8 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync4 } from "fs";
+import { join as join21, resolve as resolve12 } from "path";
 var MavenUpdaterAdapter = class {
   affectedFiles(module, _rootDir, updates) {
-    const files = new Set(updates.map((u) => resolve8(u.declaration?.file ?? join16(module.path, "pom.xml"))));
+    const files = new Set(updates.map((u) => resolve12(u.declaration?.file ?? join21(module.path, "pom.xml"))));
     return [...files];
   }
   async applyUpdates(module, rootDir, updates, onProgress) {
@@ -2176,13 +3213,13 @@ var MavenUpdaterAdapter = class {
       if (!update.declaration) {
         throw new InstallError(`No version declaration known for ${update.coordinate.identifier}; rescan the module.`);
       }
-      const file = resolve8(update.declaration.file);
+      const file = resolve12(update.declaration.file);
       byFile.set(file, [...byFile.get(file) ?? [], update]);
     }
     const writes = [];
     for (const [file, fileUpdates] of byFile) {
       onProgress(`Preparing ${fileUpdates.length} change(s) in ${fileUpdates[0].declaration.displayPath}\u2026`);
-      const source = readFileSync10(file, "utf8");
+      const source = readFileSync15(file, "utf8");
       const pom = parsePom(source, file);
       const chain = project.pomAt(file) ? project.chainOf(project.pomAt(file)).poms : [pom];
       const edits = collectEdits(pom, [pom, ...chain.slice(1)], fileUpdates);
@@ -2194,7 +3231,7 @@ var MavenUpdaterAdapter = class {
       }
     }
     onProgress("Writing POM files\u2026");
-    for (const write of writes) writeFileSync3(write.file, write.content, "utf8");
+    for (const write of writes) writeFileSync4(write.file, write.content, "utf8");
     return {
       updatedCount: updates.length,
       auditMessage: `Updated ${updates.length} version declaration(s) in ${writes.length} POM file(s).`,
@@ -2252,13 +3289,13 @@ function describe(declaration) {
 }
 
 // src/adapters/maven/maven-verifier.ts
-import { dirname as dirname7, join as join17, relative as relative6, resolve as resolve9 } from "path";
-var VERIFY_TIMEOUT_MS2 = 30 * 6e4;
+import { dirname as dirname9, join as join22, relative as relative9, resolve as resolve13 } from "path";
+var VERIFY_TIMEOUT_MS3 = 30 * 6e4;
 var MavenVerificationAdapter = class {
   async verify(module, rootDir, options = {}) {
     if (options.customScript) {
       const label2 = options.customLabel || options.customScript;
-      const result = await runShellScript(options.customScript, { cwd: module.path, timeoutMs: VERIFY_TIMEOUT_MS2 });
+      const result = await runShellScript(options.customScript, { cwd: module.path, timeoutMs: VERIFY_TIMEOUT_MS3 });
       return result.exitCode === 0 ? { status: "clean", details: "Verification script succeeded.", label: label2 } : { status: "warn", details: failureDetails2(result), label: label2 };
     }
     const plan = planBuild(module, rootDir, options.changedFiles ?? []);
@@ -2267,7 +3304,7 @@ var MavenVerificationAdapter = class {
       const result = await runMaven(["-q", "test-compile", ...plan.args], {
         cwd: plan.cwd,
         rootDir,
-        timeoutMs: VERIFY_TIMEOUT_MS2
+        timeoutMs: VERIFY_TIMEOUT_MS3
       });
       if (result.exitCode === 0) {
         return { status: "clean", details: "All affected modules compile, including tests.", label };
@@ -2289,15 +3326,15 @@ function planBuild(module, rootDir, changedFiles) {
   const aggregatorDir = module.aggregatorDir;
   if (!aggregatorDir) return { cwd: module.path, args: [] };
   const project = MavenProject.load(rootDir);
-  const files = changedFiles.length > 0 ? changedFiles : [join17(module.path, "pom.xml")];
+  const files = changedFiles.length > 0 ? changedFiles : [join22(module.path, "pom.xml")];
   const selected = /* @__PURE__ */ new Set();
   for (const file of files) {
     const pom = project.pomAt(file);
-    const dir = resolve9(dirname7(file));
-    if (!pom || project.aggregatorDirOf(pom) !== aggregatorDir || dir === resolve9(aggregatorDir)) {
+    const dir = resolve13(dirname9(file));
+    if (!pom || project.aggregatorDirOf(pom) !== aggregatorDir || dir === resolve13(aggregatorDir)) {
       return { cwd: aggregatorDir, args: [] };
     }
-    selected.add(relative6(aggregatorDir, dir).replace(/\\/g, "/"));
+    selected.add(relative9(aggregatorDir, dir).replace(/\\/g, "/"));
   }
   return { cwd: aggregatorDir, args: ["-pl", [...selected].join(","), "-amd"] };
 }
@@ -2308,6 +3345,7 @@ var MavenEcosystemStrategy = class {
   displayName = "Java / Maven";
   icon = "\u2615";
   manifestFile = "pom.xml";
+  versioning = mavenVersionPolicy;
   discovery = new MavenModuleDiscoveryAdapter();
   registry;
   reader;
@@ -2345,6 +3383,8 @@ var EcosystemFactory = class {
     if (!strategy) {
       if (ecosystem === "maven") {
         strategy = new MavenEcosystemStrategy(this.settings.mavenPlugins);
+      } else if (ecosystem === "cargo") {
+        strategy = new CargoEcosystemStrategy();
       } else {
         strategy = new NpmEcosystemStrategy();
       }
@@ -2354,18 +3394,23 @@ var EcosystemFactory = class {
   }
   /** All supported ecosystems. */
   static getAvailableEcosystems() {
-    return ["npm", "maven"];
+    return ["npm", "maven", "cargo"];
+  }
+  /** The ecosystem after `current`, for the dashboard's ecosystem switch. */
+  static next(current) {
+    const all = this.getAvailableEcosystems();
+    return all[(all.indexOf(current) + 1) % all.length];
   }
 };
 
 // src/config.ts
 function findRepositoryRoot(startDir) {
-  const start = resolve10(startDir);
+  const start = resolve14(startDir);
   const boundary = findCheckoutBoundary(start);
   let dir = start;
   for (; ; ) {
-    if (existsSync11(join18(dir, "elevate.config.json"))) return dir;
-    const parent = dirname8(dir);
+    if (existsSync16(join23(dir, "elevate.config.json"))) return dir;
+    const parent = dirname10(dir);
     if (dir === boundary || parent === dir) break;
     dir = parent;
   }
@@ -2430,15 +3475,15 @@ function resolveConfig(rootDir, file, source = "elevate.config.json") {
 }
 function loadConfig2(startDir = process.cwd()) {
   const rootDir = findRepositoryRoot(startDir);
-  const configPath = join18(rootDir, "elevate.config.json");
+  const configPath = join23(rootDir, "elevate.config.json");
   let file = {};
-  if (existsSync11(configPath)) {
+  if (existsSync16(configPath)) {
     const unreadable = (detail) => new ConfigError(
       `Cannot read elevate.config.json: ${detail} (${configPath}). Fix the file or remove it; ${NO_CONTINUE}`
     );
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync11(configPath, "utf8").replace(/^/, ""));
+      parsed = JSON.parse(readFileSync16(configPath, "utf8").replace(/^/, ""));
     } catch (err) {
       throw unreadable(err instanceof Error ? err.message : String(err));
     }
@@ -2499,7 +3544,9 @@ var de = {
     dev: "(dev/test)",
     prod: "(prod/compile)",
     align: "[Angleichen]",
-    internal: "[Intern]"
+    internal: "[Intern]",
+    lock: "[Lock]",
+    shared: (count) => `[+${count} Crates]`
   },
   status: {
     selectedOf: (selected, total) => `${selected} von ${total}`,
@@ -2528,6 +3575,7 @@ var de = {
     hint: "[\u2191/\u2193/j/k] Navigieren  \u2502  [Enter] Ausw\xE4hlen  \u2502  [Esc] Abbrechen  \u2502  [Backspace] Filter l\xF6schen",
     latestBadge: "LATEST",
     currentBadge: "AKTUELL",
+    alsoChanges: (names) => `\xC4ndert auch: ${names.join(", ")}`,
     customBadge: "MANUELL"
   },
   updating: {
@@ -2556,6 +3604,7 @@ var de = {
     scanningChirps: ["*such*", "pr\xFCfe...", "oh, Updates?", "einen Moment!"],
     updatingChirps: ["*schuft*", "baue Code...", "gleich fertig!", "arbeite emsig..."],
     successChirps: ["hurra! \u{1F389}", "alles aktuell!", "top gepflegt! \u{1FAB6}", "super gemacht!"],
+    cargoChirps: ["*krabbel* \u{1F980}", "cargo check l\xE4uft durch!", "Borrow Checker nickt!", "furchtlose Updates!"],
     mavenChirps: ["*kaffee schl\xFCrf* \u2615", "Spring Boot l\xE4uft!", "Java 25 rockt!", "sauber gebaut!"]
   },
   splash: {
@@ -2607,7 +3656,9 @@ var en = {
     dev: "(dev/test)",
     prod: "(prod/compile)",
     align: "[Align]",
-    internal: "[Internal]"
+    internal: "[Internal]",
+    lock: "[Lock]",
+    shared: (count) => `[+${count} crates]`
   },
   status: {
     selectedOf: (selected, total) => `${selected} of ${total}`,
@@ -2636,6 +3687,7 @@ var en = {
     hint: "[\u2191/\u2193/j/k] Navigate  \u2502  [Enter] Select  \u2502  [Esc] Cancel  \u2502  [Backspace] Clear filter",
     latestBadge: "LATEST",
     currentBadge: "CURRENT",
+    alsoChanges: (names) => `Also changes: ${names.join(", ")}`,
     customBadge: "MANUAL"
   },
   updating: {
@@ -2664,6 +3716,7 @@ var en = {
     scanningChirps: ["*peeking*", "checking...", "ooh, updates?", "just a sec!"],
     updatingChirps: ["*working hard*", "building...", "almost there!", "packing modules..."],
     successChirps: ["hooray! \u{1F389}", "all updated!", "looking sharp! \u{1FAB6}", "great job!"],
+    cargoChirps: ["*crab walk* \u{1F980}", "cargo check passes!", "borrow checker approves!", "fearless updates!"],
     mavenChirps: ["*sipping coffee* \u2615", "Spring Boot rocks!", "Java 25 is fly!", "clean build!"]
   },
   splash: {
@@ -2700,48 +3753,12 @@ function useI18n(initialLocale = "de") {
 
 // src/hooks/use-workspaces.ts
 import { useState as useState2, useEffect, useCallback as useCallback2 } from "react";
-function useWorkspaces(strategy, rootDir) {
-  const [modules, setModules] = useState2([]);
-  const [loading, setLoading] = useState2(true);
-  const [activeIndex, setActiveIndex] = useState2(0);
-  const reload = useCallback2(async () => {
-    setLoading(true);
-    setModules([]);
-    setActiveIndex(0);
-    try {
-      setModules(await strategy.discovery.discover(rootDir));
-    } catch {
-      setModules([]);
-    } finally {
-      setLoading(false);
-    }
-  }, [strategy, rootDir]);
-  useEffect(() => {
-    reload();
-  }, [reload]);
-  const active = modules[activeIndex] || {
-    id: "empty",
-    name: "No module found",
-    path: rootDir,
-    relPath: "Root",
-    ecosystem: strategy.ecosystem,
-    isRoot: true
-  };
-  return {
-    modules,
-    active,
-    activeIndex,
-    setActiveIndex,
-    loading,
-    reload
-  };
-}
-
-// src/hooks/use-packages.ts
-import { useState as useState3, useEffect as useEffect2, useMemo as useMemo2, useCallback as useCallback3, useRef } from "react";
-import semver5 from "semver";
 
 // src/application/scan.ts
+async function discoverModules(strategy, rootDir) {
+  const modules = await strategy.discovery.discover(rootDir);
+  return { modules, diagnostics: strategy.discovery.diagnostics?.() ?? [] };
+}
 function createScanContext(modules, config, channel) {
   return {
     rootDir: config.rootDir,
@@ -2801,7 +3818,52 @@ function candidateToJson(u) {
   };
 }
 
+// src/hooks/use-workspaces.ts
+function useWorkspaces(strategy, rootDir) {
+  const [modules, setModules] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [activeIndex, setActiveIndex] = useState2(0);
+  const [diagnostics, setDiagnostics] = useState2([]);
+  const reload = useCallback2(async () => {
+    setLoading(true);
+    setModules([]);
+    setActiveIndex(0);
+    setDiagnostics([]);
+    try {
+      const found = await discoverModules(strategy, rootDir);
+      setModules(found.modules);
+      setDiagnostics(found.diagnostics);
+    } catch (err) {
+      setModules([]);
+      setDiagnostics([err instanceof Error ? err.message : String(err)]);
+    } finally {
+      setLoading(false);
+    }
+  }, [strategy, rootDir]);
+  useEffect(() => {
+    reload();
+  }, [reload]);
+  const active = modules[activeIndex] || {
+    id: "empty",
+    name: "No module found",
+    path: rootDir,
+    relPath: "Root",
+    ecosystem: strategy.ecosystem,
+    isRoot: true
+  };
+  return {
+    modules,
+    active,
+    activeIndex,
+    setActiveIndex,
+    loading,
+    diagnostics,
+    reload
+  };
+}
+
 // src/hooks/use-packages.ts
+import { useState as useState3, useEffect as useEffect2, useMemo as useMemo2, useCallback as useCallback3, useRef } from "react";
 function usePackages(strategy, module, modules, config, channel = "stable") {
   const [candidates, setCandidates] = useState3([]);
   const [skipped, setSkipped] = useState3([]);
@@ -2868,15 +3930,12 @@ function usePackages(strategy, module, modules, config, channel = "stable") {
     setCandidates(
       (prev) => prev.map((c) => {
         if (c.coordinate.identifier !== identifier) return c;
-        const target = c.coordinate.ecosystem === "maven" ? cleanJavaVersion(chosenVersion) : semver5.valid(chosenVersion);
-        let diff = "minor";
-        if (c.currentClean && target && semver5.valid(c.currentClean)) {
-          diff = semver5.eq(c.currentClean, target) ? "patch" : diffVersions(c.currentClean, target);
-        }
+        const policy = strategy.versioning;
+        const diff = c.currentClean ? policy.diff(c.currentClean, chosenVersion) : "minor";
         const isPre = isPreReleaseVersion(chosenVersion);
         return {
           ...c,
-          newRange: c.coordinate.ecosystem === "npm" ? `${rangePrefix(c.currentRange)}${chosenVersion}` : chosenVersion,
+          newRange: policy.rewrite(c.currentRange, chosenVersion),
           latest: chosenVersion,
           diff,
           selected: true,
@@ -2886,7 +3945,7 @@ function usePackages(strategy, module, modules, config, channel = "stable") {
         };
       })
     );
-  }, []);
+  }, [strategy]);
   const switchTab = useCallback3((tab) => {
     setActiveTab(tab);
     setCursor(0);
@@ -2918,11 +3977,11 @@ function usePackages(strategy, module, modules, config, channel = "stable") {
 import { useState as useState4, useCallback as useCallback4 } from "react";
 
 // src/application/update-workflow.ts
-import { existsSync as existsSync13 } from "fs";
-import { relative as relative7 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { relative as relative10 } from "path";
 
 // src/adapters/shared/file-snapshot.ts
-import { existsSync as existsSync12, readFileSync as readFileSync12, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync17, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 var FileSnapshot = class _FileSnapshot {
   constructor(entries2) {
     this.entries = entries2;
@@ -2933,7 +3992,7 @@ var FileSnapshot = class _FileSnapshot {
     const entries2 = /* @__PURE__ */ new Map();
     for (const file of files) {
       if (entries2.has(file)) continue;
-      entries2.set(file, existsSync12(file) ? readFileSync12(file) : null);
+      entries2.set(file, existsSync17(file) ? readFileSync17(file) : null);
     }
     return new _FileSnapshot(entries2);
   }
@@ -2945,9 +4004,9 @@ var FileSnapshot = class _FileSnapshot {
   changedFiles() {
     return this.files.filter((file) => {
       const before = this.entries.get(file) ?? null;
-      const exists = existsSync12(file);
+      const exists = existsSync17(file);
       if (before === null) return exists;
-      return !exists || !readFileSync12(file).equals(before);
+      return !exists || !readFileSync17(file).equals(before);
     });
   }
   /** Writes every file back to its captured state; removes files that did not exist. */
@@ -2956,7 +4015,7 @@ var FileSnapshot = class _FileSnapshot {
       if (content === null) {
         rmSync2(file, { force: true });
       } else {
-        writeFileSync4(file, content);
+        writeFileSync5(file, content);
       }
     }
   }
@@ -2995,7 +4054,7 @@ Restoring the installed state failed as well: ${message(err)}`;
   let baseline;
   if (!options.skipVerification) {
     progress("Running verification on the current state\u2026");
-    baseline = await verify(snapshot.files.filter((file) => existsSync13(file)));
+    baseline = await verify(snapshot.files.filter((file) => existsSync18(file)));
   }
   let applied;
   try {
@@ -3041,7 +4100,7 @@ function message(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function displayPaths(files, rootDir) {
-  return files.map((file) => relative7(rootDir, file).replace(/\\/g, "/"));
+  return files.map((file) => relative10(rootDir, file).replace(/\\/g, "/"));
 }
 
 // src/hooks/use-updater.ts
@@ -3255,33 +4314,39 @@ var Header = ({
 // src/components/workspace-bar.tsx
 import { Box as Box3, Text as Text3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-var WorkspaceBar = ({ module, internalScopes, strategy, t }) => {
+var WorkspaceBar = ({ module, internalScopes, strategy, t, diagnostics = [] }) => {
   const scopeHint = internalScopes.length > 0 ? t.status.internalScopes(internalScopes) : t.status.noInternalScopes;
-  return /* @__PURE__ */ jsxs3(Box3, { marginY: 1, justifyContent: "space-between", alignItems: "center", children: [
-    /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", flexShrink: 1, children: [
-      /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
-        "\u{1F4CD} ",
-        strategy.icon,
-        " ",
-        t.workspace.label,
-        ": "
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Box3, { marginY: 1, justifyContent: "space-between", alignItems: "center", children: [
+      /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", flexShrink: 1, children: [
+        /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
+          "\u{1F4CD} ",
+          strategy.icon,
+          " ",
+          t.workspace.label,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx3(Text3, { bold: true, color: theme.colors.brandLight, children: module.name }),
+        /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
+          " (",
+          module.relPath,
+          ")"
+        ] })
       ] }),
-      /* @__PURE__ */ jsx3(Text3, { bold: true, color: theme.colors.brandLight, children: module.name }),
-      /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
-        " (",
-        module.relPath,
-        ")"
+      /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", marginLeft: 2, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: scopeHint }),
+        /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: "  \u2502  " }),
+        /* @__PURE__ */ jsx3(Text3, { color: theme.colors.brandLight, bold: true, children: "[W]" }),
+        /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
+          " ",
+          t.workspace.switchHint.replace("[W]", "").trim()
+        ] })
       ] })
     ] }),
-    /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", marginLeft: 2, children: [
-      /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: scopeHint }),
-      /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: "  \u2502  " }),
-      /* @__PURE__ */ jsx3(Text3, { color: theme.colors.brandLight, bold: true, children: "[W]" }),
-      /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
-        " ",
-        t.workspace.switchHint.replace("[W]", "").trim()
-      ] })
-    ] })
+    diagnostics.slice(0, 2).map((d) => /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.danger, wrap: "truncate-end", children: [
+      "\u26A0 ",
+      d.split("\n")[0]
+    ] }, d))
   ] });
 };
 
@@ -3331,7 +4396,9 @@ import { Box as Box5, Text as Text5 } from "ink";
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var PackageRow = ({ item, isFocused, t }) => {
   const badge = item.diff === "major" ? /* @__PURE__ */ jsx5(Text5, { bold: true, color: theme.colors.danger, children: t.badges.major }) : item.diff === "minor" ? /* @__PURE__ */ jsx5(Text5, { color: theme.colors.warning, children: t.badges.minor }) : /* @__PURE__ */ jsx5(Text5, { color: theme.colors.success, children: t.badges.patch });
-  const displayName = item.coordinate.identifier;
+  const shared = item.sharedWith && item.sharedWith.length > 0 ? ` ${t.badges.shared(item.sharedWith.length)}` : "";
+  const label = item.qualifier ? `${item.coordinate.identifier} (${item.qualifier})` : item.coordinate.identifier;
+  const displayName = label.slice(0, 42 - shared.length) + shared;
   const isDevOrTest = item.scope === "dev" || item.scope === "test";
   const property = item.declaration?.kind === "property" ? `\${${item.declaration.propertyName}}` : void 0;
   return /* @__PURE__ */ jsxs5(Box5, { justifyContent: "space-between", children: [
@@ -3361,6 +4428,10 @@ var PackageRow = ({ item, isFocused, t }) => {
         t.badges.align,
         " "
       ] }),
+      item.action === "lock" && /* @__PURE__ */ jsxs5(Text5, { bold: true, color: theme.colors.brandLight, children: [
+        t.badges.lock,
+        " "
+      ] }),
       item.origin.kind === "private" && /* @__PURE__ */ jsxs5(Text5, { color: theme.colors.brandLight, children: [
         t.badges.internal,
         " "
@@ -3510,7 +4581,7 @@ var ChickenMascot = ({ state = "idle", t, ecosystem = "npm" }) => {
     chickFace = cur.face;
     wingLeft = cur.l;
     wingRight = cur.r;
-    const chirpsPool = ecosystem === "maven" ? [...t.mascot.idleChirps, ...t.mascot.mavenChirps] : t.mascot.idleChirps;
+    const chirpsPool = ecosystem === "maven" ? [...t.mascot.idleChirps, ...t.mascot.mavenChirps] : ecosystem === "cargo" ? [...t.mascot.idleChirps, ...t.mascot.cargoChirps] : t.mascot.idleChirps;
     currentChirp = chirpsPool[chirpIndex % chirpsPool.length];
   }
   return /* @__PURE__ */ jsxs7(Box7, { alignItems: "center", children: [
@@ -3788,6 +4859,7 @@ var VersionModal = ({
           ] }),
           /* @__PURE__ */ jsx11(Text11, { color: theme.colors.muted, children: t.versionModal.current(candidate.currentRange) })
         ] }),
+        candidate.sharedWith && candidate.sharedWith.length > 0 && /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text11, { color: theme.colors.warning, children: t.versionModal.alsoChanges(candidate.sharedWith) }) }),
         /* @__PURE__ */ jsxs11(
           Box11,
           {
@@ -3962,10 +5034,10 @@ var App = ({ config }) => {
   const [versionPickerCandidate, setVersionPickerCandidate] = useState8(null);
   const [ecosystem, setEcosystem] = useState8("npm");
   const strategy = useMemo4(() => EcosystemFactory.getStrategy(ecosystem), [ecosystem]);
-  const nextEcosystem = ecosystem === "npm" ? "maven" : "npm";
+  const nextEcosystem = EcosystemFactory.next(ecosystem);
   const nextStrategy = useMemo4(() => EcosystemFactory.getStrategy(nextEcosystem), [nextEcosystem]);
   const toggleEcosystem = useCallback5(() => {
-    setEcosystem((prev) => prev === "npm" ? "maven" : "npm");
+    setEcosystem((prev) => EcosystemFactory.next(prev));
   }, []);
   const { locale, toggleLocale, t } = useI18n(resolveInitialLocale(config.locale));
   const ws = useWorkspaces(strategy, config.rootDir);
@@ -4117,7 +5189,8 @@ var App = ({ config }) => {
             module: ws.active,
             internalScopes: config.internalScopes,
             strategy,
-            t
+            t,
+            diagnostics: ws.diagnostics
           }
         ),
         /* @__PURE__ */ jsx14(
@@ -4157,6 +5230,7 @@ var App = ({ config }) => {
 };
 
 // src/cli/parser.ts
+var isEcosystem = (v) => EcosystemFactory.getAvailableEcosystems().includes(v);
 function parseCliArgs(args) {
   const [first, ...rest] = args;
   if (!first || first === "--help" || first === "-h" || first === "help") {
@@ -4194,10 +5268,10 @@ function parseCliArgs(args) {
       result.help = true;
     } else if (arg.startsWith("--ecosystem=")) {
       const val = arg.split("=")[1];
-      if (val === "npm" || val === "maven") result.ecosystem = val;
+      if (isEcosystem(val)) result.ecosystem = val;
     } else if (arg === "-e" || arg === "--ecosystem") {
       const val = remaining[++i];
-      if (val === "npm" || val === "maven") result.ecosystem = val;
+      if (isEcosystem(val)) result.ecosystem = val;
     } else if (arg.startsWith("--module=")) {
       result.module = arg.split("=")[1];
     } else if (arg === "-m" || arg === "--module") {
@@ -4239,7 +5313,7 @@ SUBCOMMANDS:
   mcp                                   Start stdio-based MCP server
 
 FLAGS:
-  -e, --ecosystem <npm|maven>          Target ecosystem (default: npm)
+  -e, --ecosystem <npm|maven|cargo>          Target ecosystem (default: npm)
   -m, --module <name|path>             Target module ID or relative path (default: root)
   -c, --channel <stable|all>           Release channel (default: stable)
   -p, --packages <pkg1,pkg2@1.2.3>     Comma-separated list of packages to update
@@ -4267,11 +5341,11 @@ EXAMPLES:
 async function handleModulesCommand(options, config) {
   const ecosystem = options.ecosystem ?? "npm";
   const strategy = EcosystemFactory.getStrategy(ecosystem);
-  const modules = await strategy.discovery.discover(config.rootDir);
+  const { modules, diagnostics } = await discoverModules(strategy, config.rootDir);
   const displayName = strategy.displayNameFor?.(config.rootDir) ?? strategy.displayName;
   const packageManager = strategy.packageManagerFor?.(config.rootDir);
   if (options.json) {
-    console.log(JSON.stringify({ ecosystem, ...packageManager ? { packageManager } : {}, count: modules.length, modules }, null, 2));
+    console.log(JSON.stringify({ ecosystem, ...packageManager ? { packageManager } : {}, count: modules.length, modules, diagnostics }, null, 2));
     return 0;
   }
   console.log(`
@@ -4282,6 +5356,7 @@ async function handleModulesCommand(options, config) {
     console.log(`  \u2022 ${m.name.padEnd(45)} (${m.relPath})${isRootBadge}`);
   }
   console.log("");
+  for (const problem of diagnostics) console.error(`\u26A0\uFE0F  ${problem}`);
   return 0;
 }
 
@@ -4303,6 +5378,8 @@ function describeSkip(skipped) {
       return `workspace package that pnpm does not link unless it is declared with the workspace: protocol${detail}`;
     case "catalog-unresolved":
       return `catalog entry could not be resolved${detail}`;
+    case "incompatible-rust-version":
+      return `newer versions need a newer Rust than the project's rust-version${detail}`;
   }
 }
 
@@ -4311,7 +5388,8 @@ async function handleScanCommand(options, config) {
   const ecosystem = options.ecosystem ?? "npm";
   const channel = options.channel ?? config.channel ?? "stable";
   const strategy = EcosystemFactory.getStrategy(ecosystem);
-  const modules = await strategy.discovery.discover(config.rootDir);
+  const { modules, diagnostics } = await discoverModules(strategy, config.rootDir);
+  for (const problem of diagnostics) console.error(`\u26A0\uFE0F  ${problem}`);
   if (modules.length === 0) {
     if (options.json) {
       console.log(JSON.stringify({ error: `No ${strategy.displayName} modules found.`, ecosystem }, null, 2));
@@ -4390,7 +5468,7 @@ async function handleScanCommand(options, config) {
     if (result.candidates.length === 0) console.log("   \u2728 All dependencies are up to date.");
     for (const u of result.candidates) {
       const diffTag = `[${u.diff.toUpperCase()}]`.padEnd(9);
-      const actionTag = u.action === "align" ? "[ALIGN] " : u.origin.kind === "private" ? "[INTERNAL] " : "";
+      const actionTag = u.action === "align" ? "[ALIGN] " : u.action === "lock" ? "[LOCK] " : u.origin.kind === "private" ? "[INTERNAL] " : "";
       const preBadge = u.isPreRelease ? `[${u.preReleaseTag || "PRE"}] ` : "";
       const where = u.declaration && u.declaration.displayPath !== modulePom ? `  (in ${u.declaration.displayPath}${u.declaration.propertyName ? ` \${${u.declaration.propertyName}}` : ""})` : "";
       console.log(
@@ -4461,7 +5539,7 @@ async function handleVersionsCommand(options, config) {
 }
 
 // src/application/update-selection.ts
-import semver6 from "semver";
+import semver12 from "semver";
 var UpdateSelectionError = class extends Error {
   constructor(message2) {
     super(message2);
@@ -4486,9 +5564,9 @@ function selectRequested(scan, requests, options) {
         `'${request.identifier}' has no pending update. Specify a target version (e.g. ${request.identifier}@1.2.3).`
       );
     }
-    if (options.ecosystem === "maven") {
+    if (!policyOf(options).allowsManualTargets) {
       throw new UpdateSelectionError(
-        `'${request.identifier}' has no pending update. Maven updates are written where the scan located the version; a dependency without an offered update cannot be retargeted.`
+        `'${request.identifier}' has no pending update. Updates are written where the scan located the version; a dependency without an offered update cannot be retargeted.`
       );
     }
     if (options.originOf(request.identifier) !== "public") {
@@ -4513,12 +5591,12 @@ function retarget(found, target, options) {
       `'${found.coordinate.identifier}' is a workspace module; it can only be aligned to its local version ${found.latest}.`
     );
   }
-  if (options.ecosystem === "maven" && found.availableVersions && !found.availableVersions.includes(target)) {
+  if (!policyOf(options).allowsManualTargets && found.availableVersions && !found.availableVersions.includes(target)) {
     throw new UpdateSelectionError(
       `'${found.coordinate.identifier}' has no version ${target} in the configured repositories. Available: ${found.availableVersions.slice(0, 5).join(", ")}${found.availableVersions.length > 5 ? ", \u2026" : ""}.`
     );
   }
-  const diff = computeDiff(found.currentClean, target, options.ecosystem);
+  const diff = policyOf(options).diff(found.currentClean, target);
   if (diff === "major" && !options.allowMajor) {
     throw new UpdateSelectionError(
       `'${found.coordinate.identifier}' requires a major upgrade to ${target}. Pass --allow-major / allowMajor.`
@@ -4527,7 +5605,9 @@ function retarget(found, target, options) {
   const isPreRelease = isPreReleaseVersion(target);
   return {
     ...found,
-    newRange: options.ecosystem === "npm" ? `${rangePrefix(found.currentRange)}${target}` : target,
+    // A lock update pins exactly the version that was picked.
+    ...found.action === "lock" ? { latest: target } : {},
+    newRange: policyOf(options).rewrite(found.currentRange, target),
     diff,
     selected: true,
     isCustomVersion: true,
@@ -4536,7 +5616,7 @@ function retarget(found, target, options) {
   };
 }
 function manualNpmCandidate(identifier, target, options) {
-  if (!semver6.valid(target)) {
+  if (!semver12.valid(target)) {
     throw new UpdateSelectionError(`'${target}' is not a valid version for '${identifier}'.`);
   }
   return {
@@ -4553,10 +5633,8 @@ function manualNpmCandidate(identifier, target, options) {
     isCustomVersion: true
   };
 }
-function computeDiff(current, target, ecosystem) {
-  const to = ecosystem === "maven" ? cleanJavaVersion(target) : semver6.valid(target);
-  if (!to || !semver6.valid(current)) return "minor";
-  return semver6.eq(current, to) ? "patch" : diffVersions(current, to);
+function policyOf(options) {
+  return EcosystemFactory.getStrategy(options.ecosystem).versioning;
 }
 
 // src/cli/command-update.ts
@@ -4568,7 +5646,8 @@ async function handleUpdateCommand(options, config) {
     else console.error(`\u274C ${message2}`);
     return code;
   };
-  const modules = await strategy.discovery.discover(config.rootDir);
+  const { modules, diagnostics } = await discoverModules(strategy, config.rootDir);
+  for (const problem of diagnostics) console.error(`\u26A0\uFE0F  ${problem}`);
   if (modules.length === 0) return fail(`No ${strategy.displayName} modules found.`);
   const targetModule = options.module ? findModule(modules, options.module) : modules[0];
   if (!targetModule) return fail(`Module '${options.module}' not found.`);
@@ -4709,9 +5788,9 @@ function parsePackageArgument(item) {
 }
 
 // src/cli/command-init.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2 } from "fs";
-import { homedir, platform } from "os";
-import { join as join19, resolve as resolve11 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync6, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2, platform } from "os";
+import { join as join24, resolve as resolve15 } from "path";
 function mcpServerEntry() {
   return {
     command: "npx",
@@ -4754,10 +5833,10 @@ automatic rollback.
    requested). A failed install or verification is rolled back automatically.
 4. \`elevate_verify\` \u2014 Verify build integrity when needed
 `;
-var home = homedir();
+var home = homedir2();
 var isWin = platform() === "win32";
 function appData() {
-  return process.env.APPDATA || join19(home, "AppData", "Roaming");
+  return process.env.APPDATA || join24(home, "AppData", "Roaming");
 }
 function detectCursor(cwd) {
   const env = {
@@ -4769,25 +5848,25 @@ function detectCursor(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const workspaceCursorDir = join19(cwd, ".cursor");
-  const globalCursorDir = join19(home, ".cursor");
-  if (existsSync14(workspaceCursorDir) || existsSync14(globalCursorDir)) {
+  const workspaceCursorDir = join24(cwd, ".cursor");
+  const globalCursorDir = join24(home, ".cursor");
+  if (existsSync19(workspaceCursorDir) || existsSync19(globalCursorDir)) {
     env.detected = true;
-    env.reason = existsSync14(workspaceCursorDir) ? `Found .cursor/ in workspace` : `Found ~/.cursor/ global config`;
+    env.reason = existsSync19(workspaceCursorDir) ? `Found .cursor/ in workspace` : `Found ~/.cursor/ global config`;
   }
-  const mcpPath = join19(cwd, ".cursor", "mcp.json");
-  if (existsSync14(mcpPath)) {
+  const mcpPath = join24(cwd, ".cursor", "mcp.json");
+  if (existsSync19(mcpPath)) {
     try {
-      const content = JSON.parse(readFileSync13(mcpPath, "utf8"));
+      const content = JSON.parse(readFileSync18(mcpPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  const rulesPath = join19(cwd, ".cursorrules");
-  if (existsSync14(rulesPath)) {
-    const content = readFileSync13(rulesPath, "utf8");
+  const rulesPath = join24(cwd, ".cursorrules");
+  if (existsSync19(rulesPath)) {
+    const content = readFileSync18(rulesPath, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -4804,12 +5883,12 @@ function detectClaudeDesktop() {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const configPath = isWin ? join19(appData(), "Claude", "claude_desktop_config.json") : join19(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  if (existsSync14(configPath)) {
+  const configPath = isWin ? join24(appData(), "Claude", "claude_desktop_config.json") : join24(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (existsSync19(configPath)) {
     env.detected = true;
     env.reason = `Found ${configPath}`;
     try {
-      const content = JSON.parse(readFileSync13(configPath, "utf8"));
+      const content = JSON.parse(readFileSync18(configPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
@@ -4828,23 +5907,23 @@ function detectClaudeCode(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const mcpJsonPath = join19(cwd, ".mcp.json");
-  const claudeMdPath = join19(cwd, "CLAUDE.md");
-  if (existsSync14(mcpJsonPath) || existsSync14(claudeMdPath)) {
+  const mcpJsonPath = join24(cwd, ".mcp.json");
+  const claudeMdPath = join24(cwd, "CLAUDE.md");
+  if (existsSync19(mcpJsonPath) || existsSync19(claudeMdPath)) {
     env.detected = true;
-    env.reason = existsSync14(mcpJsonPath) ? `Found .mcp.json in workspace` : `Found CLAUDE.md in workspace`;
+    env.reason = existsSync19(mcpJsonPath) ? `Found .mcp.json in workspace` : `Found CLAUDE.md in workspace`;
   }
-  if (existsSync14(mcpJsonPath)) {
+  if (existsSync19(mcpJsonPath)) {
     try {
-      const content = JSON.parse(readFileSync13(mcpJsonPath, "utf8"));
+      const content = JSON.parse(readFileSync18(mcpJsonPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  if (existsSync14(claudeMdPath)) {
-    const content = readFileSync13(claudeMdPath, "utf8");
+  if (existsSync19(claudeMdPath)) {
+    const content = readFileSync18(claudeMdPath, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -4861,20 +5940,20 @@ function detectAntigravity(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const globalGeminiDir = join19(home, ".gemini");
-  const workspaceAgentsDir = join19(cwd, ".agents");
-  if (existsSync14(globalGeminiDir) || existsSync14(workspaceAgentsDir)) {
+  const globalGeminiDir = join24(home, ".gemini");
+  const workspaceAgentsDir = join24(cwd, ".agents");
+  if (existsSync19(globalGeminiDir) || existsSync19(workspaceAgentsDir)) {
     env.detected = true;
-    env.reason = existsSync14(workspaceAgentsDir) ? `Found .agents/ in workspace` : `Found ~/.gemini/ global config`;
+    env.reason = existsSync19(workspaceAgentsDir) ? `Found .agents/ in workspace` : `Found ~/.gemini/ global config`;
   }
   const mcpPaths = [
-    join19(cwd, ".agents", "mcp_config.json"),
-    join19(home, ".gemini", "config", "mcp_config.json")
+    join24(cwd, ".agents", "mcp_config.json"),
+    join24(home, ".gemini", "config", "mcp_config.json")
   ];
   for (const p of mcpPaths) {
-    if (existsSync14(p)) {
+    if (existsSync19(p)) {
       try {
-        const content = JSON.parse(readFileSync13(p, "utf8"));
+        const content = JSON.parse(readFileSync18(p, "utf8"));
         if (content?.mcpServers?.elevate) {
           env.mcpConfigured = true;
           break;
@@ -4895,24 +5974,24 @@ function detectVSCode(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const vscodeDir = join19(cwd, ".vscode");
-  if (existsSync14(vscodeDir)) {
+  const vscodeDir = join24(cwd, ".vscode");
+  if (existsSync19(vscodeDir)) {
     env.detected = true;
     env.reason = `Found .vscode/ in workspace`;
   }
-  const mcpPath = join19(cwd, ".vscode", "mcp.json");
-  if (existsSync14(mcpPath)) {
+  const mcpPath = join24(cwd, ".vscode", "mcp.json");
+  if (existsSync19(mcpPath)) {
     try {
-      const content = JSON.parse(readFileSync13(mcpPath, "utf8"));
+      const content = JSON.parse(readFileSync18(mcpPath, "utf8"));
       if (content?.servers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  const copilotInstructions = join19(cwd, ".github", "copilot-instructions.md");
-  if (existsSync14(copilotInstructions)) {
-    const content = readFileSync13(copilotInstructions, "utf8");
+  const copilotInstructions = join24(cwd, ".github", "copilot-instructions.md");
+  if (existsSync19(copilotInstructions)) {
+    const content = readFileSync18(copilotInstructions, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -4929,14 +6008,14 @@ function detectWindsurf() {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const configPath = isWin ? join19(appData(), "Codeium", "Windsurf", "mcp_config.json") : join19(home, ".codeium", "windsurf", "mcp_config.json");
-  const altPath = join19(home, ".codeium", "windsurf", "mcp_config.json");
-  if (existsSync14(configPath) || existsSync14(altPath)) {
+  const configPath = isWin ? join24(appData(), "Codeium", "Windsurf", "mcp_config.json") : join24(home, ".codeium", "windsurf", "mcp_config.json");
+  const altPath = join24(home, ".codeium", "windsurf", "mcp_config.json");
+  if (existsSync19(configPath) || existsSync19(altPath)) {
     env.detected = true;
     env.reason = `Found Windsurf config`;
-    const path = existsSync14(configPath) ? configPath : altPath;
+    const path = existsSync19(configPath) ? configPath : altPath;
     try {
-      const content = JSON.parse(readFileSync13(path, "utf8"));
+      const content = JSON.parse(readFileSync18(path, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
@@ -4947,9 +6026,9 @@ function detectWindsurf() {
 }
 function mergeJsonMcpServer(filePath, serverKey, topLevelKey) {
   let existing = {};
-  if (existsSync14(filePath)) {
+  if (existsSync19(filePath)) {
     try {
-      existing = JSON.parse(readFileSync13(filePath, "utf8"));
+      existing = JSON.parse(readFileSync18(filePath, "utf8"));
     } catch {
       existing = {};
     }
@@ -4961,69 +6040,69 @@ function mergeJsonMcpServer(filePath, serverKey, topLevelKey) {
   servers[serverKey] = mcpServerEntry();
   existing[topLevelKey] = servers;
   const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
-  if (dir && !existsSync14(dir)) {
+  if (dir && !existsSync19(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
-  writeFileSync5(filePath, JSON.stringify(existing, null, 2) + "\n", "utf8");
+  writeFileSync6(filePath, JSON.stringify(existing, null, 2) + "\n", "utf8");
   return { written: true, message: `${filePath}: elevate MCP server registered` };
 }
 function appendSkillToFile(filePath, content, marker) {
-  if (existsSync14(filePath)) {
-    const existing = readFileSync13(filePath, "utf8");
+  if (existsSync19(filePath)) {
+    const existing = readFileSync18(filePath, "utf8");
     if (existing.includes(marker)) {
       return { written: false, message: `${filePath}: skill already present` };
     }
-    writeFileSync5(filePath, existing + "\n\n" + content, "utf8");
+    writeFileSync6(filePath, existing + "\n\n" + content, "utf8");
     return { written: true, message: `${filePath}: skill appended` };
   }
   const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
-  if (dir && !existsSync14(dir)) {
+  if (dir && !existsSync19(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
-  writeFileSync5(filePath, content, "utf8");
+  writeFileSync6(filePath, content, "utf8");
   return { written: true, message: `${filePath}: skill created` };
 }
 function configureCursor(cwd, result) {
-  const mcpPath = join19(cwd, ".cursor", "mcp.json");
+  const mcpPath = join24(cwd, ".cursor", "mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Cursor MCP: ${mcp.message}`);
-  const rulesPath = join19(cwd, ".cursorrules");
+  const rulesPath = join24(cwd, ".cursorrules");
   const skill = appendSkillToFile(rulesPath, ELEVATE_SKILL_CONTENT, "elevate_scan");
   result.actions.push(`${skill.written ? "\u2705" : "\u23ED\uFE0F"}  Cursor Rules: ${skill.message}`);
 }
 function configureClaudeDesktop(result) {
-  const configPath = isWin ? join19(appData(), "Claude", "claude_desktop_config.json") : join19(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  const configPath = isWin ? join24(appData(), "Claude", "claude_desktop_config.json") : join24(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
   const mcp = mergeJsonMcpServer(configPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Desktop MCP: ${mcp.message}`);
 }
 function configureClaudeCode(cwd, result) {
-  const mcpPath = join19(cwd, ".mcp.json");
+  const mcpPath = join24(cwd, ".mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Code MCP: ${mcp.message}`);
-  const claudeMdPath = join19(cwd, "CLAUDE.md");
+  const claudeMdPath = join24(cwd, "CLAUDE.md");
   const skill = appendSkillToFile(claudeMdPath, ELEVATE_SKILL_CONTENT, "elevate_scan");
   result.actions.push(`${skill.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Code Skill: ${skill.message}`);
 }
 function configureAntigravity(cwd, result) {
-  const mcpPath = join19(cwd, ".agents", "mcp_config.json");
+  const mcpPath = join24(cwd, ".agents", "mcp_config.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Antigravity MCP: ${mcp.message}`);
 }
 function configureVSCode(cwd, result) {
-  const mcpPath = join19(cwd, ".vscode", "mcp.json");
+  const mcpPath = join24(cwd, ".vscode", "mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "servers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  VS Code MCP: ${mcp.message}`);
-  const instructionsPath = join19(cwd, ".github", "copilot-instructions.md");
+  const instructionsPath = join24(cwd, ".github", "copilot-instructions.md");
   const skill = appendSkillToFile(instructionsPath, ELEVATE_SKILL_CONTENT, "elevate_scan");
   result.actions.push(`${skill.written ? "\u2705" : "\u23ED\uFE0F"}  Copilot Instructions: ${skill.message}`);
 }
 function configureWindsurf(result) {
-  const configPath = isWin ? join19(appData(), "Codeium", "Windsurf", "mcp_config.json") : join19(home, ".codeium", "windsurf", "mcp_config.json");
+  const configPath = isWin ? join24(appData(), "Codeium", "Windsurf", "mcp_config.json") : join24(home, ".codeium", "windsurf", "mcp_config.json");
   const mcp = mergeJsonMcpServer(configPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Windsurf MCP: ${mcp.message}`);
 }
 async function handleInitCommand(options) {
-  const cwd = resolve11(process.cwd());
+  const cwd = resolve15(process.cwd());
   const result = {
     cwd,
     environments: [],
@@ -5051,7 +6130,7 @@ async function handleInitCommand(options) {
       console.log(`  Creating portable .mcp.json for broad compatibility.
 `);
     }
-    const mcpPath = join19(cwd, ".mcp.json");
+    const mcpPath = join24(cwd, ".mcp.json");
     const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
     result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Generic MCP: ${mcp.message}`);
   } else {
@@ -5118,14 +6197,14 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 var ECOSYSTEM_PROPERTY = {
   type: "string",
-  enum: ["npm", "maven"],
+  enum: EcosystemFactory.getAvailableEcosystems(),
   description: "Target ecosystem (default: npm)"
 };
 async function startMcpServer(config) {
   const server = new Server(
     {
       name: "elevate-mcp",
-      version: "1.2.0"
+      version: VERSION
     },
     {
       capabilities: {
@@ -5138,7 +6217,7 @@ async function startMcpServer(config) {
       tools: [
         {
           name: "elevate_discover_modules",
-          description: "Discovers all repository modules and workspaces for Node/npm (package.json) or Java/Maven (pom.xml).",
+          description: "Discovers all repository modules and workspaces for Node/npm (package.json), Java/Maven (pom.xml) or Rust/Cargo (Cargo.toml).",
           inputSchema: {
             type: "object",
             properties: {
@@ -5178,7 +6257,7 @@ async function startMcpServer(config) {
               ecosystem: ECOSYSTEM_PROPERTY,
               identifier: {
                 type: "string",
-                description: "Package identifier (npm: chalk, maven: org.slf4j:slf4j-api)"
+                description: "Package identifier (npm: chalk, maven: org.slf4j:slf4j-api, cargo: serde)"
               }
             },
             required: ["identifier"]
@@ -5259,12 +6338,13 @@ async function startMcpServer(config) {
     };
     try {
       if (name === "elevate_discover_modules") {
-        const modules = await strategy.discovery.discover(config.rootDir);
+        const { modules, diagnostics } = await discoverModules(strategy, config.rootDir);
         const packageManager = strategy.packageManagerFor?.(config.rootDir);
         return reply({
           ecosystem,
           ...packageManager ? { packageManager } : {},
           count: modules.length,
+          diagnostics,
           modules: modules.map((m) => ({
             id: m.id,
             name: m.name,