create-better-t-stack 3.36.5 → 3.38.0

package/dist/{src-DpdI3cqy.mjs → src-Cbu9a6bq.mjs}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { n as __reExport, t as __exportAll } from "./chunk-BtN16TXe.mjs";
+import { n as __reExport, t as __exportAll } from "./rolldown-runtime-yhw22V8Z.mjs";
 import { getAllJsonSchemas } from "@better-t-stack/types/json-schema";
 import { initTRPC } from "@trpc/server";
 import { Result, Result as Result$1, TaggedError } from "better-result";
 import { createCli } from "trpc-cli";
 import z from "zod";
-import { cancel, confirm, intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts";
+import { box, cancel, confirm, intro, isCancel, limitOptions, log, outro, select, spinner, text } from "@clack/prompts";
 import pc from "picocolors";
 import path from "node:path";
 import envPaths from "env-paths";
@@ -22,6 +22,137 @@ import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt,
 import { applyEdits, modify, parse } from "jsonc-parser";
 import os from "node:os";
 import { format } from "oxfmt";
+//#region src/utils/display-config.ts
+const VALUE_LABELS = {
+	none: "None",
+	"tanstack-router": "TanStack Router",
+	"react-router": "React Router",
+	"tanstack-start": "TanStack Start",
+	next: "Next.js",
+	nuxt: "Nuxt",
+	svelte: "SvelteKit",
+	solid: "SolidStart",
+	astro: "Astro",
+	"native-bare": "Expo (bare)",
+	"native-uniwind": "Expo + Uniwind",
+	"native-unistyles": "Expo + Unistyles",
+	hono: "Hono",
+	express: "Express",
+	fastify: "Fastify",
+	elysia: "Elysia",
+	convex: "Convex",
+	self: "Fullstack framework",
+	bun: "Bun",
+	node: "Node.js",
+	workers: "Cloudflare Workers",
+	trpc: "tRPC",
+	orpc: "oRPC",
+	sqlite: "SQLite",
+	postgres: "PostgreSQL",
+	mysql: "MySQL",
+	mongodb: "MongoDB",
+	drizzle: "Drizzle",
+	prisma: "Prisma",
+	mongoose: "Mongoose",
+	"better-auth": "Better Auth",
+	clerk: "Clerk",
+	polar: "Polar",
+	pwa: "PWA",
+	tauri: "Tauri",
+	electrobun: "Electrobun",
+	biome: "Biome",
+	oxlint: "Oxlint + Oxfmt",
+	ultracite: "Ultracite",
+	lefthook: "Lefthook",
+	husky: "Husky",
+	turborepo: "Turborepo",
+	nx: "Nx",
+	"vite-plus": "Vite+",
+	starlight: "Starlight",
+	fumadocs: "Fumadocs",
+	opentui: "OpenTUI",
+	wxt: "WXT",
+	skills: "Agent skills",
+	mcp: "MCP servers",
+	evlog: "evlog",
+	todo: "Todo app",
+	ai: "AI chat",
+	turso: "Turso",
+	neon: "Neon",
+	planetscale: "PlanetScale",
+	supabase: "Supabase",
+	"prisma-postgres": "Prisma Postgres",
+	"mongodb-atlas": "MongoDB Atlas",
+	d1: "Cloudflare D1",
+	docker: "Docker",
+	cloudflare: "Cloudflare",
+	vercel: "Vercel",
+	npm: "npm",
+	pnpm: "pnpm"
+};
+function formatConfigValue(value) {
+	if (typeof value === "boolean") return value ? "Yes" : "No";
+	if (Array.isArray(value)) return value.length > 0 ? value.map(formatConfigValue).join(", ") : "None";
+	const text = String(value);
+	return VALUE_LABELS[text] ?? text.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function section(title, entries) {
+	const rows = entries.filter(([, value]) => value !== void 0).map(([label, value, format]) => ({
+		label,
+		value: format === "raw" ? String(value) : formatConfigValue(value)
+	}));
+	return rows.length > 0 ? {
+		title,
+		rows
+	} : void 0;
+}
+function getConfigSections(config) {
+	return [
+		section("Project", [[
+			"Name",
+			config.projectName,
+			"raw"
+		], [
+			"Directory",
+			config.relativePath,
+			"raw"
+		]]),
+		section("Application", [
+			["Frontend", config.frontend],
+			["Backend", config.backend],
+			["Runtime", config.runtime],
+			["API", config.api]
+		]),
+		section("Data", [
+			["Database", config.database],
+			["ORM", config.orm],
+			["Setup", config.dbSetup]
+		]),
+		section("Product", [
+			["Auth", config.auth],
+			["Payments", config.payments],
+			["Addons", config.addons],
+			["Examples", config.examples]
+		]),
+		section("Delivery", [
+			["Web deploy", config.webDeploy],
+			["Server deploy", config.serverDeploy],
+			["Package manager", config.packageManager],
+			["Git", config.git],
+			["Install deps", config.install]
+		])
+	].filter((value) => value !== void 0);
+}
+function displayConfig(config) {
+	const sections = getConfigSections(config);
+	if (sections.length === 0) return pc.yellow("No configuration selected.");
+	return sections.map(({ title, rows }) => {
+		const labelWidth = Math.max(...rows.map(({ label }) => label.length));
+		const renderedRows = rows.map(({ label, value }) => `  ${pc.dim(label.padEnd(labelWidth))}  ${value}`).join("\n");
+		return `${pc.magenta(pc.bold(title))}\n${renderedRows}`;
+	}).join("\n\n");
+}
+//#endregion
 //#region src/utils/get-package-manager.ts
 const getUserPkgManager = () => {
 	const userAgent = process.env.npm_config_user_agent;
@@ -120,6 +251,9 @@ function isFirstPrompt() {
 function didLastPromptShowUI() {
 	return getContext().navigation.lastPromptShownUI;
 }
+function getPromptProgress() {
+	return getContext().navigation.promptProgress;
+}
 function setIsFirstPrompt$1(value) {
 	const ctx = tryGetContext();
 	if (ctx) ctx.navigation.isFirstPrompt = value;
@@ -128,6 +262,10 @@ function setLastPromptShownUI(value) {
 	const ctx = tryGetContext();
 	if (ctx) ctx.navigation.lastPromptShownUI = value;
 }
+function setPromptProgress(value) {
+	const ctx = tryGetContext();
+	if (ctx) ctx.navigation.promptProgress = value;
+}
 async function runWithContextAsync(options, fn) {
 	const ctx = {
 		navigation: {
@@ -451,10 +589,10 @@ const renderTitle = () => {
 //#region src/commands/history.ts
 function formatStackSummary(entry) {
 	const parts = [];
-	if (entry.stack.frontend.length > 0 && !entry.stack.frontend.includes("none")) parts.push(entry.stack.frontend.join(", "));
-	if (entry.stack.backend && entry.stack.backend !== "none") parts.push(entry.stack.backend);
-	if (entry.stack.database && entry.stack.database !== "none") parts.push(entry.stack.database);
-	if (entry.stack.orm && entry.stack.orm !== "none") parts.push(entry.stack.orm);
+	if (entry.stack.frontend.length > 0 && !entry.stack.frontend.includes("none")) parts.push(formatConfigValue(entry.stack.frontend));
+	if (entry.stack.backend && entry.stack.backend !== "none") parts.push(formatConfigValue(entry.stack.backend));
+	if (entry.stack.database && entry.stack.database !== "none") parts.push(formatConfigValue(entry.stack.database));
+	if (entry.stack.orm && entry.stack.orm !== "none") parts.push(formatConfigValue(entry.stack.orm));
 	return parts.length > 0 ? parts.join(" + ") : "minimal";
 }
 function formatDate(isoString) {
@@ -466,6 +604,25 @@ function formatDate(isoString) {
 		minute: "2-digit"
 	});
 }
+function formatHistoryEntry(entry, index) {
+	const rows = [
+		{
+			label: "Created",
+			value: formatDate(entry.createdAt)
+		},
+		{
+			label: "Location",
+			value: entry.projectDir
+		},
+		{
+			label: "Stack",
+			value: formatStackSummary(entry)
+		}
+	];
+	const labelWidth = Math.max(...rows.map(({ label }) => label.length));
+	const details = rows.map(({ label, value }) => `${pc.dim(label.padEnd(labelWidth))}  ${value}`).join("\n");
+	return `${pc.cyan(pc.bold(`${index + 1}. ${entry.projectName}`))}\n${details}\n${pc.dim("Recreate")}\n${pc.cyan(entry.reproducibleCommand)}`;
+}
 async function historyHandler(input) {
 	if (input.clear) {
 		const clearResult = await clearHistory();
@@ -482,28 +639,18 @@ async function historyHandler(input) {
 		return;
 	}
 	const entries = historyResult.value;
-	if (entries.length === 0) {
-		log.info(pc.dim("No projects in history yet."));
-		log.info(pc.dim("Create a project with: create-better-t-stack my-app"));
-		return;
-	}
 	if (input.json) {
 		console.log(JSON.stringify(entries, null, 2));
 		return;
 	}
 	renderTitle();
-	intro(pc.magenta(`Project History (${entries.length} entries)`));
-	for (const [index, entry] of entries.entries()) {
-		const num = pc.dim(`${index + 1}.`);
-		const name = pc.cyan(pc.bold(entry.projectName));
-		const stack = pc.dim(formatStackSummary(entry));
-		log.message(`${num} ${name}`);
-		log.message(`   ${pc.dim("Created:")} ${formatDate(entry.createdAt)}`);
-		log.message(`   ${pc.dim("Path:")} ${entry.projectDir}`);
-		log.message(`   ${pc.dim("Stack:")} ${stack}`);
-		log.message(`   ${pc.dim("Command:")} ${pc.dim(entry.reproducibleCommand)}`);
-		log.message("");
+	intro(pc.magenta(`Project history · ${entries.length}`));
+	if (entries.length === 0) {
+		outro(`${pc.dim("No saved projects yet · create one with")} ${pc.cyan("create-better-t-stack my-app")}`);
+		return;
 	}
+	log.message(entries.map(formatHistoryEntry).join("\n\n"));
+	outro(pc.dim("Run a command above to recreate that project"));
 }
 //#endregion
 //#region src/utils/open-url.ts
@@ -575,27 +722,32 @@ async function fetchSponsorsQuietly({ url = SPONSORS_JSON_URL, timeoutMs = 1500
 function displaySponsors(sponsors) {
 	const { total_sponsors } = sponsors.summary;
 	if (total_sponsors === 0) {
-		log.info("No sponsors found. You can be the first one! ✨");
-		outro(pc.cyan(`Visit ${GITHUB_SPONSOR_URL} to become a sponsor.`));
+		log.info("No sponsors found yet");
+		outro(`${pc.dim("Become the first sponsor ·")} ${pc.cyan(GITHUB_SPONSOR_URL)}`);
 		return;
 	}
 	displaySponsorsBox(sponsors);
-	if (total_sponsors - sponsors.specialSponsors.length > 0) log.message(pc.blue(`+${total_sponsors - sponsors.specialSponsors.length} more amazing sponsors.\n`));
-	outro(pc.magenta(`Visit ${GITHUB_SPONSOR_URL} to become a sponsor.`));
+	if (total_sponsors - sponsors.specialSponsors.length > 0) log.message(pc.dim(`+${total_sponsors - sponsors.specialSponsors.length} more sponsors`));
+	outro(`${pc.dim("Become a sponsor ·")} ${pc.cyan(GITHUB_SPONSOR_URL)}`);
 }
 function displaySponsorsBox(sponsors) {
 	if (sponsors.specialSponsors.length === 0) return;
-	let output = `${pc.bold(pc.cyan("-> Special Sponsors"))}\n\n`;
-	sponsors.specialSponsors.forEach((sponsor, idx) => {
-		const displayName = sponsor.name ?? sponsor.githubId;
-		const tier = sponsor.tierName ? ` ${pc.yellow(`(${sponsor.tierName})`)}` : "";
-		output += `${pc.green(`• ${displayName}`)}${tier}\n`;
-		output += `  ${pc.dim("GitHub:")} https://github.com/${sponsor.githubId}\n`;
-		const website = sponsor.websiteUrl ?? sponsor.githubUrl;
-		if (website) output += `  ${pc.dim("Website:")} ${website}\n`;
-		if (idx < sponsors.specialSponsors.length - 1) output += "\n";
+	box(formatSpecialSponsorsDetails(sponsors), pc.bold("Special sponsors"), {
+		contentPadding: 2,
+		formatBorder: pc.dim,
+		rounded: true,
+		width: "auto"
 	});
-	cliConsola.box(output);
+}
+function formatSpecialSponsorsDetails(sponsors) {
+	return sponsors.specialSponsors.map((sponsor) => {
+		const displayName = sponsor.name ?? sponsor.githubId;
+		const tier = sponsor.tierName ? pc.dim(` · ${sponsor.tierName}`) : "";
+		const links = [];
+		if (sponsor.websiteUrl) links.push(`${pc.dim("Website")}  ${pc.cyan(sponsor.websiteUrl)}`);
+		links.push(`${pc.dim("GitHub ")}  ${pc.cyan(sponsor.githubUrl)}`);
+		return `${pc.bold(displayName)}${tier}\n${links.join("\n")}`;
+	}).join("\n\n");
 }
 function formatPostInstallSpecialSponsorsSection(sponsors) {
 	if (sponsors.specialSponsors.length === 0) return "";
@@ -658,7 +810,7 @@ async function fetchSponsorsData({ url = SPONSORS_JSON_URL, withSpinner = false,
 				cause: parseResult.error
 			}));
 		}
-		if (s) s.stop("Sponsors fetched successfully!");
+		if (s) s.stop("Sponsors loaded");
 		return Result.ok(parseResult.data);
 	} catch (error) {
 		const normalizedError = normalizeSponsorFetchError(error);
@@ -696,7 +848,7 @@ async function openExternalUrl(url, successMessage) {
 }
 async function showSponsorsCommand() {
 	renderTitle();
-	intro(pc.magenta("Better-T-Stack Sponsors"));
+	intro(pc.magenta("Sponsors"));
 	const sponsorsResult = await fetchSponsors();
 	if (sponsorsResult.isErr()) {
 		displayError(sponsorsResult.error);
@@ -984,15 +1136,12 @@ function isGoBack(value) {
 }
 //#endregion
 //#region src/prompts/navigable.ts
-/**
-* Navigable prompt wrappers using @clack/core
-* These prompts return GO_BACK_SYMBOL when 'b' is pressed (instead of canceling)
-*/
 const unicode = process.platform !== "win32";
 const S_STEP_ACTIVE = unicode ? "◆" : "*";
 const S_STEP_CANCEL = unicode ? "■" : "x";
 const S_STEP_ERROR = unicode ? "▲" : "x";
 const S_STEP_SUBMIT = unicode ? "◇" : "o";
+const S_STEP_BACK = unicode ? "↶" : "<";
 const S_BAR = unicode ? "│" : "|";
 const S_BAR_END = unicode ? "└" : "—";
 const S_RADIO_ACTIVE = unicode ? "●" : ">";
@@ -1000,6 +1149,10 @@ const S_RADIO_INACTIVE = unicode ? "○" : " ";
 const S_CHECKBOX_ACTIVE = unicode ? "◻" : "[•]";
 const S_CHECKBOX_SELECTED = unicode ? "◼" : "[+]";
 const S_CHECKBOX_INACTIVE = unicode ? "◻" : "[ ]";
+const promptsNavigatingBack = /* @__PURE__ */ new WeakSet();
+function keycap(label) {
+	return pc.inverse(` ${label} `);
+}
 function symbol(state) {
 	switch (state) {
 		case "initial":
@@ -1009,10 +1162,10 @@ function symbol(state) {
 		case "submit": return pc.green(S_STEP_SUBMIT);
 	}
 }
-const KEYBOARD_HINT = pc.dim(`${pc.gray("↑/↓")} navigate • ${pc.gray("enter")} confirm • ${pc.gray("b")} back • ${pc.gray("ctrl+c")} cancel`);
-const KEYBOARD_HINT_FIRST = pc.dim(`${pc.gray("↑/↓")} navigate • ${pc.gray("enter")} confirm • ${pc.gray("ctrl+c")} cancel`);
-const KEYBOARD_HINT_MULTI = pc.dim(`${pc.gray("↑/↓")} navigate • ${pc.gray("space")} select • ${pc.gray("enter")} confirm • ${pc.gray("b")} back • ${pc.gray("ctrl+c")} cancel`);
-const KEYBOARD_HINT_MULTI_FIRST = pc.dim(`${pc.gray("↑/↓")} navigate • ${pc.gray("space")} select • ${pc.gray("enter")} confirm • ${pc.gray("ctrl+c")} cancel`);
+const KEYBOARD_HINT = pc.dim(`${keycap("↑↓")} move  ${keycap("enter")} choose  ${keycap("b")} back  ${keycap("^c")} cancel`);
+const KEYBOARD_HINT_FIRST = pc.dim(`${keycap("↑↓")} move  ${keycap("enter")} choose  ${keycap("^c")} cancel`);
+const KEYBOARD_HINT_MULTI = pc.dim(`${keycap("↑↓")} move  ${keycap("space")} toggle  ${keycap("enter")} choose  ${keycap("b")} back  ${keycap("^c")} cancel`);
+const KEYBOARD_HINT_MULTI_FIRST = pc.dim(`${keycap("↑↓")} move  ${keycap("space")} toggle  ${keycap("enter")} choose  ${keycap("^c")} cancel`);
 const setIsFirstPrompt = setIsFirstPrompt$1;
 function getHint() {
 	return isFirstPrompt() ? KEYBOARD_HINT_FIRST : KEYBOARD_HINT;
@@ -1020,6 +1173,19 @@ function getHint() {
 function getMultiHint() {
 	return isFirstPrompt() ? KEYBOARD_HINT_MULTI_FIRST : KEYBOARD_HINT_MULTI;
 }
+function activePromptTitle(message, state = "active") {
+	const progress = getPromptProgress();
+	const eyebrow = progress ? `${pc.magenta(pc.bold(progress.section.toUpperCase()))} ${pc.dim(`· ${progress.current}/${progress.total}`)}` : pc.dim("SETUP");
+	return `${pc.gray(S_BAR)}  ${eyebrow}\n${symbol(state)}  ${pc.bold(message)}\n`;
+}
+function resolvedPrompt(message, value, state) {
+	const promptMessage = state === "cancel" ? pc.strikethrough(pc.dim(message)) : pc.dim(message);
+	return `${symbol(state)}  ${promptMessage} ${pc.dim("›")} ${value}`;
+}
+function canceledPrompt(prompt, message, value) {
+	if (promptsNavigatingBack.has(prompt)) return `${pc.cyan(S_STEP_BACK)}  ${pc.dim(message)}`;
+	return resolvedPrompt(message, value, "cancel");
+}
 function normalizeValidationMessage(validationMessage) {
 	return validationMessage instanceof Error ? validationMessage.message : validationMessage;
 }
@@ -1028,20 +1194,26 @@ async function runWithNavigation(prompt) {
 	prompt.on("key", (char) => {
 		if ((char === "b" || char === "B") && !isFirstPrompt()) {
 			goBack = true;
+			promptsNavigatingBack.add(prompt);
 			prompt.state = "cancel";
 		}
 	});
 	setLastPromptShownUI(true);
-	const result = await prompt.prompt();
-	return goBack ? GO_BACK_SYMBOL : result;
+	try {
+		const result = await prompt.prompt();
+		return goBack ? GO_BACK_SYMBOL : result;
+	} finally {
+		promptsNavigatingBack.delete(prompt);
+	}
 }
 async function navigableSelect(opts) {
 	const opt = (option, state) => {
+		if (!option) return pc.dim("none");
 		const label = option.label ?? String(option.value);
 		switch (state) {
 			case "disabled": return `${pc.gray(S_RADIO_INACTIVE)} ${pc.gray(label)}${option.hint ? ` ${pc.dim(`(${option.hint ?? "disabled"})`)}` : ""}`;
 			case "selected": return `${pc.dim(label)}`;
-			case "active": return `${pc.green(S_RADIO_ACTIVE)} ${label}${option.hint ? ` ${pc.dim(`(${option.hint})`)}` : ""}`;
+			case "active": return `${pc.cyan(S_RADIO_ACTIVE)} ${label}${option.hint ? ` ${pc.dim(`(${option.hint})`)}` : ""}`;
 			case "cancelled": return `${pc.strikethrough(pc.dim(label))}`;
 			default: return `${pc.dim(S_RADIO_INACTIVE)} ${pc.dim(label)}`;
 		}
@@ -1049,15 +1221,25 @@ async function navigableSelect(opts) {
 	return runWithNavigation(new SelectPrompt({
 		options: opts.options,
 		initialValue: opts.initialValue,
+		signal: opts.signal,
+		input: opts.input,
+		output: opts.output,
 		render() {
-			const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
 			switch (this.state) {
-				case "submit": return `${title}${pc.gray(S_BAR)}  ${opt(this.options[this.cursor], "selected")}`;
-				case "cancel": return `${title}${pc.gray(S_BAR)}  ${opt(this.options[this.cursor], "cancelled")}\n${pc.gray(S_BAR)}`;
+				case "submit": return resolvedPrompt(opts.message, opt(this.options[this.cursor], "selected"), "submit");
+				case "cancel": return canceledPrompt(this, opts.message, opt(this.options[this.cursor], "cancelled"));
 				default: {
-					const optionsText = this.options.map((option, i) => opt(option, option.disabled ? "disabled" : i === this.cursor ? "active" : "inactive")).join(`\n${pc.cyan(S_BAR)}  `);
-					const hint = `\n${pc.gray(S_BAR)}  ${getHint()}`;
-					return `${title}${pc.cyan(S_BAR)}  ${optionsText}\n${pc.cyan(S_BAR_END)}${hint}\n`;
+					const optionsText = limitOptions({
+						output: opts.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: opts.maxItems,
+						columnPadding: 3,
+						rowPadding: 5,
+						style: (option, active) => opt(option, option.disabled ? "disabled" : active ? "active" : "inactive")
+					}).join(`\n${pc.cyan(S_BAR)}  `);
+					const hint = `${pc.gray(S_BAR_END)}  ${getHint()}`;
+					return `${activePromptTitle(opts.message)}${pc.cyan(S_BAR)}  ${optionsText}\n${hint}\n`;
 				}
 			}
 		}
@@ -1078,13 +1260,16 @@ async function navigableMultiselect(opts) {
 	return runWithNavigation(new MultiSelectPrompt({
 		options: opts.options,
 		initialValues: opts.initialValues,
+		cursorAt: opts.cursorAt,
 		required,
+		signal: opts.signal,
+		input: opts.input,
+		output: opts.output,
 		validate(selected) {
 			if (required && (selected === void 0 || selected.length === 0)) return `Please select at least one option.\n${pc.reset(pc.dim(`Press ${pc.gray(pc.bgWhite(pc.inverse(" space ")))} to select, ${pc.gray(pc.bgWhite(pc.inverse(" enter ")))} to submit`))}`;
 			return normalizeValidationMessage(opts.validate?.(selected));
 		},
 		render() {
-			const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
 			const value = this.value ?? [];
 			const styleOption = (option, active) => {
 				if (option.disabled) return opt(option, "disabled");
@@ -1096,21 +1281,37 @@ async function navigableMultiselect(opts) {
 			switch (this.state) {
 				case "submit": {
 					const submitText = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "submitted")).join(pc.dim(", ")) || pc.dim("none");
-					return `${title}${pc.gray(S_BAR)}  ${submitText}`;
+					return resolvedPrompt(opts.message, submitText, "submit");
 				}
 				case "cancel": {
-					const label = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "cancelled")).join(pc.dim(", "));
-					return `${title}${pc.gray(S_BAR)}  ${label}\n${pc.gray(S_BAR)}`;
+					const label = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "cancelled")).join(pc.dim(", ")) || pc.dim("none");
+					return canceledPrompt(this, opts.message, label);
 				}
 				case "error": {
 					const footer = this.error.split("\n").map((ln, i) => i === 0 ? `${pc.yellow(S_BAR_END)}  ${pc.yellow(ln)}` : `   ${ln}`).join("\n");
-					const optionsText = this.options.map((option, i) => styleOption(option, i === this.cursor)).join(`\n${pc.yellow(S_BAR)}  `);
-					return `${title}${pc.yellow(S_BAR)}  ${optionsText}\n${footer}\n`;
+					const optionsText = limitOptions({
+						output: opts.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: opts.maxItems,
+						columnPadding: 3,
+						rowPadding: footer.split("\n").length + 4,
+						style: styleOption
+					}).join(`\n${pc.yellow(S_BAR)}  `);
+					return `${activePromptTitle(opts.message, "error")}${pc.yellow(S_BAR)}  ${optionsText}\n${footer}\n`;
 				}
 				default: {
-					const optionsText = this.options.map((option, i) => styleOption(option, i === this.cursor)).join(`\n${pc.cyan(S_BAR)}  `);
-					const hint = `\n${pc.gray(S_BAR)}  ${getMultiHint()}`;
-					return `${title}${pc.cyan(S_BAR)}  ${optionsText}\n${pc.cyan(S_BAR_END)}${hint}\n`;
+					const optionsText = limitOptions({
+						output: opts.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: opts.maxItems,
+						columnPadding: 3,
+						rowPadding: 5,
+						style: styleOption
+					}).join(`\n${pc.cyan(S_BAR)}  `);
+					const hint = `${pc.gray(S_BAR_END)}  ${getMultiHint()}`;
+					return `${activePromptTitle(opts.message)}${pc.cyan(S_BAR)}  ${optionsText}\n${hint}\n`;
 				}
 			}
 		}
@@ -1123,15 +1324,17 @@ async function navigableConfirm(opts) {
 		active,
 		inactive,
 		initialValue: opts.initialValue ?? true,
+		signal: opts.signal,
+		input: opts.input,
+		output: opts.output,
 		render() {
-			const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
 			const value = this.value ? active : inactive;
 			switch (this.state) {
-				case "submit": return `${title}${pc.gray(S_BAR)}  ${pc.dim(value)}`;
-				case "cancel": return `${title}${pc.gray(S_BAR)}  ${pc.strikethrough(pc.dim(value))}\n${pc.gray(S_BAR)}`;
+				case "submit": return resolvedPrompt(opts.message, pc.dim(value), "submit");
+				case "cancel": return canceledPrompt(this, opts.message, pc.strikethrough(pc.dim(value)));
 				default: {
-					const hint = `\n${pc.gray(S_BAR)}  ${getHint()}`;
-					return `${title}${pc.cyan(S_BAR)}  ${this.value ? `${pc.green(S_RADIO_ACTIVE)} ${active}` : `${pc.dim(S_RADIO_INACTIVE)} ${pc.dim(active)}`} ${pc.dim("/")} ${!this.value ? `${pc.green(S_RADIO_ACTIVE)} ${inactive}` : `${pc.dim(S_RADIO_INACTIVE)} ${pc.dim(inactive)}`}\n${pc.cyan(S_BAR_END)}${hint}\n`;
+					const hint = `${pc.gray(S_BAR_END)}  ${getHint()}`;
+					return `${activePromptTitle(opts.message)}${pc.cyan(S_BAR)}  ${this.value ? `${pc.cyan(S_RADIO_ACTIVE)} ${active}` : `${pc.dim(S_RADIO_INACTIVE)} ${pc.dim(active)}`} ${pc.dim("/")} ${!this.value ? `${pc.cyan(S_RADIO_ACTIVE)} ${inactive}` : `${pc.dim(S_RADIO_INACTIVE)} ${pc.dim(inactive)}`}\n${hint}\n`;
 				}
 			}
 		}
@@ -1161,52 +1364,59 @@ async function navigableGroupMultiselect(opts) {
 	return runWithNavigation(new GroupMultiSelectPrompt({
 		options: opts.options,
 		initialValues: opts.initialValues,
+		cursorAt: opts.cursorAt,
 		required,
 		selectableGroups: true,
+		signal: opts.signal,
+		input: opts.input,
+		output: opts.output,
 		validate(selected) {
 			if (required && (selected === void 0 || selected.length === 0)) return `Please select at least one option.\n${pc.reset(pc.dim(`Press ${pc.gray(pc.bgWhite(pc.inverse(" space ")))} to select, ${pc.gray(pc.bgWhite(pc.inverse(" enter ")))} to submit`))}`;
 			return normalizeValidationMessage(opts.validate?.(selected));
 		},
 		render() {
-			const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
 			const value = this.value ?? [];
+			const styleOption = (option, active) => {
+				const selected = value.includes(option.value) || option.group === true && this.isGroupSelected(`${option.value}`);
+				if (!active && typeof option.group === "string" && this.options[this.cursor]?.value === option.group) return opt(option, selected ? "group-active-selected" : "group-active", this.options);
+				if (active && selected) return opt(option, "active-selected", this.options);
+				if (selected) return opt(option, "selected", this.options);
+				return opt(option, active ? "active" : "inactive", this.options);
+			};
 			switch (this.state) {
 				case "submit": {
-					const selectedOptions = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "submitted"));
-					const optionsText = selectedOptions.length === 0 ? "" : `  ${selectedOptions.join(pc.dim(", "))}`;
-					return `${title}${pc.gray(S_BAR)}${optionsText}`;
+					const optionsText = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "submitted")).join(pc.dim(", ")) || pc.dim("none");
+					return resolvedPrompt(opts.message, optionsText, "submit");
 				}
 				case "cancel": {
-					const label = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "cancelled")).join(pc.dim(", "));
-					return `${title}${pc.gray(S_BAR)}  ${label.trim() ? `${label}\n${pc.gray(S_BAR)}` : ""}`;
+					const label = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "cancelled")).join(pc.dim(", ")) || pc.dim("none");
+					return canceledPrompt(this, opts.message, label);
 				}
 				case "error": {
 					const footer = this.error.split("\n").map((ln, i) => i === 0 ? `${pc.yellow(S_BAR_END)}  ${pc.yellow(ln)}` : `   ${ln}`).join("\n");
-					const optionsText = this.options.map((option, i, options) => {
-						const selected = value.includes(option.value) || option.group === true && this.isGroupSelected(`${option.value}`);
-						const active = i === this.cursor;
-						if (!active && typeof option.group === "string" && this.options[this.cursor].value === option.group) return opt(option, selected ? "group-active-selected" : "group-active", options);
-						if (active && selected) return opt(option, "active-selected", options);
-						if (selected) return opt(option, "selected", options);
-						return opt(option, active ? "active" : "inactive", options);
+					const optionsText = limitOptions({
+						output: opts.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: opts.maxItems,
+						columnPadding: 3,
+						rowPadding: footer.split("\n").length + 4,
+						style: styleOption
 					}).join(`\n${pc.yellow(S_BAR)}  `);
-					return `${title}${pc.yellow(S_BAR)}  ${optionsText}\n${footer}\n`;
+					return `${activePromptTitle(opts.message, "error")}${pc.yellow(S_BAR)}  ${optionsText}\n${footer}\n`;
 				}
 				default: {
-					const optionsText = this.options.map((option, i, options) => {
-						const selected = value.includes(option.value) || option.group === true && this.isGroupSelected(`${option.value}`);
-						const active = i === this.cursor;
-						const groupActive = !active && typeof option.group === "string" && this.options[this.cursor].value === option.group;
-						let optionText = "";
-						if (groupActive) optionText = opt(option, selected ? "group-active-selected" : "group-active", options);
-						else if (active && selected) optionText = opt(option, "active-selected", options);
-						else if (selected) optionText = opt(option, "selected", options);
-						else optionText = opt(option, active ? "active" : "inactive", options);
-						return `${i !== 0 && !optionText.startsWith("\n") ? "  " : ""}${optionText}`;
-					}).join(`\n${pc.cyan(S_BAR)}`);
-					const optionsPrefix = optionsText.startsWith("\n") ? "" : "  ";
-					const hint = `\n${pc.gray(S_BAR)}  ${getMultiHint()}`;
-					return `${title}${pc.cyan(S_BAR)}${optionsPrefix}${optionsText}\n${pc.cyan(S_BAR_END)}${hint}\n`;
+					const optionsText = limitOptions({
+						output: opts.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: opts.maxItems,
+						columnPadding: 3,
+						rowPadding: 5,
+						style: styleOption
+					}).join(`\n${pc.cyan(S_BAR)}  `);
+					const hint = `${pc.gray(S_BAR_END)}  ${getMultiHint()}`;
+					return `${activePromptTitle(opts.message)}${pc.cyan(S_BAR)}  ${optionsText}\n${hint}\n`;
 				}
 			}
 		}
@@ -1372,7 +1582,7 @@ async function getAddonsChoice(addons, frontends, auth, backend, runtime, previo
 	}
 	sortAndPruneGroupedOptions(groupedOptions);
 	const response = await navigableGroupMultiselect({
-		message: "Select addons",
+		message: "Pick addons",
 		options: groupedOptions,
 		initialValues: (previousValue ?? DEFAULT_CONFIG.addons).filter((addonValue) => Object.values(groupedOptions).some((options) => options.some((opt) => opt.value === addonValue))),
 		required: false,
@@ -1491,15 +1701,37 @@ const evlogWebFrontends = [
 	"tanstack-start",
 	"astro"
 ];
+const NODE_DEV_FS_DRAIN_EXPRESSION = "process.env.NODE_ENV === \"production\" ? undefined : createFsDrain()";
+const SVELTE_DEV_FS_DRAIN_EXPRESSION = "dev ? createFsDrain() : undefined";
+const ASTRO_DEV_FS_DRAIN_EXPRESSION = "import.meta.env.DEV ? createFsDrain() : undefined";
 function isEvlogBackend(backend) {
 	return evlogBackends.includes(backend);
 }
 function getEvlogWebFrontend(frontends) {
 	return frontends.find((frontend) => evlogWebFrontends.includes(frontend));
 }
+function shouldWireEvlogServerFsDrain(config) {
+	return isEvlogBackend(config.backend) && config.runtime !== "workers" && config.serverDeploy !== "cloudflare";
+}
+function shouldWireEvlogWebFsDrain(config) {
+	return getEvlogWebFrontend(config.frontend) !== void 0 && config.webDeploy !== "cloudflare";
+}
+function supportsEvlogLocalLogs(config) {
+	return shouldWireEvlogServerFsDrain(config) || shouldWireEvlogWebFsDrain(config);
+}
 function shouldIdentifyWebAuth(config) {
 	return config.auth === "better-auth" && config.backend === "self";
 }
+function getEvlogServerMiddlewareMarker(backend, fsDrain) {
+	const options = fsDrain ? `{ drain: ${NODE_DEV_FS_DRAIN_EXPRESSION} }` : "";
+	if (backend === "hono" || backend === "express") return `app.use(evlog(${options}));`;
+	if (backend === "fastify") return `fastify.register(evlog${options ? `, ${options}` : ""});`;
+	return `.use(evlog(${options}))`;
+}
+function findEvlogServerMiddlewareMarker(content, backend) {
+	const fsDrainMarker = getEvlogServerMiddlewareMarker(backend, true);
+	return content.includes(fsDrainMarker) ? fsDrainMarker : getEvlogServerMiddlewareMarker(backend, false);
+}
 function prependMissingImports(content, imports) {
 	const missingImports = imports.filter((line) => !content.includes(line));
 	if (missingImports.length === 0) return content;
@@ -1561,46 +1793,72 @@ function addEvlogBetterAuthServerSetup(content, backend, authExpression) {
 	const identifySnippet = usesAuthFactory ? "" : `const identifyUser = createAuthMiddleware(${evlogAuthExpression}, ${authOptions});\n\n`;
 	const identifyUserSetup = usesAuthFactory ? `\n\tconst identifyUser = createAuthMiddleware(${evlogAuthExpression}, ${authOptions});` : "";
 	if (backend === "hono") {
+		const evlogMarker = findEvlogServerMiddlewareMarker(nextContent, backend);
 		nextContent = insertBeforeOnce(nextContent, "const app = new Hono", identifySnippet, "createAuthMiddleware(");
-		return insertAfterOnce(nextContent, "app.use(evlog());", `\napp.use("*", async (c, next) => {${identifyUserSetup}\n\tawait identifyUser(c.get("log"), c.req.raw.headers, c.req.path);\n\tawait next();\n});`, "identifyUser(c.get(\"log\")");
+		return insertAfterOnce(nextContent, evlogMarker, `\napp.use("*", async (c, next) => {${identifyUserSetup}\n\tawait identifyUser(c.get("log"), c.req.raw.headers, c.req.path);\n\tawait next();\n});`, "identifyUser(c.get(\"log\")");
 	}
 	if (backend === "express") {
+		const evlogMarker = findEvlogServerMiddlewareMarker(nextContent, backend);
 		nextContent = addNamedImport(nextContent, "evlog/express", ["useLogger"]);
 		nextContent = insertBeforeOnce(nextContent, "const app = express();", identifySnippet, "createAuthMiddleware(");
-		return insertAfterOnce(nextContent, "app.use(evlog());", `\napp.use(async (req, _res, next) => {${identifyUserSetup}\n\tawait identifyUser(useLogger(), req.headers, req.path);\n\tnext();\n});`, "identifyUser(useLogger()");
+		return insertAfterOnce(nextContent, evlogMarker, `\napp.use(async (req, _res, next) => {${identifyUserSetup}\n\tawait identifyUser(useLogger(), req.headers, req.path);\n\tnext();\n});`, "identifyUser(useLogger()");
 	}
 	if (backend === "fastify") {
+		const evlogMarker = findEvlogServerMiddlewareMarker(nextContent, backend);
 		nextContent = addNamedImport(nextContent, "evlog/fastify", ["useLogger"]);
 		nextContent = insertBeforeOnce(nextContent, "const fastify = Fastify", identifySnippet, "createAuthMiddleware(");
-		return insertAfterOnce(nextContent, "fastify.register(evlog);", `\nfastify.addHook("preHandler", async (request) => {${identifyUserSetup}\n\tawait identifyUser(useLogger(), request.headers, request.url);\n});`, "identifyUser(useLogger()");
+		return insertAfterOnce(nextContent, evlogMarker, `\nfastify.addHook("preHandler", async (request) => {${identifyUserSetup}\n\tawait identifyUser(useLogger(), request.headers, request.url);\n});`, "identifyUser(useLogger()");
 	}
 	const elysiaMarker = nextContent.includes("const app = new Elysia") ? "const app = new Elysia" : "new Elysia";
 	nextContent = insertBeforeOnce(nextContent, elysiaMarker, identifySnippet, "createAuthMiddleware(");
-	return insertAfterOnce(nextContent, ".use(evlog())", `\n\t.derive(async ({ request, log }) => {${identifyUserSetup.replace(/\n\t/g, "\n		")}\n\t\tawait identifyUser(log, request.headers, new URL(request.url).pathname);\n\t\treturn {};\n\t})`, "identifyUser(log");
+	const evlogMarker = findEvlogServerMiddlewareMarker(nextContent, backend);
+	return insertAfterOnce(nextContent, evlogMarker, `\n\t.derive(async ({ request, log }) => {${identifyUserSetup.replace(/\n\t/g, "\n		")}\n\t\tawait identifyUser(log, request.headers, new URL(request.url).pathname);\n\t\treturn {};\n\t})`, "identifyUser(log");
 }
-function addEvlogServerSetup(content, backend, serviceName) {
+function addEvlogServerSetup(content, backend, serviceName, fsDrain) {
 	const initSnippet = `initLogger({\n\tenv: { service: "${serviceName}" },\n});\n\n`;
+	const evlogMarker = getEvlogServerMiddlewareMarker(backend, fsDrain);
+	const legacyEvlogMarker = getEvlogServerMiddlewareMarker(backend, false);
 	if (backend === "hono") {
-		let nextContent = prependMissingImports(content, ["import { initLogger } from \"evlog\";", "import { evlog, type EvlogVariables } from \"evlog/hono\";"]);
+		let nextContent = prependMissingImports(content, [
+			"import { initLogger } from \"evlog\";",
+			"import { evlog, type EvlogVariables } from \"evlog/hono\";",
+			...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []
+		]);
 		nextContent = insertBeforeOnce(nextContent, "const app = new Hono", initSnippet, "initLogger({");
 		nextContent = nextContent.replace("const app = new Hono();", "const app = new Hono<EvlogVariables>();");
 		nextContent = nextContent.replace("import { logger } from \"hono/logger\";\n", "").replace(/\napp\.use\(logger\(\)\);/, "");
-		return insertAfterOnce(nextContent, "const app = new Hono<EvlogVariables>();", "\n\napp.use(evlog());", "app.use(evlog());");
+		if (fsDrain) nextContent = nextContent.replace(legacyEvlogMarker, evlogMarker);
+		return insertAfterOnce(nextContent, "const app = new Hono<EvlogVariables>();", `\n\n${evlogMarker}`, evlogMarker);
 	}
 	if (backend === "express") {
-		let nextContent = prependMissingImports(content, ["import { initLogger } from \"evlog\";", "import { evlog } from \"evlog/express\";"]);
+		let nextContent = prependMissingImports(content, [
+			"import { initLogger } from \"evlog\";",
+			"import { evlog } from \"evlog/express\";",
+			...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []
+		]);
 		nextContent = insertBeforeOnce(nextContent, "const app = express();", initSnippet, "initLogger({");
-		return insertAfterOnce(nextContent, "const app = express();", "\n\napp.use(evlog());", "app.use(evlog());");
+		if (fsDrain) nextContent = nextContent.replace(legacyEvlogMarker, evlogMarker);
+		return insertAfterOnce(nextContent, "const app = express();", `\n\n${evlogMarker}`, evlogMarker);
 	}
 	if (backend === "fastify") {
-		let nextContent = prependMissingImports(content, ["import { initLogger } from \"evlog\";", "import { evlog } from \"evlog/fastify\";"]);
+		let nextContent = prependMissingImports(content, [
+			"import { initLogger } from \"evlog\";",
+			"import { evlog } from \"evlog/fastify\";",
+			...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []
+		]);
 		nextContent = insertBeforeOnce(nextContent, "const fastify = Fastify", initSnippet, "initLogger({");
-		return insertBeforeOnce(nextContent, "fastify.register(fastifyCors", "fastify.register(evlog);\n", "fastify.register(evlog);");
+		if (fsDrain) nextContent = nextContent.replace(legacyEvlogMarker, evlogMarker);
+		return insertBeforeOnce(nextContent, "fastify.register(fastifyCors", `${evlogMarker}\n`, evlogMarker);
 	}
-	let nextContent = prependMissingImports(content, ["import { initLogger } from \"evlog\";", "import { evlog } from \"evlog/elysia\";"]);
+	let nextContent = prependMissingImports(content, [
+		"import { initLogger } from \"evlog\";",
+		"import { evlog } from \"evlog/elysia\";",
+		...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []
+	]);
 	const elysiaMarker = nextContent.includes("const app = new Elysia") ? "const app = new Elysia" : "new Elysia";
 	nextContent = insertBeforeOnce(nextContent, elysiaMarker, initSnippet, "initLogger({");
-	for (const marker of ["new Elysia({ adapter: node() })", "new Elysia()"]) nextContent = insertAfterOnce(nextContent, marker, "\n	.use(evlog())", ".use(evlog())");
+	if (fsDrain) nextContent = nextContent.replace(legacyEvlogMarker, evlogMarker);
+	for (const marker of ["new Elysia({ adapter: node() })", "new Elysia()"]) nextContent = insertAfterOnce(nextContent, marker, `\n\t${evlogMarker}`, evlogMarker);
 	return nextContent;
 }
 function addNuxtEvlogSetup(content, serviceName) {
@@ -1617,14 +1875,20 @@ function addSvelteViteEvlogSetup(content, serviceName) {
 	if (nextContent.includes("evlog({")) return nextContent;
 	return nextContent.replace("plugins: [tailwindcss(), sveltekit()],", `plugins: [\n    tailwindcss(),\n    sveltekit(),\n    evlog({ service: "${serviceName}" }),\n  ],`);
 }
-function addSvelteHooksEvlogSetup(content) {
-	let nextContent = prependMissingImports(content, ["import { createEvlogHooks } from \"evlog/sveltekit\";"]);
+function getSvelteEvlogHooksCall(fsDrain) {
+	return fsDrain ? `createEvlogHooks({ drain: ${SVELTE_DEV_FS_DRAIN_EXPRESSION} })` : "createEvlogHooks()";
+}
+function addSvelteHooksEvlogSetup(content, fsDrain) {
+	let nextContent = prependMissingImports(content, ["import { createEvlogHooks } from \"evlog/sveltekit\";", ...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []]);
+	if (fsDrain) nextContent = addNamedImport(nextContent, "$app/environment", ["dev"]);
+	const hooksCall = getSvelteEvlogHooksCall(fsDrain);
+	if (fsDrain) nextContent = nextContent.replaceAll("createEvlogHooks()", hooksCall);
 	if (!nextContent.includes("export const handle") && !nextContent.includes("const authHandle")) {
-		if (!nextContent.includes("createEvlogHooks()")) nextContent = `${nextContent.trimEnd()}\n\nexport const { handle, handleError } = createEvlogHooks();\n`;
+		if (!nextContent.includes("createEvlogHooks(")) nextContent = `${nextContent.trimEnd()}\n\nexport const { handle, handleError } = ${hooksCall};\n`;
 		return nextContent;
 	}
 	nextContent = prependMissingImports(nextContent, ["import { sequence } from \"@sveltejs/kit/hooks\";"]);
-	if (!nextContent.includes("const { handle: evlogHandle, handleError }")) nextContent = nextContent.replace(/((?:import .+\n)+)/, `$1\nconst { handle: evlogHandle, handleError } = createEvlogHooks();\n\n`);
+	if (!nextContent.includes("const { handle: evlogHandle, handleError }")) nextContent = nextContent.replace(/((?:import .+\n)+)/, `$1\nconst { handle: evlogHandle, handleError } = ${hooksCall};\n\n`);
 	nextContent = nextContent.replace(/export const handle(:\s*Handle)?\s*=\s*async/, (_match, typeAnnotation) => `const authHandle${typeAnnotation ?? ""} = async`);
 	if (!nextContent.includes("sequence(evlogHandle, authHandle)")) nextContent = `${nextContent.trimEnd()}\n\nexport const handle = sequence(evlogHandle as Handle, authHandle);\nexport { handleError };\n`;
 	return nextContent;
@@ -1643,10 +1907,14 @@ function addTanstackStartRootEvlogSetup(content) {
 	if (/server:\s*{/.test(nextContent)) return nextContent.replace(/server:\s*{\n/, `server: {\n    middleware: [${middlewareEntry}],\n`);
 	return nextContent.replace("head: () => ({", `server: {\n    middleware: [${middlewareEntry}],\n  },\n\n  head: () => ({`);
 }
-function addAstroMiddlewareEvlogSetup(content, serviceName) {
-	let nextContent = prependMissingImports(content, ["import { createRequestLogger, initLogger } from \"evlog\";"]);
-	const initSnippet = `initLogger({\n  env: { service: "${serviceName}" },\n});\n\n`;
+function getInitLoggerSnippet(serviceName, fsDrain, indent) {
+	return `initLogger({\n${indent}env: { service: "${serviceName}" },${fsDrain ? `\n${indent}drain: ${ASTRO_DEV_FS_DRAIN_EXPRESSION},` : ""}\n});\n\n`;
+}
+function addAstroMiddlewareEvlogSetup(content, serviceName, fsDrain) {
+	let nextContent = prependMissingImports(content, ["import { createRequestLogger, initLogger } from \"evlog\";", ...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []]);
+	const initSnippet = getInitLoggerSnippet(serviceName, fsDrain, "  ");
 	nextContent = insertBeforeOnce(nextContent, "export const onRequest", initSnippet, "initLogger({");
+	if (fsDrain && !nextContent.includes("drain:")) nextContent = nextContent.replace(/initLogger\(\{\n(\s+env: \{ service: "[^"]+" \},)/, `initLogger({\n$1\n  drain: ${ASTRO_DEV_FS_DRAIN_EXPRESSION},`);
 	if (nextContent.includes("createRequestLogger({")) return nextContent;
 	const contextMarker = "export const onRequest = defineMiddleware(async (context, next) => {";
 	if (nextContent.includes(contextMarker)) {
@@ -1721,7 +1989,8 @@ function addSvelteBetterAuthEvlogSetup(content, config) {
 	const authExpression = getAuthExpression(config);
 	const authOptions = "{ exclude: [\"/api/auth/**\"], maskEmail: true }";
 	const authHandleSnippet = usesCreateAuthFactory(config) && config.webDeploy === "cloudflare" ? `const evlogAuthHandle: Handle = async ({ event, resolve }) => {\n\tif (building) {\n\t\treturn resolve(event);\n\t}\n\n\tconst authEnv = event.platform?.env ?? localEnv;\n\tconst identifyUser = createAuthMiddleware(createAuth(authEnv) as BetterAuthInstance, ${authOptions});\n\tawait identifyUser(event.locals.log, event.request.headers, event.url.pathname);\n\treturn resolve(event);\n};\n\n` : `const identifyUser = createAuthMiddleware(${authExpression} as BetterAuthInstance, ${authOptions});\n\nconst evlogAuthHandle: Handle = async ({ event, resolve }) => {\n\tawait identifyUser(event.locals.log, event.request.headers, event.url.pathname);\n\treturn resolve(event);\n};\n\n`;
-	nextContent = insertAfterOnce(nextContent, "const { handle: evlogHandle, handleError } = createEvlogHooks();\n\n", authHandleSnippet, "evlogAuthHandle");
+	const evlogHandleDeclaration = nextContent.match(/const \{ handle: evlogHandle, handleError \} = createEvlogHooks\([\s\S]*?\);\n\n/)?.[0];
+	if (evlogHandleDeclaration) nextContent = insertAfterOnce(nextContent, evlogHandleDeclaration, authHandleSnippet, "evlogAuthHandle");
 	return nextContent.replace("sequence(evlogHandle as Handle, authHandle)", "sequence(evlogHandle as Handle, evlogAuthHandle, authHandle)").replace("sequence(evlogHandle, authHandle)", "sequence(evlogHandle as Handle, evlogAuthHandle, authHandle)");
 }
 function addAstroBetterAuthEvlogSetup(content, config) {
@@ -1740,19 +2009,29 @@ function addAstroBetterAuthEvlogSetup(content, config) {
 	}
 	return nextContent;
 }
-function getNextEvlogFile(serviceName) {
+function getNextEvlogFile(serviceName, fsDrain) {
 	return `import { createEvlog } from "evlog/next";
 import { createInstrumentation } from "evlog/next/instrumentation/create";
+${fsDrain ? "import { createFsDrain } from \"evlog/fs\";\n" : ""}
 
 export const { withEvlog, useLogger, log, createError } = createEvlog({
   service: "${serviceName}",
-});
+${fsDrain ? `  drain: ${NODE_DEV_FS_DRAIN_EXPRESSION},\n` : ""}});
 
 export const { register, onRequestError } = createInstrumentation({
   service: "${serviceName}",
 });
 `;
 }
+function getNitroEvlogDrainFile() {
+	return `import { createFsDrain } from "evlog/fs";
+
+export default defineNitroPlugin((nitroApp) => {
+  if (!import.meta.dev) return;
+  nitroApp.hooks.hook("evlog:drain", createFsDrain());
+});
+`;
+}
 function getNextInstrumentationFile() {
 	return `import { defineNodeInstrumentation } from "evlog/next/instrumentation";
 
@@ -1867,13 +2146,12 @@ export default defineConfig({
 });
 `;
 }
-function getAstroMiddlewareFile(serviceName) {
+function getAstroMiddlewareFile(serviceName, fsDrain) {
 	return `import { defineMiddleware } from "astro:middleware";
 import { createRequestLogger, initLogger } from "evlog";
+${fsDrain ? "import { createFsDrain } from \"evlog/fs\";\n" : ""}
 
-initLogger({
-  env: { service: "${serviceName}" },
-});
+${getInitLoggerSnippet(serviceName, fsDrain, "  ").trimEnd()}
 
 export const onRequest = defineMiddleware(async ({ request, locals }, next) => {
   const url = new URL(request.url);
@@ -1910,8 +2188,9 @@ declare namespace App {
 }
 async function setupNextEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
+	const fsDrain = shouldWireEvlogWebFsDrain(config);
 	const evlogPath = path.join(webDir, "src/lib/evlog.ts");
-	if (!await fs.pathExists(evlogPath)) await writeFileIfChanged(evlogPath, getNextEvlogFile(serviceName));
+	if (!await fs.pathExists(evlogPath)) await writeFileIfChanged(evlogPath, getNextEvlogFile(serviceName, fsDrain));
 	const identifyWebAuth = shouldIdentifyWebAuth(config);
 	if (identifyWebAuth) {
 		const evlogAuthPath = path.join(webDir, "src/lib/evlog-auth.ts");
@@ -1937,7 +2216,12 @@ async function setupNextEvlog(config, serviceName) {
 }
 async function setupNuxtEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
+	const fsDrain = shouldWireEvlogWebFsDrain(config);
 	await updateFileIfExists(path.join(webDir, "nuxt.config.ts"), (content) => addNuxtEvlogSetup(content, serviceName));
+	if (fsDrain) {
+		const drainPath = path.join(webDir, "server/plugins/evlog-drain.ts");
+		if (!await fs.pathExists(drainPath)) await writeFileIfChanged(drainPath, getNitroEvlogDrainFile());
+	}
 	if (shouldIdentifyWebAuth(config)) {
 		const oldAuthPluginPath = path.join(webDir, "server/plugins/evlog-auth.ts");
 		if (await fs.pathExists(oldAuthPluginPath)) {
@@ -1950,12 +2234,15 @@ async function setupNuxtEvlog(config, serviceName) {
 }
 async function setupSvelteEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
+	const fsDrain = shouldWireEvlogWebFsDrain(config);
 	await updateFileIfExists(path.join(webDir, "vite.config.ts"), (content) => addSvelteViteEvlogSetup(content, serviceName));
 	const hooksPath = path.join(webDir, "src/hooks.server.ts");
-	if (await fs.pathExists(hooksPath)) await updateFileIfExists(hooksPath, addSvelteHooksEvlogSetup);
+	if (await fs.pathExists(hooksPath)) await updateFileIfExists(hooksPath, (content) => addSvelteHooksEvlogSetup(content, fsDrain));
 	else await writeFileIfChanged(hooksPath, `import { createEvlogHooks } from "evlog/sveltekit";
+${fsDrain ? "import { createFsDrain } from \"evlog/fs\";\n" : ""}
+${fsDrain ? "import { dev } from \"$app/environment\";\n" : ""}
 
-export const { handle, handleError } = createEvlogHooks();
+export const { handle, handleError } = ${getSvelteEvlogHooksCall(fsDrain)};
 `);
 	await updateFileIfExists(path.join(webDir, "src/app.d.ts"), addSvelteLocalsType);
 	if (shouldIdentifyWebAuth(config)) await updateFileIfExists(path.join(webDir, "src/hooks.server.ts"), (content) => addSvelteBetterAuthEvlogSetup(content, config));
@@ -1963,9 +2250,14 @@ export const { handle, handleError } = createEvlogHooks();
 }
 async function setupTanstackStartEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
+	const fsDrain = shouldWireEvlogWebFsDrain(config);
 	const nitroConfigPath = path.join(webDir, "nitro.config.ts");
 	if (!await fs.pathExists(nitroConfigPath)) await writeFileIfChanged(nitroConfigPath, getTanstackNitroConfigFile(serviceName));
 	await updateFileIfExists(path.join(webDir, "src/routes/__root.tsx"), addTanstackStartRootEvlogSetup);
+	if (fsDrain) {
+		const drainPath = path.join(webDir, "server/plugins/evlog-drain.ts");
+		if (!await fs.pathExists(drainPath)) await writeFileIfChanged(drainPath, getNitroEvlogDrainFile());
+	}
 	if (shouldIdentifyWebAuth(config)) {
 		const authPluginPath = path.join(webDir, "server/plugins/evlog-auth.ts");
 		if (!await fs.pathExists(authPluginPath)) await writeFileIfChanged(authPluginPath, getNitroEvlogAuthPluginFile(config));
@@ -1974,9 +2266,10 @@ async function setupTanstackStartEvlog(config, serviceName) {
 }
 async function setupAstroEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
+	const fsDrain = shouldWireEvlogWebFsDrain(config);
 	const middlewarePath = path.join(webDir, "src/middleware.ts");
-	if (!await fs.pathExists(middlewarePath)) await writeFileIfChanged(middlewarePath, getAstroMiddlewareFile(serviceName));
-	else await updateFileIfExists(middlewarePath, (content) => addAstroMiddlewareEvlogSetup(content, serviceName));
+	if (!await fs.pathExists(middlewarePath)) await writeFileIfChanged(middlewarePath, getAstroMiddlewareFile(serviceName, fsDrain));
+	else await updateFileIfExists(middlewarePath, (content) => addAstroMiddlewareEvlogSetup(content, serviceName, fsDrain));
 	const envPath = path.join(webDir, "src/env.d.ts");
 	if (!await fs.pathExists(envPath)) await writeFileIfChanged(envPath, getAstroEnvFile());
 	else await updateFileIfExists(envPath, addAstroLocalsType);
@@ -1999,7 +2292,7 @@ async function setupEvlog(config) {
 				const serverIndexPath = path.join(config.projectDir, "apps/server/src/index.ts");
 				if (await fs.pathExists(serverIndexPath)) {
 					const content = await fs.readFile(serverIndexPath, "utf-8");
-					let nextContent = addEvlogServerSetup(content, config.backend, `${config.projectName}-server`);
+					let nextContent = addEvlogServerSetup(content, config.backend, `${config.projectName}-server`, shouldWireEvlogServerFsDrain(config));
 					if (config.auth === "better-auth") nextContent = addEvlogBetterAuthServerSetup(nextContent, config.backend, getAuthExpression(config));
 					if (config.examples.includes("ai")) nextContent = addBackendAiEvlogSetup(nextContent, config.backend);
 					if (nextContent !== content) await fs.writeFile(serverIndexPath, nextContent);
@@ -2037,45 +2330,56 @@ async function navigableGroup(prompts, opts) {
 		delete results[prevName];
 		currentIndex--;
 	};
-	while (currentIndex < promptNames.length) {
-		const name = promptNames[currentIndex];
-		const prompt = prompts[name];
-		setIsFirstPrompt$1(currentIndex === 0);
-		setLastPromptShownUI(false);
-		const result = await prompt({
-			results,
-			previousAnswer: previousAnswers[name]
-		})?.catch((e) => {
-			throw e;
-		});
-		if (isGoBack(result)) {
-			goingBack = true;
-			if (currentIndex > 0) {
-				stepBack();
+	try {
+		while (currentIndex < promptNames.length) {
+			const name = promptNames[currentIndex];
+			const prompt = prompts[name];
+			const section = opts?.sections?.find(({ prompts: sectionPrompts }) => sectionPrompts.includes(name));
+			const sectionPromptIndex = section?.prompts.indexOf(name) ?? -1;
+			setPromptProgress({
+				current: currentIndex + 1,
+				total: promptNames.length,
+				section: section?.label ?? "Setup",
+				sectionCurrent: sectionPromptIndex + 1,
+				sectionTotal: section?.prompts.length ?? promptNames.length
+			});
+			setIsFirstPrompt$1(currentIndex === 0);
+			setLastPromptShownUI(false);
+			const presetResult = opts?.preselected?.[name];
+			const result = presetResult !== void 0 ? presetResult : await prompt({
+				results,
+				previousAnswer: previousAnswers[name]
+			});
+			if (isGoBack(result)) {
+				goingBack = true;
+				if (currentIndex > 0) {
+					stepBack();
+					continue;
+				}
+				goingBack = false;
 				continue;
 			}
-			goingBack = false;
-			continue;
-		}
-		if (isCancel$1(result)) {
-			if (typeof opts?.onCancel === "function") {
-				results[name] = "canceled";
-				opts.onCancel({ results });
+			if (isCancel$1(result)) {
+				if (typeof opts?.onCancel === "function") {
+					results[name] = "canceled";
+					opts.onCancel({ results });
+				}
+				return results;
 			}
-			setIsFirstPrompt$1(false);
-			return results;
-		}
-		if (goingBack && !didLastPromptShowUI()) {
-			if (currentIndex > 0) {
-				stepBack();
-				continue;
+			if (goingBack && !didLastPromptShowUI()) {
+				if (currentIndex > 0) {
+					stepBack();
+					continue;
+				}
 			}
+			goingBack = false;
+			results[name] = result;
+			currentIndex++;
 		}
-		goingBack = false;
-		results[name] = result;
-		currentIndex++;
+	} finally {
+		setIsFirstPrompt$1(false);
+		setPromptProgress(void 0);
 	}
-	setIsFirstPrompt$1(false);
 	return results;
 }
 //#endregion
@@ -2210,6 +2514,10 @@ const TEMPLATES$2 = {
 		label: "Tanstack Start SPA: Fumadocs MDX (not RSC)",
 		hint: "SPA mode allows you to host the site statically, compatible with a CDN.",
 		value: "tanstack-start-spa"
+	},
+	astro: {
+		label: "Astro: Fumadocs MDX",
+		value: "astro"
 	}
 };
 const DEFAULT_TEMPLATE$2 = "next-mdx";
@@ -2223,7 +2531,7 @@ function getFumadocsLinter(addons) {
 	if (addons.includes("vite-plus")) return "oxlint";
 }
 function getFumadocsAddonContext(currentAddons, persistedAddons) {
-	return Array.from(new Set([...persistedAddons ?? [], ...currentAddons]));
+	return Array.from(/* @__PURE__ */ new Set([...persistedAddons ?? [], ...currentAddons]));
 }
 async function setupFumadocs(config) {
 	if (shouldSkipExternalCommands()) return Result.ok(void 0);
@@ -2425,6 +2733,11 @@ const MCP_AGENTS = [
 		label: "GitHub Copilot CLI",
 		scope: "both"
 	},
+	{
+		value: "grok-build",
+		label: "Grok Build",
+		scope: "both"
+	},
 	{
 		value: "mcporter",
 		label: "MCPorter",
@@ -2435,6 +2748,11 @@ const MCP_AGENTS = [
 		label: "VS Code (GitHub Copilot)",
 		scope: "both"
 	},
+	{
+		value: "windsurf",
+		label: "Windsurf",
+		scope: "global"
+	},
 	{
 		value: "zed",
 		label: "Zed",
@@ -2808,10 +3126,42 @@ const SKILL_SOURCES = {
 	"haydenbleasel/ultracite": { label: "Ultracite" },
 	"https://www.evlog.dev": { label: "evlog" }
 };
-const AVAILABLE_AGENTS = [
+const SKILLS_CLI_AGENT_OPTIONS = [
 	{
-		value: "cursor",
-		label: "Cursor"
+		value: "adal",
+		label: "AdaL"
+	},
+	{
+		value: "aider-desk",
+		label: "AiderDesk"
+	},
+	{
+		value: "amp",
+		label: "Amp"
+	},
+	{
+		value: "antigravity",
+		label: "Antigravity"
+	},
+	{
+		value: "antigravity-cli",
+		label: "Antigravity CLI"
+	},
+	{
+		value: "astrbot",
+		label: "AstrBot"
+	},
+	{
+		value: "augment",
+		label: "Augment"
+	},
+	{
+		value: "autohand-code",
+		label: "Autohand Code CLI"
+	},
+	{
+		value: "bob",
+		label: "IBM Bob"
 	},
 	{
 		value: "claude-code",
@@ -2822,100 +3172,306 @@ const AVAILABLE_AGENTS = [
 		label: "Cline"
 	},
 	{
-		value: "github-copilot",
-		label: "GitHub Copilot"
+		value: "codearts-agent",
+		label: "CodeArts Agent"
+	},
+	{
+		value: "codebuddy",
+		label: "CodeBuddy"
+	},
+	{
+		value: "codemaker",
+		label: "Codemaker"
+	},
+	{
+		value: "codestudio",
+		label: "Code Studio"
 	},
 	{
 		value: "codex",
 		label: "Codex"
 	},
 	{
-		value: "opencode",
-		label: "OpenCode"
+		value: "command-code",
+		label: "Command Code"
 	},
 	{
-		value: "windsurf",
-		label: "Windsurf"
+		value: "continue",
+		label: "Continue"
+	},
+	{
+		value: "cortex",
+		label: "Cortex Code"
+	},
+	{
+		value: "crush",
+		label: "Crush"
+	},
+	{
+		value: "cursor",
+		label: "Cursor"
+	},
+	{
+		value: "deepagents",
+		label: "Deep Agents"
+	},
+	{
+		value: "devin",
+		label: "Devin for Terminal"
+	},
+	{
+		value: "dexto",
+		label: "Dexto"
+	},
+	{
+		value: "droid",
+		label: "Droid"
+	},
+	{
+		value: "eve",
+		label: "Eve"
+	},
+	{
+		value: "firebender",
+		label: "Firebender"
+	},
+	{
+		value: "forgecode",
+		label: "ForgeCode"
+	},
+	{
+		value: "gemini-cli",
+		label: "Gemini CLI"
+	},
+	{
+		value: "github-copilot",
+		label: "GitHub Copilot"
 	},
 	{
 		value: "goose",
 		label: "Goose"
 	},
 	{
-		value: "roo",
-		label: "Roo Code"
+		value: "grok",
+		label: "Grok Build"
+	},
+	{
+		value: "hermes-agent",
+		label: "Hermes Agent"
+	},
+	{
+		value: "iflow-cli",
+		label: "iFlow CLI"
+	},
+	{
+		value: "inference-sh",
+		label: "inference.sh"
+	},
+	{
+		value: "jazz",
+		label: "Jazz"
+	},
+	{
+		value: "junie",
+		label: "Junie"
 	},
 	{
 		value: "kilo",
 		label: "Kilo Code"
 	},
 	{
-		value: "gemini-cli",
-		label: "Gemini CLI"
+		value: "kimchi",
+		label: "Kimchi"
 	},
 	{
-		value: "antigravity",
-		label: "Antigravity"
+		value: "kimi-code-cli",
+		label: "Kimi Code CLI"
 	},
 	{
-		value: "openhands",
-		label: "OpenHands"
+		value: "kiro-cli",
+		label: "Kiro CLI"
 	},
 	{
-		value: "trae",
-		label: "Trae"
+		value: "kode",
+		label: "Kode"
 	},
 	{
-		value: "amp",
-		label: "Amp"
+		value: "lingma",
+		label: "Lingma"
+	},
+	{
+		value: "loaf",
+		label: "Loaf"
+	},
+	{
+		value: "mcpjam",
+		label: "MCPJam"
+	},
+	{
+		value: "mistral-vibe",
+		label: "Mistral Vibe"
+	},
+	{
+		value: "moxby",
+		label: "Moxby"
+	},
+	{
+		value: "mux",
+		label: "Mux"
+	},
+	{
+		value: "neovate",
+		label: "Neovate"
+	},
+	{
+		value: "ona",
+		label: "Ona"
+	},
+	{
+		value: "openclaw",
+		label: "OpenClaw"
+	},
+	{
+		value: "opencode",
+		label: "OpenCode"
+	},
+	{
+		value: "openhands",
+		label: "OpenHands"
 	},
 	{
 		value: "pi",
 		label: "Pi"
 	},
+	{
+		value: "pochi",
+		label: "Pochi"
+	},
+	{
+		value: "promptscript",
+		label: "PromptScript"
+	},
 	{
 		value: "qoder",
 		label: "Qoder"
 	},
+	{
+		value: "qoder-cn",
+		label: "Qoder CN"
+	},
 	{
 		value: "qwen-code",
 		label: "Qwen Code"
 	},
 	{
-		value: "kiro-cli",
-		label: "Kiro CLI"
+		value: "reasonix",
+		label: "Reasonix"
 	},
 	{
-		value: "droid",
-		label: "Droid"
+		value: "replit",
+		label: "Replit"
 	},
 	{
-		value: "command-code",
-		label: "Command Code"
+		value: "roo",
+		label: "Roo Code"
 	},
 	{
-		value: "clawdbot",
-		label: "Clawdbot"
+		value: "rovodev",
+		label: "Rovo Dev"
 	},
 	{
-		value: "zencoder",
-		label: "Zencoder"
+		value: "tabnine-cli",
+		label: "Tabnine CLI"
 	},
 	{
-		value: "neovate",
-		label: "Neovate"
+		value: "terramind",
+		label: "Terramind"
 	},
 	{
-		value: "mcpjam",
-		label: "MCPJam"
+		value: "tinycloud",
+		label: "Tinycloud"
+	},
+	{
+		value: "trae",
+		label: "Trae"
+	},
+	{
+		value: "trae-cn",
+		label: "Trae CN"
+	},
+	{
+		value: "universal",
+		label: "Universal"
+	},
+	{
+		value: "warp",
+		label: "Warp"
+	},
+	{
+		value: "windsurf",
+		label: "Windsurf"
+	},
+	{
+		value: "zcode",
+		label: "ZCode"
+	},
+	{
+		value: "zed",
+		label: "Zed"
+	},
+	{
+		value: "zencoder",
+		label: "Zencoder"
+	},
+	{
+		value: "zenflow",
+		label: "Zenflow"
 	}
 ];
-const DEFAULT_SCOPE = "project";
-const DEFAULT_AGENTS$1 = [
+const UNIVERSAL_SKILLS_AGENTS = [
+	"amp",
+	"antigravity",
+	"antigravity-cli",
+	"cline",
+	"codex",
 	"cursor",
-	"claude-code",
-	"github-copilot"
+	"deepagents",
+	"dexto",
+	"firebender",
+	"gemini-cli",
+	"github-copilot",
+	"kimi-code-cli",
+	"loaf",
+	"opencode",
+	"promptscript",
+	"warp",
+	"zed"
 ];
+const PROMPT_HIDDEN_AGENTS = /* @__PURE__ */ new Set([
+	...UNIVERSAL_SKILLS_AGENTS,
+	"universal",
+	"eve",
+	"replit"
+]);
+const SKILLS_AGENT_PROMPT_OPTIONS = [
+	{
+		value: "universal",
+		label: "Universal (.agents/skills)",
+		hint: "17 agents including Amp, Antigravity, Cline, Codex, Cursor, Gemini CLI, Copilot, OpenCode, Warp, and Zed"
+	},
+	...SKILLS_CLI_AGENT_OPTIONS.filter(({ value }) => value === "claude-code"),
+	...SKILLS_CLI_AGENT_OPTIONS.filter(({ value }) => value !== "claude-code" && !PROMPT_HIDDEN_AGENTS.has(value))
+];
+function expandSkillsAgentTargets(agents) {
+	const expanded = agents.flatMap((agent) => {
+		if (agent === "universal") return [...UNIVERSAL_SKILLS_AGENTS];
+		if (agent === "clawdbot") return ["openclaw"];
+		return [agent];
+	});
+	return Array.from(new Set(expanded));
+}
+const DEFAULT_SCOPE = "project";
+const DEFAULT_AGENTS$1 = ["universal", "claude-code"];
 function hasReactBasedFrontend(frontend) {
 	return frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("tanstack-start") || frontend.includes("next");
 }
@@ -3017,7 +3573,11 @@ const CURATED_SKILLS_BY_SOURCE = {
 	],
 	"msmps/opentui-skill": () => ["opentui"],
 	"haydenbleasel/ultracite": () => ["ultracite"],
-	"https://www.evlog.dev": () => ["review-logging-patterns", "analyze-logs"]
+	"https://www.evlog.dev": (config) => [
+		"review-logging-patterns",
+		"build-audit-logs",
+		...supportsEvlogLocalLogs(config) ? ["analyze-logs"] : []
+	]
 };
 function getCuratedSkillNamesForSourceKey(sourceKey, config) {
 	return CURATED_SKILLS_BY_SOURCE[sourceKey](config);
@@ -3094,9 +3654,10 @@ async function setupSkills(config) {
 				if (configuredAgents !== void 0) return [...configuredAgents];
 				return navigableMultiselect({
 					message: "Select agents to install skills to",
-					options: AVAILABLE_AGENTS,
+					options: SKILLS_AGENT_PROMPT_OPTIONS,
 					required: false,
-					initialValues: [...DEFAULT_AGENTS$1]
+					initialValues: [...DEFAULT_AGENTS$1],
+					maxItems: 10
 				});
 			}
 		});
@@ -3116,6 +3677,7 @@ async function setupSkills(config) {
 	installSpinner.start("Installing skills...");
 	const runner = getPackageRunnerPrefix(packageManager);
 	const globalFlags = scope === "global" ? ["-g"] : [];
+	const agentTargets = expandSkillsAgentTargets(selectedAgents);
 	for (const [source, skills] of Object.entries(skillsBySource)) if ((await Result.tryPromise({
 		try: async () => {
 			const args = [
@@ -3127,7 +3689,7 @@ async function setupSkills(config) {
 				"--skill",
 				...skills,
 				"--agent",
-				...selectedAgents,
+				...agentTargets,
 				"-y"
 			];
 			await $({
@@ -3439,7 +4001,7 @@ const HOOKS = {
 	claude: { label: "Claude Code" },
 	copilot: { label: "GitHub Copilot" }
 };
-const ULTRACITE_VERSION = "7.9.3";
+const ULTRACITE_VERSION = "7.9.4";
 const DEFAULT_LINTER = "biome";
 const DEFAULT_EDITORS = ["vscode"];
 const DEFAULT_AGENTS = ["universal"];
@@ -3846,7 +4408,7 @@ async function installDependencies({ projectDir, packageManager }) {
 			cause: e
 		})
 	});
-	if (result.isOk()) s.stop("Dependencies installed successfully");
+	if (result.isOk()) s.stop("Dependencies installed");
 	else s.stop(pc.red("Failed to install dependencies"));
 	return result;
 }
@@ -3951,7 +4513,7 @@ async function addHandlerInternal(input) {
 	}));
 	if (!isSilent()) {
 		renderTitle();
-		intro(pc.magenta("Add addons to your Better-T-Stack project"));
+		intro(pc.magenta("Add to your project"));
 	}
 	const existingConfig = await detectProjectConfig(projectDir);
 	if (!existingConfig) return Result.err(new CLIError({ message: `No Better-T-Stack project found in ${projectDir}. Make sure bts.jsonc exists.` }));
@@ -3960,7 +4522,10 @@ async function addHandlerInternal(input) {
 	if (input.addons && input.addons.length > 0) {
 		addonsToAdd = input.addons.filter((addon) => addon !== "none" && !existingConfig.addons.includes(addon));
 		if (addonsToAdd.length === 0) {
-			if (!isSilent()) log.warn(pc.yellow("All specified addons are already installed or invalid."));
+			if (!isSilent()) {
+				log.warn(pc.yellow("Nothing to add — those addons are already installed"));
+				outro(pc.dim("Project unchanged"));
+			}
 			return Result.ok({
 				success: true,
 				addedAddons: [],
@@ -3982,10 +4547,7 @@ async function addHandlerInternal(input) {
 		if (promptResult.isErr()) return Result.err(promptResult.error);
 		const selectedAddons = promptResult.value;
 		if (selectedAddons.length === 0) {
-			if (!isSilent()) {
-				log.info(pc.dim("No addons selected."));
-				outro(pc.magenta("Nothing to add."));
-			}
+			if (!isSilent()) outro(pc.dim("Nothing selected · project unchanged"));
 			return Result.ok({
 				success: true,
 				addedAddons: [],
@@ -3997,7 +4559,7 @@ async function addHandlerInternal(input) {
 	const updatedAddons = [...existingConfig.addons, ...addonsToAdd];
 	const addonsValidationResult = validateAddonsAgainstConfig(updatedAddons, existingConfig);
 	if (addonsValidationResult.isErr()) return Result.err(new CLIError({ message: addonsValidationResult.error.message }));
-	if (!isSilent()) log.info(pc.cyan(`Adding addons: ${addonsToAdd.join(", ")}`));
+	if (!isSilent()) log.info(`${pc.dim("Adding")} ${pc.cyan(formatConfigValue(addonsToAdd))}`);
 	const mergedAddonOptions = mergeAddonOptions(existingConfig.addonOptions, input.addonOptions);
 	const config = {
 		projectName: existingConfig.projectName,
@@ -4025,7 +4587,7 @@ async function addHandlerInternal(input) {
 		...config,
 		addons: updatedAddons
 	};
-	if (!isSilent()) log.info(pc.dim("Installing addon files..."));
+	if (!isSilent()) log.info(pc.dim("Preparing addon files…"));
 	const vfs = new VirtualFileSystem();
 	for (const pkgPath of ADD_PACKAGE_JSON_PATHS) {
 		const fullPath = path.join(projectDir, pkgPath);
@@ -4057,9 +4619,9 @@ async function addHandlerInternal(input) {
 	};
 	if (input.dryRun) {
 		if (!isSilent()) {
-			log.success(pc.green("Dry run validation passed. No addon files were written."));
-			log.info(pc.dim(`Planned addon files: ${vfs.getFileCount()}`));
-			outro(pc.magenta("Dry run complete."));
+			log.success(pc.green("Dry run passed · no files written"));
+			log.message(pc.dim(`${vfs.getFileCount()} addon files planned`));
+			outro(pc.dim("Project unchanged"));
 		}
 		return Result.ok({
 			success: true,
@@ -4090,17 +4652,17 @@ async function addHandlerInternal(input) {
 		addons: updatedAddons,
 		addonOptions: updatedConfig.addonOptions
 	});
-	if (input.install) {
-		if (!isSilent()) log.info(pc.dim("Installing dependencies..."));
-		await installDependencies({
-			projectDir,
-			packageManager: config.packageManager
-		});
-	}
+	if (input.install) await installDependencies({
+		projectDir,
+		packageManager: config.packageManager
+	});
 	if (!isSilent()) {
-		log.success(pc.green(`Successfully added: ${addonsToAdd.join(", ")}`));
-		if (!input.install) log.info(pc.yellow(`Run '${config.packageManager === "npm" ? "npm install" : `${config.packageManager} install`}' to install new dependencies.`));
-		outro(pc.magenta("Addons added successfully!"));
+		log.success(pc.green(`Added ${formatConfigValue(addonsToAdd)}`));
+		if (!input.install) {
+			const installCommand = config.packageManager === "npm" ? "npm install" : `${config.packageManager} install`;
+			log.message(`${pc.dim("Next step")}\n${pc.cyan(installCommand)}`);
+		}
+		outro(pc.magenta("Project updated"));
 	}
 	return Result.ok({
 		success: true,
@@ -4133,7 +4695,7 @@ async function getApiChoice(Api, frontend, backend, previousValue) {
 		hint: "No API layer (e.g. for full-stack frameworks like Next.js with Route Handlers)"
 	});
 	const apiType = await navigableSelect({
-		message: "Select API type",
+		message: "Choose an API layer",
 		options: apiOptions,
 		initialValue: preferValidInitial(apiOptions, previousValue, apiOptions[0].value)
 	});
@@ -4185,7 +4747,7 @@ async function getAuthChoice(auth, backend, frontend = [], previousValue) {
 		}
 	});
 	const response = await navigableSelect({
-		message: "Select authentication provider",
+		message: "Choose authentication",
 		options,
 		initialValue: preferValidInitial(options, previousValue, options.some((option) => option.value === DEFAULT_CONFIG.auth) ? DEFAULT_CONFIG.auth : "none")
 	});
@@ -4239,7 +4801,7 @@ async function getBackendFrameworkChoice(backendFramework, frontends, previousVa
 		hint: "No backend server"
 	});
 	const response = await navigableSelect({
-		message: "Select backend",
+		message: "Choose a backend",
 		options: backendOptions,
 		initialValue: preferValidInitial(backendOptions, previousValue, hasFullstackFrontend ? "self" : DEFAULT_CONFIG.backend)
 	});
@@ -4279,7 +4841,7 @@ async function getDatabaseChoice(database, backend, runtime, previousValue) {
 		hint: "open-source NoSQL database that stores data in JSON-like documents called BSON"
 	});
 	const response = await navigableSelect({
-		message: "Select database",
+		message: "Choose a database",
 		options: databaseOptions,
 		initialValue: preferValidInitial(databaseOptions, previousValue, DEFAULT_CONFIG.database)
 	});
@@ -4378,7 +4940,7 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime, p
 	];
 	else return "none";
 	const response = await navigableSelect({
-		message: `Select ${databaseType} setup option`,
+		message: `Choose a ${databaseType} setup`,
 		options,
 		initialValue: preferValidInitial(options, previousValue, "none")
 	});
@@ -4404,7 +4966,7 @@ async function getExamplesChoice(examples, database, frontends, backend, api, pr
 	});
 	if (options.length === 0) return [];
 	response = await navigableMultiselect({
-		message: "Include examples",
+		message: "Include starter examples?",
 		options,
 		required: false,
 		initialValues: (previousValue ?? DEFAULT_CONFIG.examples)?.filter((ex) => options.some((o) => o.value === ex))
@@ -4431,7 +4993,7 @@ async function getFrontendChoice(frontendOptions, backend, auth, previousValue)
 	while (true) {
 		const wasFirstPrompt = isFirstPrompt();
 		const frontendTypes = await navigableMultiselect({
-			message: "Select project type",
+			message: "What are you building?",
 			options: [{
 				value: "web",
 				label: "Web",
@@ -4493,7 +5055,7 @@ async function getFrontendChoice(frontendOptions, backend, auth, previousValue)
 				}
 			].filter((option) => isFrontendAllowedWithBackend(option.value, backend, auth));
 			const webFramework = await navigableSelect({
-				message: "Choose web",
+				message: "Choose a web framework",
 				options: webOptions,
 				initialValue: preferValidInitial(webOptions, previousWeb, DEFAULT_CONFIG.frontend[0])
 			});
@@ -4507,7 +5069,7 @@ async function getFrontendChoice(frontendOptions, backend, auth, previousValue)
 		}
 		if (frontendTypes.includes("native")) {
 			const nativeFramework = await navigableSelect({
-				message: "Choose native",
+				message: "Choose a native setup",
 				options: [
 					{
 						value: "native-bare",
@@ -4547,7 +5109,7 @@ async function getFrontendChoice(frontendOptions, backend, auth, previousValue)
 async function getGitChoice(git, previousValue) {
 	if (git !== void 0) return git;
 	const response = await navigableConfirm({
-		message: "Initialize git repository?",
+		message: "Initialize a Git repository?",
 		initialValue: previousValue ?? DEFAULT_CONFIG.git
 	});
 	if (isCancel$1(response)) throw new UserCancelledError({ message: "Operation cancelled" });
@@ -4799,7 +5361,7 @@ async function getORMChoice(orm, hasDatabase, database, backend, runtime, previo
 	}
 	const options = database === "mongodb" ? [ormOptions.prisma, ormOptions.mongoose] : [ormOptions.drizzle, ormOptions.prisma];
 	const response = await navigableSelect({
-		message: "Select ORM",
+		message: "Choose an ORM",
 		options,
 		initialValue: preferValidInitial(options, previousValue, database === "mongodb" ? "prisma" : runtime === "workers" ? "drizzle" : DEFAULT_CONFIG.orm)
 	});
@@ -4851,7 +5413,7 @@ async function getPaymentsChoice(payments, auth, backend, _frontends, previousVa
 		hint: "No payments integration"
 	}];
 	const response = await navigableSelect({
-		message: "Select payments provider",
+		message: "Add payments?",
 		options,
 		initialValue: preferValidInitial(options, previousValue, DEFAULT_CONFIG.payments)
 	});
@@ -4878,7 +5440,7 @@ async function getRuntimeChoice(runtime, backend, previousValue) {
 		hint: "Edge runtime on Cloudflare's global network"
 	});
 	const response = await navigableSelect({
-		message: "Select runtime",
+		message: "Choose a runtime",
 		options: runtimeOptions,
 		initialValue: preferValidInitial(runtimeOptions, previousValue, DEFAULT_CONFIG.runtime)
 	});
@@ -4932,7 +5494,7 @@ async function getServerDeploymentChoice(deployment, runtime, backend, _webDeplo
 		};
 	});
 	const response = await navigableSelect({
-		message: "Select server deployment",
+		message: "Choose server deployment",
 		options,
 		initialValue: preferValidInitial(options, previousValue, DEFAULT_CONFIG.serverDeploy)
 	});
@@ -4980,7 +5542,7 @@ async function getDeploymentChoice(deployment, _runtime, backend, frontend = [],
 		};
 	});
 	const response = await navigableSelect({
-		message: "Select web deployment",
+		message: "Choose web deployment",
 		options,
 		initialValue: preferValidInitial(options, previousValue, DEFAULT_CONFIG.webDeploy)
 	});
@@ -4989,7 +5551,7 @@ async function getDeploymentChoice(deployment, _runtime, backend, frontend = [],
 }
 //#endregion
 //#region src/prompts/config-prompts.ts
-async function gatherConfig(flags, projectName, projectDir, relativePath) {
+async function gatherConfig(flags, projectName, projectDir, relativePath, options = {}) {
 	if (isSilent()) return {
 		projectName,
 		projectDir,
@@ -5017,22 +5579,63 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 		frontend: ({ previousAnswer }) => getFrontendChoice(flags.frontend, flags.backend, flags.auth, previousAnswer),
 		backend: ({ results, previousAnswer }) => getBackendFrameworkChoice(flags.backend, results.frontend, previousAnswer),
 		runtime: ({ results, previousAnswer }) => getRuntimeChoice(flags.runtime, results.backend, previousAnswer),
+		api: ({ results, previousAnswer }) => getApiChoice(flags.api, results.frontend, results.backend, previousAnswer),
 		database: ({ results, previousAnswer }) => getDatabaseChoice(flags.database, results.backend, results.runtime, previousAnswer),
 		orm: ({ results, previousAnswer }) => getORMChoice(flags.orm, results.database !== "none", results.database, results.backend, results.runtime, previousAnswer),
-		api: ({ results, previousAnswer }) => getApiChoice(flags.api, results.frontend, results.backend, previousAnswer),
+		dbSetup: ({ results, previousAnswer }) => getDBSetupChoice(results.database ?? "none", flags.dbSetup, results.orm, results.backend, results.runtime, previousAnswer),
 		auth: ({ results, previousAnswer }) => getAuthChoice(flags.auth, results.backend, results.frontend, previousAnswer),
 		payments: ({ results, previousAnswer }) => getPaymentsChoice(flags.payments, results.auth, results.backend, results.frontend, previousAnswer),
 		addons: ({ results, previousAnswer }) => getAddonsChoice(flags.addons, results.frontend, results.auth, results.backend, results.runtime, previousAnswer),
 		examples: ({ results, previousAnswer }) => getExamplesChoice(flags.examples, results.database, results.frontend, results.backend, results.api, previousAnswer),
-		dbSetup: ({ results, previousAnswer }) => getDBSetupChoice(results.database ?? "none", flags.dbSetup, results.orm, results.backend, results.runtime, previousAnswer),
 		webDeploy: ({ results, previousAnswer }) => getDeploymentChoice(flags.webDeploy, results.runtime, results.backend, results.frontend, results.dbSetup, previousAnswer),
 		serverDeploy: ({ results, previousAnswer }) => getServerDeploymentChoice(flags.serverDeploy, results.runtime, results.backend, results.webDeploy, previousAnswer),
 		git: ({ previousAnswer }) => getGitChoice(flags.git, previousAnswer),
 		packageManager: ({ previousAnswer }) => getPackageManagerChoice(flags.packageManager, previousAnswer),
 		install: ({ previousAnswer }) => getinstallChoice(flags.install, previousAnswer)
-	}, { onCancel: () => {
-		throw new UserCancelledError({ message: "Operation cancelled" });
-	} });
+	}, {
+		preselected: options.skipCompatibilityChecks ? flags : void 0,
+		sections: [
+			{
+				label: "App",
+				prompts: [
+					"frontend",
+					"backend",
+					"runtime",
+					"api"
+				]
+			},
+			{
+				label: "Data",
+				prompts: [
+					"database",
+					"orm",
+					"dbSetup"
+				]
+			},
+			{
+				label: "Product",
+				prompts: [
+					"auth",
+					"payments",
+					"addons",
+					"examples"
+				]
+			},
+			{
+				label: "Ship",
+				prompts: [
+					"webDeploy",
+					"serverDeploy",
+					"git",
+					"packageManager",
+					"install"
+				]
+			}
+		],
+		onCancel: () => {
+			throw new UserCancelledError({ message: "Operation cancelled" });
+		}
+	});
 	return {
 		projectName,
 		projectDir,
@@ -5081,13 +5684,22 @@ async function getProjectName(initialName) {
 	let projectPath = "";
 	let defaultName = DEFAULT_CONFIG.projectName;
 	let counter = 1;
-	while (await fs.pathExists(path.resolve(process.cwd(), defaultName)) && (await fs.readdir(path.resolve(process.cwd(), defaultName))).length > 0) {
+	while (true) {
+		const defaultPath = path.resolve(process.cwd(), defaultName);
+		let stats;
+		try {
+			stats = await fs.lstat(defaultPath);
+		} catch (error) {
+			if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") break;
+			throw error;
+		}
+		if (stats.isDirectory() && (await fs.readdir(defaultPath)).length === 0) break;
 		defaultName = `${DEFAULT_CONFIG.projectName}-${counter}`;
 		counter++;
 	}
 	while (!isValid) {
 		const response = await text({
-			message: "Enter your project name or path (relative to current directory)",
+			message: "Where should we create your project?",
 			placeholder: defaultName,
 			initialValue: initialName,
 			defaultValue: defaultName,
@@ -5116,9 +5728,7 @@ async function getProjectName(initialName) {
 */
 function isTelemetryEnabled() {
 	const BTS_TELEMETRY_DISABLED = process.env.BTS_TELEMETRY_DISABLED;
-	const BTS_TELEMETRY = "1";
 	if (BTS_TELEMETRY_DISABLED !== void 0) return BTS_TELEMETRY_DISABLED !== "1";
-	if (BTS_TELEMETRY !== void 0) return BTS_TELEMETRY === "1";
 	return true;
 }
 //#endregion
@@ -5148,90 +5758,83 @@ async function trackProjectCreation(config, disableAnalytics = false) {
 	});
 }
 //#endregion
-//#region src/utils/display-config.ts
-function displayConfig(config) {
-	const configDisplay = [];
-	if (config.projectName) configDisplay.push(`${pc.blue("Project Name:")} ${config.projectName}`);
-	if (config.frontend !== void 0) {
-		const frontend = Array.isArray(config.frontend) ? config.frontend : [config.frontend];
-		const frontendText = frontend.length > 0 && frontend[0] !== void 0 ? frontend.join(", ") : "none";
-		configDisplay.push(`${pc.blue("Frontend:")} ${frontendText}`);
-	}
-	if (config.backend !== void 0) configDisplay.push(`${pc.blue("Backend:")} ${String(config.backend)}`);
-	if (config.runtime !== void 0) configDisplay.push(`${pc.blue("Runtime:")} ${String(config.runtime)}`);
-	if (config.api !== void 0) configDisplay.push(`${pc.blue("API:")} ${String(config.api)}`);
-	if (config.database !== void 0) configDisplay.push(`${pc.blue("Database:")} ${String(config.database)}`);
-	if (config.orm !== void 0) configDisplay.push(`${pc.blue("ORM:")} ${String(config.orm)}`);
-	if (config.auth !== void 0) configDisplay.push(`${pc.blue("Auth:")} ${String(config.auth)}`);
-	if (config.payments !== void 0) configDisplay.push(`${pc.blue("Payments:")} ${String(config.payments)}`);
-	if (config.addons !== void 0) {
-		const addons = Array.isArray(config.addons) ? config.addons : [config.addons];
-		const addonsText = addons.length > 0 && addons[0] !== void 0 ? addons.join(", ") : "none";
-		configDisplay.push(`${pc.blue("Addons:")} ${addonsText}`);
-	}
-	if (config.examples !== void 0) {
-		const examples = Array.isArray(config.examples) ? config.examples : [config.examples];
-		const examplesText = examples.length > 0 && examples[0] !== void 0 ? examples.join(", ") : "none";
-		configDisplay.push(`${pc.blue("Examples:")} ${examplesText}`);
-	}
-	if (config.git !== void 0) {
-		const gitText = typeof config.git === "boolean" ? config.git ? "Yes" : "No" : String(config.git);
-		configDisplay.push(`${pc.blue("Git Init:")} ${gitText}`);
-	}
-	if (config.packageManager !== void 0) configDisplay.push(`${pc.blue("Package Manager:")} ${String(config.packageManager)}`);
-	if (config.install !== void 0) {
-		const installText = typeof config.install === "boolean" ? config.install ? "Yes" : "No" : String(config.install);
-		configDisplay.push(`${pc.blue("Install Dependencies:")} ${installText}`);
-	}
-	if (config.dbSetup !== void 0) configDisplay.push(`${pc.blue("Database Setup:")} ${String(config.dbSetup)}`);
-	if (config.webDeploy !== void 0) configDisplay.push(`${pc.blue("Web Deployment:")} ${String(config.webDeploy)}`);
-	if (config.serverDeploy !== void 0) configDisplay.push(`${pc.blue("Server Deployment:")} ${String(config.serverDeploy)}`);
-	if (configDisplay.length === 0) return pc.yellow("No configuration selected.");
-	return configDisplay.join("\n");
+//#region src/utils/cli-invocation.ts
+function getCliSubcommandCommand(subcommand, fallbackPackageManager, userAgent = process.env.npm_config_user_agent) {
+	const normalizedUserAgent = userAgent?.toLowerCase();
+	return getPackageExecutionCommand(normalizedUserAgent?.startsWith("bun") ? "bun" : normalizedUserAgent?.startsWith("pnpm") ? "pnpm" : normalizedUserAgent?.startsWith("npm") ? "npm" : fallbackPackageManager, `create-better-t-stack@latest ${subcommand}`);
 }
 //#endregion
 //#region src/utils/project-directory.ts
 async function handleDirectoryConflict(currentPathInput) {
 	while (true) {
-		const resolvedPath = path.resolve(process.cwd(), currentPathInput);
-		if (!(await fs.pathExists(resolvedPath) && (await fs.readdir(resolvedPath)).length > 0)) return {
+		const pathStateResult = await inspectProjectPath(path.resolve(process.cwd(), currentPathInput));
+		if (pathStateResult.isErr()) throw pathStateResult.error;
+		const pathState = pathStateResult.value;
+		if (pathState === "missing" || pathState === "empty-directory") return {
 			finalPathInput: currentPathInput,
 			shouldClearDirectory: false
 		};
-		if (isSilent()) throw new CLIError({ message: `Directory "${currentPathInput}" already exists and is not empty. In silent mode, please provide a different project name or clear the directory manually.` });
-		log.warn(`Directory "${pc.yellow(currentPathInput)}" already exists and is not empty.`);
+		if (isSilent()) throw new CLIError({ message: `Project path "${currentPathInput}" is unavailable. In silent mode, provide a different project path or an explicit directoryConflict strategy.` });
+		if (pathState === "symbolic-link") log.warn(`Project path "${pc.yellow(currentPathInput)}" is a symbolic link.`);
+		else if (pathState === "non-directory") log.warn(`Project path "${pc.yellow(currentPathInput)}" exists and is not a directory.`);
+		else log.warn(`Directory "${pc.yellow(currentPathInput)}" already exists and is not empty.`);
+		let incrementedPath;
+		if (currentPathInput !== ".") {
+			const incrementResult = await findAvailableIncrementedPath(currentPathInput);
+			if (incrementResult.isErr()) throw incrementResult.error;
+			incrementedPath = incrementResult.value;
+		}
+		const options = [];
+		if (incrementedPath) options.push({
+			value: "increment",
+			label: `Create as "${incrementedPath}"`,
+			hint: "Keep the existing path untouched"
+		});
+		options.push({
+			value: "rename",
+			label: "Choose another path",
+			hint: "Enter a different project directory"
+		});
+		if (pathState === "non-empty-directory") options.push({
+			value: "merge",
+			label: "Merge into this directory",
+			hint: "Keep unrelated files; replace conflicts"
+		}, {
+			value: "overwrite",
+			label: "Delete and overwrite",
+			hint: "Permanently remove existing contents"
+		});
+		options.push({
+			value: "cancel",
+			label: "Cancel",
+			hint: "Leave everything unchanged"
+		});
 		const action = await select({
-			message: "What would you like to do?",
-			options: [
-				{
-					value: "overwrite",
-					label: "Overwrite",
-					hint: "Empty the directory and create the project"
-				},
-				{
-					value: "merge",
-					label: "Merge",
-					hint: "Create project files inside, potentially overwriting conflicts"
-				},
-				{
-					value: "rename",
-					label: "Choose a different name/path",
-					hint: "Keep the existing directory and create a new one"
-				},
-				{
-					value: "cancel",
-					label: "Cancel",
-					hint: "Abort the process"
-				}
-			],
-			initialValue: "rename"
+			message: "How should we continue?",
+			options,
+			initialValue: incrementedPath ? "increment" : "rename"
 		});
 		if (isCancel(action)) throw new UserCancelledError({ message: "Operation cancelled." });
 		switch (action) {
-			case "overwrite": return {
-				finalPathInput: currentPathInput,
-				shouldClearDirectory: true
+			case "increment": return {
+				finalPathInput: incrementedPath,
+				shouldClearDirectory: false
 			};
+			case "overwrite": {
+				const confirmed = await confirm({
+					message: `Permanently delete every file in "${currentPathInput}"?`,
+					initialValue: false
+				});
+				if (isCancel(confirmed)) throw new UserCancelledError({ message: "Operation cancelled." });
+				if (!confirmed) {
+					log.info("Nothing was deleted. Choose another option.");
+					continue;
+				}
+				return {
+					finalPathInput: currentPathInput,
+					shouldClearDirectory: true
+				};
+			}
 			case "merge":
 				log.info(`Proceeding into existing directory "${pc.yellow(currentPathInput)}". Files may be overwritten.`);
 				return {
@@ -5239,8 +5842,8 @@ async function handleDirectoryConflict(currentPathInput) {
 					shouldClearDirectory: false
 				};
 			case "rename":
-				log.info("Please choose a different project name or path.");
-				return await handleDirectoryConflict(await getProjectName(void 0));
+				currentPathInput = await getProjectName(void 0);
+				continue;
 			case "cancel": throw new UserCancelledError({ message: "Operation cancelled." });
 		}
 	}
@@ -5255,9 +5858,11 @@ async function setupProjectDirectory(finalPathInput, shouldClearDirectory) {
 		finalResolvedPath = path.resolve(process.cwd(), finalPathInput);
 		finalBaseName = path.basename(finalResolvedPath);
 	}
+	const pathSafetyResult = await validateSafeProjectDirectoryPath(finalPathInput);
+	if (pathSafetyResult.isErr()) throw pathSafetyResult.error;
 	if (shouldClearDirectory) {
-		const s = spinner();
-		s.start(`Clearing directory "${finalResolvedPath}"...`);
+		const s = isSilent() ? void 0 : spinner();
+		s?.start(`Clearing directory "${finalResolvedPath}"...`);
 		const clearResult = await Result.tryPromise({
 			try: () => fs.emptyDir(finalResolvedPath),
 			catch: (error) => new CLIError({
@@ -5266,16 +5871,78 @@ async function setupProjectDirectory(finalPathInput, shouldClearDirectory) {
 			})
 		});
 		if (clearResult.isErr()) {
-			s.stop(pc.red(`Failed to clear directory "${finalResolvedPath}".`));
+			s?.stop(pc.red(`Failed to clear directory "${finalResolvedPath}".`));
 			throw clearResult.error;
 		}
-		s.stop(`Directory "${finalResolvedPath}" cleared.`);
+		s?.stop(`Directory "${finalResolvedPath}" cleared.`);
 	} else await fs.ensureDir(finalResolvedPath);
 	return {
 		finalResolvedPath,
 		finalBaseName
 	};
 }
+async function validateSafeProjectDirectoryPath(finalPathInput) {
+	return Result.tryPromise({
+		try: async () => {
+			const cwd = path.resolve(process.cwd());
+			const targetPath = finalPathInput === "." ? cwd : path.resolve(cwd, finalPathInput);
+			const relativeTarget = path.relative(cwd, targetPath);
+			if (relativeTarget === ".." || relativeTarget.startsWith(`..${path.sep}`) || path.isAbsolute(relativeTarget)) throw new CLIError({ message: `Project path "${finalPathInput}" resolves outside the current working directory.` });
+			const pathSegments = relativeTarget.split(path.sep).filter(Boolean);
+			let nearestExistingPath = cwd;
+			for (const segment of pathSegments) {
+				const candidatePath = path.join(nearestExistingPath, segment);
+				let stats;
+				try {
+					stats = await fs.lstat(candidatePath);
+				} catch (error) {
+					if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") break;
+					throw error;
+				}
+				if (stats.isSymbolicLink()) throw new CLIError({ message: `Project path "${finalPathInput}" passes through symbolic link "${path.relative(cwd, candidatePath)}". Choose a real directory within the current working directory.` });
+				if (!stats.isDirectory()) throw new CLIError({ message: `Project path "${finalPathInput}" passes through "${path.relative(cwd, candidatePath)}", which is not a directory.` });
+				nearestExistingPath = candidatePath;
+			}
+			const [realCwd, realExistingPath] = await Promise.all([fs.realpath(cwd), fs.realpath(nearestExistingPath)]);
+			const relativeRealPath = path.relative(realCwd, realExistingPath);
+			if (relativeRealPath === ".." || relativeRealPath.startsWith(`..${path.sep}`) || path.isAbsolute(relativeRealPath)) throw new CLIError({ message: `Project path "${finalPathInput}" resolves outside the current working directory.` });
+		},
+		catch: (error) => CLIError.is(error) ? error : new CLIError({
+			message: `Unable to validate project path "${finalPathInput}".`,
+			cause: error
+		})
+	});
+}
+async function inspectProjectPath(targetPath) {
+	return Result.tryPromise({
+		try: async () => {
+			let stats;
+			try {
+				stats = await fs.lstat(targetPath);
+			} catch (error) {
+				if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return "missing";
+				throw error;
+			}
+			if (stats.isSymbolicLink()) return "symbolic-link";
+			if (!stats.isDirectory()) return "non-directory";
+			return (await fs.readdir(targetPath)).length === 0 ? "empty-directory" : "non-empty-directory";
+		},
+		catch: (error) => new CLIError({
+			message: `Unable to inspect project path "${targetPath}".`,
+			cause: error
+		})
+	});
+}
+async function findAvailableIncrementedPath(currentPathInput) {
+	let counter = 1;
+	while (true) {
+		const candidate = `${currentPathInput}-${counter}`;
+		const candidateStateResult = await inspectProjectPath(path.resolve(process.cwd(), candidate));
+		if (candidateStateResult.isErr()) return Result.err(candidateStateResult.error);
+		if (candidateStateResult.value === "missing" || candidateStateResult.value === "empty-directory") return Result.ok(candidate);
+		counter++;
+	}
+}
 //#endregion
 //#region src/utils/project-name-validation.ts
 function validateProjectName(name) {
@@ -5439,7 +6106,7 @@ function validateArrayOptions(options) {
 }
 //#endregion
 //#region src/validation.ts
-const CORE_STACK_FLAGS = new Set([
+const CORE_STACK_FLAGS = /* @__PURE__ */ new Set([
 	"database",
 	"orm",
 	"backend",
@@ -5689,7 +6356,7 @@ async function initMongoDBAtlas(serverDir) {
 			await $({
 				cwd: serverDir,
 				stdio: "inherit"
-			})`atlas deployments setup`;
+			})`atlas setup`;
 			cliLog.success("MongoDB Atlas deployment ready");
 		},
 		catch: (e) => new DatabaseSetupError({
@@ -5738,7 +6405,7 @@ ${pc.green("MongoDB Atlas Manual Setup Instructions:")}
    ${pc.blue("https://www.mongodb.com/docs/atlas/cli/stable/install-atlas-cli/")}
 
 2. Run the following command and follow the prompts:
-   ${pc.blue("atlas deployments setup")}
+   ${pc.blue("atlas setup")}
 
 3. Get your connection string from the Atlas dashboard:
    Format: ${pc.dim("mongodb+srv://USERNAME:PASSWORD@CLUSTER.mongodb.net/DATABASE_NAME")}
@@ -5839,10 +6506,6 @@ const NEON_REGIONS = [
 		label: "AWS Asia Pacific (Singapore)",
 		value: "aws-ap-southeast-1"
 	},
-	{
-		label: "AWS South America East 1 (São Paulo)",
-		value: "aws-sa-east-1"
-	},
 	{
 		label: "AWS Asia Pacific (Sydney)",
 		value: "aws-ap-southeast-2"
@@ -5852,13 +6515,12 @@ const NEON_REGIONS = [
 		value: "azure-eastus2"
 	}
 ];
-async function executeNeonCommand(packageManager, commandArgsString, spinnerText) {
+async function executeNeonCommand(commandArgs, spinnerText) {
 	const s = createSpinner();
-	const args = getPackageExecutionArgs(packageManager, commandArgsString);
 	if (spinnerText) s.start(spinnerText);
 	return Result.tryPromise({
 		try: async () => {
-			const result = await $`${args}`;
+			const result = await $`${commandArgs}`;
 			if (spinnerText) s.stop(pc.green(spinnerText.replace("...", "").replace("ing ", "ed ").trim()));
 			return result;
 		},
@@ -5872,8 +6534,22 @@ async function executeNeonCommand(packageManager, commandArgsString, spinnerText
 		}
 	});
 }
+function getNeonProjectCreateArgs(packageManager, projectName, regionId) {
+	return [
+		...getPackageRunnerPrefix(packageManager),
+		"neon@latest",
+		"projects",
+		"create",
+		"--name",
+		projectName,
+		"--region-id",
+		regionId,
+		"--output",
+		"json"
+	];
+}
 async function createNeonProject(projectName, regionId, packageManager) {
-	const execResult = await executeNeonCommand(packageManager, `neonctl@latest projects create --name ${projectName} --region-id ${regionId} --output json`, `Creating Neon project "${projectName}"...`);
+	const execResult = await executeNeonCommand(getNeonProjectCreateArgs(packageManager, projectName, regionId), `Creating Neon project "${projectName}"...`);
 	if (execResult.isErr()) return Result.err(execResult.error);
 	const parseResult = Result.try({
 		try: () => JSON.parse(execResult.value.stdout),
@@ -5917,7 +6593,7 @@ async function writeEnvFile$2(projectDir, backend, config) {
 }
 async function setupWithNeonDb(projectDir, packageManager, backend) {
 	const s = createSpinner();
-	s.start("Creating Neon database using get-db...");
+	s.start("Creating Neon database using neon-new...");
 	const targetApp = backend === "self" ? "apps/web" : "apps/server";
 	const targetDir = path.join(projectDir, targetApp);
 	const ensureDirResult = await Result.tryPromise({
@@ -5932,17 +6608,17 @@ async function setupWithNeonDb(projectDir, packageManager, backend) {
 		s.stop(pc.red("Failed to create directory"));
 		return ensureDirResult;
 	}
-	const packageArgs = getPackageExecutionArgs(packageManager, `get-db@latest --yes --ref "sbA3tIe"`);
+	const packageArgs = getPackageExecutionArgs(packageManager, `neon-new@latest --yes --ref "sbA3tIe"`);
 	return Result.tryPromise({
 		try: async () => {
 			await $({ cwd: targetDir })`${packageArgs}`;
 			s.stop(pc.green("Neon database created successfully!"));
 		},
 		catch: (e) => {
-			s.stop(pc.red("Failed to create database with get-db"));
+			s.stop(pc.red("Failed to create database with neon-new"));
 			return new DatabaseSetupError({
 				provider: "neon",
-				message: `Failed to create database with get-db: ${e instanceof Error ? e.message : String(e)}`,
+				message: `Failed to create database with neon-new: ${e instanceof Error ? e.message : String(e)}`,
 				cause: e
 			});
 		}
@@ -6003,25 +6679,25 @@ async function setupNeonPostgres(config, cliInput) {
 		return Result.ok(void 0);
 	}
 	let setupMethod = cliInput?.dbSetupOptions?.neon?.method ?? config.dbSetupOptions?.neon?.method;
-	if (!setupMethod) if (isSilent()) setupMethod = "neondb";
+	if (!setupMethod) if (isSilent()) setupMethod = "neon-new";
 	else {
 		const promptedSetupMethod = await select({
 			message: "Choose your Neon setup method:",
 			options: [{
-				label: "Quick setup with get-db",
-				value: "neondb",
+				label: "Quick setup with neon-new",
+				value: "neon-new",
 				hint: "fastest, no auth required"
 			}, {
-				label: "Custom setup with neonctl",
-				value: "neonctl",
+				label: "Custom setup with Neon CLI",
+				value: "neon",
 				hint: "More control - choose project name and region"
 			}],
-			initialValue: "neondb"
+			initialValue: "neon-new"
 		});
 		if (isCancel(promptedSetupMethod)) return userCancelled("Operation cancelled");
 		setupMethod = promptedSetupMethod;
 	}
-	if (setupMethod === "neondb") {
+	if (setupMethod === "neon-new" || setupMethod === "neondb") {
 		const neonDbResult = await setupWithNeonDb(projectDir, packageManager, backend);
 		if (neonDbResult.isErr()) {
 			cliLog.error(pc.red(neonDbResult.error.message));
@@ -6941,7 +7617,7 @@ async function getDockerStatus(database) {
 //#endregion
 //#region src/helpers/core/post-installation.ts
 function getDesktopStaticBuildNote(frontend) {
-	const staticBuildFrontends = new Map([
+	const staticBuildFrontends = /* @__PURE__ */ new Map([
 		["tanstack-start", "TanStack Start"],
 		["next", "Next.js"],
 		["nuxt", "Nuxt"],
@@ -6985,7 +7661,7 @@ async function displayPostInstallInstructions(config) {
 	const polarInstructions = config.payments === "polar" && config.auth === "better-auth" ? getPolarInstructions(backend, packageManager) : "";
 	const bunWebNativeWarning = packageManager === "bun" && hasNative && hasWeb ? getBunWebNativeWarning() : "";
 	const noOrmWarning = !isConvex && database !== "none" && orm === "none" ? getNoOrmWarning() : "";
-	let output = `${pc.bold("Next steps")}\n${pc.cyan("1.")} ${cdCmd}\n`;
+	let output = `${pc.cyan("1.")} ${cdCmd}\n`;
 	let stepCounter = 2;
 	if (!depsInstalled) output += `${pc.cyan(`${stepCounter++}.`)} ${packageManager} install\n`;
 	if (database === "sqlite" && dbSetup !== "d1") output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:local\n${pc.dim("   (optional - starts local SQLite database)")}\n`;
@@ -7003,19 +7679,44 @@ async function displayPostInstallInstructions(config) {
 	}
 	const hasStandaloneBackend = backend !== "none";
 	if (hasWeb || hasStandaloneBackend || addons?.includes("starlight") || addons?.includes("fumadocs")) {
-		output += `${pc.bold("Your project will be available at:")}\n`;
-		if (hasWeb) output += `${pc.cyan("•")} Frontend: http://localhost:${webPort}\n`;
-		else if (!hasNative && !addons?.includes("starlight")) output += `${pc.yellow("NOTE:")} You are creating a backend-only app\n   (no frontend selected)\n`;
+		const localServices = [];
+		let localDevelopmentNote = "";
+		if (hasWeb) localServices.push({
+			label: "Frontend",
+			url: `http://localhost:${webPort}`
+		});
+		else if (!hasNative && !addons?.includes("starlight")) localDevelopmentNote = "Backend-only app — no frontend selected";
 		if (!isConvex && !isBackendSelf && hasStandaloneBackend) {
-			output += `${pc.cyan("•")} Backend API: http://localhost:3000\n`;
-			if (api === "orpc") output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:3000/api-reference\n`;
+			localServices.push({
+				label: "API",
+				url: "http://localhost:3000"
+			});
+			if (api === "orpc") localServices.push({
+				label: "API reference",
+				url: "http://localhost:3000/api-reference"
+			});
 		}
 		if (isBackendSelf && api === "orpc") {
 			const rpcPath = frontend?.includes("next") || frontend?.includes("tanstack-start") ? "/api/rpc" : "/rpc";
-			output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:${webPort}${rpcPath}/api-reference\n`;
+			localServices.push({
+				label: "API reference",
+				url: `http://localhost:${webPort}${rpcPath}/api-reference`
+			});
+		}
+		if (addons?.includes("starlight")) localServices.push({
+			label: "Docs",
+			url: "http://localhost:4321"
+		});
+		if (addons?.includes("fumadocs")) localServices.push({
+			label: "Fumadocs",
+			url: "http://localhost:4000"
+		});
+		output += `\n${pc.bold("Local development")}\n`;
+		if (localDevelopmentNote) output += `${pc.dim(localDevelopmentNote)}\n`;
+		if (localServices.length > 0) {
+			const labelWidth = Math.max(...localServices.map(({ label }) => label.length));
+			for (const { label, url } of localServices) output += `${pc.dim(label.padEnd(labelWidth))}  ${pc.cyan(url)}\n`;
 		}
-		if (addons?.includes("starlight")) output += `${pc.cyan("•")} Docs: http://localhost:4321\n`;
-		if (addons?.includes("fumadocs")) output += `${pc.cyan("•")} Fumadocs: http://localhost:4000\n`;
 	}
 	if (nativeInstructions) output += `\n${nativeInstructions.trim()}\n`;
 	if (databaseInstructions) output += `\n${databaseInstructions.trim()}\n`;
@@ -7035,10 +7736,15 @@ async function displayPostInstallInstructions(config) {
 	if (bunWebNativeWarning) output += `\n${bunWebNativeWarning.trim()}\n`;
 	const sponsorsResult = await fetchSponsorsQuietly();
 	const specialSponsorsSection = sponsorsResult.isOk() ? formatPostInstallSpecialSponsorsSection(sponsorsResult.value) : "";
-	if (specialSponsorsSection) output += `\n${specialSponsorsSection.trim()}\n`;
-	output += `\n${pc.bold("Like Better-T-Stack?")} Please consider giving us a star\n   on GitHub:\n`;
-	output += pc.cyan("https://github.com/AmanVarshney01/create-better-t-stack");
-	cliConsola.box(output);
+	log.message([], { spacing: 1 });
+	box(output.trimEnd(), pc.bold("Next steps"), {
+		contentPadding: 2,
+		formatBorder: pc.dim,
+		rounded: true,
+		width: "auto"
+	});
+	if (specialSponsorsSection) cliLog.message(specialSponsorsSection);
+	cliLog.message(`${pc.bold("Like Better T Stack?")} ${pc.dim("Star the project on GitHub")}\n${pc.cyan("https://github.com/AmanVarshney01/create-better-t-stack")}`);
 }
 function getNativeInstructions(isConvex, isBackendSelf, frontend, runCmd) {
 	const envVar = isConvex ? "EXPO_PUBLIC_CONVEX_URL" : "EXPO_PUBLIC_SERVER_URL";
@@ -7065,43 +7771,82 @@ function getVitePlusNativeHooksInstructions(runCmd) {
 	return `${pc.bold("Vite+ native Git hooks:")}\n${pc.cyan("•")} Optional hook setup: ${`${runCmd} hooks:setup`}\n${pc.dim("   (runs vp config; hooks install into .vite-hooks and use vp staged)")}\n`;
 }
 async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup, webDeploy, serverDeploy, backend) {
-	const instructions = [];
+	const notes = [];
+	const commands = [];
 	const isD1Alchemy = dbSetup === "d1" && (serverDeploy === "cloudflare" || backend === "self" && webDeploy === "cloudflare");
 	if (dbSetup === "docker") {
 		const dockerStatus = await getDockerStatus(database);
-		if (dockerStatus.message) {
-			instructions.push(dockerStatus.message);
-			instructions.push("");
-		}
+		if (dockerStatus.message) notes.push(dockerStatus.message);
 	}
 	if (isD1Alchemy) {
-		if (orm === "drizzle") instructions.push(`${pc.cyan("•")} Generate migrations: ${`${runCmd} db:generate`}`);
+		if (orm === "drizzle") commands.push({
+			label: "Generate migrations",
+			command: `${runCmd} db:generate`
+		});
 		else if (orm === "prisma") {
-			instructions.push(`${pc.cyan("•")} Generate Prisma client: ${`${runCmd} db:generate`}`);
-			instructions.push(`${pc.cyan("•")} Apply migrations: ${`${runCmd} db:migrate`}`);
+			commands.push({
+				label: "Generate client",
+				command: `${runCmd} db:generate`
+			});
+			commands.push({
+				label: "Apply migrations",
+				command: `${runCmd} db:migrate`
+			});
 		}
 	}
 	if (dbSetup === "planetscale") {
-		if (database === "mysql" && orm === "drizzle") instructions.push(`${pc.yellow("NOTE:")} Enable foreign key constraints in PlanetScale database settings`);
-		if (database === "mysql" && orm === "prisma") instructions.push(`${pc.yellow("NOTE:")} How to handle Prisma migrations with PlanetScale:\n   https://github.com/prisma/prisma/issues/7292`);
+		if (database === "mysql" && orm === "drizzle") notes.push(`${pc.yellow("NOTE:")} Enable foreign key constraints in PlanetScale database settings`);
+		if (database === "mysql" && orm === "prisma") notes.push(`${pc.yellow("NOTE:")} How to handle Prisma migrations with PlanetScale:\n   https://github.com/prisma/prisma/issues/7292`);
 	}
-	if (dbSetup === "turso" && orm === "prisma") instructions.push(`${pc.yellow("NOTE:")} Follow Turso's Prisma guide for migrations via the Turso CLI:\n   https://docs.turso.tech/sdk/ts/orm/prisma`);
+	if (dbSetup === "turso" && orm === "prisma") notes.push(`${pc.yellow("NOTE:")} Follow Turso's Prisma guide for migrations via the Turso CLI:\n   https://docs.turso.tech/sdk/ts/orm/prisma`);
 	if (orm === "prisma") {
-		if (database === "mongodb" && dbSetup === "docker") instructions.push(`${pc.yellow("WARNING:")} Prisma + MongoDB + Docker combination\n   may not work.`);
-		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
+		if (database === "mongodb" && dbSetup === "docker") notes.push(`${pc.yellow("WARNING:")} Prisma + MongoDB + Docker combination\n   may not work.`);
+		if (dbSetup === "docker") commands.push({
+			label: "Start database",
+			command: `${runCmd} db:start`
+		});
 		if (!isD1Alchemy) {
-			instructions.push(`${pc.cyan("•")} Generate Prisma Client: ${`${runCmd} db:generate`}`);
-			instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
+			commands.push({
+				label: "Generate client",
+				command: `${runCmd} db:generate`
+			});
+			commands.push({
+				label: "Apply schema",
+				command: `${runCmd} db:push`
+			});
 		}
-		if (!isD1Alchemy) instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
+		if (!isD1Alchemy) commands.push({
+			label: "Open studio",
+			command: `${runCmd} db:studio`
+		});
 	} else if (orm === "drizzle") {
-		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
-		if (!isD1Alchemy) instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
-		if (!isD1Alchemy) instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
+		if (dbSetup === "docker") commands.push({
+			label: "Start database",
+			command: `${runCmd} db:start`
+		});
+		if (!isD1Alchemy) commands.push({
+			label: "Apply schema",
+			command: `${runCmd} db:push`
+		});
+		if (!isD1Alchemy) commands.push({
+			label: "Open studio",
+			command: `${runCmd} db:studio`
+		});
 	} else if (orm === "mongoose") {
-		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
-	} else if (orm === "none") instructions.push(`${pc.yellow("NOTE:")} Manual database schema setup\n   required.`);
-	return instructions.length ? `${pc.bold("Database commands:")}\n${instructions.join("\n")}` : "";
+		if (dbSetup === "docker") commands.push({
+			label: "Start database",
+			command: `${runCmd} db:start`
+		});
+	} else if (orm === "none") notes.push(`${pc.yellow("NOTE:")} Manual database schema setup required.`);
+	if (notes.length === 0 && commands.length === 0) return "";
+	const sections = [pc.bold("Database")];
+	if (notes.length > 0) sections.push(notes.join("\n"));
+	if (commands.length > 0) {
+		const labelWidth = Math.max(...commands.map(({ label }) => label.length));
+		const commandRows = commands.map(({ label, command }) => `${pc.dim(label.padEnd(labelWidth))}  ${pc.cyan(command)}`);
+		sections.push(commandRows.join("\n"));
+	}
+	return sections.join("\n");
 }
 function getTauriInstructions(runCmd, frontend) {
 	const staticBuildNote = getDesktopStaticBuildNote(frontend);
@@ -7268,7 +8013,7 @@ async function createProject(options, cliInput = {}) {
 			})
 		}));
 		yield* Result.await(formatProject(projectDir));
-		if (!isSilent()) log.success("Project template successfully scaffolded!");
+		if (!isSilent()) log.success("Project scaffolded");
 		if (options.install) yield* Result.await(installDependencies({
 			projectDir,
 			packageManager: options.packageManager
@@ -7363,19 +8108,16 @@ async function createProjectHandler(input, options = {}) {
 async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 	return Result.gen(async function* () {
 		if (!isSilent() && input.renderTitle !== false) renderTitle();
-		if (!isSilent()) intro(pc.magenta("Creating a new Better-T-Stack project"));
-		if (!isSilent() && input.yolo) cliConsola.fatal("YOLO mode enabled - skipping checks. Things may break!");
+		if (!isSilent()) intro(pc.magenta("Configure your new project"));
+		if (!isSilent() && input.yolo) log.warn(pc.yellow("YOLO mode enabled — compatibility checks are disabled."));
 		let currentPathInput;
 		if (isSilent()) currentPathInput = yield* Result.await(resolveProjectNameForSilent(input));
 		else if (input.yes && input.projectName) currentPathInput = input.projectName;
 		else if (input.yes) {
 			const defaultConfig = getDefaultConfig();
 			let defaultName = defaultConfig.relativePath;
-			let counter = 1;
-			while (await fs.pathExists(path.resolve(process.cwd(), defaultName)) && (await fs.readdir(path.resolve(process.cwd(), defaultName))).length > 0) {
-				defaultName = `${defaultConfig.projectName}-${counter}`;
-				counter++;
-			}
+			const defaultPathState = yield* Result.await(inspectProjectPath(path.resolve(process.cwd(), defaultName)));
+			if (defaultPathState !== "missing" && defaultPathState !== "empty-directory") defaultName = yield* Result.await(findAvailableIncrementedPath(defaultConfig.projectName));
 			currentPathInput = defaultName;
 		} else currentPathInput = yield* Result.await(Result.tryPromise({
 			try: async () => getProjectName(input.projectName),
@@ -7394,6 +8136,7 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 		finalPathInput = conflictResult.finalPathInput;
 		shouldClearDirectory = conflictResult.shouldClearDirectory;
 		yield* validateResolvedProjectPathInput(finalPathInput);
+		yield* Result.await(validateSafeProjectDirectoryPath(finalPathInput));
 		let finalResolvedPath;
 		let finalBaseName;
 		if (input.dryRun) {
@@ -7424,10 +8167,7 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 			if (templateConfig) {
 				const templateName = input.template.toUpperCase();
 				const templateDescription = getTemplateDescription(input.template);
-				if (!isSilent()) {
-					log.message(pc.bold(pc.cyan(`Using template: ${pc.white(templateName)}`)));
-					log.message(pc.dim(`   ${templateDescription}`));
-				}
+				if (!isSilent()) log.info(`${pc.dim("Template")} ${pc.bold(pc.cyan(templateName))}\n${pc.dim(templateDescription)}`);
 				const userOverrides = {};
 				for (const [key, value] of Object.entries(originalInput)) if (value !== void 0) userOverrides[key] = value;
 				cliInput = {
@@ -7458,10 +8198,7 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 				message: validationResult.error.message,
 				cause: validationResult.error
 			}));
-			if (!isSilent()) {
-				log.info(pc.yellow("Using default/flag options (config prompts skipped):"));
-				log.message(displayConfig(config));
-			}
+			if (!isSilent()) log.info(pc.dim("Quick setup selected — using defaults and provided flags."));
 		} else {
 			const flagConfigResult = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
 			if (flagConfigResult.isErr()) return Result.err(new CLIError({
@@ -7470,13 +8207,10 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 			}));
 			const flagConfig = flagConfigResult.value;
 			const { projectName: _projectNameFromFlags, ...otherFlags } = flagConfig;
-			if (!isSilent() && Object.keys(otherFlags).length > 0) {
-				log.info(pc.yellow("Using these pre-selected options:"));
-				log.message(displayConfig(otherFlags));
-				log.message("");
-			}
+			const isTemplateSetup = input.template && input.template !== "none";
+			if (!isSilent() && !isTemplateSetup && Object.keys(otherFlags).length > 0) log.info(pc.dim("Command-line options applied."));
 			config = yield* Result.await(Result.tryPromise({
-				try: async () => gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput),
+				try: async () => gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput, { skipCompatibilityChecks: cliInput.yolo }),
 				catch: (e) => {
 					if (e instanceof UserCancelledError) return e;
 					return new CLIError({
@@ -7498,12 +8232,16 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 			const addonsValidationResult = validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth, config.backend, config.runtime);
 			if (addonsValidationResult.isErr()) return Result.err(new CLIError({ message: addonsValidationResult.error.message }));
 		}
+		if (!isSilent()) {
+			log.info(pc.magenta(pc.bold("Stack ready")));
+			log.message(displayConfig(config));
+		}
 		const reproducibleCommand = generateReproducibleCommand(config);
 		if (input.dryRun) {
 			const elapsedTimeMs = Date.now() - startTime;
 			if (!isSilent()) {
 				if (shouldClearDirectory) log.warn(pc.yellow(`Dry run: directory "${finalPathInput}" would be cleared due to overwrite strategy.`));
-				log.success(pc.green("Dry run validation passed. No files were written."));
+				log.success(pc.green("Configuration ready. No files were written."));
 				log.message(pc.dim(`Target directory: ${finalResolvedPath}`));
 				log.message(pc.dim(`Run without --dry-run to create the project.`));
 				outro(pc.magenta("Dry run complete."));
@@ -7522,14 +8260,19 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 			manualDb: cliInput.manualDb ?? input.manualDb,
 			dbSetupOptions: effectiveDbSetupOptions
 		}));
-		if (!isSilent()) log.success(pc.blue(`You can reproduce this setup with the following command:\n${reproducibleCommand}`));
 		await trackProjectCreation(config, input.disableAnalytics);
 		const historyResult = await addToHistory(config, reproducibleCommand);
-		if (historyResult.isErr() && !isSilent()) log.warn(pc.yellow(historyResult.error.message));
+		if (historyResult.isErr() && !isSilent()) {
+			log.warn(pc.yellow(historyResult.error.message));
+			log.message(`${pc.dim("Recreate this stack")}\n${pc.cyan(reproducibleCommand)}`);
+		} else if (!isSilent()) {
+			const historyCommand = getCliSubcommandCommand("history", config.packageManager);
+			log.message(`${pc.dim("Setup saved to history")}\n${pc.cyan(historyCommand)}`);
+		}
 		const elapsedTimeMs = Date.now() - startTime;
 		if (!isSilent()) {
-			const elapsedTimeInSeconds = (elapsedTimeMs / 1e3).toFixed(2);
-			outro(pc.magenta(`Project created successfully in ${pc.bold(elapsedTimeInSeconds)} seconds!`));
+			const elapsedTimeInSeconds = (elapsedTimeMs / 1e3).toFixed(1);
+			outro(pc.magenta(`Project ready in ${pc.bold(`${elapsedTimeInSeconds}s`)}`));
 		}
 		return Result.ok({
 			success: true,
@@ -7582,15 +8325,23 @@ async function handleDirectoryConflictResult(currentPathInput, strategy) {
 	});
 }
 async function handleDirectoryConflictProgrammatically(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({
+	const pathStateResult = await inspectProjectPath(path.resolve(process.cwd(), currentPathInput));
+	if (pathStateResult.isErr()) return Result.err(pathStateResult.error);
+	const pathState = pathStateResult.value;
+	if (pathState === "missing" || pathState === "empty-directory") return Result.ok({
 		finalPathInput: currentPathInput,
 		shouldClearDirectory: false
 	});
+	if (strategy === "increment") {
+		const incrementResult = await findAvailableIncrementedPath(currentPathInput);
+		if (incrementResult.isErr()) return Result.err(incrementResult.error);
+		return Result.ok({
+			finalPathInput: incrementResult.value,
+			shouldClearDirectory: false
+		});
+	}
+	if (pathState === "symbolic-link") return Result.err(new CLIError({ message: `Project path "${currentPathInput}" is a symbolic link. Choose a real directory or use directoryConflict: "increment".` }));
+	if (pathState === "non-directory") return Result.err(new CLIError({ message: `Project path "${currentPathInput}" exists and is not a directory. Choose a different path or use directoryConflict: "increment".` }));
 	switch (strategy) {
 		case "overwrite": return Result.ok({
 			finalPathInput: currentPathInput,
@@ -7600,19 +8351,6 @@ async function handleDirectoryConflictProgrammatically(currentPathInput, strateg
 			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++;
-				finalPathInput = `${baseName}-${counter}`;
-			}
-			return Result.ok({
-				finalPathInput,
-				shouldClearDirectory: false
-			});
-		}
 		case "error": return Result.err(new DirectoryConflictError({ directory: currentPathInput }));
 		default: return Result.err(new DirectoryConflictError({ directory: currentPathInput }));
 	}
@@ -7647,6 +8385,10 @@ const SchemaNameSchema = z.enum([
 	"betterTStackConfigFile",
 	"initResult"
 ]).default("all");
+const CreateVirtualInputSchema = types_exports.ProjectConfigSchema.omit({
+	projectDir: true,
+	relativePath: true
+}).partial().strict();
 const t = initTRPC.meta().create();
 function getCliSchemaJson() {
 	return createCli({
@@ -7702,11 +8444,11 @@ const router = t.router({
 			projectName,
 			...options
 		});
-		if (options.verbose || options.dryRun) return result;
+		if (options.verbose) return result;
 	}),
 	createJson: t.procedure.meta({
 		description: "Create a project from a raw JSON payload (agent-friendly)",
-		jsonInput: true
+		jsonInput: "always"
 	}).input(types_exports.CreateInputSchema).mutation(async ({ input }) => {
 		const result = await createProjectHandler(input, { silent: true });
 		if (!result) throw new UserCancelledError({ message: "Operation cancelled" });
@@ -7721,13 +8463,14 @@ const router = t.router({
 		addons: z.array(types_exports.AddonsSchema).optional().describe("Addons to add"),
 		install: z.boolean().optional().default(false).describe("Install dependencies after adding"),
 		packageManager: types_exports.PackageManagerSchema.optional().describe("Package manager to use"),
-		projectDir: z.string().optional().describe("Project directory (defaults to current)")
+		projectDir: z.string().optional().describe("Project directory (defaults to current)"),
+		dryRun: z.boolean().optional().default(false).describe("Preview addon changes without writing files")
 	})).mutation(async ({ input }) => {
 		await addHandler(input);
 	}),
 	addJson: t.procedure.meta({
 		description: "Add addons from a raw JSON payload (agent-friendly)",
-		jsonInput: true
+		jsonInput: "always"
 	}).input(types_exports.AddInputSchema).mutation(async ({ input }) => {
 		const result = await addHandler(input, { silent: true });
 		if (!result) throw new UserCancelledError({ message: "Operation cancelled" });
@@ -7749,6 +8492,12 @@ function createBtsCli() {
 		version: getLatestCLIVersion()
 	});
 }
+function formatInputValidationError(label, error) {
+	return `Invalid ${label} input: ${error.issues.map((issue) => {
+		const field = issue.path.join(".");
+		return field ? `${field}: ${issue.message}` : issue.message;
+	}).join("; ")}`;
+}
 /**
 * Programmatic API to create a new Better-T-Stack project.
 * Returns a Result type - no console output, no interactive prompts.
@@ -7775,13 +8524,21 @@ function createBtsCli() {
 * ```
 */
 async function create(projectName, options) {
-	const input = {
+	const rawInput = options === void 0 || typeof options === "object" && options !== null ? {
 		...options,
-		projectName,
+		projectName
+	} : options;
+	const parsedInput = types_exports.CreateInputSchema.safeParse(rawInput);
+	if (!parsedInput.success) return Result.err(new CLIError({
+		message: formatInputValidationError("create", parsedInput.error),
+		cause: parsedInput.error
+	}));
+	const input = {
+		...parsedInput.data,
 		renderTitle: false,
 		verbose: true,
-		disableAnalytics: options?.disableAnalytics ?? true,
-		directoryConflict: options?.directoryConflict ?? "error"
+		disableAnalytics: parsedInput.data.disableAnalytics ?? true,
+		directoryConflict: parsedInput.data.directoryConflict ?? "error"
 	};
 	return Result.tryPromise({
 		try: async () => {
@@ -7834,30 +8591,37 @@ async function builder() {
 * ```
 */
 async function createVirtual(options) {
+	const parsedInput = CreateVirtualInputSchema.safeParse(options);
+	if (!parsedInput.success) return Result.err(new GeneratorError({
+		message: formatInputValidationError("virtual create", parsedInput.error),
+		phase: "validation",
+		cause: parsedInput.error
+	}));
+	const virtualOptions = parsedInput.data;
 	const config = {
-		projectName: options.projectName || "my-project",
+		projectName: virtualOptions.projectName || "my-project",
 		projectDir: "/virtual",
 		relativePath: "./virtual",
-		addonOptions: options.addonOptions,
-		dbSetupOptions: options.dbSetupOptions,
-		database: options.database || "none",
-		orm: options.orm || "none",
-		backend: options.backend || "hono",
-		runtime: options.runtime || "bun",
-		frontend: options.frontend || ["tanstack-router"],
-		addons: options.addons || [],
-		examples: options.examples || [],
-		auth: options.auth || "none",
-		payments: options.payments || "none",
-		git: options.git ?? false,
-		packageManager: options.packageManager || "bun",
+		addonOptions: virtualOptions.addonOptions,
+		dbSetupOptions: virtualOptions.dbSetupOptions,
+		database: virtualOptions.database || "none",
+		orm: virtualOptions.orm || "none",
+		backend: virtualOptions.backend || "hono",
+		runtime: virtualOptions.runtime || "bun",
+		frontend: virtualOptions.frontend || ["tanstack-router"],
+		addons: virtualOptions.addons || [],
+		examples: virtualOptions.examples || [],
+		auth: virtualOptions.auth || "none",
+		payments: virtualOptions.payments || "none",
+		git: virtualOptions.git ?? false,
+		packageManager: virtualOptions.packageManager || "bun",
 		install: false,
-		dbSetup: options.dbSetup || "none",
-		api: options.api || "trpc",
-		webDeploy: options.webDeploy || "none",
-		serverDeploy: options.serverDeploy || "none"
+		dbSetup: virtualOptions.dbSetup || "none",
+		api: virtualOptions.api || "trpc",
+		webDeploy: virtualOptions.webDeploy || "none",
+		serverDeploy: virtualOptions.serverDeploy || "none"
 	};
-	const validationResult = validateConfigCompatibility(config, new Set([
+	const validationResult = validateConfigCompatibility(config, /* @__PURE__ */ new Set([
 		"database",
 		"orm",
 		"backend",
@@ -7894,13 +8658,25 @@ async function createVirtual(options) {
 *   install: true,
 * });
 *
-* if (result?.success) {
+* if (result.success) {
 *   console.log(`Added: ${result.addedAddons.join(", ")}`);
 * }
 * ```
 */
 async function add(options = {}) {
-	return addHandler(options, { silent: true });
+	const parsedInput = types_exports.AddInputSchema.safeParse(options);
+	if (!parsedInput.success) return {
+		success: false,
+		addedAddons: [],
+		projectDir: "",
+		error: formatInputValidationError("add", parsedInput.error)
+	};
+	return await addHandler(parsedInput.data, { silent: true }) ?? {
+		success: false,
+		addedAddons: [],
+		projectDir: parsedInput.data.projectDir ?? "",
+		error: "Operation cancelled"
+	};
 }
 //#endregion
 export { ProjectCreationError as C, DirectoryConflictError as S, ValidationError as T, types_exports as _, TEMPLATE_COUNT as a, CompatibilityError as b, builder as c, createVirtual as d, docs as f, sponsors as g, router as h, SchemaNameSchema as i, create as l, getSchemaResult as m, GeneratorError$1 as n, VirtualFileSystem$1 as o, generate$1 as p, Result$1 as r, add as s, EMBEDDED_TEMPLATES$1 as t, createBtsCli as u, getLatestCLIVersion as v, UserCancelledError as w, DatabaseSetupError as x, CLIError as y };