@mnci/cli 4.3.2 → 4.4.0

package/dist/cli.js

@@ -28,23 +28,23 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/cli.ts
-var cli_exports = {};
-__export(cli_exports, {
+// src/main.ts
+var main_exports = {};
+__export(main_exports, {
   buildProgram: () => buildProgram,
   main: () => main
 });
-module.exports = __toCommonJS(cli_exports);
+module.exports = __toCommonJS(main_exports);
 var import_commander = require("commander");
 
-// src/commands/add.ts
-var import_node_path14 = require("path");
-var import_prompts6 = require("@inquirer/prompts");
+// src/project-scaffolding/add-project.use-case.ts
+var import_node_path18 = require("path");
+var import_prompts3 = require("@inquirer/prompts");
 
-// src/nx.ts
+// src/nx-workspace/nx.client.ts
 var import_cross_spawn = __toESM(require("cross-spawn"));
 
-// src/util/logger.ts
+// src/terminal/logger.client.ts
 var logger = {
   info(message) {
     console.log(message);
@@ -73,7 +73,62 @@ var logger = {
   }
 };
 
-// src/nx.ts
+// src/terminal/prompts.client.ts
+var import_prompts = require("@inquirer/prompts");
+async function promptText(message, fallback) {
+  const value = await (0, import_prompts.input)({
+    message,
+    default: fallback,
+    validate: (value2) => value2.trim().length > 0 || "A value is required"
+  });
+  return value.trim();
+}
+async function promptRegistry(fallbackOrganization) {
+  const kind = await (0, import_prompts.select)({
+    message: "Package registry for publishable libraries",
+    choices: [
+      { name: "Azure Artifacts", value: "azure-artifacts" },
+      { name: "Public npm", value: "npm" }
+    ]
+  });
+  if (kind === "npm") {
+    return { kind };
+  }
+  return {
+    kind,
+    organization: await promptText("Azure DevOps organization", fallbackOrganization),
+    project: await promptText("Azure DevOps project"),
+    artifactsFeed: await promptText("Artifacts feed name")
+  };
+}
+async function promptCi() {
+  return await (0, import_prompts.select)({
+    message: "CI provider",
+    choices: [
+      { name: "Azure Pipelines", value: "azure" },
+      { name: "GitHub Actions", value: "github" },
+      { name: "Both", value: "both" }
+    ]
+  });
+}
+async function promptNxCloud() {
+  return await (0, import_prompts.confirm)({
+    message: "Connect this workspace to Nx Cloud (remote caching + CI insights)?",
+    default: false
+  });
+}
+async function promptStack() {
+  const testRunner = await (0, import_prompts.select)({
+    message: "Unit-test runner",
+    choices: [
+      { name: "Jest", value: "jest" },
+      { name: "Vitest", value: "vitest" }
+    ]
+  });
+  return { testRunner };
+}
+
+// src/nx-workspace/nx.client.ts
 function runShell(command, arguments_, cwd) {
   const result = import_cross_spawn.default.sync(command, arguments_, { stdio: "inherit", cwd });
   return result.status ?? 1;
@@ -145,62 +200,7 @@ function runFormatter(cwd, target = ".") {
   }
 }
 
-// src/prompts.ts
-var import_prompts = require("@inquirer/prompts");
-async function promptText(message, fallback) {
-  const value = await (0, import_prompts.input)({
-    message,
-    default: fallback,
-    validate: (value2) => value2.trim().length > 0 || "A value is required"
-  });
-  return value.trim();
-}
-async function promptRegistry(fallbackOrganization) {
-  const kind = await (0, import_prompts.select)({
-    message: "Package registry for publishable libraries",
-    choices: [
-      { name: "Azure Artifacts", value: "azure-artifacts" },
-      { name: "Public npm", value: "npm" }
-    ]
-  });
-  if (kind === "npm") {
-    return { kind };
-  }
-  return {
-    kind,
-    organization: await promptText("Azure DevOps organization", fallbackOrganization),
-    project: await promptText("Azure DevOps project"),
-    artifactsFeed: await promptText("Artifacts feed name")
-  };
-}
-async function promptCi() {
-  return await (0, import_prompts.select)({
-    message: "CI provider",
-    choices: [
-      { name: "Azure Pipelines", value: "azure" },
-      { name: "GitHub Actions", value: "github" },
-      { name: "Both", value: "both" }
-    ]
-  });
-}
-async function promptNxCloud() {
-  return await (0, import_prompts.confirm)({
-    message: "Connect this workspace to Nx Cloud (remote caching + CI insights)?",
-    default: false
-  });
-}
-async function promptStack() {
-  const testRunner = await (0, import_prompts.select)({
-    message: "Unit-test runner",
-    choices: [
-      { name: "Jest", value: "jest" },
-      { name: "Vitest", value: "vitest" }
-    ]
-  });
-  return { testRunner };
-}
-
-// src/util/fsx.ts
+// src/file-system/file-system.client.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
 function readJson(path) {
@@ -282,7 +282,7 @@ function fileExists(path) {
   return (0, import_node_fs.existsSync)(path);
 }
 
-// src/util/names.ts
+// src/project-name/project-name.validator.ts
 function assertValidProjectName(name, label) {
   if (!/^[a-z][a-z0-9-]*(?:\.[a-z0-9-]+)*$/.test(name)) {
     throw new Error(
@@ -291,11 +291,11 @@ function assertValidProjectName(name, label) {
   }
 }
 
-// src/commands/add/csharp.ts
+// src/project-scaffolding/csharp.use-case.ts
 var import_node_fs4 = require("fs");
 var import_node_path4 = require("path");
 
-// src/overlay.ts
+// src/workspace-overlay/overlay.use-case.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 var DEFAULT_STACK = { testRunner: "jest" };
@@ -846,6 +846,12 @@ var GO_TOOL_PATH_AZURE = `node -e "${GO_TOOL_PATH_PRELUDE}console.log('##vso[tas
 var GO_TOOL_PATH_GITHUB = `node -e "${GO_TOOL_PATH_PRELUDE}if(!process.env.GITHUB_PATH){console.log('Not running in GitHub Actions - skipping.');process.exit(0)}fs.appendFileSync(process.env.GITHUB_PATH,bin+${String.raw`'\n'`})"`;
 var FLUTTER_SDK_VERSION = "3.44.8";
 var NODE_VERSION = "24";
+var ACTION_VERSIONS = {
+  "actions/checkout": "v7",
+  "actions/setup-node": "v7",
+  "actions/setup-dotnet": "v6",
+  "actions/upload-artifact": "v7"
+};
 var NPM_VERSION = "11";
 var DOTNET_SDK_VERSION = "10.0.x";
 var DOTNET_DETECT_AZURE = `node -e "const fs=require('node:fs');const has=[...fs.globSync('apps/*/*.csproj'),...fs.globSync('packages/*/*.csproj'),...fs.globSync('libs/*/*.csproj')].length>0;console.log('##vso[task.setvariable variable=hasDotnetProjects]'+has)"`;
@@ -1202,7 +1208,7 @@ jobs:
   ci:
     runs-on: ${agent}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@${ACTION_VERSIONS["actions/checkout"]}
         with:
           fetch-depth: 0
 
@@ -1213,7 +1219,7 @@ jobs:
       - run: git config user.name "github-actions[bot]" && git config user.email "github-actions[bot]@users.noreply.github.com"
         name: Set the git identity used for release tags
 
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@${ACTION_VERSIONS["actions/setup-node"]}
         with:
           node-version: ${NODE_VERSION}
           # Caches ~/.npm keyed on package-lock.json, so \`npm ci\` restores from
@@ -1299,7 +1305,7 @@ jobs:
       # directly rather than a hand-rolled 'node -e' guard \u2014 see
       # DOTNET_DETECT_AZURE's remarks for the full reasoning. hashFiles()
       # gates it inline, so a JS-only workspace pays nothing.
-      - uses: actions/setup-dotnet@v6
+      - uses: actions/setup-dotnet@${ACTION_VERSIONS["actions/setup-dotnet"]}
         if: \${{ hashFiles('apps/*/*.csproj', 'packages/*/*.csproj', 'libs/*/*.csproj') != '' }}
         with:
           dotnet-version: ${DOTNET_SDK_VERSION}
@@ -1331,7 +1337,7 @@ jobs:
         name: Pack all apps (one zip per app -> dist/drop)
         if: \${{ ${onMain} }}
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@${ACTION_VERSIONS["actions/upload-artifact"]}
         if: \${{ ${onMain} }}
         with:
           name: drop
@@ -1596,7 +1602,7 @@ function applyOverlay(workspaceRoot, options, onProgress = () => {
   }
 }
 
-// src/commands/add/shared.ts
+// src/project-scaffolding/post-generation.use-case.ts
 var import_node_fs3 = require("fs");
 var import_node_path3 = require("path");
 function hasPlugin(workspaceRoot, packageName) {
@@ -1636,477 +1642,180 @@ function markPublic(manifestPath) {
   const manifest = readJson(manifestPath);
   writeFileEnsured(manifestPath, toJson({ ...manifest, publishConfig: { access: "public" } }));
 }
-var WRONG_TYPES_PATH = "./dist/index.esm.d.ts";
-var ACTUAL_TYPES_PATH = "./dist/src/index.d.ts";
-var DECLARATION_MAP_EXCLUSION = "!**/*.d.ts.map";
-var SOURCE_MAP_EXCLUSION = "!**/*.js.map";
-var ROLLUP_CONFIG_PLACEHOLDER = [
-  "  {",
-  "    // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options",
-  "    // e.g.",
-  "    // output: { sourcemap: true },",
-  "  }"
-].join("\n");
-var GENERATED_COMPILER_PATTERN = /^( {4})compiler\s*:\s*'swc',$/m;
-function sourceMapCapableCompiler(indent) {
-  return [
-    `${indent}// Swapped from swc by MoNecromanCI. @nx/rollup runs swc without`,
-    `${indent}// sourceMaps, so it returns no map and the bundle's map comes out empty -`,
-    `${indent}// valid-looking, and useless for debugging. See ROADMAP.`,
-    `${indent}compiler: 'babel',`
-  ].join("\n");
-}
-var ROLLUP_ARG_ONE_BOUNDARY = ["  },", "  {", ""].join("\n");
-var ROLLUP_ARG_ONE_WITH_SOURCE_MAPS = [
-  "    // Added by MoNecromanCI: without this rollup emits no .js.map at all, so",
-  "    // a breakpoint in a .ts file can never bind. Not published - see `files`.",
-  "    sourceMap: true",
-  "  },",
-  "  {",
-  ""
-].join("\n");
-function hasRollupSourceMaps(config) {
-  return /sourceMap\s*:\s*true\b/.test(config);
-}
-function canRepairRollupConfig(config) {
-  return config.includes(ROLLUP_ARG_ONE_BOUNDARY);
-}
-function withRollupSourceMaps(config) {
-  if (hasRollupSourceMaps(config) || !canRepairRollupConfig(config)) {
-    return config;
-  }
-  const withCompiler = config.replace(
-    GENERATED_COMPILER_PATTERN,
-    (_match, indent) => sourceMapCapableCompiler(indent)
-  );
-  const withFlag = withCompiler.replace(
-    ROLLUP_ARG_ONE_BOUNDARY,
-    () => ROLLUP_ARG_ONE_WITH_SOURCE_MAPS
-  );
-  return withFlag.includes("sourcemapPathTransform") ? withFlag : withFlag.replace(
-    ROLLUP_ARG_ONE_WITH_SOURCE_MAPS,
-    () => `${ROLLUP_ARG_ONE_WITH_SOURCE_MAPS}${SOURCEMAP_PATH_TRANSFORM}`
+function writeProjectReadme(projectRoot, projectName, testRunner) {
+  const runner = testRunner === "vitest" ? "[Vitest](https://vitest.dev)" : "[Jest](https://jestjs.io)";
+  writeFileEnsured(
+    (0, import_node_path3.join)(projectRoot, "README.md"),
+    [
+      `# ${projectName}`,
+      "",
+      "Generated by [MoNecromanCI](https://github.com/russoedu/MoNecromanCi).",
+      "",
+      "## Building",
+      "",
+      `Run \`nx build ${projectName}\` to build this project.`,
+      "",
+      "## Running unit tests",
+      "",
+      `Run \`nx test ${projectName}\` to execute the unit tests via ${runner}.`,
+      ""
+    ].join("\n")
   );
 }
-function repairRollupSourceMaps(workspaceRoot) {
-  const changed = [];
-  const configs = (0, import_node_fs3.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
-    cwd: workspaceRoot
-  });
-  for (const relativePath of configs) {
-    const configPath = (0, import_node_path3.join)(workspaceRoot, relativePath);
-    const before = (0, import_node_fs3.readFileSync)(configPath, "utf8");
-    const after = withRollupSourceMaps(before);
-    if (after !== before) {
-      writeFileEnsured(configPath, after);
-      changed.push(relativePath.replaceAll("\\", "/"));
+function removeStaleGitkeeps(workspaceRoot) {
+  for (const scaffold of ["apps", "libs", "packages"]) {
+    const directory = (0, import_node_path3.join)(workspaceRoot, scaffold);
+    try {
+      const holdsAProject = (0, import_node_fs3.readdirSync)(directory, { withFileTypes: true }).some(
+        (entry) => entry.isDirectory()
+      );
+      if (holdsAProject) {
+        (0, import_node_fs3.rmSync)((0, import_node_path3.join)(directory, ".gitkeep"), { force: true });
+      }
+    } catch {
     }
   }
-  return changed;
 }
-function resolveRequireTarget(fromDir, specifier) {
-  const base = (0, import_node_path3.join)(fromDir, specifier);
-  return [base, `${base}.cjs`, `${base}.js`].find((candidate) => fileExists(candidate));
+function ensureAdmZip(workspaceRoot) {
+  if (hasPlugin(workspaceRoot, "adm-zip")) {
+    return;
+  }
+  logger.step("Installing the app packager (adm-zip)");
+  if (runShell(
+    "npm",
+    ["install", "--save-dev", "adm-zip", "--no-audit", "--no-fund"],
+    workspaceRoot
+  ) !== 0) {
+    throw new Error("npm install of adm-zip failed");
+  }
 }
-function resolveRollupConfigText(configPath, visited = /* @__PURE__ */ new Set()) {
-  if (visited.has(configPath)) {
-    return "";
+function defaultScope(workspaceRoot) {
+  const { name } = readJson((0, import_node_path3.join)(workspaceRoot, "package.json"));
+  const base = (name.startsWith("@") ? name.slice(1) : name).split("/", 1)[0];
+  return `@${base}`;
+}
+function addNxTargets(manifestPath, newTargets) {
+  const manifest = fileExists(manifestPath) ? readJson(manifestPath) : {};
+  const nx = manifest.nx ?? {};
+  const targets = nx.targets ?? {};
+  writeFileEnsured(
+    manifestPath,
+    toJson({ ...manifest, nx: { ...nx, targets: { ...targets, ...newTargets } } })
+  );
+}
+function addProjectJsonTargets(projectJsonPath, newTargets) {
+  const project = fileExists(projectJsonPath) ? readJson(projectJsonPath) : {};
+  const targets = project.targets ?? {};
+  writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
+}
+var ESLINT_CONFIG_FILENAMES = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts"
+];
+function removeGeneratedEslintConfig(workspaceRoot, projectRoot) {
+  for (const filename of ESLINT_CONFIG_FILENAMES) {
+    (0, import_node_fs3.rmSync)((0, import_node_path3.join)(workspaceRoot, projectRoot, filename), { force: true });
   }
-  visited.add(configPath);
-  let text;
+  (0, import_node_fs3.rmSync)((0, import_node_path3.join)(workspaceRoot, ".vscode"), { recursive: true, force: true });
+}
+function findCodeWorkspaceFile(workspaceRoot) {
   try {
-    text = (0, import_node_fs3.readFileSync)(configPath, "utf8");
+    const entry = (0, import_node_fs3.readdirSync)(workspaceRoot).find((file) => file.endsWith(".code-workspace"));
+    return entry ? (0, import_node_path3.join)(workspaceRoot, entry) : void 0;
   } catch {
-    return "";
+    return void 0;
   }
-  const specifiers = Array.from(
-    text.matchAll(/require\((['"])(\.[^'"]*)\1\)/g),
-    (match) => match[2]
-  );
-  const requiredText = specifiers.map((specifier) => resolveRequireTarget((0, import_node_path3.dirname)(configPath), specifier)).filter((target) => target !== void 0).map((target) => resolveRollupConfigText(target, visited));
-  return [text, ...requiredText].join("\n");
-}
-var SOURCEMAP_PATH_TRANSFORM = [
-  "    // Added by MoNecromanCI. rollup hands sourcemapPathTransform an OS-NATIVE",
-  "    // path with one parent segment too many, so `sources` resolve to nothing",
-  "    // and no breakpoint can bind. Separators are normalised too: a sources",
-  "    // entry is URL-style, so a backslash is wrong on every platform.",
-  "    output: {",
-  "      sourcemapPathTransform: relativeSourcePath =>",
-  "        relativeSourcePath",
-  "          .replaceAll(String.fromCodePoint(92), '/')",
-  "          .replace(/^([.][.][/])+/, '../')",
-  "    },",
-  ""
-].join("\n");
-var DECLARATION_SPECIFIER_PLUGIN_MARKER = "name: 'mnci-normalise-declaration-specifiers'";
-var DECLARATION_SPECIFIER_EXTENSION_MARKER = "bareRelativeSpecifier";
-var DECLARATION_SPECIFIER_DIRECTORY_MARKER = "resolveSpecifierSuffix";
-function hasDeclarationSpecifierPlugin(config) {
-  return config.includes(DECLARATION_SPECIFIER_PLUGIN_MARKER);
 }
-function hasDirectoryAwareDeclarationSpecifiers(config) {
-  return config.includes(DECLARATION_SPECIFIER_DIRECTORY_MARKER);
+function projectTask(name, kind) {
+  const script = `${name}:${kind}`;
+  const base = { label: `${name}: ${kind}`, type: "npm", script, problemMatcher: [] };
+  return kind === "start" ? { ...base, isBackground: true } : { ...base, group: kind };
 }
-var DECLARATION_SPECIFIER_PLUGIN = [
-  "      {",
-  "        name: 'mnci-normalise-declaration-specifiers',",
-  "        writeBundle (outputOptions) {",
-  "          const { existsSync, readdirSync, readFileSync, writeFileSync } = require('node:fs')",
-  "          const { join } = require('node:path')",
-  "          const dir = outputOptions.dir ?? './dist'",
-  "          const stub = join(dir, 'index.d.ts')",
-  "          let source",
-  "          try {",
-  "            source = readFileSync(stub, 'utf8')",
-  "          } catch {",
-  "            return",
-  "          }",
-  "          // The stub carries a TWO-character escape (JSON.stringify escaped one",
-  "          // backslash), so this must not match a single one - that would turn",
-  String.raw`          // "./src\index" into "./src//index". Built from char codes so there is`,
-  "          // no escaping in this file to get wrong.",
-  "          const separator = String.fromCodePoint(92, 92)",
-  "          const normalised = source.replaceAll(separator, '/')",
-  "          if (normalised !== source) writeFileSync(stub, normalised)",
-  "",
-  String.raw`          const ${DECLARATION_SPECIFIER_EXTENSION_MARKER} = /from(\s+)(['"])(\.[^'"]+?)\2/g`,
-  String.raw`          const hasExtension = /\.(?:mjs|cjs|jsx?|json)$/`,
-  "          let entries",
-  "          try {",
-  "            entries = readdirSync(dir, { recursive: true, withFileTypes: true })",
-  "          } catch {",
-  "            return",
-  "          }",
-  "          for (const entry of entries) {",
-  "            if (!entry.name.endsWith('.d.ts')) continue",
-  "            const from = entry.parentPath ?? entry.path",
-  "            const filePath = join(from, entry.name)",
-  "            let declaration",
-  "            try {",
-  "              declaration = readFileSync(filePath, 'utf8')",
-  "            } catch {",
-  "              continue",
-  "            }",
-  "            // A bare specifier may name a FILE or a DIRECTORY BARREL - resolved",
-  "            // against what rollup actually emitted next to this file, never",
-  "            // guessed. A directory needs /index.js, not .js (a file that was",
-  "            // never written); anything neither form matches is left alone rather",
-  "            // than rewritten to a specifier that cannot resolve.",
-  `            const ${DECLARATION_SPECIFIER_DIRECTORY_MARKER} = (specifier) => {`,
-  "              if (hasExtension.test(specifier)) return null",
-  "              if (existsSync(join(from, specifier + '.d.ts'))) return specifier + '.js'",
-  "              if (existsSync(join(from, specifier, 'index.d.ts'))) return specifier + '/index.js'",
-  "              return null",
-  "            }",
-  "            const withExtensions = declaration.replace(",
-  `              ${DECLARATION_SPECIFIER_EXTENSION_MARKER},`,
-  "              (match, space, quote, specifier) => {",
-  `                const resolved = ${DECLARATION_SPECIFIER_DIRECTORY_MARKER}(specifier)`,
-  "                return resolved === null ? match : `from${space}${quote}${resolved}${quote}`",
-  "              },",
-  "            )",
-  "            if (withExtensions !== declaration) writeFileSync(filePath, withExtensions)",
-  "          }",
-  "        }",
-  "      }"
-].join("\n");
-var ROLLUP_CONFIG_WITH_DTS_FIX = [
-  "  {",
-  "    // Added by MoNecromanCI. @nx/rollup's dts-bundle plugin writes dist/index.d.ts",
-  "    // as a stub re-exporting the real declarations, and builds that specifier with",
-  "    // path.relative() - an OS-NATIVE path. On Windows it emits",
-  String.raw`    //   export * from "./src\\index";`,
-  "    // which is not a valid module specifier on ANY platform: a specifier is",
-  "    // URL-style, so / is correct everywhere and a backslash nowhere. It resolves on",
-  "    // Windows only because the resolver normalises separators there, leaving the",
-  "    // package untyped on Linux and macOS.",
-  "    //",
-  "    // mnci also points `types` past this stub, so nothing depends on it being",
-  "    // correct; this makes the emitted file correct too. Remove once Nx fixes the",
-  "    // plugin - its own devkit already exports normalizePath for exactly this.",
-  "    //",
-  "    // The second half fixes a separate defect in the REAL declarations `types`",
-  '    // points at: tsconfig.lib.json declares under moduleResolution "bundler",',
-  '    // where a bare relative specifier ("./lib/align") is valid, so every emitted',
-  "    // .d.ts keeps the source's own extensionless imports verbatim. A consumer on",
-  '    // "moduleResolution": "nodenext" - the workspace root default - requires an',
-  "    // explicit extension on every relative specifier and gets TS2834 (or,",
-  "    // combined with skipLibCheck, a silent zero-export module) instead. Declared",
-  "    // extensions are left untouched; only a bare relative specifier gets .js",
-  "    // appended, matching what tsc itself emits under node16/nodenext.",
-  "    plugins: [",
-  DECLARATION_SPECIFIER_PLUGIN,
-  "    ]",
-  "  }"
-].join("\n");
-function findEnclosingBraceSpan(text, needle) {
-  const needleIndex = text.indexOf(needle);
-  if (needleIndex === -1) {
-    return void 0;
-  }
-  const start = text.lastIndexOf("{", needleIndex);
-  if (start === -1) {
-    return void 0;
+function registerProjectCommands(workspaceRoot, name, commands) {
+  removeStaleGitkeeps(workspaceRoot);
+  const scripts = {
+    [`${name}:qa`]: `nx run ${name}:lint && nx run ${name}:test`
+  };
+  if (commands.build) {
+    scripts[`${name}:build`] = `nx run ${name}:build`;
   }
-  let depth = 0;
-  for (let index = start; index < text.length; index += 1) {
-    if (text[index] === "{") {
-      depth += 1;
-    } else if (text[index] === "}") {
-      depth -= 1;
-      if (depth === 0) {
-        return [start, index + 1];
-      }
-    }
+  if (commands.start) {
+    scripts[`${name}:start`] = commands.start;
   }
-  return void 0;
-}
-function withUpgradedDeclarationSpecifierPlugin(config) {
-  if (!config.includes(DECLARATION_SPECIFIER_PLUGIN_MARKER) || config.includes(DECLARATION_SPECIFIER_DIRECTORY_MARKER)) {
-    return config;
+  const dependabotPath = (0, import_node_path3.join)(workspaceRoot, ".github/dependabot.yml");
+  if ((0, import_node_fs3.existsSync)(dependabotPath)) {
+    writeFileEnsured(dependabotPath, dependabotConfig(workspaceRoot));
   }
-  const span = findEnclosingBraceSpan(config, DECLARATION_SPECIFIER_PLUGIN_MARKER);
-  if (!span) {
-    return config;
+  const manifestPath = (0, import_node_path3.join)(workspaceRoot, "package.json");
+  const manifest = readJson(manifestPath);
+  const existingScripts = manifest.scripts ?? {};
+  const overrides = {
+    ...manifest.overrides,
+    ...reactExpressPeerOverride(manifest)
+  };
+  writeFileEnsured(
+    manifestPath,
+    toJson({
+      ...manifest,
+      scripts: { ...existingScripts, ...scripts },
+      ...Object.keys(overrides).length > 0 && { overrides }
+    })
+  );
+  const codeWorkspacePath = findCodeWorkspaceFile(workspaceRoot);
+  if (!codeWorkspacePath) {
+    return;
   }
-  const [start, end] = span;
-  return `${config.slice(0, start)}${DECLARATION_SPECIFIER_PLUGIN}${config.slice(end)}`;
+  const workspaceFile = readCodeWorkspace(codeWorkspacePath) ?? {};
+  const label = (task) => task.label ?? "";
+  const existingTasks = (workspaceFile.tasks?.tasks ?? []).filter(
+    (task) => !label(task).startsWith(`${name}: `)
+  );
+  const newTasks = [
+    projectTask(name, "qa"),
+    ...commands.build ? [projectTask(name, "build")] : [],
+    ...commands.start ? [projectTask(name, "start")] : []
+  ];
+  writeFileEnsured(
+    codeWorkspacePath,
+    toJson({
+      ...workspaceFile,
+      tasks: {
+        version: workspaceFile.tasks?.version ?? "2.0.0",
+        tasks: [...existingTasks, ...newTasks]
+      }
+    })
+  );
 }
-function upgradeDeclarationSpecifierPlugins(workspaceRoot) {
-  const changed = [];
-  const configs = (0, import_node_fs3.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
-    cwd: workspaceRoot
-  });
-  for (const relativePath of configs) {
-    const configPath = (0, import_node_path3.join)(workspaceRoot, relativePath);
-    const before = (0, import_node_fs3.readFileSync)(configPath, "utf8");
-    const after = withUpgradedDeclarationSpecifierPlugin(before);
-    if (after !== before) {
-      writeFileEnsured(configPath, after);
-      changed.push(relativePath.replaceAll("\\", "/"));
-    }
+var PROJECT_MANIFEST_ROOTS = ["apps", "packages", "libs"];
+function rootRuntimeDependencies(workspaceRoot) {
+  try {
+    return readJson((0, import_node_path3.join)(workspaceRoot, "package.json")).dependencies ?? {};
+  } catch {
+    return {};
   }
-  return changed;
 }
-function repairDeclarationSpecifiers(projectRoot) {
-  const configPath = (0, import_node_path3.join)(projectRoot, "rollup.config.cjs");
-  if (!fileExists(configPath)) {
+function relocateRootRuntimeDependencies(workspaceRoot, projectName, before) {
+  const after = rootRuntimeDependencies(workspaceRoot);
+  const added = Object.keys(after).filter((name) => !Object.hasOwn(before, name));
+  if (added.length === 0) {
     return;
   }
-  const config = (0, import_node_fs3.readFileSync)(configPath, "utf8");
-  if (!config.includes(ROLLUP_CONFIG_PLACEHOLDER)) {
+  const manifestPath = PROJECT_MANIFEST_ROOTS.map(
+    (root) => (0, import_node_path3.join)(workspaceRoot, root, projectName, "package.json")
+  ).find((candidate) => fileExists(candidate));
+  if (manifestPath === void 0) {
     return;
   }
-  const withDtsFix = config.split(ROLLUP_CONFIG_PLACEHOLDER).join(ROLLUP_CONFIG_WITH_DTS_FIX);
-  writeFileEnsured(configPath, withRollupSourceMaps(withDtsFix));
-}
-function writeProjectReadme(projectRoot, projectName, testRunner) {
-  const runner = testRunner === "vitest" ? "[Vitest](https://vitest.dev)" : "[Jest](https://jestjs.io)";
-  writeFileEnsured(
-    (0, import_node_path3.join)(projectRoot, "README.md"),
-    [
-      `# ${projectName}`,
-      "",
-      "Generated by [MoNecromanCI](https://github.com/russoedu/MoNecromanCi).",
-      "",
-      "## Building",
-      "",
-      `Run \`nx build ${projectName}\` to build this project.`,
-      "",
-      "## Running unit tests",
-      "",
-      `Run \`nx test ${projectName}\` to execute the unit tests via ${runner}.`,
-      ""
-    ].join("\n")
-  );
-}
-function removeStaleGitkeeps(workspaceRoot) {
-  for (const scaffold of ["apps", "libs", "packages"]) {
-    const directory = (0, import_node_path3.join)(workspaceRoot, scaffold);
-    try {
-      const holdsAProject = (0, import_node_fs3.readdirSync)(directory, { withFileTypes: true }).some(
-        (entry) => entry.isDirectory()
-      );
-      if (holdsAProject) {
-        (0, import_node_fs3.rmSync)((0, import_node_path3.join)(directory, ".gitkeep"), { force: true });
-      }
-    } catch {
-    }
-  }
-}
-function repairPublishableManifest(manifestPath) {
-  const manifest = readJson(manifestPath);
-  if (manifest.types === WRONG_TYPES_PATH) {
-    manifest.types = ACTUAL_TYPES_PATH;
-  }
-  const dot = manifest.exports?.["."];
-  if (typeof dot === "object" && dot.types === WRONG_TYPES_PATH) {
-    dot.types = ACTUAL_TYPES_PATH;
-  }
-  for (const exclusion of [DECLARATION_MAP_EXCLUSION, SOURCE_MAP_EXCLUSION]) {
-    if (manifest.files && !manifest.files.includes(exclusion)) {
-      manifest.files.push(exclusion);
-    }
-  }
-  writeFileEnsured(manifestPath, toJson(manifest));
-}
-function repairPublishableManifests(workspaceRoot) {
-  const changed = [];
-  const manifests = (0, import_node_fs3.globSync)(["packages/*/package.json", "libs/*/package.json"], {
-    cwd: workspaceRoot
-  });
-  for (const relativePath of manifests) {
-    const manifestPath = (0, import_node_path3.join)(workspaceRoot, relativePath);
-    const before = (0, import_node_fs3.readFileSync)(manifestPath, "utf8");
-    repairPublishableManifest(manifestPath);
-    const after = (0, import_node_fs3.readFileSync)(manifestPath, "utf8");
-    if (after !== before) {
-      changed.push(relativePath.replaceAll("\\", "/"));
-    }
-  }
-  return changed;
-}
-function ensureAdmZip(workspaceRoot) {
-  if (hasPlugin(workspaceRoot, "adm-zip")) {
-    return;
-  }
-  logger.step("Installing the app packager (adm-zip)");
-  if (runShell(
-    "npm",
-    ["install", "--save-dev", "adm-zip", "--no-audit", "--no-fund"],
-    workspaceRoot
-  ) !== 0) {
-    throw new Error("npm install of adm-zip failed");
-  }
-}
-function defaultScope(workspaceRoot) {
-  const { name } = readJson((0, import_node_path3.join)(workspaceRoot, "package.json"));
-  const base = (name.startsWith("@") ? name.slice(1) : name).split("/", 1)[0];
-  return `@${base}`;
-}
-function addNxTargets(manifestPath, newTargets) {
-  const manifest = fileExists(manifestPath) ? readJson(manifestPath) : {};
-  const nx = manifest.nx ?? {};
-  const targets = nx.targets ?? {};
-  writeFileEnsured(
-    manifestPath,
-    toJson({ ...manifest, nx: { ...nx, targets: { ...targets, ...newTargets } } })
-  );
-}
-function addProjectJsonTargets(projectJsonPath, newTargets) {
-  const project = fileExists(projectJsonPath) ? readJson(projectJsonPath) : {};
-  const targets = project.targets ?? {};
-  writeFileEnsured(projectJsonPath, toJson({ ...project, targets: { ...targets, ...newTargets } }));
-}
-var ESLINT_CONFIG_FILENAMES = [
-  "eslint.config.js",
-  "eslint.config.mjs",
-  "eslint.config.cjs",
-  "eslint.config.ts",
-  "eslint.config.mts",
-  "eslint.config.cts"
-];
-function removeGeneratedEslintConfig(workspaceRoot, projectRoot) {
-  for (const filename of ESLINT_CONFIG_FILENAMES) {
-    (0, import_node_fs3.rmSync)((0, import_node_path3.join)(workspaceRoot, projectRoot, filename), { force: true });
-  }
-  (0, import_node_fs3.rmSync)((0, import_node_path3.join)(workspaceRoot, ".vscode"), { recursive: true, force: true });
-}
-function findCodeWorkspaceFile(workspaceRoot) {
-  try {
-    const entry = (0, import_node_fs3.readdirSync)(workspaceRoot).find((file) => file.endsWith(".code-workspace"));
-    return entry ? (0, import_node_path3.join)(workspaceRoot, entry) : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function projectTask(name, kind) {
-  const script = `${name}:${kind}`;
-  const base = { label: `${name}: ${kind}`, type: "npm", script, problemMatcher: [] };
-  return kind === "start" ? { ...base, isBackground: true } : { ...base, group: kind };
-}
-function registerProjectCommands(workspaceRoot, name, commands) {
-  removeStaleGitkeeps(workspaceRoot);
-  const scripts = {
-    [`${name}:qa`]: `nx run ${name}:lint && nx run ${name}:test`
-  };
-  if (commands.build) {
-    scripts[`${name}:build`] = `nx run ${name}:build`;
-  }
-  if (commands.start) {
-    scripts[`${name}:start`] = commands.start;
-  }
-  const dependabotPath = (0, import_node_path3.join)(workspaceRoot, ".github/dependabot.yml");
-  if ((0, import_node_fs3.existsSync)(dependabotPath)) {
-    writeFileEnsured(dependabotPath, dependabotConfig(workspaceRoot));
-  }
-  const manifestPath = (0, import_node_path3.join)(workspaceRoot, "package.json");
-  const manifest = readJson(manifestPath);
-  const existingScripts = manifest.scripts ?? {};
-  const overrides = {
-    ...manifest.overrides,
-    ...reactExpressPeerOverride(manifest)
-  };
-  writeFileEnsured(
-    manifestPath,
-    toJson({
-      ...manifest,
-      scripts: { ...existingScripts, ...scripts },
-      ...Object.keys(overrides).length > 0 && { overrides }
-    })
-  );
-  const codeWorkspacePath = findCodeWorkspaceFile(workspaceRoot);
-  if (!codeWorkspacePath) {
-    return;
-  }
-  const workspaceFile = readCodeWorkspace(codeWorkspacePath) ?? {};
-  const label = (task) => task.label ?? "";
-  const existingTasks = (workspaceFile.tasks?.tasks ?? []).filter(
-    (task) => !label(task).startsWith(`${name}: `)
-  );
-  const newTasks = [
-    projectTask(name, "qa"),
-    ...commands.build ? [projectTask(name, "build")] : [],
-    ...commands.start ? [projectTask(name, "start")] : []
-  ];
-  writeFileEnsured(
-    codeWorkspacePath,
-    toJson({
-      ...workspaceFile,
-      tasks: {
-        version: workspaceFile.tasks?.version ?? "2.0.0",
-        tasks: [...existingTasks, ...newTasks]
-      }
-    })
-  );
-}
-var PROJECT_MANIFEST_ROOTS = ["apps", "packages", "libs"];
-function rootRuntimeDependencies(workspaceRoot) {
-  try {
-    return readJson((0, import_node_path3.join)(workspaceRoot, "package.json")).dependencies ?? {};
-  } catch {
-    return {};
-  }
-}
-function relocateRootRuntimeDependencies(workspaceRoot, projectName, before) {
-  const after = rootRuntimeDependencies(workspaceRoot);
-  const added = Object.keys(after).filter((name) => !Object.hasOwn(before, name));
-  if (added.length === 0) {
-    return;
-  }
-  const manifestPath = PROJECT_MANIFEST_ROOTS.map(
-    (root) => (0, import_node_path3.join)(workspaceRoot, root, projectName, "package.json")
-  ).find((candidate) => fileExists(candidate));
-  if (manifestPath === void 0) {
-    return;
-  }
-  const manifest = readJson(manifestPath);
-  const owned = manifest.dependencies ?? {};
-  const moved = Object.fromEntries(added.map((name) => [name, after[name]]));
-  writeFileEnsured(manifestPath, toJson({ ...manifest, dependencies: { ...moved, ...owned } }));
-  const remaining = Object.fromEntries(
-    Object.entries(after).filter(([name]) => !added.includes(name))
+  const manifest = readJson(manifestPath);
+  const owned = manifest.dependencies ?? {};
+  const moved = Object.fromEntries(added.map((name) => [name, after[name]]));
+  writeFileEnsured(manifestPath, toJson({ ...manifest, dependencies: { ...moved, ...owned } }));
+  const remaining = Object.fromEntries(
+    Object.entries(after).filter(([name]) => !added.includes(name))
   );
   const rootManifest = readJson((0, import_node_path3.join)(workspaceRoot, "package.json"));
   const { dependencies: _dropped, ...rest } = rootManifest;
@@ -2126,7 +1835,7 @@ function relocateRootRuntimeDependencies(workspaceRoot, projectName, before) {
   }
 }
 
-// src/commands/add/csharp.ts
+// src/project-scaffolding/csharp.use-case.ts
 function ensureDotnet(workspaceRoot) {
   if (runShell("dotnet", ["--version"], workspaceRoot) !== 0) {
     throw new Error(".NET SDK not found. Install .NET 8+ first: https://dotnet.microsoft.com/download");
@@ -2383,7 +2092,7 @@ function addCsharpFunctionApp(workspaceRoot, name) {
   registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 
-// src/commands/add/flutter.ts
+// src/project-scaffolding/flutter.use-case.ts
 var import_node_path5 = require("path");
 function flutterAppStartTarget(name) {
   return {
@@ -2436,7 +2145,7 @@ function addFlutterInternalLib(workspaceRoot, name) {
   registerProjectCommands(workspaceRoot, name, { build: false });
 }
 
-// src/commands/add/go.ts
+// src/project-scaffolding/go.use-case.ts
 var import_node_fs5 = require("fs");
 var import_node_path6 = require("path");
 function ensureGo(workspaceRoot) {
@@ -2612,7 +2321,7 @@ function addGoInternalLib(workspaceRoot, name) {
   }
 }
 
-// src/commands/add/node.ts
+// src/project-scaffolding/node.use-case.ts
 var import_node_path7 = require("path");
 function ensurePlugin2(workspaceRoot, packageName) {
   if (hasPlugin(workspaceRoot, packageName)) {
@@ -2766,72 +2475,387 @@ function addNodeFunctionApp(workspaceRoot, name, stack) {
   registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
 }
 
-// src/commands/add/npmLib.ts
-var import_node_path8 = require("path");
-async function addNpmLib(workspaceRoot, name, options, kindProvided, stack) {
-  const scope = options.scope ?? (kindProvided ? defaultScope(workspaceRoot) : await promptText("npm scope for the published package", defaultScope(workspaceRoot)));
-  const projectRoot = (0, import_node_path8.join)(workspaceRoot, "packages", name);
-  const manifestPath = (0, import_node_path8.join)(projectRoot, "package.json");
-  runGeneratorAndRepair(
-    workspaceRoot,
-    [
-      "g",
-      "@nx/js:lib",
-      `packages/${name}`,
-      "--publishable",
-      `--importPath=${scope}/${name}`,
-      "--bundler=rollup",
-      `--unitTestRunner=${stack.testRunner}`,
-      "--linter=none",
-      "--no-interactive"
-    ],
-    manifestPath,
-    () => {
-      markPublic(manifestPath);
-      repairPublishableManifest(manifestPath);
-      repairDeclarationSpecifiers(projectRoot);
-      writeProjectReadme(projectRoot, `${scope}/${name}`, stack.testRunner);
-      removeGeneratedEslintConfig(workspaceRoot, `packages/${name}`);
-      registerProjectCommands(workspaceRoot, name, { build: true });
-    }
-  );
-}
+// src/project-scaffolding/npm-lib.use-case.ts
+var import_node_path11 = require("path");
 
-// src/commands/add/python.ts
+// src/rollup-library/repair-publishable-manifest.use-case.ts
 var import_node_fs6 = require("fs");
-var import_node_path9 = require("path");
-function ensurePython(workspaceRoot) {
-  const hasPython = runShell("python3", ["--version"], workspaceRoot) === 0 || runShell("python", ["--version"], workspaceRoot) === 0;
-  if (!hasPython) {
-    throw new Error(
-      "Python not found. Install Python 3.9+ first: https://www.python.org/downloads/"
-    );
+var import_node_path8 = require("path");
+var WRONG_TYPES_PATH = "./dist/index.esm.d.ts";
+var ACTUAL_TYPES_PATH = "./dist/src/index.d.ts";
+var DECLARATION_MAP_EXCLUSION = "!**/*.d.ts.map";
+var SOURCE_MAP_EXCLUSION = "!**/*.js.map";
+function repairPublishableManifest(manifestPath) {
+  const manifest = readJson(manifestPath);
+  if (manifest.types === WRONG_TYPES_PATH) {
+    manifest.types = ACTUAL_TYPES_PATH;
   }
-}
-function pythonPipPluginSpec() {
-  return process.env.MNCI2_PYTHON_PIP_SPEC ?? "@mnci/nx-python-pip";
-}
-function ensurePythonPipPlugin(workspaceRoot) {
-  if (hasPlugin(workspaceRoot, "@mnci/nx-python-pip")) {
-    return;
+  const dot = manifest.exports?.["."];
+  if (typeof dot === "object" && dot.types === WRONG_TYPES_PATH) {
+    dot.types = ACTUAL_TYPES_PATH;
   }
-  const spec = pythonPipPluginSpec();
-  logger.step(`Installing the Python toolchain plugin (${spec})`);
-  if (runShell("npm", ["install", "--save-dev", spec, "--no-audit", "--no-fund"], workspaceRoot) !== 0) {
-    throw new Error("npm install of @mnci/nx-python-pip failed");
+  for (const exclusion of [DECLARATION_MAP_EXCLUSION, SOURCE_MAP_EXCLUSION]) {
+    if (manifest.files && !manifest.files.includes(exclusion)) {
+      manifest.files.push(exclusion);
+    }
   }
+  writeFileEnsured(manifestPath, toJson(manifest));
 }
-var PYTHON_REQUIREMENTS_DEV = `build
-twine
-ruff
-pytest
-pip-audit
-`;
-function ensureRequirementsDev(workspaceRoot) {
-  const requirementsDevPath = (0, import_node_path9.join)(workspaceRoot, "requirements-dev.txt");
-  if (!fileExists(requirementsDevPath)) {
-    writeFileEnsured(requirementsDevPath, PYTHON_REQUIREMENTS_DEV);
-  }
+function repairPublishableManifests(workspaceRoot) {
+  const changed = [];
+  const manifests = (0, import_node_fs6.globSync)(["packages/*/package.json", "libs/*/package.json"], {
+    cwd: workspaceRoot
+  });
+  for (const relativePath of manifests) {
+    const manifestPath = (0, import_node_path8.join)(workspaceRoot, relativePath);
+    const before = (0, import_node_fs6.readFileSync)(manifestPath, "utf8");
+    repairPublishableManifest(manifestPath);
+    const after = (0, import_node_fs6.readFileSync)(manifestPath, "utf8");
+    if (after !== before) {
+      changed.push(relativePath.replaceAll("\\", "/"));
+    }
+  }
+  return changed;
+}
+
+// src/rollup-library/repair-rollup-config.use-case.ts
+var import_node_fs7 = require("fs");
+var import_node_path9 = require("path");
+
+// src/rollup-library/rollup-config.algorithm.ts
+var ROLLUP_CONFIG_PLACEHOLDER = [
+  "  {",
+  "    // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options",
+  "    // e.g.",
+  "    // output: { sourcemap: true },",
+  "  }"
+].join("\n");
+var GENERATED_COMPILER_PATTERN = /^( {4})compiler\s*:\s*'swc',$/m;
+function sourceMapCapableCompiler(indent) {
+  return [
+    `${indent}// Swapped from swc by MoNecromanCI. @nx/rollup runs swc without`,
+    `${indent}// sourceMaps, so it returns no map and the bundle's map comes out empty -`,
+    `${indent}// valid-looking, and useless for debugging. See ROADMAP.`,
+    `${indent}compiler: 'babel',`
+  ].join("\n");
+}
+var ROLLUP_ARG_ONE_BOUNDARY = ["  },", "  {", ""].join("\n");
+var ROLLUP_ARG_ONE_WITH_SOURCE_MAPS = [
+  "    // Added by MoNecromanCI: without this rollup emits no .js.map at all, so",
+  "    // a breakpoint in a .ts file can never bind. Not published - see `files`.",
+  "    sourceMap: true",
+  "  },",
+  "  {",
+  ""
+].join("\n");
+function hasRollupSourceMaps(config) {
+  return /sourceMap\s*:\s*true\b/.test(config);
+}
+function canRepairRollupConfig(config) {
+  return config.includes(ROLLUP_ARG_ONE_BOUNDARY);
+}
+function withRollupSourceMaps(config) {
+  if (hasRollupSourceMaps(config) || !canRepairRollupConfig(config)) {
+    return config;
+  }
+  const withCompiler = config.replace(
+    GENERATED_COMPILER_PATTERN,
+    (_match, indent) => sourceMapCapableCompiler(indent)
+  );
+  const withFlag = withCompiler.replace(
+    ROLLUP_ARG_ONE_BOUNDARY,
+    () => ROLLUP_ARG_ONE_WITH_SOURCE_MAPS
+  );
+  return withFlag.includes("sourcemapPathTransform") ? withFlag : withFlag.replace(
+    ROLLUP_ARG_ONE_WITH_SOURCE_MAPS,
+    () => `${ROLLUP_ARG_ONE_WITH_SOURCE_MAPS}${SOURCEMAP_PATH_TRANSFORM}`
+  );
+}
+var SOURCEMAP_PATH_TRANSFORM = [
+  "    // Added by MoNecromanCI. rollup hands sourcemapPathTransform an OS-NATIVE",
+  "    // path with one parent segment too many, so `sources` resolve to nothing",
+  "    // and no breakpoint can bind. Separators are normalised too: a sources",
+  "    // entry is URL-style, so a backslash is wrong on every platform.",
+  "    output: {",
+  "      sourcemapPathTransform: relativeSourcePath =>",
+  "        relativeSourcePath",
+  "          .replaceAll(String.fromCodePoint(92), '/')",
+  "          .replace(/^([.][.][/])+/, '../')",
+  "    },",
+  ""
+].join("\n");
+var DECLARATION_SPECIFIER_PLUGIN_MARKER = "name: 'mnci-normalise-declaration-specifiers'";
+var DECLARATION_SPECIFIER_EXTENSION_MARKER = "bareRelativeSpecifier";
+var DECLARATION_SPECIFIER_DIRECTORY_MARKER = "resolveSpecifierSuffix";
+function hasDeclarationSpecifierPlugin(config) {
+  return config.includes(DECLARATION_SPECIFIER_PLUGIN_MARKER);
+}
+function hasDirectoryAwareDeclarationSpecifiers(config) {
+  return config.includes(DECLARATION_SPECIFIER_DIRECTORY_MARKER);
+}
+var DECLARATION_SPECIFIER_PLUGIN = [
+  "      {",
+  "        name: 'mnci-normalise-declaration-specifiers',",
+  "        writeBundle (outputOptions) {",
+  "          const { existsSync, readdirSync, readFileSync, writeFileSync } = require('node:fs')",
+  "          const { join } = require('node:path')",
+  "          const dir = outputOptions.dir ?? './dist'",
+  "          const stub = join(dir, 'index.d.ts')",
+  "          let source",
+  "          try {",
+  "            source = readFileSync(stub, 'utf8')",
+  "          } catch {",
+  "            return",
+  "          }",
+  "          // The stub carries a TWO-character escape (JSON.stringify escaped one",
+  "          // backslash), so this must not match a single one - that would turn",
+  String.raw`          // "./src\index" into "./src//index". Built from char codes so there is`,
+  "          // no escaping in this file to get wrong.",
+  "          const separator = String.fromCodePoint(92, 92)",
+  "          const normalised = source.replaceAll(separator, '/')",
+  "          if (normalised !== source) writeFileSync(stub, normalised)",
+  "",
+  String.raw`          const ${DECLARATION_SPECIFIER_EXTENSION_MARKER} = /from(\s+)(['"])(\.[^'"]+?)\2/g`,
+  String.raw`          const hasExtension = /\.(?:mjs|cjs|jsx?|json)$/`,
+  "          let entries",
+  "          try {",
+  "            entries = readdirSync(dir, { recursive: true, withFileTypes: true })",
+  "          } catch {",
+  "            return",
+  "          }",
+  "          for (const entry of entries) {",
+  "            if (!entry.name.endsWith('.d.ts')) continue",
+  "            const from = entry.parentPath ?? entry.path",
+  "            const filePath = join(from, entry.name)",
+  "            let declaration",
+  "            try {",
+  "              declaration = readFileSync(filePath, 'utf8')",
+  "            } catch {",
+  "              continue",
+  "            }",
+  "            // A bare specifier may name a FILE or a DIRECTORY BARREL - resolved",
+  "            // against what rollup actually emitted next to this file, never",
+  "            // guessed. A directory needs /index.js, not .js (a file that was",
+  "            // never written); anything neither form matches is left alone rather",
+  "            // than rewritten to a specifier that cannot resolve.",
+  `            const ${DECLARATION_SPECIFIER_DIRECTORY_MARKER} = (specifier) => {`,
+  "              if (hasExtension.test(specifier)) return null",
+  "              if (existsSync(join(from, specifier + '.d.ts'))) return specifier + '.js'",
+  "              if (existsSync(join(from, specifier, 'index.d.ts'))) return specifier + '/index.js'",
+  "              return null",
+  "            }",
+  "            const withExtensions = declaration.replace(",
+  `              ${DECLARATION_SPECIFIER_EXTENSION_MARKER},`,
+  "              (match, space, quote, specifier) => {",
+  `                const resolved = ${DECLARATION_SPECIFIER_DIRECTORY_MARKER}(specifier)`,
+  "                return resolved === null ? match : `from${space}${quote}${resolved}${quote}`",
+  "              },",
+  "            )",
+  "            if (withExtensions !== declaration) writeFileSync(filePath, withExtensions)",
+  "          }",
+  "        }",
+  "      }"
+].join("\n");
+var ROLLUP_CONFIG_WITH_DTS_FIX = [
+  "  {",
+  "    // Added by MoNecromanCI. @nx/rollup's dts-bundle plugin writes dist/index.d.ts",
+  "    // as a stub re-exporting the real declarations, and builds that specifier with",
+  "    // path.relative() - an OS-NATIVE path. On Windows it emits",
+  String.raw`    //   export * from "./src\\index";`,
+  "    // which is not a valid module specifier on ANY platform: a specifier is",
+  "    // URL-style, so / is correct everywhere and a backslash nowhere. It resolves on",
+  "    // Windows only because the resolver normalises separators there, leaving the",
+  "    // package untyped on Linux and macOS.",
+  "    //",
+  "    // mnci also points `types` past this stub, so nothing depends on it being",
+  "    // correct; this makes the emitted file correct too. Remove once Nx fixes the",
+  "    // plugin - its own devkit already exports normalizePath for exactly this.",
+  "    //",
+  "    // The second half fixes a separate defect in the REAL declarations `types`",
+  '    // points at: tsconfig.lib.json declares under moduleResolution "bundler",',
+  '    // where a bare relative specifier ("./lib/align") is valid, so every emitted',
+  "    // .d.ts keeps the source's own extensionless imports verbatim. A consumer on",
+  '    // "moduleResolution": "nodenext" - the workspace root default - requires an',
+  "    // explicit extension on every relative specifier and gets TS2834 (or,",
+  "    // combined with skipLibCheck, a silent zero-export module) instead. Declared",
+  "    // extensions are left untouched; only a bare relative specifier gets .js",
+  "    // appended, matching what tsc itself emits under node16/nodenext.",
+  "    plugins: [",
+  DECLARATION_SPECIFIER_PLUGIN,
+  "    ]",
+  "  }"
+].join("\n");
+function findEnclosingBraceSpan(text, needle) {
+  const needleIndex = text.indexOf(needle);
+  if (needleIndex === -1) {
+    return void 0;
+  }
+  const start = text.lastIndexOf("{", needleIndex);
+  if (start === -1) {
+    return void 0;
+  }
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    if (text[index] === "{") {
+      depth += 1;
+    } else if (text[index] === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return [start, index + 1];
+      }
+    }
+  }
+  return void 0;
+}
+function withUpgradedDeclarationSpecifierPlugin(config) {
+  if (!config.includes(DECLARATION_SPECIFIER_PLUGIN_MARKER) || config.includes(DECLARATION_SPECIFIER_DIRECTORY_MARKER)) {
+    return config;
+  }
+  const span = findEnclosingBraceSpan(config, DECLARATION_SPECIFIER_PLUGIN_MARKER);
+  if (!span) {
+    return config;
+  }
+  const [start, end] = span;
+  return `${config.slice(0, start)}${DECLARATION_SPECIFIER_PLUGIN}${config.slice(end)}`;
+}
+
+// src/rollup-library/repair-rollup-config.use-case.ts
+function repairRollupSourceMaps(workspaceRoot) {
+  const changed = [];
+  const configs = (0, import_node_fs7.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+    cwd: workspaceRoot
+  });
+  for (const relativePath of configs) {
+    const configPath = (0, import_node_path9.join)(workspaceRoot, relativePath);
+    const before = (0, import_node_fs7.readFileSync)(configPath, "utf8");
+    const after = withRollupSourceMaps(before);
+    if (after !== before) {
+      writeFileEnsured(configPath, after);
+      changed.push(relativePath.replaceAll("\\", "/"));
+    }
+  }
+  return changed;
+}
+function upgradeDeclarationSpecifierPlugins(workspaceRoot) {
+  const changed = [];
+  const configs = (0, import_node_fs7.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+    cwd: workspaceRoot
+  });
+  for (const relativePath of configs) {
+    const configPath = (0, import_node_path9.join)(workspaceRoot, relativePath);
+    const before = (0, import_node_fs7.readFileSync)(configPath, "utf8");
+    const after = withUpgradedDeclarationSpecifierPlugin(before);
+    if (after !== before) {
+      writeFileEnsured(configPath, after);
+      changed.push(relativePath.replaceAll("\\", "/"));
+    }
+  }
+  return changed;
+}
+function repairDeclarationSpecifiers(projectRoot) {
+  const configPath = (0, import_node_path9.join)(projectRoot, "rollup.config.cjs");
+  if (!fileExists(configPath)) {
+    return;
+  }
+  const config = (0, import_node_fs7.readFileSync)(configPath, "utf8");
+  if (!config.includes(ROLLUP_CONFIG_PLACEHOLDER)) {
+    return;
+  }
+  const withDtsFix = config.split(ROLLUP_CONFIG_PLACEHOLDER).join(ROLLUP_CONFIG_WITH_DTS_FIX);
+  writeFileEnsured(configPath, withRollupSourceMaps(withDtsFix));
+}
+
+// src/rollup-library/rollup-config.repository.ts
+var import_node_fs8 = require("fs");
+var import_node_path10 = require("path");
+function resolveRequireTarget(fromDir, specifier) {
+  const base = (0, import_node_path10.join)(fromDir, specifier);
+  return [base, `${base}.cjs`, `${base}.js`].find((candidate) => fileExists(candidate));
+}
+function resolveRollupConfigText(configPath, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(configPath)) {
+    return "";
+  }
+  visited.add(configPath);
+  let text;
+  try {
+    text = (0, import_node_fs8.readFileSync)(configPath, "utf8");
+  } catch {
+    return "";
+  }
+  const specifiers = Array.from(
+    text.matchAll(/require\((['"])(\.[^'"]*)\1\)/g),
+    (match) => match[2]
+  );
+  const requiredText = specifiers.map((specifier) => resolveRequireTarget((0, import_node_path10.dirname)(configPath), specifier)).filter((target) => target !== void 0).map((target) => resolveRollupConfigText(target, visited));
+  return [text, ...requiredText].join("\n");
+}
+
+// src/project-scaffolding/npm-lib.use-case.ts
+async function addNpmLib(workspaceRoot, name, options, kindProvided, stack) {
+  const scope = options.scope ?? (kindProvided ? defaultScope(workspaceRoot) : await promptText("npm scope for the published package", defaultScope(workspaceRoot)));
+  const projectRoot = (0, import_node_path11.join)(workspaceRoot, "packages", name);
+  const manifestPath = (0, import_node_path11.join)(projectRoot, "package.json");
+  runGeneratorAndRepair(
+    workspaceRoot,
+    [
+      "g",
+      "@nx/js:lib",
+      `packages/${name}`,
+      "--publishable",
+      `--importPath=${scope}/${name}`,
+      "--bundler=rollup",
+      `--unitTestRunner=${stack.testRunner}`,
+      "--linter=none",
+      "--no-interactive"
+    ],
+    manifestPath,
+    () => {
+      markPublic(manifestPath);
+      repairPublishableManifest(manifestPath);
+      repairDeclarationSpecifiers(projectRoot);
+      writeProjectReadme(projectRoot, `${scope}/${name}`, stack.testRunner);
+      removeGeneratedEslintConfig(workspaceRoot, `packages/${name}`);
+      registerProjectCommands(workspaceRoot, name, { build: true });
+    }
+  );
+}
+
+// src/project-scaffolding/python.use-case.ts
+var import_node_fs9 = require("fs");
+var import_node_path12 = require("path");
+function ensurePython(workspaceRoot) {
+  const hasPython = runShell("python3", ["--version"], workspaceRoot) === 0 || runShell("python", ["--version"], workspaceRoot) === 0;
+  if (!hasPython) {
+    throw new Error(
+      "Python not found. Install Python 3.9+ first: https://www.python.org/downloads/"
+    );
+  }
+}
+function pythonPipPluginSpec() {
+  return process.env.MNCI2_PYTHON_PIP_SPEC ?? "@mnci/nx-python-pip";
+}
+function ensurePythonPipPlugin(workspaceRoot) {
+  if (hasPlugin(workspaceRoot, "@mnci/nx-python-pip")) {
+    return;
+  }
+  const spec = pythonPipPluginSpec();
+  logger.step(`Installing the Python toolchain plugin (${spec})`);
+  if (runShell("npm", ["install", "--save-dev", spec, "--no-audit", "--no-fund"], workspaceRoot) !== 0) {
+    throw new Error("npm install of @mnci/nx-python-pip failed");
+  }
+}
+var PYTHON_REQUIREMENTS_DEV = `build
+twine
+ruff
+pytest
+pip-audit
+`;
+function ensureRequirementsDev(workspaceRoot) {
+  const requirementsDevPath = (0, import_node_path12.join)(workspaceRoot, "requirements-dev.txt");
+  if (!fileExists(requirementsDevPath)) {
+    writeFileEnsured(requirementsDevPath, PYTHON_REQUIREMENTS_DEV);
+  }
 }
 function pythonModuleDirectory(name) {
   return name.replaceAll("-", "_");
@@ -2888,8 +2912,8 @@ function addPythonApp(workspaceRoot, name) {
     ["g", "@mnci/nx-python-pip:application", name, `--directory=apps/${name}`, "--no-interactive"],
     workspaceRoot
   );
-  writeFileEnsured((0, import_node_path9.join)(workspaceRoot, "apps", name, "main.py"), pythonAppMain(name));
-  addProjectJsonTargets((0, import_node_path9.join)(workspaceRoot, "apps", name, "project.json"), {
+  writeFileEnsured((0, import_node_path12.join)(workspaceRoot, "apps", name, "main.py"), pythonAppMain(name));
+  addProjectJsonTargets((0, import_node_path12.join)(workspaceRoot, "apps", name, "project.json"), {
     package: pythonAppPackageTarget(name),
     start: pythonAppStartTarget(name)
   });
@@ -2911,7 +2935,7 @@ function addPythonFunctionApp(workspaceRoot, name) {
     workspaceRoot
   );
   const moduleDirectory = pythonModuleDirectory(name);
-  addProjectJsonTargets((0, import_node_path9.join)(workspaceRoot, "apps", name, "project.json"), {
+  addProjectJsonTargets((0, import_node_path12.join)(workspaceRoot, "apps", name, "project.json"), {
     package: pythonFunctionAppPackageTarget(name, moduleDirectory),
     start: pythonFunctionAppStartTarget(name)
   });
@@ -2952,7 +2976,7 @@ function addPythonInternalLib(workspaceRoot, name) {
 var PYTHON_PROJECT_DIRS = ["apps", "python-packages", "libs"];
 function findPythonProjectDirectory(workspaceRoot, name) {
   return PYTHON_PROJECT_DIRS.find(
-    (directory) => fileExists((0, import_node_path9.join)(workspaceRoot, directory, name, "pyproject.toml"))
+    (directory) => fileExists((0, import_node_path12.join)(workspaceRoot, directory, name, "pyproject.toml"))
   );
 }
 function parseVendorEntries(pyprojectToml) {
@@ -2991,7 +3015,7 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
       `No Python project named '${consumer}' with a pyproject.toml found (checked apps/, python-packages/, libs/). A Python function app has no pyproject.toml \u2014 there is nothing to vendor into.`
     );
   }
-  if (!fileExists((0, import_node_path9.join)(workspaceRoot, "libs", lib, "pyproject.toml"))) {
+  if (!fileExists((0, import_node_path12.join)(workspaceRoot, "libs", lib, "pyproject.toml"))) {
     throw new Error(
       `No internal Python library named '${lib}' found at libs/${lib}/pyproject.toml. Only an internal library (added via 'mnci add python-internal-lib') can be vendored.`
     );
@@ -2999,8 +3023,8 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
   if (consumerDirectory === "libs" && consumer === lib) {
     throw new Error(`'${consumer}' cannot vendor itself.`);
   }
-  const pyprojectPath = (0, import_node_path9.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
-  const pyprojectToml = (0, import_node_fs6.readFileSync)(pyprojectPath, "utf8");
+  const pyprojectPath = (0, import_node_path12.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
+  const pyprojectToml = (0, import_node_fs9.readFileSync)(pyprojectPath, "utf8");
   if (parseVendorEntries(pyprojectToml).includes(lib)) {
     logger.info(`'${consumer}' already vendors '${lib}' \u2014 nothing to do.`);
     return;
@@ -3011,9 +3035,9 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
   );
 }
 
-// src/commands/add/reactApp.ts
-var import_node_fs7 = require("fs");
-var import_node_path10 = require("path");
+// src/project-scaffolding/react-app.use-case.ts
+var import_node_fs10 = require("fs");
+var import_node_path13 = require("path");
 var REACT_ENVIRONMENTS = ["dev", "uat", "prod"];
 function reactEnvironmentFile(environment) {
   return `# Vite compiles VITE_-prefixed vars into the '${environment}' bundle at build time.
@@ -3050,12 +3074,12 @@ function reactAppTargets(name) {
   return targets;
 }
 function allowEnvFiles(workspaceRoot) {
-  const gitignorePath = (0, import_node_path10.join)(workspaceRoot, ".gitignore");
+  const gitignorePath = (0, import_node_path13.join)(workspaceRoot, ".gitignore");
   if (!fileExists(gitignorePath)) {
     return;
   }
   const marker = "# MoNecromanCI: keep the committed per-environment Vite config (public VITE_ values)";
-  const current = (0, import_node_fs7.readFileSync)(gitignorePath, "utf8");
+  const current = (0, import_node_fs10.readFileSync)(gitignorePath, "utf8");
   if (current.includes(marker)) {
     return;
   }
@@ -3082,24 +3106,24 @@ function addReactApp(workspaceRoot, name, stack) {
     workspaceRoot
   );
   ensureAdmZip(workspaceRoot);
-  const reactAppRoot = (0, import_node_path10.join)(workspaceRoot, "apps", name);
+  const reactAppRoot = (0, import_node_path13.join)(workspaceRoot, "apps", name);
   for (const environment of REACT_ENVIRONMENTS) {
-    writeFileEnsured((0, import_node_path10.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
+    writeFileEnsured((0, import_node_path13.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
   }
   allowEnvFiles(workspaceRoot);
-  addNxTargets((0, import_node_path10.join)(reactAppRoot, "package.json"), reactAppTargets(name));
+  addNxTargets((0, import_node_path13.join)(reactAppRoot, "package.json"), reactAppTargets(name));
   removeGeneratedEslintConfig(workspaceRoot, `apps/${name}`);
   registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:serve` });
 }
 
-// src/commands/add/reactLib.ts
-var import_node_path11 = require("path");
+// src/project-scaffolding/react-lib.use-case.ts
+var import_node_path14 = require("path");
 var REACT_LIB_BUNDLER = "rollup";
 async function addReactLib(workspaceRoot, name, options, kindProvided, stack) {
   ensurePlugin(workspaceRoot, "@nx/react");
   const scope = options.scope ?? (kindProvided ? defaultScope(workspaceRoot) : await promptText("npm scope for the published package", defaultScope(workspaceRoot)));
-  const projectRoot = (0, import_node_path11.join)(workspaceRoot, "packages", name);
-  const publishableManifest = (0, import_node_path11.join)(projectRoot, "package.json");
+  const projectRoot = (0, import_node_path14.join)(workspaceRoot, "packages", name);
+  const publishableManifest = (0, import_node_path14.join)(projectRoot, "package.json");
   runGeneratorAndRepair(
     workspaceRoot,
     [
@@ -3127,8 +3151,8 @@ async function addReactLib(workspaceRoot, name, options, kindProvided, stack) {
 }
 function addReactInternalLib(workspaceRoot, name, stack) {
   ensurePlugin(workspaceRoot, "@nx/react");
-  const projectRoot = (0, import_node_path11.join)(workspaceRoot, "libs", name);
-  const privateManifest = (0, import_node_path11.join)(projectRoot, "package.json");
+  const projectRoot = (0, import_node_path14.join)(workspaceRoot, "libs", name);
+  const privateManifest = (0, import_node_path14.join)(projectRoot, "package.json");
   runGeneratorAndRepair(
     workspaceRoot,
     [
@@ -3153,12 +3177,12 @@ function addReactInternalLib(workspaceRoot, name, stack) {
   );
 }
 
-// src/commands/sync.ts
-var import_node_path13 = require("path");
+// src/dependency-management/sync-dependencies.use-case.ts
+var import_node_path16 = require("path");
 
-// src/deps/inventory.ts
-var import_node_fs8 = require("fs");
-var import_node_path12 = require("path");
+// src/dependency-management/manifest.repository.ts
+var import_node_fs11 = require("fs");
+var import_node_path15 = require("path");
 var ECOSYSTEMS = ["npm", "pip", "pub", "nuget", "go"];
 var ROOT_LABEL = "(root)";
 var MANIFEST_GLOBS = {
@@ -3191,23 +3215,23 @@ function projectOf(manifestRelativePath) {
 }
 function hasEcosystem(workspaceRoot, ecosystem) {
   if (ecosystem === "go") {
-    return fileExists((0, import_node_path12.join)(workspaceRoot, "go.mod"));
+    return fileExists((0, import_node_path15.join)(workspaceRoot, "go.mod"));
   }
   if (ecosystem === "nuget") {
-    return (0, import_node_fs8.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot }).length > 0;
+    return (0, import_node_fs11.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot }).length > 0;
   }
   const rootMarker = {
     npm: "package.json",
     pip: "requirements-dev.txt",
     pub: "pubspec.yaml"
   };
-  return fileExists((0, import_node_path12.join)(workspaceRoot, rootMarker[ecosystem])) || (0, import_node_fs8.globSync)(MANIFEST_GLOBS[ecosystem], { cwd: workspaceRoot }).length > 0;
+  return fileExists((0, import_node_path15.join)(workspaceRoot, rootMarker[ecosystem])) || (0, import_node_fs11.globSync)(MANIFEST_GLOBS[ecosystem], { cwd: workspaceRoot }).length > 0;
 }
 function collectNpm(workspaceRoot) {
   const sites = [];
-  const relativePaths = ["package.json", ...(0, import_node_fs8.globSync)(MANIFEST_GLOBS.npm, { cwd: workspaceRoot })];
+  const relativePaths = ["package.json", ...(0, import_node_fs11.globSync)(MANIFEST_GLOBS.npm, { cwd: workspaceRoot })];
   for (const relativePath of relativePaths) {
-    const manifestPath = (0, import_node_path12.join)(workspaceRoot, relativePath);
+    const manifestPath = (0, import_node_path15.join)(workspaceRoot, relativePath);
     try {
       const manifest = readJson(manifestPath);
       sites.push(...npmManifestSites(manifest, relativePath, manifestPath));
@@ -3268,17 +3292,17 @@ function collectPip(workspaceRoot) {
       name: parsed.name,
       ecosystem: "pip",
       project: projectOf(relativePath),
-      manifestPath: (0, import_node_path12.join)(workspaceRoot, relativePath),
+      manifestPath: (0, import_node_path15.join)(workspaceRoot, relativePath),
       section,
       spec: parsed.spec,
       rewritable: parsed.rewritable && parsed.spec !== ""
     });
   };
-  const pyprojectPaths = (0, import_node_fs8.globSync)(MANIFEST_GLOBS.pip, { cwd: workspaceRoot });
+  const pyprojectPaths = (0, import_node_fs11.globSync)(MANIFEST_GLOBS.pip, { cwd: workspaceRoot });
   for (const relativePath of pyprojectPaths) {
     let content;
     try {
-      content = (0, import_node_fs8.readFileSync)((0, import_node_path12.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs11.readFileSync)((0, import_node_path15.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -3289,14 +3313,14 @@ function collectPip(workspaceRoot) {
   }
   const requirementsPaths = [
     "requirements-dev.txt",
-    ...(0, import_node_fs8.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot })
+    ...(0, import_node_fs11.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot })
   ];
   for (const relativePath of requirementsPaths) {
-    if (!fileExists((0, import_node_path12.join)(workspaceRoot, relativePath))) {
+    if (!fileExists((0, import_node_path15.join)(workspaceRoot, relativePath))) {
       continue;
     }
     const section = relativePath === "requirements-dev.txt" ? "devDep" : "dep";
-    const lines = (0, import_node_fs8.readFileSync)((0, import_node_path12.join)(workspaceRoot, relativePath), "utf8").split(/\r?\n/);
+    const lines = (0, import_node_fs11.readFileSync)((0, import_node_path15.join)(workspaceRoot, relativePath), "utf8").split(/\r?\n/);
     for (const line of lines) {
       push(relativePath, section, line);
     }
@@ -3334,11 +3358,11 @@ function pyprojectDependencies(content) {
 }
 function collectPub(workspaceRoot) {
   const sites = [];
-  const pubspecPaths = (0, import_node_fs8.globSync)(MANIFEST_GLOBS.pub, { cwd: workspaceRoot });
+  const pubspecPaths = (0, import_node_fs11.globSync)(MANIFEST_GLOBS.pub, { cwd: workspaceRoot });
   for (const relativePath of pubspecPaths) {
     let content;
     try {
-      content = (0, import_node_fs8.readFileSync)((0, import_node_path12.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs11.readFileSync)((0, import_node_path15.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -3348,7 +3372,7 @@ function collectPub(workspaceRoot) {
           name: entry.name,
           ecosystem: "pub",
           project: projectOf(relativePath),
-          manifestPath: (0, import_node_path12.join)(workspaceRoot, relativePath),
+          manifestPath: (0, import_node_path15.join)(workspaceRoot, relativePath),
           section: block === "dependencies" ? "dep" : "devDep",
           spec: entry.spec,
           rewritable: entry.spec !== ""
@@ -3398,11 +3422,11 @@ function stripQuotes(value) {
 }
 function collectNuget(workspaceRoot) {
   const sites = [];
-  const csprojPaths = (0, import_node_fs8.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot });
+  const csprojPaths = (0, import_node_fs11.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot });
   for (const relativePath of csprojPaths) {
     let content;
     try {
-      content = (0, import_node_fs8.readFileSync)((0, import_node_path12.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs11.readFileSync)((0, import_node_path15.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -3411,7 +3435,7 @@ function collectNuget(workspaceRoot) {
         name: entry.name,
         ecosystem: "nuget",
         project: projectOf(relativePath),
-        manifestPath: (0, import_node_path12.join)(workspaceRoot, relativePath),
+        manifestPath: (0, import_node_path15.join)(workspaceRoot, relativePath),
         section: "dep",
         spec: entry.spec,
         // A plain SemVer string is rewritable; an MSBuild property reference
@@ -3436,13 +3460,13 @@ function csprojPackageReferences(content) {
   return entries;
 }
 function collectGo(workspaceRoot) {
-  const manifestPath = (0, import_node_path12.join)(workspaceRoot, "go.mod");
+  const manifestPath = (0, import_node_path15.join)(workspaceRoot, "go.mod");
   if (!fileExists(manifestPath)) {
     return [];
   }
   let content;
   try {
-    content = (0, import_node_fs8.readFileSync)(manifestPath, "utf8");
+    content = (0, import_node_fs11.readFileSync)(manifestPath, "utf8");
   } catch {
     return [];
   }
@@ -3499,7 +3523,7 @@ function rewriteSpec(site, spec) {
     writeFileEnsured(site.manifestPath, toJson(manifest));
     return true;
   }
-  const before = (0, import_node_fs8.readFileSync)(site.manifestPath, "utf8");
+  const before = (0, import_node_fs11.readFileSync)(site.manifestPath, "utf8");
   const after = (() => {
     switch (site.ecosystem) {
       case "pip": {
@@ -3555,13 +3579,13 @@ function escapeForRegex(value) {
 function isWorkspaceProject(workspaceRoot, name) {
   const short = name.includes("/") ? name.split("/").at(-1) : name;
   return ["apps", "libs", "packages"].some(
-    (directory) => fileExists((0, import_node_path12.join)(workspaceRoot, directory, short ?? name, "package.json"))
+    (directory) => fileExists((0, import_node_path15.join)(workspaceRoot, directory, short ?? name, "package.json"))
   );
 }
 function isAliasedInstall(workspaceRoot, name) {
   try {
     const installed = readJson(
-      (0, import_node_path12.join)(workspaceRoot, "node_modules", name, "package.json")
+      (0, import_node_path15.join)(workspaceRoot, "node_modules", name, "package.json")
     );
     return installed.name !== void 0 && installed.name !== name;
   } catch {
@@ -3572,1340 +3596,1340 @@ function resolvedVersion(workspaceRoot, ecosystem, name) {
   if (ecosystem === "npm") {
     try {
       return readJson(
-        (0, import_node_path12.join)(workspaceRoot, "node_modules", name, "package.json")
+        (0, import_node_path15.join)(workspaceRoot, "node_modules", name, "package.json")
       ).version;
     } catch {
       return void 0;
     }
   }
   if (ecosystem === "pub") {
-    const lockPath = (0, import_node_path12.join)(workspaceRoot, "pubspec.lock");
+    const lockPath = (0, import_node_path15.join)(workspaceRoot, "pubspec.lock");
     if (!fileExists(lockPath)) {
       return void 0;
     }
     try {
       const match = new RegExp(
-        String.raw`^\s{2}${escapeForRegex(name)}:[^]*?^\s+version:\s*["']?([^"'\s]+)`,
-        "m"
-      ).exec((0, import_node_fs8.readFileSync)(lockPath, "utf8"));
-      return match?.[1];
-    } catch {
-      return void 0;
-    }
-  }
-  if (ecosystem === "pip") {
-    const python = process.platform === "win32" ? "python" : "python3";
-    const result = runCapture(python, ["-m", "pip", "show", name], workspaceRoot);
-    if (result.status !== 0) {
-      return void 0;
-    }
-    return /^Version:\s*(\S+)/m.exec(result.stdout)?.[1];
-  }
-  return void 0;
-}
-
-// src/deps/semver.ts
-var UPDATE_KINDS = ["patch", "minor", "major", "non-semver"];
-var UPDATE_KIND_LABELS = {
-  "patch": { title: "Patch Update", blurb: "Backwards-compatible bug fixes." },
-  "minor": { title: "Minor Update", blurb: "New backwards-compatible features." },
-  "major": { title: "Major Update", blurb: "Potentially breaking API changes. Use caution." },
-  "non-semver": { title: "Non-Semver", blurb: "Versions less than 1.0.0, caution." }
-};
-var RANGE_OPERATORS = [">=", "<=", "^", "~", ">", "<", "="];
-function parseVersion(raw) {
-  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([\w.-]+))?/.exec(raw.trim());
-  if (!match) {
-    return void 0;
-  }
-  return {
-    major: Number(match[1]),
-    minor: Number(match[2]),
-    patch: Number(match[3]),
-    prerelease: match[4]
-  };
-}
-function rangeOperator(spec) {
-  const trimmed = spec.trim();
-  return RANGE_OPERATORS.find((operator) => trimmed.startsWith(operator)) ?? "";
-}
-function specVersion(spec) {
-  const bare2 = spec.trim().slice(rangeOperator(spec).length).trim();
-  return /^\d+\.\d+(?:\.\d+)?(?:-[\w.-]+)?$/.test(bare2) ? bare2 : void 0;
-}
-function compareVersions(left, right) {
-  const a = parseVersion(left);
-  const b = parseVersion(right);
-  if (!a || !b) {
-    return 0;
-  }
-  if (a.major !== b.major) {
-    return a.major - b.major;
-  }
-  if (a.minor !== b.minor) {
-    return a.minor - b.minor;
-  }
-  if (a.patch !== b.patch) {
-    return a.patch - b.patch;
-  }
-  if (a.prerelease === b.prerelease) {
-    return 0;
-  }
-  if (!a.prerelease) {
-    return 1;
-  }
-  if (!b.prerelease) {
-    return -1;
-  }
-  return a.prerelease < b.prerelease ? -1 : 1;
-}
-function isNewer(candidate, current) {
-  return compareVersions(candidate, current) > 0;
-}
-function classify(current, latest) {
-  const from = parseVersion(current);
-  const to = parseVersion(latest);
-  if (!from || !to || from.major === 0) {
-    return "non-semver";
-  }
-  if (from.major !== to.major) {
-    return "major";
-  }
-  return from.minor === to.minor ? "patch" : "minor";
-}
-function highestSpec(specs) {
-  let best;
-  let bestVersion;
-  for (const spec of specs) {
-    const version = specVersion(spec);
-    if (!version) {
-      continue;
-    }
-    if (!bestVersion || isNewer(version, bestVersion)) {
-      best = spec;
-      bestVersion = version;
-    }
-  }
-  return best;
-}
-
-// src/commands/sync.ts
-function resolveEcosystems(requested) {
-  if (!requested) {
-    return ECOSYSTEMS;
-  }
-  const match = ECOSYSTEMS.find((ecosystem) => ecosystem === requested);
-  if (!match) {
-    throw new Error(
-      `Unknown ecosystem '${requested}'. Expected one of: ${ECOSYSTEMS.join(", ")}.`
-    );
-  }
-  return [match];
-}
-function collectDrift(workspaceRoot, ecosystems = ECOSYSTEMS) {
-  const reconcilable = ecosystems.filter((ecosystem) => ecosystem !== "go");
-  const inventory = collectInventory(workspaceRoot, reconcilable);
-  const drift = [];
-  for (const [name, allSites] of inventory) {
-    const sites = allSites.filter((site) => site.section !== PEER_SECTION);
-    if (sites.length < 2 || isWorkspaceLocal(workspaceRoot, sites, name)) {
-      continue;
-    }
-    const distinct = new Set(sites.map((site) => site.spec));
-    if (distinct.size < 2) {
-      continue;
-    }
-    const installed = resolvedVersion(workspaceRoot, sites[0].ecosystem, name);
-    const target = chooseTarget(sites, installed);
-    if (!target) {
-      continue;
-    }
-    const disagreeing = sites.filter((site) => site.spec !== target);
-    drift.push({
-      name,
-      ecosystem: sites[0].ecosystem,
-      target,
-      reason: installed ? "resolved" : "highest",
-      fixable: disagreeing.filter((site) => site.rewritable),
-      blocked: disagreeing.filter((site) => !site.rewritable)
-    });
-  }
-  return drift.toSorted((left, right) => left.name.localeCompare(right.name));
-}
-function isWorkspaceLocal(workspaceRoot, sites, name) {
-  return sites[0].ecosystem === "npm" && isWorkspaceProject(workspaceRoot, name);
-}
-function chooseTarget(sites, installed) {
-  if (!installed) {
-    return highestSpec(sites.map((site) => site.spec));
-  }
-  const counts = /* @__PURE__ */ new Map();
-  for (const site of sites) {
-    if (!specVersion(site.spec)) {
-      continue;
-    }
-    const operator2 = rangeOperator(site.spec);
-    counts.set(operator2, (counts.get(operator2) ?? 0) + 1);
-  }
-  if (counts.size === 0) {
-    return void 0;
-  }
-  const [operator] = [...counts].toSorted(
-    (left, right) => right[1] - left[1] || (left[0] === "^" ? -1 : 1)
-  )[0];
-  return `${operator}${installed}`;
-}
-function applyDrift(drift) {
-  const changed = /* @__PURE__ */ new Set();
-  for (const finding of drift) {
-    for (const site of finding.fixable) {
-      if (rewriteSpec(site, finding.target)) {
-        changed.add(site.manifestPath);
-      }
+        String.raw`^\s{2}${escapeForRegex(name)}:[^]*?^\s+version:\s*["']?([^"'\s]+)`,
+        "m"
+      ).exec((0, import_node_fs11.readFileSync)(lockPath, "utf8"));
+      return match?.[1];
+    } catch {
+      return void 0;
     }
   }
-  return [...changed];
+  if (ecosystem === "pip") {
+    const python = process.platform === "win32" ? "python" : "python3";
+    const result = runCapture(python, ["-m", "pip", "show", name], workspaceRoot);
+    if (result.status !== 0) {
+      return void 0;
+    }
+    return /^Version:\s*(\S+)/m.exec(result.stdout)?.[1];
+  }
+  return void 0;
 }
-function syncProjectReferences(workspaceRoot) {
-  logger.step("Syncing TypeScript project references (nx sync)");
-  if (runShell("npx", ["nx", "sync"], workspaceRoot) !== 0) {
-    logger.warn(
-      "nx sync did not complete \u2014 run `npx nx sync` yourself so cross-project imports resolve in your editor."
-    );
+
+// src/dependency-management/semver.algorithm.ts
+var UPDATE_KINDS = ["patch", "minor", "major", "non-semver"];
+var UPDATE_KIND_LABELS = {
+  "patch": { title: "Patch Update", blurb: "Backwards-compatible bug fixes." },
+  "minor": { title: "Minor Update", blurb: "New backwards-compatible features." },
+  "major": { title: "Major Update", blurb: "Potentially breaking API changes. Use caution." },
+  "non-semver": { title: "Non-Semver", blurb: "Versions less than 1.0.0, caution." }
+};
+var RANGE_OPERATORS = [">=", "<=", "^", "~", ">", "<", "="];
+function parseVersion(raw) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([\w.-]+))?/.exec(raw.trim());
+  if (!match) {
+    return void 0;
   }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4]
+  };
 }
-function describe(finding) {
-  const sites = [...finding.fixable, ...finding.blocked].map((site) => `${site.project === ROOT_LABEL ? ROOT_LABEL : site.project} ${site.spec}`).join(", ");
-  return `${finding.name} \u2192 ${finding.target} (${finding.reason}); disagreeing: ${sites}`;
+function rangeOperator(spec) {
+  const trimmed = spec.trim();
+  return RANGE_OPERATORS.find((operator) => trimmed.startsWith(operator)) ?? "";
 }
-function runSync(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path13.join)(workspaceRoot, "nx.json"))) {
-    throw new Error(
-      `No nx.json found in ${workspaceRoot} \u2014 run 'mnci sync' from the workspace root.`
-    );
-  }
-  const ecosystems = resolveEcosystems(options.ecosystem);
-  for (const ecosystem of ecosystems) {
-    if (!hasEcosystem(workspaceRoot, ecosystem)) {
-      logger.info(`\u2298 SKIPPED ${ecosystem} \u2014 no ${ecosystem} project in this workspace.`);
-    }
+function specVersion(spec) {
+  const bare2 = spec.trim().slice(rangeOperator(spec).length).trim();
+  return /^\d+\.\d+(?:\.\d+)?(?:-[\w.-]+)?$/.test(bare2) ? bare2 : void 0;
+}
+function compareVersions(left, right) {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (!a || !b) {
+    return 0;
   }
-  if (ecosystems.includes("go") && hasEcosystem(workspaceRoot, "go")) {
-    logger.success("go \u2014 nothing to sync; one root go.mod means one version of every module.");
+  if (a.major !== b.major) {
+    return a.major - b.major;
   }
-  const drift = collectDrift(workspaceRoot, ecosystems);
-  if (drift.length === 0) {
-    logger.success("Every project agrees on every shared dependency version.");
-  } else {
-    for (const finding of drift) {
-      logger.info(`  ${describe(finding)}`);
-    }
+  if (a.minor !== b.minor) {
+    return a.minor - b.minor;
   }
-  if (options.check) {
-    if (drift.length > 0) {
-      logger.error(
-        `${drift.length} package(s) declared at more than one version. Run 'mnci sync' to converge them.`
-      );
-      process.exitCode = 1;
-    }
-    return;
+  if (a.patch !== b.patch) {
+    return a.patch - b.patch;
   }
-  const changed = applyDrift(drift);
-  for (const path of changed) {
-    logger.detail(`updated ${path}`);
+  if (a.prerelease === b.prerelease) {
+    return 0;
   }
-  const blocked = drift.flatMap((finding) => finding.blocked);
-  for (const site of blocked) {
-    logger.warn(
-      `${site.name} in ${site.project} is declared as '${site.spec}', which is not a plain version range \u2014 left unchanged.`
-    );
+  if (!a.prerelease) {
+    return 1;
   }
-  syncProjectReferences(workspaceRoot);
-  if (changed.length > 0) {
-    logger.step("Formatting the changed manifests (eslint --fix)");
-    runFormatter(workspaceRoot);
+  if (!b.prerelease) {
+    return -1;
   }
-  logger.success("Done. Review the changes with `git diff` before committing.");
+  return a.prerelease < b.prerelease ? -1 : 1;
 }
-
-// src/commands/add.ts
-var PROJECT_KINDS = [
-  "react-app",
-  "react-lib",
-  "react-internal-lib",
-  "node-app",
-  "node-function-app",
-  "npm-lib",
-  "internal-lib",
-  "python-app",
-  "python-function-app",
-  "python-lib",
-  "python-internal-lib",
-  "python-vendor",
-  "go-app",
-  "go-function-app",
-  "go-lib",
-  "go-internal-lib",
-  "flutter-app",
-  "flutter-lib",
-  "flutter-internal-lib",
-  "csharp-app",
-  "csharp-function-app",
-  "csharp-lib",
-  "csharp-internal-lib"
-];
-async function runAdd(kind, name, options) {
-  const workspaceRoot = process.cwd();
-  if (!fileExists((0, import_node_path14.join)(workspaceRoot, "nx.json"))) {
-    throw new Error("No nx.json found here. Run `add` from the workspace root.");
+function isNewer(candidate, current) {
+  return compareVersions(candidate, current) > 0;
+}
+function classify(current, latest) {
+  const from = parseVersion(current);
+  const to = parseVersion(latest);
+  if (!from || !to || from.major === 0) {
+    return "non-semver";
   }
-  const stack = readWorkspaceStack(workspaceRoot);
-  const kindProvided = kind !== void 0;
-  const resolvedKind = kind ?? await (0, import_prompts6.select)({
-    message: "What kind of project?",
-    choices: PROJECT_KINDS.map((value) => ({ name: value, value }))
-  });
-  const resolvedName = name ?? await promptText("Project name");
-  assertValidProjectName(resolvedName, "Project name");
-  const rootDependenciesBefore = rootRuntimeDependencies(workspaceRoot);
-  switch (resolvedKind) {
-    case "react-app": {
-      addReactApp(workspaceRoot, resolvedName, stack);
-      break;
-    }
-    case "react-lib": {
-      await addReactLib(workspaceRoot, resolvedName, options, kindProvided, stack);
-      break;
-    }
-    case "react-internal-lib": {
-      addReactInternalLib(workspaceRoot, resolvedName, stack);
-      break;
-    }
-    case "node-app": {
-      addNodeApp(workspaceRoot, resolvedName, stack, options.framework);
-      break;
-    }
-    case "node-function-app": {
-      addNodeFunctionApp(workspaceRoot, resolvedName, stack);
-      break;
-    }
-    case "npm-lib": {
-      await addNpmLib(workspaceRoot, resolvedName, options, kindProvided, stack);
-      break;
-    }
-    case "internal-lib": {
-      runNx(
-        [
-          "g",
-          "@nx/js:lib",
-          `libs/${resolvedName}`,
-          "--bundler=tsc",
-          `--unitTestRunner=${stack.testRunner}`,
-          "--linter=none",
-          "--no-interactive"
-        ],
-        workspaceRoot
-      );
-      markPrivate((0, import_node_path14.join)(workspaceRoot, "libs", resolvedName, "package.json"));
-      removeGeneratedEslintConfig(workspaceRoot, `libs/${resolvedName}`);
-      registerProjectCommands(workspaceRoot, resolvedName, { build: true });
-      break;
-    }
-    case "python-app": {
-      addPythonApp(workspaceRoot, resolvedName);
-      break;
-    }
-    case "python-function-app": {
-      addPythonFunctionApp(workspaceRoot, resolvedName);
-      break;
-    }
-    case "python-lib": {
-      addPythonLib(workspaceRoot, resolvedName);
-      break;
-    }
-    case "python-internal-lib": {
-      addPythonInternalLib(workspaceRoot, resolvedName);
-      break;
-    }
-    case "go-app": {
-      addGoApp(workspaceRoot, resolvedName);
-      break;
-    }
-    case "go-function-app": {
-      addGoFunctionApp(workspaceRoot, resolvedName);
-      break;
-    }
-    case "go-lib": {
-      addGoLib(workspaceRoot, resolvedName);
-      break;
-    }
-    case "go-internal-lib": {
-      addGoInternalLib(workspaceRoot, resolvedName);
-      break;
-    }
-    case "flutter-app": {
-      addFlutterApp(workspaceRoot, resolvedName);
-      break;
-    }
-    case "flutter-lib": {
-      addFlutterLib(workspaceRoot, resolvedName);
-      break;
-    }
-    case "flutter-internal-lib": {
-      addFlutterInternalLib(workspaceRoot, resolvedName);
-      break;
-    }
-    case "csharp-app": {
-      addCsharpApp(workspaceRoot, resolvedName);
-      break;
-    }
-    case "csharp-function-app": {
-      addCsharpFunctionApp(workspaceRoot, resolvedName);
-      break;
+  if (from.major !== to.major) {
+    return "major";
+  }
+  return from.minor === to.minor ? "patch" : "minor";
+}
+function highestSpec(specs) {
+  let best;
+  let bestVersion;
+  for (const spec of specs) {
+    const version = specVersion(spec);
+    if (!version) {
+      continue;
     }
-    case "csharp-lib": {
-      await addCsharpLib(workspaceRoot, resolvedName, options, kindProvided);
-      break;
+    if (!bestVersion || isNewer(version, bestVersion)) {
+      best = spec;
+      bestVersion = version;
     }
-    case "csharp-internal-lib": {
-      addCsharpInternalLib(workspaceRoot, resolvedName);
-      break;
+  }
+  return best;
+}
+
+// src/dependency-management/sync-dependencies.use-case.ts
+function resolveEcosystems(requested) {
+  if (!requested) {
+    return ECOSYSTEMS;
+  }
+  const match = ECOSYSTEMS.find((ecosystem) => ecosystem === requested);
+  if (!match) {
+    throw new Error(
+      `Unknown ecosystem '${requested}'. Expected one of: ${ECOSYSTEMS.join(", ")}.`
+    );
+  }
+  return [match];
+}
+function collectDrift(workspaceRoot, ecosystems = ECOSYSTEMS) {
+  const reconcilable = ecosystems.filter((ecosystem) => ecosystem !== "go");
+  const inventory = collectInventory(workspaceRoot, reconcilable);
+  const drift = [];
+  for (const [name, allSites] of inventory) {
+    const sites = allSites.filter((site) => site.section !== PEER_SECTION);
+    if (sites.length < 2 || isWorkspaceLocal(workspaceRoot, sites, name)) {
+      continue;
     }
-    case "python-vendor": {
-      await addPythonVendor(workspaceRoot, resolvedName, options, kindProvided);
-      syncProjectReferences(workspaceRoot);
-      runFormatter(workspaceRoot);
-      return;
+    const distinct = new Set(sites.map((site) => site.spec));
+    if (distinct.size < 2) {
+      continue;
     }
-    default: {
-      const exhaustive = resolvedKind;
-      throw new Error(
-        `Unknown project kind '${exhaustive}'. Expected one of: ${PROJECT_KINDS.join(", ")}.`
-      );
+    const installed = resolvedVersion(workspaceRoot, sites[0].ecosystem, name);
+    const target = chooseTarget(sites, installed);
+    if (!target) {
+      continue;
     }
+    const disagreeing = sites.filter((site) => site.spec !== target);
+    drift.push({
+      name,
+      ecosystem: sites[0].ecosystem,
+      target,
+      reason: installed ? "resolved" : "highest",
+      fixable: disagreeing.filter((site) => site.rewritable),
+      blocked: disagreeing.filter((site) => !site.rewritable)
+    });
   }
-  relocateRootRuntimeDependencies(workspaceRoot, resolvedName, rootDependenciesBefore);
-  syncProjectReferences(workspaceRoot);
-  runFormatter(workspaceRoot);
-  logger.success(`Added ${resolvedKind} '${resolvedName}'.`);
-}
-function readWorkspaceStack(workspaceRoot) {
-  const nxJson = readJson(
-    (0, import_node_path14.join)(workspaceRoot, "nx.json")
-  );
-  const stack = nxJson.mnci?.stack;
-  return {
-    testRunner: stack?.testRunner === "vitest" ? "vitest" : "jest"
-  };
+  return drift.toSorted((left, right) => left.name.localeCompare(right.name));
 }
-
-// src/commands/doctor.ts
-var import_node_fs9 = require("fs");
-var import_node_path15 = require("path");
-var SUPPORTED_ESLINT_MAJOR = ESLINT_VERSION.replace(/^\D*/, "").split(".", 1)[0];
-function toPosix2(path) {
-  return path.replaceAll("\\", "/");
+function isWorkspaceLocal(workspaceRoot, sites, name) {
+  return sites[0].ecosystem === "npm" && isWorkspaceProject(workspaceRoot, name);
 }
-function checkEslintConfigs(workspaceRoot) {
-  const rootConfigs = (0, import_node_fs9.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
-  const projectConfigs = (0, import_node_fs9.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
-    cwd: workspaceRoot
-  }).map((config) => toPosix2(config));
-  return [
-    {
-      check: "root ESLint config",
-      ok: rootConfigs.length === 1,
-      detail: rootConfigs.length === 0 ? "no eslint.config.* at the workspace root" : `${rootConfigs.length} root configs: ${rootConfigs.join(", ")}`,
-      remedy: "run `mnci upgrade` to rewrite the root config"
-    },
-    {
-      check: "no per-project ESLint configs",
-      ok: projectConfigs.length === 0,
-      detail: `found ${projectConfigs.length}: ${projectConfigs.join(", ")}`,
-      remedy: "run `mnci upgrade`, which sweeps {apps,libs,packages}/*/eslint.config.*"
+function chooseTarget(sites, installed) {
+  if (!installed) {
+    return highestSpec(sites.map((site) => site.spec));
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const site of sites) {
+    if (!specVersion(site.spec)) {
+      continue;
     }
-  ];
+    const operator2 = rangeOperator(site.spec);
+    counts.set(operator2, (counts.get(operator2) ?? 0) + 1);
+  }
+  if (counts.size === 0) {
+    return void 0;
+  }
+  const [operator] = [...counts].toSorted(
+    (left, right) => right[1] - left[1] || (left[0] === "^" ? -1 : 1)
+  )[0];
+  return `${operator}${installed}`;
 }
-function declaredDevDependencies(workspaceRoot) {
-  try {
-    const manifest = readJson(
-      (0, import_node_path15.join)(workspaceRoot, "package.json")
-    );
-    return manifest.devDependencies ?? {};
-  } catch {
-    return {};
+function applyDrift(drift) {
+  const changed = /* @__PURE__ */ new Set();
+  for (const finding of drift) {
+    for (const site of finding.fixable) {
+      if (rewriteSpec(site, finding.target)) {
+        changed.add(site.manifestPath);
+      }
+    }
   }
+  return [...changed];
 }
-function checkNoRetiredFormatter(workspaceRoot) {
-  const files = RETIRED_FORMATTER_FILES.filter((file) => fileExists((0, import_node_path15.join)(workspaceRoot, file)));
-  const declared = ["prettier", "eslint-config-prettier", "oxlint", "oxfmt", "@mnci/oxlint-config"].filter((name) => declaredDevDependencies(workspaceRoot)[name] !== void 0);
-  const stale = [...files, ...declared];
-  if (stale.length === 0) {
-    return { check: "ESLint is the only linter and formatter", ok: true };
+function syncProjectReferences(workspaceRoot) {
+  logger.step("Syncing TypeScript project references (nx sync)");
+  if (runShell("npx", ["nx", "sync"], workspaceRoot) !== 0) {
+    logger.warn(
+      "nx sync did not complete \u2014 run `npx nx sync` yourself so cross-project imports resolve in your editor."
+    );
   }
-  return {
-    check: "no retired formatter is still configured",
-    ok: false,
-    detail: `Found: ${stale.join(", ")}. These no longer run, but an editor extension still resolves them and will reformat on save against an opinion no gate checks.`,
-    remedy: "Run 'mnci upgrade' to remove them."
-  };
 }
-function checkEslintPlugin(nxJson) {
-  const plugins = nxJson.plugins ?? [];
-  const registered = plugins.some(
-    (entry) => (typeof entry === "string" ? entry : entry.plugin) === "@nx/eslint/plugin"
-  );
-  return {
-    check: "@nx/eslint/plugin registered",
-    ok: registered,
-    detail: "not in nx.json plugins \u2014 every project silently loses its lint target",
-    remedy: "run `mnci upgrade`"
-  };
+function describe(finding) {
+  const sites = [...finding.fixable, ...finding.blocked].map((site) => `${site.project === ROOT_LABEL ? ROOT_LABEL : site.project} ${site.spec}`).join(", ");
+  return `${finding.name} \u2192 ${finding.target} (${finding.reason}); disagreeing: ${sites}`;
 }
-function checkResolvedEslint(workspaceRoot) {
-  const manifestPath = (0, import_node_path15.join)(workspaceRoot, "node_modules/eslint/package.json");
-  if (!fileExists(manifestPath)) {
-    return void 0;
+function runSync(workspaceRoot, options) {
+  if (!fileExists((0, import_node_path16.join)(workspaceRoot, "nx.json"))) {
+    throw new Error(
+      `No nx.json found in ${workspaceRoot} \u2014 run 'mnci sync' from the workspace root.`
+    );
   }
-  try {
-    const { version } = readJson(manifestPath);
-    const major = version.split(".", 1)[0];
-    return {
-      check: `resolved eslint is ${SUPPORTED_ESLINT_MAJOR}.x`,
-      ok: major === SUPPORTED_ESLINT_MAJOR,
-      detail: `node_modules/eslint is ${version}, but this stack supports ${SUPPORTED_ESLINT_MAJOR}.x (eslint-plugin-react has no release beyond it)`,
-      remedy: `pin eslint to ${ESLINT_VERSION} in every package manifest, then reinstall`
-    };
-  } catch {
-    return void 0;
+  const ecosystems = resolveEcosystems(options.ecosystem);
+  for (const ecosystem of ecosystems) {
+    if (!hasEcosystem(workspaceRoot, ecosystem)) {
+      logger.info(`\u2298 SKIPPED ${ecosystem} \u2014 no ${ecosystem} project in this workspace.`);
+    }
   }
-}
-function checkNpmrc(workspaceRoot, registry, scope) {
-  const npmrcPath = (0, import_node_path15.join)(workspaceRoot, ".npmrc");
-  if (!registry || !fileExists(npmrcPath)) {
-    return void 0;
+  if (ecosystems.includes("go") && hasEcosystem(workspaceRoot, "go")) {
+    logger.success("go \u2014 nothing to sync; one root go.mod means one version of every module.");
   }
-  const npmrc = (0, import_node_fs9.readFileSync)(npmrcPath, "utf8");
-  if (registry.kind === "npm") {
-    return {
-      check: ".npmrc authenticates the public registry",
-      ok: npmrc.includes("//registry.npmjs.org/:_authToken="),
-      detail: "no npmjs.org token line \u2014 `npm publish` cannot authenticate",
-      remedy: "run `mnci upgrade`"
-    };
+  const drift = collectDrift(workspaceRoot, ecosystems);
+  if (drift.length === 0) {
+    logger.success("Every project agrees on every shared dependency version.");
+  } else {
+    for (const finding of drift) {
+      logger.info(`  ${describe(finding)}`);
+    }
   }
-  return {
-    check: ".npmrc routes the scope to the feed",
-    ok: scope !== void 0 && npmrc.includes(`${scope}:registry=`),
-    detail: `no '${scope ?? "@scope"}:registry=' line \u2014 a scoped package could publish to npmjs.org instead of the feed`,
-    remedy: "run `mnci upgrade`"
-  };
+  if (options.check) {
+    if (drift.length > 0) {
+      logger.error(
+        `${drift.length} package(s) declared at more than one version. Run 'mnci sync' to converge them.`
+      );
+      process.exitCode = 1;
+    }
+    return;
+  }
+  const changed = applyDrift(drift);
+  for (const path of changed) {
+    logger.detail(`updated ${path}`);
+  }
+  const blocked = drift.flatMap((finding) => finding.blocked);
+  for (const site of blocked) {
+    logger.warn(
+      `${site.name} in ${site.project} is declared as '${site.spec}', which is not a plain version range \u2014 left unchanged.`
+    );
+  }
+  syncProjectReferences(workspaceRoot);
+  if (changed.length > 0) {
+    logger.step("Formatting the changed manifests (eslint --fix)");
+    runFormatter(workspaceRoot);
+  }
+  logger.success("Done. Review the changes with `git diff` before committing.");
 }
-function checkVersionActions(workspaceRoot) {
-  const candidates = [
-    ...(0, import_node_fs9.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
-    ...(0, import_node_fs9.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
-    ...(0, import_node_fs9.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot })
-  ].map((manifest) => toPosix2(manifest));
-  return candidates.flatMap((manifest) => {
-    const projectRoot = manifest.slice(0, manifest.lastIndexOf("/"));
-    const projectJsonPath = (0, import_node_path15.join)(workspaceRoot, projectRoot, "project.json");
-    let hasOverride = false;
+
+// src/dependency-management/update-dependencies.use-case.ts
+var import_node_path17 = require("path");
+var import_prompts2 = require("@inquirer/prompts");
+
+// src/dependency-management/registry.client.ts
+var LOOKUP_CONCURRENCY = 8;
+async function latestNpmVersions(names, cwd) {
+  const results = await pool(names, LOOKUP_CONCURRENCY, async (name) => {
+    const result = await runCaptureAsync("npm", ["view", name, "version", "--json"], cwd);
+    if (result.status !== 0) {
+      return;
+    }
     try {
-      const projectJson = readJson(projectJsonPath);
-      hasOverride = Boolean(projectJson.release?.version?.versionActions);
+      const parsed = JSON.parse(result.stdout);
+      const version = Array.isArray(parsed) ? parsed.at(-1) : parsed;
+      return typeof version === "string" ? [name, version] : void 0;
     } catch {
+      return;
     }
-    return [
-      {
-        check: `${projectRoot} keeps its versionActions override`,
-        ok: hasOverride,
-        detail: "missing \u2014 nx release aborts for the ENTIRE workspace, not just this project",
-        remedy: `add release.version.versionActions to ${projectRoot}/project.json`
-      }
-    ];
   });
+  return new Map(results.filter((entry) => entry !== void 0));
 }
-var TARGET_FILE_OPTIONS = ["main", "tsConfig", "packageJson"];
-function declaredTargets(workspaceRoot, projectRoot) {
-  const sources = [];
-  for (const [file, extract] of [
-    ["project.json", (json) => json["targets"]],
-    [
-      "package.json",
-      (json) => json["nx"]?.["targets"]
-    ]
-  ]) {
+async function latestPipVersions(names, cwd) {
+  const python = process.platform === "win32" ? "python" : "python3";
+  const results = await pool(names, LOOKUP_CONCURRENCY, async (name) => {
+    const result = await runCaptureAsync(python, ["-m", "pip", "index", "versions", name], cwd);
+    if (result.status !== 0) {
+      return;
+    }
+    const match = /\(([^)]+)\)/.exec(result.stdout);
+    return match ? [name, match[1]] : void 0;
+  });
+  return new Map(results.filter((entry) => entry !== void 0));
+}
+async function latestGoVersions(cwd) {
+  const result = await runCaptureAsync("go", ["list", "-m", "-u", "-json", "all"], cwd);
+  if (result.status !== 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const latest = /* @__PURE__ */ new Map();
+  for (const chunk of result.stdout.split(/^\}\s*$/m)) {
+    const text = `${chunk.trim()}${chunk.trim() ? "}" : ""}`;
+    if (!text.startsWith("{")) {
+      continue;
+    }
     try {
-      const targets = extract(
-        readJson((0, import_node_path15.join)(workspaceRoot, projectRoot, file))
-      );
-      if (targets && typeof targets === "object") {
-        sources.push({
-          source: `${projectRoot}/${file}`,
-          targets
-        });
+      const module_ = JSON.parse(text);
+      if (module_.Path && module_.Update?.Version) {
+        latest.set(module_.Path, module_.Update.Version);
       }
     } catch {
     }
   }
-  return sources;
+  return latest;
 }
-function checkTargetFilesExist(workspaceRoot) {
-  const projectRoots = new Set(
-    [
-      ...(0, import_node_fs9.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
-      ...(0, import_node_fs9.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
-    ].map((manifest) => toPosix2(manifest).split("/").slice(0, 2).join("/"))
-  );
-  return [...projectRoots].flatMap(
-    (projectRoot) => declaredTargets(workspaceRoot, projectRoot).flatMap(
-      ({ source, targets }) => Object.entries(targets).flatMap(
-        ([targetName, target]) => checkOneTargetsFiles(workspaceRoot, source, targetName, target)
-      )
-    )
-  );
+async function latestPubVersions(cwd) {
+  const result = await runCaptureAsync("flutter", ["pub", "outdated", "--json"], cwd);
+  if (result.status !== 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const report = JSON.parse(result.stdout);
+    const latest = /* @__PURE__ */ new Map();
+    const packages = report.packages ?? [];
+    for (const entry of packages) {
+      if (entry.package && entry.latest?.version) {
+        latest.set(entry.package, entry.latest.version);
+      }
+    }
+    return latest;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
 }
-function checkOneTargetsFiles(workspaceRoot, source, targetName, target) {
-  return TARGET_FILE_OPTIONS.flatMap((option) => {
-    const value = target?.options?.[option];
-    const checkable = typeof value === "string" && !value.includes("{");
-    if (!checkable || fileExists((0, import_node_path15.join)(workspaceRoot, value))) {
-      return [];
+async function latestNugetVersions(names, cwd) {
+  const results = await pool(names, LOOKUP_CONCURRENCY, async (name) => {
+    const result = await runCaptureAsync(
+      "dotnet",
+      ["package", "search", name, "--exact-match", "--format", "json"],
+      cwd
+    );
+    if (result.status !== 0) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      const packages = parsed.searchResult?.flatMap((source) => source.packages ?? []) ?? [];
+      const match = packages.find((entry) => entry.id?.toLowerCase() === name.toLowerCase()) ?? packages[0];
+      return match?.latestVersion ? [name, match.latestVersion] : void 0;
+    } catch {
+      return;
     }
-    return [
-      {
-        check: `${source} \u2192 ${targetName}.${option} points at a real file`,
-        ok: false,
-        detail: `${value} does not exist \u2014 the target fails as if the compiler were misconfigured`,
-        remedy: `create ${value}, or correct ${option} in ${source}`
-      }
-    ];
   });
+  return new Map(results.filter((entry) => entry !== void 0));
 }
-function checkSync(workspaceRoot) {
-  return {
-    check: "TypeScript project references synced",
-    ok: runShell("npx", ["nx", "sync:check"], workspaceRoot) === 0,
-    detail: "nx sync:check failed \u2014 a stale project reference was never committed",
-    remedy: "run `npx nx sync` and commit the result"
-  };
+async function latestVersions(ecosystem, names, cwd) {
+  switch (ecosystem) {
+    case "npm": {
+      return await latestNpmVersions(names, cwd);
+    }
+    case "pip": {
+      return await latestPipVersions(names, cwd);
+    }
+    case "nuget": {
+      return await latestNugetVersions(names, cwd);
+    }
+    case "go": {
+      return await latestGoVersions(cwd);
+    }
+    // 'pub' explicitly, not a default: a future ecosystem added to the union
+    // without a case here should fail to compile, not silently resolve as
+    // Dart/Flutter's whole-graph query — exactly the trap this switch would
+    // otherwise have laid for 'nuget' itself.
+    case "pub": {
+      return await latestPubVersions(cwd);
+    }
+  }
 }
-function checkNoRootRuntimeDependencies(workspaceRoot) {
-  const manifestPath = (0, import_node_path15.join)(workspaceRoot, "package.json");
-  if (!fileExists(manifestPath)) {
-    return void 0;
+
+// src/dependency-management/update-dependencies.use-case.ts
+function currentVersion(workspaceRoot, sites) {
+  const installed = resolvedVersion(workspaceRoot, sites[0].ecosystem, sites[0].name);
+  if (installed) {
+    return installed;
   }
-  let declared;
-  try {
-    declared = Object.keys(
-      readJson(manifestPath).dependencies ?? {}
+  if (sites[0].ecosystem === "go") {
+    return bare(sites[0].spec);
+  }
+  const highest = highestSpec(sites.map((site) => site.spec));
+  return highest ? specVersion(highest) : void 0;
+}
+async function collectOutdated(workspaceRoot, ecosystems) {
+  const present = ecosystems.filter((ecosystem) => hasEcosystem(workspaceRoot, ecosystem));
+  const inventory = collectInventory(workspaceRoot, present);
+  const outdated = [];
+  for (const ecosystem of present) {
+    const forEcosystem = [...inventory].filter(
+      ([name, sites]) => offerable(workspaceRoot, ecosystem, name, sites)
     );
-  } catch {
-    return void 0;
+    const latest = await latestVersions(
+      ecosystem,
+      forEcosystem.map(([name]) => name),
+      workspaceRoot
+    );
+    outdated.push(...upgradable(workspaceRoot, ecosystem, forEcosystem, latest));
+  }
+  return outdated.toSorted(
+    (left, right) => UPDATE_KINDS.indexOf(left.kind) - UPDATE_KINDS.indexOf(right.kind) || left.name.localeCompare(right.name)
+  );
+}
+function offerable(workspaceRoot, ecosystem, name, sites) {
+  if (sites[0].ecosystem !== ecosystem || sites[0].section === "indirect") {
+    return false;
+  }
+  if (sites.every((site) => site.section === PEER_SECTION)) {
+    return false;
+  }
+  if (ecosystem !== "npm") {
+    return true;
+  }
+  return !isWorkspaceProject(workspaceRoot, name) && !isAliasedInstall(workspaceRoot, name);
+}
+function bare(version) {
+  return version.replace(/^v/, "");
+}
+function upgradable(workspaceRoot, ecosystem, declared, latest) {
+  const outdated = [];
+  for (const [name, sites] of declared) {
+    const newest = latest.get(name);
+    const current = currentVersion(workspaceRoot, sites);
+    if (!newest || !current || !isNewer(bare(newest), bare(current))) {
+      continue;
+    }
+    outdated.push({
+      name,
+      ecosystem,
+      current,
+      latest: newest,
+      kind: classify(bare(current), bare(newest)),
+      sites
+    });
   }
+  return outdated;
+}
+function row(entry, widths) {
+  const sections = [...new Set(entry.sites.map((site) => site.section))].join("/");
+  const projects = [...new Set(entry.sites.map((site) => site.project))].join(", ");
+  return [
+    entry.name.padEnd(widths.name),
+    sections.padEnd(widths.section),
+    `${entry.current.padStart(widths.current)}  \u203A  ${entry.latest}`,
+    projects
+  ].join("  ");
+}
+function columnWidths(entries) {
   return {
-    check: "no runtime dependencies in the root manifest",
-    ok: declared.length === 0,
-    detail: `the root package.json declares ${declared.join(", ")} \u2014 the root is private and never published, and @nx/rollup externalises only what a project's own manifest declares, so a package importing one of these ships an inlined private copy instead`,
-    remedy: `move ${declared.join(", ")} into the dependencies of each package that imports it (devDependencies at the root are fine \u2014 that is what the root is for)`
+    name: widthOf(entries.map((entry) => entry.name)),
+    section: widthOf(
+      entries.map((entry) => [...new Set(entry.sites.map((site) => site.section))].join("/"))
+    ),
+    current: widthOf(entries.map((entry) => entry.current))
   };
 }
-function checkRollupSourceMaps(workspaceRoot) {
-  const configs = (0, import_node_fs9.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
-    cwd: workspaceRoot
-  }).map((config) => toPosix2(config));
-  return configs.flatMap((relativePath) => {
-    const configPath = (0, import_node_path15.join)(workspaceRoot, relativePath);
-    let config;
-    try {
-      config = (0, import_node_fs9.readFileSync)(configPath, "utf8");
-    } catch {
-      return [];
+function widthOf(values) {
+  return Math.max(0, ...values.map((value) => value.length));
+}
+function reportOutdated(outdated) {
+  const widths = columnWidths(outdated);
+  for (const kind of UPDATE_KINDS) {
+    const section = outdated.filter((entry) => entry.kind === kind);
+    if (section.length === 0) {
+      continue;
+    }
+    const { title, blurb } = UPDATE_KIND_LABELS[kind];
+    logger.info("");
+    logger.info(`${title}  ${blurb}`);
+    for (const entry of section) {
+      logger.info(`  ${row(entry, widths)}`);
     }
-    return [
-      {
-        check: `source maps enabled in ${relativePath}`,
-        ok: hasRollupSourceMaps(resolveRollupConfigText(configPath)),
-        detail: "rollup emits no .js.map without it, so a breakpoint in a .ts file can never bind",
-        remedy: canRepairRollupConfig(config) ? "run `mnci upgrade`, which adds it to every rollup config" : "this config delegates via require() to a shared base mnci does not own \u2014 add `sourceMap: true` to withNx's first argument there by hand; `mnci upgrade` cannot repair a config in this shape"
-      }
-    ];
-  });
+  }
 }
-function checkDeclarationSpecifiers(workspaceRoot) {
-  const configs = (0, import_node_fs9.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
-    cwd: workspaceRoot
-  }).map((config) => toPosix2(config));
-  return configs.flatMap((relativePath) => {
-    const configPath = (0, import_node_path15.join)(workspaceRoot, relativePath);
-    if (!fileExists(configPath)) {
-      return [];
+async function promptForUpdates(outdated) {
+  const widths = columnWidths(outdated);
+  const choices = [];
+  for (const kind of UPDATE_KINDS) {
+    const section = outdated.filter((entry) => entry.kind === kind);
+    if (section.length === 0) {
+      continue;
     }
-    const resolved = resolveRollupConfigText(configPath);
-    if (!hasDeclarationSpecifierPlugin(resolved)) {
-      return [
-        {
-          check: `${relativePath} normalises declaration specifiers`,
-          ok: false,
-          detail: "no mnci-normalise-declaration-specifiers plugin \u2014 the emitted .d.ts files keep the extensionless imports tsconfig.lib.json allows, which a nodenext consumer cannot resolve",
-          // Deliberately NOT `mnci upgrade`, which would send the user in a
-          // circle: `upgradeDeclarationSpecifierPlugins` only rewrites a
-          // plugin that is already there, and `repairDeclarationSpecifiers`
-          // is anchored on the generator's own placeholder comment, which a
-          // config in this state no longer has. Verified by running the
-          // command against exactly this shape — it no-ops. Naming a command
-          // that silently does nothing is the failure mode this file's own
-          // source-map check already goes out of its way to avoid.
-          remedy: "add the plugin to withNx's second argument by hand (copy it from a freshly `mnci add npm-lib`'d project) \u2014 `mnci upgrade` only updates a plugin that is already present, it cannot restore a missing one"
-        }
-      ];
+    const { title, blurb } = UPDATE_KIND_LABELS[kind];
+    choices.push(new import_prompts2.Separator(`
+${title}  ${blurb}`));
+    for (const entry of section) {
+      choices.push({ name: row(entry, widths), value: entry });
     }
-    return [
-      {
-        check: `${relativePath} resolves directory barrels in declarations`,
-        ok: hasDirectoryAwareDeclarationSpecifiers(resolved),
-        detail: "the plugin appends .js to every bare specifier, including ones naming a directory barrel, which needs /index.js \u2014 the named file is never emitted, so every export behind it publishes as `any` with nothing reporting it",
-        remedy: "run `mnci upgrade`, which replaces the plugin body with the current one"
-      }
-    ];
+  }
+  return await (0, import_prompts2.checkbox)({
+    message: "Choose which packages to update.",
+    choices,
+    pageSize: 20
   });
 }
-function collectFindings(workspaceRoot) {
-  const nxJsonPath = (0, import_node_path15.join)(workspaceRoot, "nx.json");
-  if (!fileExists(nxJsonPath)) {
-    throw new Error(
-      `No nx.json found in ${workspaceRoot} \u2014 run 'mnci doctor' from the workspace root.`
-    );
+function applyUpdate(entry) {
+  const changed = [];
+  for (const site of entry.sites) {
+    if (!site.rewritable) {
+      continue;
+    }
+    const spec = `${rangeOperator(site.spec)}${entry.latest}`;
+    if (rewriteSpec(site, spec)) {
+      changed.push(site.manifestPath);
+    }
   }
-  const nxJson = readJson(nxJsonPath);
-  return [
-    ...checkEslintConfigs(workspaceRoot),
-    checkNoRetiredFormatter(workspaceRoot),
-    checkEslintPlugin(nxJson),
-    checkResolvedEslint(workspaceRoot),
-    checkNpmrc(workspaceRoot, nxJson.mnci?.registry, nxJson.mnci?.scope),
-    checkNoRootRuntimeDependencies(workspaceRoot),
-    ...checkRollupSourceMaps(workspaceRoot),
-    ...checkDeclarationSpecifiers(workspaceRoot),
-    ...checkVersionActions(workspaceRoot),
-    ...checkTargetFilesExist(workspaceRoot),
-    checkSync(workspaceRoot)
-  ].filter((finding) => finding !== void 0);
+  return changed;
 }
-function runDoctor(workspaceRoot) {
-  const findings = collectFindings(workspaceRoot);
-  const failed = findings.filter((finding) => !finding.ok);
-  for (const finding of findings) {
-    if (finding.ok) {
-      logger.success(finding.check);
-    } else {
-      logger.error(`${finding.check} \u2014 ${finding.detail ?? "failed"}`);
-      if (finding.remedy) {
-        logger.info(`    fix: ${finding.remedy}`);
-      }
+function reinstall(workspaceRoot, ecosystems) {
+  const commands = [
+    ["npm", "npm", ["install"]],
+    ["pip", "npm", ["run", "python:install"]],
+    ["pub", "flutter", ["pub", "get"]],
+    ["nuget", "npx", ["nx", "run-many", "-t", "restore"]],
+    ["go", "go", ["mod", "tidy"]]
+  ];
+  for (const [ecosystem, command, arguments_] of commands) {
+    if (!ecosystems.has(ecosystem)) {
+      continue;
+    }
+    if (ecosystem === "pip" && !hasPythonInstallScript(workspaceRoot)) {
+      logger.warn(
+        "This workspace has no 'python:install' script \u2014 run 'mnci upgrade' to add it, then reinstall by hand."
+      );
+      continue;
+    }
+    logger.step(`Reinstalling ${ecosystem} dependencies (${command} ${arguments_.join(" ")})`);
+    if (runShell(command, arguments_, workspaceRoot) !== 0) {
+      logger.warn(
+        `${command} ${arguments_.join(" ")} failed \u2014 the manifests were updated, so re-run it once the cause is fixed.`
+      );
     }
   }
-  if (failed.length === 0) {
-    logger.success(`All ${findings.length} checks passed.`);
-    return;
-  }
-  logger.error(`${failed.length} of ${findings.length} checks failed.`);
-  process.exitCode = 1;
 }
-
-// src/commands/interactive.ts
-var import_node_path18 = require("path");
-var import_prompts9 = require("@inquirer/prompts");
-
-// src/commands/new.ts
-var import_node_fs10 = require("fs");
-var import_node_path16 = require("path");
-function nxCloudProviderValue(ci) {
-  return ci === "azure" ? "azure" : "github";
+function hasPythonInstallScript(workspaceRoot) {
+  try {
+    const manifest = readJson(
+      (0, import_node_path17.join)(workspaceRoot, "package.json")
+    );
+    return manifest.scripts?.["python:install"] !== void 0;
+  } catch {
+    return false;
+  }
 }
-async function resolveStack(options) {
-  if (options.testRunner || options.yes) {
-    return { testRunner: options.testRunner ?? DEFAULT_STACK.testRunner };
+function applyGoUpdates(workspaceRoot, entries) {
+  for (const entry of entries) {
+    logger.step(`go get ${entry.name}@${entry.latest}`);
+    if (runShell("go", ["get", `${entry.name}@${entry.latest}`], workspaceRoot) !== 0) {
+      logger.warn(`go get ${entry.name}@${entry.latest} failed \u2014 left at ${entry.current}.`);
+    }
   }
-  const prompted = await promptStack();
-  return { testRunner: prompted.testRunner };
 }
-var CI_PROVIDERS = /* @__PURE__ */ new Set(["azure", "github", "both"]);
-async function resolveCi(options) {
-  if (options.ci && CI_PROVIDERS.has(options.ci)) {
-    return options.ci;
+async function runUp(workspaceRoot, options) {
+  if (!fileExists((0, import_node_path17.join)(workspaceRoot, "nx.json"))) {
+    throw new Error(`No nx.json found in ${workspaceRoot} \u2014 run 'mnci up' from the workspace root.`);
   }
-  if (options.yes) {
-    return "azure";
+  const ecosystems = resolveEcosystems(options.ecosystem);
+  for (const ecosystem of ecosystems) {
+    if (!hasEcosystem(workspaceRoot, ecosystem)) {
+      logger.info(`\u2298 SKIPPED ${ecosystem} \u2014 no ${ecosystem} project in this workspace.`);
+    }
   }
-  return await promptCi();
-}
-async function resolveRegistry(options) {
-  if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
-    return {
-      kind: "azure-artifacts",
-      organization: options.organization ?? await promptText("Azure DevOps organization"),
-      project: options.project ?? await promptText("Azure DevOps project"),
-      artifactsFeed: options.artifactsFeed ?? await promptText("Artifacts feed name")
-    };
+  logger.step("Querying registries for the latest published versions");
+  const outdated = await collectOutdated(workspaceRoot, ecosystems);
+  if (outdated.length === 0) {
+    logger.success("Every dependency is on its latest published version.");
+    return;
   }
-  if (options.registry === "npm" || options.yes) {
-    return { kind: "npm" };
+  const readOnly = options.check ?? !process.stdout.isTTY;
+  if (readOnly) {
+    reportOutdated(outdated);
+    logger.info("");
+    logger.info(`${outdated.length} package(s) have a newer release. Run 'mnci up' to update them.`);
+    return;
   }
-  return await promptRegistry();
-}
-async function runNew(name, options) {
-  const workspaceName = name ?? await promptText("Workspace name");
-  assertValidProjectName(workspaceName, "Workspace name");
-  const scope = options.scope ?? (options.yes ? `@${workspaceName}` : await promptText("npm scope for publishable packages", `@${workspaceName}`));
-  const registry = await resolveRegistry(options);
-  const ci = await resolveCi(options);
-  const agent = options.agent ?? (options.yes ? "ubuntu-latest" : await promptText(
-    "CI build agent/runner (vmImage, GitHub Actions runner label, or self-hosted pool name)",
-    "ubuntu-latest"
-  ));
-  const variableGroup = ci === "github" ? options.variableGroup ?? "Build" : options.variableGroup ?? (options.yes ? "Build" : await promptText("Azure DevOps variable group holding the npm PAT", "Build"));
-  const stack = await resolveStack(options);
-  const nxCloud = options.nxCloud ?? (options.yes ? false : await promptNxCloud());
-  logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
-  runNpx(
-    [
-      "--yes",
-      "create-nx-workspace@latest",
-      workspaceName,
-      "--preset=ts",
-      "--pm=npm",
-      nxCloud ? `--nxCloud=${nxCloudProviderValue(ci)}` : "--nxCloud=skip",
-      "--no-interactive"
-    ],
-    process.cwd()
-  );
-  const workspaceRoot = (0, import_node_path16.join)(process.cwd(), workspaceName);
-  logger.step(
-    "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
-  );
-  applyOverlay(
-    workspaceRoot,
-    { workspaceName, scope, registry, agent, variableGroup, ci, stack },
-    logger.detail
-  );
-  (0, import_node_fs10.rmSync)((0, import_node_path16.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
-  (0, import_node_fs10.rmSync)((0, import_node_path16.join)(workspaceRoot, "package-lock.json"), { force: true });
-  logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
-  const installStatus = runShell(
-    "npm",
-    ["install", "--save-dev", "husky", "@commitlint/cli", "@commitlint/config-conventional"],
-    workspaceRoot
-  );
-  if (installStatus !== 0) {
-    throw new Error(`npm install of the toolchain failed with exit code ${installStatus}`);
+  const selected = options.yes ? [...outdated] : await promptForUpdates(outdated);
+  if (selected.length === 0) {
+    logger.info("Nothing selected; no manifest was changed.");
+    return;
+  }
+  const goSelections = selected.filter((entry) => entry.ecosystem === "go");
+  const changed = selected.filter((entry) => entry.ecosystem !== "go").flatMap((entry) => applyUpdate(entry));
+  const changedManifests = new Set(changed);
+  for (const path of changedManifests) {
+    logger.detail(`updated ${path}`);
+  }
+  applyGoUpdates(workspaceRoot, goSelections);
+  if (options.install !== false) {
+    reinstall(workspaceRoot, new Set(selected.map((entry) => entry.ecosystem)));
+  }
+  if (changed.length > 0) {
+    syncProjectReferences(workspaceRoot);
+    logger.step("Formatting the changed manifests (eslint --fix)");
+    runFormatter(workspaceRoot);
   }
-  runShell("npx", ["husky"], workspaceRoot);
-  logger.step("Formatting the workspace (eslint --fix, JavaScript Standard Style)");
-  runFormatter(workspaceRoot);
-  logger.success("Done. Next steps:");
-  logger.info(`  cd ${workspaceName}`);
-  logger.info("  mnci add react-app web        # or: react-lib, react-internal-lib, node-app,");
-  logger.info("                                 #     node-function-app, npm-lib, internal-lib,");
-  logger.info(
-    "                                 #     python-app, python-function-app, python-lib, python-internal-lib,"
-  );
-  logger.info(
-    "                                 #     go-app, go-function-app, go-lib, go-internal-lib,"
-  );
-  logger.info(
-    "                                 #     flutter-app, flutter-lib, flutter-internal-lib"
+  logger.success(
+    `Updated ${selected.length} package(s). Review the changes with \`git diff\` before committing.`
   );
-  logger.info('  git add -A && git commit -m "feat: initial workspace"');
 }
 
-// src/commands/upgrade.ts
-var import_node_fs11 = require("fs");
-var import_node_path17 = require("path");
-function resolveRegistry2(options, persisted) {
-  if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
-    const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
-    const organization = options.organization ?? persistedAzure?.organization;
-    const project = options.project ?? persistedAzure?.project;
-    const artifactsFeed = options.artifactsFeed ?? persistedAzure?.artifactsFeed;
-    if (!organization || !project || !artifactsFeed) {
+// src/project-scaffolding/add-project.use-case.ts
+var PROJECT_KINDS = [
+  "react-app",
+  "react-lib",
+  "react-internal-lib",
+  "node-app",
+  "node-function-app",
+  "npm-lib",
+  "internal-lib",
+  "python-app",
+  "python-function-app",
+  "python-lib",
+  "python-internal-lib",
+  "python-vendor",
+  "go-app",
+  "go-function-app",
+  "go-lib",
+  "go-internal-lib",
+  "flutter-app",
+  "flutter-lib",
+  "flutter-internal-lib",
+  "csharp-app",
+  "csharp-function-app",
+  "csharp-lib",
+  "csharp-internal-lib"
+];
+async function runAdd(kind, name, options) {
+  const workspaceRoot = process.cwd();
+  if (!fileExists((0, import_node_path18.join)(workspaceRoot, "nx.json"))) {
+    throw new Error("No nx.json found here. Run `add` from the workspace root.");
+  }
+  const stack = readWorkspaceStack(workspaceRoot);
+  const kindProvided = kind !== void 0;
+  const resolvedKind = kind ?? await (0, import_prompts3.select)({
+    message: "What kind of project?",
+    choices: PROJECT_KINDS.map((value) => ({ name: value, value }))
+  });
+  const resolvedName = name ?? await promptText("Project name");
+  assertValidProjectName(resolvedName, "Project name");
+  const rootDependenciesBefore = rootRuntimeDependencies(workspaceRoot);
+  switch (resolvedKind) {
+    case "react-app": {
+      addReactApp(workspaceRoot, resolvedName, stack);
+      break;
+    }
+    case "react-lib": {
+      await addReactLib(workspaceRoot, resolvedName, options, kindProvided, stack);
+      break;
+    }
+    case "react-internal-lib": {
+      addReactInternalLib(workspaceRoot, resolvedName, stack);
+      break;
+    }
+    case "node-app": {
+      addNodeApp(workspaceRoot, resolvedName, stack, options.framework);
+      break;
+    }
+    case "node-function-app": {
+      addNodeFunctionApp(workspaceRoot, resolvedName, stack);
+      break;
+    }
+    case "npm-lib": {
+      await addNpmLib(workspaceRoot, resolvedName, options, kindProvided, stack);
+      break;
+    }
+    case "internal-lib": {
+      runNx(
+        [
+          "g",
+          "@nx/js:lib",
+          `libs/${resolvedName}`,
+          "--bundler=tsc",
+          `--unitTestRunner=${stack.testRunner}`,
+          "--linter=none",
+          "--no-interactive"
+        ],
+        workspaceRoot
+      );
+      markPrivate((0, import_node_path18.join)(workspaceRoot, "libs", resolvedName, "package.json"));
+      removeGeneratedEslintConfig(workspaceRoot, `libs/${resolvedName}`);
+      registerProjectCommands(workspaceRoot, resolvedName, { build: true });
+      break;
+    }
+    case "python-app": {
+      addPythonApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "python-function-app": {
+      addPythonFunctionApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "python-lib": {
+      addPythonLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "python-internal-lib": {
+      addPythonInternalLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "go-app": {
+      addGoApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "go-function-app": {
+      addGoFunctionApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "go-lib": {
+      addGoLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "go-internal-lib": {
+      addGoInternalLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "flutter-app": {
+      addFlutterApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "flutter-lib": {
+      addFlutterLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "flutter-internal-lib": {
+      addFlutterInternalLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "csharp-app": {
+      addCsharpApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "csharp-function-app": {
+      addCsharpFunctionApp(workspaceRoot, resolvedName);
+      break;
+    }
+    case "csharp-lib": {
+      await addCsharpLib(workspaceRoot, resolvedName, options, kindProvided);
+      break;
+    }
+    case "csharp-internal-lib": {
+      addCsharpInternalLib(workspaceRoot, resolvedName);
+      break;
+    }
+    case "python-vendor": {
+      await addPythonVendor(workspaceRoot, resolvedName, options, kindProvided);
+      syncProjectReferences(workspaceRoot);
+      runFormatter(workspaceRoot);
+      return;
+    }
+    default: {
+      const exhaustive = resolvedKind;
       throw new Error(
-        "Azure Artifacts registry needs --organization, --project and --artifacts-feed (none found in nx.json's persisted config either)."
+        `Unknown project kind '${exhaustive}'. Expected one of: ${PROJECT_KINDS.join(", ")}.`
       );
     }
-    return { kind: "azure-artifacts", organization, project, artifactsFeed };
-  }
-  if (options.registry === "npm") {
-    return { kind: "npm" };
-  }
-  if (persisted) {
-    return persisted;
   }
-  throw new Error(
-    "No registry found in nx.json's persisted config. Pass --registry npm or --registry azure-artifacts (with --organization/--project/--artifacts-feed)."
+  relocateRootRuntimeDependencies(workspaceRoot, resolvedName, rootDependenciesBefore);
+  syncProjectReferences(workspaceRoot);
+  runFormatter(workspaceRoot);
+  logger.success(`Added ${resolvedKind} '${resolvedName}'.`);
+}
+function readWorkspaceStack(workspaceRoot) {
+  const nxJson = readJson(
+    (0, import_node_path18.join)(workspaceRoot, "nx.json")
   );
+  const stack = nxJson.mnci?.stack;
+  return {
+    testRunner: stack?.testRunner === "vitest" ? "vitest" : "jest"
+  };
 }
-function resolveWorkspaceName(workspaceRoot, persisted) {
-  if (persisted.workspaceName) {
-    return persisted.workspaceName;
-  }
-  try {
-    const existing = (0, import_node_fs11.readdirSync)(workspaceRoot).find(
-      (file) => file.endsWith(".code-workspace") && file !== "undefined.code-workspace"
-    );
-    if (existing) {
-      return existing.replace(/\.code-workspace$/, "");
+
+// src/workspace-diagnostics/check-invariants.use-case.ts
+var import_node_fs12 = require("fs");
+var import_node_path19 = require("path");
+var SUPPORTED_ESLINT_MAJOR = ESLINT_VERSION.replace(/^\D*/, "").split(".", 1)[0];
+function toPosix2(path) {
+  return path.replaceAll("\\", "/");
+}
+function checkEslintConfigs(workspaceRoot) {
+  const rootConfigs = (0, import_node_fs12.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
+  const projectConfigs = (0, import_node_fs12.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
+    cwd: workspaceRoot
+  }).map((config) => toPosix2(config));
+  return [
+    {
+      check: "root ESLint config",
+      ok: rootConfigs.length === 1,
+      detail: rootConfigs.length === 0 ? "no eslint.config.* at the workspace root" : `${rootConfigs.length} root configs: ${rootConfigs.join(", ")}`,
+      remedy: "run `mnci upgrade` to rewrite the root config"
+    },
+    {
+      check: "no per-project ESLint configs",
+      ok: projectConfigs.length === 0,
+      detail: `found ${projectConfigs.length}: ${projectConfigs.join(", ")}`,
+      remedy: "run `mnci upgrade`, which sweeps {apps,libs,packages}/*/eslint.config.*"
     }
-  } catch {
-  }
-  return (0, import_node_path17.basename)(workspaceRoot);
+  ];
 }
-function resolveOverlayOptions(workspaceRoot, options, persisted) {
-  const scope = options.scope ?? persisted.scope;
-  if (!scope) {
-    throw new Error("No npm scope found in nx.json's persisted config. Pass --scope explicitly.");
-  }
-  const registry = resolveRegistry2(options, persisted.registry);
-  const ci = options.ci ?? persisted.ci;
-  if (!ci) {
-    throw new Error(
-      "No CI provider found in nx.json's persisted config. Pass --ci azure|github|both explicitly."
-    );
-  }
-  const agent = options.agent ?? persisted.agent;
-  if (!agent) {
-    throw new Error(
-      "No CI build agent found in nx.json's persisted config. Pass --agent explicitly."
-    );
-  }
-  const variableGroup = options.variableGroup ?? persisted.variableGroup ?? "Build";
-  const testRunner = options.testRunner ?? persisted.stack?.testRunner;
-  if (!testRunner) {
-    throw new Error(
-      "No testRunner found in nx.json's persisted config. Pass --test-runner explicitly."
+function declaredDevDependencies(workspaceRoot) {
+  try {
+    const manifest = readJson(
+      (0, import_node_path19.join)(workspaceRoot, "package.json")
     );
+    return manifest.devDependencies ?? {};
+  } catch {
+    return {};
+  }
+}
+function checkNoRetiredFormatter(workspaceRoot) {
+  const files = RETIRED_FORMATTER_FILES.filter((file) => fileExists((0, import_node_path19.join)(workspaceRoot, file)));
+  const declared = ["prettier", "eslint-config-prettier", "oxlint", "oxfmt", "@mnci/oxlint-config"].filter((name) => declaredDevDependencies(workspaceRoot)[name] !== void 0);
+  const stale = [...files, ...declared];
+  if (stale.length === 0) {
+    return { check: "ESLint is the only linter and formatter", ok: true };
   }
   return {
-    workspaceName: resolveWorkspaceName(workspaceRoot, persisted),
-    scope,
-    registry,
-    agent,
-    variableGroup,
-    ci,
-    stack: { testRunner }
+    check: "no retired formatter is still configured",
+    ok: false,
+    detail: `Found: ${stale.join(", ")}. These no longer run, but an editor extension still resolves them and will reformat on save against an opinion no gate checks.`,
+    remedy: "Run 'mnci upgrade' to remove them."
   };
 }
-function runUpgrade(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path17.join)(workspaceRoot, "nx.json"))) {
-    throw new Error(
-      `No nx.json found in ${workspaceRoot} \u2014 this does not look like an Nx workspace. Run 'mnci upgrade' from the workspace root.`
-    );
+function checkEslintPlugin(nxJson) {
+  const plugins = nxJson.plugins ?? [];
+  const registered = plugins.some(
+    (entry) => (typeof entry === "string" ? entry : entry.plugin) === "@nx/eslint/plugin"
+  );
+  return {
+    check: "@nx/eslint/plugin registered",
+    ok: registered,
+    detail: "not in nx.json plugins \u2014 every project silently loses its lint target",
+    remedy: "run `mnci upgrade`"
+  };
+}
+function checkResolvedEslint(workspaceRoot) {
+  const manifestPath = (0, import_node_path19.join)(workspaceRoot, "node_modules/eslint/package.json");
+  if (!fileExists(manifestPath)) {
+    return void 0;
   }
-  const persisted = readMnciConfig(workspaceRoot);
-  const resolved = resolveOverlayOptions(workspaceRoot, options, persisted);
-  logger.step("Re-applying the MoNecromanCI overlay");
-  applyOverlay(workspaceRoot, resolved, logger.detail);
-  const repaired = repairRollupSourceMaps(workspaceRoot);
-  if (repaired.length > 0) {
-    logger.step("Enabling source maps in rollup configs (breakpoints in .ts files)");
-    for (const path of repaired) {
-      logger.detail(`updated ${path}`);
-    }
+  try {
+    const { version } = readJson(manifestPath);
+    const major = version.split(".", 1)[0];
+    return {
+      check: `resolved eslint is ${SUPPORTED_ESLINT_MAJOR}.x`,
+      ok: major === SUPPORTED_ESLINT_MAJOR,
+      detail: `node_modules/eslint is ${version}, but this stack supports ${SUPPORTED_ESLINT_MAJOR}.x (eslint-plugin-react has no release beyond it)`,
+      remedy: `pin eslint to ${ESLINT_VERSION} in every package manifest, then reinstall`
+    };
+  } catch {
+    return void 0;
   }
-  const repairedManifests = repairPublishableManifests(workspaceRoot);
-  if (repairedManifests.length > 0) {
-    logger.step("Repointing `types` at the real declaration file");
-    for (const path of repairedManifests) {
-      logger.detail(`updated ${path}`);
-    }
+}
+function checkNpmrc(workspaceRoot, registry, scope) {
+  const npmrcPath = (0, import_node_path19.join)(workspaceRoot, ".npmrc");
+  if (!registry || !fileExists(npmrcPath)) {
+    return void 0;
   }
-  const upgradedDtsPlugins = upgradeDeclarationSpecifierPlugins(workspaceRoot);
-  if (upgradedDtsPlugins.length > 0) {
-    logger.step("Upgrading declaration specifiers to resolve under nodenext");
-    for (const path of upgradedDtsPlugins) {
-      logger.detail(`updated ${path}`);
-    }
+  const npmrc = (0, import_node_fs12.readFileSync)(npmrcPath, "utf8");
+  if (registry.kind === "npm") {
+    return {
+      check: ".npmrc authenticates the public registry",
+      ok: npmrc.includes("//registry.npmjs.org/:_authToken="),
+      detail: "no npmjs.org token line \u2014 `npm publish` cannot authenticate",
+      remedy: "run `mnci upgrade`"
+    };
   }
-  logger.step(
-    "Formatting the workspace (eslint --fix) \u2014 the slowest step, minutes on a large workspace"
-  );
-  runFormatter(workspaceRoot);
-  logger.success("Done. Review the changes with `git diff` before committing.");
-}
-
-// src/commands/interactive.ts
-async function runInteractive() {
-  const inWorkspace = fileExists((0, import_node_path18.join)(process.cwd(), "nx.json"));
-  const choiceNew = { name: "Create a new monorepo", value: "new" };
-  const choiceAdd = { name: "Add a project to this workspace", value: "add" };
-  const choiceUpgrade = {
-    name: "Upgrade this workspace (re-apply the latest overlay)",
-    value: "upgrade"
+  return {
+    check: ".npmrc routes the scope to the feed",
+    ok: scope !== void 0 && npmrc.includes(`${scope}:registry=`),
+    detail: `no '${scope ?? "@scope"}:registry=' line \u2014 a scoped package could publish to npmjs.org instead of the feed`,
+    remedy: "run `mnci upgrade`"
   };
-  const action = await (0, import_prompts9.select)({
-    message: "What would you like to do?",
-    choices: inWorkspace ? [choiceAdd, choiceUpgrade, choiceNew] : [choiceNew, choiceAdd, choiceUpgrade]
-  });
-  if (action === "new") {
-    await runNew(void 0, {});
-  } else if (action === "upgrade") {
-    runUpgrade(process.cwd(), {});
-  } else {
-    await runAdd(void 0, void 0, {});
-  }
 }
-
-// src/commands/up.ts
-var import_node_path19 = require("path");
-var import_prompts10 = require("@inquirer/prompts");
-
-// src/deps/registry.ts
-var LOOKUP_CONCURRENCY = 8;
-async function latestNpmVersions(names, cwd) {
-  const results = await pool(names, LOOKUP_CONCURRENCY, async (name) => {
-    const result = await runCaptureAsync("npm", ["view", name, "version", "--json"], cwd);
-    if (result.status !== 0) {
-      return;
-    }
+function checkVersionActions(workspaceRoot) {
+  const candidates = [
+    ...(0, import_node_fs12.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
+    ...(0, import_node_fs12.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
+    ...(0, import_node_fs12.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot })
+  ].map((manifest) => toPosix2(manifest));
+  return candidates.flatMap((manifest) => {
+    const projectRoot = manifest.slice(0, manifest.lastIndexOf("/"));
+    const projectJsonPath = (0, import_node_path19.join)(workspaceRoot, projectRoot, "project.json");
+    let hasOverride = false;
     try {
-      const parsed = JSON.parse(result.stdout);
-      const version = Array.isArray(parsed) ? parsed.at(-1) : parsed;
-      return typeof version === "string" ? [name, version] : void 0;
+      const projectJson = readJson(projectJsonPath);
+      hasOverride = Boolean(projectJson.release?.version?.versionActions);
     } catch {
-      return;
-    }
-  });
-  return new Map(results.filter((entry) => entry !== void 0));
-}
-async function latestPipVersions(names, cwd) {
-  const python = process.platform === "win32" ? "python" : "python3";
-  const results = await pool(names, LOOKUP_CONCURRENCY, async (name) => {
-    const result = await runCaptureAsync(python, ["-m", "pip", "index", "versions", name], cwd);
-    if (result.status !== 0) {
-      return;
     }
-    const match = /\(([^)]+)\)/.exec(result.stdout);
-    return match ? [name, match[1]] : void 0;
+    return [
+      {
+        check: `${projectRoot} keeps its versionActions override`,
+        ok: hasOverride,
+        detail: "missing \u2014 nx release aborts for the ENTIRE workspace, not just this project",
+        remedy: `add release.version.versionActions to ${projectRoot}/project.json`
+      }
+    ];
   });
-  return new Map(results.filter((entry) => entry !== void 0));
 }
-async function latestGoVersions(cwd) {
-  const result = await runCaptureAsync("go", ["list", "-m", "-u", "-json", "all"], cwd);
-  if (result.status !== 0) {
-    return /* @__PURE__ */ new Map();
-  }
-  const latest = /* @__PURE__ */ new Map();
-  for (const chunk of result.stdout.split(/^\}\s*$/m)) {
-    const text = `${chunk.trim()}${chunk.trim() ? "}" : ""}`;
-    if (!text.startsWith("{")) {
-      continue;
-    }
+var TARGET_FILE_OPTIONS = ["main", "tsConfig", "packageJson"];
+function declaredTargets(workspaceRoot, projectRoot) {
+  const sources = [];
+  for (const [file, extract] of [
+    ["project.json", (json) => json["targets"]],
+    [
+      "package.json",
+      (json) => json["nx"]?.["targets"]
+    ]
+  ]) {
     try {
-      const module_ = JSON.parse(text);
-      if (module_.Path && module_.Update?.Version) {
-        latest.set(module_.Path, module_.Update.Version);
+      const targets = extract(
+        readJson((0, import_node_path19.join)(workspaceRoot, projectRoot, file))
+      );
+      if (targets && typeof targets === "object") {
+        sources.push({
+          source: `${projectRoot}/${file}`,
+          targets
+        });
       }
     } catch {
     }
   }
-  return latest;
+  return sources;
 }
-async function latestPubVersions(cwd) {
-  const result = await runCaptureAsync("flutter", ["pub", "outdated", "--json"], cwd);
-  if (result.status !== 0) {
-    return /* @__PURE__ */ new Map();
-  }
-  try {
-    const report = JSON.parse(result.stdout);
-    const latest = /* @__PURE__ */ new Map();
-    const packages = report.packages ?? [];
-    for (const entry of packages) {
-      if (entry.package && entry.latest?.version) {
-        latest.set(entry.package, entry.latest.version);
-      }
+function checkTargetFilesExist(workspaceRoot) {
+  const projectRoots = new Set(
+    [
+      ...(0, import_node_fs12.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
+      ...(0, import_node_fs12.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
+    ].map((manifest) => toPosix2(manifest).split("/").slice(0, 2).join("/"))
+  );
+  return [...projectRoots].flatMap(
+    (projectRoot) => declaredTargets(workspaceRoot, projectRoot).flatMap(
+      ({ source, targets }) => Object.entries(targets).flatMap(
+        ([targetName, target]) => checkOneTargetsFiles(workspaceRoot, source, targetName, target)
+      )
+    )
+  );
+}
+function checkOneTargetsFiles(workspaceRoot, source, targetName, target) {
+  return TARGET_FILE_OPTIONS.flatMap((option) => {
+    const value = target?.options?.[option];
+    const checkable = typeof value === "string" && !value.includes("{");
+    if (!checkable || fileExists((0, import_node_path19.join)(workspaceRoot, value))) {
+      return [];
     }
-    return latest;
-  } catch {
-    return /* @__PURE__ */ new Map();
-  }
+    return [
+      {
+        check: `${source} \u2192 ${targetName}.${option} points at a real file`,
+        ok: false,
+        detail: `${value} does not exist \u2014 the target fails as if the compiler were misconfigured`,
+        remedy: `create ${value}, or correct ${option} in ${source}`
+      }
+    ];
+  });
 }
-async function latestNugetVersions(names, cwd) {
-  const results = await pool(names, LOOKUP_CONCURRENCY, async (name) => {
-    const result = await runCaptureAsync(
-      "dotnet",
-      ["package", "search", name, "--exact-match", "--format", "json"],
-      cwd
+function checkSync(workspaceRoot) {
+  return {
+    check: "TypeScript project references synced",
+    ok: runShell("npx", ["nx", "sync:check"], workspaceRoot) === 0,
+    detail: "nx sync:check failed \u2014 a stale project reference was never committed",
+    remedy: "run `npx nx sync` and commit the result"
+  };
+}
+function checkNoRootRuntimeDependencies(workspaceRoot) {
+  const manifestPath = (0, import_node_path19.join)(workspaceRoot, "package.json");
+  if (!fileExists(manifestPath)) {
+    return void 0;
+  }
+  let declared;
+  try {
+    declared = Object.keys(
+      readJson(manifestPath).dependencies ?? {}
     );
-    if (result.status !== 0) {
-      return;
-    }
+  } catch {
+    return void 0;
+  }
+  return {
+    check: "no runtime dependencies in the root manifest",
+    ok: declared.length === 0,
+    detail: `the root package.json declares ${declared.join(", ")} \u2014 the root is private and never published, and @nx/rollup externalises only what a project's own manifest declares, so a package importing one of these ships an inlined private copy instead`,
+    remedy: `move ${declared.join(", ")} into the dependencies of each package that imports it (devDependencies at the root are fine \u2014 that is what the root is for)`
+  };
+}
+function checkRollupSourceMaps(workspaceRoot) {
+  const configs = (0, import_node_fs12.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+    cwd: workspaceRoot
+  }).map((config) => toPosix2(config));
+  return configs.flatMap((relativePath) => {
+    const configPath = (0, import_node_path19.join)(workspaceRoot, relativePath);
+    let config;
     try {
-      const parsed = JSON.parse(result.stdout);
-      const packages = parsed.searchResult?.flatMap((source) => source.packages ?? []) ?? [];
-      const match = packages.find((entry) => entry.id?.toLowerCase() === name.toLowerCase()) ?? packages[0];
-      return match?.latestVersion ? [name, match.latestVersion] : void 0;
+      config = (0, import_node_fs12.readFileSync)(configPath, "utf8");
     } catch {
-      return;
+      return [];
     }
+    return [
+      {
+        check: `source maps enabled in ${relativePath}`,
+        ok: hasRollupSourceMaps(resolveRollupConfigText(configPath)),
+        detail: "rollup emits no .js.map without it, so a breakpoint in a .ts file can never bind",
+        remedy: canRepairRollupConfig(config) ? "run `mnci upgrade`, which adds it to every rollup config" : "this config delegates via require() to a shared base mnci does not own \u2014 add `sourceMap: true` to withNx's first argument there by hand; `mnci upgrade` cannot repair a config in this shape"
+      }
+    ];
   });
-  return new Map(results.filter((entry) => entry !== void 0));
 }
-async function latestVersions(ecosystem, names, cwd) {
-  switch (ecosystem) {
-    case "npm": {
-      return await latestNpmVersions(names, cwd);
-    }
-    case "pip": {
-      return await latestPipVersions(names, cwd);
-    }
-    case "nuget": {
-      return await latestNugetVersions(names, cwd);
-    }
-    case "go": {
-      return await latestGoVersions(cwd);
+function checkDeclarationSpecifiers(workspaceRoot) {
+  const configs = (0, import_node_fs12.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+    cwd: workspaceRoot
+  }).map((config) => toPosix2(config));
+  return configs.flatMap((relativePath) => {
+    const configPath = (0, import_node_path19.join)(workspaceRoot, relativePath);
+    if (!fileExists(configPath)) {
+      return [];
     }
-    // 'pub' explicitly, not a default: a future ecosystem added to the union
-    // without a case here should fail to compile, not silently resolve as
-    // Dart/Flutter's whole-graph query — exactly the trap this switch would
-    // otherwise have laid for 'nuget' itself.
-    case "pub": {
-      return await latestPubVersions(cwd);
+    const resolved = resolveRollupConfigText(configPath);
+    if (!hasDeclarationSpecifierPlugin(resolved)) {
+      return [
+        {
+          check: `${relativePath} normalises declaration specifiers`,
+          ok: false,
+          detail: "no mnci-normalise-declaration-specifiers plugin \u2014 the emitted .d.ts files keep the extensionless imports tsconfig.lib.json allows, which a nodenext consumer cannot resolve",
+          // Deliberately NOT `mnci upgrade`, which would send the user in a
+          // circle: `upgradeDeclarationSpecifierPlugins` only rewrites a
+          // plugin that is already there, and `repairDeclarationSpecifiers`
+          // is anchored on the generator's own placeholder comment, which a
+          // config in this state no longer has. Verified by running the
+          // command against exactly this shape — it no-ops. Naming a command
+          // that silently does nothing is the failure mode this file's own
+          // source-map check already goes out of its way to avoid.
+          remedy: "add the plugin to withNx's second argument by hand (copy it from a freshly `mnci add npm-lib`'d project) \u2014 `mnci upgrade` only updates a plugin that is already present, it cannot restore a missing one"
+        }
+      ];
     }
-  }
-}
-
-// src/commands/up.ts
-function currentVersion(workspaceRoot, sites) {
-  const installed = resolvedVersion(workspaceRoot, sites[0].ecosystem, sites[0].name);
-  if (installed) {
-    return installed;
-  }
-  if (sites[0].ecosystem === "go") {
-    return bare(sites[0].spec);
-  }
-  const highest = highestSpec(sites.map((site) => site.spec));
-  return highest ? specVersion(highest) : void 0;
+    return [
+      {
+        check: `${relativePath} resolves directory barrels in declarations`,
+        ok: hasDirectoryAwareDeclarationSpecifiers(resolved),
+        detail: "the plugin appends .js to every bare specifier, including ones naming a directory barrel, which needs /index.js \u2014 the named file is never emitted, so every export behind it publishes as `any` with nothing reporting it",
+        remedy: "run `mnci upgrade`, which replaces the plugin body with the current one"
+      }
+    ];
+  });
 }
-async function collectOutdated(workspaceRoot, ecosystems) {
-  const present = ecosystems.filter((ecosystem) => hasEcosystem(workspaceRoot, ecosystem));
-  const inventory = collectInventory(workspaceRoot, present);
-  const outdated = [];
-  for (const ecosystem of present) {
-    const forEcosystem = [...inventory].filter(
-      ([name, sites]) => offerable(workspaceRoot, ecosystem, name, sites)
-    );
-    const latest = await latestVersions(
-      ecosystem,
-      forEcosystem.map(([name]) => name),
-      workspaceRoot
+function collectFindings(workspaceRoot) {
+  const nxJsonPath = (0, import_node_path19.join)(workspaceRoot, "nx.json");
+  if (!fileExists(nxJsonPath)) {
+    throw new Error(
+      `No nx.json found in ${workspaceRoot} \u2014 run 'mnci doctor' from the workspace root.`
     );
-    outdated.push(...upgradable(workspaceRoot, ecosystem, forEcosystem, latest));
   }
-  return outdated.toSorted(
-    (left, right) => UPDATE_KINDS.indexOf(left.kind) - UPDATE_KINDS.indexOf(right.kind) || left.name.localeCompare(right.name)
-  );
+  const nxJson = readJson(nxJsonPath);
+  return [
+    ...checkEslintConfigs(workspaceRoot),
+    checkNoRetiredFormatter(workspaceRoot),
+    checkEslintPlugin(nxJson),
+    checkResolvedEslint(workspaceRoot),
+    checkNpmrc(workspaceRoot, nxJson.mnci?.registry, nxJson.mnci?.scope),
+    checkNoRootRuntimeDependencies(workspaceRoot),
+    ...checkRollupSourceMaps(workspaceRoot),
+    ...checkDeclarationSpecifiers(workspaceRoot),
+    ...checkVersionActions(workspaceRoot),
+    ...checkTargetFilesExist(workspaceRoot),
+    checkSync(workspaceRoot)
+  ].filter((finding) => finding !== void 0);
 }
-function offerable(workspaceRoot, ecosystem, name, sites) {
-  if (sites[0].ecosystem !== ecosystem || sites[0].section === "indirect") {
-    return false;
-  }
-  if (sites.every((site) => site.section === PEER_SECTION)) {
-    return false;
+function runDoctor(workspaceRoot) {
+  const findings = collectFindings(workspaceRoot);
+  const failed = findings.filter((finding) => !finding.ok);
+  for (const finding of findings) {
+    if (finding.ok) {
+      logger.success(finding.check);
+    } else {
+      logger.error(`${finding.check} \u2014 ${finding.detail ?? "failed"}`);
+      if (finding.remedy) {
+        logger.info(`    fix: ${finding.remedy}`);
+      }
+    }
   }
-  if (ecosystem !== "npm") {
-    return true;
+  if (failed.length === 0) {
+    logger.success(`All ${findings.length} checks passed.`);
+    return;
   }
-  return !isWorkspaceProject(workspaceRoot, name) && !isAliasedInstall(workspaceRoot, name);
+  logger.error(`${failed.length} of ${findings.length} checks failed.`);
+  process.exitCode = 1;
 }
-function bare(version) {
-  return version.replace(/^v/, "");
+
+// src/workspace-creation/create-workspace.use-case.ts
+var import_node_fs13 = require("fs");
+var import_node_path20 = require("path");
+function nxCloudProviderValue(ci) {
+  return ci === "azure" ? "azure" : "github";
 }
-function upgradable(workspaceRoot, ecosystem, declared, latest) {
-  const outdated = [];
-  for (const [name, sites] of declared) {
-    const newest = latest.get(name);
-    const current = currentVersion(workspaceRoot, sites);
-    if (!newest || !current || !isNewer(bare(newest), bare(current))) {
-      continue;
-    }
-    outdated.push({
-      name,
-      ecosystem,
-      current,
-      latest: newest,
-      kind: classify(bare(current), bare(newest)),
-      sites
-    });
+async function resolveStack(options) {
+  if (options.testRunner || options.yes) {
+    return { testRunner: options.testRunner ?? DEFAULT_STACK.testRunner };
   }
-  return outdated;
-}
-function row(entry, widths) {
-  const sections = [...new Set(entry.sites.map((site) => site.section))].join("/");
-  const projects = [...new Set(entry.sites.map((site) => site.project))].join(", ");
-  return [
-    entry.name.padEnd(widths.name),
-    sections.padEnd(widths.section),
-    `${entry.current.padStart(widths.current)}  \u203A  ${entry.latest}`,
-    projects
-  ].join("  ");
-}
-function columnWidths(entries) {
-  return {
-    name: widthOf(entries.map((entry) => entry.name)),
-    section: widthOf(
-      entries.map((entry) => [...new Set(entry.sites.map((site) => site.section))].join("/"))
-    ),
-    current: widthOf(entries.map((entry) => entry.current))
-  };
-}
-function widthOf(values) {
-  return Math.max(0, ...values.map((value) => value.length));
+  const prompted = await promptStack();
+  return { testRunner: prompted.testRunner };
 }
-function reportOutdated(outdated) {
-  const widths = columnWidths(outdated);
-  for (const kind of UPDATE_KINDS) {
-    const section = outdated.filter((entry) => entry.kind === kind);
-    if (section.length === 0) {
-      continue;
-    }
-    const { title, blurb } = UPDATE_KIND_LABELS[kind];
-    logger.info("");
-    logger.info(`${title}  ${blurb}`);
-    for (const entry of section) {
-      logger.info(`  ${row(entry, widths)}`);
-    }
+var CI_PROVIDERS = /* @__PURE__ */ new Set(["azure", "github", "both"]);
+async function resolveCi(options) {
+  if (options.ci && CI_PROVIDERS.has(options.ci)) {
+    return options.ci;
+  }
+  if (options.yes) {
+    return "azure";
   }
+  return await promptCi();
 }
-async function promptForUpdates(outdated) {
-  const widths = columnWidths(outdated);
-  const choices = [];
-  for (const kind of UPDATE_KINDS) {
-    const section = outdated.filter((entry) => entry.kind === kind);
-    if (section.length === 0) {
-      continue;
-    }
-    const { title, blurb } = UPDATE_KIND_LABELS[kind];
-    choices.push(new import_prompts10.Separator(`
-${title}  ${blurb}`));
-    for (const entry of section) {
-      choices.push({ name: row(entry, widths), value: entry });
-    }
+async function resolveRegistry(options) {
+  if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
+    return {
+      kind: "azure-artifacts",
+      organization: options.organization ?? await promptText("Azure DevOps organization"),
+      project: options.project ?? await promptText("Azure DevOps project"),
+      artifactsFeed: options.artifactsFeed ?? await promptText("Artifacts feed name")
+    };
   }
-  return await (0, import_prompts10.checkbox)({
-    message: "Choose which packages to update.",
-    choices,
-    pageSize: 20
-  });
+  if (options.registry === "npm" || options.yes) {
+    return { kind: "npm" };
+  }
+  return await promptRegistry();
 }
-function applyUpdate(entry) {
-  const changed = [];
-  for (const site of entry.sites) {
-    if (!site.rewritable) {
-      continue;
-    }
-    const spec = `${rangeOperator(site.spec)}${entry.latest}`;
-    if (rewriteSpec(site, spec)) {
-      changed.push(site.manifestPath);
-    }
+async function runNew(name, options) {
+  const workspaceName = name ?? await promptText("Workspace name");
+  assertValidProjectName(workspaceName, "Workspace name");
+  const scope = options.scope ?? (options.yes ? `@${workspaceName}` : await promptText("npm scope for publishable packages", `@${workspaceName}`));
+  const registry = await resolveRegistry(options);
+  const ci = await resolveCi(options);
+  const agent = options.agent ?? (options.yes ? "ubuntu-latest" : await promptText(
+    "CI build agent/runner (vmImage, GitHub Actions runner label, or self-hosted pool name)",
+    "ubuntu-latest"
+  ));
+  const variableGroup = ci === "github" ? options.variableGroup ?? "Build" : options.variableGroup ?? (options.yes ? "Build" : await promptText("Azure DevOps variable group holding the npm PAT", "Build"));
+  const stack = await resolveStack(options);
+  const nxCloud = options.nxCloud ?? (options.yes ? false : await promptNxCloud());
+  logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
+  runNpx(
+    [
+      "--yes",
+      "create-nx-workspace@latest",
+      workspaceName,
+      "--preset=ts",
+      "--pm=npm",
+      nxCloud ? `--nxCloud=${nxCloudProviderValue(ci)}` : "--nxCloud=skip",
+      "--no-interactive"
+    ],
+    process.cwd()
+  );
+  const workspaceRoot = (0, import_node_path20.join)(process.cwd(), workspaceName);
+  logger.step(
+    "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
+  );
+  applyOverlay(
+    workspaceRoot,
+    { workspaceName, scope, registry, agent, variableGroup, ci, stack },
+    logger.detail
+  );
+  (0, import_node_fs13.rmSync)((0, import_node_path20.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
+  (0, import_node_fs13.rmSync)((0, import_node_path20.join)(workspaceRoot, "package-lock.json"), { force: true });
+  logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
+  const installStatus = runShell(
+    "npm",
+    ["install", "--save-dev", "husky", "@commitlint/cli", "@commitlint/config-conventional"],
+    workspaceRoot
+  );
+  if (installStatus !== 0) {
+    throw new Error(`npm install of the toolchain failed with exit code ${installStatus}`);
   }
-  return changed;
+  runShell("npx", ["husky"], workspaceRoot);
+  logger.step("Formatting the workspace (eslint --fix, JavaScript Standard Style)");
+  runFormatter(workspaceRoot);
+  logger.success("Done. Next steps:");
+  logger.info(`  cd ${workspaceName}`);
+  logger.info("  mnci add react-app web        # or: react-lib, react-internal-lib, node-app,");
+  logger.info("                                 #     node-function-app, npm-lib, internal-lib,");
+  logger.info(
+    "                                 #     python-app, python-function-app, python-lib, python-internal-lib,"
+  );
+  logger.info(
+    "                                 #     go-app, go-function-app, go-lib, go-internal-lib,"
+  );
+  logger.info(
+    "                                 #     flutter-app, flutter-lib, flutter-internal-lib"
+  );
+  logger.info('  git add -A && git commit -m "feat: initial workspace"');
 }
-function reinstall(workspaceRoot, ecosystems) {
-  const commands = [
-    ["npm", "npm", ["install"]],
-    ["pip", "npm", ["run", "python:install"]],
-    ["pub", "flutter", ["pub", "get"]],
-    ["nuget", "npx", ["nx", "run-many", "-t", "restore"]],
-    ["go", "go", ["mod", "tidy"]]
-  ];
-  for (const [ecosystem, command, arguments_] of commands) {
-    if (!ecosystems.has(ecosystem)) {
-      continue;
-    }
-    if (ecosystem === "pip" && !hasPythonInstallScript(workspaceRoot)) {
-      logger.warn(
-        "This workspace has no 'python:install' script \u2014 run 'mnci upgrade' to add it, then reinstall by hand."
-      );
-      continue;
-    }
-    logger.step(`Reinstalling ${ecosystem} dependencies (${command} ${arguments_.join(" ")})`);
-    if (runShell(command, arguments_, workspaceRoot) !== 0) {
-      logger.warn(
-        `${command} ${arguments_.join(" ")} failed \u2014 the manifests were updated, so re-run it once the cause is fixed.`
+
+// src/workspace-creation/interactive-wizard.use-case.ts
+var import_node_path22 = require("path");
+var import_prompts4 = require("@inquirer/prompts");
+
+// src/workspace-upgrade/upgrade-workspace.use-case.ts
+var import_node_fs14 = require("fs");
+var import_node_path21 = require("path");
+function resolveRegistry2(options, persisted) {
+  if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
+    const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
+    const organization = options.organization ?? persistedAzure?.organization;
+    const project = options.project ?? persistedAzure?.project;
+    const artifactsFeed = options.artifactsFeed ?? persistedAzure?.artifactsFeed;
+    if (!organization || !project || !artifactsFeed) {
+      throw new Error(
+        "Azure Artifacts registry needs --organization, --project and --artifacts-feed (none found in nx.json's persisted config either)."
       );
     }
+    return { kind: "azure-artifacts", organization, project, artifactsFeed };
+  }
+  if (options.registry === "npm") {
+    return { kind: "npm" };
+  }
+  if (persisted) {
+    return persisted;
   }
+  throw new Error(
+    "No registry found in nx.json's persisted config. Pass --registry npm or --registry azure-artifacts (with --organization/--project/--artifacts-feed)."
+  );
 }
-function hasPythonInstallScript(workspaceRoot) {
+function resolveWorkspaceName(workspaceRoot, persisted) {
+  if (persisted.workspaceName) {
+    return persisted.workspaceName;
+  }
   try {
-    const manifest = readJson(
-      (0, import_node_path19.join)(workspaceRoot, "package.json")
+    const existing = (0, import_node_fs14.readdirSync)(workspaceRoot).find(
+      (file) => file.endsWith(".code-workspace") && file !== "undefined.code-workspace"
     );
-    return manifest.scripts?.["python:install"] !== void 0;
-  } catch {
-    return false;
-  }
-}
-function applyGoUpdates(workspaceRoot, entries) {
-  for (const entry of entries) {
-    logger.step(`go get ${entry.name}@${entry.latest}`);
-    if (runShell("go", ["get", `${entry.name}@${entry.latest}`], workspaceRoot) !== 0) {
-      logger.warn(`go get ${entry.name}@${entry.latest} failed \u2014 left at ${entry.current}.`);
+    if (existing) {
+      return existing.replace(/\.code-workspace$/, "");
     }
+  } catch {
   }
+  return (0, import_node_path21.basename)(workspaceRoot);
 }
-async function runUp(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path19.join)(workspaceRoot, "nx.json"))) {
-    throw new Error(`No nx.json found in ${workspaceRoot} \u2014 run 'mnci up' from the workspace root.`);
+function resolveOverlayOptions(workspaceRoot, options, persisted) {
+  const scope = options.scope ?? persisted.scope;
+  if (!scope) {
+    throw new Error("No npm scope found in nx.json's persisted config. Pass --scope explicitly.");
   }
-  const ecosystems = resolveEcosystems(options.ecosystem);
-  for (const ecosystem of ecosystems) {
-    if (!hasEcosystem(workspaceRoot, ecosystem)) {
-      logger.info(`\u2298 SKIPPED ${ecosystem} \u2014 no ${ecosystem} project in this workspace.`);
-    }
+  const registry = resolveRegistry2(options, persisted.registry);
+  const ci = options.ci ?? persisted.ci;
+  if (!ci) {
+    throw new Error(
+      "No CI provider found in nx.json's persisted config. Pass --ci azure|github|both explicitly."
+    );
   }
-  logger.step("Querying registries for the latest published versions");
-  const outdated = await collectOutdated(workspaceRoot, ecosystems);
-  if (outdated.length === 0) {
-    logger.success("Every dependency is on its latest published version.");
-    return;
+  const agent = options.agent ?? persisted.agent;
+  if (!agent) {
+    throw new Error(
+      "No CI build agent found in nx.json's persisted config. Pass --agent explicitly."
+    );
   }
-  const readOnly = options.check ?? !process.stdout.isTTY;
-  if (readOnly) {
-    reportOutdated(outdated);
-    logger.info("");
-    logger.info(`${outdated.length} package(s) have a newer release. Run 'mnci up' to update them.`);
-    return;
+  const variableGroup = options.variableGroup ?? persisted.variableGroup ?? "Build";
+  const testRunner = options.testRunner ?? persisted.stack?.testRunner;
+  if (!testRunner) {
+    throw new Error(
+      "No testRunner found in nx.json's persisted config. Pass --test-runner explicitly."
+    );
   }
-  const selected = options.yes ? [...outdated] : await promptForUpdates(outdated);
-  if (selected.length === 0) {
-    logger.info("Nothing selected; no manifest was changed.");
-    return;
+  return {
+    workspaceName: resolveWorkspaceName(workspaceRoot, persisted),
+    scope,
+    registry,
+    agent,
+    variableGroup,
+    ci,
+    stack: { testRunner }
+  };
+}
+function runUpgrade(workspaceRoot, options) {
+  if (!fileExists((0, import_node_path21.join)(workspaceRoot, "nx.json"))) {
+    throw new Error(
+      `No nx.json found in ${workspaceRoot} \u2014 this does not look like an Nx workspace. Run 'mnci upgrade' from the workspace root.`
+    );
   }
-  const goSelections = selected.filter((entry) => entry.ecosystem === "go");
-  const changed = selected.filter((entry) => entry.ecosystem !== "go").flatMap((entry) => applyUpdate(entry));
-  const changedManifests = new Set(changed);
-  for (const path of changedManifests) {
-    logger.detail(`updated ${path}`);
+  const persisted = readMnciConfig(workspaceRoot);
+  const resolved = resolveOverlayOptions(workspaceRoot, options, persisted);
+  logger.step("Re-applying the MoNecromanCI overlay");
+  applyOverlay(workspaceRoot, resolved, logger.detail);
+  const repaired = repairRollupSourceMaps(workspaceRoot);
+  if (repaired.length > 0) {
+    logger.step("Enabling source maps in rollup configs (breakpoints in .ts files)");
+    for (const path of repaired) {
+      logger.detail(`updated ${path}`);
+    }
   }
-  applyGoUpdates(workspaceRoot, goSelections);
-  if (options.install !== false) {
-    reinstall(workspaceRoot, new Set(selected.map((entry) => entry.ecosystem)));
+  const repairedManifests = repairPublishableManifests(workspaceRoot);
+  if (repairedManifests.length > 0) {
+    logger.step("Repointing `types` at the real declaration file");
+    for (const path of repairedManifests) {
+      logger.detail(`updated ${path}`);
+    }
   }
-  if (changed.length > 0) {
-    syncProjectReferences(workspaceRoot);
-    logger.step("Formatting the changed manifests (eslint --fix)");
-    runFormatter(workspaceRoot);
+  const upgradedDtsPlugins = upgradeDeclarationSpecifierPlugins(workspaceRoot);
+  if (upgradedDtsPlugins.length > 0) {
+    logger.step("Upgrading declaration specifiers to resolve under nodenext");
+    for (const path of upgradedDtsPlugins) {
+      logger.detail(`updated ${path}`);
+    }
   }
-  logger.success(
-    `Updated ${selected.length} package(s). Review the changes with \`git diff\` before committing.`
+  logger.step(
+    "Formatting the workspace (eslint --fix) \u2014 the slowest step, minutes on a large workspace"
   );
+  runFormatter(workspaceRoot);
+  logger.success("Done. Review the changes with `git diff` before committing.");
 }
 
-// src/util/versionChecker.ts
-var import_node_fs12 = require("fs");
-var import_node_path20 = require("path");
+// src/workspace-creation/interactive-wizard.use-case.ts
+async function runInteractive() {
+  const inWorkspace = fileExists((0, import_node_path22.join)(process.cwd(), "nx.json"));
+  const choiceNew = { name: "Create a new monorepo", value: "new" };
+  const choiceAdd = { name: "Add a project to this workspace", value: "add" };
+  const choiceUpgrade = {
+    name: "Upgrade this workspace (re-apply the latest overlay)",
+    value: "upgrade"
+  };
+  const action = await (0, import_prompts4.select)({
+    message: "What would you like to do?",
+    choices: inWorkspace ? [choiceAdd, choiceUpgrade, choiceNew] : [choiceNew, choiceAdd, choiceUpgrade]
+  });
+  if (action === "new") {
+    await runNew(void 0, {});
+  } else if (action === "upgrade") {
+    runUpgrade(process.cwd(), {});
+  } else {
+    await runAdd(void 0, void 0, {});
+  }
+}
+
+// src/cli-version/check-for-update.use-case.ts
+var import_node_fs15 = require("fs");
+var import_node_path23 = require("path");
 var import_cross_spawn2 = __toESM(require("cross-spawn"));
 var PACKAGE_NAME = "@mnci/cli";
 var REGISTRY_TIMEOUT_MS = 2e3;
@@ -4961,15 +4985,15 @@ function releaseTriple(version) {
 }
 function readCliVersion(packageDirectory) {
   try {
-    const manifestPath = (0, import_node_path20.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs12.readFileSync)(manifestPath, "utf8"));
+    const manifestPath = (0, import_node_path23.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs15.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 
-// src/cli.ts
+// src/main.ts
 function buildProgram(cliVersion) {
   const program = new import_commander.Command();
   program.name("mnci").description("MoNecromanCI \u2014 a thin CLI over official Nx plugins").version(cliVersion, "-v, --version", "display the version");