@mnci/cli 4.37.0 → 4.39.0

package/dist/cli.js

@@ -340,18 +340,81 @@ function runAudit(workspaceRoot, dependencies = {}) {
 }
 
 // src/ci-pipeline/native.use-case.ts
+var import_node_fs6 = require("fs");
+var import_node_path5 = require("path");
+
+// src/native-build-config/native-build.contract.ts
+var DEFAULT_NATIVE_RUNNERS = ["windows-latest", "macos-latest", "ubuntu-latest"];
+
+// src/native-build-config/read-native-build-config.use-case.ts
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+var PACKAGE_NAME = /^[a-z0-9][a-z0-9+.-]*$/;
+var RUNNER_NAME = /^[A-Z0-9][\w.-]*$/i;
+function readNativeBuildConfig(workspaceRoot) {
+  const settings = {
+    config: { linuxPackages: [], runners: [...DEFAULT_NATIVE_RUNNERS] },
+    problems: []
+  };
+  const raw = readNativeEntry(workspaceRoot);
+  if (raw === void 0) {
+    return settings;
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    settings.problems.push("mnci.native must be an object");
+    return settings;
+  }
+  const entry = raw;
+  const packages = validList(entry.linuxPackages, "mnci.native.linuxPackages", PACKAGE_NAME, settings.problems);
+  const runners = validList(entry.runners, "mnci.native.runners", RUNNER_NAME, settings.problems);
+  if (packages !== void 0) {
+    settings.config.linuxPackages = packages;
+  }
+  if (runners !== void 0 && runners.length > 0) {
+    settings.config.runners = runners;
+  }
+  return settings;
+}
+function readNativeEntry(workspaceRoot) {
+  const path = (0, import_node_path2.join)(workspaceRoot, "nx.json");
+  if (!(0, import_node_fs3.existsSync)(path)) {
+    return void 0;
+  }
+  try {
+    const nxJson = JSON.parse((0, import_node_fs3.readFileSync)(path, "utf8"));
+    return nxJson.mnci?.native;
+  } catch {
+    return void 0;
+  }
+}
+function validList(value, label, pattern, problems) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    problems.push(`${label} must be a list of strings`);
+    return void 0;
+  }
+  const valid = [];
+  for (const item of value) {
+    if (typeof item === "string" && pattern.test(item)) {
+      valid.push(item);
+    } else {
+      problems.push(`${label} has an invalid entry: ${JSON.stringify(item)}`);
+    }
+  }
+  return valid;
+}
+
+// src/workspace-overlay/overlay.use-case.ts
 var import_node_fs5 = require("fs");
 var import_node_path4 = require("path");
 
-// src/workspace-overlay/overlay.use-case.ts
+// src/file-system/file-system.client.ts
 var import_node_fs4 = require("fs");
 var import_node_path3 = require("path");
