create-lumen 2.0.0-alpha.2 → 2.0.0-beta.2

package/src/engine/composition.js

@@ -41,9 +41,13 @@ export const TOOLING_ORDER = [
   "router",
   "icons",
   "api",
+  "database",
   "testing",
   "linter",
   "feature-script",
+  "next-config",
+  "route-groups",
+  "docker",
   "formatter",
 ];
 
@@ -149,6 +153,15 @@ export function resolveFragments(responses = {}, templatesDir) {
       try { await fsp.rm(path.join(projectPath, "src", "App.jsx"), { force: true }); } catch {}
       try { await fsp.rm(path.join(projectPath, "src", "index.css"), { force: true }); } catch {}
       try { await fsp.rm(path.join(projectPath, "src", "App.css"), { force: true }); } catch {}
+      if (fw.name === "next") {
+        // Next cleanup: remove Vite defaults without touching app/
+        try { await fsp.rm(path.join(projectPath, "src", "main.tsx"), { force: true }); } catch {}
+        try { await fsp.rm(path.join(projectPath, "src", "main.jsx"), { force: true }); } catch {}
+        try { await fsp.rm(path.join(projectPath, "index.html"), { force: true }); } catch {}
+        try { await fsp.rm(path.join(projectPath, "vite.config.ts"), { force: true }); } catch {}
+        try { await fsp.rm(path.join(projectPath, "vite.config.js"), { force: true }); } catch {}
+        try { await fsp.rm(path.join(projectPath, "public", "vite.svg"), { force: true }); } catch {}
+      }
     },
   });
 
@@ -164,6 +177,19 @@ export function resolveFragments(responses = {}, templatesDir) {
     sourceDir: archSrcDir,
     targetDir: "src",
     action: async ({ projectPath }) => {
+      if (fw.name === "next") {
+        if (fw.variant === "pages-router") {
+          try { await fsp.rm(path.join(projectPath, "src", "app"), { recursive: true, force: true }); } catch {}
+        } else {
+          // Next App Router: preserve file-system routes; purge React/Vite-specific application layer
+          try { await fsp.rm(path.join(projectPath, "src", "app", "App.tsx"), { force: true }); } catch {}
+          try { await fsp.rm(path.join(projectPath, "src", "app", "App.jsx"), { force: true }); } catch {}
+          try { await fsp.rm(path.join(projectPath, "src", "app", "hooks"), { recursive: true, force: true }); } catch {}
+          try { await fsp.rm(path.join(projectPath, "src", "app", "contexts"), { recursive: true, force: true }); } catch {}
+          try { await fsp.rm(path.join(projectPath, "src", "app", "providers"), { recursive: true, force: true }); } catch {}
+        }
+        return;
+      }
       // Copy architecture main entry
       try {
         await fsp.access(archMainSrc);
@@ -194,6 +220,16 @@ export function resolveFragments(responses = {}, templatesDir) {
       id: `styling:${cssFramework}:components`,
       sourceDir: componentStylesDir,
       targetDir: "src",
+      action: async ({ projectPath }) => {
+        if (fw.name === "next") {
+          if (fw.variant === "pages-router") {
+            try { await fsp.rm(path.join(projectPath, "src", "app"), { recursive: true, force: true }); } catch {}
+          } else {
+            try { await fsp.rm(path.join(projectPath, "src", "app", "App.tsx"), { force: true }); } catch {}
+            try { await fsp.rm(path.join(projectPath, "src", "app", "App.jsx"), { force: true }); } catch {}
+          }
+        }
+      },
     });
   }
 
@@ -210,6 +246,7 @@ export function resolveFragments(responses = {}, templatesDir) {
       sourceDir: path.join(templatesDir, "conditional", "state", "redux", architecture, "src"),
       targetDir: "src",
       action: async ({ projectPath }) => {
+        if (fw.name === "next") return;
         await updateMainWithProvider(projectPath, "redux", architecture, ext);
       },
     });
