anhedral 0.1.1 → 0.1.4

package/dist/scaffold.js

@@ -1,14 +1,14 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { readdirSync } 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, writeFile } from './util.js';
+import { getSkillCommands } from './commands.js';
+import { API_CLIENT_DEPENDENCIES, PACKAGE_MANAGER, ROOT_DEPENDENCIES, SHARED_DB_DEPENDENCIES, SHARED_PACKAGE_DEPENDENCIES, dependencyManifest, } from './dependencies.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'];
 const ASCII_LOGO = [
@@ -39,56 +39,42 @@ async function printAsciiLogo() {
     }
     console.log('');
 }
+function getUsedToolchain(options, toolchain) {
+    return {
+        verifiedAt: toolchain.verifiedAt,
+        shadcn: toolchain.shadcn,
+        reactNativeReusables: toolchain.reactNativeReusables,
+        wxt: toolchain.wxt,
+    };
+}
 function normalizeStack(options, generatedPaths) {
     const toolchain = resolveToolchain(options.toolchainChannel);
-    const frontend = options.mode === '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';
     return {
         schema_version: '2.0.0',
-        mode: options.mode,
+        mode: 'fullstack',
         project_name: options.projectName,
         display_name: options.displayName,
-        frontend,
-        backend,
+        frontend: 'expo_react_native_reusables',
+        extension: 'wxt_chrome_extension',
+        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(),
         outputs: {
-            monorepo: options.monorepo,
+            monorepo: true,
             package_manager: 'pnpm',
+            dependency_manifest: dependencyManifest(),
             toolchain_channel: options.toolchainChannel,
-            toolchain,
+            toolchain: getUsedToolchain(options, toolchain),
             generated_paths: generatedPaths,
         },
     };
 }
-function readJsonFile(filePath) {
-    return JSON.parse(readFileSync(filePath, 'utf-8'));
-}
 function writeJsonFile(filePath, payload) {
     writeFile(filePath, JSON.stringify(payload, null, 2) + '\n');
 }
