@dennisrepa/elevate 1.3.0 → 1.4.0

package/dist/cli.js

@@ -4,74 +4,25 @@
 import { render } from "ink";
 
 // src/config.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname8, join as join16, resolve as resolve10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
+import { dirname as dirname8, join as join18, resolve as resolve10 } from "path";
 
-// src/adapters/npm/npm-discovery.ts
-import { readFileSync } from "fs";
-import { dirname, join, relative, resolve } from "path";
-import mapWorkspaces from "@npmcli/map-workspaces";
-function readJson(filePath) {
-  try {
-    return JSON.parse(readFileSync(filePath, "utf8"));
-  } catch {
-    return null;
+// src/adapters/npm/npm-package-manager.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+
+// src/adapters/shared/checkout.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+function findCheckoutBoundary(startDir) {
+  let dir = resolve(startDir);
+  for (; ; ) {
+    if (existsSync(join(dir, ".git"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
   }
 }
-var NpmModuleDiscoveryAdapter = class {
-  /**
-   * The nearest directory, from `startDir` upwards to the boundary, whose
-   * package.json is valid JSON and declares `workspaces`.
-   */
-  findRoot(startDir, boundaryDir) {
-    let dir = resolve(startDir);
-    const boundary = boundaryDir ? resolve(boundaryDir) : void 0;
-    for (; ; ) {
-      if (readJson(join(dir, "package.json"))?.workspaces) return dir;
-      const parent = dirname(dir);
-      if (dir === boundary || parent === dir) return void 0;
-      dir = parent;
-    }
-  }
-  async discover(rootDir) {
-    const rootPkg = readJson(join(rootDir, "package.json"));
-    const modules = [
-      {
-        id: rootPkg?.name ?? "root",
-        name: rootPkg?.name ?? "Root Workspace (npm)",
-        path: rootDir,
-        relPath: "Root",
-        ecosystem: "npm",
-        isRoot: true,
-        version: typeof rootPkg?.version === "string" ? rootPkg.version : void 0
-      }
-    ];
-    if (!rootPkg?.workspaces) return modules;
-    let workspaces;
-    try {
-      workspaces = await mapWorkspaces({ cwd: rootDir, pkg: rootPkg });
-    } catch {
-      return modules;
-    }
-    for (const [name, path] of workspaces) {
-      const pkg = readJson(join(path, "package.json"));
-      modules.push({
-        id: name,
-        name,
-        path,
-        relPath: relative(rootDir, path).replace(/\\/g, "/"),
-        ecosystem: "npm",
-        isRoot: false,
-        version: typeof pkg?.version === "string" ? pkg.version : void 0
-      });
-    }
-    modules.sort((a, b) => a.isRoot ? -1 : b.isRoot ? 1 : a.relPath.localeCompare(b.relPath));
-    return modules;
-  }
-};
-
-// src/adapters/npm/npm-registry.ts
-import semver from "semver";
 
 // src/adapters/shared/process.ts
 import { exec, spawn } from "child_process";
@@ -148,6 +99,213 @@ function quoteWindows(arg) {
   return /^[\w.:\\/@+-]+$/.test(arg) ? arg : `"${arg}"`;
 }
 
+// src/adapters/npm/npm-package-manager.ts
+var MARKER_FILES = [
+  ["npm", ["package-lock.json", "npm-shrinkwrap.json"]],
+  ["pnpm", ["pnpm-lock.yaml", "pnpm-workspace.yaml"]],
+  ["yarn", ["yarn.lock", ".yarnrc.yml"]],
+  ["bun", ["bun.lock", "bun.lockb"]]
+];
+var UnsupportedPackageManagerError = class extends Error {
+  constructor(detected) {
+    super(
+      `This repository is managed by ${detected.name} (${detected.evidence}). Elevate supports npm and pnpm for Node.js projects; using either here would create a lockfile next to ${detected.name}'s. Nothing was changed.`
+    );
+    this.name = "UnsupportedPackageManagerError";
+  }
+};
+function detectPackageManager(dir) {
+  const boundary = findCheckoutBoundary(dir);
+  let current = resolve2(dir);
+  for (; ; ) {
+    const found = detectIn(current);
+    if (found) return found;
+    const parent = dirname2(current);
+    if (boundary === void 0 || current === boundary || parent === current) break;
+    current = parent;
+  }
+  return { name: "npm", evidence: "no other package manager detected" };
+}
+function detectIn(dir) {
+  const declared = readPackageManagerField(dir);
+  const name = declared?.match(/^(npm|pnpm|yarn|bun)@/)?.[1];
+  if (declared && name) return { name, evidence: `"packageManager": "${declared}" in package.json` };
+  for (const [manager, files] of MARKER_FILES) {
+    const found = files.find((file) => existsSync2(join2(dir, file)));
+    if (found) return { name: manager, evidence: found };
+  }
+  return void 0;
+}
+function assertSupportedPackageManager(rootDir) {
+  const detected = detectPackageManager(rootDir);
+  if (detected.name === "npm" || detected.name === "pnpm") return detected.name;
+  throw new UnsupportedPackageManagerError(detected);
+}
+var PackageManagerNotFoundError = class extends Error {
+  constructor(reason, detected) {
+    super(
+      `pnpm could not be run in this repository (${reason}). This repository is managed by pnpm (${detected.evidence}); install pnpm or enable Corepack (corepack enable). Nothing was changed.`
+    );
+    this.name = "PackageManagerNotFoundError";
+  }
+};
+var VERSION_TIMEOUT_MS = 15e3;
+var verifiedRoots = /* @__PURE__ */ new Set();
+async function ensurePnpmRunnable(rootDir, detected) {
+  const key = resolve2(rootDir);
+  if (verifiedRoots.has(key)) return;
+  let reason;
+  try {
+    const result = await runCommand("pnpm", ["--version"], { cwd: rootDir, timeoutMs: VERSION_TIMEOUT_MS });
+    if (result.timedOut) reason = "pnpm --version timed out";
+    else if (result.exitCode !== 0) {
+      const line = firstLine(result.stderr) || firstLine(result.stdout);
+      reason = `pnpm --version exited with code ${result.exitCode}: ${line}`;
+    }
+  } catch {
+    reason = "command not found";
+  }
+  if (reason !== void 0) throw new PackageManagerNotFoundError(reason, detected);
+  verifiedRoots.add(key);
+}
+async function prepareSupportedPackageManager(rootDir) {
+  const manager = assertSupportedPackageManager(rootDir);
+  if (manager === "pnpm") await ensurePnpmRunnable(rootDir, detectPackageManager(rootDir));
+  return manager;
+}
+function firstLine(text) {
+  return text.split(/\r?\n/).find((l) => l.trim() !== "")?.trim() ?? "";
+}
+function readPackageManagerField(rootDir) {
+  try {
+    const field = JSON.parse(readFileSync(join2(rootDir, "package.json"), "utf8"))?.packageManager;
+    return typeof field === "string" ? field : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/adapters/npm/npm-discovery.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, join as join4, relative, resolve as resolve3 } from "path";
+import mapWorkspaces from "@npmcli/map-workspaces";
+
+// src/adapters/npm/pnpm-workspace.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+import { isMap, isScalar, parse, parseDocument } from "yaml";
+var PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function entries(value) {
+  const map = /* @__PURE__ */ new Map();
+  if (isRecord(value)) {
+    for (const [name, range] of Object.entries(value)) {
+      if (typeof range === "string") map.set(name, range);
+    }
+  }
+  return map;
+}
+function readPnpmWorkspace(rootDir) {
+  const file = join3(rootDir, PNPM_WORKSPACE_FILE);
+  let data;
+  try {
+    data = parse(readFileSync2(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+  if (data !== null && !isRecord(data)) return void 0;
+  const doc = data ?? {};
+  const packages = Array.isArray(doc.packages) ? doc.packages.filter((p) => typeof p === "string") : [];
+  const catalogs = /* @__PURE__ */ new Map();
+  const named = isRecord(doc.catalogs) ? doc.catalogs : {};
+  for (const [name, content] of Object.entries(named)) catalogs.set(name, entries(content));
+  const hasTopLevel = isRecord(doc.catalog);
+  const hasNamedDefault = isRecord(named.default);
+  if (hasTopLevel) catalogs.set("default", entries(doc.catalog));
+  return { file, packages, catalogs, ambiguousDefaultCatalog: hasTopLevel && hasNamedDefault };
+}
+function setCatalogRange(source, catalog, name, newRange) {
+  const doc = parseDocument(source);
+  const holders = catalog === "default" ? [doc.get("catalog", true), doc.getIn(["catalogs", "default"], true)] : [doc.getIn(["catalogs", catalog], true)];
+  for (const holder of holders) {
+    if (!isMap(holder)) continue;
+    const node = holder.get(name, true);
+    if (!isScalar(node) || !node.range) continue;
+    const scalar = node;
+    const [start, end] = scalar.range;
+    const quote = scalar.type === "QUOTE_DOUBLE" ? '"' : scalar.type === "QUOTE_SINGLE" ? "'" : "";
+    return source.slice(0, start) + quote + newRange + quote + source.slice(end);
+  }
+  throw new Error(`No entry for '${name}' in catalog '${catalog}' of ${PNPM_WORKSPACE_FILE}.`);
+}
+
+// src/adapters/npm/npm-discovery.ts
+function readJson(filePath) {
+  try {
+    return JSON.parse(readFileSync3(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var NpmModuleDiscoveryAdapter = class {
+  /**
+   * The nearest directory, from `startDir` upwards to the boundary, whose
+   * package.json is valid JSON and declares `workspaces`, or that contains a
+   * valid `pnpm-workspace.yaml`.
+   */
+  findRoot(startDir, boundaryDir) {
+    let dir = resolve3(startDir);
+    const boundary = boundaryDir ? resolve3(boundaryDir) : void 0;
+    for (; ; ) {
+      if (readJson(join4(dir, "package.json"))?.workspaces || readPnpmWorkspace(dir)) return dir;
+      const parent = dirname3(dir);
+      if (dir === boundary || parent === dir) return void 0;
+      dir = parent;
+    }
+  }
+  async discover(rootDir) {
+    const rootPkg = readJson(join4(rootDir, "package.json"));
+    const modules = [
+      {
+        id: rootPkg?.name ?? "root",
+        name: rootPkg?.name ?? "Root Workspace (npm)",
+        path: rootDir,
+        relPath: "Root",
+        ecosystem: "npm",
+        isRoot: true,
+        version: typeof rootPkg?.version === "string" ? rootPkg.version : void 0
+      }
+    ];
+    const patterns = detectPackageManager(rootDir).name === "pnpm" ? readPnpmWorkspace(rootDir)?.packages : rootPkg?.workspaces;
+    if (!patterns || Array.isArray(patterns) && patterns.length === 0) return modules;
+    let workspaces;
+    try {
+      workspaces = await mapWorkspaces({ cwd: rootDir, pkg: { ...rootPkg, workspaces: patterns } });
+    } catch {
+      return modules;
+    }
+    for (const [name, path] of workspaces) {
+      const pkg = readJson(join4(path, "package.json"));
+      modules.push({
+        id: name,
+        name,
+        path,
+        relPath: relative(rootDir, path).replace(/\\/g, "/"),
+        ecosystem: "npm",
+        isRoot: false,
+        version: typeof pkg?.version === "string" ? pkg.version : void 0
+      });
+    }
+    modules.sort((a, b) => a.isRoot ? -1 : b.isRoot ? 1 : a.relPath.localeCompare(b.relPath));
+    return modules;
+  }
+};
+
+// src/adapters/npm/npm-registry.ts
+import semver from "semver";
+
 // src/domain/origin.ts
 function buildWorkspaceIndex(modules) {
   const index = /* @__PURE__ */ new Map();
@@ -194,9 +352,24 @@ function npmScopeOf(name) {
   return slash > 1 ? name.slice(0, slash) : void 0;
 }
 
+// src/adapters/npm/npm-commands.ts
+function driverFor(dir) {
+  return detectPackageManager(dir).name === "pnpm" ? "pnpm" : "npm";
+}
+var commands = {
+  /** Install after Elevate wrote new ranges. pnpm is told explicitly not to freeze: `CI` would otherwise imply it. */
+  install: (m) => m === "pnpm" ? { command: "pnpm", args: ["install", "--no-frozen-lockfile"] } : { command: "npm", args: ["install"] },
+  /** Restore the installed state after a rollback. */
+  restore: (m) => m === "pnpm" ? { command: "pnpm", args: ["install", "--frozen-lockfile"] } : { command: "npm", args: ["install"] },
+  /** Default verification. */
+  verify: (m) => m === "pnpm" ? { command: "pnpm", args: ["install", "--frozen-lockfile", "--lockfile-only"] } : { command: "npm", args: ["ls"] },
+  view: (m, name, field) => ({ command: m, args: ["view", name, field, "--json"] }),
+  config: (m) => ({ command: m, args: ["config", "list", "--json"] })
+};
+
 // src/adapters/npm/npm-config.ts
 var DEFAULT_REGISTRY = "https://registry.npmjs.org/";
-var PUBLIC_NPM_HOSTS = /* @__PURE__ */ new Set(["registry.npmjs.org", "registry.npmjs.com", "registry.yarnpkg.com"]);
+var PUBLIC_NPM_HOSTS = /* @__PURE__ */ new Set(["registry.npmjs.org", "registry.npmjs.com", "registry.yarnpkg.com", "npm.jsr.io"]);
 var NpmConfigReader = class {
   cache = /* @__PURE__ */ new Map();
   /** Returns the registry configuration that applies in `cwd` (cached per directory). */
@@ -233,7 +406,8 @@ function parseNpmConfig(json) {
 }
 async function loadConfig(cwd) {
   try {
-    const result = await runCommand("npm", ["config", "list", "--json"], { cwd, timeoutMs: 15e3 });
+    const { command, args } = commands.config(driverFor(cwd));
+    const result = await runCommand(command, args, { cwd, timeoutMs: 15e3 });
     if (result.exitCode !== 0) return parseNpmConfig({});
     return parseNpmConfig(JSON.parse(result.stdout));
   } catch {
@@ -277,10 +451,11 @@ var NpmRegistryAdapter = class {
     const list = Array.isArray(versions) ? versions : versions ? [versions] : [];
     return list.map(String).reverse();
   }
-  /** Runs `npm view <name> <field> --json`; resolves null on any failure. */
+  /** Runs `npm view <name> <field> --json` (`pnpm view` in a pnpm repository); resolves null on any failure. */
   async view(name, field, cwd) {
     try {
-      const result = await runCommand("npm", ["view", name, field, "--json"], {
+      const { command, args } = commands.view(driverFor(cwd), name, field);
+      const result = await runCommand(command, args, {
         cwd,
         timeoutMs: LOOKUP_TIMEOUT_MS
       });
@@ -293,8 +468,8 @@ var NpmRegistryAdapter = class {
 };
 
 // src/adapters/npm/npm-scanner.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
 import semver3 from "semver";
 
 // src/domain/versions.ts
@@ -347,71 +522,11 @@ async function mapPooled(items, concurrency, fn) {
   return results;
 }
 
-// src/adapters/npm/npm-package-manager.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
-
-// src/adapters/shared/checkout.ts
-import { existsSync } from "fs";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-function findCheckoutBoundary(startDir) {
-  let dir = resolve2(startDir);
-  for (; ; ) {
-    if (existsSync(join2(dir, ".git"))) return dir;
-    const parent = dirname2(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-
-// src/adapters/npm/npm-package-manager.ts
-var MARKER_FILES = [
-  ["npm", ["package-lock.json", "npm-shrinkwrap.json"]],
-  ["pnpm", ["pnpm-lock.yaml", "pnpm-workspace.yaml"]],
-  ["yarn", ["yarn.lock", ".yarnrc.yml"]],
-  ["bun", ["bun.lock", "bun.lockb"]]
-];
-var UnsupportedPackageManagerError = class extends Error {
-  constructor(detected) {
-    super(
-      `This repository is managed by ${detected.name} (${detected.evidence}). Elevate supports npm for Node.js projects; using it here would create an npm lockfile next to ${detected.name}'s. Nothing was changed.`
-    );
-    this.name = "UnsupportedPackageManagerError";
-  }
-};
-function detectPackageManager(dir) {
-  const boundary = findCheckoutBoundary(dir);
-  let current = resolve3(dir);
-  for (; ; ) {
-    const found = detectIn(current);
-    if (found) return found;
-    const parent = dirname3(current);
-    if (boundary === void 0 || current === boundary || parent === current) break;
-    current = parent;
-  }
-  return { name: "npm", evidence: "no other package manager detected" };
-}
-function detectIn(dir) {
-  const declared = readPackageManagerField(dir);
-  const name = declared?.match(/^(npm|pnpm|yarn|bun)@/)?.[1];
-  if (declared && name) return { name, evidence: `"packageManager": "${declared}" in package.json` };
-  for (const [manager, files] of MARKER_FILES) {
-    const found = files.find((file) => existsSync2(join3(dir, file)));
-    if (found) return { name: manager, evidence: found };
-  }
-  return void 0;
-}
-function assertNpmManaged(rootDir) {
-  const detected = detectPackageManager(rootDir);
-  if (detected.name !== "npm") throw new UnsupportedPackageManagerError(detected);
-}
-function readPackageManagerField(rootDir) {
-  try {
-    const field = JSON.parse(readFileSync2(join3(rootDir, "package.json"), "utf8"))?.packageManager;
-    return typeof field === "string" ? field : void 0;
-  } catch {
-    return void 0;
-  }
+// src/adapters/npm/npm-protocols.ts
+function splitRangeProtocol(range) {
+  if (range.startsWith("workspace:")) return { protocol: "workspace", rest: range.slice("workspace:".length) };
+  if (range.startsWith("catalog:")) return { protocol: "catalog", rest: range.slice("catalog:".length) };
+  return { protocol: void 0, rest: range };
 }
 
 // src/adapters/npm/npm-scanner.ts
@@ -425,10 +540,11 @@ var NpmDependencyAdapter = class {
   registry;
   config;
   async scan(module, context) {
-    assertNpmManaged(context.rootDir);
+    const manager = await prepareSupportedPackageManager(context.rootDir);
+    const pnpm = manager === "pnpm";
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync3(join4(module.path, "package.json"), "utf8"));
+      pkg = JSON.parse(readFileSync4(join5(module.path, "package.json"), "utf8"));
     } catch {
       return { candidates: [], skipped: [] };
     }
@@ -442,13 +558,20 @@ var NpmDependencyAdapter = class {
         [...npmConfig.scopedRegistries].filter(([, url]) => !isPublicNpmRegistry(url))
       )
     };
+    const workspaceFile = pnpm ? readPnpmWorkspace(context.rootDir) : void 0;
     const outcomes = await mapPooled(declaredDependencies(pkg), CONCURRENCY, async (dep) => {
       const origin = classifyOrigin(dep.name, "npm", originContext);
       if (origin.kind === "workspace") {
         const target = context.workspace.get(dep.name);
-        const candidate = target ? alignmentCandidate(dep, target, origin) : null;
+        if (pnpm && isUpgradableRange(dep.range) && splitRangeProtocol(dep.range).protocol === void 0) {
+          return { skipped: { identifier: dep.name, origin: "workspace", reason: "not-linked", detail: dep.range } };
+        }
+        const candidate = target ? alignmentCandidate(dep, target, origin, pnpm) : null;
         return candidate ? { candidate } : null;
       }
+      if (pnpm && splitRangeProtocol(dep.range).protocol === "catalog") {
+        return this.catalogOutcome(dep, origin, context, module.path, workspaceFile);
+      }
       return this.registryOutcome(dep, origin, context);
     });
     const candidates = [];
@@ -461,8 +584,34 @@ var NpmDependencyAdapter = class {
     candidates.sort((a, b) => (DIFF_ORDER[a.diff] ?? 3) - (DIFF_ORDER[b.diff] ?? 3));
     return { candidates, skipped };
   }
+  /** A `catalog:` dependency: the range comes from pnpm-workspace.yaml and is written back there. */
+  async catalogOutcome(dep, origin, context, modulePath, workspaceFile) {
+    const catalogName = splitRangeProtocol(dep.range).rest || "default";
+    const unresolved = (detail) => ({
+      skipped: { identifier: dep.name, origin: origin.kind, reason: "catalog-unresolved", detail }
+    });
+    if (!workspaceFile) return unresolved("pnpm-workspace.yaml is missing or not valid YAML");
+    if (catalogName === "default" && workspaceFile.ambiguousDefaultCatalog) {
+      return unresolved("catalog 'default' is defined twice (catalog and catalogs.default)");
+    }
+    const catalog = workspaceFile.catalogs.get(catalogName);
+    if (!catalog) return unresolved(`no catalog '${catalogName}'`);
+    const range = catalog.get(dep.name);
+    if (range === void 0) return unresolved(`no entry for '${dep.name}' in catalog '${catalogName}'`);
+    const declaration = {
+      file: workspaceFile.file,
+      kind: "catalog",
+      catalogName,
+      displayPath: "pnpm-workspace.yaml"
+    };
+    const sharedWith = usersOfCatalogEntry(context, modulePath, dep.name, catalogName);
+    return this.registryOutcome({ ...dep, range }, origin, context, {
+      declaration,
+      ...sharedWith.length > 0 ? { sharedWith } : {}
+    });
+  }
   /** Looks up a private or public dependency in its registry. */
-  async registryOutcome(dep, origin, context) {
+  async registryOutcome(dep, origin, context, extra = {}) {
     if (!isUpgradableRange(dep.range)) return null;
     if (!isValidPackageName(dep.name)) {
       return { skipped: { identifier: dep.name, origin: origin.kind, reason: "invalid-name" } };
@@ -504,7 +653,8 @@ var NpmDependencyAdapter = class {
         origin: resolvedOrigin,
         action: "update",
         isPreRelease: tag !== void 0,
-        preReleaseTag: tag
+        preReleaseTag: tag,
+        ...extra
       }
     };
   }
@@ -525,11 +675,14 @@ function isUpgradableRange(range) {
   if (trimmed === "" || trimmed === "*" || trimmed.toLowerCase() === "x") return false;
   return semver3.validRange(trimmed) !== null;
 }
-function alignmentCandidate(dep, target, origin) {
+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(dep.range)) return null;
-  if (semver3.satisfies(local, dep.range, { includePrerelease: true })) return null;
-  const currentClean = semver3.minVersion(dep.range)?.version ?? "0.0.0";
+  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";
   const diff = diffVersions(currentClean, local);
   const tag = semver3.prerelease(local) ? extractPreReleaseTag(local) ?? "PRE" : void 0;
   return {
@@ -537,7 +690,7 @@ function alignmentCandidate(dep, target, origin) {
     currentRange: dep.range,
     currentClean,
     latest: local,
-    newRange: `${rangePrefix(dep.range)}${local}`,
+    newRange: `${protocol}${rangePrefix(range)}${local}`,
     diff,
     scope: dep.scope,
     selected: diff !== "major",
@@ -548,10 +701,27 @@ function alignmentCandidate(dep, target, origin) {
     preReleaseTag: tag
   };
 }
+function usersOfCatalogEntry(context, selfPath, name, catalogName) {
+  const users = [];
+  for (const module of context.workspace.values()) {
+    if (module.path === selfPath) continue;
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync4(join5(module.path, "package.json"), "utf8"));
+    } catch {
+      continue;
+    }
+    const dep = declaredDependencies(pkg).find((d) => d.name === name);
+    if (!dep || splitRangeProtocol(dep.range).protocol !== "catalog") continue;
+    if ((splitRangeProtocol(dep.range).rest || "default") !== catalogName) continue;
+    users.push(module.id);
+  }
+  return users;
+}
 
 // src/adapters/npm/npm-updater.ts
-import { readFileSync as readFileSync5, writeFileSync } from "fs";
-import { join as join6, relative as relative2 } from "path";
+import { readFileSync as readFileSync7, writeFileSync } from "fs";
+import { join as join8, relative as relative2 } from "path";
 
 // src/domain/ports.ts
 var InstallError = class extends Error {
@@ -564,13 +734,13 @@ var InstallError = class extends Error {
 };
 
 // src/adapters/npm/npm-lockfile.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
 function readLockfile(rootDir) {
-  const file = join5(rootDir, "package-lock.json");
+  const file = join6(rootDir, "package-lock.json");
   if (!existsSync3(file)) return void 0;
   try {
-    return JSON.parse(readFileSync4(file, "utf8"));
+    return JSON.parse(readFileSync5(file, "utf8"));
   } catch {
     return void 0;
   }
@@ -591,51 +761,168 @@ function findUnlinkedWorkspaceDependencies(lockfile, moduleRelPath, names) {
   return violations;
 }
 
+// src/adapters/npm/pnpm-audit.ts
+var AUDIT_TIMEOUT_MS = 6e4;
+var LEVELS = ["info", "low", "moderate", "high", "critical"];
+function unavailable(reason) {
+  return { message: `Vulnerability check unavailable: ${reason}.`, severity: "warn" };
+}
+function parsePnpmAudit(output) {
+  let json;
+  try {
+    json = JSON.parse(output);
+  } catch {
+    return unavailable("pnpm audit returned no result");
+  }
+  const counts = json?.metadata?.vulnerabilities;
+  if (counts && typeof counts === "object") {
+    const parts = [];
+    let total = 0;
+    for (const level of LEVELS) {
+      const n = Number(counts[level]) || 0;
+      total += n;
+      if (n > 0) parts.push(`${n} ${level}`);
+    }
+    if (total === 0) return { message: "No known vulnerabilities found.", severity: "clean" };
+    return {
+      message: `${total} ${total === 1 ? "vulnerability" : "vulnerabilities"} (${parts.join(", ")})`,
+      severity: "warn"
+    };
+  }
+  const errorMessage = json?.error?.message;
+  if (typeof errorMessage === "string" && errorMessage) return unavailable(errorMessage);
+  return unavailable("pnpm audit returned no result");
+}
+
+// src/adapters/npm/pnpm-lockfile.ts
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
+import { parse as parse2 } from "yaml";
+var SECTIONS = ["dependencies", "devDependencies", "optionalDependencies"];
+function readPnpmLockfile(rootDir) {
+  const file = join7(rootDir, "pnpm-lock.yaml");
+  if (!existsSync4(file)) return { kind: "missing" };
+  let data;
+  try {
+    data = parse2(readFileSync6(file, "utf8"));
+  } catch {
+    return { kind: "unreadable" };
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return { kind: "unreadable" };
+  const lockfileVersion = String(data.lockfileVersion ?? "");
+  if (!/^9(\.|$)/.test(lockfileVersion)) return { kind: "unsupported", lockfileVersion };
+  const importers = data.importers ?? {};
+  if (typeof importers !== "object" || Array.isArray(importers)) return { kind: "unreadable" };
+  return { kind: "ok", importers };
+}
+function findUnlinkedPnpmDependencies(lockfile, moduleRelPath, names) {
+  switch (lockfile.kind) {
+    case "missing":
+      return ["pnpm-lock.yaml is missing; workspace links cannot be verified"];
+    case "unreadable":
+      return ["pnpm-lock.yaml could not be read; workspace links cannot be verified"];
+    case "unsupported":
+      return [
+        `pnpm-lock.yaml has lockfileVersion '${lockfile.lockfileVersion}', which Elevate cannot read; workspace links cannot be verified`
+      ];
+  }
+  const importer = lockfile.importers[moduleRelPath === "" ? "." : moduleRelPath] ?? {};
+  const violations = [];
+  for (const name of names) {
+    let entry;
+    for (const section of SECTIONS) {
+      entry = importer[section]?.[name];
+      if (entry) break;
+    }
+    if (!entry) violations.push(`${name}: not present in pnpm-lock.yaml`);
+    else if (!String(entry.version).startsWith("link:")) {
+      violations.push(`${name}: resolved to ${entry.version} instead of linking the workspace package`);
+    }
+  }
+  return violations;
+}
+
 // src/adapters/npm/npm-updater.ts
 var INSTALL_TIMEOUT_MS = 10 * 6e4;
+function failureDetails(manager, result) {
+  return manager === "pnpm" ? tail(`${result.stdout}
+${result.stderr}`) : tail(result.stderr || result.stdout);
+}
 var NpmUpdaterAdapter = class {
   affectedFiles(module, rootDir) {
+    if (detectPackageManager(rootDir).name === "pnpm") {
+      return [
+        join8(module.path, "package.json"),
+        join8(rootDir, "package.json"),
+        join8(rootDir, "pnpm-lock.yaml"),
+        join8(rootDir, "pnpm-workspace.yaml")
+      ];
+    }
     return [
-      join6(module.path, "package.json"),
-      join6(rootDir, "package.json"),
-      join6(rootDir, "package-lock.json"),
-      join6(rootDir, "npm-shrinkwrap.json")
+      join8(module.path, "package.json"),
+      join8(rootDir, "package.json"),
+      join8(rootDir, "package-lock.json"),
+      join8(rootDir, "npm-shrinkwrap.json")
     ];
   }
   async applyUpdates(module, rootDir, updates, onProgress) {
+    let manager;
     try {
-      assertNpmManaged(rootDir);
+      manager = await prepareSupportedPackageManager(rootDir);
     } catch (err) {
-      if (err instanceof UnsupportedPackageManagerError) throw new InstallError(err.message);
+      if (err instanceof UnsupportedPackageManagerError || err instanceof PackageManagerNotFoundError) {
+        throw new InstallError(err.message);
+      }
       throw err;
     }
-    const pkgPath = join6(module.path, "package.json");
-    let source;
-    let pkg;
-    try {
-      source = readFileSync5(pkgPath, "utf8");
-      pkg = JSON.parse(source);
-    } catch {
-      throw new InstallError(`Cannot read package.json in ${module.path}.`);
+    const catalogUpdates = updates.filter((u) => u.declaration?.kind === "catalog");
+    const manifestUpdates = updates.filter((u) => u.declaration?.kind !== "catalog");
+    const pkgPath = join8(module.path, "package.json");
+    let manifest;
+    if (manifestUpdates.length > 0 || catalogUpdates.length === 0) {
+      try {
+        const source = readFileSync7(pkgPath, "utf8");
+        manifest = { source, pkg: JSON.parse(source) };
+      } catch {
+        throw new InstallError(`Cannot read package.json in ${module.path}.`);
+      }
     }
-    onProgress("Writing new versions to package.json\u2026");
-    for (const item of updates) {
-      const name = item.coordinate.artifact;
-      for (const section of DEPENDENCY_SECTIONS) {
-        if (typeof pkg[section]?.[name] === "string") pkg[section][name] = item.newRange;
+    if (manifest) {
+      onProgress("Writing new versions to package.json\u2026");
+      for (const item of manifestUpdates) {
+        const name = item.coordinate.artifact;
+        for (const section of DEPENDENCY_SECTIONS) {
+          if (typeof manifest.pkg[section]?.[name] === "string") manifest.pkg[section][name] = item.newRange;
+        }
       }
+      writeFileSync(pkgPath, serializeLike(manifest.source, manifest.pkg), "utf8");
+    }
+    if (catalogUpdates.length > 0) {
+      onProgress("Writing new versions to pnpm-workspace.yaml\u2026");
+      writeCatalogRanges(catalogUpdates);
     }
-    writeFileSync(pkgPath, serializeLike(source, pkg), "utf8");
-    onProgress("Running npm install\u2026");
-    const install = await runCommand("npm", ["install"], { cwd: rootDir, timeoutMs: INSTALL_TIMEOUT_MS });
-    if (install.exitCode !== 0) {
-      const reason = install.timedOut ? "npm install timed out" : "npm install failed";
-      throw new InstallError(reason, tail(install.stderr || install.stdout));
-    }
-    onProgress("Checking workspace links in package-lock.json\u2026");
-    const integrityViolations = verifyAlignedLinks(module, rootDir, updates);
-    const combined = `${install.stdout}
-${install.stderr}`;
+    const install = commands.install(manager);
+    onProgress(`Running ${manager} install\u2026`);
+    const result = await runCommand(install.command, install.args, { cwd: rootDir, timeoutMs: INSTALL_TIMEOUT_MS });
+    if (result.exitCode !== 0) {
+      const reason = result.timedOut ? `${manager} install timed out` : `${manager} install failed`;
+      throw new InstallError(reason, failureDetails(manager, result));
+    }
+    const lockName = manager === "pnpm" ? "pnpm-lock.yaml" : "package-lock.json";
+    onProgress(`Checking workspace links in ${lockName}\u2026`);
+    const integrityViolations = verifyAlignedLinks(manager, module, rootDir, updates);
+    if (manager === "pnpm") {
+      const audit2 = integrityViolations.length > 0 ? void 0 : await runPnpmAudit(rootDir);
+      return {
+        updatedCount: updates.length,
+        auditMessage: audit2?.message ?? "",
+        auditSeverity: audit2?.severity ?? "clean",
+        fundingMessage: void 0,
+        integrityViolations
+      };
+    }
+    const combined = `${result.stdout}
+${result.stderr}`;
     const audit = parseAuditSummary(combined);
     const fundingMatch = combined.match(/(\d+ packages? (?:is|are) looking for funding)/i);
     return {
@@ -647,14 +934,42 @@ ${install.stderr}`;
     };
   }
   async resync(_module, rootDir, onProgress) {
-    if (detectPackageManager(rootDir).name !== "npm") return;
-    onProgress("Restoring node_modules (npm install)\u2026");
-    const result = await runCommand("npm", ["install"], { cwd: rootDir, timeoutMs: INSTALL_TIMEOUT_MS });
+    const name = detectPackageManager(rootDir).name;
+    if (name !== "npm" && name !== "pnpm") return;
+    const restore = commands.restore(name);
+    onProgress(`Restoring node_modules (${name} install)\u2026`);
+    const result = await runCommand(restore.command, restore.args, { cwd: rootDir, timeoutMs: INSTALL_TIMEOUT_MS });
     if (result.exitCode !== 0) {
-      throw new InstallError("npm install failed while restoring the previous state", tail(result.stderr));
+      throw new InstallError(
+        `${name} install failed while restoring the previous state`,
+        name === "pnpm" ? failureDetails(name, result) : tail(result.stderr)
+      );
     }
   }
 };
+function writeCatalogRanges(updates) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const item of updates) {
+    const declaration = item.declaration;
+    try {
+      let source = sources.get(declaration.file) ?? readFileSync7(declaration.file, "utf8");
+      source = setCatalogRange(source, declaration.catalogName ?? "default", item.coordinate.artifact, item.newRange);
+      sources.set(declaration.file, source);
+    } catch (err) {
+      throw new InstallError(err instanceof Error ? err.message : `Cannot update ${declaration.displayPath}.`);
+    }
+  }
+  for (const [file, source] of sources) writeFileSync(file, source, "utf8");
+}
+async function runPnpmAudit(rootDir) {
+  try {
+    const result = await runCommand("pnpm", ["audit", "--json"], { cwd: rootDir, timeoutMs: AUDIT_TIMEOUT_MS });
+    if (result.timedOut) return unavailable(`pnpm audit timed out after ${AUDIT_TIMEOUT_MS / 1e3} seconds`);
+    return parsePnpmAudit(result.stdout);
+  } catch {
+    return unavailable("pnpm audit returned no result");
+  }
+}
 var VULNERABILITY_LINE = /^(?:found\s+)?(\d+)\s+(?:(?:info|low|moderate|high|critical)\s+severity\s+)?vulnerabilit(?:y|ies)\b.*$/i;
 function parseAuditSummary(output) {
   for (const line of output.split(/\r?\n/)) {
@@ -663,12 +978,13 @@ function parseAuditSummary(output) {
   }
   return { message: "No known vulnerabilities found.", severity: "clean" };
 }
-function verifyAlignedLinks(module, rootDir, updates) {
+function verifyAlignedLinks(manager, module, rootDir, updates) {
   const aligned = updates.filter((u) => u.origin.kind === "workspace").map((u) => u.coordinate.identifier);
   if (aligned.length === 0) return [];
+  const moduleRelPath = relative2(rootDir, module.path).replace(/\\/g, "/");
+  if (manager === "pnpm") return findUnlinkedPnpmDependencies(readPnpmLockfile(rootDir), moduleRelPath, aligned);
   const lockfile = readLockfile(rootDir);
   if (!lockfile) return ["package-lock.json is missing; workspace links cannot be verified"];
-  const moduleRelPath = relative2(rootDir, module.path).replace(/\\/g, "/");
   return findUnlinkedWorkspaceDependencies(lockfile, moduleRelPath, aligned);
 }
 function serializeLike(original, value) {
@@ -682,24 +998,28 @@ function serializeLike(original, value) {
 var VERIFY_TIMEOUT_MS = 10 * 6e4;
 var NpmVerificationAdapter = class {
   async verify(_module, rootDir, options = {}) {
-    const label = options.customLabel || options.customScript || "Dependency tree integrity (npm ls)";
+    let manager = "npm";
     if (!options.customScript) {
       try {
-        assertNpmManaged(rootDir);
+        manager = await prepareSupportedPackageManager(rootDir);
       } catch (err) {
-        if (err instanceof UnsupportedPackageManagerError) return { status: "warn", details: err.message, label };
+        if (err instanceof UnsupportedPackageManagerError || err instanceof PackageManagerNotFoundError) {
+          return { status: "warn", details: err.message, label: options.customLabel || "Dependency verification" };
+        }
         throw err;
       }
     }
-    const result = options.customScript ? await runShellScript(options.customScript, { cwd: rootDir, timeoutMs: VERIFY_TIMEOUT_MS }) : await runCommand("npm", ["ls"], { cwd: rootDir, timeoutMs: VERIFY_TIMEOUT_MS });
+    const defaultLabel = manager === "pnpm" ? "Lockfile consistency (pnpm install --frozen-lockfile)" : "Dependency tree integrity (npm ls)";
+    const label = options.customLabel || options.customScript || defaultLabel;
+    const verify = commands.verify(manager);
+    const result = options.customScript ? await runShellScript(options.customScript, { cwd: rootDir, timeoutMs: VERIFY_TIMEOUT_MS }) : await runCommand(verify.command, verify.args, { cwd: rootDir, timeoutMs: VERIFY_TIMEOUT_MS });
     if (result.exitCode === 0) {
-      return { status: "clean", details: "All dependencies are installed and consistent.", label };
+      const details = manager === "pnpm" && !options.customScript ? "pnpm-lock.yaml is up to date with all package.json files." : "All dependencies are installed and consistent.";
+      return { status: "clean", details, label };
     }
-    return {
-      status: "warn",
-      details: result.timedOut ? "Verification timed out." : tail(result.stderr || result.stdout),
-      label
-    };
+    const output = manager === "pnpm" && !options.customScript ? tail(`${result.stdout}
+${result.stderr}`) : tail(result.stderr || result.stdout);
+    return { status: "warn", details: result.timedOut ? "Verification timed out." : output, label };
   }
 };
 
@@ -707,6 +1027,12 @@ var NpmVerificationAdapter = class {
 var NpmEcosystemStrategy = class {
   ecosystem = "npm";
   displayName = "Node / npm";
+  packageManagerFor(rootDir) {
+    return detectPackageManager(rootDir).name;
+  }
+  displayNameFor(rootDir) {
+    return detectPackageManager(rootDir).name === "pnpm" ? "Node / pnpm" : "Node / npm";
+  }
   icon = "\u{1F4E6}";
   manifestFile = "package.json";
   discovery = new NpmModuleDiscoveryAdapter();
@@ -724,16 +1050,16 @@ var NpmEcosystemStrategy = class {
 };
 
 // src/adapters/maven/maven-discovery.ts
-import { existsSync as existsSync6 } from "fs";
-import { dirname as dirname5, join as join9, relative as relative3, resolve as resolve6 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { dirname as dirname5, join as join11, relative as relative3, resolve as resolve6 } from "path";
 
 // src/adapters/maven/maven-project.ts
-import { existsSync as existsSync5, readdirSync, statSync as statSync2 } from "fs";
-import { join as join8, resolve as resolve5 } from "path";
+import { existsSync as existsSync6, readdirSync, statSync as statSync2 } from "fs";
+import { join as join10, resolve as resolve5 } from "path";
 
 // src/adapters/maven/maven-pom.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6, statSync } from "fs";
-import { dirname as dirname4, join as join7, resolve as resolve4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync8, statSync } from "fs";
+import { dirname as dirname4, join as join9, resolve as resolve4 } from "path";
 
 // src/adapters/shared/xml.ts
 import { SaxesParser } from "saxes";
@@ -868,7 +1194,7 @@ function localName(qualified) {
 
 // src/adapters/maven/maven-pom.ts
 function readPom(file) {
-  const source = readFileSync6(file, "utf8");
+  const source = readFileSync8(file, "utf8");
   return parsePom(source, file);
 }
 function parsePom(source, file) {
@@ -917,8 +1243,8 @@ function parentPomFile(pom) {
   const relativePath = pom.parent.relativePath ?? "../pom.xml";
   if (relativePath === "") return void 0;
   let candidate = resolve4(pom.dir, relativePath);
-  if (existsSync4(candidate) && statSync(candidate).isDirectory()) candidate = join7(candidate, "pom.xml");
-  return existsSync4(candidate) ? candidate : void 0;
+  if (existsSync5(candidate) && statSync(candidate).isDirectory()) candidate = join9(candidate, "pom.xml");
+  return existsSync5(candidate) ? candidate : void 0;
 }
 function builtinProperty(name, module) {
   switch (name) {
@@ -994,8 +1320,8 @@ 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 : join8(target, "pom.xml");
-        if (!seen.has(moduleFile) && existsSync5(moduleFile)) {
+        const moduleFile = target.endsWith(".xml") ? target : join10(target, "pom.xml");
+        if (!seen.has(moduleFile) && existsSync6(moduleFile)) {
           seen.add(moduleFile);
           queue.push(moduleFile);
         }
@@ -1065,7 +1391,7 @@ var MavenProject = class _MavenProject {
         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 : join8(target, "pom.xml");
+          const file = target.endsWith(".xml") ? target : join10(target, "pom.xml");
           const modulePom = this.byFile.get(file);
           if (modulePom) queue.push(modulePom);
         }
@@ -1075,23 +1401,23 @@ var MavenProject = class _MavenProject {
 };
 function findPomFiles(rootDir) {
   const results = [];
-  const rootPom = join8(rootDir, "pom.xml");
-  if (existsSync5(rootPom)) results.push(resolve5(rootPom));
+  const rootPom = join10(rootDir, "pom.xml");
+  if (existsSync6(rootPom)) results.push(resolve5(rootPom));
   const walk = (dir, depth) => {
     if (depth > MAX_DEPTH) return;
-    let entries;
+    let entries2;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries2 = readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
-    const isProject = existsSync5(join8(dir, "pom.xml"));
-    for (const entry of entries) {
+    const isProject = existsSync6(join10(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 = join8(dir, entry.name);
-      const pom = join8(subDir, "pom.xml");
-      if (existsSync5(pom) && statSync2(pom).isFile()) results.push(resolve5(pom));
+      const subDir = join10(dir, entry.name);
+      const pom = join10(subDir, "pom.xml");
+      if (existsSync6(pom) && statSync2(pom).isFile()) results.push(resolve5(pom));
       walk(subDir, depth + 1);
     }
   };
@@ -1107,7 +1433,7 @@ var MavenModuleDiscoveryAdapter = class {
    */
   findRoot(startDir, boundaryDir) {
     let dir = resolve6(startDir);
-    if (!existsSync6(join9(dir, "pom.xml"))) return void 0;
+    if (!existsSync7(join11(dir, "pom.xml"))) return void 0;
     const boundary = boundaryDir ? resolve6(boundaryDir) : void 0;
     for (; ; ) {
       const above = pomAbove(dir, boundary);
@@ -1154,7 +1480,7 @@ function ancestorsWithin(dir, boundary) {
   return result;
 }
 function pomAbove(dir, boundary) {
-  const pom = tryReadPom(join9(dir, "pom.xml"));
+  const pom = tryReadPom(join11(dir, "pom.xml"));
   if (!pom) return void 0;
   const ancestors = ancestorsWithin(dir, boundary);
   const found = [];
@@ -1166,9 +1492,9 @@ function pomAbove(dir, boundary) {
       found.push(dirname5(parentFile));
     }
   }
-  const ownFile = join9(dir, "pom.xml");
+  const ownFile = join11(dir, "pom.xml");
   const aggregator = ancestors.find(
-    (ancestor) => tryReadPom(join9(ancestor, "pom.xml"))?.modules.some((entry) => {
+    (ancestor) => tryReadPom(join11(ancestor, "pom.xml"))?.modules.some((entry) => {
       const target = resolve6(ancestor, entry);
       return target === dir || target === ownFile;
     })
@@ -1178,12 +1504,12 @@ function pomAbove(dir, boundary) {
 }
 
 // src/adapters/maven/maven-registry.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join14 } from "path";
 
 // src/adapters/maven/maven-command.ts
-import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname6, isAbsolute, join as join10, relative as relative4, resolve as resolve7, sep } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { dirname as dirname6, isAbsolute, join as join12, relative as relative4, resolve as resolve7, 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.");
@@ -1206,8 +1532,8 @@ function findMavenWrapper(fromDir, rootDir) {
   let dir = resolve7(fromDir);
   const root = resolve7(rootDir);
   for (; ; ) {
-    const candidate = join10(dir, WRAPPER);
-    if (existsSync7(candidate)) return candidate;
+    const candidate = join12(dir, WRAPPER);
+    if (existsSync8(candidate)) return candidate;
     if (dir === root || relative4(root, dir).startsWith("..")) return void 0;
     const parent = dirname6(dir);
     if (parent === dir) return void 0;
@@ -1240,8 +1566,8 @@ function mavenErrors(output) {
 
 // src/adapters/maven/maven-resolution.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync8, mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync9, mkdirSync, readFileSync as readFileSync9, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join13 } 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";
@@ -1273,9 +1599,9 @@ var ScratchDirectory = class {
   target;
   createdTarget;
   constructor(moduleDir) {
-    this.target = join11(moduleDir, "target");
-    this.createdTarget = !existsSync8(this.target);
-    this.path = join11(this.target, `.elevate-${randomUUID().slice(0, 8)}`);
+    this.target = join13(moduleDir, "target");
+    this.createdTarget = !existsSync9(this.target);
+    this.path = join13(this.target, `.elevate-${randomUUID().slice(0, 8)}`);
     mkdirSync(this.path, { recursive: true });
   }
   dispose() {
@@ -1287,7 +1613,7 @@ var ScratchDirectory = class {
   }
 };
 async function readEffectivePoms(pomFile, moduleDir, rootDir, scratch, plugins, recursive = false) {
-  const output = join11(scratch.path, "effective-pom.xml");
+  const output = join13(scratch.path, "effective-pom.xml");
   const args = [
     "-f",
     relativeToCwd(moduleDir, pomFile),
@@ -1299,7 +1625,7 @@ async function readEffectivePoms(pomFile, moduleDir, rootDir, scratch, plugins,
     rootDir,
     timeoutMs: MAVEN_TIMEOUT_MS
   });
-  if (result.exitCode !== 0 || !existsSync8(output)) {
+  if (result.exitCode !== 0 || !existsSync9(output)) {
     const text = `${result.stdout}
 ${result.stderr}`;
     if (isPluginUnavailable(text, HELP_PLUGIN_ID)) {
@@ -1311,7 +1637,7 @@ ${result.stderr}`;
     throw new MavenCommandError(`Maven could not build the effective POM:
 ${mavenErrors(text)}`, text);
   }
-  return parseEffectivePoms(readFileSync7(output, "utf8"));
+  return parseEffectivePoms(readFileSync9(output, "utf8"));
 }
 function parseEffectivePoms(source) {
   const root = parseXml(source);
@@ -1360,7 +1686,7 @@ function readEffectiveDependencies(container) {
 }
 function buildProbePom(artifacts, model) {
   const seen = /* @__PURE__ */ new Set();
-  const entries = [];
+  const entries2 = [];
   for (const artifact of artifacts) {
     const key = `${artifact.groupId}:${artifact.artifactId}:${artifact.type ?? "jar"}:${artifact.classifier ?? ""}`;
     if (seen.has(key)) continue;
@@ -1372,7 +1698,7 @@ function buildProbePom(artifacts, model) {
       artifact.type && artifact.type !== "jar" ? `<type>${escapeXml(artifact.type)}</type>` : "",
       artifact.classifier ? `<classifier>${escapeXml(artifact.classifier)}</classifier>` : ""
     ].filter(Boolean);
-    entries.push(`      <dependency>${fields.join("")}</dependency>`);
+    entries2.push(`      <dependency>${fields.join("")}</dependency>`);
   }
   const repositories = [model.repositories, model.pluginRepositories].filter((element) => element !== void 0).map((element) => serializeXml(element, "  ")).join("\n");
   return [
@@ -1386,7 +1712,7 @@ function buildProbePom(artifacts, model) {
     repositories,
     "  <dependencyManagement>",
     "    <dependencies>",
-    ...entries,
+    ...entries2,
     "    </dependencies>",
     "  </dependencyManagement>",
     "</project>",
@@ -1395,9 +1721,9 @@ 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 = join11(scratch.path, "probe");
+  const probeDir = join13(scratch.path, "probe");
   mkdirSync(probeDir, { recursive: true });
-  const probePom = join11(probeDir, "pom.xml");
+  const probePom = join13(probeDir, "pom.xml");
   writeFileSync2(probePom, buildProbePom(artifacts, model), "utf8");
   const result = await runMaven(
     [
@@ -1412,8 +1738,8 @@ async function queryNewerVersions(artifacts, model, moduleDir, rootDir, scratch,
   );
   const log = `${result.stdout}
 ${result.stderr}`;
-  const reportFile = join11(probeDir, "target", "dependency-updates-report.xml");
-  if (result.exitCode !== 0 || !existsSync8(reportFile)) {
+  const reportFile = join13(probeDir, "target", "dependency-updates-report.xml");
+  if (result.exitCode !== 0 || !existsSync9(reportFile)) {
     if (isPluginUnavailable(log, VERSIONS_PLUGIN_ID)) {
       throw new MavenPluginUnavailableError(
         { id: VERSIONS_PLUGIN_ID, version: plugins.versions, key: "versions", purpose: "look up newer versions" },
@@ -1424,7 +1750,7 @@ ${result.stderr}`;
 ${mavenErrors(log)}`, log);
   }
   return {
-    newerVersions: parseUpdatesReport(readFileSync7(reportFile, "utf8")),
+    newerVersions: parseUpdatesReport(readFileSync9(reportFile, "utf8")),
     failedLookups: parseFailedLookups(log)
   };
 }
@@ -1509,14 +1835,14 @@ var MavenRegistryAdapter = class {
   }
 };
 async function projectRepositories(cwd, scratch, plugins) {
-  const rootPom = join12(cwd, "pom.xml");
-  if (!existsSync9(rootPom)) return NO_REPOSITORIES;
+  const rootPom = join14(cwd, "pom.xml");
+  if (!existsSync10(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 join13 } from "path";
+import { join as join15 } from "path";
 import semver4 from "semver";
 
 // src/adapters/maven/maven-locator.ts
@@ -1661,14 +1987,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(join13(module.path, "pom.xml"));
+    const pom = project.pomAt(join15(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 ? join13(reactor, "pom.xml") : void 0,
+      aggregatorPom: batched ? join15(reactor, "pom.xml") : void 0,
       members: []
     };
     group.members.push({ module, pom });
@@ -1836,11 +2162,11 @@ function markSharedDeclarations(candidates) {
 }
 
 // src/adapters/maven/maven-updater.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
-import { join as join14, resolve as resolve8 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync3 } from "fs";
+import { join as join16, resolve as resolve8 } from "path";
 var MavenUpdaterAdapter = class {
   affectedFiles(module, _rootDir, updates) {
-    const files = new Set(updates.map((u) => resolve8(u.declaration?.file ?? join14(module.path, "pom.xml"))));
+    const files = new Set(updates.map((u) => resolve8(u.declaration?.file ?? join16(module.path, "pom.xml"))));
     return [...files];
   }
   async applyUpdates(module, rootDir, updates, onProgress) {
@@ -1856,7 +2182,7 @@ var MavenUpdaterAdapter = class {
     const writes = [];
     for (const [file, fileUpdates] of byFile) {
       onProgress(`Preparing ${fileUpdates.length} change(s) in ${fileUpdates[0].declaration.displayPath}\u2026`);
-      const source = readFileSync8(file, "utf8");
+      const source = readFileSync10(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);
@@ -1926,14 +2252,14 @@ function describe(declaration) {
 }
 
 // src/adapters/maven/maven-verifier.ts
-import { dirname as dirname7, join as join15, relative as relative6, resolve as resolve9 } from "path";
+import { dirname as dirname7, join as join17, relative as relative6, resolve as resolve9 } from "path";
 var VERIFY_TIMEOUT_MS2 = 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 });
-      return result.exitCode === 0 ? { status: "clean", details: "Verification script succeeded.", label: label2 } : { status: "warn", details: failureDetails(result), label: label2 };
+      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 ?? []);
     const label = `Maven build (${["test-compile", ...plan.args].join(" ")})`;
@@ -1946,7 +2272,7 @@ var MavenVerificationAdapter = class {
       if (result.exitCode === 0) {
         return { status: "clean", details: "All affected modules compile, including tests.", label };
       }
-      const details = result.timedOut ? "Maven build timed out." : failureDetails(result);
+      const details = result.timedOut ? "Maven build timed out." : failureDetails2(result);
       return { status: "warn", details, label };
     } catch (err) {
       if (err instanceof MavenUnavailableError) return { status: "warn", details: err.message, label };
@@ -1954,7 +2280,7 @@ var MavenVerificationAdapter = class {
     }
   }
 };
-function failureDetails(result) {
+function failureDetails2(result) {
   const output = `${result.stdout}
 ${result.stderr}`.trim();
   return output ? mavenErrors(output) : `Exited with code ${result.exitCode}.`;
@@ -1963,7 +2289,7 @@ 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 : [join15(module.path, "pom.xml")];
+  const files = changedFiles.length > 0 ? changedFiles : [join17(module.path, "pom.xml")];
   const selected = /* @__PURE__ */ new Set();
   for (const file of files) {
     const pom = project.pomAt(file);
@@ -2038,7 +2364,7 @@ function findRepositoryRoot(startDir) {
   const boundary = findCheckoutBoundary(start);
   let dir = start;
   for (; ; ) {
-    if (existsSync10(join16(dir, "elevate.config.json"))) return dir;
+    if (existsSync11(join18(dir, "elevate.config.json"))) return dir;
     const parent = dirname8(dir);
     if (dir === boundary || parent === dir) break;
     dir = parent;
@@ -2104,15 +2430,15 @@ function resolveConfig(rootDir, file, source = "elevate.config.json") {
 }
 function loadConfig2(startDir = process.cwd()) {
   const rootDir = findRepositoryRoot(startDir);
-  const configPath = join16(rootDir, "elevate.config.json");
+  const configPath = join18(rootDir, "elevate.config.json");
   let file = {};
-  if (existsSync10(configPath)) {
+  if (existsSync11(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(readFileSync9(configPath, "utf8").replace(/^/, ""));
+      parsed = JSON.parse(readFileSync11(configPath, "utf8").replace(/^/, ""));
     } catch (err) {
       throw unreadable(err instanceof Error ? err.message : String(err));
     }
@@ -2161,7 +2487,9 @@ var de = {
       "lookup-failed": "Abfrage der Registry fehlgeschlagen",
       "managed-externally": "Version wird au\xDFerhalb dieses Repos verwaltet",
       "declaration-mismatch": "Ort der Versionsangabe ist nicht eindeutig",
-      "invalid-name": "ung\xFCltiger Paketname"
+      "invalid-name": "ung\xFCltiger Paketname",
+      "not-linked": "Workspace-Paket, das pnpm ohne das workspace:-Protokoll nicht verlinkt",
+      "catalog-unresolved": "Catalog-Eintrag konnte nicht aufgel\xF6st werden"
     })[reason]
   },
   badges: {
@@ -2267,7 +2595,9 @@ var en = {
       "lookup-failed": "registry lookup failed",
       "managed-externally": "version is managed outside this repository",
       "declaration-mismatch": "version location is ambiguous",
-      "invalid-name": "invalid package name"
+      "invalid-name": "invalid package name",
+      "not-linked": "workspace package that pnpm does not link without the workspace: protocol",
+      "catalog-unresolved": "catalog entry could not be resolved"
     })[reason]
   },
   badges: {
@@ -2461,7 +2791,12 @@ function candidateToJson(u) {
     scope: u.scope,
     isPreRelease: u.isPreRelease ?? false,
     preReleaseTag: u.preReleaseTag,
-    declaredIn: u.declaration ? { file: u.declaration.displayPath, kind: u.declaration.kind, property: u.declaration.propertyName } : void 0,
+    declaredIn: u.declaration ? {
+      file: u.declaration.displayPath,
+      kind: u.declaration.kind,
+      property: u.declaration.propertyName,
+      catalog: u.declaration.catalogName
+    } : void 0,
     sharedWith: u.sharedWith
   };
 }
@@ -2583,24 +2918,24 @@ 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 existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { relative as relative7 } from "path";
 
 // src/adapters/shared/file-snapshot.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync12, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
 var FileSnapshot = class _FileSnapshot {
-  constructor(entries) {
-    this.entries = entries;
+  constructor(entries2) {
+    this.entries = entries2;
   }
   entries;
   /** Records the current content (or absence) of each file. */
   static capture(files) {
-    const entries = /* @__PURE__ */ new Map();
+    const entries2 = /* @__PURE__ */ new Map();
     for (const file of files) {
-      if (entries.has(file)) continue;
-      entries.set(file, existsSync11(file) ? readFileSync10(file) : null);
+      if (entries2.has(file)) continue;
+      entries2.set(file, existsSync12(file) ? readFileSync12(file) : null);
     }
-    return new _FileSnapshot(entries);
+    return new _FileSnapshot(entries2);
   }
   /** The files covered by this snapshot. */
   get files() {
@@ -2610,9 +2945,9 @@ var FileSnapshot = class _FileSnapshot {
   changedFiles() {
     return this.files.filter((file) => {
       const before = this.entries.get(file) ?? null;
-      const exists = existsSync11(file);
+      const exists = existsSync12(file);
       if (before === null) return exists;
-      return !exists || !readFileSync10(file).equals(before);
+      return !exists || !readFileSync12(file).equals(before);
     });
   }
   /** Writes every file back to its captured state; removes files that did not exist. */
@@ -2660,7 +2995,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) => existsSync12(file)));
+    baseline = await verify(snapshot.files.filter((file) => existsSync13(file)));
   }
   let applied;
   try {
@@ -2864,7 +3199,8 @@ var Header = ({
   currentLocale,
   strategy,
   nextStrategyName,
-  channel
+  channel,
+  rootDir
 }) => /* @__PURE__ */ jsxs2(
   Box2,
   {
@@ -2885,7 +3221,7 @@ var Header = ({
           /* @__PURE__ */ jsxs2(Text2, { color: theme.colors.brandLight, bold: true, children: [
             strategy.icon,
             " ",
-            strategy.displayName
+            rootDir && strategy.displayNameFor?.(rootDir) || strategy.displayName
           ] }),
           /* @__PURE__ */ jsxs2(Text2, { color: theme.colors.muted, children: [
             " [",
@@ -3733,7 +4069,8 @@ var App = ({ config }) => {
           currentLocale: locale,
           strategy,
           nextStrategyName: `${nextStrategy.icon} ${nextStrategy.displayName}`,
-          channel: config.channel
+          channel: config.channel,
+          rootDir: config.rootDir
         }
       ),
       view === "workspace_modal" && /* @__PURE__ */ jsx14(
@@ -3931,12 +4268,14 @@ async function handleModulesCommand(options, config) {
   const ecosystem = options.ecosystem ?? "npm";
   const strategy = EcosystemFactory.getStrategy(ecosystem);
   const modules = await strategy.discovery.discover(config.rootDir);
+  const displayName = strategy.displayNameFor?.(config.rootDir) ?? strategy.displayName;
+  const packageManager = strategy.packageManagerFor?.(config.rootDir);
   if (options.json) {
-    console.log(JSON.stringify({ ecosystem, count: modules.length, modules }, null, 2));
+    console.log(JSON.stringify({ ecosystem, ...packageManager ? { packageManager } : {}, count: modules.length, modules }, null, 2));
     return 0;
   }
   console.log(`
-\u{1FAB6} Discovered ${strategy.icon} ${strategy.displayName} Modules (${modules.length}):
+\u{1FAB6} Discovered ${strategy.icon} ${displayName} Modules (${modules.length}):
 `);
   for (const m of modules) {
     const isRootBadge = m.isRoot ? " [ROOT]" : "";
@@ -3960,6 +4299,10 @@ function describeSkip(skipped) {
       return `version location is ambiguous${detail}`;
     case "invalid-name":
       return "not a valid package name";
+    case "not-linked":
+      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}`;
   }
 }
 
@@ -4366,9 +4709,9 @@ function parsePackageArgument(item) {
 }
 
 // src/cli/command-init.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2 } from "fs";
 import { homedir, platform } from "os";
-import { join as join17, resolve as resolve11 } from "path";
+import { join as join19, resolve as resolve11 } from "path";
 function mcpServerEntry() {
   return {
     command: "npx",
@@ -4414,7 +4757,7 @@ automatic rollback.
 var home = homedir();
 var isWin = platform() === "win32";
 function appData() {
-  return process.env.APPDATA || join17(home, "AppData", "Roaming");
+  return process.env.APPDATA || join19(home, "AppData", "Roaming");
 }
 function detectCursor(cwd) {
   const env = {
@@ -4426,25 +4769,25 @@ function detectCursor(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const workspaceCursorDir = join17(cwd, ".cursor");
-  const globalCursorDir = join17(home, ".cursor");
-  if (existsSync13(workspaceCursorDir) || existsSync13(globalCursorDir)) {
+  const workspaceCursorDir = join19(cwd, ".cursor");
+  const globalCursorDir = join19(home, ".cursor");
+  if (existsSync14(workspaceCursorDir) || existsSync14(globalCursorDir)) {
     env.detected = true;
-    env.reason = existsSync13(workspaceCursorDir) ? `Found .cursor/ in workspace` : `Found ~/.cursor/ global config`;
+    env.reason = existsSync14(workspaceCursorDir) ? `Found .cursor/ in workspace` : `Found ~/.cursor/ global config`;
   }
-  const mcpPath = join17(cwd, ".cursor", "mcp.json");
-  if (existsSync13(mcpPath)) {
+  const mcpPath = join19(cwd, ".cursor", "mcp.json");
+  if (existsSync14(mcpPath)) {
     try {
-      const content = JSON.parse(readFileSync11(mcpPath, "utf8"));
+      const content = JSON.parse(readFileSync13(mcpPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  const rulesPath = join17(cwd, ".cursorrules");
-  if (existsSync13(rulesPath)) {
-    const content = readFileSync11(rulesPath, "utf8");
+  const rulesPath = join19(cwd, ".cursorrules");
+  if (existsSync14(rulesPath)) {
+    const content = readFileSync13(rulesPath, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -4461,12 +4804,12 @@ function detectClaudeDesktop() {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const configPath = isWin ? join17(appData(), "Claude", "claude_desktop_config.json") : join17(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  if (existsSync13(configPath)) {
+  const configPath = isWin ? join19(appData(), "Claude", "claude_desktop_config.json") : join19(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (existsSync14(configPath)) {
     env.detected = true;
     env.reason = `Found ${configPath}`;
     try {
-      const content = JSON.parse(readFileSync11(configPath, "utf8"));
+      const content = JSON.parse(readFileSync13(configPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
@@ -4485,23 +4828,23 @@ function detectClaudeCode(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const mcpJsonPath = join17(cwd, ".mcp.json");
-  const claudeMdPath = join17(cwd, "CLAUDE.md");
-  if (existsSync13(mcpJsonPath) || existsSync13(claudeMdPath)) {
+  const mcpJsonPath = join19(cwd, ".mcp.json");
+  const claudeMdPath = join19(cwd, "CLAUDE.md");
+  if (existsSync14(mcpJsonPath) || existsSync14(claudeMdPath)) {
     env.detected = true;
-    env.reason = existsSync13(mcpJsonPath) ? `Found .mcp.json in workspace` : `Found CLAUDE.md in workspace`;
+    env.reason = existsSync14(mcpJsonPath) ? `Found .mcp.json in workspace` : `Found CLAUDE.md in workspace`;
   }
-  if (existsSync13(mcpJsonPath)) {
+  if (existsSync14(mcpJsonPath)) {
     try {
-      const content = JSON.parse(readFileSync11(mcpJsonPath, "utf8"));
+      const content = JSON.parse(readFileSync13(mcpJsonPath, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  if (existsSync13(claudeMdPath)) {
-    const content = readFileSync11(claudeMdPath, "utf8");
+  if (existsSync14(claudeMdPath)) {
+    const content = readFileSync13(claudeMdPath, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -4518,20 +4861,20 @@ function detectAntigravity(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const globalGeminiDir = join17(home, ".gemini");
-  const workspaceAgentsDir = join17(cwd, ".agents");
-  if (existsSync13(globalGeminiDir) || existsSync13(workspaceAgentsDir)) {
+  const globalGeminiDir = join19(home, ".gemini");
+  const workspaceAgentsDir = join19(cwd, ".agents");
+  if (existsSync14(globalGeminiDir) || existsSync14(workspaceAgentsDir)) {
     env.detected = true;
-    env.reason = existsSync13(workspaceAgentsDir) ? `Found .agents/ in workspace` : `Found ~/.gemini/ global config`;
+    env.reason = existsSync14(workspaceAgentsDir) ? `Found .agents/ in workspace` : `Found ~/.gemini/ global config`;
   }
   const mcpPaths = [
-    join17(cwd, ".agents", "mcp_config.json"),
-    join17(home, ".gemini", "config", "mcp_config.json")
+    join19(cwd, ".agents", "mcp_config.json"),
+    join19(home, ".gemini", "config", "mcp_config.json")
   ];
   for (const p of mcpPaths) {
-    if (existsSync13(p)) {
+    if (existsSync14(p)) {
       try {
-        const content = JSON.parse(readFileSync11(p, "utf8"));
+        const content = JSON.parse(readFileSync13(p, "utf8"));
         if (content?.mcpServers?.elevate) {
           env.mcpConfigured = true;
           break;
@@ -4552,24 +4895,24 @@ function detectVSCode(cwd) {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const vscodeDir = join17(cwd, ".vscode");
-  if (existsSync13(vscodeDir)) {
+  const vscodeDir = join19(cwd, ".vscode");
+  if (existsSync14(vscodeDir)) {
     env.detected = true;
     env.reason = `Found .vscode/ in workspace`;
   }
-  const mcpPath = join17(cwd, ".vscode", "mcp.json");
-  if (existsSync13(mcpPath)) {
+  const mcpPath = join19(cwd, ".vscode", "mcp.json");
+  if (existsSync14(mcpPath)) {
     try {
-      const content = JSON.parse(readFileSync11(mcpPath, "utf8"));
+      const content = JSON.parse(readFileSync13(mcpPath, "utf8"));
       if (content?.servers?.elevate) {
         env.mcpConfigured = true;
       }
     } catch {
     }
   }
-  const copilotInstructions = join17(cwd, ".github", "copilot-instructions.md");
-  if (existsSync13(copilotInstructions)) {
-    const content = readFileSync11(copilotInstructions, "utf8");
+  const copilotInstructions = join19(cwd, ".github", "copilot-instructions.md");
+  if (existsSync14(copilotInstructions)) {
+    const content = readFileSync13(copilotInstructions, "utf8");
     if (content.includes("elevate") || content.includes("Elevate")) {
       env.skillConfigured = true;
     }
@@ -4586,14 +4929,14 @@ function detectWindsurf() {
     mcpConfigured: false,
     skillConfigured: false
   };
-  const configPath = isWin ? join17(appData(), "Codeium", "Windsurf", "mcp_config.json") : join17(home, ".codeium", "windsurf", "mcp_config.json");
-  const altPath = join17(home, ".codeium", "windsurf", "mcp_config.json");
-  if (existsSync13(configPath) || existsSync13(altPath)) {
+  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)) {
     env.detected = true;
     env.reason = `Found Windsurf config`;
-    const path = existsSync13(configPath) ? configPath : altPath;
+    const path = existsSync14(configPath) ? configPath : altPath;
     try {
-      const content = JSON.parse(readFileSync11(path, "utf8"));
+      const content = JSON.parse(readFileSync13(path, "utf8"));
       if (content?.mcpServers?.elevate) {
         env.mcpConfigured = true;
       }
@@ -4604,9 +4947,9 @@ function detectWindsurf() {
 }
 function mergeJsonMcpServer(filePath, serverKey, topLevelKey) {
   let existing = {};
-  if (existsSync13(filePath)) {
+  if (existsSync14(filePath)) {
     try {
-      existing = JSON.parse(readFileSync11(filePath, "utf8"));
+      existing = JSON.parse(readFileSync13(filePath, "utf8"));
     } catch {
       existing = {};
     }
@@ -4618,15 +4961,15 @@ function mergeJsonMcpServer(filePath, serverKey, topLevelKey) {
   servers[serverKey] = mcpServerEntry();
   existing[topLevelKey] = servers;
   const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
-  if (dir && !existsSync13(dir)) {
+  if (dir && !existsSync14(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   writeFileSync5(filePath, JSON.stringify(existing, null, 2) + "\n", "utf8");
   return { written: true, message: `${filePath}: elevate MCP server registered` };
 }
 function appendSkillToFile(filePath, content, marker) {
-  if (existsSync13(filePath)) {
-    const existing = readFileSync11(filePath, "utf8");
+  if (existsSync14(filePath)) {
+    const existing = readFileSync13(filePath, "utf8");
     if (existing.includes(marker)) {
       return { written: false, message: `${filePath}: skill already present` };
     }
@@ -4634,48 +4977,48 @@ function appendSkillToFile(filePath, content, marker) {
     return { written: true, message: `${filePath}: skill appended` };
   }
   const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
-  if (dir && !existsSync13(dir)) {
+  if (dir && !existsSync14(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   writeFileSync5(filePath, content, "utf8");
   return { written: true, message: `${filePath}: skill created` };
 }
 function configureCursor(cwd, result) {
-  const mcpPath = join17(cwd, ".cursor", "mcp.json");
+  const mcpPath = join19(cwd, ".cursor", "mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Cursor MCP: ${mcp.message}`);
-  const rulesPath = join17(cwd, ".cursorrules");
+  const rulesPath = join19(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 ? join17(appData(), "Claude", "claude_desktop_config.json") : join17(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  const configPath = isWin ? join19(appData(), "Claude", "claude_desktop_config.json") : join19(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 = join17(cwd, ".mcp.json");
+  const mcpPath = join19(cwd, ".mcp.json");
   const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Code MCP: ${mcp.message}`);
-  const claudeMdPath = join17(cwd, "CLAUDE.md");
+  const claudeMdPath = join19(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 = join17(cwd, ".agents", "mcp_config.json");
+  const mcpPath = join19(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 = join17(cwd, ".vscode", "mcp.json");
+  const mcpPath = join19(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 = join17(cwd, ".github", "copilot-instructions.md");
+  const instructionsPath = join19(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 ? join17(appData(), "Codeium", "Windsurf", "mcp_config.json") : join17(home, ".codeium", "windsurf", "mcp_config.json");
+  const configPath = isWin ? join19(appData(), "Codeium", "Windsurf", "mcp_config.json") : join19(home, ".codeium", "windsurf", "mcp_config.json");
   const mcp = mergeJsonMcpServer(configPath, "elevate", "mcpServers");
   result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Windsurf MCP: ${mcp.message}`);
 }
@@ -4708,7 +5051,7 @@ async function handleInitCommand(options) {
       console.log(`  Creating portable .mcp.json for broad compatibility.
 `);
     }
-    const mcpPath = join17(cwd, ".mcp.json");
+    const mcpPath = join19(cwd, ".mcp.json");
     const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
     result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Generic MCP: ${mcp.message}`);
   } else {
@@ -4917,8 +5260,10 @@ async function startMcpServer(config) {
     try {
       if (name === "elevate_discover_modules") {
         const modules = await strategy.discovery.discover(config.rootDir);
+        const packageManager = strategy.packageManagerFor?.(config.rootDir);
         return reply({
           ecosystem,
+          ...packageManager ? { packageManager } : {},
           count: modules.length,
           modules: modules.map((m) => ({
             id: m.id,