@@ -306,6 +343,106 @@ export function resolveFragments(responses = {}, templatesDir) {
       id: `tooling:api:${responses.apiClient}`,
       sourceDir: apiDir,
       targetDir: "src",
+      action: async ({ projectPath }) => {
+        if (fw.name === "next") {
+          const configCandidates = [
+            path.join(projectPath, "src", "config", `axios.config.${extConfig}`),
+            path.join(projectPath, "src", "shared", "lib", "axios", `api.config.${extConfig}`),
+            path.join(projectPath, "src", "config", `api.config.${extConfig}`),
+            path.join(projectPath, "src", "shared", "api", `api.config.${extConfig}`),
+          ];
+          for (const cfgPath of configCandidates) {
+            try {
+              let content = await fsp.readFile(cfgPath, "utf8");
+              if (content.includes("import.meta.env.VITE_API_URL")) {
+                content = content.replace(
+                  /import\.meta\.env\.VITE_API_URL/g,
+                  "process.env.NEXT_PUBLIC_API_URL"
+                );
+                await fsp.writeFile(cfgPath, content, "utf8");
+              }
+            } catch {}
+          }
+        }
+      },
+    });
+  }
+
+  // 5.45 Database (Prisma)
+  if (responses.database === "prisma") {
+    fragments.push({
+      scope: FRAGMENT_SCOPES.TOOLING,
+      category: "database",
+      id: "tooling:database:prisma",
+      scripts: {
+        "db:generate": "prisma generate",
+        "db:push": "prisma db push",
+        "db:seed": "prisma db seed",
+        "db:studio": "prisma studio",
+      },
+      action: async ({ projectPath, templatesDir: tDir }) => {
+        const prismaTplDir = path.join(tDir, "conditional", "database", "prisma");
+        const prismaDir = path.join(projectPath, "prisma");
+        await fsp.mkdir(prismaDir, { recursive: true });
+
+        // Copy schema.prisma
+        const schemaSrc = path.join(prismaTplDir, "schema.prisma");
+        const schemaDest = path.join(prismaDir, "schema.prisma");
+        try {
+          await fsp.access(schemaSrc);
+          await fsp.copyFile(schemaSrc, schemaDest);
+        } catch {}
+
+        // Copy seed file: prisma/seed.ts or prisma/seed.js
+        const seedFileName = language === "ts" ? "seed.ts" : "seed.js";
+        const seedSrc = path.join(prismaTplDir, seedFileName);
+        const seedDest = path.join(prismaDir, seedFileName);
+        try {
+          await fsp.access(seedSrc);
+          await fsp.copyFile(seedSrc, seedDest);
+        } catch {}
+
+        // Copy client singleton: src/lib/db.ts or src/lib/db.js
+        const libDir = path.join(projectPath, "src", "lib");
+        await fsp.mkdir(libDir, { recursive: true });
+        const dbFileName = language === "ts" ? "db.ts" : "db.js";
+        const dbSrc = path.join(prismaTplDir, dbFileName);
+        const dbDest = path.join(libDir, dbFileName);
+        try {
+          await fsp.access(dbSrc);
+          await fsp.copyFile(dbSrc, dbDest);
+        } catch {}
+
+        // Configure prisma.seed in package.json
+        const pkgPath = path.join(projectPath, "package.json");
+        try {
+          const content = await fsp.readFile(pkgPath, "utf8");
+          const pkg = JSON.parse(content);
+          pkg.prisma = {
+            seed: language === "ts" ? "tsx prisma/seed.ts" : "node prisma/seed.js",
+          };
+          await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+        } catch {}
+
+        // Append DATABASE_URL and DIRECT_URL to .env.example
+        const envExamplePath = path.join(projectPath, ".env.example");
+        const envLines = [
+          "",
+          "# Database (Prisma + PostgreSQL / Supabase)",
+          'DATABASE_URL="postgresql://postgres:[YOUR-PASSWORD]@db.[YOUR-PROJECT-REF].supabase.co:5432/postgres"',
+          'DIRECT_URL="postgresql://postgres:[YOUR-PASSWORD]@db.[YOUR-PROJECT-REF].supabase.co:5432/postgres"',
+        ].join("\n");
+        try {
+          let envContent = "";
+          try {
+            envContent = await fsp.readFile(envExamplePath, "utf8");
+          } catch {}
+          if (!envContent.includes("DATABASE_URL")) {
+            envContent = envContent.trimEnd() + "\n" + envLines.trimStart() + "\n";
+            await writeFileRecursive(envExamplePath, envContent);
+          }
+        } catch {}
+      },
     });
   }
 
