anhedral 0.1.0 → 0.1.3

package/dist/scaffold.js

@@ -1,13 +1,14 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { readFileSync, readdirSync, rmSync } from 'node:fs';
 import path from 'node:path';
 import { env } from 'node:process';
-import { appendGitignore, exec, execWithInput, liftNestedProject, writeFile } from './util.js';
-import { getDefaultWebDependencyCommands, getDefaultWebInitCommand, getHeadlessInstallCommands, getSkillCommands, } from './commands.js';
+import { anhedralPrint } from './print.js';
+import { appendGitignore, exec, execWithInput, writeFile } from './util.js';
+import { getDefaultWebDependencyCommands, getDefaultWebInitCommand, getSkillCommands, } from './commands.js';
 import { resolveToolchain } from './toolchain.js';
 import { scaffoldBackend } from './templates/backend.js';
 import { writeDefaultWebEnvExample, writeDefaultWebFiles } from './templates/default-web.js';
+import { scaffoldExtension } from './templates/extension.js';
 import { scaffoldFrontend } from './templates/frontend.js';
-export const STACK_IDS = ['next', 'next-fullstack', 'expo-fullstack', 'backend'];
 const PNPM_PACKAGE_MANAGER = 'pnpm@10.15.1';
 const SHARED_ENV_GITIGNORE_LINES = ['.env', '.env.*', '!.env.example'];
 const SHARED_TYPESCRIPT_GITIGNORE_LINES = ['*.tsbuildinfo'];
@@ -39,33 +40,37 @@ async function printAsciiLogo() {
     }
     console.log('');
 }