-
-// src/file-system/file-system.client.ts
-var import_node_fs3 = require("fs");
-var import_node_path2 = require("path");
 function readJson(path) {
-  return JSON.parse((0, import_node_fs3.readFileSync)(path, "utf8"));
+  return JSON.parse((0, import_node_fs4.readFileSync)(path, "utf8"));
 }
 function stripJsonComments(text) {
   let result = "";
@@ -408,7 +471,7 @@ function stripJsonComments(text) {
 }
 function readCodeWorkspace(path) {
   try {
-    const withoutComments = stripJsonComments((0, import_node_fs3.readFileSync)(path, "utf8"));
+    const withoutComments = stripJsonComments((0, import_node_fs4.readFileSync)(path, "utf8"));
     return JSON.parse(withoutComments.replaceAll(/,(\s*[}\]])/g, "$1"));
   } catch {
     return void 0;
@@ -419,14 +482,14 @@ function toJson(value) {
 `;
 }
 function writeFileEnsured(path, content) {
-  (0, import_node_fs3.mkdirSync)((0, import_node_path2.dirname)(path), { recursive: true });
-  (0, import_node_fs3.writeFileSync)(path, content);
+  (0, import_node_fs4.mkdirSync)((0, import_node_path3.dirname)(path), { recursive: true });
+  (0, import_node_fs4.writeFileSync)(path, content);
 }
 function markExecutable(path) {
-  (0, import_node_fs3.chmodSync)(path, 493);
+  (0, import_node_fs4.chmodSync)(path, 493);
 }
 function fileExists(path) {
-  return (0, import_node_fs3.existsSync)(path);
+  return (0, import_node_fs4.existsSync)(path);
 }
 
 // src/pipeline-customization/pipeline-markers.algorithm.ts
@@ -694,9 +757,9 @@ var VSCODE_EXTENSION_TAG = "type:vscode-extension";
 var GO_RELEASE_TAG = "release:go";
 var GO_CGO_TAG = "build:cgo";
 function hasNativeGoApp(workspaceRoot) {
-  return (0, import_node_fs4.globSync)("apps/*/project.json", { cwd: workspaceRoot }).some((projectJson) => {
+  return (0, import_node_fs5.globSync)("apps/*/project.json", { cwd: workspaceRoot }).some((projectJson) => {
     try {
-      const { tags } = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path3.join)(workspaceRoot, projectJson), "utf8"));
+      const { tags } = JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path4.join)(workspaceRoot, projectJson), "utf8"));
       return (tags ?? []).includes(GO_CGO_TAG);
     } catch {
       return false;
@@ -1044,15 +1107,15 @@ function isUnmodifiedMnciEslintConfig(content) {
   return code.length === 2 && code[0] === "import mnci from '@mnci/eslint-config'" && code[1] === "export default mnci({ workspaceRoot: import.meta.dirname })";
 }
 function writePipeline(path, onProgress, generated) {
-  const { text, notes } = mergePipeline((0, import_node_fs4.existsSync)(path) ? (0, import_node_fs4.readFileSync)(path, "utf8") : void 0, generated);
+  const { text, notes } = mergePipeline((0, import_node_fs5.existsSync)(path) ? (0, import_node_fs5.readFileSync)(path, "utf8") : void 0, generated);
   for (const note of notes) {
     onProgress(`  ${note}`);
   }
   writeFileEnsured(path, text);
 }
 function writeEslintEntryPoint(workspaceRoot, onProgress) {
-  const path = (0, import_node_path3.join)(workspaceRoot, ESLINT_USER_FILENAME);
-  if ((0, import_node_fs4.existsSync)(path) && !isUnmodifiedMnciEslintConfig((0, import_node_fs4.readFileSync)(path, "utf8"))) {
+  const path = (0, import_node_path4.join)(workspaceRoot, ESLINT_USER_FILENAME);
+  if ((0, import_node_fs5.existsSync)(path) && !isUnmodifiedMnciEslintConfig((0, import_node_fs5.readFileSync)(path, "utf8"))) {
     onProgress(`${ESLINT_USER_FILENAME} \u2014 kept as it is, it is yours`);
     return;
   }
@@ -1220,7 +1283,7 @@ function mnciConfig(options) {
   };
 }
 function readMnciConfig(workspaceRoot) {
-  const nxJson = readJson((0, import_node_path3.join)(workspaceRoot, "nx.json"));
+  const nxJson = readJson((0, import_node_path4.join)(workspaceRoot, "nx.json"));
   return nxJson.mnci ?? {};
 }
 function pythonPublishUrl(registry) {
@@ -1305,8 +1368,7 @@ 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)"`;
 var VERIFY_TARGETS = "lint,typecheck,test,build";
 var NATIVE_TARGETS = "lint,test,build-native,package-native";
-var NATIVE_LINUX_PREREQUISITES = "sudo apt-get update && sudo apt-get install -y gcc pkg-config";
-function githubNativeJob(npmAuthName, npmAuthValue) {
+function githubNativeJob(npmAuthName, npmAuthValue, runners) {
   return `
   # Apps that need a C toolchain (mnci add go-app --cgo) cannot be cross-compiled
   # from the job above, so each is linted, tested, built and packaged here, on a
@@ -1318,7 +1380,7 @@ function githubNativeJob(npmAuthName, npmAuthValue) {
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-latest, macos-latest, ubuntu-latest]
+        os: [${runners.join(", ")}]
     steps:
       - uses: actions/checkout@${ACTION_VERSIONS["actions/checkout"]}
         with:
@@ -1346,15 +1408,9 @@ function githubNativeJob(npmAuthName, npmAuthValue) {
       - run: npx mnci ci setup
         name: Set up the Go toolchain
 
-      # A C compiler and pkg-config, which is all mnci can know a cgo app needs.
-      # Add the -dev packages your app links to this line, for example
-      # libgtk-3-dev and libayatana-appindicator3-dev for a system-tray icon.
-      # macOS and Windows runners ship their toolchains.
-      - run: ${NATIVE_LINUX_PREREQUISITES}
-        name: Install native prerequisites (Linux)
-        if: \${{ runner.os == 'Linux' }}
-
-      # Lints, tests, builds and packages the native apps on this OS. On a push to
+      # Lints, tests, builds and packages the native apps on this OS. On a Linux leg it
+      # first installs a C compiler, pkg-config and the packages of mnci.native.linuxPackages
+      # in nx.json (for a tray icon: libgtk-3-dev, libayatana-appindicator3-dev). On a push to
       # main, a releasable native app (--cgo with --release) also gets this OS's zip
       # attached to the GitHub Release the ci job just created, stamped with the
       # tag's version.
@@ -1374,7 +1430,7 @@ function indentYaml(text, spaces) {
   const pad = " ".repeat(spaces);
   return text.split("\n").map((line) => line === "" ? line : pad + line).join("\n");
 }
-function withAzureNativeJob(document, nativeSteps) {
+function withAzureNativeJob(document, nativeSteps, runners) {
   const poolAt = document.indexOf("\npool:\n");
   const variablesAt = document.indexOf("\nvariables:\n");
   const stepsAt = document.indexOf("\nsteps:\n");
@@ -1385,7 +1441,7 @@ function withAzureNativeJob(document, nativeSteps) {
   const pool2 = document.slice(poolAt + "\npool:\n".length, variablesAt).replace(/\n+$/, "");
   const variables = document.slice(variablesAt + 1, stepsAt).replace(/\n+$/, "");
   const steps = document.slice(stepsAt + "\nsteps:\n".length).replace(/\n+$/, "");
-  const matrix = Object.entries({ windows: "windows-latest", macos: "macos-latest", linux: "ubuntu-latest" }).map(([leg, image]) => `        ${leg}:
+  const matrix = runners.map((image) => ({ leg: image.replaceAll(/\W/g, "_"), image })).map(({ leg, image }) => `        ${leg}:
           legName: ${leg}
           vmImage: ${image}`).join("\n");
   return `${head}${variables}
@@ -1424,7 +1480,7 @@ function npmAuthEnvVariable(registryKind, variableReference) {
 function poolBlock(agent) {
   return /^(?:ubuntu|windows|macos)-/i.test(agent) ? `  vmImage: ${agent}` : `  name: ${agent}`;
 }
-function azurePipelinesYaml(agent, variableGroup, pythonPublishUrl2, registryKind = "azure-artifacts", nugetFeedUrl2, npmAuth = "pat", nativeApps = false) {
+function azurePipelinesYaml(agent, variableGroup, pythonPublishUrl2, registryKind = "azure-artifacts", nugetFeedUrl2, npmAuth = "pat", nativeApps = false, nativeRunners = DEFAULT_NATIVE_RUNNERS) {
   const onMain = "and(succeeded(), in(variables['Build.Reason'], 'IndividualCI', 'BatchedCI'), eq(variables['Build.SourceBranchName'], 'main'))";
   const [npmAuthName, npmAuthValue] = npmAuthEnvVariable(registryKind, (name) => `$(${name})`);
   const buildIdentity = npmAuth === "build-identity" && registryKind === "azure-artifacts";
@@ -1686,14 +1742,9 @@ ${npmAuthenticateStep}  - script: npm ci
   - script: npx mnci ci setup
     displayName: Set up the Go toolchain
 
-  # A C compiler and pkg-config, which is all mnci can know a cgo app needs. Add the
-  # -dev packages your app links to this line, for example libgtk-3-dev and
-  # libayatana-appindicator3-dev for a system-tray icon. macOS and Windows agents
-  # ship their toolchains.
-  - script: ${NATIVE_LINUX_PREREQUISITES}
-    displayName: Install native prerequisites (Linux)
-    condition: eq(variables['Agent.OS'], 'Linux')
-
+  # On a Linux leg this first installs a C compiler, pkg-config and the packages of
+  # mnci.native.linuxPackages in nx.json (for a tray icon: libgtk-3-dev,
+  # libayatana-appindicator3-dev). macOS and Windows agents ship their toolchains.
   - script: npx mnci ci native
     displayName: Lint, test, build and package the native apps
 
@@ -1703,9 +1754,9 @@ ${npmAuthenticateStep}  - script: npm ci
       PathtoPublish: $(Build.SourcesDirectory)/dist/drop
       ArtifactName: native-$(legName)
 `;
-  return withAzureNativeJob(document, nativeSteps);
+  return withAzureNativeJob(document, nativeSteps, nativeRunners);
 }
-function githubActionsYaml(agent, pythonPublishUrl2, registryKind = "azure-artifacts", ci = "github", nugetFeedUrl2, nativeApps = false) {
+function githubActionsYaml(agent, pythonPublishUrl2, registryKind = "azure-artifacts", ci = "github", nugetFeedUrl2, nativeApps = false, nativeRunners = DEFAULT_NATIVE_RUNNERS) {
   const onMain = "github.event_name == 'push' && github.ref_name == 'main'";
   const [npmAuthName, npmAuthValue] = npmAuthEnvVariable(
     registryKind,
@@ -1891,7 +1942,7 @@ ${phaseStart("release", " ".repeat(6))}
 ${phaseEnd("release", " ".repeat(6))}
 
 ${slotMarkers("after-release", " ".repeat(6))}
-${nativeApps ? githubNativeJob(npmAuthName, npmAuthValue) : ""}`;
+${nativeApps ? githubNativeJob(npmAuthName, npmAuthValue, nativeRunners) : ""}`;
 }
 var PIP_PROJECT_GLOBS = ["apps", "python-packages", "libs"];
 var PUB_PROJECT_GLOBS = ["apps", "packages", "libs"];
@@ -1901,12 +1952,12 @@ var ECOSYSTEM_MANIFESTS = {
 };
 function hasEcosystemProject(workspaceRoot, roots, manifests) {
   return roots.some((root) => {
-    const base = (0, import_node_path3.join)(workspaceRoot, root);
-    if (!(0, import_node_fs4.existsSync)(base)) {
+    const base = (0, import_node_path4.join)(workspaceRoot, root);
+    if (!(0, import_node_fs5.existsSync)(base)) {
       return false;
     }
-    return (0, import_node_fs4.readdirSync)(base, { withFileTypes: true }).some(
-      (entry) => entry.isDirectory() && manifests.some((manifest) => (0, import_node_fs4.existsSync)((0, import_node_path3.join)(base, entry.name, manifest)))
+    return (0, import_node_fs5.readdirSync)(base, { withFileTypes: true }).some(
+      (entry) => entry.isDirectory() && manifests.some((manifest) => (0, import_node_fs5.existsSync)((0, import_node_path4.join)(base, entry.name, manifest)))
     );
   });
 }
@@ -1984,11 +2035,11 @@ var LOCAL_REGISTRY_SCAFFOLDING = {
   rootTarget: "local-registry"
 };
 function removeLocalRegistryScaffolding(workspaceRoot) {
-  (0, import_node_fs4.rmSync)((0, import_node_path3.join)(workspaceRoot, LOCAL_REGISTRY_SCAFFOLDING.directory), {
+  (0, import_node_fs5.rmSync)((0, import_node_path4.join)(workspaceRoot, LOCAL_REGISTRY_SCAFFOLDING.directory), {
     recursive: true,
     force: true
   });
-  const manifestPath = (0, import_node_path3.join)(workspaceRoot, "package.json");
+  const manifestPath = (0, import_node_path4.join)(workspaceRoot, "package.json");
   if (!fileExists(manifestPath)) return;
   const manifest = readJson(manifestPath);
   if (manifest.devDependencies?.[LOCAL_REGISTRY_SCAFFOLDING.devDependency] !== void 0) {
@@ -2004,23 +2055,23 @@ function removeLocalRegistryScaffolding(workspaceRoot) {
 }
 function removeNxScaffolding(workspaceRoot) {
   for (const entry of NX_SCAFFOLDING_TO_REMOVE) {
-    (0, import_node_fs4.rmSync)((0, import_node_path3.join)(workspaceRoot, entry), { recursive: true, force: true });
+    (0, import_node_fs5.rmSync)((0, import_node_path4.join)(workspaceRoot, entry), { recursive: true, force: true });
   }
   removeNxAuthoredAgentFiles(workspaceRoot);
   removeProjectEslintConfigs(workspaceRoot);
 }
 function removeNxAuthoredAgentFiles(workspaceRoot) {
-  (0, import_node_fs4.rmSync)((0, import_node_path3.join)(workspaceRoot, NX_CLAUDE_SETTINGS), { force: true });
-  const claudeDirectory = (0, import_node_path3.join)(workspaceRoot, (0, import_node_path3.dirname)(NX_CLAUDE_SETTINGS));
-  if ((0, import_node_fs4.existsSync)(claudeDirectory) && (0, import_node_fs4.readdirSync)(claudeDirectory).length === 0) {
-    (0, import_node_fs4.rmSync)(claudeDirectory, { recursive: true, force: true });
+  (0, import_node_fs5.rmSync)((0, import_node_path4.join)(workspaceRoot, NX_CLAUDE_SETTINGS), { force: true });
+  const claudeDirectory = (0, import_node_path4.join)(workspaceRoot, (0, import_node_path4.dirname)(NX_CLAUDE_SETTINGS));
+  if ((0, import_node_fs5.existsSync)(claudeDirectory) && (0, import_node_fs5.readdirSync)(claudeDirectory).length === 0) {
+    (0, import_node_fs5.rmSync)(claudeDirectory, { recursive: true, force: true });
   }
   for (const name of NX_AUTHORED_AGENT_FILES) {
-    const path = (0, import_node_path3.join)(workspaceRoot, name);
-    if (!(0, import_node_fs4.existsSync)(path)) continue;
-    const kept = withoutNxAgentRules((0, import_node_fs4.readFileSync)(path, "utf8"));
+    const path = (0, import_node_path4.join)(workspaceRoot, name);
+    if (!(0, import_node_fs5.existsSync)(path)) continue;
+    const kept = withoutNxAgentRules((0, import_node_fs5.readFileSync)(path, "utf8"));
     if (kept === void 0) continue;
-    if (kept.trim() === "") (0, import_node_fs4.rmSync)(path, { force: true });
+    if (kept.trim() === "") (0, import_node_fs5.rmSync)(path, { force: true });
     else writeFileEnsured(path, kept);
   }
 }
@@ -2035,14 +2086,14 @@ function withoutNxAgentRules(content) {
   return `${content.slice(0, start)}${rest}`.replace(/^[\r\n]+/, "");
 }
 function removeIfPresent(path) {
-  (0, import_node_fs4.rmSync)(path, { recursive: true, force: true });
+  (0, import_node_fs5.rmSync)(path, { recursive: true, force: true });
 }
 function ensureEslintCacheIgnored(workspaceRoot) {
-  const gitignorePath = (0, import_node_path3.join)(workspaceRoot, ".gitignore");
+  const gitignorePath = (0, import_node_path4.join)(workspaceRoot, ".gitignore");
   if (!fileExists(gitignorePath)) {
     return;
   }
-  const current = (0, import_node_fs4.readFileSync)(gitignorePath, "utf8");
+  const current = (0, import_node_fs5.readFileSync)(gitignorePath, "utf8");
   if (current.split("\n").some((line) => line.trim() === ".eslintcache")) {
     return;
   }
@@ -2057,18 +2108,18 @@ function ensureEslintCacheIgnored(workspaceRoot) {
 }
 var PYTHON_ARTEFACT_IGNORES = ["__pycache__/", "*.py[cod]"];
 function ensurePythonArtefactsIgnored(workspaceRoot) {
-  const gitignorePath = (0, import_node_path3.join)(workspaceRoot, ".gitignore");
+  const gitignorePath = (0, import_node_path4.join)(workspaceRoot, ".gitignore");
   if (!fileExists(gitignorePath)) {
     return;
   }
-  const hasPython = (0, import_node_fs4.globSync)(
+  const hasPython = (0, import_node_fs5.globSync)(
     ["python-packages/*/pyproject.toml", "apps/*/pyproject.toml", "libs/*/pyproject.toml"],
     { cwd: workspaceRoot }
   ).length > 0;
   if (!hasPython) {
     return;
   }
-  const current = (0, import_node_fs4.readFileSync)(gitignorePath, "utf8");
+  const current = (0, import_node_fs5.readFileSync)(gitignorePath, "utf8");
   const present = new Set(current.split("\n").map((line) => line.trim()));
   const missing = PYTHON_ARTEFACT_IGNORES.filter((line) => !present.has(line));
   if (missing.length === 0) {
@@ -2088,16 +2139,16 @@ ${missing.join("\n")}
   );
 }
 function removeProjectEslintConfigs(workspaceRoot) {
-  const matches = (0, import_node_fs4.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
+  const matches = (0, import_node_fs5.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
     cwd: workspaceRoot
   });
   for (const match of matches) {
-    (0, import_node_fs4.rmSync)((0, import_node_path3.join)(workspaceRoot, match), { force: true });
+    (0, import_node_fs5.rmSync)((0, import_node_path4.join)(workspaceRoot, match), { force: true });
   }
 }
 function applyOverlay(workspaceRoot, options, onProgress = () => {
 }) {
-  const nxJsonPath = (0, import_node_path3.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path4.join)(workspaceRoot, "nx.json");
   const nxJson = readJson(nxJsonPath);
   const generators = {
     ...nxJson.generators,
@@ -2105,7 +2156,7 @@ function applyOverlay(workspaceRoot, options, onProgress = () => {
   };
   const sync = { ...nxJson.sync, ...SYNC_CONFIG };
   const mnci = { ...nxJson.mnci, ...mnciConfig(options) };
-  const rootManifest = readJson((0, import_node_path3.join)(workspaceRoot, "package.json"));
+  const rootManifest = readJson((0, import_node_path4.join)(workspaceRoot, "package.json"));
   const hasPythonPlugin = (rootManifest.devDependencies ?? {})["@mnci/nx-python-pip"] !== void 0 || (rootManifest.dependencies ?? {})["@mnci/nx-python-pip"] !== void 0;
   const withRelease = withReleaseConfig(nxJson, options.ci);
   const patched = withPythonGraphPlugin(
@@ -2115,7 +2166,7 @@ function applyOverlay(workspaceRoot, options, onProgress = () => {
   onProgress("nx.json \u2014 release, sync, generators, shared inputs, mnci block");
   writeFileEnsured(nxJsonPath, toJson({ ...patched, generators, sync, mnci }));
   onProgress("package.json \u2014 root scripts, TS compilers, ESLint toolchain, overrides");
-  const manifestPath = (0, import_node_path3.join)(workspaceRoot, "package.json");
+  const manifestPath = (0, import_node_path4.join)(workspaceRoot, "package.json");
   const manifest = readJson(manifestPath);
   const scripts = {
     ...manifest.scripts,
@@ -2167,32 +2218,32 @@ function applyOverlay(workspaceRoot, options, onProgress = () => {
     `.npmrc \u2014 ${options.registry.kind === "azure-artifacts" ? "Azure Artifacts feed routing and credentials" : "public npm registry auth"}`
   );
   writeFileEnsured(
-    (0, import_node_path3.join)(workspaceRoot, ".npmrc"),
+    (0, import_node_path4.join)(workspaceRoot, ".npmrc"),
     npmrcContent(options.registry, options.scope, options.npmAuth)
   );
   onProgress("commitlint.config.mjs and .husky/commit-msg \u2014 conventional commit enforcement");
-  writeFileEnsured((0, import_node_path3.join)(workspaceRoot, "commitlint.config.mjs"), COMMITLINT_CONFIG);
-  const hookPath = (0, import_node_path3.join)(workspaceRoot, ".husky/commit-msg");
+  writeFileEnsured((0, import_node_path4.join)(workspaceRoot, "commitlint.config.mjs"), COMMITLINT_CONFIG);
+  const hookPath = (0, import_node_path4.join)(workspaceRoot, ".husky/commit-msg");
   writeFileEnsured(hookPath, COMMIT_MSG_HOOK);
   markExecutable(hookPath);
   onProgress(`${ESLINT_MNCI_FILENAME} \u2014 the shared lint AND formatting opinion`);
-  writeFileEnsured((0, import_node_path3.join)(workspaceRoot, ESLINT_MNCI_FILENAME), ESLINT_MNCI_CONFIG);
+  writeFileEnsured((0, import_node_path4.join)(workspaceRoot, ESLINT_MNCI_FILENAME), ESLINT_MNCI_CONFIG);
   writeEslintEntryPoint(workspaceRoot, onProgress);
   ensureEslintCacheIgnored(workspaceRoot);
   ensurePythonArtefactsIgnored(workspaceRoot);
   for (const retired of RETIRED_FORMATTER_FILES) {
-    removeIfPresent((0, import_node_path3.join)(workspaceRoot, retired));
+    removeIfPresent((0, import_node_path4.join)(workspaceRoot, retired));
   }
   onProgress(".devcontainer/devcontainer.json \u2014 a local toolchain matching CI");
   writeFileEnsured(
-    (0, import_node_path3.join)(workspaceRoot, ".devcontainer/devcontainer.json"),
+    (0, import_node_path4.join)(workspaceRoot, ".devcontainer/devcontainer.json"),
     devcontainerJson(options.workspaceName)
   );
   removeNxScaffolding(workspaceRoot);
   onProgress(
     `${options.workspaceName}.code-workspace \u2014 settings, extensions, launch configs`
   );
-  const codeWorkspacePath = (0, import_node_path3.join)(workspaceRoot, `${options.workspaceName}.code-workspace`);
+  const codeWorkspacePath = (0, import_node_path4.join)(workspaceRoot, `${options.workspaceName}.code-workspace`);
   const existing = readCodeWorkspace(codeWorkspacePath);
   writeFileEnsured(
     codeWorkspacePath,
@@ -2204,15 +2255,16 @@ function applyOverlay(workspaceRoot, options, onProgress = () => {
     )
   );
   if (options.workspaceName !== "undefined") {
-    (0, import_node_fs4.rmSync)((0, import_node_path3.join)(workspaceRoot, "undefined.code-workspace"), { force: true });
+    (0, import_node_fs5.rmSync)((0, import_node_path4.join)(workspaceRoot, "undefined.code-workspace"), { force: true });
   }
   const publishUrl = pythonPublishUrl(options.registry);
   const nugetUrl = nugetFeedUrl(options.registry);
   const nativeApps = hasNativeGoApp(workspaceRoot);
+  const nativeRunners = readNativeBuildConfig(workspaceRoot).config.runners;
   if (options.ci === "azure" || options.ci === "both") {
     onProgress("azure-pipelines.yml \u2014 build, verify, pack and release");
     writePipeline(
-      (0, import_node_path3.join)(workspaceRoot, "azure-pipelines.yml"),
+      (0, import_node_path4.join)(workspaceRoot, "azure-pipelines.yml"),
       onProgress,
       azurePipelinesYaml(
         options.agent,
@@ -2221,18 +2273,19 @@ function applyOverlay(workspaceRoot, options, onProgress = () => {
         options.registry.kind,
         nugetUrl,
         options.npmAuth,
-        nativeApps
+        nativeApps,
+        nativeRunners
       )
     );
   }
   if (options.ci === "github" || options.ci === "both") {
     onProgress(".github/workflows/ci.yml and dependabot.yml");
     writePipeline(
-      (0, import_node_path3.join)(workspaceRoot, ".github/workflows/ci.yml"),
+      (0, import_node_path4.join)(workspaceRoot, ".github/workflows/ci.yml"),
       onProgress,
-      githubActionsYaml(options.agent, publishUrl, options.registry.kind, options.ci, nugetUrl, nativeApps)
+      githubActionsYaml(options.agent, publishUrl, options.registry.kind, options.ci, nugetUrl, nativeApps, nativeRunners)
     );
-    writeFileEnsured((0, import_node_path3.join)(workspaceRoot, ".github/dependabot.yml"), dependabotConfig(workspaceRoot));
+    writeFileEnsured((0, import_node_path4.join)(workspaceRoot, ".github/dependabot.yml"), dependabotConfig(workspaceRoot));
   }
 }
 
@@ -2256,30 +2309,47 @@ function runNative(workspaceRoot, dependencies = {}) {
     }
     return status;
   };
+  if (isLinuxAgent(environment)) {
+    const prerequisites = installLinuxPrerequisites(workspaceRoot, inGroup);
+    if (prerequisites !== 0) {
+      return prerequisites;
+    }
+  }
   const built = inGroup("Lint, test, build and package the native apps", "npx", ["nx", "run-many", "-t", NATIVE_TARGETS, `--projects=tag:${GO_CGO_TAG}`]);
   if (built !== 0) {
     return built;
   }
-  if (host !== "github" || !isMainPush(environment) || !(0, import_node_fs5.existsSync)((0, import_node_path4.join)(workspaceRoot, "tools", "go-app-release.cjs"))) {
+  if (host !== "github" || !isMainPush(environment) || !(0, import_node_fs6.existsSync)((0, import_node_path5.join)(workspaceRoot, "tools", "go-app-release.cjs"))) {
     return 0;
   }
   return inGroup("Attach this OS's zip to the GitHub Release", "node", ["tools/go-app-release.cjs", "assets", "--native"]);
 }
+function isLinuxAgent(environment) {
+  return environment.RUNNER_OS === "Linux" || environment.AGENT_OS === "Linux";
+}
+function installLinuxPrerequisites(workspaceRoot, inGroup) {
+  const { linuxPackages } = readNativeBuildConfig(workspaceRoot).config;
+  const updated = inGroup("Update the package index", "sudo", ["apt-get", "update"]);
+  if (updated !== 0) {
+    return updated;
+  }
+  return inGroup("Install the native prerequisites (Linux)", "sudo", ["apt-get", "install", "-y", "gcc", "pkg-config", ...linuxPackages]);
+}
 
 // src/ci-pipeline/pack.use-case.ts
-var import_node_fs6 = require("fs");
-var import_node_path5 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path6 = require("path");
 function hasAppToPack(workspaceRoot) {
-  const hasProjectJson = (0, import_node_fs6.globSync)("apps/*/project.json", { cwd: workspaceRoot }).length > 0;
-  const hasInlineNx = (0, import_node_fs6.globSync)("apps/*/package.json", { cwd: workspaceRoot }).some((manifest) => {
+  const hasProjectJson = (0, import_node_fs7.globSync)("apps/*/project.json", { cwd: workspaceRoot }).length > 0;
+  const hasInlineNx = (0, import_node_fs7.globSync)("apps/*/package.json", { cwd: workspaceRoot }).some((manifest) => {
     try {
-      const parsed = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path5.join)(workspaceRoot, manifest), "utf8"));
+      const parsed = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path6.join)(workspaceRoot, manifest), "utf8"));
       return Boolean(parsed.nx);
     } catch {
       return false;
     }
   });
-  const hasCsproj = (0, import_node_fs6.globSync)("apps/*/*.csproj", { cwd: workspaceRoot }).length > 0;
+  const hasCsproj = (0, import_node_fs7.globSync)("apps/*/*.csproj", { cwd: workspaceRoot }).length > 0;
   return hasProjectJson || hasInlineNx || hasCsproj;
 }
 function runPack(workspaceRoot, dependencies = {}) {
@@ -2292,7 +2362,7 @@ function runPack(workspaceRoot, dependencies = {}) {
     console.log(message);
   });
   const host = detectCiHost(environment);
-  (0, import_node_fs6.mkdirSync)((0, import_node_path5.join)(workspaceRoot, "dist", "drop"), { recursive: true });
+  (0, import_node_fs7.mkdirSync)((0, import_node_path6.join)(workspaceRoot, "dist", "drop"), { recursive: true });
   if (!hasAppToPack(workspaceRoot)) {
     log("No apps to pack - skipping.");
     return 0;
@@ -2306,13 +2376,80 @@ function runPack(workspaceRoot, dependencies = {}) {
   return status;
 }
 
+// src/ci-pipeline/report-phase.use-case.ts
+var import_node_fs8 = require("fs");
+
+// src/ci-pipeline/phase-timing.algorithm.ts
+function formatDuration(milliseconds) {
+  const seconds = Math.max(0, milliseconds) / 1e3;
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const whole = Math.round(seconds);
+  return `${Math.floor(whole / 60)}m ${String(whole % 60).padStart(2, "0")}s`;
+}
+function escapeCommandData(text) {
+  return text.replaceAll("%", "%25").replaceAll("\r", "%0D").replaceAll("\n", "%0A");
+}
+function describePhaseOutcome(host, phase, status, milliseconds) {
+  const took = formatDuration(milliseconds);
+  if (status === 0) {
+    return {
+      log: `mnci ci ${phase}: passed in ${took}`,
+      summary: `- \u2705 **${phase}** passed in ${took}`
+    };
+  }
+  const message = `The ${phase} phase failed with exit status ${status} after ${took}`;
+  let annotation;
+  if (host === "github") {
+    annotation = `::error title=mnci ci ${phase}::${escapeCommandData(message)}`;
+  } else if (host === "azure") {
+    annotation = `##vso[task.logissue type=error;]${message}`;
+  }
+  return {
+    log: `mnci ci ${phase}: failed (exit ${status}) in ${took}`,
+    annotation,
+    summary: `- \u274C **${phase}** failed (exit ${status}) after ${took}`
+  };
+}
+
+// src/ci-pipeline/report-phase.use-case.ts
+async function reportPhase(phase, run, dependencies = {}) {
+  const environment = dependencies.environment ?? process.env;
+  const log = dependencies.log ?? ((message) => {
+    console.log(message);
+  });
+  const clock = dependencies.clock ?? (() => Date.now());
+  const host = detectCiHost(environment);
+  const started = clock();
+  const finish = (status) => {
+    const outcome = describePhaseOutcome(host, phase, status, clock() - started);
+    log(outcome.log);
+    if (outcome.annotation !== void 0) {
+      log(outcome.annotation);
+    }
+    if (host === "github" && environment.GITHUB_STEP_SUMMARY) {
+      (0, import_node_fs8.appendFileSync)(environment.GITHUB_STEP_SUMMARY, `${outcome.summary}
+`);
+    }
+  };
+  try {
+    const status = await run();
+    finish(status);
+    return status;
+  } catch (error) {
+    finish(1);
+    throw error;
+  }
+}
+
 // src/ci-pipeline/release.use-case.ts
-var import_node_fs7 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path7 = require("path");
 var SPECIFIER = /^(?:major|minor|patch|\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/;
 function hasTag(workspaceRoot, relativePath, tag) {
   try {
-    const parsed = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path6.join)(workspaceRoot, relativePath), "utf8"));
+    const parsed = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path7.join)(workspaceRoot, relativePath), "utf8"));
     const tags = relativePath.endsWith("project.json") ? parsed.tags : parsed.nx?.tags;
     return Array.isArray(tags) && tags.includes(tag);
   } catch {
@@ -2321,12 +2458,12 @@ function hasTag(workspaceRoot, relativePath, tag) {
 }
 function releasableCounts(workspaceRoot) {
   return {
-    npm: (0, import_node_fs7.globSync)("packages/*/package.json", { cwd: workspaceRoot }).length,
-    csharp: (0, import_node_fs7.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }).length,
-    python: (0, import_node_fs7.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot }).length,
-    dart: (0, import_node_fs7.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }).length,
-    vscode: (0, import_node_fs7.globSync)("apps/*/package.json", { cwd: workspaceRoot }).filter((path) => hasTag(workspaceRoot, path, VSCODE_EXTENSION_TAG)).length,
-    go: (0, import_node_fs7.globSync)("apps/*/project.json", { cwd: workspaceRoot }).filter((path) => hasTag(workspaceRoot, path, GO_RELEASE_TAG)).length
+    npm: (0, import_node_fs9.globSync)("packages/*/package.json", { cwd: workspaceRoot }).length,
+    csharp: (0, import_node_fs9.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }).length,
+    python: (0, import_node_fs9.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot }).length,
+    dart: (0, import_node_fs9.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }).length,
+    vscode: (0, import_node_fs9.globSync)("apps/*/package.json", { cwd: workspaceRoot }).filter((path) => hasTag(workspaceRoot, path, VSCODE_EXTENSION_TAG)).length,
+    go: (0, import_node_fs9.globSync)("apps/*/project.json", { cwd: workspaceRoot }).filter((path) => hasTag(workspaceRoot, path, GO_RELEASE_TAG)).length
   };
 }
 function shallowCloneGuard(processes, log) {
@@ -2342,7 +2479,7 @@ function shallowCloneGuard(processes, log) {
   return 0;
 }
 function npmPreflight(workspaceRoot, registryKind, environment, processes, log) {
-  if (registryKind !== "npm" || (0, import_node_fs7.globSync)("packages/*/package.json", { cwd: workspaceRoot }).length === 0) {
+  if (registryKind !== "npm" || (0, import_node_fs9.globSync)("packages/*/package.json", { cwd: workspaceRoot }).length === 0) {
     return 0;
   }
   if (!environment.NODE_AUTH_TOKEN) {
@@ -2358,7 +2495,7 @@ function npmPreflight(workspaceRoot, registryKind, environment, processes, log)
   return 0;
 }
 async function pypiPreflight(workspaceRoot, registryKind, environment, log, fetchStatus) {
-  const files = (0, import_node_fs7.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot });
+  const files = (0, import_node_fs9.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot });
   if (registryKind !== "npm" || files.length === 0) {
     return 0;
   }
@@ -2371,7 +2508,7 @@ async function pypiPreflight(workspaceRoot, registryKind, environment, log, fetc
     return 1;
   }
   const names = files.map((file) => {
-    const text = (0, import_node_fs7.readFileSync)((0, import_node_path6.join)(workspaceRoot, file), "utf8");
+    const text = (0, import_node_fs9.readFileSync)((0, import_node_path7.join)(workspaceRoot, file), "utf8");
     const block = text.slice(text.indexOf("[project]"));
     const line = block.split("\n").find((entry) => entry.trimStart().startsWith("name"));
     return line ? line.split("=", 2)[1].replaceAll(/[^\w.-]/gi, "") : "";
@@ -2446,14 +2583,14 @@ function runReleaseCommand(workspaceRoot, registry, counts, environment, process
 }
 function nxPushesTags(workspaceRoot) {
   try {
-    const nx = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path6.join)(workspaceRoot, "nx.json"), "utf8"));
+    const nx = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path7.join)(workspaceRoot, "nx.json"), "utf8"));
     return nx.release?.git?.push === true;
   } catch {
     return false;
   }
 }
 function afterRelease(workspaceRoot, processes, githubReleases) {
-  if (githubReleases && (0, import_node_fs7.existsSync)((0, import_node_path6.join)(workspaceRoot, "tools", "go-app-release.cjs"))) {
+  if (githubReleases && (0, import_node_fs9.existsSync)((0, import_node_path7.join)(workspaceRoot, "tools", "go-app-release.cjs"))) {
     const assets = processes.run("node", ["tools/go-app-release.cjs", "assets"]);
     if (assets !== 0) {
       return assets;
@@ -2504,17 +2641,17 @@ async function runRelease(workspaceRoot, dependencies = {}) {
 }
 
 // src/ci-pipeline/setup.use-case.ts
-var import_node_fs10 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path10 = require("path");
 
 // src/ci-pipeline/flutter-sdk.use-case.ts
-var import_node_fs8 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path8 = require("path");
 function flutterSdkDirectory(machine) {
-  return (0, import_node_path7.join)(machine.home, `.mnci-flutter-${FLUTTER_SDK_VERSION}`);
+  return (0, import_node_path8.join)(machine.home, `.mnci-flutter-${FLUTTER_SDK_VERSION}`);
 }
 function installFlutterSdk(workspaceRoot, processes, log, machine) {
-  if (!(0, import_node_fs8.existsSync)((0, import_node_path7.join)(workspaceRoot, "pubspec.yaml"))) {
+  if (!(0, import_node_fs10.existsSync)((0, import_node_path8.join)(workspaceRoot, "pubspec.yaml"))) {
     log("No Flutter projects - skipping.");
     return 0;
   }
@@ -2523,26 +2660,26 @@ function installFlutterSdk(workspaceRoot, processes, log, machine) {
     return 0;
   }
   const sdk = flutterSdkDirectory(machine);
-  if ((0, import_node_fs8.existsSync)(sdk)) {
+  if ((0, import_node_fs10.existsSync)(sdk)) {
     log(`Flutter SDK already installed at ${sdk} - skipping.`);
     return 0;
   }
   return processes.run("git", ["clone", "--depth", "1", "--branch", FLUTTER_SDK_VERSION, "https://github.com/flutter/flutter.git", sdk]);
 }
 function publishFlutterSdk(workspaceRoot, host, environment, log, machine) {
-  if (!(0, import_node_fs8.existsSync)((0, import_node_path7.join)(workspaceRoot, "pubspec.yaml"))) {
+  if (!(0, import_node_fs10.existsSync)((0, import_node_path8.join)(workspaceRoot, "pubspec.yaml"))) {
     log("No Flutter projects - skipping.");
     return;
   }
   const sdk = flutterSdkDirectory(machine);
-  if (!(0, import_node_fs8.existsSync)(sdk)) {
+  if (!(0, import_node_fs10.existsSync)(sdk)) {
     log("Flutter SDK was not installed by mnci (already on PATH) - skipping.");
     return;
   }
-  addToPath(host, environment, (0, import_node_path7.join)(sdk, "bin"), log);
+  addToPath(host, environment, (0, import_node_path8.join)(sdk, "bin"), log);
 }
 function resolveDartDependencies(workspaceRoot, processes, log) {
-  if (!(0, import_node_fs8.existsSync)((0, import_node_path7.join)(workspaceRoot, "pubspec.yaml"))) {
+  if (!(0, import_node_fs10.existsSync)((0, import_node_path8.join)(workspaceRoot, "pubspec.yaml"))) {
     log("No Flutter projects - skipping.");
     return 0;
   }
@@ -2551,15 +2688,15 @@ function resolveDartDependencies(workspaceRoot, processes, log) {
 
 // src/ci-pipeline/go-tools.use-case.ts
 var import_node_crypto = require("crypto");
-var import_node_fs9 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_os = require("os");
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 function currentMachine() {
   return { platform: process.platform, architecture: process.arch, home: (0, import_node_os.homedir)() };
 }
 var GOLANGCI_LINT_MODULE = "github.com/golangci/golangci-lint/v2/cmd/golangci-lint";
 function downloadGoModules(workspaceRoot, processes, log) {
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path8.join)(workspaceRoot, "go.mod"))) {
+  if (!(0, import_node_fs11.existsSync)((0, import_node_path9.join)(workspaceRoot, "go.mod"))) {
     log("No Go projects - skipping.");
     return 0;
   }
@@ -2567,7 +2704,7 @@ function downloadGoModules(workspaceRoot, processes, log) {
 }
 async function installGolangciLint(workspaceRoot, dependencies, machine) {
   const { processes, log, fetchBytes } = dependencies;
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path8.join)(workspaceRoot, "go.mod"))) {
+  if (!(0, import_node_fs11.existsSync)((0, import_node_path9.join)(workspaceRoot, "go.mod"))) {
     log("No Go projects - skipping.");
     return 0;
   }
@@ -2604,30 +2741,30 @@ async function installGolangciLint(workspaceRoot, dependencies, machine) {
     if ((0, import_node_crypto.createHash)("sha256").update(archive).digest("hex") !== entry[0]) {
       throw new Error(`checksum mismatch for ${file}`);
     }
-    temporary = (0, import_node_fs9.mkdtempSync)((0, import_node_path8.join)((0, import_node_os.tmpdir)(), "golangci-lint-"));
-    const archivePath = (0, import_node_path8.join)(temporary, file);
-    (0, import_node_fs9.writeFileSync)(archivePath, archive);
-    const tar = platform === "windows" ? (0, import_node_path8.join)(process.env.SystemRoot ?? "", "System32", "tar.exe") : "tar";
+    temporary = (0, import_node_fs11.mkdtempSync)((0, import_node_path9.join)((0, import_node_os.tmpdir)(), "golangci-lint-"));
+    const archivePath = (0, import_node_path9.join)(temporary, file);
+    (0, import_node_fs11.writeFileSync)(archivePath, archive);
+    const tar = platform === "windows" ? (0, import_node_path9.join)(process.env.SystemRoot ?? "", "System32", "tar.exe") : "tar";
     if (processes.run(tar, ["-xf", archivePath, "-C", temporary]) !== 0) {
       throw new Error(`could not extract ${file}`);
     }
     const executable = `golangci-lint${platform === "windows" ? ".exe" : ""}`;
-    const bin = (0, import_node_path8.join)(gopath.stdout.trim(), "bin");
-    (0, import_node_fs9.mkdirSync)(bin, { recursive: true });
-    (0, import_node_fs9.copyFileSync)((0, import_node_path8.join)(temporary, name, executable), (0, import_node_path8.join)(bin, executable));
-    (0, import_node_fs9.chmodSync)((0, import_node_path8.join)(bin, executable), 493);
+    const bin = (0, import_node_path9.join)(gopath.stdout.trim(), "bin");
+    (0, import_node_fs11.mkdirSync)(bin, { recursive: true });
+    (0, import_node_fs11.copyFileSync)((0, import_node_path9.join)(temporary, name, executable), (0, import_node_path9.join)(bin, executable));
+    (0, import_node_fs11.chmodSync)((0, import_node_path9.join)(bin, executable), 493);
     log(`golangci-lint ${version} installed from its checksum-verified prebuilt release into ${bin}`);
     return 0;
   } catch (error) {
     return fallback(error instanceof Error ? error.message : String(error));
   } finally {
     if (temporary !== void 0) {
-      (0, import_node_fs9.rmSync)(temporary, { recursive: true, force: true });
+      (0, import_node_fs11.rmSync)(temporary, { recursive: true, force: true });
     }
   }
 }
 function publishGoTools(workspaceRoot, host, environment, processes, log) {
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path8.join)(workspaceRoot, "go.mod"))) {
+  if (!(0, import_node_fs11.existsSync)((0, import_node_path9.join)(workspaceRoot, "go.mod"))) {
     log("No Go projects - skipping.");
     return;
   }
@@ -2636,7 +2773,7 @@ function publishGoTools(workspaceRoot, host, environment, processes, log) {
     log("Could not resolve GOPATH - skipping.");
     return;
   }
-  addToPath(host, environment, (0, import_node_path8.join)(gopath.stdout.trim(), "bin"), log);
+  addToPath(host, environment, (0, import_node_path9.join)(gopath.stdout.trim(), "bin"), log);
 }
 
 // src/ci-pipeline/setup.use-case.ts
@@ -2644,15 +2781,15 @@ function pythonCommand(machine) {
   return machine.platform === "win32" ? "python" : "python3";
 }
 function installPythonToolchain(workspaceRoot, processes, log, machine) {
-  if (!(0, import_node_fs10.existsSync)((0, import_node_path9.join)(workspaceRoot, "requirements-dev.txt"))) {
+  if (!(0, import_node_fs12.existsSync)((0, import_node_path10.join)(workspaceRoot, "requirements-dev.txt"))) {
     log("No Python projects - skipping.");
     return 0;
   }
   return processes.run(pythonCommand(machine), ["-m", "pip", "install", "-r", "requirements-dev.txt"]);
 }
 function installPythonProjects(workspaceRoot, processes, log, machine) {
-  const editable = ["apps/*/pyproject.toml", "python-packages/*/pyproject.toml", "libs/*/pyproject.toml"].flatMap((pattern) => (0, import_node_fs10.globSync)(pattern, { cwd: workspaceRoot })).map((path) => (0, import_node_path9.dirname)(path));
-  const requirements = (0, import_node_fs10.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot });
+  const editable = ["apps/*/pyproject.toml", "python-packages/*/pyproject.toml", "libs/*/pyproject.toml"].flatMap((pattern) => (0, import_node_fs12.globSync)(pattern, { cwd: workspaceRoot })).map((path) => (0, import_node_path10.dirname)(path));
+  const requirements = (0, import_node_fs12.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot });
   if (editable.length === 0 && requirements.length === 0) {
     log("No Python projects - skipping.");
     return 0;
@@ -2771,6 +2908,9 @@ function runVerify(workspaceRoot, dependencies = {}) {
 // src/ci-pipeline/index.ts
 var CI_PHASES = ["setup", "audit", "verify", "pack", "release", "native"];
 function runCiPhase(phase, workspaceRoot, dependencies = {}) {
+  return reportPhase(phase, () => runPhase(phase, workspaceRoot, dependencies), dependencies);
+}
+function runPhase(phase, workspaceRoot, dependencies) {
   switch (phase) {
     case "verify": {
       return runVerify(workspaceRoot, dependencies);
@@ -2794,7 +2934,7 @@ function runCiPhase(phase, workspaceRoot, dependencies = {}) {
 }
 
 // src/project-scaffolding/add-project.use-case.ts
-var import_node_path30 = require("path");
+var import_node_path31 = require("path");
 var import_prompts3 = require("@inquirer/prompts");
 
 // src/project-name/project-name.validator.ts
@@ -2807,8 +2947,8 @@ function assertValidProjectName(name, label) {
 }
 
 // src/project-scaffolding/csharp.use-case.ts
-var import_node_fs12 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs14 = require("fs");
+var import_node_path12 = require("path");
 
 // src/project-scaffolding/csharp-example.algorithm.ts
 function csharpExampleFiles(identity) {
@@ -2849,10 +2989,10 @@ public class GreetUseCaseTests
 }
 
 // src/project-scaffolding/post-generation.use-case.ts
-var import_node_fs11 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_path11 = require("path");
 function hasPlugin(workspaceRoot, packageName) {
-  const manifest = readJson((0, import_node_path10.join)(workspaceRoot, "package.json"));
+  const manifest = readJson((0, import_node_path11.join)(workspaceRoot, "package.json"));
   const installed = { ...manifest.dependencies, ...manifest.devDependencies };
   return Object.hasOwn(installed, packageName);
 }
@@ -2891,7 +3031,7 @@ function markPublic(manifestPath) {
 function writeProjectReadme(projectRoot, projectName, testRunner) {
   const runner = testRunner === "vitest" ? "[Vitest](https://vitest.dev)" : "[Jest](https://jestjs.io)";
   writeFileEnsured(
-    (0, import_node_path10.join)(projectRoot, "README.md"),
+    (0, import_node_path11.join)(projectRoot, "README.md"),
     [
       `# ${projectName}`,
       "",
@@ -2910,13 +3050,13 @@ function writeProjectReadme(projectRoot, projectName, testRunner) {
 }
 function removeStaleGitkeeps(workspaceRoot) {
   for (const scaffold of ["apps", "libs", "packages"]) {
-    const directory = (0, import_node_path10.join)(workspaceRoot, scaffold);
+    const directory = (0, import_node_path11.join)(workspaceRoot, scaffold);
     try {
-      const holdsAProject = (0, import_node_fs11.readdirSync)(directory, { withFileTypes: true }).some(
+      const holdsAProject = (0, import_node_fs13.readdirSync)(directory, { withFileTypes: true }).some(
         (entry) => entry.isDirectory()
       );
       if (holdsAProject) {
-        (0, import_node_fs11.rmSync)((0, import_node_path10.join)(directory, ".gitkeep"), { force: true });
+        (0, import_node_fs13.rmSync)((0, import_node_path11.join)(directory, ".gitkeep"), { force: true });
       }
     } catch {
     }
@@ -2936,7 +3076,7 @@ function ensureAdmZip(workspaceRoot) {
   }
 }
 function defaultScope(workspaceRoot) {
-  const { name } = readJson((0, import_node_path10.join)(workspaceRoot, "package.json"));
+  const { name } = readJson((0, import_node_path11.join)(workspaceRoot, "package.json"));
   const base = (name.startsWith("@") ? name.slice(1) : name).split("/", 1)[0];
   return `@${base}`;
 }
@@ -2964,14 +3104,14 @@ var ESLINT_CONFIG_FILENAMES = [
 ];
 function removeGeneratedEslintConfig(workspaceRoot, projectRoot) {
   for (const filename of ESLINT_CONFIG_FILENAMES) {
-    (0, import_node_fs11.rmSync)((0, import_node_path10.join)(workspaceRoot, projectRoot, filename), { force: true });
+    (0, import_node_fs13.rmSync)((0, import_node_path11.join)(workspaceRoot, projectRoot, filename), { force: true });
   }
-  (0, import_node_fs11.rmSync)((0, import_node_path10.join)(workspaceRoot, ".vscode"), { recursive: true, force: true });
+  (0, import_node_fs13.rmSync)((0, import_node_path11.join)(workspaceRoot, ".vscode"), { recursive: true, force: true });
 }
 function findCodeWorkspaceFile(workspaceRoot) {
   try {
-    const entry = (0, import_node_fs11.readdirSync)(workspaceRoot).find((file) => file.endsWith(".code-workspace"));
-    return entry ? (0, import_node_path10.join)(workspaceRoot, entry) : void 0;
+    const entry = (0, import_node_fs13.readdirSync)(workspaceRoot).find((file) => file.endsWith(".code-workspace"));
+    return entry ? (0, import_node_path11.join)(workspaceRoot, entry) : void 0;
   } catch {
     return void 0;
   }
@@ -2988,8 +3128,8 @@ function reshapeReactScaffold(projectRoot, name, empty = false) {
   reshapeScaffoldSlice(projectRoot, name, "tsx", "component", empty);
 }
 function reshapeReactAppScaffold(projectRoot) {
-  const appDir = (0, import_node_path10.join)(projectRoot, "src", "app");
-  if (!(0, import_node_fs11.existsSync)((0, import_node_path10.join)(appDir, "app.tsx"))) {
+  const appDir = (0, import_node_path11.join)(projectRoot, "src", "app");
+  if (!(0, import_node_fs13.existsSync)((0, import_node_path11.join)(appDir, "app.tsx"))) {
     return;
   }
   for (const [from, to] of [
@@ -2997,60 +3137,60 @@ function reshapeReactAppScaffold(projectRoot) {
     ["app.spec.tsx", "app.component.spec.tsx"],
     ["nx-welcome.tsx", "nx-welcome.component.tsx"]
   ]) {
-    if ((0, import_node_fs11.existsSync)((0, import_node_path10.join)(appDir, from))) {
-      (0, import_node_fs11.renameSync)((0, import_node_path10.join)(appDir, from), (0, import_node_path10.join)(appDir, to));
+    if ((0, import_node_fs13.existsSync)((0, import_node_path11.join)(appDir, from))) {
+      (0, import_node_fs13.renameSync)((0, import_node_path11.join)(appDir, from), (0, import_node_path11.join)(appDir, to));
     }
   }
   const rewrite = (file, from, to) => {
-    if ((0, import_node_fs11.existsSync)(file)) {
-      writeFileEnsured(file, repointSpecifier((0, import_node_fs11.readFileSync)(file, "utf8"), from, to));
+    if ((0, import_node_fs13.existsSync)(file)) {
+      writeFileEnsured(file, repointSpecifier((0, import_node_fs13.readFileSync)(file, "utf8"), from, to));
     }
   };
-  rewrite((0, import_node_path10.join)(appDir, "app.component.tsx"), "./nx-welcome", "./nx-welcome.component");
-  rewrite((0, import_node_path10.join)(appDir, "app.component.spec.tsx"), "./app", "./app.component");
-  rewrite((0, import_node_path10.join)(projectRoot, "src", "main.tsx"), "./app/app", "./app");
+  rewrite((0, import_node_path11.join)(appDir, "app.component.tsx"), "./nx-welcome", "./nx-welcome.component");
+  rewrite((0, import_node_path11.join)(appDir, "app.component.spec.tsx"), "./app", "./app.component");
+  rewrite((0, import_node_path11.join)(projectRoot, "src", "main.tsx"), "./app/app", "./app");
   writeFileEnsured(
-    (0, import_node_path10.join)(appDir, "index.ts"),
+    (0, import_node_path11.join)(appDir, "index.ts"),
     "export * from './app.component'\nexport { default } from './app.component'\n"
   );
 }
 function emptySlice(projectRoot, sliceDir) {
-  for (const entry of (0, import_node_fs11.readdirSync)(sliceDir)) {
-    (0, import_node_fs11.rmSync)((0, import_node_path10.join)(sliceDir, entry), { recursive: true, force: true });
+  for (const entry of (0, import_node_fs13.readdirSync)(sliceDir)) {
+    (0, import_node_fs13.rmSync)((0, import_node_path11.join)(sliceDir, entry), { recursive: true, force: true });
   }
-  writeFileEnsured((0, import_node_path10.join)(sliceDir, "index.ts"), "export {}\n");
-  addNxTargets((0, import_node_path10.join)(projectRoot, "package.json"), { test: { options: { passWithNoTests: true } } });
+  writeFileEnsured((0, import_node_path11.join)(sliceDir, "index.ts"), "export {}\n");
+  addNxTargets((0, import_node_path11.join)(projectRoot, "package.json"), { test: { options: { passWithNoTests: true } } });
 }
 function reshapeScaffoldSlice(projectRoot, name, extension, role, empty) {
-  const sourceDir = (0, import_node_path10.join)(projectRoot, "src");
-  const libDir = (0, import_node_path10.join)(sourceDir, "lib");
-  if (!(0, import_node_fs11.existsSync)((0, import_node_path10.join)(libDir, `${name}.${extension}`))) {
+  const sourceDir = (0, import_node_path11.join)(projectRoot, "src");
+  const libDir = (0, import_node_path11.join)(sourceDir, "lib");
+  if (!(0, import_node_fs13.existsSync)((0, import_node_path11.join)(libDir, `${name}.${extension}`))) {
     return;
   }
-  const sliceDir = (0, import_node_path10.join)(sourceDir, name);
-  (0, import_node_fs11.mkdirSync)(sliceDir, { recursive: true });
-  for (const entry of (0, import_node_fs11.readdirSync)(libDir)) {
+  const sliceDir = (0, import_node_path11.join)(sourceDir, name);
+  (0, import_node_fs13.mkdirSync)(sliceDir, { recursive: true });
+  for (const entry of (0, import_node_fs13.readdirSync)(libDir)) {
     if (entry === `${name}.${extension}`) {
-      (0, import_node_fs11.renameSync)((0, import_node_path10.join)(libDir, entry), (0, import_node_path10.join)(sliceDir, `${name}.${role}.${extension}`));
+      (0, import_node_fs13.renameSync)((0, import_node_path11.join)(libDir, entry), (0, import_node_path11.join)(sliceDir, `${name}.${role}.${extension}`));
     } else if (entry === `${name}.spec.${extension}`) {
-      const renamed = (0, import_node_path10.join)(sliceDir, `${name}.${role}.spec.${extension}`);
-      (0, import_node_fs11.renameSync)((0, import_node_path10.join)(libDir, entry), renamed);
-      writeFileEnsured(renamed, repointSpecifier((0, import_node_fs11.readFileSync)(renamed, "utf8"), `./${name}`, `./${name}.${role}`));
+      const renamed = (0, import_node_path11.join)(sliceDir, `${name}.${role}.spec.${extension}`);
+      (0, import_node_fs13.renameSync)((0, import_node_path11.join)(libDir, entry), renamed);
+      writeFileEnsured(renamed, repointSpecifier((0, import_node_fs13.readFileSync)(renamed, "utf8"), `./${name}`, `./${name}.${role}`));
     } else {
-      (0, import_node_fs11.renameSync)((0, import_node_path10.join)(libDir, entry), (0, import_node_path10.join)(sliceDir, entry));
+      (0, import_node_fs13.renameSync)((0, import_node_path11.join)(libDir, entry), (0, import_node_path11.join)(sliceDir, entry));
     }
   }
-  const barrel = (0, import_node_path10.join)(sourceDir, "index.ts");
-  const esm = (0, import_node_fs11.existsSync)(barrel) && (0, import_node_fs11.readFileSync)(barrel, "utf8").includes(`./lib/${name}.js'`);
-  writeFileEnsured((0, import_node_path10.join)(sliceDir, "index.ts"), `export * from './${name}.${role}${esm ? ".js" : ""}'
+  const barrel = (0, import_node_path11.join)(sourceDir, "index.ts");
+  const esm = (0, import_node_fs13.existsSync)(barrel) && (0, import_node_fs13.readFileSync)(barrel, "utf8").includes(`./lib/${name}.js'`);
+  writeFileEnsured((0, import_node_path11.join)(sliceDir, "index.ts"), `export * from './${name}.${role}${esm ? ".js" : ""}'
 `);
-  if ((0, import_node_fs11.existsSync)(barrel)) {
+  if ((0, import_node_fs13.existsSync)(barrel)) {
     writeFileEnsured(
       barrel,
-      (0, import_node_fs11.readFileSync)(barrel, "utf8").replaceAll(`./lib/${name}.js'`, () => `./${name}/index.js'`).replaceAll(`./lib/${name}'`, () => `./${name}'`)
+      (0, import_node_fs13.readFileSync)(barrel, "utf8").replaceAll(`./lib/${name}.js'`, () => `./${name}/index.js'`).replaceAll(`./lib/${name}'`, () => `./${name}'`)
     );
   }
-  (0, import_node_fs11.rmSync)(libDir, { recursive: true, force: true });
+  (0, import_node_fs13.rmSync)(libDir, { recursive: true, force: true });
   if (empty) {
     emptySlice(projectRoot, sliceDir);
   } else if (role === "use-case") {
@@ -3060,7 +3200,7 @@ function reshapeScaffoldSlice(projectRoot, name, extension, role, empty) {
 function writeWorkedExample(sliceDir, name, esm) {
   const suffix = esm ? ".js" : "";
   writeFileEnsured(
-    (0, import_node_path10.join)(sliceDir, `${name}.contract.ts`),
+    (0, import_node_path11.join)(sliceDir, `${name}.contract.ts`),
     `/** What greeting someone returns. */
 export interface Greeting {
   readonly message: string
@@ -3068,7 +3208,7 @@ export interface Greeting {
 `
   );
   writeFileEnsured(
-    (0, import_node_path10.join)(sliceDir, `${name}.use-case.ts`),
+    (0, import_node_path11.join)(sliceDir, `${name}.use-case.ts`),
     `import type { Greeting } from './${name}.contract${suffix}'
 
 /**
@@ -3087,7 +3227,7 @@ export function greet (name: string): Greeting {
 `
   );
   writeFileEnsured(
-    (0, import_node_path10.join)(sliceDir, `${name}.use-case.spec.ts`),
+    (0, import_node_path11.join)(sliceDir, `${name}.use-case.spec.ts`),
     `import { greet } from './${name}.use-case${suffix}'
 
 describe('greet', () => {
@@ -3098,7 +3238,7 @@ describe('greet', () => {
 `
   );
   writeFileEnsured(
-    (0, import_node_path10.join)(sliceDir, "index.ts"),
+    (0, import_node_path11.join)(sliceDir, "index.ts"),
     `export * from './${name}.contract${suffix}'
 export * from './${name}.use-case${suffix}'
 `
@@ -3112,8 +3252,8 @@ function repointSpecifier(source, from, to) {
   return result;
 }
 function ensureNxPeerOverrides(workspaceRoot) {
-  const manifestPath = (0, import_node_path10.join)(workspaceRoot, "package.json");
-  if (!(0, import_node_fs11.existsSync)(manifestPath)) {
+  const manifestPath = (0, import_node_path11.join)(workspaceRoot, "package.json");
+  if (!(0, import_node_fs13.existsSync)(manifestPath)) {
     return;
   }
   const manifest = readJson(manifestPath);
@@ -3136,11 +3276,11 @@ function registerProjectCommands(workspaceRoot, name, commands) {
   if (commands.start) {
     scripts[`${name}:start`] = commands.start;
   }
-  const dependabotPath = (0, import_node_path10.join)(workspaceRoot, ".github/dependabot.yml");
-  if ((0, import_node_fs11.existsSync)(dependabotPath)) {
+  const dependabotPath = (0, import_node_path11.join)(workspaceRoot, ".github/dependabot.yml");
+  if ((0, import_node_fs13.existsSync)(dependabotPath)) {
     writeFileEnsured(dependabotPath, dependabotConfig(workspaceRoot));
   }
-  const manifestPath = (0, import_node_path10.join)(workspaceRoot, "package.json");
+  const manifestPath = (0, import_node_path11.join)(workspaceRoot, "package.json");
   const manifest = readJson(manifestPath);
   const existingScripts = manifest.scripts ?? {};
   writeFileEnsured(
@@ -3178,7 +3318,7 @@ function registerProjectCommands(workspaceRoot, name, commands) {
 var PROJECT_MANIFEST_ROOTS = ["apps", "packages", "libs"];
 function rootRuntimeDependencies(workspaceRoot) {
   try {
-    return readJson((0, import_node_path10.join)(workspaceRoot, "package.json")).dependencies ?? {};
+    return readJson((0, import_node_path11.join)(workspaceRoot, "package.json")).dependencies ?? {};
   } catch {
     return {};
   }
@@ -3190,7 +3330,7 @@ function relocateRootRuntimeDependencies(workspaceRoot, projectName, before) {
     return;
   }
   const manifestPath = PROJECT_MANIFEST_ROOTS.map(
-    (root) => (0, import_node_path10.join)(workspaceRoot, root, projectName, "package.json")
+    (root) => (0, import_node_path11.join)(workspaceRoot, root, projectName, "package.json")
   ).find((candidate) => fileExists(candidate));
   if (manifestPath === void 0) {
     return;
@@ -3202,10 +3342,10 @@ function relocateRootRuntimeDependencies(workspaceRoot, projectName, before) {
   const remaining = Object.fromEntries(
     Object.entries(after).filter(([name]) => !added.includes(name))
   );
-  const rootManifest = readJson((0, import_node_path10.join)(workspaceRoot, "package.json"));
+  const rootManifest = readJson((0, import_node_path11.join)(workspaceRoot, "package.json"));
   const { dependencies: _dropped, ...rest } = rootManifest;
   writeFileEnsured(
-    (0, import_node_path10.join)(workspaceRoot, "package.json"),
+    (0, import_node_path11.join)(workspaceRoot, "package.json"),
     toJson(Object.keys(remaining).length > 0 ? { ...rest, dependencies: remaining } : rest)
   );
   logger.step(`Moved ${added.join(", ")} into ${projectName}'s own manifest`);
@@ -3244,28 +3384,28 @@ function scaffoldDotnetProject(workspaceRoot, projectRoot, identity, template) {
 }
 function writeCsharpExample(absoluteRoot, identity, kind) {
   if (kind === "classlib") {
-    (0, import_node_fs12.rmSync)((0, import_node_path11.join)(absoluteRoot, "Class1.cs"), { force: true });
+    (0, import_node_fs14.rmSync)((0, import_node_path12.join)(absoluteRoot, "Class1.cs"), { force: true });
   }
   const files = csharpExampleFiles(identity);
   for (const [file, contents] of Object.entries(files)) {
-    writeFileEnsured((0, import_node_path11.join)(absoluteRoot, file), contents);
+    writeFileEnsured((0, import_node_path12.join)(absoluteRoot, file), contents);
   }
   if (kind === "console") {
-    writeFileEnsured((0, import_node_path11.join)(absoluteRoot, "Program.cs"), csharpConsoleProgram(identity));
+    writeFileEnsured((0, import_node_path12.join)(absoluteRoot, "Program.cs"), csharpConsoleProgram(identity));
   }
 }
 function addCsharpTestProject(workspaceRoot, projectRoot, identity) {
-  const name = (0, import_node_path11.basename)(projectRoot);
+  const name = (0, import_node_path12.basename)(projectRoot);
   const testRoot = `tests/${name}`;
   scaffoldDotnetProject(workspaceRoot, testRoot, `${identity}.Tests`, "xunit");
-  (0, import_node_fs12.rmSync)((0, import_node_path11.join)(workspaceRoot, testRoot, "UnitTest1.cs"), { force: true });
-  writeFileEnsured((0, import_node_path11.join)(workspaceRoot, testRoot, "GreetUseCaseTests.cs"), csharpExampleTest(identity));
+  (0, import_node_fs14.rmSync)((0, import_node_path12.join)(workspaceRoot, testRoot, "UnitTest1.cs"), { force: true });
+  writeFileEnsured((0, import_node_path12.join)(workspaceRoot, testRoot, "GreetUseCaseTests.cs"), csharpExampleTest(identity));
   writeFileEnsured(
-    (0, import_node_path11.join)(workspaceRoot, testRoot, "project.json"),
+    (0, import_node_path12.join)(workspaceRoot, testRoot, "project.json"),
     toJson({ name: `${name}-tests`, tags: ["type:csharp-test"] })
   );
-  const reference = (0, import_node_path11.join)(workspaceRoot, projectRoot, `${identity}.csproj`);
-  if (runShell("dotnet", ["add", (0, import_node_path11.join)(workspaceRoot, testRoot), "reference", reference], workspaceRoot) !== 0) {
+  const reference = (0, import_node_path12.join)(workspaceRoot, projectRoot, `${identity}.csproj`);
+  if (runShell("dotnet", ["add", (0, import_node_path12.join)(workspaceRoot, testRoot), "reference", reference], workspaceRoot) !== 0) {
     throw new Error(`dotnet add reference failed for ${testRoot}`);
   }
 }
@@ -3292,9 +3432,9 @@ function addCsharpApp(workspaceRoot, name, template = "console") {
   ensureAdmZip(workspaceRoot);
   const projectRoot = `apps/${name}`;
   scaffoldDotnetProject(workspaceRoot, projectRoot, pascalCase(name), template);
-  writeCsharpExample((0, import_node_path11.join)(workspaceRoot, projectRoot), pascalCase(name), template);
+  writeCsharpExample((0, import_node_path12.join)(workspaceRoot, projectRoot), pascalCase(name), template);
   addCsharpTestProject(workspaceRoot, projectRoot, pascalCase(name));
-  addProjectJsonTargets((0, import_node_path11.join)(workspaceRoot, projectRoot, "project.json"), {
+  addProjectJsonTargets((0, import_node_path12.join)(workspaceRoot, projectRoot, "project.json"), {
     package: csharpAppPackageTarget("csharp-app", projectRoot, name),
     start: csharpAppStartTarget(projectRoot)
   });
@@ -3387,7 +3527,7 @@ class CsharpVersionActions extends VersionActions {
 module.exports = CsharpVersionActions
 `;
 function writeCsharpVersionActions(workspaceRoot) {
-  writeFileEnsured((0, import_node_path11.join)(workspaceRoot, CSHARP_VERSION_ACTIONS_PATH), CSHARP_VERSION_ACTIONS);
+  writeFileEnsured((0, import_node_path12.join)(workspaceRoot, CSHARP_VERSION_ACTIONS_PATH), CSHARP_VERSION_ACTIONS);
 }
 function addProjectJsonReleaseVersionActions(projectJsonPath) {
   const project = fileExists(projectJsonPath) ? readJson(projectJsonPath) : {};
@@ -3402,7 +3542,7 @@ function addProjectJsonReleaseVersionActions(projectJsonPath) {
   );
 }
 function addInitialVersion(csprojPath) {
-  const contents = (0, import_node_fs12.readFileSync)(csprojPath, "utf8");
+  const contents = (0, import_node_fs14.readFileSync)(csprojPath, "utf8");
   writeFileEnsured(csprojPath, contents.replace("<PropertyGroup>", "<PropertyGroup>\n    <Version>0.1.0</Version>"));
 }
 function csharpLibPublishTarget(projectRoot) {
@@ -3417,16 +3557,16 @@ async function addCsharpLib(workspaceRoot, name, options, kindProvided) {
   const projectRoot = `packages/${name}`;
   const identity = `${pascalScope(scope)}.${pascalCase(name)}`;
   scaffoldDotnetProject(workspaceRoot, projectRoot, identity, "classlib");
-  writeCsharpExample((0, import_node_path11.join)(workspaceRoot, projectRoot), identity, "classlib");
+  writeCsharpExample((0, import_node_path12.join)(workspaceRoot, projectRoot), identity, "classlib");
   addCsharpTestProject(workspaceRoot, projectRoot, identity);
-  addInitialVersion((0, import_node_path11.join)(workspaceRoot, projectRoot, `${identity}.csproj`));
+  addInitialVersion((0, import_node_path12.join)(workspaceRoot, projectRoot, `${identity}.csproj`));
   writeCsharpVersionActions(workspaceRoot);
-  addProjectJsonReleaseVersionActions((0, import_node_path11.join)(workspaceRoot, projectRoot, "project.json"));
-  addProjectJsonTargets((0, import_node_path11.join)(workspaceRoot, projectRoot, "project.json"), {
+  addProjectJsonReleaseVersionActions((0, import_node_path12.join)(workspaceRoot, projectRoot, "project.json"));
+  addProjectJsonTargets((0, import_node_path12.join)(workspaceRoot, projectRoot, "project.json"), {
     "nx-release-publish": csharpLibPublishTarget(projectRoot)
   });
   const registry = readMnciConfig(workspaceRoot).registry ?? { kind: "npm" };
-  writeFileEnsured((0, import_node_path11.join)(workspaceRoot, "nuget.config"), nugetConfigContent(registry, scope));
+  writeFileEnsured((0, import_node_path12.join)(workspaceRoot, "nuget.config"), nugetConfigContent(registry, scope));
   registerProjectCommands(workspaceRoot, name, { build: true });
 }
 function addCsharpInternalLib(workspaceRoot, name) {
@@ -3435,7 +3575,7 @@ function addCsharpInternalLib(workspaceRoot, name) {
   const projectRoot = `libs/${name}`;
   const identity = pascalCase(name);
   scaffoldDotnetProject(workspaceRoot, projectRoot, identity, "classlib");
-  writeCsharpExample((0, import_node_path11.join)(workspaceRoot, projectRoot), identity, "classlib");
+  writeCsharpExample((0, import_node_path12.join)(workspaceRoot, projectRoot), identity, "classlib");
   addCsharpTestProject(workspaceRoot, projectRoot, identity);
   registerProjectCommands(workspaceRoot, name, { build: false });
   logger.step(
@@ -3504,20 +3644,20 @@ function addCsharpFunctionApp(workspaceRoot, name) {
   const projectRoot = `apps/${name}`;
   const identity = pascalCase(name);
   scaffoldDotnetProject(workspaceRoot, projectRoot, identity, "console");
-  const absoluteRoot = (0, import_node_path11.join)(workspaceRoot, projectRoot);
-  writeFileEnsured((0, import_node_path11.join)(absoluteRoot, `${identity}.csproj`), csharpFunctionAppCsproj());
-  writeFileEnsured((0, import_node_path11.join)(absoluteRoot, "Program.cs"), CSHARP_FUNCTION_APP_PROGRAM);
-  writeFileEnsured((0, import_node_path11.join)(absoluteRoot, "Hello.cs"), csharpFunctionAppHello(identity));
+  const absoluteRoot = (0, import_node_path12.join)(workspaceRoot, projectRoot);
+  writeFileEnsured((0, import_node_path12.join)(absoluteRoot, `${identity}.csproj`), csharpFunctionAppCsproj());
+  writeFileEnsured((0, import_node_path12.join)(absoluteRoot, "Program.cs"), CSHARP_FUNCTION_APP_PROGRAM);
+  writeFileEnsured((0, import_node_path12.join)(absoluteRoot, "Hello.cs"), csharpFunctionAppHello(identity));
   const example = csharpExampleFiles(identity);
   for (const [file, contents] of Object.entries(example)) {
-    writeFileEnsured((0, import_node_path11.join)(absoluteRoot, file), contents);
+    writeFileEnsured((0, import_node_path12.join)(absoluteRoot, file), contents);
   }
-  writeFileEnsured((0, import_node_path11.join)(absoluteRoot, "host.json"), CSHARP_FUNCTION_APP_HOST_JSON);
+  writeFileEnsured((0, import_node_path12.join)(absoluteRoot, "host.json"), CSHARP_FUNCTION_APP_HOST_JSON);
   if (runShell("dotnet", ["restore", projectRoot], workspaceRoot) !== 0) {
     throw new Error(`dotnet restore failed for ${projectRoot}`);
   }
   addCsharpTestProject(workspaceRoot, projectRoot, identity);
-  addProjectJsonTargets((0, import_node_path11.join)(absoluteRoot, "project.json"), {
+  addProjectJsonTargets((0, import_node_path12.join)(absoluteRoot, "project.json"), {
     package: csharpAppPackageTarget("csharp-function-app", projectRoot, name),
     start: csharpFunctionAppStartTarget(projectRoot)
   });
@@ -3525,7 +3665,7 @@ function addCsharpFunctionApp(workspaceRoot, name) {
 }
 
 // src/project-scaffolding/flutter.use-case.ts
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 function flutterAppStartTarget(name) {
   return {
     executor: "nx:run-commands",
@@ -3561,7 +3701,7 @@ function addFlutterApp(workspaceRoot, name) {
   prepareFlutter(workspaceRoot);
   ensureAdmZip(workspaceRoot);
   runNx(["g", "@mnci/nx-flutter:application", name, "--no-interactive"], workspaceRoot);
-  addProjectJsonTargets((0, import_node_path12.join)(workspaceRoot, "apps", name, "project.json"), {
+  addProjectJsonTargets((0, import_node_path13.join)(workspaceRoot, "apps", name, "project.json"), {
     start: flutterAppStartTarget(name)
   });
   registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:start` });
@@ -3578,8 +3718,8 @@ function addFlutterInternalLib(workspaceRoot, name) {
 }
 
 // src/project-scaffolding/go.use-case.ts
-var import_node_fs16 = require("fs");
-var import_node_path16 = require("path");
+var import_node_fs18 = require("fs");
+var import_node_path17 = require("path");
 
 // src/project-scaffolding/go-example.algorithm.ts
 function greetingContract(packageName) {
@@ -3648,14 +3788,14 @@ function goAppExampleFiles(modulePath) {
 }
 
 // src/go-workspace/go-plugin.use-case.ts
-var import_node_fs13 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs15 = require("fs");
+var import_node_path14 = require("path");
 var NX_GO_PLUGIN = "@nx-go/nx-go";
 function hasGoProject(workspaceRoot) {
-  const projectFiles = ["apps", "libs", "packages"].flatMap((directory) => (0, import_node_fs13.globSync)(`${directory}/*/project.json`, { cwd: workspaceRoot }));
+  const projectFiles = ["apps", "libs", "packages"].flatMap((directory) => (0, import_node_fs15.globSync)(`${directory}/*/project.json`, { cwd: workspaceRoot }));
   return projectFiles.some((projectFile) => {
     try {
-      const { tags } = JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path13.join)(workspaceRoot, projectFile), "utf8"));
+      const { tags } = JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path14.join)(workspaceRoot, projectFile), "utf8"));
       return (tags ?? []).some((tag) => tag.startsWith("type:go-"));
     } catch {
       return false;
@@ -3663,7 +3803,7 @@ function hasGoProject(workspaceRoot) {
   });
 }
 function isNxGoPluginRegistered(workspaceRoot) {
-  const nxJsonPath = (0, import_node_path13.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path14.join)(workspaceRoot, "nx.json");
   if (!fileExists(nxJsonPath)) {
     return false;
   }
@@ -3690,7 +3830,7 @@ function goModulePrefix(workspaceRoot) {
   return result.status === 0 ? modulePrefixFromRemoteUrl(result.stdout) : void 0;
 }
 function registerNxGoPlugin(workspaceRoot) {
-  const nxJsonPath = (0, import_node_path13.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path14.join)(workspaceRoot, "nx.json");
   if (!fileExists(nxJsonPath)) {
     return false;
   }
@@ -3714,8 +3854,8 @@ function registerNxGoPlugin(workspaceRoot) {
 }
 
 // src/project-scaffolding/go-release.use-case.ts
-var import_node_fs14 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_path15 = require("path");
 var GO_RELEASE_SCRIPT_PATH = "tools/go-app-release.cjs";
 var GO_RELEASE_SCRIPT = String.raw`#!/usr/bin/env node
 // Written by mnci: 'mnci add go-app --release' creates it and 'mnci upgrade'
@@ -3841,7 +3981,7 @@ var GO_RELEASE_PUBLISH_TARGET = {
   }
 };
 function makeGoAppReleasable(workspaceRoot, name) {
-  const projectJsonPath = (0, import_node_path14.join)(workspaceRoot, "apps", name, "project.json");
+  const projectJsonPath = (0, import_node_path15.join)(workspaceRoot, "apps", name, "project.json");
   if (!fileExists(projectJsonPath)) {
     throw new Error(`No Go app at apps/${name}: cannot make it releasable.`);
   }
@@ -3862,22 +4002,22 @@ function makeGoAppReleasable(workspaceRoot, name) {
       }
     })
   );
-  writeFileEnsured((0, import_node_path14.join)(workspaceRoot, GO_RELEASE_SCRIPT_PATH), GO_RELEASE_SCRIPT);
+  writeFileEnsured((0, import_node_path15.join)(workspaceRoot, GO_RELEASE_SCRIPT_PATH), GO_RELEASE_SCRIPT);
 }
 function refreshGoReleaseScript(workspaceRoot) {
-  const apps = (0, import_node_path14.join)(workspaceRoot, "apps");
+  const apps = (0, import_node_path15.join)(workspaceRoot, "apps");
   let entries;
   try {
-    entries = (0, import_node_fs14.readdirSync)(apps);
+    entries = (0, import_node_fs16.readdirSync)(apps);
   } catch {
     return false;
   }
   const hasReleasableApp = entries.some((entry) => {
-    const projectJsonPath = (0, import_node_path14.join)(apps, entry, "project.json");
+    const projectJsonPath = (0, import_node_path15.join)(apps, entry, "project.json");
     return fileExists(projectJsonPath) && (readJson(projectJsonPath).tags ?? []).includes(GO_RELEASE_TAG);
   });
-  const path = (0, import_node_path14.join)(workspaceRoot, GO_RELEASE_SCRIPT_PATH);
-  if (!hasReleasableApp || fileExists(path) && (0, import_node_fs14.readFileSync)(path, "utf8") === GO_RELEASE_SCRIPT) {
+  const path = (0, import_node_path15.join)(workspaceRoot, GO_RELEASE_SCRIPT_PATH);
+  if (!hasReleasableApp || fileExists(path) && (0, import_node_fs16.readFileSync)(path, "utf8") === GO_RELEASE_SCRIPT) {
     return false;
   }
   writeFileEnsured(path, GO_RELEASE_SCRIPT);
@@ -3885,8 +4025,8 @@ function refreshGoReleaseScript(workspaceRoot) {
 }
 
 // src/project-scaffolding/go-web.use-case.ts
-var import_node_fs15 = require("fs");
-var import_node_path15 = require("path");
+var import_node_fs17 = require("fs");
+var import_node_path16 = require("path");
 var TARGETS_NEEDING_THE_FRONTEND = ["build", "test", "lint", "start", "build-all", "build-native"];
 var DEFAULT_ADDRESS = "127.0.0.1:8080";
 var GO_WEB_SOURCE = `package main
@@ -3964,18 +4104,18 @@ func TestWebHandlerServesTheBuiltFrontend(t *testing.T) {
 }
 `;
 function assertWebApp(workspaceRoot, web) {
-  const directory = (0, import_node_path15.join)(workspaceRoot, "apps", web);
-  const isReactApp = fileExists((0, import_node_path15.join)(directory, "package.json")) && (0, import_node_fs15.readdirSync)(directory).some((entry) => entry.startsWith("vite.config."));
+  const directory = (0, import_node_path16.join)(workspaceRoot, "apps", web);
+  const isReactApp = fileExists((0, import_node_path16.join)(directory, "package.json")) && (0, import_node_fs17.readdirSync)(directory).some((entry) => entry.startsWith("vite.config."));
   if (!isReactApp) {
     throw new Error(`--web ${web}: no React app at apps/${web}. Add it first with \`mnci add react-app ${web}\`.`);
   }
 }
 function webProjectName(workspaceRoot, web) {
-  const manifest = readJson((0, import_node_path15.join)(workspaceRoot, "apps", web, "package.json"));
+  const manifest = readJson((0, import_node_path16.join)(workspaceRoot, "apps", web, "package.json"));
   return manifest.nx?.name ?? manifest.name ?? web;
 }
 function addApiProxy(viteConfigPath) {
-  const source = (0, import_node_fs15.readFileSync)(viteConfigPath, "utf8");
+  const source = (0, import_node_fs17.readFileSync)(viteConfigPath, "utf8");
   if (source.includes("'/api'") || source.includes('"/api"')) {
     return false;
   }
@@ -3988,7 +4128,7 @@ function addApiProxy(viteConfigPath) {
   return true;
 }
 function wireGoAppToWeb(workspaceRoot, name, web) {
-  const projectJsonPath = (0, import_node_path15.join)(workspaceRoot, "apps", name, "project.json");
+  const projectJsonPath = (0, import_node_path16.join)(workspaceRoot, "apps", name, "project.json");
   const project = readJson(projectJsonPath);
   const webName = webProjectName(workspaceRoot, web);
   const targets = project.targets ?? {};
@@ -4014,13 +4154,13 @@ function wireGoAppToWeb(workspaceRoot, name, web) {
     projectJsonPath,
     toJson({ ...project, implicitDependencies: [.../* @__PURE__ */ new Set([...project.implicitDependencies ?? [], webName])], targets })
   );
-  const directory = (0, import_node_path15.join)(workspaceRoot, "apps", name);
-  writeFileEnsured((0, import_node_path15.join)(directory, ".gitignore"), "/web/\n");
-  writeFileEnsured((0, import_node_path15.join)(directory, "web.go"), GO_WEB_SOURCE);
-  writeFileEnsured((0, import_node_path15.join)(directory, "main.go"), GO_WEB_MAIN);
-  writeFileEnsured((0, import_node_path15.join)(directory, "main_test.go"), GO_WEB_MAIN_TEST);
-  const viteConfig = (0, import_node_fs15.readdirSync)((0, import_node_path15.join)(workspaceRoot, "apps", web)).find((entry) => entry.startsWith("vite.config."));
-  if (viteConfig === void 0 || !addApiProxy((0, import_node_path15.join)(workspaceRoot, "apps", web, viteConfig))) {
+  const directory = (0, import_node_path16.join)(workspaceRoot, "apps", name);
+  writeFileEnsured((0, import_node_path16.join)(directory, ".gitignore"), "/web/\n");
+  writeFileEnsured((0, import_node_path16.join)(directory, "web.go"), GO_WEB_SOURCE);
+  writeFileEnsured((0, import_node_path16.join)(directory, "main.go"), GO_WEB_MAIN);
+  writeFileEnsured((0, import_node_path16.join)(directory, "main_test.go"), GO_WEB_MAIN_TEST);
+  const viteConfig = (0, import_node_fs17.readdirSync)((0, import_node_path16.join)(workspaceRoot, "apps", web)).find((entry) => entry.startsWith("vite.config."));
+  if (viteConfig === void 0 || !addApiProxy((0, import_node_path16.join)(workspaceRoot, "apps", web, viteConfig))) {
     logger.warn(
       `Could not add the /api proxy to apps/${web}'s Vite config: add \`server: { proxy: { '/api': 'http://${DEFAULT_ADDRESS}' } }\` yourself, so \`nx run ${name}:dev\` reaches the Go server.`
     );
@@ -4054,7 +4194,7 @@ function ensureNxGoPlugin(workspaceRoot) {
   }
 }
 function ensureGoModule(workspaceRoot) {
-  if (fileExists((0, import_node_path16.join)(workspaceRoot, "go.work")) || fileExists((0, import_node_path16.join)(workspaceRoot, "go.mod"))) {
+  if (fileExists((0, import_node_path17.join)(workspaceRoot, "go.work")) || fileExists((0, import_node_path17.join)(workspaceRoot, "go.mod"))) {
     return;
   }
   logger.step("Bootstrapping the Go workspace (go.work, one module per project)");
@@ -4062,38 +4202,38 @@ function ensureGoModule(workspaceRoot) {
 }
 function readGoModModule(goModPath) {
   try {
-    return /^module\s+(\S+)/m.exec((0, import_node_fs16.readFileSync)(goModPath, "utf8"))?.[1];
+    return /^module\s+(\S+)/m.exec((0, import_node_fs18.readFileSync)(goModPath, "utf8"))?.[1];
   } catch {
     return void 0;
   }
 }
 function goModulePathFor(workspaceRoot, projectDir) {
-  const projectModule = readGoModModule((0, import_node_path16.join)(workspaceRoot, projectDir, "go.mod"));
+  const projectModule = readGoModModule((0, import_node_path17.join)(workspaceRoot, projectDir, "go.mod"));
   if (projectModule !== void 0) {
     return projectModule;
   }
-  const rootModule = readGoModModule((0, import_node_path16.join)(workspaceRoot, "go.mod"));
+  const rootModule = readGoModModule((0, import_node_path17.join)(workspaceRoot, "go.mod"));
   return rootModule === void 0 ? void 0 : `${rootModule}/${projectDir}`;
 }
 function setGoModulePath(workspaceRoot, projectDir) {
   const prefix = goModulePrefix(workspaceRoot);
-  const goModPath = (0, import_node_path16.join)(workspaceRoot, projectDir, "go.mod");
+  const goModPath = (0, import_node_path17.join)(workspaceRoot, projectDir, "go.mod");
   if (prefix === void 0 || !fileExists(goModPath)) {
     return;
   }
-  const rewritten = (0, import_node_fs16.readFileSync)(goModPath, "utf8").replace(/^module\s+\S+/m, () => `module ${prefix}/${projectDir}`);
+  const rewritten = (0, import_node_fs18.readFileSync)(goModPath, "utf8").replace(/^module\s+\S+/m, () => `module ${prefix}/${projectDir}`);
   writeFileEnsured(goModPath, rewritten);
 }
 function writeGoAppExample(workspaceRoot, projectDir) {
-  const goModPath = (0, import_node_path16.join)(workspaceRoot, projectDir, "go.mod");
-  const modulePath = fileExists(goModPath) ? /^module\s+(\S+)/m.exec((0, import_node_fs16.readFileSync)(goModPath, "utf8"))?.[1] : void 0;
+  const goModPath = (0, import_node_path17.join)(workspaceRoot, projectDir, "go.mod");
+  const modulePath = fileExists(goModPath) ? /^module\s+(\S+)/m.exec((0, import_node_fs18.readFileSync)(goModPath, "utf8"))?.[1] : void 0;
   if (modulePath === void 0) {
     return;
   }
-  (0, import_node_fs16.rmSync)((0, import_node_path16.join)(workspaceRoot, projectDir, "main_test.go"), { force: true });
+  (0, import_node_fs18.rmSync)((0, import_node_path17.join)(workspaceRoot, projectDir, "main_test.go"), { force: true });
   const example = goAppExampleFiles(modulePath);
   for (const [relative, contents] of Object.entries(example)) {
-    writeFileEnsured((0, import_node_path16.join)(workspaceRoot, projectDir, relative), contents);
+    writeFileEnsured((0, import_node_path17.join)(workspaceRoot, projectDir, relative), contents);
   }
 }
 function goTestTarget() {
@@ -4171,16 +4311,16 @@ function goNativePackageTarget(name) {
 }
 function addGoPlatformTargets(workspaceRoot) {
   const changed = [];
-  const apps = (0, import_node_path16.join)(workspaceRoot, "apps");
+  const apps = (0, import_node_path17.join)(workspaceRoot, "apps");
   if (!fileExists(apps)) {
     return changed;
   }
-  for (const name of (0, import_node_fs16.readdirSync)(apps)) {
-    const projectJsonPath = (0, import_node_path16.join)(apps, name, "project.json");
+  for (const name of (0, import_node_fs18.readdirSync)(apps)) {
+    const projectJsonPath = (0, import_node_path17.join)(apps, name, "project.json");
     if (!fileExists(projectJsonPath)) {
       continue;
     }
-    const project = JSON.parse((0, import_node_fs16.readFileSync)(projectJsonPath, "utf8"));
+    const project = JSON.parse((0, import_node_fs18.readFileSync)(projectJsonPath, "utf8"));
     const tag = (project.tags ?? []).find((each) => each === "type:go-app" || each === "type:go-function-app")?.slice("type:".length);
     if (tag === void 0 || (project.tags ?? []).includes(GO_CGO_TAG)) {
       continue;
@@ -4216,8 +4356,8 @@ function goLibraryIdentifiers(projectName) {
 }
 function reshapeGoLibraryScaffold(projectRoot, projectName) {
   const { packageName, fileStem } = goLibraryIdentifiers(projectName);
-  (0, import_node_fs16.rmSync)((0, import_node_path16.join)(projectRoot, `${projectName}.go`), { force: true });
-  (0, import_node_fs16.rmSync)((0, import_node_path16.join)(projectRoot, `${projectName}_test.go`), { force: true });
+  (0, import_node_fs18.rmSync)((0, import_node_path17.join)(projectRoot, `${projectName}.go`), { force: true });
+  (0, import_node_fs18.rmSync)((0, import_node_path17.join)(projectRoot, `${projectName}_test.go`), { force: true });
   const files = [
     [
       "doc.go",
@@ -4227,7 +4367,7 @@ package ${packageName}
 `
     ],
     [
-      (0, import_node_path16.join)(packageName, "doc.go"),
+      (0, import_node_path17.join)(packageName, "doc.go"),
       `// Package ${packageName} is the starter slice of ${projectName}: rename it after
 // the outcome it delivers, and add one package per further outcome.
 package ${packageName}
@@ -4235,11 +4375,11 @@ package ${packageName}
     ],
     // The starter slice: a contract, a use case and its test (see goLibraryExampleFiles).
     ...Object.entries(goLibraryExampleFiles(packageName, fileStem)).map(
-      ([name, content]) => [(0, import_node_path16.join)(packageName, name), content]
+      ([name, content]) => [(0, import_node_path17.join)(packageName, name), content]
     )
   ];
   for (const [relativePath, content] of files) {
-    const path = (0, import_node_path16.join)(projectRoot, relativePath);
+    const path = (0, import_node_path17.join)(projectRoot, relativePath);
     if (!fileExists(path)) {
       writeFileEnsured(path, content);
     }
@@ -4277,7 +4417,7 @@ function addGoApp(workspaceRoot, name, options = {}) {
   if (options.web === void 0) {
     writeGoAppExample(workspaceRoot, `apps/${name}`);
   }
-  addProjectJsonTargets((0, import_node_path16.join)(workspaceRoot, "apps", name, "project.json"), {
+  addProjectJsonTargets((0, import_node_path17.join)(workspaceRoot, "apps", name, "project.json"), {
     build: goBuildTarget(name),
     test: goTestTarget(),
     lint: goLintTarget(),
@@ -4317,7 +4457,7 @@ function addGoFunctionApp(workspaceRoot, name) {
   );
   setGoModulePath(workspaceRoot, `apps/${name}`);
   writeGoAppExample(workspaceRoot, `apps/${name}`);
-  addProjectJsonTargets((0, import_node_path16.join)(workspaceRoot, "apps", name, "project.json"), {
+  addProjectJsonTargets((0, import_node_path17.join)(workspaceRoot, "apps", name, "project.json"), {
     "build": goBuildTarget(name),
     "test": goTestTarget(),
     "lint": goLintTarget(),
@@ -4341,11 +4481,11 @@ function addGoLib(workspaceRoot, name) {
     workspaceRoot
   );
   setGoModulePath(workspaceRoot, `packages/${name}`);
-  addProjectJsonTargets((0, import_node_path16.join)(workspaceRoot, "packages", name, "project.json"), {
+  addProjectJsonTargets((0, import_node_path17.join)(workspaceRoot, "packages", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
-  const slice = reshapeGoLibraryScaffold((0, import_node_path16.join)(workspaceRoot, "packages", name), name);
+  const slice = reshapeGoLibraryScaffold((0, import_node_path17.join)(workspaceRoot, "packages", name), name);
   registerProjectCommands(workspaceRoot, name, { build: false });
   const module2 = goModulePathFor(workspaceRoot, `packages/${name}`);
   if (module2) {
@@ -4366,11 +4506,11 @@ function addGoInternalLib(workspaceRoot, name) {
     workspaceRoot
   );
   setGoModulePath(workspaceRoot, `libs/${name}`);
-  addProjectJsonTargets((0, import_node_path16.join)(workspaceRoot, "libs", name, "project.json"), {
+  addProjectJsonTargets((0, import_node_path17.join)(workspaceRoot, "libs", name, "project.json"), {
     test: goTestTarget(),
     lint: goLintTarget()
   });
-  const slice = reshapeGoLibraryScaffold((0, import_node_path16.join)(workspaceRoot, "libs", name), name);
+  const slice = reshapeGoLibraryScaffold((0, import_node_path17.join)(workspaceRoot, "libs", name), name);
   registerProjectCommands(workspaceRoot, name, { build: false });
   const module2 = goModulePathFor(workspaceRoot, `libs/${name}`);
   if (module2) {
@@ -4379,7 +4519,7 @@ function addGoInternalLib(workspaceRoot, name) {
 }
 
 // src/project-scaffolding/node.use-case.ts
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 
 // src/project-scaffolding/node-app-example.algorithm.ts
 var GREET_USE_CASE = `import type { Greeting } from './greeting.contract'
@@ -4502,12 +4642,12 @@ function runNodeApp(workspaceRoot, name, stack, framework) {
     ],
     workspaceRoot
   );
-  const appRoot = (0, import_node_path17.join)(workspaceRoot, "apps", name);
+  const appRoot = (0, import_node_path18.join)(workspaceRoot, "apps", name);
   separateDeclarationOutput(appRoot);
   repairAssetMapping(appRoot, name);
 }
 function separateDeclarationOutput(appRoot) {
-  const tsconfigPath = (0, import_node_path17.join)(appRoot, "tsconfig.app.json");
+  const tsconfigPath = (0, import_node_path18.join)(appRoot, "tsconfig.app.json");
   if (!fileExists(tsconfigPath)) {
     return;
   }
@@ -4529,7 +4669,7 @@ function separateDeclarationOutput(appRoot) {
   );
 }
 function repairAssetMapping(appRoot, name) {
-  const manifestPath = (0, import_node_path17.join)(appRoot, "package.json");
+  const manifestPath = (0, import_node_path18.join)(appRoot, "package.json");
   if (!fileExists(manifestPath)) {
     return;
   }
@@ -4558,11 +4698,11 @@ function addNodeApp(workspaceRoot, name, stack, framework = "none") {
   const example = nodeAppExampleFiles(framework);
   if (example !== null) {
     for (const [relative, contents] of Object.entries(example)) {
-      writeFileEnsured((0, import_node_path17.join)(workspaceRoot, "apps", name, "src", relative), contents);
+      writeFileEnsured((0, import_node_path18.join)(workspaceRoot, "apps", name, "src", relative), contents);
     }
   }
   ensureAdmZip(workspaceRoot);
-  addNxTargets((0, import_node_path17.join)(workspaceRoot, "apps", name, "package.json"), {
+  addNxTargets((0, import_node_path18.join)(workspaceRoot, "apps", name, "package.json"), {
     package: nodeAppPackageTarget(name)
   });
   removeGeneratedEslintConfig(workspaceRoot, `apps/${name}`);
@@ -4631,10 +4771,10 @@ describe('greet', () => {
 })
 `;
 function repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot) {
-  const manifestPath = (0, import_node_path17.join)(nodeFunctionAppRoot, "package.json");
+  const manifestPath = (0, import_node_path18.join)(nodeFunctionAppRoot, "package.json");
   const manifest = readJson(manifestPath);
   const azureFunctionsVersion = readJson(
-    (0, import_node_path17.join)(workspaceRoot, "node_modules/@azure/functions/package.json")
+    (0, import_node_path18.join)(workspaceRoot, "node_modules/@azure/functions/package.json")
   ).version;
   const dependencies = manifest.dependencies ?? {};
   writeFileEnsured(
@@ -4677,20 +4817,20 @@ function nodeFunctionAppStartTarget(name) {
 function addNodeFunctionApp(workspaceRoot, name, stack, empty = false) {
   runNodeApp(workspaceRoot, name, stack, "none");
   ensureAzureFunctionsPackage(workspaceRoot);
-  const nodeFunctionAppRoot = (0, import_node_path17.join)(workspaceRoot, "apps", name);
-  writeFileEnsured((0, import_node_path17.join)(nodeFunctionAppRoot, "src/main.ts"), empty ? NODE_FUNCTION_APP_MAIN_EMPTY : NODE_FUNCTION_APP_MAIN);
+  const nodeFunctionAppRoot = (0, import_node_path18.join)(workspaceRoot, "apps", name);
+  writeFileEnsured((0, import_node_path18.join)(nodeFunctionAppRoot, "src/main.ts"), empty ? NODE_FUNCTION_APP_MAIN_EMPTY : NODE_FUNCTION_APP_MAIN);
   if (!empty) {
-    const slice = (0, import_node_path17.join)(nodeFunctionAppRoot, "src/hello");
-    writeFileEnsured((0, import_node_path17.join)(slice, "hello.handler.ts"), NODE_FUNCTION_APP_HELLO);
-    writeFileEnsured((0, import_node_path17.join)(slice, "greet.use-case.ts"), NODE_FUNCTION_APP_GREET_USE_CASE);
-    writeFileEnsured((0, import_node_path17.join)(slice, "greet.use-case.spec.ts"), NODE_FUNCTION_APP_GREET_SPEC);
-    writeFileEnsured((0, import_node_path17.join)(slice, "greeting.contract.ts"), NODE_FUNCTION_APP_GREETING_CONTRACT);
-    writeFileEnsured((0, import_node_path17.join)(slice, "index.ts"), NODE_FUNCTION_APP_HELLO_BARREL);
-  }
-  writeFileEnsured((0, import_node_path17.join)(nodeFunctionAppRoot, "host.json"), NODE_FUNCTION_APP_HOST_JSON);
+    const slice = (0, import_node_path18.join)(nodeFunctionAppRoot, "src/hello");
+    writeFileEnsured((0, import_node_path18.join)(slice, "hello.handler.ts"), NODE_FUNCTION_APP_HELLO);
+    writeFileEnsured((0, import_node_path18.join)(slice, "greet.use-case.ts"), NODE_FUNCTION_APP_GREET_USE_CASE);
+    writeFileEnsured((0, import_node_path18.join)(slice, "greet.use-case.spec.ts"), NODE_FUNCTION_APP_GREET_SPEC);
+    writeFileEnsured((0, import_node_path18.join)(slice, "greeting.contract.ts"), NODE_FUNCTION_APP_GREETING_CONTRACT);
+    writeFileEnsured((0, import_node_path18.join)(slice, "index.ts"), NODE_FUNCTION_APP_HELLO_BARREL);
+  }
+  writeFileEnsured((0, import_node_path18.join)(nodeFunctionAppRoot, "host.json"), NODE_FUNCTION_APP_HOST_JSON);
   repairNodeFunctionAppManifest(nodeFunctionAppRoot, workspaceRoot);
   ensureAdmZip(workspaceRoot);
-  addNxTargets((0, import_node_path17.join)(nodeFunctionAppRoot, "package.json"), {
+  addNxTargets((0, import_node_path18.join)(nodeFunctionAppRoot, "package.json"), {
     package: nodeFunctionAppPackageTarget(name),
     prune: nodeFunctionAppPruneTarget(name),
     start: nodeFunctionAppStartTarget(name),
@@ -4702,11 +4842,11 @@ function addNodeFunctionApp(workspaceRoot, name, stack, empty = false) {
 }
 
 // src/project-scaffolding/npm-lib.use-case.ts
-var import_node_path21 = require("path");
+var import_node_path22 = require("path");
 
 // src/rollup-library/repair-publishable-manifest.use-case.ts
-var import_node_fs17 = require("fs");
-var import_node_path18 = require("path");
+var import_node_fs19 = require("fs");
+var import_node_path19 = 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";
@@ -4729,14 +4869,14 @@ function repairPublishableManifest(manifestPath) {
 }
 function repairPublishableManifests(workspaceRoot) {
   const changed = [];
-  const manifests = (0, import_node_fs17.globSync)(["packages/*/package.json", "libs/*/package.json"], {
+  const manifests = (0, import_node_fs19.globSync)(["packages/*/package.json", "libs/*/package.json"], {
     cwd: workspaceRoot
   });
   for (const relativePath of manifests) {
-    const manifestPath = (0, import_node_path18.join)(workspaceRoot, relativePath);
-    const before = (0, import_node_fs17.readFileSync)(manifestPath, "utf8");
+    const manifestPath = (0, import_node_path19.join)(workspaceRoot, relativePath);
+    const before = (0, import_node_fs19.readFileSync)(manifestPath, "utf8");
     repairPublishableManifest(manifestPath);
-    const after = (0, import_node_fs17.readFileSync)(manifestPath, "utf8");
+    const after = (0, import_node_fs19.readFileSync)(manifestPath, "utf8");
     if (after !== before) {
       changed.push(relativePath.replaceAll("\\", "/"));
     }
@@ -4745,8 +4885,8 @@ function repairPublishableManifests(workspaceRoot) {
 }
 
 // src/rollup-library/repair-rollup-config.use-case.ts
-var import_node_fs18 = require("fs");
-var import_node_path19 = require("path");
+var import_node_fs20 = require("fs");
+var import_node_path20 = require("path");
 
 // src/rollup-library/rollup-config.algorithm.ts
 var ROLLUP_CONFIG_PLACEHOLDER = [
@@ -4948,12 +5088,12 @@ function withUpgradedDeclarationSpecifierPlugin(config) {
 // src/rollup-library/repair-rollup-config.use-case.ts
 function repairRollupSourceMaps(workspaceRoot) {
   const changed = [];
-  const configs = (0, import_node_fs18.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs20.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   });
   for (const relativePath of configs) {
-    const configPath = (0, import_node_path19.join)(workspaceRoot, relativePath);
-    const before = (0, import_node_fs18.readFileSync)(configPath, "utf8");
+    const configPath = (0, import_node_path20.join)(workspaceRoot, relativePath);
+    const before = (0, import_node_fs20.readFileSync)(configPath, "utf8");
     const after = withRollupSourceMaps(before);
     if (after !== before) {
       writeFileEnsured(configPath, after);
@@ -4964,12 +5104,12 @@ function repairRollupSourceMaps(workspaceRoot) {
 }
 function upgradeDeclarationSpecifierPlugins(workspaceRoot) {
   const changed = [];
-  const configs = (0, import_node_fs18.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs20.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   });
   for (const relativePath of configs) {
-    const configPath = (0, import_node_path19.join)(workspaceRoot, relativePath);
-    const before = (0, import_node_fs18.readFileSync)(configPath, "utf8");
+    const configPath = (0, import_node_path20.join)(workspaceRoot, relativePath);
+    const before = (0, import_node_fs20.readFileSync)(configPath, "utf8");
     const after = withUpgradedDeclarationSpecifierPlugin(before);
     if (after !== before) {
       writeFileEnsured(configPath, after);
@@ -4979,11 +5119,11 @@ function upgradeDeclarationSpecifierPlugins(workspaceRoot) {
   return changed;
 }
 function repairDeclarationSpecifiers(projectRoot) {
-  const configPath = (0, import_node_path19.join)(projectRoot, "rollup.config.cjs");
+  const configPath = (0, import_node_path20.join)(projectRoot, "rollup.config.cjs");
   if (!fileExists(configPath)) {
     return;
   }
-  const config = (0, import_node_fs18.readFileSync)(configPath, "utf8");
+  const config = (0, import_node_fs20.readFileSync)(configPath, "utf8");
   if (!config.includes(ROLLUP_CONFIG_PLACEHOLDER)) {
     return;
   }
@@ -4992,10 +5132,10 @@ function repairDeclarationSpecifiers(projectRoot) {
 }
 
 // src/rollup-library/rollup-config.repository.ts
-var import_node_fs19 = require("fs");
-var import_node_path20 = require("path");
+var import_node_fs21 = require("fs");
+var import_node_path21 = require("path");
 function resolveRequireTarget(fromDir, specifier) {
-  const base = (0, import_node_path20.join)(fromDir, specifier);
+  const base = (0, import_node_path21.join)(fromDir, specifier);
   return [base, `${base}.cjs`, `${base}.js`].find((candidate) => fileExists(candidate));
 }
 function resolveRollupConfigText(configPath, visited = /* @__PURE__ */ new Set()) {
@@ -5005,7 +5145,7 @@ function resolveRollupConfigText(configPath, visited = /* @__PURE__ */ new Set()
   visited.add(configPath);
   let text;
   try {
-    text = (0, import_node_fs19.readFileSync)(configPath, "utf8");
+    text = (0, import_node_fs21.readFileSync)(configPath, "utf8");
   } catch {
     return "";
   }
@@ -5013,15 +5153,15 @@ function resolveRollupConfigText(configPath, visited = /* @__PURE__ */ new Set()
     text.matchAll(/require\((['"])(\.[^'"]*)\1\)/g),
     (match) => match[2]
   );
-  const requiredText = specifiers.map((specifier) => resolveRequireTarget((0, import_node_path20.dirname)(configPath), specifier)).filter((target) => target !== void 0).map((target) => resolveRollupConfigText(target, visited));
+  const requiredText = specifiers.map((specifier) => resolveRequireTarget((0, import_node_path21.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_path21.join)(workspaceRoot, "packages", name);
-  const manifestPath = (0, import_node_path21.join)(projectRoot, "package.json");
+  const projectRoot = (0, import_node_path22.join)(workspaceRoot, "packages", name);
+  const manifestPath = (0, import_node_path22.join)(projectRoot, "package.json");
   runGeneratorAndRepair(
     workspaceRoot,
     [
@@ -5050,8 +5190,8 @@ async function addNpmLib(workspaceRoot, name, options, kindProvided, stack) {
 }
 
 // src/project-scaffolding/python.use-case.ts
-var import_node_fs20 = require("fs");
-var import_node_path22 = require("path");
+var import_node_fs22 = require("fs");
+var import_node_path23 = require("path");
 function ensurePython(workspaceRoot) {
   const hasPython = runShell("python3", ["--version"], workspaceRoot) === 0 || runShell("python", ["--version"], workspaceRoot) === 0;
   if (!hasPython) {
@@ -5074,7 +5214,7 @@ function ensurePythonPipPlugin(workspaceRoot) {
   registerPythonGraphPlugin(workspaceRoot);
 }
 function registerPythonGraphPlugin(workspaceRoot) {
-  const nxJsonPath = (0, import_node_path22.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path23.join)(workspaceRoot, "nx.json");
   if (!fileExists(nxJsonPath)) {
     return;
   }
@@ -5097,7 +5237,7 @@ pytest
 pip-audit
 `;
 function ensureRequirementsDev(workspaceRoot) {
-  const requirementsDevPath = (0, import_node_path22.join)(workspaceRoot, "requirements-dev.txt");
+  const requirementsDevPath = (0, import_node_path23.join)(workspaceRoot, "requirements-dev.txt");
   if (!fileExists(requirementsDevPath)) {
     writeFileEnsured(requirementsDevPath, PYTHON_REQUIREMENTS_DEV);
   }
@@ -5157,8 +5297,8 @@ function addPythonApp(workspaceRoot, name) {
     ["g", "@mnci/nx-python-pip:application", name, `--directory=apps/${name}`, "--no-interactive"],
     workspaceRoot
   );
-  writeFileEnsured((0, import_node_path22.join)(workspaceRoot, "apps", name, "main.py"), pythonAppMain(name));
-  addProjectJsonTargets((0, import_node_path22.join)(workspaceRoot, "apps", name, "project.json"), {
+  writeFileEnsured((0, import_node_path23.join)(workspaceRoot, "apps", name, "main.py"), pythonAppMain(name));
+  addProjectJsonTargets((0, import_node_path23.join)(workspaceRoot, "apps", name, "project.json"), {
     package: pythonAppPackageTarget(name),
     start: pythonAppStartTarget(name)
   });
@@ -5180,7 +5320,7 @@ function addPythonFunctionApp(workspaceRoot, name) {
     workspaceRoot
   );
   const moduleDirectory = pythonModuleDirectory(name);
-  addProjectJsonTargets((0, import_node_path22.join)(workspaceRoot, "apps", name, "project.json"), {
+  addProjectJsonTargets((0, import_node_path23.join)(workspaceRoot, "apps", name, "project.json"), {
     package: pythonFunctionAppPackageTarget(name, moduleDirectory),
     start: pythonFunctionAppStartTarget(name)
   });
@@ -5221,7 +5361,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_path22.join)(workspaceRoot, directory, name, "pyproject.toml"))
+    (directory) => fileExists((0, import_node_path23.join)(workspaceRoot, directory, name, "pyproject.toml"))
   );
 }
 function parseVendorEntries(pyprojectToml) {
@@ -5260,7 +5400,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_path22.join)(workspaceRoot, "libs", lib, "pyproject.toml"))) {
+  if (!fileExists((0, import_node_path23.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.`
     );
@@ -5268,8 +5408,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_path22.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
-  const pyprojectToml = (0, import_node_fs20.readFileSync)(pyprojectPath, "utf8");
+  const pyprojectPath = (0, import_node_path23.join)(workspaceRoot, consumerDirectory, consumer, "pyproject.toml");
+  const pyprojectToml = (0, import_node_fs22.readFileSync)(pyprojectPath, "utf8");
   if (parseVendorEntries(pyprojectToml).includes(lib)) {
     logger.info(`'${consumer}' already vendors '${lib}' \u2014 nothing to do.`);
     return;
@@ -5281,8 +5421,8 @@ async function addPythonVendor(workspaceRoot, consumer, options, kindProvided) {
 }
 
 // src/project-scaffolding/react-app.use-case.ts
-var import_node_fs21 = require("fs");
-var import_node_path23 = require("path");
+var import_node_fs23 = require("fs");
+var import_node_path24 = require("path");
 
 // src/project-scaffolding/react-app-example.algorithm.ts
 function reactAppExampleFiles(name) {
@@ -5399,12 +5539,12 @@ function reactAppTargets(name) {
   return targets;
 }
 function allowEnvFiles(workspaceRoot) {
-  const gitignorePath = (0, import_node_path23.join)(workspaceRoot, ".gitignore");
+  const gitignorePath = (0, import_node_path24.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_fs21.readFileSync)(gitignorePath, "utf8");
+  const current = (0, import_node_fs23.readFileSync)(gitignorePath, "utf8");
   if (current.includes(marker)) {
     return;
   }
@@ -5431,30 +5571,30 @@ function addReactApp(workspaceRoot, name, stack) {
     workspaceRoot
   );
   ensureAdmZip(workspaceRoot);
-  const reactAppRoot = (0, import_node_path23.join)(workspaceRoot, "apps", name);
+  const reactAppRoot = (0, import_node_path24.join)(workspaceRoot, "apps", name);
   for (const environment of REACT_ENVIRONMENTS) {
-    writeFileEnsured((0, import_node_path23.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
+    writeFileEnsured((0, import_node_path24.join)(reactAppRoot, `.env.${environment}`), reactEnvironmentFile(environment));
   }
   allowEnvFiles(workspaceRoot);
-  addNxTargets((0, import_node_path23.join)(reactAppRoot, "package.json"), reactAppTargets(name));
+  addNxTargets((0, import_node_path24.join)(reactAppRoot, "package.json"), reactAppTargets(name));
   reshapeReactAppScaffold(reactAppRoot);
-  (0, import_node_fs21.rmSync)((0, import_node_path23.join)(reactAppRoot, "src/app/nx-welcome.component.tsx"), { force: true });
+  (0, import_node_fs23.rmSync)((0, import_node_path24.join)(reactAppRoot, "src/app/nx-welcome.component.tsx"), { force: true });
   const example = reactAppExampleFiles(name);
   for (const [relative, contents] of Object.entries(example)) {
-    writeFileEnsured((0, import_node_path23.join)(reactAppRoot, "src", relative), contents);
+    writeFileEnsured((0, import_node_path24.join)(reactAppRoot, "src", relative), contents);
   }
   removeGeneratedEslintConfig(workspaceRoot, `apps/${name}`);
   registerProjectCommands(workspaceRoot, name, { build: true, start: `nx run ${name}:serve` });
 }
 
 // src/project-scaffolding/react-lib.use-case.ts
-var import_node_path24 = require("path");
+var import_node_path25 = 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_path24.join)(workspaceRoot, "packages", name);
-  const publishableManifest = (0, import_node_path24.join)(projectRoot, "package.json");
+  const projectRoot = (0, import_node_path25.join)(workspaceRoot, "packages", name);
+  const publishableManifest = (0, import_node_path25.join)(projectRoot, "package.json");
   runGeneratorAndRepair(
     workspaceRoot,
     [
@@ -5484,8 +5624,8 @@ async function addReactLib(workspaceRoot, name, options, kindProvided, stack) {
 }
 function addReactInternalLib(workspaceRoot, name, stack, empty = false) {
   ensurePlugin(workspaceRoot, "@nx/react");
-  const projectRoot = (0, import_node_path24.join)(workspaceRoot, "libs", name);
-  const privateManifest = (0, import_node_path24.join)(projectRoot, "package.json");
+  const projectRoot = (0, import_node_path25.join)(workspaceRoot, "libs", name);
+  const privateManifest = (0, import_node_path25.join)(projectRoot, "package.json");
   runGeneratorAndRepair(
     workspaceRoot,
     [
@@ -5512,8 +5652,8 @@ function addReactInternalLib(workspaceRoot, name, stack, empty = false) {
 }
 
 // src/project-scaffolding/vscode-extension.use-case.ts
-var import_node_fs22 = require("fs");
-var import_node_path25 = require("path");
+var import_node_fs24 = require("fs");
+var import_node_path26 = require("path");
 var VSCODE_EXTENSION_SCRIPT_PATH = "tools/vscode-extension.cjs";
 var VSCODE_ENGINE_FLOOR = "1.96.0";
 var VSCODE_SIDECAR_TARGETS = {
@@ -5698,8 +5838,8 @@ export const window = {
 var VSCODE_STUB_PATH = "test/vscode.stub.ts";
 function mapVscodeToStub(projectRoot, testRunner) {
   const [file, anchor, mapping] = testRunner === "jest" ? ["jest.config.cts", "testEnvironment: 'node',", `moduleNameMapper: { '^vscode$': '<rootDir>/${VSCODE_STUB_PATH}' },`] : ["vitest.config.mts", "environment: 'node',", `alias: { vscode: \`\${import.meta.dirname}/${VSCODE_STUB_PATH}\` },`];
-  const path = (0, import_node_path25.join)(projectRoot, file);
-  const content = fileExists(path) ? (0, import_node_fs22.readFileSync)(path, "utf8") : "";
+  const path = (0, import_node_path26.join)(projectRoot, file);
+  const content = fileExists(path) ? (0, import_node_fs24.readFileSync)(path, "utf8") : "";
   const line = content.split("\n").find((candidate) => candidate.trim() === anchor);
   if (line === void 0) {
     throw new Error(`${file} has no "${anchor}" line to map the vscode module after; map 'vscode' to ${VSCODE_STUB_PATH} by hand.`);
@@ -5719,11 +5859,11 @@ function ensureVscodeToolchain(workspaceRoot) {
   }
 }
 function defaultPublisher(workspaceRoot) {
-  const { name } = readJson((0, import_node_path25.join)(workspaceRoot, "package.json"));
+  const { name } = readJson((0, import_node_path26.join)(workspaceRoot, "package.json"));
   return (name ?? "publisher").replace(/^@/, "").split("/", 1)[0];
 }
 function reshapeManifest(projectRoot, name, publisher) {
-  const manifestPath = (0, import_node_path25.join)(projectRoot, "package.json");
+  const manifestPath = (0, import_node_path26.join)(projectRoot, "package.json");
   const manifest = readJson(manifestPath);
   const { nx = {}, ...rest } = manifest;
   const targets = { ...nx.targets };
@@ -5787,11 +5927,11 @@ function vscodeExtensionPublishTarget(name, sidecar) {
   };
 }
 function addDebugLaunch(workspaceRoot, name) {
-  const file = (0, import_node_fs22.readdirSync)(workspaceRoot).find((entry) => entry.endsWith(".code-workspace"));
+  const file = (0, import_node_fs24.readdirSync)(workspaceRoot).find((entry) => entry.endsWith(".code-workspace"));
   if (file === void 0) {
     return;
   }
-  const path = (0, import_node_path25.join)(workspaceRoot, file);
+  const path = (0, import_node_path26.join)(workspaceRoot, file);
   const workspace = readCodeWorkspace(path) ?? {};
   const folder = `\${workspaceFolder:${workspace.folders?.[0]?.name ?? file.replace(/\.code-workspace$/, "")}}`;
   const taskLabel = `${name}: build (development)`;
@@ -5824,39 +5964,39 @@ function addDebugLaunch(workspaceRoot, name) {
   );
 }
 function refreshVscodeExtensionScript(workspaceRoot) {
-  const apps = (0, import_node_path25.join)(workspaceRoot, "apps");
+  const apps = (0, import_node_path26.join)(workspaceRoot, "apps");
   let entries;
   try {
-    entries = (0, import_node_fs22.readdirSync)(apps);
+    entries = (0, import_node_fs24.readdirSync)(apps);
   } catch {
     return false;
   }
   const hasExtension = entries.some((entry) => {
-    const manifestPath = (0, import_node_path25.join)(apps, entry, "package.json");
+    const manifestPath = (0, import_node_path26.join)(apps, entry, "package.json");
     if (!fileExists(manifestPath)) {
       return false;
     }
     const tags = readJson(manifestPath).nx?.tags ?? [];
     return tags.includes(VSCODE_EXTENSION_TAG);
   });
-  const path = (0, import_node_path25.join)(workspaceRoot, VSCODE_EXTENSION_SCRIPT_PATH);
-  if (!hasExtension || fileExists(path) && (0, import_node_fs22.readFileSync)(path, "utf8") === VSCODE_EXTENSION_SCRIPT) {
+  const path = (0, import_node_path26.join)(workspaceRoot, VSCODE_EXTENSION_SCRIPT_PATH);
+  if (!hasExtension || fileExists(path) && (0, import_node_fs24.readFileSync)(path, "utf8") === VSCODE_EXTENSION_SCRIPT) {
     return false;
   }
   writeFileEnsured(path, VSCODE_EXTENSION_SCRIPT);
   return true;
 }
 function pinVscodeExtensionProjectNames(workspaceRoot) {
-  const apps = (0, import_node_path25.join)(workspaceRoot, "apps");
+  const apps = (0, import_node_path26.join)(workspaceRoot, "apps");
   let entries;
   try {
-    entries = (0, import_node_fs22.readdirSync)(apps);
+    entries = (0, import_node_fs24.readdirSync)(apps);
   } catch {
     return [];
   }
   const updated = [];
   for (const entry of entries) {
-    const manifestPath = (0, import_node_path25.join)(apps, entry, "package.json");
+    const manifestPath = (0, import_node_path26.join)(apps, entry, "package.json");
     if (!fileExists(manifestPath)) {
       continue;
     }
@@ -5876,22 +6016,22 @@ function refreshLockFile(workspaceRoot, name) {
 }
 function addVscodeExtension(workspaceRoot, name, stack, options = {}) {
   const { sidecar } = options;
-  if (sidecar !== void 0 && !fileExists((0, import_node_path25.join)(workspaceRoot, "apps", sidecar, "project.json"))) {
+  if (sidecar !== void 0 && !fileExists((0, import_node_path26.join)(workspaceRoot, "apps", sidecar, "project.json"))) {
     throw new Error(`--sidecar ${sidecar}: no Go app at apps/${sidecar}. Add it first with \`mnci add go-app ${sidecar}\`.`);
   }
   runNodeApp(workspaceRoot, name, stack, "none");
   ensureVscodeToolchain(workspaceRoot);
-  const projectRoot = (0, import_node_path25.join)(workspaceRoot, "apps", name);
+  const projectRoot = (0, import_node_path26.join)(workspaceRoot, "apps", name);
   reshapeManifest(projectRoot, name, options.publisher ?? defaultPublisher(workspaceRoot));
-  addVscodeTypes((0, import_node_path25.join)(projectRoot, "tsconfig.app.json"));
-  addVscodeTypes((0, import_node_path25.join)(projectRoot, "tsconfig.spec.json"));
-  writeFileEnsured((0, import_node_path25.join)(projectRoot, "src/main.ts"), vscodeExtensionMain(name));
-  writeFileEnsured((0, import_node_path25.join)(projectRoot, "src/main.spec.ts"), vscodeExtensionMainSpec(name));
-  writeFileEnsured((0, import_node_path25.join)(projectRoot, VSCODE_STUB_PATH), VSCODE_STUB);
+  addVscodeTypes((0, import_node_path26.join)(projectRoot, "tsconfig.app.json"));
+  addVscodeTypes((0, import_node_path26.join)(projectRoot, "tsconfig.spec.json"));
+  writeFileEnsured((0, import_node_path26.join)(projectRoot, "src/main.ts"), vscodeExtensionMain(name));
+  writeFileEnsured((0, import_node_path26.join)(projectRoot, "src/main.spec.ts"), vscodeExtensionMainSpec(name));
+  writeFileEnsured((0, import_node_path26.join)(projectRoot, VSCODE_STUB_PATH), VSCODE_STUB);
   mapVscodeToStub(projectRoot, stack.testRunner);
-  writeFileEnsured((0, import_node_path25.join)(projectRoot, ".vscodeignore"), VSCODE_IGNORE);
-  writeFileEnsured((0, import_node_path25.join)(workspaceRoot, VSCODE_EXTENSION_SCRIPT_PATH), VSCODE_EXTENSION_SCRIPT);
-  addNxTargets((0, import_node_path25.join)(projectRoot, "package.json"), {
+  writeFileEnsured((0, import_node_path26.join)(projectRoot, ".vscodeignore"), VSCODE_IGNORE);
+  writeFileEnsured((0, import_node_path26.join)(workspaceRoot, VSCODE_EXTENSION_SCRIPT_PATH), VSCODE_EXTENSION_SCRIPT);
+  addNxTargets((0, import_node_path26.join)(projectRoot, "package.json"), {
     "package": vscodeExtensionPackageTarget(name, sidecar),
     "nx-release-publish": vscodeExtensionPublishTarget(name, sidecar)
   });
@@ -5902,12 +6042,12 @@ function addVscodeExtension(workspaceRoot, name, stack, options = {}) {
 }
 
 // src/dependency-management/install-dependencies.use-case.ts
-var import_node_fs24 = require("fs");
-var import_node_path27 = require("path");
+var import_node_fs26 = require("fs");
+var import_node_path28 = require("path");
 
 // src/dependency-management/manifest.repository.ts
-var import_node_fs23 = require("fs");
-var import_node_path26 = require("path");
+var import_node_fs25 = require("fs");
+var import_node_path27 = require("path");
 var ECOSYSTEMS = ["npm", "pip", "pub", "nuget", "go"];
 var ROOT_LABEL = "(root)";
 var MANIFEST_GLOBS = {
@@ -5940,23 +6080,23 @@ function projectOf(manifestRelativePath) {
 }
 function hasEcosystem(workspaceRoot, ecosystem) {
   if (ecosystem === "go") {
-    return fileExists((0, import_node_path26.join)(workspaceRoot, "go.mod"));
+    return fileExists((0, import_node_path27.join)(workspaceRoot, "go.mod"));
   }
   if (ecosystem === "nuget") {
-    return (0, import_node_fs23.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot }).length > 0;
+    return (0, import_node_fs25.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_path26.join)(workspaceRoot, rootMarker[ecosystem])) || (0, import_node_fs23.globSync)(MANIFEST_GLOBS[ecosystem], { cwd: workspaceRoot }).length > 0;
+  return fileExists((0, import_node_path27.join)(workspaceRoot, rootMarker[ecosystem])) || (0, import_node_fs25.globSync)(MANIFEST_GLOBS[ecosystem], { cwd: workspaceRoot }).length > 0;
 }
 function collectNpm(workspaceRoot) {
   const sites = [];
-  const relativePaths = ["package.json", ...(0, import_node_fs23.globSync)(MANIFEST_GLOBS.npm, { cwd: workspaceRoot })];
+  const relativePaths = ["package.json", ...(0, import_node_fs25.globSync)(MANIFEST_GLOBS.npm, { cwd: workspaceRoot })];
   for (const relativePath of relativePaths) {
-    const manifestPath = (0, import_node_path26.join)(workspaceRoot, relativePath);
+    const manifestPath = (0, import_node_path27.join)(workspaceRoot, relativePath);
     try {
       const manifest = readJson(manifestPath);
       sites.push(...npmManifestSites(manifest, relativePath, manifestPath));
@@ -6017,17 +6157,17 @@ function collectPip(workspaceRoot) {
       name: parsed.name,
       ecosystem: "pip",
       project: projectOf(relativePath),
-      manifestPath: (0, import_node_path26.join)(workspaceRoot, relativePath),
+      manifestPath: (0, import_node_path27.join)(workspaceRoot, relativePath),
       section,
       spec: parsed.spec,
       rewritable: parsed.rewritable && parsed.spec !== ""
     });
   };
-  const pyprojectPaths = (0, import_node_fs23.globSync)(MANIFEST_GLOBS.pip, { cwd: workspaceRoot });
+  const pyprojectPaths = (0, import_node_fs25.globSync)(MANIFEST_GLOBS.pip, { cwd: workspaceRoot });
   for (const relativePath of pyprojectPaths) {
     let content;
     try {
-      content = (0, import_node_fs23.readFileSync)((0, import_node_path26.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs25.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -6038,14 +6178,14 @@ function collectPip(workspaceRoot) {
   }
   const requirementsPaths = [
     "requirements-dev.txt",
-    ...(0, import_node_fs23.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot })
+    ...(0, import_node_fs25.globSync)("apps/*/requirements.txt", { cwd: workspaceRoot })
   ];
   for (const relativePath of requirementsPaths) {
-    if (!fileExists((0, import_node_path26.join)(workspaceRoot, relativePath))) {
+    if (!fileExists((0, import_node_path27.join)(workspaceRoot, relativePath))) {
       continue;
     }
     const section = relativePath === "requirements-dev.txt" ? "devDep" : "dep";
-    const lines = (0, import_node_fs23.readFileSync)((0, import_node_path26.join)(workspaceRoot, relativePath), "utf8").split(/\r?\n/);
+    const lines = (0, import_node_fs25.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8").split(/\r?\n/);
     for (const line of lines) {
       push(relativePath, section, line);
     }
@@ -6083,11 +6223,11 @@ function pyprojectDependencies(content) {
 }
 function collectPub(workspaceRoot) {
   const sites = [];
-  const pubspecPaths = (0, import_node_fs23.globSync)(MANIFEST_GLOBS.pub, { cwd: workspaceRoot });
+  const pubspecPaths = (0, import_node_fs25.globSync)(MANIFEST_GLOBS.pub, { cwd: workspaceRoot });
   for (const relativePath of pubspecPaths) {
     let content;
     try {
-      content = (0, import_node_fs23.readFileSync)((0, import_node_path26.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs25.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -6097,7 +6237,7 @@ function collectPub(workspaceRoot) {
           name: entry.name,
           ecosystem: "pub",
           project: projectOf(relativePath),
-          manifestPath: (0, import_node_path26.join)(workspaceRoot, relativePath),
+          manifestPath: (0, import_node_path27.join)(workspaceRoot, relativePath),
           section: block === "dependencies" ? "dep" : "devDep",
           spec: entry.spec,
           rewritable: entry.spec !== ""
@@ -6147,11 +6287,11 @@ function stripQuotes(value) {
 }
 function collectNuget(workspaceRoot) {
   const sites = [];
-  const csprojPaths = (0, import_node_fs23.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot });
+  const csprojPaths = (0, import_node_fs25.globSync)(MANIFEST_GLOBS.nuget, { cwd: workspaceRoot });
   for (const relativePath of csprojPaths) {
     let content;
     try {
-      content = (0, import_node_fs23.readFileSync)((0, import_node_path26.join)(workspaceRoot, relativePath), "utf8");
+      content = (0, import_node_fs25.readFileSync)((0, import_node_path27.join)(workspaceRoot, relativePath), "utf8");
     } catch {
       continue;
     }
@@ -6160,7 +6300,7 @@ function collectNuget(workspaceRoot) {
         name: entry.name,
         ecosystem: "nuget",
         project: projectOf(relativePath),
-        manifestPath: (0, import_node_path26.join)(workspaceRoot, relativePath),
+        manifestPath: (0, import_node_path27.join)(workspaceRoot, relativePath),
         section: "dep",
         spec: entry.spec,
         // A plain SemVer string is rewritable; an MSBuild property reference
@@ -6185,13 +6325,13 @@ function csprojPackageReferences(content) {
   return entries;
 }
 function collectGo(workspaceRoot) {
-  const manifestPath = (0, import_node_path26.join)(workspaceRoot, "go.mod");
+  const manifestPath = (0, import_node_path27.join)(workspaceRoot, "go.mod");
   if (!fileExists(manifestPath)) {
     return [];
   }
   let content;
   try {
-    content = (0, import_node_fs23.readFileSync)(manifestPath, "utf8");
+    content = (0, import_node_fs25.readFileSync)(manifestPath, "utf8");
   } catch {
     return [];
   }
@@ -6240,7 +6380,7 @@ var PROJECT_GLOBS = {
 function locateProjects(workspaceRoot) {
   const locations = [];
   for (const ecosystem of ECOSYSTEMS) {
-    const relativePaths = (0, import_node_fs23.globSync)(PROJECT_GLOBS[ecosystem], { cwd: workspaceRoot });
+    const relativePaths = (0, import_node_fs25.globSync)(PROJECT_GLOBS[ecosystem], { cwd: workspaceRoot });
     for (const relativePath of relativePaths) {
       const posix = toPosix(relativePath);
       const dir = posix.slice(0, posix.lastIndexOf("/"));
@@ -6248,7 +6388,7 @@ function locateProjects(workspaceRoot) {
         ecosystem,
         dir,
         name: dir.slice(dir.lastIndexOf("/") + 1),
-        manifestPath: (0, import_node_path26.join)(workspaceRoot, relativePath)
+        manifestPath: (0, import_node_path27.join)(workspaceRoot, relativePath)
       });
     }
   }
@@ -6269,7 +6409,7 @@ function rewriteSpec(site, spec) {
     writeFileEnsured(site.manifestPath, toJson(manifest));
     return true;
   }
-  const before = (0, import_node_fs23.readFileSync)(site.manifestPath, "utf8");
+  const before = (0, import_node_fs25.readFileSync)(site.manifestPath, "utf8");
   const after = (() => {
     switch (site.ecosystem) {
       case "pip": {
@@ -6360,13 +6500,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_path26.join)(workspaceRoot, directory, short ?? name, "package.json"))
+    (directory) => fileExists((0, import_node_path27.join)(workspaceRoot, directory, short ?? name, "package.json"))
   );
 }
 function isAliasedInstall(workspaceRoot, name) {
   try {
     const installed = readJson(
-      (0, import_node_path26.join)(workspaceRoot, "node_modules", name, "package.json")
+      (0, import_node_path27.join)(workspaceRoot, "node_modules", name, "package.json")
     );
     return installed.name !== void 0 && installed.name !== name;
   } catch {
@@ -6377,14 +6517,14 @@ function resolvedVersion(workspaceRoot, ecosystem, name) {
   if (ecosystem === "npm") {
     try {
       return readJson(
-        (0, import_node_path26.join)(workspaceRoot, "node_modules", name, "package.json")
+        (0, import_node_path27.join)(workspaceRoot, "node_modules", name, "package.json")
       ).version;
     } catch {
       return void 0;
     }
   }
   if (ecosystem === "pub") {
-    const lockPath = (0, import_node_path26.join)(workspaceRoot, "pubspec.lock");
+    const lockPath = (0, import_node_path27.join)(workspaceRoot, "pubspec.lock");
     if (!fileExists(lockPath)) {
       return void 0;
     }
@@ -6392,7 +6532,7 @@ function resolvedVersion(workspaceRoot, ecosystem, name) {
       const match = new RegExp(
         String.raw`^\s{2}${escapeForRegex(name)}:[^]*?^\s+version:\s*["']?([^"'\s]+)`,
         "m"
-      ).exec((0, import_node_fs23.readFileSync)(lockPath, "utf8"));
+      ).exec((0, import_node_fs25.readFileSync)(lockPath, "utf8"));
       return match?.[1];
     } catch {
       return void 0;
@@ -6458,7 +6598,7 @@ function resolveTarget(locations, target) {
   return byName[0];
 }
 function installInto(workspaceRoot, location, packages, saveDev) {
-  const projectDir = (0, import_node_path27.join)(workspaceRoot, location.dir);
+  const projectDir = (0, import_node_path28.join)(workspaceRoot, location.dir);
   switch (location.ecosystem) {
     case "npm": {
       const flags = saveDev ? ["--save-dev"] : [];
@@ -6511,7 +6651,7 @@ function installInto(workspaceRoot, location, packages, saveDev) {
 function addPythonDependency(manifestPath, specifier) {
   let content;
   try {
-    content = (0, import_node_fs24.readFileSync)(manifestPath, "utf8");
+    content = (0, import_node_fs26.readFileSync)(manifestPath, "utf8");
   } catch {
     logger.warn(`Could not read ${manifestPath} \u2014 skipped ${specifier}`);
     return;
@@ -6540,7 +6680,7 @@ function installEverything(workspaceRoot, only) {
 }
 function ecosystemPresent(workspaceRoot, ecosystem) {
   if (ecosystem === "go") {
-    return fileExists((0, import_node_path27.join)(workspaceRoot, "go.work")) || fileExists((0, import_node_path27.join)(workspaceRoot, "go.mod"));
+    return fileExists((0, import_node_path28.join)(workspaceRoot, "go.work")) || fileExists((0, import_node_path28.join)(workspaceRoot, "go.mod"));
   }
   return hasEcosystem(workspaceRoot, ecosystem);
 }
@@ -6559,7 +6699,7 @@ function splitAtLast(value, separator) {
 }
 
 // src/dependency-management/sync-dependencies.use-case.ts
-var import_node_path28 = require("path");
+var import_node_path29 = require("path");
 
 // src/dependency-management/semver.algorithm.ts
 var UPDATE_KINDS = ["patch", "minor", "major", "non-semver"];
@@ -6736,7 +6876,7 @@ function describe(finding) {
   return `${finding.name} \u2192 ${finding.target} (${finding.reason}); disagreeing: ${sites}`;
 }
 function runSync(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path28.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path29.join)(workspaceRoot, "nx.json"))) {
     throw new Error(
       `No nx.json found in ${workspaceRoot} \u2014 run 'mnci sync' from the workspace root.`
     );
@@ -6786,7 +6926,7 @@ function runSync(workspaceRoot, options) {
 }
 
 // src/dependency-management/update-dependencies.use-case.ts
-var import_node_path29 = require("path");
+var import_node_path30 = require("path");
 var import_prompts2 = require("@inquirer/prompts");
 
 // src/dependency-management/registry.client.ts
@@ -7069,7 +7209,7 @@ function reinstall(workspaceRoot, ecosystems) {
 function hasPythonInstallScript(workspaceRoot) {
   try {
     const manifest = readJson(
-      (0, import_node_path29.join)(workspaceRoot, "package.json")
+      (0, import_node_path30.join)(workspaceRoot, "package.json")
     );
     return manifest.scripts?.["python:install"] !== void 0;
   } catch {
@@ -7085,7 +7225,7 @@ function applyGoUpdates(workspaceRoot, entries) {
   }
 }
 async function runUp(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path29.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path30.join)(workspaceRoot, "nx.json"))) {
     throw new Error(`No nx.json found in ${workspaceRoot} \u2014 run 'mnci up' from the workspace root.`);
   }
   const ecosystems = resolveEcosystems(options.ecosystem);
@@ -7162,7 +7302,7 @@ var PROJECT_KINDS = [
 var EMPTY_KINDS = /* @__PURE__ */ new Set(["npm-lib", "internal-lib", "react-lib", "react-internal-lib", "node-function-app"]);
 async function runAdd(kind, name, options) {
   const workspaceRoot = process.cwd();
-  if (!fileExists((0, import_node_path30.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path31.join)(workspaceRoot, "nx.json"))) {
     throw new Error("No nx.json found here. Run `add` from the workspace root.");
   }
   const stack = readWorkspaceStack(workspaceRoot);
@@ -7225,8 +7365,8 @@ async function runAdd(kind, name, options) {
         ],
         workspaceRoot
       );
-      markPrivate((0, import_node_path30.join)(workspaceRoot, "libs", resolvedName, "package.json"));
-      renameScaffoldPlaceholder((0, import_node_path30.join)(workspaceRoot, "libs", resolvedName), resolvedName, options.empty === true);
+      markPrivate((0, import_node_path31.join)(workspaceRoot, "libs", resolvedName, "package.json"));
+      renameScaffoldPlaceholder((0, import_node_path31.join)(workspaceRoot, "libs", resolvedName), resolvedName, options.empty === true);
       removeGeneratedEslintConfig(workspaceRoot, `libs/${resolvedName}`);
       registerProjectCommands(workspaceRoot, resolvedName, { build: true });
       break;
@@ -7318,7 +7458,7 @@ async function runAdd(kind, name, options) {
 }
 function readWorkspaceStack(workspaceRoot) {
   const nxJson = readJson(
-    (0, import_node_path30.join)(workspaceRoot, "nx.json")
+    (0, import_node_path31.join)(workspaceRoot, "nx.json")
   );
   const stack = nxJson.mnci?.stack;
   return {
@@ -7367,15 +7507,15 @@ function runKinds(options) {
 
 // src/workspace-diagnostics/check-invariants.use-case.ts
 var import_node_child_process = require("child_process");
-var import_node_fs25 = require("fs");
-var import_node_path31 = require("path");
+var import_node_fs27 = require("fs");
+var import_node_path32 = 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_fs25.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
-  const projectConfigs = (0, import_node_fs25.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
+  const rootConfigs = (0, import_node_fs27.globSync)("eslint.config.{js,mjs,cjs,ts,mts,cts}", { cwd: workspaceRoot });
+  const projectConfigs = (0, import_node_fs27.globSync)("{apps,libs,packages}/*/eslint.config.{js,mjs,cjs,ts,mts,cts}", {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return [
@@ -7395,10 +7535,10 @@ function checkEslintConfigs(workspaceRoot) {
   ];
 }
 function checkEslintEntryPointReachesTheRules(workspaceRoot) {
-  const rules = (0, import_node_path31.join)(workspaceRoot, ESLINT_MNCI_FILENAME);
-  if (!(0, import_node_fs25.existsSync)(rules)) return [];
-  const entryPoint = (0, import_node_path31.join)(workspaceRoot, ESLINT_USER_FILENAME);
-  const source = (0, import_node_fs25.existsSync)(entryPoint) ? (0, import_node_fs25.readFileSync)(entryPoint, "utf8") : "";
+  const rules = (0, import_node_path32.join)(workspaceRoot, ESLINT_MNCI_FILENAME);
+  if (!(0, import_node_fs27.existsSync)(rules)) return [];
+  const entryPoint = (0, import_node_path32.join)(workspaceRoot, ESLINT_USER_FILENAME);
+  const source = (0, import_node_fs27.existsSync)(entryPoint) ? (0, import_node_fs27.readFileSync)(entryPoint, "utf8") : "";
   return [
     {
       check: `${ESLINT_USER_FILENAME} imports the mnci rules`,
@@ -7411,7 +7551,7 @@ function checkEslintEntryPointReachesTheRules(workspaceRoot) {
 function declaredDevDependencies(workspaceRoot) {
   try {
     const manifest = readJson(
-      (0, import_node_path31.join)(workspaceRoot, "package.json")
+      (0, import_node_path32.join)(workspaceRoot, "package.json")
     );
     return manifest.devDependencies ?? {};
   } catch {
@@ -7419,7 +7559,7 @@ function declaredDevDependencies(workspaceRoot) {
   }
 }
 function checkNoRetiredFormatter(workspaceRoot) {
-  const files = RETIRED_FORMATTER_FILES.filter((file) => fileExists((0, import_node_path31.join)(workspaceRoot, file)));
+  const files = RETIRED_FORMATTER_FILES.filter((file) => fileExists((0, import_node_path32.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) {
@@ -7445,7 +7585,7 @@ function checkEslintPlugin(nxJson) {
   };
 }
 function checkResolvedEslint(workspaceRoot) {
-  const manifestPath = (0, import_node_path31.join)(workspaceRoot, "node_modules/eslint/package.json");
+  const manifestPath = (0, import_node_path32.join)(workspaceRoot, "node_modules/eslint/package.json");
   if (!fileExists(manifestPath)) {
     return void 0;
   }
@@ -7463,11 +7603,11 @@ function checkResolvedEslint(workspaceRoot) {
   }
 }
 function checkNpmrc(workspaceRoot, registry, scope) {
-  const npmrcPath = (0, import_node_path31.join)(workspaceRoot, ".npmrc");
+  const npmrcPath = (0, import_node_path32.join)(workspaceRoot, ".npmrc");
   if (!registry || !fileExists(npmrcPath)) {
     return void 0;
   }
-  const npmrc = (0, import_node_fs25.readFileSync)(npmrcPath, "utf8");
+  const npmrc = (0, import_node_fs27.readFileSync)(npmrcPath, "utf8");
   if (registry.kind === "npm") {
     return {
       check: ".npmrc authenticates the public registry",
@@ -7484,11 +7624,11 @@ function checkNpmrc(workspaceRoot, registry, scope) {
   };
 }
 function checkNpmrcCredentialResolves(workspaceRoot, environment = process.env) {
-  const npmrcPath = (0, import_node_path31.join)(workspaceRoot, ".npmrc");
+  const npmrcPath = (0, import_node_path32.join)(workspaceRoot, ".npmrc");
   if (!fileExists(npmrcPath)) {
     return void 0;
   }
-  const npmrc = (0, import_node_fs25.readFileSync)(npmrcPath, "utf8");
+  const npmrc = (0, import_node_fs27.readFileSync)(npmrcPath, "utf8");
   const credentials = npmrc.split("\n").filter((line) => !line.trimStart().startsWith(";") && !line.trimStart().startsWith("#")).filter((line) => /(?:_authToken|_password|_auth)\s*=/u.test(line));
   const referenced = [
     ...new Set(
@@ -7512,13 +7652,13 @@ function checkNpmrcCredentialResolves(workspaceRoot, environment = process.env)
   };
 }
 function checkNpmAuthMatchesPipeline(workspaceRoot, registry) {
-  const npmrcPath = (0, import_node_path31.join)(workspaceRoot, ".npmrc");
-  const pipelinePath = (0, import_node_path31.join)(workspaceRoot, "azure-pipelines.yml");
+  const npmrcPath = (0, import_node_path32.join)(workspaceRoot, ".npmrc");
+  const pipelinePath = (0, import_node_path32.join)(workspaceRoot, "azure-pipelines.yml");
   if (registry?.kind !== "azure-artifacts" || !fileExists(npmrcPath) || !fileExists(pipelinePath)) {
     return void 0;
   }
-  const holdsCredentials = (0, import_node_fs25.readFileSync)(npmrcPath, "utf8").split("\n").filter((line) => !line.trimStart().startsWith(";") && !line.trimStart().startsWith("#")).some((line) => /(?:_authToken|_password|_auth)\s*=/u.test(line));
-  const runsTask = (0, import_node_fs25.readFileSync)(pipelinePath, "utf8").includes("npmAuthenticate@0");
+  const holdsCredentials = (0, import_node_fs27.readFileSync)(npmrcPath, "utf8").split("\n").filter((line) => !line.trimStart().startsWith(";") && !line.trimStart().startsWith("#")).some((line) => /(?:_authToken|_password|_auth)\s*=/u.test(line));
+  const runsTask = (0, import_node_fs27.readFileSync)(pipelinePath, "utf8").includes("npmAuthenticate@0");
   if (!holdsCredentials && !runsTask) {
     return {
       check: "npm auth: .npmrc and azure-pipelines.yml agree",
@@ -7563,13 +7703,13 @@ function npmjsCredentialShape(credentials, environment) {
 }
 function checkVersionActions(workspaceRoot) {
   const candidates = [
-    ...(0, import_node_fs25.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
-    ...(0, import_node_fs25.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
-    ...(0, import_node_fs25.globSync)("python-packages/*/pyproject.toml", { cwd: workspaceRoot })
+    ...(0, import_node_fs27.globSync)("packages/*/pubspec.yaml", { cwd: workspaceRoot }),
+    ...(0, import_node_fs27.globSync)("packages/*/*.csproj", { cwd: workspaceRoot }),
+    ...(0, import_node_fs27.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_path31.join)(workspaceRoot, projectRoot, "project.json");
+    const projectJsonPath = (0, import_node_path32.join)(workspaceRoot, projectRoot, "project.json");
     let hasOverride = false;
     try {
       const projectJson = readJson(projectJsonPath);
@@ -7598,7 +7738,7 @@ function declaredTargets(workspaceRoot, projectRoot) {
   ]) {
     try {
       const targets = extract(
-        readJson((0, import_node_path31.join)(workspaceRoot, projectRoot, file))
+        readJson((0, import_node_path32.join)(workspaceRoot, projectRoot, file))
       );
       if (targets && typeof targets === "object") {
         sources.push({
@@ -7614,8 +7754,8 @@ function declaredTargets(workspaceRoot, projectRoot) {
 function checkTargetFilesExist(workspaceRoot) {
   const projectRoots = new Set(
     [
-      ...(0, import_node_fs25.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
-      ...(0, import_node_fs25.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
+      ...(0, import_node_fs27.globSync)("{apps,libs,packages}/*/project.json", { cwd: workspaceRoot }),
+      ...(0, import_node_fs27.globSync)("{apps,libs,packages}/*/package.json", { cwd: workspaceRoot })
     ].map((manifest) => toPosix2(manifest).split("/").slice(0, 2).join("/"))
   );
   return [...projectRoots].flatMap(
@@ -7630,7 +7770,7 @@ 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_path31.join)(workspaceRoot, value))) {
+    if (!checkable || fileExists((0, import_node_path32.join)(workspaceRoot, value))) {
       return [];
     }
     return [
@@ -7669,15 +7809,15 @@ function checkGoPluginRegistered(workspaceRoot) {
   };
 }
 function checkGoWorkInSync(workspaceRoot) {
-  const goWorkPath = (0, import_node_path31.join)(workspaceRoot, "go.work");
+  const goWorkPath = (0, import_node_path32.join)(workspaceRoot, "go.work");
   if (!fileExists(goWorkPath)) {
     return void 0;
   }
-  const contents = (0, import_node_fs25.existsSync)(goWorkPath) ? (0, import_node_fs25.readFileSync)(goWorkPath, "utf8") : "";
+  const contents = (0, import_node_fs27.existsSync)(goWorkPath) ? (0, import_node_fs27.readFileSync)(goWorkPath, "utf8") : "";
   const blockEntries = Array.from(contents.matchAll(/(?:^|\n)\s*use\s+\(([^)]*)\)/g), (match) => match[1].split("\n")).flat();
   const singleEntries = Array.from(contents.matchAll(/(?:^|\n)\s*use\s+(\.\S+)/g), (match) => match[1]);
   const uses = [...blockEntries, ...singleEntries].map((entry) => entry.trim()).filter(Boolean);
-  const stale = uses.filter((entry) => !(0, import_node_fs25.existsSync)((0, import_node_path31.join)(workspaceRoot, entry, "go.mod")));
+  const stale = uses.filter((entry) => !(0, import_node_fs27.existsSync)((0, import_node_path32.join)(workspaceRoot, entry, "go.mod")));
   return {
     check: "every go.work `use` entry points to a module that still exists",
     ok: stale.length === 0,
@@ -7693,9 +7833,9 @@ function checkNativeApps(workspaceRoot) {
     { file: ".github/workflows/ci.yml", marker: "native (${{ matrix.os }})" },
     { file: "azure-pipelines.yml", marker: "- job: native" }
   ];
-  const findings = pipelines.filter(({ file }) => fileExists((0, import_node_path31.join)(workspaceRoot, file))).map(({ file, marker }) => ({
+  const findings = pipelines.filter(({ file }) => fileExists((0, import_node_path32.join)(workspaceRoot, file))).map(({ file, marker }) => ({
     check: `${file} builds the native apps on every OS`,
-    ok: (0, import_node_fs25.readFileSync)((0, import_node_path31.join)(workspaceRoot, file), "utf8").includes(marker),
+    ok: (0, import_node_fs27.readFileSync)((0, import_node_path32.join)(workspaceRoot, file), "utf8").includes(marker),
     detail: `${file} has no native job: CI would verify a cgo app on the one agent that cannot build it`,
     remedy: "run `mnci upgrade`"
   }));
@@ -7708,7 +7848,7 @@ function checkNativeApps(workspaceRoot) {
   return findings;
 }
 function checkNoRootRuntimeDependencies(workspaceRoot) {
-  const manifestPath = (0, import_node_path31.join)(workspaceRoot, "package.json");
+  const manifestPath = (0, import_node_path32.join)(workspaceRoot, "package.json");
   if (!fileExists(manifestPath)) {
     return void 0;
   }
@@ -7728,14 +7868,14 @@ function checkNoRootRuntimeDependencies(workspaceRoot) {
   };
 }
 function checkRollupSourceMaps(workspaceRoot) {
-  const configs = (0, import_node_fs25.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs27.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return configs.flatMap((relativePath) => {
-    const configPath = (0, import_node_path31.join)(workspaceRoot, relativePath);
+    const configPath = (0, import_node_path32.join)(workspaceRoot, relativePath);
     let config;
     try {
-      config = (0, import_node_fs25.readFileSync)(configPath, "utf8");
+      config = (0, import_node_fs27.readFileSync)(configPath, "utf8");
     } catch {
       return [];
     }
@@ -7750,11 +7890,11 @@ function checkRollupSourceMaps(workspaceRoot) {
   });
 }
 function checkDeclarationSpecifiers(workspaceRoot) {
-  const configs = (0, import_node_fs25.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
+  const configs = (0, import_node_fs27.globSync)(["packages/*/rollup.config.cjs", "libs/*/rollup.config.cjs"], {
     cwd: workspaceRoot
   }).map((config) => toPosix2(config));
   return configs.flatMap((relativePath) => {
-    const configPath = (0, import_node_path31.join)(workspaceRoot, relativePath);
+    const configPath = (0, import_node_path32.join)(workspaceRoot, relativePath);
     if (!fileExists(configPath)) {
       return [];
     }
@@ -7789,8 +7929,8 @@ function checkDeclarationSpecifiers(workspaceRoot) {
 }
 function checkPipelinePhases(workspaceRoot) {
   const files = ["azure-pipelines.yml", ".github/workflows/ci.yml"];
-  return files.filter((file) => fileExists((0, import_node_path31.join)(workspaceRoot, file))).flatMap((file) => {
-    const { verifyActive, switchedOff } = inspectPipeline((0, import_node_fs25.readFileSync)((0, import_node_path31.join)(workspaceRoot, file), "utf8"));
+  return files.filter((file) => fileExists((0, import_node_path32.join)(workspaceRoot, file))).flatMap((file) => {
+    const { verifyActive, switchedOff } = inspectPipeline((0, import_node_fs27.readFileSync)((0, import_node_path32.join)(workspaceRoot, file), "utf8"));
     const verify = {
       check: `${file} runs the enforced verify phase`,
       ok: verifyActive,
@@ -7807,8 +7947,20 @@ function checkPipelinePhases(workspaceRoot) {
     return [verify, ...warnings];
   });
 }
+function checkNativeBuildConfig(workspaceRoot) {
+  const { problems } = readNativeBuildConfig(workspaceRoot);
+  if (problems.length === 0) {
+    return [];
+  }
+  return [{
+    check: "mnci.native in nx.json is valid",
+    ok: false,
+    detail: problems.join("; "),
+    remedy: "fix the entry in the mnci block of nx.json, then run `mnci upgrade`"
+  }];
+}
 function collectFindings(workspaceRoot) {
-  const nxJsonPath = (0, import_node_path31.join)(workspaceRoot, "nx.json");
+  const nxJsonPath = (0, import_node_path32.join)(workspaceRoot, "nx.json");
   if (!fileExists(nxJsonPath)) {
     throw new Error(
       `No nx.json found in ${workspaceRoot} \u2014 run 'mnci doctor' from the workspace root.`
@@ -7832,7 +7984,8 @@ function collectFindings(workspaceRoot) {
     checkGoPluginRegistered(workspaceRoot),
     checkGoWorkInSync(workspaceRoot),
     ...checkNativeApps(workspaceRoot),
-    ...checkPipelinePhases(workspaceRoot)
+    ...checkPipelinePhases(workspaceRoot),
+    ...checkNativeBuildConfig(workspaceRoot)
   ].filter((finding) => finding !== void 0);
 }
 function runDoctor(workspaceRoot, options = {}) {
@@ -7938,11 +8091,11 @@ function runCommands(program, options) {
 }
 
 // src/workspace-info/list-projects.use-case.ts
-var import_node_path32 = require("path");
+var import_node_path33 = require("path");
 var TYPE_TAG_PREFIX = "type:";
 function listProjects(workspaceRoot) {
   return locateProjects(workspaceRoot).map((location) => {
-    const projectJsonPath = (0, import_node_path32.join)(workspaceRoot, location.dir, "project.json");
+    const projectJsonPath = (0, import_node_path33.join)(workspaceRoot, location.dir, "project.json");
     const project = fileExists(projectJsonPath) ? readJson(projectJsonPath) : {};
     const typeTag = (project.tags ?? []).find((tag) => tag.startsWith(TYPE_TAG_PREFIX));
     return {
@@ -7955,7 +8108,7 @@ function listProjects(workspaceRoot) {
   }).toSorted((a, b) => a.dir.localeCompare(b.dir));
 }
 function runProjects(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path32.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path33.join)(workspaceRoot, "nx.json"))) {
     throw new Error("No nx.json found here. Run `projects` from the workspace root.");
   }
   const projects = listProjects(workspaceRoot);
@@ -7969,13 +8122,13 @@ function runProjects(workspaceRoot, options) {
 }
 
 // src/workspace-info/read-workspace-info.use-case.ts
-var import_node_path34 = require("path");
+var import_node_path35 = require("path");
 
 // src/cli-version/check-for-update.use-case.ts
-var import_node_fs26 = require("fs");
-var import_node_path33 = require("path");
+var import_node_fs28 = require("fs");
+var import_node_path34 = require("path");
 var import_cross_spawn3 = __toESM(require("cross-spawn"));
-var PACKAGE_NAME = "@mnci/cli";
+var PACKAGE_NAME2 = "@mnci/cli";
 var REGISTRY_TIMEOUT_MS = 2e3;
 function checkForUpdate(currentVersion2) {
   try {
@@ -7992,7 +8145,7 @@ function checkForUpdate(currentVersion2) {
   }
 }
 function fetchLatestVersion() {
-  const result = import_cross_spawn3.default.sync("npm", ["view", PACKAGE_NAME, "version"], {
+  const result = import_cross_spawn3.default.sync("npm", ["view", PACKAGE_NAME2, "version"], {
     encoding: "utf8",
     timeout: REGISTRY_TIMEOUT_MS,
     stdio: ["ignore", "pipe", "ignore"]
@@ -8008,9 +8161,9 @@ function reportIfOutdated(currentVersion2) {
     return;
   }
   logger.info("");
-  logger.info(`A new version of ${PACKAGE_NAME} is available: ${latestVersion}`);
+  logger.info(`A new version of ${PACKAGE_NAME2} is available: ${latestVersion}`);
   logger.info(`  Current version: ${currentVersion2}`);
-  logger.info(`  Update with: npm install -g ${PACKAGE_NAME}@latest`);
+  logger.info(`  Update with: npm install -g ${PACKAGE_NAME2}@latest`);
   logger.info("");
 }
 function isNewerVersion(candidate, current) {
@@ -8032,8 +8185,8 @@ function releaseTriple(version) {
 }
 function readCliVersion(packageDirectory) {
   try {
-    const manifestPath = (0, import_node_path33.join)(packageDirectory, "..", "package.json");
-    const manifest = JSON.parse((0, import_node_fs26.readFileSync)(manifestPath, "utf8"));
+    const manifestPath = (0, import_node_path34.join)(packageDirectory, "..", "package.json");
+    const manifest = JSON.parse((0, import_node_fs28.readFileSync)(manifestPath, "utf8"));
     return manifest.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -8043,7 +8196,7 @@ function readCliVersion(packageDirectory) {
 // src/workspace-info/read-workspace-info.use-case.ts
 function readWorkspaceInfo(workspaceRoot, cliVersion) {
   const latest = fetchLatestVersion() ?? null;
-  const isWorkspace = fileExists((0, import_node_path34.join)(workspaceRoot, "nx.json"));
+  const isWorkspace = fileExists((0, import_node_path35.join)(workspaceRoot, "nx.json"));
   return {
     cli: {
       version: cliVersion,
@@ -8064,8 +8217,8 @@ function runInfo(workspaceRoot, cliVersion, options) {
 }
 
 // src/workspace-creation/adopt-directory.use-case.ts
-var import_node_fs27 = require("fs");
-var import_node_path35 = require("path");
+var import_node_fs29 = require("fs");
+var import_node_path36 = require("path");
 var NEVER_COPIED = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var AGENT_AND_CI_ENTRIES = [
   "AGENTS.md",
@@ -8096,13 +8249,13 @@ var PREFLIGHT_BLOCKERS = [
   "packages"
 ];
 function assertAdoptableDirectory(target) {
-  if (!(0, import_node_fs27.existsSync)(target)) {
+  if (!(0, import_node_fs29.existsSync)(target)) {
     throw new Error(`--into '${target}' does not exist. Create or clone it first.`);
   }
-  if (!(0, import_node_fs27.statSync)(target).isDirectory()) {
+  if (!(0, import_node_fs29.statSync)(target).isDirectory()) {
     throw new Error(`--into '${target}' is not a directory.`);
   }
-  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs27.existsSync)((0, import_node_path35.join)(target, entry)));
+  const blockers = PREFLIGHT_BLOCKERS.filter((entry) => (0, import_node_fs29.existsSync)((0, import_node_path36.join)(target, entry)));
   if (blockers.length > 0) {
     throw new Error(
       `--into '${target}' already holds ${blockers.join(", ")}, so it is a project already. Use \`mnci upgrade\` to re-apply the overlay to an existing workspace, or point --into at an empty checkout.`
@@ -8110,15 +8263,15 @@ function assertAdoptableDirectory(target) {
   }
 }
 function mergeGitignore(generatedFile, targetFile) {
-  const existing = (0, import_node_fs27.readFileSync)(targetFile, "utf8");
+  const existing = (0, import_node_fs29.readFileSync)(targetFile, "utf8");
   const present = new Set(existing.split("\n").map((line) => line.trim()));
-  const additions = (0, import_node_fs27.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
+  const additions = (0, import_node_fs29.readFileSync)(generatedFile, "utf8").split("\n").map((line) => line.trimEnd()).filter((line) => {
     const trimmed = line.trim();
     return trimmed !== "" && !trimmed.startsWith("#") && !present.has(trimmed);
   });
   if (additions.length === 0) return false;
   const separator = existing.endsWith("\n") ? "" : "\n";
-  (0, import_node_fs27.writeFileSync)(
+  (0, import_node_fs29.writeFileSync)(
     targetFile,
     `${existing}${separator}
 # Added by mnci (Nx workspace)
@@ -8128,9 +8281,9 @@ ${additions.join("\n")}
   return true;
 }
 function adoptGeneratedWorkspace(generatedRoot, target) {
-  const entries = (0, import_node_fs27.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
+  const entries = (0, import_node_fs29.readdirSync)(generatedRoot).filter((entry) => !NEVER_COPIED.has(entry));
   const collisions = entries.filter(
-    (entry) => (0, import_node_fs27.existsSync)((0, import_node_path35.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
+    (entry) => (0, import_node_fs29.existsSync)((0, import_node_path36.join)(target, entry)) && !EXISTING_WINS.has(entry) && entry !== ".gitignore"
   );
   if (collisions.length > 0) {
     throw new Error(
@@ -8139,28 +8292,28 @@ function adoptGeneratedWorkspace(generatedRoot, target) {
   }
   const result = { copied: [], kept: [], mergedGitignore: false };
   for (const entry of entries) {
-    const from = (0, import_node_path35.join)(generatedRoot, entry);
-    const to = (0, import_node_path35.join)(target, entry);
-    if (entry === ".gitignore" && (0, import_node_fs27.existsSync)(to)) {
+    const from = (0, import_node_path36.join)(generatedRoot, entry);
+    const to = (0, import_node_path36.join)(target, entry);
+    if (entry === ".gitignore" && (0, import_node_fs29.existsSync)(to)) {
       result.mergedGitignore = mergeGitignore(from, to);
       result.kept.push(entry);
       continue;
     }
-    if ((0, import_node_fs27.existsSync)(to)) {
+    if ((0, import_node_fs29.existsSync)(to)) {
       result.kept.push(entry);
       continue;
     }
-    (0, import_node_fs27.cpSync)(from, to, { recursive: true });
+    (0, import_node_fs29.cpSync)(from, to, { recursive: true });
     result.copied.push(entry);
   }
-  (0, import_node_fs27.rmSync)(generatedRoot, { recursive: true, force: true });
+  (0, import_node_fs29.rmSync)(generatedRoot, { recursive: true, force: true });
   return result;
 }
 
 // src/workspace-creation/create-workspace.use-case.ts
-var import_node_fs28 = require("fs");
+var import_node_fs30 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path36 = require("path");
+var import_node_path37 = require("path");
 function nxCloudProviderValue(ci) {
   return ci === "azure" ? "azure" : "github";
 }
@@ -8203,9 +8356,9 @@ async function resolveRegistry(options) {
   return await promptRegistry();
 }
 async function runNew(name, options) {
-  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path36.resolve)(process.cwd(), options.into);
+  const adoptTarget = options.into === void 0 ? void 0 : (0, import_node_path37.resolve)(process.cwd(), options.into);
   if (adoptTarget !== void 0) assertAdoptableDirectory(adoptTarget);
-  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path36.basename)(adoptTarget));
+  const workspaceName = name ?? (adoptTarget === void 0 ? await promptText("Workspace name") : (0, import_node_path37.basename)(adoptTarget));
   assertValidProjectName(workspaceName, "Workspace name");
   const scope = options.scope ?? (options.yes ? `@${workspaceName}` : await promptText("npm scope for publishable packages", `@${workspaceName}`));
   const registry = await resolveRegistry(options);
@@ -8218,8 +8371,8 @@ async function runNew(name, options) {
   const npmAuth = resolveNpmAuth(options.npmAuth, registry, ci);
   const stack = await resolveStack(options);
   const nxCloud = options.nxCloud ?? (options.yes ? false : await promptNxCloud());
-  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs28.mkdtempSync)((0, import_node_path36.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
-  let workspaceRoot = (0, import_node_path36.join)(stagingParent, workspaceName);
+  const stagingParent = adoptTarget === void 0 ? process.cwd() : (0, import_node_fs30.mkdtempSync)((0, import_node_path37.join)((0, import_node_os2.tmpdir)(), "mnci-new-"));
+  let workspaceRoot = (0, import_node_path37.join)(stagingParent, workspaceName);
   try {
     logger.step(`Creating Nx workspace '${workspaceName}' (preset: ts)`);
     runNpx(
@@ -8242,7 +8395,7 @@ async function runNew(name, options) {
       workspaceRoot = adoptTarget;
     }
   } finally {
-    if (adoptTarget !== void 0) (0, import_node_fs28.rmSync)(stagingParent, { recursive: true, force: true });
+    if (adoptTarget !== void 0) (0, import_node_fs30.rmSync)(stagingParent, { recursive: true, force: true });
   }
   logger.step(
     "Applying MoNecromanCI overlay (VS Code workspace, release config, .npmrc, commitlint, pipeline, stack)"
@@ -8252,8 +8405,8 @@ async function runNew(name, options) {
     { workspaceName, scope, registry, agent, variableGroup, ci, stack, ...npmAuth && { npmAuth } },
     logger.detail
   );
-  (0, import_node_fs28.rmSync)((0, import_node_path36.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
-  (0, import_node_fs28.rmSync)((0, import_node_path36.join)(workspaceRoot, "package-lock.json"), { force: true });
+  (0, import_node_fs30.rmSync)((0, import_node_path37.join)(workspaceRoot, "node_modules"), { recursive: true, force: true });
+  (0, import_node_fs30.rmSync)((0, import_node_path37.join)(workspaceRoot, "package-lock.json"), { force: true });
   logger.step("Installing the toolchain (commitlint + husky + linting/formatting)");
   const installStatus = runShell(
     "npm",
@@ -8291,12 +8444,12 @@ function projectKindHintLines(kinds = PROJECT_KINDS) {
 }
 
 // src/workspace-creation/interactive-wizard.use-case.ts
-var import_node_path38 = require("path");
+var import_node_path39 = require("path");
 var import_prompts4 = require("@inquirer/prompts");
 
 // src/workspace-upgrade/upgrade-workspace.use-case.ts
-var import_node_fs29 = require("fs");
-var import_node_path37 = require("path");
+var import_node_fs31 = require("fs");
+var import_node_path38 = require("path");
 function resolveRegistry2(options, persisted) {
   if (options.registry === "azure-artifacts" || options.organization && options.artifactsFeed) {
     const persistedAzure = persisted?.kind === "azure-artifacts" ? persisted : void 0;
@@ -8325,7 +8478,7 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     return persisted.workspaceName;
   }
   try {
-    const existing = (0, import_node_fs29.readdirSync)(workspaceRoot).find(
+    const existing = (0, import_node_fs31.readdirSync)(workspaceRoot).find(
       (file) => file.endsWith(".code-workspace") && file !== "undefined.code-workspace"
     );
     if (existing) {
@@ -8333,11 +8486,11 @@ function resolveWorkspaceName(workspaceRoot, persisted) {
     }
   } catch {
   }
-  return (0, import_node_path37.basename)(workspaceRoot);
+  return (0, import_node_path38.basename)(workspaceRoot);
 }
 function detectNpmAuth(workspaceRoot) {
   try {
-    return (0, import_node_fs29.readFileSync)((0, import_node_path37.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
+    return (0, import_node_fs31.readFileSync)((0, import_node_path38.join)(workspaceRoot, "azure-pipelines.yml"), "utf8").includes("npmAuthenticate@0") ? "build-identity" : void 0;
   } catch {
     return void 0;
   }
@@ -8384,7 +8537,7 @@ function resolveOverlayOptions(workspaceRoot, options, persisted) {
   };
 }
 function runUpgrade(workspaceRoot, options) {
-  if (!fileExists((0, import_node_path37.join)(workspaceRoot, "nx.json"))) {
+  if (!fileExists((0, import_node_path38.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.`
     );
@@ -8450,7 +8603,7 @@ function runUpgrade(workspaceRoot, options) {
 
 // src/workspace-creation/interactive-wizard.use-case.ts
 async function runInteractive() {
-  const inWorkspace = fileExists((0, import_node_path38.join)(process.cwd(), "nx.json"));
+  const inWorkspace = fileExists((0, import_node_path39.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 = {