@terreno/mcp 57.3.0 → 57.4.0

package/dist/bootstrap.js

@@ -1,34 +1,5 @@
 import { composePackageGuidelinesForRules, filterGuidelineIdsForRootRules, loadPackageGuidelineMarkdown, resolveBootstrapGuidelinePackages, } from "./packageGuidelines.js";
-/** Pinned so `npx -y` does not resolve a moving `@latest` target in generated MCP configs. */
-export const PLAYWRIGHT_MCP_PACKAGE_VERSION = "0.0.76";
 export const bootstrapTools = [
-    {
-        description: "Bootstrap a new Terreno full-stack application with frontend (Expo/React Native) and backend (Express/Mongoose) directories, including Cursor rules and MCP settings",
-        inputSchema: {
-            properties: {
-                appDisplayName: {
-                    description: "Human-readable display name (e.g., 'My Todo App', 'Task Manager')",
-                    type: "string",
-                },
-                appName: {
-                    description: "The application name in kebab-case (e.g., 'my-app', 'todo-app'). Used for directory names and package names.",
-                    type: "string",
-                },
-                description: {
-                    description: "A brief description of the app (optional)",
-                    type: "string",
-                },
-                mcpServerUrl: {
-                    default: "https://mcp.terreno.flourish.health",
-                    description: "URL of the Terreno MCP server for AI assistance",
-                    type: "string",
-                },
-            },
-            required: ["appName", "appDisplayName"],
-            type: "object",
-        },
-        name: "terreno_bootstrap_app",
-    },
     {
         description: "Bootstrap AI coding assistant rules for a Terreno project. Creates configuration files for Cursor, Windsurf, Claude Code, and GitHub Copilot with Terreno-specific guidelines adapted for the project.",
         inputSchema: {
@@ -57,2156 +28,6 @@ export const bootstrapTools = [
         name: "terreno_bootstrap_ai_rules",
     },
 ];
-const _toPascalCase = (str) => {
-    return str
-        .split("-")
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join("");
-};
-const generateCursorRules = (args) => {
-    const { appDisplayName } = args;
-    return `# ${appDisplayName}
-
-A full-stack application built with the Terreno framework.
-
-## Project Structure
-
-- **frontend/** - Expo/React Native frontend using @terreno/ui, @terreno/syncdb, and @terreno/rtk (SDK + Better Auth)
-- **backend/** - Express/Mongoose backend using @terreno/api
-
-## Development
-
-Uses [Bun](https://bun.sh/) as the package manager.
-
-\`\`\`bash
-# Backend
-cd backend && bun run dev    # Start backend on port 4000
-
-# Frontend
-cd frontend && bun run web   # Start web frontend
-cd frontend && bun run sdk   # Regenerate SDK after backend changes
-\`\`\`
-
-## Code Style
-
-### TypeScript/JavaScript
-- Use ES module syntax and TypeScript for all code
-- Prefer interfaces over types; avoid enums, use maps
-- Prefer const arrow functions over \`function\` keyword
-- Use descriptive variable names with auxiliary verbs (e.g., \`isLoading\`)
-- Favor named exports
-- Use the RORO pattern (Receive an Object, Return an Object)
-
-### Dates and Time
-- Always use Luxon instead of Date or dayjs
-
-### Error Handling
-- Check error conditions at start of functions and return early
-- Limit nested if statements
-- Use multiline syntax with curly braces for all conditionals
-
-### React Best Practices
-- Use functional components with \`React.FC\` type
-- Add explanatory comment above each \`useEffect\`
-- Wrap callbacks in \`useCallback\`
-- Use Redux Toolkit for state management
-
-### Backend Conventions
-- Use \`modelRouter\` for CRUD endpoints
-- Use \`APIError\` for error responses
-- Use \`logger.info/warn/error/debug\` for logging
-- Use \`Model.findExactlyOne\` or \`Model.findOneOrNone\` (not \`Model.findOne\`)
-
-### Frontend Conventions
-- Use \`@terreno/syncdb/react\` hooks (\`useQuery\`, \`useMutate\`) for synced collection CRUD
-- Use generated SDK hooks from \`@/store/openApiSdk\` for non-synced routes only
-- Use @terreno/ui components (Box, Page, Button, TextField, etc.)
-- Never modify \`openApiSdk.ts\` manually - regenerate with \`bun run sdk\`
-
-## AI Assistance
-
-This project is configured to use the Terreno MCP server for AI-assisted development.
-Use the MCP tools and prompts for:
-- Generating new models and routes
-- Creating screens and forms
-- Following Terreno patterns and best practices
-`;
-};
-const generateMcpSettings = (args) => {
-    const mcpUrl = args.mcpServerUrl || "https://mcp.terreno.flourish.health";
-    return JSON.stringify({
-        mcpServers: {
-            expo: {
-                type: "http",
-                url: "https://mcp.expo.dev/mcp",
-            },
-            playwright: {
-                args: ["-y", `@playwright/mcp@${PLAYWRIGHT_MCP_PACKAGE_VERSION}`],
-                command: "npx",
-            },
-            terreno: {
-                type: "http",
-                url: `${mcpUrl}/mcp`,
-            },
-            "terreno-local": {
-                args: ["terreno-mcp-local"],
-                command: "bunx",
-            },
-        },
-    }, null, 2);
-};
-const generateRootGitignore = () => {
-    return [
-        "# Dependencies",
-        "node_modules/",
-        "",
-        "# Local Terreno dev logs (winston JSONL + optional browser fallback)",
-        ".terreno/",
-        "",
-        "# Build outputs",
-        "dist/",
-        "build/",
-        "",
-        "# OS",
-        ".DS_Store",
-        "",
-    ].join("\n");
-};
-const generateClaudeMd = (args) => {
-    const { appDisplayName } = args;
-    return `# ${appDisplayName}
-
-A full-stack application built with the Terreno framework.
-
-## Project Structure
-
-- **frontend/** - Expo/React Native frontend
-- **backend/** - Express/Mongoose backend
-
-## Development
-
-\`\`\`bash
-# Install dependencies
-cd backend && bun install
-cd frontend && bun install
-
-# Start backend (port 4000)
-cd backend && bun run dev
-
-# Start frontend (port 8082)
-cd frontend && bun run web
-
-# Regenerate SDK after backend changes
-cd frontend && bun run sdk
-\`\`\`
-
-## Adding Features
-
-1. Create model in \`backend/src/models/\`
-2. Create route in \`backend/src/api/\`
-3. Register route in \`backend/src/server.ts\`
-4. Regenerate SDK: \`cd frontend && bun run sdk\`
-5. Create screens in \`frontend/app/\`
-
-## Code Style
-
-- Use TypeScript with ES modules
-- Use Luxon for dates
-- Prefer const arrow functions
-- Named exports preferred
-- Use interfaces over types
-`;
-};
-// Backend file generators
-const generateBackendPackageJson = (args) => {
-    const { appName } = args;
-    return JSON.stringify({
-        dependencies: {
-            "@terreno/admin-backend": "latest",
-            "@terreno/api": "latest",
-            luxon: "^3.7.2",
-            mongoose: "^9.7.4",
-            "passport-local-mongoose": "^9.0.1",
-        },
-        devDependencies: {
-            "@biomejs/biome": "^2.3.6",
-            "@types/bun": "^1.4.0",
-            "@types/express": "^4.17.21",
-            "@types/luxon": "^3.7.1",
-            typescript: "~5.9.2",
-        },
-        name: `@${appName}/backend`,
-        private: true,
-        scripts: {
-            build: "bun build src/index.ts --outdir ./dist --target node",
-            compile: "tsc",
-            dev: "PORT=4000 bun run --watch src/index.ts",
-            format: "biome format --write .",
-            lint: "biome check .",
-            "lint:fix": "biome check --write .",
-            "lint:unsafefix": "biome check --write . --unsafe",
-            seed: "bun run src/scripts/seed.ts",
-            start: "bun run src/index.ts",
-            test: "bun test",
-        },
-        type: "module",
-        version: "1.0.0",
-    }, null, 2);
-};
-const generateBackendTsConfig = () => {
-    return JSON.stringify({
-        compilerOptions: {
-            allowSyntheticDefaultImports: true,
-            esModuleInterop: true,
-            lib: ["ESNext"],
-            module: "ESNext",
-            moduleResolution: "bundler",
-            noEmit: true,
-            outDir: "./dist",
-            resolveJsonModule: true,
-            skipLibCheck: true,
-            strict: true,
-            target: "ESNext",
-            types: ["bun-types"],
-        },
-        exclude: ["node_modules", "dist"],
-        include: ["src/**/*"],
-    }, null, 2);
-};
-const generateBackendBiomeJsonc = () => {
-    return `{
-  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
-  "assist": {
-    "actions": {
-      "source": {
-        "organizeImports": "on",
-        "useSortedAttributes": "on",
-        "useSortedKeys": "on"
-      }
-    },
-    "enabled": true
-  },
-  "files": {
-    "includes": [
-      "package.json",
-      "src/**/*.ts",
-      "src/**/*.tsx",
-      "!!**/node_modules",
-      "!!**/dist",
-      "!!**/build",
-      "!!**/coverage",
-      "!!**/.git"
-    ]
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineWidth": 100
-  },
-  "javascript": {
-    "formatter": {
-      "arrowParentheses": "always",
-      "bracketSpacing": false,
-      "jsxQuoteStyle": "double",
-      "quoteStyle": "double",
-      "semicolons": "always",
-      "trailingCommas": "es5"
-    },
-    // TODO: Remove once we don't need to import React from 'react' in our JSX files.
-    "jsxRuntime": "reactClassic"
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "nursery": {
-        "noFloatingPromises": "error",
-        "noMisusedPromises": "error",
-        "useExhaustiveSwitchCases": "error"
-      },
-      "recommended": true,
-      "suspicious": {
-        "noConsole": {
-          "level": "error",
-          "options": {
-            "allow": ["assert", "debug", "error", "info", "warn"]
-          }
-        },
-        "noExplicitAny": "off",
-        "noImplicitAnyLet": "off"
-      }
-    }
-  },
-  "vcs": {
-    "clientKind": "git",
-    "defaultBranch": "master",
-    "enabled": true
-  }
-}
-`;
-};
-const generateBackendIndex = () => {
-    return `import "./server";
-`;
-};
-const generateBackendServer = (args) => {
-    const { appDisplayName } = args;
-    return `import {AdminApp} from "@terreno/admin-backend";
-import {
-  BetterAuthApp,
-  checkModelsStrict,
-  createBetterAuth,
-  getMongoClientFromMongoose,
-  logger,
-  RealtimeApp,
-  SyncApp,
-  TerrenoApp,
-  type UserModel as TerrenoAuthUserModel,
-} from "@terreno/api";
-import type express from "express";
-import {userRouter} from "./api/users";
-import {AppConfiguration} from "./models/appConfiguration";
-import {User} from "./models/user";
-import {buildBetterAuthConfig, getWebOrigins} from "./utils/betterAuthConfig";
-import {connectToMongoDB} from "./utils/database";
-
-const isDeployed = process.env.NODE_ENV === "production";
-
-export async function start(skipListen = false): Promise<express.Application> {
-  await connectToMongoDB();
-
-  logger.info(\`Starting ${appDisplayName} server on port \${process.env.PORT || 4000}\`);
-
-  if (!isDeployed) {
-    checkModelsStrict();
-  }
-
-  const betterAuthConfig = buildBetterAuthConfig();
-  const betterAuthInstance = betterAuthConfig
-    ? createBetterAuth({
-        config: betterAuthConfig,
-        mongoClient: getMongoClientFromMongoose(),
-        // noExplicitAny: User model type mismatch
-        // biome-ignore lint/suspicious/noExplicitAny: User model type mismatch
-        userModel: User as any,
-      })
-    : undefined;
-
-  const app = new TerrenoApp({
-    corsOrigin: getWebOrigins(),
-    loggingOptions: {
-      disableConsoleColors: isDeployed,
-      level: "debug",
-      logRequests: !isDeployed,
-    },
-    skipListen,
-    // noExplicitAny: User model type mismatch
-    // biome-ignore lint/suspicious/noExplicitAny: User model type mismatch
-    userModel: User as any,
-  }).configure(AppConfiguration);
-
-  if (betterAuthConfig) {
-    app.register(
-      new BetterAuthApp({
-        config: betterAuthConfig,
-        userModel: User as unknown as TerrenoAuthUserModel,
-      })
-    );
-  }
-
-  app
-    .register(userRouter)
-    .register(
-      new AdminApp({
-        models: [
-          {
-            displayName: "Users",
-            listFields: ["email", "name", "admin", "created"],
-            // noExplicitAny: User model type mismatch
-            // biome-ignore lint/suspicious/noExplicitAny: User model type mismatch
-            model: User as any,
-            routePath: "/users",
-          },
-        ],
-      })
-    )
-    .register(new SyncApp())
-    .register(
-      new RealtimeApp({
-        betterAuth: betterAuthInstance
-          ? {
-              auth: betterAuthInstance,
-              // noExplicitAny: User model type mismatch
-              // biome-ignore lint/suspicious/noExplicitAny: User model type mismatch
-              userModel: User as any,
-            }
-          : undefined,
-        // noExplicitAny: User model type mismatch
-        // biome-ignore lint/suspicious/noExplicitAny: User model type mismatch
-        userModel: User as any,
-      })
-    )
-    .start();
-
-  return app;
-}
-
-start().catch((error) => {
-  logger.error(\`Fatal error starting server: \${error}\`);
-});
-`;
-};
-const generateBackendDatabase = (args) => {
-    const { appName } = args;
-    const dbName = appName.replace(/-/g, "_");
-    return `import {logger} from "@terreno/api";
-import mongoose from "mongoose";
-
-export const connectToMongoDB = async (): Promise<void> => {
-  if (mongoose.connection.readyState === 1) {
-    logger.info("Already connected to MongoDB");
-    return;
-  }
-
-  const mongoURI =
-    process.env.MONGO_URI || "mongodb://127.0.0.1:27017/${dbName}?replicaSet=rs0";
-
-  try {
-    await mongoose.connect(mongoURI);
-    logger.info("Connected to MongoDB");
-  } catch (error: unknown) {
-    logger.error(\`MongoDB connection error: \${error}\`);
-    throw error;
-  }
-
-  mongoose.connection.on("error", (error: unknown) => {
-    logger.error(\`MongoDB connection error: \${error}\`);
-  });
-
-  mongoose.connection.on("disconnected", () => {
-    logger.warn("MongoDB disconnected");
-  });
-};
-`;
-};
-const generateBackendSeed = () => {
-    return `import {
-  APIError,
-  createBetterAuth,
-  getMongoClientFromMongoose,
-  logger,
-  runSeedCli,
-  seedBetterAuthUser,
-  type SeedStep,
-  type UserModel as TerrenoAuthUserModel,
-} from "@terreno/api";
-import mongoose from "mongoose";
-
-import {User} from "../models/user";
-import {buildBetterAuthConfig} from "../utils/betterAuthConfig";
-import {connectToMongoDB} from "../utils/database";
-
-const SEED_USERS = [
-  {
-    admin: false,
-    email: "test@example.com",
-    name: "Test User",
-    password: "testpassword123",
-  },
-  {
-    admin: true,
-    email: "admin@example.com",
-    name: "Admin User",
-    password: "testpassword123",
-  },
-];
-
-const seedSteps: SeedStep[] = [
-  {
-    description: "Create login-ready development users and reconcile profile fields",
-    name: "users",
-    run: async (context) => {
-      if (context.dryRun) {
-        for (const user of SEED_USERS) {
-          const existing = await User.findByEmail(user.email);
-          context.changes.push({
-            change: existing ? "updated" : "created",
-            count: 1,
-            key: JSON.stringify({email: user.email}),
-            model: User.modelName,
-          });
-        }
-        return;
-      }
-
-      const config = buildBetterAuthConfig();
-      if (!config) {
-        throw new APIError({
-          status: 500,
-          title: "Seed users require Better Auth to be enabled",
-        });
-      }
-      const auth = createBetterAuth({
-        config,
-        mongoClient: getMongoClientFromMongoose(),
-        userModel: User as unknown as TerrenoAuthUserModel,
-      });
-      for (const definition of SEED_USERS) {
-        const user = await seedBetterAuthUser({
-          auth,
-          user: definition,
-          userModel: User as unknown as TerrenoAuthUserModel,
-        });
-        const appUser = user as unknown as {
-          admin: boolean;
-          save: () => Promise<unknown>;
-        };
-        appUser.admin = definition.admin;
-        await appUser.save();
-      }
-    },
-  },
-];
-
-const main = async (): Promise<void> => {
-  const cli = await runSeedCli({
-    allowProductionReset: () => process.env.ALLOW_SEED_RESET === "true",
-    connect: connectToMongoDB,
-    disconnect: async () => {
-      await mongoose.disconnect();
-    },
-    name: "bun run seed",
-    steps: seedSteps,
-  });
-  if (cli.help) {
-    logger.info(cli.help);
-  }
-  process.exit(cli.exitCode);
-};
-
-main().catch((error: unknown) => {
-  logger.error(\`Seed failed: \${error}\`);
-  process.exit(1);
-});
-`;
-};
-const generateBackendBetterAuthConfig = (args) => {
-    const { appName } = args;
-    return `import type {AuthProvider, BetterAuthConfig} from "@terreno/api";
-
-const DEFAULT_BETTER_AUTH_SECRET = "${appName}-better-auth-secret-dev-only-32chars";
-const DEFAULT_BETTER_AUTH_URL = "http://localhost:4000";
-const DEFAULT_WEB_ORIGINS = ["http://localhost:8082", "http://127.0.0.1:8082"];
-const APP_SCHEMES = ["${appName}://", "exp://"];
-
-export const getAuthProvider = (): AuthProvider => {
-  const provider = process.env.AUTH_PROVIDER as AuthProvider | undefined;
-  return provider ?? "better-auth";
-};
-
-export const getWebOrigins = (): string[] => {
-  const origins = new Set<string>(DEFAULT_WEB_ORIGINS);
-  const fromEnv = process.env.CORS_ORIGINS?.split(",")
-    .map((value) => value.trim())
-    .filter(Boolean);
-  for (const origin of fromEnv ?? []) {
-    origins.add(origin);
-  }
-  return [...origins];
-};
-
-export const buildBetterAuthConfig = (): BetterAuthConfig | undefined => {
-  if (getAuthProvider() !== "better-auth") {
-    return undefined;
-  }
-
-  return {
-    baseURL: process.env.BETTER_AUTH_URL ?? DEFAULT_BETTER_AUTH_URL,
-    crossDomainCookies: process.env.CROSS_DOMAIN_AUTH_COOKIES === "true",
-    enabled: true,
-    secret: process.env.BETTER_AUTH_SECRET ?? DEFAULT_BETTER_AUTH_SECRET,
-    trustedOrigins: [...APP_SCHEMES, ...getWebOrigins()],
-  };
-};
-`;
-};
-const generateBackendModelPlugins = () => {
-    return `import {
-  createdUpdatedPlugin,
-  findExactlyOne,
-  findOneOrNone,
-  isDeletedPlugin,
-} from "@terreno/api";
-import type mongoose from "mongoose";
-
-// noExplicitAny: Leaving open for flexibility
-// biome-ignore lint/suspicious/noExplicitAny: Leaving open for flexibility
-export function addDefaultPlugins(schema: mongoose.Schema<any, any, any, any>): void {
-  schema.plugin(createdUpdatedPlugin);
-  schema.plugin(isDeletedPlugin);
-  schema.plugin(findOneOrNone);
-  schema.plugin(findExactlyOne);
-}
-`;
-};
-const generateBackendUserModel = () => {
-    return `import mongoose from "mongoose";
-import passportLocalMongoose from "passport-local-mongoose";
-import type {UserDocument, UserModel} from "../types";
-import {addDefaultPlugins} from "./modelPlugins";
-
-const userSchema = new mongoose.Schema<UserDocument, UserModel>(
-  {
-    admin: {
-      default: false,
-      type: Boolean,
-    },
-    betterAuthId: {
-      index: true,
-      sparse: true,
-      type: String,
-    },
-    email: {
-      lowercase: true,
-      required: true,
-      trim: true,
-      type: String,
-      unique: true,
-    },
-    name: {
-      required: true,
-      trim: true,
-      type: String,
-    },
-  },
-  {strict: "throw", toJSON: {virtuals: true}, toObject: {virtuals: true}}
-);
-
-userSchema.plugin(passportLocalMongoose, {
-  usernameField: "email",
-});
-
-addDefaultPlugins(userSchema);
-
-userSchema.method("getDisplayName", function (this: UserDocument): string {
-  return this.name;
-});
-
-export const User = mongoose.model<UserDocument, UserModel>("User", userSchema);
-
-User.findByEmail = async function (email: string): Promise<UserDocument | null> {
-  return this.findOneOrNone({email: email.toLowerCase()});
-};
-`;
-};
-const generateBackendAppConfiguration = (args) => {
-    const { appDisplayName } = args;
-    return `import {configurationPlugin, createdUpdatedPlugin} from "@terreno/api";
-import mongoose, {Schema} from "mongoose";
-
-const generalSchema = new Schema(
-  {
-    appName: {
-      default: "${appDisplayName}",
-      description: "Display name of the application",
-      type: String,
-    },
-    maintenanceMode: {
-      default: false,
-      description: "When enabled, the app returns 503 for all non-admin requests",
-      type: Boolean,
-    },
-  },
-  {_id: false}
-);
-
-const debugSchema = new Schema(
-  {
-    websocketsDebug: {
-      default: false,
-      description: "Enable verbose WebSocket and realtime sync debug logging",
-      type: Boolean,
-    },
-  },
-  {_id: false}
-);
-
-export interface AppConfigDocument {
-  general: {
-    appName: string;
-    maintenanceMode: boolean;
-  };
-  debug: {
-    websocketsDebug: boolean;
-  };
-}
-
-const appConfigSchema = new Schema<AppConfigDocument>(
-  {
-    general: {
-      description: "General application settings",
-      type: generalSchema,
-    },
-    debug: {
-      description: "Debug and diagnostic settings",
-      type: debugSchema,
-    },
-  },
-  {strict: "throw", toJSON: {virtuals: true}, toObject: {virtuals: true}}
-);
-
-appConfigSchema.plugin(configurationPlugin);
-appConfigSchema.plugin(createdUpdatedPlugin);
-
-export const AppConfiguration = mongoose.model<AppConfigDocument>(
-  "AppConfiguration",
-  appConfigSchema
-);
-`;
-};
-const generateBackendModelsIndex = () => {
-    return `export * from "./appConfiguration";
-export * from "./user";
-`;
-};
-const generateBackendUserRoutes = () => {
-    return `import {Permissions, modelRouter} from "@terreno/api";
-import {User} from "../models/user";
-
-export const userRouter = modelRouter("/users", User, {
-  permissions: {
-    create: [Permissions.IsAdmin],
-    delete: [Permissions.IsAdmin],
-    list: [Permissions.IsAuthenticated],
-    read: [Permissions.IsAuthenticated],
-    update: [Permissions.IsAdmin],
-  },
-  queryFields: ["email", "name"],
-  sort: "name",
-});
-`;
-};
-const generateBackendTypes = () => {
-    return `export * from "./models";
-`;
-};
-const generateBackendTypesModels = () => {
-    return `export * from "./userTypes";
-`;
-};
-const generateBackendUserTypes = () => {
-    return `import type {APIErrorConstructor} from "@terreno/api";
-import type mongoose from "mongoose";
-import type {Document, Model} from "mongoose";
-
-type ModelQuery<T> = Partial<Record<keyof T, unknown>> & Record<string, unknown>;
-
-export interface DefaultStatics<T> {
-  findOneOrNone(
-    query: ModelQuery<T>,
-    errorArgs?: Partial<APIErrorConstructor>
-  ): Promise<(Document & T) | null>;
-
-  findExactlyOne(
-    query: ModelQuery<T>,
-    errorArgs?: Partial<APIErrorConstructor>
-  ): Promise<Document & T>;
-}
-
-export interface DefaultPluginFields {
-  created: Date;
-  updated: Date;
-  deleted: boolean;
-}
-
-export type DefaultModel<T> = Model<T & DefaultPluginFields> & DefaultStatics<T>;
-export type DefaultDoc = mongoose.Document<mongoose.Types.ObjectId> & DefaultPluginFields;
-
-export type UserMethods = {
-  getDisplayName: (this: UserDocument) => string;
-};
-
-export type UserStatics = DefaultStatics<UserDocument> & {
-  findByEmail: (this: UserModel, email: string) => Promise<UserDocument | null>;
-};
-
-export type UserModel = DefaultModel<UserDocument> &
-  UserStatics &
-  mongoose.PassportLocalModel<UserDocument>;
-
-export type UserSchema = mongoose.Schema<UserDocument, UserModel, UserMethods>;
-
-export type UserDocument = DefaultDoc &
-  UserMethods &
-  mongoose.PassportLocalDocument & {
-    admin: boolean;
-    betterAuthId?: string;
-    email: string;
-    name: string;
-  };
-`;
-};
-// Frontend file generators
-const generateFrontendPackageJson = (args) => {
-    const { appName } = args;
-    return JSON.stringify({
-        dependencies: {
-            "@expo/vector-icons": "^15.1.1",
-            "@react-native-async-storage/async-storage": "2.2.0",
-            "@reduxjs/toolkit": "^2.11.1",
-            "@sentry/react": "^10.29.0",
-            "@terreno/admin-frontend": "latest",
-            "@terreno/rtk": "latest",
-            "@terreno/syncdb": "latest",
-            "@terreno/ui": "latest",
-            expo: "~57.0.14",
-            "expo-constants": "~18.0.13",
-            "expo-router": "~57.0.14",
-            "expo-sqlite": "~16.0.10",
-            lodash: "^4.18.1",
-            luxon: "^3.7.2",
-            react: "19.2.3",
-            "react-dom": "19.2.3",
-            "react-native": "0.86.2",
-            "react-native-reanimated": "4.5.1",
-            "react-redux": "^9.2.0",
-            "redux-persist": "^6.0.0",
-        },
-        devDependencies: {
-            "@biomejs/biome": "^2.3.6",
-            "@playwright/test": "^1.58.2",
-            "@rtk-query/codegen-openapi": "^2.2.0",
-            "@types/lodash": "^4.17.17",
-            "@types/luxon": "^3.7.1",
-            "@types/react": "~19.2.14",
-            tsx: "^4.23.12",
-            typescript: "~6.0.3",
-        },
-        main: "expo-router/entry",
-        name: `@${appName}/frontend`,
-        private: true,
-        scripts: {
-            android: "EXPO_UNSTABLE_MCP_SERVER=1 bun expo start --android --port 8082",
-            compile: "tsc",
-            ios: "EXPO_UNSTABLE_MCP_SERVER=1 bun expo start --ios --port 8082",
-            lint: "bun biome check .",
-            "lint:fix": "bun biome check --write .",
-            "lint:unsafefix": "biome check --write . --unsafe",
-            sdk: "bun scripts/generate-sdk.ts && bun biome check --write scripts/generate-sdk.ts",
-            start: "EXPO_UNSTABLE_MCP_SERVER=1 bun expo start --port 8082",
-            test: "bun test",
-            web: "EXPO_UNSTABLE_MCP_SERVER=1 bun expo start --web --port 8082",
-        },
-        version: "1.0.0",
-    }, null, 2);
-};
-const generateFrontendAppJson = (args) => {
-    const { appDisplayName, appName } = args;
-    return JSON.stringify({
-        // No icon/splash/favicon keys: Expo falls back to its built-in defaults, so a freshly
-        // generated app bundles without any binary assets. Add your own branding later and
-        // point `icon`, `android.adaptiveIcon`, `splash`, and `web.favicon` at those files.
-        expo: {
-            experiments: {
-                typedRoutes: true,
-            },
-            ios: {
-                supportsTablet: true,
-            },
-            name: appDisplayName,
-            orientation: "portrait",
-            plugins: ["expo-router"],
-            scheme: appName,
-            slug: appName,
-            userInterfaceStyle: "automatic",
-            version: "1.0.0",
-            web: {
-                bundler: "metro",
-                output: "static",
-            },
-        },
-    }, null, 2);
-};
-const generateFrontendTsConfig = () => {
-    // No `baseUrl`: it is deprecated as of TypeScript 6 and makes `tsc` abort with TS5101
-    // before checking a single file. `paths` entries are relative to this tsconfig instead.
-    return JSON.stringify({
-        compilerOptions: {
-            allowJs: true,
-            allowSyntheticDefaultImports: true,
-            esModuleInterop: true,
-            jsx: "react-jsx",
-            lib: ["DOM", "ESNext"],
-            module: "esnext",
-            moduleResolution: "bundler",
-            noEmit: true,
-            paths: {
-                "@/*": ["./*"],
-                "@components/*": ["./components/*"],
-                "@store": ["./store/index"],
-                "@store/*": ["./store/*"],
-                "@utils": ["./utils/index"],
-                "@utils/*": ["./utils/*"],
-            },
-            resolveJsonModule: true,
-            skipLibCheck: true,
-            strict: true,
-            target: "ESNext",
-            types: ["react-native", "@types/react"],
-        },
-        extends: "expo/tsconfig.base",
-        include: ["**/*.ts", "**/*.tsx", ".expo/types/**/*.ts", "expo-env.d.ts"],
-    }, null, 2);
-};
-const generateFrontendMetroConfig = () => {
-    return `const {getDefaultConfig} = require("expo/metro-config");
-const path = require("path");
-
-const config = getDefaultConfig(__dirname);
-
-const defaultResolveRequest = config.resolver.resolveRequest;
-
-config.resolver.resolveRequest = (context, moduleName, platform) => {
-  // @terreno/admin-frontend imports jspdf for its consent-PDF export. jspdf's CommonJS and
-  // Node builds wrap an AMD-style \`require(["html2canvas"], cb)\` call that Metro's static
-  // transform cannot parse, which fails the whole bundle — including Expo Router's static
-  // web render, which resolves under a "node" condition and would otherwise pick
-  // jspdf.node.min.js. Pin every jspdf request to the ESM browser build on web, and drop it
-  // on native, where PDF export is unavailable and jspdf's browser/Node APIs are missing.
-  if (moduleName === "jspdf" || moduleName.startsWith("jspdf/dist/jspdf.node")) {
-    if (platform !== "web") {
-      return {type: "empty"};
-    }
-    try {
-      const jspdfDir = path.dirname(require.resolve("jspdf/package.json", {paths: [__dirname]}));
-      return {
-        filePath: path.join(jspdfDir, "dist", "jspdf.es.min.js"),
-        type: "sourceFile",
-      };
-    } catch {
-      // jspdf is not installed — let Metro report the failure itself.
-    }
-  }
-
-  return defaultResolveRequest
-    ? defaultResolveRequest(context, moduleName, platform)
-    : context.resolveRequest(context, moduleName, platform);
-};
-
-module.exports = config;
-`;
-};
-const generateFrontendTsConfigCodegen = () => {
-    return JSON.stringify({
-        compilerOptions: {
-            esModuleInterop: true,
-            module: "commonjs",
-            moduleResolution: "node",
-            resolveJsonModule: true,
-            skipLibCheck: true,
-            target: "ES2020",
-        },
-    }, null, 2);
-};
-const generateFrontendBiomeJsonc = () => {
-    return `{
-  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
-  "assist": {
-    "actions": {
-      "source": {
-        "organizeImports": "on",
-        "useSortedAttributes": "on",
-        "useSortedKeys": "on"
-      }
-    },
-    "enabled": true
-  },
-  "files": {
-    "includes": [
-      "package.json",
-      "app/**/*.ts",
-      "app/**/*.tsx",
-      "components/**/*.ts",
-      "components/**/*.tsx",
-      "store/**/*.ts",
-      "store/**/*.tsx",
-      "utils/**/*.ts",
-      "utils/**/*.tsx",
-      "constants/**/*.ts",
-      "scripts/**/*.ts",
-      "!!**/node_modules",
-      "!!**/dist",
-      "!!**/build",
-      "!!**/coverage",
-      "!!**/.expo",
-      "!!**/.next",
-      "!!**/generated",
-      "!!**/.git"
-    ]
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineWidth": 100
-  },
-  "javascript": {
-    "formatter": {
-      "arrowParentheses": "always",
-      "bracketSpacing": false,
-      "jsxQuoteStyle": "double",
-      "quoteStyle": "double",
-      "semicolons": "always",
-      "trailingCommas": "es5"
-    },
-    // TODO: Remove once we don't need to import React from 'react' in our JSX files.
-    "jsxRuntime": "reactClassic"
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "nursery": {
-        "noFloatingPromises": "error",
-        "noMisusedPromises": "error",
-        "useExhaustiveSwitchCases": "error"
-      },
-      "recommended": true,
-      "suspicious": {
-        "noConsole": {
-          "level": "error",
-          "options": {
-            "allow": ["assert", "debug", "error", "info", "warn"]
-          }
-        },
-        "noExplicitAny": "off",
-        "noImplicitAnyLet": "off"
-      }
-    }
-  },
-  "vcs": {
-    "clientKind": "git",
-    "defaultBranch": "master",
-    "enabled": true
-  }
-}
-`;
-};
-const generateFrontendOpenApiConfig = () => {
-    return `import type {ConfigFile} from "@rtk-query/codegen-openapi";
-
-const config: ConfigFile = {
-  apiFile: "@terreno/rtk",
-  apiImport: "emptySplitApi",
-  argSuffix: "Args",
-  exportName: "openapi",
-  flattenArg: true,
-  hooks: true,
-  outputFile: "./store/openApiSdk.ts",
-  responseSuffix: "Res",
-  schemaFile: process.env.OPENAPI_URL ?? "http://localhost:4000/openapi.json",
-  tag: true,
-};
-
-export default config;
-`;
-};
-const generateFrontendGenerateSdk = () => {
-    return `#!/usr/bin/env bun
-
-import {exec} from "node:child_process";
-import {existsSync, readFileSync, writeFileSync} from "node:fs";
-import {join} from "node:path";
-
-const cliPath = join(
-  __dirname,
-  "..",
-  "node_modules",
-  "@rtk-query",
-  "codegen-openapi",
-  "lib",
-  "bin",
-  "cli.mjs"
-);
-const configPath = join(__dirname, "..", "openapi-config.ts");
-const tsConfigPath = join(__dirname, "..", "tsconfig.codegen.json");
-
-const command = \`TS_NODE_PROJECT=\${tsConfigPath} tsx \${cliPath} \${configPath}\`;
-
-exec(command, (error, _stdout, stderr) => {
-  if (error) {
-    console.error(\`Error: \${error.message}\`);
-    process.exit(1);
-  }
-  if (stderr) {
-    console.error(\`stderr: \${stderr}\`);
-  }
-
-  const sdkPath = join(__dirname, "..", "store", "openApiSdk.ts");
-
-  if (existsSync(sdkPath)) {
-    let content = readFileSync(sdkPath, "utf8");
-    content = content.replace(/^export const \\{\\} = injectedRtkApi;\\n?/m, "");
-    writeFileSync(sdkPath, content, "utf8");
-  }
-
-  exec(
-    "bunx biome check --unsafe --write store/openApiSdk.ts",
-    {cwd: join(__dirname, "..")},
-    (formatError) => {
-      if (formatError) {
-        console.error(\`Formatting error: \${formatError.message}\`);
-        process.exit(1);
-      }
-    }
-  );
-});
-`;
-};
-const generateFrontendRootLayout = (_args) => {
-    return `import {DefaultTheme, ThemeProvider} from "expo-router/react-navigation";
-import {Stack} from "expo-router";
-import {useEffect} from "react";
-import "react-native-reanimated";
-import {baseUrl, selectBetterAuthIsLoading, selectBetterAuthUserId} from "@terreno/rtk";
-import {SyncDbProvider} from "@terreno/syncdb/react";
-import {Spinner, TerrenoProvider} from "@terreno/ui";
-import {Provider, useSelector} from "react-redux";
-import {PersistGate} from "redux-persist/integration/react";
-import store, {persistor, syncBetterAuthSession} from "@/store/index";
-import {setSyncDbReady, syncDb} from "@/store/syncdb";
-
-export {ErrorBoundary} from "expo-router";
-
-export const unstable_settings = {
-  initialRouteName: "(tabs)",
-};
-
-// TerrenoProvider loads the Nunito/Titillium Web families @terreno/ui renders with, so this
-// app ships no font assets of its own. Add \`useFonts\` here only for extra custom faces.
-export default function RootLayout(): React.ReactElement | null {
-  return (
-    <Provider store={store}>
-      <PersistGate loading={null} persistor={persistor}>
-        <TerrenoProvider openAPISpecUrl={\`\${baseUrl}/openapi.json\`}>
-          <RootLayoutNav />
-        </TerrenoProvider>
-      </PersistGate>
-    </Provider>
-  );
-}
-
-function RootLayoutNav(): React.ReactElement {
-  const userId = useSelector(selectBetterAuthUserId) ?? undefined;
-  const isAuthLoading = useSelector(selectBetterAuthIsLoading);
-
-  // Hydrate Better Auth session into Redux on startup.
-  useEffect(() => {
-    void syncBetterAuthSession(store.dispatch);
-  }, []);
-
-  // Start syncdb after login; stop on logout.
-  useEffect(() => {
-    if (!userId) {
-      setSyncDbReady(false);
-      return;
-    }
-    let stopped = false;
-    void syncDb
-      .start()
-      .then(() => {
-        if (!stopped) {
-          setSyncDbReady(true);
-        }
-      })
-      .catch((startError: unknown) => {
-        console.error("[syncdb] start failed", startError);
-        setSyncDbReady(false);
-      });
-    return () => {
-      stopped = true;
-      setSyncDbReady(false);
-      void syncDb.stop();
-    };
-  }, [userId]);
-
-  if (isAuthLoading) {
-    return <Spinner />;
-  }
-
-  return (
-    <SyncDbProvider client={syncDb}>
-      <ThemeProvider value={DefaultTheme}>
-        {/* Stack.Protected is the supported way to gate routes on auth state. Rendering
-            Stack.Screen children behind a raw conditional (or a fragment) crashes the
-            navigator, because Stack reads its screen config off the child elements. */}
-        <Stack>
-          <Stack.Protected guard={!userId}>
-            <Stack.Screen name="login" options={{headerShown: false}} />
-            <Stack.Screen name="signup" options={{headerShown: false}} />
-          </Stack.Protected>
-          <Stack.Protected guard={Boolean(userId)}>
-            <Stack.Screen name="(tabs)" options={{headerShown: false}} />
-          </Stack.Protected>
-        </Stack>
-      </ThemeProvider>
-    </SyncDbProvider>
-  );
-}
-`;
-};
-const generateFrontendLogin = () => {
-    return `import {baseUrl} from "@terreno/rtk";
-import {LoginScreen} from "@terreno/ui";
-import {useRouter} from "expo-router";
-import type React from "react";
-import {useCallback, useState} from "react";
-import {betterAuthClient} from "@/lib/betterAuth";
-import {syncBetterAuthSession, useAppDispatch} from "@/store/index";
-
-const Login: React.FC = () => {
-  const router = useRouter();
-  const dispatch = useAppDispatch();
-  const [errorMessage, setErrorMessage] = useState<string | undefined>(undefined);
-  const [isSubmitting, setIsSubmitting] = useState(false);
-
-  const handleSubmit = useCallback(
-    async (values: Record<string, string>): Promise<void> => {
-      const {email, password} = values;
-      setErrorMessage(undefined);
-      setIsSubmitting(true);
-      try {
-        const result = await betterAuthClient.signIn.email({email, password});
-        if (result.error) {
-          setErrorMessage(result.error.message ?? "Sign in failed.");
-          return;
-        }
-        await syncBetterAuthSession(dispatch);
-        router.replace("/(tabs)");
-      } catch (error: unknown) {
-        console.error("[login] Sign in threw", {baseUrl, error});
-        setErrorMessage("Sign in failed. Please try again.");
-      } finally {
-        setIsSubmitting(false);
-      }
-    },
-    [dispatch, router]
-  );
-
-  return (
-    <LoginScreen
-      error={errorMessage}
-      fields={[
-        {autoComplete: "off", label: "Email", name: "email", required: true, type: "email"},
-        {label: "Password", name: "password", required: true, type: "password"},
-      ]}
-      loading={isSubmitting}
-      onSignUpPress={() => router.push("/signup")}
-      onSubmit={handleSubmit}
-      title="Welcome"
-    />
-  );
-};
-
-export default Login;
-`;
-};
-const generateFrontendSignup = () => {
-    return `import {SignUpScreen, simplePasswordRequirements} from "@terreno/ui";
-import {useRouter} from "expo-router";
-import type React from "react";
-import {useCallback, useState} from "react";
-import {betterAuthClient} from "@/lib/betterAuth";
-import {syncBetterAuthSession, useAppDispatch} from "@/store/index";
-
-const SignUp: React.FC = () => {
-  const router = useRouter();
-  const dispatch = useAppDispatch();
-  const [errorMessage, setErrorMessage] = useState<string | undefined>(undefined);
-  const [isSubmitting, setIsSubmitting] = useState(false);
-
-  const handleSubmit = useCallback(
-    async (values: Record<string, string>): Promise<void> => {
-      const {email, password, name} = values;
-      setErrorMessage(undefined);
-      setIsSubmitting(true);
-      try {
-        const result = await betterAuthClient.signUp.email({email, name, password});
-        if (result.error) {
-          setErrorMessage(result.error.message ?? "Sign up failed.");
-          return;
-        }
-        await syncBetterAuthSession(dispatch);
-        router.replace("/(tabs)");
-      } catch {
-        setErrorMessage("Sign up failed. Please try again.");
-      } finally {
-        setIsSubmitting(false);
-      }
-    },
-    [dispatch, router]
-  );
-
-  return (
-    <SignUpScreen
-      error={errorMessage}
-      fields={[
-        {label: "Name", name: "name", required: true, type: "text"},
-        {autoComplete: "off", label: "Email", name: "email", required: true, type: "email"},
-        {label: "Password", name: "password", required: true, type: "password"},
-      ]}
-      loading={isSubmitting}
-      onLoginPress={() => router.back()}
-      onSubmit={handleSubmit}
-      passwordRequirements={simplePasswordRequirements}
-    />
-  );
-};
-
-export default SignUp;
-`;
-};
-const generateFrontendTabsLayout = () => {
-    return `import FontAwesome from "@expo/vector-icons/FontAwesome";
-import {Tabs} from "expo-router";
-import type React from "react";
-import {colors} from "@/constants/theme";
-
-const TabBarIcon: React.FC<{
-  name: React.ComponentProps<typeof FontAwesome>["name"];
-  color: string;
-}> = ({name, color}) => {
-  return <FontAwesome color={color} name={name} size={24} style={{marginBottom: -3}} />;
-};
-
-const TabLayout: React.FC = () => {
-  return (
-    <Tabs
-      screenOptions={{
-        tabBarActiveTintColor: colors.tint,
-      }}
-    >
-      <Tabs.Screen
-        name="index"
-        options={{
-          tabBarIcon: ({color}) => <TabBarIcon color={color} name="home" />,
-          title: "Home",
-        }}
-      />
-      <Tabs.Screen
-        name="profile"
-        options={{
-          headerShown: false,
-          tabBarIcon: ({color}) => <TabBarIcon color={color} name="user" />,
-          title: "Profile",
-        }}
-      />
-      <Tabs.Screen
-        name="admin"
-        options={{
-          headerShown: false,
-          tabBarIcon: ({color}) => <TabBarIcon color={color} name="cog" />,
-          title: "Admin",
-        }}
-      />
-    </Tabs>
-  );
-};
-
-export default TabLayout;
-`;
-};
-const generateFrontendTabsIndex = (args) => {
-    const { appDisplayName } = args;
-    return `import {Box, Heading, Page, Text} from "@terreno/ui";
-import type React from "react";
-
-const HomeScreen: React.FC = () => {
-  return (
-    <Page navigation={undefined} title="Home">
-      <Box padding={4} gap={4}>
-        <Heading>Welcome to ${appDisplayName}</Heading>
-        <Text>Your app is ready for development!</Text>
-        <Text color="secondary">
-          Start by adding models to the backend and screens to the frontend.
-        </Text>
-      </Box>
-    </Page>
-  );
-};
-
-export default HomeScreen;
-`;
-};
-const generateFrontendTabsProfile = () => {
-    return `import {Box, Button, Card, Heading, Page, Spinner, TapToEdit, Text} from "@terreno/ui";
-import type React from "react";
-import {useCallback, useEffect, useState} from "react";
-import {signOut} from "@/lib/betterAuth";
-import {logout, syncBetterAuthSession, useAppDispatch} from "@/store/index";
-import {useGetMeQuery, usePatchMeMutation} from "@/store/sdk";
-
-const ProfileScreen: React.FC = () => {
-  const dispatch = useAppDispatch();
-  const {data: profile, isLoading} = useGetMeQuery();
-  const [updateProfile] = usePatchMeMutation();
-  const [name, setName] = useState<string>("");
-  const [email, setEmail] = useState<string>("");
-  const [password, setPassword] = useState<string>("");
-  const [saveError, setSaveError] = useState<string | null>(null);
-
-  const user = profile?.data;
-
-  // Copy the server name into local state without resetting an in-progress email edit.
-  useEffect(() => {
-    if (!user) {
-      return;
-    }
-    setName(user.name || "");
-  }, [user?.name]);
-
-  // Copy the server email into local state without resetting an in-progress name edit.
-  useEffect(() => {
-    if (!user) {
-      return;
-    }
-    setEmail(user.email || "");
-  }, [user?.email]);
-
-  const handleLogout = useCallback(async (): Promise<void> => {
-    await signOut();
-    dispatch(logout());
-    await syncBetterAuthSession(dispatch);
-  }, [dispatch]);
-
-  const handleSaveName = useCallback(
-    async (value: string): Promise<void> => {
-      setSaveError(null);
-      try {
-        await updateProfile({name: value}).unwrap();
-      } catch (err) {
-        console.error("Error updating name:", err);
-        setSaveError("Failed to update name");
-      }
-    },
-    [updateProfile]
-  );
-
-  const handleSaveEmail = useCallback(
-    async (value: string): Promise<void> => {
-      setSaveError(null);
-      try {
-        await updateProfile({email: value}).unwrap();
-      } catch (err) {
-        console.error("Error updating email:", err);
-        setSaveError("Failed to update email");
-      }
-    },
-    [updateProfile]
-  );
-
-  const handleSavePassword = useCallback(
-    async (value: string): Promise<void> => {
-      if (!value) {
-        return;
-      }
-      setSaveError(null);
-      try {
-        await updateProfile({password: value}).unwrap();
-        setPassword("");
-      } catch (err) {
-        console.error("Error updating password:", err);
-        setSaveError("Failed to update password");
-      }
-    },
-    [updateProfile]
-  );
-
-  if (isLoading) {
-    return (
-      <Page navigation={undefined} title="Profile">
-        <Box alignItems="center" flex="grow" justifyContent="center" padding={4}>
-          <Spinner />
-        </Box>
-      </Page>
-    );
-  }
-
-  return (
-    <Page navigation={undefined} scroll title="Profile">
-      <Box gap={4} padding={4}>
-        <Heading>Profile</Heading>
-        <Card>
-          <Box gap={4}>
-            <TapToEdit
-              onSave={handleSaveName}
-              setValue={setName}
-              title="Name"
-              type="text"
-              value={name}
-            />
-            <TapToEdit
-              onSave={handleSaveEmail}
-              setValue={setEmail}
-              title="Email"
-              type="email"
-              value={email}
-            />
-            <TapToEdit
-              helperText="Leave blank to keep your current password"
-              onSave={handleSavePassword}
-              setValue={setPassword}
-              title="New Password"
-              type="password"
-              value={password}
-            />
-            {saveError && <Text color="error">{saveError}</Text>}
-          </Box>
-        </Card>
-        <Box marginTop={4}>
-          <Button fullWidth onClick={handleLogout} text="Logout" variant="outline" />
-        </Box>
-      </Box>
-    </Page>
-  );
-};
-
-export default ProfileScreen;
-`;
-};
-const generateFrontendAdminLayout = () => {
-    return `import {Stack} from "expo-router";
-import type React from "react";
-
-const AdminLayout: React.FC = () => {
-  return <Stack screenOptions={{headerShown: false}} />;
-};
-
-export default AdminLayout;
-`;
-};
-const generateFrontendAdminIndex = () => {
-    return `import {AdminModelList} from "@terreno/admin-frontend";
-import type React from "react";
-import {terrenoApi} from "@/store/sdk";
-
-const AdminListScreen: React.FC = () => {
-  return (
-    <AdminModelList
-      api={terrenoApi}
-      baseUrl="/admin"
-      configurationPath="/admin/configuration"
-    />
-  );
-};
-
-export default AdminListScreen;
-`;
-};
-const generateFrontendAdminConfiguration = () => {
-    return `import {ConfigurationScreen} from "@terreno/admin-frontend";
-import type React from "react";
-import {terrenoApi} from "@/store/sdk";
-
-const ConfigurationPage: React.FC = () => {
-  return <ConfigurationScreen api={terrenoApi} />;
-};
-
-export default ConfigurationPage;
-`;
-};
-const generateFrontendNotFound = () => {
-    return `import {Box, Text} from "@terreno/ui";
-import {Link, Stack} from "expo-router";
-import type React from "react";
-
-const NotFoundScreen: React.FC = () => {
-  return (
-    <>
-      <Stack.Screen options={{title: "Oops!"}} />
-      <Box flex={1} alignItems="center" justifyContent="center" padding={4}>
-        <Text size="lg" weight="bold">
-          This screen doesn't exist.
-        </Text>
-        <Link href="/" style={{marginTop: 16}}>
-          <Text color="link">Go to home screen</Text>
-        </Link>
-      </Box>
-    </>
-  );
-};
-
-export default NotFoundScreen;
-`;
-};
-const generateFrontendStoreIndex = () => {
-    return `import AsyncStorage from "@react-native-async-storage/async-storage";
-import {combineReducers, configureStore} from "@reduxjs/toolkit";
-import {generateBetterAuthSlice, registerTerrenoDevStore} from "@terreno/rtk";
-import {DateTime} from "luxon";
-import {useDispatch} from "react-redux";
-import type {Storage} from "redux-persist";
-import {persistReducer, persistStore} from "redux-persist";
-import {betterAuthClient} from "@/lib/betterAuth";
-
-import appState from "./appState";
-import {rtkQueryErrorMiddleware} from "./errors";
-import {terrenoApi} from "./sdk";
-
-const betterAuth = generateBetterAuthSlice({authClient: betterAuthClient});
-
-export const logout = betterAuth.actions.logout;
-export const syncBetterAuthSession = betterAuth.syncSession;
-
-const createSafeStorage = (): Storage => {
-  return {
-    getItem: async (key: string): Promise<string | null> => {
-      if (typeof window !== "undefined") {
-        return AsyncStorage.getItem(key);
-      }
-      return null;
-    },
-    removeItem: async (key: string): Promise<void> => {
-      if (typeof window !== "undefined") {
-        return AsyncStorage.removeItem(key);
-      }
-    },
-    setItem: async (key: string, value: string): Promise<void> => {
-      if (typeof window !== "undefined") {
-        return AsyncStorage.setItem(key, value);
-      }
-    },
-  };
-};
-
-const persistConfig = {
-  blacklist: ["terreno-rtk", "betterAuth"],
-  key: "root",
-  storage: createSafeStorage(),
-  timeout: 0,
-  version: 1,
-};
-
-const rootReducer = combineReducers({
-  appState,
-  betterAuth: betterAuth.reducer,
-  "terreno-rtk": terrenoApi.reducer,
-});
-
-const persistedReducer = persistReducer(persistConfig, rootReducer);
-
-const store = configureStore({
-  devTools: process.env.NODE_ENV !== "production" && {
-    name: \`App-\${
-      typeof window !== "undefined"
-        // biome-ignore lint/suspicious/noAssignInExpressions: Window name assignment
-        ? window.name || ((window.name = \`Window-\${DateTime.now().toFormat("HH:mm:ss")}\`))
-        : "Unknown"
-    }\`,
-  },
-  middleware: (getDefaultMiddleware) => {
-    return getDefaultMiddleware({
-      immutableCheck: false,
-      serializableCheck: false,
-      thunk: true,
-    }).concat([
-      ...betterAuth.middleware,
-// noExplicitAny: RTK Query middleware typing
-      // biome-ignore lint/suspicious/noExplicitAny: RTK Query middleware typing
-      terrenoApi.middleware as any,
-      rtkQueryErrorMiddleware,
-// noExplicitAny: Middleware array typing
-      // biome-ignore lint/suspicious/noExplicitAny: Middleware array typing
-    ]) as any;
-  },
-  reducer: persistedReducer,
-});
-
-registerTerrenoDevStore(store);
-
-export const persistor = persistStore(store);
-
-export type RootState = ReturnType<typeof store.getState>;
-export type AppDispatch = typeof store.dispatch;
-
-export const useAppDispatch: () => AppDispatch = useDispatch;
-
-export default store;
-`;
-};
-const generateFrontendStoreAppState = () => {
-    return `import {createSlice, type PayloadAction} from "@reduxjs/toolkit";
-import type {RootState} from "@terreno/rtk";
-import {type TypedUseSelectorHook, useSelector} from "react-redux";
-
-export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;
-
-export type AppState = {
-  darkMode: boolean;
-  language: string;
-};
-
-const initialState: AppState = {
-  darkMode: false,
-  language: "en",
-};
-
-export const appStateSlice = createSlice({
-  initialState,
-  name: "appState",
-  reducers: {
-    resetAppState: () => initialState,
-    setDarkMode: (state, action: PayloadAction<boolean>) => {
-      state.darkMode = action.payload;
-    },
-    setLanguage: (state, action: PayloadAction<string>) => {
-      state.language = action.payload;
-    },
-  },
-});
-
-export const {setDarkMode, setLanguage, resetAppState} = appStateSlice.actions;
-
-export const useSelectDarkMode = (): boolean => {
-  return useAppSelector((state: RootState): boolean => {
-    return state.appState.darkMode;
-  });
-};
-
-export const useSelectLanguage = (): string => {
-  return useAppSelector((state: RootState): string => {
-    return state.appState.language;
-  });
-};
-
-export default appStateSlice.reducer;
-`;
-};
-const generateFrontendStoreErrors = () => {
-    return `import type {Middleware} from "@reduxjs/toolkit";
-import {useToast} from "@terreno/ui";
-
-const ignoredErrors = [
-  "Password or username is incorrect",
-  "Token refresh failed with 401",
-  "Failed to refresh token",
-];
-
-// noExplicitAny: Generic middleware
-// biome-ignore lint/suspicious/noExplicitAny: Generic middleware
-export const rtkQueryErrorMiddleware: Middleware = () => (next) => (action: any) => {
-  if (action?.error && action?.payload) {
-    const errorMessage =
-      action.payload?.data?.title ??
-      action.payload?.data?.message ??
-      action.payload?.error ??
-      JSON.stringify(action.payload);
-
-    let endpointInfo = "unknown endpoint";
-    if (action.meta?.baseQueryMeta?.request?.method && action.meta?.baseQueryMeta?.request?.url) {
-      endpointInfo = \`\${action.meta.baseQueryMeta.request.url} \${action.meta.baseQueryMeta.request.method}\`;
-    } else if (action.meta?.arg?.endpointName) {
-      endpointInfo = \`\${action.meta.arg.endpointName} rejected \${action.meta.arg.type || ""}\`;
-    }
-
-    const message = \`\${endpointInfo.trim()}: \${errorMessage}\`;
-    console.debug(message);
-
-    if (action.payload.status === 404 || action.payload.status === 401) {
-      return next(action);
-    }
-
-    const shouldIgnore = ignoredErrors.some((err) => errorMessage.includes(err));
-    if (!shouldIgnore) {
-      console.warn(message);
-    }
-  }
-
-  return next(action);
-};
-
-export const useSentryAndToast = (): ((errorMessage: string) => void) => {
-  const toast = useToast();
-  return (error: string): void => {
-    if (!error) {
-      return;
-    }
-    toast.error(error);
-    console.warn(\`Error: \${error}\`);
-  };
-};
-`;
-};
-const generateFrontendStoreSdk = () => {
-    return `import {generateTags} from "@terreno/rtk";
-import startCase from "lodash/startCase";
-
-import {addTagTypes, openapi} from "./openApiSdk";
-
-export interface ProfileResponse {
-  data: {
-    _id: string;
-    id: string;
-    email: string;
-    name: string;
-  };
-}
-
-export interface UpdateProfileRequest {
-  name?: string;
-  email?: string;
-  password?: string;
-}
-
-export const terrenoApi = openapi
-  .injectEndpoints({
-    endpoints: (builder) => ({
-      getMe: builder.query<ProfileResponse, void>({
-        providesTags: ["profile"],
-        query: () => ({
-          method: "GET",
-          url: "/auth/me",
-        }),
-      }),
-      patchMe: builder.mutation<ProfileResponse, UpdateProfileRequest>({
-        invalidatesTags: ["profile"],
-        query: (body) => ({
-          body,
-          method: "PATCH",
-          url: "/auth/me",
-        }),
-      }),
-    }),
-  })
-  .enhanceEndpoints({
-    addTagTypes: ["profile"],
-    endpoints: {
-      ...generateTags(openapi, [...addTagTypes]),
-    },
-  });
-
-export const {
-  useGetMeQuery,
-  usePatchMeMutation,
-} = terrenoApi;
-export * from "./openApiSdk";
-
-type OpenApiEndpoints = Record<string, unknown>;
-
-export const getSdkHook = (
-  modelName: string,
-  type: "list" | "read" | "create" | "update" | "remove"
-): Record<string, unknown> => {
-  const modelPath = startCase(modelName).replace(/\\s/g, "");
-  const endpoints = openapi.endpoints as OpenApiEndpoints;
-  switch (type) {
-    case "list":
-      return endpoints[\`get\${modelPath}\`] as Record<string, unknown>;
-    case "read":
-      return endpoints[\`get\${modelPath}ById\`] as Record<string, unknown>;
-    case "create":
-      return endpoints[\`post\${modelPath}\`] as Record<string, unknown>;
-    case "update":
-      return endpoints[\`patch\${modelPath}ById\`] as Record<string, unknown>;
-    case "remove":
-      return endpoints[\`delete\${modelPath}ById\`] as Record<string, unknown>;
-    default:
-      throw new Error(\`Invalid SDK hook: \${modelName}/\${type}\`);
-  }
-};
-`;
-};
-const generateFrontendStoreOpenApiSdk = () => {
-    return `// THIS FILE IS AUTO-GENERATED. DO NOT EDIT.
-// Run "bun run sdk" to regenerate this file from the backend OpenAPI spec.
-
-import {emptySplitApi as api} from "@terreno/rtk";
-export const addTagTypes = ["Users", "Auth"] as const;
-const injectedRtkApi = api
-  .enhanceEndpoints({
-    addTagTypes,
-  })
-  .injectEndpoints({
-    endpoints: () => ({}),
-    overrideExisting: false,
-  });
-export {injectedRtkApi as openapi};
-`;
-};
-const generateFrontendTheme = () => {
-    return `// Theme configuration for the app
-// Override these values to customize the app's appearance
-// Colors are based on @terreno/ui's default theme primitives
-
-export const primitives = {
-  // Primary colors (teal/cyan)
-  primary000: "#EBFAFF",
-  primary050: "#BCE9F7",
-  primary100: "#90D8F0",
-  primary200: "#73CAE8",
-  primary300: "#40B8E0",
-  primary400: "#0E9DCD",
-  primary500: "#0086B3",
-  primary600: "#0A7092",
-  primary700: "#035D7E",
-  primary800: "#004B64",
-  primary900: "#013749",
-
-  // Secondary colors (dark teal)
-  secondary000: "#F2F9FA",
-  secondary050: "#D7E5EA",
-  secondary100: "#B6CDD5",
-  secondary200: "#9EB7BF",
-  secondary300: "#87A1AA",
-  secondary400: "#608997",
-  secondary500: "#2B6072",
-  secondary600: "#1C4E5F",
-  secondary700: "#0F3D4D",
-  secondary800: "#092E3A",
-  secondary900: "#041E27",
-
-  // Accent colors (gold/yellow)
-  accent000: "#FFFDF7",
-  accent050: "#FCECC2",
-  accent100: "#F9E0A1",
-  accent200: "#F7D582",
-  accent300: "#F2CB62",
-  accent400: "#E5B132",
-  accent500: "#D69C0E",
-  accent600: "#B58201",
-  accent700: "#956A00",
-  accent800: "#543C00",
-  accent900: "#332400",
-
-  // Neutral colors (grays)
-  neutral000: "#FFFFFF",
-  neutral050: "#F2F2F2",
-  neutral100: "#E6E6E6",
-  neutral200: "#D9D9D9",
-  neutral300: "#CDCDCD",
-  neutral400: "#B3B3B3",
-  neutral500: "#9A9A9A",
-  neutral600: "#686868",
-  neutral700: "#4E4E4E",
-  neutral800: "#353535",
-  neutral900: "#1C1C1C",
-
-  // Status colors
-  error000: "#FDD7D7",
-  error100: "#D33232",
-  error200: "#BD1111",
-  success000: "#DCF2E2",
-  success100: "#3EA45C",
-  success200: "#1A7F36",
-  warning000: "#FFE3C6",
-  warning100: "#F36719",
-  warning200: "#B14202",
-};
-
-// Semantic color mappings - override these to change app appearance
-export const colors = {
-  // Backgrounds
-  background: primitives.neutral000,
-  backgroundSecondary: primitives.neutral050,
-
-  // Text
-  text: primitives.neutral900,
-  textSecondary: primitives.neutral600,
-  textInverted: primitives.neutral000,
-
-  // Primary action colors
-  primary: primitives.primary400,
-  primaryDark: primitives.primary600,
-  primaryLight: primitives.primary100,
-
-  // Secondary colors
-  secondary: primitives.secondary500,
-  secondaryDark: primitives.secondary700,
-  secondaryLight: primitives.secondary100,
-
-  // Accent colors
-  accent: primitives.accent500,
-  accentDark: primitives.accent700,
-  accentLight: primitives.accent100,
-
-  // Status colors
-  error: primitives.error100,
-  errorLight: primitives.error000,
-  success: primitives.success100,
-  successLight: primitives.success000,
-  warning: primitives.warning100,
-  warningLight: primitives.warning000,
-
-  // UI elements
-  border: primitives.neutral300,
-  borderFocus: primitives.primary200,
-  icon: primitives.neutral600,
-  tint: primitives.primary400,
-
-  // Tab bar
-  tabIconDefault: primitives.neutral600,
-  tabIconSelected: primitives.primary400,
-};
-
-export default colors;
-`;
-};
-const generateFrontendEnv = () => {
-    return `EXPO_PUBLIC_API_URL=http://localhost:4000
-`;
-};
-const generateBackendEnv = (args) => {
-    const { appName } = args;
-    const dbName = appName.replace(/-/g, "_");
-    return `MONGO_URI=mongodb://127.0.0.1:27017/${dbName}?replicaSet=rs0
-AUTH_PROVIDER=better-auth
-BETTER_AUTH_SECRET=${appName}-better-auth-secret-dev-only-32chars
-BETTER_AUTH_URL=http://localhost:4000
-TOKEN_SECRET=dev-token-secret
-TOKEN_ISSUER=${appName}-dev
-REFRESH_TOKEN_SECRET=dev-refresh-secret
-SESSION_SECRET=dev-session-secret
-PORT=4000
-`;
-};
-const generateFrontendBetterAuthLib = (args) => {
-    const { appName } = args;
-    return `import {baseUrl, createBetterAuthClient} from "@terreno/rtk";
-import Constants from "expo-constants";
-
-const getAppScheme = (): string => {
-  const expoExtra = Constants.expoConfig?.extra;
-  return expoExtra?.scheme ?? "${appName}";
-};
-
-export const betterAuthClient = createBetterAuthClient({
-  baseURL: baseUrl,
-  scheme: getAppScheme(),
-  storagePrefix: "${appName}",
-});
-
-export const signOut = async (): Promise<void> => {
-  await betterAuthClient.signOut();
-};
-`;
-};
-const generateFrontendSyncDb = (args) => {
-    const { appName } = args;
-    const dbName = appName.replace(/-/g, "-");
-    return `import {baseUrl} from "@terreno/rtk";
-import {betterAuthAdapter, createSyncDb, type SyncDb} from "@terreno/syncdb";
-import {betterAuthClient} from "@/lib/betterAuth";
-
-export const SYNC_DB_NAME = "${dbName}";
-
-/** Add synced collection names here as you register modelRouter sync scopes on the backend. */
-export const SYNC_COLLECTIONS: string[] = [];
-
-const authProvider = betterAuthAdapter(betterAuthClient, {pollIntervalMs: 60_000});
-
-export const syncDb: SyncDb = createSyncDb({
-  authProvider,
-  baseUrl,
-  collections: SYNC_COLLECTIONS,
-  name: SYNC_DB_NAME,
-});
-
-let syncDbReady = false;
-const syncDbReadyListeners = new Set<() => void>();
-
-export const setSyncDbReady = (ready: boolean): void => {
-  if (syncDbReady === ready) {
-    return;
-  }
-  syncDbReady = ready;
-  for (const listener of syncDbReadyListeners) {
-    listener();
-  }
-};
-
-export const subscribeSyncDbReady = (listener: () => void): (() => void) => {
-  syncDbReadyListeners.add(listener);
-  return () => {
-    syncDbReadyListeners.delete(listener);
-  };
-};
-
-export const getSyncDbReadySnapshot = (): boolean => syncDbReady;
-`;
-};
-const generateFrontendUtilsIndex = () => {
-    return `export const captureException = (error: unknown): void => {
-  console.error("Captured exception:", error);
-};
-
-export const captureMessage = (message: string): void => {
-  console.warn("Captured message:", message);
-};
-
-export const createSentryReduxEnhancer = (): unknown => {
-  return undefined;
-};
-`;
-};
-const generateBackendCiWorkflow = (_args) => {
-    return `name: Backend CI
-
-on:
-  push:
-    paths:
-      - "backend/**"
-      - ".github/workflows/backend-ci.yml"
-
-jobs:
-  lint-and-test:
-    name: Backend Lint, Build, and Test
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        mongodb-version: ["6.0"]
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: Cache Bun dependencies
-        id: cache
-        uses: actions/cache@v5
-        with:
-          path: |
-            ~/.bun/install/cache
-            node_modules
-          key: bun-\${{ runner.os }}-\${{ github.ref }}-\${{ hashFiles('bun.lockb', 'package.json') }}
-          restore-keys: |
-            bun-\${{ runner.os }}-\${{ github.ref }}-
-            bun-\${{ runner.os }}-
-
-      - name: Start MongoDB
-        uses: supercharge/mongodb-github-action@1.12.1
-        with:
-          mongodb-version: \${{ matrix.mongodb-version }}
-
-      - name: Install dependencies
-        run: bun install --frozen-lockfile
-        working-directory: backend
-
-      - name: Lint
-        run: bun run lint
-        working-directory: backend
-
-      - name: Build
-        run: bun run compile
-        working-directory: backend
-
-      - name: Test
-        run: bun run test
-        working-directory: backend
-        env:
-          CI: true
-`;
-};
 const generateRulesyncConfig = () => {
     return JSON.stringify({
         $schema: "https://raw.githubusercontent.com/dyoshikawa/rulesync/refs/heads/main/config-schema.json",
@@ -2533,7 +354,7 @@ const generateAiRulesFiles = (args) => {
         { content: generateRulesyncConfig(), path: "rulesync.jsonc" },
     ];
 };
-export const handleBootstrapAiRulesToolCall = (args) => {
+const handleBootstrapAiRulesToolCall = (args) => {
     const bootstrapArgs = args;
     if (!bootstrapArgs.appName || !bootstrapArgs.appDisplayName) {
         return {
@@ -2604,249 +425,12 @@ ${f.content}
         content: [{ text: instructions + fileContents, type: "text" }],
     };
 };
-const generateFrontendCiWorkflow = (_args) => {
-    return `name: Frontend CI
-
-on:
-  push:
-    paths:
-      - "frontend/**"
-      - ".github/workflows/frontend-ci.yml"
-
-jobs:
-  lint-and-test:
-    name: Frontend Lint, Build, and Test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: Cache Bun dependencies
-        id: cache
-        uses: actions/cache@v5
-        with:
-          path: |
-            ~/.bun/install/cache
-            node_modules
-          key: bun-\${{ runner.os }}-\${{ github.ref }}-\${{ hashFiles('bun.lockb', 'package.json') }}
-          restore-keys: |
-            bun-\${{ runner.os }}-\${{ github.ref }}-
-            bun-\${{ runner.os }}-
-
-      - name: Install dependencies
-        run: bun install --frozen-lockfile
-        working-directory: frontend
-
-      - name: Lint
-        run: bun run lint
-        working-directory: frontend
-
-      - name: TypeScript compile
-        run: bun run compile
-        working-directory: frontend
-
-      - name: Test
-        run: bun run test
-        working-directory: frontend
-        env:
-          CI: true
-`;
-};
-const getFenceLanguage = (filePath) => {
-    if (filePath.endsWith(".json") || filePath.endsWith(".jsonc")) {
-        return "json";
-    }
-    if (filePath.endsWith(".js")) {
-        return "javascript";
-    }
-    if (filePath.endsWith(".yml") || filePath.endsWith(".yaml")) {
-        return "yaml";
-    }
-    if (filePath.endsWith(".md")) {
-        return "markdown";
-    }
-    return "typescript";
-};
-const generateAllFiles = (args) => {
-    const frontendDir = `frontend`;
-    const backendDir = `backend`;
-    return [
-        // Root files
-        { content: generateRootGitignore(), path: ".gitignore" },
-        { content: generateCursorRules(args), path: ".cursorrules" },
-        { content: generateMcpSettings(args), path: ".cursor/mcp.json" },
-        { content: generateClaudeMd(args), path: "CLAUDE.md" },
-        // Backend files
-        { content: generateBackendPackageJson(args), path: `${backendDir}/package.json` },
-        { content: generateBackendTsConfig(), path: `${backendDir}/tsconfig.json` },
-        { content: generateBackendBiomeJsonc(), path: `${backendDir}/biome.jsonc` },
-        { content: generateBackendIndex(), path: `${backendDir}/src/index.ts` },
-        { content: generateBackendServer(args), path: `${backendDir}/src/server.ts` },
-        { content: generateBackendDatabase(args), path: `${backendDir}/src/utils/database.ts` },
-        { content: generateBackendSeed(), path: `${backendDir}/src/scripts/seed.ts` },
-        {
-            content: generateBackendBetterAuthConfig(args),
-            path: `${backendDir}/src/utils/betterAuthConfig.ts`,
-        },
-        { content: generateBackendEnv(args), path: `${backendDir}/.env` },
-        { content: generateBackendModelPlugins(), path: `${backendDir}/src/models/modelPlugins.ts` },
-        { content: generateBackendUserModel(), path: `${backendDir}/src/models/user.ts` },
-        {
-            content: generateBackendAppConfiguration(args),
-            path: `${backendDir}/src/models/appConfiguration.ts`,
-        },
-        { content: generateBackendModelsIndex(), path: `${backendDir}/src/models/index.ts` },
-        { content: generateBackendUserRoutes(), path: `${backendDir}/src/api/users.ts` },
-        { content: generateBackendTypes(), path: `${backendDir}/src/types/index.ts` },
-        { content: generateBackendTypesModels(), path: `${backendDir}/src/types/models/index.ts` },
-        { content: generateBackendUserTypes(), path: `${backendDir}/src/types/models/userTypes.ts` },
-        // Frontend files
-        { content: generateFrontendPackageJson(args), path: `${frontendDir}/package.json` },
-        { content: generateFrontendAppJson(args), path: `${frontendDir}/app.json` },
-        { content: generateFrontendTsConfig(), path: `${frontendDir}/tsconfig.json` },
-        { content: generateFrontendTsConfigCodegen(), path: `${frontendDir}/tsconfig.codegen.json` },
-        { content: generateFrontendMetroConfig(), path: `${frontendDir}/metro.config.js` },
-        { content: generateFrontendBiomeJsonc(), path: `${frontendDir}/biome.jsonc` },
-        { content: generateFrontendOpenApiConfig(), path: `${frontendDir}/openapi-config.ts` },
-        { content: generateFrontendGenerateSdk(), path: `${frontendDir}/scripts/generate-sdk.ts` },
-        { content: generateFrontendRootLayout(args), path: `${frontendDir}/app/_layout.tsx` },
-        { content: generateFrontendLogin(), path: `${frontendDir}/app/login.tsx` },
-        { content: generateFrontendSignup(), path: `${frontendDir}/app/signup.tsx` },
-        { content: generateFrontendNotFound(), path: `${frontendDir}/app/+not-found.tsx` },
-        { content: generateFrontendTabsLayout(), path: `${frontendDir}/app/(tabs)/_layout.tsx` },
-        { content: generateFrontendTabsIndex(args), path: `${frontendDir}/app/(tabs)/index.tsx` },
-        { content: generateFrontendTabsProfile(), path: `${frontendDir}/app/(tabs)/profile.tsx` },
-        { content: generateFrontendAdminLayout(), path: `${frontendDir}/app/(tabs)/admin/_layout.tsx` },
-        { content: generateFrontendAdminIndex(), path: `${frontendDir}/app/(tabs)/admin/index.tsx` },
-        {
-            content: generateFrontendAdminConfiguration(),
-            path: `${frontendDir}/app/(tabs)/admin/configuration.tsx`,
-        },
-        { content: generateFrontendStoreIndex(), path: `${frontendDir}/store/index.ts` },
-        { content: generateFrontendStoreAppState(), path: `${frontendDir}/store/appState.ts` },
-        { content: generateFrontendStoreErrors(), path: `${frontendDir}/store/errors.ts` },
-        { content: generateFrontendStoreSdk(), path: `${frontendDir}/store/sdk.ts` },
-        { content: generateFrontendStoreOpenApiSdk(), path: `${frontendDir}/store/openApiSdk.ts` },
-        { content: generateFrontendBetterAuthLib(args), path: `${frontendDir}/lib/betterAuth.ts` },
-        { content: generateFrontendSyncDb(args), path: `${frontendDir}/store/syncdb.ts` },
-        { content: generateFrontendTheme(), path: `${frontendDir}/constants/theme.ts` },
-        { content: generateFrontendUtilsIndex(), path: `${frontendDir}/utils/index.ts` },
-        { content: generateFrontendEnv(), path: `${frontendDir}/.env` },
-        // GitHub Actions workflows
-        { content: generateBackendCiWorkflow(args), path: ".github/workflows/backend-ci.yml" },
-        { content: generateFrontendCiWorkflow(args), path: ".github/workflows/frontend-ci.yml" },
-    ];
-};
 export const handleBootstrapToolCall = (name, args) => {
     if (name === "terreno_bootstrap_ai_rules") {
         return handleBootstrapAiRulesToolCall(args);
     }
-    if (name !== "terreno_bootstrap_app") {
-        return {
-            content: [{ text: `Unknown bootstrap tool: ${name}`, type: "text" }],
-        };
-    }
-    const bootstrapArgs = args;
-    if (!bootstrapArgs.appName || !bootstrapArgs.appDisplayName) {
-        return {
-            content: [
-                {
-                    text: "Error: appName and appDisplayName are required parameters",
-                    type: "text",
-                },
-            ],
-        };
-    }
-    const files = generateAllFiles(bootstrapArgs);
-    const fileList = files.map((f) => `- \`${f.path}\``).join("\n");
-    const instructions = `# Bootstrap ${bootstrapArgs.appDisplayName}
-
-## Files to Create
-
-The following files need to be created for your new Terreno application:
-
-${fileList}
-
-## Instructions
-
-1. **Create the project directory:**
-   \`\`\`bash
-   mkdir ${bootstrapArgs.appName}
-   cd ${bootstrapArgs.appName}
-   \`\`\`
-
-2. **Create all the files listed above.** Each file's content is provided below.
-
-   No \`assets/\` directory is needed: \`@terreno/ui\` ships the Nunito and Titillium Web
-   fonts it renders with, and \`app.json\` leaves \`icon\`/\`splash\`/\`favicon\` unset so Expo
-   uses its built-in defaults. Add your own branding assets whenever you're ready and
-   point \`app.json\` at them then.
-
-3. **Install dependencies:**
-   \`\`\`bash
-   cd backend && bun install
-   cd ../frontend && bun install
-   \`\`\`
-
-4. **Start MongoDB as a replica set** (required for realtime/sync):
-   \`\`\`bash
-   # Using Docker (single-node replica set):
-   docker run -d --name mongo -p 27017:27017 mongo:7 --replSet rs0
-   docker exec mongo mongosh --eval 'rs.initiate({_id:"rs0",members:[{_id:0,host:"127.0.0.1:27017"}]})'
-   \`\`\`
-
-5. **Start the backend:**
-   \`\`\`bash
-   cd backend && bun run dev
-   \`\`\`
-
-7. **In a new terminal, seed login-ready development users:**
-   \`\`\`bash
-   cd backend && bun run seed
-   # Re-run safely after seed definitions change, or use --reset to reset managed data.
-   \`\`\`
-
-8. **In a new terminal, regenerate and start the frontend:**
-   \`\`\`bash
-   cd frontend
-   bun run sdk  # Generate SDK from backend
-   bun run web  # Start web frontend
-   \`\`\`
-
-9. **Open http://localhost:8082** and sign in as \`test@example.com\` / \`testpassword123\`
-
-## MCP Integration
-
-The project is configured to use the Terreno MCP server at:
-\`${bootstrapArgs.mcpServerUrl || "https://mcp.terreno.flourish.health"}\`
-
-This provides AI assistance with:
-- Generating models and routes
-- Creating screens and forms
-- Following Terreno patterns
-
----
-
-## File Contents
-
-`;
-    const fileContents = files
-        .map((f) => {
-        const lang = getFenceLanguage(f.path);
-        return `### \`${f.path}\`
-
-\`\`\`${lang}
-${f.content}
-\`\`\`
-`;
-    })
-        .join("\n");
     return {
-        content: [{ text: instructions + fileContents, type: "text" }],
+        content: [{ text: `Unknown bootstrap tool: ${name}`, type: "text" }],
     };
 };
 export const bootstrapPrompts = [
@@ -2863,7 +447,7 @@ export const bootstrapPrompts = [
                 required: true,
             },
         ],
-        description: "Bootstrap a new Terreno full-stack application with frontend, backend, Cursor rules, and MCP integration",
+        description: "Bootstrap a new Terreno app: instruct the assistant to run bunx create-terreno-app, then terreno_bootstrap_ai_rules",
         name: "terreno_bootstrap",
     },
 ];
@@ -2887,15 +471,13 @@ export const handleBootstrapPromptRequest = (name, args) => {
 - **App Name** (kebab-case): ${appName}
 - **Display Name**: ${appDisplayName}
 
-Use the \`terreno_bootstrap_app\` tool to generate all the necessary files for the application.
+Scaffold the app with the published CLI (not an MCP tool):
+
+\`\`\`bash
+bunx create-terreno-app ${appName} --display-name "${appDisplayName}"
+\`\`\`
 
-After generating the files:
-1. Create all directories and files as specified (no \`assets/\` directory is required)
-2. Install dependencies with \`bun install\`
-3. Start MongoDB
-4. Start the backend with \`bun run dev\`
-5. Generate the SDK with \`bun run sdk\` in the frontend
-6. Start the frontend with \`bun run web\`
+Then follow the CLI next-step commands: install, seed, start MongoDB as a replica set, start the backend, and in another terminal run frontend \`bun run sdk\` then \`bun run web\`.
 
 The application should include:
 - Better Auth login (email/password via \`@terreno/ui\` LoginScreen)
@@ -2906,7 +488,7 @@ The application should include:
 - Cursor rules for AI assistance
 - MCP integration for development assistance
 
-**IMPORTANT: After completing the terreno_bootstrap_app steps, also run the \`terreno_bootstrap_ai_rules\` tool** with the same appName and appDisplayName to set up AI coding assistant rules for Cursor, Windsurf, Claude Code, and GitHub Copilot. This will create:
+**IMPORTANT: After the CLI writes the app, also run the \`terreno_bootstrap_ai_rules\` tool** with the same appName and appDisplayName to set up AI coding assistant rules for Cursor, Windsurf, Claude Code, and GitHub Copilot. This will create:
 - AGENTS.md files for each directory
 - .cursorrules and .windsurfrules files
 - GitHub Copilot instructions