-function runScaffoldCommands(cwd, commands) {
-    for (const command of commands) {
-        if (env.ANHEDRAL_SKIP_INSTALL === '1' && command.skippable) {
-            console.log(`  $ ${command.cmd} (skipped via ANHEDRAL_SKIP_INSTALL=1)`);
-            continue;
-        }
-        if (command.stdinInput == null) {
-            exec(command.cmd, cwd);
-            continue;
-        }
-        execWithInput(command.cmd, cwd, command.stdinInput);
-    }
-}
 function ensureScaffoldRoot(root) {
     const allowedEntries = new Set(['.git', '.gitignore', '.DS_Store']);
     const unexpected = readdirSync(root).filter((entry) => !allowedEntries.has(entry));
@@ -101,7 +87,7 @@ function writeRootPackageJson(root, projectName, scripts, workspaces, extraField
         name: projectName,
         private: true,
         version: '0.1.0',
-        packageManager: PNPM_PACKAGE_MANAGER,
+        packageManager: PACKAGE_MANAGER,
         scripts,
         ...extraFields,
     };
@@ -114,32 +100,6 @@ function writePnpmWorkspace(root, packages) {
     const serializedPackages = packages.map((entry) => `  - '${entry}'`).join('\n');
     writeFile(path.join(root, 'pnpm-workspace.yaml'), `packages:\n${serializedPackages}\n`);
 }
-function patchPackageJson(root, updates) {
-    const filePath = path.join(root, 'package.json');
-    const packageJson = readJsonFile(filePath);
-    const scripts = (packageJson.scripts ?? {});
-    if (updates.scripts) {
-        Object.assign(scripts, updates.scripts);
-    }
-    packageJson.scripts = scripts;
-    if (updates.packageManager) {
-        packageJson.packageManager = updates.packageManager;
-    }
-    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 writeSkillsGuide(root, commands) {
     const commandBlock = commands.map((command) => `${command}\n`).join('\n');
     writeFile(path.join(root, 'install-skills.sh'), `#!/usr/bin/env bash
@@ -154,131 +114,220 @@ 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') || '- `.`';
+    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: Expo + React Native Reusables
+- Backend: Fastify
+- Extension: WXT Chrome extension
+- Shared packages: \`packages/*\`
+- Auth: ${options.auth}
+- Payments: ${options.payments}
+- Database: ${options.db} + ${options.orm}
+- Storage: ${options.storage}
+- API: ${options.api ?? 'framework-native'}
+- Toolchain: ${toolchainLine}
+- Dependency manifest: recorded in \`stack.json\`
 
-# 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
-
-# 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_***
+## Generated paths
 
-# Cloudflare R2
-R2_ACCOUNT_ID=
-R2_ACCESS_KEY_ID=
-R2_SECRET_ACCESS_KEY=
-R2_BUCKET=
+${generatedPaths}
+
+## First Run
 
-# Stripe
-STRIPE_SECRET_KEY=sk_test_***
-STRIPE_WEBHOOK_SECRET=whsec_***
-STRIPE_PRICE_STARTER=price_***
+\`\`\`bash
+pnpm install
+cp .env.example .env
+# apps/frontend/.env is generated for local Expo development
+cp apps/extension/.env.example apps/extension/.env
+pnpm db:generate
+pnpm db:migrate
+pnpm dev:api
+pnpm dev:frontend
+pnpm dev:extension
+\`\`\`
+
+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 Expo and extension publishable keys.
+- RevenueCat + Stripe: create an entitlement named \`pro\`, configure Stripe as a RevenueCat web billing source, configure app keys, then set \`RC_SECRET_API_KEY\`, \`RC_WEBHOOK_SECRET\`, and the \`EXPO_PUBLIC_RC_*\` values.
+- Cloudflare R2: create a bucket and API token, then set \`R2_ACCOUNT_ID\`, \`R2_ACCESS_KEY_ID\`, \`R2_SECRET_ACCESS_KEY\`, and \`R2_BUCKET\`.
+- Vercel: import this same Git repository twice. Use \`apps/frontend\` as the root directory for the Expo web project, and \`apps/api\` as the root directory for the Fastify API project. Enable access to source files outside each root directory so workspace packages under \`packages/*\` are available during builds.
+- EAS: use \`apps/frontend\` as the Expo project root for iOS and Android builds. Vercel deploys the web export from the same source.
+
+## 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, RevenueCat, Stripe web billing, Neon, and R2 where the scaffolded helper files indicate.
+4. Use \`stack.json\` when debugging generated projects; it records the verified dependency manifest used by this init run.
+5. Run database generation and migrations from the shared DB package:
+
+\`\`\`bash
+pnpm db:generate
+pnpm db:migrate
+\`\`\`
+
+6. Build or run the extension separately. It is not deployed by Vercel:
+
+\`\`\`bash
+pnpm dev:extension
+pnpm extension:zip
+\`\`\`
 `);
 }
-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: SHARED_DB_DEPENDENCIES.dependencies,
+        devDependencies: SHARED_DB_DEPENDENCIES.devDependencies,
+    }, 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'),
+  subscriptionTier: text('subscription_tier').notNull().default('free'),
+  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,309 +335,582 @@ 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(),
 });
