create-better-fullstack 2.0.3 → 2.1.1

package/dist/mcp-entry.mjs

@@ -1,10 +1,902 @@
 #!/usr/bin/env node
-import { a as getEffectiveStack, i as writeBtsConfig, l as getGraphSummary, n as readBtsConfig, p as getLatestCLIVersion, t as previewBtsConfigUpdate } from "./bts-config-Bg1Qea9Y.mjs";
+import { A as types_exports, C as getEffectiveStack, D as getGraphSummary, _ as writeBtsConfig, f as buildBtsConfigForPersistence, m as readBtsConfig, p as previewBtsConfigUpdate, v as getLatestCLIVersion, x as getDefaultConfig } from "./errors-D9yiiGVq.mjs";
+import { a as generateReproducibleCommand, i as getTemplateDescription, r as getTemplateConfig, s as CreateCommandOptionsSchema, t as validateConfigForProgrammaticUse } from "./config-validation-C4glouQh.mjs";
+import "./compatibility-rules-D7zYNVjC.mjs";
 import z from "zod";
-import { AISchema, APISchema, AddonsSchema, AnalyticsSchema, AnimationSchema, AstroIntegrationSchema, AuthSchema, BackendSchema, CATEGORY_ORDER, CMSSchema, CSSFrameworkSchema, CachingSchema, DatabaseSchema, DatabaseSetupSchema, DotnetApiSchema, DotnetAuthSchema, DotnetCachingSchema, DotnetDeploySchema, DotnetJobQueueSchema, DotnetObservabilitySchema, DotnetOrmSchema, DotnetRealtimeSchema, DotnetTestingSchema, DotnetValidationSchema, DotnetWebFrameworkSchema, EcosystemSchema, EffectSchema, ElixirApiSchema, ElixirAuthSchema, ElixirCachingSchema, ElixirDeploySchema, ElixirEmailSchema, ElixirHttpSchema, ElixirJobsSchema, ElixirJsonSchema, ElixirLibrariesSchema, ElixirObservabilitySchema, ElixirOrmSchema, ElixirQualitySchema, ElixirRealtimeSchema, ElixirTestingSchema, ElixirValidationSchema, ElixirWebFrameworkSchema, EmailSchema, ExamplesSchema, FeatureFlagsSchema, FileStorageSchema, FileUploadSchema, FormsSchema, FrontendSchema, GoApiSchema, GoAuthSchema, GoCachingSchema, GoCliSchema, GoConfigSchema, GoLoggingSchema, GoMessageQueueSchema, GoObservabilitySchema, GoOrmSchema, GoRealtimeSchema, GoTestingSchema, GoWebFrameworkSchema, I18nSchema, JavaApiSchema, JavaAuthSchema, JavaBuildToolSchema, JavaLibrariesSchema, JavaLoggingSchema, JavaOrmSchema, JavaTestingLibrariesSchema, JavaWebFrameworkSchema, JobQueueSchema, LoggingSchema, MobileDeepLinkingSchema, MobileNavigationSchema, MobileOTASchema, MobilePushSchema, MobileStorageSchema, MobileTestingSchema, MobileUISchema, OPTION_CATEGORY_METADATA, ORMSchema, ObservabilitySchema, PackageManagerSchema, PaymentsSchema, PythonAiSchema, PythonApiSchema, PythonAuthSchema, PythonCachingSchema, PythonCliSchema, PythonGraphqlSchema, PythonObservabilitySchema, PythonOrmSchema, PythonQualitySchema, PythonRealtimeSchema, PythonTaskQueueSchema, PythonTestingSchema, PythonValidationSchema, PythonWebFrameworkSchema, RateLimitSchema, RealtimeSchema, RuntimeSchema, RustApiSchema, RustAuthSchema, RustCachingSchema, RustCliSchema, RustErrorHandlingSchema, RustFrontendSchema, RustLibrariesSchema, RustLoggingSchema, RustMessageQueueSchema, RustObservabilitySchema, RustOrmSchema, RustRealtimeSchema, RustTemplatingSchema, RustWebFrameworkSchema, SearchSchema, ServerDeploySchema, StateManagementSchema, TestingSchema, UILibrarySchema, ValidationSchema, WebDeploySchema, analyzeStackCompatibility, formatStackPartSpec, getCategoryOrderForEcosystem, legacyProjectConfigToStackParts } from "@better-fullstack/types";
+import fs from "fs-extra";
+import path from "node:path";
+import { AISchema, APISchema, AddonsSchema, AiDocsSchema, AnalyticsSchema, AnimationSchema, AstroIntegrationSchema, AuthSchema, BackendSchema, CATEGORY_ORDER, CMSSchema, CSSFrameworkSchema, CachingSchema, DatabaseSchema, DatabaseSetupSchema, DotnetApiSchema, DotnetAuthSchema, DotnetCachingSchema, DotnetDeploySchema, DotnetJobQueueSchema, DotnetObservabilitySchema, DotnetOrmSchema, DotnetRealtimeSchema, DotnetTestingSchema, DotnetValidationSchema, DotnetWebFrameworkSchema, EcosystemSchema, EffectSchema, ElixirApiSchema, ElixirAuthSchema, ElixirCachingSchema, ElixirDeploySchema, ElixirEmailSchema, ElixirHttpSchema, ElixirJobsSchema, ElixirJsonSchema, ElixirLibrariesSchema, ElixirObservabilitySchema, ElixirOrmSchema, ElixirQualitySchema, ElixirRealtimeSchema, ElixirTestingSchema, ElixirValidationSchema, ElixirWebFrameworkSchema, EmailSchema, ExamplesSchema, FeatureFlagsSchema, FileStorageSchema, FileUploadSchema, FormsSchema, FrontendSchema, GoApiSchema, GoAuthSchema, GoCachingSchema, GoCliSchema, GoConfigSchema, GoLoggingSchema, GoMessageQueueSchema, GoObservabilitySchema, GoOrmSchema, GoRealtimeSchema, GoTestingSchema, GoWebFrameworkSchema, I18nSchema, JavaApiSchema, JavaAuthSchema, JavaBuildToolSchema, JavaLibrariesSchema, JavaLoggingSchema, JavaOrmSchema, JavaTestingLibrariesSchema, JavaWebFrameworkSchema, JobQueueSchema, LoggingSchema, MobileDeepLinkingSchema, MobileNavigationSchema, MobileOTASchema, MobilePushSchema, MobileStorageSchema, MobileTestingSchema, MobileUISchema, OPTION_CATEGORY_METADATA, ORMSchema, ObservabilitySchema, PackageManagerSchema, PaymentsSchema, PythonAiSchema, PythonApiSchema, PythonAuthSchema, PythonCachingSchema, PythonCliSchema, PythonGraphqlSchema, PythonObservabilitySchema, PythonOrmSchema, PythonQualitySchema, PythonRealtimeSchema, PythonTaskQueueSchema, PythonTestingSchema, PythonValidationSchema, PythonWebFrameworkSchema, RateLimitSchema, RealtimeSchema, RuntimeSchema, RustApiSchema, RustAuthSchema, RustCachingSchema, RustCliSchema, RustErrorHandlingSchema, RustFrontendSchema, RustLibrariesSchema, RustLoggingSchema, RustMessageQueueSchema, RustObservabilitySchema, RustOrmSchema, RustRealtimeSchema, RustTemplatingSchema, RustWebFrameworkSchema, SearchSchema, ServerDeploySchema, ShadcnBaseColorSchema, ShadcnBaseSchema, ShadcnColorThemeSchema, ShadcnFontSchema, ShadcnIconLibrarySchema, ShadcnRadiusSchema, ShadcnStyleSchema, StateManagementSchema, TEMPLATE_VALUES, TestingSchema, UILibrarySchema, ValidationSchema, VectorDbSchema, VersionChannelSchema, WebDeploySchema, analyzeStackCompatibility, evaluateCompatibility, formatStackPartSpec, getCategoryOrderForEcosystem, legacyProjectConfigToStackParts, parseStackPartSpecs, stackPartsToLegacyProjectConfigPartial } from "@better-fullstack/types";
+import { tmpdir } from "node:os";
+import { EMBEDDED_TEMPLATES, generateVirtualProject } from "@better-fullstack/template-generator";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { writeSelectedFiles } from "@better-fullstack/template-generator/fs-writer";
 
