@solid-stack/mason 1.0.25 → 1.0.27

package/dist/bin.cjs

@@ -2,9 +2,9 @@
 'use strict';
 
 var cac = require('cac');
-var p15 = require('@clack/prompts');
-var pc15 = require('picocolors');
-var fs10 = require('fs');
+var p19 = require('@clack/prompts');
+var pc13 = require('picocolors');
+var fs14 = require('fs');
 var path2 = require('path');
 var url = require('url');
 var Handlebars = require('handlebars');
@@ -32,16 +32,16 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var p15__namespace = /*#__PURE__*/_interopNamespace(p15);
-var pc15__default = /*#__PURE__*/_interopDefault(pc15);
-var fs10__default = /*#__PURE__*/_interopDefault(fs10);
+var p19__namespace = /*#__PURE__*/_interopNamespace(p19);
+var pc13__default = /*#__PURE__*/_interopDefault(pc13);
+var fs14__default = /*#__PURE__*/_interopDefault(fs14);
 var path2__default = /*#__PURE__*/_interopDefault(path2);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 
 function writeFileSafely(absolutePath, content, options = {}) {
   const projectRoot = options.projectRoot || process.cwd();
   const relPath = path2__default.default.relative(projectRoot, absolutePath).replace(/\\/g, "/");
-  const existedBefore = fs10__default.default.existsSync(absolutePath);
+  const existedBefore = fs14__default.default.existsSync(absolutePath);
   if (options.dryRun) {
     return {
       relativePath: relPath,
@@ -61,10 +61,10 @@ function writeFileSafely(absolutePath, content, options = {}) {
     };
   }
   const dir = path2__default.default.dirname(absolutePath);
-  if (!fs10__default.default.existsSync(dir)) {
-    fs10__default.default.mkdirSync(dir, { recursive: true });
+  if (!fs14__default.default.existsSync(dir)) {
+    fs14__default.default.mkdirSync(dir, { recursive: true });
   }
-  fs10__default.default.writeFileSync(absolutePath, content, "utf-8");
+  fs14__default.default.writeFileSync(absolutePath, content, "utf-8");
   return {
     relativePath: relPath,
     absolutePath,
@@ -76,17 +76,17 @@ function writeFileSafely(absolutePath, content, options = {}) {
 function printGeneratedFiles(files, isDryRun = false) {
   console.log("");
   if (isDryRun) {
-    p15__namespace.log.warn(pc15__default.default.yellow(pc15__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
+    p19__namespace.log.warn(pc13__default.default.yellow(pc13__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
   }
   for (const f of files) {
     if (f.action === "created") {
-      p15__namespace.log.success(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(created)")}`);
+      p19__namespace.log.success(`${pc13__default.default.bold(f.relativePath)} ${pc13__default.default.dim("(created)")}`);
     } else if (f.action === "overwritten") {
-      p15__namespace.log.warn(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(overwritten)")}`);
+      p19__namespace.log.warn(`${pc13__default.default.bold(f.relativePath)} ${pc13__default.default.dim("(overwritten)")}`);
     } else if (f.action === "skipped") {
-      p15__namespace.log.info(`${pc15__default.default.dim(f.relativePath)} ${pc15__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
+      p19__namespace.log.info(`${pc13__default.default.dim(f.relativePath)} ${pc13__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
     } else {
-      p15__namespace.log.info(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(preview)")}`);
+      p19__namespace.log.info(`${pc13__default.default.bold(f.relativePath)} ${pc13__default.default.dim("(preview)")}`);
     }
   }
 }
@@ -158,9 +158,9 @@ function loadMasonConfig(startDir = process.cwd()) {
   let current = path2__default.default.resolve(startDir);
   while (true) {
     const configPath = path2__default.default.join(current, "mason.config.json");
-    if (fs10__default.default.existsSync(configPath)) {
+    if (fs14__default.default.existsSync(configPath)) {
       try {
-        return JSON.parse(fs10__default.default.readFileSync(configPath, "utf-8"));
+        return JSON.parse(fs14__default.default.readFileSync(configPath, "utf-8"));
       } catch {
         return null;
       }
@@ -175,7 +175,7 @@ function getEffectiveMode(projectRoot, flags) {
   if (flags?.registry) return "registry";
   const config = loadMasonConfig(projectRoot);
   if (config?.mode) return config.mode;
-  if (fs10__default.default.existsSync(path2__default.default.join(projectRoot, "index.json")) && (fs10__default.default.existsSync(path2__default.default.join(projectRoot, "features")) || fs10__default.default.existsSync(path2__default.default.join(projectRoot, "shared")) || fs10__default.default.existsSync(path2__default.default.join(projectRoot, "src/features")) || fs10__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared")))) {
+  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "index.json")) && (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "features")) || fs14__default.default.existsSync(path2__default.default.join(projectRoot, "shared")) || fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/features")) || fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared")))) {
     return "registry";
   }
   return "app";
@@ -189,12 +189,12 @@ function getConfiguredFeaturesDir(projectRoot, flags) {
   }
   const mode = getEffectiveMode(projectRoot, flags);
   if (mode === "registry") {
-    if (fs10__default.default.existsSync(path2__default.default.join(projectRoot, "src/features"))) {
+    if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/features"))) {
       return path2__default.default.join(projectRoot, "src/features");
     }
     return path2__default.default.join(projectRoot, "features");
   }
-  if (fs10__default.default.existsSync(path2__default.default.join(projectRoot, "src/features"))) {
+  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/features"))) {
     return path2__default.default.join(projectRoot, "src/features");
   }
   return path2__default.default.join(projectRoot, "features");
@@ -208,12 +208,12 @@ function getConfiguredSharedDir(projectRoot, flags) {
   }
   const mode = getEffectiveMode(projectRoot, flags);
   if (mode === "registry") {
-    if (fs10__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared"))) {
+    if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared"))) {
       return path2__default.default.join(projectRoot, "src/shared");
     }
     return path2__default.default.join(projectRoot, "shared");
   }
-  if (fs10__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared"))) {
+  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared"))) {
     return path2__default.default.join(projectRoot, "src/shared");
   }
   return path2__default.default.join(projectRoot, "shared");
@@ -223,7 +223,7 @@ function getConfiguredSharedDir(projectRoot, flags) {
 function findProjectRoot(startDir = process.cwd()) {
   let current = path2__default.default.resolve(startDir);
   while (true) {
-    if (fs10__default.default.existsSync(path2__default.default.join(current, "package.json"))) {
+    if (fs14__default.default.existsSync(path2__default.default.join(current, "package.json"))) {
       return current;
     }
     const parent = path2__default.default.dirname(current);
@@ -241,9 +241,9 @@ function resolveSharedDir(projectRoot, flags) {
 }
 function listExistingFeatures(projectRoot) {
   const featuresDir = resolveFeaturesDir(projectRoot);
-  if (!fs10__default.default.existsSync(featuresDir)) return [];
+  if (!fs14__default.default.existsSync(featuresDir)) return [];
   try {
-    const entries = fs10__default.default.readdirSync(featuresDir, { withFileTypes: true });
+    const entries = fs14__default.default.readdirSync(featuresDir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -254,9 +254,9 @@ function listDomainInterfaces(projectRoot, featureName) {
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
     const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs10__default.default.existsSync(domainDir)) continue;
+    if (!fs14__default.default.existsSync(domainDir)) continue;
     try {
-      const files = fs10__default.default.readdirSync(domainDir);
+      const files = fs14__default.default.readdirSync(domainDir);
       for (const file of files) {
         if (file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".d.ts")) {
           const name = file.replace(/\.ts$/, "");
@@ -269,7 +269,7 @@ function listDomainInterfaces(projectRoot, featureName) {
             });
           } else {
             try {
-              const content = fs10__default.default.readFileSync(fullPath, "utf-8");
+              const content = fs14__default.default.readFileSync(fullPath, "utf-8");
               if (/export\s+(?:abstract\s+class|interface)\s+(\w+)/.test(content)) {
                 results.push({
                   name,
@@ -292,9 +292,9 @@ function listDomainEntities(projectRoot, featureName) {
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
     const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs10__default.default.existsSync(domainDir)) continue;
+    if (!fs14__default.default.existsSync(domainDir)) continue;
     try {
-      const files = fs10__default.default.readdirSync(domainDir);
+      const files = fs14__default.default.readdirSync(domainDir);
       for (const file of files) {
         if (file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".d.ts")) {
           const name = file.replace(/\.ts$/, "");
@@ -317,9 +317,9 @@ function listUseCases(projectRoot, featureName) {
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
     const useCasesDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "useCases");
-    if (!fs10__default.default.existsSync(useCasesDir)) continue;
+    if (!fs14__default.default.existsSync(useCasesDir)) continue;
     try {
-      const files = fs10__default.default.readdirSync(useCasesDir);
+      const files = fs14__default.default.readdirSync(useCasesDir);
       for (const file of files) {
         if (file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".d.ts")) {
           const name = file.replace(/\.ts$/, "");
@@ -351,29 +351,29 @@ hbs.registerHelper("join", (arr, sep) => {
 });
 var cachedTemplatesDir = null;
 function getTemplatesDir() {
-  if (cachedTemplatesDir && fs10__default.default.existsSync(cachedTemplatesDir)) {
+  if (cachedTemplatesDir && fs14__default.default.existsSync(cachedTemplatesDir)) {
     return cachedTemplatesDir;
   }
   const currentDir = typeof __dirname !== "undefined" ? __dirname : path2__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
   const cand1 = path2__default.default.resolve(currentDir, "../../templates");
-  if (fs10__default.default.existsSync(cand1)) {
+  if (fs14__default.default.existsSync(cand1)) {
     cachedTemplatesDir = cand1;
     return cand1;
   }
   const cand2 = path2__default.default.resolve(currentDir, "../templates");
-  if (fs10__default.default.existsSync(cand2)) {
+  if (fs14__default.default.existsSync(cand2)) {
     cachedTemplatesDir = cand2;
     return cand2;
   }
   const cand3 = path2__default.default.resolve(currentDir, "templates");
-  if (fs10__default.default.existsSync(cand3)) {
+  if (fs14__default.default.existsSync(cand3)) {
     cachedTemplatesDir = cand3;
     return cand3;
   }
   let curr = currentDir;
   while (true) {
     const candTemplates = path2__default.default.join(curr, "templates");
-    if (fs10__default.default.existsSync(candTemplates)) {
+    if (fs14__default.default.existsSync(candTemplates)) {
       cachedTemplatesDir = candTemplates;
       return candTemplates;
     }
@@ -386,7 +386,7 @@ function getTemplatesDir() {
 var templateCache = /* @__PURE__ */ new Map();
 function loadTemplate(relativePath) {
   const fullPath = path2__default.default.isAbsolute(relativePath) ? relativePath : path2__default.default.join(getTemplatesDir(), relativePath);
-  return fs10__default.default.readFileSync(fullPath, "utf-8");
+  return fs14__default.default.readFileSync(fullPath, "utf-8");
 }
 function renderTemplateFile(relativePath, context) {
   let compiled = templateCache.get(relativePath);
@@ -498,7 +498,7 @@ function generateInterfaceCode(ifaceName, kind = "abstractClass", entityName, me
   const idKey = `${entityKey}Id`;
   const listKey = `${entityKey}s`;
   const formattedCustomMethods = customMethods.map((m) => {
-    const params = m.params && m.params.length > 0 ? m.params.map((p18) => `${p18.name}: ${p18.type}`).join("; ") : "";
+    const params = m.params && m.params.length > 0 ? m.params.map((p22) => `${p22.name}: ${p22.type}`).join("; ") : "";
     const returnType = m.returnType ? `Promise<${m.returnType}>` : "Promise<void>";
     return {
       name: m.name,
@@ -759,7 +759,7 @@ function parseInterfaceMethodsAndImports(content, targetIfaceName) {
   };
 }
 function findInterfaceFile(projectRoot, ifaceName, featureName, customPath) {
-  if (customPath && fs10__default.default.existsSync(customPath)) {
+  if (customPath && fs14__default.default.existsSync(customPath)) {
     return { filePath: customPath, ifaceName };
   }
   const candidateNames = [
@@ -770,21 +770,21 @@ function findInterfaceFile(projectRoot, ifaceName, featureName, customPath) {
   const features = featureName ? [featureName, ...listExistingFeatures(projectRoot).filter((f) => f !== featureName)] : listExistingFeatures(projectRoot);
   for (const feat of features) {
     const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs10__default.default.existsSync(domainDir)) continue;
+    if (!fs14__default.default.existsSync(domainDir)) continue;
     for (const cand of candidateNames) {
       const p1 = path2__default.default.join(domainDir, `${cand}.ts`);
-      if (fs10__default.default.existsSync(p1)) {
+      if (fs14__default.default.existsSync(p1)) {
         return { filePath: p1, ifaceName: cand, feature: feat };
       }
     }
   }
   for (const cand of candidateNames) {
     const p1 = path2__default.default.join(projectRoot, "domain", `${cand}.ts`);
-    if (fs10__default.default.existsSync(p1)) return { filePath: p1, ifaceName: cand };
+    if (fs14__default.default.existsSync(p1)) return { filePath: p1, ifaceName: cand };
     const p22 = path2__default.default.join(projectRoot, "src", "domain", `${cand}.ts`);
-    if (fs10__default.default.existsSync(p22)) return { filePath: p22, ifaceName: cand };
+    if (fs14__default.default.existsSync(p22)) return { filePath: p22, ifaceName: cand };
     const p32 = path2__default.default.join(projectRoot, "interfaces", `${cand}.ts`);
-    if (fs10__default.default.existsSync(p32)) return { filePath: p32, ifaceName: cand };
+    if (fs14__default.default.existsSync(p32)) return { filePath: p32, ifaceName: cand };
   }
   return null;
 }
@@ -807,7 +807,7 @@ function loadInterfaceHierarchy(projectRoot, initialIfaceName, featureName, cust
   while (currentFile && !visited.has(currentFile)) {
     visited.add(currentFile);
     try {
-      const content = fs10__default.default.readFileSync(currentFile, "utf-8");
+      const content = fs14__default.default.readFileSync(currentFile, "utf-8");
       const parsed = parseInterfaceMethodsAndImports(content, currentName);
       for (const m of parsed.methods) {
         if (!allMethods.some((existing) => existing.name === m.name)) {
@@ -1079,22 +1079,22 @@ function generateUseCaseCode(useCaseName, dependencies = [], inputProps = [], ou
     from: /^I[A-Z]/.test(dep) ? `../domain/${dep}.js` : `./${dep}.js`
   }));
   const domainTypesToImport = new Set(domainImports);
-  for (const p18 of [...inputProps, ...outputProps]) {
-    const rawType = p18.type.trim();
+  for (const p22 of [...inputProps, ...outputProps]) {
+    const rawType = p22.type.trim();
     const baseType = rawType.replace(/\[\]$/, "").trim();
     if (!primitiveTypes.has(baseType) && /^[A-Z][A-Za-z0-9_]*$/.test(baseType) && !dependencies.includes(baseType)) {
       domainTypesToImport.add(baseType);
     }
   }
-  const formattedInputProps = inputProps.map((p18) => ({
-    name: p18.name,
-    optional: p18.optional,
-    type: p18.optional && !p18.type.includes("undefined") ? `${p18.type} | undefined` : p18.type
+  const formattedInputProps = inputProps.map((p22) => ({
+    name: p22.name,
+    optional: p22.optional,
+    type: p22.optional && !p22.type.includes("undefined") ? `${p22.type} | undefined` : p22.type
   }));
-  const formattedOutputProps = outputProps.map((p18) => ({
-    name: p18.name,
-    optional: p18.optional,
-    type: p18.optional && !p18.type.includes("undefined") ? `${p18.type} | undefined` : p18.type
+  const formattedOutputProps = outputProps.map((p22) => ({
+    name: p22.name,
+    optional: p22.optional,
+    type: p22.optional && !p22.type.includes("undefined") ? `${p22.type} | undefined` : p22.type
   }));
   const formattedDeps = dependencies.map((dep) => ({
     key: toCamelCase(dep),
@@ -1281,7 +1281,7 @@ function generateHttpHandler(options) {
   const pxDir = path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress");
   const handlersDir = path2__default.default.join(pxDir, "handlers");
   const pxIndexPath = path2__default.default.join(pxDir, "index.ts");
-  if (!fs10__default.default.existsSync(pxIndexPath)) {
+  if (!fs14__default.default.existsSync(pxIndexPath)) {
     const featurePath = options.routePrefix || `/${options.feature.toLowerCase()}`;
     const pxIndexContent = renderTemplate(expressIndexTemplate, {
       routePath: featurePath
@@ -1318,8 +1318,8 @@ function updateOrGenerateDiProvider(featureDir, featureName, bindings = [], opti
   const providerPath = path2__default.default.join(featureDir, "diProvider.ts");
   const pascalFeature = toPascalCase(featureName);
   const providerModuleName = `${pascalFeature}Provider`;
-  if (fs10__default.default.existsSync(providerPath) && !options.overwrite) {
-    let content = fs10__default.default.readFileSync(providerPath, "utf-8");
+  if (fs14__default.default.existsSync(providerPath) && !options.overwrite) {
+    let content = fs14__default.default.readFileSync(providerPath, "utf-8");
     content = content.replace(/\n*export\s+const\s+ScaffoldProvider\s*=[^;]+;?/g, "");
     for (const b of bindings) {
       const ifaceImp = b.ifaceImportPath || `./domain/${b.ifaceName}.js`;
@@ -1765,23 +1765,23 @@ var PromptCancelledError = class extends Error {
   }
 };
 function handleCancel(result) {
-  if (p15__namespace.isCancel(result)) {
-    p15__namespace.cancel("Operation cancelled.");
+  if (p19__namespace.isCancel(result)) {
+    p19__namespace.cancel("Operation cancelled.");
     throw new PromptCancelledError();
   }
   return result;
 }
 function printBanner() {
   console.log("");
-  p15__namespace.intro(pc15__default.default.bgCyan(pc15__default.default.black(" @solid-stack/mason ")));
+  p19__namespace.intro(pc13__default.default.bgCyan(pc13__default.default.black(" @solid-stack/mason ")));
 }
 async function promptProperties(options = {}) {
   const properties = options.defaults ? [...options.defaults] : [];
   if (properties.length > 0) {
-    const summary = properties.map((p18) => `${p18.name}: ${p18.type}${p18.optional ? "?" : ""}`).join(", ");
-    p15__namespace.log.info(pc15__default.default.dim(`Pre-configured fields: ${summary}`));
+    const summary = properties.map((p22) => `${p22.name}: ${p22.type}${p22.optional ? "?" : ""}`).join(", ");
+    p19__namespace.log.info(pc13__default.default.dim(`Pre-configured fields: ${summary}`));
     const addMore = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Would you like to add custom fields/properties?",
         initialValue: false
       })
@@ -1790,10 +1790,10 @@ async function promptProperties(options = {}) {
       return properties;
     }
   }
-  p15__namespace.log.info(pc15__default.default.cyan("Enter properties (leave name blank when finished):"));
+  p19__namespace.log.info(pc13__default.default.cyan("Enter properties (leave name blank when finished):"));
   while (true) {
     const name = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Property name (or press Enter to finish):",
         placeholder: "e.g. title, email, status"
       })
@@ -1802,7 +1802,7 @@ async function promptProperties(options = {}) {
       break;
     }
     const type = handleCancel(
-      await p15__namespace.select({
+      await p19__namespace.select({
         message: `Type for property "${name.trim()}":`,
         options: [
           { value: "string", label: "string" },
@@ -1819,7 +1819,7 @@ async function promptProperties(options = {}) {
     let finalType = type;
     if (type === "custom") {
       finalType = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: `Enter custom type for "${name.trim()}":`,
           placeholder: "e.g. UserRole, string | null",
           validate: (val) => val && val.trim() ? void 0 : "Type cannot be empty"
@@ -1827,7 +1827,7 @@ async function promptProperties(options = {}) {
       );
     }
     const optional = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: `Is "${name.trim()}" optional?`,
         initialValue: false
       })
@@ -1837,8 +1837,8 @@ async function promptProperties(options = {}) {
       type: finalType.trim(),
       optional
     });
-    p15__namespace.log.success(
-      pc15__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
+    p19__namespace.log.success(
+      pc13__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
     );
   }
   return properties;
@@ -1854,7 +1854,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   }
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "What is the feature name?",
         placeholder: "e.g. users, auth, orders, billing",
         validate: (val) => {
@@ -1870,7 +1870,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   let targetDirRel = defaultDir;
   if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Target directory for the feature:",
         initialValue: defaultDir,
         defaultValue: defaultDir
@@ -1892,14 +1892,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   const customUseCases = [];
   if (!flags.yes) {
     includeExpress = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Include Express Presentation layer (pxExpress routes & handlers)?",
         initialValue: true
       })
     );
     if (includeExpress) {
       routePath = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: "Express route prefix:",
           initialValue: `/${normalizedName}`,
           defaultValue: `/${normalizedName}`
@@ -1907,14 +1907,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       ).trim();
     }
     includeDomain = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Include Domain Entity/Entities?",
         initialValue: true
       })
     );
     if (includeDomain) {
       const domainInput = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: "Domain entity name(s) (comma-separated):",
           initialValue: defaultEntity,
           defaultValue: defaultEntity,
@@ -1933,21 +1933,21 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       entityNames = [defaultEntity];
     }
     includeInterface = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: `Include Domain Repository interface(s) for ${entityNames.join(", ")}?`,
         initialValue: true
       })
     );
     if (includeInterface) {
       includeInfra = handleCancel(
-        await p15__namespace.confirm({
+        await p19__namespace.confirm({
           message: `Include Infrastructure Stub implementation(s) for ${entityNames.join(", ")}?`,
           initialValue: true
         })
       );
     }
     includeUseCase = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Include Domain Use Cases?",
         initialValue: true
       })
@@ -1961,7 +1961,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         { value: "delete", label: "Delete (Delete<Entity>)", hint: "DELETE /:id" }
       ];
       crudOperations = handleCancel(
-        await p15__namespace.multiselect({
+        await p19__namespace.multiselect({
           message: "Select standard CRUD use cases to generate:",
           options: crudChoices,
           initialValues: ["create", "read", "list", "update", "delete"],
@@ -1969,13 +1969,13 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         })
       );
       includeTests = handleCancel(
-        await p15__namespace.confirm({
+        await p19__namespace.confirm({
           message: "Generate Vitest unit tests for use cases?",
           initialValue: true
         })
       );
       const wantCustom = handleCancel(
-        await p15__namespace.confirm({
+        await p19__namespace.confirm({
           message: "Do you want to add any custom use cases to this feature?",
           initialValue: false
         })
@@ -1985,7 +1985,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         const availableIfaces = entityNames.map((e) => `I${e}Repository`);
         while (addMore) {
           const customName = handleCancel(
-            await p15__namespace.text({
+            await p19__namespace.text({
               message: "Custom Use Case name:",
               placeholder: "e.g. ResetPassword, VerifyEmail, AssignRole",
               validate: (v) => v && v.trim() ? void 0 : "Use Case name cannot be empty"
@@ -1995,7 +1995,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           let selectedDeps = [];
           if (availableIfaces.length > 0) {
             selectedDeps = handleCancel(
-              await p15__namespace.multiselect({
+              await p19__namespace.multiselect({
                 message: `Select domain interfaces to inject into ${customUcName}:`,
                 options: availableIfaces.map((i) => ({ value: i, label: i })),
                 required: false
@@ -2004,7 +2004,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           }
           let customInputProps = [];
           const hasInput = handleCancel(
-            await p15__namespace.confirm({
+            await p19__namespace.confirm({
               message: `Does ${customUcName} accept input arguments?`,
               initialValue: true
             })
@@ -2015,7 +2015,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           }
           let customOutputProps = [];
           const hasCustomOutput = handleCancel(
-            await p15__namespace.confirm({
+            await p19__namespace.confirm({
               message: `Does ${customUcName} return custom output data?`,
               initialValue: false
             })
@@ -2025,7 +2025,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
               });
           }
           const customIncludeTest = handleCancel(
-            await p15__namespace.confirm({
+            await p19__namespace.confirm({
               message: `Generate Vitest unit test for ${customUcName}?`,
               initialValue: true
             })
@@ -2035,14 +2035,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           let customHttpPath = `/${toKebabCase(customUcName)}`;
           if (includeExpress) {
             customCreateHttp = handleCancel(
-              await p15__namespace.confirm({
+              await p19__namespace.confirm({
                 message: `Generate a matching ExpressRoute HTTP handler for ${customUcName}?`,
                 initialValue: true
               })
             );
             if (customCreateHttp) {
               customHttpMethod = handleCancel(
-                await p15__namespace.select({
+                await p19__namespace.select({
                   message: "HTTP method for route:",
                   options: [
                     { value: "post", label: "POST" },
@@ -2055,7 +2055,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
                 })
               );
               customHttpPath = handleCancel(
-                await p15__namespace.text({
+                await p19__namespace.text({
                   message: "Route subpath (relative to feature prefix):",
                   initialValue: `/${toKebabCase(customUcName)}`,
                   defaultValue: `/${toKebabCase(customUcName)}`
@@ -2076,7 +2076,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
             validationFields: customInputProps
           });
           addMore = handleCancel(
-            await p15__namespace.confirm({
+            await p19__namespace.confirm({
               message: "Add another custom use case?",
               initialValue: false
             })
@@ -2085,7 +2085,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       }
     }
     includeDiProvider = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Generate / update feature DI provider (diProvider.ts)?",
         initialValue: true
       })
@@ -2097,8 +2097,8 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       entityNames = [defaultEntity];
     }
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating feature '${pc15__default.default.cyan(normalizedName)}'...`);
+  const s = p19__namespace.spinner();
+  s.start(`Generating feature '${pc13__default.default.cyan(normalizedName)}'...`);
   const options = {
     name: normalizedName,
     projectRoot,
@@ -2120,7 +2120,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   const files = generateFeature(options);
   if (isRegistry) {
     const registryPath = path2__default.default.join(targetDir, "registry.json");
-    if (!fs10__default.default.existsSync(registryPath)) {
+    if (!fs14__default.default.existsSync(registryPath)) {
       const manifest = {
         name: toKebabCase(normalizedName),
         type: "feature",
@@ -2144,8 +2144,8 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   }
   s.stop("Feature scaffolded successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(
-    pc15__default.default.green(
+  p19__namespace.outro(
+    pc13__default.default.green(
       `\u2713 Feature '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
@@ -2259,7 +2259,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   }
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "What is the shared module name?",
         placeholder: "e.g. hasher, time, uuid, cache, logger",
         validate: (val) => {
@@ -2275,7 +2275,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   let targetDirRel = defaultDir;
   if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Target directory for the shared module:",
         initialValue: defaultDir,
         defaultValue: defaultDir
@@ -2287,21 +2287,21 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   let includeStub = true;
   if (!flags.yes) {
     description = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Module description (optional):",
         placeholder: "e.g. In-memory caching and Redis port abstraction",
         initialValue: ""
       })
     ).trim();
     includeStub = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Include stub implementation in infrastructure/?",
         initialValue: true
       })
     );
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating shared module '${pc15__default.default.cyan(normalizedName)}'...`);
+  const s = p19__namespace.spinner();
+  s.start(`Generating shared module '${pc13__default.default.cyan(normalizedName)}'...`);
   const files = generateShared({
     name: normalizedName,
     description,
@@ -2314,8 +2314,8 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   });
   s.stop("Shared module generated successfully!");
   printGeneratedFiles(files, Boolean(flags.dryRun));
-  p15__namespace.outro(
-    pc15__default.default.green(
+  p19__namespace.outro(
+    pc13__default.default.green(
       `\u2713 Shared module '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
@@ -2329,14 +2329,14 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p19__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2346,7 +2346,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2357,7 +2357,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   let name = useCaseNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Use Case name:",
         placeholder: "e.g. CreateUser, GetUser, CancelOrder",
         validate: (v) => v && v.trim() ? void 0 : "Use Case name cannot be empty"
@@ -2373,7 +2373,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       label: i.name
     }));
     selectedDeps = handleCancel(
-      await p15__namespace.multiselect({
+      await p19__namespace.multiselect({
         message: "Select domain interfaces to inject into use case:",
         options: multiOptions,
         required: false
@@ -2388,7 +2388,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   let httpPath = "/";
   if (!flags.yes) {
     const hasInput = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Does this use case accept input arguments?",
         initialValue: true
       })
@@ -2398,7 +2398,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         });
     }
     const hasCustomOutput = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Does this use case return custom output data?",
         initialValue: false
       })
@@ -2408,20 +2408,20 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         });
     }
     includeTest = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Generate Vitest unit test skeleton (.test.ts)?",
         initialValue: true
       })
     );
     createHttp = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Generate a matching ExpressRoute HTTP handler?",
         initialValue: false
       })
     );
     if (createHttp) {
       httpMethod = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "HTTP method for route:",
           options: [
             { value: "post", label: "POST" },
@@ -2434,7 +2434,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         })
       );
       httpPath = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: "Route subpath (relative to feature prefix):",
           initialValue: "/",
           defaultValue: "/"
@@ -2442,8 +2442,8 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       ).trim();
     }
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating use case '${pc15__default.default.cyan(ucName)}'...`);
+  const s = p19__namespace.spinner();
+  s.start(`Generating use case '${pc13__default.default.cyan(ucName)}'...`);
   const options = {
     name: ucName,
     feature,
@@ -2475,7 +2475,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   }
   s.stop("Use case generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
+  p19__namespace.outro(pc13__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
 }
 async function runDomainCommand(domainNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2486,14 +2486,14 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p19__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2503,7 +2503,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2514,7 +2514,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   let name = domainNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Domain model / entity name:",
         placeholder: "e.g. User, Order, Product, Address",
         validate: (v) => v && v.trim() ? void 0 : "Domain name cannot be empty"
@@ -2526,7 +2526,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   let properties = [];
   if (!flags.yes) {
     kind = handleCancel(
-      await p15__namespace.select({
+      await p19__namespace.select({
         message: "Select domain model type:",
         options: [
           { value: "interface", label: "TypeScript Interface (pure data structure)" },
@@ -2545,8 +2545,8 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       defaults: kind === "valueObject" ? [{ name: "value", type: "string" }] : defaultProps
     });
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating domain model '${pc15__default.default.cyan(entityName)}'...`);
+  const s = p19__namespace.spinner();
+  s.start(`Generating domain model '${pc13__default.default.cyan(entityName)}'...`);
   const options = {
     name: entityName,
     feature,
@@ -2559,7 +2559,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   const file = generateDomain(options);
   s.stop("Domain model generated successfully!");
   printGeneratedFiles([file], options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
+  p19__namespace.outro(pc13__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
 }
 async function runInfrastructureCommand(classNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2568,7 +2568,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   let feature = flags.feature?.trim();
   if (!flags.yes && !flags.global && !flags.feature) {
     scope = handleCancel(
-      await p15__namespace.select({
+      await p19__namespace.select({
         message: "Where should this infrastructure implementation be placed?",
         options: [
           { value: "feature", label: "Feature-level (features/<feature>/infrastructure)" },
@@ -2583,14 +2583,14 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p19__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2600,7 +2600,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2613,7 +2613,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   let name = classNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Infrastructure class name:",
         placeholder: "e.g. StubUserRepository, PostgresUserRepository, S3FileStorage",
         validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
@@ -2632,7 +2632,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
           (i) => className.toLowerCase().includes(removeInterfacePrefix(i.name).toLowerCase())
         );
         const ifaceChoice = handleCancel(
-          await p15__namespace.select({
+          await p19__namespace.select({
             message: "Does this class implement a domain interface or abstract class?",
             options: [
               ...interfaces.map((i) => ({ value: i.name, label: i.name })),
@@ -2644,7 +2644,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
         );
         if (ifaceChoice === "__custom__") {
           implementsInterface = handleCancel(
-            await p15__namespace.text({
+            await p19__namespace.text({
               message: "Enter interface or abstract class name:",
               placeholder: "e.g. IUserRepository, BaseStorageAdapter",
               validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
@@ -2655,14 +2655,14 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
         }
       } else {
         const wantImpl = handleCancel(
-          await p15__namespace.confirm({
+          await p19__namespace.confirm({
             message: "Does this class implement a domain interface or abstract class?",
             initialValue: false
           })
         );
         if (wantImpl) {
           implementsInterface = handleCancel(
-            await p15__namespace.text({
+            await p19__namespace.text({
               message: "Enter interface or abstract class name:",
               placeholder: "e.g. IUserRepository, BaseStorageAdapter",
               validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
@@ -2682,7 +2682,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     const allInterfaces = listDomainInterfaces(projectRoot);
     if (allInterfaces.length > 0) {
       const ifaceChoice = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "Does this class implement an interface or abstract class?",
           options: [
             ...allInterfaces.map((i) => ({ value: i.name, label: `${i.name} (${i.feature})` })),
@@ -2694,7 +2694,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       );
       if (ifaceChoice === "__custom__") {
         implementsInterface = handleCancel(
-          await p15__namespace.text({
+          await p19__namespace.text({
             message: "Enter interface or abstract class name:",
             placeholder: "e.g. IAuthRepository",
             validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
@@ -2707,7 +2707,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   if (!flags.yes && !flags.kind) {
     kind = handleCancel(
-      await p15__namespace.select({
+      await p19__namespace.select({
         message: "Select implementation kind:",
         options: [
           { value: "stub", label: "In-Memory Stub (with in-memory store and test helper methods)" },
@@ -2718,7 +2718,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     );
     if (scope === "feature" && feature && implementsInterface) {
       registerInProvider = handleCancel(
-        await p15__namespace.confirm({
+        await p19__namespace.confirm({
           message: "Register this implementation in feature diProvider.ts?",
           initialValue: true
         })
@@ -2727,8 +2727,8 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   } else if (flags.yes && scope === "feature" && feature && implementsInterface) {
     registerInProvider = !flags.noProvider;
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating infrastructure class '${pc15__default.default.cyan(className)}'...`);
+  const s = p19__namespace.spinner();
+  s.start(`Generating infrastructure class '${pc13__default.default.cyan(className)}'...`);
   const files = [];
   const options = {
     name: className,
@@ -2763,7 +2763,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   s.stop("Infrastructure class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Infrastructure class '${className}' created!`));
+  p19__namespace.outro(pc13__default.default.green(`Infrastructure class '${className}' created!`));
 }
 async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2774,14 +2774,14 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p19__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2791,7 +2791,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2802,7 +2802,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   let name = interfaceNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Domain interface name:",
         placeholder: "e.g. IUserRepository, IPaymentService",
         validate: (v) => v && v.trim() ? void 0 : "Interface name cannot be empty"
@@ -2820,7 +2820,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   if (!flags.yes) {
     if (existingEntities.length > 0) {
       const selectedEntity = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "Select domain entity associated with this interface:",
           options: [
             ...existingEntities.map((e) => ({ value: e.name, label: e.name })),
@@ -2831,7 +2831,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       );
       if (selectedEntity === "__custom__") {
         entityName = handleCancel(
-          await p15__namespace.text({
+          await p19__namespace.text({
             message: "Enter entity name:",
             defaultValue: removeInterfacePrefix(ifaceName).replace(/Repository$|Service$/, "")
           })
@@ -2841,7 +2841,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       }
     }
     kind = handleCancel(
-      await p15__namespace.select({
+      await p19__namespace.select({
         message: "Interface definition style:",
         options: [
           { value: "abstractClass", label: "Abstract Class (Recommended - acts as DI token & type)" },
@@ -2851,7 +2851,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       })
     );
     methodsPreset = handleCancel(
-      await p15__namespace.select({
+      await p19__namespace.select({
         message: "Method signature preset:",
         options: [
           { value: "crud", label: "Standard CRUD (GetById, List, Create, Update, Delete)" },
@@ -2861,22 +2861,22 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       })
     );
     generateStub = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Auto-generate Infrastructure Stub implementation?",
         initialValue: true
       })
     );
     if (generateStub) {
       registerInProvider = handleCancel(
-        await p15__namespace.confirm({
+        await p19__namespace.confirm({
           message: "Auto-register interface & stub in feature diProvider.ts?",
           initialValue: true
         })
       );
     }
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating interface '${pc15__default.default.cyan(ifaceName)}'...`);
+  const s = p19__namespace.spinner();
+  s.start(`Generating interface '${pc13__default.default.cyan(ifaceName)}'...`);
   const files = [];
   const options = {
     name: ifaceName,
@@ -2925,7 +2925,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   }
   s.stop("Interface generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
+  p19__namespace.outro(pc13__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
 }
 async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2936,14 +2936,14 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p19__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2953,7 +2953,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2964,7 +2964,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   let name = handlerNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "HTTP Route Handler class name:",
         placeholder: "e.g. CreateUserHttp, GetUserHttp, HealthHttp",
         validate: (v) => v && v.trim() ? void 0 : "Handler name cannot be empty"
@@ -2983,7 +2983,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   let validationFields = [];
   if (!flags.yes) {
     method = handleCancel(
-      await p15__namespace.select({
+      await p19__namespace.select({
         message: "HTTP Method:",
         options: [
           { value: "get", label: "GET" },
@@ -2997,7 +2997,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     );
     const defaultPath = method === "get" ? "/" : "/";
     subPath = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Route subpath (relative to feature prefix):",
         initialValue: defaultPath,
         defaultValue: defaultPath
@@ -3008,7 +3008,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       const ucOptions = useCases.map((u) => ({ value: u.name, label: u.name }));
       ucOptions.push({ value: "__none__", label: "None / Standalone Handler" });
       const chosenUc = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "Connect this handler to a domain Use Case?",
           options: ucOptions,
           initialValue: ucOptions[0]?.value
@@ -3019,7 +3019,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       }
     }
     includeValidation = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: "Include Zod inbound request validation?",
         initialValue: method !== "delete"
       })
@@ -3027,7 +3027,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     if (includeValidation) {
       const defaultSource = method === "get" ? "query" : "body";
       validationSource = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "Validation data source:",
           options: [
             { value: "body", label: "req.body (for POST / PUT / PATCH payloads)" },
@@ -3041,8 +3041,8 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
         });
     }
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating HTTP handler '${pc15__default.default.cyan(className)}'...`);
+  const s = p19__namespace.spinner();
+  s.start(`Generating HTTP handler '${pc13__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -3060,7 +3060,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const files = generateHttpHandler(options);
   s.stop("HTTP handler generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
+  p19__namespace.outro(pc13__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
 }
 function generateInjectableCode(className, dependencies = [], methods = [], implementsInterface) {
   const formattedDeps = dependencies.map((dep) => ({
@@ -3070,7 +3070,7 @@ function generateInjectableCode(className, dependencies = [], methods = [], impl
   const formattedMethods = methods.map((m) => {
     const isAsync = m.async !== false;
     const retType = m.returnType ? isAsync ? `Promise<${m.returnType}>` : m.returnType : isAsync ? "Promise<void>" : "void";
-    const params = m.params && m.params.length > 0 ? m.params.map((p18) => `${p18.name}: ${p18.type}`).join(", ") : "";
+    const params = m.params && m.params.length > 0 ? m.params.map((p22) => `${p22.name}: ${p22.type}`).join(", ") : "";
     return {
       name: m.name,
       isAsync,
@@ -3140,7 +3140,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let name = classNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p19__namespace.text({
         message: "Injectable class name:",
         placeholder: "e.g. PasswordHasher, TokenService, UserTransformer",
         validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
@@ -3153,7 +3153,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let customPath;
   if (!flags.yes) {
     location = handleCancel(
-      await p15__namespace.select({
+      await p19__namespace.select({
         message: "Select target architectural location:",
         options: [
           { value: "feature-service", label: "Feature Service (features/<feature>/services/)" },
@@ -3171,14 +3171,14 @@ async function runInjectableCommand(classNameArg, flags = {}) {
           const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
           featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
           const selected = handleCancel(
-            await p15__namespace.select({
+            await p19__namespace.select({
               message: "Select target feature:",
               options: featureOptions
             })
           );
           if (selected === "__custom__") {
             feature = handleCancel(
-              await p15__namespace.text({
+              await p19__namespace.text({
                 message: "Enter feature name:",
                 validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
               })
@@ -3188,7 +3188,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
           }
         } else {
           feature = handleCancel(
-            await p15__namespace.text({
+            await p19__namespace.text({
               message: "Enter target feature name:",
               validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
             })
@@ -3198,7 +3198,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
       feature = toCamelCase(feature);
     } else if (location === "custom") {
       customPath = handleCancel(
-        await p15__namespace.text({
+        await p19__namespace.text({
           message: "Enter destination directory path:",
           placeholder: "e.g. src/services or lib/utils",
           validate: (v) => v && v.trim() ? void 0 : "Path cannot be empty"
@@ -3209,14 +3209,14 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let generateInterface2 = false;
   if (!flags.yes) {
     generateInterface2 = handleCancel(
-      await p15__namespace.confirm({
+      await p19__namespace.confirm({
         message: `Generate abstract class interface (I${className}) as runtime DI token?`,
         initialValue: false
       })
     );
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating injectable '${pc15__default.default.cyan(className)}'...`);
+  const s = p19__namespace.spinner();
+  s.start(`Generating injectable '${pc13__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -3230,17 +3230,17 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   const files = generateInjectable(options);
   s.stop("Injectable class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Injectable '${className}' created successfully!`));
+  p19__namespace.outro(pc13__default.default.green(`Injectable '${className}' created successfully!`));
 }
-async function runEnvCommand(flags = {}) {
+async function runEnvInit(flags = {}) {
   const projectRoot = flags.cwd || flags.targetDir || findProjectRoot();
-  const s = p15__namespace.spinner();
+  const s = p19__namespace.spinner();
   s.start("Scanning for .example environment files...");
-  const files = fs10__default.default.readdirSync(projectRoot);
+  const files = fs14__default.default.readdirSync(projectRoot);
   const exampleFiles = files.filter((file) => file.startsWith(".env") && file.endsWith(".example")).sort();
   if (exampleFiles.length === 0) {
     s.stop("No .example files found.");
-    p15__namespace.log.info(pc15__default.default.yellow(`No files matching '.env*.example' were found in ${projectRoot}`));
+    p19__namespace.log.info(pc13__default.default.yellow(`No files matching '.env*.example' were found in ${projectRoot}`));
     return [];
   }
   s.message(`Found ${exampleFiles.length} template(s). Generating...`);
@@ -3249,25 +3249,667 @@ async function runEnvCommand(flags = {}) {
     const sourcePath = path2__default.default.join(projectRoot, exampleFile);
     const targetFile = exampleFile.replace(/\.example$/, "");
     const targetPath = path2__default.default.join(projectRoot, targetFile);
-    const content = fs10__default.default.readFileSync(sourcePath, "utf-8");
+    let overwrite = flags.overwrite;
+    if (overwrite === void 0 && !flags.dryRun && !flags.yes && !process.env.VITEST && process.stdin.isTTY && fs14__default.default.existsSync(targetPath)) {
+      overwrite = await p19__namespace.confirm({
+        message: `${targetFile} already exists. Overwrite?`,
+        initialValue: false
+      });
+      if (p19__namespace.isCancel(overwrite)) {
+        p19__namespace.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+    }
+    const content = fs14__default.default.readFileSync(sourcePath, "utf-8");
     const genFile = writeFileSafely(targetPath, content, {
       projectRoot,
       dryRun: Boolean(flags.dryRun),
-      overwrite: Boolean(flags.overwrite)
+      overwrite: Boolean(overwrite)
     });
     generatedFiles.push(genFile);
   }
   s.stop("Environment files processed!");
   printGeneratedFiles(generatedFiles, Boolean(flags.dryRun));
-  p15__namespace.outro(pc15__default.default.green("\u2713 Local environment files are ready!"));
+  p19__namespace.outro(pc13__default.default.green("\u2713 Local environment files are ready!"));
+  return generatedFiles;
+}
+var EnvEditor = class {
+  lines;
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.lines = fs14__default.default.existsSync(filePath) ? fs14__default.default.readFileSync(filePath, "utf-8").split(/\r?\n/) : [];
+  }
+  getLines() {
+    return [...this.lines];
+  }
+  getKeys() {
+    return this.lines.filter((line) => line.trim() && !line.trim().startsWith("#")).map((line) => {
+      const eqIdx = line.indexOf("=");
+      return eqIdx !== -1 ? line.substring(0, eqIdx).trim() : line.trim();
+    }).filter(Boolean);
+  }
+  getValue(key) {
+    const line = this.lines.find((l) => {
+      const trimmed = l.trim();
+      if (trimmed.startsWith("#") || !trimmed) return false;
+      const eqIdx = l.indexOf("=");
+      const k = eqIdx !== -1 ? l.substring(0, eqIdx).trim() : l.trim();
+      return k === key;
+    });
+    if (!line) return null;
+    const eqIndex = line.indexOf("=");
+    return eqIndex !== -1 ? line.substring(eqIndex + 1).trim() : "";
+  }
+  has(key) {
+    return this.getKeys().includes(key);
+  }
+  set(key, value) {
+    const newLine = `${key}=${value}`;
+    const index = this.lines.findIndex((l) => {
+      const trimmed = l.trim();
+      if (trimmed.startsWith("#") || !trimmed) return false;
+      const eqIdx = l.indexOf("=");
+      const k = eqIdx !== -1 ? l.substring(0, eqIdx).trim() : l.trim();
+      return k === key;
+    });
+    if (index !== -1) {
+      this.lines[index] = newLine;
+    } else {
+      if (this.lines.length > 0 && this.lines[this.lines.length - 1] !== "") {
+        this.lines.push("");
+      }
+      this.lines.push(newLine);
+    }
+  }
+  delete(key) {
+    const initialLen = this.lines.length;
+    this.lines = this.lines.filter((l) => {
+      const trimmed = l.trim();
+      if (trimmed.startsWith("#") || !trimmed) return true;
+      const eqIdx = l.indexOf("=");
+      const k = eqIdx !== -1 ? l.substring(0, eqIdx).trim() : l.trim();
+      return k !== key;
+    });
+    return this.lines.length !== initialLen;
+  }
+  redactAll() {
+    this.lines = this.lines.map((line) => {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#") || !trimmed) return line;
+      const eqIndex = line.indexOf("=");
+      return eqIndex !== -1 ? line.substring(0, eqIndex + 1) : line;
+    });
+  }
+  save() {
+    const dir = path2__default.default.dirname(this.filePath);
+    if (!fs14__default.default.existsSync(dir)) {
+      fs14__default.default.mkdirSync(dir, { recursive: true });
+    }
+    fs14__default.default.writeFileSync(this.filePath, this.lines.join("\n"), "utf-8");
+  }
+};
+function discoverEnvironments(projectRoot) {
+  if (!fs14__default.default.existsSync(projectRoot)) {
+    return ["local", "dev", "prod"];
+  }
+  const files = fs14__default.default.readdirSync(projectRoot);
+  const envs = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (file.startsWith(".env")) {
+      const cleanName = file.replace(/\.example$/, "");
+      const match = cleanName.match(/^\.env\.([a-zA-Z0-9_-]+)$/);
+      if (match && match[1]) {
+        envs.add(match[1]);
+      } else if (cleanName === ".env") {
+        envs.add("local");
+      }
+    }
+  }
+  return envs.size > 0 ? Array.from(envs) : ["local", "dev", "prod"];
+}
+function resolveEnvFilename(envName, isExample = false) {
+  const base = envName === "local" ? ".env" : `.env.${envName}`;
+  return isExample ? `${base}.example` : base;
+}
+
+// src/commands/env/initExamples.ts
+async function runEnvInitExamples(flags = {}) {
+  const projectRoot = flags.cwd || flags.targetDir || findProjectRoot();
+  const s = p19__namespace.spinner();
+  s.start("Scanning for local environment files...");
+  const files = fs14__default.default.readdirSync(projectRoot, { withFileTypes: true });
+  const envFiles = files.filter((dirent) => dirent.isFile() && dirent.name.startsWith(".env") && !dirent.name.endsWith(".example")).map((dirent) => dirent.name).sort();
+  if (envFiles.length === 0) {
+    s.stop("No local .env files found.");
+    p19__namespace.log.info(pc13__default.default.yellow(`No files matching '.env*' were found in ${projectRoot}`));
+    return [];
+  }
+  s.message(`Found ${envFiles.length} local .env file(s). Generating templates...`);
+  const generatedFiles = [];
+  for (const envFile of envFiles) {
+    const sourcePath = path2__default.default.join(projectRoot, envFile);
+    const targetFile = `${envFile}.example`;
+    const targetPath = path2__default.default.join(projectRoot, targetFile);
+    let overwrite = flags.overwrite;
+    if (overwrite === void 0 && !flags.dryRun && !flags.yes && !process.env.VITEST && process.stdin.isTTY && fs14__default.default.existsSync(targetPath)) {
+      overwrite = await p19__namespace.confirm({
+        message: `${targetFile} already exists. Overwrite with redacted values?`,
+        initialValue: true
+      });
+      if (p19__namespace.isCancel(overwrite)) {
+        p19__namespace.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+    }
+    const editor = new EnvEditor(sourcePath);
+    editor.redactAll();
+    const redactedContent = editor.getLines().join("\n");
+    const genFile = writeFileSafely(targetPath, redactedContent, {
+      projectRoot,
+      dryRun: Boolean(flags.dryRun),
+      overwrite: Boolean(overwrite)
+    });
+    generatedFiles.push(genFile);
+  }
+  s.stop("Environment example templates generated!");
+  printGeneratedFiles(generatedFiles, Boolean(flags.dryRun));
+  p19__namespace.outro(pc13__default.default.green("\u2713 .env*.example files are up to date and safely redacted!"));
   return generatedFiles;
 }
+function isInteractive(flags) {
+  if (flags.yes || Boolean(flags.nonInteractive)) return false;
+  if (process.env.VITEST) return false;
+  return Boolean(process.stdin.isTTY);
+}
+function getAllExistingKeys(projectRoot, envs) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const env of envs) {
+    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
+    if (fs14__default.default.existsSync(localPath)) {
+      new EnvEditor(localPath).getKeys().forEach((k) => keys.add(k));
+    }
+    if (fs14__default.default.existsSync(examplePath)) {
+      new EnvEditor(examplePath).getKeys().forEach((k) => keys.add(k));
+    }
+  }
+  return Array.from(keys).sort();
+}
+async function runEnvAdd(key, value, flags = {}) {
+  const projectRoot = flags.cwd || flags.targetDir || findProjectRoot();
+  const allEnvs = discoverEnvironments(projectRoot);
+  let targetKey = key?.trim();
+  if (!targetKey) {
+    if (!isInteractive(flags)) {
+      throw new Error("Variable key is required for 'mason env add <key> [value]'");
+    }
+    targetKey = handleCancel(
+      await p19__namespace.text({
+        message: "Enter the variable key name:",
+        placeholder: "e.g. DATABASE_URL, STRIPE_KEY, PORT",
+        validate: (val) => {
+          if (!val || !val.trim()) return "Variable key name cannot be empty";
+          if (/\s/.test(val.trim())) return "Variable key cannot contain spaces";
+          if (val.includes("=")) return "Variable key cannot contain '='";
+          return void 0;
+        }
+      })
+    ).trim();
+  }
+  let targetEnvs = [];
+  if (flags.env) {
+    targetEnvs = String(flags.env).split(",").map((s) => s.trim()).filter(Boolean);
+  } else if (!isInteractive(flags)) {
+    targetEnvs = allEnvs;
+  } else {
+    targetEnvs = handleCancel(
+      await p19__namespace.multiselect({
+        message: `Which environments should receive ${pc13__default.default.bold(targetKey)}?`,
+        options: allEnvs.map((env) => ({
+          value: env,
+          label: env === "local" ? "local (.env)" : `${env} (.env.${env})`
+        })),
+        initialValues: allEnvs,
+        required: true
+      })
+    );
+  }
+  if (targetEnvs.length === 0) {
+    p19__namespace.log.warn("No environments selected. Nothing was changed.");
+    return { key: targetKey, environments: [] };
+  }
+  for (const env of targetEnvs) {
+    let envVal = value;
+    if (envVal === void 0) {
+      if (!isInteractive(flags)) {
+        envVal = "";
+      } else {
+        envVal = handleCancel(
+          await p19__namespace.text({
+            message: `Value for ${pc13__default.default.cyan(targetKey)} in ${pc13__default.default.bold(env)} (${resolveEnvFilename(env)})?`,
+            initialValue: "",
+            placeholder: "Leave empty for blank value"
+          })
+        );
+      }
+    } else if (isInteractive(flags) && !flags.yes) {
+      envVal = handleCancel(
+        await p19__namespace.text({
+          message: `Value for ${pc13__default.default.cyan(targetKey)} in ${pc13__default.default.bold(env)} (${resolveEnvFilename(env)})?`,
+          initialValue: value ?? "",
+          placeholder: "Leave empty for blank value"
+        })
+      );
+    }
+    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
+    if (flags.dryRun) {
+      p19__namespace.log.info(
+        pc13__default.default.cyan(`[DRY RUN] Would set ${targetKey}=${envVal} in ${resolveEnvFilename(env, false)}`)
+      );
+      p19__namespace.log.info(
+        pc13__default.default.cyan(`[DRY RUN] Would add ${targetKey}= to ${resolveEnvFilename(env, true)}`)
+      );
+    } else {
+      const localEditor = new EnvEditor(localPath);
+      localEditor.set(targetKey, envVal);
+      localEditor.save();
+      const exampleEditor = new EnvEditor(examplePath);
+      exampleEditor.set(targetKey, "");
+      exampleEditor.save();
+    }
+  }
+  if (!flags.dryRun) {
+    p19__namespace.log.success(
+      pc13__default.default.green(
+        `\u2713 Added ${pc13__default.default.bold(targetKey)} to [${targetEnvs.join(", ")}] and updated .example templates.`
+      )
+    );
+  }
+  return { key: targetKey, environments: targetEnvs };
+}
+async function runEnvUpdate(key, value, flags = {}) {
+  const projectRoot = flags.cwd || flags.targetDir || findProjectRoot();
+  const allEnvs = discoverEnvironments(projectRoot);
+  const existingKeys = getAllExistingKeys(projectRoot, allEnvs);
+  let targetKey = key?.trim();
+  if (!targetKey) {
+    if (!isInteractive(flags)) {
+      throw new Error("Variable key is required for 'mason env update <key> [value]'");
+    }
+    if (existingKeys.length === 0) {
+      p19__namespace.log.error(pc13__default.default.red("No environment variables found to update."));
+      return { key: "", environments: [] };
+    }
+    targetKey = handleCancel(
+      await p19__namespace.select({
+        message: "Select a variable to update:",
+        options: existingKeys.map((k) => ({ value: k, label: k }))
+      })
+    );
+  }
+  const envsWithKey = allEnvs.filter((env) => {
+    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    return fs14__default.default.existsSync(localPath) && new EnvEditor(localPath).has(targetKey);
+  });
+  let targetEnvs = [];
+  if (flags.env) {
+    targetEnvs = String(flags.env).split(",").map((s) => s.trim()).filter(Boolean);
+  } else if (!isInteractive(flags)) {
+    targetEnvs = envsWithKey.length > 0 ? envsWithKey : allEnvs;
+  } else {
+    targetEnvs = handleCancel(
+      await p19__namespace.multiselect({
+        message: `Which environments should be updated for ${pc13__default.default.bold(targetKey)}?`,
+        options: allEnvs.map((env) => ({
+          value: env,
+          label: env === "local" ? "local (.env)" : `${env} (.env.${env})`,
+          hint: envsWithKey.includes(env) ? "currently exists" : "not set"
+        })),
+        initialValues: envsWithKey.length > 0 ? envsWithKey : allEnvs,
+        required: true
+      })
+    );
+  }
+  if (targetEnvs.length === 0) {
+    p19__namespace.log.warn("No environments selected. Nothing was changed.");
+    return { key: targetKey, environments: [] };
+  }
+  for (const env of targetEnvs) {
+    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const localEditor = new EnvEditor(localPath);
+    const currentVal = localEditor.getValue(targetKey);
+    let newVal = value;
+    if (newVal === void 0) {
+      if (!isInteractive(flags)) {
+        newVal = currentVal ?? "";
+      } else {
+        newVal = handleCancel(
+          await p19__namespace.text({
+            message: `New value for ${pc13__default.default.cyan(targetKey)} in ${pc13__default.default.bold(env)}? (Current: "${currentVal ?? ""}")`,
+            initialValue: currentVal ?? ""
+          })
+        );
+      }
+    } else if (isInteractive(flags) && !flags.yes) {
+      newVal = handleCancel(
+        await p19__namespace.text({
+          message: `New value for ${pc13__default.default.cyan(targetKey)} in ${pc13__default.default.bold(env)}? (Current: "${currentVal ?? ""}")`,
+          initialValue: value ?? currentVal ?? ""
+        })
+      );
+    }
+    if (flags.dryRun) {
+      p19__namespace.log.info(
+        pc13__default.default.cyan(`[DRY RUN] Would update ${targetKey}=${newVal} in ${resolveEnvFilename(env, false)}`)
+      );
+    } else {
+      localEditor.set(targetKey, newVal);
+      localEditor.save();
+      const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
+      const exampleEditor = new EnvEditor(examplePath);
+      if (!exampleEditor.has(targetKey)) {
+        exampleEditor.set(targetKey, "");
+        exampleEditor.save();
+      }
+    }
+  }
+  if (!flags.dryRun) {
+    p19__namespace.log.success(
+      pc13__default.default.green(`\u2713 Updated ${pc13__default.default.bold(targetKey)} in [${targetEnvs.join(", ")}].`)
+    );
+  }
+  return { key: targetKey, environments: targetEnvs };
+}
+async function runEnvDelete(key, flags = {}) {
+  const projectRoot = flags.cwd || flags.targetDir || findProjectRoot();
+  const allEnvs = discoverEnvironments(projectRoot);
+  const existingKeys = getAllExistingKeys(projectRoot, allEnvs);
+  let targetKey = key?.trim();
+  if (!targetKey) {
+    if (!isInteractive(flags)) {
+      throw new Error("Variable key is required for 'mason env delete <key>'");
+    }
+    if (existingKeys.length === 0) {
+      p19__namespace.log.error(pc13__default.default.red("No environment variables found to delete."));
+      return { key: "", environments: [] };
+    }
+    targetKey = handleCancel(
+      await p19__namespace.select({
+        message: "Select a variable to delete:",
+        options: existingKeys.map((k) => ({ value: k, label: k }))
+      })
+    );
+  }
+  const envsWithKey = allEnvs.filter((env) => {
+    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
+    return fs14__default.default.existsSync(localPath) && new EnvEditor(localPath).has(targetKey) || fs14__default.default.existsSync(examplePath) && new EnvEditor(examplePath).has(targetKey);
+  });
+  let targetEnvs = [];
+  if (flags.env) {
+    targetEnvs = String(flags.env).split(",").map((s) => s.trim()).filter(Boolean);
+  } else if (!isInteractive(flags)) {
+    targetEnvs = envsWithKey.length > 0 ? envsWithKey : allEnvs;
+  } else {
+    targetEnvs = handleCancel(
+      await p19__namespace.multiselect({
+        message: `Which environments should remove ${pc13__default.default.bold(targetKey)}?`,
+        options: allEnvs.map((env) => ({
+          value: env,
+          label: env === "local" ? "local (.env)" : `${env} (.env.${env})`,
+          ...envsWithKey.includes(env) ? { hint: "currently present" } : {}
+        })),
+        initialValues: envsWithKey.length > 0 ? envsWithKey : allEnvs,
+        required: true
+      })
+    );
+  }
+  if (targetEnvs.length === 0) {
+    p19__namespace.log.warn("No environments selected. Nothing was deleted.");
+    return { key: targetKey, environments: [] };
+  }
+  if (isInteractive(flags) && !flags.yes) {
+    const confirm13 = handleCancel(
+      await p19__namespace.confirm({
+        message: `Are you sure you want to delete ${pc13__default.default.bold(targetKey)} from ${targetEnvs.join(", ")} and their .example templates?`,
+        initialValue: false
+      })
+    );
+    if (!confirm13) {
+      p19__namespace.log.warn("Operation cancelled.");
+      return { key: targetKey, environments: [] };
+    }
+  }
+  for (const env of targetEnvs) {
+    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
+    if (flags.dryRun) {
+      p19__namespace.log.info(
+        pc13__default.default.cyan(`[DRY RUN] Would delete ${targetKey} from ${resolveEnvFilename(env, false)} and ${resolveEnvFilename(env, true)}`)
+      );
+    } else {
+      if (fs14__default.default.existsSync(localPath)) {
+        const localEditor = new EnvEditor(localPath);
+        localEditor.delete(targetKey);
+        localEditor.save();
+      }
+      if (fs14__default.default.existsSync(examplePath)) {
+        const exampleEditor = new EnvEditor(examplePath);
+        exampleEditor.delete(targetKey);
+        exampleEditor.save();
+      }
+    }
+  }
+  if (!flags.dryRun) {
+    p19__namespace.log.success(
+      pc13__default.default.green(`\u2713 Deleted ${pc13__default.default.bold(targetKey)} from [${targetEnvs.join(", ")}] and .example templates.`)
+    );
+  }
+  return { key: targetKey, environments: targetEnvs };
+}
+async function runEnvAudit(flags = {}) {
+  const projectRoot = flags.cwd || flags.targetDir || findProjectRoot();
+  const envs = discoverEnvironments(projectRoot);
+  p19__namespace.intro(pc13__default.default.bgCyan(pc13__default.default.black(" mason env audit ")));
+  const items = [];
+  let totalIssues = 0;
+  let hasDrift = false;
+  let hasErrors = false;
+  for (const env of envs) {
+    const localFile = resolveEnvFilename(env, false);
+    const exampleFile = resolveEnvFilename(env, true);
+    const localPath = path2__default.default.join(projectRoot, localFile);
+    const examplePath = path2__default.default.join(projectRoot, exampleFile);
+    const localExists = fs14__default.default.existsSync(localPath);
+    const exampleExists = fs14__default.default.existsSync(examplePath);
+    const localEditor = new EnvEditor(localPath);
+    const exampleEditor = new EnvEditor(examplePath);
+    const localKeys = localExists ? localEditor.getKeys() : [];
+    const exampleKeys = exampleExists ? exampleEditor.getKeys() : [];
+    const missingInLocal = exampleKeys.filter((k) => !localKeys.includes(k));
+    const missingInExample = localKeys.filter((k) => !exampleKeys.includes(k));
+    const emptyLocals = localKeys.filter((k) => {
+      const val = localEditor.getValue(k);
+      return val === "" || val === null;
+    });
+    const envIssues = (!localExists ? 1 : 0) + (!exampleExists ? 1 : 0) + missingInLocal.length + missingInExample.length + emptyLocals.length;
+    totalIssues += envIssues;
+    if (missingInExample.length > 0 || !exampleExists) hasDrift = true;
+    if (missingInLocal.length > 0 || !localExists) hasErrors = true;
+    items.push({
+      env,
+      localFile,
+      exampleFile,
+      localExists,
+      exampleExists,
+      missingInLocal,
+      missingInExample,
+      emptyLocals
+    });
+    if (!localExists && !exampleExists) {
+      p19__namespace.log.warn(
+        pc13__default.default.yellow(`\u25B2 ${pc13__default.default.bold(env)}: Neither '${localFile}' nor '${exampleFile}' exist.`)
+      );
+      continue;
+    }
+    if (!localExists) {
+      p19__namespace.log.error(
+        pc13__default.default.red(`\u2717 ${pc13__default.default.bold(env)}: Local file '${localFile}' is missing! Run 'mason env init' to create it.`)
+      );
+      continue;
+    }
+    if (!exampleExists) {
+      p19__namespace.log.warn(
+        pc13__default.default.yellow(`\u25B2 ${pc13__default.default.bold(env)}: Template '${exampleFile}' is missing! Run 'mason env init-examples' to generate it.`)
+      );
+      continue;
+    }
+    if (envIssues === 0) {
+      p19__namespace.log.success(
+        pc13__default.default.green(`\u2713 ${pc13__default.default.bold(env)} (${localFile} \u2194 ${exampleFile}): All ${localKeys.length} keys in sync!`)
+      );
+    } else {
+      p19__namespace.log.step(
+        pc13__default.default.bold(pc13__default.default.cyan(`Environment: ${env} (${localFile} \u2194 ${exampleFile})`))
+      );
+      if (missingInLocal.length > 0) {
+        p19__namespace.log.error(
+          pc13__default.default.red(`  \u25CF Missing locally (${missingInLocal.length} in template but missing in ${localFile}):`)
+        );
+        for (const k of missingInLocal) {
+          p19__namespace.log.message(pc13__default.default.red(`    - ${k}`));
+        }
+      }
+      if (missingInExample.length > 0) {
+        p19__namespace.log.warn(
+          pc13__default.default.yellow(`  \u25CF Template drift (${missingInExample.length} local keys missing in ${exampleFile}):`)
+        );
+        for (const k of missingInExample) {
+          p19__namespace.log.message(pc13__default.default.yellow(`    - ${k}`));
+        }
+      }
+      if (emptyLocals.length > 0) {
+        p19__namespace.log.info(
+          pc13__default.default.dim(`  \u25B2 Empty values (${emptyLocals.length} defined with blank value in ${localFile}):`)
+        );
+        for (const k of emptyLocals) {
+          p19__namespace.log.message(pc13__default.default.dim(`    - ${k}`));
+        }
+      }
+    }
+  }
+  if (totalIssues === 0) {
+    p19__namespace.outro(pc13__default.default.green("\u2713 All environment files are in sync! No drift detected."));
+  } else {
+    p19__namespace.outro(
+      pc13__default.default.yellow(`Found ${totalIssues} environment issue(s) across inspected environments.`)
+    );
+  }
+  return {
+    hasDrift,
+    hasErrors,
+    totalIssues,
+    items
+  };
+}
+
+// src/commands/env/index.ts
+async function runEnvMenu(flags = {}) {
+  const task = handleCancel(
+    await p19__namespace.select({
+      message: "What environment task do you want to run?",
+      options: [
+        {
+          value: "add",
+          label: "Add Variable",
+          hint: "Add a new key across selected environments and sync .example templates"
+        },
+        {
+          value: "update",
+          label: "Update Variable",
+          hint: "Update an existing variable value across environments"
+        },
+        {
+          value: "delete",
+          label: "Delete Variable",
+          hint: "Delete a variable from .env and .example files"
+        },
+        {
+          value: "audit",
+          label: "Audit Drift",
+          hint: "Scan for missing keys, uncommitted secrets, or template drift"
+        },
+        {
+          value: "init",
+          label: "Init Files (.env)",
+          hint: "Clone .env*.example templates to local .env files"
+        },
+        {
+          value: "init-examples",
+          label: "Init Templates (.env.example)",
+          hint: "Safely clone and redact local .env files to .example templates"
+        }
+      ]
+    })
+  );
+  switch (task) {
+    case "add":
+      return await runEnvAdd(void 0, void 0, flags);
+    case "update":
+      return await runEnvUpdate(void 0, void 0, flags);
+    case "delete":
+      return await runEnvDelete(void 0, flags);
+    case "audit":
+      return await runEnvAudit(flags);
+    case "init":
+      return await runEnvInit(flags);
+    case "init-examples":
+      return await runEnvInitExamples(flags);
+  }
+}
+async function handleEnv(subcommand, args = [], flags = {}) {
+  if (!subcommand) {
+    return await runEnvMenu(flags);
+  }
+  const normalized = subcommand.trim().toLowerCase();
+  switch (normalized) {
+    case "init":
+      return await runEnvInit(flags);
+    case "init-examples":
+    case "initexamples":
+      return await runEnvInitExamples(flags);
+    case "add":
+      return await runEnvAdd(args[0], args[1], flags);
+    case "update":
+      return await runEnvUpdate(args[0], args[1], flags);
+    case "delete":
+    case "remove":
+    case "rm":
+      return await runEnvDelete(args[0], flags);
+    case "audit":
+      return await runEnvAudit(flags);
+    default:
+      p19__namespace.log.error(
+        pc13__default.default.red(
+          `Unknown env subcommand: "${subcommand}". Allowed subcommands: init, init-examples, add, update, delete, audit.`
+        )
+      );
+      if (process.env.VITEST) {
+        throw new Error(
+          `Unknown env subcommand: "${subcommand}". Allowed subcommands: init, init-examples, add, update, delete, audit.`
+        );
+      }
+      process.exit(1);
+  }
+}
 
 // src/commands/menu.ts
 async function runInteractiveMenu(flags = {}) {
   printBanner();
   const choice = handleCancel(
-    await p15__namespace.select({
+    await p19__namespace.select({
       message: "What would you like to create in your architecture?",
       options: [
         {
@@ -3312,8 +3954,8 @@ async function runInteractiveMenu(flags = {}) {
         },
         {
           value: "env",
-          label: "Generate Env Files",
-          hint: "Clone .env*.example files to local .env equivalents"
+          label: "Environment Variables",
+          hint: "Manage .env files, add/delete keys, and sync templates"
         }
       ]
     })
@@ -3344,7 +3986,7 @@ async function runInteractiveMenu(flags = {}) {
       await runInjectableCommand(void 0, flags);
       break;
     case "env":
-      await runEnvCommand(flags);
+      await runEnvMenu(flags);
       break;
   }
 }
@@ -3383,8 +4025,8 @@ async function handleCreate(type, name, flags = {}) {
       await runInjectableCommand(name, flags);
       break;
     default:
-      p15__namespace.log.error(
-        pc15__default.default.red(
+      p19__namespace.log.error(
+        pc13__default.default.red(
           `Unknown component type: "${type}". Allowed types: feature, shared, usecase, domain, infrastructure, interface, httpHandler, injectable.`
         )
       );
@@ -3416,7 +4058,7 @@ function findLocalRegistry(startDir = process.cwd()) {
   let current = path2__default.default.resolve(startDir);
   while (true) {
     const candidate = path2__default.default.join(current, "mason-registry");
-    if (fs10__default.default.existsSync(candidate) && fs10__default.default.existsSync(path2__default.default.join(candidate, "index.json"))) {
+    if (fs14__default.default.existsSync(candidate) && fs14__default.default.existsSync(path2__default.default.join(candidate, "index.json"))) {
       return candidate;
     }
     const parent = path2__default.default.dirname(current);
@@ -3438,9 +4080,9 @@ function getRegistryBase(projectRoot, override) {
     path2__default.default.join(process.cwd(), "mason.config.json")
   ];
   for (const configPath of configLocations) {
-    if (fs10__default.default.existsSync(configPath)) {
+    if (fs14__default.default.existsSync(configPath)) {
       try {
-        const config = JSON.parse(fs10__default.default.readFileSync(configPath, "utf-8"));
+        const config = JSON.parse(fs14__default.default.readFileSync(configPath, "utf-8"));
         if (config.registry && typeof config.registry === "string") {
           return normalizeRegistryUrl(config.registry.trim(), path2__default.default.dirname(configPath));
         }
@@ -3453,9 +4095,9 @@ function getRegistryBase(projectRoot, override) {
     path2__default.default.join(process.cwd(), "package.json")
   ];
   for (const pkgPath of pkgLocations) {
-    if (fs10__default.default.existsSync(pkgPath)) {
+    if (fs14__default.default.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs10__default.default.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs14__default.default.readFileSync(pkgPath, "utf-8"));
         if (pkg.mason?.registry && typeof pkg.mason.registry === "string") {
           return normalizeRegistryUrl(pkg.mason.registry.trim(), path2__default.default.dirname(pkgPath));
         }
@@ -3506,15 +4148,15 @@ async function fetchRegistryFile(registryBase, relPath) {
     baseDir = url.fileURLToPath(baseDir);
   }
   let filePath = path2__default.default.resolve(baseDir, cleanRelPath);
-  if (!fs10__default.default.existsSync(filePath)) {
+  if (!fs14__default.default.existsSync(filePath)) {
     const inSrcPath = path2__default.default.resolve(baseDir, "src", cleanRelPath);
-    if (fs10__default.default.existsSync(inSrcPath)) {
+    if (fs14__default.default.existsSync(inSrcPath)) {
       filePath = inSrcPath;
     } else {
       throw new Error(`Registry file not found at ${filePath}`);
     }
   }
-  return fs10__default.default.promises.readFile(filePath, "utf-8");
+  return fs14__default.default.promises.readFile(filePath, "utf-8");
 }
 async function fetchRegistryIndex(registryBase) {
   const content = await fetchRegistryFile(registryBase, "index.json");
@@ -3576,26 +4218,26 @@ function findClosestMatch(target, candidates) {
   return null;
 }
 function detectPackageManager(projectRoot) {
-  if (fs10__default.default.existsSync(path2__default.default.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs10__default.default.existsSync(path2__default.default.join(projectRoot, "yarn.lock"))) return "yarn";
-  if (fs10__default.default.existsSync(path2__default.default.join(projectRoot, "bun.lockb")) || fs10__default.default.existsSync(path2__default.default.join(projectRoot, "bun.lock"))) return "bun";
+  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "bun.lockb")) || fs14__default.default.existsSync(path2__default.default.join(projectRoot, "bun.lock"))) return "bun";
   return "npm";
 }
 function getMissingNpmPackages(projectRoot, requiredPackages) {
   if (!requiredPackages || requiredPackages.length === 0) return [];
   const pkgJsonPath = path2__default.default.join(projectRoot, "package.json");
-  if (!fs10__default.default.existsSync(pkgJsonPath)) {
+  if (!fs14__default.default.existsSync(pkgJsonPath)) {
     return requiredPackages;
   }
   try {
-    const pkg = JSON.parse(fs10__default.default.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs14__default.default.readFileSync(pkgJsonPath, "utf-8"));
     const installed = /* @__PURE__ */ new Set([
       ...Object.keys(pkg.dependencies || {}),
       ...Object.keys(pkg.devDependencies || {}),
       ...Object.keys(pkg.peerDependencies || {})
     ]);
-    return requiredPackages.filter((p18) => {
-      const nameOnly = p18.startsWith("@") ? `@${p18.slice(1).split("@")[0] || ""}` : p18.split("@")[0] || p18;
+    return requiredPackages.filter((p22) => {
+      const nameOnly = p22.startsWith("@") ? `@${p22.slice(1).split("@")[0] || ""}` : p22.split("@")[0] || p22;
       return !installed.has(nameOnly);
     });
   } catch {
@@ -3620,15 +4262,15 @@ function installNpmPackages(projectRoot, packages, pm) {
       installCmd = `npm install ${packages.join(" ")}`;
       break;
   }
-  p15__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc15__default.default.cyan(packages.join(", "))}`);
+  p19__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc13__default.default.cyan(packages.join(", "))}`);
   child_process.execSync(installCmd, {
     cwd: projectRoot,
     stdio: "inherit"
   });
 }
 function getAllFiles(dir, baseDir = dir) {
-  if (!fs10__default.default.existsSync(dir)) return [];
-  const entries = fs10__default.default.readdirSync(dir, { withFileTypes: true });
+  if (!fs14__default.default.existsSync(dir)) return [];
+  const entries = fs14__default.default.readdirSync(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const fullPath = path2__default.default.join(dir, entry.name);
@@ -3648,13 +4290,13 @@ function getAllFiles(dir, baseDir = dir) {
   return files.sort();
 }
 function computeDirectoryHash(dirPath, files) {
-  if (!fs10__default.default.existsSync(dirPath)) return "";
+  if (!fs14__default.default.existsSync(dirPath)) return "";
   const hash = crypto.createHash("sha256");
   const fileList = (getAllFiles(dirPath)).sort();
   for (const relativePath of fileList) {
     const absolutePath = path2__default.default.join(dirPath, relativePath);
-    if (!fs10__default.default.existsSync(absolutePath)) continue;
-    const content = fs10__default.default.readFileSync(absolutePath, "utf8");
+    if (!fs14__default.default.existsSync(absolutePath)) continue;
+    const content = fs14__default.default.readFileSync(absolutePath, "utf8");
     const normalizedContent = content.replace(/\r\n/g, "\n");
     hash.update(relativePath);
     hash.update(normalizedContent);
@@ -3664,9 +4306,9 @@ function computeDirectoryHash(dirPath, files) {
 
 // src/commands/import.ts
 var importPrompts = {
-  select: p15__namespace.select,
-  text: p15__namespace.text,
-  confirm: p15__namespace.confirm
+  select: p19__namespace.select,
+  text: p19__namespace.text,
+  confirm: p19__namespace.confirm
 };
 function isTestFile(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
@@ -3698,11 +4340,11 @@ function getExistingModuleDir(projectRoot, modType, modName) {
   const folder = modType === "shared" ? "shared" : "features";
   const configuredDir = modType === "shared" ? getConfiguredSharedDir(projectRoot) : getConfiguredFeaturesDir(projectRoot);
   const inConfigured = path2__default.default.join(configuredDir, modName);
-  if (fs10__default.default.existsSync(inConfigured)) return inConfigured;
+  if (fs14__default.default.existsSync(inConfigured)) return inConfigured;
   const inSrc = path2__default.default.join(projectRoot, "src", folder, modName);
-  if (fs10__default.default.existsSync(inSrc)) return inSrc;
+  if (fs14__default.default.existsSync(inSrc)) return inSrc;
   const inRoot = path2__default.default.join(projectRoot, folder, modName);
-  if (fs10__default.default.existsSync(inRoot)) return inRoot;
+  if (fs14__default.default.existsSync(inRoot)) return inRoot;
   return null;
 }
 function checkModuleExists(projectRoot, modType, modName) {
@@ -3718,9 +4360,9 @@ function getAvailableLocalModules(projectRoot, modType) {
   ];
   const set = /* @__PURE__ */ new Set();
   for (const dir of dirs) {
-    if (fs10__default.default.existsSync(dir)) {
+    if (fs14__default.default.existsSync(dir)) {
       try {
-        const entries = fs10__default.default.readdirSync(dir, { withFileTypes: true });
+        const entries = fs14__default.default.readdirSync(dir, { withFileTypes: true });
         for (const e of entries) {
           if (e.isDirectory() && !e.name.startsWith(".")) {
             set.add(e.name);
@@ -3776,19 +4418,19 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     );
   }
   if (type !== "shared" && type !== "feature") {
-    p15__namespace.log.error(pc15__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
+    p19__namespace.log.error(pc13__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
     process.exit(1);
   }
   const registryBase = getRegistryBase(projectRoot, flags.registry);
-  const s = p15__namespace.spinner();
-  s.start(`Connecting to registry at ${pc15__default.default.dim(registryBase)}...`);
+  const s = p19__namespace.spinner();
+  s.start(`Connecting to registry at ${pc13__default.default.dim(registryBase)}...`);
   let index;
   try {
     index = await fetchRegistryIndex(registryBase);
     s.stop("Registry index loaded.");
   } catch (err) {
-    s.stop(pc15__default.default.red("Failed to load registry index."));
-    p15__namespace.log.error(pc15__default.default.red(err.message || String(err)));
+    s.stop(pc13__default.default.red("Failed to load registry index."));
+    p19__namespace.log.error(pc13__default.default.red(err.message || String(err)));
     process.exit(1);
   }
   const availableList = type === "shared" ? index.shared : index.features;
@@ -3796,7 +4438,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   let name = nameArg?.trim();
   if (!name) {
     if (availableList.length === 0) {
-      p15__namespace.log.warn(`No ${type} modules available in the registry.`);
+      p19__namespace.log.warn(`No ${type} modules available in the registry.`);
       return;
     }
     name = handleCancel(
@@ -3812,9 +4454,9 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   }
   if (!candidateNames.includes(name)) {
     const closest = findClosestMatch(name, candidateNames);
-    p15__namespace.log.error(pc15__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
+    p19__namespace.log.error(pc13__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
     if (closest) {
-      p15__namespace.log.info(pc15__default.default.yellow(`Did you mean '${pc15__default.default.cyan(closest)}'?`));
+      p19__namespace.log.info(pc13__default.default.yellow(`Did you mean '${pc13__default.default.cyan(closest)}'?`));
     }
     process.exit(1);
   }
@@ -3826,7 +4468,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     try {
       manifest = await fetchModuleManifest(registryBase, modType, modName);
     } catch (err) {
-      p15__namespace.log.error(pc15__default.default.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
+      p19__namespace.log.error(pc13__default.default.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
       process.exit(1);
     }
     nodes.set(key, {
@@ -3866,7 +4508,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   buildTopologicalOrder(rootKey);
   const resolutions = /* @__PURE__ */ new Map();
   const globalAliasMap = /* @__PURE__ */ new Map();
-  p15__namespace.log.step(`Importing ${type}: ${pc15__default.default.cyan(name)}...`);
+  p19__namespace.log.step(`Importing ${type}: ${pc13__default.default.cyan(name)}...`);
   for (const key of orderedKeys) {
     const node = nodes.get(key);
     const { type: modType, name: registryName, manifest } = node;
@@ -3898,8 +4540,8 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     const programmaticPointTo = pointToMap[registryName] || pointToMap[`${modType}/${registryName}`];
     if (programmaticPointTo) {
       if (!checkModuleExists(projectRoot, modType, programmaticPointTo)) {
-        p15__namespace.log.error(
-          pc15__default.default.red(
+        p19__namespace.log.error(
+          pc13__default.default.red(
             `Module '${programmaticPointTo}' specified in --point-to does not exist in ${folder}.`
           )
         );
@@ -3907,7 +4549,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       }
       globalAliasMap.set(`@/${folder}/${registryName}/`, `@/${folder}/${programmaticPointTo}/`);
       globalAliasMap.set(`@/${folder}/${registryName}`, `@/${folder}/${programmaticPointTo}`);
-      p15__namespace.log.step(`Pointing '${modType}/${registryName}' to existing '${folder}/${programmaticPointTo}'`);
+      p19__namespace.log.step(`Pointing '${modType}/${registryName}' to existing '${folder}/${programmaticPointTo}'`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -3923,7 +4565,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       globalAliasMap.set(`@/${folder}/${registryName}`, `@/${folder}/${programmaticAlias}`);
       const baseDir = getModuleBaseDir(projectRoot, modType);
       const displayDest = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, programmaticAlias));
-      p15__namespace.log.step(`Importing '${registryName}' into '${displayDest}'...`);
+      p19__namespace.log.step(`Importing '${registryName}' into '${displayDest}'...`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -3935,7 +4577,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     }
     const existingDir = getExistingModuleDir(projectRoot, modType, registryName);
     if (!existingDir) {
-      p15__namespace.log.info(`  \u21B3 Resolving required ${modType} dependency: ${pc15__default.default.cyan(registryName)}`);
+      p19__namespace.log.info(`  \u21B3 Resolving required ${modType} dependency: ${pc13__default.default.cyan(registryName)}`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -3951,7 +4593,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     const remoteIntegrity = manifest.integrity || entry?.integrity;
     const localHash = computeDirectoryHash(existingDir);
     if (remoteIntegrity && localHash === remoteIntegrity) {
-      p15__namespace.log.step(`\u2713 ${modType}/${registryName} is up to date (reusing existing)`);
+      p19__namespace.log.step(`\u2713 ${modType}/${registryName} is up to date (reusing existing)`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -3962,7 +4604,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       continue;
     }
     if (flags.overwrite) {
-      p15__namespace.log.step(`Overwriting '${modType}/${registryName}' with registry version (--overwrite)...`);
+      p19__namespace.log.step(`Overwriting '${modType}/${registryName}' with registry version (--overwrite)...`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -3973,7 +4615,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       continue;
     }
     if (flags.yes) {
-      p15__namespace.log.info(`Using existing '${modType}/${registryName}'`);
+      p19__namespace.log.info(`Using existing '${modType}/${registryName}'`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -4007,7 +4649,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       })
     );
     if (choice === "keep_existing" || choice === "use_existing") {
-      p15__namespace.log.step(`Skipping '${modType}/${registryName}' (keeping existing)`);
+      p19__namespace.log.step(`Skipping '${modType}/${registryName}' (keeping existing)`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -4079,7 +4721,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       chosenName = chosenName.replace(/^@\/(shared|features)\//, "").replace(/^(src\/)?(shared|features)\//, "").replace(/^\/+|\/+$/g, "").trim();
       globalAliasMap.set(`@/${folder}/${registryName}/`, `@/${folder}/${chosenName}/`);
       globalAliasMap.set(`@/${folder}/${registryName}`, `@/${folder}/${chosenName}`);
-      p15__namespace.log.step(`Pointing '${modType}/${registryName}' to existing '${folder}/${chosenName}'`);
+      p19__namespace.log.step(`Pointing '${modType}/${registryName}' to existing '${folder}/${chosenName}'`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -4111,7 +4753,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       globalAliasMap.set(`@/${folder}/${registryName}`, `@/${folder}/${newName}`);
       const baseDir = getModuleBaseDir(projectRoot, modType);
       const displayDest = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, newName));
-      p15__namespace.log.step(`Importing '${registryName}' into '${displayDest}'...`);
+      p19__namespace.log.step(`Importing '${registryName}' into '${displayDest}'...`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -4122,7 +4764,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       continue;
     }
     if (choice === "overwrite") {
-      p15__namespace.log.step(`Overwriting '${modType}/${registryName}' with registry version...`);
+      p19__namespace.log.step(`Overwriting '${modType}/${registryName}' with registry version...`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -4165,17 +4807,17 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     const targetDir = path2__default.default.join(getModuleBaseDir(projectRoot, res.type), res.targetName);
     const isOverwrite = Boolean(flags.overwrite || res.action === "overwrite");
     if (key !== rootKey) {
-      p15__namespace.log.step(
-        `Importing ${res.type}: ${pc15__default.default.cyan(res.targetName)}${res.targetName !== res.registryName ? pc15__default.default.dim(` (from ${res.registryName})`) : ""}...`
+      p19__namespace.log.step(
+        `Importing ${res.type}: ${pc13__default.default.cyan(res.targetName)}${res.targetName !== res.registryName ? pc13__default.default.dim(` (from ${res.registryName})`) : ""}...`
       );
     }
     if (res.action === "overwrite" && !flags.dryRun) {
       const existingDir = getExistingModuleDir(projectRoot, res.type, res.targetName);
       if (existingDir && existingDir !== targetDir) {
-        fs10__default.default.rmSync(existingDir, { recursive: true, force: true });
+        fs14__default.default.rmSync(existingDir, { recursive: true, force: true });
       }
-      if (fs10__default.default.existsSync(targetDir)) {
-        fs10__default.default.rmSync(targetDir, { recursive: true, force: true });
+      if (fs14__default.default.existsSync(targetDir)) {
+        fs14__default.default.rmSync(targetDir, { recursive: true, force: true });
       }
     }
     for (const file of res.manifest.files || []) {
@@ -4183,32 +4825,32 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       if (!includeTests && isTestFile(file)) continue;
       const remoteFilePath = `${folder}/${res.registryName}/${file}`;
       const localFilePath = path2__default.default.join(targetDir, file);
-      if (fs10__default.default.existsSync(localFilePath) && !isOverwrite) {
-        p15__namespace.log.warn(
-          `  \u21B3 Skipping existing file: ${pc15__default.default.dim(path2__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
+      if (fs14__default.default.existsSync(localFilePath) && !isOverwrite) {
+        p19__namespace.log.warn(
+          `  \u21B3 Skipping existing file: ${pc13__default.default.dim(path2__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
         );
         continue;
       }
       let content = await fetchRegistryFile(registryBase, remoteFilePath);
       content = rewriteImports(content, globalAliasMap);
       if (!flags.dryRun) {
-        fs10__default.default.mkdirSync(path2__default.default.dirname(localFilePath), { recursive: true });
-        fs10__default.default.writeFileSync(localFilePath, content, "utf-8");
+        fs14__default.default.mkdirSync(path2__default.default.dirname(localFilePath), { recursive: true });
+        fs14__default.default.writeFileSync(localFilePath, content, "utf-8");
       }
       const displayPath = path2__default.default.relative(projectRoot, localFilePath);
       totalWrittenFiles.push(displayPath);
-      p15__namespace.log.message(`  ${pc15__default.default.green("+")} ${displayPath}`);
+      p19__namespace.log.message(`  ${pc13__default.default.green("+")} ${displayPath}`);
     }
   }
   const missingNpm = getMissingNpmPackages(projectRoot, Array.from(requiredNpmPackages));
   if (missingNpm.length > 0) {
     if (flags.skipInstall || flags.dryRun) {
-      p15__namespace.log.info(`Required npm dependencies to install: ${pc15__default.default.cyan(missingNpm.join(", "))}`);
+      p19__namespace.log.info(`Required npm dependencies to install: ${pc13__default.default.cyan(missingNpm.join(", "))}`);
     } else {
       try {
         installNpmPackages(projectRoot, missingNpm);
       } catch (err) {
-        p15__namespace.log.warn(
+        p19__namespace.log.warn(
           `Could not automatically install packages (${err.message}). Please run: npm install ${missingNpm.join(
             " "
           )}`
@@ -4217,13 +4859,13 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     }
   }
   if (flags.dryRun) {
-    p15__namespace.log.info(pc15__default.default.yellow("Dry run complete: No files were written to disk."));
+    p19__namespace.log.info(pc13__default.default.yellow("Dry run complete: No files were written to disk."));
   } else {
     const rootRes = resolutions.get(rootKey);
     const baseDir = getModuleBaseDir(projectRoot, type);
     const displayTarget = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, rootRes.targetName));
-    p15__namespace.log.success(
-      pc15__default.default.green(
+    p19__namespace.log.success(
+      pc13__default.default.green(
         `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in ${displayTarget})`
       )
     );
@@ -4245,8 +4887,8 @@ function isTestFile2(filePath, projectRoot) {
   return base.endsWith(".test.ts") || base.endsWith(".test.js") || base.endsWith(".spec.ts") || base.endsWith(".spec.js") || base.endsWith(".d.ts") || norm.includes("/__tests__/") || norm.startsWith("__tests__/") || /(?:^|\/)tests?\//.test(norm);
 }
 function scanDirFiles(dir, projectRoot) {
-  if (!fs10__default.default.existsSync(dir)) return [];
-  const entries = fs10__default.default.readdirSync(dir, { withFileTypes: true });
+  if (!fs14__default.default.existsSync(dir)) return [];
+  const entries = fs14__default.default.readdirSync(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "__tests__" || entry.name.startsWith(".")) {
@@ -4446,10 +5088,10 @@ var FeatureDependencyGraph = class {
             if (cycle) return cycle;
           } else if (inStack.has(next)) {
             const cycle = [next];
-            let p18 = curr;
-            while (p18 !== next) {
-              cycle.push(p18);
-              p18 = parent.get(p18) || next;
+            let p22 = curr;
+            while (p22 !== next) {
+              cycle.push(p22);
+              p22 = parent.get(p22) || next;
             }
             cycle.push(next);
             cycle.reverse();
@@ -4465,8 +5107,8 @@ var FeatureDependencyGraph = class {
 };
 function discoverAllFeatures(projectRoot) {
   const featuresBase = resolveFeaturesDir(projectRoot);
-  if (!fs10__default.default.existsSync(featuresBase)) return [];
-  const entries = fs10__default.default.readdirSync(featuresBase, { withFileTypes: true });
+  if (!fs14__default.default.existsSync(featuresBase)) return [];
+  const entries = fs14__default.default.readdirSync(featuresBase, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "__tests__" && e.name !== "tests").map((e) => ({
     name: e.name,
     dir: path2__default.default.join(featuresBase, e.name)
@@ -4857,7 +5499,7 @@ Code: ${v.code}`;
       const relPath = path2__default.default.relative(projectRoot, file).replace(/\\/g, "/");
       const { layer } = classifyFile(file, projectRoot);
       if (!layer) continue;
-      const content = fs10__default.default.readFileSync(file, "utf-8");
+      const content = fs14__default.default.readFileSync(file, "utf-8");
       const statements = extractImportStatements(content);
       const baseName = path2__default.default.basename(file);
       const isBarrel = baseName === "index.ts" || baseName === "index.js";
@@ -5351,15 +5993,15 @@ ${compiledDetails}
 // src/commands/lint.ts
 function formatViolation(v) {
   const lines = [];
-  lines.push(pc15__default.default.underline(pc15__default.default.cyan(v.relativePath)) + pc15__default.default.dim(":") + pc15__default.default.yellow(String(v.line)));
+  lines.push(pc13__default.default.underline(pc13__default.default.cyan(v.relativePath)) + pc13__default.default.dim(":") + pc13__default.default.yellow(String(v.line)));
   const gutter = `${String(v.line).padStart(4, " ")} | `;
-  lines.push(pc15__default.default.dim(gutter) + v.code);
+  lines.push(pc13__default.default.dim(gutter) + v.code);
   const categoryShort = v.category.replace(" Violation", "");
   lines.push(
-    "       " + pc15__default.default.red(pc15__default.default.bold("\u2716")) + " " + pc15__default.default.red(`[${categoryShort}]`) + " " + v.advice
+    "       " + pc13__default.default.red(pc13__default.default.bold("\u2716")) + " " + pc13__default.default.red(`[${categoryShort}]`) + " " + v.advice
   );
   if (v.fixExample?.good) {
-    lines.push("       " + pc15__default.default.dim("\u2192") + " " + pc15__default.default.dim(v.fixExample.good));
+    lines.push("       " + pc13__default.default.dim("\u2192") + " " + pc13__default.default.dim(v.fixExample.good));
   }
   return lines.join("\n");
 }
@@ -5384,7 +6026,7 @@ async function handleLint(flags = {}) {
           console.log("");
         }
         console.log(
-          pc15__default.default.red(
+          pc13__default.default.red(
             `\u2716 Dependency rules check failed with ${summary.totalViolations} error${summary.totalViolations > 1 ? "s" : ""} across ${summary.violatedFeatures} feature${summary.violatedFeatures > 1 ? "s" : ""} (${summary.totalFeatures} features scanned).`
           )
         );
@@ -5403,7 +6045,7 @@ ${compiledDetails}
     }
     if (!quiet) {
       console.log(
-        pc15__default.default.green(
+        pc13__default.default.green(
           `\u2714 Dependency rules verified across ${summary.totalFeatures} feature${summary.totalFeatures === 1 ? "" : "s"}.`
         )
       );
@@ -5418,7 +6060,7 @@ ${compiledDetails}
           console.log(formatViolation(v));
           console.log("");
         }
-        console.log(pc15__default.default.red(`\u2716 Dependency rules check failed (1 error).`));
+        console.log(pc13__default.default.red(`\u2716 Dependency rules check failed (1 error).`));
         console.log("");
       }
     }
@@ -5428,33 +6070,42 @@ ${compiledDetails}
 async function handleInit(type, flags = {}) {
   if (!type) {
     const choice = handleCancel(
-      await p15__namespace.select({
+      await p19__namespace.select({
         message: "What would you like to initialize?",
         options: [
           {
             value: "env",
             label: "Environment Files",
             hint: "Generate local .env files from .env*.example templates"
+          },
+          {
+            value: "env-examples",
+            label: "Sync Env Examples",
+            hint: "Safely clone and redact local .env files to .example templates"
           }
         ]
       })
     );
     if (choice === "env") {
-      await runEnvCommand(flags);
+      await runEnvInit(flags);
+    } else if (choice === "env-examples") {
+      await runEnvInitExamples(flags);
     }
     return;
   }
   const normalized = type.trim().toLowerCase();
   if (normalized === "env") {
-    await runEnvCommand(flags);
+    await runEnvInit(flags);
+  } else if (normalized === "env-examples" || normalized === "envexamples") {
+    await runEnvInitExamples(flags);
   } else {
-    p15__namespace.log.error(
-      pc15__default.default.red(
-        `Unknown init target: "${type}". Allowed targets: env.`
+    p19__namespace.log.error(
+      pc13__default.default.red(
+        `Unknown init target: "${type}". Allowed targets: env, env-examples.`
       )
     );
     if (process.env.VITEST) {
-      throw new Error(`Unknown init target: "${type}". Allowed targets: env.`);
+      throw new Error(`Unknown init target: "${type}". Allowed targets: env, env-examples.`);
     }
     process.exit(1);
   }
@@ -5465,8 +6116,8 @@ function createCli() {
   const cli = cac.cac("mason");
   cli.command("[...args]", "Interactive scaffolding and import wizard").option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-y, --yes", "Accept defaults and skip interactive prompts").option("--registry", "Run in registry mode").option("--point-to <mapping>", "Point a dependency to an existing local module (e.g. --point-to time:mytime)").option("--alias <mapping>", "Import a dependency fresh under an alias name (e.g. --alias time:time-mason)").option("--tests", "Include test files (use --no-tests to exclude)").action(async (args, flags) => {
     if (args && args.length > 0) {
-      p15__namespace.log.error(
-        pc15__default.default.red(
+      p19__namespace.log.error(
+        pc13__default.default.red(
           `Unknown command: "${args.join(" ")}". Use --help to list available commands.`
         )
       );
@@ -5477,7 +6128,7 @@ function createCli() {
       const mode = getEffectiveMode(projectRoot, flags);
       if (mode === "registry") {
         const choice2 = handleCancel(
-          await p15__namespace.select({
+          await p19__namespace.select({
             message: "\u{1F3DB}\uFE0F  Mason (Registry Mode): What would you like to scaffold?",
             options: [
               {
@@ -5520,7 +6171,7 @@ function createCli() {
         return;
       }
       const choice = handleCancel(
-        await p15__namespace.select({
+        await p19__namespace.select({
           message: "\u{1F9F1} Mason: What would you like to do?",
           options: [
             {
@@ -5539,9 +6190,9 @@ function createCli() {
               hint: "Scan codebase and verify Clean Architecture dependency rules"
             },
             {
-              value: "init",
-              label: "Initialize environment",
-              hint: "Generate local .env files from .env*.example templates"
+              value: "env",
+              label: "Environment variables",
+              hint: "Manage .env files, add/delete keys, and sync templates"
             }
           ]
         })
@@ -5552,8 +6203,8 @@ function createCli() {
         await handleImport(void 0, void 0, flags);
       } else if (choice === "lint") {
         await handleLint(flags);
-      } else if (choice === "init") {
-        await handleInit("env", flags);
+      } else if (choice === "env") {
+        await handleEnv(void 0, [], flags);
       }
     } catch (err) {
       handleCliError(err);
@@ -5601,16 +6252,36 @@ function createCli() {
       handleCliError(err);
     }
   });
+  cli.command(
+    "env [subcommand] [...args]",
+    "Environment variable management and template synchronization (init, init-examples, add, update, delete, audit)"
+  ).option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-e, --env <environments>", "Comma-separated target environments (e.g. dev,prod)").example("mason env").example("mason env init").example("mason env init-examples").example("mason env add API_KEY secret123").example("mason env update API_KEY newsecret").example("mason env delete API_KEY").example("mason env audit").action(async (subcommand, args = [], flags = {}) => {
+    try {
+      await handleEnv(subcommand, args, flags);
+    } catch (err) {
+      handleCliError(err);
+    }
+  });
   cli.command(
     "init [type]",
-    "Initialize project configurations and resources (e.g. 'mason init env')"
-  ).option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing .env files").example("mason init env").example("mason init env --overwrite").example("mason init env --dry-run").action(async (type, flags = {}) => {
+    "Initialize project configurations (legacy shorthand: use 'mason env init')"
+  ).option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").example("mason init env").example("mason init env-examples").action(async (type, flags = {}) => {
     try {
       await handleInit(type, flags);
     } catch (err) {
       handleCliError(err);
     }
   });
+  cli.command(
+    "env-examples",
+    "Shorthand for 'mason env init-examples'"
+  ).option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing .env*.example files").action(async (flags = {}) => {
+    try {
+      await handleEnv("init-examples", [], flags);
+    } catch (err) {
+      handleCliError(err);
+    }
+  });
   const createSubtypes = [
     "feature",
     "shared",
@@ -5642,7 +6313,7 @@ function handleCliError(err) {
     process.exit(0);
   }
   const message = err instanceof Error ? err.message : String(err);
-  p15__namespace.log.error(pc15__default.default.red(`Error: ${message}`));
+  p19__namespace.log.error(pc13__default.default.red(`Error: ${message}`));
   if (process.env.VITEST) {
     throw err;
   }