create-better-t-stack 3.20.2 → 3.21.0-pr892.a7e1b0f

package/README.md

@@ -58,7 +58,7 @@ Options:
   --auth                          Include authentication
   --no-auth                       Exclude authentication
   --frontend <types...>           Frontend types (tanstack-router, react-router, tanstack-start, next, nuxt, svelte, solid, native-bare, native-uniwind, native-unistyles, none)
-  --addons <types...>             Additional addons (pwa, tauri, starlight, biome, lefthook, husky, turborepo, fumadocs, ultracite, oxlint, none)
+  --addons <types...>             Additional addons (pwa, tauri, starlight, fumadocs, biome, lefthook, husky, turborepo, ultracite, oxlint, ruler, opentui, wxt, skills, mcp, none)
   --examples <types...>           Examples to include (todo, ai, none)
   --git                           Initialize git repository
   --no-git                        Skip git initialization
@@ -74,6 +74,14 @@ Options:
   -h, --help                      Display help
 ```
 
+Additional commands:
+
+```bash
+create-better-t-stack add [options]    # Add addons to an existing project
+create-better-t-stack history [options] # Show or clear local scaffold history
+create-better-t-stack mcp               # Start MCP server over stdio
+```
+
 ## Telemetry
 
 This CLI collects anonymous usage data to help improve the tool. The data collected includes:

package/dist/cli.mjs

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
-import { l as createBtsCli } from "./src-BqpeME-D.mjs";
+import { h as startMcpServer, l as createBtsCli } from "./src-Dtzva6-_.mjs";
 
 //#region src/cli.ts
-createBtsCli().run();
+if (process.argv[2] === "mcp") startMcpServer().catch((error) => {
+	console.error("Failed to start MCP server:", error);
+	process.exit(1);
+});
+else createBtsCli().run();
 
 //#endregion
 export {  };

package/dist/index.d.mts

@@ -287,6 +287,7 @@ declare const router: {
     clear: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
   }, z.core.$strip>, _orpc_server0.Schema<void, void>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+  mcp: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, _orpc_server0.Schema<unknown, unknown>, _orpc_server0.Schema<void, void>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
 };
 declare function createBtsCli(): trpc_cli0.TrpcCli;
 /**

package/dist/index.mjs

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { _ as DatabaseSetupError, a as VirtualFileSystem, b as UserCancelledError, c as create, d as docs, f as generate, g as CompatibilityError, h as CLIError, i as TEMPLATE_COUNT, l as createBtsCli, m as sponsors, n as GeneratorError, o as add, p as router, r as Result, s as builder, t as EMBEDDED_TEMPLATES, u as createVirtual, v as DirectoryConflictError, x as ValidationError, y as ProjectCreationError } from "./src-BqpeME-D.mjs";
+import { S as ValidationError, _ as CompatibilityError, a as VirtualFileSystem, b as ProjectCreationError, c as create, d as docs, f as generate, g as CLIError, i as TEMPLATE_COUNT, l as createBtsCli, m as sponsors, n as GeneratorError, o as add, p as router, r as Result, s as builder, t as EMBEDDED_TEMPLATES, u as createVirtual, v as DatabaseSetupError, x as UserCancelledError, y as DirectoryConflictError } from "./src-Dtzva6-_.mjs";
 
 export { CLIError, CompatibilityError, DatabaseSetupError, DirectoryConflictError, EMBEDDED_TEMPLATES, GeneratorError, ProjectCreationError, Result, TEMPLATE_COUNT, UserCancelledError, ValidationError, VirtualFileSystem, add, builder, create, createBtsCli, createVirtual, docs, generate, router, sponsors };

package/dist/{src-BqpeME-D.mjs → src-Dtzva6-_.mjs}

@@ -20,6 +20,9 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { applyEdits, modify, parse } from "jsonc-parser";
 import os$1 from "node:os";
 import { format } from "oxfmt";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z$1 from "zod/v4";
 
 //#region src/utils/get-package-manager.ts
 const getUserPkgManager = () => {
@@ -199,7 +202,7 @@ function getLatestCLIVersionResult() {
 	});
 }
 function getLatestCLIVersion() {
-	return getLatestCLIVersionResult().unwrapOr("1.0.0");
+	return getLatestCLIVersionResult().unwrapOr("1.0.0") ?? "1.0.0";
 }
 
 //#endregion
@@ -1336,20 +1339,33 @@ const TEMPLATES$2 = {
 		value: "tanstack-start-spa"
 	}
 };
-async function setupFumadocs(config) {
-	if (shouldSkipExternalCommands()) return Result.ok(void 0);
+async function setupFumadocs(config, context = {}) {
+	const emit = context.collectExternalReport;
+	if (shouldSkipExternalCommands()) {
+		emit?.({
+			addon: "fumadocs",
+			status: "skipped",
+			warning: "Skipped because BTS_SKIP_EXTERNAL_COMMANDS or BTS_TEST_MODE is enabled."
+		});
+		return Result.ok(void 0);
+	}
 	const { packageManager, projectDir } = config;
+	const isInteractive = context.interactive ?? true;
 	log.info("Setting up Fumadocs...");
-	const template = await select({
-		message: "Choose a template",
-		options: Object.entries(TEMPLATES$2).map(([key, template]) => ({
-			value: key,
-			label: template.label,
-			hint: template.hint
-		})),
-		initialValue: "next-mdx"
-	});
-	if (isCancel(template)) return userCancelled("Operation cancelled");
+	let template = context.addonOptions?.fumadocs?.template ?? "next-mdx";
+	if (isInteractive) {
+		const selectedTemplate = await select({
+			message: "Choose a template",
+			options: Object.entries(TEMPLATES$2).map(([key, template]) => ({
+				value: key,
+				label: template.label,
+				hint: template.hint
+			})),
+			initialValue: template
+		});
+		if (isCancel(selectedTemplate)) return userCancelled("Operation cancelled");
+		template = selectedTemplate;
+	}
 	const templateArg = TEMPLATES$2[template].value;
 	const isNextTemplate = template.startsWith("next-");
 	const options = [
@@ -1372,12 +1388,14 @@ async function setupFumadocs(config) {
 			})`${args}`;
 			const fumadocsDir = path.join(projectDir, "apps", "fumadocs");
 			const packageJsonPath = path.join(fumadocsDir, "package.json");
-			if (await fs.pathExists(packageJsonPath)) {
-				const packageJson = await fs.readJson(packageJsonPath);
-				packageJson.name = "fumadocs";
-				if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port=4000`;
-				await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-			}
+			if (!await fs.pathExists(packageJsonPath)) throw new AddonSetupError({
+				addon: "fumadocs",
+				message: "Fumadocs generator did not create apps/fumadocs/package.json. Upstream template shape may have changed."
+			});
+			const packageJson = await fs.readJson(packageJsonPath);
+			packageJson.name = "fumadocs";
+			if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port=4000`;
+			await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 		},
 		catch: (e) => new AddonSetupError({
 			addon: "fumadocs",
@@ -1387,9 +1405,24 @@ async function setupFumadocs(config) {
 	});
 	if (result.isErr()) {
 		s.stop("Failed to set up Fumadocs");
+		emit?.({
+			addon: "fumadocs",
+			status: "failed",
+			selectedOptions: { template },
+			commands: [args.join(" ")],
+			postChecks: ["apps/fumadocs/package.json exists", "apps/fumadocs/package.json scripts.dev uses --port=4000"],
+			error: result.error.message
+		});
 		return result;
 	}
 	s.stop("Fumadocs setup complete!");
+	emit?.({
+		addon: "fumadocs",
+		status: "success",
+		selectedOptions: { template },
+		commands: [args.join(" ")],
+		postChecks: ["apps/fumadocs/package.json exists", "apps/fumadocs/package.json scripts.dev uses --port=4000"]
+	});
 	return Result.ok(void 0);
 }
 
@@ -1554,24 +1587,37 @@ function getRecommendedMcpServers(config) {
 function filterAgentsForScope(scope) {
 	return MCP_AGENTS.filter((a) => a.scope === "both" || a.scope === scope);
 }
-async function setupMcp(config) {
-	if (shouldSkipExternalCommands()) return Result.ok(void 0);
+async function setupMcp(config, context = {}) {
+	const emit = context.collectExternalReport;
+	if (shouldSkipExternalCommands()) {
+		emit?.({
+			addon: "mcp",
+			status: "skipped",
+			warning: "Skipped because BTS_SKIP_EXTERNAL_COMMANDS or BTS_TEST_MODE is enabled."
+		});
+		return Result.ok(void 0);
+	}
 	const { packageManager, projectDir } = config;
+	const isInteractive = context.interactive ?? true;
 	log.info("Setting up MCP servers...");
-	const scope = await select({
-		message: "Where should MCP servers be installed?",
-		options: [{
-			value: "project",
-			label: "Project",
-			hint: "Writes to project config files (recommended for teams)"
-		}, {
-			value: "global",
-			label: "Global",
-			hint: "Writes to user-level config files (personal machine)"
-		}],
-		initialValue: "project"
-	});
-	if (isCancel(scope)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+	let scope = context.addonOptions?.mcp?.scope ?? "project";
+	if (isInteractive) {
+		const selectedScope = await select({
+			message: "Where should MCP servers be installed?",
+			options: [{
+				value: "project",
+				label: "Project",
+				hint: "Writes to project config files (recommended for teams)"
+			}, {
+				value: "global",
+				label: "Global",
+				hint: "Writes to user-level config files (personal machine)"
+			}],
+			initialValue: scope
+		});
+		if (isCancel(selectedScope)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+		scope = selectedScope;
+	}
 	const recommendedServers = getRecommendedMcpServers(config);
 	if (recommendedServers.length === 0) return Result.ok(void 0);
 	const serverOptions = recommendedServers.map((s) => ({
@@ -1579,37 +1625,77 @@ async function setupMcp(config) {
 		label: s.label,
 		hint: s.target
 	}));
-	const selectedServerKeys = await multiselect({
-		message: "Select MCP servers to install",
-		options: serverOptions,
-		required: false,
-		initialValues: serverOptions.map((o) => o.value)
-	});
-	if (isCancel(selectedServerKeys)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-	if (selectedServerKeys.length === 0) return Result.ok(void 0);
+	let selectedServerKeys = context.addonOptions?.mcp?.serverKeys?.length === 0 ? [] : context.addonOptions?.mcp?.serverKeys ?? serverOptions.map((o) => o.value);
+	if (isInteractive) {
+		const selectedServersResult = await multiselect({
+			message: "Select MCP servers to install",
+			options: serverOptions,
+			required: false,
+			initialValues: selectedServerKeys
+		});
+		if (isCancel(selectedServersResult)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+		selectedServerKeys = selectedServersResult;
+	}
+	if (selectedServerKeys.length === 0) {
+		emit?.({
+			addon: "mcp",
+			status: "warning",
+			selectedOptions: { scope },
+			warning: "No MCP servers were selected for installation."
+		});
+		return Result.ok(void 0);
+	}
 	const agentOptions = filterAgentsForScope(scope).map((a) => ({
 		value: a.value,
 		label: a.label
 	}));
-	const selectedAgents = await multiselect({
-		message: "Select agents to install MCP servers to",
-		options: agentOptions,
-		required: false,
-		initialValues: uniqueValues$1([
-			"cursor",
-			"claude-code",
-			"vscode"
-		].filter((a) => agentOptions.some((o) => o.value === a)))
-	});
-	if (isCancel(selectedAgents)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-	if (selectedAgents.length === 0) return Result.ok(void 0);
+	const defaultAgents = uniqueValues$1([
+		"cursor",
+		"claude-code",
+		"vscode"
+	].filter((a) => agentOptions.some((o) => o.value === a)));
+	let selectedAgents = uniqueValues$1((context.addonOptions?.mcp?.agents ?? defaultAgents).filter((agent) => agentOptions.some((option) => option.value === agent)));
+	if (isInteractive) {
+		const selectedAgentsResult = await multiselect({
+			message: "Select agents to install MCP servers to",
+			options: agentOptions,
+			required: false,
+			initialValues: selectedAgents
+		});
+		if (isCancel(selectedAgentsResult)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+		selectedAgents = selectedAgentsResult;
+	}
+	if (selectedAgents.length === 0) {
+		emit?.({
+			addon: "mcp",
+			status: "warning",
+			selectedOptions: {
+				scope,
+				selectedServerKeys
+			},
+			warning: "No agents were selected for MCP server installation."
+		});
+		return Result.ok(void 0);
+	}
 	const serversByKey = new Map(recommendedServers.map((s) => [s.key, s]));
 	const selectedServers = [];
 	for (const key of selectedServerKeys) {
 		const server = serversByKey.get(key);
 		if (server) selectedServers.push(server);
 	}
-	if (selectedServers.length === 0) return Result.ok(void 0);
+	if (selectedServers.length === 0) {
+		emit?.({
+			addon: "mcp",
+			status: "warning",
+			selectedOptions: {
+				scope,
+				selectedServerKeys,
+				selectedAgents
+			},
+			warning: "No matching recommended MCP servers were found for the selected keys."
+		});
+		return Result.ok(void 0);
+	}
 	const installSpinner = spinner();
 	installSpinner.start("Installing MCP servers...");
 	const runner = getPackageRunnerPrefix(packageManager);
@@ -1630,7 +1716,8 @@ async function setupMcp(config) {
 			...globalFlags,
 			"-y"
 		];
-		if ((await Result.tryPromise({
+		const postChecks = [`MCP agent configs updated with server '${server.name}'`];
+		const installResult = await Result.tryPromise({
 			try: async () => {
 				await $({
 					cwd: projectDir,
@@ -1642,7 +1729,36 @@ async function setupMcp(config) {
 				message: `Failed to install MCP server '${server.name}': ${e instanceof Error ? e.message : String(e)}`,
 				cause: e
 			})
-		})).isErr()) log.warn(pc.yellow(`Warning: Could not install MCP server '${server.name}'`));
+		});
+		if (installResult.isErr()) {
+			log.warn(pc.yellow(`Warning: Could not install MCP server '${server.name}'`));
+			emit?.({
+				addon: "mcp",
+				status: "warning",
+				selectedOptions: {
+					scope,
+					server: server.key,
+					serverName: server.name,
+					agents: selectedAgents
+				},
+				commands: [args.join(" ")],
+				postChecks,
+				warning: installResult.error.message
+			});
+			continue;
+		}
+		emit?.({
+			addon: "mcp",
+			status: "success",
+			selectedOptions: {
+				scope,
+				server: server.key,
+				serverName: server.name,
+				agents: selectedAgents
+			},
+			commands: [args.join(" ")],
+			postChecks
+		});
 	}
 	installSpinner.stop("MCP servers installed");
 	return Result.ok(void 0);
@@ -1994,9 +2110,18 @@ function getCuratedSkillNamesForSourceKey(sourceKey, config) {
 function uniqueValues(values) {
 	return Array.from(new Set(values));
 }
-async function setupSkills(config) {
-	if (shouldSkipExternalCommands()) return Result.ok(void 0);
+async function setupSkills(config, context = {}) {
+	const emit = context.collectExternalReport;
+	if (shouldSkipExternalCommands()) {
+		emit?.({
+			addon: "skills",
+			status: "skipped",
+			warning: "Skipped because BTS_SKIP_EXTERNAL_COMMANDS or BTS_TEST_MODE is enabled."
+		});
+		return Result.ok(void 0);
+	}
 	const { packageManager, projectDir } = config;
+	const isInteractive = context.interactive ?? true;
 	const btsConfig = await readBtsConfig(projectDir);
 	const fullConfig = btsConfig ? {
 		...config,
@@ -2013,40 +2138,73 @@ async function setupSkills(config) {
 		}));
 	});
 	if (skillOptions.length === 0) return Result.ok(void 0);
-	const scope = await select({
-		message: "Where should skills be installed?",
-		options: [{
-			value: "project",
-			label: "Project",
-			hint: "Writes to project config files (recommended for teams)"
-		}, {
-			value: "global",
-			label: "Global",
-			hint: "Writes to user-level config files (personal machine)"
-		}],
-		initialValue: "project"
-	});
-	if (isCancel(scope)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-	const selectedSkills = await multiselect({
-		message: "Select skills to install",
-		options: skillOptions,
-		required: false,
-		initialValues: skillOptions.map((opt) => opt.value)
-	});
-	if (isCancel(selectedSkills)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-	if (selectedSkills.length === 0) return Result.ok(void 0);
-	const selectedAgents = await multiselect({
-		message: "Select agents to install skills to",
-		options: AVAILABLE_AGENTS,
-		required: false,
-		initialValues: [
-			"cursor",
-			"claude-code",
-			"github-copilot"
-		]
-	});
-	if (isCancel(selectedAgents)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-	if (selectedAgents.length === 0) return Result.ok(void 0);
+	let scope = context.addonOptions?.skills?.scope ?? "project";
+	if (isInteractive) {
+		const selectedScope = await select({
+			message: "Where should skills be installed?",
+			options: [{
+				value: "project",
+				label: "Project",
+				hint: "Writes to project config files (recommended for teams)"
+			}, {
+				value: "global",
+				label: "Global",
+				hint: "Writes to user-level config files (personal machine)"
+			}],
+			initialValue: scope
+		});
+		if (isCancel(selectedScope)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+		scope = selectedScope;
+	}
+	const allSkillValues = skillOptions.map((opt) => opt.value);
+	let selectedSkills = context.addonOptions?.skills?.skillKeys?.length === 0 ? [] : context.addonOptions?.skills?.skillKeys ?? allSkillValues;
+	if (isInteractive) {
+		const selectedSkillsResult = await multiselect({
+			message: "Select skills to install",
+			options: skillOptions,
+			required: false,
+			initialValues: allSkillValues
+		});
+		if (isCancel(selectedSkillsResult)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+		selectedSkills = selectedSkillsResult;
+	}
+	if (selectedSkills.length === 0) {
+		emit?.({
+			addon: "skills",
+			status: "warning",
+			selectedOptions: { scope },
+			warning: "No skills were selected for installation."
+		});
+		return Result.ok(void 0);
+	}
+	let selectedAgents = context.addonOptions?.skills?.agents ?? [
+		"cursor",
+		"claude-code",
+		"github-copilot"
+	];
+	selectedAgents = selectedAgents.filter((agent) => AVAILABLE_AGENTS.some((option) => option.value === agent));
+	if (isInteractive) {
+		const selectedAgentsResult = await multiselect({
+			message: "Select agents to install skills to",
+			options: AVAILABLE_AGENTS,
+			required: false,
+			initialValues: selectedAgents
+		});
+		if (isCancel(selectedAgentsResult)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+		selectedAgents = selectedAgentsResult;
+	}
+	if (selectedAgents.length === 0) {
+		emit?.({
+			addon: "skills",
+			status: "warning",
+			selectedOptions: {
+				scope,
+				selectedSkills
+			},
+			warning: "No agents were selected for skills installation."
+		});
+		return Result.ok(void 0);
+	}
 	const skillsBySource = {};
 	for (const skillKey of selectedSkills) {
 		const [source, skillName] = skillKey.split("::");
@@ -2059,7 +2217,7 @@ async function setupSkills(config) {
 	const globalFlag = scope === "global" ? "-g" : "";
 	for (const [source, skills] of Object.entries(skillsBySource)) {
 		const skillFlags = skills.map((s) => `-s ${s}`).join(" ");
-		if ((await Result.tryPromise({
+		const installResult = await Result.tryPromise({
 			try: async () => {
 				const args = getPackageExecutionArgs(packageManager, `skills@latest add ${source} ${globalFlag} ${skillFlags} ${agentFlags} -y`);
 				await $({
@@ -2072,7 +2230,32 @@ async function setupSkills(config) {
 				message: `Failed to install skills from ${source}: ${e instanceof Error ? e.message : String(e)}`,
 				cause: e
 			})
-		})).isErr()) log.warn(pc.yellow(`Warning: Could not install skills from ${source}`));
+		});
+		if (installResult.isErr()) {
+			log.warn(pc.yellow(`Warning: Could not install skills from ${source}`));
+			emit?.({
+				addon: "skills",
+				status: "warning",
+				selectedOptions: {
+					scope,
+					source,
+					skills,
+					agents: selectedAgents
+				},
+				warning: installResult.error.message
+			});
+			continue;
+		}
+		emit?.({
+			addon: "skills",
+			status: "success",
+			selectedOptions: {
+				scope,
+				source,
+				skills,
+				agents: selectedAgents
+			}
+		});
 	}
 	installSpinner.stop("Skills installed");
 	return Result.ok(void 0);
@@ -2080,8 +2263,16 @@ async function setupSkills(config) {
 
 //#endregion
 //#region src/helpers/addons/starlight-setup.ts
-async function setupStarlight(config) {
-	if (shouldSkipExternalCommands()) return Result.ok(void 0);
+async function setupStarlight(config, context = {}) {
+	const emit = context.collectExternalReport;
+	if (shouldSkipExternalCommands()) {
+		emit?.({
+			addon: "starlight",
+			status: "skipped",
+			warning: "Skipped because BTS_SKIP_EXTERNAL_COMMANDS or BTS_TEST_MODE is enabled."
+		});
+		return Result.ok(void 0);
+	}
 	const { packageManager, projectDir } = config;
 	const s = spinner();
 	s.start("Setting up Starlight docs...");
@@ -2112,20 +2303,48 @@ async function setupStarlight(config) {
 	});
 	if (result.isErr()) {
 		s.stop("Failed to set up Starlight docs");
+		emit?.({
+			addon: "starlight",
+			status: "failed",
+			commands: [args.join(" ")],
+			postChecks: ["apps/docs exists"],
+			error: result.error.message
+		});
 		return result;
 	}
 	s.stop("Starlight docs setup successfully!");
+	emit?.({
+		addon: "starlight",
+		status: "success",
+		commands: [args.join(" ")],
+		postChecks: ["apps/docs exists"]
+	});
 	return Result.ok(void 0);
 }
 
 //#endregion
 //#region src/helpers/addons/tauri-setup.ts
-async function setupTauri(config) {
-	if (shouldSkipExternalCommands()) return Result.ok(void 0);
+async function setupTauri(config, context = {}) {
+	const emit = context.collectExternalReport;
+	if (shouldSkipExternalCommands()) {
+		emit?.({
+			addon: "tauri",
+			status: "skipped",
+			warning: "Skipped because BTS_SKIP_EXTERNAL_COMMANDS or BTS_TEST_MODE is enabled."
+		});
+		return Result.ok(void 0);
+	}
 	const { packageManager, frontend, projectDir } = config;
 	const s = spinner();
 	const clientPackageDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(clientPackageDir)) return Result.ok(void 0);
+	if (!await fs.pathExists(clientPackageDir)) {
+		emit?.({
+			addon: "tauri",
+			status: "skipped",
+			warning: "Skipped because apps/web does not exist in this project."
+		});
+		return Result.ok(void 0);
+	}
 	s.start("Setting up Tauri desktop app support...");
 	const hasReactRouter = frontend.includes("react-router");
 	const hasNuxt = frontend.includes("nuxt");
@@ -2159,9 +2378,22 @@ async function setupTauri(config) {
 	});
 	if (result.isErr()) {
 		s.stop("Failed to set up Tauri");
+		emit?.({
+			addon: "tauri",
+			status: "failed",
+			commands: [[...prefix, ...tauriArgs].join(" ")],
+			postChecks: ["apps/web/src-tauri exists"],
+			error: result.error.message
+		});
 		return result;
 	}
 	s.stop("Tauri desktop app support configured successfully!");
+	emit?.({
+		addon: "tauri",
+		status: "success",
+		commands: [[...prefix, ...tauriArgs].join(" ")],
+		postChecks: ["apps/web/src-tauri exists"]
+	});
 	return Result.ok(void 0);
 }
 
@@ -2438,20 +2670,33 @@ const TEMPLATES = {
 		hint: "Svelte template"
 	}
 };
-async function setupWxt(config) {
-	if (shouldSkipExternalCommands()) return Result.ok(void 0);
+async function setupWxt(config, context = {}) {
+	const emit = context.collectExternalReport;
+	if (shouldSkipExternalCommands()) {
+		emit?.({
+			addon: "wxt",
+			status: "skipped",
+			warning: "Skipped because BTS_SKIP_EXTERNAL_COMMANDS or BTS_TEST_MODE is enabled."
+		});
+		return Result.ok(void 0);
+	}
 	const { packageManager, projectDir } = config;
+	const isInteractive = context.interactive ?? true;
 	log.info("Setting up WXT...");
-	const template = await select({
-		message: "Choose a template",
-		options: Object.entries(TEMPLATES).map(([key, template]) => ({
-			value: key,
-			label: template.label,
-			hint: template.hint
-		})),
-		initialValue: "react"
-	});
-	if (isCancel(template)) return userCancelled("Operation cancelled");
+	let template = context.addonOptions?.wxt?.template ?? "react";
+	if (isInteractive) {
+		const selectedTemplate = await select({
+			message: "Choose a template",
+			options: Object.entries(TEMPLATES).map(([key, template]) => ({
+				value: key,
+				label: template.label,
+				hint: template.hint
+			})),
+			initialValue: template
+		});
+		if (isCancel(selectedTemplate)) return userCancelled("Operation cancelled");
+		template = selectedTemplate;
+	}
 	const args = getPackageExecutionArgs(packageManager, `wxt@latest init extension --template ${template} --pm ${packageManager}`);
 	const appsDir = path.join(projectDir, "apps");
 	const ensureDirResult = await Result.tryPromise({
@@ -2483,26 +2728,56 @@ async function setupWxt(config) {
 	});
 	if (initResult.isErr()) {
 		log.error(pc.red("Failed to set up WXT"));
+		emit?.({
+			addon: "wxt",
+			status: "failed",
+			selectedOptions: { template },
+			commands: [args.join(" ")],
+			postChecks: ["apps/extension/package.json exists", "apps/extension/package.json scripts.dev uses --port 5555"],
+			error: initResult.error.message
+		});
 		return initResult;
 	}
 	const extensionDir = path.join(projectDir, "apps", "extension");
 	const packageJsonPath = path.join(extensionDir, "package.json");
-	if ((await Result.tryPromise({
+	const updatePackageResult = await Result.tryPromise({
 		try: async () => {
-			if (await fs.pathExists(packageJsonPath)) {
-				const packageJson = await fs.readJson(packageJsonPath);
-				packageJson.name = "extension";
-				if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port 5555`;
-				await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-			}
+			if (!await fs.pathExists(packageJsonPath)) throw new AddonSetupError({
+				addon: "wxt",
+				message: "WXT generator did not create apps/extension/package.json. Upstream template shape may have changed."
+			});
+			const packageJson = await fs.readJson(packageJsonPath);
+			packageJson.name = "extension";
+			if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port 5555`;
+			await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 		},
 		catch: (e) => new AddonSetupError({
 			addon: "wxt",
 			message: `Failed to update package.json: ${e instanceof Error ? e.message : String(e)}`,
 			cause: e
 		})
-	})).isErr()) log.warn(pc.yellow("WXT setup completed but failed to update package.json"));
+	});
+	if (updatePackageResult.isErr()) {
+		log.warn(pc.yellow("WXT setup completed but failed to update package.json"));
+		s.stop("WXT setup completed with warnings");
+		emit?.({
+			addon: "wxt",
+			status: "warning",
+			selectedOptions: { template },
+			commands: [args.join(" ")],
+			postChecks: ["apps/extension/package.json exists", "apps/extension/package.json scripts.dev uses --port 5555"],
+			warning: updatePackageResult.error.message
+		});
+		return Result.ok(void 0);
+	}
 	s.stop("WXT setup complete!");
+	emit?.({
+		addon: "wxt",
+		status: "success",
+		selectedOptions: { template },
+		commands: [args.join(" ")],
+		postChecks: ["apps/extension/package.json exists", "apps/extension/package.json scripts.dev uses --port 5555"]
+	});
 	return Result.ok(void 0);
 }
 
@@ -2526,14 +2801,14 @@ async function runAddonStep(addon, step) {
 	});
 	if (result.isErr()) consola.error(pc.red(result.error.message));
 }
-async function setupAddons(config) {
+async function setupAddons(config, context = {}) {
 	const { addons, frontend, projectDir } = config;
 	const hasReactWebFrontend = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next");
 	const hasNuxtFrontend = frontend.includes("nuxt");
 	const hasSvelteFrontend = frontend.includes("svelte");
 	const hasSolidFrontend = frontend.includes("solid");
 	const hasNextFrontend = frontend.includes("next");
-	if (addons.includes("tauri") && (hasReactWebFrontend || hasNuxtFrontend || hasSvelteFrontend || hasSolidFrontend || hasNextFrontend)) await runSetup(() => setupTauri(config));
+	if (addons.includes("tauri") && (hasReactWebFrontend || hasNuxtFrontend || hasSvelteFrontend || hasSolidFrontend || hasNextFrontend)) await runSetup(() => setupTauri(config, context));
 	const hasUltracite = addons.includes("ultracite");
 	const hasBiome = addons.includes("biome");
 	const hasHusky = addons.includes("husky");
@@ -2555,13 +2830,13 @@ async function setupAddons(config) {
 			if (hasLefthook) await runAddonStep("lefthook", () => setupLefthook(projectDir));
 		}
 	}
-	if (addons.includes("starlight")) await runSetup(() => setupStarlight(config));
-	if (addons.includes("fumadocs")) await runSetup(() => setupFumadocs(config));
+	if (addons.includes("starlight")) await runSetup(() => setupStarlight(config, context));
+	if (addons.includes("fumadocs")) await runSetup(() => setupFumadocs(config, context));
 	if (addons.includes("opentui")) await runSetup(() => setupTui(config));
-	if (addons.includes("wxt")) await runSetup(() => setupWxt(config));
+	if (addons.includes("wxt")) await runSetup(() => setupWxt(config, context));
 	if (addons.includes("ruler")) await runSetup(() => setupRuler(config));
-	if (addons.includes("skills")) await runSetup(() => setupSkills(config));
-	if (addons.includes("mcp")) await runSetup(() => setupMcp(config));
+	if (addons.includes("skills")) await runSetup(() => setupSkills(config, context));
+	if (addons.includes("mcp")) await runSetup(() => setupMcp(config, context));
 }
 async function setupBiome(projectDir) {
 	await addPackageDependency({
@@ -3543,7 +3818,7 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 
 //#endregion
 //#region src/prompts/project-name.ts
-function isPathWithinCwd$1(targetPath) {
+function isPathWithinCwd$2(targetPath) {
 	const resolved = path.resolve(targetPath);
 	const rel = path.relative(process.cwd(), resolved);
 	return !rel.startsWith("..") && !path.isAbsolute(rel);
@@ -3557,7 +3832,7 @@ async function getProjectName(initialName) {
 	if (initialName) {
 		if (initialName === ".") return initialName;
 		if (!validateDirectoryName(path.basename(initialName))) {
-			if (isPathWithinCwd$1(path.resolve(process.cwd(), initialName))) return initialName;
+			if (isPathWithinCwd$2(path.resolve(process.cwd(), initialName))) return initialName;
 			consola.error(pc.red("Project path must be within current directory"));
 		}
 	}
@@ -3580,7 +3855,7 @@ async function getProjectName(initialName) {
 				const validationError = validateDirectoryName(path.basename(nameToUse));
 				if (validationError) return validationError;
 				if (nameToUse !== ".") {
-					if (!isPathWithinCwd$1(path.resolve(process.cwd(), nameToUse))) return "Project path must be within current directory";
+					if (!isPathWithinCwd$2(path.resolve(process.cwd(), nameToUse))) return "Project path must be within current directory";
 				}
 			}
 		});
@@ -3601,7 +3876,7 @@ async function getProjectName(initialName) {
 */
 function isTelemetryEnabled() {
 	const BTS_TELEMETRY_DISABLED = process.env.BTS_TELEMETRY_DISABLED;
-	const BTS_TELEMETRY = "1";
+	const BTS_TELEMETRY = "0";
 	if (BTS_TELEMETRY_DISABLED !== void 0) return BTS_TELEMETRY_DISABLED !== "1";
 	if (BTS_TELEMETRY !== void 0) return BTS_TELEMETRY === "1";
 	return true;
@@ -3609,17 +3884,7 @@ function isTelemetryEnabled() {
 
 //#endregion
 //#region src/utils/analytics.ts
-const CONVEX_INGEST_URL = "https://striped-seahorse-863.convex.site/api/analytics/ingest";
-async function sendConvexEvent(payload) {
-	await Result.tryPromise({
-		try: () => fetch(CONVEX_INGEST_URL, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(payload)
-		}),
-		catch: () => void 0
-	});
-}
+async function sendConvexEvent(payload) {}
 async function trackProjectCreation(config, disableAnalytics = false) {
 	if (!isTelemetryEnabled() || disableAnalytics) return;
 	const { projectName: _projectName, projectDir: _projectDir, relativePath: _relativePath, ...safeConfig } = config;
@@ -4205,6 +4470,19 @@ async function formatProject(projectDir) {
 	});
 }
 
+//#endregion
+//#region src/helpers/addons/external-manifest.ts
+async function writeExternalAddonManifest(projectDir, reports) {
+	if (reports.length === 0) return;
+	const manifest = {
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		reports
+	};
+	const btsDir = path.join(projectDir, ".bts");
+	await fs.ensureDir(btsDir);
+	await fs.writeJson(path.join(btsDir, "external-manifest.json"), manifest, { spaces: 2 });
+}
+
 //#endregion
 //#region src/utils/env-utils.ts
 async function addEnvVariablesToFile(envPath, variables) {
@@ -5647,6 +5925,7 @@ async function createProject(options, cliInput = {}) {
 	return Result.gen(async function* () {
 		const projectDir = options.projectDir;
 		const isConvex = options.backend === "convex";
+		const externalReports = [];
 		yield* Result.await(Result.tryPromise({
 			try: () => fs.ensureDir(projectDir),
 			catch: (e) => new ProjectCreationError({
@@ -5678,11 +5957,32 @@ async function createProject(options, cliInput = {}) {
 				cause: e
 			})
 		}));
-		if (options.addons.length > 0 && options.addons[0] !== "none") yield* Result.await(Result.tryPromise({
-			try: () => setupAddons(options),
+		if (options.addons.length > 0 && options.addons[0] !== "none") {
+			const baseSetupContext = cliInput.addonSetupContext ?? {};
+			const setupContext = {
+				...baseSetupContext,
+				collectExternalReport: (report) => {
+					externalReports.push(report);
+					baseSetupContext.collectExternalReport?.(report);
+				}
+			};
+			yield* Result.await(Result.tryPromise({
+				try: () => setupAddons(options, setupContext),
+				catch: (e) => new ProjectCreationError({
+					phase: "addons-setup",
+					message: `Failed to setup addons: ${e instanceof Error ? e.message : String(e)}`,
+					cause: e
+				})
+			}));
+		}
+		yield* Result.await(Result.tryPromise({
+			try: async () => {
+				await writeExternalAddonManifest(projectDir, externalReports);
+				cliInput.onExternalAddonReports?.(externalReports);
+			},
 			catch: (e) => new ProjectCreationError({
-				phase: "addons-setup",
-				message: `Failed to setup addons: ${e instanceof Error ? e.message : String(e)}`,
+				phase: "addons-manifest",
+				message: `Failed to write external addon manifest: ${e instanceof Error ? e.message : String(e)}`,
 				cause: e
 			})
 		}));
@@ -5917,7 +6217,7 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 		});
 	});
 }
-function isPathWithinCwd(targetPath) {
+function isPathWithinCwd$1(targetPath) {
 	const resolved = path.resolve(targetPath);
 	const rel = path.relative(process.cwd(), resolved);
 	return !rel.startsWith("..") && !path.isAbsolute(rel);
@@ -5931,7 +6231,7 @@ async function resolveProjectNameForSilent(input) {
 		message: validationResult.error.message,
 		cause: validationResult.error
 	}));
-	if (!isPathWithinCwd(candidate)) return Result.err(new CLIError({ message: "Project path must be within current directory" }));
+	if (!isPathWithinCwd$1(candidate)) return Result.err(new CLIError({ message: "Project path must be within current directory" }));
 	return Result.ok(candidate);
 }
 async function handleDirectoryConflictResult(currentPathInput, strategy) {
@@ -5985,6 +6285,385 @@ async function handleDirectoryConflictProgrammatically(currentPathInput, strateg
 	}
 }
 
+//#endregion
+//#region src/mcp/planning.ts
+const EXTERNAL_ADDON_KEYS = new Set([
+	"fumadocs",
+	"starlight",
+	"wxt",
+	"tauri",
+	"mcp",
+	"skills"
+]);
+function getPreferredTemplate(options, addon) {
+	if (addon === "fumadocs") return options?.fumadocs?.template;
+	if (addon === "wxt") return options?.wxt?.template;
+}
+function toResultError(message) {
+	return new CLIError({ message });
+}
+function isPathWithinCwd(candidatePath) {
+	const resolvedCwd = path.resolve(process.cwd());
+	const resolvedPath = path.resolve(process.cwd(), candidatePath);
+	const relative = path.relative(resolvedCwd, resolvedPath);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function buildPlannedExternalSteps(config, addonOptions) {
+	return config.addons.filter((addon) => EXTERNAL_ADDON_KEYS.has(addon)).map((addon) => {
+		const preferredTemplate = getPreferredTemplate(addonOptions, addon);
+		return {
+			addon,
+			status: "planned",
+			selectedOptions: preferredTemplate ? { template: preferredTemplate } : void 0
+		};
+	});
+}
+function resolveScaffoldPlan(input) {
+	return Result.gen(function* () {
+		const configInput = input.config ?? {};
+		const defaultConfig = getDefaultConfig();
+		const requestedTarget = input.directory ?? input.projectName ?? defaultConfig.relativePath;
+		if (!isPathWithinCwd(requestedTarget)) yield* Result.err(toResultError("Project path must be within current directory"));
+		const processedInput = {
+			...configInput,
+			projectName: requestedTarget,
+			template: configInput.template,
+			yes: false,
+			yolo: false,
+			install: configInput.install ?? defaultConfig.install,
+			git: configInput.git ?? defaultConfig.git,
+			packageManager: configInput.packageManager ?? defaultConfig.packageManager
+		};
+		let mergedInput = processedInput;
+		if (configInput.template && configInput.template !== "none") {
+			const templateConfig = getTemplateConfig(configInput.template);
+			if (templateConfig) mergedInput = {
+				...templateConfig,
+				...processedInput,
+				template: configInput.template
+			};
+		}
+		const providedFlags = getProvidedFlags(mergedInput);
+		const projectNameBase = path.basename(path.resolve(process.cwd(), requestedTarget));
+		const flagConfig = yield* processAndValidateFlags({
+			...mergedInput,
+			projectDirectory: requestedTarget
+		}, providedFlags, projectNameBase).mapError((error) => toResultError(error.message));
+		const resolvedProjectDir = path.resolve(process.cwd(), requestedTarget);
+		const normalizedConfig = {
+			...defaultConfig,
+			...flagConfig,
+			projectName: projectNameBase,
+			projectDir: resolvedProjectDir,
+			relativePath: requestedTarget
+		};
+		yield* validateConfigCompatibility(normalizedConfig, providedFlags, mergedInput).mapError((error) => toResultError(error.message));
+		const warnings = [];
+		const plannedExternalSteps = buildPlannedExternalSteps(normalizedConfig, input.addonOptions);
+		if (plannedExternalSteps.length > 0) warnings.push("This configuration includes addons that execute external generators. The project can complete with partial_success if upstream generators fail.");
+		return Result.ok({
+			config: normalizedConfig,
+			reproducibleCommand: generateReproducibleCommand(normalizedConfig),
+			plannedExternalSteps,
+			warnings
+		});
+	});
+}
+function computeExternalStatusFromReports(reports) {
+	return reports.some((report) => report.status === "warning" || report.status === "failed") ? "partial_success" : "success";
+}
+
+//#endregion
+//#region src/mcp/tools/create-stack.ts
+function collectReportWarnings(reports) {
+	return reports.flatMap((report) => {
+		if (report.warning) return [report.warning];
+		if (report.error) return [report.error];
+		return [];
+	});
+}
+async function resolveDirectoryConflict(currentPathInput, strategy) {
+	const currentPath = path.resolve(process.cwd(), currentPathInput);
+	if (!await fs.pathExists(currentPath)) return Result.ok({
+		finalPathInput: currentPathInput,
+		shouldClearDirectory: false
+	});
+	if (!((await fs.readdir(currentPath)).length > 0)) return Result.ok({
+		finalPathInput: currentPathInput,
+		shouldClearDirectory: false
+	});
+	switch (strategy) {
+		case "overwrite": return Result.ok({
+			finalPathInput: currentPathInput,
+			shouldClearDirectory: true
+		});
+		case "merge": return Result.ok({
+			finalPathInput: currentPathInput,
+			shouldClearDirectory: false
+		});
+		case "increment": {
+			let counter = 1;
+			const baseName = currentPathInput;
+			let finalPathInput = `${baseName}-${counter}`;
+			while (await fs.pathExists(path.resolve(process.cwd(), finalPathInput)) && (await fs.readdir(path.resolve(process.cwd(), finalPathInput))).length > 0) {
+				counter += 1;
+				finalPathInput = `${baseName}-${counter}`;
+			}
+			return Result.ok({
+				finalPathInput,
+				shouldClearDirectory: false
+			});
+		}
+		case "error": return Result.err(new DirectoryConflictError({ directory: currentPathInput }));
+		default: return Result.err(new CLIError({ message: `Unknown directory conflict strategy: ${strategy}` }));
+	}
+}
+async function createStack(input) {
+	const planResult = resolveScaffoldPlan(input);
+	if (planResult.isErr()) return {
+		status: "failed",
+		externalStepReports: [],
+		warnings: [],
+		errors: [planResult.error.message]
+	};
+	const strategy = input.directoryConflict ?? "error";
+	const planned = planResult.value;
+	const conflictResult = await resolveDirectoryConflict(planned.config.relativePath, strategy);
+	if (conflictResult.isErr()) return {
+		status: "failed",
+		externalStepReports: [],
+		warnings: planned.warnings,
+		errors: [conflictResult.error.message]
+	};
+	const dirSetupResult = await Result.tryPromise({
+		try: async () => setupProjectDirectory(conflictResult.value.finalPathInput, conflictResult.value.shouldClearDirectory),
+		catch: (e) => new CLIError({
+			message: e instanceof Error ? e.message : String(e),
+			cause: e
+		})
+	});
+	if (dirSetupResult.isErr()) return {
+		status: "failed",
+		externalStepReports: [],
+		warnings: planned.warnings,
+		errors: [dirSetupResult.error.message]
+	};
+	const { finalBaseName, finalResolvedPath } = dirSetupResult.value;
+	const finalConfig = {
+		...planned.config,
+		projectName: finalBaseName,
+		projectDir: finalResolvedPath,
+		relativePath: conflictResult.value.finalPathInput
+	};
+	const reports = [];
+	const addonOptions = input.addonOptions;
+	const projectResult = await runWithContextAsync({ silent: true }, () => createProject(finalConfig, {
+		manualDb: input.config?.manualDb ?? false,
+		addonSetupContext: {
+			interactive: false,
+			addonOptions
+		},
+		onExternalAddonReports: (newReports) => reports.push(...newReports)
+	}));
+	if (projectResult.isErr()) return {
+		status: "failed",
+		externalStepReports: reports,
+		warnings: [...planned.warnings, ...collectReportWarnings(reports)],
+		errors: [projectResult.error.message]
+	};
+	const reproducibleCommand = generateReproducibleCommand(finalConfig);
+	const status = computeExternalStatusFromReports(reports);
+	const warnings = [...planned.warnings, ...collectReportWarnings(reports)];
+	return {
+		status,
+		projectDirectory: finalConfig.projectDir,
+		relativePath: finalConfig.relativePath,
+		reproducibleCommand,
+		externalStepReports: reports,
+		warnings,
+		errors: []
+	};
+}
+
+//#endregion
+//#region src/mcp/tools/plan-stack.ts
+function planStack(input) {
+	const result = resolveScaffoldPlan({
+		projectName: input.projectName,
+		directory: input.directory,
+		config: input.config,
+		addonOptions: input.addonOptions
+	});
+	if (result.isErr()) return {
+		success: false,
+		warnings: [],
+		errors: [result.error.message]
+	};
+	const plan = result.value;
+	return {
+		success: true,
+		normalizedConfig: plan.config,
+		reproducibleCommand: plan.reproducibleCommand,
+		plannedExternalSteps: plan.plannedExternalSteps,
+		warnings: plan.warnings,
+		errors: []
+	};
+}
+
+//#endregion
+//#region src/mcp/server.ts
+const AddonOptionsSchema = z$1.object({
+	fumadocs: z$1.object({ template: z$1.enum([
+		"next-mdx",
+		"next-mdx-static",
+		"waku",
+		"react-router",
+		"react-router-spa",
+		"tanstack-start",
+		"tanstack-start-spa"
+	]).optional() }).optional(),
+	wxt: z$1.object({ template: z$1.enum([
+		"vanilla",
+		"vue",
+		"react",
+		"solid",
+		"svelte"
+	]).optional() }).optional(),
+	mcp: z$1.object({
+		scope: z$1.enum(["project", "global"]).optional(),
+		agents: z$1.array(z$1.string()).optional(),
+		serverKeys: z$1.array(z$1.string()).optional()
+	}).optional(),
+	skills: z$1.object({
+		scope: z$1.enum(["project", "global"]).optional(),
+		agents: z$1.array(z$1.string()).optional(),
+		skillKeys: z$1.array(z$1.string()).optional()
+	}).optional()
+});
+const SharedInputSchema = {
+	projectName: z$1.string().optional(),
+	directory: z$1.string().optional(),
+	config: z$1.unknown().optional(),
+	addonOptions: AddonOptionsSchema.optional()
+};
+function validateConfig(input) {
+	const parsed = types_exports.CreateInputSchema.partial().safeParse(input ?? {});
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		throw new Error(`Invalid config: ${issue?.message ?? "unknown error"}`);
+	}
+	return parsed.data;
+}
+async function startMcpServer() {
+	const server = new McpServer({
+		name: "create-better-t-stack",
+		version: getLatestCLIVersion()
+	});
+	server.registerTool("plan_stack", {
+		description: "Validate and normalize a Better-T-Stack configuration without writing files. Returns reproducible command and planned external steps.",
+		inputSchema: SharedInputSchema,
+		outputSchema: {
+			success: z$1.boolean(),
+			normalizedConfig: z$1.record(z$1.string(), z$1.unknown()).optional(),
+			reproducibleCommand: z$1.string().optional(),
+			plannedExternalSteps: z$1.array(z$1.object({
+				addon: z$1.string(),
+				status: z$1.literal("planned"),
+				selectedOptions: z$1.record(z$1.string(), z$1.unknown()).optional()
+			})).optional(),
+			warnings: z$1.array(z$1.string()),
+			errors: z$1.array(z$1.string())
+		}
+	}, async (args) => {
+		try {
+			const result = planStack({
+				projectName: args.projectName,
+				directory: args.directory,
+				config: validateConfig(args.config),
+				addonOptions: args.addonOptions
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				structuredContent: result
+			};
+		} catch (error) {
+			const result = {
+				success: false,
+				warnings: [],
+				errors: [error instanceof Error ? error.message : String(error)]
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				structuredContent: result
+			};
+		}
+	});
+	server.registerTool("create_stack", {
+		description: "Scaffold a Better-T-Stack project on disk. Returns success, partial_success, or failed along with external step reports.",
+		inputSchema: {
+			...SharedInputSchema,
+			directoryConflict: z$1.enum([
+				"merge",
+				"overwrite",
+				"increment",
+				"error"
+			]).optional()
+		},
+		outputSchema: {
+			status: z$1.enum([
+				"success",
+				"partial_success",
+				"failed"
+			]),
+			projectDirectory: z$1.string().optional(),
+			relativePath: z$1.string().optional(),
+			reproducibleCommand: z$1.string().optional(),
+			externalStepReports: z$1.array(z$1.record(z$1.string(), z$1.unknown())),
+			warnings: z$1.array(z$1.string()),
+			errors: z$1.array(z$1.string())
+		}
+	}, async (args) => {
+		try {
+			const result = await createStack({
+				projectName: args.projectName,
+				directory: args.directory,
+				config: validateConfig(args.config),
+				addonOptions: args.addonOptions,
+				directoryConflict: args.directoryConflict
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				structuredContent: result
+			};
+		} catch (error) {
+			const result = {
+				status: "failed",
+				externalStepReports: [],
+				warnings: [],
+				errors: [error instanceof Error ? error.message : String(error)]
+			};
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				structuredContent: result
+			};
+		}
+	});
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+}
+
 //#endregion
 //#region src/index.ts
 const router = os.router({
@@ -6042,6 +6721,9 @@ const router = os.router({
 		json: z.boolean().optional().default(false).describe("Output as JSON")
 	})).handler(async ({ input }) => {
 		await historyHandler(input);
+	}),
+	mcp: os.meta({ description: "Start Better-T-Stack MCP server over stdio" }).handler(async () => {
+		await startMcpServer();
 	})
 });
 const caller = createRouterClient(router, { context: {} });
@@ -6184,4 +6866,4 @@ async function add(options = {}) {
 }
 
 //#endregion
-export { DatabaseSetupError as _, VirtualFileSystem$1 as a, UserCancelledError as b, create as c, docs as d, generate$1 as f, CompatibilityError as g, CLIError as h, TEMPLATE_COUNT as i, createBtsCli as l, sponsors as m, GeneratorError$1 as n, add as o, router as p, Result$1 as r, builder as s, EMBEDDED_TEMPLATES$1 as t, createVirtual as u, DirectoryConflictError as v, ValidationError as x, ProjectCreationError as y };
+export { ValidationError as S, CompatibilityError as _, VirtualFileSystem$1 as a, ProjectCreationError as b, create as c, docs as d, generate$1 as f, CLIError as g, startMcpServer as h, TEMPLATE_COUNT as i, createBtsCli as l, sponsors as m, GeneratorError$1 as n, add as o, router as p, Result$1 as r, builder as s, EMBEDDED_TEMPLATES$1 as t, createVirtual as u, DatabaseSetupError as v, UserCancelledError as x, DirectoryConflictError as y };

package/dist/virtual.d.mts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
-import { EMBEDDED_TEMPLATES, GeneratorError, GeneratorOptions, Result, TEMPLATE_COUNT, VirtualDirectory, VirtualFile, VirtualFileSystem, VirtualFileTree, VirtualNode, generate } from "@better-t-stack/template-generator";
+import { Result } from "better-result";
+import { EMBEDDED_TEMPLATES, GeneratorError, GeneratorOptions, TEMPLATE_COUNT, VirtualDirectory, VirtualFile, VirtualFileSystem, VirtualFileTree, VirtualNode, generate } from "@better-t-stack/template-generator";
 import { API, Addons, Auth, Backend, Database, DatabaseSetup, Examples, Frontend, ORM, PackageManager, Payments, ProjectConfig, Runtime, ServerDeploy, WebDeploy } from "@better-t-stack/types";
 export { type API, type Addons, type Auth, type Backend, type Database, type DatabaseSetup, EMBEDDED_TEMPLATES, type Examples, type Frontend, GeneratorError, type GeneratorOptions, type ORM, type PackageManager, type Payments, type ProjectConfig, Result, type Runtime, type ServerDeploy, TEMPLATE_COUNT, type VirtualDirectory, type VirtualFile, VirtualFileSystem, type VirtualFileTree, type VirtualNode, type WebDeploy, generate };

package/dist/virtual.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
-import { EMBEDDED_TEMPLATES, GeneratorError, Result, TEMPLATE_COUNT, VirtualFileSystem, generate } from "@better-t-stack/template-generator";
+import { Result } from "better-result";
+import { EMBEDDED_TEMPLATES, GeneratorError, TEMPLATE_COUNT, VirtualFileSystem, generate } from "@better-t-stack/template-generator";
 
 export { EMBEDDED_TEMPLATES, GeneratorError, Result, TEMPLATE_COUNT, VirtualFileSystem, generate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-t-stack",
-  "version": "3.20.2",
+  "version": "3.21.0-pr892.a7e1b0f",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "keywords": [
     "better-auth",
@@ -70,10 +70,11 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@better-t-stack/template-generator": "^3.20.2",
-    "@better-t-stack/types": "^3.20.2",
+    "@better-t-stack/template-generator": "3.21.0-pr892.a7e1b0f",
+    "@better-t-stack/types": "3.21.0-pr892.a7e1b0f",
     "@clack/core": "^1.0.0",
     "@clack/prompts": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "@orpc/server": "^1.13.4",
     "better-result": "^2.7.0",
     "consola": "^3.4.2",