@@ -325,11 +462,26 @@ export function resolveFragments(responses = {}, templatesDir) {
       scripts: testScripts,
       action: async ({ projectPath }) => {
         // Config file to project root
-        const configSrc = path.join(testingDir, `${testingFramework}.config.${extConfig}`);
-        try {
-          await fsp.access(configSrc);
-          await fsp.copyFile(configSrc, path.join(projectPath, `${testingFramework}.config.${extConfig}`));
-        } catch {}
+        if (testingFramework === "jest" && fw.name === "next") {
+          const nextConfigExt = language === "ts" ? "ts" : "mjs";
+          const configSrc = path.join(testingDir, "next", `jest.config.${nextConfigExt}`);
+          try {
+            await fsp.access(configSrc);
+            await fsp.copyFile(configSrc, path.join(projectPath, `jest.config.${nextConfigExt}`));
+          } catch {}
+        } else if (testingFramework === "vitest" && fw.name === "next") {
+          const configSrc = path.join(testingDir, "next", `vitest.config.${extConfig}`);
+          try {
+            await fsp.access(configSrc);
+            await fsp.copyFile(configSrc, path.join(projectPath, `vitest.config.${extConfig}`));
+          } catch {}
+        } else {
+          const configSrc = path.join(testingDir, `${testingFramework}.config.${extConfig}`);
+          try {
+            await fsp.access(configSrc);
+            await fsp.copyFile(configSrc, path.join(projectPath, `${testingFramework}.config.${extConfig}`));
+          } catch {}
+        }
 
         // Setup file to src/test/setup.*
         const setupSrc = path.join(testingDir, `src/test/setup.${extConfig}`);
@@ -345,20 +497,39 @@ export function resolveFragments(responses = {}, templatesDir) {
             await fsp.access(jestSetupSrc);
             await fsp.copyFile(jestSetupSrc, path.join(projectPath, `jest.setup.${extConfig}`));
           } catch {}
-          const babelSrc = path.join(testingDir, "babel.config.cjs");
+          if (fw.name !== "next") {
+            const babelSrc = path.join(testingDir, "babel.config.cjs");
+            try {
+              await fsp.access(babelSrc);
+              await fsp.copyFile(babelSrc, path.join(projectPath, "babel.config.cjs"));
+            } catch {}
+          }
+        }
+
+        if (fw.name === "next") {
+          const testFileName = fw.variant === "pages-router" ? "index" : "page";
+          const testSrc = path.join(
+            testingDir,
+            "next",
+            fw.variant,
+            "src",
+            "__tests__",
+            `${testFileName}.test.${ext}`
+          );
           try {
-            await fsp.access(babelSrc);
-            await fsp.copyFile(babelSrc, path.join(projectPath, "babel.config.cjs"));
+            await fsp.access(testSrc);
+            const testDest = path.join(projectPath, "src", "__tests__", `${testFileName}.test.${ext}`);
+            await writeFileRecursive(testDest, await fsp.readFile(testSrc, "utf8"));
+          } catch {}
+        } else {
+          // Architecture-scoped test file
+          const testSrc = path.join(testingDir, architecture, `src/__tests__/App.test.${ext}`);
+          try {
+            await fsp.access(testSrc);
+            const testDest = path.join(projectPath, "src", "__tests__", `App.test.${ext}`);
+            await writeFileRecursive(testDest, await fsp.readFile(testSrc, "utf8"));
           } catch {}
         }
-
-        // Architecture-scoped test file
-        const testSrc = path.join(testingDir, architecture, `src/__tests__/App.test.${ext}`);
-        try {
-          await fsp.access(testSrc);
-          const testDest = path.join(projectPath, "src", "__tests__", `App.test.${ext}`);
-          await writeFileRecursive(testDest, await fsp.readFile(testSrc, "utf8"));
-        } catch {}
       },
     });
   }