+function getUsedToolchain(options, toolchain) {
+    return {
+        verifiedAt: toolchain.verifiedAt,
+        ...(options.frontend === 'next' || options.extension ? { shadcn: toolchain.shadcn } : {}),
+        ...(options.frontend === 'expo' ? { reactNativeReusables: toolchain.reactNativeReusables } : {}),
+        ...(options.extension ? { wxt: toolchain.wxt } : {}),
+    };
+}
 function normalizeStack(options, generatedPaths) {
     const toolchain = resolveToolchain(options.toolchainChannel);
-    const frontend = options.mode === 'next'
+    const frontend = options.frontend === 'next'
         ? 'nextjs_shadcn'
-        : options.mode === 'next-fullstack'
-            ? 'nextjs_shadcn'
-            : options.mode === 'expo-fullstack'
-                ? 'expo_react_native_reusables'
-                : null;
-    const backend = options.mode === 'next' ? null : 'fastify';
+        : 'expo_react_native_reusables';
     return {
         schema_version: '2.0.0',
-        mode: options.mode,
+        mode: 'fullstack',
         project_name: options.projectName,
         display_name: options.displayName,
         frontend,
-        backend,
+        extension: options.extension ? 'wxt_chrome_extension' : null,
+        backend: 'fastify',
         auth: options.auth,
         payments: options.payments,
         storage: 'cloudflare_r2_via_aws_s3_sdk',
         database: 'neon_plus_drizzle',
-        skills: getSkillCommands(options.mode),
+        skills: getSkillCommands(options),
         outputs: {
             monorepo: options.monorepo,
             package_manager: 'pnpm',
             toolchain_channel: options.toolchainChannel,
-            toolchain,
+            toolchain: getUsedToolchain(options, toolchain),
             generated_paths: generatedPaths,
         },
     };
@@ -77,9 +82,10 @@ function writeJsonFile(filePath, payload) {
     writeFile(filePath, JSON.stringify(payload, null, 2) + '\n');
 }
 function runScaffoldCommands(cwd, commands) {
+    let skippedCount = 0;
     for (const command of commands) {
         if (env.ANHEDRAL_SKIP_INSTALL === '1' && command.skippable) {
-            console.log(`  $ ${command.cmd} (skipped via ANHEDRAL_SKIP_INSTALL=1)`);
+            skippedCount += 1;
             continue;
         }
         if (command.stdinInput == null) {
@@ -88,6 +94,9 @@ function runScaffoldCommands(cwd, commands) {
         }
         execWithInput(command.cmd, cwd, command.stdinInput);
     }
+    if (skippedCount > 0) {
+        anhedralPrint.info(`Skipped ${skippedCount} install step${skippedCount === 1 ? '' : 's'} (ANHEDRAL_SKIP_INSTALL=1)`);
+    }
 }
 function ensureScaffoldRoot(root) {
     const allowedEntries = new Set(['.git', '.gitignore', '.DS_Store']);
@@ -127,18 +136,12 @@ function patchPackageJson(root, updates) {
     }
     writeJsonFile(filePath, packageJson);
 }
-function writeDrizzleConfig(root, schemaPath, migrationsPath) {
-    writeFile(path.join(root, 'drizzle.config.ts'), `import type { Config } from 'drizzle-kit';
-
-export default {
-  schema: '${schemaPath}',
-  out: '${migrationsPath}',
-  dialect: 'postgresql',
-  dbCredentials: {
-    url: process.env.DATABASE_URL!,
-  },
-} satisfies Config;
-`);
+function replaceInFile(filePath, replacements) {
+    let contents = readFileSync(filePath, 'utf-8');
+    for (const [search, replacement] of replacements) {
+        contents = contents.split(search).join(replacement);
+    }
+    writeFile(filePath, contents);
 }
 function writeSkillsGuide(root, commands) {
     const commandBlock = commands.map((command) => `${command}\n`).join('\n');
@@ -154,131 +157,235 @@ function writeSkillsGuide(root, commands) {
 
 ${commandBlock}`);
 }
-function writeCrossplatformEnvExample(root) {
-    writeFile(path.join(root, '.env.example'), `# Shared services
-DATABASE_URL=postgresql://user:pass@ep-xxx.us-east-1.aws.neon.tech/dbname?sslmode=require
+function writeRootDocs(root, options, stack) {
+    const toolchainLine = stack.outputs.toolchain.verifiedAt
+        ? `${options.toolchainChannel} (verified ${stack.outputs.toolchain.verifiedAt})`
+        : `${options.toolchainChannel} (floating latest)`;
+    const generatedPaths = stack.outputs.generated_paths.map((entry) => `- \`${entry}\``).join('\n') || '- `.`';
+    const frontendLabel = options.frontend === 'next' ? 'Next.js' : 'Expo';
+    const extensionLine = options.extension ? '- Extension: WXT Chrome extension\n' : '';
+    const extensionSetup = options.extension
+        ? '\n5. Build or run the extension separately. It is not deployed by Vercel:\n\n```bash\npnpm dev:extension\npnpm extension:zip\n```\n'
+        : '';
+    const frontendDevCommand = options.frontend === 'next' ? 'pnpm dev:web' : 'pnpm dev:mobile';
+    const frontendEnvCommand = options.frontend === 'next'
+        ? 'cp apps/web/.env.example apps/web/.env.local'
+        : '# apps/mobile/.env is generated for local Expo development';
+    const extensionEnvCommand = options.extension ? '\ncp apps/extension/.env.example apps/extension/.env' : '';
+    const extensionDevCommand = options.extension ? '\npnpm dev:extension' : '';
+    const paymentSetup = options.payments === 'stripe'
+        ? `- Stripe: create a Checkout price, then set \`STRIPE_SECRET_KEY\`, \`STRIPE_WEBHOOK_SECRET\`, and \`STRIPE_PRICE_STARTER\`.`
+        : `- RevenueCat: create an entitlement named \`pro\`, configure app keys, then set \`RC_SECRET_API_KEY\`, \`RC_WEBHOOK_SECRET\`, and the \`EXPO_PUBLIC_RC_*\` values.`;
+    const deploySetup = options.frontend === 'next'
+        ? '- Vercel: deploy this repo from the root. The root `vercel.json` builds `apps/web` and `apps/api`; Fastify is routed under `/backend/*`.'
+        : '- Vercel: deploy this repo from the root when you want the Fastify API hosted. Expo is built and shipped outside Vercel.';
+    writeFile(path.join(root, 'README.md'), `# ${options.displayName}
 
-# Clerk
-NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_test_***
-CLERK_SECRET_KEY=sk_test_***
-EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_test_***
+Generated by anhedral.
 
-# Cloudflare R2
-R2_ACCOUNT_ID=
-R2_ACCESS_KEY_ID=
-R2_SECRET_ACCESS_KEY=
-R2_BUCKET=
+## Stack
 
-# RevenueCat
-RC_SECRET_API_KEY=
-RC_WEBHOOK_SECRET=
-RC_ENTITLEMENT_ID=pro
-RC_OFFERING_ID=default
-EXPO_PUBLIC_RC_ENTITLEMENT_ID=pro
-EXPO_PUBLIC_RC_API_KEY_IOS=
-EXPO_PUBLIC_RC_API_KEY_ANDROID=
-EXPO_PUBLIC_RC_WEB_API_KEY=
+- Mode: fullstack
+- Frontend: ${frontendLabel}
+- Backend: Fastify
+${extensionLine}- Shared packages: \`packages/*\`
+- Auth: ${options.auth}
+- Payments: ${options.payments}
+- Database: ${options.db} + ${options.orm}
+- Storage: ${options.storage}
+- API: ${options.api ?? 'framework-native'}
+- Toolchain: ${toolchainLine}
 
-# Stripe
-STRIPE_SECRET_KEY=sk_test_***
-STRIPE_WEBHOOK_SECRET=whsec_***
-`);
-}
-function writeNextFullstackRootEnvExample(root) {
-    writeFile(path.join(root, '.env.example'), `# Frontend
-NEXT_PUBLIC_APP_URL=http://localhost:3000
-NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_test_***
-NEXT_PUBLIC_CLERK_SIGN_IN_URL=/sign-in
-NEXT_PUBLIC_CLERK_SIGN_UP_URL=/sign-up
-NEXT_PUBLIC_CLERK_AFTER_SIGN_IN_URL=/dashboard
-NEXT_PUBLIC_CLERK_AFTER_SIGN_UP_URL=/dashboard
+## Generated paths
 
-# Backend
-PORT=8787
-FRONTEND_URL=http://localhost:3000
-DATABASE_URL=postgresql://user:pass@ep-xxx.us-east-1.aws.neon.tech/dbname?sslmode=require
-CLERK_SECRET_KEY=sk_test_***
-CLERK_PUBLISHABLE_KEY=pk_test_***
+${generatedPaths}
 
-# Cloudflare R2
-R2_ACCOUNT_ID=
-R2_ACCESS_KEY_ID=
-R2_SECRET_ACCESS_KEY=
-R2_BUCKET=
+## First Run
 
-# Stripe
-STRIPE_SECRET_KEY=sk_test_***
-STRIPE_WEBHOOK_SECRET=whsec_***
-STRIPE_PRICE_STARTER=price_***
+\`\`\`bash
+pnpm install
+cp .env.example .env
+${frontendEnvCommand}${extensionEnvCommand}
+pnpm db:generate
+pnpm db:migrate
+pnpm dev:api
+${frontendDevCommand}${extensionDevCommand}
+\`\`\`
+
+For a provider-free smoke test, keep \`ANHEDRAL_DEMO=true\` in \`apps/api/.env\`. Demo mode returns a signed-in sample user and active subscription responses without Clerk, RevenueCat, or Stripe credentials. It is for local development only.
+
+## Provider Setup
+
+- Neon: create a Postgres database and set \`DATABASE_URL\` in the root and API env files.
+- Clerk: create an application, configure allowed origins, and set \`CLERK_PUBLISHABLE_KEY\`, \`CLERK_SECRET_KEY\`, plus the frontend publishable key for your selected client.
+${paymentSetup}
+- Cloudflare R2: create a bucket and API token, then set \`R2_ACCOUNT_ID\`, \`R2_ACCESS_KEY_ID\`, \`R2_SECRET_ACCESS_KEY\`, and \`R2_BUCKET\`.
+${deploySetup}
+
+## Setup Notes
+
+1. Copy \`.env.example\` into the runtime env files your apps need and fill in provider values.
+2. Review \`install-skills.sh\` and run the listed skill commands manually so you can choose scope and agent targets.
+3. Add the real provider configuration for Clerk, Stripe, RevenueCat, Neon, and R2 where the scaffolded helper files indicate.
+4. Run database generation and migrations from the shared DB package:
+
+\`\`\`bash
+pnpm db:generate
+pnpm db:migrate
+\`\`\`
+${extensionSetup}
 `);
 }
-function writeHeadlessPackageJson(root, projectName) {
-    writeRootPackageJson(root, projectName, {
-        dev: 'tsx --env-file=.env --watch src/index.ts',
-        build: 'tsc',
-        typecheck: 'tsc --noEmit',
-        'db:generate': 'drizzle-kit generate',
-        'db:migrate': 'pnpm tsx src/lib/db/migrate.ts',
-    }, undefined, {
-        type: 'module',
-    });
+function writeStackFile(root, stack) {
+    writeFile(path.join(root, 'stack.json'), JSON.stringify(stack, null, 2) + '\n');
 }
-function writeHeadlessTsConfig(root) {
-    writeFile(path.join(root, 'tsconfig.json'), JSON.stringify({
+function writeSharedPackages(root) {
+    const dbRoot = path.join(root, 'packages/db');
+    writeFile(path.join(dbRoot, 'package.json'), JSON.stringify({
+        name: '@anhedral/db',
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        exports: {
+            '.': './src/index.ts',
+            './schema': './src/schema.ts',
+            './queries': './src/queries/index.ts',
+            './migrate': './src/migrate.ts',
+        },
+        scripts: {
+            build: 'pnpm typecheck',
+            typecheck: 'tsc --noEmit',
+            'db:generate': 'drizzle-kit generate',
+            'db:migrate': 'tsx --env-file=../../.env src/migrate.ts',
+        },
+        dependencies: {
+            '@neondatabase/serverless': '^1.0.0',
+            'drizzle-orm': '^0.44.0',
+            dotenv: '^17.2.3',
+        },
+        devDependencies: {
+            'drizzle-kit': '^0.31.0',
+            tsx: '^4.20.5',
+            typescript: '^5.9.3',
+            '@types/node': '25.5.0',
+        },
+    }, null, 2) + '\n');
+    writeFile(path.join(dbRoot, 'tsconfig.json'), JSON.stringify({
         compilerOptions: {
             target: 'ESNext',
-            module: 'NodeNext',
-            moduleResolution: 'NodeNext',
+            module: 'ESNext',
+            moduleResolution: 'Bundler',
             strict: true,
-            esModuleInterop: true,
             skipLibCheck: true,
-            outDir: 'dist',
-            rootDir: 'src',
+            noEmit: true,
             types: ['node'],
         },
-        include: ['src/**/*'],
-        exclude: ['node_modules', 'dist'],
+        include: ['src/**/*', 'drizzle.config.ts'],
     }, null, 2) + '\n');
-}
-function writeHeadlessEnvExample(root) {
-    writeFile(path.join(root, '.env.example'), `PORT=8787
-CLIENT_ORIGIN=http://localhost:3000
-DATABASE_URL=postgresql://user:pass@ep-xxx.us-east-1.aws.neon.tech/dbname?sslmode=require
-
-# Better Auth
-BETTER_AUTH_SECRET=replace-me
-BETTER_AUTH_URL=http://localhost:8787
-BETTER_AUTH_TRUSTED_ORIGINS=http://localhost:3000
+    writeFile(path.join(dbRoot, 'drizzle.config.ts'), `import type { Config } from 'drizzle-kit';
 
-# Cloudflare R2
-R2_ACCOUNT_ID=
-R2_ACCESS_KEY_ID=
-R2_SECRET_ACCESS_KEY=
-R2_BUCKET=
+export default {
+  schema: './src/schema.ts',
+  out: './migrations',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+} satisfies Config;
 `);
-}
-function writeHeadlessFiles(root) {
-    writeFile(path.join(root, 'src/lib/db/client.ts'), `import { drizzle } from 'drizzle-orm/neon-http';
+    writeFile(path.join(dbRoot, 'src/index.ts'), `import { drizzle } from 'drizzle-orm/neon-http';
 import { neon } from '@neondatabase/serverless';
-import * as schema from './schema.js';
+import * as schema from './schema';
 
-if (!process.env.DATABASE_URL) {
-  throw new Error('DATABASE_URL is not defined');
+export function createDb(databaseUrl = process.env.DATABASE_URL) {
+  if (!databaseUrl) {
+    throw new Error('DATABASE_URL is not defined');
+  }
+
+  const sql = neon(databaseUrl);
+  return drizzle(sql, { schema });
+}
+
+export type Database = ReturnType<typeof createDb>;
+
+let cachedDb: Database | undefined;
+
+function getDb() {
+  cachedDb ??= createDb();
+  return cachedDb;
 }
 
-const sql = neon(process.env.DATABASE_URL);
-export const db = drizzle(sql, { schema });
+export const db = new Proxy({} as Database, {
+  get(_target, prop, receiver) {
+    return Reflect.get(getDb(), prop, receiver);
+  },
+});
+
+export * from './schema';
 `);
-    writeFile(path.join(root, 'src/lib/db/schema.ts'), `import { pgTable, text, timestamp, index } from 'drizzle-orm/pg-core';
+    writeFile(path.join(dbRoot, 'src/schema.ts'), `import { boolean, index, integer, jsonb, pgTable, text, timestamp } from 'drizzle-orm/pg-core';
+import type { InferInsertModel, InferSelectModel } from 'drizzle-orm';
+
+export const SUBSCRIPTION_TIERS = ['free', 'pro'] as const;
+export type SubscriptionTier = (typeof SUBSCRIPTION_TIERS)[number];
+
+export const SUBSCRIPTION_STATUSES = ['active', 'expired', 'canceled'] as const;
+export type SubscriptionStatus = (typeof SUBSCRIPTION_STATUSES)[number];
+
+export const SUBSCRIPTION_METHODS = ['trialing', 'redeemed', 'paid'] as const;
+export type SubscriptionMethod = (typeof SUBSCRIPTION_METHODS)[number];
+
+export const SUBSCRIPTION_ORIGINS = ['web', 'apple', 'google'] as const;
+export type SubscriptionOrigin = (typeof SUBSCRIPTION_ORIGINS)[number];
+
+export const SUBSCRIPTION_EVENT_TYPES = [
+  'trial_started', 'trial_converted', 'trial_expired',
+  'initial_purchase', 'renewal', 'product_change',
+  'cancellation_scheduled', 'cancellation_unscheduled', 'subscription_expired', 'subscription_canceled',
+  'promo_redeemed', 'billing_issue', 'billing_recovered',
+] as const;
+export type SubscriptionEventType = (typeof SUBSCRIPTION_EVENT_TYPES)[number];
+
+export type SubscriptionMetadata = {
+  revenueCatProductId?: string;
+  lastWebhookUpdate?: string;
+  cancelReason?: string;
+  redeemCode?: string;
+  redeemCodeRedeemedAt?: string;
+};
+
+export type SubscriptionEventMetadata = {
+  revenueCatEventType?: string;
+  revenueCatProductId?: string;
+  promoCode?: string;
+  billingPeriod?: string;
+  price?: { amount: number; currency: string };
+  store?: string;
+  transactionId?: string;
+  reason?: string;
+};
+
+export const PROMO_CODE_DURATIONS = [1, 6, 12] as const;
+export type PromoCodeDuration = (typeof PROMO_CODE_DURATIONS)[number];
 
 export const users = pgTable('users', {
   id: text('id').primaryKey(),
+  clerkUserId: text('clerk_user_id').unique(),
   email: text('email').notNull().unique(),
-  name: text('name'),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  updatedAt: timestamp('updated_at').defaultNow().notNull(),
-}, (table) => [
-  index('users_email_idx').on(table.email),
+  displayName: text('display_name'),
+  lastLoginAt: timestamp('last_login_at'),
+  profileImageUrl: text('profile_image_url'),
+  stripeCustomerId: text('stripe_customer_id').unique(),
+  subscriptionTier: text('subscription_tier').notNull().default('starter'),
+  subscriptionStatus: text('subscription_status').notNull().default('active'),
+  avatarObjectKey: text('avatar_object_key'),
+  avatarMimeType: text('avatar_mime_type'),
+  creditsBalance: integer('credits_balance').notNull().default(250),
+  createdAt: timestamp('created_at').$defaultFn(() => new Date()).notNull(),
+  updatedAt: timestamp('updated_at').$defaultFn(() => new Date()).notNull(),
+}, (t) => [
+  index('users_clerk_user_id_idx').on(t.clerkUserId),
+  index('users_email_idx').on(t.email),
 ]);
 
 export const uploads = pgTable('uploads', {
@@ -286,220 +393,440 @@ export const uploads = pgTable('uploads', {
   userId: text('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
   objectKey: text('object_key').notNull().unique(),
   bucket: text('bucket').notNull(),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
+  contentType: text('content_type'),
+  createdAt: timestamp('created_at').$defaultFn(() => new Date()).notNull(),
 });
-`);
-    writeFile(path.join(root, 'src/lib/db/queries/users.ts'), `import { eq } from 'drizzle-orm';
-import { db } from '../client.js';
-import { users } from '../schema.js';
 
-export async function findUserByEmail(email: string) {
-  return db.query.users.findFirst({
-    where: eq(users.email, email),
-  });
-}
-`);
-    writeFile(path.join(root, 'src/lib/db/queries/index.ts'), `export * from './users.js';
-`);
-    writeFile(path.join(root, 'src/lib/db/migrate.ts'), `import { drizzle } from 'drizzle-orm/neon-http';
-import { migrate } from 'drizzle-orm/neon-http/migrator';
-import { neon } from '@neondatabase/serverless';
-import 'dotenv/config';
+export const subscriptions = pgTable('subscriptions', {
+  id: text('id').primaryKey(),
+  userId: text('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }).unique(),
+  tier: text('tier').$type<SubscriptionTier>().notNull().default('free'),
+  status: text('status').$type<SubscriptionStatus>().notNull().default('active'),
+  method: text('method').$type<SubscriptionMethod>(),
+  origin: text('origin').$type<SubscriptionOrigin>(),
+  billingPeriod: text('billing_period'),
+  currentPeriodStart: timestamp('current_period_start'),
+  currentPeriodEnd: timestamp('current_period_end'),
+  canceledAt: timestamp('canceled_at'),
+  cancelAtPeriodEnd: boolean('cancel_at_period_end').notNull().default(false),
+  trialStart: timestamp('trial_start'),
+  trialEnd: timestamp('trial_end'),
+  dailyLimit: integer('daily_limit'),
+  metadata: jsonb('metadata').$type<SubscriptionMetadata>(),
+  createdAt: timestamp('created_at').$defaultFn(() => new Date()).notNull(),
+  updatedAt: timestamp('updated_at').$defaultFn(() => new Date()).notNull(),
+}, (t) => [
+  index('subscriptions_user_idx').on(t.userId),
+  index('subscriptions_status_idx').on(t.status),
+  index('subscriptions_tier_idx').on(t.tier),
+  index('subscriptions_period_end_idx').on(t.currentPeriodEnd),
+]);
 
-if (!process.env.DATABASE_URL) {
-  throw new Error('DATABASE_URL is not defined');
-}
+export const subscriptionEvents = pgTable('subscription_events', {
+  id: text('id').primaryKey(),
+  userId: text('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  subscriptionId: text('subscription_id').references(() => subscriptions.id, { onDelete: 'set null' }),
+  eventType: text('event_type').$type<SubscriptionEventType>().notNull(),
+  previousTier: text('previous_tier').$type<SubscriptionTier>(),
+  previousStatus: text('previous_status').$type<SubscriptionStatus>(),
+  previousMethod: text('previous_method').$type<SubscriptionMethod>(),
+  newTier: text('new_tier').$type<SubscriptionTier>(),
+  newStatus: text('new_status').$type<SubscriptionStatus>(),
+  newMethod: text('new_method').$type<SubscriptionMethod>(),
+  revenueCatEventType: text('revenuecat_event_type'),
+  revenueCatProductId: text('revenuecat_product_id'),
+  origin: text('origin').$type<SubscriptionOrigin>(),
+  periodStart: timestamp('period_start'),
+  periodEnd: timestamp('period_end'),
+  metadata: jsonb('metadata').$type<SubscriptionEventMetadata>(),
+  createdAt: timestamp('created_at').$defaultFn(() => new Date()).notNull(),
+}, (t) => [
+  index('sub_events_user_idx').on(t.userId),
+  index('sub_events_user_created_idx').on(t.userId, t.createdAt),
+  index('sub_events_type_idx').on(t.eventType),
+]);
 
-const sql = neon(process.env.DATABASE_URL);
-const db = drizzle(sql);
+export const trialClaims = pgTable('trial_claims', {
+  id: text('id').primaryKey(),
+  userId: text('user_id').references(() => users.id, { onDelete: 'set null' }),
+  email: text('email').notNull().unique(),
+  claimedAt: timestamp('claimed_at').$defaultFn(() => new Date()).notNull(),
+}, (t) => [index('trial_claims_email_idx').on(t.email)]);
 
-await migrate(db, { migrationsFolder: './src/lib/db/migrations' });
-`);
-    writeFile(path.join(root, 'src/lib/db/migrations/.gitkeep'), '');
-    writeFile(path.join(root, 'src/lib/storage/r2.ts'), `import { S3Client } from '@aws-sdk/client-s3';
-
-export const r2 = new S3Client({
-  region: 'auto',
-  endpoint: \`https://\${process.env.R2_ACCOUNT_ID}.r2.cloudflarestorage.com\`,
-  credentials: {
-    accessKeyId: process.env.R2_ACCESS_KEY_ID ?? '',
-    secretAccessKey: process.env.R2_SECRET_ACCESS_KEY ?? '',
-  },
-});
-`);
-    writeFile(path.join(root, 'src/lib/auth/auth.ts'), `import { betterAuth } from 'better-auth';
-import { drizzleAdapter } from 'better-auth/adapters/drizzle';
-import { db } from '../db/client.js';
-import * as schema from '../db/schema.js';
-
-export const auth = betterAuth({
-  database: drizzleAdapter(db, {
-    provider: 'pg',
-    usePlural: true,
-    schema,
-  }),
-  emailAndPassword: {
-    enabled: true,
-  },
-  baseURL: process.env.BETTER_AUTH_URL,
-  trustedOrigins: (process.env.BETTER_AUTH_TRUSTED_ORIGINS ?? '')
-    .split(',')
-    .map((value) => value.trim())
-    .filter(Boolean),
-});
+export const promoCodes = pgTable('promo_codes', {
+  id: text('id').primaryKey(),
+  code: text('code').notNull().unique(),
+  months: integer('months').$type<PromoCodeDuration>().notNull(),
+  maxRedemptions: integer('max_redemptions').notNull().default(1),
+  redeemedCount: integer('redeemed_count').notNull().default(0),
+  expiresAt: timestamp('expires_at'),
+  createdAt: timestamp('created_at').$defaultFn(() => new Date()).notNull(),
+}, (t) => [index('promo_codes_code_idx').on(t.code)]);
+
+export const promoRedemptions = pgTable('promo_redemptions', {
+  id: text('id').primaryKey(),
+  promoCodeId: text('promo_code_id').notNull().references(() => promoCodes.id, { onDelete: 'cascade' }),
+  userId: text('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  redeemedAt: timestamp('redeemed_at').$defaultFn(() => new Date()).notNull(),
+  entitlementExpiresAt: timestamp('entitlement_expires_at').notNull(),
+}, (t) => [
+  index('promo_redemptions_user_idx').on(t.userId),
+  index('promo_redemptions_code_idx').on(t.promoCodeId),
+]);
+
+export type Users = InferSelectModel<typeof users>;
+export type NewUsers = InferInsertModel<typeof users>;
+export type Uploads = InferSelectModel<typeof uploads>;
+export type NewUploads = InferInsertModel<typeof uploads>;
+export type Subscriptions = InferSelectModel<typeof subscriptions>;
+export type NewSubscriptions = InferInsertModel<typeof subscriptions>;
+export type SubscriptionEvents = InferSelectModel<typeof subscriptionEvents>;
+export type NewSubscriptionEvents = InferInsertModel<typeof subscriptionEvents>;
+export type TrialClaims = InferSelectModel<typeof trialClaims>;
+export type NewTrialClaims = InferInsertModel<typeof trialClaims>;
+export type PromoCodes = InferSelectModel<typeof promoCodes>;
+export type NewPromoCodes = InferInsertModel<typeof promoCodes>;
+export type PromoRedemptions = InferSelectModel<typeof promoRedemptions>;
+export type NewPromoRedemptions = InferInsertModel<typeof promoRedemptions>;
 `);
-    writeFile(path.join(root, 'src/app.ts'), `import Fastify from 'fastify';
-import cors from '@fastify/cors';
-import { fromNodeHeaders } from 'better-auth/node';
-import { auth } from './lib/auth/auth.js';
+    writeFile(path.join(dbRoot, 'src/queries/users.ts'), `import { eq } from 'drizzle-orm';
+import { db } from '../index';
+import { uploads, users } from '../schema';
 
-export function buildApp() {
-  const app = Fastify({ logger: true });
+type SyncUserInput = {
+  clerkUserId: string;
+  email: string;
+  displayName: string | null;
+};
 
-  app.register(cors, {
-    origin: process.env.CLIENT_ORIGIN ?? true,
-    credentials: true,
+export async function findUserByClerkId(clerkUserId: string) {
+  return db.query.users.findFirst({
+    where: eq(users.clerkUserId, clerkUserId),
   });
+}
 
-  app.get('/health', async () => ({ ok: true }));
-
-  app.route({
-    method: ['GET', 'POST'],
-    url: '/api/auth/*',
-    async handler(request, reply) {
-      const url = new URL(request.url, \`http://\${request.headers.host}\`);
-      const headers = new Headers();
+export async function syncUserProfile(input: SyncUserInput) {
+  await db
+    .insert(users)
+    .values({
+      id: input.clerkUserId,
+      clerkUserId: input.clerkUserId,
+      email: input.email,
+      displayName: input.displayName,
+    })
+    .onConflictDoUpdate({
+      target: users.clerkUserId,
+      set: {
+        email: input.email,
+        displayName: input.displayName,
+        updatedAt: new Date(),
+      },
+    });
 
-      Object.entries(request.headers).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-          for (const entry of value) headers.append(key, entry);
-          return;
-        }
+  return findUserByClerkId(input.clerkUserId);
+}
 
-        if (value) headers.append(key, value.toString());
-      });
+export async function updateStripeCustomerForUser(clerkUserId: string, stripeCustomerId: string) {
+  await db
+    .update(users)
+    .set({
+      stripeCustomerId,
+      subscriptionStatus: 'checkout_started',
+      updatedAt: new Date(),
+    })
+    .where(eq(users.clerkUserId, clerkUserId));
+}
 
-      const authRequest = new Request(url.toString(), {
-        method: request.method,
-        headers,
-        body: request.body ? JSON.stringify(request.body) : undefined,
-      });
+export async function updateAvatarForUser(
+  clerkUserId: string,
+  input: { objectKey: string; contentType: string | null },
+) {
+  await db
+    .update(users)
+    .set({
+      avatarObjectKey: input.objectKey,
+      avatarMimeType: input.contentType,
+      updatedAt: new Date(),
+    })
+    .where(eq(users.clerkUserId, clerkUserId));
+}
 
-      const response = await auth.handler(authRequest);
-      reply.status(response.status);
-      response.headers.forEach((value, key) => reply.header(key, value));
-      reply.send(response.body ? await response.text() : null);
-    },
+export async function createUploadRecord(
+  clerkUserId: string,
+  input: { objectKey: string; bucket: string; contentType: string | null },
+) {
+  await db.insert(uploads).values({
+    id: crypto.randomUUID(),
+    userId: clerkUserId,
+    objectKey: input.objectKey,
+    bucket: input.bucket,
+    contentType: input.contentType,
   });
+}
+`);
+    writeFile(path.join(dbRoot, 'src/queries/uploads.ts'), `import { eq } from 'drizzle-orm';
+import { db } from '../index';
+import { uploads } from '../schema';
 
-  app.get('/api/me', async (request, reply) => {
-    const session = await auth.api.getSession({
-      headers: fromNodeHeaders(request.headers),
-    });
-
-    if (!session) {
-      return reply.status(401).send({ error: 'Unauthorized' });
-    }
-
-    return reply.send(session);
+export async function listUploadsForUser(userId: string) {
+  return db.query.uploads.findMany({
+    where: eq(uploads.userId, userId),
   });
-
-  return app;
 }
 `);
-    writeFile(path.join(root, 'src/index.ts'), `import 'dotenv/config';
-import { buildApp } from './app.js';
-
-const app = buildApp();
-const port = Number(process.env.PORT ?? 8787);
-
-app.listen({ port, host: '0.0.0.0' })
-  .then(() => {
-    app.log.info({ port }, 'server_started');
-  })
-  .catch((error) => {
-    app.log.error(error);
-    process.exit(1);
-  });
+    writeFile(path.join(dbRoot, 'src/queries/index.ts'), `export * from './uploads';
+export * from './users';
 `);
+    writeFile(path.join(dbRoot, 'src/migrate.ts'), `import { drizzle } from 'drizzle-orm/neon-http';
+import { migrate } from 'drizzle-orm/neon-http/migrator';
+import { neon } from '@neondatabase/serverless';
+import dotenv from 'dotenv';
+
+dotenv.config({ path: '../../.env', quiet: true });
+dotenv.config({ quiet: true });
+
+if (!process.env.DATABASE_URL) {
+  throw new Error('DATABASE_URL is not defined');
 }
-function writeRootDocs(root, options, stack) {
-    const toolchainLine = stack.outputs.toolchain.verifiedAt
-        ? `${options.toolchainChannel} (verified ${stack.outputs.toolchain.verifiedAt})`
-        : `${options.toolchainChannel} (floating latest)`;
-    const generatedPaths = stack.outputs.generated_paths.map((entry) => `- \`${entry}\``).join('\n') || '- `.`';
-    const envCopyStep = options.mode === 'next'
-        ? 'Copy `.env.example` to `.env.local` and fill in your provider values.'
-        : options.mode === 'next-fullstack'
-            ? 'Copy the root `.env.example` values into the `.env.local` and `.env` files your frontend and backend will read before starting the apps.'
-            : options.mode === 'expo-fullstack'
-                ? 'Copy the generated `.env.example` files into the runtime `.env` files each package expects before starting the apps.'
-                : 'Copy `.env.example` to `.env` and fill in your provider values.';
-    const authStep = options.mode === 'backend'
-        ? 'Review `src/lib/auth/auth.ts` and align the Better Auth schema with your production auth tables before shipping.'
-        : options.mode === 'expo-fullstack'
-            ? 'Add the real provider configuration for Clerk, RevenueCat, and Stripe where the scaffolded helper files indicate.'
-            : options.mode === 'next-fullstack'
-                ? 'Add the real provider configuration for Clerk and Stripe across the frontend and backend where the scaffolded helper files indicate.'
-                : 'Add the real provider configuration for Clerk and Stripe where the scaffolded helper files indicate.';
-    const databaseCommands = options.mode === 'next-fullstack' || options.mode === 'expo-fullstack'
-        ? '```bash\ncd backend\npnpm db:generate\npnpm db:migrate\n```'
-        : '```bash\npnpm db:generate\npnpm db:migrate\n```';
-    writeFile(path.join(root, 'README.md'), `# ${options.displayName}
 
-Generated by anhedral.
+const client = neon(process.env.DATABASE_URL);
+const database = drizzle(client);
 
-## Stack
+console.log('Running migrations...');
+const start = Date.now();
+await migrate(database, { migrationsFolder: './migrations' });
+console.log('Migrations completed in', Date.now() - start, 'ms');
+`);
+    writeFile(path.join(dbRoot, 'migrations/.gitkeep'), '');
+    const simplePackages = [
+        ['types', { exports: { '.': './src/index.ts' } }, `export type ApiEnvelope<T> = { data: T } | { error: string; message: string };
+export type ClientPlatform = 'web' | 'mobile' | 'extension';
+export type SubscriptionEntitlements = {
+  pro: boolean;
+  inTrial: boolean;
+  trialEndsAt?: string;
+  expiresAt?: string;
+  periodStart?: string;
+  periodEnd?: string;
+  method?: 'trialing' | 'redeemed' | 'paid' | null;
+  managementUrl?: string;
+  cancelAtPeriodEnd?: boolean;
+};
+export type AuthMeResponse = {
+  user: {
+    id: string;
+    email: string;
+    firstName?: string | null;
+    lastName?: string | null;
+    displayName?: string | null;
+    imageUrl?: string | null;
+    avatarUrl?: string | null;
+    creditsBalance: number;
+    subscriptionTier: string;
+    subscriptionStatus: string;
+  };
+};
+export type PricingResponse = {
+  plans: Array<{
+    id: string;
+    name: string;
+    description: string;
+    price: string;
+    features: string[];
+  }>;
+};
+`],
+        ['config', { exports: { '.': './src/index.ts' } }, `export const DEFAULT_API_PATH_PREFIX = '/api';
+export const DEFAULT_LOCAL_API_URL = 'http://localhost:8787';
+export const DEFAULT_WEB_URL = 'http://localhost:3000';
+export const DEFAULT_MOBILE_URL = 'http://localhost:8081';
+export const DEFAULT_EXTENSION_URL = 'chrome-extension://';
+
+export function joinApiUrl(baseUrl: string, path: string) {
+  const base = baseUrl.replace(/\\/$/, '');
+  const suffix = path.startsWith('/') ? path : \`/\${path}\`;
+  return \`\${base}\${suffix}\`;
+}
+`],
+        ['api-client', {
+                exports: { '.': './src/index.ts' },
+                dependencies: {
+                    '@anhedral/config': 'workspace:*',
+                    '@anhedral/types': 'workspace:*',
+                },
+            }, `import { joinApiUrl } from '@anhedral/config';
+import type { AuthMeResponse, ClientPlatform, PricingResponse, SubscriptionEntitlements } from '@anhedral/types';
+
+export type ApiClientOptions = {
+  baseUrl: string;
+  platform: ClientPlatform;
+  getToken?: () => Promise<string | null>;
+};
+
+export class ApiClient {
+  constructor(private readonly options: ApiClientOptions) {}
+
+  async request<T>(path: string, init: RequestInit = {}): Promise<T> {
+    const token = await this.options.getToken?.();
+    const headers = new Headers(init.headers);
+    headers.set('Content-Type', headers.get('Content-Type') ?? 'application/json');
+    headers.set('X-Platform', this.options.platform);
+    if (token) headers.set('Authorization', \`Bearer \${token}\`);
+
+    const response = await fetch(joinApiUrl(this.options.baseUrl, path), {
+      ...init,
+      headers,
+    });
 
-- Mode: ${options.mode}
-- Auth: ${options.auth}
-- Payments: ${options.payments}
-- Database: ${options.db} + ${options.orm}
-- Storage: ${options.storage}
-- API: ${options.api ?? 'framework-native'}
-- Toolchain: ${toolchainLine}
+    if (!response.ok) {
+      throw new Error(\`API request failed: \${response.status}\`);
+    }
 
-## Generated paths
+    return response.json() as Promise<T>;
+  }
 
-${generatedPaths}
+  getMe() {
+    return this.request<AuthMeResponse>('/auth/me');
+  }
 
-## Setup
+  getPricing() {
+    return this.request<PricingResponse>('/subscriptions/pricing');
+  }
 
-1. ${envCopyStep}
-2. Review \`install-skills.sh\` and run the listed skill commands manually so you can choose scope and agent targets.
-3. ${authStep}
-4. Run database generation and migrations:
+  getSubscriptionEntitlements(options?: { refresh?: boolean }) {
+    return this.request<SubscriptionEntitlements>(
+      options?.refresh ? '/subscriptions/entitlements/me?refresh=true' : '/subscriptions/entitlements/me',
+    );
+  }
 
-${databaseCommands}
-`);
+  redeemCode(code: string) {
+    return this.request<{ ok: boolean; expiresAt: string }>('/subscriptions/redeem', {
+      method: 'POST',
+      body: JSON.stringify({ code }),
+    });
+  }
 }
-function writeStackFile(root, stack) {
-    writeFile(path.join(root, 'stack.json'), JSON.stringify(stack, null, 2) + '\n');
+`],
+    ];
+    for (const [name, packageFields, source] of simplePackages) {
+        const packageRoot = path.join(root, `packages/${name}`);
+        writeFile(path.join(packageRoot, 'package.json'), JSON.stringify({
+            name: `@anhedral/${name}`,
+            version: '0.1.0',
+            private: true,
+            type: 'module',
+            scripts: {
+                build: 'pnpm typecheck',
+                typecheck: 'tsc --noEmit',
+            },
+            devDependencies: {
+                typescript: '^5.9.3',
+            },
+            ...packageFields,
+        }, null, 2) + '\n');
+        writeFile(path.join(packageRoot, 'tsconfig.json'), JSON.stringify({
+            compilerOptions: {
+                target: 'ESNext',
+                module: 'ESNext',
+                moduleResolution: 'Bundler',
+                strict: true,
+                skipLibCheck: true,
+                noEmit: true,
+            },
+            include: ['src/**/*'],
+        }, null, 2) + '\n');
+        writeFile(path.join(packageRoot, 'src/index.ts'), source);
+    }
 }
-function scaffoldDefaultWeb(root, options) {
-    const toolchain = resolveToolchain(options.toolchainChannel);
-    runScaffoldCommands(root, [getDefaultWebInitCommand(toolchain, options.projectName)]);
-    liftNestedProject(root, options.projectName);
-    runScaffoldCommands(root, getDefaultWebDependencyCommands());
-    appendGitignore(root, [
-        ...SHARED_ENV_GITIGNORE_LINES,
-        '.next',
-        'node_modules',
-        'lib/db/migrations',
-        ...SHARED_TYPESCRIPT_GITIGNORE_LINES,
-    ]);
-    patchPackageJson(root, {
-        packageManager: PNPM_PACKAGE_MANAGER,
-        scripts: {
-            typecheck: 'tsc --noEmit',
-            'db:generate': 'drizzle-kit generate',
-            'db:migrate': 'pnpm tsx lib/db/migrate.ts',
-        },
-    });
-    writeDrizzleConfig(root, './lib/db/schema.ts', './lib/db/migrations');
-    writeDefaultWebEnvExample(root);
-    writeDefaultWebFiles(root, options.displayName);
-    return ['.'];
+function writeRootEnvExample(root, options) {
+    const frontendUrl = options.frontend === 'next' ? 'http://localhost:3000' : 'http://localhost:8081';
+    const nextEnv = options.frontend === 'next'
+        ? `NEXT_PUBLIC_APP_URL=http://localhost:3000
+NEXT_PUBLIC_API_URL=http://localhost:8787
+NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_test_***
+NEXT_PUBLIC_CLERK_SIGN_IN_URL=/sign-in
+NEXT_PUBLIC_CLERK_SIGN_UP_URL=/sign-up
+NEXT_PUBLIC_CLERK_AFTER_SIGN_IN_URL=/dashboard
+NEXT_PUBLIC_CLERK_AFTER_SIGN_UP_URL=/dashboard
+`
+        : '';
+    const expoEnv = options.frontend === 'expo'
+        ? `EXPO_PUBLIC_API_URL=http://localhost:8787
+EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_test_***
+EXPO_PUBLIC_RC_ENTITLEMENT_ID=pro
+EXPO_PUBLIC_RC_API_KEY_IOS=
+EXPO_PUBLIC_RC_API_KEY_ANDROID=
+EXPO_PUBLIC_RC_WEB_API_KEY=
+`
+        : '';
+    const extensionEnv = options.extension
+        ? `VITE_API_URL=http://localhost:8787
+VITE_WEBSITE_URL=${frontendUrl}
+VITE_CLERK_PUBLISHABLE_KEY=pk_test_***
+VITE_CRX_PUBLIC_KEY=
+VITE_RC_BILLING_URL=
+`
+        : '';
+    const revenueCatEnv = options.payments === 'revenuecat'
+        ? `# RevenueCat
+RC_SECRET_API_KEY=
+RC_WEBHOOK_SECRET=
+RC_ENTITLEMENT_ID=pro
+RC_OFFERING_ID=default
+`
+        : '';
+    const stripeEnv = options.payments === 'stripe'
+        ? `# Stripe
+STRIPE_SECRET_KEY=sk_test_***
+STRIPE_WEBHOOK_SECRET=whsec_***
+STRIPE_PRICE_STARTER=price_***
+`
+        : '';
+    writeFile(path.join(root, '.env.example'), `# Apps
+FRONTEND_URL=${frontendUrl}
+ANHEDRAL_DEMO=false
+${nextEnv}${expoEnv}${extensionEnv}
+
+# Server
+PORT=8787
+DATABASE_URL=postgresql://user:pass@ep-xxx.us-east-1.aws.neon.tech/dbname?sslmode=require
+
+# Clerk
+CLERK_PUBLISHABLE_KEY=pk_test_***
+CLERK_SECRET_KEY=sk_test_***
+
+# Cloudflare R2
+R2_ACCOUNT_ID=
+R2_ACCESS_KEY_ID=
+R2_SECRET_ACCESS_KEY=
+R2_BUCKET=
+
+${revenueCatEnv}${stripeEnv}`);
+}
+function writeRootVercelJson(root, options) {
+    const builds = options.frontend === 'next'
+        ? [
+            { src: 'apps/web/package.json', use: '@vercel/next' },
+            { src: 'apps/api/api/index.ts', use: '@vercel/node' },
+        ]
+        : [
+            { src: 'apps/api/api/index.ts', use: '@vercel/node' },
+        ];
+    const routes = options.frontend === 'next'
+        ? [
+            { src: '/backend/(.*)', dest: 'apps/api/api/index.ts' },
+            { src: '/(.*)', dest: 'apps/web/$1' },
+        ]
+        : [
+            { src: '/api/(.*)', dest: 'apps/api/api/index.ts' },
+            { src: '/(.*)', dest: 'apps/api/api/index.ts' },
+        ];
+    writeFile(path.join(root, 'vercel.json'), JSON.stringify({ version: 2, builds, routes }, null, 2) + '\n');
+    writeFile(path.join(root, '.vercelignore'), `apps/extension/.output
+apps/extension/.wxt
+apps/extension/dist
+apps/mobile/.expo
+`);
 }
 function patchGeneratedPackageName(root, name) {
     const filePath = path.join(root, 'package.json');
@@ -509,86 +836,136 @@ function patchGeneratedPackageName(root, name) {
 }
 function scaffoldNextFrontend(root, options, directoryName) {
     const toolchain = resolveToolchain(options.toolchainChannel);
-    runScaffoldCommands(root, [getDefaultWebInitCommand(toolchain, directoryName)]);
-    runScaffoldCommands(path.join(root, directoryName), getDefaultWebDependencyCommands());
-    appendGitignore(path.join(root, directoryName), [
+    const appsRoot = path.join(root, 'apps');
+    const appRoot = path.join(appsRoot, directoryName);
+    anhedralPrint.section('Web (Next.js + shadcn/ui)');
+    anhedralPrint.step('Scaffolding Next.js app');
+    writeFile(path.join(appsRoot, '.gitkeep'), '');
+    runScaffoldCommands(appsRoot, [getDefaultWebInitCommand(toolchain, directoryName)]);
+    anhedralPrint.done('Next.js app scaffolded');
+    const packageJsonPath = path.join(appRoot, 'package.json');
+    const packageJson = readJsonFile(packageJsonPath);
+    packageJson.dependencies = {
+        ...(packageJson.dependencies ?? {}),
+        '@anhedral/db': 'workspace:*',
+    };
+    writeJsonFile(packageJsonPath, packageJson);
+    anhedralPrint.step('Installing web dependencies');
+    runScaffoldCommands(appRoot, getDefaultWebDependencyCommands());
+    anhedralPrint.done('Web dependencies installed');
+    rmSync(path.join(appRoot, '.git'), { recursive: true, force: true });
+    appendGitignore(appRoot, [
         ...SHARED_ENV_GITIGNORE_LINES,
         '.next',
         'node_modules',
         'lib/db/migrations',
         ...SHARED_TYPESCRIPT_GITIGNORE_LINES,
     ]);
-    patchPackageJson(path.join(root, directoryName), {
+    patchPackageJson(appRoot, {
         packageManager: PNPM_PACKAGE_MANAGER,
         scripts: {
             typecheck: 'tsc --noEmit',
-            'db:generate': 'drizzle-kit generate',
-            'db:migrate': 'pnpm tsx lib/db/migrate.ts',
+            'db:generate': 'pnpm --filter @anhedral/db db:generate',
+            'db:migrate': 'pnpm --filter @anhedral/db db:migrate',
         },
     });
-    patchGeneratedPackageName(path.join(root, directoryName), `${options.projectName}-${directoryName}`);
-    writeDrizzleConfig(path.join(root, directoryName), './lib/db/schema.ts', './lib/db/migrations');
-    writeDefaultWebEnvExample(path.join(root, directoryName));
-    writeDefaultWebFiles(path.join(root, directoryName), options.displayName);
-}
-async function scaffoldNextFullstack(root, options) {
-    scaffoldNextFrontend(root, options, 'frontend');
-    writeRootPackageJson(root, options.projectName, {
-        dev: 'pnpm -r --parallel --filter ./frontend --filter ./backend run dev',
-    }, ['frontend', 'backend']);
-    writePnpmWorkspace(root, ['frontend', 'backend']);
+    patchGeneratedPackageName(appRoot, `${options.projectName}-${directoryName}`);
+    writeDefaultWebEnvExample(appRoot);
+    writeDefaultWebFiles(appRoot, options.displayName);
+    for (const relativePath of [
+        'lib/app/dashboard.ts',
+        'app/api/account/avatar/route.ts',
+        'app/api/stripe/checkout/route.ts',
+        'app/api/stripe/portal/route.ts',
+    ]) {
+        replaceInFile(path.join(appRoot, relativePath), [
+            ["@/lib/db/queries", '@anhedral/db/queries'],
+        ]);
+    }
+    rmSync(path.join(appRoot, 'lib/db'), { recursive: true, force: true });
+}
+function writeFullstackRootFiles(root, options) {
+    const appFilters = [
+        options.frontend === 'next' ? './apps/web' : './apps/mobile',
+        './apps/api',
+        ...(options.extension ? ['./apps/extension'] : []),
+    ];
+    const parallelFilters = appFilters.map((entry) => `--filter ${entry}`).join(' ');
+    const buildFilters = ['./packages/db', ...appFilters].map((entry) => `--filter ${entry}`).join(' ');
+    const scripts = {
+        dev: `pnpm -r --parallel ${parallelFilters} run dev`,
+        'dev:api': 'pnpm --filter ./apps/api dev',
+        build: `pnpm -r ${buildFilters} build`,
+        typecheck: 'pnpm -r typecheck',
+        'db:generate': 'pnpm --filter @anhedral/db db:generate',
+        'db:migrate': 'pnpm --filter @anhedral/db db:migrate',
+    };
+    if (options.frontend === 'next') {
+        scripts['dev:web'] = 'pnpm --filter ./apps/web dev';
+    }
+    else {
+        scripts['dev:mobile'] = 'pnpm --filter ./apps/mobile dev';
+    }
+    if (options.extension) {
+        scripts['dev:extension'] = 'pnpm --filter ./apps/extension dev';
+        scripts['extension:zip'] = 'pnpm --filter ./apps/extension zip';
+    }
+    writeRootPackageJson(root, options.projectName, scripts, ['apps/*', 'packages/*']);
+    writePnpmWorkspace(root, ['apps/*', 'packages/*']);
     appendGitignore(root, [
         'node_modules',
-        'frontend/node_modules',
-        'backend/node_modules',
+        'apps/*/node_modules',
+        'packages/*/node_modules',
         ...SHARED_ENV_GITIGNORE_LINES,
+        ...SHARED_TYPESCRIPT_GITIGNORE_LINES,
     ]);
-    writeNextFullstackRootEnvExample(root);
+    writeRootEnvExample(root, options);
+    writeRootVercelJson(root, options);
+}
+async function scaffoldFullstack(root, options) {
+    anhedralPrint.section('Workspace root');
+    anhedralPrint.step('Writing root config (package.json, pnpm workspace, env, vercel)');
+    writeFullstackRootFiles(root, options);
+    anhedralPrint.done('Root config written');
+    anhedralPrint.section('Shared packages');
+    anhedralPrint.step('Writing @anhedral/db, types, config, api-client');
+    writeSharedPackages(root);
+    anhedralPrint.done('Shared packages written');
+    const frontendUrl = options.frontend === 'next' ? 'http://localhost:3000' : 'http://localhost:8081';
     await scaffoldBackend(root, {
         projectName: options.projectName,
         displayName: options.displayName,
         githubOrg: null,
-        frontendUrl: 'http://localhost:3000',
+        frontendUrl,
     });
-    return ['frontend', 'backend'];
-}
-async function scaffoldCrossplatform(root, options) {
-    writeRootPackageJson(root, options.projectName, {
-        dev: 'pnpm -r --parallel --filter ./frontend --filter ./backend run dev',
-    }, ['frontend', 'backend']);
-    writePnpmWorkspace(root, ['frontend', 'backend']);
-    appendGitignore(root, [
-        'node_modules',
-        'frontend/node_modules',
-        'backend/node_modules',
-        ...SHARED_ENV_GITIGNORE_LINES,
-    ]);
-    writeCrossplatformEnvExample(root);
-    const projectOptions = {
-        projectName: options.projectName,
-        displayName: options.displayName,
-        githubOrg: null,
-        frontendUrl: 'http://localhost:8081',
-    };
-    await scaffoldFrontend(root, projectOptions);
-    await scaffoldBackend(root, projectOptions);
-    return ['frontend', 'backend'];
-}
-function scaffoldHeadless(root, options) {
-    writeHeadlessPackageJson(root, options.projectName);
-    appendGitignore(root, [
-        'dist',
-        'node_modules',
-        ...SHARED_ENV_GITIGNORE_LINES,
-        '*.log',
-        ...SHARED_TYPESCRIPT_GITIGNORE_LINES,
-    ]);
-    writeHeadlessTsConfig(root);
-    writeDrizzleConfig(root, './src/lib/db/schema.ts', './src/lib/db/migrations');
-    writeHeadlessEnvExample(root);
-    writeHeadlessFiles(root);
-    runScaffoldCommands(root, getHeadlessInstallCommands());
-    return ['.'];
+    if (options.frontend === 'next') {
+        scaffoldNextFrontend(root, options, 'web');
+    }
+    else {
+        await scaffoldFrontend(root, {
+            projectName: options.projectName,
+            displayName: options.displayName,
+            githubOrg: null,
+            frontendUrl,
+        });
+    }
+    if (options.extension) {
+        await scaffoldExtension(root, {
+            projectName: options.projectName,
+            displayName: options.displayName,
+            githubOrg: null,
+            frontendUrl,
+        });
+    }
+    return [
+        options.frontend === 'next' ? 'apps/web' : 'apps/mobile',
+        'apps/api',
+        ...(options.extension ? ['apps/extension'] : []),
+        'packages/db',
+        'packages/types',
+        'packages/config',
+        'packages/api-client',
+    ];
 }
 export async function scaffoldProject(options) {
     const root = path.resolve(process.cwd());
@@ -597,24 +974,36 @@ export async function scaffoldProject(options) {
     env.ANHEDRAL_TOOLCHAIN = options.toolchainChannel;
     try {
         await printAsciiLogo();
-        console.log(`\n📁 Initializing ${options.displayName} in ${root}\n`);
-        const generatedPaths = options.mode === 'next'
-            ? scaffoldDefaultWeb(root, options)
-            : options.mode === 'next-fullstack'
-                ? await scaffoldNextFullstack(root, options)
-                : options.mode === 'expo-fullstack'
-                    ? await scaffoldCrossplatform(root, options)
-                    : scaffoldHeadless(root, options);
-        const skillCommands = getSkillCommands(options.mode);
+        anhedralPrint.banner(`Initializing ${options.displayName} in ${root}`);
+        const generatedPaths = await scaffoldFullstack(root, options);
+        anhedralPrint.section('Project metadata');
+        anhedralPrint.step('Writing skills guide, README, and stack.json');
+        const skillCommands = getSkillCommands(options);
         writeSkillsGuide(root, skillCommands);
         const stack = normalizeStack(options, generatedPaths);
         writeRootDocs(root, options, stack);
         writeStackFile(root, stack);
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log(`\n🎉 ${options.displayName} is ready.\n`);
-        console.log('Generated:');
+        anhedralPrint.done('Project metadata written');
+        console.log('');
+        anhedralPrint.banner(`${options.displayName} is ready`);
         for (const generatedPath of generatedPaths) {
-            console.log(`  - ${generatedPath}`);
+            anhedralPrint.done(generatedPath);
+        }
+        console.log('');
+        anhedralPrint.info('Next commands:');
+        console.log('  pnpm install');
+        console.log('  cp .env.example .env');
+        if (options.frontend === 'next') {
+            console.log('  cp apps/web/.env.example apps/web/.env.local');
+        }
+        if (options.extension) {
+            console.log('  cp apps/extension/.env.example apps/extension/.env');
+        }
+        console.log('  pnpm db:generate && pnpm db:migrate');
+        console.log('  pnpm dev:api');
+        console.log(options.frontend === 'next' ? '  pnpm dev:web' : '  pnpm dev:mobile');
+        if (options.extension) {
+            console.log('  pnpm dev:extension');
         }
         console.log('');
     }