+//#region src/helpers/core/stack-update.ts
+const ARRAY_UPDATE_KEYS = new Set([
+	"frontend",
+	"addons",
+	"examples",
+	"aiDocs",
+	"rustLibraries",
+	"pythonAi",
+	"pythonTesting",
+	"pythonCli",
+	"goTesting",
+	"javaLibraries",
+	"javaTestingLibraries",
+	"dotnetTesting",
+	"dotnetObservability",
+	"elixirLibraries"
+]);
+const NON_STACK_UPDATE_CREATE_KEYS = new Set([
+	"template",
+	"fromHistory",
+	"config",
+	"yes",
+	"yolo",
+	"verbose",
+	"dryRun",
+	"verify",
+	"git",
+	"install",
+	"directoryConflict",
+	"renderTitle",
+	"disableAnalytics",
+	"manualDb"
+]);
+const SUPPORTED_STACK_UPDATE_KEYS = Object.keys(CreateCommandOptionsSchema.shape).filter((key) => !NON_STACK_UPDATE_CREATE_KEYS.has(key)).sort();
+const SUPPORTED_STACK_UPDATE_KEY_SET = new Set(SUPPORTED_STACK_UPDATE_KEYS);
+const IGNORED_REQUEST_KEYS = new Set([
+	"projectDir",
+	"projectName",
+	"install",
+	"git"
+]);
+const PACKAGE_JSON_SECTIONS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"scripts"
+];
+const BINARY_FILE_MARKER = "[Binary file]";
+function isEnvFilePath(filePath) {
+	const name = path.basename(filePath);
+	return name === ".env" || name.endsWith(".env.example");
+}
+function isSkippableGeneratedDoc(filePath) {
+	return path.basename(filePath).toLowerCase() === "readme.md";
+}
+function isGeneratedBinaryFile(file) {
+	return file?.content === BINARY_FILE_MARKER && typeof file.sourcePath === "string";
+}
+async function readGeneratedFileBytes(tree, filePath, file) {
+	if (!isGeneratedBinaryFile(file)) return void 0;
+	const tempDir = await fs.mkdtemp(path.join(tmpdir(), "bfs-stack-update-binary-"));
+	try {
+		if (!(await writeSelectedFiles(tree, tempDir, (candidatePath) => candidatePath === filePath)).includes(filePath)) return void 0;
+		return await fs.readFile(path.join(tempDir, filePath));
+	} finally {
+		await fs.rm(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function buffersEqual(left, right) {
+	return Boolean(left && right && left.equals(right));
+}
+async function inferProjectName(projectDir) {
+	const packageJsonPath = path.join(projectDir, "package.json");
+	const packageJson = await fs.readJson(packageJsonPath).catch(() => null);
+	if (packageJson && typeof packageJson.name === "string" && packageJson.name.trim()) return packageJson.name.trim();
+	return path.basename(projectDir);
+}
+function configFromBtsConfig(config, projectDir, projectName) {
+	return {
+		...getDefaultConfig(),
+		...config,
+		projectName,
+		projectDir,
+		relativePath: ".",
+		git: false,
+		install: false
+	};
+}
+function buildRequestedChanges(input) {
+	const changes = {};
+	const stackPartSpecs = [];
+	const unsupportedKeys = [];
+	for (const [key, value] of Object.entries(input)) {
+		if (value === void 0 || IGNORED_REQUEST_KEYS.has(key)) continue;
+		if (!SUPPORTED_STACK_UPDATE_KEY_SET.has(key)) {
+			unsupportedKeys.push(key);
+			continue;
+		}
+		if (key === "part") {
+			if (Array.isArray(value)) stackPartSpecs.push(...value.filter((item) => typeof item === "string"));
+			continue;
+		}
+		changes[key] = value;
+	}
+	return {
+		changes,
+		stackPartSpecs,
+		unsupportedKeys
+	};
+}
+function mergeProjectConfig(currentConfig, requestedChanges) {
+	const next = { ...currentConfig };
+	for (const [key, value] of Object.entries(requestedChanges)) {
+		if (value === void 0) continue;
+		if (ARRAY_UPDATE_KEYS.has(key) && Array.isArray(value)) {
+			const arrayValue = value;
+			const requested = arrayValue.filter((item) => typeof item === "string" && item !== "none");
+			if (requested.length === 0 && arrayValue.includes("none")) next[key] = [];
+			else {
+				const existing = Array.isArray(next[key]) ? next[key].filter((item) => item !== "none") : [];
+				next[key] = [...new Set([...existing, ...requested])];
+			}
+			continue;
+		}
+		next[key] = value;
+	}
+	return next;
+}
+function mergeStackPartSpecs(currentConfig, specs) {
+	if (specs.length === 0) return {};
+	const currentStackParts = currentConfig.stackParts?.length ? currentConfig.stackParts : (0, types_exports.legacyProjectConfigToStackParts)(currentConfig);
+	const currentSpecs = currentStackParts.filter((part) => part.source !== "provided").map((part) => (0, types_exports.formatStackPartSpec)(part, currentStackParts));
+	const stackParts = (0, types_exports.parseStackPartSpecs)([...new Set([...currentSpecs, ...specs])], "selected");
+	return {
+		...(0, types_exports.stackPartsToLegacyProjectConfigPartial)(stackParts),
+		stackParts
+	};
+}
+function asString(value, fallback = "none") {
+	return typeof value === "string" ? value : fallback;
+}
+function asStringArray(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function getCompatibilityBackend(config, webFrontend) {
+	if (config.backend !== "self") return asString(config.backend, "hono");
+	if (webFrontend.includes("next")) return "self-next";
+	if (webFrontend.includes("vinext")) return "self-vinext";
+	if (webFrontend.includes("tanstack-start")) return "self-tanstack-start";
+	if (webFrontend.includes("astro")) return "self-astro";
+	if (webFrontend.includes("nuxt")) return "self-nuxt";
+	if (webFrontend.includes("svelte")) return "self-svelte";
+	if (webFrontend.includes("solid-start")) return "self-solid-start";
+	return "self";
+}
+function getProjectBackendFromCompatibility(backend) {
+	return backend.startsWith("self-") ? "self" : backend;
+}
+function getDefaultDatabaseForDbSetup(dbSetup) {
+	switch (dbSetup) {
+		case "turso":
+		case "d1": return "sqlite";
+		case "neon":
+		case "prisma-postgres":
+		case "planetscale":
+		case "supabase":
+		case "docker": return "postgres";
+		case "mongodb-atlas": return "mongodb";
+		case "upstash": return "redis";
+		default: return;
+	}
+}
+function getDefaultOrmForDatabase(database) {
+	switch (database) {
+		case "sqlite":
+		case "postgres":
+		case "mysql": return "drizzle";
+		case "mongodb": return "prisma";
+		default: return;
+	}
+}
+function getRequiredCssFrameworkForUiLibrary(uiLibrary) {
+	switch (uiLibrary) {
+		case "shadcn-ui":
+		case "shadcn-svelte":
+		case "daisyui":
+		case "nextui":
+		case "park-ui": return "tailwind";
+		default: return;
+	}
+}
+function isBetterAuth(auth) {
+	return auth === "better-auth" || auth === "better-auth-organizations";
+}
+function withNativeFrontendVariant(frontend, nativeFrontend) {
+	return [...(Array.isArray(frontend) ? frontend : []).filter((item) => !item.startsWith("native-") && item !== "none"), nativeFrontend];
+}
+function withWebFrontendVariant(frontend, webFrontend) {
+	return [webFrontend, ...(Array.isArray(frontend) ? frontend : []).filter((item) => item.startsWith("native-"))];
+}
+function hasRequestedNonNoneValue(requestedChanges, key) {
+	const value = requestedChanges[key];
+	if (Array.isArray(value)) return value.some((item) => item !== "none");
+	return value !== void 0 && value !== "none";
+}
+function needsStandaloneBackendForRequestedUpdate(requestedChanges) {
+	return hasRequestedNonNoneValue(requestedChanges, "database") || hasRequestedNonNoneValue(requestedChanges, "orm") || hasRequestedNonNoneValue(requestedChanges, "dbSetup") || hasRequestedNonNoneValue(requestedChanges, "api") || isBetterAuth(requestedChanges.auth) || hasRequestedNonNoneValue(requestedChanges, "payments") || hasRequestedNonNoneValue(requestedChanges, "email") || hasRequestedNonNoneValue(requestedChanges, "logging") || hasRequestedNonNoneValue(requestedChanges, "observability") || hasRequestedNonNoneValue(requestedChanges, "caching") || hasRequestedNonNoneValue(requestedChanges, "rateLimit") || hasRequestedNonNoneValue(requestedChanges, "jobQueue") || hasRequestedNonNoneValue(requestedChanges, "realtime") || hasRequestedNonNoneValue(requestedChanges, "search") || hasRequestedNonNoneValue(requestedChanges, "vectorDb") || hasRequestedNonNoneValue(requestedChanges, "fileStorage") || hasRequestedNonNoneValue(requestedChanges, "serverDeploy");
+}
+function getDefaultWebFrontendForRequestedUpdate(requestedChanges) {
+	if (hasRequestedNonNoneValue(requestedChanges, "payments")) return "next";
+	if (requestedChanges.i18n === "next-intl") return "next";
+	if (requestedChanges.cms === "payload" || requestedChanges.cms === "keystatic") return "next";
+	if (requestedChanges.uiLibrary === "shadcn-svelte") return "svelte";
+	if (asStringArray(requestedChanges.addons).some((addon) => addon === "pwa" || addon === "tauri")) return "react-vite";
+	return hasRequestedNonNoneValue(requestedChanges, "cssFramework") || hasRequestedNonNoneValue(requestedChanges, "uiLibrary") || hasRequestedNonNoneValue(requestedChanges, "forms") || hasRequestedNonNoneValue(requestedChanges, "stateManagement") || hasRequestedNonNoneValue(requestedChanges, "animation") || hasRequestedNonNoneValue(requestedChanges, "fileUpload") || hasRequestedNonNoneValue(requestedChanges, "i18n") || hasRequestedNonNoneValue(requestedChanges, "cms") || hasRequestedNonNoneValue(requestedChanges, "analytics") || hasRequestedNonNoneValue(requestedChanges, "webDeploy") || requestedChanges.ai === "tanstack-ai" ? "react-vite" : void 0;
+}
+function getDefaultNativeFrontendForRequestedUpdate(requestedChanges) {
+	if (requestedChanges.mobileUI === "uniwind" || requestedChanges.mobileUI === "unistyles") return;
+	return hasRequestedNonNoneValue(requestedChanges, "mobileNavigation") || hasRequestedNonNoneValue(requestedChanges, "mobileUI") || hasRequestedNonNoneValue(requestedChanges, "mobileStorage") || hasRequestedNonNoneValue(requestedChanges, "mobileTesting") || hasRequestedNonNoneValue(requestedChanges, "mobilePush") || hasRequestedNonNoneValue(requestedChanges, "mobileOTA") || hasRequestedNonNoneValue(requestedChanges, "mobileDeepLinking") ? "native-bare" : void 0;
+}
+function buildCompatibilityInputFromConfig(config) {
+	const frontend = asStringArray(config.frontend);
+	const addons = asStringArray(config.addons);
+	const webFrontend = frontend.filter((item) => !item.startsWith("native-") && item !== "none");
+	const nativeFrontend = frontend.filter((item) => item.startsWith("native-"));
+	const codeQuality = [];
+	const documentation = [];
+	const appPlatforms = [];
+	for (const addon of addons) {
+		const binding = (0, types_exports.getAddonStackPartBinding)(addon);
+		if (binding?.role === "codeQuality") codeQuality.push(addon);
+		else if (binding?.role === "documentation") documentation.push(addon);
+		else if (addon !== "none") appPlatforms.push(addon);
+	}
+	return {
+		ecosystem: config.ecosystem,
+		projectName: config.projectName ?? null,
+		webFrontend,
+		nativeFrontend,
+		astroIntegration: asString(config.astroIntegration),
+		runtime: asString(config.runtime, "bun"),
+		backend: getCompatibilityBackend(config, webFrontend),
+		database: asString(config.database),
+		orm: asString(config.orm),
+		dbSetup: asString(config.dbSetup),
+		auth: asString(config.auth),
+		payments: asString(config.payments),
+		email: asString(config.email),
+		fileUpload: asString(config.fileUpload),
+		logging: asString(config.logging),
+		observability: asString(config.observability),
+		featureFlags: asString(config.featureFlags),
+		analytics: asString(config.analytics),
+		backendLibraries: "none",
+		stateManagement: asString(config.stateManagement),
+		forms: asString(config.forms),
+		validation: asString(config.validation),
+		testing: asString(config.testing),
+		realtime: asString(config.realtime),
+		jobQueue: asString(config.jobQueue),
+		caching: asString(config.caching),
+		rateLimit: asString(config.rateLimit),
+		animation: asString(config.animation),
+		cssFramework: asString(config.cssFramework),
+		uiLibrary: asString(config.uiLibrary),
+		shadcnBase: asString(config.shadcnBase, "radix"),
+		shadcnStyle: asString(config.shadcnStyle, "nova"),
+		shadcnIconLibrary: asString(config.shadcnIconLibrary, "lucide"),
+		shadcnColorTheme: asString(config.shadcnColorTheme, "neutral"),
+		shadcnBaseColor: asString(config.shadcnBaseColor, "neutral"),
+		shadcnFont: asString(config.shadcnFont, "inter"),
+		shadcnRadius: asString(config.shadcnRadius, "default"),
+		cms: asString(config.cms),
+		i18n: asString(config.i18n),
+		search: asString(config.search),
+		vectorDb: asString(config.vectorDb),
+		fileStorage: asString(config.fileStorage),
+		mobileNavigation: asString(config.mobileNavigation),
+		mobileUI: asString(config.mobileUI),
+		mobileStorage: asString(config.mobileStorage),
+		mobileTesting: asString(config.mobileTesting),
+		mobilePush: asString(config.mobilePush),
+		mobileOTA: asString(config.mobileOTA),
+		mobileDeepLinking: asString(config.mobileDeepLinking),
+		codeQuality,
+		documentation,
+		appPlatforms,
+		packageManager: asString(config.packageManager, "bun"),
+		versionChannel: asString(config.versionChannel, "stable"),
+		examples: asStringArray(config.examples),
+		aiSdk: asString(config.ai),
+		aiDocs: asStringArray(config.aiDocs),
+		git: "false",
+		install: "false",
+		api: asString(config.api),
+		webDeploy: asString(config.webDeploy),
+		serverDeploy: asString(config.serverDeploy),
+		yolo: "false",
+		rustWebFramework: asString(config.rustWebFramework),
+		rustFrontend: asString(config.rustFrontend),
+		rustOrm: asString(config.rustOrm),
+		rustApi: asString(config.rustApi),
+		rustCli: asString(config.rustCli),
+		rustLibraries: asStringArray(config.rustLibraries),
+		rustLogging: asString(config.rustLogging),
+		rustErrorHandling: asString(config.rustErrorHandling),
+		rustCaching: asString(config.rustCaching),
+		rustAuth: asString(config.rustAuth),
+		rustRealtime: asString(config.rustRealtime),
+		rustMessageQueue: asString(config.rustMessageQueue),
+		rustObservability: asString(config.rustObservability),
+		rustTemplating: asString(config.rustTemplating),
+		pythonWebFramework: asString(config.pythonWebFramework),
+		pythonOrm: asString(config.pythonOrm),
+		pythonValidation: asString(config.pythonValidation),
+		pythonAi: asStringArray(config.pythonAi),
+		pythonAuth: asString(config.pythonAuth),
+		pythonApi: asString(config.pythonApi),
+		pythonTaskQueue: asString(config.pythonTaskQueue),
+		pythonGraphql: asString(config.pythonGraphql),
+		pythonQuality: asString(config.pythonQuality),
+		pythonTesting: asStringArray(config.pythonTesting),
+		pythonCaching: asString(config.pythonCaching),
+		pythonRealtime: asString(config.pythonRealtime),
+		pythonObservability: asString(config.pythonObservability),
+		pythonCli: asStringArray(config.pythonCli),
+		goWebFramework: asString(config.goWebFramework),
+		goOrm: asString(config.goOrm),
+		goApi: asString(config.goApi),
+		goCli: asString(config.goCli),
+		goLogging: asString(config.goLogging),
+		goAuth: asString(config.goAuth),
+		goTesting: asStringArray(config.goTesting),
+		goRealtime: asString(config.goRealtime),
+		goMessageQueue: asString(config.goMessageQueue),
+		goCaching: asString(config.goCaching),
+		goConfig: asString(config.goConfig),
+		goObservability: asString(config.goObservability),
+		javaWebFramework: asString(config.javaWebFramework),
+		javaBuildTool: asString(config.javaBuildTool),
+		javaOrm: asString(config.javaOrm),
+		javaAuth: asString(config.javaAuth),
+		javaApi: asString(config.javaApi),
+		javaLogging: asString(config.javaLogging),
+		javaLibraries: asStringArray(config.javaLibraries),
+		javaTestingLibraries: asStringArray(config.javaTestingLibraries),
+		dotnetWebFramework: asString(config.dotnetWebFramework),
+		dotnetOrm: asString(config.dotnetOrm),
+		dotnetAuth: asString(config.dotnetAuth),
+		dotnetApi: asString(config.dotnetApi),
+		dotnetTesting: asStringArray(config.dotnetTesting),
+		dotnetJobQueue: asString(config.dotnetJobQueue),
+		dotnetRealtime: asString(config.dotnetRealtime),
+		dotnetObservability: asStringArray(config.dotnetObservability),
+		dotnetValidation: asString(config.dotnetValidation),
+		dotnetCaching: asString(config.dotnetCaching),
+		dotnetDeploy: asString(config.dotnetDeploy),
+		elixirWebFramework: asString(config.elixirWebFramework),
+		elixirOrm: asString(config.elixirOrm),
+		elixirAuth: asString(config.elixirAuth),
+		elixirApi: asString(config.elixirApi),
+		elixirRealtime: asString(config.elixirRealtime),
+		elixirJobs: asString(config.elixirJobs),
+		elixirValidation: asString(config.elixirValidation),
+		elixirHttp: asString(config.elixirHttp),
+		elixirJson: asString(config.elixirJson),
+		elixirEmail: asString(config.elixirEmail),
+		elixirCaching: asString(config.elixirCaching),
+		elixirObservability: asString(config.elixirObservability),
+		elixirTesting: asString(config.elixirTesting),
+		elixirQuality: asString(config.elixirQuality),
+		elixirDeploy: asString(config.elixirDeploy),
+		elixirLibraries: asStringArray(config.elixirLibraries)
+	};
+}
+function compatibilityChangesToProjectConfig(adjusted, baseConfig) {
+	const frontend = [...adjusted.webFrontend, ...adjusted.nativeFrontend];
+	const ignoredCompatibilityKeys = new Set([
+		"webFrontend",
+		"nativeFrontend",
+		"codeQuality",
+		"documentation",
+		"appPlatforms",
+		"aiSdk",
+		"backendLibraries",
+		"projectName",
+		"git",
+		"install",
+		"yolo"
+	]);
+	const changes = {};
+	for (const [key, value] of Object.entries(adjusted)) if (!ignoredCompatibilityKeys.has(key)) changes[key] = value;
+	changes.frontend = frontend.length > 0 ? frontend : baseConfig.frontend;
+	changes.addons = [
+		...adjusted.codeQuality,
+		...adjusted.documentation,
+		...adjusted.appPlatforms
+	];
+	changes.ai = adjusted.aiSdk;
+	changes.backend = getProjectBackendFromCompatibility(adjusted.backend);
+	return changes;
+}
+function applyKnownDependencyExpansions(config, requestedChanges) {
+	const next = { ...config };
+	const adjustments = [];
+	const requestedKeys = new Set(Object.keys(requestedChanges));
+	const hasWebFrontend = asStringArray(next.frontend).some((item) => !item.startsWith("native-") && item !== "none");
+	if (next.ecosystem === "typescript" && !hasWebFrontend && !requestedKeys.has("frontend")) {
+		const defaultWebFrontend = getDefaultWebFrontendForRequestedUpdate(requestedChanges);
+		if (defaultWebFrontend) {
+			next.frontend = withWebFrontendVariant(next.frontend, defaultWebFrontend);
+			adjustments.push(`frontend: Web frontend set to '${defaultWebFrontend}' (requested feature requires a web app)`);
+		}
+	}
+	if (next.ecosystem === "typescript" && !requestedKeys.has("frontend")) {
+		const hasNativeFrontend = asStringArray(next.frontend).some((item) => item.startsWith("native-"));
+		const defaultNativeFrontend = getDefaultNativeFrontendForRequestedUpdate(requestedChanges);
+		if (defaultNativeFrontend && !hasNativeFrontend) {
+			next.frontend = withNativeFrontendVariant(next.frontend, defaultNativeFrontend);
+			adjustments.push(`mobile: Native frontend set to '${defaultNativeFrontend}' (requested feature requires a native app)`);
+		}
+	}
+	if (next.ecosystem === "typescript" && next.backend === "none" && needsStandaloneBackendForRequestedUpdate(requestedChanges)) {
+		if (!requestedKeys.has("backend")) {
+			next.backend = "hono";
+			adjustments.push("backend: Backend set to 'hono' (requested feature requires a server)");
+		}
+		if (next.backend !== "none" && next.runtime === "none" && !requestedKeys.has("runtime")) {
+			next.runtime = "bun";
+			adjustments.push("backend: Runtime set to 'bun' (Hono server default)");
+		}
+	}
+	if (hasRequestedNonNoneValue(requestedChanges, "orm") && next.database === "none" && !requestedKeys.has("database")) {
+		next.database = "sqlite";
+		adjustments.push("orm: Database set to 'sqlite' (ORM requires a database)");
+	}
+	if (isBetterAuth(requestedChanges.auth) || requestedChanges.payments === "polar") {
+		if (requestedChanges.payments === "polar" && !isBetterAuth(next.auth) && !requestedKeys.has("auth")) {
+			next.auth = "better-auth";
+			adjustments.push("payments: Auth set to 'better-auth' (Polar requires Better Auth)");
+		}
+		if (next.database === "none" && !requestedKeys.has("database")) {
+			next.database = "sqlite";
+			const reason = requestedChanges.payments === "polar" ? "payments: Database set to 'sqlite' (Better Auth requires a SQL database)" : "auth: Database set to 'sqlite' (Better Auth requires a SQL database)";
+			adjustments.push(reason);
+		}
+		if (next.orm === "none" && !requestedKeys.has("orm")) {
+			next.orm = "drizzle";
+			const reason = requestedChanges.payments === "polar" ? "payments: ORM set to 'drizzle' (Better Auth requires an adapter)" : "auth: ORM set to 'drizzle' (Better Auth requires an adapter)";
+			adjustments.push(reason);
+		}
+	}
+	if (requestedChanges.uiLibrary && requestedChanges.uiLibrary !== "none") {
+		const requiredCssFramework = getRequiredCssFrameworkForUiLibrary(requestedChanges.uiLibrary);
+		if (requiredCssFramework && next.cssFramework !== requiredCssFramework && !requestedKeys.has("cssFramework")) {
+			next.cssFramework = requiredCssFramework;
+			adjustments.push(`uiLibrary: CSS framework set to '${requiredCssFramework}' (${requestedChanges.uiLibrary} requires Tailwind CSS)`);
+		}
+	}
+	if (requestedChanges.mobileUI === "uniwind" && !requestedKeys.has("frontend")) {
+		if (!asStringArray(next.frontend).includes("native-uniwind")) {
+			next.frontend = withNativeFrontendVariant(next.frontend, "native-uniwind");
+			adjustments.push("mobileUI: Native frontend set to 'native-uniwind' (Uniwind mobile UI requires Expo + Uniwind)");
+		}
+	}
+	if (requestedChanges.mobileUI === "unistyles" && !requestedKeys.has("frontend")) {
+		if (!asStringArray(next.frontend).includes("native-unistyles")) {
+			next.frontend = withNativeFrontendVariant(next.frontend, "native-unistyles");
+			adjustments.push("mobileUI: Native frontend set to 'native-unistyles' (Unistyles mobile UI requires Expo + Unistyles)");
+		}
+	}
+	if (requestedChanges.dbSetup && requestedChanges.dbSetup !== "none") {
+		const defaultDatabase = getDefaultDatabaseForDbSetup(requestedChanges.dbSetup);
+		if (defaultDatabase && next.database !== defaultDatabase && !requestedKeys.has("database")) {
+			next.database = defaultDatabase;
+			adjustments.push(`dbSetup: Database set to '${defaultDatabase}' (${requestedChanges.dbSetup} requires ${defaultDatabase})`);
+		}
+		const defaultOrm = getDefaultOrmForDatabase(next.database);
+		if (defaultOrm && next.orm === "none" && !requestedKeys.has("orm")) {
+			next.orm = defaultOrm;
+			adjustments.push(`dbSetup: ORM set to '${defaultOrm}' (${requestedChanges.dbSetup} requires a database adapter)`);
+		}
+	}
+	if (requestedChanges.dbSetup === "d1") {
+		if (next.runtime !== "workers" && !requestedKeys.has("runtime")) {
+			next.runtime = "workers";
+			adjustments.push("dbSetup: Runtime set to 'workers' (D1 requires Workers)");
+		}
+		if (next.backend !== "hono" && !requestedKeys.has("backend")) {
+			next.backend = "hono";
+			adjustments.push("dbSetup: Backend set to 'hono' (Workers requires Hono)");
+		}
+	}
+	if (requestedChanges.serverDeploy === "cloudflare") {
+		if (next.backend === "hono" && next.runtime !== "workers" && !requestedKeys.has("runtime")) {
+			next.runtime = "workers";
+			adjustments.push("serverDeploy: Runtime set to 'workers' (Cloudflare requires Workers)");
+		}
+	}
+	if (requestedChanges.serverDeploy === "netlify") {
+		if (next.backend === "hono" && next.runtime !== "node" && !requestedKeys.has("runtime")) {
+			next.runtime = "node";
+			adjustments.push("serverDeploy: Runtime set to 'node' (Netlify Functions requires Node)");
+		}
+	}
+	if (asStringArray(next.examples).includes("chat-sdk")) {
+		if (getCompatibilityBackend(next, asStringArray(next.frontend).filter((item) => !item.startsWith("native-") && item !== "none")) === "hono" && next.runtime !== "node" && !requestedKeys.has("runtime")) {
+			next.runtime = "node";
+			adjustments.push("examples: Runtime set to 'node' (Chat SDK Hono profile requires Node)");
+		}
+		if ((0, types_exports.requiresChatSdkVercelAI)(buildCompatibilityInputFromConfig(next)) && next.ai !== "vercel-ai" && !requestedKeys.has("ai")) {
+			next.ai = "vercel-ai";
+			adjustments.push("examples: AI SDK set to 'vercel-ai' (Chat SDK profile requires Vercel AI)");
+		}
+	}
+	return {
+		config: next,
+		adjustments
+	};
+}
+async function generateTree(config) {
+	const result = await generateVirtualProject({
+		config,
+		templates: EMBEDDED_TEMPLATES
+	});
+	if (!result.success || !result.tree) throw new Error(result.error ?? "Failed to generate virtual project");
+	return result.tree;
+}
+function treeToFileMap(tree) {
+	const files = /* @__PURE__ */ new Map();
+	function walk(nodes) {
+		for (const node of nodes) if (node.type === "file") files.set(node.path, node);
+		else walk(node.children);
+	}
+	walk(tree.root.children);
+	return files;
+}
+function parseJson(content) {
+	if (!content) return null;
+	try {
+		const parsed = JSON.parse(content);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function stringifyJson(data) {
+	return `${JSON.stringify(data, null, 2)}\n`;
+}
+function isPlainObject(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function diffJsonSection(current, previous, proposed, section) {
+	const previousSection = isPlainObject(previous[section]) ? previous[section] : {};
+	const proposedSection = isPlainObject(proposed[section]) ? proposed[section] : {};
+	const currentSection = isPlainObject(current[section]) ? current[section] : {};
+	const values = {};
+	const blockers = [];
+	for (const [name, proposedValue] of Object.entries(proposedSection)) {
+		if (previousSection[name] === proposedValue) continue;
+		const currentValue = currentSection[name];
+		if (currentValue !== void 0 && currentValue !== previousSection[name]) {
+			blockers.push(`${section}.${name}`);
+			continue;
+		}
+		values[name] = String(proposedValue);
+	}
+	return {
+		values,
+		blockers
+	};
+}
+function mergePackageJson(existingContent, previousContent, proposedContent) {
+	const existing = parseJson(existingContent);
+	const previous = parseJson(previousContent);
+	const proposed = parseJson(proposedContent);
+	if (!existing || !previous || !proposed) return {
+		summary: [],
+		blockers: ["package.json is not valid JSON or has no generated baseline"],
+		dependencyChanges: {},
+		scriptChanges: []
+	};
+	const next = structuredClone(existing);
+	const summary = [];
+	const blockers = [];
+	const dependencyChanges = {};
+	const scriptChanges = [];
+	for (const section of PACKAGE_JSON_SECTIONS) {
+		const diff = diffJsonSection(existing, previous, proposed, section);
+		blockers.push(...diff.blockers);
+		if (Object.keys(diff.values).length === 0) continue;
+		const target = isPlainObject(next[section]) ? { ...next[section] } : {};
+		for (const [name, value] of Object.entries(diff.values)) target[name] = value;
+		next[section] = Object.fromEntries(Object.entries(target).sort(([a], [b]) => a.localeCompare(b)));
+		summary.push(`${section}: ${Object.keys(diff.values).join(", ")}`);
+		if (section === "scripts") scriptChanges.push(...Object.keys(diff.values));
+		else dependencyChanges[section] = diff.values;
+	}
+	return {
+		content: blockers.length === 0 && summary.length > 0 ? stringifyJson(next) : void 0,
+		summary,
+		blockers,
+		dependencyChanges,
+		scriptChanges
+	};
+}
+function parseEnvKeys(content) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const rawLine of content.split("\n")) {
+		const line = rawLine.trim();
+		if (!line || line.startsWith("#")) continue;
+		const eq = line.indexOf("=");
+		if (eq === -1) continue;
+		const key = line.slice(0, eq).trim();
+		if (key) keys.add(key);
+	}
+	return keys;
+}
+function mergeEnvExample(existingContent, previousContent, proposedContent) {
+	const existingKeys = parseEnvKeys(existingContent);
+	const previousKeys = previousContent ? parseEnvKeys(previousContent) : /* @__PURE__ */ new Set();
+	const nextLines = [];
+	const keys = [];
+	for (const line of proposedContent.split("\n")) {
+		const trimmed = line.trim();
+		const eq = trimmed.indexOf("=");
+		if (!trimmed || trimmed.startsWith("#") || eq === -1) continue;
+		const key = trimmed.slice(0, eq).trim();
+		if (!key || previousKeys.has(key) || existingKeys.has(key)) continue;
+		nextLines.push(line);
+		keys.push(key);
+	}
+	if (nextLines.length === 0) return { keys };
+	return {
+		content: `${existingContent}${existingContent.endsWith("\n") ? "" : "\n"}${nextLines.join("\n")}\n`,
+		keys
+	};
+}
+function collectEnvReferences(content) {
+	const keys = /* @__PURE__ */ new Set();
+	if (!content) return keys;
+	for (const pattern of [
+		/\bprocess\.env\.([A-Z][A-Z0-9_]*)/g,
+		/\bDeno\.env\.get\(\s*["']([A-Z][A-Z0-9_]*)["']/g,
+		/\bSystem\.getenv\(\s*["']([A-Z][A-Z0-9_]*)["']/g,
+		/\bstd::env::var\(\s*["']([A-Z][A-Z0-9_]*)["']/g,
+		/\bos\.Getenv\(\s*["']([A-Z][A-Z0-9_]*)["']/g,
+		/\bos\.environ\[\s*["']([A-Z][A-Z0-9_]*)["']\s*\]/g,
+		/\bos\.getenv\(\s*["']([A-Z][A-Z0-9_]*)["']/g,
+		/^([A-Z][A-Z0-9_]*)=/gm
+	]) for (const match of content.matchAll(pattern)) if (match[1]) keys.add(match[1]);
+	return keys;
+}
+function recordEnvReferenceChanges(envChanges, filePath, previousContent, proposedContent) {
+	const previous = collectEnvReferences(previousContent);
+	const added = [...collectEnvReferences(proposedContent)].filter((key) => !previous.has(key)).sort();
+	if (added.length > 0) envChanges[filePath] = [...new Set([...envChanges[filePath] ?? [], ...added])].sort();
+}
+function getInstallCommand$1(config) {
+	switch (config.ecosystem) {
+		case "rust": return "cargo build";
+		case "python": return "uv sync";
+		case "go": return "go mod tidy";
+		case "java": return config.javaBuildTool === "gradle" ? "./gradlew test" : "./mvnw test";
+		case "elixir": return "mix deps.get && mix compile";
+		default: return config.packageManager === "npm" ? "npm install" : `${config.packageManager} install`;
+	}
+}
+function getGraphPreview(config) {
+	const stackParts = config.stackParts?.length ? config.stackParts : (0, types_exports.legacyProjectConfigToStackParts)(config);
+	const graphSummary = stackParts.length > 0 ? getGraphSummary({ stackParts }) : void 0;
+	const effectiveStack = stackParts.length > 0 ? getEffectiveStack({ stackParts }) : void 0;
+	const stackPartSpecs = stackParts.filter((part) => part.source !== "provided").map((part) => (0, types_exports.formatStackPartSpec)(part, stackParts));
+	return {
+		...graphSummary ? {
+			graphSummary,
+			effectiveStack
+		} : {},
+		stackPartSpecs
+	};
+}
+async function planStackUpdate(projectDirInput, input) {
+	const projectDir = path.resolve(projectDirInput);
+	const currentBtsConfig = await readBtsConfig(projectDir);
+	if (!currentBtsConfig) return {
+		success: false,
+		projectDir,
+		error: `No bts.jsonc found in ${projectDir}. Is this a Better-Fullstack project?`
+	};
+	const projectName = await inferProjectName(projectDir);
+	const currentConfig = configFromBtsConfig(currentBtsConfig, projectDir, projectName);
+	const { changes: requestedChanges, stackPartSpecs, unsupportedKeys } = buildRequestedChanges(input);
+	if (unsupportedKeys.length > 0) return {
+		success: false,
+		projectDir,
+		error: `Unsupported stack update field(s): ${unsupportedKeys.sort().join(", ")}`
+	};
+	let proposedConfig = mergeProjectConfig(currentConfig, requestedChanges);
+	const dependencyExpansion = applyKnownDependencyExpansions(proposedConfig, requestedChanges);
+	proposedConfig = dependencyExpansion.config;
+	const compatibilityResult = proposedConfig.ecosystem === "typescript" || proposedConfig.ecosystem === "react-native" ? (0, types_exports.analyzeStackCompatibility)(buildCompatibilityInputFromConfig(proposedConfig)) : {
+		adjustedStack: null,
+		changes: []
+	};
+	const compatibilityAdjustments = [...dependencyExpansion.adjustments, ...compatibilityResult.changes.map((change) => `${change.category}: ${change.message}`)];
+	if (compatibilityResult.adjustedStack) proposedConfig = mergeProjectConfig(proposedConfig, compatibilityChangesToProjectConfig(compatibilityResult.adjustedStack, proposedConfig));
+	proposedConfig.stackParts = (0, types_exports.legacyProjectConfigToStackParts)(proposedConfig);
+	Object.assign(proposedConfig, mergeStackPartSpecs(proposedConfig, stackPartSpecs));
+	try {
+		validateConfigForProgrammaticUse(proposedConfig);
+	} catch (error) {
+		return {
+			success: false,
+			projectDir,
+			error: `Invalid stack update: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	const persistedProposedConfig = buildBtsConfigForPersistence(proposedConfig, {
+		version: currentBtsConfig.version,
+		createdAt: currentBtsConfig.createdAt
+	});
+	const normalizedProposedConfig = configFromBtsConfig(persistedProposedConfig, projectDir, projectName);
+	let currentTree;
+	let proposedTree;
+	try {
+		[currentTree, proposedTree] = await Promise.all([generateTree(currentConfig), generateTree(normalizedProposedConfig)]);
+	} catch (error) {
+		return {
+			success: false,
+			projectDir,
+			error: `Failed to generate stack update plan: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	const currentGeneratedFiles = treeToFileMap(currentTree);
+	const proposedGeneratedFiles = treeToFileMap(proposedTree);
+	const operations = [];
+	const filesToAdd = [];
+	const filesToPatch = [];
+	const filesUnchanged = [];
+	const manualReviewBlockers = [];
+	const dependencyChanges = {};
+	const scriptChanges = {};
+	const envChanges = {};
+	const proposedFileEntries = await Promise.all([...proposedGeneratedFiles].map(async ([filePath, proposedFile]) => {
+		const existingPath = path.join(projectDir, filePath);
+		const exists = await fs.pathExists(existingPath);
+		return {
+			filePath,
+			proposedFile,
+			exists,
+			existingBuffer: exists ? await fs.readFile(existingPath).catch(() => void 0) : void 0
+		};
+	}));
+	for (const { filePath, proposedFile, exists, existingBuffer } of proposedFileEntries) {
+		const previousFile = currentGeneratedFiles.get(filePath);
+		const proposedContent = proposedFile.content;
+		const previousContent = previousFile?.content;
+		const isBinaryFile = isGeneratedBinaryFile(proposedFile) || isGeneratedBinaryFile(previousFile);
+		const existingContent = exists && existingBuffer && !isBinaryFile ? existingBuffer.toString("utf-8") : void 0;
+		if (!exists) {
+			filesToAdd.push(filePath);
+			operations.push({
+				kind: "add",
+				path: filePath,
+				writeMode: "generated"
+			});
+			if (isEnvFilePath(filePath)) envChanges[filePath] = [...parseEnvKeys(proposedContent)].sort();
+			recordEnvReferenceChanges(envChanges, filePath, void 0, proposedContent);
+			continue;
+		}
+		if (isBinaryFile) {
+			const [previousBinaryContent, proposedBinaryContent] = await Promise.all([readGeneratedFileBytes(currentTree, filePath, previousFile), readGeneratedFileBytes(proposedTree, filePath, proposedFile)]);
+			if (buffersEqual(existingBuffer, proposedBinaryContent)) {
+				filesUnchanged.push(filePath);
+				continue;
+			}
+			if (buffersEqual(existingBuffer, previousBinaryContent)) {
+				filesToPatch.push(filePath);
+				operations.push({
+					kind: "replace",
+					path: filePath,
+					writeMode: "generated"
+				});
+				continue;
+			}
+			manualReviewBlockers.push(`${filePath}: existing binary file differs from the generated baseline`);
+			continue;
+		}
+		if (existingContent === void 0 || existingContent === proposedContent) {
+			filesUnchanged.push(filePath);
+			continue;
+		}
+		if (filePath.endsWith("package.json")) {
+			const merged = mergePackageJson(existingContent, previousContent, proposedContent);
+			for (const blocker of merged.blockers) manualReviewBlockers.push(`${filePath}: ${blocker}`);
+			if (merged.content) {
+				filesToPatch.push(filePath);
+				operations.push({
+					kind: "merge",
+					path: filePath,
+					writeMode: "content",
+					content: merged.content,
+					summary: merged.summary
+				});
+				for (const [section, values] of Object.entries(merged.dependencyChanges)) dependencyChanges[`${filePath}:${section}`] = values;
+				if (merged.scriptChanges.length > 0) scriptChanges[filePath] = merged.scriptChanges;
+			}
+			continue;
+		}
+		if (isEnvFilePath(filePath)) {
+			const merged = mergeEnvExample(existingContent, previousContent, proposedContent);
+			if (merged.content) {
+				filesToPatch.push(filePath);
+				operations.push({
+					kind: "merge",
+					path: filePath,
+					writeMode: "content",
+					content: merged.content,
+					summary: [`env: ${merged.keys.join(", ")}`]
+				});
+				envChanges[filePath] = merged.keys;
+			}
+			continue;
+		}
+		if (previousContent !== void 0 && existingContent === previousContent) {
+			filesToPatch.push(filePath);
+			operations.push({
+				kind: "replace",
+				path: filePath,
+				writeMode: "generated"
+			});
+			recordEnvReferenceChanges(envChanges, filePath, previousContent, proposedContent);
+			continue;
+		}
+		if (isSkippableGeneratedDoc(filePath)) continue;
+		manualReviewBlockers.push(`${filePath}: existing file differs from the generated baseline`);
+	}
+	const graphPreview = getGraphPreview(persistedProposedConfig);
+	return {
+		success: true,
+		projectDir,
+		requestedChanges,
+		proposedConfig: persistedProposedConfig,
+		filesToAdd: [...new Set(filesToAdd)].sort(),
+		filesToPatch: [...new Set(filesToPatch)].sort(),
+		filesUnchanged: [...new Set(filesUnchanged)].sort(),
+		dependencyChanges,
+		scriptChanges,
+		envChanges,
+		manualReviewBlockers,
+		operations,
+		installCommand: getInstallCommand$1(normalizedProposedConfig),
+		compatibilityAdjustments,
+		...graphPreview
+	};
+}
+async function applyStackUpdate(projectDirInput, input) {
+	const plan = await planStackUpdate(projectDirInput, input);
+	if (!plan.success) return plan;
+	if (plan.manualReviewBlockers.length > 0) return {
+		success: false,
+		projectDir: plan.projectDir,
+		error: `Manual review required before applying stack update: ${plan.manualReviewBlockers.join("; ")}`
+	};
+	const projectName = await inferProjectName(plan.projectDir);
+	const proposedConfig = configFromBtsConfig(plan.proposedConfig, plan.projectDir, projectName);
+	const proposedTree = await generateTree(proposedConfig);
+	const generatedPaths = new Set(plan.operations.filter((operation) => operation.writeMode === "generated").map((operation) => operation.path));
+	if (generatedPaths.size > 0) await writeSelectedFiles(proposedTree, plan.projectDir, (filePath) => generatedPaths.has(filePath));
+	await Promise.all(plan.operations.filter((operation) => operation.writeMode === "content").map(async (operation) => {
+		const targetPath = path.join(plan.projectDir, operation.path);
+		await fs.ensureDir(path.dirname(targetPath));
+		await fs.writeFile(targetPath, operation.content, "utf-8");
+	}));
+	await writeBtsConfig(proposedConfig, {
+		version: plan.proposedConfig.version,
+		createdAt: plan.proposedConfig.createdAt
+	});
+	return plan;
+}
+
+//#endregion
 //#region src/mcp.ts
 const INSTRUCTIONS = `Better-Fullstack scaffolds fullstack projects across TypeScript, React Native, Rust, Go, Python, Java, .NET, and Elixir ecosystems with ${Object.values(OPTION_CATEGORY_METADATA).reduce((sum, metadata) => sum + metadata.options.length, 0)} configurable options.
 
@@ -16,8 +908,9 @@ RECOMMENDED WORKFLOW:
 5. Call bfs_create_project to scaffold the project on disk.
 
 For existing projects:
-1. Call bfs_plan_addition to validate proposed changes.
-2. Call bfs_add_feature to apply changes.
+1. Call bfs_plan_stack_update to preview scaffold-time capability changes.
+2. Call bfs_apply_stack_update to safely apply supported stack changes.
+3. Use bfs_plan_addition / bfs_add_feature only for legacy addon/deploy-only flows.
 
 CRITICAL RULES:
 - Dependency installation is ALWAYS skipped in MCP mode (timeout risk). After scaffolding, tell the user to run install manually.
@@ -34,7 +927,8 @@ function getGuidance() {
 			"Call bfs_check_compatibility to validate your planned stack before creation.",
 			"Call bfs_plan_project to preview the generated project (dry-run, no files written).",
 			"Call bfs_create_project to scaffold the project on disk.",
-			"For existing projects: call bfs_plan_addition, then bfs_add_feature."
+			"For existing projects: call bfs_plan_stack_update, then bfs_apply_stack_update.",
+			"Use bfs_plan_addition / bfs_add_feature only for legacy addon/deploy-only flows."
 		],
 		ecosystems: {
 			typescript: "Full-featured web: frontend + backend + database + ORM + auth + payments + 20+ feature categories.",
@@ -56,7 +950,8 @@ function getGuidance() {
 			addons: "ARRAY of strings. Monorepo tools, code quality, desktop (tauri), browser extensions (wxt), etc.",
 			email: "String. TypeScript supports multiple providers; Rust, Python, Go, and Java currently support resend or none.",
 			observability: "String. TypeScript supports multiple providers; Rust, Python, Go, and Java currently support sentry or none.",
-			search: "String. TypeScript supports multiple providers; Rust, Python, Go, and Java currently support meilisearch or none."
+			search: "String. TypeScript supports multiple providers; Rust, Python, Go, and Java currently support meilisearch or none.",
+			vectorDb: "String. TypeScript-only vector database for AI embeddings: pgvector, qdrant, chroma, pinecone, or none. Each provider is a standalone service (pgvector connects to a dedicated Postgres+pgvector instance via PGVECTOR_DATABASE_URL). Requires a standalone backend (not convex/none)."
 		},
 		ambiguityRules: [
 			"If the user request leaves major stack choices unspecified, ASK the user before proceeding. Do not guess.",
@@ -118,14 +1013,7 @@ const MCP_SCHEMA_EXCLUDED_CATEGORIES = new Set([
 	"aiDocs",
 	"git",
 	"install",
-	"versionChannel",
-	"shadcnBase",
-	"shadcnStyle",
-	"shadcnIconLibrary",
-	"shadcnColorTheme",
-	"shadcnBaseColor",
-	"shadcnFont",
-	"shadcnRadius"
+	"versionChannel"
 ]);
 const MCP_SCHEMA_OPTION_OVERRIDES = {
 	ecosystem: EcosystemSchema.options,
@@ -245,6 +1133,7 @@ const MCP_COMPATIBILITY_DEFAULTS = {
 	shadcnRadius: "default",
 	cms: "none",
 	search: "none",
+	vectorDb: "none",
 	fileStorage: "none",
 	mobileUI: "none",
 	mobileStorage: "none",
@@ -255,7 +1144,7 @@ const MCP_COMPATIBILITY_DEFAULTS = {
 	versionChannel: "stable",
 	examples: [],
 	aiSdk: "none",
-	aiDocs: ["claude-md"],
+	aiDocs: ["claude-md", "agents-md"],
 	git: "true",
 	install: "false",
 	api: "none",
@@ -364,7 +1253,7 @@ function buildProjectConfig(input, overrides) {
 	const hasNativeFrontend = frontend.some((item) => item.startsWith("native-"));
 	const hasMobileProject = ecosystem === "react-native" || hasNativeFrontend;
 	const defaults = getMcpProjectConfigDefaults(input);
-	return {
+	const config = {
 		projectName,
 		projectDir: overrides?.projectDir ?? "/virtual",
 		relativePath: overrides ? `./${projectName}` : "./virtual",
@@ -376,19 +1265,22 @@ function buildProjectConfig(input, overrides) {
 		cssFramework: input.cssFramework ?? (ecosystem === "react-native" ? "none" : defaults.cssFramework),
 		mobileNavigation: input.mobileNavigation ?? (hasMobileProject ? "expo-router" : "none"),
 		mobileDeepLinking: input.mobileDeepLinking ?? (hasMobileProject ? "expo-linking" : "none"),
-		astroIntegration: "none",
-		versionChannel: "stable",
-		shadcnBase: "radix",
-		shadcnStyle: "nova",
-		shadcnIconLibrary: "lucide",
-		shadcnColorTheme: "neutral",
-		shadcnBaseColor: "neutral",
-		shadcnFont: "inter",
-		shadcnRadius: "default",
-		aiDocs: ["claude-md"],
+		shadcnBase: input.shadcnBase ?? "radix",
+		shadcnStyle: input.shadcnStyle ?? "nova",
+		shadcnIconLibrary: input.shadcnIconLibrary ?? "lucide",
+		shadcnColorTheme: input.shadcnColorTheme ?? "neutral",
+		shadcnBaseColor: input.shadcnBaseColor ?? "neutral",
+		shadcnFont: input.shadcnFont ?? "inter",
+		shadcnRadius: input.shadcnRadius ?? "default",
+		aiDocs: input.aiDocs ?? ["claude-md", "agents-md"],
 		git: !!overrides,
 		install: false
 	};
+	if (Array.isArray(input.part) && input.part.length > 0) {
+		const stackParts = parseStackPartSpecs(input.part.filter((part) => typeof part === "string"), "selected");
+		Object.assign(config, stackPartsToLegacyProjectConfigPartial(stackParts), { stackParts });
+	}
+	return config;
 }
 function sanitizePath(input) {
 	for (const ch of input) if (ch.charCodeAt(0) < 32) throw new Error("Path contains control characters");
@@ -561,10 +1453,450 @@ const GETTING_STARTED_MD = `# Getting Started with Better-Fullstack MCP
 2. Tell the user to run: cd my-elixir-app && mix deps.get && mix phx.server
 
 ## Adding Features to Existing Projects
-1. Call bfs_add_feature with projectDir pointing to the project root.
-2. Provide addons array with features to add (e.g., ["biome", "turborepo"]).
-3. Service categories such as email and observability are scaffold-time options. To add those to an existing app, inspect the generated templates from bfs_plan_project and apply the equivalent dependency, env var, and initialization changes manually.
+1. Call bfs_plan_stack_update with projectDir and any stack fields to add or change.
+2. Review filesToAdd, filesToPatch, dependencyChanges, envChanges, and manualReviewBlockers.
+3. If there are no blockers, call bfs_apply_stack_update with the same arguments.
+4. Use bfs_add_feature only for older addon/deploy-only workflows.
 `;
+const guidanceOutputSchema = {
+	workflow: z.array(z.string()),
+	ecosystems: z.record(z.string(), z.string()),
+	fieldRules: z.record(z.string(), z.string()),
+	ambiguityRules: z.array(z.string()),
+	criticalConstraints: z.array(z.string())
+};
+const schemaOutputSchema = {
+	category: z.string().optional(),
+	options: z.array(z.string()).optional(),
+	categories: z.record(z.string(), z.array(z.string())).optional(),
+	error: z.string().optional()
+};
+const compatibilityIssueOutputSchema = z.object({
+	code: z.string(),
+	message: z.string(),
+	category: z.string().optional(),
+	optionId: z.string().optional(),
+	provided: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
+	suggestions: z.array(z.string()).optional()
+});
+const compatibilityOutputSchema = {
+	adjustedStack: z.record(z.string(), z.unknown()).nullable(),
+	changes: z.array(z.object({
+		category: z.string(),
+		message: z.string()
+	})),
+	issues: z.array(compatibilityIssueOutputSchema),
+	hasIssues: z.boolean()
+};
+const graphPreviewOutputShape = {
+	graphSummary: z.string().optional(),
+	effectiveStack: z.record(z.string(), z.string()).optional(),
+	stackPartSpecs: z.array(z.string()).optional()
+};
+const planProjectOutputSchema = {
+	success: z.boolean(),
+	fileCount: z.number().optional(),
+	directoryCount: z.number().optional(),
+	files: z.array(z.string()).optional(),
+	...graphPreviewOutputShape
+};
+const createProjectOutputSchema = {
+	success: z.boolean(),
+	projectDirectory: z.string().optional(),
+	fileCount: z.number().optional(),
+	addonWarnings: z.array(z.string()).optional(),
+	message: z.string().optional(),
+	...graphPreviewOutputShape
+};
+const planAdditionOutputSchema = {
+	success: z.boolean(),
+	existingConfig: z.object({
+		ecosystem: z.string(),
+		frontend: z.array(z.string()).optional(),
+		backend: z.string().optional(),
+		addons: z.array(z.string()).optional(),
+		graphSummary: z.string().optional(),
+		effectiveStack: z.record(z.string(), z.string()).optional(),
+		stackPartSpecs: z.array(z.string())
+	}).optional(),
+	proposedAdditions: z.object({
+		newAddons: z.array(z.string()),
+		webDeploy: z.string().nullable(),
+		serverDeploy: z.string().nullable(),
+		graphSummary: z.string().optional(),
+		effectiveStack: z.record(z.string(), z.string()).optional(),
+		stackPartSpecs: z.array(z.string())
+	}).optional(),
+	alreadyPresent: z.array(z.string()).optional(),
+	compatibilityWarnings: z.array(z.string()).optional()
+};
+const addFeatureOutputSchema = {
+	success: z.boolean(),
+	addedAddons: z.array(z.string()).optional(),
+	projectDir: z.string().optional(),
+	message: z.string().optional(),
+	...graphPreviewOutputShape
+};
+const stackUpdateOutputSchema = {
+	success: z.boolean(),
+	projectDir: z.string().optional(),
+	error: z.string().optional(),
+	requestedChanges: z.record(z.string(), z.unknown()).optional(),
+	proposedConfig: z.record(z.string(), z.unknown()).optional(),
+	filesToAdd: z.array(z.string()).optional(),
+	filesToPatch: z.array(z.string()).optional(),
+	dependencyChanges: z.record(z.string(), z.record(z.string(), z.string())).optional(),
+	scriptChanges: z.record(z.string(), z.array(z.string())).optional(),
+	envChanges: z.record(z.string(), z.array(z.string())).optional(),
+	manualReviewBlockers: z.array(z.string()).optional(),
+	compatibilityAdjustments: z.array(z.string()).optional(),
+	compatibilityWarnings: z.array(z.string()).optional(),
+	installCommand: z.string().optional(),
+	message: z.string().optional(),
+	...graphPreviewOutputShape
+};
+function buildPresetStackSummary(config) {
+	const parts = [];
+	const frontend = (config.frontend ?? []).filter((item) => item !== "none");
+	if (frontend.length > 0) parts.push(`frontend: ${frontend.join("+")}`);
+	if (config.backend && config.backend !== "none") parts.push(`backend: ${config.backend}`);
+	if (config.runtime && config.runtime !== "none") parts.push(`runtime: ${config.runtime}`);
+	if (config.database && config.database !== "none") parts.push(`database: ${config.database}`);
+	if (config.orm && config.orm !== "none") parts.push(`orm: ${config.orm}`);
+	if (config.api && config.api !== "none") parts.push(`api: ${config.api}`);
+	if (config.auth && config.auth !== "none") parts.push(`auth: ${config.auth}`);
+	if (config.payments && config.payments !== "none") parts.push(`payments: ${config.payments}`);
+	const addons = (config.addons ?? []).filter((item) => item !== "none");
+	if (addons.length > 0) parts.push(`addons: ${addons.join("+")}`);
+	return parts.join(", ");
+}
+function listMcpPresets() {
+	const presets = [];
+	for (const id of TEMPLATE_VALUES) {
+		if (id === "none") continue;
+		const config = getTemplateConfig(id);
+		if (!config) continue;
+		const ecosystem = (config.frontend ?? []).some((item) => item.startsWith("native-")) ? "react-native" : "typescript";
+		presets.push({
+			id,
+			name: id.toUpperCase(),
+			description: getTemplateDescription(id),
+			ecosystem,
+			stackSummary: buildPresetStackSummary(config),
+			stack: config
+		});
+	}
+	return presets;
+}
+function briefMatches(text, keywords) {
+	const tokens = new Set(text.split(/[^a-z0-9]+/i).filter(Boolean));
+	return keywords.some((keyword) => keyword.includes(" ") ? text.includes(keyword) : tokens.has(keyword));
+}
+function matchNearestPreset(input) {
+	const signatureKeys = [
+		"database",
+		"backend",
+		"api",
+		"auth"
+	];
+	const inputFrontend = input.frontend?.[0];
+	let best = null;
+	for (const id of TEMPLATE_VALUES) {
+		if (id === "none") continue;
+		const config = getTemplateConfig(id);
+		if (!config) continue;
+		let score = 0;
+		for (const key of signatureKeys) {
+			const value = config[key];
+			if (value !== void 0 && value === input[key]) score += 1;
+		}
+		const presetFrontend = (config.frontend ?? [])[0];
+		if (presetFrontend && presetFrontend === inputFrontend) score += 1;
+		if (!best || score > best.score) best = {
+			id,
+			score
+		};
+	}
+	return best && best.score >= 3 ? best.id : null;
+}
+function recommendStackFromBrief(brief, ecosystemHint) {
+	const text = brief.toLowerCase();
+	const has = (...keywords) => briefMatches(text, keywords);
+	const rationale = [];
+	const input = {};
+	if (ecosystemHint && ecosystemHint !== "typescript") {
+		input.ecosystem = ecosystemHint;
+		rationale.push(`Ecosystem forced to ${ecosystemHint} from the provided hint; using ${ecosystemHint} defaults.`);
+		rationale.push(`Brief keyword analysis (database/auth/payments/AI feature detection) currently applies to the TypeScript ecosystem only — configure those features explicitly for ${ecosystemHint} via bfs_check_compatibility.`);
+		return {
+			input,
+			rationale,
+			matchedPreset: null
+		};
+	}
+	if (has("mobile", "ios", "android", "expo") || text.includes("react native") || text.includes("react-native") || text.includes("app store") || text.includes("play store")) {
+		input.ecosystem = "react-native";
+		input.frontend = ["native-uniwind"];
+		input.backend = "none";
+		input.runtime = "none";
+		input.api = "none";
+		input.database = "none";
+		input.orm = "none";
+		rationale.push("Mobile app detected: React Native (Expo) with the native-uniwind styling preset and no bundled backend.");
+		return {
+			input,
+			rationale,
+			matchedPreset: "uniwind"
+		};
+	}
+	input.ecosystem = "typescript";
+	input.frontend = ["tanstack-router"];
+	input.backend = "hono";
+	input.runtime = "bun";
+	input.database = "sqlite";
+	input.orm = "drizzle";
+	input.api = "trpc";
+	rationale.push("Default TypeScript fullstack baseline: TanStack Router + Hono + tRPC on SQLite/Drizzle (Bun).");
+	if (has("postgres", "postgresql", "supabase", "neon")) {
+		input.database = "postgres";
+		input.orm = "drizzle";
+		rationale.push("Postgres requested: database=postgres, orm=drizzle.");
+	} else if (has("mysql", "planetscale")) {
+		input.database = "mysql";
+		input.orm = "drizzle";
+		rationale.push("MySQL requested: database=mysql, orm=drizzle.");
+	} else if (has("mongo", "mongodb")) {
+		input.database = "mongodb";
+		input.orm = "mongoose";
+		rationale.push("MongoDB requested: database=mongodb, orm=mongoose.");
+	}
+	if (has("saas", "payment", "payments", "billing", "subscription", "subscriptions", "checkout", "stripe", "ecommerce")) {
+		input.payments = "stripe";
+		input.auth = "better-auth";
+		if (input.database === "sqlite") {
+			input.database = "postgres";
+			input.orm = "drizzle";
+		}
+		rationale.push("SaaS/payments detected: Stripe + better-auth, upgraded to Postgres/Drizzle for production data.");
+	} else if (has("auth", "login", "signin", "signup", "account", "accounts", "user", "users", "authentication", "admin", "dashboard", "portal", "members", "rbac", "permissions", "roles")) {
+		input.auth = "better-auth";
+		rationale.push("Authentication requested: auth=better-auth.");
+	}
+	if (has("ai", "chatbot", "llm", "gpt", "rag", "agent", "agents", "openai", "assistant", "copilot")) {
+		input.ai = "vercel-ai";
+		input.examples = ["ai"];
+		rationale.push("AI/chatbot detected: Vercel AI SDK with the bundled AI example.");
+	}
+	if (has("blog", "content", "cms", "marketing", "landing", "publishing")) {
+		input.cms = "sanity";
+		rationale.push("Content/marketing site detected: Sanity CMS.");
+	}
+	if (has("realtime", "collaborative", "collaboration", "multiplayer", "presence") || text.includes("real-time") || text.includes("real time")) {
+		input.realtime = "socket-io";
+		rationale.push("Realtime/collaboration detected: Socket.IO.");
+	}
+	let matchedPreset = null;
+	if (has("t3")) matchedPreset = "t3";
+	else if (has("mern")) matchedPreset = "mern";
+	else if (has("pern")) matchedPreset = "pern";
+	else matchedPreset = matchNearestPreset(input);
+	if (matchedPreset) rationale.push(`Closest ready-made preset: ${matchedPreset}.`);
+	return {
+		input,
+		rationale,
+		matchedPreset
+	};
+}
+function normalizeAdjustedToInput(adjusted, base) {
+	const webFrontend = adjusted.webFrontend ?? [];
+	const nativeFrontend = adjusted.nativeFrontend ?? [];
+	const frontend = [...webFrontend, ...nativeFrontend];
+	const codeQuality = adjusted.codeQuality ?? [];
+	const documentation = adjusted.documentation ?? [];
+	const appPlatforms = adjusted.appPlatforms ?? [];
+	return {
+		...adjusted,
+		projectName: base.projectName,
+		ecosystem: adjusted.ecosystem ?? base.ecosystem,
+		frontend: frontend.length > 0 ? frontend : base.frontend,
+		addons: [
+			...codeQuality,
+			...documentation,
+			...appPlatforms
+		],
+		ai: adjusted.aiSdk ?? base.ai
+	};
+}
+function summarizeRecommendedConfig(config) {
+	const isTsWeb = config.ecosystem === "typescript" || config.ecosystem === "react-native";
+	return {
+		projectName: config.projectName,
+		ecosystem: config.ecosystem,
+		...isTsWeb ? {
+			frontend: config.frontend,
+			backend: config.backend,
+			runtime: config.runtime,
+			api: config.api
+		} : {},
+		database: config.database,
+		orm: config.orm,
+		auth: config.auth,
+		payments: config.payments,
+		ai: config.ai,
+		cms: config.cms,
+		realtime: config.realtime,
+		examples: config.examples,
+		addons: config.addons
+	};
+}
+const mobileInputSchema = {
+	mobileNavigation: MobileNavigationSchema.optional().describe("Mobile navigation"),
+	mobileUI: MobileUISchema.optional().describe("Mobile UI"),
+	mobileStorage: MobileStorageSchema.optional().describe("Mobile storage"),
+	mobileTesting: MobileTestingSchema.optional().describe("Mobile testing"),
+	mobilePush: MobilePushSchema.optional().describe("Mobile push notifications"),
+	mobileOTA: MobileOTASchema.optional().describe("Mobile OTA updates"),
+	mobileDeepLinking: MobileDeepLinkingSchema.optional().describe("Mobile deep linking")
+};
+const deploymentInputSchema = {
+	dbSetup: DatabaseSetupSchema.optional().describe("Database hosting provider"),
+	webDeploy: WebDeploySchema.optional().describe("Web deployment target"),
+	serverDeploy: ServerDeploySchema.optional().describe("Server deployment target")
+};
+const crossEcosystemInputSchema = {
+	rustWebFramework: RustWebFrameworkSchema.optional().describe("Rust web framework"),
+	rustFrontend: RustFrontendSchema.optional().describe("Rust frontend (WASM)"),
+	rustOrm: RustOrmSchema.optional().describe("Rust ORM"),
+	rustApi: RustApiSchema.optional().describe("Rust API layer"),
+	rustCli: RustCliSchema.optional().describe("Rust CLI framework"),
+	rustLibraries: z.array(RustLibrariesSchema).optional().describe("Rust libraries"),
+	rustLogging: RustLoggingSchema.optional().describe("Rust logging library"),
+	rustErrorHandling: RustErrorHandlingSchema.optional().describe("Rust error handling library"),
+	rustCaching: RustCachingSchema.optional().describe("Rust caching library"),
+	rustAuth: RustAuthSchema.optional().describe("Rust authentication library"),
+	rustRealtime: RustRealtimeSchema.optional().describe("Rust realtime library"),
+	rustMessageQueue: RustMessageQueueSchema.optional().describe("Rust message queue"),
+	rustObservability: RustObservabilitySchema.optional().describe("Rust observability"),
+	rustTemplating: RustTemplatingSchema.optional().describe("Rust template engine"),
+	pythonWebFramework: PythonWebFrameworkSchema.optional().describe("Python web framework"),
+	pythonOrm: PythonOrmSchema.optional().describe("Python ORM"),
+	pythonValidation: PythonValidationSchema.optional().describe("Python validation"),
+	pythonAi: z.array(PythonAiSchema).optional().describe("Python AI libraries"),
+	pythonAuth: PythonAuthSchema.optional().describe("Python auth library"),
+	pythonApi: PythonApiSchema.optional().describe("Python API framework"),
+	pythonTaskQueue: PythonTaskQueueSchema.optional().describe("Python task queue"),
+	pythonGraphql: PythonGraphqlSchema.optional().describe("Python GraphQL framework"),
+	pythonQuality: PythonQualitySchema.optional().describe("Python code quality"),
+	pythonTesting: z.array(PythonTestingSchema).optional().describe("Python testing libraries"),
+	pythonCaching: PythonCachingSchema.optional().describe("Python caching library"),
+	pythonRealtime: PythonRealtimeSchema.optional().describe("Python realtime library"),
+	pythonObservability: PythonObservabilitySchema.optional().describe("Python observability"),
+	pythonCli: z.array(PythonCliSchema).optional().describe("Python CLI tooling"),
+	goWebFramework: GoWebFrameworkSchema.optional().describe("Go web framework"),
+	goOrm: GoOrmSchema.optional().describe("Go ORM"),
+	goApi: GoApiSchema.optional().describe("Go API layer"),
+	goCli: GoCliSchema.optional().describe("Go CLI framework"),
+	goLogging: GoLoggingSchema.optional().describe("Go logging library"),
+	goAuth: GoAuthSchema.optional().describe("Go authentication library"),
+	goTesting: z.array(GoTestingSchema).optional().describe("Go testing libraries"),
+	goRealtime: GoRealtimeSchema.optional().describe("Go realtime/WebSocket library"),
+	goMessageQueue: GoMessageQueueSchema.optional().describe("Go message queue"),
+	goCaching: GoCachingSchema.optional().describe("Go caching library"),
+	goConfig: GoConfigSchema.optional().describe("Go config management"),
+	goObservability: GoObservabilitySchema.optional().describe("Go observability"),
+	javaWebFramework: JavaWebFrameworkSchema.optional().describe("Java web framework"),
+	javaBuildTool: JavaBuildToolSchema.optional().describe("Java build tool"),
+	javaOrm: JavaOrmSchema.optional().describe("Java ORM"),
+	javaAuth: JavaAuthSchema.optional().describe("Java authentication library"),
+	javaApi: JavaApiSchema.optional().describe("Java API layer"),
+	javaLogging: JavaLoggingSchema.optional().describe("Java logging configuration"),
+	javaLibraries: z.array(JavaLibrariesSchema).optional().describe("Java application libraries"),
+	javaTestingLibraries: z.array(JavaTestingLibrariesSchema).optional().describe("Java testing libraries"),
+	dotnetWebFramework: DotnetWebFrameworkSchema.optional().describe(".NET web framework"),
+	dotnetOrm: DotnetOrmSchema.optional().describe(".NET ORM/data access"),
+	dotnetAuth: DotnetAuthSchema.optional().describe(".NET authentication library"),
+	dotnetApi: DotnetApiSchema.optional().describe(".NET API style"),
+	dotnetTesting: z.array(DotnetTestingSchema).optional().describe(".NET testing libraries"),
+	dotnetJobQueue: DotnetJobQueueSchema.optional().describe(".NET jobs and scheduling"),
+	dotnetRealtime: DotnetRealtimeSchema.optional().describe(".NET realtime feature"),
+	dotnetObservability: z.array(DotnetObservabilitySchema).optional().describe(".NET observability/logging libraries"),
+	dotnetValidation: DotnetValidationSchema.optional().describe(".NET validation"),
+	dotnetCaching: DotnetCachingSchema.optional().describe(".NET caching library"),
+	dotnetDeploy: DotnetDeploySchema.optional().describe(".NET deployment target"),
+	elixirWebFramework: ElixirWebFrameworkSchema.optional().describe("Elixir web framework"),
+	elixirOrm: ElixirOrmSchema.optional().describe("Elixir persistence layer"),
+	elixirAuth: ElixirAuthSchema.optional().describe("Elixir authentication"),
+	elixirApi: ElixirApiSchema.optional().describe("Elixir API layer"),
+	elixirRealtime: ElixirRealtimeSchema.optional().describe("Elixir realtime feature"),
+	elixirJobs: ElixirJobsSchema.optional().describe("Elixir jobs and scheduling"),
+	elixirValidation: ElixirValidationSchema.optional().describe("Elixir validation/data"),
+	elixirHttp: ElixirHttpSchema.optional().describe("Elixir HTTP client"),
+	elixirJson: ElixirJsonSchema.optional().describe("Elixir JSON library"),
+	elixirEmail: ElixirEmailSchema.optional().describe("Elixir email library"),
+	elixirCaching: ElixirCachingSchema.optional().describe("Elixir caching library"),
+	elixirObservability: ElixirObservabilitySchema.optional().describe("Elixir observability"),
+	elixirTesting: ElixirTestingSchema.optional().describe("Elixir testing library"),
+	elixirQuality: ElixirQualitySchema.optional().describe("Elixir code quality/security"),
+	elixirDeploy: ElixirDeploySchema.optional().describe("Elixir deployment target"),
+	elixirLibraries: z.array(ElixirLibrariesSchema).optional().describe("Elixir libraries")
+};
+const MCP_PLAN_CREATE_SCHEMA = {
+	projectName: z.string().optional().describe("Project name (kebab-case)"),
+	part: z.array(z.string()).optional().describe("Stack graph part binding, e.g. frontend:typescript:next or backend.orm:go:gorm"),
+	ecosystem: EcosystemSchema.optional().describe("Language ecosystem (default: typescript)"),
+	frontend: z.array(FrontendSchema).optional().describe("Frontend frameworks (TypeScript only)"),
+	backend: BackendSchema.optional().describe("Backend framework"),
+	runtime: RuntimeSchema.optional().describe("JavaScript runtime"),
+	database: DatabaseSchema.optional().describe("Database type"),
+	orm: ORMSchema.optional().describe("ORM"),
+	api: APISchema.optional().describe("API layer"),
+	auth: AuthSchema.optional().describe("Auth provider"),
+	payments: PaymentsSchema.optional().describe("Payments provider"),
+	email: EmailSchema.optional().describe("Email provider"),
+	addons: z.array(AddonsSchema).optional().describe("Addons"),
+	examples: z.array(ExamplesSchema).optional().describe("Example templates"),
+	packageManager: PackageManagerSchema.optional().describe("Package manager (default: bun)"),
+	cssFramework: CSSFrameworkSchema.optional().describe("CSS framework"),
+	uiLibrary: UILibrarySchema.optional().describe("UI component library"),
+	shadcnBase: ShadcnBaseSchema.optional().describe("shadcn/ui headless library"),
+	shadcnStyle: ShadcnStyleSchema.optional().describe("shadcn/ui visual style"),
+	shadcnIconLibrary: ShadcnIconLibrarySchema.optional().describe("shadcn/ui icon library"),
+	shadcnColorTheme: ShadcnColorThemeSchema.optional().describe("shadcn/ui color theme"),
+	shadcnBaseColor: ShadcnBaseColorSchema.optional().describe("shadcn/ui base neutral color"),
+	shadcnFont: ShadcnFontSchema.optional().describe("shadcn/ui font"),
+	shadcnRadius: ShadcnRadiusSchema.optional().describe("shadcn/ui border radius"),
+	ai: AISchema.optional().describe("AI SDK"),
+	stateManagement: StateManagementSchema.optional().describe("State management"),
+	forms: FormsSchema.optional().describe("Forms library"),
+	validation: ValidationSchema.optional().describe("Validation library"),
+	testing: TestingSchema.optional().describe("Testing framework"),
+	realtime: RealtimeSchema.optional().describe("Realtime library"),
+	jobQueue: JobQueueSchema.optional().describe("Job queue"),
+	animation: AnimationSchema.optional().describe("Animation library"),
+	logging: LoggingSchema.optional().describe("Logging library"),
+	observability: ObservabilitySchema.optional().describe("Observability"),
+	featureFlags: FeatureFlagsSchema.optional().describe("Feature flag provider"),
+	search: SearchSchema.optional().describe("Search engine"),
+	vectorDb: VectorDbSchema.optional().describe("Vector database (TypeScript only)"),
+	caching: CachingSchema.optional().describe("Caching solution"),
+	rateLimit: RateLimitSchema.optional().describe("Rate limiting solution"),
+	i18n: I18nSchema.optional().describe("Internationalization (i18n) library"),
+	cms: CMSSchema.optional().describe("CMS"),
+	fileStorage: FileStorageSchema.optional().describe("File storage"),
+	...mobileInputSchema,
+	fileUpload: FileUploadSchema.optional().describe("File upload"),
+	...deploymentInputSchema,
+	effect: EffectSchema.optional().describe("Effect ecosystem (effect, effect-full)"),
+	analytics: AnalyticsSchema.optional().describe("Privacy-focused analytics provider"),
+	astroIntegration: AstroIntegrationSchema.optional().describe("Astro UI framework integration (react, vue, svelte, solid)"),
+	aiDocs: z.array(AiDocsSchema).optional().describe("AI documentation files (claude-md, agents-md, cursorrules)"),
+	versionChannel: VersionChannelSchema.optional().describe("Dependency version channel (stable, latest, beta)"),
+	...crossEcosystemInputSchema
+};
+const MCP_STACK_UPDATE_SCHEMA = {
+	...MCP_PLAN_CREATE_SCHEMA,
+	projectDir: z.string().describe("Absolute path to the existing Better-Fullstack project")
+};
 async function startMcpServer() {
 	const server = new McpServer({
 		name: "better-fullstack",
@@ -573,161 +1905,201 @@ async function startMcpServer() {
 		instructions: INSTRUCTIONS,
 		capabilities: { logging: {} }
 	});
-	const registerTool = server.tool.bind(server);
-	registerTool("bfs_get_guidance", "Returns workflow rules, field semantics, ambiguity rules, and critical constraints. Call this FIRST before using other tools.", mcpInputSchema({}), async () => {
+	const registerTool = (name, config, cb) => {
+		server.registerTool(name, config, cb);
+	};
+	registerTool("bfs_get_guidance", {
+		description: "Returns workflow rules, field semantics, ambiguity rules, and critical constraints. Call this FIRST before using other tools.",
+		inputSchema: mcpInputSchema({}),
+		outputSchema: guidanceOutputSchema,
+		annotations: {
+			title: "Get guidance",
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async () => {
 		const guidance = getGuidance();
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(guidance, null, 2)
-		}] };
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(guidance, null, 2)
+			}],
+			structuredContent: guidance
+		};
 	});
-	registerTool("bfs_get_schema", "Returns valid options for a specific category (e.g., 'database', 'frontend', 'backend') or ALL categories. Use ecosystem to filter to relevant categories only.", mcpInputSchema({
-		category: z.string().optional().describe("Category name (e.g., 'database', 'orm', 'frontend'). Omit for all categories."),
-		ecosystem: EcosystemSchema.optional().describe("Filter categories to this ecosystem (e.g., 'rust' returns only Rust + shared categories).")
-	}), async ({ category, ecosystem }) => {
+	registerTool("bfs_get_schema", {
+		description: "Returns valid options for a specific category (e.g., 'database', 'frontend', 'backend') or ALL categories. Use ecosystem to filter to relevant categories only.",
+		inputSchema: mcpInputSchema({
+			category: z.string().optional().describe("Category name (e.g., 'database', 'orm', 'frontend'). Omit for all categories."),
+			ecosystem: EcosystemSchema.optional().describe("Filter categories to this ecosystem (e.g., 'rust' returns only Rust + shared categories).")
+		}),
+		outputSchema: schemaOutputSchema,
+		annotations: {
+			title: "Get schema options",
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async ({ category, ecosystem }) => {
 		const result = getSchemaOptions(category, ecosystem);
+		const structuredContent = "error" in result ? { error: result.error } : "category" in result ? {
+			category: result.category,
+			options: result.options
+		} : { categories: result };
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}],
+			structuredContent
+		};
+	});
+	registerTool("bfs_list_presets", {
+		description: "Lists the ready-made stack presets available to the CLI (mern, pern, t3, uniwind) with id, name, description, ecosystem, and a stack summary. Use to discover a starting point before bfs_recommend_stack, bfs_plan_project, or bfs_create_project.",
+		inputSchema: mcpInputSchema({}),
+		annotations: {
+			title: "List presets",
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async () => {
+		const presets = listMcpPresets();
 		return { content: [{
 			type: "text",
-			text: JSON.stringify(result, null, 2)
+			text: JSON.stringify({ presets }, null, 2)
 		}] };
 	});
-	const mobileInputSchema = {
-		mobileNavigation: MobileNavigationSchema.optional().describe("Mobile navigation"),
-		mobileUI: MobileUISchema.optional().describe("Mobile UI"),
-		mobileStorage: MobileStorageSchema.optional().describe("Mobile storage"),
-		mobileTesting: MobileTestingSchema.optional().describe("Mobile testing"),
-		mobilePush: MobilePushSchema.optional().describe("Mobile push notifications"),
-		mobileOTA: MobileOTASchema.optional().describe("Mobile OTA updates"),
-		mobileDeepLinking: MobileDeepLinkingSchema.optional().describe("Mobile deep linking")
-	};
-	const deploymentInputSchema = {
-		dbSetup: DatabaseSetupSchema.optional().describe("Database hosting provider"),
-		webDeploy: WebDeploySchema.optional().describe("Web deployment target"),
-		serverDeploy: ServerDeploySchema.optional().describe("Server deployment target")
-	};
-	const crossEcosystemInputSchema = {
-		rustWebFramework: RustWebFrameworkSchema.optional().describe("Rust web framework"),
-		rustFrontend: RustFrontendSchema.optional().describe("Rust frontend (WASM)"),
-		rustOrm: RustOrmSchema.optional().describe("Rust ORM"),
-		rustApi: RustApiSchema.optional().describe("Rust API layer"),
-		rustCli: RustCliSchema.optional().describe("Rust CLI framework"),
-		rustLibraries: z.array(RustLibrariesSchema).optional().describe("Rust libraries"),
-		rustLogging: RustLoggingSchema.optional().describe("Rust logging library"),
-		rustErrorHandling: RustErrorHandlingSchema.optional().describe("Rust error handling library"),
-		rustCaching: RustCachingSchema.optional().describe("Rust caching library"),
-		rustAuth: RustAuthSchema.optional().describe("Rust authentication library"),
-		rustRealtime: RustRealtimeSchema.optional().describe("Rust realtime library"),
-		rustMessageQueue: RustMessageQueueSchema.optional().describe("Rust message queue"),
-		rustObservability: RustObservabilitySchema.optional().describe("Rust observability"),
-		rustTemplating: RustTemplatingSchema.optional().describe("Rust template engine"),
-		pythonWebFramework: PythonWebFrameworkSchema.optional().describe("Python web framework"),
-		pythonOrm: PythonOrmSchema.optional().describe("Python ORM"),
-		pythonValidation: PythonValidationSchema.optional().describe("Python validation"),
-		pythonAi: z.array(PythonAiSchema).optional().describe("Python AI libraries"),
-		pythonAuth: PythonAuthSchema.optional().describe("Python auth library"),
-		pythonApi: PythonApiSchema.optional().describe("Python API framework"),
-		pythonTaskQueue: PythonTaskQueueSchema.optional().describe("Python task queue"),
-		pythonGraphql: PythonGraphqlSchema.optional().describe("Python GraphQL framework"),
-		pythonQuality: PythonQualitySchema.optional().describe("Python code quality"),
-		pythonTesting: z.array(PythonTestingSchema).optional().describe("Python testing libraries"),
-		pythonCaching: PythonCachingSchema.optional().describe("Python caching library"),
-		pythonRealtime: PythonRealtimeSchema.optional().describe("Python realtime library"),
-		pythonObservability: PythonObservabilitySchema.optional().describe("Python observability"),
-		pythonCli: z.array(PythonCliSchema).optional().describe("Python CLI tooling"),
-		goWebFramework: GoWebFrameworkSchema.optional().describe("Go web framework"),
-		goOrm: GoOrmSchema.optional().describe("Go ORM"),
-		goApi: GoApiSchema.optional().describe("Go API layer"),
-		goCli: GoCliSchema.optional().describe("Go CLI framework"),
-		goLogging: GoLoggingSchema.optional().describe("Go logging library"),
-		goAuth: GoAuthSchema.optional().describe("Go authentication library"),
-		goTesting: z.array(GoTestingSchema).optional().describe("Go testing libraries"),
-		goRealtime: GoRealtimeSchema.optional().describe("Go realtime/WebSocket library"),
-		goMessageQueue: GoMessageQueueSchema.optional().describe("Go message queue"),
-		goCaching: GoCachingSchema.optional().describe("Go caching library"),
-		goConfig: GoConfigSchema.optional().describe("Go config management"),
-		goObservability: GoObservabilitySchema.optional().describe("Go observability"),
-		javaWebFramework: JavaWebFrameworkSchema.optional().describe("Java web framework"),
-		javaBuildTool: JavaBuildToolSchema.optional().describe("Java build tool"),
-		javaOrm: JavaOrmSchema.optional().describe("Java ORM"),
-		javaAuth: JavaAuthSchema.optional().describe("Java authentication library"),
-		javaApi: JavaApiSchema.optional().describe("Java API layer"),
-		javaLogging: JavaLoggingSchema.optional().describe("Java logging configuration"),
-		javaLibraries: z.array(JavaLibrariesSchema).optional().describe("Java application libraries"),
-		javaTestingLibraries: z.array(JavaTestingLibrariesSchema).optional().describe("Java testing libraries"),
-		dotnetWebFramework: DotnetWebFrameworkSchema.optional().describe(".NET web framework"),
-		dotnetOrm: DotnetOrmSchema.optional().describe(".NET ORM/data access"),
-		dotnetAuth: DotnetAuthSchema.optional().describe(".NET authentication library"),
-		dotnetApi: DotnetApiSchema.optional().describe(".NET API style"),
-		dotnetTesting: z.array(DotnetTestingSchema).optional().describe(".NET testing libraries"),
-		dotnetJobQueue: DotnetJobQueueSchema.optional().describe(".NET jobs and scheduling"),
-		dotnetRealtime: DotnetRealtimeSchema.optional().describe(".NET realtime feature"),
-		dotnetObservability: z.array(DotnetObservabilitySchema).optional().describe(".NET observability/logging libraries"),
-		dotnetValidation: DotnetValidationSchema.optional().describe(".NET validation"),
-		dotnetCaching: DotnetCachingSchema.optional().describe(".NET caching library"),
-		dotnetDeploy: DotnetDeploySchema.optional().describe(".NET deployment target"),
-		elixirWebFramework: ElixirWebFrameworkSchema.optional().describe("Elixir web framework"),
-		elixirOrm: ElixirOrmSchema.optional().describe("Elixir persistence layer"),
-		elixirAuth: ElixirAuthSchema.optional().describe("Elixir authentication"),
-		elixirApi: ElixirApiSchema.optional().describe("Elixir API layer"),
-		elixirRealtime: ElixirRealtimeSchema.optional().describe("Elixir realtime feature"),
-		elixirJobs: ElixirJobsSchema.optional().describe("Elixir jobs and scheduling"),
-		elixirValidation: ElixirValidationSchema.optional().describe("Elixir validation/data"),
-		elixirHttp: ElixirHttpSchema.optional().describe("Elixir HTTP client"),
-		elixirJson: ElixirJsonSchema.optional().describe("Elixir JSON library"),
-		elixirEmail: ElixirEmailSchema.optional().describe("Elixir email library"),
-		elixirCaching: ElixirCachingSchema.optional().describe("Elixir caching library"),
-		elixirObservability: ElixirObservabilitySchema.optional().describe("Elixir observability"),
-		elixirTesting: ElixirTestingSchema.optional().describe("Elixir testing library"),
-		elixirQuality: ElixirQualitySchema.optional().describe("Elixir code quality/security"),
-		elixirDeploy: ElixirDeploySchema.optional().describe("Elixir deployment target"),
-		elixirLibraries: z.array(ElixirLibrariesSchema).optional().describe("Elixir libraries")
-	};
-	registerTool("bfs_check_compatibility", "Validates a stack combination and returns auto-adjusted selections with warnings. Call BEFORE creating a project to avoid invalid combinations.", mcpInputSchema({
-		ecosystem: EcosystemSchema.describe("Language ecosystem"),
-		frontend: z.array(z.string()).optional().describe("Web frontend frameworks (TypeScript only)"),
-		backend: z.string().optional().describe("Backend framework"),
-		runtime: z.string().optional().describe("JavaScript runtime"),
-		database: z.string().optional().describe("Database type"),
-		orm: z.string().optional().describe("ORM"),
-		api: z.string().optional().describe("API layer"),
-		auth: z.string().optional().describe("Auth provider"),
-		payments: z.string().optional().describe("Payments provider"),
-		email: EmailSchema.optional().describe("Email provider"),
-		fileUpload: FileUploadSchema.optional().describe("File upload provider"),
-		ai: AISchema.optional().describe("AI SDK"),
-		stateManagement: StateManagementSchema.optional().describe("State management"),
-		forms: FormsSchema.optional().describe("Forms library"),
-		validation: ValidationSchema.optional().describe("Validation library"),
-		testing: TestingSchema.optional().describe("Testing framework"),
-		realtime: RealtimeSchema.optional().describe("Realtime library"),
-		jobQueue: JobQueueSchema.optional().describe("Job queue"),
-		animation: AnimationSchema.optional().describe("Animation library"),
-		logging: LoggingSchema.optional().describe("Logging library"),
-		observability: ObservabilitySchema.optional().describe("Observability provider"),
-		featureFlags: FeatureFlagsSchema.optional().describe("Feature flags provider"),
-		analytics: AnalyticsSchema.optional().describe("Analytics provider"),
-		cms: CMSSchema.optional().describe("CMS"),
-		caching: CachingSchema.optional().describe("Caching solution"),
-		rateLimit: RateLimitSchema.optional().describe("Rate limiting solution"),
-		i18n: I18nSchema.optional().describe("Internationalization library"),
-		search: SearchSchema.optional().describe("Search engine"),
-		fileStorage: FileStorageSchema.optional().describe("File storage"),
-		...mobileInputSchema,
-		...deploymentInputSchema,
-		astroIntegration: AstroIntegrationSchema.optional().describe("Astro UI framework integration"),
-		uiLibrary: z.string().optional().describe("UI component library"),
-		cssFramework: z.string().optional().describe("CSS framework"),
-		addons: z.array(AddonsSchema).optional().describe("Addon list"),
-		examples: z.array(ExamplesSchema).optional().describe("Example templates"),
-		packageManager: PackageManagerSchema.optional().describe("Package manager"),
-		...crossEcosystemInputSchema
-	}), async (input) => {
+	registerTool("bfs_recommend_stack", {
+		description: "Recommends a compatibility-validated stack from a natural-language brief using deterministic keyword rules (no LLM). Returns the config, rationale, any auto-applied compatibility adjustments, the nearest matching preset, and a reproducible CLI command.",
+		inputSchema: mcpInputSchema({
+			brief: z.string().describe("Natural-language description of the app to build (e.g., 'a SaaS with payments and auth')."),
+			ecosystem: EcosystemSchema.optional().describe("Force a language ecosystem. Omit to let the brief decide (defaults to TypeScript)."),
+			projectName: z.string().optional().describe("Project name (kebab-case). Default: 'my-app'.")
+		}),
+		annotations: {
+			title: "Recommend stack",
+			readOnlyHint: true,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async ({ brief, ecosystem, projectName }) => {
 		try {
-			const filtered = filterCompatibilityResult(analyzeStackCompatibility(buildCompatibilityInput(input)), input.ecosystem);
+			const { input: recommended, rationale, matchedPreset } = recommendStackFromBrief(brief, ecosystem);
+			const baseInput = {
+				projectName: projectName ?? "my-app",
+				...recommended
+			};
+			const compatResult = analyzeStackCompatibility(buildCompatibilityInput(baseInput));
+			const finalConfig = buildProjectConfig(compatResult.adjustedStack ? normalizeAdjustedToInput(compatResult.adjustedStack, baseInput) : baseInput, { projectDir: `/${baseInput.projectName}` });
+			const adjustments = compatResult.changes.map((change) => `${change.category}: ${change.message}`);
+			const graphPreview = getMcpGraphPreview(finalConfig);
+			const reproducibleCommand = generateReproducibleCommand(finalConfig);
 			return { content: [{
 				type: "text",
-				text: JSON.stringify(filtered, null, 2)
+				text: JSON.stringify({
+					brief,
+					config: summarizeRecommendedConfig(finalConfig),
+					rationale,
+					adjustments,
+					matchedPreset,
+					reproducibleCommand,
+					...graphPreview,
+					nextSteps: "Call bfs_plan_project with this config to preview the files, then bfs_create_project to scaffold it."
+				}, null, 2)
 			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Recommend stack failed: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	});
+	registerTool("bfs_check_compatibility", {
+		description: "Validates a stack combination and returns auto-adjusted selections with warnings. Call BEFORE creating a project to avoid invalid combinations.",
+		outputSchema: compatibilityOutputSchema,
+		annotations: {
+			title: "Check stack compatibility",
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		},
+		inputSchema: mcpInputSchema({
+			ecosystem: EcosystemSchema.describe("Language ecosystem"),
+			frontend: z.array(z.string()).optional().describe("Web frontend frameworks (TypeScript only)"),
+			backend: z.string().optional().describe("Backend framework"),
+			runtime: z.string().optional().describe("JavaScript runtime"),
+			database: z.string().optional().describe("Database type"),
+			orm: z.string().optional().describe("ORM"),
+			api: z.string().optional().describe("API layer"),
+			auth: z.string().optional().describe("Auth provider"),
+			payments: z.string().optional().describe("Payments provider"),
+			email: EmailSchema.optional().describe("Email provider"),
+			fileUpload: FileUploadSchema.optional().describe("File upload provider"),
+			ai: AISchema.optional().describe("AI SDK"),
+			stateManagement: StateManagementSchema.optional().describe("State management"),
+			forms: FormsSchema.optional().describe("Forms library"),
+			validation: ValidationSchema.optional().describe("Validation library"),
+			testing: TestingSchema.optional().describe("Testing framework"),
+			realtime: RealtimeSchema.optional().describe("Realtime library"),
+			jobQueue: JobQueueSchema.optional().describe("Job queue"),
+			animation: AnimationSchema.optional().describe("Animation library"),
+			logging: LoggingSchema.optional().describe("Logging library"),
+			observability: ObservabilitySchema.optional().describe("Observability provider"),
+			featureFlags: FeatureFlagsSchema.optional().describe("Feature flags provider"),
+			analytics: AnalyticsSchema.optional().describe("Analytics provider"),
+			cms: CMSSchema.optional().describe("CMS"),
+			caching: CachingSchema.optional().describe("Caching solution"),
+			rateLimit: RateLimitSchema.optional().describe("Rate limiting solution"),
+			i18n: I18nSchema.optional().describe("Internationalization library"),
+			search: SearchSchema.optional().describe("Search engine"),
+			vectorDb: VectorDbSchema.optional().describe("Vector database (TypeScript only)"),
+			fileStorage: FileStorageSchema.optional().describe("File storage"),
+			...mobileInputSchema,
+			...deploymentInputSchema,
+			astroIntegration: AstroIntegrationSchema.optional().describe("Astro UI framework integration"),
+			uiLibrary: z.string().optional().describe("UI component library"),
+			cssFramework: z.string().optional().describe("CSS framework"),
+			shadcnBase: ShadcnBaseSchema.optional().describe("shadcn/ui headless library"),
+			shadcnStyle: ShadcnStyleSchema.optional().describe("shadcn/ui visual style"),
+			shadcnIconLibrary: ShadcnIconLibrarySchema.optional().describe("shadcn/ui icon library"),
+			shadcnColorTheme: ShadcnColorThemeSchema.optional().describe("shadcn/ui color theme"),
+			shadcnBaseColor: ShadcnBaseColorSchema.optional().describe("shadcn/ui base neutral color"),
+			shadcnFont: ShadcnFontSchema.optional().describe("shadcn/ui font"),
+			shadcnRadius: ShadcnRadiusSchema.optional().describe("shadcn/ui border radius"),
+			addons: z.array(AddonsSchema).optional().describe("Addon list"),
+			examples: z.array(ExamplesSchema).optional().describe("Example templates"),
+			packageManager: PackageManagerSchema.optional().describe("Package manager"),
+			...crossEcosystemInputSchema
+		})
+	}, async (input) => {
+		try {
+			const compatInput = buildCompatibilityInput(input);
+			const filtered = filterCompatibilityResult(analyzeStackCompatibility(compatInput), input.ecosystem);
+			const evaluation = evaluateCompatibility(compatInput);
+			const relevantEcosystem = isMcpEcosystem(input.ecosystem) ? input.ecosystem : "typescript";
+			const relevantIssueKeys = new Set([...getMcpCategoryKeysForEcosystem(relevantEcosystem), ...MCP_SHARED_COMPATIBILITY_KEYS]);
+			const issues = evaluation.issues.filter((issue) => !issue.category || relevantIssueKeys.has(issue.category));
+			const structuredContent = {
+				adjustedStack: filtered.adjustedStack,
+				changes: filtered.changes,
+				issues,
+				hasIssues: issues.length > 0
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						...filtered,
+						issues
+					}, null, 2)
+				}],
+				structuredContent
+			};
 		} catch (error) {
 			return {
 				content: [{
@@ -738,64 +2110,39 @@ async function startMcpServer() {
 			};
 		}
 	});
-	const planCreateSchema = {
-		projectName: z.string().optional().describe("Project name (kebab-case)"),
-		ecosystem: EcosystemSchema.optional().describe("Language ecosystem (default: typescript)"),
-		frontend: z.array(FrontendSchema).optional().describe("Frontend frameworks (TypeScript only)"),
-		backend: BackendSchema.optional().describe("Backend framework"),
-		runtime: RuntimeSchema.optional().describe("JavaScript runtime"),
-		database: DatabaseSchema.optional().describe("Database type"),
-		orm: ORMSchema.optional().describe("ORM"),
-		api: APISchema.optional().describe("API layer"),
-		auth: AuthSchema.optional().describe("Auth provider"),
-		payments: PaymentsSchema.optional().describe("Payments provider"),
-		email: EmailSchema.optional().describe("Email provider"),
-		addons: z.array(AddonsSchema).optional().describe("Addons"),
-		examples: z.array(ExamplesSchema).optional().describe("Example templates"),
-		packageManager: PackageManagerSchema.optional().describe("Package manager (default: bun)"),
-		cssFramework: CSSFrameworkSchema.optional().describe("CSS framework"),
-		uiLibrary: UILibrarySchema.optional().describe("UI component library"),
-		ai: AISchema.optional().describe("AI SDK"),
-		stateManagement: StateManagementSchema.optional().describe("State management"),
-		forms: FormsSchema.optional().describe("Forms library"),
-		validation: ValidationSchema.optional().describe("Validation library"),
-		testing: TestingSchema.optional().describe("Testing framework"),
-		realtime: RealtimeSchema.optional().describe("Realtime library"),
-		jobQueue: JobQueueSchema.optional().describe("Job queue"),
-		animation: AnimationSchema.optional().describe("Animation library"),
-		logging: LoggingSchema.optional().describe("Logging library"),
-		observability: ObservabilitySchema.optional().describe("Observability"),
-		featureFlags: FeatureFlagsSchema.optional().describe("Feature flag provider"),
-		search: SearchSchema.optional().describe("Search engine"),
-		caching: CachingSchema.optional().describe("Caching solution"),
-		rateLimit: RateLimitSchema.optional().describe("Rate limiting solution"),
-		i18n: I18nSchema.optional().describe("Internationalization (i18n) library"),
-		cms: CMSSchema.optional().describe("CMS"),
-		fileStorage: FileStorageSchema.optional().describe("File storage"),
-		...mobileInputSchema,
-		fileUpload: FileUploadSchema.optional().describe("File upload"),
-		...deploymentInputSchema,
-		...crossEcosystemInputSchema
-	};
-	registerTool("bfs_plan_project", "Dry-run: generates a project in-memory and returns the file tree WITHOUT writing to disk. Use this to preview what would be created.", mcpInputSchema(planCreateSchema), async (input) => {
+	registerTool("bfs_plan_project", {
+		description: "Dry-run: generates a project in-memory and returns the file tree WITHOUT writing to disk. Use this to preview what would be created.",
+		inputSchema: mcpInputSchema(MCP_PLAN_CREATE_SCHEMA),
+		outputSchema: planProjectOutputSchema,
+		annotations: {
+			title: "Plan project (dry run)",
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => {
 		try {
-			const { generateVirtualProject, EMBEDDED_TEMPLATES } = await import("@better-fullstack/template-generator");
+			const { generateVirtualProject: generateVirtualProject$1, EMBEDDED_TEMPLATES: EMBEDDED_TEMPLATES$1 } = await import("@better-fullstack/template-generator");
 			const config = buildProjectConfig(input);
-			const result = await generateVirtualProject({
+			const result = await generateVirtualProject$1({
 				config,
-				templates: EMBEDDED_TEMPLATES
+				templates: EMBEDDED_TEMPLATES$1
 			});
 			if (result.success && result.tree) {
 				const summary = summarizeTree(result.tree);
 				const graphPreview = getMcpGraphPreview(config);
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						success: true,
-						...summary,
-						...graphPreview
-					}, null, 2)
-				}] };
+				const payload = {
+					success: true,
+					...summary,
+					...graphPreview
+				};
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(payload, null, 2)
+					}],
+					structuredContent: payload
+				};
 			}
 			return {
 				content: [{
@@ -817,21 +2164,34 @@ async function startMcpServer() {
 			};
 		}
 	});
-	registerTool("bfs_create_project", "Creates a new fullstack project on disk. Dependencies are NOT installed (agent must tell user to install manually). Call bfs_plan_project first to preview.", mcpInputSchema({
-		...planCreateSchema,
-		projectName: z.string().describe("Project name (kebab-case). Will be the directory name.")
-	}), async (input) => {
+	registerTool("bfs_create_project", {
+		description: "Creates a new fullstack project on disk. Dependencies are NOT installed (agent must tell user to install manually). Call bfs_plan_project first to preview.",
+		inputSchema: mcpInputSchema({
+			...MCP_PLAN_CREATE_SCHEMA,
+			projectName: z.string().describe("Project name (kebab-case). Will be the directory name."),
+			targetDir: z.string().optional().describe("Absolute path to the parent directory in which to create the project folder (default: current working directory).")
+		}),
+		outputSchema: createProjectOutputSchema,
+		annotations: {
+			title: "Create project",
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async (input) => {
 		try {
-			const { generateVirtualProject, EMBEDDED_TEMPLATES } = await import("@better-fullstack/template-generator");
-			const { writeTreeToFilesystem } = await import("@better-fullstack/template-generator/fs-writer");
-			const path = await import("node:path");
+			const { generateVirtualProject: generateVirtualProject$1, EMBEDDED_TEMPLATES: EMBEDDED_TEMPLATES$1 } = await import("@better-fullstack/template-generator");
+			const { writeTreeToFilesystem: writeTreeToFilesystem$1 } = await import("@better-fullstack/template-generator/fs-writer");
+			const path$1 = await import("node:path");
 			const projectName = sanitizePath(input.projectName);
-			const projectDir = path.resolve(process.cwd(), projectName);
+			const targetDir = input.targetDir ? sanitizePath(input.targetDir) : void 0;
+			const projectDir = path$1.resolve(targetDir ?? process.cwd(), projectName);
 			const config = buildProjectConfig(input, { projectDir });
 			await (await import("node:fs/promises")).mkdir(projectDir, { recursive: true });
-			const result = await generateVirtualProject({
+			const result = await generateVirtualProject$1({
 				config,
-				templates: EMBEDDED_TEMPLATES
+				templates: EMBEDDED_TEMPLATES$1
 			});
 			if (!result.success || !result.tree) return {
 				content: [{
@@ -843,26 +2203,30 @@ async function startMcpServer() {
 				}],
 				isError: true
 			};
-			await writeTreeToFilesystem(result.tree, projectDir);
+			await writeTreeToFilesystem$1(result.tree, projectDir);
 			await writeBtsConfig(config);
 			const graphPreview = getMcpGraphPreview(config);
 			let addonWarnings = [];
 			if (config.addons.length > 0 && config.addons[0] !== "none") {
-				const { setupAddons } = await import("./addons-setup-CV5uZyhH.mjs");
+				const { setupAddons } = await import("./addons-setup-C8eaCaH5.mjs");
 				addonWarnings = await setupAddons(config);
 			}
 			const installCmd = getInstallCommand(input.ecosystem ?? "typescript", projectName, input.packageManager, input.javaBuildTool, input.javaWebFramework);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: true,
-					projectDirectory: projectDir,
-					fileCount: result.tree.fileCount,
-					...graphPreview,
-					...addonWarnings.length > 0 ? { addonWarnings } : {},
-					message: `Project created at ${projectDir}. Tell the user to run: ${installCmd}`
-				}, null, 2)
-			}] };
+			const payload = {
+				success: true,
+				projectDirectory: projectDir,
+				fileCount: result.tree.fileCount,
+				...graphPreview,
+				...addonWarnings.length > 0 ? { addonWarnings } : {},
+				message: `Project created at ${projectDir}. Tell the user to run: ${installCmd}`
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(payload, null, 2)
+				}],
+				structuredContent: payload
+			};
 		} catch (error) {
 			return {
 				content: [{
@@ -873,12 +2237,135 @@ async function startMcpServer() {
 			};
 		}
 	});
-	registerTool("bfs_plan_addition", "Validates what would be added to an existing project. Reads the project config (bts.jsonc) and checks which addons are new.", mcpInputSchema({
-		projectDir: z.string().describe("Absolute path to the existing project directory"),
-		addons: z.array(AddonsSchema).optional().describe("Addons to add"),
-		webDeploy: WebDeploySchema.optional().describe("Web deployment option"),
-		serverDeploy: ServerDeploySchema.optional().describe("Server deployment option")
-	}), async ({ projectDir, addons, webDeploy, serverDeploy }) => {
+	function compatibilityWarningsForStackUpdate(proposedConfig) {
+		const compatResult = analyzeStackCompatibility(buildCompatibilityInput(proposedConfig));
+		return compatResult.changes.length > 0 ? compatResult.changes.map((change) => change.message) : void 0;
+	}
+	registerTool("bfs_plan_stack_update", {
+		description: "Plans scaffold-time stack updates for an existing Better-Fullstack project. Supports the same stack fields as project creation (email, auth, payments, API, CMS, search, vector DB, observability, mobile/non-TS categories, addons, deploy, etc.). Does not write files.",
+		inputSchema: mcpInputSchema(MCP_STACK_UPDATE_SCHEMA),
+		outputSchema: stackUpdateOutputSchema,
+		annotations: {
+			title: "Plan stack update",
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async (input) => {
+		try {
+			const safePath = sanitizePath(input.projectDir);
+			const { projectDir: _projectDir, projectName: _projectName, ...requestedChanges } = input;
+			const plan = await planStackUpdate(safePath, requestedChanges);
+			if (!plan.success) return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(plan, null, 2)
+				}],
+				structuredContent: plan,
+				isError: true
+			};
+			const compatibilityWarnings = compatibilityWarningsForStackUpdate(plan.proposedConfig);
+			const { operations: _operations, filesUnchanged: _filesUnchanged, ...safePlan } = plan;
+			const payload = {
+				...safePlan,
+				...plan.compatibilityAdjustments.length > 0 ? { compatibilityAdjustments: plan.compatibilityAdjustments } : {},
+				...compatibilityWarnings ? { compatibilityWarnings } : {},
+				message: plan.manualReviewBlockers.length > 0 ? "Plan created, but manual review is required before applying." : `Plan created. If approved, call bfs_apply_stack_update, then run: ${plan.installCommand}`
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(payload, null, 2)
+				}],
+				structuredContent: payload
+			};
+		} catch (error) {
+			const payload = {
+				success: false,
+				projectDir: input.projectDir,
+				error: `Plan stack update failed: ${error instanceof Error ? error.message : String(error)}`
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(payload, null, 2)
+				}],
+				structuredContent: payload,
+				isError: true
+			};
+		}
+	});
+	registerTool("bfs_apply_stack_update", {
+		description: "Applies a previously reviewed scaffold-time stack update to an existing Better-Fullstack project. Refuses to overwrite user-edited generated files and does not install dependencies.",
+		inputSchema: mcpInputSchema(MCP_STACK_UPDATE_SCHEMA),
+		outputSchema: stackUpdateOutputSchema,
+		annotations: {
+			title: "Apply stack update",
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async (input) => {
+		try {
+			const safePath = sanitizePath(input.projectDir);
+			const { projectDir: _projectDir, projectName: _projectName, ...requestedChanges } = input;
+			const result = await applyStackUpdate(safePath, requestedChanges);
+			if (!result.success) return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				structuredContent: result,
+				isError: true
+			};
+			const compatibilityWarnings = compatibilityWarningsForStackUpdate(result.proposedConfig);
+			const { operations: _operations, filesUnchanged: _filesUnchanged, ...safeResult } = result;
+			const payload = {
+				...safeResult,
+				...result.compatibilityAdjustments.length > 0 ? { compatibilityAdjustments: result.compatibilityAdjustments } : {},
+				...compatibilityWarnings ? { compatibilityWarnings } : {},
+				message: `Stack update applied. Dependencies were not installed; run: ${result.installCommand}`
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(payload, null, 2)
+				}],
+				structuredContent: payload
+			};
+		} catch (error) {
+			const payload = {
+				success: false,
+				projectDir: input.projectDir,
+				error: `Apply stack update failed: ${error instanceof Error ? error.message : String(error)}`
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(payload, null, 2)
+				}],
+				structuredContent: payload,
+				isError: true
+			};
+		}
+	});
+	registerTool("bfs_plan_addition", {
+		description: "Validates what would be added to an existing project. Reads the project config (bts.jsonc) and checks which addons are new.",
+		inputSchema: mcpInputSchema({
+			projectDir: z.string().describe("Absolute path to the existing project directory"),
+			addons: z.array(AddonsSchema).optional().describe("Addons to add"),
+			webDeploy: WebDeploySchema.optional().describe("Web deployment option"),
+			serverDeploy: ServerDeploySchema.optional().describe("Server deployment option")
+		}),
+		outputSchema: planAdditionOutputSchema,
+		annotations: {
+			title: "Plan feature addition",
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, async ({ projectDir, addons, webDeploy, serverDeploy }) => {
 		try {
 			const safePath = sanitizePath(projectDir);
 			const config = await readBtsConfig(safePath);
@@ -909,31 +2396,35 @@ async function startMcpServer() {
 				serverDeploy: serverDeploy ?? config.serverDeploy
 			}));
 			const compatibilityWarnings = compatResult.changes.length > 0 ? compatResult.changes.map((c) => c.message) : void 0;
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					success: true,
-					existingConfig: {
-						ecosystem: config.ecosystem,
-						frontend: config.frontend,
-						backend: config.backend,
-						addons: config.addons,
-						graphSummary: existingGraphPreview.graphSummary,
-						effectiveStack: existingGraphPreview.effectiveStack,
-						stackPartSpecs: existingGraphPreview.stackPartSpecs
-					},
-					proposedAdditions: {
-						newAddons,
-						webDeploy: webDeploy ?? null,
-						serverDeploy: serverDeploy ?? null,
-						graphSummary: proposedGraphPreview.graphSummary,
-						effectiveStack: proposedGraphPreview.effectiveStack,
-						stackPartSpecs: proposedGraphPreview.stackPartSpecs
-					},
-					alreadyPresent: (addons ?? []).filter((a) => existingAddons.has(a)),
-					...compatibilityWarnings ? { compatibilityWarnings } : {}
-				}, null, 2)
-			}] };
+			const payload = {
+				success: true,
+				existingConfig: {
+					ecosystem: config.ecosystem,
+					frontend: config.frontend,
+					backend: config.backend,
+					addons: config.addons,
+					graphSummary: existingGraphPreview.graphSummary,
+					effectiveStack: existingGraphPreview.effectiveStack,
+					stackPartSpecs: existingGraphPreview.stackPartSpecs
+				},
+				proposedAdditions: {
+					newAddons,
+					webDeploy: webDeploy ?? null,
+					serverDeploy: serverDeploy ?? null,
+					graphSummary: proposedGraphPreview.graphSummary,
+					effectiveStack: proposedGraphPreview.effectiveStack,
+					stackPartSpecs: proposedGraphPreview.stackPartSpecs
+				},
+				alreadyPresent: (addons ?? []).filter((a) => existingAddons.has(a)),
+				...compatibilityWarnings ? { compatibilityWarnings } : {}
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(payload, null, 2)
+				}],
+				structuredContent: payload
+			};
 		} catch (error) {
 			return {
 				content: [{
@@ -944,13 +2435,24 @@ async function startMcpServer() {
 			};
 		}
 	});
-	registerTool("bfs_add_feature", "Adds addons/features to an existing Better-Fullstack project. Dependencies are NOT installed. Call bfs_plan_addition first to validate.", mcpInputSchema({
-		projectDir: z.string().describe("Absolute path to the existing project directory"),
-		addons: z.array(AddonsSchema).optional().describe("Addons to add"),
-		webDeploy: WebDeploySchema.optional().describe("Web deployment option"),
-		serverDeploy: ServerDeploySchema.optional().describe("Server deployment option"),
-		packageManager: PackageManagerSchema.optional().describe("Package manager to use")
-	}), async (input) => {
+	registerTool("bfs_add_feature", {
+		description: "Adds addons/features to an existing Better-Fullstack project. Dependencies are NOT installed. Call bfs_plan_addition first to validate.",
+		inputSchema: mcpInputSchema({
+			projectDir: z.string().describe("Absolute path to the existing project directory"),
+			addons: z.array(AddonsSchema).optional().describe("Addons to add"),
+			webDeploy: WebDeploySchema.optional().describe("Web deployment option"),
+			serverDeploy: ServerDeploySchema.optional().describe("Server deployment option"),
+			packageManager: PackageManagerSchema.optional().describe("Package manager to use")
+		}),
+		outputSchema: addFeatureOutputSchema,
+		annotations: {
+			title: "Add feature",
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}, async (input) => {
 		try {
 			const safePath = sanitizePath(input.projectDir);
 			const { add } = await import("./index.mjs");
@@ -966,16 +2468,20 @@ async function startMcpServer() {
 				const existingConfig = await readBtsConfig(safePath);
 				const graphPreview = existingConfig ? getMcpGraphPreview(existingConfig) : void 0;
 				const installCmd = getInstallCommand(existingConfig?.ecosystem ?? "typescript", safePath.split("/").pop() ?? "project", input.packageManager, existingConfig?.javaBuildTool, existingConfig?.javaWebFramework);
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						success: true,
-						addedAddons: result.addedAddons,
-						projectDir: result.projectDir,
-						...graphPreview,
-						message: `Added ${result.addedAddons.join(", ")} to project. Tell the user to run: ${installCmd}`
-					}, null, 2)
-				}] };
+				const payload = {
+					success: true,
+					addedAddons: result.addedAddons,
+					projectDir: result.projectDir,
+					...graphPreview,
+					message: `Added ${result.addedAddons.join(", ")} to project. Tell the user to run: ${installCmd}`
+				};
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(payload, null, 2)
+					}],
+					structuredContent: payload
+				};
 			}
 			return {
 				content: [{
@@ -1027,4 +2533,4 @@ async function startMcpServer() {
 startMcpServer();
 
 //#endregion
-export { startMcpServer as n, getMcpGraphPreview as t };
+export { startMcpServer as i, MCP_STACK_UPDATE_SCHEMA as n, getMcpGraphPreview as r, MCP_PLAN_CREATE_SCHEMA as t };