@@ -406,6 +577,23 @@ export function resolveFragments(responses = {}, templatesDir) {
         } catch {}
       },
     });
+  } else if (responses.linter === "biome") {
+    fragments.push({
+      scope: FRAGMENT_SCOPES.TOOLING,
+      category: "linter",
+      id: "tooling:linter:biome",
+      scripts: {
+        lint: "biome check .",
+        "lint:fix": "biome check --write .",
+      },
+      action: async ({ projectPath }) => {
+        const configSrc = path.join(templatesDir, "conditional", "linting", "biome", "biome.json");
+        try {
+          await fsp.access(configSrc);
+          await fsp.copyFile(configSrc, path.join(projectPath, "biome.json"));
+        } catch {}
+      },
+    });
   }
 
   // 5.7 Feature Script (Feature-based only)
@@ -437,7 +625,136 @@ export function resolveFragments(responses = {}, templatesDir) {
     });
   }
 
-  // 5.8 Formatter
+  // 5.75 Next.js Configuration & Adapter Overlays
+  if (fw.name === "next") {
+    const nextScripts = {};
+    if (responses.bundler === "turbopack") {
+      nextScripts.dev = "next dev --turbopack";
+    } else if (responses.bundler === "webpack") {
+      nextScripts.dev = "next dev --webpack";
+    }
+
+    fragments.push({
+      scope: FRAGMENT_SCOPES.TOOLING,
+      category: "next-config",
+      id: "tooling:next:config",
+      scripts: nextScripts,
+      action: async ({ projectPath }) => {
+        const configExt = language === "ts" ? "ts" : "mjs";
+
+        // Apply adapter overlay if specified and not "none"
+        if (responses.adapter && responses.adapter !== "none") {
+          const adapterConfigSrc = path.join(
+            templatesDir,
+            "conditional",
+            "next",
+            "config",
+            responses.adapter,
+            `next.config.${configExt}`
+          );
+          try {
+            await fsp.access(adapterConfigSrc);
+            await fsp.copyFile(adapterConfigSrc, path.join(projectPath, `next.config.${configExt}`));
+          } catch {}
+        } else if (responses.bundler === "turbopack" || responses.bundler === "webpack") {
+          // If no adapter specified, but bundler config overlay exists, apply bundler overlay
+          const bundlerConfigSrc = path.join(
+            templatesDir,
+            "conditional",
+            "next",
+            "config",
+            responses.bundler,
+            `next.config.${configExt}`
+          );
+          try {
+            await fsp.access(bundlerConfigSrc);
+            await fsp.copyFile(bundlerConfigSrc, path.join(projectPath, `next.config.${configExt}`));
+          } catch {}
+        }
+
+        // Apply reactCompiler flag to next.config if enabled
+        if (responses.reactCompiler === true) {
+          const targetConfigPath = path.join(projectPath, `next.config.${configExt}`);
+          try {
+            let content = await fsp.readFile(targetConfigPath, "utf8");
+            if (!content.includes("reactCompiler")) {
+              content = content.replace(
+                /const nextConfig(?::\s*NextConfig)?\s*=\s*\{/,
+                (match) => `${match}\n  reactCompiler: true,`
+              );
+              await fsp.writeFile(targetConfigPath, content, "utf8");
+            }
+          } catch {}
+        }
+
+        // Apply standalone output to next.config if docker is enabled
+        if (responses.docker === true) {
+          const targetConfigPath = path.join(projectPath, `next.config.${configExt}`);
+          try {
+            let content = await fsp.readFile(targetConfigPath, "utf8");
+            if (!content.includes('"standalone"') && !content.includes("'standalone'")) {
+              content = content.replace(
+                /const nextConfig(?::\s*NextConfig)?\s*=\s*\{/,
+                (match) => `${match}\n  output: "standalone",`
+              );
+              await fsp.writeFile(targetConfigPath, content, "utf8");
+            }
+          } catch {}
+        }
+      },
+    });
+  }
+
+  // 5.8 Route Groups Preset & Auth Proxy Template (#64)
+  if (responses.routeGroups === true && fw.name === "next" && fw.variant === "app-router") {
+    fragments.push({
+      scope: FRAGMENT_SCOPES.TOOLING,
+      category: "route-groups",
+      id: "tooling:next:route-groups",
+      sourceDir: path.join(templatesDir, "conditional", "next", "route-groups", language),
+      targetDir: "",
+      action: async ({ projectPath }) => {
+        // Remove colliding root page so it does not collide with (public)/page
+        try {
+          await fsp.rm(path.join(projectPath, "src", "app", `page.${ext}`), { force: true });
+        } catch {}
+        const oppositeExt = language === "ts" ? "jsx" : "tsx";
+        try {
+          await fsp.rm(path.join(projectPath, "src", "app", `page.${oppositeExt}`), { force: true });
+        } catch {}
+        // Also remove page.js / page.tsx in case base provider was named page.js
+        try {
+          await fsp.rm(path.join(projectPath, "src", "app", "page.js"), { force: true });
+        } catch {}
+        try {
+          await fsp.rm(path.join(projectPath, "src", "app", "page.tsx"), { force: true });
+        } catch {}
+      },
+    });
+  }
+
+  // 5.9 Docker (Multi-stage Dockerfile and docker-compose for Next.js standalone)
+  if (responses.docker === true && hasCapability(fw, CAPABILITIES.DOCKER)) {
+    fragments.push({
+      scope: FRAGMENT_SCOPES.TOOLING,
+      category: "docker",
+      id: "tooling:docker",
+      action: async ({ projectPath }) => {
+        const dockerSrcDir = path.join(templatesDir, "conditional", "docker");
+        const filesToCopy = ["Dockerfile", ".dockerignore", "docker-compose.yml"];
+        for (const file of filesToCopy) {
+          const srcFile = path.join(dockerSrcDir, file);
+          const destFile = path.join(projectPath, file);
+          try {
+            await fsp.access(srcFile);
+            await fsp.copyFile(srcFile, destFile);
+          } catch {}
+        }
+      },
+    });
+  }
+
+  // 5.10 Formatter
   if (responses.formatter && responses.formatter !== "none") {
     const isPrettier = responses.formatter === "prettier";
     const configFile = isPrettier ? ".prettierrc" : ".oxfmtrc.json";

package/src/engine/providers/base-provider.js

@@ -125,7 +125,7 @@ export class NextAppRouterProvider extends BaseProvider {
   getPackageSet({ options = {} } = {}) {
     const isTs = options.language === "ts";
     const deps = {
-      next: "^15.0.0",
+      next: "^16.0.0",
       react: "^19.0.0",
       "react-dom": "^19.0.0",
     };
@@ -134,7 +134,7 @@ export class NextAppRouterProvider extends BaseProvider {
       devDeps.typescript = "^5.7.0";
       devDeps["@types/react"] = "^19.0.0";
       devDeps["@types/react-dom"] = "^19.0.0";
-      devDeps["@types/node"] = "^20.0.0";
+      devDeps["@types/node"] = "^22.0.0";
     }
     return {
       dependencies: deps,
@@ -159,7 +159,7 @@ export class NextPagesRouterProvider extends BaseProvider {
   getPackageSet({ options = {} } = {}) {
     const isTs = options.language === "ts";
     const deps = {
-      next: "^15.0.0",
+      next: "^16.0.0",
       react: "^19.0.0",
       "react-dom": "^19.0.0",
     };
@@ -168,7 +168,7 @@ export class NextPagesRouterProvider extends BaseProvider {
       devDeps.typescript = "^5.7.0";
       devDeps["@types/react"] = "^19.0.0";
       devDeps["@types/react-dom"] = "^19.0.0";
-      devDeps["@types/node"] = "^20.0.0";
+      devDeps["@types/node"] = "^22.0.0";
     }
     return {
       dependencies: deps,

package/src/env.js

@@ -1,5 +1,6 @@
 import path from "path";
 import { promises as fsp } from "fs";
+import { normalizeFramework } from "./engine/capabilities.js";
 
 const ENV_GITIGNORE = `
 # Environment variables
@@ -8,12 +9,29 @@ const ENV_GITIGNORE = `
 !.env.example
 `;
 
-export async function copyEnvExample(projectPath, templatesDir) {
-  const src = path.join(templatesDir, ".env.example");
-  try {
-    await fsp.access(src);
-    await fsp.copyFile(src, path.join(projectPath, ".env.example"));
-  } catch {}
+const NEXT_ENV_EXAMPLE = `# Copy this file to \`.env.local\` (or \`.env\`) and fill in your values.
+# See https://nextjs.org/docs/app/building-your-application/configuring/environment-variables for details.
+
+NEXT_PUBLIC_API_URL=https://api.example.com
+`;
+
+export async function copyEnvExample(projectPath, templatesDir, responses = {}) {
+  const fw = normalizeFramework(
+    responses.framework || {
+      name: responses.frameworkName,
+      variant: responses.frameworkVariant,
+    }
+  );
+
+  if (fw.name === "next") {
+    await fsp.writeFile(path.join(projectPath, ".env.example"), NEXT_ENV_EXAMPLE, "utf8");
+  } else {
+    const src = path.join(templatesDir, ".env.example");
+    try {
+      await fsp.access(src);
+      await fsp.copyFile(src, path.join(projectPath, ".env.example"));
+    } catch {}
+  }
 
   // Ensure the project gitignore excludes env files but keeps .env.example.
   const gitignore = path.join(projectPath, ".gitignore");

package/src/main.js

@@ -12,7 +12,7 @@ import { injectArchitecture, injectConditionals, injectFormatter } from "@/injec
 import { getPkgManager } from "@/utils/pkg-manager.js";
 import { handleDevServer } from "@/utils/dev-server.js";
 import { getUserInputs, onCancel } from "@/prompts.js";
-import { runBaseInstall, runGitInit, runViteCreate } from "@/scaffold.js";
+import { runBaseInstall, runGitInit, runViteCreate, scaffoldBase } from "@/scaffold.js";
 import { installAllDeps } from "@/dependencies.js";
 import { generateReadme } from "@/readme.js";
 import { runProjectFormat } from "@/format.js";
@@ -20,6 +20,8 @@ import { emitManifest } from "@/manifest/emit.js";
 import { emitAgentContext } from "@/agent-context.js";
 
 import { parseCliArgs, loadManifestSource, manifestToResponses, PRESETS } from "@/cli-args.js";
+import { getProvider } from "@/engine/providers/base-provider.js";
+import { normalizeFramework } from "@/engine/capabilities.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -48,6 +50,7 @@ export async function main(options = {}) {
     projectName: nameArg,
     manifest: manifestSource,
     template: templateName,
+    framework: frameworkArg,
     arch: archArg,
   } = options;
   const pkg = getPkgManager();
@@ -94,20 +97,40 @@ export async function main(options = {}) {
       ...preset,
     };
   } else {
-    responses = await getUserInputs(projectName, { quickSetup, initialArch: archArg });
+    responses = await getUserInputs(projectName, { quickSetup, initialArch: archArg, framework: frameworkArg });
   }
 
   const projectPath = path.resolve(CURRENT_DIR, projectName);
 
-  // 4. Scaffold via vite create
+  // 4. Scaffold the base project (provider-owned bases; Vite shells out, Next copies)
+  const fw = normalizeFramework(
+    responses.framework || { name: responses.frameworkName, variant: responses.frameworkVariant }
+  );
   const createSpin = spinner();
-  createSpin.start("Creating your Vite + React project...");
-  try {
-    await runViteCreate(projectPath, projectName, pkg, responses.language);
-    createSpin.stop(chalk.green("Project created successfully!"));
-  } catch (err) {
-    createSpin.stop(chalk.red("Failed to create project."));
-    throw err;
+  if (fw.name === "next") {
+    createSpin.start("Creating your Next.js project...");
+    try {
+      const provider = getProvider(fw.name, fw.variant);
+      const based = await scaffoldBase(projectPath, provider, responses.language, TEMPLATES_DIR);
+      if (!based) {
+        throw new Error(
+          `Next.js base template not found for variant "${fw.variant}" (${responses.language}).`
+        );
+      }
+      createSpin.stop(chalk.green("Project created successfully!"));
+    } catch (err) {
+      createSpin.stop(chalk.red("Failed to create project."));
+      throw err;
+    }
+  } else {
+    createSpin.start("Creating your Vite + React project...");
+    try {
+      await runViteCreate(projectPath, projectName, pkg, responses.language);
+      createSpin.stop(chalk.green("Project created successfully!"));
+    } catch (err) {
+      createSpin.stop(chalk.red("Failed to create project."));
+      throw err;
+    }
   }
 
   // 5. Install base dependencies
@@ -234,7 +257,7 @@ export async function main(options = {}) {
   await cleanupBoilerplate(projectPath);
 
   // 12.5 Copy .env.example into the project
-  await copyEnvExample(projectPath, TEMPLATES_DIR);
+  await copyEnvExample(projectPath, TEMPLATES_DIR, responses);
 
   // 12.6 Emit lumen.config.json (manifest v2) — byte-deterministic, Zod-validated
   const manifestSpin = spinner();
@@ -247,15 +270,15 @@ export async function main(options = {}) {
     throw err;
   }
 
-  // 12.7 Emit .lumen agent context dir (only when agentDocs is enabled)
+  // 12.7 Emit AGENTS.md at root (only when agentDocs is enabled)
   if (responses.agentDocs === true || responses._manifestSource?.agentDocs === true) {
     const agentSpin = spinner();
-    agentSpin.start("Writing .lumen agent context...");
+    agentSpin.start("Writing AGENTS.md...");
     try {
       await emitAgentContext(projectPath, responses._manifestSource ?? responses);
-      agentSpin.stop(chalk.green(".lumen agent context written."));
+      agentSpin.stop(chalk.green("AGENTS.md written."));
     } catch (err) {
-      agentSpin.stop(chalk.red("Failed to write .lumen agent context."));
+      agentSpin.stop(chalk.red("Failed to write AGENTS.md."));
       throw err;
     }
   }

package/src/manifest/emit.js

@@ -64,7 +64,7 @@ export function buildManifest(responses, opts = {}) {
   };
   // Include optional axes only if present in responses (future overlays)
   if (responses.bundler) framework.bundler = responses.bundler;
-  if (responses.adapter) framework.adapter = responses.adapter;
+  if (responses.adapter && responses.adapter !== "none") framework.adapter = responses.adapter;
 
   const styling = {
     engine: responses.cssFramework || "tailwind",
@@ -117,8 +117,18 @@ export function buildManifest(responses, opts = {}) {
   };
 
   // Optional cross-cutting flags — only include if explicitly set (keeps minimal manifest byte-stable)
+  if (responses.database && responses.database !== "none") {
+    manifest.database = {
+      orm: responses.database,
+      provider: "postgresql",
+    };
+  }
+  if (typeof responses.docker === "boolean") manifest.docker = responses.docker;
+  if (typeof responses.routeGroups === "boolean") manifest.routeGroups = responses.routeGroups;
   if (typeof responses.reactCompiler === "boolean") manifest.reactCompiler = responses.reactCompiler;
+  if (typeof responses.routeGroups === "boolean") manifest.routeGroups = responses.routeGroups;
   if (typeof responses.agentDocs === "boolean") manifest.agentDocs = responses.agentDocs;
+  if (typeof responses.docker === "boolean") manifest.docker = responses.docker;
 
   // Enforce stable top-level key order for determinism (like formatter pass)
   const ordered = {};
@@ -133,6 +143,9 @@ export function buildManifest(responses, opts = {}) {
     "docs",
     "paths",
     "tooling",
+    "database",
+    "docker",
+    "routeGroups",
     "reactCompiler",
     "agentDocs",
   ];