+
+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),
+]);
+
+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),
+]);
+
+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)]);
+
+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/lib/db/queries/users.ts'), `import { eq } from 'drizzle-orm';
-import { db } from '../client.js';
-import { users } from '../schema.js';
+    writeFile(path.join(dbRoot, 'src/queries/users.ts'), `import { eq } from 'drizzle-orm';
+import { db } from '../index';
+import { uploads, users } from '../schema';
 
-export async function findUserByEmail(email: string) {
+type SyncUserInput = {
+  clerkUserId: string;
+  email: string;
+  displayName: string | null;
+};
+
+export async function findUserByClerkId(clerkUserId: string) {
   return db.query.users.findFirst({
-    where: eq(users.email, email),
+    where: eq(users.clerkUserId, clerkUserId),
+  });
+}
+
+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(),
+      },
+    });
+
+  return findUserByClerkId(input.clerkUserId);
+}
+
+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));
+}
+
+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(root, 'src/lib/db/queries/index.ts'), `export * from './users.js';
+    writeFile(path.join(dbRoot, 'src/queries/uploads.ts'), `import { eq } from 'drizzle-orm';
+import { db } from '../index';
+import { uploads } from '../schema';
+
+export async function listUploadsForUser(userId: string) {
+  return db.query.uploads.findMany({
+    where: eq(uploads.userId, userId),
+  });
+}
 `);
-    writeFile(path.join(root, 'src/lib/db/migrate.ts'), `import { drizzle } from 'drizzle-orm/neon-http';
+    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/config';
+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');
 }
 
-const sql = neon(process.env.DATABASE_URL);
-const db = drizzle(sql);
+const client = neon(process.env.DATABASE_URL);
+const database = drizzle(client);
 
-await migrate(db, { migrationsFolder: './src/lib/db/migrations' });
+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(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),
-});
-`);
-    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, 'migrations/.gitkeep'), '');
+    const simplePackages = [
+        ['types', { exports: { '.': './src/index.ts' } }, `export type ApiEnvelope<T> = { data: T } | { error: string; message: string };
+export type ClientPlatform = 'frontend' | '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;
+    imageUrl?: string | null;
+    avatarUrl?: string | null;
+    creditsBalance: number;
+    subscriptionTier: string;
+    subscriptionStatus: string;
+  };
+};
+export type PricingResponse = {
+  tiers: Array<{
+    tier: 'free' | 'pro';
+    displayName: string;
+    description: string;
+    priceMonthly: number | null;
+    priceYearly: number | null;
+    currency: string;
+    limits: {
+      dailyLimit: number | null;
+    };
+    paymentInfo?: {
+      revenueCatEntitlementId: string;
+      revenueCatOfferingId: 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_FRONTEND_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: API_CLIENT_DEPENDENCIES.dependencies,
+            }, `import { joinApiUrl } from '@anhedral/config';
+import type { AuthMeResponse, ClientPlatform, PricingResponse, SubscriptionEntitlements } from '@anhedral/types';
+
+export class APIRequestError extends Error {
+  constructor(
+    public statusCode: number,
+    message: string,
+    public errorCode?: string,
+  ) {
+    super(message);
+    this.name = 'APIRequestError';
+  }
+}
 
-export function buildApp() {
-  const app = Fastify({ logger: true });
+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,
+    });
 
-  app.register(cors, {
-    origin: process.env.CLIENT_ORIGIN ?? true,
-    credentials: true,
-  });
+    if (!response.ok) {
+      let error: { error?: string; message?: string } = {};
+      try { error = await response.json(); } catch {}
+      throw new APIRequestError(
+        response.status,
+        error.message || \`API request failed: \${response.status}\`,
+        error.error,
+      );
+    }
 
-  app.get('/health', async () => ({ ok: true }));
+    if (response.status === 204) return {} as T;
+    return response.json() as Promise<T>;
+  }
 
-  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();
+  getMe() {
+    return this.request<AuthMeResponse>('/auth/me');
+  }
 
-      Object.entries(request.headers).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-          for (const entry of value) headers.append(key, entry);
-          return;
-        }
+  getPricing() {
+    return this.request<PricingResponse>('/subscriptions/pricing');
+  }
 
-        if (value) headers.append(key, value.toString());
-      });
+  getSubscriptionPricing() {
+    return this.getPricing();
+  }
 
-      const authRequest = new Request(url.toString(), {
-        method: request.method,
-        headers,
-        body: request.body ? JSON.stringify(request.body) : undefined,
-      });
+  getSubscriptionEntitlements(options?: { refresh?: boolean }) {
+    return this.request<SubscriptionEntitlements>(
+      options?.refresh ? '/subscriptions/entitlements/me?refresh=true' : '/subscriptions/entitlements/me',
+    );
+  }
 
-      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);
-    },
-  });
+  redeemCode(code: string) {
+    return this.request<{ ok: boolean; expiresAt: string }>('/subscriptions/redeem', {
+      method: 'POST',
+      body: JSON.stringify({ code }),
+    });
+  }
 
-  app.get('/api/me', async (request, reply) => {
-    const session = await auth.api.getSession({
-      headers: fromNodeHeaders(request.headers),
+  signOut() {
+    return this.request<{ success: boolean }>('/auth/signout', {
+      method: 'POST',
     });
+  }
 
-    if (!session) {
-      return reply.status(401).send({ error: 'Unauthorized' });
+  uploadAvatar(input: { base64: string; mimeType: string; fileName?: string }) {
+    return this.request<{ ok: boolean; avatarUrl: string }>('/auth/avatar', {
+      method: 'POST',
+      body: JSON.stringify(input),
+    });
+  }
+
+  deleteAccount() {
+    return this.request<void>('/auth/account', {
+      method: 'DELETE',
+    });
+  }
+}
+`],
+    ];
+    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: SHARED_PACKAGE_DEPENDENCIES.devDependencies,
+            ...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 writeRootEnvExample(root) {
+    const frontendUrl = 'http://localhost:8081';
+    const expoEnv = `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 = `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 paymentsEnv = `# RevenueCat
+RC_SECRET_API_KEY=
+RC_WEBHOOK_SECRET=
+RC_ENTITLEMENT_ID=pro
+RC_OFFERING_ID=default
+`;
+    writeFile(path.join(root, '.env.example'), `# Apps
+FRONTEND_URL=${frontendUrl}
+ANHEDRAL_DEMO=false
+${expoEnv}${extensionEnv}
 
-    return reply.send(session);
-  });
+# 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=
 
-  return app;
+${paymentsEnv}`);
 }
-`);
-    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);
-  });
+function writeRootVercelFiles(root) {
+    writeFile(path.join(root, '.vercelignore'), `apps/extension/.output
+apps/extension/.wxt
+apps/extension/dist
 `);
 }
-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}
+function writeGeneratedCiWorkflow(root) {
+    writeFile(path.join(root, '.github/workflows/ci.yml'), `name: CI
 
-Generated by anhedral.
+on:
+  pull_request:
+  push:
+    branches:
+      - main
 
-## Stack
+permissions:
+  contents: read
 
-- Mode: ${options.mode}
-- Auth: ${options.auth}
-- Payments: ${options.payments}
-- Database: ${options.db} + ${options.orm}
-- Storage: ${options.storage}
-- API: ${options.api ?? 'framework-native'}
-- Toolchain: ${toolchainLine}
+concurrency:
+  group: ci-\${{ github.workflow }}-\${{ github.ref }}
+  cancel-in-progress: true
 
-## Generated paths
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
 
-${generatedPaths}
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10.15.1
 
-## Setup
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
 
-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:
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Check Expo dependency alignment
+        run: pnpm --filter ./apps/frontend exec expo install --check
+
+      - name: Build Expo web
+        run: pnpm --filter ./apps/frontend build:web
+
+      - name: Test API
+        run: pnpm --filter ./apps/api test
+
+      - name: Build API
+        run: pnpm --filter ./apps/api build
+
+      - name: Build extension
+        run: pnpm --filter ./apps/extension build
+
+      - name: Zip extension
+        run: pnpm --filter ./apps/extension zip
 
-${databaseCommands}
+      - name: Build workspace
+        run: pnpm build
 `);
 }
-function writeStackFile(root, stack) {
-    writeFile(path.join(root, 'stack.json'), JSON.stringify(stack, null, 2) + '\n');
-}
-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',
-        },
+function writeFullstackRootFiles(root, options) {
+    const appFilters = [
+        './apps/frontend',
+        './apps/api',
+        './apps/extension',
+    ];
+    const parallelFilters = appFilters.map((entry) => `--filter=${entry}`).join(' ');
+    const scripts = {
+        dev: `turbo dev --parallel ${parallelFilters}`,
+        'dev:api': 'pnpm --filter ./apps/api dev',
+        build: 'turbo build',
+        typecheck: 'turbo typecheck',
+        'db:generate': 'pnpm --filter @anhedral/db db:generate',
+        'db:migrate': 'pnpm --filter @anhedral/db db:migrate',
+    };
+    scripts['dev:frontend'] = 'pnpm --filter ./apps/frontend dev';
+    scripts['dev:extension'] = 'pnpm --filter ./apps/extension dev';
+    scripts['extension:zip'] = 'pnpm --filter ./apps/extension zip';
+    writeRootPackageJson(root, options.projectName, scripts, ['apps/*', 'packages/*'], {
+        devDependencies: ROOT_DEPENDENCIES.devDependencies,
     });
-    writeDrizzleConfig(root, './lib/db/schema.ts', './lib/db/migrations');
-    writeDefaultWebEnvExample(root);
-    writeDefaultWebFiles(root, options.displayName);
-    return ['.'];
-}
-function patchGeneratedPackageName(root, name) {
-    const filePath = path.join(root, 'package.json');
-    const packageJson = readJsonFile(filePath);
-    packageJson.name = name;
-    writeJsonFile(filePath, packageJson);
-}
-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), [
-        ...SHARED_ENV_GITIGNORE_LINES,
-        '.next',
-        'node_modules',
-        'lib/db/migrations',
-        ...SHARED_TYPESCRIPT_GITIGNORE_LINES,
-    ]);
-    patchPackageJson(path.join(root, directoryName), {
-        packageManager: PNPM_PACKAGE_MANAGER,
-        scripts: {
-            typecheck: 'tsc --noEmit',
-            'db:generate': 'drizzle-kit generate',
-            'db:migrate': 'pnpm tsx lib/db/migrate.ts',
+    writePnpmWorkspace(root, ['apps/*', 'packages/*']);
+    writeFile(path.join(root, 'turbo.json'), JSON.stringify({
+        $schema: 'https://turborepo.dev/schema.json',
+        tasks: {
+            build: {
+                dependsOn: ['^build'],
+                outputs: ['dist/**', '.output/**'],
+            },
+            typecheck: {
+                dependsOn: ['^build'],
+            },
+            dev: {
+                cache: false,
+                persistent: true,
+            },
         },
-    });
-    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']);
+    }, null, 2) + '\n');
     appendGitignore(root, [
         'node_modules',
-        'frontend/node_modules',
-        'backend/node_modules',
+        '.turbo',
+        'apps/*/node_modules',
+        'packages/*/node_modules',
         ...SHARED_ENV_GITIGNORE_LINES,
+        ...SHARED_TYPESCRIPT_GITIGNORE_LINES,
     ]);
-    writeNextFullstackRootEnvExample(root);
+    writeRootEnvExample(root);
+    writeRootVercelFiles(root);
+    writeGeneratedCiWorkflow(root);
+}
+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 = 'http://localhost:8081';
     await scaffoldBackend(root, {
         projectName: options.projectName,
         displayName: options.displayName,
         githubOrg: null,
-        frontendUrl: 'http://localhost:3000',
+        frontendUrl,
+        skipInstall: options.skipInstall,
     });
-    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 = {
+    await scaffoldFrontend(root, {
         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 ['.'];
+        frontendUrl,
+        skipInstall: options.skipInstall,
+    });
+    await scaffoldExtension(root, {
+        projectName: options.projectName,
+        displayName: options.displayName,
+        githubOrg: null,
+        frontendUrl,
+        skipInstall: options.skipInstall,
+    });
+    return [
+        '.github/workflows/ci.yml',
+        'apps/frontend',
+        'apps/api',
+        'apps/extension',
+        'packages/db',
+        'packages/types',
+        'packages/config',
+        'packages/api-client',
+    ];
 }
 export async function scaffoldProject(options) {
     const root = path.resolve(process.cwd());
@@ -597,26 +919,31 @@ 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();
         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');
+        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('  pnpm dev:frontend');
+        console.log('  pnpm dev:extension');
+        console.log('');
     }
     finally {
         if (previousToolchain == null) {